diff --git a/PyQt5-shims/QtCore.py b/PyQt5-shims/QtCore.py new file mode 100644 index 0000000..c92b515 --- /dev/null +++ b/PyQt5-shims/QtCore.py @@ -0,0 +1 @@ +from PySide6.QtCore import * diff --git a/PyQt5-shims/QtGui.py b/PyQt5-shims/QtGui.py new file mode 100644 index 0000000..05af839 --- /dev/null +++ b/PyQt5-shims/QtGui.py @@ -0,0 +1 @@ +from PySide6.QtGui import * diff --git a/PyQt5-shims/QtWidgets.py b/PyQt5-shims/QtWidgets.py new file mode 100644 index 0000000..4b24a28 --- /dev/null +++ b/PyQt5-shims/QtWidgets.py @@ -0,0 +1 @@ +from PySide6.QtWidgets import * diff --git a/PyQt5-shims/__init__.py b/PyQt5-shims/__init__.py new file mode 100644 index 0000000..e845f43 --- /dev/null +++ b/PyQt5-shims/__init__.py @@ -0,0 +1,17 @@ +print("#" * 70) +print("""# Please note that IDA is now using Qt 6, and PyQt5 +# support will be dropped eventually. +# It is recommended to port your scripts/plugins to PySide6 +# as soon as possible. +# Essentially, that means rewriting statement such as: +# +# import PyQt5 +# import PyQt5.QtWidgets +# from PyQt5.QtGui import QGuiApplication +# +# into: +# +# import PySide6 +# import PySide6.QtWidgets +# from PySide6.QtGui import QGuiApplication""") +print("#" * 70) diff --git a/PyQt5-shims/sip.py b/PyQt5-shims/sip.py new file mode 100644 index 0000000..dcf2c80 --- /dev/null +++ b/PyQt5-shims/sip.py @@ -0,0 +1 @@ +# Placeholder diff --git a/README.md b/README.md index 000463f..b11e299 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ Latest stable versions of IDAPython are available from ## Resources The full function cross-reference is readable online at - https://www.hex-rays.com/products/ida/support/idapython_docs/ + https://python.docs.hex-rays.com Mailing list for the project is hosted by Google Groups at https://groups.google.com/g/idapython diff --git a/README_python3.txt b/README_python3.txt index 156f4c6..fa40c6e 100644 --- a/README_python3.txt +++ b/README_python3.txt @@ -13,8 +13,3 @@ please run `idapyswitch` from the IDA directory. It will scan for Python installs present in the system's standard locations and offer you to choose one. It also supports optional command-line switches to handle non-standard installs. Run `idapyswitch -h` to see them. - -On Windows, you may need to run it as administrator -so it can patch sip.pyd (library required for PyQt bindings). - - diff --git a/STATUS.txt b/STATUS.txt index aa4a35d..a09e007 100644 --- a/STATUS.txt +++ b/STATUS.txt @@ -21,7 +21,6 @@ dbg.hpp - INCOMPLETE (SWIGs and lot of fixing to do) demangle.hpp - EXCLUDED diskio.hpp - INCOMPLETE (no SWIGs, some unwrapped) entry.hpp - COMPLETE -enum.hpp - COMPLETE err.h - EXCLUDED exehdr.h - EXCLUDED expr.hpp - COMPLETE (necessary SWIGs) @@ -57,7 +56,6 @@ segment.hpp - COMPLETE sistack.hpp - EXCLUDED segregs.hpp - INCOMPLETE (not wrapped at all) strlist.hpp - COMPLETE -struct.hpp - COMPLETE typeinf.hpp - INCOMPLETE (no SWIGs, lot of fixing to do) ua.hpp - INCOMPLETE (SWIGs and lot of fixing to do) va.hpp - EXCLUDED diff --git a/Scripts/CallStackWalk.py b/Scripts/CallStackWalk.py index 98ba75a..835acf0 100644 --- a/Scripts/CallStackWalk.py +++ b/Scripts/CallStackWalk.py @@ -4,7 +4,7 @@ A script that tries to determine the call stack Run the application with the debugger, suspend the debugger, select a thread and finally run the script. -Copyright (c) 1990-2024 Hex-Rays +Copyright (c) 1990-2025 Hex-Rays ALL RIGHTS RESERVED. """ import ida_ua @@ -169,7 +169,7 @@ def main(): return # get all debug namesp - dn = ida_name.get_debug_names(ida_ida.cvar.inf.min_ea, ida_ida.cvar.inf.max_ea) + dn = ida_name.get_debug_names(ida_ida.inf_get_min_ea(), ida_ida.inf_get_max_ea()) # initiate a nearest name search (using debug names) nn = ida_name.NearestName(dn) diff --git a/Scripts/DrvsDispatch.py b/Scripts/DrvsDispatch.py index c6464de..1eda3ab 100644 --- a/Scripts/DrvsDispatch.py +++ b/Scripts/DrvsDispatch.py @@ -2,7 +2,7 @@ A script to demonstrate how to send commands to the debugger and then parse and use the output in IDA -Copyright (c) 1990-2024 Hex-Rays +Copyright (c) 1990-2025 Hex-Rays ALL RIGHTS RESERVED. """ diff --git a/Scripts/ExchainDump.py b/Scripts/ExchainDump.py index 4f1c6e0..fe22061 100644 --- a/Scripts/ExchainDump.py +++ b/Scripts/ExchainDump.py @@ -2,7 +2,7 @@ This script shows how to send debugger commands and use the result in IDA -Copyright (c) 1990-2024 Hex-Rays +Copyright (c) 1990-2025 Hex-Rays ALL RIGHTS RESERVED. """ diff --git a/Scripts/FindInstructions.py b/Scripts/FindInstructions.py index 4158053..e84682c 100644 --- a/Scripts/FindInstructions.py +++ b/Scripts/FindInstructions.py @@ -13,7 +13,7 @@ The general syntax is: * To specify in which context the instructions should be assembled, pass asm_where=ea: find("jmp dword ptr [esp]", asm_where=here()) -Copyright (c) 1990-2024 Hex-Rays +Copyright (c) 1990-2025 Hex-Rays ALL RIGHTS RESERVED. """ from __future__ import print_function @@ -27,7 +27,6 @@ import ida_kernwin import ida_bytes import ida_ua import ida_ida -import ida_search import ida_funcs import idautils @@ -76,10 +75,10 @@ def FindInstructions(instr, asm_where=None): # find all binary strings print("Searching for: [%s]" % bin_str) - ea = ida_ida.cvar.inf.min_ea + ea = ida_ida.inf_get_min_ea() ret = [] while True: - ea = ida_search.find_binary(ea, ida_idaapi.BADADDR, bin_str, 16, ida_search.SEARCH_DOWN) + ea = ida_bytes.find_bytes(bin_str, ea, radix=16) if ea == ida_idaapi.BADADDR: break ret.append(ea) diff --git a/Scripts/SEHGraph.py b/Scripts/SEHGraph.py index 88aae57..b6d0bc0 100644 --- a/Scripts/SEHGraph.py +++ b/Scripts/SEHGraph.py @@ -4,7 +4,7 @@ A script that graphs all the exception handlers in a given process It will be easy to see what thread uses what handler and what handlers are commonly used between threads -Copyright (c) 1990-2024 Hex-Rays +Copyright (c) 1990-2025 Hex-Rays ALL RIGHTS RESERVED. """ from __future__ import print_function diff --git a/Scripts/VaDump.py b/Scripts/VaDump.py index 078d259..cc7adfe 100644 --- a/Scripts/VaDump.py +++ b/Scripts/VaDump.py @@ -2,7 +2,7 @@ This script shows how to send debugger commands and use the result in IDA -Copyright (c) 1990-2024 Hex-Rays +Copyright (c) 1990-2025 Hex-Rays ALL RIGHTS RESERVED. """ diff --git a/Scripts/VirusTotal.py b/Scripts/VirusTotal.py index db43ba0..cab751e 100644 --- a/Scripts/VirusTotal.py +++ b/Scripts/VirusTotal.py @@ -2,7 +2,7 @@ from __future__ import print_function # ----------------------------------------------------------------------- # VirusTotal IDA Plugin # By Elias Bachaalany -# (c) Hex-Rays 2011-2024 +# (c) Hex-Rays 2011-2025 # # Special thanks: # - VirusTotal team diff --git a/api-examples/api-examples-toc.md b/api-examples/api-examples-toc.md new file mode 100644 index 0000000..94cf8dc --- /dev/null +++ b/api-examples/api-examples-toc.md @@ -0,0 +1,72 @@ +# API examples + + +This file contains the list of all the IDA python examples. + + +## func + +* decompile_func_and_callees.py +* list_func_callees.py +* print_location_info.py +* sort_func_by_calls.py + +## gdl + +* colorize_graph_node.py + +## hexrays + +* hr_decompile_func_and_callees.py + +## idb + +* frame_event_listener.py +* lt_event_listener.py + +## idp + +* log_idp_events.py + +## inf + +* print_basic_info.py +* print_basic_info_plugin.py + +## misc + +* find_binary_pattern.py + +## segm + +* list_imports.py + +## typeinf + +* add_frame_member.py +* apply_callee_tinfo.py +* change_stkvar_name.py +* change_stkvar_type.py +* create_array.py +* create_bfstruct.py +* create_bmenum.py +* create_libssh2_til.py +* create_structs.py +* create_user_shared_data.py +* del_struct_members.py +* func_ti_changed_listener.py +* gap_size_align_snippet.py +* import_type_from_til.py +* insert_gap.py +* list_enum_member.py +* list_frame_info.py +* list_func_details.py +* list_stkvar_xrefs.py +* list_struct_accesses.py +* list_struct_member.py +* list_struct_xrefs.py +* list_union_member.py +* mark_func_spoiled.py +* operand_to_struct_member.py +* setpehdr.py +* visit_tinfo.py diff --git a/api-examples/dbg/filemon.py b/api-examples/dbg/filemon.py new file mode 100644 index 0000000..3490300 --- /dev/null +++ b/api-examples/dbg/filemon.py @@ -0,0 +1,104 @@ +import ida_idaapi +import ida_dbg +import ida_kernwin +import ida_name +import ida_idd +import ida_bytes +import ida_ida +import ida_ua +import idc +import os + +ST_NONE = 0 +ST_RUNTO = 1 +ST_ADD_BPT = 2 +ST_MONITOR = 3 + +func_name = 'kernelbase_CreateFileW' + +class filemon_dbg_hook_t(ida_dbg.DBG_Hooks): + def __init__(self): + ida_dbg.DBG_Hooks.__init__(self) + self.func_entry_ea = ida_idaapi.BADADDR + ida_dbg.run_to(ida_ida.inf_get_start_ea()) + self.stage = ST_RUNTO + + def dbg_process_start(self, pid, tid, ea, path, base, size): + name = os.path.basename(path) + ida_kernwin.msg(f'Process started: {name}.\n\tLoad address: {base:x}\n\tPID: {pid:x}\n') + + def dbg_run_to(self, pid, tid=0, ea=0): + if self.stage == ST_RUNTO: + ida_kernwin.msg(f'Run to: {ea:x}\n') + self.stage = ST_ADD_BPT + + def dbg_suspend_process(self): + all_good = True + if self.stage == ST_ADD_BPT: + ida_dbg.refresh_debugger_memory() + + self.func_entry_ea = ida_name.get_name_ea(ida_idaapi.BADADDR, func_name) + if self.func_entry_ea == ida_idaapi.BADADDR: + all_good = False + ida_kernwin.msg('Could not resolve \n') + else: + ida_kernwin.msg(f'{func_name} found @ {self.func_entry_ea:x}. Setting breakpoint.\n') + if ida_dbg.add_bpt(self.func_entry_ea): + ida_kernwin.msg('Breakpoint added\n') + else: + ida_kernwin.msg('Failed to add the breakpoint.\n') + + if not all_good: + ida_dbg.request_exit_process() + ida_dbg.run_requests() + else: + ida_dbg.continue_process() + self.stage = ST_MONITOR + + def dbg_bpt(self, tid, bpt_ea): + if self.stage == ST_MONITOR: + ida_kernwin.msg(f'In dbg_bpt {bpt_ea:x}.\n') + + if bpt_ea == self.func_entry_ea: + ida_kernwin.msg('Trying to retreive RCX: ') + rcx_val = ida_idd.regval_t() + if not ida_dbg.get_reg_val('rcx', rcx_val): + ida_kernwin.msg('Could not get rcx register.\n') + return 0 + + fn_ea = rcx_val.ival + ida_kernwin.msg(f'{fn_ea:x}\n') + if not ida_bytes.is_mapped(fn_ea): + ida_dbg.invalidate_dbgmem_config() + + ida_dbg.invalidate_dbgmem_contents(fn_ea, 1024) + len = ida_bytes.get_max_strlit_length(fn_ea, idc.STRTYPE_C_16) + ida_kernwin.msg(f'String length: {len}.\n') + if len: + raw = ida_bytes.get_strlit_contents(fn_ea, len, idc.STRTYPE_C_16) + ida_kernwin.msg(f' CreateFile -> {raw.decode('UTF-8')}\n') + + ida_dbg.continue_process() + + return 0 + + def dbg_process_exit(self, pid, tid, ea, code): + if not self.func_entry_ea == ida_idaapi.BADADDR: + ida_dbg.del_bpt(self.func_entry_ea) + self.func_entry_ea = ida_idaapi.BADADDR + self.stage = ST_NONE + +try: + dbg_hook_stat = "un" + print("Filemon DBG hook: checking for hook...") + dbg_hook + print("Filemon DBG hook: unhooking....") + dbg_hook_stat2 = "" + dbg_hook.unhook() + del dbg_hook +except: + print("Filemon DBG hook: not installed, installing now....") + dbg_hook_stat = "" + dbg_hook_stat2 = "un" + dbg_hook = filemon_dbg_hook_t() + dbg_hook.hook() \ No newline at end of file diff --git a/api-examples/func/classify_ntdll_func.py b/api-examples/func/classify_ntdll_func.py new file mode 100644 index 0000000..6885700 --- /dev/null +++ b/api-examples/func/classify_ntdll_func.py @@ -0,0 +1,56 @@ +""" +summary: This script shows an example of function clasification + using the dirtree API. + +description: + In this example we calssify the functions of ntdll.dll into + three categories (there are more but three is enough for this + example): + * Runtime library (Rtl). + * System calls (Zw). + * Kernel internal (Ki) + For each category we create a corresponding folder in the functions + dirtreee. Then we iterates through all the functions and use the + folder name as filter: namely if a function name starts with 'Rtl' + it is moved to the Rtl folder and so on. + +level: intermediate. +""" +import ida_funcs +import ida_dirtree +import idautils + +lst = ['Rtl', 'Zw', 'Ki'] + +def main(): + # + # Get the functions standard dirtree. + # + dt = ida_dirtree.get_std_dirtree(ida_dirtree.DIRTREE_FUNCS) + + # + # Create the folders. + # + for folder in lst: + result = dt.mkdir(folder) + if result != ida_dirtree.DTE_OK and result != ida_dirtree.DTE_ALREADY_EXISTS: + print(f'Not able to create folder {folder} ({result:x})') + return + + # + # For all the function in the base directory, check that the function name + # starts with the provided prefix. If it does we try to move it to the + # corresponding folder. + # + for func_ea in idautils.Functions(): + name = ida_funcs.get_func_name(func_ea) + for func_prefix in lst: + if name and name.startswith(func_prefix): + if dt.isfile(name): + if dt.rename(name, f'{func_prefix}/{name}') != ida_dirtree.DTE_OK: + print(f'Not able to move {name} inside {func_prefix} folder') + else: + print(f'{name} moved in {func_prefix} folder') + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/api-examples/func/decompile_func_and_callees.py b/api-examples/func/decompile_func_and_callees.py new file mode 100644 index 0000000..6774058 --- /dev/null +++ b/api-examples/func/decompile_func_and_callees.py @@ -0,0 +1,76 @@ +import idautils +import ida_kernwin +import ida_funcs +import ida_ua +import ida_allins +import ida_ida +import ida_hexrays +import ida_lines +import idc + +def build_function_list(func): + func_list = [] + + items = ida_funcs.func_item_iterator_t(func) + for item in items: + is_jmp = False + + insn = ida_ua.insn_t() + if not ida_ua.decode_insn(insn, item): + continue + + if not insn.itype == ida_allins.NN_call and not insn.itype == ida_allins.NN_jmp: + continue + + if insn.itype == ida_allins.NN_jmp: + is_jmp = True + + for xref in idautils.CodeRefsFrom(item, 0): + callee = ida_funcs.get_func(xref) + if not callee: + print(f'Unable to retrieve function object for {xref:x}. Skipping.') + continue + + if is_jmp and callee.start_ea == func.start_ea: + continue + + if callee not in func_list: + func_list.append(callee) + + return func_list + + +def print_pseudo_code(cfunc): + sv = cfunc.get_pseudocode() + for sline in sv: + print(ida_lines.tag_remove(sline.line)) + print('') + + +def decompile_and_print(func): + func_list = build_function_list(func) + func_list = [func, *func_list] + + for item in func_list: + cfunc = ida_hexrays.decompile(item) + if not cfunc: + print(f'Unable to decompile function {ida_funcs.get_func_name(item.start_ea)}') + return False + print_pseudo_code(cfunc) + + +def main(): + if not ida_ida.inf_get_procname() == 'metapc': + return False + + if not ida_hexrays.init_hexrays_plugin(): + return False + + func = ida_funcs.get_func(idc.here()) + if not func: + print('Please put the cursor inside a function and retry.') + + decompile_and_print(func) + +ida_kernwin.msg_clear() +main() \ No newline at end of file diff --git a/api-examples/func/list_func_callees.py b/api-examples/func/list_func_callees.py new file mode 100644 index 0000000..c287fe8 --- /dev/null +++ b/api-examples/func/list_func_callees.py @@ -0,0 +1,55 @@ +""" +summary: List all the functions called by the one in which the + cursor is currently located. + +description: + If the cursor is located inside a function: + * get the function object + * get the function name + * get a function item iterator + * iterate through the items, and for each one decode it + * if the item is a call get the address of the callee + - get its name + - display its name its address and address of the call. + * if no calle is found print a statement indicating this fact. +""" +import idautils +import ida_kernwin +import ida_funcs +import ida_ua +import ida_allins +import ida_ida +import idc + +ida_kernwin.msg_clear() + +if ida_ida.inf_get_procname() == 'metapc': + func = ida_funcs.get_func(idc.here()) + if func: + has_callee = False + func_name = ida_funcs.get_func_name(func.start_ea) + if not func_name: + func_name = hex(func.start_ea) + print(f'Function {func_name} [{func.start_ea:x}] calls:') + + items = ida_funcs.func_item_iterator_t(func) + for item in items: + insn = ida_ua.insn_t() + if not ida_ua.decode_insn(insn, item): + continue + + if not insn.itype == ida_allins.NN_call: + continue + + if not has_callee: + has_callee = True + + for xref in idautils.CodeRefsFrom(item, 0): + print(f'\t- {ida_funcs.get_func_name(xref)} [{xref:x}] @{item:x}') + + if not has_callee: + print('\t- no function.') + else: + print('Please place the cursor inside a function and retry.') +else: + print('This script will propely work for "metapc" procmod only.') diff --git a/api-examples/func/print_location_info.py b/api-examples/func/print_location_info.py new file mode 100644 index 0000000..4dd9608 --- /dev/null +++ b/api-examples/func/print_location_info.py @@ -0,0 +1,50 @@ +""" +summary: Print argument location information. + +description: + In this script, we iterate through a function + arguments and display information about their + location and size. For this we: + * get the function type information + * iterate through the arguments + * for each of them we print its location (register or stack), + offset (if in stack) and size +""" +import ida_nalt +import ida_funcs +import ida_typeinf +import idc +import ida_kernwin + +def print_argument_locations(func): + tif = ida_typeinf.tinfo_t() + if ida_nalt.get_tinfo(tif, func.start_ea): + fi = ida_typeinf.func_type_data_t() + if tif.get_func_details(fi): + if fi.size(): + print('Argument location:') + for item in fi: + if item.name: + ida_kernwin.msg(f'\t{item.name}: ') + else: + ida_kernwin.msg(f'\t????: ') + location = ida_typeinf.print_argloc(item.argloc) + if location: + ida_kernwin.msg(f'{location}.') + elif item.argloc.in_stack: + ida_kernwin.msg(f'stack({item.argloc.stkoff():x}).') + print(f'{item.type.get_size()}') + else: + print('No arguments') + else: + print('Problems retrieving function details') + else: + print('Problem retrieving function type info.') + + +if __name__ == '__main__': + func = ida_funcs.get_func(idc.here()) + if not func: + print('Place the cursor inside a function and retry.') + else: + print_argument_locations(func) \ No newline at end of file diff --git a/api-examples/func/sort_func_by_calls.py b/api-examples/func/sort_func_by_calls.py new file mode 100644 index 0000000..b18f7aa --- /dev/null +++ b/api-examples/func/sort_func_by_calls.py @@ -0,0 +1,38 @@ +""" +summary: Print the list of the functions in the currently loaded + IDB sorted (descending) by the number of code reference to + each of them. + +description: + In this script, we iterate through the list of function entry + points and fore each of them we: + * get its name + * get the number of code reference made to it + * put it in the map. + Once done we: + * sort the map in descending number of calls + * print it. +""" +import ida_kernwin +import ida_funcs +import idc +import idautils + +ida_kernwin.msg_clear() + +func_map = {} +for funcea in idautils.Functions(): + func_name = ida_funcs.get_func_name(funcea) + if not func_name: + func_name = hex(funcea) + else: + func_name = idc.demangle_name(func_name, idc.get_inf_attr(idc.INF_LONG_DN)) + call_count = 0 + for xref in idautils.CodeRefsTo(funcea, 1): + call_count += 1 + if call_count: + func_map[func_name] = call_count + +func_map_by_calls = sorted(func_map.items(), key=lambda x:x[1], reverse=True) +for func, calls in func_map_by_calls: + print(f'{func} called {calls} time(s)') diff --git a/api-examples/gdl/colorize_graph_node.py b/api-examples/gdl/colorize_graph_node.py new file mode 100644 index 0000000..6e03540 --- /dev/null +++ b/api-examples/gdl/colorize_graph_node.py @@ -0,0 +1,15 @@ +import ida_graph +import ida_funcs +import ida_gdl +import ida_kernwin +import idc + +func = ida_funcs.get_func(idc.here()) +qflow = ida_gdl.qflow_chart_t("", func, 0, 0, 0) +for n in range(qflow.size()): + node = qflow[n] + print(f'Start ea : {node.start_ea:x}, end ea: {node.end_ea:x}, index: {n}') + ni = ida_graph.node_info_t() + ni.bg_color = 0xFF00 + ida_graph.set_node_info(func.start_ea, n, ni, ida_graph.NIF_BG_COLOR) +ida_kernwin.refresh_idaview_anyway() \ No newline at end of file diff --git a/api-examples/hexrays/hr_decompile_func_and_callees.py b/api-examples/hexrays/hr_decompile_func_and_callees.py new file mode 100644 index 0000000..2c0f490 --- /dev/null +++ b/api-examples/hexrays/hr_decompile_func_and_callees.py @@ -0,0 +1,74 @@ +""" +summary: Python plugin that decompiles a function and its callees. + +description: + This script does the same as decompile_func_and_callee but instead + of using the cross-references, uses a ctree visitor to build the + list of callees. +""" +import ida_hexrays +import ida_lines +import ida_funcs +import ida_kernwin + + +def find_calls(cfunc): + class finder_t(ida_hexrays.ctree_visitor_t): + def __init__(self): + ida_hexrays.ctree_visitor_t.__init__(self, ida_hexrays.CV_FAST | ida_hexrays.CV_INSNS) + + self.results = [] + return + + def visit_insn(self, inst): + if inst.op == ida_hexrays.cit_expr and inst.cexpr.op == ida_hexrays.cot_call: + self.results.append(inst.cexpr.x.obj_ea) + return 0 + + finder = finder_t() + finder.apply_to(cfunc.body, None) + return finder.results + + +def print_pseudo_code(cfunc): + sv = cfunc.get_pseudocode(); + for sline in sv: + print(ida_lines.tag_remove(sline.line)) + + +def main(): + if not ida_hexrays.init_hexrays_plugin(): + return False + + print("Hex-rays version %s has been detected" % ida_hexrays.get_hexrays_version()) + + f = ida_funcs.get_func(ida_kernwin.get_screen_ea()) + if f is None: + print("Please position the cursor within a function") + return True + + cfunc = ida_hexrays.decompile(f); + if cfunc is None: + print("Failed to decompile!") + return True + + print_pseudo_code(cfunc) + + lst = find_calls(cfunc) + lst = list(set(lst)) + already = [] + for ea in lst: + f = ida_funcs.get_func(ea) + if f is None: + continue + + cfunc = ida_hexrays.decompile(f); + if cfunc is None: + print("Failed to decompile!") + return True + print_pseudo_code(cfunc) + + return True + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/api-examples/idb/frame_event_listener.py b/api-examples/idb/frame_event_listener.py new file mode 100644 index 0000000..3f3f389 --- /dev/null +++ b/api-examples/idb/frame_event_listener.py @@ -0,0 +1,65 @@ +""" +summary: log various frame events. + +description: + hooks to be notified about frame IDP events, and + dump their information to the "Output" window. +""" +import inspect +import ida_idp +import ida_ua + +class frame_logger_hooks_t(ida_idp.IDB_Hooks): + def __init__(self): + ida_idp.IDB_Hooks.__init__(self) + self.inhibit_log = 0 + + def _format_value(self, v): + return str(v) + + def _log(self, msg=None): + if self.inhibit_log <= 0: + if msg: + print(f'>>> frame_logger_hooks_f: {msg}') + else: + stack = inspect.stack() + frame, _, _, _, _, _ = stack[1] + args, _, _, values = inspect.getargvalues(frame) + method_name = inspect.getframeinfo(frame)[2] + argstrs = [] + for arg in args[1:]: + argstrs.append("%s=%s" % (arg, self._format_value(values[arg]))) + print(f'>>> frame_logger_hooks_t.{method_name}: {", ".join(args)}') + return 0 + + def frame_udm_created(self, func_ea, udm): + return self._log() + + def frame_udm_deleted(self, func_ea, udm_tid, udm): + return self._log() + + def frame_udm_renamed(self, func_ea, udm, oldname): + return self._log() + + def frame_udm_changed(self, func_ea, udm_tid, udmold, udmnew): + return self._log() + + + +# Remove an existing hook on second run +try: + frame_idp_hook_stat = "un" + print("Frame IDP hook: checking for hook...") + framehook + print("Frame IDP hook: unhooking....") + frame_idp_hook_stat2 = "" + framehook.unhook() + del framehook +except: + print("Frame IDP hook: not installed, installing now....") + frame_idp_hook_stat = "" + frame_idp_hook_stat2 = "un" + framehook = frame_logger_hooks_t() + framehook.hook() + +print(f'Frame IDB hook {frame_idp_hook_stat}installed. Run the script again to {frame_idp_hook_stat2}install') \ No newline at end of file diff --git a/api-examples/idb/lt_event_listener.py b/api-examples/idb/lt_event_listener.py new file mode 100644 index 0000000..0800372 --- /dev/null +++ b/api-examples/idb/lt_event_listener.py @@ -0,0 +1,68 @@ +""" +summary: log various local type events. + +description: + hooks to be notified about local type IDP events, + and dump their information to the "Output" window +""" +import inspect +import ida_idp +import ida_ua + +class lt_logger_hooks_t(ida_idp.IDB_Hooks): + def __init__(self): + ida_idp.IDB_Hooks.__init__(self) + self.inhibit_log = 0 + + def _format_value(self, v): + return str(v) + + def _log(self, msg=None): + if self.inhibit_log <= 0: + if msg: + print(f'>>> lt_logger_hooks_f: {msg}') + else: + stack = inspect.stack() + frame, _, _, _, _, _ = stack[1] + args, _, _, values = inspect.getargvalues(frame) + method_name = inspect.getframeinfo(frame)[2] + argstrs = [] + for arg in args[1:]: + argstrs.append("%s=%s" % (arg, self._format_value(values[arg]))) + print(f'>>> lt_logger_hooks_t.{method_name}: {", ".join(args)}') + return 0 + + def lt_udm_created(self, udtname, udm): + msg = f'UDM {udm.name} has been created in UDT {udtname}' + return self._log(msg) + + def lt_udm_deleted(self, udtname, udm_tid): + msg = f'UDM tid {udm_tid:x} has been deleted from {udtname}' + return self._log(msg) + + def lt_udm_renamed(self, udtname, udm, oldname): + msg = f'UDM {oldname} from UDT {udtname} has been renamed to {udm.name}' + return self._log(msg) + + def lt_udm_changed(self, udtname, udm_tid, udmold, udmnew): + return self._log() + + + +# Remove an existing hook on second run +try: + idp_hook_stat = "un" + print("Local type IDB hook: checking for hook...") + lthook + print("Local type IDB hook: unhooking....") + idp_hook_stat2 = "" + lthook.unhook() + del lthook +except: + print("local type IDB hook: not installed, installing now....") + idp_hook_stat = "" + idp_hook_stat2 = "un" + lthook = lt_logger_hooks_t() + lthook.hook() + +print(f'Local type IDB hook {idp_hook_stat}installed. Run the script again to {idp_hook_stat2}install') \ No newline at end of file diff --git a/api-examples/idp/log_idp_events.py b/api-examples/idp/log_idp_events.py new file mode 100644 index 0000000..f910ccc --- /dev/null +++ b/api-examples/idp/log_idp_events.py @@ -0,0 +1,677 @@ +""" +summary: being notified, and logging some IDP events + +description: + hooks to be notified about certain IDP events, and + dump their information to the "Output" window + See enum event_t in idp.hpp for additional. +""" +import inspect +import ida_idp +import ida_ua + +class idp_logger_hooks_t(ida_idp.IDP_Hooks): + def __init__(self): + ida_idp.IDP_Hooks.__init__(self) + self.inhibit_log = 0 + + def _format_value(self, v): + return str(v) + + def _log(self, msg=None): + if self.inhibit_log <= 0: + if msg: + print(f'>>> idp_logger_hooks_f: {msg}') + else: + stack = inspect.stack() + frame, _, _, _, _, _ = stack[1] + args, _, _, values = inspect.getargvalues(frame) + method_name = inspect.getframeinfo(frame)[2] + argstrs = [] + for arg in args[1:]: + argstrs.append("%s=%s" % (arg, self._format_value(values[arg]))) + print(f'>>> idp_logger_hooks_t.{method_name}: {", ".join(args)}') + return 0 + + def ev_init(self, idp_modname): + """ + The IDP module is just loaded. + idp_modname - processor module name + Returns: <0 on failure + """ + return self._log(f'idp_logger_hooks_t.ev_init(self, {idp_modname})') + + def ev_term(self): + """ + The IDP module is being unloaded + """ + return self._log() + + def ev_newprc(self, nproc, keep_cfg): + """ + Before changing proccesor type + nproc - processor number in the array of processor names + Returns: >=0-ok,<0-prohibit + """ + return self._log() + + def ev_newasm(self, asmnum): + """ + Before setting a new assembler. + """ + return self._log() + + def ev_newfile(self, fname): + """ + A new file has been loaded. + """ + return self._log() + + def ev_oldfile(self, filename): + """ + An old file has been loaded. + """ + return self._log() + + def ev_newbinary(self, filename, fileoff, basepara, binoff, nbytes): + """ + Before loading a binary file + """ + return self._log() + + def ev_endbinary(self, ok): + """ + After loading a binary file + Returns: >=0-ok + """ + return self._log() + + def ev_set_idp_options(self, keyword, value_type, value, idb_loaded): + """ + Set IDP-specific option + Returns: 1-ok, 0-not implemented, -1-error + """ + #msg = f'KEY: {keyword}, TYPE: {value_type}, value: {value}, loaded: {idb_loaded}' + return self._log() + + def ev_set_proc_options(self, options, confidence): + """ + Called if the user specified an option string in the command line: + Returns: <0-bad option string + """ + return self._log() + + def ev_ana_insn(self, insn): + """ + Decodes an instruction into insn + Returns: insn.size (=the size of the decoded instruction) or zero + """ + self._log() + return insn.size + + def ev_emu_insn(self, insn): + """ + 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 'insn' structure. + Returns: -1, the kernel will delete the instruction. + """ + return self._log() + + def ev_out_header(self, ctx): + """ + Function to produce start of disassembled text + """ + self._log() + + def ev_out_footer(self, ctx): + """ + Function to produce end of disassembled text + """ + self._log() + + def ev_out_segstart(self, ctx, segment): + """ + Function to produce start of segment + Returns: 1-ok, 0-not implemented + """ + return self._log() + + def ev_out_insn(self, ctx): + """ + Generate text representation of an instruction in 'ctx.insn' structure. + This function shouldn't change the database, flags or anything else. + All these actions should be performed only by u_emu() function. + Returns: nothing + """ + self._log() + + def ev_out_segstart(self, ctx, segment): + """ + Function to produce start of segment + Returns: 1-ok, 0-not implemented + """ + return self._log() + + def ev_out_segend(self, ctx, segment): + """ + Function to produce end of segment + Returns: 1-ok, 0-not implemented + """ + return self._log() + + def ev_out_assumes(self, ctx): + """ + Function to produce assume directives + Returns: 1-ok, 0-not implemented + """ + return self._log() + + def ev_out_mnem(self, ctx): + """ + Generate text representation of an instruction in 'ctx.insn' + Returns: 1-if appended the mnemonics, 0-not implemented. + """ + return self._log() + + def ev_out_operand(self, ctx, op): + """ + Generate text representation of an instructon operand. + This function shouldn't change the database, flags or anything else. + All these actions should be performed only by u_emu() function. + Returns: 1-ok, -1-operand is hidden + """ + return self._log() + + def ev_out_data(self, ctx, analyze_only): + """ + Generate text represenation of data items + This function MAY change the database and create cross-references, etc. + Returns: 1-ok, 0-not implemented + """ + return self._log() + + def ev_out_label(self, ctx, label): + """ + The kernel is going to generate an instruction label line + or a function header. + Returns: <0-the kernel should not generate the label, 0-not implemented/continue + """ + return self._log() + + def ev_out_special_item(self, ctx, segtype): + """ + Generate text representation of an item in a special segment + i.e. absolute symbols, externs, communal definitions etc. + Returns: 1-ok, 0-not implemented, -1-overflow + """ + return self._log() + + def ev_gen_stkvar_def(self, ctx, mptr, v): + """ + Generate stack variable definition line. + Default line is varname = type ptr value, + where 'type' is one of byte,word,dword,qword,tbyte. + Returns: 1-ok, 0-not implemented. + """ + return self._log() + + def ev_gen_regvar_def(self, ctx, v): + """ + Generate register variable definition line. + Returns: >0-ok, 0-not implemented. + """ + return self._log() + + def ev_gen_src_file_lnnum(self, ctx, filename, lnnum): + """ + Callback: generate analog of#line "file.c" 123 + directive. + Returns: 1-ok, 0-not implemented + """ + return self._log() + + def ev_creating_segm(self, s): + """ + A new segment is about to be created. + Returns 1-ok, <0-should not be created + """ + return self._log() + + def ev_moving_segm(self, segment, to, flags): + """ + May the kernel move the segment? + returns: 0-yes, <0-the kernel should stop + """ + return self._log() + + def ev_coagulate(self, start_ea): + """ + Try to define some unexplored bytes + This notification will be called if the + kernel tried all possibilities and could + not find anything more useful than to + convert to array of bytes. + The module can help the kernel and convert + the bytes into something more useful. + Returns: number of converted bytes + """ + return self._log() + + def ev_undefine(self, ea): + """ + An item in the database (insn or data) is being deleted. + Returns: >=0-ok, <0-the kernel should stop + """ + return self._log() + + def ev_treat_hindering_item(self, hindering_item_ea, new_item_flags, new_item_ea, new_item_length): + """ + An item hinders creation of another item + Returns: 0-no reaction, <0-the kernel may delete the hindering item + """ + return self._log() + + def ev_rename(self, ea, new_name): + """ + The kernel is going to rename a byte + Returns: <0-then the kernel should not rename it + """ + return self._log() + + def ev_is_far_jump(self, icode): + """ + Is indirect far jump or call instruction? + meaningful only if the processor has 'near' and 'far' reference types. + Returns: 0-not implemented, 1-yes, -1-no + """ + return self._log() + + def ev_is_sane_insn(self, insn, no_crefs): + """ + Is the instruction sane for the current file type? + Returns: >=0-ok, <0-no + """ + return self._log() + + def ev_is_cond_insn(self, insn): + """ + Is conditional instruction? + Returns: 1-yes, -1-no, 0-not implemented. + """ + return self._log() + + def ev_is_call_insn(self, insn): + """ + Is the instruction a "call"? + Returns: 0-unknown, <0-no, 1-yes + """ + return self._log() + + def ev_is_ret_insn(self, insn, flags): + """ + Is the instruction a "return"? + Returns: 0-unknown, <0-no, 1-yes + """ + return self._log() + + def ev_may_be_func(self, insn, state): + """ + Can a function start here? + Returns: probability 0..100 + """ + return self._log() + + def ev_is_basic_block_end(self, insn, call_insn_stops_block): + """ + Is the current instruction end of a basic block? + Returns: 0-unknown, -1-no, 1-yes + """ + return self._log() + + def ev_is_indirect_jump(self, insn): + """ + Callback: determine if instruction is an indrect jump + If CF_JUMP bit cannot describe all jump types + jumps, please define this callback. + Returns: 0-use CF_JUMP, 1-no, 2-yes + """ + return self._log() + + def ev_is_switch(self, swi, insn): + """ + Find 'switch' idiom or override processor module's + decision. + Returns: 1-switch found, -1-no switch found, 0-not implmented + """ + return self._log() + + def ev_calc_switch_cases(self, casevec, targets, insn_ea, si): + """ + Calculate case values and targets for a custom jump table. + Returns: 1-ok, <=0-failed + """ + return self._log() + + def ev_create_switch_xrefs(self, jumpea, swi): + """ + Create xrefs for a custom jump table + Must return 1 + """ + self._log() + return 1 + + def ev_is_align_insn(self, ea): + """ + Is the instruction created only for alignment purposes? + Returns: number of bytes in the instruction + """ + return self._log() + + def ev_is_alloca_probe(self, ea): + """ + Does the function at 'ea' behave as __alloca_probe? + Returns: 1-yes, 0-no + """ + return self._log() + + def ev_delay_slot_insn(self, ea, bexec, fexec): + """ + Get delay slot instruction. + Returns 1-yes, <=O-ordianry insn. + """ + return self._log() + + def ev_is_sp_based(self, mode, insn, op): + """ + Check whether the operand is relative to stack pointer or frame pointer. + This function is used to determine how to output a stack variable + This function may be absent. If it is absent, then all operands + are sp based by default. + Define this function only if some stack references use frame pointer + instead of stack pointer. + Returns: 0-not implemented, 1-ok + """ + return self._log() + + def ev_can_have_type(self, op): + """ + Can the operand have a type as offset, segment, decimal, etc? + (for example, a register AX can't have a type, meaning that the user can't + change its representation. see bytes.hpp for information about types and flags) + Returns: 0-unknown, <0-no, 1-yes + """ + return self._log() + + def ev_cmp_operands(self, op1, op2): + """ + Compare instruction operands. + Returns 1-equal, -1-not equal, 0-not implemented + """ + return self._log() + + def ev_adjust_refinfo(self, ri, ea, n, fd): + """ + Called from apply_fixup before converting operand to reference. + Can be used for changing the reference info. + Returns: <0-do not create an offset, 0-not implemented + """ + return self._log() + + def ev_get_operand_string(self, buf, insn, opnum): + """ + Request text string for operand. + Returns: 0-no string (or empty), >0-original string length (without final 0) + """ + return self._log() + + def ev_get_reg_name(self, buf, reg, width, reghi): + """ + Generate text representation of a register. + Most processor modules do not need to implement this callback. + Returns: -1-error, strlen(buf)-success + """ + return self._log() + + def ev_str2reg(self, regname): + """ + Convert a register name to a register number + Returns: 0-not implemented, register number + 1 + """ + return self._log() + + def ev_get_autocmt(self, insn): + """ + Get instruction comment. 'insn' describes the instruction in question + @return: 1-new comment has been generated, 0-not been handled. + """ + return self._log() + + def ev_get_bg_color(self, color, ea): + """ + Get item background color. + Plugins can hook this callback to color disassembly lines dynamically. + Returns: 0-not implemented, 1-color set + """ + return self._log() + + def ev_is_jump_func(self, pfn, jump_target, func_pointer): + """ + Is the function a trivial "jump" function? + Returns: <0-no, 0-don't know, 1-yes + """ + return self._log() + + def ev_func_bounds(self, possible_return_code, pfn, max_func_end_ea): + """ + Find_func_bounds() finished its work. + The module may fine tune the function bounds. + Returns: None + """ + return self._log() + + def ev_verify_sp(self, pfn): + """ + All function instructions have been analyzed. + Now the processor module can analyze the stack pointer + for the whole function + Returns: 0-ok, <0-bad stack pointer + """ + return self._log() + + def ev_verify_noreturn(self, pfn): + """ + The kernel wants to set 'noreturn' flags for a function + Returns: 0-ok, <0-do not set 'noreturn' flag + """ + return self._log() + + def ev_create_func_frame(self, pfn): + """ + Create a function frame for a newly created function. + Set up frame size, its attributes etc. + Returns: 1-ok, 0-not implemented + """ + return self._log() + + def ev_get_frame_retsize(self, frsize, pfn): + """ + Get size of function return address in bytes + If this function is absent, the kernel will assume + 8 bytes for 64-bit function,4 bytes for 32-bit + function, c2 bytes otherwise. + Returns 1-ok, 0-not implemented + """ + return self._log() + + def ev_get_stkvar_scale_factor(self): + """ + Should stack variable references be multiplied by + a coefficient before being used in the stack frame? + Currently used by TMS320C55 because the references into + the stack should be multiplied by 2. + Returns: 0-not implemented, >0-scaling factor + """ + return self._log() + + def ev_demangle_name(self, out, res , demreq): + """ + Demangle a C++ (or another language) name into a user-readable string. + This event is called by ::demangle_name(). + Returns: 0-not implemented, 1-success + """ + return self._log() + + def ev_add_cref(self, frm, to, type): + """ + A code reference is being created. + Returns: 0-not implemented, <0-cancel cref creation + """ + return self._log() + + def ev_add_dref(self, frm, to, type): + """ + A data reference is being created. + Returns: 0-not implemented, <0-cancel dref creation + """ + return self._log() + + def ev_del_cref(self, frm, to, expand): + """ + A code reference is being deleted. + Returns: 0-not implemented, <0-cancel cref deletion + """ + return self._log() + + def ev_del_dref(self, frm, to): + """ + A data reference is being deleted. + Retuns: 0-not implemented, <0-cancel dref deletion + """ + return self._log() + + def ev_coagulate_dref(self, from_ea, to_ea, may_define, code_ea): + """ + Data reference is being analyzed. + plugin may correct code_ea (e.g. for thumb mode refs, we clear the last bit) + Returns: >0-new code_ea, -1-cancel dref analysis + """ + return self._log() + + def ev_may_show_sreg(self, current_ea): + """ + The kernel wants to display the segment registers + in the messages window. + Returns: 0-not implemented, <0-kernel should not show. + """ + return self._log() + + def ev_loader_elf_machine(self, li, machine_type, p_procname, p_pd, loader, reader): + """ + ELF loader machine type checkpoint. + A plugin check of the 'machine_type'. If it is the desired one, + the the plugin fills 'p_procname' with the processor name. + Returns: e_machine value + """ + pass + + def ev_auto_queue_empty(self, atype): + """ + One analysis queue is empty. + Returns: an int (?) + """ + return self._log() + + def ev_validate_flirt_func(self, start_ea, func_name): + """ + FLIRT has recognized a library function. + This callback can be used by a plugin or proc module + to intercept it and validate such a function. + Returns: -1-do not create, 0-validated + """ + return self._log() + + def ev_adjust_libfunc_ea(self, sig, libfun, ea): + """ + Called when a signature module has been matched against + bytes in the database. This is used to compute the + offset at which a particular module's libfunc should + be applied. + Returns: 1-ea has been modified, <=0 not modified + """ + return self._log() + + def ev_assemble(self, ea, cs, ip, use32, line): + """ + Assemble an instruction + (make sure that PR_ASSEMBLE flag is set in the processor flags) + (display a warning if an error occurs) + Returns opcode string-ok, None-failed + """ + return self._log() + + def ev_extract_address(self, out_ea, screen_ea, string, position): + """ + Extract address from a string. + Returns: 1-ok, 0-use standard algorithm, -1-error + """ + return self._log() + + def ev_realcvt(self, m,e, swt): + """ + Floating point -> IEEE conversion + Returns: 1-ok, 0-not implemented, REAL_ERROR_-error + """ + return self._log() + + def ev_gen_asm_or_lst(self, starting, fp, is_asm, flags, outline): + """ + Callback generating asm orlst file. + The kernel calls this callback twice, at the beginning + and at the end of listing generation. The processor + module can intercept this event and adjust its output. + Returns: None + """ + return self._log() + + def ev_gen_map_file(self, nlines, fp): + """ + Generate a map file. If not implemented + the kernel itself will create the map file. + Returns: 1-ok, 0-not implemented, -1-write error + """ + return self._log() + + def ev_create_flat_group(self, image_base, bitness, dataseg_sel): + """ + Create special segment representing the flat group. + Returns: return value ignored. + """ + return self._log() + + def ev_analyze_prolog(self, ea): + """ + Analyzes function prolog, epilog, and updates + purge, and function attributes + Returns: 1-ok, 0-not implemented. + """ + return self._log() + + +# Remove an existing hook on second run +try: + idp_hook_stat = "un" + print("IDP hook: checking for hook...") + idphook + print("IDP hook: unhooking....") + idp_hook_stat2 = "" + idphook.unhook() + del idphook +except: + print("IDP hook: not installed, installing now....") + idp_hook_stat = "" + idp_hook_stat2 = "un" + idphook = idp_logger_hooks_t() + idphook.hook() + +print(f'IDP hook {idp_hook_stat}installed. Run the script again to {idp_hook_stat2}install') diff --git a/api-examples/inf/print_basic_info.py b/api-examples/inf/print_basic_info.py new file mode 100644 index 0000000..6090496 --- /dev/null +++ b/api-examples/inf/print_basic_info.py @@ -0,0 +1,84 @@ +""" +summary: Print basic information about the currently loaded IDB. + +description: + In this script we display some basic information about the + current IDB: + * the compiler name and the size of some datatypes + * Other general IDB information including: application bitness, + file type, various address ranges, main address and start + addresses if exist. + For this we use some of the inf_get_xxx functions from the + ida_ida module. +""" +import ida_ida +import ida_kernwin +import ida_typeinf +import ida_idaapi + +ft_dict = { + ida_ida.f_EXE_old: 'MS DOS EXE File', + ida_ida.f_COM_old: 'MS DOS COM File', + ida_ida.f_BIN: 'Binary File', + ida_ida.f_DRV: 'MS DOS Driver', + ida_ida.f_WIN: 'New Executable (NE)', + ida_ida.f_HEX: 'Intel Hex Object File', + ida_ida.f_MEX: 'MOS Technology Hex Object File', + ida_ida.f_LX: 'Linear Executable (LX)', + ida_ida.f_LE: 'Linear Executable (LE)', + ida_ida.f_NLM: 'Netware Loadable Module (NLM)', + ida_ida.f_COFF: 'Common Object File Format (COFF)', + ida_ida.f_PE: 'Portable Executable (PE)', + ida_ida.f_OMF: 'Object Module Format', + ida_ida.f_SREC: 'Motorola SREC (S-record)', + ida_ida.f_ZIP: 'ZIP file (this file is never loaded to IDA database)', + ida_ida.f_OMFLIB: 'Library of OMF Modules', + ida_ida.f_AR: 'ar library', + ida_ida.f_LOADER: 'file is loaded using LOADER DLL', + ida_ida.f_ELF: 'Executable and Linkable Format (ELF)', + ida_ida.f_W32RUN: 'Watcom DOS32 Extender (W32RUN)', + ida_ida.f_AOUT: 'Linux a.out (AOUT)', + ida_ida.f_PRC: 'PalmPilot program file', + ida_ida.f_EXE: 'MS DOS EXE File', + ida_ida.f_COM: 'MS DOS COM File', + ida_ida.f_AIXAR: 'AIX ar library', + ida_ida.f_MACHO: 'Mac OS X Mach-O', + ida_ida.f_PSXOBJ: 'Sony Playstation PSX object file', + ida_ida.f_MD1IMG: 'Mediatek Firmware Image' +} + +def main(): + print('\nCompiler info:') + cc = ida_ida.compiler_info_t() + ida_ida.inf_get_cc(cc) + print(f'\tCompilateur: {ida_typeinf.get_compiler_name(cc.id)}') + print(f'\t\tByte size: {ida_ida.inf_get_cc_size_b()}') + print(f'\t\tShort size: {ida_ida.inf_get_cc_size_s()}') + print(f'\t\tEnum size: {ida_ida.inf_get_cc_size_e()}') + print(f'\t\tInteger size: {ida_ida.inf_get_cc_size_i()}') + print(f'\t\tLong size: {ida_ida.inf_get_cc_size_l()}') + print(f'\t\tLong double size: {ida_ida.inf_get_cc_size_ldbl()}') + print(f'\t\tLong long size: {ida_ida.inf_get_cc_size_ll()}') + + print('\nGeneral IDB information:') + print(f'\tApplication bitness: {ida_ida.inf_get_app_bitness()}-bit') + if ida_ida.inf_is_kernel_mode(): + land = 'Kernel' + else: + land = 'User' + print(f'\tExecution mode: {land}') + print(f'\tFile type: {ft_dict[ida_ida.inf_get_filetype()]}') + main_ea = ida_ida.inf_get_main() + if not main_ea == ida_idaapi.BADADDR: + print(f'\tMain entry point: {main_ea:x}') + start_ea = ida_ida.inf_get_start_ea() + if not start_ea == ida_idaapi.BADADDR: + print(f'Start entry: {start_ea:x}') + print(f'\tMinimum effective address: {ida_ida.inf_get_min_ea():x}') + print(f'\tMaximum effective address: {ida_ida.inf_get_max_ea():x}') + print(f'\tPrivate range start: {ida_ida.inf_get_privrange_start_ea():x}') + print(f'\tPrivate range end: {ida_ida.inf_get_privrange_end_ea():x}') + + +ida_kernwin.msg_clear() +main() \ No newline at end of file diff --git a/api-examples/inf/print_basic_info_plugin.py b/api-examples/inf/print_basic_info_plugin.py new file mode 100644 index 0000000..6e05b39 --- /dev/null +++ b/api-examples/inf/print_basic_info_plugin.py @@ -0,0 +1,37 @@ +""" +summary: Python plugin that print basic IDB information. + +description: + Demonstrates how to turn an IDA python script into + an IDA Python plugin. +""" +import ida_idaapi +import ida_kernwin +import print_basic_info + +class pbi_plugmod_t(ida_idaapi.plugmod_t): + def __del__(self): + ida_kernwin.msg("PBI >> unloaded pbi_plugmod\n") + + def run(self, arg): + ida_kernwin.msg("PBI >> run() called with %d!\n" % arg) + print_basic_info.main() + return True + +class pbi_plugin_t(ida_idaapi.plugin_t): + flags = ida_idaapi.PLUGIN_UNL | ida_idaapi.PLUGIN_MULTI + comment = "This is a simple plugin printing basic info" + help = "" + wanted_name = "Print Basic Info (PBI) plugin" + wanted_hotkey = "Ctrl-Alt-F12" + + + def init(self): + ida_kernwin.msg("PBI >> init() called!\n") + return pbi_plugmod_t() + + def term(self): + ida_kernwin.msg("PBI >> ERROR: term() called (should never be called)\n") + +def PLUGIN_ENTRY(): + return pbi_plugin_t() \ No newline at end of file diff --git a/api-examples/misc/find_binary_pattern.py b/api-examples/misc/find_binary_pattern.py new file mode 100644 index 0000000..9781b3b --- /dev/null +++ b/api-examples/misc/find_binary_pattern.py @@ -0,0 +1,103 @@ +''' +summary: Use bin_search to find the occurences of + "mov rax, cs:___security_cookie" + +description: + This example shows a way of finding the + "mov rax, cs:___security_cookie" instruction in a x64 database using + bin_search. For this we: + * check that the database is, indeed an x64 one + * build the binary pattern vector + * search for the pattern + * for each result we validate that operand 1 (Op2.addr) points to + __security_cookie + * once the list is built, print it ([index] func_name @ address) +''' + +import ida_bytes +import ida_idaapi +import ida_name +import ida_funcs +import ida_ua +import ida_ida + +message = 'Pattern \"mov rax, cs:__security_cookie\" found:' + +pattern_bytes = b'\x48\x8B\x05\x56\xAF\x35\x00' +pattern_mask = b'\x01\x01\x01\x00\x00\x00\x01' + +def is_pc_64(): + if ida_ida.inf_get_procname() != 'metapc' and not ida_ida.inf_is64bit(): + return False + return True + +def build_pattern_vec(bytes, mask = None): + pattern = ida_bytes.compiled_binpat_t() + pattern.bytes = bytes + if mask: + pattern.mask = mask + + pattern_vec = ida_bytes.compiled_binpat_vec_t() + pattern_vec.push_back(pattern) + + return pattern_vec + +def is_valid(ea, sc_ea): + insn = ida_ua.insn_t() + ida_ua.decode_insn(insn, ea) + + op = insn.Op2 + if op.type == 2 and op.dtype == 7 and op.addr == sc_ea: + return True + + return False + +def build_ea_list(start_ea, end_ea, pattern_vec, flags, sc_ea): + ea_list = [] + + while start_ea < end_ea: + start_ea, _ = ida_bytes.bin_search(start_ea, end_ea, pattern_vec, flags) + if start_ea == ida_idaapi.BADADDR: + break + + if is_valid(start_ea, sc_ea): + ea_list.append(start_ea) + + start_ea += 1 + + return ea_list + +def print_result(str, lst): + print(str) + + idx = 0 + for ea in lst: + fname = ida_funcs.get_func_name(ea) + dname = ida_name.demangle_name(fname, 0) + pname = fname + if dname: + pname = dname + + print(f'[{idx}] {pname} @ {ea:x}') + idx += 1 + + +def main(): + if not is_pc_64(): + print('This script will only work for x64 databases.') + return + + security_ea = ida_name.get_name_ea(ida_idaapi.BADADDR, '__security_cookie') + if security_ea == ida_idaapi.BADADDR: + print('No reference to __security_cookie.') + return + + pv = build_pattern_vec(pattern_bytes, pattern_mask) + + flags = ida_bytes.BIN_SEARCH_FORWARD | ida_bytes.BIN_SEARCH_NOCASE | ida_bytes.BIN_SEARCH_NOBREAK + lst = build_ea_list(ida_ida.inf_get_min_ea(), ida_ida.inf_get_max_ea(), pv, flags, security_ea) + + print_result(message, lst) + +if __name__ == '__main__': + main() diff --git a/api-examples/misc/find_syscall.py b/api-examples/misc/find_syscall.py new file mode 100644 index 0000000..3fa8052 --- /dev/null +++ b/api-examples/misc/find_syscall.py @@ -0,0 +1,27 @@ +import ida_ida +import ida_idaapi +import ida_bytes +import ida_funcs + +def main(): + if ida_ida.inf_get_filetype() != ida_ida.f_PE or not ida_ida.inf_is_64bit() or ida_ida.inf_get_procname() != 'metapc': + return + + pattern_bytes = b'\x75\x03\x0F\x05' + rstart = ida_ida.inf_get_min_ea() + + found = False + while True: + rstart = ida_bytes.find_bytes(pattern_bytes, rstart) + if rstart == ida_idaapi.BADADDR: + break + fname = ida_funcs.get_func_name(rstart) + if fname and not found: + found = True + print('Syscall found:') + if fname: + print(f'\t@ {rstart + 2:x} ({fname})') + rstart += 1 + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/api-examples/readme.md b/api-examples/readme.md new file mode 100644 index 0000000..efc55ae --- /dev/null +++ b/api-examples/readme.md @@ -0,0 +1,21 @@ +# TIL API examples: + +## Beginner level examples: +* list_enum_member.py +* list_struct_member.py +* list_union_member.py +* import_type_from_til.py +* list_struct_xref.py +* create_array.py + +## Intermediate level examples: +* create_structs.py +* create_libssh2.py +* create_bmenum.py +* create_bfstruct.py +* func_ti_changed_listener.py +* mark_func_spoiled.py +* setpehdr.py + +## Advanced level examples: +* operand_to_struct_member.py diff --git a/api-examples/segm/list_imports.py b/api-examples/segm/list_imports.py new file mode 100644 index 0000000..02c1373 --- /dev/null +++ b/api-examples/segm/list_imports.py @@ -0,0 +1,71 @@ +""" +summary: List the .idata section content and the corresponding + data and code references when it applies. + +description: + In this script, we iterate through the .idata PE section. + For each imported function we display: + * its name + * the data references to it (when applying) + * the code references to it (when applying, +""" +import ida_segment +import ida_name +import idautils +import ida_kernwin +import ida_funcs + +def is_code(ea): + return ida_segment.segtype(ea) == ida_segment.SEG_CODE + +def newline(): + print('') + +def list_refs(refs, code): + first = True + if code: + type = 'code' + else: + type = 'data' + + idx = 1 + for ref in refs: + if first: + print(f'\tList of {type} references:') + first = False + ida_kernwin.msg(f'\t* [{idx}] @ {ref:x}') + if is_code(ref): + name = ida_funcs.get_func_name(ref) + if name: + print(f' ({name})') + else: + newline() + else: + newline() + idx += 1 + + +def main(): + import_seg = ida_segment.get_segm_by_name('.idata') + + if import_seg: + curr_ea = import_seg.start_ea + end_ea = import_seg.end_ea + idx = 1 + while curr_ea < end_ea: + name = ida_name.get_ea_name(curr_ea) + print(f'Imported function [{idx}]: {name}') + + list_refs(idautils.DataRefsTo(curr_ea), False) + + list_refs(idautils.CodeRefsTo(curr_ea, 0), True) + + if import_seg.is_64bit(): + curr_ea += 8 + else: + curr_ea += 4 + idx += 1 + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/api_contents.brief b/api_contents.brief index 02b954c..bde6784 100644 --- a/api_contents.brief +++ b/api_contents.brief @@ -1,14561 +1,15070 @@ -ida_hexrays (module) -ida_hexrays.ACFL_BLKOPT (variable) -ida_hexrays.ACFL_GLBDEL (variable) -ida_hexrays.ACFL_GLBPROP (variable) -ida_hexrays.ACFL_GUESS (variable) -ida_hexrays.ACFL_LOCOPT (variable) -ida_hexrays.ALLOW_UNUSED_LABELS (variable) -ida_hexrays.ANCHOR_BLKCMT (variable) -ida_hexrays.ANCHOR_CITEM (variable) -ida_hexrays.ANCHOR_ITP (variable) -ida_hexrays.ANCHOR_LVAR (variable) -ida_hexrays.ANY_FPSIZE (variable) -ida_hexrays.ANY_REGSIZE (variable) -ida_hexrays.BLT_0WAY (variable) -ida_hexrays.BLT_1WAY (variable) -ida_hexrays.BLT_2WAY (variable) -ida_hexrays.BLT_NONE (variable) -ida_hexrays.BLT_NWAY (variable) -ida_hexrays.BLT_STOP (variable) -ida_hexrays.BLT_XTRN (variable) -ida_hexrays.CALC_CURLY_BRACES (variable) -ida_hexrays.CFL_FINAL (variable) -ida_hexrays.CFL_HELPER (variable) -ida_hexrays.CFL_NORET (variable) -ida_hexrays.CFS_BOUNDS (variable) -ida_hexrays.CFS_LOCKED (variable) -ida_hexrays.CFS_LVARS_HIDDEN (variable) -ida_hexrays.CFS_TEXT (variable) -ida_hexrays.CHF_FAKE (variable) -ida_hexrays.CHF_INITED (variable) -ida_hexrays.CHF_OVER (variable) -ida_hexrays.CHF_PASSTHRU (variable) -ida_hexrays.CHF_REPLACED (variable) -ida_hexrays.CHF_TERM (variable) -ida_hexrays.CIT_COLLAPSED (variable) -ida_hexrays.CMAT_BUILT (variable) -ida_hexrays.CMAT_CASTED (variable) -ida_hexrays.CMAT_CPA (variable) -ida_hexrays.CMAT_FINAL (variable) -ida_hexrays.CMAT_NICE (variable) -ida_hexrays.CMAT_TRANS1 (variable) -ida_hexrays.CMAT_TRANS2 (variable) -ida_hexrays.CMAT_TRANS3 (variable) -ida_hexrays.CMAT_ZERO (variable) -ida_hexrays.CMT_ALL (variable) -ida_hexrays.CMT_BLOCK1 (variable) -ida_hexrays.CMT_BLOCK2 (variable) -ida_hexrays.CMT_FUNC (variable) -ida_hexrays.CMT_LVAR (variable) -ida_hexrays.CMT_NONE (variable) -ida_hexrays.CMT_TAIL (variable) -ida_hexrays.CPBLK_FAST (variable) -ida_hexrays.CPBLK_MINREF (variable) -ida_hexrays.CPBLK_OPTJMP (variable) -ida_hexrays.CV_FAST (variable) -ida_hexrays.CV_INSNS (variable) -ida_hexrays.CV_PARENTS (variable) -ida_hexrays.CV_POST (variable) -ida_hexrays.CV_PRUNE (variable) -ida_hexrays.CV_RESTART (variable) -ida_hexrays.DECOMP_ALL_BLKS (variable) -ida_hexrays.DECOMP_GXREFS_DEFLT (variable) -ida_hexrays.DECOMP_GXREFS_FORCE (variable) -ida_hexrays.DECOMP_GXREFS_NOUPD (variable) -ida_hexrays.DECOMP_NO_CACHE (variable) -ida_hexrays.DECOMP_NO_FRAME (variable) -ida_hexrays.DECOMP_NO_HIDE (variable) -ida_hexrays.DECOMP_NO_WAIT (variable) -ida_hexrays.DECOMP_NO_XREFS (variable) -ida_hexrays.DECOMP_VOID_MBA (variable) -ida_hexrays.DECOMP_WARNINGS (variable) -ida_hexrays.DecompilationFailure (class) -ida_hexrays.EQ_CMPDEST (variable) -ida_hexrays.EQ_IGNCODE (variable) -ida_hexrays.EQ_IGNSIZE (variable) -ida_hexrays.EQ_OPTINSN (variable) -ida_hexrays.EXFL_ALL (variable) -ida_hexrays.EXFL_ALONE (variable) -ida_hexrays.EXFL_CPADONE (variable) -ida_hexrays.EXFL_CSTR (variable) -ida_hexrays.EXFL_FPOP (variable) -ida_hexrays.EXFL_JUMPOUT (variable) -ida_hexrays.EXFL_LVALUE (variable) -ida_hexrays.EXFL_PARTIAL (variable) -ida_hexrays.EXFL_UNDEF (variable) -ida_hexrays.EXFL_VFTABLE (variable) -ida_hexrays.FCI_DEAD (variable) -ida_hexrays.FCI_EXPLOCS (variable) -ida_hexrays.FCI_FINAL (variable) -ida_hexrays.FCI_HASCALL (variable) -ida_hexrays.FCI_HASFMT (variable) -ida_hexrays.FCI_NORET (variable) -ida_hexrays.FCI_NOSIDE (variable) -ida_hexrays.FCI_PROP (variable) -ida_hexrays.FCI_PURE (variable) -ida_hexrays.FCI_SPLOK (variable) -ida_hexrays.FD_BACKWARD (variable) -ida_hexrays.FD_DEF (variable) -ida_hexrays.FD_DIRTY (variable) -ida_hexrays.FD_FORWARD (variable) -ida_hexrays.FD_USE (variable) -ida_hexrays.FORBID_UNUSED_LABELS (variable) -ida_hexrays.GCA_ALLOC (variable) -ida_hexrays.GCA_EMPTY (variable) -ida_hexrays.GCA_NALLOC (variable) -ida_hexrays.GCA_OFIRST (variable) -ida_hexrays.GCA_OLAST (variable) -ida_hexrays.GCA_SPEC (variable) -ida_hexrays.GCO_DEF (variable) -ida_hexrays.GCO_REG (variable) -ida_hexrays.GCO_STK (variable) -ida_hexrays.GCO_USE (variable) -ida_hexrays.GC_ASR (variable) -ida_hexrays.GC_DIRTY_ALL (variable) -ida_hexrays.GC_END (variable) -ida_hexrays.GC_REGS_AND_STKVARS (variable) -ida_hexrays.GC_XDSU (variable) -ida_hexrays.GLN_ALL (variable) -ida_hexrays.GLN_CURRENT (variable) -ida_hexrays.GLN_GOTO_TARGET (variable) -ida_hexrays.Hexrays_Hooks (class) -ida_hexrays.Hexrays_Hooks.__disown__ (method) -ida_hexrays.Hexrays_Hooks.__init__ (method) -ida_hexrays.Hexrays_Hooks.build_callinfo (method) -ida_hexrays.Hexrays_Hooks.callinfo_built (method) -ida_hexrays.Hexrays_Hooks.calls_done (method) -ida_hexrays.Hexrays_Hooks.close_pseudocode (method) -ida_hexrays.Hexrays_Hooks.cmt_changed (method) -ida_hexrays.Hexrays_Hooks.combine (method) -ida_hexrays.Hexrays_Hooks.create_hint (method) -ida_hexrays.Hexrays_Hooks.curpos (method) -ida_hexrays.Hexrays_Hooks.double_click (method) -ida_hexrays.Hexrays_Hooks.flowchart (method) -ida_hexrays.Hexrays_Hooks.func_printed (method) -ida_hexrays.Hexrays_Hooks.glbopt (method) -ida_hexrays.Hexrays_Hooks.hook (method) -ida_hexrays.Hexrays_Hooks.interr (method) -ida_hexrays.Hexrays_Hooks.keyboard (method) -ida_hexrays.Hexrays_Hooks.locopt (method) -ida_hexrays.Hexrays_Hooks.lvar_cmt_changed (method) -ida_hexrays.Hexrays_Hooks.lvar_mapping_changed (method) -ida_hexrays.Hexrays_Hooks.lvar_name_changed (method) -ida_hexrays.Hexrays_Hooks.lvar_type_changed (method) -ida_hexrays.Hexrays_Hooks.maturity (method) -ida_hexrays.Hexrays_Hooks.microcode (method) -ida_hexrays.Hexrays_Hooks.open_pseudocode (method) -ida_hexrays.Hexrays_Hooks.populating_popup (method) -ida_hexrays.Hexrays_Hooks.prealloc (method) -ida_hexrays.Hexrays_Hooks.preoptimized (method) -ida_hexrays.Hexrays_Hooks.print_func (method) -ida_hexrays.Hexrays_Hooks.prolog (method) -ida_hexrays.Hexrays_Hooks.refresh_pseudocode (method) -ida_hexrays.Hexrays_Hooks.resolve_stkaddrs (method) -ida_hexrays.Hexrays_Hooks.right_click (method) -ida_hexrays.Hexrays_Hooks.stkpnts (method) -ida_hexrays.Hexrays_Hooks.structural (method) -ida_hexrays.Hexrays_Hooks.switch_pseudocode (method) -ida_hexrays.Hexrays_Hooks.text_ready (method) -ida_hexrays.Hexrays_Hooks.unhook (method) -ida_hexrays.IPROP_CLNPOP (variable) -ida_hexrays.IPROP_COMBINED (variable) -ida_hexrays.IPROP_DONT_COMB (variable) -ida_hexrays.IPROP_DONT_PROP (variable) -ida_hexrays.IPROP_EXTSTX (variable) -ida_hexrays.IPROP_FARCALL (variable) -ida_hexrays.IPROP_FPINSN (variable) -ida_hexrays.IPROP_IGNLOWSRC (variable) -ida_hexrays.IPROP_INV_JX (variable) -ida_hexrays.IPROP_MBARRIER (variable) -ida_hexrays.IPROP_MULTI_MOV (variable) -ida_hexrays.IPROP_OPTIONAL (variable) -ida_hexrays.IPROP_PERSIST (variable) -ida_hexrays.IPROP_SPLIT (variable) -ida_hexrays.IPROP_SPLIT1 (variable) -ida_hexrays.IPROP_SPLIT2 (variable) -ida_hexrays.IPROP_SPLIT4 (variable) -ida_hexrays.IPROP_SPLIT8 (variable) -ida_hexrays.IPROP_TAILCALL (variable) -ida_hexrays.IPROP_UNMERGED (variable) -ida_hexrays.IPROP_WAS_NORET (variable) -ida_hexrays.IPROP_WILDMATCH (variable) -ida_hexrays.ITP_ARG1 (variable) -ida_hexrays.ITP_ASM (variable) -ida_hexrays.ITP_BLOCK1 (variable) -ida_hexrays.ITP_BLOCK2 (variable) -ida_hexrays.ITP_BRACE2 (variable) -ida_hexrays.ITP_CASE (variable) -ida_hexrays.ITP_COLON (variable) -ida_hexrays.ITP_CURLY1 (variable) -ida_hexrays.ITP_CURLY2 (variable) -ida_hexrays.ITP_DO (variable) -ida_hexrays.ITP_ELSE (variable) -ida_hexrays.ITP_EMPTY (variable) -ida_hexrays.ITP_SEMI (variable) -ida_hexrays.ITP_SIGN (variable) -ida_hexrays.LOCOPT_ALL (variable) -ida_hexrays.LOCOPT_REFINE (variable) -ida_hexrays.LOCOPT_REFINE2 (variable) -ida_hexrays.LVINF_KEEP (variable) -ida_hexrays.LVINF_NOMAP (variable) -ida_hexrays.LVINF_NOPTR (variable) -ida_hexrays.LVINF_SPLIT (variable) -ida_hexrays.LVINF_UNUSED (variable) -ida_hexrays.MBA2_ARGIDX_OK (variable) -ida_hexrays.MBA2_ARGIDX_SORTED (variable) -ida_hexrays.MBA2_CODE16_BIT (variable) -ida_hexrays.MBA2_DONT_VERIFY (variable) -ida_hexrays.MBA2_HAS_OUTLINES (variable) -ida_hexrays.MBA2_IS_CTR (variable) -ida_hexrays.MBA2_IS_DTR (variable) -ida_hexrays.MBA2_LVARNAMES_OK (variable) -ida_hexrays.MBA2_LVARS_RENAMED (variable) -ida_hexrays.MBA2_NO_DUP_CALLS (variable) -ida_hexrays.MBA2_NO_DUP_LVARS (variable) -ida_hexrays.MBA2_NO_FRAME (variable) -ida_hexrays.MBA2_OVER_CHAINS (variable) -ida_hexrays.MBA2_PROP_COMPLEX (variable) -ida_hexrays.MBA2_STACK_RETVAL (variable) -ida_hexrays.MBA2_UNDEF_RETVAR (variable) -ida_hexrays.MBA2_VALRNG_DONE (variable) -ida_hexrays.MBA_ASRPROP (variable) -ida_hexrays.MBA_ASRTOK (variable) -ida_hexrays.MBA_CALLS (variable) -ida_hexrays.MBA_CHVARS (variable) -ida_hexrays.MBA_CMBBLK (variable) -ida_hexrays.MBA_CMNSTK (variable) -ida_hexrays.MBA_COLGDL (variable) -ida_hexrays.MBA_DELPAIRS (variable) -ida_hexrays.MBA_GLBOPT (variable) -ida_hexrays.MBA_INSGDL (variable) -ida_hexrays.MBA_LOADED (variable) -ida_hexrays.MBA_LVARS0 (variable) -ida_hexrays.MBA_LVARS1 (variable) -ida_hexrays.MBA_NICE (variable) -ida_hexrays.MBA_NOFUNC (variable) -ida_hexrays.MBA_NUMADDR (variable) -ida_hexrays.MBA_PASSREGS (variable) -ida_hexrays.MBA_PATTERN (variable) -ida_hexrays.MBA_PRCDEFS (variable) -ida_hexrays.MBA_PREOPT (variable) -ida_hexrays.MBA_REFINE (variable) -ida_hexrays.MBA_RETFP (variable) -ida_hexrays.MBA_RETREF (variable) -ida_hexrays.MBA_SAVRST (variable) -ida_hexrays.MBA_SHORT (variable) -ida_hexrays.MBA_SPLINFO (variable) -ida_hexrays.MBA_THUNK (variable) -ida_hexrays.MBA_VALNUM (variable) -ida_hexrays.MBA_WINGR32 (variable) -ida_hexrays.MBL_BACKPROP (variable) -ida_hexrays.MBL_CALL (variable) -ida_hexrays.MBL_COMB (variable) -ida_hexrays.MBL_DEAD (variable) -ida_hexrays.MBL_DMT64 (variable) -ida_hexrays.MBL_DSLOT (variable) -ida_hexrays.MBL_FAKE (variable) -ida_hexrays.MBL_GOTO (variable) -ida_hexrays.MBL_INCONST (variable) -ida_hexrays.MBL_KEEP (variable) -ida_hexrays.MBL_LIST (variable) -ida_hexrays.MBL_NONFAKE (variable) -ida_hexrays.MBL_NORET (variable) -ida_hexrays.MBL_PRIV (variable) -ida_hexrays.MBL_PROP (variable) -ida_hexrays.MBL_PUSH (variable) -ida_hexrays.MBL_TCAL (variable) -ida_hexrays.MBL_VALRANGES (variable) -ida_hexrays.MERR_BADARCH (variable) -ida_hexrays.MERR_BADBLK (variable) -ida_hexrays.MERR_BADCALL (variable) -ida_hexrays.MERR_BADFRAME (variable) -ida_hexrays.MERR_BADIDB (variable) -ida_hexrays.MERR_BADRANGES (variable) -ida_hexrays.MERR_BADSP (variable) -ida_hexrays.MERR_BITNESS (variable) -ida_hexrays.MERR_BLOCK (variable) -ida_hexrays.MERR_BUSY (variable) -ida_hexrays.MERR_CANCELED (variable) -ida_hexrays.MERR_COMPLEX (variable) -ida_hexrays.MERR_DSLOT (variable) -ida_hexrays.MERR_EXCEPTION (variable) -ida_hexrays.MERR_EXTERN (variable) -ida_hexrays.MERR_FARPTR (variable) -ida_hexrays.MERR_FUNCSIZE (variable) -ida_hexrays.MERR_HUGESTACK (variable) -ida_hexrays.MERR_INSN (variable) -ida_hexrays.MERR_INTERR (variable) -ida_hexrays.MERR_LICENSE (variable) -ida_hexrays.MERR_LOOP (variable) -ida_hexrays.MERR_LVARS (variable) -ida_hexrays.MERR_MEM (variable) -ida_hexrays.MERR_OK (variable) -ida_hexrays.MERR_ONLY32 (variable) -ida_hexrays.MERR_ONLY64 (variable) -ida_hexrays.MERR_OVERLAP (variable) -ida_hexrays.MERR_PARTINIT (variable) -ida_hexrays.MERR_PROLOG (variable) -ida_hexrays.MERR_RECDEPTH (variable) -ida_hexrays.MERR_REDO (variable) -ida_hexrays.MERR_SIZEOF (variable) -ida_hexrays.MERR_STOP (variable) -ida_hexrays.MERR_SWITCH (variable) -ida_hexrays.MERR_UNKTYPE (variable) -ida_hexrays.MLI_CLR_FLAGS (variable) -ida_hexrays.MLI_CMT (variable) -ida_hexrays.MLI_NAME (variable) -ida_hexrays.MLI_SET_FLAGS (variable) -ida_hexrays.MLI_TYPE (variable) -ida_hexrays.MMAT_CALLS (variable) -ida_hexrays.MMAT_GENERATED (variable) -ida_hexrays.MMAT_GLBOPT1 (variable) -ida_hexrays.MMAT_GLBOPT2 (variable) -ida_hexrays.MMAT_GLBOPT3 (variable) -ida_hexrays.MMAT_LOCOPT (variable) -ida_hexrays.MMAT_LVARS (variable) -ida_hexrays.MMAT_PREOPTIMIZED (variable) -ida_hexrays.MMAT_ZERO (variable) -ida_hexrays.MMIDX_GLBHIGH (variable) -ida_hexrays.MMIDX_GLBLOW (variable) -ida_hexrays.NALT_VD (variable) -ida_hexrays.NF_BINVDONE (variable) -ida_hexrays.NF_BITNOT (variable) -ida_hexrays.NF_FIXED (variable) -ida_hexrays.NF_NEGATE (variable) -ida_hexrays.NF_NEGDONE (variable) -ida_hexrays.NF_VALID (variable) -ida_hexrays.NOSIZE (variable) -ida_hexrays.NO_CURLY_BRACES (variable) -ida_hexrays.NO_SIDEFF (variable) -ida_hexrays.ONLY_SIDEFF (variable) -ida_hexrays.OPF_NEW_WINDOW (variable) -ida_hexrays.OPF_NO_WAIT (variable) -ida_hexrays.OPF_REUSE (variable) -ida_hexrays.OPF_REUSE_ACTIVE (variable) -ida_hexrays.OPROP_FLOAT (variable) -ida_hexrays.OPROP_IMPDONE (variable) -ida_hexrays.OPROP_LOWADDR (variable) -ida_hexrays.OPROP_UDEFVAL (variable) -ida_hexrays.OPROP_UDT (variable) -ida_hexrays.OPTI_ADDREXPRS (variable) -ida_hexrays.OPTI_COMBINSNS (variable) -ida_hexrays.OPTI_MINSTKREF (variable) -ida_hexrays.OPTI_NO_LDXOPT (variable) -ida_hexrays.RETRIEVE_ALWAYS (variable) -ida_hexrays.RETRIEVE_ONCE (variable) -ida_hexrays.ROLE_3WAYCMP0 (variable) -ida_hexrays.ROLE_3WAYCMP1 (variable) -ida_hexrays.ROLE_ABS (variable) -ida_hexrays.ROLE_ALLOCA (variable) -ida_hexrays.ROLE_BITTEST (variable) -ida_hexrays.ROLE_BITTESTANDCOMPLEMENT (variable) -ida_hexrays.ROLE_BITTESTANDRESET (variable) -ida_hexrays.ROLE_BITTESTANDSET (variable) -ida_hexrays.ROLE_BSWAP (variable) -ida_hexrays.ROLE_BUG (variable) -ida_hexrays.ROLE_CFSUB3 (variable) -ida_hexrays.ROLE_CONTAINING_RECORD (variable) -ida_hexrays.ROLE_EMPTY (variable) -ida_hexrays.ROLE_FASTFAIL (variable) -ida_hexrays.ROLE_IS_MUL_OK (variable) -ida_hexrays.ROLE_MEMCPY (variable) -ida_hexrays.ROLE_MEMSET (variable) -ida_hexrays.ROLE_MEMSET32 (variable) -ida_hexrays.ROLE_MEMSET64 (variable) -ida_hexrays.ROLE_OFSUB3 (variable) -ida_hexrays.ROLE_PRESENT (variable) -ida_hexrays.ROLE_READFLAGS (variable) -ida_hexrays.ROLE_ROL (variable) -ida_hexrays.ROLE_ROR (variable) -ida_hexrays.ROLE_SATURATED_MUL (variable) -ida_hexrays.ROLE_SSE_CMP4 (variable) -ida_hexrays.ROLE_SSE_CMP8 (variable) -ida_hexrays.ROLE_STRCAT (variable) -ida_hexrays.ROLE_STRCPY (variable) -ida_hexrays.ROLE_STRLEN (variable) -ida_hexrays.ROLE_TAIL (variable) -ida_hexrays.ROLE_UNK (variable) -ida_hexrays.ROLE_VA_ARG (variable) -ida_hexrays.ROLE_VA_COPY (variable) -ida_hexrays.ROLE_VA_END (variable) -ida_hexrays.ROLE_VA_START (variable) -ida_hexrays.ROLE_WCSCAT (variable) -ida_hexrays.ROLE_WCSCPY (variable) -ida_hexrays.ROLE_WCSLEN (variable) -ida_hexrays.ROLE_WMEMCPY (variable) -ida_hexrays.ROLE_WMEMSET (variable) -ida_hexrays.SHINS_LDXEA (variable) -ida_hexrays.SHINS_NUMADDR (variable) -ida_hexrays.SHINS_SHORT (variable) -ida_hexrays.SHINS_VALNUM (variable) -ida_hexrays.ULV_PRECISE_DEFEA (variable) -ida_hexrays.USE_CURLY_BRACES (variable) -ida_hexrays.USE_KEYBOARD (variable) -ida_hexrays.USE_MOUSE (variable) -ida_hexrays.VDI_EXPR (variable) -ida_hexrays.VDI_FUNC (variable) -ida_hexrays.VDI_LVAR (variable) -ida_hexrays.VDI_NONE (variable) -ida_hexrays.VDI_TAIL (variable) -ida_hexrays.VDRUN_APPEND (variable) -ida_hexrays.VDRUN_CMDLINE (variable) -ida_hexrays.VDRUN_LUMINA (variable) -ida_hexrays.VDRUN_MAYSTOP (variable) -ida_hexrays.VDRUN_NEWFILE (variable) -ida_hexrays.VDRUN_ONLYNEW (variable) -ida_hexrays.VDRUN_SENDIDB (variable) -ida_hexrays.VDRUN_SILENT (variable) -ida_hexrays.VDRUN_STATS (variable) -ida_hexrays.VDUI_VALID (variable) -ida_hexrays.VDUI_VISIBLE (variable) -ida_hexrays.VR_AT_END (variable) -ida_hexrays.VR_AT_START (variable) -ida_hexrays.VR_EXACT (variable) -ida_hexrays.WARN_ADDR_OUTARGS (variable) -ida_hexrays.WARN_ARRAY_INARG (variable) -ida_hexrays.WARN_BAD_CALL_SP (variable) -ida_hexrays.WARN_BAD_FIELD_TYPE (variable) -ida_hexrays.WARN_BAD_INSN (variable) -ida_hexrays.WARN_BAD_MAPDST (variable) -ida_hexrays.WARN_BAD_PURGED (variable) -ida_hexrays.WARN_BAD_RETVAR (variable) -ida_hexrays.WARN_BAD_SHADOW (variable) -ida_hexrays.WARN_BAD_SP (variable) -ida_hexrays.WARN_BAD_STD_TYPE (variable) -ida_hexrays.WARN_BAD_STKPNT (variable) -ida_hexrays.WARN_BAD_STROFF (variable) -ida_hexrays.WARN_BAD_VALRNG (variable) -ida_hexrays.WARN_BAD_VARSIZE (variable) -ida_hexrays.WARN_CBUILD_LOOPS (variable) -ida_hexrays.WARN_CR_BADOFF (variable) -ida_hexrays.WARN_CR_NOFIELD (variable) -ida_hexrays.WARN_DEP_UNK_CALLS (variable) -ida_hexrays.WARN_EXP_LINVAR (variable) -ida_hexrays.WARN_FIXED_MACRO (variable) -ida_hexrays.WARN_FRAG_LVAR (variable) -ida_hexrays.WARN_GUESSED_TYPE (variable) -ida_hexrays.WARN_HUGE_STKOFF (variable) -ida_hexrays.WARN_ILL_ELLIPSIS (variable) -ida_hexrays.WARN_ILL_FPU_STACK (variable) -ida_hexrays.WARN_ILL_FUNCTYPE (variable) -ida_hexrays.WARN_ILL_PURGED (variable) -ida_hexrays.WARN_JUMPOUT (variable) -ida_hexrays.WARN_MAX (variable) -ida_hexrays.WARN_MAX_ARGS (variable) -ida_hexrays.WARN_MISSED_SWITCH (variable) -ida_hexrays.WARN_MUST_RET_FP (variable) -ida_hexrays.WARN_NO_SAVE_REST (variable) -ida_hexrays.WARN_ODD_ABI (variable) -ida_hexrays.WARN_ODD_ADDR_USE (variable) -ida_hexrays.WARN_ODD_INPUT_REG (variable) -ida_hexrays.WARN_OPT_USELESS_JCND (variable) -ida_hexrays.WARN_OPT_VALRNG (variable) -ida_hexrays.WARN_OPT_VALRNG2 (variable) -ida_hexrays.WARN_OPT_VALRNG3 (variable) -ida_hexrays.WARN_RET_LOCREF (variable) -ida_hexrays.WARN_SELFREF_PROP (variable) -ida_hexrays.WARN_UNALIGNED_ARG (variable) -ida_hexrays.WARN_UNBALANCED_STACK (variable) -ida_hexrays.WARN_UNDEF_LVAR (variable) -ida_hexrays.WARN_UNINITED_REG (variable) -ida_hexrays.WARN_UNSUPP_REG (variable) -ida_hexrays.WARN_VARARG_MANY (variable) -ida_hexrays.WARN_VARARG_NOSTK (variable) -ida_hexrays.WARN_VARARG_REGS (variable) -ida_hexrays.WARN_VARARG_TCAL (variable) -ida_hexrays.WARN_WIDEN_CHAINS (variable) -ida_hexrays.WARN_WOULD_OVERLAP (variable) -ida_hexrays.WARN_WRITE_CONST (variable) -ida_hexrays.WARN_WRONG_VA_OFF (variable) -ida_hexrays.WITH_SIDEFF (variable) -ida_hexrays.__cbhooks_t (class) -ida_hexrays.__cbhooks_t.__init__ (method) -ida_hexrays.__cbhooks_t.close_pseudocode (method) -ida_hexrays.__cbhooks_t.create_hint (method) -ida_hexrays.__cbhooks_t.curpos (method) -ida_hexrays.__cbhooks_t.double_click (method) -ida_hexrays.__cbhooks_t.func_printed (method) -ida_hexrays.__cbhooks_t.interr (method) -ida_hexrays.__cbhooks_t.keyboard (method) -ida_hexrays.__cbhooks_t.maturity (method) -ida_hexrays.__cbhooks_t.open_pseudocode (method) -ida_hexrays.__cbhooks_t.populating_popup (method) -ida_hexrays.__cbhooks_t.print_func (method) -ida_hexrays.__cbhooks_t.refresh_pseudocode (method) -ida_hexrays.__cbhooks_t.right_click (method) -ida_hexrays.__cbhooks_t.switch_pseudocode (method) -ida_hexrays.__cbhooks_t.text_ready (method) -ida_hexrays._call_with_transferrable_ownership (function) -ida_hexrays._kludge_force_declare_TPopupMenu (function) -ida_hexrays._ll_call_helper (function) -ida_hexrays._ll_create_helper (function) -ida_hexrays._ll_dereference (function) -ida_hexrays._ll_lnot (function) -ida_hexrays._ll_make_num (function) -ida_hexrays._ll_make_ref (function) -ida_hexrays._ll_new_block (function) -ida_hexrays._map_as_dict (function) -ida_hexrays._map_as_dict._map___contains__ (function) -ida_hexrays._map_as_dict._map___delitem__ (function) -ida_hexrays._map_as_dict._map___getitem__ (function) -ida_hexrays._map_as_dict._map___iter__ (function) -ida_hexrays._map_as_dict._map___setitem__ (function) -ida_hexrays._map_as_dict._map_clear (function) -ida_hexrays._map_as_dict._map_copy (function) -ida_hexrays._map_as_dict._map_get (function) -ida_hexrays._map_as_dict._map_has_key (function) -ida_hexrays._map_as_dict._map_items (function) -ida_hexrays._map_as_dict._map_iteritems (function) -ida_hexrays._map_as_dict._map_iterkeys (function) -ida_hexrays._map_as_dict._map_itervalues (function) -ida_hexrays._map_as_dict._map_keys (function) -ida_hexrays._map_as_dict._map_pop (function) -ida_hexrays._map_as_dict._map_popitem (function) -ida_hexrays._map_as_dict._map_setdefault (function) -ida_hexrays._map_as_dict._map_values (function) -ida_hexrays.accepts_small_udts (function) -ida_hexrays.accepts_udts (function) -ida_hexrays.arglocs_overlap (function) -ida_hexrays.array_of_bitsets (class) -ida_hexrays.array_of_bitsets.__eq__ (method) -ida_hexrays.array_of_bitsets.__getitem__ (method) -ida_hexrays.array_of_bitsets.__init__ (method) -ida_hexrays.array_of_bitsets.__len__ (method) -ida_hexrays.array_of_bitsets.__ne__ (method) -ida_hexrays.array_of_bitsets.__setitem__ (method) -ida_hexrays.array_of_bitsets._del (method) -ida_hexrays.array_of_bitsets.add_unique (method) -ida_hexrays.array_of_bitsets.at (method) -ida_hexrays.array_of_bitsets.begin (method) -ida_hexrays.array_of_bitsets.capacity (method) -ida_hexrays.array_of_bitsets.clear (method) -ida_hexrays.array_of_bitsets.empty (method) -ida_hexrays.array_of_bitsets.end (method) -ida_hexrays.array_of_bitsets.erase (method) -ida_hexrays.array_of_bitsets.extract (method) -ida_hexrays.array_of_bitsets.find (method) -ida_hexrays.array_of_bitsets.grow (method) -ida_hexrays.array_of_bitsets.has (method) -ida_hexrays.array_of_bitsets.inject (method) -ida_hexrays.array_of_bitsets.insert (method) -ida_hexrays.array_of_bitsets.pop_back (method) -ida_hexrays.array_of_bitsets.push_back (method) -ida_hexrays.array_of_bitsets.qclear (method) -ida_hexrays.array_of_bitsets.reserve (method) -ida_hexrays.array_of_bitsets.resize (method) -ida_hexrays.array_of_bitsets.size (method) -ida_hexrays.array_of_bitsets.swap (method) -ida_hexrays.array_of_bitsets.truncate (method) -ida_hexrays.array_of_ivlsets (class) -ida_hexrays.array_of_ivlsets.__eq__ (method) -ida_hexrays.array_of_ivlsets.__getitem__ (method) -ida_hexrays.array_of_ivlsets.__init__ (method) -ida_hexrays.array_of_ivlsets.__len__ (method) -ida_hexrays.array_of_ivlsets.__ne__ (method) -ida_hexrays.array_of_ivlsets.__setitem__ (method) -ida_hexrays.array_of_ivlsets._del (method) -ida_hexrays.array_of_ivlsets.add_unique (method) -ida_hexrays.array_of_ivlsets.at (method) -ida_hexrays.array_of_ivlsets.begin (method) -ida_hexrays.array_of_ivlsets.capacity (method) -ida_hexrays.array_of_ivlsets.clear (method) -ida_hexrays.array_of_ivlsets.empty (method) -ida_hexrays.array_of_ivlsets.end (method) -ida_hexrays.array_of_ivlsets.erase (method) -ida_hexrays.array_of_ivlsets.extract (method) -ida_hexrays.array_of_ivlsets.find (method) -ida_hexrays.array_of_ivlsets.grow (method) -ida_hexrays.array_of_ivlsets.has (method) -ida_hexrays.array_of_ivlsets.inject (method) -ida_hexrays.array_of_ivlsets.insert (method) -ida_hexrays.array_of_ivlsets.pop_back (method) -ida_hexrays.array_of_ivlsets.push_back (method) -ida_hexrays.array_of_ivlsets.qclear (method) -ida_hexrays.array_of_ivlsets.reserve (method) -ida_hexrays.array_of_ivlsets.resize (method) -ida_hexrays.array_of_ivlsets.size (method) -ida_hexrays.array_of_ivlsets.swap (method) -ida_hexrays.array_of_ivlsets.truncate (method) -ida_hexrays.asgop (function) -ida_hexrays.asgop_revert (function) -ida_hexrays.bit_bound_t (class) -ida_hexrays.bit_bound_t.__init__ (method) -ida_hexrays.bitset_t (class) -ida_hexrays.bitset_t.__eq__ (method) -ida_hexrays.bitset_t.__ge__ (method) -ida_hexrays.bitset_t.__gt__ (method) -ida_hexrays.bitset_t.__init__ (method) -ida_hexrays.bitset_t.__iter__ (method) -ida_hexrays.bitset_t.__le__ (method) -ida_hexrays.bitset_t.__lt__ (method) -ida_hexrays.bitset_t.__ne__ (method) -ida_hexrays.bitset_t.add (method) -ida_hexrays.bitset_t.back (method) -ida_hexrays.bitset_t.begin (method) -ida_hexrays.bitset_t.clear (method) -ida_hexrays.bitset_t.compare (method) -ida_hexrays.bitset_t.copy (method) -ida_hexrays.bitset_t.count (method) -ida_hexrays.bitset_t.cut_at (method) -ida_hexrays.bitset_t.dstr (method) -ida_hexrays.bitset_t.empty (method) -ida_hexrays.bitset_t.end (method) -ida_hexrays.bitset_t.fill_with_ones (method) -ida_hexrays.bitset_t.front (method) -ida_hexrays.bitset_t.has (method) -ida_hexrays.bitset_t.has_all (method) -ida_hexrays.bitset_t.has_any (method) -ida_hexrays.bitset_t.has_common (method) -ida_hexrays.bitset_t.inc (method) -ida_hexrays.bitset_t.includes (method) -ida_hexrays.bitset_t.intersect (method) -ida_hexrays.bitset_t.is_subset_of (method) -ida_hexrays.bitset_t.itat (method) -ida_hexrays.bitset_t.itv (method) -ida_hexrays.bitset_t.last (method) -ida_hexrays.bitset_t.shift_down (method) -ida_hexrays.bitset_t.sub (method) -ida_hexrays.bitset_t.swap (method) -ida_hexrays.block_chains_begin (function) -ida_hexrays.block_chains_clear (function) -ida_hexrays.block_chains_end (function) -ida_hexrays.block_chains_erase (function) -ida_hexrays.block_chains_find (function) -ida_hexrays.block_chains_free (function) -ida_hexrays.block_chains_get (function) -ida_hexrays.block_chains_insert (function) -ida_hexrays.block_chains_iterator_t (class) -ida_hexrays.block_chains_iterator_t.__eq__ (method) -ida_hexrays.block_chains_iterator_t.__init__ (method) -ida_hexrays.block_chains_iterator_t.__ne__ (method) -ida_hexrays.block_chains_new (function) -ida_hexrays.block_chains_next (function) -ida_hexrays.block_chains_prev (function) -ida_hexrays.block_chains_size (function) -ida_hexrays.block_chains_t (class) -ida_hexrays.block_chains_t.__init__ (method) -ida_hexrays.block_chains_t._print (method) -ida_hexrays.block_chains_t.dstr (method) -ida_hexrays.block_chains_t.get_chain (method) -ida_hexrays.block_chains_t.get_reg_chain (method) -ida_hexrays.block_chains_t.get_stk_chain (method) -ida_hexrays.block_chains_vec_t (class) -ida_hexrays.block_chains_vec_t.__getitem__ (method) -ida_hexrays.block_chains_vec_t.__init__ (method) -ida_hexrays.block_chains_vec_t.__len__ (method) -ida_hexrays.block_chains_vec_t.__setitem__ (method) -ida_hexrays.block_chains_vec_t.at (method) -ida_hexrays.block_chains_vec_t.begin (method) -ida_hexrays.block_chains_vec_t.capacity (method) -ida_hexrays.block_chains_vec_t.clear (method) -ida_hexrays.block_chains_vec_t.empty (method) -ida_hexrays.block_chains_vec_t.end (method) -ida_hexrays.block_chains_vec_t.erase (method) -ida_hexrays.block_chains_vec_t.extract (method) -ida_hexrays.block_chains_vec_t.grow (method) -ida_hexrays.block_chains_vec_t.inject (method) -ida_hexrays.block_chains_vec_t.insert (method) -ida_hexrays.block_chains_vec_t.pop_back (method) -ida_hexrays.block_chains_vec_t.push_back (method) -ida_hexrays.block_chains_vec_t.qclear (method) -ida_hexrays.block_chains_vec_t.reserve (method) -ida_hexrays.block_chains_vec_t.resize (method) -ida_hexrays.block_chains_vec_t.size (method) -ida_hexrays.block_chains_vec_t.swap (method) -ida_hexrays.block_chains_vec_t.truncate (method) -ida_hexrays.boundaries_begin (function) -ida_hexrays.boundaries_clear (function) -ida_hexrays.boundaries_end (function) -ida_hexrays.boundaries_erase (function) -ida_hexrays.boundaries_find (function) -ida_hexrays.boundaries_first (function) -ida_hexrays.boundaries_free (function) -ida_hexrays.boundaries_insert (function) -ida_hexrays.boundaries_iterator_t (class) -ida_hexrays.boundaries_iterator_t.__eq__ (method) -ida_hexrays.boundaries_iterator_t.__init__ (method) -ida_hexrays.boundaries_iterator_t.__ne__ (method) -ida_hexrays.boundaries_new (function) -ida_hexrays.boundaries_next (function) -ida_hexrays.boundaries_prev (function) -ida_hexrays.boundaries_second (function) -ida_hexrays.boundaries_size (function) -ida_hexrays.boundaries_t (class) -ida_hexrays.boundaries_t.__init__ (method) -ida_hexrays.boundaries_t.at (method) -ida_hexrays.boundaries_t.size (method) -ida_hexrays.call_helper (function) -ida_hexrays.carg_t (class) -ida_hexrays.carg_t.__eq__ (method) -ida_hexrays.carg_t.__ge__ (method) -ida_hexrays.carg_t.__gt__ (method) -ida_hexrays.carg_t.__init__ (method) -ida_hexrays.carg_t.__le__ (method) -ida_hexrays.carg_t.__lt__ (method) -ida_hexrays.carg_t.__ne__ (method) -ida_hexrays.carg_t.compare (method) -ida_hexrays.carg_t.consume_cexpr (method) -ida_hexrays.carg_t.formal_type (variable) -ida_hexrays.carg_t.is_vararg (variable) -ida_hexrays.carglist_t (class) -ida_hexrays.carglist_t.__eq__ (method) -ida_hexrays.carglist_t.__ge__ (method) -ida_hexrays.carglist_t.__gt__ (method) -ida_hexrays.carglist_t.__init__ (method) -ida_hexrays.carglist_t.__le__ (method) -ida_hexrays.carglist_t.__lt__ (method) -ida_hexrays.carglist_t.__ne__ (method) -ida_hexrays.carglist_t.compare (method) -ida_hexrays.carglist_t.flags (variable) -ida_hexrays.carglist_t.functype (variable) -ida_hexrays.casm_t (class) -ida_hexrays.casm_t.__eq__ (method) -ida_hexrays.casm_t.__ge__ (method) -ida_hexrays.casm_t.__gt__ (method) -ida_hexrays.casm_t.__init__ (method) -ida_hexrays.casm_t.__le__ (method) -ida_hexrays.casm_t.__lt__ (method) -ida_hexrays.casm_t.__ne__ (method) -ida_hexrays.casm_t.compare (method) -ida_hexrays.casm_t.one_insn (method) -ida_hexrays.cblock_t (class) -ida_hexrays.cblock_t.__eq__ (method) -ida_hexrays.cblock_t.__ge__ (method) -ida_hexrays.cblock_t.__gt__ (method) -ida_hexrays.cblock_t.__init__ (method) -ida_hexrays.cblock_t.__le__ (method) -ida_hexrays.cblock_t.__lt__ (method) -ida_hexrays.cblock_t.__ne__ (method) -ida_hexrays.cblock_t._deregister (method) -ida_hexrays.cblock_t.compare (method) -ida_hexrays.ccase_t (class) -ida_hexrays.ccase_t.__eq__ (method) -ida_hexrays.ccase_t.__ge__ (method) -ida_hexrays.ccase_t.__gt__ (method) -ida_hexrays.ccase_t.__init__ (method) -ida_hexrays.ccase_t.__le__ (method) -ida_hexrays.ccase_t.__lt__ (method) -ida_hexrays.ccase_t.__ne__ (method) -ida_hexrays.ccase_t.compare (method) -ida_hexrays.ccase_t.size (method) -ida_hexrays.ccase_t.value (method) -ida_hexrays.ccase_t.values (variable) -ida_hexrays.ccases_t (class) -ida_hexrays.ccases_t.__eq__ (method) -ida_hexrays.ccases_t.__ge__ (method) -ida_hexrays.ccases_t.__gt__ (method) -ida_hexrays.ccases_t.__init__ (method) -ida_hexrays.ccases_t.__le__ (method) -ida_hexrays.ccases_t.__lt__ (method) -ida_hexrays.ccases_t.__ne__ (method) -ida_hexrays.ccases_t.compare (method) -ida_hexrays.cdg_insn_iterator_t (class) -ida_hexrays.cdg_insn_iterator_t.__init__ (method) -ida_hexrays.cdg_insn_iterator_t.dslot_with_xrefs (method) -ida_hexrays.cdg_insn_iterator_t.has_dslot (method) -ida_hexrays.cdg_insn_iterator_t.is_severed_dslot (method) -ida_hexrays.cdg_insn_iterator_t.next (method) -ida_hexrays.cdg_insn_iterator_t.ok (method) -ida_hexrays.cdg_insn_iterator_t.start (method) -ida_hexrays.cdo_t (class) -ida_hexrays.cdo_t.__eq__ (method) -ida_hexrays.cdo_t.__ge__ (method) -ida_hexrays.cdo_t.__gt__ (method) -ida_hexrays.cdo_t.__init__ (method) -ida_hexrays.cdo_t.__le__ (method) -ida_hexrays.cdo_t.__lt__ (method) -ida_hexrays.cdo_t.__ne__ (method) -ida_hexrays.cdo_t.compare (method) -ida_hexrays.ceinsn_t (class) -ida_hexrays.ceinsn_t.__init__ (method) -ida_hexrays.ceinsn_t.expr (variable) -ida_hexrays.cexpr_operands (function) -ida_hexrays.cexpr_t (class) -ida_hexrays.cexpr_t.__eq__ (method) -ida_hexrays.cexpr_t.__ge__ (method) -ida_hexrays.cexpr_t.__gt__ (method) -ida_hexrays.cexpr_t.__init__ (method) -ida_hexrays.cexpr_t.__le__ (method) -ida_hexrays.cexpr_t.__lt__ (method) -ida_hexrays.cexpr_t.__ne__ (method) -ida_hexrays.cexpr_t._deregister (method) -ida_hexrays.cexpr_t._get_a (method) -ida_hexrays.cexpr_t._get_fpc (method) -ida_hexrays.cexpr_t._get_helper (method) -ida_hexrays.cexpr_t._get_insn (method) -ida_hexrays.cexpr_t._get_m (method) -ida_hexrays.cexpr_t._get_n (method) -ida_hexrays.cexpr_t._get_obj_ea (method) -ida_hexrays.cexpr_t._get_ptrsize (method) -ida_hexrays.cexpr_t._get_refwidth (method) -ida_hexrays.cexpr_t._get_string (method) -ida_hexrays.cexpr_t._get_x (method) -ida_hexrays.cexpr_t._get_y (method) -ida_hexrays.cexpr_t._get_z (method) -ida_hexrays.cexpr_t._register (method) -ida_hexrays.cexpr_t._replace_by (method) -ida_hexrays.cexpr_t._set_a (method) -ida_hexrays.cexpr_t._set_fpc (method) -ida_hexrays.cexpr_t._set_helper (method) -ida_hexrays.cexpr_t._set_insn (method) -ida_hexrays.cexpr_t._set_m (method) -ida_hexrays.cexpr_t._set_n (method) -ida_hexrays.cexpr_t._set_obj_ea (method) -ida_hexrays.cexpr_t._set_ptrsize (method) -ida_hexrays.cexpr_t._set_refwidth (method) -ida_hexrays.cexpr_t._set_string (method) -ida_hexrays.cexpr_t._set_x (method) -ida_hexrays.cexpr_t._set_y (method) -ida_hexrays.cexpr_t._set_z (method) -ida_hexrays.cexpr_t.a (variable) -ida_hexrays.cexpr_t.assign (method) -ida_hexrays.cexpr_t.calc_type (method) -ida_hexrays.cexpr_t.cleanup (method) -ida_hexrays.cexpr_t.compare (method) -ida_hexrays.cexpr_t.contains_comma (method) -ida_hexrays.cexpr_t.contains_comma_or_insn_or_label (method) -ida_hexrays.cexpr_t.contains_insn (method) -ida_hexrays.cexpr_t.contains_insn_or_label (method) -ida_hexrays.cexpr_t.contains_operator (method) -ida_hexrays.cexpr_t.cpadone (method) -ida_hexrays.cexpr_t.dstr (method) -ida_hexrays.cexpr_t.equal_effect (method) -ida_hexrays.cexpr_t.exflags (variable) -ida_hexrays.cexpr_t.find_num_op (method) -ida_hexrays.cexpr_t.find_op (method) -ida_hexrays.cexpr_t.fpc (variable) -ida_hexrays.cexpr_t.get_1num_op (method) -ida_hexrays.cexpr_t.get_const_value (method) -ida_hexrays.cexpr_t.get_high_nbit_bound (method) -ida_hexrays.cexpr_t.get_low_nbit_bound (method) -ida_hexrays.cexpr_t.get_ptr_or_array (method) -ida_hexrays.cexpr_t.get_type_sign (method) -ida_hexrays.cexpr_t.get_v (method) -ida_hexrays.cexpr_t.has_side_effects (method) -ida_hexrays.cexpr_t.helper (variable) -ida_hexrays.cexpr_t.insn (variable) -ida_hexrays.cexpr_t.is_call_arg_of (method) -ida_hexrays.cexpr_t.is_call_object_of (method) -ida_hexrays.cexpr_t.is_child_of (method) -ida_hexrays.cexpr_t.is_const_value (method) -ida_hexrays.cexpr_t.is_cstr (method) -ida_hexrays.cexpr_t.is_fpop (method) -ida_hexrays.cexpr_t.is_jumpout (method) -ida_hexrays.cexpr_t.is_negative_const (method) -ida_hexrays.cexpr_t.is_nice_cond (method) -ida_hexrays.cexpr_t.is_nice_expr (method) -ida_hexrays.cexpr_t.is_non_negative_const (method) -ida_hexrays.cexpr_t.is_non_zero_const (method) -ida_hexrays.cexpr_t.is_odd_lvalue (method) -ida_hexrays.cexpr_t.is_type_signed (method) -ida_hexrays.cexpr_t.is_type_unsigned (method) -ida_hexrays.cexpr_t.is_undef_val (method) -ida_hexrays.cexpr_t.is_vftable (method) -ida_hexrays.cexpr_t.is_zero_const (method) -ida_hexrays.cexpr_t.m (variable) -ida_hexrays.cexpr_t.maybe_ptr (method) -ida_hexrays.cexpr_t.n (variable) -ida_hexrays.cexpr_t.numval (method) -ida_hexrays.cexpr_t.obj_ea (variable) -ida_hexrays.cexpr_t.print1 (method) -ida_hexrays.cexpr_t.ptrsize (variable) -ida_hexrays.cexpr_t.put_number (method) -ida_hexrays.cexpr_t.refwidth (variable) -ida_hexrays.cexpr_t.requires_lvalue (method) -ida_hexrays.cexpr_t.set_cpadone (method) -ida_hexrays.cexpr_t.set_v (method) -ida_hexrays.cexpr_t.set_vftable (method) -ida_hexrays.cexpr_t.string (variable) -ida_hexrays.cexpr_t.swap (method) -ida_hexrays.cexpr_t.theother (method) -ida_hexrays.cexpr_t.type (variable) -ida_hexrays.cexpr_t.v (variable) -ida_hexrays.cexpr_t.x (variable) -ida_hexrays.cexpr_t.y (variable) -ida_hexrays.cexpr_t.z (variable) -ida_hexrays.cfor_t (class) -ida_hexrays.cfor_t.__eq__ (method) -ida_hexrays.cfor_t.__ge__ (method) -ida_hexrays.cfor_t.__gt__ (method) -ida_hexrays.cfor_t.__init__ (method) -ida_hexrays.cfor_t.__le__ (method) -ida_hexrays.cfor_t.__lt__ (method) -ida_hexrays.cfor_t.__ne__ (method) -ida_hexrays.cfor_t.compare (method) -ida_hexrays.cfor_t.init (variable) -ida_hexrays.cfor_t.step (variable) -ida_hexrays.cfunc_parentee_t (class) -ida_hexrays.cfunc_parentee_t.__disown__ (method) -ida_hexrays.cfunc_parentee_t.__init__ (method) -ida_hexrays.cfunc_parentee_t.calc_rvalue_type (method) -ida_hexrays.cfunc_parentee_t.func (variable) -ida_hexrays.cfunc_t (class) -ida_hexrays.cfunc_t.__init__ (method) -ida_hexrays.cfunc_t.__str__ (method) -ida_hexrays.cfunc_t.argidx (variable) -ida_hexrays.cfunc_t.body (variable) -ida_hexrays.cfunc_t.build_c_tree (method) -ida_hexrays.cfunc_t.del_orphan_cmts (method) -ida_hexrays.cfunc_t.entry_ea (variable) -ida_hexrays.cfunc_t.find_item_coords (method) -ida_hexrays.cfunc_t.find_label (method) -ida_hexrays.cfunc_t.gather_derefs (method) -ida_hexrays.cfunc_t.get_boundaries (method) -ida_hexrays.cfunc_t.get_eamap (method) -ida_hexrays.cfunc_t.get_func_type (method) -ida_hexrays.cfunc_t.get_line_item (method) -ida_hexrays.cfunc_t.get_lvars (method) -ida_hexrays.cfunc_t.get_pseudocode (method) -ida_hexrays.cfunc_t.get_stkoff_delta (method) -ida_hexrays.cfunc_t.get_user_cmt (method) -ida_hexrays.cfunc_t.get_user_iflags (method) -ida_hexrays.cfunc_t.get_user_union_selection (method) -ida_hexrays.cfunc_t.get_warnings (method) -ida_hexrays.cfunc_t.has_orphan_cmts (method) -ida_hexrays.cfunc_t.hdrlines (variable) -ida_hexrays.cfunc_t.locked (method) -ida_hexrays.cfunc_t.maturity (variable) -ida_hexrays.cfunc_t.mba (variable) -ida_hexrays.cfunc_t.numforms (variable) -ida_hexrays.cfunc_t.print_dcl (method) -ida_hexrays.cfunc_t.print_func (method) -ida_hexrays.cfunc_t.refcnt (variable) -ida_hexrays.cfunc_t.refresh_func_ctext (method) -ida_hexrays.cfunc_t.release (method) -ida_hexrays.cfunc_t.remove_unused_labels (method) -ida_hexrays.cfunc_t.save_user_cmts (method) -ida_hexrays.cfunc_t.save_user_iflags (method) -ida_hexrays.cfunc_t.save_user_labels (method) -ida_hexrays.cfunc_t.save_user_numforms (method) -ida_hexrays.cfunc_t.save_user_unions (method) -ida_hexrays.cfunc_t.set_user_cmt (method) -ida_hexrays.cfunc_t.set_user_iflags (method) -ida_hexrays.cfunc_t.set_user_union_selection (method) -ida_hexrays.cfunc_t.statebits (variable) -ida_hexrays.cfunc_t.treeitems (variable) -ida_hexrays.cfunc_t.user_cmts (variable) -ida_hexrays.cfunc_t.user_iflags (variable) -ida_hexrays.cfunc_t.user_labels (variable) -ida_hexrays.cfunc_t.user_unions (variable) -ida_hexrays.cfunc_t.verify (method) -ida_hexrays.cfunc_type (function) -ida_hexrays.cfuncptr_t (class) -ida_hexrays.cfuncptr_t.__deref__ (method) -ida_hexrays.cfuncptr_t.__init__ (method) -ida_hexrays.cfuncptr_t.__ptrval__ (method) -ida_hexrays.cfuncptr_t.__ref__ (method) -ida_hexrays.cfuncptr_t.__str__ (method) -ida_hexrays.cfuncptr_t.build_c_tree (method) -ida_hexrays.cfuncptr_t.del_orphan_cmts (method) -ida_hexrays.cfuncptr_t.find_item_coords (method) -ida_hexrays.cfuncptr_t.find_label (method) -ida_hexrays.cfuncptr_t.gather_derefs (method) -ida_hexrays.cfuncptr_t.get_boundaries (method) -ida_hexrays.cfuncptr_t.get_eamap (method) -ida_hexrays.cfuncptr_t.get_func_type (method) -ida_hexrays.cfuncptr_t.get_line_item (method) -ida_hexrays.cfuncptr_t.get_lvars (method) -ida_hexrays.cfuncptr_t.get_pseudocode (method) -ida_hexrays.cfuncptr_t.get_stkoff_delta (method) -ida_hexrays.cfuncptr_t.get_user_cmt (method) -ida_hexrays.cfuncptr_t.get_user_iflags (method) -ida_hexrays.cfuncptr_t.get_user_union_selection (method) -ida_hexrays.cfuncptr_t.get_warnings (method) -ida_hexrays.cfuncptr_t.has_orphan_cmts (method) -ida_hexrays.cfuncptr_t.locked (method) -ida_hexrays.cfuncptr_t.print_dcl (method) -ida_hexrays.cfuncptr_t.print_func (method) -ida_hexrays.cfuncptr_t.refresh_func_ctext (method) -ida_hexrays.cfuncptr_t.release (method) -ida_hexrays.cfuncptr_t.remove_unused_labels (method) -ida_hexrays.cfuncptr_t.reset (method) -ida_hexrays.cfuncptr_t.save_user_cmts (method) -ida_hexrays.cfuncptr_t.save_user_iflags (method) -ida_hexrays.cfuncptr_t.save_user_labels (method) -ida_hexrays.cfuncptr_t.save_user_numforms (method) -ida_hexrays.cfuncptr_t.save_user_unions (method) -ida_hexrays.cfuncptr_t.set_user_cmt (method) -ida_hexrays.cfuncptr_t.set_user_iflags (method) -ida_hexrays.cfuncptr_t.set_user_union_selection (method) -ida_hexrays.cfuncptr_t.verify (method) -ida_hexrays.cgoto_t (class) -ida_hexrays.cgoto_t.__eq__ (method) -ida_hexrays.cgoto_t.__ge__ (method) -ida_hexrays.cgoto_t.__gt__ (method) -ida_hexrays.cgoto_t.__init__ (method) -ida_hexrays.cgoto_t.__le__ (method) -ida_hexrays.cgoto_t.__lt__ (method) -ida_hexrays.cgoto_t.__ne__ (method) -ida_hexrays.cgoto_t.compare (method) -ida_hexrays.cgoto_t.label_num (variable) -ida_hexrays.chain_keeper_t (class) -ida_hexrays.chain_keeper_t.__init__ (method) -ida_hexrays.chain_keeper_t.back (method) -ida_hexrays.chain_keeper_t.for_all_chains (method) -ida_hexrays.chain_keeper_t.front (method) -ida_hexrays.chain_t (class) -ida_hexrays.chain_t.__init__ (method) -ida_hexrays.chain_t.__lt__ (method) -ida_hexrays.chain_t._print (method) -ida_hexrays.chain_t.append_list (method) -ida_hexrays.chain_t.clear_varnum (method) -ida_hexrays.chain_t.dstr (method) -ida_hexrays.chain_t.endoff (method) -ida_hexrays.chain_t.flags (variable) -ida_hexrays.chain_t.get_reg (method) -ida_hexrays.chain_t.get_stkoff (method) -ida_hexrays.chain_t.includes (method) -ida_hexrays.chain_t.is_fake (method) -ida_hexrays.chain_t.is_inited (method) -ida_hexrays.chain_t.is_overlapped (method) -ida_hexrays.chain_t.is_passreg (method) -ida_hexrays.chain_t.is_reg (method) -ida_hexrays.chain_t.is_replaced (method) -ida_hexrays.chain_t.is_stkoff (method) -ida_hexrays.chain_t.is_term (method) -ida_hexrays.chain_t.key (method) -ida_hexrays.chain_t.overlap (method) -ida_hexrays.chain_t.set_inited (method) -ida_hexrays.chain_t.set_overlapped (method) -ida_hexrays.chain_t.set_replaced (method) -ida_hexrays.chain_t.set_term (method) -ida_hexrays.chain_t.set_value (method) -ida_hexrays.chain_t.varnum (variable) -ida_hexrays.chain_t.width (variable) -ida_hexrays.chain_visitor_t (class) -ida_hexrays.chain_visitor_t.__disown__ (method) -ida_hexrays.chain_visitor_t.__init__ (method) -ida_hexrays.chain_visitor_t.parent (variable) -ida_hexrays.chain_visitor_t.visit_chain (method) -ida_hexrays.change_hexrays_config (function) -ida_hexrays.checkout_hexrays_license (function) -ida_hexrays.cif_t (class) -ida_hexrays.cif_t.__eq__ (method) -ida_hexrays.cif_t.__ge__ (method) -ida_hexrays.cif_t.__gt__ (method) -ida_hexrays.cif_t.__init__ (method) -ida_hexrays.cif_t.__le__ (method) -ida_hexrays.cif_t.__lt__ (method) -ida_hexrays.cif_t.__ne__ (method) -ida_hexrays.cif_t.assign (method) -ida_hexrays.cif_t.cleanup (method) -ida_hexrays.cif_t.compare (method) -ida_hexrays.cif_t.ielse (variable) -ida_hexrays.cif_t.ithen (variable) -ida_hexrays.cinsn_details (function) -ida_hexrays.cinsn_list_t (class) -ida_hexrays.cinsn_list_t.__eq__ (method) -ida_hexrays.cinsn_list_t.__getitem__ (method) -ida_hexrays.cinsn_list_t.__init__ (method) -ida_hexrays.cinsn_list_t.__len__ (method) -ida_hexrays.cinsn_list_t.__ne__ (method) -ida_hexrays.cinsn_list_t.__setitem__ (method) -ida_hexrays.cinsn_list_t.at (method) -ida_hexrays.cinsn_list_t.back (method) -ida_hexrays.cinsn_list_t.begin (method) -ida_hexrays.cinsn_list_t.clear (method) -ida_hexrays.cinsn_list_t.empty (method) -ida_hexrays.cinsn_list_t.end (method) -ida_hexrays.cinsn_list_t.erase (method) -ida_hexrays.cinsn_list_t.find (method) -ida_hexrays.cinsn_list_t.front (method) -ida_hexrays.cinsn_list_t.index (method) -ida_hexrays.cinsn_list_t.insert (method) -ida_hexrays.cinsn_list_t.pop_back (method) -ida_hexrays.cinsn_list_t.pop_front (method) -ida_hexrays.cinsn_list_t.push_back (method) -ida_hexrays.cinsn_list_t.push_front (method) -ida_hexrays.cinsn_list_t.rbegin (method) -ida_hexrays.cinsn_list_t.remove (method) -ida_hexrays.cinsn_list_t.rend (method) -ida_hexrays.cinsn_list_t.size (method) -ida_hexrays.cinsn_list_t.swap (method) -ida_hexrays.cinsn_list_t_iterator (class) -ida_hexrays.cinsn_list_t_iterator.__eq__ (method) -ida_hexrays.cinsn_list_t_iterator.__init__ (method) -ida_hexrays.cinsn_list_t_iterator.__ne__ (method) -ida_hexrays.cinsn_list_t_iterator.__next__ (method) -ida_hexrays.cinsn_t (class) -ida_hexrays.cinsn_t.__eq__ (method) -ida_hexrays.cinsn_t.__ge__ (method) -ida_hexrays.cinsn_t.__gt__ (method) -ida_hexrays.cinsn_t.__init__ (method) -ida_hexrays.cinsn_t.__le__ (method) -ida_hexrays.cinsn_t.__lt__ (method) -ida_hexrays.cinsn_t.__ne__ (method) -ida_hexrays.cinsn_t._deregister (method) -ida_hexrays.cinsn_t._get_casm (method) -ida_hexrays.cinsn_t._get_cblock (method) -ida_hexrays.cinsn_t._get_cdo (method) -ida_hexrays.cinsn_t._get_cexpr (method) -ida_hexrays.cinsn_t._get_cfor (method) -ida_hexrays.cinsn_t._get_cgoto (method) -ida_hexrays.cinsn_t._get_cif (method) -ida_hexrays.cinsn_t._get_creturn (method) -ida_hexrays.cinsn_t._get_cswitch (method) -ida_hexrays.cinsn_t._get_cwhile (method) -ida_hexrays.cinsn_t._print (method) -ida_hexrays.cinsn_t._register (method) -ida_hexrays.cinsn_t._replace_by (method) -ida_hexrays.cinsn_t._set_casm (method) -ida_hexrays.cinsn_t._set_cblock (method) -ida_hexrays.cinsn_t._set_cdo (method) -ida_hexrays.cinsn_t._set_cexpr (method) -ida_hexrays.cinsn_t._set_cfor (method) -ida_hexrays.cinsn_t._set_cgoto (method) -ida_hexrays.cinsn_t._set_cif (method) -ida_hexrays.cinsn_t._set_creturn (method) -ida_hexrays.cinsn_t._set_cswitch (method) -ida_hexrays.cinsn_t._set_cwhile (method) -ida_hexrays.cinsn_t.assign (method) -ida_hexrays.cinsn_t.casm (variable) -ida_hexrays.cinsn_t.cblock (variable) -ida_hexrays.cinsn_t.cdo (variable) -ida_hexrays.cinsn_t.cexpr (variable) -ida_hexrays.cinsn_t.cfor (variable) -ida_hexrays.cinsn_t.cgoto (variable) -ida_hexrays.cinsn_t.cif (variable) -ida_hexrays.cinsn_t.cleanup (method) -ida_hexrays.cinsn_t.collect_free_breaks (method) -ida_hexrays.cinsn_t.collect_free_continues (method) -ida_hexrays.cinsn_t.compare (method) -ida_hexrays.cinsn_t.contains_free_break (method) -ida_hexrays.cinsn_t.contains_free_continue (method) -ida_hexrays.cinsn_t.contains_insn (method) -ida_hexrays.cinsn_t.create_if (method) -ida_hexrays.cinsn_t.creturn (variable) -ida_hexrays.cinsn_t.cswitch (variable) -ida_hexrays.cinsn_t.cwhile (variable) -ida_hexrays.cinsn_t.dstr (method) -ida_hexrays.cinsn_t.insn_is_epilog (method) -ida_hexrays.cinsn_t.is_epilog (method) -ida_hexrays.cinsn_t.is_ordinary_flow (method) -ida_hexrays.cinsn_t.new_insn (method) -ida_hexrays.cinsn_t.print1 (method) -ida_hexrays.cinsn_t.swap (method) -ida_hexrays.cinsn_t.zero (method) -ida_hexrays.cinsn_t_insn_is_epilog (function) -ida_hexrays.cinsnptrvec_t (class) -ida_hexrays.cinsnptrvec_t.__eq__ (method) -ida_hexrays.cinsnptrvec_t.__getitem__ (method) -ida_hexrays.cinsnptrvec_t.__init__ (method) -ida_hexrays.cinsnptrvec_t.__len__ (method) -ida_hexrays.cinsnptrvec_t.__ne__ (method) -ida_hexrays.cinsnptrvec_t.__setitem__ (method) -ida_hexrays.cinsnptrvec_t._del (method) -ida_hexrays.cinsnptrvec_t.add_unique (method) -ida_hexrays.cinsnptrvec_t.at (method) -ida_hexrays.cinsnptrvec_t.begin (method) -ida_hexrays.cinsnptrvec_t.capacity (method) -ida_hexrays.cinsnptrvec_t.clear (method) -ida_hexrays.cinsnptrvec_t.empty (method) -ida_hexrays.cinsnptrvec_t.end (method) -ida_hexrays.cinsnptrvec_t.erase (method) -ida_hexrays.cinsnptrvec_t.extract (method) -ida_hexrays.cinsnptrvec_t.find (method) -ida_hexrays.cinsnptrvec_t.has (method) -ida_hexrays.cinsnptrvec_t.inject (method) -ida_hexrays.cinsnptrvec_t.insert (method) -ida_hexrays.cinsnptrvec_t.pop_back (method) -ida_hexrays.cinsnptrvec_t.push_back (method) -ida_hexrays.cinsnptrvec_t.qclear (method) -ida_hexrays.cinsnptrvec_t.reserve (method) -ida_hexrays.cinsnptrvec_t.resize (method) -ida_hexrays.cinsnptrvec_t.size (method) -ida_hexrays.cinsnptrvec_t.swap (method) -ida_hexrays.cinsnptrvec_t.truncate (method) -ida_hexrays.cit_asm (variable) -ida_hexrays.cit_block (variable) -ida_hexrays.cit_break (variable) -ida_hexrays.cit_continue (variable) -ida_hexrays.cit_do (variable) -ida_hexrays.cit_empty (variable) -ida_hexrays.cit_expr (variable) -ida_hexrays.cit_for (variable) -ida_hexrays.cit_goto (variable) -ida_hexrays.cit_if (variable) -ida_hexrays.cit_return (variable) -ida_hexrays.cit_switch (variable) -ida_hexrays.cit_while (variable) -ida_hexrays.citem_cmt_t (class) -ida_hexrays.citem_cmt_t.__init__ (method) -ida_hexrays.citem_cmt_t.__str__ (method) -ida_hexrays.citem_cmt_t.c_str (method) -ida_hexrays.citem_cmt_t.used (variable) -ida_hexrays.citem_locator_t (class) -ida_hexrays.citem_locator_t.__eq__ (method) -ida_hexrays.citem_locator_t.__ge__ (method) -ida_hexrays.citem_locator_t.__gt__ (method) -ida_hexrays.citem_locator_t.__init__ (method) -ida_hexrays.citem_locator_t.__le__ (method) -ida_hexrays.citem_locator_t.__lt__ (method) -ida_hexrays.citem_locator_t.__ne__ (method) -ida_hexrays.citem_locator_t.compare (method) -ida_hexrays.citem_locator_t.ea (variable) -ida_hexrays.citem_locator_t.op (variable) -ida_hexrays.citem_t (class) -ida_hexrays.citem_t.__dbg_get_meminfo (method) -ida_hexrays.citem_t.__dbg_get_registered_kind (method) -ida_hexrays.citem_t.__init__ (method) -ida_hexrays.citem_t._acquire_ownership (method) -ida_hexrays.citem_t._ensure_cond (method) -ida_hexrays.citem_t._ensure_no_obj (method) -ida_hexrays.citem_t._ensure_no_op (method) -ida_hexrays.citem_t._ensure_ownership_transferrable (method) -ida_hexrays.citem_t._get_op (method) -ida_hexrays.citem_t._maybe_disown_and_deregister (method) -ida_hexrays.citem_t._meminfo (method) -ida_hexrays.citem_t._obj_id (method) -ida_hexrays.citem_t._own_and_register (method) -ida_hexrays.citem_t._set_op (method) -ida_hexrays.citem_t.contains_expr (method) -ida_hexrays.citem_t.contains_label (method) -ida_hexrays.citem_t.ea (variable) -ida_hexrays.citem_t.find_closest_addr (method) -ida_hexrays.citem_t.find_parent_of (method) -ida_hexrays.citem_t.index (variable) -ida_hexrays.citem_t.is_expr (method) -ida_hexrays.citem_t.label_num (variable) -ida_hexrays.citem_t.op (variable) -ida_hexrays.citem_t.print1 (method) -ida_hexrays.citem_t.replace_by (method) -ida_hexrays.citem_t.swap (method) -ida_hexrays.citem_to_specific_type (function) -ida_hexrays.clear_cached_cfuncs (function) -ida_hexrays.cloop_t (class) -ida_hexrays.cloop_t.__init__ (method) -ida_hexrays.cloop_t.assign (method) -ida_hexrays.cloop_t.cleanup (method) -ida_hexrays.close_hexrays_waitbox (function) -ida_hexrays.close_pseudocode (function) -ida_hexrays.cnumber_t (class) -ida_hexrays.cnumber_t.__eq__ (method) -ida_hexrays.cnumber_t.__ge__ (method) -ida_hexrays.cnumber_t.__gt__ (method) -ida_hexrays.cnumber_t.__init__ (method) -ida_hexrays.cnumber_t.__le__ (method) -ida_hexrays.cnumber_t.__lt__ (method) -ida_hexrays.cnumber_t.__ne__ (method) -ida_hexrays.cnumber_t._print (method) -ida_hexrays.cnumber_t._value (variable) -ida_hexrays.cnumber_t.assign (method) -ida_hexrays.cnumber_t.compare (method) -ida_hexrays.cnumber_t.nf (variable) -ida_hexrays.cnumber_t.value (method) -ida_hexrays.codegen_t (class) -ida_hexrays.codegen_t.__init__ (method) -ida_hexrays.codegen_t.analyze_prolog (method) -ida_hexrays.codegen_t.emit (method) -ida_hexrays.codegen_t.emit_micro_mvm (method) -ida_hexrays.codegen_t.gen_micro (method) -ida_hexrays.codegen_t.load_effective_address (method) -ida_hexrays.codegen_t.load_operand (method) -ida_hexrays.codegen_t.microgen_completed (method) -ida_hexrays.codegen_t.prepare_gen_micro (method) -ida_hexrays.codegen_t.store_operand (method) -ida_hexrays.convert_to_user_call (function) -ida_hexrays.cot_add (variable) -ida_hexrays.cot_asg (variable) -ida_hexrays.cot_asgadd (variable) -ida_hexrays.cot_asgband (variable) -ida_hexrays.cot_asgbor (variable) -ida_hexrays.cot_asgmul (variable) -ida_hexrays.cot_asgsdiv (variable) -ida_hexrays.cot_asgshl (variable) -ida_hexrays.cot_asgsmod (variable) -ida_hexrays.cot_asgsshr (variable) -ida_hexrays.cot_asgsub (variable) -ida_hexrays.cot_asgudiv (variable) -ida_hexrays.cot_asgumod (variable) -ida_hexrays.cot_asgushr (variable) -ida_hexrays.cot_asgxor (variable) -ida_hexrays.cot_band (variable) -ida_hexrays.cot_bnot (variable) -ida_hexrays.cot_bor (variable) -ida_hexrays.cot_call (variable) -ida_hexrays.cot_cast (variable) -ida_hexrays.cot_comma (variable) -ida_hexrays.cot_eq (variable) -ida_hexrays.cot_fadd (variable) -ida_hexrays.cot_fdiv (variable) -ida_hexrays.cot_fmul (variable) -ida_hexrays.cot_fneg (variable) -ida_hexrays.cot_fnum (variable) -ida_hexrays.cot_fsub (variable) -ida_hexrays.cot_helper (variable) -ida_hexrays.cot_idx (variable) -ida_hexrays.cot_insn (variable) -ida_hexrays.cot_land (variable) -ida_hexrays.cot_lnot (variable) -ida_hexrays.cot_lor (variable) -ida_hexrays.cot_memptr (variable) -ida_hexrays.cot_memref (variable) -ida_hexrays.cot_mul (variable) -ida_hexrays.cot_ne (variable) -ida_hexrays.cot_neg (variable) -ida_hexrays.cot_num (variable) -ida_hexrays.cot_obj (variable) -ida_hexrays.cot_postdec (variable) -ida_hexrays.cot_postinc (variable) -ida_hexrays.cot_predec (variable) -ida_hexrays.cot_preinc (variable) -ida_hexrays.cot_ptr (variable) -ida_hexrays.cot_ref (variable) -ida_hexrays.cot_sdiv (variable) -ida_hexrays.cot_sge (variable) -ida_hexrays.cot_sgt (variable) -ida_hexrays.cot_shl (variable) -ida_hexrays.cot_sizeof (variable) -ida_hexrays.cot_sle (variable) -ida_hexrays.cot_slt (variable) -ida_hexrays.cot_smod (variable) -ida_hexrays.cot_sshr (variable) -ida_hexrays.cot_str (variable) -ida_hexrays.cot_sub (variable) -ida_hexrays.cot_tern (variable) -ida_hexrays.cot_type (variable) -ida_hexrays.cot_udiv (variable) -ida_hexrays.cot_uge (variable) -ida_hexrays.cot_ugt (variable) -ida_hexrays.cot_ule (variable) -ida_hexrays.cot_ult (variable) -ida_hexrays.cot_umod (variable) -ida_hexrays.cot_ushr (variable) -ida_hexrays.cot_var (variable) -ida_hexrays.cot_xor (variable) -ida_hexrays.create_cfunc (function) -ida_hexrays.create_empty_mba (function) -ida_hexrays.create_field_name (function) -ida_hexrays.create_helper (function) -ida_hexrays.create_typedef (function) -ida_hexrays.creturn_t (class) -ida_hexrays.creturn_t.__eq__ (method) -ida_hexrays.creturn_t.__ge__ (method) -ida_hexrays.creturn_t.__gt__ (method) -ida_hexrays.creturn_t.__init__ (method) -ida_hexrays.creturn_t.__le__ (method) -ida_hexrays.creturn_t.__lt__ (method) -ida_hexrays.creturn_t.__ne__ (method) -ida_hexrays.creturn_t.compare (method) -ida_hexrays.cswitch_t (class) -ida_hexrays.cswitch_t.__eq__ (method) -ida_hexrays.cswitch_t.__ge__ (method) -ida_hexrays.cswitch_t.__gt__ (method) -ida_hexrays.cswitch_t.__init__ (method) -ida_hexrays.cswitch_t.__le__ (method) -ida_hexrays.cswitch_t.__lt__ (method) -ida_hexrays.cswitch_t.__ne__ (method) -ida_hexrays.cswitch_t.cases (variable) -ida_hexrays.cswitch_t.compare (method) -ida_hexrays.cswitch_t.mvnf (variable) -ida_hexrays.ctext_position_t (class) -ida_hexrays.ctext_position_t.__eq__ (method) -ida_hexrays.ctext_position_t.__ge__ (method) -ida_hexrays.ctext_position_t.__gt__ (method) -ida_hexrays.ctext_position_t.__init__ (method) -ida_hexrays.ctext_position_t.__le__ (method) -ida_hexrays.ctext_position_t.__lt__ (method) -ida_hexrays.ctext_position_t.__ne__ (method) -ida_hexrays.ctext_position_t.compare (method) -ida_hexrays.ctext_position_t.in_ctree (method) -ida_hexrays.ctext_position_t.lnnum (variable) -ida_hexrays.ctext_position_t.x (variable) -ida_hexrays.ctext_position_t.y (variable) -ida_hexrays.ctree_anchor_t (class) -ida_hexrays.ctree_anchor_t.__init__ (method) -ida_hexrays.ctree_anchor_t.get_index (method) -ida_hexrays.ctree_anchor_t.get_itp (method) -ida_hexrays.ctree_anchor_t.is_blkcmt_anchor (method) -ida_hexrays.ctree_anchor_t.is_citem_anchor (method) -ida_hexrays.ctree_anchor_t.is_itp_anchor (method) -ida_hexrays.ctree_anchor_t.is_lvar_anchor (method) -ida_hexrays.ctree_anchor_t.is_valid_anchor (method) -ida_hexrays.ctree_item_t (class) -ida_hexrays.ctree_item_t.__init__ (method) -ida_hexrays.ctree_item_t._get_e (method) -ida_hexrays.ctree_item_t._get_f (method) -ida_hexrays.ctree_item_t._get_i (method) -ida_hexrays.ctree_item_t._get_it (method) -ida_hexrays.ctree_item_t._get_l (method) -ida_hexrays.ctree_item_t._print (method) -ida_hexrays.ctree_item_t.citype (variable) -ida_hexrays.ctree_item_t.dstr (method) -ida_hexrays.ctree_item_t.get_ea (method) -ida_hexrays.ctree_item_t.get_edm (method) -ida_hexrays.ctree_item_t.get_label_num (method) -ida_hexrays.ctree_item_t.get_lvar (method) -ida_hexrays.ctree_item_t.get_memptr (method) -ida_hexrays.ctree_item_t.get_udm (method) -ida_hexrays.ctree_item_t.is_citem (method) -ida_hexrays.ctree_items_t (class) -ida_hexrays.ctree_items_t.__eq__ (method) -ida_hexrays.ctree_items_t.__getitem__ (method) -ida_hexrays.ctree_items_t.__init__ (method) -ida_hexrays.ctree_items_t.__len__ (method) -ida_hexrays.ctree_items_t.__ne__ (method) -ida_hexrays.ctree_items_t.__setitem__ (method) -ida_hexrays.ctree_items_t._del (method) -ida_hexrays.ctree_items_t.add_unique (method) -ida_hexrays.ctree_items_t.at (method) -ida_hexrays.ctree_items_t.begin (method) -ida_hexrays.ctree_items_t.capacity (method) -ida_hexrays.ctree_items_t.clear (method) -ida_hexrays.ctree_items_t.empty (method) -ida_hexrays.ctree_items_t.end (method) -ida_hexrays.ctree_items_t.erase (method) -ida_hexrays.ctree_items_t.extract (method) -ida_hexrays.ctree_items_t.find (method) -ida_hexrays.ctree_items_t.has (method) -ida_hexrays.ctree_items_t.inject (method) -ida_hexrays.ctree_items_t.insert (method) -ida_hexrays.ctree_items_t.pop_back (method) -ida_hexrays.ctree_items_t.push_back (method) -ida_hexrays.ctree_items_t.qclear (method) -ida_hexrays.ctree_items_t.reserve (method) -ida_hexrays.ctree_items_t.resize (method) -ida_hexrays.ctree_items_t.size (method) -ida_hexrays.ctree_items_t.swap (method) -ida_hexrays.ctree_items_t.truncate (method) -ida_hexrays.ctree_parentee_t (class) -ida_hexrays.ctree_parentee_t.__disown__ (method) -ida_hexrays.ctree_parentee_t.__init__ (method) -ida_hexrays.ctree_parentee_t.get_block (method) -ida_hexrays.ctree_parentee_t.recalc_parent_types (method) -ida_hexrays.ctree_visitor_t (class) -ida_hexrays.ctree_visitor_t.__disown__ (method) -ida_hexrays.ctree_visitor_t.__init__ (method) -ida_hexrays.ctree_visitor_t.apply_to (method) -ida_hexrays.ctree_visitor_t.apply_to_exprs (method) -ida_hexrays.ctree_visitor_t.clr_prune (method) -ida_hexrays.ctree_visitor_t.clr_restart (method) -ida_hexrays.ctree_visitor_t.cv_flags (variable) -ida_hexrays.ctree_visitor_t.is_postorder (method) -ida_hexrays.ctree_visitor_t.leave_expr (method) -ida_hexrays.ctree_visitor_t.leave_insn (method) -ida_hexrays.ctree_visitor_t.maintain_parents (method) -ida_hexrays.ctree_visitor_t.must_prune (method) -ida_hexrays.ctree_visitor_t.must_restart (method) -ida_hexrays.ctree_visitor_t.only_insns (method) -ida_hexrays.ctree_visitor_t.parent_expr (method) -ida_hexrays.ctree_visitor_t.parent_insn (method) -ida_hexrays.ctree_visitor_t.parents (variable) -ida_hexrays.ctree_visitor_t.prune_now (method) -ida_hexrays.ctree_visitor_t.set_restart (method) -ida_hexrays.ctree_visitor_t.visit_expr (method) -ida_hexrays.ctree_visitor_t.visit_insn (method) -ida_hexrays.cwhile_t (class) -ida_hexrays.cwhile_t.__eq__ (method) -ida_hexrays.cwhile_t.__ge__ (method) -ida_hexrays.cwhile_t.__gt__ (method) -ida_hexrays.cwhile_t.__init__ (method) -ida_hexrays.cwhile_t.__le__ (method) -ida_hexrays.cwhile_t.__lt__ (method) -ida_hexrays.cwhile_t.__ne__ (method) -ida_hexrays.cwhile_t.compare (method) -ida_hexrays.debug_hexrays_ctree (function) -ida_hexrays.decompile (function) -ida_hexrays.decompile (function) -ida_hexrays.decompile_func (function) -ida_hexrays.decompile_many (function) -ida_hexrays.dereference (function) -ida_hexrays.dstr (function) -ida_hexrays.dummy_ptrtype (function) -ida_hexrays.eamap_begin (function) -ida_hexrays.eamap_clear (function) -ida_hexrays.eamap_end (function) -ida_hexrays.eamap_erase (function) -ida_hexrays.eamap_find (function) -ida_hexrays.eamap_first (function) -ida_hexrays.eamap_free (function) -ida_hexrays.eamap_insert (function) -ida_hexrays.eamap_iterator_t (class) -ida_hexrays.eamap_iterator_t.__eq__ (method) -ida_hexrays.eamap_iterator_t.__init__ (method) -ida_hexrays.eamap_iterator_t.__ne__ (method) -ida_hexrays.eamap_new (function) -ida_hexrays.eamap_next (function) -ida_hexrays.eamap_prev (function) -ida_hexrays.eamap_second (function) -ida_hexrays.eamap_size (function) -ida_hexrays.eamap_t (class) -ida_hexrays.eamap_t.__init__ (method) -ida_hexrays.eamap_t.at (method) -ida_hexrays.eamap_t.size (method) -ida_hexrays.fnumber_t (class) -ida_hexrays.fnumber_t.__eq__ (method) -ida_hexrays.fnumber_t.__ge__ (method) -ida_hexrays.fnumber_t.__gt__ (method) -ida_hexrays.fnumber_t.__init__ (method) -ida_hexrays.fnumber_t.__le__ (method) -ida_hexrays.fnumber_t.__lt__ (method) -ida_hexrays.fnumber_t.__ne__ (method) -ida_hexrays.fnumber_t._print (method) -ida_hexrays.fnumber_t.compare (method) -ida_hexrays.fnumber_t.dereference_const_uint16 (method) -ida_hexrays.fnumber_t.dereference_uint16 (method) -ida_hexrays.fnumber_t.fnum (variable) -ida_hexrays.fnumber_t.nbytes (variable) -ida_hexrays.gco_info_t (class) -ida_hexrays.gco_info_t.__init__ (method) -ida_hexrays.gco_info_t.append_to_list (method) -ida_hexrays.gco_info_t.cvt_to_ivl (method) -ida_hexrays.gco_info_t.is_def (method) -ida_hexrays.gco_info_t.is_reg (method) -ida_hexrays.gco_info_t.is_use (method) -ida_hexrays.gco_info_t.name (variable) -ida_hexrays.gco_info_t.regnum (variable) -ida_hexrays.gco_info_t.size (variable) -ida_hexrays.gco_info_t.stkoff (variable) -ida_hexrays.gen_microcode (function) -ida_hexrays.get_ctype_name (function) -ida_hexrays.get_current_operand (function) -ida_hexrays.get_float_type (function) -ida_hexrays.get_hexrays_version (function) -ida_hexrays.get_int_type_by_width_and_sign (function) -ida_hexrays.get_member_type (function) -ida_hexrays.get_merror_desc (function) -ida_hexrays.get_mreg_name (function) -ida_hexrays.get_op_signness (function) -ida_hexrays.get_signed_mcode (function) -ida_hexrays.get_temp_regs (function) -ida_hexrays.get_type (function) -ida_hexrays.get_unk_type (function) -ida_hexrays.get_unsigned_mcode (function) -ida_hexrays.get_widget_vdui (function) -ida_hexrays.getb_reginsn (function) -ida_hexrays.getf_reginsn (function) -ida_hexrays.graph_chains_t (class) -ida_hexrays.graph_chains_t.__init__ (method) -ida_hexrays.graph_chains_t.acquire (method) -ida_hexrays.graph_chains_t.for_all_chains (method) -ida_hexrays.graph_chains_t.is_locked (method) -ida_hexrays.graph_chains_t.release (method) -ida_hexrays.graph_chains_t.swap (method) -ida_hexrays.has_cached_cfunc (function) -ida_hexrays.has_mcode_seloff (function) -ida_hexrays.hexrays_alloc (function) -ida_hexrays.hexrays_failure_t (class) -ida_hexrays.hexrays_failure_t.__init__ (method) -ida_hexrays.hexrays_failure_t.code (variable) -ida_hexrays.hexrays_failure_t.desc (method) -ida_hexrays.hexrays_failure_t.errea (variable) -ida_hexrays.hexrays_failure_t.str (variable) -ida_hexrays.hexrays_free (function) -ida_hexrays.hexwarn_t (class) -ida_hexrays.hexwarn_t.__eq__ (method) -ida_hexrays.hexwarn_t.__ge__ (method) -ida_hexrays.hexwarn_t.__gt__ (method) -ida_hexrays.hexwarn_t.__init__ (method) -ida_hexrays.hexwarn_t.__le__ (method) -ida_hexrays.hexwarn_t.__lt__ (method) -ida_hexrays.hexwarn_t.__ne__ (method) -ida_hexrays.hexwarn_t.compare (method) -ida_hexrays.hexwarn_t.ea (variable) -ida_hexrays.hexwarn_t.id (variable) -ida_hexrays.hexwarn_t.text (variable) -ida_hexrays.hexwarns_t (class) -ida_hexrays.hexwarns_t.__eq__ (method) -ida_hexrays.hexwarns_t.__getitem__ (method) -ida_hexrays.hexwarns_t.__init__ (method) -ida_hexrays.hexwarns_t.__len__ (method) -ida_hexrays.hexwarns_t.__ne__ (method) -ida_hexrays.hexwarns_t.__setitem__ (method) -ida_hexrays.hexwarns_t._del (method) -ida_hexrays.hexwarns_t.add_unique (method) -ida_hexrays.hexwarns_t.at (method) -ida_hexrays.hexwarns_t.begin (method) -ida_hexrays.hexwarns_t.capacity (method) -ida_hexrays.hexwarns_t.clear (method) -ida_hexrays.hexwarns_t.empty (method) -ida_hexrays.hexwarns_t.end (method) -ida_hexrays.hexwarns_t.erase (method) -ida_hexrays.hexwarns_t.extract (method) -ida_hexrays.hexwarns_t.find (method) -ida_hexrays.hexwarns_t.grow (method) -ida_hexrays.hexwarns_t.has (method) -ida_hexrays.hexwarns_t.inject (method) -ida_hexrays.hexwarns_t.insert (method) -ida_hexrays.hexwarns_t.pop_back (method) -ida_hexrays.hexwarns_t.push_back (method) -ida_hexrays.hexwarns_t.qclear (method) -ida_hexrays.hexwarns_t.reserve (method) -ida_hexrays.hexwarns_t.resize (method) -ida_hexrays.hexwarns_t.size (method) -ida_hexrays.hexwarns_t.swap (method) -ida_hexrays.hexwarns_t.truncate (method) -ida_hexrays.history_item_t (class) -ida_hexrays.history_item_t.__init__ (method) -ida_hexrays.history_item_t.ea (variable) -ida_hexrays.history_item_t.end (variable) -ida_hexrays.history_t (class) -ida_hexrays.history_t.__init__ (method) -ida_hexrays.history_t.pop (method) -ida_hexrays.history_t.push (method) -ida_hexrays.history_t.top (method) -ida_hexrays.hxe_build_callinfo (variable) -ida_hexrays.hxe_callinfo_built (variable) -ida_hexrays.hxe_calls_done (variable) -ida_hexrays.hxe_close_pseudocode (variable) -ida_hexrays.hxe_cmt_changed (variable) -ida_hexrays.hxe_combine (variable) -ida_hexrays.hxe_create_hint (variable) -ida_hexrays.hxe_curpos (variable) -ida_hexrays.hxe_double_click (variable) -ida_hexrays.hxe_flowchart (variable) -ida_hexrays.hxe_func_printed (variable) -ida_hexrays.hxe_glbopt (variable) -ida_hexrays.hxe_interr (variable) -ida_hexrays.hxe_keyboard (variable) -ida_hexrays.hxe_locopt (variable) -ida_hexrays.hxe_maturity (variable) -ida_hexrays.hxe_microcode (variable) -ida_hexrays.hxe_open_pseudocode (variable) -ida_hexrays.hxe_populating_popup (variable) -ida_hexrays.hxe_prealloc (variable) -ida_hexrays.hxe_preoptimized (variable) -ida_hexrays.hxe_print_func (variable) -ida_hexrays.hxe_prolog (variable) -ida_hexrays.hxe_refresh_pseudocode (variable) -ida_hexrays.hxe_resolve_stkaddrs (variable) -ida_hexrays.hxe_right_click (variable) -ida_hexrays.hxe_stkpnts (variable) -ida_hexrays.hxe_structural (variable) -ida_hexrays.hxe_switch_pseudocode (variable) -ida_hexrays.hxe_text_ready (variable) -ida_hexrays.init_hexrays_plugin (function) -ida_hexrays.install_hexrays_callback (function) -ida_hexrays.install_microcode_filter (function) -ida_hexrays.is_additive (function) -ida_hexrays.is_assignment (function) -ida_hexrays.is_binary (function) -ida_hexrays.is_bitop (function) -ida_hexrays.is_bool_type (function) -ida_hexrays.is_break_consumer (function) -ida_hexrays.is_commutative (function) -ida_hexrays.is_inplace_def (function) -ida_hexrays.is_kreg (function) -ida_hexrays.is_logical (function) -ida_hexrays.is_loop (function) -ida_hexrays.is_lvalue (function) -ida_hexrays.is_may_access (function) -ida_hexrays.is_mcode_addsub (function) -ida_hexrays.is_mcode_call (function) -ida_hexrays.is_mcode_commutative (function) -ida_hexrays.is_mcode_convertible_to_jmp (function) -ida_hexrays.is_mcode_convertible_to_set (function) -ida_hexrays.is_mcode_divmod (function) -ida_hexrays.is_mcode_fpu (function) -ida_hexrays.is_mcode_j1 (function) -ida_hexrays.is_mcode_jcond (function) -ida_hexrays.is_mcode_propagatable (function) -ida_hexrays.is_mcode_set (function) -ida_hexrays.is_mcode_set1 (function) -ida_hexrays.is_mcode_shift (function) -ida_hexrays.is_mcode_xdsu (function) -ida_hexrays.is_multiplicative (function) -ida_hexrays.is_nonbool_type (function) -ida_hexrays.is_paf (function) -ida_hexrays.is_prepost (function) -ida_hexrays.is_ptr_or_array (function) -ida_hexrays.is_relational (function) -ida_hexrays.is_signed_mcode (function) -ida_hexrays.is_small_udt (function) -ida_hexrays.is_type_correct (function) -ida_hexrays.is_unary (function) -ida_hexrays.is_unsigned_mcode (function) -ida_hexrays.iterator (class) -ida_hexrays.iterator.__eq__ (method) -ida_hexrays.iterator.__init__ (method) -ida_hexrays.iterator.__ne__ (method) -ida_hexrays.iterator.__ref__ (method) -ida_hexrays.ivl_t (class) -ida_hexrays.ivl_t.__eq__ (method) -ida_hexrays.ivl_t.__ge__ (method) -ida_hexrays.ivl_t.__gt__ (method) -ida_hexrays.ivl_t.__init__ (method) -ida_hexrays.ivl_t.__le__ (method) -ida_hexrays.ivl_t.__lt__ (method) -ida_hexrays.ivl_t.__ne__ (method) -ida_hexrays.ivl_t.clear (method) -ida_hexrays.ivl_t.compare (method) -ida_hexrays.ivl_t.contains (method) -ida_hexrays.ivl_t.dstr (method) -ida_hexrays.ivl_t.empty (method) -ida_hexrays.ivl_t.extend_to_cover (method) -ida_hexrays.ivl_t.includes (method) -ida_hexrays.ivl_t.intersect (method) -ida_hexrays.ivl_t.overlap (method) -ida_hexrays.ivl_with_name_t (class) -ida_hexrays.ivl_with_name_t.__init__ (method) -ida_hexrays.ivlset_t (class) -ida_hexrays.ivlset_t.__eq__ (method) -ida_hexrays.ivlset_t.__ge__ (method) -ida_hexrays.ivlset_t.__gt__ (method) -ida_hexrays.ivlset_t.__init__ (method) -ida_hexrays.ivlset_t.__le__ (method) -ida_hexrays.ivlset_t.__lt__ (method) -ida_hexrays.ivlset_t.__ne__ (method) -ida_hexrays.ivlset_t._print (method) -ida_hexrays.ivlset_t.add (method) -ida_hexrays.ivlset_t.addmasked (method) -ida_hexrays.ivlset_t.compare (method) -ida_hexrays.ivlset_t.contains (method) -ida_hexrays.ivlset_t.count (method) -ida_hexrays.ivlset_t.dstr (method) -ida_hexrays.ivlset_t.has_common (method) -ida_hexrays.ivlset_t.includes (method) -ida_hexrays.ivlset_t.intersect (method) -ida_hexrays.ivlset_t.sub (method) -ida_hexrays.jcnd2set (function) -ida_hexrays.lexcompare (function) -ida_hexrays.lnot (function) -ida_hexrays.locate_lvar (function) -ida_hexrays.lvar_locator_t (class) -ida_hexrays.lvar_locator_t.__eq__ (method) -ida_hexrays.lvar_locator_t.__ge__ (method) -ida_hexrays.lvar_locator_t.__gt__ (method) -ida_hexrays.lvar_locator_t.__init__ (method) -ida_hexrays.lvar_locator_t.__le__ (method) -ida_hexrays.lvar_locator_t.__lt__ (method) -ida_hexrays.lvar_locator_t.__ne__ (method) -ida_hexrays.lvar_locator_t.compare (method) -ida_hexrays.lvar_locator_t.defea (variable) -ida_hexrays.lvar_locator_t.get_reg1 (method) -ida_hexrays.lvar_locator_t.get_reg2 (method) -ida_hexrays.lvar_locator_t.get_scattered (method) -ida_hexrays.lvar_locator_t.get_stkoff (method) -ida_hexrays.lvar_locator_t.is_reg1 (method) -ida_hexrays.lvar_locator_t.is_reg2 (method) -ida_hexrays.lvar_locator_t.is_reg_var (method) -ida_hexrays.lvar_locator_t.is_scattered (method) -ida_hexrays.lvar_locator_t.is_stk_var (method) -ida_hexrays.lvar_locator_t.location (variable) -ida_hexrays.lvar_mapping_begin (function) -ida_hexrays.lvar_mapping_clear (function) -ida_hexrays.lvar_mapping_end (function) -ida_hexrays.lvar_mapping_erase (function) -ida_hexrays.lvar_mapping_find (function) -ida_hexrays.lvar_mapping_first (function) -ida_hexrays.lvar_mapping_free (function) -ida_hexrays.lvar_mapping_insert (function) -ida_hexrays.lvar_mapping_iterator_t (class) -ida_hexrays.lvar_mapping_iterator_t.__eq__ (method) -ida_hexrays.lvar_mapping_iterator_t.__init__ (method) -ida_hexrays.lvar_mapping_iterator_t.__ne__ (method) -ida_hexrays.lvar_mapping_new (function) -ida_hexrays.lvar_mapping_next (function) -ida_hexrays.lvar_mapping_prev (function) -ida_hexrays.lvar_mapping_second (function) -ida_hexrays.lvar_mapping_size (function) -ida_hexrays.lvar_mapping_t (class) -ida_hexrays.lvar_mapping_t.__init__ (method) -ida_hexrays.lvar_mapping_t.at (method) -ida_hexrays.lvar_mapping_t.size (method) -ida_hexrays.lvar_ref_t (class) -ida_hexrays.lvar_ref_t.__eq__ (method) -ida_hexrays.lvar_ref_t.__ge__ (method) -ida_hexrays.lvar_ref_t.__gt__ (method) -ida_hexrays.lvar_ref_t.__init__ (method) -ida_hexrays.lvar_ref_t.__le__ (method) -ida_hexrays.lvar_ref_t.__lt__ (method) -ida_hexrays.lvar_ref_t.__ne__ (method) -ida_hexrays.lvar_ref_t.compare (method) -ida_hexrays.lvar_ref_t.idx (variable) -ida_hexrays.lvar_ref_t.mba (variable) -ida_hexrays.lvar_ref_t.off (variable) -ida_hexrays.lvar_ref_t.swap (method) -ida_hexrays.lvar_ref_t.var (method) -ida_hexrays.lvar_saved_info_t (class) -ida_hexrays.lvar_saved_info_t.__eq__ (method) -ida_hexrays.lvar_saved_info_t.__init__ (method) -ida_hexrays.lvar_saved_info_t.__ne__ (method) -ida_hexrays.lvar_saved_info_t.clear_keep (method) -ida_hexrays.lvar_saved_info_t.clr_nomap_lvar (method) -ida_hexrays.lvar_saved_info_t.clr_noptr_lvar (method) -ida_hexrays.lvar_saved_info_t.clr_split_lvar (method) -ida_hexrays.lvar_saved_info_t.clr_unused_lvar (method) -ida_hexrays.lvar_saved_info_t.cmt (variable) -ida_hexrays.lvar_saved_info_t.flags (variable) -ida_hexrays.lvar_saved_info_t.has_info (method) -ida_hexrays.lvar_saved_info_t.is_kept (method) -ida_hexrays.lvar_saved_info_t.is_nomap_lvar (method) -ida_hexrays.lvar_saved_info_t.is_noptr_lvar (method) -ida_hexrays.lvar_saved_info_t.is_split_lvar (method) -ida_hexrays.lvar_saved_info_t.is_unused_lvar (method) -ida_hexrays.lvar_saved_info_t.ll (variable) -ida_hexrays.lvar_saved_info_t.name (variable) -ida_hexrays.lvar_saved_info_t.set_keep (method) -ida_hexrays.lvar_saved_info_t.set_nomap_lvar (method) -ida_hexrays.lvar_saved_info_t.set_noptr_lvar (method) -ida_hexrays.lvar_saved_info_t.set_split_lvar (method) -ida_hexrays.lvar_saved_info_t.set_unused_lvar (method) -ida_hexrays.lvar_saved_info_t.size (variable) -ida_hexrays.lvar_saved_info_t.type (variable) -ida_hexrays.lvar_saved_infos_t (class) -ida_hexrays.lvar_saved_infos_t.__eq__ (method) -ida_hexrays.lvar_saved_infos_t.__getitem__ (method) -ida_hexrays.lvar_saved_infos_t.__init__ (method) -ida_hexrays.lvar_saved_infos_t.__len__ (method) -ida_hexrays.lvar_saved_infos_t.__ne__ (method) -ida_hexrays.lvar_saved_infos_t.__setitem__ (method) -ida_hexrays.lvar_saved_infos_t._del (method) -ida_hexrays.lvar_saved_infos_t.add_unique (method) -ida_hexrays.lvar_saved_infos_t.at (method) -ida_hexrays.lvar_saved_infos_t.begin (method) -ida_hexrays.lvar_saved_infos_t.capacity (method) -ida_hexrays.lvar_saved_infos_t.clear (method) -ida_hexrays.lvar_saved_infos_t.empty (method) -ida_hexrays.lvar_saved_infos_t.end (method) -ida_hexrays.lvar_saved_infos_t.erase (method) -ida_hexrays.lvar_saved_infos_t.extract (method) -ida_hexrays.lvar_saved_infos_t.find (method) -ida_hexrays.lvar_saved_infos_t.grow (method) -ida_hexrays.lvar_saved_infos_t.has (method) -ida_hexrays.lvar_saved_infos_t.inject (method) -ida_hexrays.lvar_saved_infos_t.insert (method) -ida_hexrays.lvar_saved_infos_t.pop_back (method) -ida_hexrays.lvar_saved_infos_t.push_back (method) -ida_hexrays.lvar_saved_infos_t.qclear (method) -ida_hexrays.lvar_saved_infos_t.reserve (method) -ida_hexrays.lvar_saved_infos_t.resize (method) -ida_hexrays.lvar_saved_infos_t.size (method) -ida_hexrays.lvar_saved_infos_t.swap (method) -ida_hexrays.lvar_saved_infos_t.truncate (method) -ida_hexrays.lvar_t (class) -ida_hexrays.lvar_t.__init__ (method) -ida_hexrays.lvar_t.accepts_type (method) -ida_hexrays.lvar_t.append_list (method) -ida_hexrays.lvar_t.clear_used (method) -ida_hexrays.lvar_t.clr_arg_var (method) -ida_hexrays.lvar_t.clr_automapped (method) -ida_hexrays.lvar_t.clr_decl_unused (method) -ida_hexrays.lvar_t.clr_dummy_arg (method) -ida_hexrays.lvar_t.clr_fake_var (method) -ida_hexrays.lvar_t.clr_floating_var (method) -ida_hexrays.lvar_t.clr_mapdst_var (method) -ida_hexrays.lvar_t.clr_mreg_done (method) -ida_hexrays.lvar_t.clr_noptr_var (method) -ida_hexrays.lvar_t.clr_notarg (method) -ida_hexrays.lvar_t.clr_overlapped_var (method) -ida_hexrays.lvar_t.clr_shared (method) -ida_hexrays.lvar_t.clr_split_var (method) -ida_hexrays.lvar_t.clr_spoiled_var (method) -ida_hexrays.lvar_t.clr_thisarg (method) -ida_hexrays.lvar_t.clr_unknown_width (method) -ida_hexrays.lvar_t.clr_used_byref (method) -ida_hexrays.lvar_t.clr_user_info (method) -ida_hexrays.lvar_t.clr_user_name (method) -ida_hexrays.lvar_t.clr_user_type (method) -ida_hexrays.lvar_t.cmt (variable) -ida_hexrays.lvar_t.defblk (variable) -ida_hexrays.lvar_t.divisor (variable) -ida_hexrays.lvar_t.has_common (method) -ida_hexrays.lvar_t.has_common_bit (method) -ida_hexrays.lvar_t.has_nice_name (method) -ida_hexrays.lvar_t.has_regname (method) -ida_hexrays.lvar_t.has_user_info (method) -ida_hexrays.lvar_t.has_user_name (method) -ida_hexrays.lvar_t.has_user_type (method) -ida_hexrays.lvar_t.in_asm (method) -ida_hexrays.lvar_t.is_aliasable (method) -ida_hexrays.lvar_t.is_arg_var (method) -ida_hexrays.lvar_t.is_automapped (method) -ida_hexrays.lvar_t.is_decl_unused (method) -ida_hexrays.lvar_t.is_dummy_arg (method) -ida_hexrays.lvar_t.is_fake_var (method) -ida_hexrays.lvar_t.is_floating_var (method) -ida_hexrays.lvar_t.is_mapdst_var (method) -ida_hexrays.lvar_t.is_noptr_var (method) -ida_hexrays.lvar_t.is_notarg (method) -ida_hexrays.lvar_t.is_overlapped_var (method) -ida_hexrays.lvar_t.is_result_var (method) -ida_hexrays.lvar_t.is_shared (method) -ida_hexrays.lvar_t.is_split_var (method) -ida_hexrays.lvar_t.is_spoiled_var (method) -ida_hexrays.lvar_t.is_thisarg (method) -ida_hexrays.lvar_t.is_unknown_width (method) -ida_hexrays.lvar_t.is_used_byref (method) -ida_hexrays.lvar_t.mreg_done (method) -ida_hexrays.lvar_t.name (variable) -ida_hexrays.lvar_t.set_arg_var (method) -ida_hexrays.lvar_t.set_automapped (method) -ida_hexrays.lvar_t.set_decl_unused (method) -ida_hexrays.lvar_t.set_dummy_arg (method) -ida_hexrays.lvar_t.set_fake_var (method) -ida_hexrays.lvar_t.set_final_lvar_type (method) -ida_hexrays.lvar_t.set_floating_var (method) -ida_hexrays.lvar_t.set_lvar_type (method) -ida_hexrays.lvar_t.set_mapdst_var (method) -ida_hexrays.lvar_t.set_mreg_done (method) -ida_hexrays.lvar_t.set_non_typed (method) -ida_hexrays.lvar_t.set_noptr_var (method) -ida_hexrays.lvar_t.set_notarg (method) -ida_hexrays.lvar_t.set_overlapped_var (method) -ida_hexrays.lvar_t.set_shared (method) -ida_hexrays.lvar_t.set_split_var (method) -ida_hexrays.lvar_t.set_spoiled_var (method) -ida_hexrays.lvar_t.set_thisarg (method) -ida_hexrays.lvar_t.set_typed (method) -ida_hexrays.lvar_t.set_unknown_width (method) -ida_hexrays.lvar_t.set_used (method) -ida_hexrays.lvar_t.set_used_byref (method) -ida_hexrays.lvar_t.set_user_name (method) -ida_hexrays.lvar_t.set_user_type (method) -ida_hexrays.lvar_t.set_width (method) -ida_hexrays.lvar_t.tif (variable) -ida_hexrays.lvar_t.type (method) -ida_hexrays.lvar_t.typed (method) -ida_hexrays.lvar_t.used (method) -ida_hexrays.lvar_t.width (variable) -ida_hexrays.lvar_uservec_t (class) -ida_hexrays.lvar_uservec_t.__init__ (method) -ida_hexrays.lvar_uservec_t.clear (method) -ida_hexrays.lvar_uservec_t.empty (method) -ida_hexrays.lvar_uservec_t.find_info (method) -ida_hexrays.lvar_uservec_t.keep_info (method) -ida_hexrays.lvar_uservec_t.lmaps (variable) -ida_hexrays.lvar_uservec_t.lvvec (variable) -ida_hexrays.lvar_uservec_t.stkoff_delta (variable) -ida_hexrays.lvar_uservec_t.swap (method) -ida_hexrays.lvar_uservec_t.ulv_flags (variable) -ida_hexrays.lvars_t (class) -ida_hexrays.lvars_t.__init__ (method) -ida_hexrays.lvars_t.find (method) -ida_hexrays.lvars_t.find_input_lvar (method) -ida_hexrays.lvars_t.find_lvar (method) -ida_hexrays.lvars_t.find_stkvar (method) -ida_hexrays.lxe_lvar_cmt_changed (variable) -ida_hexrays.lxe_lvar_mapping_changed (variable) -ida_hexrays.lxe_lvar_name_changed (variable) -ida_hexrays.lxe_lvar_type_changed (variable) -ida_hexrays.make_num (function) -ida_hexrays.make_pointer (function) -ida_hexrays.make_ref (function) -ida_hexrays.mark_cfunc_dirty (function) -ida_hexrays.mba_range_iterator_t (class) -ida_hexrays.mba_range_iterator_t.__init__ (method) -ida_hexrays.mba_range_iterator_t.chunk (method) -ida_hexrays.mba_range_iterator_t.is_snippet (method) -ida_hexrays.mba_range_iterator_t.next (method) -ida_hexrays.mba_range_iterator_t.set (method) -ida_hexrays.mba_ranges_t (class) -ida_hexrays.mba_ranges_t.__init__ (method) -ida_hexrays.mba_ranges_t.clear (method) -ida_hexrays.mba_ranges_t.empty (method) -ida_hexrays.mba_ranges_t.is_fragmented (method) -ida_hexrays.mba_ranges_t.is_snippet (method) -ida_hexrays.mba_ranges_t.pfn (variable) -ida_hexrays.mba_ranges_t.ranges (variable) -ida_hexrays.mba_ranges_t.start (method) -ida_hexrays.mba_t (class) -ida_hexrays.mba_t.__init__ (method) -ida_hexrays.mba_t._deregister (method) -ida_hexrays.mba_t._print (method) -ida_hexrays.mba_t._register (method) -ida_hexrays.mba_t.aliased_args (variable) -ida_hexrays.mba_t.aliased_memory (variable) -ida_hexrays.mba_t.aliased_vars (variable) -ida_hexrays.mba_t.alloc_fict_ea (method) -ida_hexrays.mba_t.alloc_kreg (method) -ida_hexrays.mba_t.alloc_lvars (method) -ida_hexrays.mba_t.analyze_calls (method) -ida_hexrays.mba_t.arg (method) -ida_hexrays.mba_t.argbase (method) -ida_hexrays.mba_t.argidx (variable) -ida_hexrays.mba_t.argidx_ok (method) -ida_hexrays.mba_t.argidx_sorted (method) -ida_hexrays.mba_t.bad_call_sp_detected (method) -ida_hexrays.mba_t.blocks (variable) -ida_hexrays.mba_t.build_graph (method) -ida_hexrays.mba_t.calc_shins_flags (method) -ida_hexrays.mba_t.callinfo_built (method) -ida_hexrays.mba_t.cc (variable) -ida_hexrays.mba_t.chain_varnums_ok (method) -ida_hexrays.mba_t.clr_cdtr (method) -ida_hexrays.mba_t.clr_mba_flags (method) -ida_hexrays.mba_t.clr_mba_flags2 (method) -ida_hexrays.mba_t.code16_bit_removed (method) -ida_hexrays.mba_t.combine_blocks (method) -ida_hexrays.mba_t.common_stkvars_stkargs (method) -ida_hexrays.mba_t.consumed_argregs (variable) -ida_hexrays.mba_t.copy_block (method) -ida_hexrays.mba_t.create_helper_call (method) -ida_hexrays.mba_t.deleted_pairs (method) -ida_hexrays.mba_t.deprecated_idb_node (variable) -ida_hexrays.mba_t.deserialize (method) -ida_hexrays.mba_t.display_numaddrs (method) -ida_hexrays.mba_t.display_valnums (method) -ida_hexrays.mba_t.dump (method) -ida_hexrays.mba_t.dump_mba (method) -ida_hexrays.mba_t.error_ea (variable) -ida_hexrays.mba_t.final_type (variable) -ida_hexrays.mba_t.find_mop (method) -ida_hexrays.mba_t.for_all_insns (method) -ida_hexrays.mba_t.for_all_ops (method) -ida_hexrays.mba_t.for_all_topinsns (method) -ida_hexrays.mba_t.fpd (variable) -ida_hexrays.mba_t.free_kreg (method) -ida_hexrays.mba_t.frregs (variable) -ida_hexrays.mba_t.frsize (variable) -ida_hexrays.mba_t.fti_flags (variable) -ida_hexrays.mba_t.fullsize (variable) -ida_hexrays.mba_t.generated_asserts (method) -ida_hexrays.mba_t.get_args_region (method) -ida_hexrays.mba_t.get_curfunc (method) -ida_hexrays.mba_t.get_func_output_lists (method) -ida_hexrays.mba_t.get_graph (method) -ida_hexrays.mba_t.get_ida_argloc (method) -ida_hexrays.mba_t.get_lvars_region (method) -ida_hexrays.mba_t.get_mba_flags (method) -ida_hexrays.mba_t.get_mba_flags2 (method) -ida_hexrays.mba_t.get_mblock (method) -ida_hexrays.mba_t.get_shadow_region (method) -ida_hexrays.mba_t.get_stack_region (method) -ida_hexrays.mba_t.get_std_region (method) -ida_hexrays.mba_t.gotoff_stkvars (variable) -ida_hexrays.mba_t.graph_insns (method) -ida_hexrays.mba_t.has_bad_sp (method) -ida_hexrays.mba_t.has_outlines (method) -ida_hexrays.mba_t.has_over_chains (method) -ida_hexrays.mba_t.has_passregs (method) -ida_hexrays.mba_t.has_stack_retval (method) -ida_hexrays.mba_t.idaloc2vd (method) -ida_hexrays.mba_t.idb_spoiled (variable) -ida_hexrays.mba_t.idb_type (variable) -ida_hexrays.mba_t.inargoff (variable) -ida_hexrays.mba_t.insert_block (method) -ida_hexrays.mba_t.is_cdtr (method) -ida_hexrays.mba_t.is_ctr (method) -ida_hexrays.mba_t.is_dtr (method) -ida_hexrays.mba_t.is_pattern (method) -ida_hexrays.mba_t.is_snippet (method) -ida_hexrays.mba_t.is_stkarg (method) -ida_hexrays.mba_t.is_thunk (method) -ida_hexrays.mba_t.label (variable) -ida_hexrays.mba_t.loaded_gdl (method) -ida_hexrays.mba_t.lvar_names_ok (method) -ida_hexrays.mba_t.lvars_allocated (method) -ida_hexrays.mba_t.lvars_renamed (method) -ida_hexrays.mba_t.map_fict_ea (method) -ida_hexrays.mba_t.mark_chains_dirty (method) -ida_hexrays.mba_t.maturity (variable) -ida_hexrays.mba_t.may_refine_rettype (method) -ida_hexrays.mba_t.minargref (variable) -ida_hexrays.mba_t.minstkref (variable) -ida_hexrays.mba_t.minstkref_ea (variable) -ida_hexrays.mba_t.natural (variable) -ida_hexrays.mba_t.nodel_memory (variable) -ida_hexrays.mba_t.npurged (variable) -ida_hexrays.mba_t.optimize_global (method) -ida_hexrays.mba_t.optimize_local (method) -ida_hexrays.mba_t.optimized (method) -ida_hexrays.mba_t.pfn_flags (variable) -ida_hexrays.mba_t.precise_defeas (method) -ida_hexrays.mba_t.prop_complex (method) -ida_hexrays.mba_t.propagated_asserts (method) -ida_hexrays.mba_t.qty (variable) -ida_hexrays.mba_t.really_alloc (method) -ida_hexrays.mba_t.regargs_is_not_aligned (method) -ida_hexrays.mba_t.remove_block (method) -ida_hexrays.mba_t.remove_empty_and_unreachable_blocks (method) -ida_hexrays.mba_t.reqmat (variable) -ida_hexrays.mba_t.retsize (variable) -ida_hexrays.mba_t.returns_fpval (method) -ida_hexrays.mba_t.retvaridx (variable) -ida_hexrays.mba_t.rtype_refined (method) -ida_hexrays.mba_t.save_snapshot (method) -ida_hexrays.mba_t.saverest_done (method) -ida_hexrays.mba_t.serialize (method) -ida_hexrays.mba_t.set_lvar_name (method) -ida_hexrays.mba_t.set_maturity (method) -ida_hexrays.mba_t.set_mba_flags (method) -ida_hexrays.mba_t.set_mba_flags2 (method) -ida_hexrays.mba_t.set_nice_lvar_name (method) -ida_hexrays.mba_t.set_user_lvar_name (method) -ida_hexrays.mba_t.shadow_args (variable) -ida_hexrays.mba_t.short_display (method) -ida_hexrays.mba_t.should_beautify (method) -ida_hexrays.mba_t.show_reduction (method) -ida_hexrays.mba_t.spd_adjust (variable) -ida_hexrays.mba_t.spoiled_list (variable) -ida_hexrays.mba_t.stacksize (variable) -ida_hexrays.mba_t.std_ivls (variable) -ida_hexrays.mba_t.stkoff_ida2vd (method) -ida_hexrays.mba_t.stkoff_vd2ida (method) -ida_hexrays.mba_t.term (method) -ida_hexrays.mba_t.tmpstk_size (variable) -ida_hexrays.mba_t.use_frame (method) -ida_hexrays.mba_t.use_wingraph32 (method) -ida_hexrays.mba_t.valranges_done (method) -ida_hexrays.mba_t.vars (variable) -ida_hexrays.mba_t.vd2idaloc (method) -ida_hexrays.mba_t.verify (method) -ida_hexrays.mba_t.write_to_const_detected (method) -ida_hexrays.mba_t_deserialize (function) -ida_hexrays.mbl_graph_t (class) -ida_hexrays.mbl_graph_t.__init__ (method) -ida_hexrays.mbl_graph_t.get_chain_stamp (method) -ida_hexrays.mbl_graph_t.get_du (method) -ida_hexrays.mbl_graph_t.get_mblock (method) -ida_hexrays.mbl_graph_t.get_ud (method) -ida_hexrays.mbl_graph_t.is_du_chain_dirty (method) -ida_hexrays.mbl_graph_t.is_redefined_globally (method) -ida_hexrays.mbl_graph_t.is_ud_chain_dirty (method) -ida_hexrays.mbl_graph_t.is_used_globally (method) -ida_hexrays.mblock_t (class) -ida_hexrays.mblock_t.__init__ (method) -ida_hexrays.mblock_t._print (method) -ida_hexrays.mblock_t.append_def_list (method) -ida_hexrays.mblock_t.append_use_list (method) -ida_hexrays.mblock_t.build_def_list (method) -ida_hexrays.mblock_t.build_lists (method) -ida_hexrays.mblock_t.build_use_list (method) -ida_hexrays.mblock_t.dead_at_start (variable) -ida_hexrays.mblock_t.dnu (variable) -ida_hexrays.mblock_t.dump (method) -ida_hexrays.mblock_t.dump_block (method) -ida_hexrays.mblock_t.empty (method) -ida_hexrays.mblock_t.end (variable) -ida_hexrays.mblock_t.find_access (method) -ida_hexrays.mblock_t.find_def (method) -ida_hexrays.mblock_t.find_first_use (method) -ida_hexrays.mblock_t.find_redefinition (method) -ida_hexrays.mblock_t.find_use (method) -ida_hexrays.mblock_t.flags (variable) -ida_hexrays.mblock_t.for_all_insns (method) -ida_hexrays.mblock_t.for_all_ops (method) -ida_hexrays.mblock_t.for_all_uses (method) -ida_hexrays.mblock_t.get_reginsn_qty (method) -ida_hexrays.mblock_t.get_valranges (method) -ida_hexrays.mblock_t.head (variable) -ida_hexrays.mblock_t.insert_into_block (method) -ida_hexrays.mblock_t.is_branch (method) -ida_hexrays.mblock_t.is_call_block (method) -ida_hexrays.mblock_t.is_nway (method) -ida_hexrays.mblock_t.is_redefined (method) -ida_hexrays.mblock_t.is_rhs_redefined (method) -ida_hexrays.mblock_t.is_simple_goto_block (method) -ida_hexrays.mblock_t.is_simple_jcnd_block (method) -ida_hexrays.mblock_t.is_unknown_call (method) -ida_hexrays.mblock_t.is_used (method) -ida_hexrays.mblock_t.lists_dirty (method) -ida_hexrays.mblock_t.lists_ready (method) -ida_hexrays.mblock_t.make_lists_ready (method) -ida_hexrays.mblock_t.make_nop (method) -ida_hexrays.mblock_t.mark_lists_dirty (method) -ida_hexrays.mblock_t.maxbsp (variable) -ida_hexrays.mblock_t.maybdef (variable) -ida_hexrays.mblock_t.maybuse (variable) -ida_hexrays.mblock_t.mba (variable) -ida_hexrays.mblock_t.minbargref (variable) -ida_hexrays.mblock_t.minbstkref (variable) -ida_hexrays.mblock_t.mustbdef (variable) -ida_hexrays.mblock_t.mustbuse (variable) -ida_hexrays.mblock_t.needs_propagation (method) -ida_hexrays.mblock_t.nextb (variable) -ida_hexrays.mblock_t.npred (method) -ida_hexrays.mblock_t.nsucc (method) -ida_hexrays.mblock_t.optimize_block (method) -ida_hexrays.mblock_t.optimize_insn (method) -ida_hexrays.mblock_t.optimize_useless_jump (method) -ida_hexrays.mblock_t.pred (method) -ida_hexrays.mblock_t.preds (method) -ida_hexrays.mblock_t.predset (variable) -ida_hexrays.mblock_t.prevb (variable) -ida_hexrays.mblock_t.remove_from_block (method) -ida_hexrays.mblock_t.request_demote64 (method) -ida_hexrays.mblock_t.request_propagation (method) -ida_hexrays.mblock_t.serial (variable) -ida_hexrays.mblock_t.start (variable) -ida_hexrays.mblock_t.succ (method) -ida_hexrays.mblock_t.succs (method) -ida_hexrays.mblock_t.succset (variable) -ida_hexrays.mblock_t.tail (variable) -ida_hexrays.mblock_t.type (variable) -ida_hexrays.mcallarg_t (class) -ida_hexrays.mcallarg_t.__init__ (method) -ida_hexrays.mcallarg_t._print (method) -ida_hexrays.mcallarg_t.argloc (variable) -ida_hexrays.mcallarg_t.copy_mop (method) -ida_hexrays.mcallarg_t.dstr (method) -ida_hexrays.mcallarg_t.ea (variable) -ida_hexrays.mcallarg_t.flags (variable) -ida_hexrays.mcallarg_t.make_int (method) -ida_hexrays.mcallarg_t.make_uint (method) -ida_hexrays.mcallarg_t.name (variable) -ida_hexrays.mcallarg_t.set_regarg (method) -ida_hexrays.mcallarg_t.type (variable) -ida_hexrays.mcallargs_t (class) -ida_hexrays.mcallargs_t.__eq__ (method) -ida_hexrays.mcallargs_t.__getitem__ (method) -ida_hexrays.mcallargs_t.__init__ (method) -ida_hexrays.mcallargs_t.__len__ (method) -ida_hexrays.mcallargs_t.__ne__ (method) -ida_hexrays.mcallargs_t.__setitem__ (method) -ida_hexrays.mcallargs_t._del (method) -ida_hexrays.mcallargs_t.add_unique (method) -ida_hexrays.mcallargs_t.at (method) -ida_hexrays.mcallargs_t.begin (method) -ida_hexrays.mcallargs_t.capacity (method) -ida_hexrays.mcallargs_t.clear (method) -ida_hexrays.mcallargs_t.empty (method) -ida_hexrays.mcallargs_t.end (method) -ida_hexrays.mcallargs_t.erase (method) -ida_hexrays.mcallargs_t.extract (method) -ida_hexrays.mcallargs_t.find (method) -ida_hexrays.mcallargs_t.grow (method) -ida_hexrays.mcallargs_t.has (method) -ida_hexrays.mcallargs_t.inject (method) -ida_hexrays.mcallargs_t.insert (method) -ida_hexrays.mcallargs_t.pop_back (method) -ida_hexrays.mcallargs_t.push_back (method) -ida_hexrays.mcallargs_t.qclear (method) -ida_hexrays.mcallargs_t.reserve (method) -ida_hexrays.mcallargs_t.resize (method) -ida_hexrays.mcallargs_t.size (method) -ida_hexrays.mcallargs_t.swap (method) -ida_hexrays.mcallargs_t.truncate (method) -ida_hexrays.mcallinfo_t (class) -ida_hexrays.mcallinfo_t.__init__ (method) -ida_hexrays.mcallinfo_t._print (method) -ida_hexrays.mcallinfo_t.args (variable) -ida_hexrays.mcallinfo_t.call_spd (variable) -ida_hexrays.mcallinfo_t.callee (variable) -ida_hexrays.mcallinfo_t.cc (variable) -ida_hexrays.mcallinfo_t.dead_regs (variable) -ida_hexrays.mcallinfo_t.dstr (method) -ida_hexrays.mcallinfo_t.flags (variable) -ida_hexrays.mcallinfo_t.fti_attrs (variable) -ida_hexrays.mcallinfo_t.get_type (method) -ida_hexrays.mcallinfo_t.is_vararg (method) -ida_hexrays.mcallinfo_t.lexcompare (method) -ida_hexrays.mcallinfo_t.pass_regs (variable) -ida_hexrays.mcallinfo_t.retregs (variable) -ida_hexrays.mcallinfo_t.return_argloc (variable) -ida_hexrays.mcallinfo_t.return_regs (variable) -ida_hexrays.mcallinfo_t.return_type (variable) -ida_hexrays.mcallinfo_t.role (variable) -ida_hexrays.mcallinfo_t.set_type (method) -ida_hexrays.mcallinfo_t.solid_args (variable) -ida_hexrays.mcallinfo_t.spoiled (variable) -ida_hexrays.mcallinfo_t.stkargs_top (variable) -ida_hexrays.mcallinfo_t.visible_memory (variable) -ida_hexrays.mcases_t (class) -ida_hexrays.mcases_t.__eq__ (method) -ida_hexrays.mcases_t.__ge__ (method) -ida_hexrays.mcases_t.__gt__ (method) -ida_hexrays.mcases_t.__init__ (method) -ida_hexrays.mcases_t.__le__ (method) -ida_hexrays.mcases_t.__lt__ (method) -ida_hexrays.mcases_t.__ne__ (method) -ida_hexrays.mcases_t._print (method) -ida_hexrays.mcases_t.compare (method) -ida_hexrays.mcases_t.dstr (method) -ida_hexrays.mcases_t.empty (method) -ida_hexrays.mcases_t.resize (method) -ida_hexrays.mcases_t.size (method) -ida_hexrays.mcases_t.swap (method) -ida_hexrays.mcases_t.targets (variable) -ida_hexrays.mcases_t.values (variable) -ida_hexrays.mcode_modifies_d (function) -ida_hexrays.microcode_filter_t (class) -ida_hexrays.microcode_filter_t.__disown__ (method) -ida_hexrays.microcode_filter_t.__init__ (method) -ida_hexrays.microcode_filter_t.apply (method) -ida_hexrays.microcode_filter_t.match (method) -ida_hexrays.minsn_t (class) -ida_hexrays.minsn_t.__dbg_get_meminfo (method) -ida_hexrays.minsn_t.__dbg_get_registered_kind (method) -ida_hexrays.minsn_t.__init__ (method) -ida_hexrays.minsn_t.__lt__ (method) -ida_hexrays.minsn_t._acquire_ownership (method) -ida_hexrays.minsn_t._deregister (method) -ida_hexrays.minsn_t._ensure_cond (method) -ida_hexrays.minsn_t._ensure_no_obj (method) -ida_hexrays.minsn_t._ensure_ownership_transferrable (method) -ida_hexrays.minsn_t._make_nop (method) -ida_hexrays.minsn_t._maybe_disown_and_deregister (method) -ida_hexrays.minsn_t._meminfo (method) -ida_hexrays.minsn_t._obj_id (method) -ida_hexrays.minsn_t._own_and_register (method) -ida_hexrays.minsn_t._print (method) -ida_hexrays.minsn_t._register (method) -ida_hexrays.minsn_t.clr_assert (method) -ida_hexrays.minsn_t.clr_combinable (method) -ida_hexrays.minsn_t.clr_combined (method) -ida_hexrays.minsn_t.clr_fpinsn (method) -ida_hexrays.minsn_t.clr_ignlowsrc (method) -ida_hexrays.minsn_t.clr_multimov (method) -ida_hexrays.minsn_t.clr_noret_icall (method) -ida_hexrays.minsn_t.clr_propagatable (method) -ida_hexrays.minsn_t.clr_tailcall (method) -ida_hexrays.minsn_t.contains_call (method) -ida_hexrays.minsn_t.contains_opcode (method) -ida_hexrays.minsn_t.d (variable) -ida_hexrays.minsn_t.deserialize (method) -ida_hexrays.minsn_t.dstr (method) -ida_hexrays.minsn_t.ea (variable) -ida_hexrays.minsn_t.equal_insns (method) -ida_hexrays.minsn_t.find_call (method) -ida_hexrays.minsn_t.find_ins_op (method) -ida_hexrays.minsn_t.find_num_op (method) -ida_hexrays.minsn_t.find_opcode (method) -ida_hexrays.minsn_t.for_all_insns (method) -ida_hexrays.minsn_t.for_all_ops (method) -ida_hexrays.minsn_t.get_role (method) -ida_hexrays.minsn_t.get_split_size (method) -ida_hexrays.minsn_t.has_side_effects (method) -ida_hexrays.minsn_t.iprops (variable) -ida_hexrays.minsn_t.is_after (method) -ida_hexrays.minsn_t.is_alloca (method) -ida_hexrays.minsn_t.is_assert (method) -ida_hexrays.minsn_t.is_between (method) -ida_hexrays.minsn_t.is_bswap (method) -ida_hexrays.minsn_t.is_cleaning_pop (method) -ida_hexrays.minsn_t.is_combinable (method) -ida_hexrays.minsn_t.is_combined (method) -ida_hexrays.minsn_t.is_extstx (method) -ida_hexrays.minsn_t.is_farcall (method) -ida_hexrays.minsn_t.is_fpinsn (method) -ida_hexrays.minsn_t.is_helper (method) -ida_hexrays.minsn_t.is_ignlowsrc (method) -ida_hexrays.minsn_t.is_inverted_jx (method) -ida_hexrays.minsn_t.is_like_move (method) -ida_hexrays.minsn_t.is_mbarrier (method) -ida_hexrays.minsn_t.is_memcpy (method) -ida_hexrays.minsn_t.is_memset (method) -ida_hexrays.minsn_t.is_mov (method) -ida_hexrays.minsn_t.is_multimov (method) -ida_hexrays.minsn_t.is_noret_call (method) -ida_hexrays.minsn_t.is_optional (method) -ida_hexrays.minsn_t.is_persistent (method) -ida_hexrays.minsn_t.is_propagatable (method) -ida_hexrays.minsn_t.is_readflags (method) -ida_hexrays.minsn_t.is_tailcall (method) -ida_hexrays.minsn_t.is_unknown_call (method) -ida_hexrays.minsn_t.is_wild_match (method) -ida_hexrays.minsn_t.l (variable) -ida_hexrays.minsn_t.lexcompare (method) -ida_hexrays.minsn_t.may_use_aliased_memory (method) -ida_hexrays.minsn_t.modifies_d (method) -ida_hexrays.minsn_t.modifies_pair_mop (method) -ida_hexrays.minsn_t.next (variable) -ida_hexrays.minsn_t.opcode (variable) -ida_hexrays.minsn_t.optimize_solo (method) -ida_hexrays.minsn_t.optimize_subtree (method) -ida_hexrays.minsn_t.prev (variable) -ida_hexrays.minsn_t.r (variable) -ida_hexrays.minsn_t.replace_by (method) -ida_hexrays.minsn_t.serialize (method) -ida_hexrays.minsn_t.set_assert (method) -ida_hexrays.minsn_t.set_cleaning_pop (method) -ida_hexrays.minsn_t.set_combinable (method) -ida_hexrays.minsn_t.set_extstx (method) -ida_hexrays.minsn_t.set_farcall (method) -ida_hexrays.minsn_t.set_fpinsn (method) -ida_hexrays.minsn_t.set_ignlowsrc (method) -ida_hexrays.minsn_t.set_inverted_jx (method) -ida_hexrays.minsn_t.set_mbarrier (method) -ida_hexrays.minsn_t.set_multimov (method) -ida_hexrays.minsn_t.set_noret_icall (method) -ida_hexrays.minsn_t.set_optional (method) -ida_hexrays.minsn_t.set_persistent (method) -ida_hexrays.minsn_t.set_split_size (method) -ida_hexrays.minsn_t.set_tailcall (method) -ida_hexrays.minsn_t.set_unmerged (method) -ida_hexrays.minsn_t.set_wild_match (method) -ida_hexrays.minsn_t.setaddr (method) -ida_hexrays.minsn_t.swap (method) -ida_hexrays.minsn_t.was_noret_icall (method) -ida_hexrays.minsn_t.was_split (method) -ida_hexrays.minsn_t.was_unmerged (method) -ida_hexrays.minsn_visitor_t (class) -ida_hexrays.minsn_visitor_t.__disown__ (method) -ida_hexrays.minsn_visitor_t.__init__ (method) -ida_hexrays.minsn_visitor_t.visit_minsn (method) -ida_hexrays.mlist_mop_visitor_t (class) -ida_hexrays.mlist_mop_visitor_t.__disown__ (method) -ida_hexrays.mlist_mop_visitor_t.__init__ (method) -ida_hexrays.mlist_mop_visitor_t.visit_mop (method) -ida_hexrays.mlist_t (class) -ida_hexrays.mlist_t.__eq__ (method) -ida_hexrays.mlist_t.__ge__ (method) -ida_hexrays.mlist_t.__gt__ (method) -ida_hexrays.mlist_t.__init__ (method) -ida_hexrays.mlist_t.__le__ (method) -ida_hexrays.mlist_t.__lt__ (method) -ida_hexrays.mlist_t.__ne__ (method) -ida_hexrays.mlist_t._print (method) -ida_hexrays.mlist_t.add (method) -ida_hexrays.mlist_t.addmem (method) -ida_hexrays.mlist_t.clear (method) -ida_hexrays.mlist_t.compare (method) -ida_hexrays.mlist_t.count (method) -ida_hexrays.mlist_t.dstr (method) -ida_hexrays.mlist_t.empty (method) -ida_hexrays.mlist_t.has (method) -ida_hexrays.mlist_t.has_all (method) -ida_hexrays.mlist_t.has_any (method) -ida_hexrays.mlist_t.has_common (method) -ida_hexrays.mlist_t.has_memory (method) -ida_hexrays.mlist_t.includes (method) -ida_hexrays.mlist_t.intersect (method) -ida_hexrays.mlist_t.is_subset_of (method) -ida_hexrays.mlist_t.sub (method) -ida_hexrays.mlist_t.swap (method) -ida_hexrays.mnumber_t (class) -ida_hexrays.mnumber_t.__eq__ (method) -ida_hexrays.mnumber_t.__ge__ (method) -ida_hexrays.mnumber_t.__gt__ (method) -ida_hexrays.mnumber_t.__init__ (method) -ida_hexrays.mnumber_t.__le__ (method) -ida_hexrays.mnumber_t.__lt__ (method) -ida_hexrays.mnumber_t.__ne__ (method) -ida_hexrays.mnumber_t.compare (method) -ida_hexrays.mnumber_t.update_value (method) -ida_hexrays.modify_user_lvar_info (function) -ida_hexrays.modify_user_lvars (function) -ida_hexrays.mop_S (variable) -ida_hexrays.mop_addr_t (class) -ida_hexrays.mop_addr_t.__init__ (method) -ida_hexrays.mop_addr_t.lexcompare (method) -ida_hexrays.mop_b (variable) -ida_hexrays.mop_c (variable) -ida_hexrays.mop_d (variable) -ida_hexrays.mop_f (variable) -ida_hexrays.mop_fn (variable) -ida_hexrays.mop_h (variable) -ida_hexrays.mop_l (variable) -ida_hexrays.mop_n (variable) -ida_hexrays.mop_p (variable) -ida_hexrays.mop_pair_t (class) -ida_hexrays.mop_pair_t.__init__ (method) -ida_hexrays.mop_pair_t.hop (variable) -ida_hexrays.mop_pair_t.lop (variable) -ida_hexrays.mop_r (variable) -ida_hexrays.mop_sc (variable) -ida_hexrays.mop_str (variable) -ida_hexrays.mop_t (class) -ida_hexrays.mop_t.__dbg_get_meminfo (method) -ida_hexrays.mop_t.__dbg_get_registered_kind (method) -ida_hexrays.mop_t.__eq__ (method) -ida_hexrays.mop_t.__init__ (method) -ida_hexrays.mop_t.__lt__ (method) -ida_hexrays.mop_t.__ne__ (method) -ida_hexrays.mop_t._acquire_ownership (method) -ida_hexrays.mop_t._deregister (method) -ida_hexrays.mop_t._ensure_cond (method) -ida_hexrays.mop_t._ensure_no_obj (method) -ida_hexrays.mop_t._ensure_no_t (method) -ida_hexrays.mop_t._ensure_ownership_transferrable (method) -ida_hexrays.mop_t._get_a (method) -ida_hexrays.mop_t._get_b (method) -ida_hexrays.mop_t._get_c (method) -ida_hexrays.mop_t._get_cstr (method) -ida_hexrays.mop_t._get_d (method) -ida_hexrays.mop_t._get_f (method) -ida_hexrays.mop_t._get_fpc (method) -ida_hexrays.mop_t._get_g (method) -ida_hexrays.mop_t._get_helper (method) -ida_hexrays.mop_t._get_l (method) -ida_hexrays.mop_t._get_nnn (method) -ida_hexrays.mop_t._get_pair (method) -ida_hexrays.mop_t._get_r (method) -ida_hexrays.mop_t._get_s (method) -ida_hexrays.mop_t._get_scif (method) -ida_hexrays.mop_t._get_t (method) -ida_hexrays.mop_t._make_blkref (method) -ida_hexrays.mop_t._make_callinfo (method) -ida_hexrays.mop_t._make_cases (method) -ida_hexrays.mop_t._make_gvar (method) -ida_hexrays.mop_t._make_insn (method) -ida_hexrays.mop_t._make_lvar (method) -ida_hexrays.mop_t._make_pair (method) -ida_hexrays.mop_t._make_reg (method) -ida_hexrays.mop_t._make_stkvar (method) -ida_hexrays.mop_t._make_strlit (method) -ida_hexrays.mop_t._maybe_disown_and_deregister (method) -ida_hexrays.mop_t._meminfo (method) -ida_hexrays.mop_t._obj_id (method) -ida_hexrays.mop_t._own_and_register (method) -ida_hexrays.mop_t._print (method) -ida_hexrays.mop_t._register (method) -ida_hexrays.mop_t._set_a (method) -ida_hexrays.mop_t._set_b (method) -ida_hexrays.mop_t._set_c (method) -ida_hexrays.mop_t._set_cstr (method) -ida_hexrays.mop_t._set_d (method) -ida_hexrays.mop_t._set_f (method) -ida_hexrays.mop_t._set_fpc (method) -ida_hexrays.mop_t._set_g (method) -ida_hexrays.mop_t._set_helper (method) -ida_hexrays.mop_t._set_l (method) -ida_hexrays.mop_t._set_nnn (method) -ida_hexrays.mop_t._set_pair (method) -ida_hexrays.mop_t._set_r (method) -ida_hexrays.mop_t._set_s (method) -ida_hexrays.mop_t._set_scif (method) -ida_hexrays.mop_t._set_t (method) -ida_hexrays.mop_t.apply_ld_mcode (method) -ida_hexrays.mop_t.apply_xds (method) -ida_hexrays.mop_t.apply_xdu (method) -ida_hexrays.mop_t.assign (method) -ida_hexrays.mop_t.change_size (method) -ida_hexrays.mop_t.create_from_insn (method) -ida_hexrays.mop_t.create_from_ivlset (method) -ida_hexrays.mop_t.create_from_mlist (method) -ida_hexrays.mop_t.create_from_scattered_vdloc (method) -ida_hexrays.mop_t.create_from_vdloc (method) -ida_hexrays.mop_t.double_size (method) -ida_hexrays.mop_t.dstr (method) -ida_hexrays.mop_t.empty (method) -ida_hexrays.mop_t.equal_mops (method) -ida_hexrays.mop_t.erase (method) -ida_hexrays.mop_t.erase_but_keep_size (method) -ida_hexrays.mop_t.for_all_ops (method) -ida_hexrays.mop_t.for_all_scattered_submops (method) -ida_hexrays.mop_t.get_insn (method) -ida_hexrays.mop_t.get_stkoff (method) -ida_hexrays.mop_t.get_stkvar (method) -ida_hexrays.mop_t.has_side_effects (method) -ida_hexrays.mop_t.is01 (method) -ida_hexrays.mop_t.is_arglist (method) -ida_hexrays.mop_t.is_bit_reg (method) -ida_hexrays.mop_t.is_cc (method) -ida_hexrays.mop_t.is_ccflags (method) -ida_hexrays.mop_t.is_constant (method) -ida_hexrays.mop_t.is_equal_to (method) -ida_hexrays.mop_t.is_extended_from (method) -ida_hexrays.mop_t.is_glbaddr (method) -ida_hexrays.mop_t.is_glbaddr_from_fixup (method) -ida_hexrays.mop_t.is_impptr_done (method) -ida_hexrays.mop_t.is_insn (method) -ida_hexrays.mop_t.is_kreg (method) -ida_hexrays.mop_t.is_lowaddr (method) -ida_hexrays.mop_t.is_mob (method) -ida_hexrays.mop_t.is_negative_constant (method) -ida_hexrays.mop_t.is_one (method) -ida_hexrays.mop_t.is_pcval (method) -ida_hexrays.mop_t.is_positive_constant (method) -ida_hexrays.mop_t.is_reg (method) -ida_hexrays.mop_t.is_scattered (method) -ida_hexrays.mop_t.is_sign_extended_from (method) -ida_hexrays.mop_t.is_stkaddr (method) -ida_hexrays.mop_t.is_udt (method) -ida_hexrays.mop_t.is_undef_val (method) -ida_hexrays.mop_t.is_zero (method) -ida_hexrays.mop_t.is_zero_extended_from (method) -ida_hexrays.mop_t.lexcompare (method) -ida_hexrays.mop_t.make_blkref (method) -ida_hexrays.mop_t.make_first_half (method) -ida_hexrays.mop_t.make_fpnum (method) -ida_hexrays.mop_t.make_gvar (method) -ida_hexrays.mop_t.make_helper (method) -ida_hexrays.mop_t.make_high_half (method) -ida_hexrays.mop_t.make_insn (method) -ida_hexrays.mop_t.make_low_half (method) -ida_hexrays.mop_t.make_number (method) -ida_hexrays.mop_t.make_reg (method) -ida_hexrays.mop_t.make_reg_pair (method) -ida_hexrays.mop_t.make_second_half (method) -ida_hexrays.mop_t.make_stkvar (method) -ida_hexrays.mop_t.may_use_aliased_memory (method) -ida_hexrays.mop_t.oprops (variable) -ida_hexrays.mop_t.preserve_side_effects (method) -ida_hexrays.mop_t.probably_floating (method) -ida_hexrays.mop_t.replace_by (method) -ida_hexrays.mop_t.set_impptr_done (method) -ida_hexrays.mop_t.set_lowaddr (method) -ida_hexrays.mop_t.set_udt (method) -ida_hexrays.mop_t.set_undef_val (method) -ida_hexrays.mop_t.shift_mop (method) -ida_hexrays.mop_t.signed_value (method) -ida_hexrays.mop_t.size (variable) -ida_hexrays.mop_t.swap (method) -ida_hexrays.mop_t.t (variable) -ida_hexrays.mop_t.unsigned_value (method) -ida_hexrays.mop_t.update_numop_value (method) -ida_hexrays.mop_t.valnum (variable) -ida_hexrays.mop_t.value (method) -ida_hexrays.mop_t.zero (method) -ida_hexrays.mop_v (variable) -ida_hexrays.mop_visitor_t (class) -ida_hexrays.mop_visitor_t.__disown__ (method) -ida_hexrays.mop_visitor_t.__init__ (method) -ida_hexrays.mop_visitor_t.prune (variable) -ida_hexrays.mop_visitor_t.visit_mop (method) -ida_hexrays.mop_z (variable) -ida_hexrays.mopvec_t (class) -ida_hexrays.mopvec_t.__eq__ (method) -ida_hexrays.mopvec_t.__getitem__ (method) -ida_hexrays.mopvec_t.__init__ (method) -ida_hexrays.mopvec_t.__len__ (method) -ida_hexrays.mopvec_t.__ne__ (method) -ida_hexrays.mopvec_t.__setitem__ (method) -ida_hexrays.mopvec_t._del (method) -ida_hexrays.mopvec_t.add_unique (method) -ida_hexrays.mopvec_t.at (method) -ida_hexrays.mopvec_t.begin (method) -ida_hexrays.mopvec_t.capacity (method) -ida_hexrays.mopvec_t.clear (method) -ida_hexrays.mopvec_t.empty (method) -ida_hexrays.mopvec_t.end (method) -ida_hexrays.mopvec_t.erase (method) -ida_hexrays.mopvec_t.extract (method) -ida_hexrays.mopvec_t.find (method) -ida_hexrays.mopvec_t.grow (method) -ida_hexrays.mopvec_t.has (method) -ida_hexrays.mopvec_t.inject (method) -ida_hexrays.mopvec_t.insert (method) -ida_hexrays.mopvec_t.pop_back (method) -ida_hexrays.mopvec_t.push_back (method) -ida_hexrays.mopvec_t.qclear (method) -ida_hexrays.mopvec_t.reserve (method) -ida_hexrays.mopvec_t.resize (method) -ida_hexrays.mopvec_t.size (method) -ida_hexrays.mopvec_t.swap (method) -ida_hexrays.mopvec_t.truncate (method) -ida_hexrays.mreg2reg (function) -ida_hexrays.must_mcode_close_block (function) -ida_hexrays.negate_mcode_relation (function) -ida_hexrays.negated_relation (function) -ida_hexrays.new_block (function) -ida_hexrays.number_format_t (class) -ida_hexrays.number_format_t.__init__ (method) -ida_hexrays.number_format_t.flags (variable) -ida_hexrays.number_format_t.flags32 (variable) -ida_hexrays.number_format_t.get_radix (method) -ida_hexrays.number_format_t.has_unmutable_type (method) -ida_hexrays.number_format_t.is_char (method) -ida_hexrays.number_format_t.is_dec (method) -ida_hexrays.number_format_t.is_enum (method) -ida_hexrays.number_format_t.is_fixed (method) -ida_hexrays.number_format_t.is_hex (method) -ida_hexrays.number_format_t.is_numop (method) -ida_hexrays.number_format_t.is_oct (method) -ida_hexrays.number_format_t.is_stroff (method) -ida_hexrays.number_format_t.needs_to_be_inverted (method) -ida_hexrays.number_format_t.opnum (variable) -ida_hexrays.number_format_t.org_nbytes (variable) -ida_hexrays.number_format_t.serial (variable) -ida_hexrays.number_format_t.type_name (variable) -ida_hexrays.op_parent_info_t (class) -ida_hexrays.op_parent_info_t.__init__ (method) -ida_hexrays.op_uses_x (function) -ida_hexrays.op_uses_y (function) -ida_hexrays.op_uses_z (function) -ida_hexrays.open_pseudocode (function) -ida_hexrays.operand_locator_t (class) -ida_hexrays.operand_locator_t.__eq__ (method) -ida_hexrays.operand_locator_t.__ge__ (method) -ida_hexrays.operand_locator_t.__gt__ (method) -ida_hexrays.operand_locator_t.__init__ (method) -ida_hexrays.operand_locator_t.__le__ (method) -ida_hexrays.operand_locator_t.__lt__ (method) -ida_hexrays.operand_locator_t.__ne__ (method) -ida_hexrays.operand_locator_t.compare (method) -ida_hexrays.operand_locator_t.ea (variable) -ida_hexrays.operand_locator_t.opnum (variable) -ida_hexrays.optblock_t (class) -ida_hexrays.optblock_t.__disown__ (method) -ida_hexrays.optblock_t.__init__ (method) -ida_hexrays.optblock_t.func (method) -ida_hexrays.optblock_t.install (method) -ida_hexrays.optblock_t.remove (method) -ida_hexrays.optinsn_t (class) -ida_hexrays.optinsn_t.__disown__ (method) -ida_hexrays.optinsn_t.__init__ (method) -ida_hexrays.optinsn_t.func (method) -ida_hexrays.optinsn_t.install (method) -ida_hexrays.optinsn_t.remove (method) -ida_hexrays.parse_user_call (function) -ida_hexrays.partial_type_num (function) -ida_hexrays.print_vdloc (function) -ida_hexrays.property_op_to_typename (function) -ida_hexrays.qstring_printer_t (class) -ida_hexrays.qstring_printer_t.__init__ (method) -ida_hexrays.qstring_printer_t._print (method) -ida_hexrays.qstring_printer_t.get_s (method) -ida_hexrays.qstring_printer_t.s (variable) -ida_hexrays.qstring_printer_t.with_tags (variable) -ida_hexrays.qswap (function) -ida_hexrays.qvector_carg_t (class) -ida_hexrays.qvector_carg_t.__eq__ (method) -ida_hexrays.qvector_carg_t.__getitem__ (method) -ida_hexrays.qvector_carg_t.__init__ (method) -ida_hexrays.qvector_carg_t.__len__ (method) -ida_hexrays.qvector_carg_t.__ne__ (method) -ida_hexrays.qvector_carg_t.__setitem__ (method) -ida_hexrays.qvector_carg_t._del (method) -ida_hexrays.qvector_carg_t.add_unique (method) -ida_hexrays.qvector_carg_t.at (method) -ida_hexrays.qvector_carg_t.begin (method) -ida_hexrays.qvector_carg_t.capacity (method) -ida_hexrays.qvector_carg_t.clear (method) -ida_hexrays.qvector_carg_t.empty (method) -ida_hexrays.qvector_carg_t.end (method) -ida_hexrays.qvector_carg_t.erase (method) -ida_hexrays.qvector_carg_t.extract (method) -ida_hexrays.qvector_carg_t.find (method) -ida_hexrays.qvector_carg_t.grow (method) -ida_hexrays.qvector_carg_t.has (method) -ida_hexrays.qvector_carg_t.inject (method) -ida_hexrays.qvector_carg_t.insert (method) -ida_hexrays.qvector_carg_t.pop_back (method) -ida_hexrays.qvector_carg_t.push_back (method) -ida_hexrays.qvector_carg_t.qclear (method) -ida_hexrays.qvector_carg_t.reserve (method) -ida_hexrays.qvector_carg_t.resize (method) -ida_hexrays.qvector_carg_t.size (method) -ida_hexrays.qvector_carg_t.swap (method) -ida_hexrays.qvector_carg_t.truncate (method) -ida_hexrays.qvector_ccase_t (class) -ida_hexrays.qvector_ccase_t.__eq__ (method) -ida_hexrays.qvector_ccase_t.__getitem__ (method) -ida_hexrays.qvector_ccase_t.__init__ (method) -ida_hexrays.qvector_ccase_t.__len__ (method) -ida_hexrays.qvector_ccase_t.__ne__ (method) -ida_hexrays.qvector_ccase_t.__setitem__ (method) -ida_hexrays.qvector_ccase_t._del (method) -ida_hexrays.qvector_ccase_t.add_unique (method) -ida_hexrays.qvector_ccase_t.at (method) -ida_hexrays.qvector_ccase_t.begin (method) -ida_hexrays.qvector_ccase_t.capacity (method) -ida_hexrays.qvector_ccase_t.clear (method) -ida_hexrays.qvector_ccase_t.empty (method) -ida_hexrays.qvector_ccase_t.end (method) -ida_hexrays.qvector_ccase_t.erase (method) -ida_hexrays.qvector_ccase_t.extract (method) -ida_hexrays.qvector_ccase_t.find (method) -ida_hexrays.qvector_ccase_t.grow (method) -ida_hexrays.qvector_ccase_t.has (method) -ida_hexrays.qvector_ccase_t.inject (method) -ida_hexrays.qvector_ccase_t.insert (method) -ida_hexrays.qvector_ccase_t.pop_back (method) -ida_hexrays.qvector_ccase_t.push_back (method) -ida_hexrays.qvector_ccase_t.qclear (method) -ida_hexrays.qvector_ccase_t.reserve (method) -ida_hexrays.qvector_ccase_t.resize (method) -ida_hexrays.qvector_ccase_t.size (method) -ida_hexrays.qvector_ccase_t.swap (method) -ida_hexrays.qvector_ccase_t.truncate (method) -ida_hexrays.qvector_history_t (class) -ida_hexrays.qvector_history_t.__eq__ (method) -ida_hexrays.qvector_history_t.__getitem__ (method) -ida_hexrays.qvector_history_t.__init__ (method) -ida_hexrays.qvector_history_t.__len__ (method) -ida_hexrays.qvector_history_t.__ne__ (method) -ida_hexrays.qvector_history_t.__setitem__ (method) -ida_hexrays.qvector_history_t._del (method) -ida_hexrays.qvector_history_t.add_unique (method) -ida_hexrays.qvector_history_t.at (method) -ida_hexrays.qvector_history_t.begin (method) -ida_hexrays.qvector_history_t.capacity (method) -ida_hexrays.qvector_history_t.clear (method) -ida_hexrays.qvector_history_t.empty (method) -ida_hexrays.qvector_history_t.end (method) -ida_hexrays.qvector_history_t.erase (method) -ida_hexrays.qvector_history_t.extract (method) -ida_hexrays.qvector_history_t.find (method) -ida_hexrays.qvector_history_t.grow (method) -ida_hexrays.qvector_history_t.has (method) -ida_hexrays.qvector_history_t.inject (method) -ida_hexrays.qvector_history_t.insert (method) -ida_hexrays.qvector_history_t.pop_back (method) -ida_hexrays.qvector_history_t.push_back (method) -ida_hexrays.qvector_history_t.qclear (method) -ida_hexrays.qvector_history_t.reserve (method) -ida_hexrays.qvector_history_t.resize (method) -ida_hexrays.qvector_history_t.size (method) -ida_hexrays.qvector_history_t.swap (method) -ida_hexrays.qvector_history_t.truncate (method) -ida_hexrays.qvector_lvar_t (class) -ida_hexrays.qvector_lvar_t.__eq__ (method) -ida_hexrays.qvector_lvar_t.__getitem__ (method) -ida_hexrays.qvector_lvar_t.__init__ (method) -ida_hexrays.qvector_lvar_t.__len__ (method) -ida_hexrays.qvector_lvar_t.__ne__ (method) -ida_hexrays.qvector_lvar_t.__setitem__ (method) -ida_hexrays.qvector_lvar_t._del (method) -ida_hexrays.qvector_lvar_t.add_unique (method) -ida_hexrays.qvector_lvar_t.at (method) -ida_hexrays.qvector_lvar_t.begin (method) -ida_hexrays.qvector_lvar_t.capacity (method) -ida_hexrays.qvector_lvar_t.clear (method) -ida_hexrays.qvector_lvar_t.empty (method) -ida_hexrays.qvector_lvar_t.end (method) -ida_hexrays.qvector_lvar_t.erase (method) -ida_hexrays.qvector_lvar_t.extract (method) -ida_hexrays.qvector_lvar_t.find (method) -ida_hexrays.qvector_lvar_t.grow (method) -ida_hexrays.qvector_lvar_t.has (method) -ida_hexrays.qvector_lvar_t.inject (method) -ida_hexrays.qvector_lvar_t.insert (method) -ida_hexrays.qvector_lvar_t.pop_back (method) -ida_hexrays.qvector_lvar_t.push_back (method) -ida_hexrays.qvector_lvar_t.qclear (method) -ida_hexrays.qvector_lvar_t.reserve (method) -ida_hexrays.qvector_lvar_t.resize (method) -ida_hexrays.qvector_lvar_t.size (method) -ida_hexrays.qvector_lvar_t.swap (method) -ida_hexrays.qvector_lvar_t.truncate (method) -ida_hexrays.reg2mreg (function) -ida_hexrays.remitem (function) -ida_hexrays.remove_hexrays_callback (function) -ida_hexrays.rename_lvar (function) -ida_hexrays.restore_user_cmts (function) -ida_hexrays.restore_user_defined_calls (function) -ida_hexrays.restore_user_iflags (function) -ida_hexrays.restore_user_labels (function) -ida_hexrays.restore_user_labels2 (function) -ida_hexrays.restore_user_lvar_settings (function) -ida_hexrays.restore_user_numforms (function) -ida_hexrays.restore_user_unions (function) -ida_hexrays.rlist_t (class) -ida_hexrays.rlist_t.__init__ (method) -ida_hexrays.rlist_t.dstr (method) -ida_hexrays.save_user_cmts (function) -ida_hexrays.save_user_defined_calls (function) -ida_hexrays.save_user_iflags (function) -ida_hexrays.save_user_labels (function) -ida_hexrays.save_user_labels2 (function) -ida_hexrays.save_user_lvar_settings (function) -ida_hexrays.save_user_numforms (function) -ida_hexrays.save_user_unions (function) -ida_hexrays.scif_t (class) -ida_hexrays.scif_t.__init__ (method) -ida_hexrays.scif_t.mba (variable) -ida_hexrays.scif_t.name (variable) -ida_hexrays.scif_t.type (variable) -ida_hexrays.scif_visitor_t (class) -ida_hexrays.scif_visitor_t.__disown__ (method) -ida_hexrays.scif_visitor_t.__init__ (method) -ida_hexrays.scif_visitor_t.visit_scif_mop (method) -ida_hexrays.select_udt_by_offset (function) -ida_hexrays.send_database (function) -ida_hexrays.set2jcnd (function) -ida_hexrays.set_type (function) -ida_hexrays.simple_graph_t (class) -ida_hexrays.simple_graph_t.__init__ (method) -ida_hexrays.stkvar_ref_t (class) -ida_hexrays.stkvar_ref_t.__eq__ (method) -ida_hexrays.stkvar_ref_t.__ge__ (method) -ida_hexrays.stkvar_ref_t.__gt__ (method) -ida_hexrays.stkvar_ref_t.__init__ (method) -ida_hexrays.stkvar_ref_t.__le__ (method) -ida_hexrays.stkvar_ref_t.__lt__ (method) -ida_hexrays.stkvar_ref_t.__ne__ (method) -ida_hexrays.stkvar_ref_t.compare (method) -ida_hexrays.stkvar_ref_t.get_stkvar (method) -ida_hexrays.stkvar_ref_t.mba (variable) -ida_hexrays.stkvar_ref_t.off (variable) -ida_hexrays.stkvar_ref_t.swap (method) -ida_hexrays.swap_mcode_relation (function) -ida_hexrays.swapped_relation (function) -ida_hexrays.term_hexrays_plugin (function) -ida_hexrays.treeloc_t (class) -ida_hexrays.treeloc_t.__eq__ (method) -ida_hexrays.treeloc_t.__init__ (method) -ida_hexrays.treeloc_t.__lt__ (method) -ida_hexrays.udc_filter_t (class) -ida_hexrays.udc_filter_t.__disown__ (method) -ida_hexrays.udc_filter_t.__init__ (method) -ida_hexrays.udc_filter_t.apply (method) -ida_hexrays.udc_filter_t.cleanup (method) -ida_hexrays.udc_filter_t.empty (method) -ida_hexrays.udc_filter_t.init (method) -ida_hexrays.udc_filter_t.install (method) -ida_hexrays.udc_filter_t.match (method) -ida_hexrays.udc_filter_t.remove (method) -ida_hexrays.udcall_map_begin (function) -ida_hexrays.udcall_map_clear (function) -ida_hexrays.udcall_map_end (function) -ida_hexrays.udcall_map_erase (function) -ida_hexrays.udcall_map_find (function) -ida_hexrays.udcall_map_first (function) -ida_hexrays.udcall_map_free (function) -ida_hexrays.udcall_map_insert (function) -ida_hexrays.udcall_map_iterator_t (class) -ida_hexrays.udcall_map_iterator_t.__eq__ (method) -ida_hexrays.udcall_map_iterator_t.__init__ (method) -ida_hexrays.udcall_map_iterator_t.__ne__ (method) -ida_hexrays.udcall_map_new (function) -ida_hexrays.udcall_map_next (function) -ida_hexrays.udcall_map_prev (function) -ida_hexrays.udcall_map_second (function) -ida_hexrays.udcall_map_size (function) -ida_hexrays.udcall_t (class) -ida_hexrays.udcall_t.__eq__ (method) -ida_hexrays.udcall_t.__ge__ (method) -ida_hexrays.udcall_t.__gt__ (method) -ida_hexrays.udcall_t.__init__ (method) -ida_hexrays.udcall_t.__le__ (method) -ida_hexrays.udcall_t.__lt__ (method) -ida_hexrays.udcall_t.__ne__ (method) -ida_hexrays.udcall_t.compare (method) -ida_hexrays.udcall_t.empty (method) -ida_hexrays.ui_stroff_applicator_t (class) -ida_hexrays.ui_stroff_applicator_t.__disown__ (method) -ida_hexrays.ui_stroff_applicator_t.__init__ (method) -ida_hexrays.ui_stroff_applicator_t.apply (method) -ida_hexrays.ui_stroff_op_t (class) -ida_hexrays.ui_stroff_op_t.__eq__ (method) -ida_hexrays.ui_stroff_op_t.__init__ (method) -ida_hexrays.ui_stroff_op_t.__ne__ (method) -ida_hexrays.ui_stroff_op_t.offset (variable) -ida_hexrays.ui_stroff_op_t.text (variable) -ida_hexrays.ui_stroff_ops_t (class) -ida_hexrays.ui_stroff_ops_t.__eq__ (method) -ida_hexrays.ui_stroff_ops_t.__getitem__ (method) -ida_hexrays.ui_stroff_ops_t.__init__ (method) -ida_hexrays.ui_stroff_ops_t.__len__ (method) -ida_hexrays.ui_stroff_ops_t.__ne__ (method) -ida_hexrays.ui_stroff_ops_t.__setitem__ (method) -ida_hexrays.ui_stroff_ops_t._del (method) -ida_hexrays.ui_stroff_ops_t.add_unique (method) -ida_hexrays.ui_stroff_ops_t.at (method) -ida_hexrays.ui_stroff_ops_t.begin (method) -ida_hexrays.ui_stroff_ops_t.capacity (method) -ida_hexrays.ui_stroff_ops_t.clear (method) -ida_hexrays.ui_stroff_ops_t.empty (method) -ida_hexrays.ui_stroff_ops_t.end (method) -ida_hexrays.ui_stroff_ops_t.erase (method) -ida_hexrays.ui_stroff_ops_t.extract (method) -ida_hexrays.ui_stroff_ops_t.find (method) -ida_hexrays.ui_stroff_ops_t.grow (method) -ida_hexrays.ui_stroff_ops_t.has (method) -ida_hexrays.ui_stroff_ops_t.inject (method) -ida_hexrays.ui_stroff_ops_t.insert (method) -ida_hexrays.ui_stroff_ops_t.pop_back (method) -ida_hexrays.ui_stroff_ops_t.push_back (method) -ida_hexrays.ui_stroff_ops_t.qclear (method) -ida_hexrays.ui_stroff_ops_t.reserve (method) -ida_hexrays.ui_stroff_ops_t.resize (method) -ida_hexrays.ui_stroff_ops_t.size (method) -ida_hexrays.ui_stroff_ops_t.swap (method) -ida_hexrays.ui_stroff_ops_t.truncate (method) -ida_hexrays.user_cmts_begin (function) -ida_hexrays.user_cmts_clear (function) -ida_hexrays.user_cmts_end (function) -ida_hexrays.user_cmts_erase (function) -ida_hexrays.user_cmts_find (function) -ida_hexrays.user_cmts_first (function) -ida_hexrays.user_cmts_free (function) -ida_hexrays.user_cmts_insert (function) -ida_hexrays.user_cmts_iterator_t (class) -ida_hexrays.user_cmts_iterator_t.__eq__ (method) -ida_hexrays.user_cmts_iterator_t.__init__ (method) -ida_hexrays.user_cmts_iterator_t.__ne__ (method) -ida_hexrays.user_cmts_new (function) -ida_hexrays.user_cmts_next (function) -ida_hexrays.user_cmts_prev (function) -ida_hexrays.user_cmts_second (function) -ida_hexrays.user_cmts_size (function) -ida_hexrays.user_cmts_t (class) -ida_hexrays.user_cmts_t.__init__ (method) -ida_hexrays.user_cmts_t.at (method) -ida_hexrays.user_cmts_t.size (method) -ida_hexrays.user_iflags_begin (function) -ida_hexrays.user_iflags_clear (function) -ida_hexrays.user_iflags_end (function) -ida_hexrays.user_iflags_erase (function) -ida_hexrays.user_iflags_find (function) -ida_hexrays.user_iflags_first (function) -ida_hexrays.user_iflags_free (function) -ida_hexrays.user_iflags_insert (function) -ida_hexrays.user_iflags_iterator_t (class) -ida_hexrays.user_iflags_iterator_t.__eq__ (method) -ida_hexrays.user_iflags_iterator_t.__init__ (method) -ida_hexrays.user_iflags_iterator_t.__ne__ (method) -ida_hexrays.user_iflags_new (function) -ida_hexrays.user_iflags_next (function) -ida_hexrays.user_iflags_prev (function) -ida_hexrays.user_iflags_second (function) -ida_hexrays.user_iflags_size (function) -ida_hexrays.user_iflags_t (class) -ida_hexrays.user_iflags_t.__init__ (method) -ida_hexrays.user_iflags_t.at (method) -ida_hexrays.user_iflags_t.size (method) -ida_hexrays.user_labels_begin (function) -ida_hexrays.user_labels_clear (function) -ida_hexrays.user_labels_end (function) -ida_hexrays.user_labels_erase (function) -ida_hexrays.user_labels_find (function) -ida_hexrays.user_labels_first (function) -ida_hexrays.user_labels_free (function) -ida_hexrays.user_labels_insert (function) -ida_hexrays.user_labels_iterator_t (class) -ida_hexrays.user_labels_iterator_t.__eq__ (method) -ida_hexrays.user_labels_iterator_t.__init__ (method) -ida_hexrays.user_labels_iterator_t.__ne__ (method) -ida_hexrays.user_labels_new (function) -ida_hexrays.user_labels_next (function) -ida_hexrays.user_labels_prev (function) -ida_hexrays.user_labels_second (function) -ida_hexrays.user_labels_size (function) -ida_hexrays.user_labels_t (class) -ida_hexrays.user_labels_t.__init__ (method) -ida_hexrays.user_labels_t.at (method) -ida_hexrays.user_labels_t.size (method) -ida_hexrays.user_lvar_modifier_t (class) -ida_hexrays.user_lvar_modifier_t.__disown__ (method) -ida_hexrays.user_lvar_modifier_t.__init__ (method) -ida_hexrays.user_lvar_modifier_t.modify_lvars (method) -ida_hexrays.user_numforms_begin (function) -ida_hexrays.user_numforms_clear (function) -ida_hexrays.user_numforms_end (function) -ida_hexrays.user_numforms_erase (function) -ida_hexrays.user_numforms_find (function) -ida_hexrays.user_numforms_first (function) -ida_hexrays.user_numforms_free (function) -ida_hexrays.user_numforms_insert (function) -ida_hexrays.user_numforms_iterator_t (class) -ida_hexrays.user_numforms_iterator_t.__eq__ (method) -ida_hexrays.user_numforms_iterator_t.__init__ (method) -ida_hexrays.user_numforms_iterator_t.__ne__ (method) -ida_hexrays.user_numforms_new (function) -ida_hexrays.user_numforms_next (function) -ida_hexrays.user_numforms_prev (function) -ida_hexrays.user_numforms_second (function) -ida_hexrays.user_numforms_size (function) -ida_hexrays.user_numforms_t (class) -ida_hexrays.user_numforms_t.__init__ (method) -ida_hexrays.user_numforms_t.at (method) -ida_hexrays.user_numforms_t.size (method) -ida_hexrays.user_unions_begin (function) -ida_hexrays.user_unions_clear (function) -ida_hexrays.user_unions_end (function) -ida_hexrays.user_unions_erase (function) -ida_hexrays.user_unions_find (function) -ida_hexrays.user_unions_first (function) -ida_hexrays.user_unions_free (function) -ida_hexrays.user_unions_insert (function) -ida_hexrays.user_unions_iterator_t (class) -ida_hexrays.user_unions_iterator_t.__eq__ (method) -ida_hexrays.user_unions_iterator_t.__init__ (method) -ida_hexrays.user_unions_iterator_t.__ne__ (method) -ida_hexrays.user_unions_new (function) -ida_hexrays.user_unions_next (function) -ida_hexrays.user_unions_prev (function) -ida_hexrays.user_unions_second (function) -ida_hexrays.user_unions_size (function) -ida_hexrays.user_unions_t (class) -ida_hexrays.user_unions_t.__init__ (method) -ida_hexrays.user_unions_t.at (method) -ida_hexrays.user_unions_t.size (method) -ida_hexrays.uval_ivl_ivlset_t (class) -ida_hexrays.uval_ivl_ivlset_t.__eq__ (method) -ida_hexrays.uval_ivl_ivlset_t.__init__ (method) -ida_hexrays.uval_ivl_ivlset_t.__ne__ (method) -ida_hexrays.uval_ivl_ivlset_t.all_values (method) -ida_hexrays.uval_ivl_ivlset_t.begin (method) -ida_hexrays.uval_ivl_ivlset_t.clear (method) -ida_hexrays.uval_ivl_ivlset_t.empty (method) -ida_hexrays.uval_ivl_ivlset_t.end (method) -ida_hexrays.uval_ivl_ivlset_t.getivl (method) -ida_hexrays.uval_ivl_ivlset_t.lastivl (method) -ida_hexrays.uval_ivl_ivlset_t.nivls (method) -ida_hexrays.uval_ivl_ivlset_t.qclear (method) -ida_hexrays.uval_ivl_ivlset_t.set_all_values (method) -ida_hexrays.uval_ivl_ivlset_t.single_value (method) -ida_hexrays.uval_ivl_ivlset_t.swap (method) -ida_hexrays.uval_ivl_t (class) -ida_hexrays.uval_ivl_t.__init__ (method) -ida_hexrays.uval_ivl_t.end (method) -ida_hexrays.uval_ivl_t.last (method) -ida_hexrays.uval_ivl_t.valid (method) -ida_hexrays.valrng_t (class) -ida_hexrays.valrng_t.__eq__ (method) -ida_hexrays.valrng_t.__ge__ (method) -ida_hexrays.valrng_t.__gt__ (method) -ida_hexrays.valrng_t.__init__ (method) -ida_hexrays.valrng_t.__le__ (method) -ida_hexrays.valrng_t.__lt__ (method) -ida_hexrays.valrng_t.__ne__ (method) -ida_hexrays.valrng_t._deregister (method) -ida_hexrays.valrng_t._print (method) -ida_hexrays.valrng_t._register (method) -ida_hexrays.valrng_t.all_values (method) -ida_hexrays.valrng_t.compare (method) -ida_hexrays.valrng_t.cvt_to_cmp (method) -ida_hexrays.valrng_t.cvt_to_single_value (method) -ida_hexrays.valrng_t.dstr (method) -ida_hexrays.valrng_t.empty (method) -ida_hexrays.valrng_t.get_size (method) -ida_hexrays.valrng_t.has (method) -ida_hexrays.valrng_t.intersect_with (method) -ida_hexrays.valrng_t.inverse (method) -ida_hexrays.valrng_t.is_unknown (method) -ida_hexrays.valrng_t.max_svalue (method) -ida_hexrays.valrng_t.max_value (method) -ida_hexrays.valrng_t.min_svalue (method) -ida_hexrays.valrng_t.reduce_size (method) -ida_hexrays.valrng_t.set_all (method) -ida_hexrays.valrng_t.set_cmp (method) -ida_hexrays.valrng_t.set_eq (method) -ida_hexrays.valrng_t.set_none (method) -ida_hexrays.valrng_t.set_unk (method) -ida_hexrays.valrng_t.swap (method) -ida_hexrays.valrng_t.unite_with (method) -ida_hexrays.var_ref_t (class) -ida_hexrays.var_ref_t.__eq__ (method) -ida_hexrays.var_ref_t.__ge__ (method) -ida_hexrays.var_ref_t.__gt__ (method) -ida_hexrays.var_ref_t.__init__ (method) -ida_hexrays.var_ref_t.__le__ (method) -ida_hexrays.var_ref_t.__lt__ (method) -ida_hexrays.var_ref_t.__ne__ (method) -ida_hexrays.var_ref_t.compare (method) -ida_hexrays.var_ref_t.getv (method) -ida_hexrays.var_ref_t.idx (variable) -ida_hexrays.var_ref_t.mba (variable) -ida_hexrays.vc_printer_t (class) -ida_hexrays.vc_printer_t.__disown__ (method) -ida_hexrays.vc_printer_t.__init__ (method) -ida_hexrays.vc_printer_t.func (variable) -ida_hexrays.vc_printer_t.oneliner (method) -ida_hexrays.vd_failure_t (class) -ida_hexrays.vd_failure_t.__init__ (method) -ida_hexrays.vd_failure_t.desc (method) -ida_hexrays.vd_interr_t (class) -ida_hexrays.vd_interr_t.__init__ (method) -ida_hexrays.vd_printer_t (class) -ida_hexrays.vd_printer_t.__disown__ (method) -ida_hexrays.vd_printer_t.__init__ (method) -ida_hexrays.vd_printer_t._print (method) -ida_hexrays.vd_printer_t.hdrlines (variable) -ida_hexrays.vdloc_t (class) -ida_hexrays.vdloc_t.__eq__ (method) -ida_hexrays.vdloc_t.__ge__ (method) -ida_hexrays.vdloc_t.__gt__ (method) -ida_hexrays.vdloc_t.__init__ (method) -ida_hexrays.vdloc_t.__le__ (method) -ida_hexrays.vdloc_t.__lt__ (method) -ida_hexrays.vdloc_t.__ne__ (method) -ida_hexrays.vdloc_t._set_reg1 (method) -ida_hexrays.vdloc_t.compare (method) -ida_hexrays.vdloc_t.is_aliasable (method) -ida_hexrays.vdloc_t.reg1 (method) -ida_hexrays.vdloc_t.set_reg1 (method) -ida_hexrays.vdui_t (class) -ida_hexrays.vdui_t.__init__ (method) -ida_hexrays.vdui_t.calc_cmt_type (method) -ida_hexrays.vdui_t.cfunc (variable) -ida_hexrays.vdui_t.clear (method) -ida_hexrays.vdui_t.collapse_item (method) -ida_hexrays.vdui_t.collapse_lvars (method) -ida_hexrays.vdui_t.cpos (variable) -ida_hexrays.vdui_t.ct (variable) -ida_hexrays.vdui_t.ctree_to_disasm (method) -ida_hexrays.vdui_t.del_orphan_cmts (method) -ida_hexrays.vdui_t.edit_cmt (method) -ida_hexrays.vdui_t.edit_func_cmt (method) -ida_hexrays.vdui_t.flags (variable) -ida_hexrays.vdui_t.get_current_item (method) -ida_hexrays.vdui_t.get_current_label (method) -ida_hexrays.vdui_t.get_number (method) -ida_hexrays.vdui_t.head (variable) -ida_hexrays.vdui_t.in_ctree (method) -ida_hexrays.vdui_t.invert_bits (method) -ida_hexrays.vdui_t.invert_sign (method) -ida_hexrays.vdui_t.item (variable) -ida_hexrays.vdui_t.jump_enter (method) -ida_hexrays.vdui_t.last_code (variable) -ida_hexrays.vdui_t.locked (method) -ida_hexrays.vdui_t.map_lvar (method) -ida_hexrays.vdui_t.mba (variable) -ida_hexrays.vdui_t.refresh_cpos (method) -ida_hexrays.vdui_t.refresh_ctext (method) -ida_hexrays.vdui_t.refresh_view (method) -ida_hexrays.vdui_t.rename_global (method) -ida_hexrays.vdui_t.rename_label (method) -ida_hexrays.vdui_t.rename_lvar (method) -ida_hexrays.vdui_t.rename_strmem (method) -ida_hexrays.vdui_t.rename_udm (method) -ida_hexrays.vdui_t.set_global_type (method) -ida_hexrays.vdui_t.set_locked (method) -ida_hexrays.vdui_t.set_lvar_cmt (method) -ida_hexrays.vdui_t.set_lvar_type (method) -ida_hexrays.vdui_t.set_noptr_lvar (method) -ida_hexrays.vdui_t.set_num_enum (method) -ida_hexrays.vdui_t.set_num_radix (method) -ida_hexrays.vdui_t.set_num_stroff (method) -ida_hexrays.vdui_t.set_strmem_type (method) -ida_hexrays.vdui_t.set_udm_type (method) -ida_hexrays.vdui_t.set_valid (method) -ida_hexrays.vdui_t.set_visible (method) -ida_hexrays.vdui_t.split_item (method) -ida_hexrays.vdui_t.switch_to (method) -ida_hexrays.vdui_t.tail (variable) -ida_hexrays.vdui_t.ui_edit_lvar_cmt (method) -ida_hexrays.vdui_t.ui_map_lvar (method) -ida_hexrays.vdui_t.ui_rename_lvar (method) -ida_hexrays.vdui_t.ui_set_call_type (method) -ida_hexrays.vdui_t.ui_set_lvar_type (method) -ida_hexrays.vdui_t.ui_unmap_lvar (method) -ida_hexrays.vdui_t.valid (method) -ida_hexrays.vdui_t.view_idx (variable) -ida_hexrays.vdui_t.visible (method) -ida_hexrays.vivl_t (class) -ida_hexrays.vivl_t.__eq__ (method) -ida_hexrays.vivl_t.__ge__ (method) -ida_hexrays.vivl_t.__gt__ (method) -ida_hexrays.vivl_t.__init__ (method) -ida_hexrays.vivl_t.__le__ (method) -ida_hexrays.vivl_t.__lt__ (method) -ida_hexrays.vivl_t.__ne__ (method) -ida_hexrays.vivl_t._print (method) -ida_hexrays.vivl_t.compare (method) -ida_hexrays.vivl_t.contains (method) -ida_hexrays.vivl_t.dstr (method) -ida_hexrays.vivl_t.extend_to_cover (method) -ida_hexrays.vivl_t.includes (method) -ida_hexrays.vivl_t.intersect (method) -ida_hexrays.vivl_t.overlap (method) -ida_hexrays.vivl_t.set (method) -ida_hexrays.vivl_t.set_reg (method) -ida_hexrays.vivl_t.set_stkoff (method) -ida_hexrays.vivl_t.size (variable) -ida_hexrays.voff_t (class) -ida_hexrays.voff_t.__eq__ (method) -ida_hexrays.voff_t.__ge__ (method) -ida_hexrays.voff_t.__gt__ (method) -ida_hexrays.voff_t.__init__ (method) -ida_hexrays.voff_t.__le__ (method) -ida_hexrays.voff_t.__lt__ (method) -ida_hexrays.voff_t.__ne__ (method) -ida_hexrays.voff_t.add (method) -ida_hexrays.voff_t.compare (method) -ida_hexrays.voff_t.defined (method) -ida_hexrays.voff_t.diff (method) -ida_hexrays.voff_t.get_reg (method) -ida_hexrays.voff_t.get_stkoff (method) -ida_hexrays.voff_t.inc (method) -ida_hexrays.voff_t.is_reg (method) -ida_hexrays.voff_t.is_stkoff (method) -ida_hexrays.voff_t.off (variable) -ida_hexrays.voff_t.set (method) -ida_hexrays.voff_t.set_reg (method) -ida_hexrays.voff_t.set_stkoff (method) -ida_hexrays.voff_t.type (variable) -ida_hexrays.voff_t.undef (method) -ida_allins (module) -ida_auto (module) -ida_auto.AU_CHLB (variable) -ida_auto.AU_CODE (variable) -ida_auto.AU_FCHUNK (variable) -ida_auto.AU_FINAL (variable) -ida_auto.AU_LBF2 (variable) -ida_auto.AU_LBF3 (variable) -ida_auto.AU_LIBF (variable) -ida_auto.AU_NONE (variable) -ida_auto.AU_PROC (variable) -ida_auto.AU_TAIL (variable) -ida_auto.AU_TYPE (variable) -ida_auto.AU_UNK (variable) -ida_auto.AU_USD2 (variable) -ida_auto.AU_USED (variable) -ida_auto.AU_WEAK (variable) -ida_auto.auto_apply_tail (function) -ida_auto.auto_apply_type (function) -ida_auto.auto_cancel (function) -ida_auto.auto_display_t (class) -ida_auto.auto_display_t.__init__ (method) -ida_auto.auto_get (function) -ida_auto.auto_is_ok (function) -ida_auto.auto_make_code (function) -ida_auto.auto_make_proc (function) -ida_auto.auto_make_step (function) -ida_auto.auto_mark (function) -ida_auto.auto_mark_range (function) -ida_auto.auto_postpone_analysis (function) -ida_auto.auto_recreate_insn (function) -ida_auto.auto_unmark (function) -ida_auto.auto_wait (function) -ida_auto.auto_wait_range (function) -ida_auto.enable_auto (function) -ida_auto.get_auto_display (function) -ida_auto.get_auto_state (function) -ida_auto.is_auto_enabled (function) -ida_auto.may_create_stkvars (function) -ida_auto.may_trace_sp (function) -ida_auto.peek_auto_queue (function) -ida_auto.plan_and_wait (function) -ida_auto.plan_ea (function) -ida_auto.plan_range (function) -ida_auto.reanalyze_callers (function) -ida_auto.revert_ida_decisions (function) -ida_auto.set_auto_state (function) -ida_auto.set_ida_state (function) -ida_auto.show_addr (function) -ida_auto.show_auto (function) -ida_bitrange (module) -ida_bitrange.bitrange_t (class) -ida_bitrange.bitrange_t.__eq__ (method) -ida_bitrange.bitrange_t.__ge__ (method) -ida_bitrange.bitrange_t.__gt__ (method) -ida_bitrange.bitrange_t.__init__ (method) -ida_bitrange.bitrange_t.__le__ (method) -ida_bitrange.bitrange_t.__lt__ (method) -ida_bitrange.bitrange_t.__ne__ (method) -ida_bitrange.bitrange_t.__str__ (method) -ida_bitrange.bitrange_t.apply_mask (method) -ida_bitrange.bitrange_t.bitoff (method) -ida_bitrange.bitrange_t.bitsize (method) -ida_bitrange.bitrange_t.bytesize (method) -ida_bitrange.bitrange_t.compare (method) -ida_bitrange.bitrange_t.create_union (method) -ida_bitrange.bitrange_t.empty (method) -ida_bitrange.bitrange_t.extract (method) -ida_bitrange.bitrange_t.has_common (method) -ida_bitrange.bitrange_t.init (method) -ida_bitrange.bitrange_t.inject (method) -ida_bitrange.bitrange_t.intersect (method) -ida_bitrange.bitrange_t.mask64 (method) -ida_bitrange.bitrange_t.reset (method) -ida_bitrange.bitrange_t.shift_down (method) -ida_bitrange.bitrange_t.shift_up (method) -ida_bitrange.bitrange_t.sub (method) -ida_bytes (module) -ida_bytes.ALOPT_APPEND (variable) -ida_bytes.ALOPT_IGNCLT (variable) -ida_bytes.ALOPT_IGNHEADS (variable) -ida_bytes.ALOPT_IGNPRINT (variable) -ida_bytes.ALOPT_MAX4K (variable) -ida_bytes.ALOPT_ONLYTERM (variable) -ida_bytes.BIN_SEARCH_BACKWARD (variable) -ida_bytes.BIN_SEARCH_BITMASK (variable) -ida_bytes.BIN_SEARCH_CASE (variable) -ida_bytes.BIN_SEARCH_FORWARD (variable) -ida_bytes.BIN_SEARCH_INITED (variable) -ida_bytes.BIN_SEARCH_NOBREAK (variable) -ida_bytes.BIN_SEARCH_NOCASE (variable) -ida_bytes.BIN_SEARCH_NOSHOW (variable) -ida_bytes.DELIT_DELNAMES (variable) -ida_bytes.DELIT_EXPAND (variable) -ida_bytes.DELIT_KEEPFUNC (variable) -ida_bytes.DELIT_NOCMT (variable) -ida_bytes.DELIT_NOTRUNC (variable) -ida_bytes.DELIT_NOUNAME (variable) -ida_bytes.DELIT_SIMPLE (variable) -ida_bytes.DTP_NODUP (variable) -ida_bytes.DT_TYPE (variable) -ida_bytes.FF_ALIGN (variable) -ida_bytes.FF_BNOT (variable) -ida_bytes.FF_BYTE (variable) -ida_bytes.FF_CODE (variable) -ida_bytes.FF_COMM (variable) -ida_bytes.FF_CUSTOM (variable) -ida_bytes.FF_DATA (variable) -ida_bytes.FF_DOUBLE (variable) -ida_bytes.FF_DWORD (variable) -ida_bytes.FF_FLOAT (variable) -ida_bytes.FF_FLOW (variable) -ida_bytes.FF_FUNC (variable) -ida_bytes.FF_IMMD (variable) -ida_bytes.FF_IVL (variable) -ida_bytes.FF_JUMP (variable) -ida_bytes.FF_LABL (variable) -ida_bytes.FF_LINE (variable) -ida_bytes.FF_NAME (variable) -ida_bytes.FF_N_CHAR (variable) -ida_bytes.FF_N_CUST (variable) -ida_bytes.FF_N_ENUM (variable) -ida_bytes.FF_N_FLT (variable) -ida_bytes.FF_N_FOP (variable) -ida_bytes.FF_N_NUMB (variable) -ida_bytes.FF_N_NUMD (variable) -ida_bytes.FF_N_NUMH (variable) -ida_bytes.FF_N_NUMO (variable) -ida_bytes.FF_N_OFF (variable) -ida_bytes.FF_N_SEG (variable) -ida_bytes.FF_N_STK (variable) -ida_bytes.FF_N_STRO (variable) -ida_bytes.FF_N_VOID (variable) -ida_bytes.FF_OWORD (variable) -ida_bytes.FF_PACKREAL (variable) -ida_bytes.FF_QWORD (variable) -ida_bytes.FF_REF (variable) -ida_bytes.FF_SIGN (variable) -ida_bytes.FF_STRLIT (variable) -ida_bytes.FF_STRUCT (variable) -ida_bytes.FF_TAIL (variable) -ida_bytes.FF_TBYTE (variable) -ida_bytes.FF_UNK (variable) -ida_bytes.FF_UNUSED (variable) -ida_bytes.FF_WORD (variable) -ida_bytes.FF_YWORD (variable) -ida_bytes.FF_ZWORD (variable) -ida_bytes.GFE_IDB_VALUE (variable) -ida_bytes.GFE_VALUE (variable) -ida_bytes.GMB_READALL (variable) -ida_bytes.GMB_WAITBOX (variable) -ida_bytes.ITEM_END_CANCEL (variable) -ida_bytes.ITEM_END_FIXUP (variable) -ida_bytes.ITEM_END_INITED (variable) -ida_bytes.ITEM_END_NAME (variable) -ida_bytes.ITEM_END_XREF (variable) -ida_bytes.MS_CLS (variable) -ida_bytes.MS_CODE (variable) -ida_bytes.MS_COMM (variable) -ida_bytes.MS_N_TYPE (variable) -ida_bytes.MS_VAL (variable) -ida_bytes.OPND_ALL (variable) -ida_bytes.OPND_MASK (variable) -ida_bytes.OPND_OUTER (variable) -ida_bytes.PSTF_ATTRIB (variable) -ida_bytes.PSTF_ENC (variable) -ida_bytes.PSTF_HOTKEY (variable) -ida_bytes.PSTF_ONLY_ENC (variable) -ida_bytes.PSTF_TBRIEF (variable) -ida_bytes.PSTF_TINLIN (variable) -ida_bytes.PSTF_TMASK (variable) -ida_bytes.PSTF_TNORM (variable) -ida_bytes.STRCONV_ESCAPE (variable) -ida_bytes.STRCONV_INCLLEN (variable) -ida_bytes.STRCONV_REPLCHAR (variable) -ida_bytes.__walk_types_and_formats (function) -ida_bytes.add_byte (function) -ida_bytes.add_dword (function) -ida_bytes.add_hidden_range (function) -ida_bytes.add_mapping (function) -ida_bytes.add_qword (function) -ida_bytes.add_word (function) -ida_bytes.align_flag (function) -ida_bytes.append_cmt (function) -ida_bytes.attach_custom_data_format (function) -ida_bytes.bin_flag (function) -ida_bytes.bin_search (function) -ida_bytes.bin_search3 (function) -ida_bytes.byte_flag (function) -ida_bytes.bytesize (function) -ida_bytes.calc_def_align (function) -ida_bytes.calc_dflags (function) -ida_bytes.calc_max_align (function) -ida_bytes.calc_max_item_end (function) -ida_bytes.calc_min_align (function) -ida_bytes.can_define_item (function) -ida_bytes.change_storage_type (function) -ida_bytes.char_flag (function) -ida_bytes.chunk_size (function) -ida_bytes.chunk_start (function) -ida_bytes.clr_lzero (function) -ida_bytes.clr_op_type (function) -ida_bytes.code_flag (function) -ida_bytes.combine_flags (function) -ida_bytes.compiled_binpat_t (class) -ida_bytes.compiled_binpat_t.__eq__ (method) -ida_bytes.compiled_binpat_t.__init__ (method) -ida_bytes.compiled_binpat_t.__ne__ (method) -ida_bytes.compiled_binpat_t.all_bytes_defined (method) -ida_bytes.compiled_binpat_t.qclear (method) -ida_bytes.compiled_binpat_vec_t (class) -ida_bytes.compiled_binpat_vec_t.__eq__ (method) -ida_bytes.compiled_binpat_vec_t.__getitem__ (method) -ida_bytes.compiled_binpat_vec_t.__init__ (method) -ida_bytes.compiled_binpat_vec_t.__len__ (method) -ida_bytes.compiled_binpat_vec_t.__ne__ (method) -ida_bytes.compiled_binpat_vec_t.__setitem__ (method) -ida_bytes.compiled_binpat_vec_t._del (method) -ida_bytes.compiled_binpat_vec_t.add_unique (method) -ida_bytes.compiled_binpat_vec_t.at (method) -ida_bytes.compiled_binpat_vec_t.begin (method) -ida_bytes.compiled_binpat_vec_t.capacity (method) -ida_bytes.compiled_binpat_vec_t.clear (method) -ida_bytes.compiled_binpat_vec_t.empty (method) -ida_bytes.compiled_binpat_vec_t.end (method) -ida_bytes.compiled_binpat_vec_t.erase (method) -ida_bytes.compiled_binpat_vec_t.extract (method) -ida_bytes.compiled_binpat_vec_t.find (method) -ida_bytes.compiled_binpat_vec_t.grow (method) -ida_bytes.compiled_binpat_vec_t.has (method) -ida_bytes.compiled_binpat_vec_t.inject (method) -ida_bytes.compiled_binpat_vec_t.insert (method) -ida_bytes.compiled_binpat_vec_t.pop_back (method) -ida_bytes.compiled_binpat_vec_t.push_back (method) -ida_bytes.compiled_binpat_vec_t.qclear (method) -ida_bytes.compiled_binpat_vec_t.reserve (method) -ida_bytes.compiled_binpat_vec_t.resize (method) -ida_bytes.compiled_binpat_vec_t.size (method) -ida_bytes.compiled_binpat_vec_t.swap (method) -ida_bytes.compiled_binpat_vec_t.truncate (method) -ida_bytes.create_16bit_data (function) -ida_bytes.create_32bit_data (function) -ida_bytes.create_align (function) -ida_bytes.create_byte (function) -ida_bytes.create_custdata (function) -ida_bytes.create_data (function) -ida_bytes.create_double (function) -ida_bytes.create_dword (function) -ida_bytes.create_float (function) -ida_bytes.create_oword (function) -ida_bytes.create_packed_real (function) -ida_bytes.create_qword (function) -ida_bytes.create_strlit (function) -ida_bytes.create_struct (function) -ida_bytes.create_tbyte (function) -ida_bytes.create_word (function) -ida_bytes.create_yword (function) -ida_bytes.create_zword (function) -ida_bytes.cust_flag (function) -ida_bytes.custfmt_flag (function) -ida_bytes.data_format_t (class) -ida_bytes.data_format_t.__get_id (method) -ida_bytes.data_format_t.__init__ (method) -ida_bytes.data_format_t.__init__ (method) -ida_bytes.data_format_t.hotkey (variable) -ida_bytes.data_format_t.is_present_in_menus (method) -ida_bytes.data_format_t.menu_name (variable) -ida_bytes.data_format_t.name (variable) -ida_bytes.data_format_t.props (variable) -ida_bytes.data_format_t.text_width (variable) -ida_bytes.data_format_t.value_size (variable) -ida_bytes.data_type_t (class) -ida_bytes.data_type_t.__get_id (method) -ida_bytes.data_type_t.__init__ (method) -ida_bytes.data_type_t.__init__ (method) -ida_bytes.data_type_t.asm_keyword (variable) -ida_bytes.data_type_t.hotkey (variable) -ida_bytes.data_type_t.is_present_in_menus (method) -ida_bytes.data_type_t.menu_name (variable) -ida_bytes.data_type_t.name (variable) -ida_bytes.data_type_t.props (variable) -ida_bytes.data_type_t.value_size (variable) -ida_bytes.dec_flag (function) -ida_bytes.del_hidden_range (function) -ida_bytes.del_items (function) -ida_bytes.del_mapping (function) -ida_bytes.del_value (function) -ida_bytes.detach_custom_data_format (function) -ida_bytes.disable_flags (function) -ida_bytes.double_flag (function) -ida_bytes.dword_flag (function) -ida_bytes.enable_flags (function) -ida_bytes.enum_flag (function) -ida_bytes.equal_bytes (function) -ida_bytes.f_has_cmt (function) -ida_bytes.f_has_dummy_name (function) -ida_bytes.f_has_extra_cmts (function) -ida_bytes.f_has_name (function) -ida_bytes.f_has_user_name (function) -ida_bytes.f_has_xref (function) -ida_bytes.f_is_align (function) -ida_bytes.f_is_byte (function) -ida_bytes.f_is_code (function) -ida_bytes.f_is_custom (function) -ida_bytes.f_is_data (function) -ida_bytes.f_is_double (function) -ida_bytes.f_is_dword (function) -ida_bytes.f_is_float (function) -ida_bytes.f_is_head (function) -ida_bytes.f_is_not_tail (function) -ida_bytes.f_is_oword (function) -ida_bytes.f_is_pack_real (function) -ida_bytes.f_is_qword (function) -ida_bytes.f_is_strlit (function) -ida_bytes.f_is_struct (function) -ida_bytes.f_is_tail (function) -ida_bytes.f_is_tbyte (function) -ida_bytes.f_is_word (function) -ida_bytes.f_is_yword (function) -ida_bytes.find_byte (function) -ida_bytes.find_byter (function) -ida_bytes.find_custom_data_format (function) -ida_bytes.find_custom_data_type (function) -ida_bytes.find_free_chunk (function) -ida_bytes.float_flag (function) -ida_bytes.flt_flag (function) -ida_bytes.free_chunk (function) -ida_bytes.get_16bit (function) -ida_bytes.get_32bit (function) -ida_bytes.get_64bit (function) -ida_bytes.get_8bit (function) -ida_bytes.get_byte (function) -ida_bytes.get_bytes (function) -ida_bytes.get_bytes_and_mask (function) -ida_bytes.get_cmt (function) -ida_bytes.get_custom_data_format (function) -ida_bytes.get_custom_data_formats (function) -ida_bytes.get_custom_data_type (function) -ida_bytes.get_custom_data_types (function) -ida_bytes.get_data_elsize (function) -ida_bytes.get_data_value (function) -ida_bytes.get_db_byte (function) -ida_bytes.get_default_radix (function) -ida_bytes.get_dword (function) -ida_bytes.get_enum_id (function) -ida_bytes.get_first_hidden_range (function) -ida_bytes.get_flags (function) -ida_bytes.get_flags_by_size (function) -ida_bytes.get_flags_ex (function) -ida_bytes.get_forced_operand (function) -ida_bytes.get_full_data_elsize (function) -ida_bytes.get_full_flags (function) -ida_bytes.get_hidden_range (function) -ida_bytes.get_hidden_range_num (function) -ida_bytes.get_hidden_range_qty (function) -ida_bytes.get_item_end (function) -ida_bytes.get_item_flag (function) -ida_bytes.get_item_head (function) -ida_bytes.get_item_refinfo (function) -ida_bytes.get_item_size (function) -ida_bytes.get_last_hidden_range (function) -ida_bytes.get_manual_insn (function) -ida_bytes.get_mapping (function) -ida_bytes.get_mappings_qty (function) -ida_bytes.get_max_strlit_length (function) -ida_bytes.get_next_hidden_range (function) -ida_bytes.get_octet (function) -ida_bytes.get_octet2 (function) -ida_bytes.get_operand_flag (function) -ida_bytes.get_operand_type_shift (function) -ida_bytes.get_opinfo (function) -ida_bytes.get_optype_flags0 (function) -ida_bytes.get_optype_flags1 (function) -ida_bytes.get_original_byte (function) -ida_bytes.get_original_dword (function) -ida_bytes.get_original_qword (function) -ida_bytes.get_original_word (function) -ida_bytes.get_possible_item_varsize (function) -ida_bytes.get_predef_insn_cmt (function) -ida_bytes.get_prev_hidden_range (function) -ida_bytes.get_qword (function) -ida_bytes.get_radix (function) -ida_bytes.get_strlit_contents (function) -ida_bytes.get_stroff_path (function) -ida_bytes.get_wide_byte (function) -ida_bytes.get_wide_dword (function) -ida_bytes.get_wide_word (function) -ida_bytes.get_word (function) -ida_bytes.get_zero_ranges (function) -ida_bytes.getn_hidden_range (function) -ida_bytes.has_any_name (function) -ida_bytes.has_auto_name (function) -ida_bytes.has_cmt (function) -ida_bytes.has_dummy_name (function) -ida_bytes.has_extra_cmts (function) -ida_bytes.has_immd (function) -ida_bytes.has_name (function) -ida_bytes.has_user_name (function) -ida_bytes.has_value (function) -ida_bytes.has_xref (function) -ida_bytes.hex_flag (function) -ida_bytes.hidden_range_t (class) -ida_bytes.hidden_range_t.__init__ (method) -ida_bytes.hidden_range_t.color (variable) -ida_bytes.hidden_range_t.description (variable) -ida_bytes.hidden_range_t.footer (variable) -ida_bytes.hidden_range_t.header (variable) -ida_bytes.hidden_range_t.visible (variable) -ida_bytes.is_align (function) -ida_bytes.is_attached_custom_data_format (function) -ida_bytes.is_bnot (function) -ida_bytes.is_byte (function) -ida_bytes.is_char (function) -ida_bytes.is_char0 (function) -ida_bytes.is_char1 (function) -ida_bytes.is_code (function) -ida_bytes.is_custfmt (function) -ida_bytes.is_custfmt0 (function) -ida_bytes.is_custfmt1 (function) -ida_bytes.is_custom (function) -ida_bytes.is_data (function) -ida_bytes.is_defarg (function) -ida_bytes.is_defarg0 (function) -ida_bytes.is_defarg1 (function) -ida_bytes.is_double (function) -ida_bytes.is_dword (function) -ida_bytes.is_enum (function) -ida_bytes.is_enum0 (function) -ida_bytes.is_enum1 (function) -ida_bytes.is_flag_for_operand (function) -ida_bytes.is_float (function) -ida_bytes.is_float0 (function) -ida_bytes.is_float1 (function) -ida_bytes.is_flow (function) -ida_bytes.is_fltnum (function) -ida_bytes.is_forced_operand (function) -ida_bytes.is_func (function) -ida_bytes.is_head (function) -ida_bytes.is_invsign (function) -ida_bytes.is_loaded (function) -ida_bytes.is_lzero (function) -ida_bytes.is_manual (function) -ida_bytes.is_manual_insn (function) -ida_bytes.is_mapped (function) -ida_bytes.is_not_tail (function) -ida_bytes.is_numop (function) -ida_bytes.is_numop0 (function) -ida_bytes.is_numop1 (function) -ida_bytes.is_off (function) -ida_bytes.is_off0 (function) -ida_bytes.is_off1 (function) -ida_bytes.is_oword (function) -ida_bytes.is_pack_real (function) -ida_bytes.is_qword (function) -ida_bytes.is_same_data_type (function) -ida_bytes.is_seg (function) -ida_bytes.is_seg0 (function) -ida_bytes.is_seg1 (function) -ida_bytes.is_stkvar (function) -ida_bytes.is_stkvar0 (function) -ida_bytes.is_stkvar1 (function) -ida_bytes.is_strlit (function) -ida_bytes.is_stroff (function) -ida_bytes.is_stroff0 (function) -ida_bytes.is_stroff1 (function) -ida_bytes.is_struct (function) -ida_bytes.is_suspop (function) -ida_bytes.is_tail (function) -ida_bytes.is_tbyte (function) -ida_bytes.is_unknown (function) -ida_bytes.is_varsize_item (function) -ida_bytes.is_word (function) -ida_bytes.is_yword (function) -ida_bytes.is_zword (function) -ida_bytes.leading_zero_important (function) -ida_bytes.nbits (function) -ida_bytes.next_addr (function) -ida_bytes.next_chunk (function) -ida_bytes.next_head (function) -ida_bytes.next_inited (function) -ida_bytes.next_not_tail (function) -ida_bytes.next_that (function) -ida_bytes.next_unknown (function) -ida_bytes.next_visea (function) -ida_bytes.num_flag (function) -ida_bytes.oct_flag (function) -ida_bytes.octet_generator_t (class) -ida_bytes.octet_generator_t.__init__ (method) -ida_bytes.octet_generator_t.invert_byte_order (method) -ida_bytes.off_flag (function) -ida_bytes.op_adds_xrefs (function) -ida_bytes.op_based_stroff (function) -ida_bytes.op_bin (function) -ida_bytes.op_chr (function) -ida_bytes.op_custfmt (function) -ida_bytes.op_dec (function) -ida_bytes.op_enum (function) -ida_bytes.op_flt (function) -ida_bytes.op_hex (function) -ida_bytes.op_num (function) -ida_bytes.op_oct (function) -ida_bytes.op_seg (function) -ida_bytes.op_stkvar (function) -ida_bytes.op_stroff (function) -ida_bytes.oword_flag (function) -ida_bytes.packreal_flag (function) -ida_bytes.parse_binpat_str (function) -ida_bytes.patch_byte (function) -ida_bytes.patch_bytes (function) -ida_bytes.patch_dword (function) -ida_bytes.patch_qword (function) -ida_bytes.patch_word (function) -ida_bytes.prev_addr (function) -ida_bytes.prev_chunk (function) -ida_bytes.prev_head (function) -ida_bytes.prev_inited (function) -ida_bytes.prev_not_tail (function) -ida_bytes.prev_that (function) -ida_bytes.prev_unknown (function) -ida_bytes.prev_visea (function) -ida_bytes.print_strlit_type (function) -ida_bytes.put_byte (function) -ida_bytes.put_bytes (function) -ida_bytes.put_dword (function) -ida_bytes.put_qword (function) -ida_bytes.put_word (function) -ida_bytes.qword_flag (function) -ida_bytes.register_custom_data_format (function) -ida_bytes.register_custom_data_type (function) -ida_bytes.register_data_types_and_formats (function) -ida_bytes.register_data_types_and_formats.__reg_format (function) -ida_bytes.register_data_types_and_formats.__reg_type (function) -ida_bytes.revert_byte (function) -ida_bytes.seg_flag (function) -ida_bytes.set_cmt (function) -ida_bytes.set_forced_operand (function) -ida_bytes.set_immd (function) -ida_bytes.set_lzero (function) -ida_bytes.set_manual_insn (function) -ida_bytes.set_op_type (function) -ida_bytes.set_opinfo (function) -ida_bytes.stkvar_flag (function) -ida_bytes.strlit_flag (function) -ida_bytes.stroff_flag (function) -ida_bytes.stru_flag (function) -ida_bytes.tbyte_flag (function) -ida_bytes.toggle_bnot (function) -ida_bytes.toggle_lzero (function) -ida_bytes.toggle_sign (function) -ida_bytes.unregister_custom_data_format (function) -ida_bytes.unregister_custom_data_type (function) -ida_bytes.unregister_data_types_and_formats (function) -ida_bytes.unregister_data_types_and_formats.__unreg_format (function) -ida_bytes.unregister_data_types_and_formats.__unreg_type (function) -ida_bytes.update_hidden_range (function) -ida_bytes.use_mapping (function) -ida_bytes.visit_patched_bytes (function) -ida_bytes.word_flag (function) -ida_bytes.yword_flag (function) -ida_bytes.zword_flag (function) -ida_dbg (module) -ida_dbg.BKPT_ACTIVE (variable) -ida_dbg.BKPT_BADBPT (variable) -ida_dbg.BKPT_CNDREADY (variable) -ida_dbg.BKPT_FAKEPEND (variable) -ida_dbg.BKPT_LISTBPT (variable) -ida_dbg.BKPT_PAGE (variable) -ida_dbg.BKPT_PARTIAL (variable) -ida_dbg.BKPT_TRACE (variable) -ida_dbg.BPLT_ABS (variable) -ida_dbg.BPLT_REL (variable) -ida_dbg.BPLT_SRC (variable) -ida_dbg.BPTCK_ACT (variable) -ida_dbg.BPTCK_NO (variable) -ida_dbg.BPTCK_NONE (variable) -ida_dbg.BPTCK_YES (variable) -ida_dbg.BPTEV_ADDED (variable) -ida_dbg.BPTEV_CHANGED (variable) -ida_dbg.BPTEV_REMOVED (variable) -ida_dbg.BPT_BRK (variable) -ida_dbg.BPT_ELANG_SHIFT (variable) -ida_dbg.BPT_ENABLED (variable) -ida_dbg.BPT_LOWCND (variable) -ida_dbg.BPT_TRACE (variable) -ida_dbg.BPT_TRACEON (variable) -ida_dbg.BPT_TRACE_BBLK (variable) -ida_dbg.BPT_TRACE_FUNC (variable) -ida_dbg.BPT_TRACE_INSN (variable) -ida_dbg.BPT_TRACE_TYPES (variable) -ida_dbg.BPT_UPDMEM (variable) -ida_dbg.BT_LOG_INSTS (variable) -ida_dbg.DBGINV_ALL (variable) -ida_dbg.DBGINV_MEMCFG (variable) -ida_dbg.DBGINV_MEMORY (variable) -ida_dbg.DBGINV_NONE (variable) -ida_dbg.DBGINV_REDRAW (variable) -ida_dbg.DBGINV_REGS (variable) -ida_dbg.DBG_Hooks (class) -ida_dbg.DBG_Hooks.__disown__ (method) -ida_dbg.DBG_Hooks.__init__ (method) -ida_dbg.DBG_Hooks.dbg_bpt (method) -ida_dbg.DBG_Hooks.dbg_bpt_changed (method) -ida_dbg.DBG_Hooks.dbg_exception (method) -ida_dbg.DBG_Hooks.dbg_finished_loading_bpts (method) -ida_dbg.DBG_Hooks.dbg_information (method) -ida_dbg.DBG_Hooks.dbg_library_load (method) -ida_dbg.DBG_Hooks.dbg_library_unload (method) -ida_dbg.DBG_Hooks.dbg_process_attach (method) -ida_dbg.DBG_Hooks.dbg_process_detach (method) -ida_dbg.DBG_Hooks.dbg_process_exit (method) -ida_dbg.DBG_Hooks.dbg_process_start (method) -ida_dbg.DBG_Hooks.dbg_request_error (method) -ida_dbg.DBG_Hooks.dbg_run_to (method) -ida_dbg.DBG_Hooks.dbg_started_loading_bpts (method) -ida_dbg.DBG_Hooks.dbg_step_into (method) -ida_dbg.DBG_Hooks.dbg_step_over (method) -ida_dbg.DBG_Hooks.dbg_step_until_ret (method) -ida_dbg.DBG_Hooks.dbg_suspend_process (method) -ida_dbg.DBG_Hooks.dbg_thread_exit (method) -ida_dbg.DBG_Hooks.dbg_thread_start (method) -ida_dbg.DBG_Hooks.dbg_trace (method) -ida_dbg.DBG_Hooks.hook (method) -ida_dbg.DBG_Hooks.unhook (method) -ida_dbg.DEC_ERROR (variable) -ida_dbg.DEC_NOTASK (variable) -ida_dbg.DEC_TIMEOUT (variable) -ida_dbg.DOPT_BPT_MSGS (variable) -ida_dbg.DOPT_DISABLE_ASLR (variable) -ida_dbg.DOPT_END_BPT (variable) -ida_dbg.DOPT_ENTRY_BPT (variable) -ida_dbg.DOPT_EXCDLG (variable) -ida_dbg.DOPT_FAST_STEP (variable) -ida_dbg.DOPT_INFO_BPT (variable) -ida_dbg.DOPT_INFO_MSGS (variable) -ida_dbg.DOPT_LIB_BPT (variable) -ida_dbg.DOPT_LIB_MSGS (variable) -ida_dbg.DOPT_LOAD_DINFO (variable) -ida_dbg.DOPT_REAL_MEMORY (variable) -ida_dbg.DOPT_REDO_STACK (variable) -ida_dbg.DOPT_SEGM_MSGS (variable) -ida_dbg.DOPT_START_BPT (variable) -ida_dbg.DOPT_TEMP_HWBPT (variable) -ida_dbg.DOPT_THREAD_BPT (variable) -ida_dbg.DOPT_THREAD_MSGS (variable) -ida_dbg.DSTATE_NOTASK (variable) -ida_dbg.DSTATE_RUN (variable) -ida_dbg.DSTATE_SUSP (variable) -ida_dbg.EXCDLG_ALWAYS (variable) -ida_dbg.EXCDLG_NEVER (variable) -ida_dbg.EXCDLG_UNKNOWN (variable) -ida_dbg.FT_LOG_RET (variable) -ida_dbg.IT_LOG_SAME_IP (variable) -ida_dbg.SRCIT_EXPR (variable) -ida_dbg.SRCIT_FUNC (variable) -ida_dbg.SRCIT_LOCVAR (variable) -ida_dbg.SRCIT_MODULE (variable) -ida_dbg.SRCIT_NONE (variable) -ida_dbg.SRCIT_STMT (variable) -ida_dbg.SRCIT_STTVAR (variable) -ida_dbg.ST_ALREADY_LOGGED (variable) -ida_dbg.ST_OPTIONS_MASK (variable) -ida_dbg.ST_OVER_DEBUG_SEG (variable) -ida_dbg.ST_OVER_LIB_FUNC (variable) -ida_dbg.ST_SKIP_LOOPS (variable) -ida_dbg.WFNE_ANY (variable) -ida_dbg.WFNE_CONT (variable) -ida_dbg.WFNE_NOWAIT (variable) -ida_dbg.WFNE_SILENT (variable) -ida_dbg.WFNE_SUSP (variable) -ida_dbg.WFNE_USEC (variable) -ida_dbg.add_bpt (function) -ida_dbg.add_path_mapping (function) -ida_dbg.add_virt_module (function) -ida_dbg.attach_process (function) -ida_dbg.bpt_location_t (class) -ida_dbg.bpt_location_t.__eq__ (method) -ida_dbg.bpt_location_t.__ge__ (method) -ida_dbg.bpt_location_t.__gt__ (method) -ida_dbg.bpt_location_t.__init__ (method) -ida_dbg.bpt_location_t.__le__ (method) -ida_dbg.bpt_location_t.__lt__ (method) -ida_dbg.bpt_location_t.__ne__ (method) -ida_dbg.bpt_location_t.compare (method) -ida_dbg.bpt_location_t.ea (method) -ida_dbg.bpt_location_t.is_empty_path (method) -ida_dbg.bpt_location_t.lineno (method) -ida_dbg.bpt_location_t.offset (method) -ida_dbg.bpt_location_t.path (method) -ida_dbg.bpt_location_t.set_abs_bpt (method) -ida_dbg.bpt_location_t.set_rel_bpt (method) -ida_dbg.bpt_location_t.set_src_bpt (method) -ida_dbg.bpt_location_t.set_sym_bpt (method) -ida_dbg.bpt_location_t.symbol (method) -ida_dbg.bpt_location_t.type (method) -ida_dbg.bpt_t (class) -ida_dbg.bpt_t.__init__ (method) -ida_dbg.bpt_t.badbpt (method) -ida_dbg.bpt_t.bptid (variable) -ida_dbg.bpt_t.cb (variable) -ida_dbg.bpt_t.cndidx (variable) -ida_dbg.bpt_t.ea (variable) -ida_dbg.bpt_t.enabled (method) -ida_dbg.bpt_t.flags (variable) -ida_dbg.bpt_t.get_cnd_elang_idx (method) -ida_dbg.bpt_t.get_size (method) -ida_dbg.bpt_t.is_absbpt (method) -ida_dbg.bpt_t.is_active (method) -ida_dbg.bpt_t.is_compiled (method) -ida_dbg.bpt_t.is_hwbpt (method) -ida_dbg.bpt_t.is_inactive (method) -ida_dbg.bpt_t.is_low_level (method) -ida_dbg.bpt_t.is_page_bpt (method) -ida_dbg.bpt_t.is_partially_active (method) -ida_dbg.bpt_t.is_relbpt (method) -ida_dbg.bpt_t.is_srcbpt (method) -ida_dbg.bpt_t.is_symbpt (method) -ida_dbg.bpt_t.is_tracemodebpt (method) -ida_dbg.bpt_t.is_traceoffbpt (method) -ida_dbg.bpt_t.is_traceonbpt (method) -ida_dbg.bpt_t.listbpt (method) -ida_dbg.bpt_t.loc (variable) -ida_dbg.bpt_t.pass_count (variable) -ida_dbg.bpt_t.pid (variable) -ida_dbg.bpt_t.props (variable) -ida_dbg.bpt_t.set_abs_bpt (method) -ida_dbg.bpt_t.set_rel_bpt (method) -ida_dbg.bpt_t.set_src_bpt (method) -ida_dbg.bpt_t.set_sym_bpt (method) -ida_dbg.bpt_t.set_trace_action (method) -ida_dbg.bpt_t.size (variable) -ida_dbg.bpt_t.tid (variable) -ida_dbg.bpt_t.type (variable) -ida_dbg.bpt_vec_t (class) -ida_dbg.bpt_vec_t.__getitem__ (method) -ida_dbg.bpt_vec_t.__init__ (method) -ida_dbg.bpt_vec_t.__len__ (method) -ida_dbg.bpt_vec_t.__setitem__ (method) -ida_dbg.bpt_vec_t.at (method) -ida_dbg.bpt_vec_t.begin (method) -ida_dbg.bpt_vec_t.capacity (method) -ida_dbg.bpt_vec_t.clear (method) -ida_dbg.bpt_vec_t.empty (method) -ida_dbg.bpt_vec_t.end (method) -ida_dbg.bpt_vec_t.erase (method) -ida_dbg.bpt_vec_t.extract (method) -ida_dbg.bpt_vec_t.grow (method) -ida_dbg.bpt_vec_t.inject (method) -ida_dbg.bpt_vec_t.insert (method) -ida_dbg.bpt_vec_t.pop_back (method) -ida_dbg.bpt_vec_t.push_back (method) -ida_dbg.bpt_vec_t.qclear (method) -ida_dbg.bpt_vec_t.reserve (method) -ida_dbg.bpt_vec_t.resize (method) -ida_dbg.bpt_vec_t.size (method) -ida_dbg.bpt_vec_t.swap (method) -ida_dbg.bpt_vec_t.truncate (method) -ida_dbg.bptaddrs_t (class) -ida_dbg.bptaddrs_t.__init__ (method) -ida_dbg.bring_debugger_to_front (function) -ida_dbg.check_bpt (function) -ida_dbg.choose_trace_file (function) -ida_dbg.clear_requests_queue (function) -ida_dbg.clear_trace (function) -ida_dbg.collect_stack_trace (function) -ida_dbg.continue_process (function) -ida_dbg.create_source_viewer (function) -ida_dbg.dbg_add_bpt_tev (function) -ida_dbg.dbg_add_call_tev (function) -ida_dbg.dbg_add_debug_event (function) -ida_dbg.dbg_add_insn_tev (function) -ida_dbg.dbg_add_many_tevs (function) -ida_dbg.dbg_add_ret_tev (function) -ida_dbg.dbg_add_tev (function) -ida_dbg.dbg_add_thread (function) -ida_dbg.dbg_bin_search (function) -ida_dbg.dbg_bpt (variable) -ida_dbg.dbg_bpt_changed (variable) -ida_dbg.dbg_can_query (function) -ida_dbg.dbg_del_thread (function) -ida_dbg.dbg_finished_loading_bpts (variable) -ida_dbg.dbg_is_loaded (function) -ida_dbg.dbg_last (variable) -ida_dbg.dbg_process_attach (variable) -ida_dbg.dbg_process_detach (variable) -ida_dbg.dbg_process_exit (variable) -ida_dbg.dbg_process_start (variable) -ida_dbg.dbg_request_error (variable) -ida_dbg.dbg_started_loading_bpts (variable) -ida_dbg.dbg_suspend_process (variable) -ida_dbg.dbg_trace (variable) -ida_dbg.define_exception (function) -ida_dbg.del_bpt (function) -ida_dbg.del_bptgrp (function) -ida_dbg.del_virt_module (function) -ida_dbg.detach_process (function) -ida_dbg.diff_trace_file (function) -ida_dbg.disable_bblk_trace (function) -ida_dbg.disable_bpt (function) -ida_dbg.disable_func_trace (function) -ida_dbg.disable_insn_trace (function) -ida_dbg.disable_step_trace (function) -ida_dbg.edit_manual_regions (function) -ida_dbg.enable_bblk_trace (function) -ida_dbg.enable_bpt (function) -ida_dbg.enable_bptgrp (function) -ida_dbg.enable_func_trace (function) -ida_dbg.enable_insn_trace (function) -ida_dbg.enable_manual_regions (function) -ida_dbg.enable_step_trace (function) -ida_dbg.eval_ctx_t (class) -ida_dbg.eval_ctx_t.__init__ (method) -ida_dbg.exist_bpt (function) -ida_dbg.exit_process (function) -ida_dbg.find_bpt (function) -ida_dbg.get_bblk_trace_options (function) -ida_dbg.get_bpt (function) -ida_dbg.get_bpt_group (function) -ida_dbg.get_bpt_qty (function) -ida_dbg.get_bpt_tev_ea (function) -ida_dbg.get_bptloc_string (function) -ida_dbg.get_call_tev_callee (function) -ida_dbg.get_current_source_file (function) -ida_dbg.get_current_source_line (function) -ida_dbg.get_current_thread (function) -ida_dbg.get_dbg_byte (function) -ida_dbg.get_dbg_memory_info (function) -ida_dbg.get_dbg_reg_info (function) -ida_dbg.get_debug_event (function) -ida_dbg.get_debugger_event_cond (function) -ida_dbg.get_first_module (function) -ida_dbg.get_func_trace_options (function) -ida_dbg.get_global_var (function) -ida_dbg.get_grp_bpts (function) -ida_dbg.get_insn_tev_reg_mem (function) -ida_dbg.get_insn_tev_reg_result (function) -ida_dbg.get_insn_tev_reg_val (function) -ida_dbg.get_insn_trace_options (function) -ida_dbg.get_ip_val (function) -ida_dbg.get_local_var (function) -ida_dbg.get_local_vars (function) -ida_dbg.get_manual_regions (function) -ida_dbg.get_module_info (function) -ida_dbg.get_next_module (function) -ida_dbg.get_process_options (function) -ida_dbg.get_process_state (function) -ida_dbg.get_processes (function) -ida_dbg.get_reg_val (function) -ida_dbg.get_reg_vals (function) -ida_dbg.get_ret_tev_return (function) -ida_dbg.get_running_notification (function) -ida_dbg.get_running_request (function) -ida_dbg.get_sp_val (function) -ida_dbg.get_srcinfo_provider (function) -ida_dbg.get_step_trace_options (function) -ida_dbg.get_tev_ea (function) -ida_dbg.get_tev_event (function) -ida_dbg.get_tev_info (function) -ida_dbg.get_tev_memory_info (function) -ida_dbg.get_tev_qty (function) -ida_dbg.get_tev_reg_mem (function) -ida_dbg.get_tev_reg_mem_ea (function) -ida_dbg.get_tev_reg_mem_qty (function) -ida_dbg.get_tev_reg_val (function) -ida_dbg.get_tev_tid (function) -ida_dbg.get_tev_type (function) -ida_dbg.get_thread_qty (function) -ida_dbg.get_trace_base_address (function) -ida_dbg.get_trace_dynamic_register_set (function) -ida_dbg.get_trace_file_desc (function) -ida_dbg.get_trace_platform (function) -ida_dbg.getn_bpt (function) -ida_dbg.getn_thread (function) -ida_dbg.getn_thread_name (function) -ida_dbg.graph_trace (function) -ida_dbg.handle_debug_event (function) -ida_dbg.hide_all_bpts (function) -ida_dbg.internal_get_sreg_base (function) -ida_dbg.internal_ioctl (function) -ida_dbg.invalidate_dbg_state (function) -ida_dbg.invalidate_dbgmem_config (function) -ida_dbg.invalidate_dbgmem_contents (function) -ida_dbg.is_bblk_trace_enabled (function) -ida_dbg.is_debugger_busy (function) -ida_dbg.is_debugger_memory (function) -ida_dbg.is_debugger_on (function) -ida_dbg.is_func_trace_enabled (function) -ida_dbg.is_insn_trace_enabled (function) -ida_dbg.is_reg_custom (function) -ida_dbg.is_reg_float (function) -ida_dbg.is_reg_integer (function) -ida_dbg.is_request_running (function) -ida_dbg.is_step_trace_enabled (function) -ida_dbg.is_valid_dstate (function) -ida_dbg.is_valid_trace_file (function) -ida_dbg.list_bptgrps (function) -ida_dbg.load_debugger (function) -ida_dbg.load_trace_file (function) -ida_dbg.memreg_info_t (class) -ida_dbg.memreg_info_t.__init__ (method) -ida_dbg.memreg_info_t.get_bytes (method) -ida_dbg.memreg_infos_t (class) -ida_dbg.memreg_infos_t.__getitem__ (method) -ida_dbg.memreg_infos_t.__init__ (method) -ida_dbg.memreg_infos_t.__len__ (method) -ida_dbg.memreg_infos_t.__setitem__ (method) -ida_dbg.memreg_infos_t.at (method) -ida_dbg.memreg_infos_t.begin (method) -ida_dbg.memreg_infos_t.capacity (method) -ida_dbg.memreg_infos_t.clear (method) -ida_dbg.memreg_infos_t.empty (method) -ida_dbg.memreg_infos_t.end (method) -ida_dbg.memreg_infos_t.erase (method) -ida_dbg.memreg_infos_t.extract (method) -ida_dbg.memreg_infos_t.grow (method) -ida_dbg.memreg_infos_t.inject (method) -ida_dbg.memreg_infos_t.insert (method) -ida_dbg.memreg_infos_t.pop_back (method) -ida_dbg.memreg_infos_t.push_back (method) -ida_dbg.memreg_infos_t.qclear (method) -ida_dbg.memreg_infos_t.reserve (method) -ida_dbg.memreg_infos_t.resize (method) -ida_dbg.memreg_infos_t.size (method) -ida_dbg.memreg_infos_t.swap (method) -ida_dbg.memreg_infos_t.truncate (method) -ida_dbg.put_dbg_byte (function) -ida_dbg.read_dbg_memory (function) -ida_dbg.refresh_debugger_memory (function) -ida_dbg.rename_bptgrp (function) -ida_dbg.request_add_bpt (function) -ida_dbg.request_attach_process (function) -ida_dbg.request_clear_trace (function) -ida_dbg.request_continue_process (function) -ida_dbg.request_del_bpt (function) -ida_dbg.request_detach_process (function) -ida_dbg.request_disable_bblk_trace (function) -ida_dbg.request_disable_bpt (function) -ida_dbg.request_disable_func_trace (function) -ida_dbg.request_disable_insn_trace (function) -ida_dbg.request_disable_step_trace (function) -ida_dbg.request_enable_bblk_trace (function) -ida_dbg.request_enable_bpt (function) -ida_dbg.request_enable_func_trace (function) -ida_dbg.request_enable_insn_trace (function) -ida_dbg.request_enable_step_trace (function) -ida_dbg.request_exit_process (function) -ida_dbg.request_resume_thread (function) -ida_dbg.request_run_to (function) -ida_dbg.request_select_thread (function) -ida_dbg.request_set_bblk_trace_options (function) -ida_dbg.request_set_func_trace_options (function) -ida_dbg.request_set_insn_trace_options (function) -ida_dbg.request_set_reg_val (function) -ida_dbg.request_set_resume_mode (function) -ida_dbg.request_set_step_trace_options (function) -ida_dbg.request_start_process (function) -ida_dbg.request_step_into (function) -ida_dbg.request_step_over (function) -ida_dbg.request_step_until_ret (function) -ida_dbg.request_suspend_process (function) -ida_dbg.request_suspend_thread (function) -ida_dbg.resume_thread (function) -ida_dbg.retrieve_exceptions (function) -ida_dbg.run_requests (function) -ida_dbg.run_to (function) -ida_dbg.save_trace_file (function) -ida_dbg.select_thread (function) -ida_dbg.send_dbg_command (function) -ida_dbg.set_bblk_trace_options (function) -ida_dbg.set_bpt_group (function) -ida_dbg.set_bptloc_group (function) -ida_dbg.set_bptloc_string (function) -ida_dbg.set_debugger_event_cond (function) -ida_dbg.set_debugger_options (function) -ida_dbg.set_func_trace_options (function) -ida_dbg.set_highlight_trace_options (function) -ida_dbg.set_insn_trace_options (function) -ida_dbg.set_manual_regions (function) -ida_dbg.set_process_options (function) -ida_dbg.set_process_state (function) -ida_dbg.set_reg_val (function) -ida_dbg.set_remote_debugger (function) -ida_dbg.set_resume_mode (function) -ida_dbg.set_step_trace_options (function) -ida_dbg.set_trace_base_address (function) -ida_dbg.set_trace_dynamic_register_set (function) -ida_dbg.set_trace_file_desc (function) -ida_dbg.set_trace_platform (function) -ida_dbg.set_trace_size (function) -ida_dbg.srcdbg_request_step_into (function) -ida_dbg.srcdbg_request_step_over (function) -ida_dbg.srcdbg_request_step_until_ret (function) -ida_dbg.srcdbg_step_into (function) -ida_dbg.srcdbg_step_over (function) -ida_dbg.srcdbg_step_until_ret (function) -ida_dbg.start_process (function) -ida_dbg.step_into (function) -ida_dbg.step_over (function) -ida_dbg.step_until_ret (function) -ida_dbg.store_exceptions (function) -ida_dbg.suspend_process (function) -ida_dbg.suspend_thread (function) -ida_dbg.tev_bpt (variable) -ida_dbg.tev_call (variable) -ida_dbg.tev_event (variable) -ida_dbg.tev_info_reg_t (class) -ida_dbg.tev_info_reg_t.__init__ (method) -ida_dbg.tev_info_t (class) -ida_dbg.tev_info_t.__init__ (method) -ida_dbg.tev_info_t.ea (variable) -ida_dbg.tev_info_t.tid (variable) -ida_dbg.tev_info_t.type (variable) -ida_dbg.tev_insn (variable) -ida_dbg.tev_max (variable) -ida_dbg.tev_mem (variable) -ida_dbg.tev_none (variable) -ida_dbg.tev_reg_value_t (class) -ida_dbg.tev_reg_value_t.__init__ (method) -ida_dbg.tev_reg_values_t (class) -ida_dbg.tev_reg_values_t.__getitem__ (method) -ida_dbg.tev_reg_values_t.__init__ (method) -ida_dbg.tev_reg_values_t.__len__ (method) -ida_dbg.tev_reg_values_t.__setitem__ (method) -ida_dbg.tev_reg_values_t.at (method) -ida_dbg.tev_reg_values_t.begin (method) -ida_dbg.tev_reg_values_t.capacity (method) -ida_dbg.tev_reg_values_t.clear (method) -ida_dbg.tev_reg_values_t.empty (method) -ida_dbg.tev_reg_values_t.end (method) -ida_dbg.tev_reg_values_t.erase (method) -ida_dbg.tev_reg_values_t.extract (method) -ida_dbg.tev_reg_values_t.grow (method) -ida_dbg.tev_reg_values_t.inject (method) -ida_dbg.tev_reg_values_t.insert (method) -ida_dbg.tev_reg_values_t.pop_back (method) -ida_dbg.tev_reg_values_t.push_back (method) -ida_dbg.tev_reg_values_t.qclear (method) -ida_dbg.tev_reg_values_t.reserve (method) -ida_dbg.tev_reg_values_t.resize (method) -ida_dbg.tev_reg_values_t.size (method) -ida_dbg.tev_reg_values_t.swap (method) -ida_dbg.tev_reg_values_t.truncate (method) -ida_dbg.tev_ret (variable) -ida_dbg.tevinforeg_vec_t (class) -ida_dbg.tevinforeg_vec_t.__getitem__ (method) -ida_dbg.tevinforeg_vec_t.__init__ (method) -ida_dbg.tevinforeg_vec_t.__len__ (method) -ida_dbg.tevinforeg_vec_t.__setitem__ (method) -ida_dbg.tevinforeg_vec_t.at (method) -ida_dbg.tevinforeg_vec_t.begin (method) -ida_dbg.tevinforeg_vec_t.capacity (method) -ida_dbg.tevinforeg_vec_t.clear (method) -ida_dbg.tevinforeg_vec_t.empty (method) -ida_dbg.tevinforeg_vec_t.end (method) -ida_dbg.tevinforeg_vec_t.erase (method) -ida_dbg.tevinforeg_vec_t.extract (method) -ida_dbg.tevinforeg_vec_t.grow (method) -ida_dbg.tevinforeg_vec_t.inject (method) -ida_dbg.tevinforeg_vec_t.insert (method) -ida_dbg.tevinforeg_vec_t.pop_back (method) -ida_dbg.tevinforeg_vec_t.push_back (method) -ida_dbg.tevinforeg_vec_t.qclear (method) -ida_dbg.tevinforeg_vec_t.reserve (method) -ida_dbg.tevinforeg_vec_t.resize (method) -ida_dbg.tevinforeg_vec_t.size (method) -ida_dbg.tevinforeg_vec_t.swap (method) -ida_dbg.tevinforeg_vec_t.truncate (method) -ida_dbg.update_bpt (function) -ida_dbg.wait_for_next_event (function) -ida_dbg.write_dbg_memory (function) -ida_diskio (module) -ida_diskio.IDA_SUBDIR_IDADIR_FIRST (variable) -ida_diskio.IDA_SUBDIR_IDP (variable) -ida_diskio.IDA_SUBDIR_ONLY_EXISTING (variable) -ida_diskio.LINPUT_GENERIC (variable) -ida_diskio.LINPUT_LOCAL (variable) -ida_diskio.LINPUT_NONE (variable) -ida_diskio.LINPUT_PROCMEM (variable) -ida_diskio.LINPUT_RFILE (variable) -ida_diskio.choose_ioport_device2 (function) -ida_diskio.choose_ioport_parser_t (class) -ida_diskio.choose_ioport_parser_t.__disown__ (method) -ida_diskio.choose_ioport_parser_t.__init__ (method) -ida_diskio.choose_ioport_parser_t.parse (method) -ida_diskio.close_linput (function) -ida_diskio.create_bytearray_linput (function) -ida_diskio.create_generic_linput (function) -ida_diskio.create_memory_linput (function) -ida_diskio.eclose (function) -ida_diskio.enumerate_files (function) -ida_diskio.enumerate_files2 (function) -ida_diskio.file_enumerator_t (class) -ida_diskio.file_enumerator_t.__disown__ (method) -ida_diskio.file_enumerator_t.__init__ (method) -ida_diskio.file_enumerator_t.visit_file (method) -ida_diskio.fopenA (function) -ida_diskio.fopenM (function) -ida_diskio.fopenRB (function) -ida_diskio.fopenRT (function) -ida_diskio.fopenWB (function) -ida_diskio.fopenWT (function) -ida_diskio.generic_linput_t (class) -ida_diskio.generic_linput_t.__init__ (method) -ida_diskio.generic_linput_t.blocksize (variable) -ida_diskio.generic_linput_t.filesize (variable) -ida_diskio.generic_linput_t.read (method) -ida_diskio.get_ida_subdirs (function) -ida_diskio.get_linput_type (function) -ida_diskio.get_special_folder (function) -ida_diskio.get_user_idadir (function) -ida_diskio.getsysfile (function) -ida_diskio.idadir (function) -ida_diskio.ioports_fallback_t (class) -ida_diskio.ioports_fallback_t.__disown__ (method) -ida_diskio.ioports_fallback_t.__init__ (method) -ida_diskio.ioports_fallback_t.handle (method) -ida_diskio.open_linput (function) -ida_diskio.qlgetz (function) -ida_diskio.read_ioports2 (function) -ida_dirtree (module) -ida_dirtree.DTN_DISPLAY_NAME (variable) -ida_dirtree.DTN_FULL_NAME (variable) -ida_dirtree.direntry_t (class) -ida_dirtree.direntry_t.__eq__ (method) -ida_dirtree.direntry_t.__init__ (method) -ida_dirtree.direntry_t.__lt__ (method) -ida_dirtree.direntry_t.__ne__ (method) -ida_dirtree.direntry_t.idx (variable) -ida_dirtree.direntry_t.isdir (variable) -ida_dirtree.direntry_t.valid (method) -ida_dirtree.direntry_vec_t (class) -ida_dirtree.direntry_vec_t.__eq__ (method) -ida_dirtree.direntry_vec_t.__getitem__ (method) -ida_dirtree.direntry_vec_t.__init__ (method) -ida_dirtree.direntry_vec_t.__len__ (method) -ida_dirtree.direntry_vec_t.__ne__ (method) -ida_dirtree.direntry_vec_t.__setitem__ (method) -ida_dirtree.direntry_vec_t._del (method) -ida_dirtree.direntry_vec_t.add_unique (method) -ida_dirtree.direntry_vec_t.at (method) -ida_dirtree.direntry_vec_t.begin (method) -ida_dirtree.direntry_vec_t.capacity (method) -ida_dirtree.direntry_vec_t.clear (method) -ida_dirtree.direntry_vec_t.empty (method) -ida_dirtree.direntry_vec_t.end (method) -ida_dirtree.direntry_vec_t.erase (method) -ida_dirtree.direntry_vec_t.extract (method) -ida_dirtree.direntry_vec_t.find (method) -ida_dirtree.direntry_vec_t.grow (method) -ida_dirtree.direntry_vec_t.has (method) -ida_dirtree.direntry_vec_t.inject (method) -ida_dirtree.direntry_vec_t.insert (method) -ida_dirtree.direntry_vec_t.pop_back (method) -ida_dirtree.direntry_vec_t.push_back (method) -ida_dirtree.direntry_vec_t.qclear (method) -ida_dirtree.direntry_vec_t.reserve (method) -ida_dirtree.direntry_vec_t.resize (method) -ida_dirtree.direntry_vec_t.size (method) -ida_dirtree.direntry_vec_t.swap (method) -ida_dirtree.direntry_vec_t.truncate (method) -ida_dirtree.dirspec_t (class) -ida_dirtree.dirspec_t.__disown__ (method) -ida_dirtree.dirspec_t.__init__ (method) -ida_dirtree.dirspec_t.get_attrs (method) -ida_dirtree.dirspec_t.get_inode (method) -ida_dirtree.dirspec_t.get_name (method) -ida_dirtree.dirspec_t.is_orderable (method) -ida_dirtree.dirspec_t.rename_inode (method) -ida_dirtree.dirspec_t.unlink_inode (method) -ida_dirtree.dirtree_cursor_t (class) -ida_dirtree.dirtree_cursor_t.__eq__ (method) -ida_dirtree.dirtree_cursor_t.__ge__ (method) -ida_dirtree.dirtree_cursor_t.__gt__ (method) -ida_dirtree.dirtree_cursor_t.__init__ (method) -ida_dirtree.dirtree_cursor_t.__le__ (method) -ida_dirtree.dirtree_cursor_t.__lt__ (method) -ida_dirtree.dirtree_cursor_t.__ne__ (method) -ida_dirtree.dirtree_cursor_t.compare (method) -ida_dirtree.dirtree_cursor_t.is_root_cursor (method) -ida_dirtree.dirtree_cursor_t.parent (variable) -ida_dirtree.dirtree_cursor_t.rank (variable) -ida_dirtree.dirtree_cursor_t.root_cursor (method) -ida_dirtree.dirtree_cursor_t.set_root_cursor (method) -ida_dirtree.dirtree_cursor_t.valid (method) -ida_dirtree.dirtree_cursor_t_root_cursor (function) -ida_dirtree.dirtree_cursor_vec_t (class) -ida_dirtree.dirtree_cursor_vec_t.__eq__ (method) -ida_dirtree.dirtree_cursor_vec_t.__getitem__ (method) -ida_dirtree.dirtree_cursor_vec_t.__init__ (method) -ida_dirtree.dirtree_cursor_vec_t.__len__ (method) -ida_dirtree.dirtree_cursor_vec_t.__ne__ (method) -ida_dirtree.dirtree_cursor_vec_t.__setitem__ (method) -ida_dirtree.dirtree_cursor_vec_t._del (method) -ida_dirtree.dirtree_cursor_vec_t.add_unique (method) -ida_dirtree.dirtree_cursor_vec_t.at (method) -ida_dirtree.dirtree_cursor_vec_t.begin (method) -ida_dirtree.dirtree_cursor_vec_t.capacity (method) -ida_dirtree.dirtree_cursor_vec_t.clear (method) -ida_dirtree.dirtree_cursor_vec_t.empty (method) -ida_dirtree.dirtree_cursor_vec_t.end (method) -ida_dirtree.dirtree_cursor_vec_t.erase (method) -ida_dirtree.dirtree_cursor_vec_t.extract (method) -ida_dirtree.dirtree_cursor_vec_t.find (method) -ida_dirtree.dirtree_cursor_vec_t.grow (method) -ida_dirtree.dirtree_cursor_vec_t.has (method) -ida_dirtree.dirtree_cursor_vec_t.inject (method) -ida_dirtree.dirtree_cursor_vec_t.insert (method) -ida_dirtree.dirtree_cursor_vec_t.pop_back (method) -ida_dirtree.dirtree_cursor_vec_t.push_back (method) -ida_dirtree.dirtree_cursor_vec_t.qclear (method) -ida_dirtree.dirtree_cursor_vec_t.reserve (method) -ida_dirtree.dirtree_cursor_vec_t.resize (method) -ida_dirtree.dirtree_cursor_vec_t.size (method) -ida_dirtree.dirtree_cursor_vec_t.swap (method) -ida_dirtree.dirtree_cursor_vec_t.truncate (method) -ida_dirtree.dirtree_iterator_t (class) -ida_dirtree.dirtree_iterator_t.__init__ (method) -ida_dirtree.dirtree_selection_t (class) -ida_dirtree.dirtree_selection_t.__init__ (method) -ida_dirtree.dirtree_t (class) -ida_dirtree.dirtree_t.__init__ (method) -ida_dirtree.dirtree_t.change_rank (method) -ida_dirtree.dirtree_t.chdir (method) -ida_dirtree.dirtree_t.errstr (method) -ida_dirtree.dirtree_t.find_entry (method) -ida_dirtree.dirtree_t.findfirst (method) -ida_dirtree.dirtree_t.findnext (method) -ida_dirtree.dirtree_t.get_abspath (method) -ida_dirtree.dirtree_t.get_dir_size (method) -ida_dirtree.dirtree_t.get_entry_attrs (method) -ida_dirtree.dirtree_t.get_entry_name (method) -ida_dirtree.dirtree_t.get_id (method) -ida_dirtree.dirtree_t.get_parent_cursor (method) -ida_dirtree.dirtree_t.get_rank (method) -ida_dirtree.dirtree_t.getcwd (method) -ida_dirtree.dirtree_t.is_dir_ordered (method) -ida_dirtree.dirtree_t.is_orderable (method) -ida_dirtree.dirtree_t.isdir (method) -ida_dirtree.dirtree_t.isfile (method) -ida_dirtree.dirtree_t.link (method) -ida_dirtree.dirtree_t.load (method) -ida_dirtree.dirtree_t.mkdir (method) -ida_dirtree.dirtree_t.notify_dirtree (method) -ida_dirtree.dirtree_t.rename (method) -ida_dirtree.dirtree_t.resolve_cursor (method) -ida_dirtree.dirtree_t.resolve_path (method) -ida_dirtree.dirtree_t.rmdir (method) -ida_dirtree.dirtree_t.save (method) -ida_dirtree.dirtree_t.set_id (method) -ida_dirtree.dirtree_t.set_natural_order (method) -ida_dirtree.dirtree_t.traverse (method) -ida_dirtree.dirtree_t.unlink (method) -ida_dirtree.dirtree_t_errstr (function) -ida_dirtree.dirtree_visitor_t (class) -ida_dirtree.dirtree_visitor_t.__disown__ (method) -ida_dirtree.dirtree_visitor_t.__init__ (method) -ida_dirtree.dirtree_visitor_t.visit (method) -ida_dirtree.get_std_dirtree (function) -ida_entry (module) -ida_entry.AEF_IDBENC (variable) -ida_entry.AEF_NODUMMY (variable) -ida_entry.AEF_UTF8 (variable) -ida_entry.add_entry (function) -ida_entry.get_entry (function) -ida_entry.get_entry_forwarder (function) -ida_entry.get_entry_name (function) -ida_entry.get_entry_ordinal (function) -ida_entry.get_entry_qty (function) -ida_entry.rename_entry (function) -ida_entry.set_entry_forwarder (function) -ida_enum (module) -ida_enum.DEFMASK (variable) -ida_enum.ENFL_REGEX (variable) -ida_enum.ENUM_MEMBER_ERROR_ENUM (variable) -ida_enum.ENUM_MEMBER_ERROR_ILLV (variable) -ida_enum.ENUM_MEMBER_ERROR_MASK (variable) -ida_enum.ENUM_MEMBER_ERROR_NAME (variable) -ida_enum.ENUM_MEMBER_ERROR_VALUE (variable) -ida_enum.MAX_ENUM_SERIAL (variable) -ida_enum.add_enum (function) -ida_enum.add_enum_member (function) -ida_enum.del_enum (function) -ida_enum.del_enum_member (function) -ida_enum.enum_member_visitor_t (class) -ida_enum.enum_member_visitor_t.__disown__ (method) -ida_enum.enum_member_visitor_t.__init__ (method) -ida_enum.enum_member_visitor_t.visit_enum_member (method) -ida_enum.for_all_enum_members (function) -ida_enum.get_bmask_cmt (function) -ida_enum.get_bmask_name (function) -ida_enum.get_enum (function) -ida_enum.get_enum_cmt (function) -ida_enum.get_enum_flag (function) -ida_enum.get_enum_idx (function) -ida_enum.get_enum_member (function) -ida_enum.get_enum_member_bmask (function) -ida_enum.get_enum_member_by_name (function) -ida_enum.get_enum_member_cmt (function) -ida_enum.get_enum_member_enum (function) -ida_enum.get_enum_member_name (function) -ida_enum.get_enum_member_serial (function) -ida_enum.get_enum_member_value (function) -ida_enum.get_enum_name (function) -ida_enum.get_enum_name2 (function) -ida_enum.get_enum_qty (function) -ida_enum.get_enum_size (function) -ida_enum.get_enum_type_ordinal (function) -ida_enum.get_enum_width (function) -ida_enum.get_first_bmask (function) -ida_enum.get_first_enum_member (function) -ida_enum.get_first_serial_enum_member (function) -ida_enum.get_last_bmask (function) -ida_enum.get_last_enum_member (function) -ida_enum.get_last_serial_enum_member (function) -ida_enum.get_next_bmask (function) -ida_enum.get_next_enum_member (function) -ida_enum.get_next_serial_enum_member (function) -ida_enum.get_prev_bmask (function) -ida_enum.get_prev_enum_member (function) -ida_enum.get_prev_serial_enum_member (function) -ida_enum.getn_enum (function) -ida_enum.is_bf (function) -ida_enum.is_enum_fromtil (function) -ida_enum.is_enum_hidden (function) -ida_enum.is_ghost_enum (function) -ida_enum.is_one_bit_mask (function) -ida_enum.set_bmask_cmt (function) -ida_enum.set_bmask_name (function) -ida_enum.set_enum_bf (function) -ida_enum.set_enum_cmt (function) -ida_enum.set_enum_flag (function) -ida_enum.set_enum_fromtil (function) -ida_enum.set_enum_ghost (function) -ida_enum.set_enum_hidden (function) -ida_enum.set_enum_idx (function) -ida_enum.set_enum_member_cmt (function) -ida_enum.set_enum_member_name (function) -ida_enum.set_enum_name (function) -ida_enum.set_enum_type_ordinal (function) -ida_enum.set_enum_width (function) -ida_expr (module) -ida_expr.CPL_DEL_MACROS (variable) -ida_expr.CPL_ONLY_SAFE (variable) -ida_expr.CPL_USE_LABELS (variable) -ida_expr.EXTFUN_BASE (variable) -ida_expr.EXTFUN_NORET (variable) -ida_expr.EXTFUN_SAFE (variable) -ida_expr.IDC_LANG_EXT (variable) -ida_expr.VARSLICE_SINGLE (variable) -ida_expr.VREF_COPY (variable) -ida_expr.VREF_LOOP (variable) -ida_expr.VREF_ONCE (variable) -ida_expr.VT_FLOAT (variable) -ida_expr.VT_FUNC (variable) -ida_expr.VT_INT64 (variable) -ida_expr.VT_LONG (variable) -ida_expr.VT_OBJ (variable) -ida_expr.VT_PVOID (variable) -ida_expr.VT_REF (variable) -ida_expr.VT_STR (variable) -ida_expr.VT_WILD (variable) -ida_expr._IdcFunction (class) -ida_expr._IdcFunction.__call__ (method) -ida_expr._IdcFunction.__init__ (method) -ida_expr.add_idc_class (function) -ida_expr.add_idc_func (function) -ida_expr.add_idc_gvar (function) -ida_expr.call_idc_func__ (function) -ida_expr.compile_idc_file (function) -ida_expr.compile_idc_snippet (function) -ida_expr.compile_idc_text (function) -ida_expr.copy_idcv (function) -ida_expr.create_idcv_ref (function) -ida_expr.deep_copy_idcv (function) -ida_expr.del_idc_func (function) -ida_expr.del_idcv_attr (function) -ida_expr.deref_idcv (function) -ida_expr.eExecThrow (variable) -ida_expr.eval_expr (function) -ida_expr.eval_idc_expr (function) -ida_expr.exec_idc_script (function) -ida_expr.exec_system_script (function) -ida_expr.find_idc_class (function) -ida_expr.find_idc_func (function) -ida_expr.find_idc_gvar (function) -ida_expr.first_idcv_attr (function) -ida_expr.free_idcv (function) -ida_expr.get_idc_filename (function) -ida_expr.get_idcv_attr (function) -ida_expr.get_idcv_class_name (function) -ida_expr.get_idcv_slice (function) -ida_expr.highlighter_cbs_t (class) -ida_expr.highlighter_cbs_t.__disown__ (method) -ida_expr.highlighter_cbs_t.__init__ (method) -ida_expr.highlighter_cbs_t.cur_block_state (method) -ida_expr.highlighter_cbs_t.prev_block_state (method) -ida_expr.highlighter_cbs_t.set_block_state (method) -ida_expr.highlighter_cbs_t.set_style (method) -ida_expr.idc_global_t (class) -ida_expr.idc_global_t.__init__ (method) -ida_expr.idc_value_t (class) -ida_expr.idc_value_t.__init__ (method) -ida_expr.idc_value_t._create_empty_string (method) -ida_expr.idc_value_t.c_str (method) -ida_expr.idc_value_t.clear (method) -ida_expr.idc_value_t.create_empty_string (method) -ida_expr.idc_value_t.e (variable) -ida_expr.idc_value_t.funcidx (variable) -ida_expr.idc_value_t.i64 (variable) -ida_expr.idc_value_t.is_convertible (method) -ida_expr.idc_value_t.is_integral (method) -ida_expr.idc_value_t.is_zero (method) -ida_expr.idc_value_t.num (variable) -ida_expr.idc_value_t.pvoid (variable) -ida_expr.idc_value_t.qstr (method) -ida_expr.idc_value_t.reserve (variable) -ida_expr.idc_value_t.set_float (method) -ida_expr.idc_value_t.set_int64 (method) -ida_expr.idc_value_t.set_long (method) -ida_expr.idc_value_t.set_pvoid (method) -ida_expr.idc_value_t.set_string (method) -ida_expr.idc_value_t.swap (method) -ida_expr.idc_value_t.u_str (method) -ida_expr.idc_value_t.vtype (variable) -ida_expr.idc_values_t (class) -ida_expr.idc_values_t.__getitem__ (method) -ida_expr.idc_values_t.__init__ (method) -ida_expr.idc_values_t.__len__ (method) -ida_expr.idc_values_t.__setitem__ (method) -ida_expr.idc_values_t.at (method) -ida_expr.idc_values_t.begin (method) -ida_expr.idc_values_t.capacity (method) -ida_expr.idc_values_t.clear (method) -ida_expr.idc_values_t.empty (method) -ida_expr.idc_values_t.end (method) -ida_expr.idc_values_t.erase (method) -ida_expr.idc_values_t.extract (method) -ida_expr.idc_values_t.grow (method) -ida_expr.idc_values_t.inject (method) -ida_expr.idc_values_t.insert (method) -ida_expr.idc_values_t.pop_back (method) -ida_expr.idc_values_t.push_back (method) -ida_expr.idc_values_t.qclear (method) -ida_expr.idc_values_t.reserve (method) -ida_expr.idc_values_t.resize (method) -ida_expr.idc_values_t.size (method) -ida_expr.idc_values_t.swap (method) -ida_expr.idc_values_t.truncate (method) -ida_expr.idcv_float (function) -ida_expr.idcv_int64 (function) -ida_expr.idcv_long (function) -ida_expr.idcv_num (function) -ida_expr.idcv_object (function) -ida_expr.idcv_string (function) -ida_expr.last_idcv_attr (function) -ida_expr.move_idcv (function) -ida_expr.next_idcv_attr (function) -ida_expr.prev_idcv_attr (function) -ida_expr.print_idcv (function) -ida_expr.py_add_idc_func (function) -ida_expr.py_get_call_idc_func (function) -ida_expr.pyw_convert_defvals (function) -ida_expr.pyw_register_idc_func (function) -ida_expr.pyw_unregister_idc_func (function) -ida_expr.set_header_path (function) -ida_expr.set_idcv_attr (function) -ida_expr.set_idcv_slice (function) -ida_expr.swap_idcvs (function) -ida_expr.throw_idc_exception (function) -ida_fixup (module) -ida_fixup.FIXUPF_CREATED (variable) -ida_fixup.FIXUPF_EXTDEF (variable) -ida_fixup.FIXUPF_LOADER_MASK (variable) -ida_fixup.FIXUPF_REL (variable) -ida_fixup.FIXUPF_UNUSED (variable) -ida_fixup.FIXUP_CUSTOM (variable) -ida_fixup.FIXUP_HI16 (variable) -ida_fixup.FIXUP_HI8 (variable) -ida_fixup.FIXUP_LOW16 (variable) -ida_fixup.FIXUP_LOW8 (variable) -ida_fixup.FIXUP_OFF16 (variable) -ida_fixup.FIXUP_OFF16S (variable) -ida_fixup.FIXUP_OFF32 (variable) -ida_fixup.FIXUP_OFF32S (variable) -ida_fixup.FIXUP_OFF64 (variable) -ida_fixup.FIXUP_OFF8 (variable) -ida_fixup.FIXUP_OFF8S (variable) -ida_fixup.FIXUP_PTR16 (variable) -ida_fixup.FIXUP_PTR32 (variable) -ida_fixup.FIXUP_SEG16 (variable) -ida_fixup.V695_FIXUP_VHIGH (variable) -ida_fixup.V695_FIXUP_VLOW (variable) -ida_fixup.calc_fixup_size (function) -ida_fixup.contains_fixups (function) -ida_fixup.del_fixup (function) -ida_fixup.exists_fixup (function) -ida_fixup.find_custom_fixup (function) -ida_fixup.fixup_data_t (class) -ida_fixup.fixup_data_t.__init__ (method) -ida_fixup.fixup_data_t.calc_size (method) -ida_fixup.fixup_data_t.clr_extdef (method) -ida_fixup.fixup_data_t.clr_unused (method) -ida_fixup.fixup_data_t.displacement (variable) -ida_fixup.fixup_data_t.get (method) -ida_fixup.fixup_data_t.get_base (method) -ida_fixup.fixup_data_t.get_desc (method) -ida_fixup.fixup_data_t.get_flags (method) -ida_fixup.fixup_data_t.get_handler (method) -ida_fixup.fixup_data_t.get_type (method) -ida_fixup.fixup_data_t.get_value (method) -ida_fixup.fixup_data_t.has_base (method) -ida_fixup.fixup_data_t.is_custom (method) -ida_fixup.fixup_data_t.is_extdef (method) -ida_fixup.fixup_data_t.is_unused (method) -ida_fixup.fixup_data_t.off (variable) -ida_fixup.fixup_data_t.patch_value (method) -ida_fixup.fixup_data_t.sel (variable) -ida_fixup.fixup_data_t.set (method) -ida_fixup.fixup_data_t.set_base (method) -ida_fixup.fixup_data_t.set_extdef (method) -ida_fixup.fixup_data_t.set_sel (method) -ida_fixup.fixup_data_t.set_target_sel (method) -ida_fixup.fixup_data_t.set_type (method) -ida_fixup.fixup_data_t.set_type_and_flags (method) -ida_fixup.fixup_data_t.set_unused (method) -ida_fixup.fixup_data_t.was_created (method) -ida_fixup.fixup_info_t (class) -ida_fixup.fixup_info_t.__init__ (method) -ida_fixup.gen_fix_fixups (function) -ida_fixup.get_first_fixup_ea (function) -ida_fixup.get_fixup (function) -ida_fixup.get_fixup_desc (function) -ida_fixup.get_fixup_handler (function) -ida_fixup.get_fixup_value (function) -ida_fixup.get_fixups (function) -ida_fixup.get_next_fixup_ea (function) -ida_fixup.get_prev_fixup_ea (function) -ida_fixup.handle_fixups_in_macro (function) -ida_fixup.is_fixup_custom (function) -ida_fixup.patch_fixup_value (function) -ida_fixup.set_fixup (function) -ida_fpro (module) -ida_fpro.qfile_t (class) -ida_fpro.qfile_t.__init__ (method) -ida_fpro.qfile_t.close (method) -ida_fpro.qfile_t.filename (method) -ida_fpro.qfile_t.flush (method) -ida_fpro.qfile_t.from_capsule (method) -ida_fpro.qfile_t.from_fp (method) -ida_fpro.qfile_t.get_byte (method) -ida_fpro.qfile_t.get_fp (method) -ida_fpro.qfile_t.gets (method) -ida_fpro.qfile_t.open (method) -ida_fpro.qfile_t.opened (method) -ida_fpro.qfile_t.put_byte (method) -ida_fpro.qfile_t.puts (method) -ida_fpro.qfile_t.read (method) -ida_fpro.qfile_t.readbytes (method) -ida_fpro.qfile_t.seek (method) -ida_fpro.qfile_t.size (method) -ida_fpro.qfile_t.tell (method) -ida_fpro.qfile_t.tmpfile (method) -ida_fpro.qfile_t.write (method) -ida_fpro.qfile_t.writebytes (method) -ida_fpro.qfile_t_from_capsule (function) -ida_fpro.qfile_t_from_fp (function) -ida_fpro.qfile_t_tmpfile (function) -ida_frame (module) -ida_frame.REGVAR_ERROR_ARG (variable) -ida_frame.REGVAR_ERROR_NAME (variable) -ida_frame.REGVAR_ERROR_OK (variable) -ida_frame.REGVAR_ERROR_RANGE (variable) -ida_frame.STKVAR_VALID_SIZE (variable) -ida_frame.add_auto_stkpnt (function) -ida_frame.add_frame (function) -ida_frame.add_regvar (function) -ida_frame.add_user_stkpnt (function) -ida_frame.build_stkvar_name (function) -ida_frame.build_stkvar_xrefs (function) -ida_frame.calc_stkvar_struc_offset (function) -ida_frame.define_stkvar (function) -ida_frame.del_frame (function) -ida_frame.del_regvar (function) -ida_frame.del_stkpnt (function) -ida_frame.delete_unreferenced_stkvars (function) -ida_frame.delete_wrong_stkvar_ops (function) -ida_frame.find_regvar (function) -ida_frame.frame_off_args (function) -ida_frame.frame_off_lvars (function) -ida_frame.frame_off_retaddr (function) -ida_frame.frame_off_savregs (function) -ida_frame.free_regvar (function) -ida_frame.get_effective_spd (function) -ida_frame.get_frame (function) -ida_frame.get_frame_member_by_id (function) -ida_frame.get_frame_part (function) -ida_frame.get_frame_retsize (function) -ida_frame.get_frame_size (function) -ida_frame.get_func_by_frame (function) -ida_frame.get_min_spd_ea (function) -ida_frame.get_sp_delta (function) -ida_frame.get_spd (function) -ida_frame.get_stkvar (function) -ida_frame.has_regvar (function) -ida_frame.is_funcarg_off (function) -ida_frame.lvar_off (function) -ida_frame.recalc_spd (function) -ida_frame.recalc_spd_for_basic_block (function) -ida_frame.regvar_t (class) -ida_frame.regvar_t.__init__ (method) -ida_frame.regvar_t.canon (variable) -ida_frame.regvar_t.cmt (variable) -ida_frame.regvar_t.swap (method) -ida_frame.regvar_t.user (variable) -ida_frame.rename_regvar (function) -ida_frame.set_auto_spd (function) -ida_frame.set_frame_size (function) -ida_frame.set_purged (function) -ida_frame.set_regvar_cmt (function) -ida_frame.soff_to_fpoff (function) -ida_frame.stkpnt_t (class) -ida_frame.stkpnt_t.__eq__ (method) -ida_frame.stkpnt_t.__ge__ (method) -ida_frame.stkpnt_t.__gt__ (method) -ida_frame.stkpnt_t.__init__ (method) -ida_frame.stkpnt_t.__le__ (method) -ida_frame.stkpnt_t.__lt__ (method) -ida_frame.stkpnt_t.__ne__ (method) -ida_frame.stkpnt_t.compare (method) -ida_frame.stkpnts_t (class) -ida_frame.stkpnts_t.__eq__ (method) -ida_frame.stkpnts_t.__ge__ (method) -ida_frame.stkpnts_t.__gt__ (method) -ida_frame.stkpnts_t.__init__ (method) -ida_frame.stkpnts_t.__le__ (method) -ida_frame.stkpnts_t.__lt__ (method) -ida_frame.stkpnts_t.__ne__ (method) -ida_frame.stkpnts_t.compare (method) -ida_frame.update_fpd (function) -ida_frame.xreflist_entry_t (class) -ida_frame.xreflist_entry_t.__eq__ (method) -ida_frame.xreflist_entry_t.__ge__ (method) -ida_frame.xreflist_entry_t.__gt__ (method) -ida_frame.xreflist_entry_t.__init__ (method) -ida_frame.xreflist_entry_t.__le__ (method) -ida_frame.xreflist_entry_t.__lt__ (method) -ida_frame.xreflist_entry_t.__ne__ (method) -ida_frame.xreflist_entry_t.compare (method) -ida_frame.xreflist_entry_t.ea (variable) -ida_frame.xreflist_entry_t.opnum (variable) -ida_frame.xreflist_entry_t.type (variable) -ida_frame.xreflist_t (class) -ida_frame.xreflist_t.__eq__ (method) -ida_frame.xreflist_t.__getitem__ (method) -ida_frame.xreflist_t.__init__ (method) -ida_frame.xreflist_t.__len__ (method) -ida_frame.xreflist_t.__ne__ (method) -ida_frame.xreflist_t.__setitem__ (method) -ida_frame.xreflist_t._del (method) -ida_frame.xreflist_t.add_unique (method) -ida_frame.xreflist_t.at (method) -ida_frame.xreflist_t.begin (method) -ida_frame.xreflist_t.capacity (method) -ida_frame.xreflist_t.clear (method) -ida_frame.xreflist_t.empty (method) -ida_frame.xreflist_t.end (method) -ida_frame.xreflist_t.erase (method) -ida_frame.xreflist_t.extract (method) -ida_frame.xreflist_t.find (method) -ida_frame.xreflist_t.grow (method) -ida_frame.xreflist_t.has (method) -ida_frame.xreflist_t.inject (method) -ida_frame.xreflist_t.insert (method) -ida_frame.xreflist_t.pop_back (method) -ida_frame.xreflist_t.push_back (method) -ida_frame.xreflist_t.qclear (method) -ida_frame.xreflist_t.reserve (method) -ida_frame.xreflist_t.resize (method) -ida_frame.xreflist_t.size (method) -ida_frame.xreflist_t.swap (method) -ida_frame.xreflist_t.truncate (method) -ida_funcs (module) -ida_funcs.FIND_FUNC_DEFINE (variable) -ida_funcs.FIND_FUNC_EXIST (variable) -ida_funcs.FIND_FUNC_IGNOREFN (variable) -ida_funcs.FIND_FUNC_KEEPBD (variable) -ida_funcs.FIND_FUNC_NORMAL (variable) -ida_funcs.FIND_FUNC_OK (variable) -ida_funcs.FIND_FUNC_UNDEF (variable) -ida_funcs.FUNC_BOTTOMBP (variable) -ida_funcs.FUNC_FAR (variable) -ida_funcs.FUNC_FRAME (variable) -ida_funcs.FUNC_FUZZY_SP (variable) -ida_funcs.FUNC_HIDDEN (variable) -ida_funcs.FUNC_LIB (variable) -ida_funcs.FUNC_LUMINA (variable) -ida_funcs.FUNC_NORET (variable) -ida_funcs.FUNC_NORET_PENDING (variable) -ida_funcs.FUNC_OUTLINE (variable) -ida_funcs.FUNC_PROLOG_OK (variable) -ida_funcs.FUNC_PURGED_OK (variable) -ida_funcs.FUNC_REANALYZE (variable) -ida_funcs.FUNC_SP_READY (variable) -ida_funcs.FUNC_STATICDEF (variable) -ida_funcs.FUNC_TAIL (variable) -ida_funcs.FUNC_THUNK (variable) -ida_funcs.FUNC_USERFAR (variable) -ida_funcs.IDASGN_APPLIED (variable) -ida_funcs.IDASGN_BADARG (variable) -ida_funcs.IDASGN_CURRENT (variable) -ida_funcs.IDASGN_OK (variable) -ida_funcs.IDASGN_PLANNED (variable) -ida_funcs.LIBFUNC_DELAY (variable) -ida_funcs.LIBFUNC_FOUND (variable) -ida_funcs.LIBFUNC_NONE (variable) -ida_funcs.MOVE_FUNC_BADSTART (variable) -ida_funcs.MOVE_FUNC_NOCODE (variable) -ida_funcs.MOVE_FUNC_NOFUNC (variable) -ida_funcs.MOVE_FUNC_OK (variable) -ida_funcs.MOVE_FUNC_REFUSED (variable) -ida_funcs.add_func (function) -ida_funcs.add_func_ex (function) -ida_funcs.add_regarg (function) -ida_funcs.append_func_tail (function) -ida_funcs.apply_idasgn_to (function) -ida_funcs.apply_startup_sig (function) -ida_funcs.calc_func_size (function) -ida_funcs.calc_idasgn_state (function) -ida_funcs.calc_thunk_func_target (function) -ida_funcs.calc_thunk_func_target (function) -ida_funcs.del_func (function) -ida_funcs.del_idasgn (function) -ida_funcs.dyn_ea_array (class) -ida_funcs.dyn_ea_array.__getitem__ (method) -ida_funcs.dyn_ea_array.__init__ (method) -ida_funcs.dyn_ea_array.__len__ (method) -ida_funcs.dyn_ea_array.__setitem__ (method) -ida_funcs.dyn_range_array (class) -ida_funcs.dyn_range_array.__getitem__ (method) -ida_funcs.dyn_range_array.__init__ (method) -ida_funcs.dyn_range_array.__len__ (method) -ida_funcs.dyn_range_array.__setitem__ (method) -ida_funcs.dyn_regarg_array (class) -ida_funcs.dyn_regarg_array.__getitem__ (method) -ida_funcs.dyn_regarg_array.__init__ (method) -ida_funcs.dyn_regarg_array.__len__ (method) -ida_funcs.dyn_regarg_array.__setitem__ (method) -ida_funcs.dyn_regvar_array (class) -ida_funcs.dyn_regvar_array.__getitem__ (method) -ida_funcs.dyn_regvar_array.__init__ (method) -ida_funcs.dyn_regvar_array.__len__ (method) -ida_funcs.dyn_regvar_array.__setitem__ (method) -ida_funcs.dyn_stkpnt_array (class) -ida_funcs.dyn_stkpnt_array.__getitem__ (method) -ida_funcs.dyn_stkpnt_array.__init__ (method) -ida_funcs.dyn_stkpnt_array.__len__ (method) -ida_funcs.dyn_stkpnt_array.__setitem__ (method) -ida_funcs.f_any (function) -ida_funcs.find_func_bounds (function) -ida_funcs.free_regarg (function) -ida_funcs.func_contains (function) -ida_funcs.func_does_return (function) -ida_funcs.func_item_iterator_t (class) -ida_funcs.func_item_iterator_t.__init__ (method) -ida_funcs.func_item_iterator_t.__iter__ (method) -ida_funcs.func_item_iterator_t.__next__ (method) -ida_funcs.func_item_iterator_t.addresses (method) -ida_funcs.func_item_iterator_t.chunk (method) -ida_funcs.func_item_iterator_t.code_items (method) -ida_funcs.func_item_iterator_t.current (method) -ida_funcs.func_item_iterator_t.data_items (method) -ida_funcs.func_item_iterator_t.decode_preceding_insn (method) -ida_funcs.func_item_iterator_t.decode_prev_insn (method) -ida_funcs.func_item_iterator_t.first (method) -ida_funcs.func_item_iterator_t.head_items (method) -ida_funcs.func_item_iterator_t.last (method) -ida_funcs.func_item_iterator_t.next_addr (method) -ida_funcs.func_item_iterator_t.next_code (method) -ida_funcs.func_item_iterator_t.next_data (method) -ida_funcs.func_item_iterator_t.next_head (method) -ida_funcs.func_item_iterator_t.next_not_tail (method) -ida_funcs.func_item_iterator_t.not_tails (method) -ida_funcs.func_item_iterator_t.prev (method) -ida_funcs.func_item_iterator_t.prev_addr (method) -ida_funcs.func_item_iterator_t.prev_code (method) -ida_funcs.func_item_iterator_t.prev_data (method) -ida_funcs.func_item_iterator_t.prev_head (method) -ida_funcs.func_item_iterator_t.prev_not_tail (method) -ida_funcs.func_item_iterator_t.set (method) -ida_funcs.func_item_iterator_t.set_range (method) -ida_funcs.func_item_iterator_t.succ (method) -ida_funcs.func_item_iterator_t.succ_code (method) -ida_funcs.func_parent_iterator_set (function) -ida_funcs.func_parent_iterator_t (class) -ida_funcs.func_parent_iterator_t.__init__ (method) -ida_funcs.func_parent_iterator_t.__iter__ (method) -ida_funcs.func_parent_iterator_t.__next__ (method) -ida_funcs.func_parent_iterator_t.first (method) -ida_funcs.func_parent_iterator_t.last (method) -ida_funcs.func_parent_iterator_t.parent (method) -ida_funcs.func_parent_iterator_t.prev (method) -ida_funcs.func_parent_iterator_t.reset_fnt (method) -ida_funcs.func_parent_iterator_t.set (method) -ida_funcs.func_t (class) -ida_funcs.func_t.__get_points__ (method) -ida_funcs.func_t.__get_referers__ (method) -ida_funcs.func_t.__get_regargs__ (method) -ida_funcs.func_t.__get_regvars__ (method) -ida_funcs.func_t.__get_tails__ (method) -ida_funcs.func_t.__init__ (method) -ida_funcs.func_t.__iter__ (method) -ida_funcs.func_t.addresses (method) -ida_funcs.func_t.analyzed_sp (method) -ida_funcs.func_t.argsize (variable) -ida_funcs.func_t.code_items (method) -ida_funcs.func_t.color (variable) -ida_funcs.func_t.data_items (method) -ida_funcs.func_t.does_return (method) -ida_funcs.func_t.flags (variable) -ida_funcs.func_t.fpd (variable) -ida_funcs.func_t.frame (variable) -ida_funcs.func_t.frregs (variable) -ida_funcs.func_t.frsize (variable) -ida_funcs.func_t.head_items (method) -ida_funcs.func_t.is_far (method) -ida_funcs.func_t.need_prolog_analysis (method) -ida_funcs.func_t.not_tails (method) -ida_funcs.func_t.owner (variable) -ida_funcs.func_t.pntqty (variable) -ida_funcs.func_t.points (variable) -ida_funcs.func_t.referers (variable) -ida_funcs.func_t.refqty (variable) -ida_funcs.func_t.regargqty (variable) -ida_funcs.func_t.regargs (variable) -ida_funcs.func_t.regvarqty (variable) -ida_funcs.func_t.regvars (variable) -ida_funcs.func_t.tailqty (variable) -ida_funcs.func_t.tails (variable) -ida_funcs.func_t__from_ptrval__ (function) -ida_funcs.func_tail_iterator_set (function) -ida_funcs.func_tail_iterator_set_ea (function) -ida_funcs.func_tail_iterator_t (class) -ida_funcs.func_tail_iterator_t.__init__ (method) -ida_funcs.func_tail_iterator_t.__iter__ (method) -ida_funcs.func_tail_iterator_t.__next__ (method) -ida_funcs.func_tail_iterator_t.chunk (method) -ida_funcs.func_tail_iterator_t.first (method) -ida_funcs.func_tail_iterator_t.last (method) -ida_funcs.func_tail_iterator_t.main (method) -ida_funcs.func_tail_iterator_t.prev (method) -ida_funcs.func_tail_iterator_t.set (method) -ida_funcs.func_tail_iterator_t.set_ea (method) -ida_funcs.func_tail_iterator_t.set_range (method) -ida_funcs.get_current_idasgn (function) -ida_funcs.get_fchunk (function) -ida_funcs.get_fchunk_num (function) -ida_funcs.get_fchunk_qty (function) -ida_funcs.get_fchunk_referer (function) -ida_funcs.get_func (function) -ida_funcs.get_func_bitness (function) -ida_funcs.get_func_bits (function) -ida_funcs.get_func_bytes (function) -ida_funcs.get_func_chunknum (function) -ida_funcs.get_func_cmt (function) -ida_funcs.get_func_name (function) -ida_funcs.get_func_num (function) -ida_funcs.get_func_qty (function) -ida_funcs.get_func_ranges (function) -ida_funcs.get_idasgn_desc (function) -ida_funcs.get_idasgn_desc_with_matches (function) -ida_funcs.get_idasgn_qty (function) -ida_funcs.get_idasgn_title (function) -ida_funcs.get_next_fchunk (function) -ida_funcs.get_next_func (function) -ida_funcs.get_next_func_addr (function) -ida_funcs.get_prev_fchunk (function) -ida_funcs.get_prev_func (function) -ida_funcs.get_prev_func_addr (function) -ida_funcs.getn_fchunk (function) -ida_funcs.getn_func (function) -ida_funcs.is_finally_visible_func (function) -ida_funcs.is_func_entry (function) -ida_funcs.is_func_locked (function) -ida_funcs.is_func_tail (function) -ida_funcs.is_same_func (function) -ida_funcs.is_visible_func (function) -ida_funcs.lock_func (class) -ida_funcs.lock_func.__init__ (method) -ida_funcs.lock_func_range (function) -ida_funcs.lock_func_with_tails_t (class) -ida_funcs.lock_func_with_tails_t.__init__ (method) -ida_funcs.plan_to_apply_idasgn (function) -ida_funcs.read_regargs (function) -ida_funcs.reanalyze_function (function) -ida_funcs.reanalyze_noret_flag (function) -ida_funcs.regarg_t (class) -ida_funcs.regarg_t.__init__ (method) -ida_funcs.regarg_t.swap (method) -ida_funcs.remove_func_tail (function) -ida_funcs.set_func_cmt (function) -ida_funcs.set_func_end (function) -ida_funcs.set_func_name_if_jumpfunc (function) -ida_funcs.set_func_start (function) -ida_funcs.set_noret_insn (function) -ida_funcs.set_tail_owner (function) -ida_funcs.set_visible_func (function) -ida_funcs.try_to_add_libfunc (function) -ida_funcs.update_func (function) -ida_gdl (module) -ida_gdl.BasicBlock (class) -ida_gdl.BasicBlock.__init__ (method) -ida_gdl.BasicBlock.preds (method) -ida_gdl.BasicBlock.succs (method) -ida_gdl.CHART_FOLLOW_DIRECTION (variable) -ida_gdl.CHART_GEN_DOT (variable) -ida_gdl.CHART_GEN_GDL (variable) -ida_gdl.CHART_IGNORE_LIB_FROM (variable) -ida_gdl.CHART_IGNORE_LIB_TO (variable) -ida_gdl.CHART_NOLIBFUNCS (variable) -ida_gdl.CHART_PRINT_DOTS (variable) -ida_gdl.CHART_PRINT_NAMES (variable) -ida_gdl.CHART_RECURSIVE (variable) -ida_gdl.CHART_REFERENCED (variable) -ida_gdl.CHART_REFERENCING (variable) -ida_gdl.CHART_WINGRAPH (variable) -ida_gdl.FC_APPND (variable) -ida_gdl.FC_CALL_ENDS (variable) -ida_gdl.FC_CHKBREAK (variable) -ida_gdl.FC_NOEXT (variable) -ida_gdl.FC_NOPREDS (variable) -ida_gdl.FC_OUTLINES (variable) -ida_gdl.FC_PRINT (variable) -ida_gdl.FlowChart (class) -ida_gdl.FlowChart.__getitem__ (method) -ida_gdl.FlowChart.__init__ (method) -ida_gdl.FlowChart.__iter__ (method) -ida_gdl.FlowChart._getitem (method) -ida_gdl.FlowChart.refresh (method) -ida_gdl.FlowChart.size (variable) -ida_gdl.cancellable_graph_t (class) -ida_gdl.cancellable_graph_t.__disown__ (method) -ida_gdl.cancellable_graph_t.__init__ (method) -ida_gdl.display_gdl (function) -ida_gdl.fcb_cndret (variable) -ida_gdl.fcb_enoret (variable) -ida_gdl.fcb_error (variable) -ida_gdl.fcb_extern (variable) -ida_gdl.fcb_indjump (variable) -ida_gdl.fcb_noret (variable) -ida_gdl.fcb_normal (variable) -ida_gdl.fcb_ret (variable) -ida_gdl.gdl_graph_t (class) -ida_gdl.gdl_graph_t.__disown__ (method) -ida_gdl.gdl_graph_t.__init__ (method) -ida_gdl.gdl_graph_t.begin (method) -ida_gdl.gdl_graph_t.edge (method) -ida_gdl.gdl_graph_t.empty (method) -ida_gdl.gdl_graph_t.end (method) -ida_gdl.gdl_graph_t.entry (method) -ida_gdl.gdl_graph_t.exists (method) -ida_gdl.gdl_graph_t.exit (method) -ida_gdl.gdl_graph_t.front (method) -ida_gdl.gdl_graph_t.get_edge_color (method) -ida_gdl.gdl_graph_t.get_node_color (method) -ida_gdl.gdl_graph_t.get_node_label (method) -ida_gdl.gdl_graph_t.nedge (method) -ida_gdl.gdl_graph_t.node_qty (method) -ida_gdl.gdl_graph_t.npred (method) -ida_gdl.gdl_graph_t.nsucc (method) -ida_gdl.gdl_graph_t.pred (method) -ida_gdl.gdl_graph_t.print_edge (method) -ida_gdl.gdl_graph_t.print_graph_attributes (method) -ida_gdl.gdl_graph_t.print_node (method) -ida_gdl.gdl_graph_t.print_node_attributes (method) -ida_gdl.gdl_graph_t.size (method) -ida_gdl.gdl_graph_t.succ (method) -ida_gdl.gen_complex_call_chart (function) -ida_gdl.gen_flow_graph (function) -ida_gdl.gen_gdl (function) -ida_gdl.gen_simple_call_chart (function) -ida_gdl.is_noret_block (function) -ida_gdl.is_ret_block (function) -ida_gdl.node_iterator (class) -ida_gdl.node_iterator.__eq__ (method) -ida_gdl.node_iterator.__init__ (method) -ida_gdl.node_iterator.__ne__ (method) -ida_gdl.node_iterator.__ref__ (method) -ida_gdl.qbasic_block_t (class) -ida_gdl.qbasic_block_t.__init__ (method) -ida_gdl.qflow_chart_t (class) -ida_gdl.qflow_chart_t.__getitem__ (method) -ida_gdl.qflow_chart_t.__init__ (method) -ida_gdl.qflow_chart_t.append_to_flowchart (method) -ida_gdl.qflow_chart_t.bounds (variable) -ida_gdl.qflow_chart_t.calc_block_type (method) -ida_gdl.qflow_chart_t.create (method) -ida_gdl.qflow_chart_t.flags (variable) -ida_gdl.qflow_chart_t.get_node_label (method) -ida_gdl.qflow_chart_t.is_noret_block (method) -ida_gdl.qflow_chart_t.is_ret_block (method) -ida_gdl.qflow_chart_t.npred (method) -ida_gdl.qflow_chart_t.nproper (variable) -ida_gdl.qflow_chart_t.nsucc (method) -ida_gdl.qflow_chart_t.pfn (variable) -ida_gdl.qflow_chart_t.pred (method) -ida_gdl.qflow_chart_t.print_names (method) -ida_gdl.qflow_chart_t.print_node_attributes (method) -ida_gdl.qflow_chart_t.refresh (method) -ida_gdl.qflow_chart_t.size (method) -ida_gdl.qflow_chart_t.succ (method) -ida_graph (module) -ida_graph.GLICTL_CENTER (variable) -ida_graph.GraphViewer (class) -ida_graph.GraphViewer.AddCommand (method) -ida_graph.GraphViewer.AddEdge (method) -ida_graph.GraphViewer.AddNode (method) -ida_graph.GraphViewer.Clear (method) -ida_graph.GraphViewer.Close (method) -ida_graph.GraphViewer.Count (method) -ida_graph.GraphViewer.OnCommand (method) -ida_graph.GraphViewer.OnPopup (method) -ida_graph.GraphViewer.OnRefresh (method) -ida_graph.GraphViewer.Select (method) -ida_graph.GraphViewer.Show (method) -ida_graph.GraphViewer.UI_Hooks_Trampoline (class) -ida_graph.GraphViewer.UI_Hooks_Trampoline.__init__ (method) -ida_graph.GraphViewer.UI_Hooks_Trampoline.populating_widget_popup (method) -ida_graph.GraphViewer._OnBind (method) -ida_graph.GraphViewer.__getitem__ (method) -ida_graph.GraphViewer.__init__ (method) -ida_graph.GraphViewer.__init__._qccb (function) -ida_graph.GraphViewer.__iter__ (method) -ida_graph.MTG_DOT_NODE (variable) -ida_graph.MTG_GROUP_NODE (variable) -ida_graph.MTG_NON_DISPLAYABLE_NODE (variable) -ida_graph.NIF_BG_COLOR (variable) -ida_graph.NIF_EA (variable) -ida_graph.NIF_FLAGS (variable) -ida_graph.NIF_FRAME_COLOR (variable) -ida_graph.NIF_TEXT (variable) -ida_graph.TPointDouble (class) -ida_graph.TPointDouble.__eq__ (method) -ida_graph.TPointDouble.__init__ (method) -ida_graph.TPointDouble.__ne__ (method) -ida_graph.TPointDouble.add (method) -ida_graph.TPointDouble.negate (method) -ida_graph.TPointDouble.sub (method) -ida_graph.abstract_graph_t (class) -ida_graph.abstract_graph_t.__disown__ (method) -ida_graph.abstract_graph_t.__init__ (method) -ida_graph.abstract_graph_t.callback_ud (variable) -ida_graph.abstract_graph_t.circle_center (variable) -ida_graph.abstract_graph_t.circle_radius (variable) -ida_graph.abstract_graph_t.create_circle_layout (method) -ida_graph.abstract_graph_t.create_tree_layout (method) -ida_graph.abstract_graph_t.current_layout (variable) -ida_graph.abstract_graph_t.get_edge (method) -ida_graph.abstract_graph_t.grcall (method) -ida_graph.abstract_graph_t.nrect (method) -ida_graph.abstract_graph_t.rect_edges_made (variable) -ida_graph.abstract_graph_t.set_callback (method) -ida_graph.abstract_graph_t.title (variable) -ida_graph.calc_dist (function) -ida_graph.clr_node_info (function) -ida_graph.create_disasm_graph (function) -ida_graph.create_graph_viewer (function) -ida_graph.create_mutable_graph (function) -ida_graph.create_user_graph_place (function) -ida_graph.del_node_info (function) -ida_graph.delete_mutable_graph (function) -ida_graph.edge_info_t (class) -ida_graph.edge_info_t.__init__ (method) -ida_graph.edge_info_t.color (variable) -ida_graph.edge_info_t.layout (variable) -ida_graph.edge_info_t.reverse_layout (method) -ida_graph.edge_info_t.width (variable) -ida_graph.edge_infos_wrapper_t (class) -ida_graph.edge_infos_wrapper_t.__init__ (method) -ida_graph.edge_infos_wrapper_t.clear (method) -ida_graph.edge_layout_point_t (class) -ida_graph.edge_layout_point_t.__eq__ (method) -ida_graph.edge_layout_point_t.__init__ (method) -ida_graph.edge_layout_point_t.__ne__ (method) -ida_graph.edge_layout_point_t.compare (method) -ida_graph.edge_layout_point_t.e (variable) -ida_graph.edge_layout_point_t.pidx (variable) -ida_graph.edge_segment_t (class) -ida_graph.edge_segment_t.__init__ (method) -ida_graph.edge_segment_t.__lt__ (method) -ida_graph.edge_segment_t.length (method) -ida_graph.edge_segment_t.toright (method) -ida_graph.edge_t (class) -ida_graph.edge_t.__eq__ (method) -ida_graph.edge_t.__init__ (method) -ida_graph.edge_t.__lt__ (method) -ida_graph.edge_t.__ne__ (method) -ida_graph.edge_t.dst (variable) -ida_graph.edge_t.src (variable) -ida_graph.get_graph_viewer (function) -ida_graph.get_node_info (function) -ida_graph.get_viewer_graph (function) -ida_graph.git_edge (variable) -ida_graph.git_elp (variable) -ida_graph.git_node (variable) -ida_graph.git_none (variable) -ida_graph.git_text (variable) -ida_graph.git_tool (variable) -ida_graph.graph_item_t (class) -ida_graph.graph_item_t.__init__ (method) -ida_graph.graph_item_t.b (variable) -ida_graph.graph_item_t.e (variable) -ida_graph.graph_item_t.elp (variable) -ida_graph.graph_item_t.is_edge (method) -ida_graph.graph_item_t.is_node (method) -ida_graph.graph_item_t.n (variable) -ida_graph.graph_item_t.p (variable) -ida_graph.graph_item_t.type (variable) -ida_graph.graph_node_visitor_t (class) -ida_graph.graph_node_visitor_t.__disown__ (method) -ida_graph.graph_node_visitor_t.__init__ (method) -ida_graph.graph_node_visitor_t.is_forbidden_edge (method) -ida_graph.graph_node_visitor_t.is_visited (method) -ida_graph.graph_node_visitor_t.reinit (method) -ida_graph.graph_node_visitor_t.set_visited (method) -ida_graph.graph_node_visitor_t.visit_node (method) -ida_graph.graph_path_visitor_t (class) -ida_graph.graph_path_visitor_t.__disown__ (method) -ida_graph.graph_path_visitor_t.__init__ (method) -ida_graph.graph_path_visitor_t.path (variable) -ida_graph.graph_path_visitor_t.prune (variable) -ida_graph.graph_path_visitor_t.walk_backward (method) -ida_graph.graph_path_visitor_t.walk_forward (method) -ida_graph.graph_visitor_t (class) -ida_graph.graph_visitor_t.__disown__ (method) -ida_graph.graph_visitor_t.__init__ (method) -ida_graph.graph_visitor_t.visit_edge (method) -ida_graph.graph_visitor_t.visit_node (method) -ida_graph.grcode_calculating_layout (variable) -ida_graph.grcode_center_on (variable) -ida_graph.grcode_change_group_visibility (variable) -ida_graph.grcode_changed_graph (variable) -ida_graph.grcode_clear (variable) -ida_graph.grcode_clicked (variable) -ida_graph.grcode_create_circle_layout (variable) -ida_graph.grcode_create_digraph_layout (variable) -ida_graph.grcode_create_disasm_graph1 (variable) -ida_graph.grcode_create_disasm_graph2 (variable) -ida_graph.grcode_create_graph_viewer (variable) -ida_graph.grcode_create_group (variable) -ida_graph.grcode_create_mutable_graph (variable) -ida_graph.grcode_create_tree_layout (variable) -ida_graph.grcode_create_user_graph_place (variable) -ida_graph.grcode_creating_group (variable) -ida_graph.grcode_dblclicked (variable) -ida_graph.grcode_del_custom_layout (variable) -ida_graph.grcode_del_node_info (variable) -ida_graph.grcode_delete_group (variable) -ida_graph.grcode_delete_mutable_graph (variable) -ida_graph.grcode_deleting_group (variable) -ida_graph.grcode_destroyed (variable) -ida_graph.grcode_edge_infos_wrapper_clear (variable) -ida_graph.grcode_edge_infos_wrapper_copy (variable) -ida_graph.grcode_empty (variable) -ida_graph.grcode_find_subgraph_node (variable) -ida_graph.grcode_fit_window (variable) -ida_graph.grcode_get_curnode (variable) -ida_graph.grcode_get_custom_layout (variable) -ida_graph.grcode_get_gli (variable) -ida_graph.grcode_get_graph_groups (variable) -ida_graph.grcode_get_graph_viewer (variable) -ida_graph.grcode_get_node_info (variable) -ida_graph.grcode_get_node_representative (variable) -ida_graph.grcode_get_selection (variable) -ida_graph.grcode_get_viewer_graph (variable) -ida_graph.grcode_gotfocus (variable) -ida_graph.grcode_group_visibility (variable) -ida_graph.grcode_is_visible_node (variable) -ida_graph.grcode_layout_calculated (variable) -ida_graph.grcode_lostfocus (variable) -ida_graph.grcode_node_qty (variable) -ida_graph.grcode_nrect (variable) -ida_graph.grcode_refresh_viewer (variable) -ida_graph.grcode_set_custom_layout (variable) -ida_graph.grcode_set_edge (variable) -ida_graph.grcode_set_gli (variable) -ida_graph.grcode_set_graph_groups (variable) -ida_graph.grcode_set_node_info (variable) -ida_graph.grcode_set_titlebar_height (variable) -ida_graph.grcode_set_viewer_graph (variable) -ida_graph.grcode_user_draw (variable) -ida_graph.grcode_user_hint (variable) -ida_graph.grcode_user_refresh (variable) -ida_graph.grcode_user_size (variable) -ida_graph.grcode_user_text (variable) -ida_graph.grcode_user_title (variable) -ida_graph.grcode_viewer_create_groups_vec (variable) -ida_graph.grcode_viewer_delete_groups_vec (variable) -ida_graph.grcode_viewer_groups_visibility_vec (variable) -ida_graph.group_crinfo_t (class) -ida_graph.group_crinfo_t.__init__ (method) -ida_graph.interval_t (class) -ida_graph.interval_t.__eq__ (method) -ida_graph.interval_t.__init__ (method) -ida_graph.interval_t.__ne__ (method) -ida_graph.interval_t.contains (method) -ida_graph.interval_t.empty (method) -ida_graph.interval_t.intersect (method) -ida_graph.interval_t.length (method) -ida_graph.interval_t.make_union (method) -ida_graph.interval_t.move_by (method) -ida_graph.mutable_graph_t (class) -ida_graph.mutable_graph_t.__init__ (method) -ida_graph.mutable_graph_t.add_edge (method) -ida_graph.mutable_graph_t.add_node (method) -ida_graph.mutable_graph_t.belongs (variable) -ida_graph.mutable_graph_t.calc_group_ea (method) -ida_graph.mutable_graph_t.change_group_visibility (method) -ida_graph.mutable_graph_t.create_digraph_layout (method) -ida_graph.mutable_graph_t.create_group (method) -ida_graph.mutable_graph_t.del_custom_layout (method) -ida_graph.mutable_graph_t.del_edge (method) -ida_graph.mutable_graph_t.del_node (method) -ida_graph.mutable_graph_t.delete_group (method) -ida_graph.mutable_graph_t.empty (method) -ida_graph.mutable_graph_t.exists (method) -ida_graph.mutable_graph_t.get_custom_layout (method) -ida_graph.mutable_graph_t.get_first_subgraph_node (method) -ida_graph.mutable_graph_t.get_graph_groups (method) -ida_graph.mutable_graph_t.get_next_subgraph_node (method) -ida_graph.mutable_graph_t.get_node_group (method) -ida_graph.mutable_graph_t.get_node_representative (method) -ida_graph.mutable_graph_t.gid (variable) -ida_graph.mutable_graph_t.is_collapsed_node (method) -ida_graph.mutable_graph_t.is_deleted_node (method) -ida_graph.mutable_graph_t.is_displayable_node (method) -ida_graph.mutable_graph_t.is_dot_node (method) -ida_graph.mutable_graph_t.is_group_node (method) -ida_graph.mutable_graph_t.is_simple_node (method) -ida_graph.mutable_graph_t.is_subgraph_node (method) -ida_graph.mutable_graph_t.is_uncollapsed_node (method) -ida_graph.mutable_graph_t.is_user_graph (method) -ida_graph.mutable_graph_t.is_visible_node (method) -ida_graph.mutable_graph_t.node_flags (variable) -ida_graph.mutable_graph_t.node_qty (method) -ida_graph.mutable_graph_t.npred (method) -ida_graph.mutable_graph_t.nsucc (method) -ida_graph.mutable_graph_t.pred (method) -ida_graph.mutable_graph_t.predset (method) -ida_graph.mutable_graph_t.redo_layout (method) -ida_graph.mutable_graph_t.refresh (method) -ida_graph.mutable_graph_t.replace_edge (method) -ida_graph.mutable_graph_t.reset (method) -ida_graph.mutable_graph_t.resize (method) -ida_graph.mutable_graph_t.set_custom_layout (method) -ida_graph.mutable_graph_t.set_deleted_node (method) -ida_graph.mutable_graph_t.set_edge (method) -ida_graph.mutable_graph_t.set_graph_groups (method) -ida_graph.mutable_graph_t.set_node_group (method) -ida_graph.mutable_graph_t.set_nrect (method) -ida_graph.mutable_graph_t.size (method) -ida_graph.mutable_graph_t.succ (method) -ida_graph.mutable_graph_t.succset (method) -ida_graph.node_info_t (class) -ida_graph.node_info_t.__init__ (method) -ida_graph.node_info_t.bg_color (variable) -ida_graph.node_info_t.ea (variable) -ida_graph.node_info_t.flags (variable) -ida_graph.node_info_t.frame_color (variable) -ida_graph.node_info_t.get_flags_for_valid (method) -ida_graph.node_info_t.text (variable) -ida_graph.node_info_t.valid_bg_color (method) -ida_graph.node_info_t.valid_ea (method) -ida_graph.node_info_t.valid_flags (method) -ida_graph.node_info_t.valid_frame_color (method) -ida_graph.node_info_t.valid_text (method) -ida_graph.node_layout_t (class) -ida_graph.node_layout_t.__eq__ (method) -ida_graph.node_layout_t.__getitem__ (method) -ida_graph.node_layout_t.__init__ (method) -ida_graph.node_layout_t.__len__ (method) -ida_graph.node_layout_t.__ne__ (method) -ida_graph.node_layout_t.__setitem__ (method) -ida_graph.node_layout_t._del (method) -ida_graph.node_layout_t.add_unique (method) -ida_graph.node_layout_t.at (method) -ida_graph.node_layout_t.begin (method) -ida_graph.node_layout_t.capacity (method) -ida_graph.node_layout_t.clear (method) -ida_graph.node_layout_t.empty (method) -ida_graph.node_layout_t.end (method) -ida_graph.node_layout_t.erase (method) -ida_graph.node_layout_t.extract (method) -ida_graph.node_layout_t.find (method) -ida_graph.node_layout_t.grow (method) -ida_graph.node_layout_t.has (method) -ida_graph.node_layout_t.inject (method) -ida_graph.node_layout_t.insert (method) -ida_graph.node_layout_t.pop_back (method) -ida_graph.node_layout_t.push_back (method) -ida_graph.node_layout_t.qclear (method) -ida_graph.node_layout_t.reserve (method) -ida_graph.node_layout_t.resize (method) -ida_graph.node_layout_t.size (method) -ida_graph.node_layout_t.swap (method) -ida_graph.node_layout_t.truncate (method) -ida_graph.node_ordering_t (class) -ida_graph.node_ordering_t.__init__ (method) -ida_graph.node_ordering_t.clear (method) -ida_graph.node_ordering_t.clr (method) -ida_graph.node_ordering_t.node (method) -ida_graph.node_ordering_t.order (method) -ida_graph.node_ordering_t.resize (method) -ida_graph.node_ordering_t.set (method) -ida_graph.node_ordering_t.size (method) -ida_graph.point_t (class) -ida_graph.point_t.__eq__ (method) -ida_graph.point_t.__init__ (method) -ida_graph.point_t.__ne__ (method) -ida_graph.point_t.add (method) -ida_graph.point_t.negate (method) -ida_graph.point_t.sub (method) -ida_graph.pointseq_t (class) -ida_graph.pointseq_t.__init__ (method) -ida_graph.pointvec_t (class) -ida_graph.pointvec_t.__eq__ (method) -ida_graph.pointvec_t.__getitem__ (method) -ida_graph.pointvec_t.__init__ (method) -ida_graph.pointvec_t.__len__ (method) -ida_graph.pointvec_t.__ne__ (method) -ida_graph.pointvec_t.__setitem__ (method) -ida_graph.pointvec_t._del (method) -ida_graph.pointvec_t.add_unique (method) -ida_graph.pointvec_t.at (method) -ida_graph.pointvec_t.begin (method) -ida_graph.pointvec_t.capacity (method) -ida_graph.pointvec_t.clear (method) -ida_graph.pointvec_t.empty (method) -ida_graph.pointvec_t.end (method) -ida_graph.pointvec_t.erase (method) -ida_graph.pointvec_t.extract (method) -ida_graph.pointvec_t.find (method) -ida_graph.pointvec_t.grow (method) -ida_graph.pointvec_t.has (method) -ida_graph.pointvec_t.inject (method) -ida_graph.pointvec_t.insert (method) -ida_graph.pointvec_t.pop_back (method) -ida_graph.pointvec_t.push_back (method) -ida_graph.pointvec_t.qclear (method) -ida_graph.pointvec_t.reserve (method) -ida_graph.pointvec_t.resize (method) -ida_graph.pointvec_t.size (method) -ida_graph.pointvec_t.swap (method) -ida_graph.pointvec_t.truncate (method) -ida_graph.pyg_close (function) -ida_graph.pyg_select_node (function) -ida_graph.pyg_show (function) -ida_graph.rect_t (class) -ida_graph.rect_t.__eq__ (method) -ida_graph.rect_t.__init__ (method) -ida_graph.rect_t.__ne__ (method) -ida_graph.rect_t.area (method) -ida_graph.rect_t.bottomright (method) -ida_graph.rect_t.center (method) -ida_graph.rect_t.contains (method) -ida_graph.rect_t.empty (method) -ida_graph.rect_t.grow (method) -ida_graph.rect_t.height (method) -ida_graph.rect_t.intersect (method) -ida_graph.rect_t.is_intersection_empty (method) -ida_graph.rect_t.make_union (method) -ida_graph.rect_t.move_by (method) -ida_graph.rect_t.move_to (method) -ida_graph.rect_t.topleft (method) -ida_graph.rect_t.width (method) -ida_graph.refresh_viewer (function) -ida_graph.row_info_t (class) -ida_graph.row_info_t.__init__ (method) -ida_graph.row_info_t.bottom (variable) -ida_graph.row_info_t.height (method) -ida_graph.row_info_t.nodes (variable) -ida_graph.row_info_t.top (variable) -ida_graph.screen_graph_selection_base_t (class) -ida_graph.screen_graph_selection_base_t.__eq__ (method) -ida_graph.screen_graph_selection_base_t.__getitem__ (method) -ida_graph.screen_graph_selection_base_t.__init__ (method) -ida_graph.screen_graph_selection_base_t.__len__ (method) -ida_graph.screen_graph_selection_base_t.__ne__ (method) -ida_graph.screen_graph_selection_base_t.__setitem__ (method) -ida_graph.screen_graph_selection_base_t._del (method) -ida_graph.screen_graph_selection_base_t.add_unique (method) -ida_graph.screen_graph_selection_base_t.at (method) -ida_graph.screen_graph_selection_base_t.begin (method) -ida_graph.screen_graph_selection_base_t.capacity (method) -ida_graph.screen_graph_selection_base_t.clear (method) -ida_graph.screen_graph_selection_base_t.empty (method) -ida_graph.screen_graph_selection_base_t.end (method) -ida_graph.screen_graph_selection_base_t.erase (method) -ida_graph.screen_graph_selection_base_t.extract (method) -ida_graph.screen_graph_selection_base_t.find (method) -ida_graph.screen_graph_selection_base_t.grow (method) -ida_graph.screen_graph_selection_base_t.has (method) -ida_graph.screen_graph_selection_base_t.inject (method) -ida_graph.screen_graph_selection_base_t.insert (method) -ida_graph.screen_graph_selection_base_t.pop_back (method) -ida_graph.screen_graph_selection_base_t.push_back (method) -ida_graph.screen_graph_selection_base_t.qclear (method) -ida_graph.screen_graph_selection_base_t.reserve (method) -ida_graph.screen_graph_selection_base_t.resize (method) -ida_graph.screen_graph_selection_base_t.size (method) -ida_graph.screen_graph_selection_base_t.swap (method) -ida_graph.screen_graph_selection_base_t.truncate (method) -ida_graph.screen_graph_selection_t (class) -ida_graph.screen_graph_selection_t.__init__ (method) -ida_graph.screen_graph_selection_t.add (method) -ida_graph.screen_graph_selection_t.add_node (method) -ida_graph.screen_graph_selection_t.add_point (method) -ida_graph.screen_graph_selection_t.del_node (method) -ida_graph.screen_graph_selection_t.del_point (method) -ida_graph.screen_graph_selection_t.has (method) -ida_graph.screen_graph_selection_t.items_count (method) -ida_graph.screen_graph_selection_t.nodes_count (method) -ida_graph.screen_graph_selection_t.points_count (method) -ida_graph.screen_graph_selection_t.sub (method) -ida_graph.selection_item_t (class) -ida_graph.selection_item_t.__eq__ (method) -ida_graph.selection_item_t.__init__ (method) -ida_graph.selection_item_t.__lt__ (method) -ida_graph.selection_item_t.__ne__ (method) -ida_graph.selection_item_t.compare (method) -ida_graph.selection_item_t.elp (variable) -ida_graph.selection_item_t.is_node (variable) -ida_graph.selection_item_t.node (variable) -ida_graph.set_node_info (function) -ida_graph.set_viewer_graph (function) -ida_graph.user_graph_place_t (class) -ida_graph.user_graph_place_t.__init__ (method) -ida_graph.viewer_attach_menu_item (function) -ida_graph.viewer_center_on (function) -ida_graph.viewer_create_groups (function) -ida_graph.viewer_del_node_info (function) -ida_graph.viewer_delete_groups (function) -ida_graph.viewer_fit_window (function) -ida_graph.viewer_get_curnode (function) -ida_graph.viewer_get_gli (function) -ida_graph.viewer_get_node_info (function) -ida_graph.viewer_get_selection (function) -ida_graph.viewer_set_gli (function) -ida_graph.viewer_set_groups_visibility (function) -ida_graph.viewer_set_node_info (function) -ida_graph.viewer_set_titlebar_height (function) -ida_ida (module) -ida_ida.ABI_8ALIGN4 (variable) -ida_ida.ABI_BIGARG_ALIGN (variable) -ida_ida.ABI_GCC_LAYOUT (variable) -ida_ida.ABI_HARD_FLOAT (variable) -ida_ida.ABI_HUGEARG_ALIGN (variable) -ida_ida.ABI_MAP_STKARGS (variable) -ida_ida.ABI_PACK_STKARGS (variable) -ida_ida.ABI_SET_BY_USER (variable) -ida_ida.ABI_STACK_LDBL (variable) -ida_ida.ABI_STACK_VARARGS (variable) -ida_ida.AF2_DOEH (variable) -ida_ida.AF2_DORTTI (variable) -ida_ida.AF2_MACRO (variable) -ida_ida.AF2_MERGESTR (variable) -ida_ida.AF_ANORET (variable) -ida_ida.AF_CHKUNI (variable) -ida_ida.AF_CODE (variable) -ida_ida.AF_DATOFF (variable) -ida_ida.AF_DOCODE (variable) -ida_ida.AF_DODATA (variable) -ida_ida.AF_DREFOFF (variable) -ida_ida.AF_FINAL (variable) -ida_ida.AF_FIXUP (variable) -ida_ida.AF_FLIRT (variable) -ida_ida.AF_FTAIL (variable) -ida_ida.AF_HFLIRT (variable) -ida_ida.AF_IMMOFF (variable) -ida_ida.AF_JFUNC (variable) -ida_ida.AF_JUMPTBL (variable) -ida_ida.AF_LVAR (variable) -ida_ida.AF_MARKCODE (variable) -ida_ida.AF_MEMFUNC (variable) -ida_ida.AF_NULLSUB (variable) -ida_ida.AF_PROC (variable) -ida_ida.AF_PROCPTR (variable) -ida_ida.AF_PURDAT (variable) -ida_ida.AF_REGARG (variable) -ida_ida.AF_SIGCMT (variable) -ida_ida.AF_SIGMLT (variable) -ida_ida.AF_STKARG (variable) -ida_ida.AF_STRLIT (variable) -ida_ida.AF_TRACE (variable) -ida_ida.AF_TRFUNC (variable) -ida_ida.AF_UNK (variable) -ida_ida.AF_USED (variable) -ida_ida.AF_VERSP (variable) -ida_ida.DEMNAM_CMNT (variable) -ida_ida.DEMNAM_FIRST (variable) -ida_ida.DEMNAM_GCC3 (variable) -ida_ida.DEMNAM_MASK (variable) -ida_ida.DEMNAM_NAME (variable) -ida_ida.DEMNAM_NONE (variable) -ida_ida.IDAINFO_TAG_SIZE (variable) -ida_ida.IDB_COMPRESSED (variable) -ida_ida.IDB_PACKED (variable) -ida_ida.IDB_UNPACKED (variable) -ida_ida.IDI_BITMAP (variable) -ida_ida.IDI_BYTEARRAY (variable) -ida_ida.IDI_CSTR (variable) -ida_ida.IDI_DEC (variable) -ida_ida.IDI_EA_HEX (variable) -ida_ida.IDI_HASH (variable) -ida_ida.IDI_HEX (variable) -ida_ida.IDI_HLPSTRUC (variable) -ida_ida.IDI_INC (variable) -ida_ida.IDI_MAP_VAL (variable) -ida_ida.IDI_NOMERGE (variable) -ida_ida.IDI_ONOFF (variable) -ida_ida.IDI_QSTRING (variable) -ida_ida.IDI_READONLY (variable) -ida_ida.IDI_SCALAR (variable) -ida_ida.IDI_STRUCFLD (variable) -ida_ida.INFFL_ALLASM (variable) -ida_ida.INFFL_AUTO (variable) -ida_ida.INFFL_CHKOPS (variable) -ida_ida.INFFL_GRAPH_VIEW (variable) -ida_ida.INFFL_LOADIDC (variable) -ida_ida.INFFL_NMOPS (variable) -ida_ida.INFFL_NOUSER (variable) -ida_ida.INFFL_READONLY (variable) -ida_ida.INF_ABINAME (variable) -ida_ida.INF_ARCHIVE_PATH (variable) -ida_ida.INF_CRC32 (variable) -ida_ida.INF_CTIME (variable) -ida_ida.INF_C_MACROS (variable) -ida_ida.INF_DBG_BINPATHS (variable) -ida_ida.INF_DUALOP_GRAPH (variable) -ida_ida.INF_DUALOP_TEXT (variable) -ida_ida.INF_ELAPSED (variable) -ida_ida.INF_FILE_FORMAT_NAME (variable) -ida_ida.INF_FSIZE (variable) -ida_ida.INF_GROUPS (variable) -ida_ida.INF_H_PATH (variable) -ida_ida.INF_IDA_VERSION (variable) -ida_ida.INF_IDSNODE (variable) -ida_ida.INF_IMAGEBASE (variable) -ida_ida.INF_INCLUDE (variable) -ida_ida.INF_INITIAL_VERSION (variable) -ida_ida.INF_MD5 (variable) -ida_ida.INF_NOPENS (variable) -ida_ida.INF_NOTEPAD (variable) -ida_ida.INF_OUTFILEENC (variable) -ida_ida.INF_PROBLEMS (variable) -ida_ida.INF_SELECTORS (variable) -ida_ida.INF_SHA256 (variable) -ida_ida.INF_SRCDBG_PATHS (variable) -ida_ida.INF_SRCDBG_UNDESIRED (variable) -ida_ida.INF_STR_ENCODINGS (variable) -ida_ida.LFLG_64BIT (variable) -ida_ida.LFLG_COMPRESS (variable) -ida_ida.LFLG_DBG_NOPATH (variable) -ida_ida.LFLG_FLAT_OFF32 (variable) -ida_ida.LFLG_IS_DLL (variable) -ida_ida.LFLG_KERNMODE (variable) -ida_ida.LFLG_MSF (variable) -ida_ida.LFLG_PACK (variable) -ida_ida.LFLG_PC_FLAT (variable) -ida_ida.LFLG_PC_FPP (variable) -ida_ida.LFLG_SNAPSHOT (variable) -ida_ida.LFLG_WIDE_HBF (variable) -ida_ida.LMT_EMPTY (variable) -ida_ida.LMT_THICK (variable) -ida_ida.LMT_THIN (variable) -ida_ida.LN_AUTO (variable) -ida_ida.LN_NORMAL (variable) -ida_ida.LN_PUBLIC (variable) -ida_ida.LN_WEAK (variable) -ida_ida.OFLG_GEN_ASSUME (variable) -ida_ida.OFLG_GEN_NULL (variable) -ida_ida.OFLG_GEN_ORG (variable) -ida_ida.OFLG_GEN_TRYBLKS (variable) -ida_ida.OFLG_LZERO (variable) -ida_ida.OFLG_PREF_SEG (variable) -ida_ida.OFLG_SHOW_AUTO (variable) -ida_ida.OFLG_SHOW_PREF (variable) -ida_ida.OFLG_SHOW_VOID (variable) -ida_ida.PREF_FNCOFF (variable) -ida_ida.PREF_PFXTRUNC (variable) -ida_ida.PREF_SEGADR (variable) -ida_ida.PREF_STACK (variable) -ida_ida.SCF_ALLCMT (variable) -ida_ida.SCF_LINNUM (variable) -ida_ida.SCF_NOCMT (variable) -ida_ida.SCF_RPTCMT (variable) -ida_ida.SCF_SHHID_FUNC (variable) -ida_ida.SCF_SHHID_ITEM (variable) -ida_ida.SCF_SHHID_SEGM (variable) -ida_ida.SCF_TESTMODE (variable) -ida_ida.STRF_AUTO (variable) -ida_ida.STRF_COMMENT (variable) -ida_ida.STRF_GEN (variable) -ida_ida.STRF_SAVECASE (variable) -ida_ida.STRF_SERIAL (variable) -ida_ida.STRF_UNICODE (variable) -ida_ida.STT_CUR (variable) -ida_ida.STT_DBG (variable) -ida_ida.STT_MM (variable) -ida_ida.STT_VA (variable) -ida_ida.SW_SEGXRF (variable) -ida_ida.SW_XRFFNC (variable) -ida_ida.SW_XRFMRK (variable) -ida_ida.SW_XRFVAL (variable) -ida_ida.UA_MAXOP (variable) -ida_ida.VLD_AUTO_REPAIR (variable) -ida_ida.VLD_DIALOG (variable) -ida_ida.VLD_SILENT (variable) -ida_ida.__make_idainfo_accessors (function) -ida_ida.__make_idainfo_bound (function) -ida_ida.__make_idainfo_bound.__func (function) -ida_ida.__make_idainfo_getter (function) -ida_ida.__set_module_dynattrs (function) -ida_ida.__wrap_hooks_callback (function) -ida_ida.__wrap_hooks_callback.__wrapper (function) -ida_ida.calc_default_idaplace_flags (function) -ida_ida.compiler_info_t (class) -ida_ida.compiler_info_t.__init__ (method) -ida_ida.compiler_info_t.cm (variable) -ida_ida.compiler_info_t.defalign (variable) -ida_ida.compiler_info_t.id (variable) -ida_ida.compiler_info_t.size_b (variable) -ida_ida.compiler_info_t.size_e (variable) -ida_ida.compiler_info_t.size_i (variable) -ida_ida.compiler_info_t.size_l (variable) -ida_ida.compiler_info_t.size_ldbl (variable) -ida_ida.compiler_info_t.size_ll (variable) -ida_ida.compiler_info_t.size_s (variable) -ida_ida.delinf (function) -ida_ida.f_AIXAR (variable) -ida_ida.f_AOUT (variable) -ida_ida.f_AR (variable) -ida_ida.f_BIN (variable) -ida_ida.f_COFF (variable) -ida_ida.f_COM (variable) -ida_ida.f_COM_old (variable) -ida_ida.f_DRV (variable) -ida_ida.f_ELF (variable) -ida_ida.f_EXE (variable) -ida_ida.f_EXE_old (variable) -ida_ida.f_HEX (variable) -ida_ida.f_LE (variable) -ida_ida.f_LOADER (variable) -ida_ida.f_LX (variable) -ida_ida.f_MACHO (variable) -ida_ida.f_MEX (variable) -ida_ida.f_NLM (variable) -ida_ida.f_OMF (variable) -ida_ida.f_OMFLIB (variable) -ida_ida.f_PE (variable) -ida_ida.f_PRC (variable) -ida_ida.f_PSXOBJ (variable) -ida_ida.f_SREC (variable) -ida_ida.f_W32RUN (variable) -ida_ida.f_WIN (variable) -ida_ida.f_ZIP (variable) -ida_ida.get_dbctx_id (function) -ida_ida.get_dbctx_qty (function) -ida_ida.getinf_str (function) -ida_ida.idainfo (class) -ida_ida.idainfo.__init__ (method) -ida_ida.idainfo._get_lflags (method) -ida_ida.idainfo._set_lflags (method) -ida_ida.idainfo.abibits (variable) -ida_ida.idainfo.af (variable) -ida_ida.idainfo.af2 (variable) -ida_ida.idainfo.appcall_options (variable) -ida_ida.idainfo.apptype (variable) -ida_ida.idainfo.asmtype (variable) -ida_ida.idainfo.baseaddr (variable) -ida_ida.idainfo.bin_prefix_size (variable) -ida_ida.idainfo.cc (variable) -ida_ida.idainfo.cmt_indent (variable) -ida_ida.idainfo.database_change_count (variable) -ida_ida.idainfo.datatypes (variable) -ida_ida.idainfo.demnames (variable) -ida_ida.idainfo.filetype (variable) -ida_ida.idainfo.get_abiname (method) -ida_ida.idainfo.highoff (variable) -ida_ida.idainfo.indent (variable) -ida_ida.idainfo.lenxref (variable) -ida_ida.idainfo.lflags (variable) -ida_ida.idainfo.listnames (variable) -ida_ida.idainfo.long_demnames (variable) -ida_ida.idainfo.lowoff (variable) -ida_ida.idainfo.main (variable) -ida_ida.idainfo.margin (variable) -ida_ida.idainfo.max_autoname_len (variable) -ida_ida.idainfo.max_ea (variable) -ida_ida.idainfo.maxref (variable) -ida_ida.idainfo.min_ea (variable) -ida_ida.idainfo.nametype (variable) -ida_ida.idainfo.omax_ea (variable) -ida_ida.idainfo.omin_ea (variable) -ida_ida.idainfo.ostype (variable) -ida_ida.idainfo.outflags (variable) -ida_ida.idainfo.procname (variable) -ida_ida.idainfo.refcmtnum (variable) -ida_ida.idainfo.s_cmtflg (variable) -ida_ida.idainfo.s_genflags (variable) -ida_ida.idainfo.s_limiter (variable) -ida_ida.idainfo.s_prefflag (variable) -ida_ida.idainfo.s_xrefflag (variable) -ida_ida.idainfo.short_demnames (variable) -ida_ida.idainfo.specsegs (variable) -ida_ida.idainfo.start_cs (variable) -ida_ida.idainfo.start_ea (variable) -ida_ida.idainfo.start_ip (variable) -ida_ida.idainfo.start_sp (variable) -ida_ida.idainfo.start_ss (variable) -ida_ida.idainfo.strlit_break (variable) -ida_ida.idainfo.strlit_flags (variable) -ida_ida.idainfo.strlit_pref (variable) -ida_ida.idainfo.strlit_sernum (variable) -ida_ida.idainfo.strlit_zeroes (variable) -ida_ida.idainfo.strtype (variable) -ida_ida.idainfo.tag (variable) -ida_ida.idainfo.type_xrefnum (variable) -ida_ida.idainfo.version (variable) -ida_ida.idainfo.xrefnum (variable) -ida_ida.idainfo_is_32bit (function) -ida_ida.idbattr_info_t (class) -ida_ida.idbattr_info_t.__init__ (method) -ida_ida.idbattr_info_t.__lt__ (method) -ida_ida.idbattr_info_t.bitmask (variable) -ida_ida.idbattr_info_t.has_individual_node (method) -ida_ida.idbattr_info_t.hashname (method) -ida_ida.idbattr_info_t.individual_node (variable) -ida_ida.idbattr_info_t.is_bitfield (method) -ida_ida.idbattr_info_t.is_bitmap (method) -ida_ida.idbattr_info_t.is_boolean (method) -ida_ida.idbattr_info_t.is_buf_var (method) -ida_ida.idbattr_info_t.is_bytearray (method) -ida_ida.idbattr_info_t.is_cstr (method) -ida_ida.idbattr_info_t.is_decimal (method) -ida_ida.idbattr_info_t.is_hash (method) -ida_ida.idbattr_info_t.is_hexadecimal (method) -ida_ida.idbattr_info_t.is_incremented (method) -ida_ida.idbattr_info_t.is_node_altval (method) -ida_ida.idbattr_info_t.is_node_blob (method) -ida_ida.idbattr_info_t.is_node_supval (method) -ida_ida.idbattr_info_t.is_node_valobj (method) -ida_ida.idbattr_info_t.is_node_var (method) -ida_ida.idbattr_info_t.is_onoff (method) -ida_ida.idbattr_info_t.is_qstring (method) -ida_ida.idbattr_info_t.is_readonly_var (method) -ida_ida.idbattr_info_t.is_scalar_var (method) -ida_ida.idbattr_info_t.is_struc_field (method) -ida_ida.idbattr_info_t.is_val_mapped (method) -ida_ida.idbattr_info_t.maxsize (variable) -ida_ida.idbattr_info_t.name (variable) -ida_ida.idbattr_info_t.offset (variable) -ida_ida.idbattr_info_t.ridx (method) -ida_ida.idbattr_info_t.str_false (method) -ida_ida.idbattr_info_t.str_true (method) -ida_ida.idbattr_info_t.tag (variable) -ida_ida.idbattr_info_t.use_hlpstruc (method) -ida_ida.idbattr_info_t.vmap (variable) -ida_ida.idbattr_info_t.width (variable) -ida_ida.idbattr_valmap_t (class) -ida_ida.idbattr_valmap_t.__init__ (method) -ida_ida.inf_abi_set_by_user (function) -ida_ida.inf_allow_non_matched_ops (function) -ida_ida.inf_allow_sigmulti (function) -ida_ida.inf_append_sigcmt (function) -ida_ida.inf_big_arg_align (function) -ida_ida.inf_check_manual_ops (function) -ida_ida.inf_check_unicode_strlits (function) -ida_ida.inf_coagulate_code (function) -ida_ida.inf_coagulate_data (function) -ida_ida.inf_compress_idb (function) -ida_ida.inf_create_all_xrefs (function) -ida_ida.inf_create_func_from_call (function) -ida_ida.inf_create_func_from_ptr (function) -ida_ida.inf_create_func_tails (function) -ida_ida.inf_create_jump_tables (function) -ida_ida.inf_create_off_on_dref (function) -ida_ida.inf_create_off_using_fixup (function) -ida_ida.inf_create_strlit_on_xref (function) -ida_ida.inf_data_offset (function) -ida_ida.inf_dbg_no_store_path (function) -ida_ida.inf_decode_fpp (function) -ida_ida.inf_del_no_xref_insns (function) -ida_ida.inf_final_pass (function) -ida_ida.inf_full_sp_ana (function) -ida_ida.inf_gen_assume (function) -ida_ida.inf_gen_lzero (function) -ida_ida.inf_gen_null (function) -ida_ida.inf_gen_org (function) -ida_ida.inf_gen_tryblks (function) -ida_ida.inf_get_abibits (function) -ida_ida.inf_get_af (function) -ida_ida.inf_get_af2 (function) -ida_ida.inf_get_af2_low (function) -ida_ida.inf_get_af_high (function) -ida_ida.inf_get_af_low (function) -ida_ida.inf_get_app_bitness (function) -ida_ida.inf_get_appcall_options (function) -ida_ida.inf_get_apptype (function) -ida_ida.inf_get_asmtype (function) -ida_ida.inf_get_baseaddr (function) -ida_ida.inf_get_bin_prefix_size (function) -ida_ida.inf_get_cc (function) -ida_ida.inf_get_cc_cm (function) -ida_ida.inf_get_cc_defalign (function) -ida_ida.inf_get_cc_id (function) -ida_ida.inf_get_cc_size_b (function) -ida_ida.inf_get_cc_size_e (function) -ida_ida.inf_get_cc_size_i (function) -ida_ida.inf_get_cc_size_l (function) -ida_ida.inf_get_cc_size_ldbl (function) -ida_ida.inf_get_cc_size_ll (function) -ida_ida.inf_get_cc_size_s (function) -ida_ida.inf_get_cmt_indent (function) -ida_ida.inf_get_cmtflg (function) -ida_ida.inf_get_database_change_count (function) -ida_ida.inf_get_datatypes (function) -ida_ida.inf_get_demname_form (function) -ida_ida.inf_get_demnames (function) -ida_ida.inf_get_filetype (function) -ida_ida.inf_get_genflags (function) -ida_ida.inf_get_highoff (function) -ida_ida.inf_get_indent (function) -ida_ida.inf_get_lenxref (function) -ida_ida.inf_get_lflags (function) -ida_ida.inf_get_limiter (function) -ida_ida.inf_get_listnames (function) -ida_ida.inf_get_long_demnames (function) -ida_ida.inf_get_lowoff (function) -ida_ida.inf_get_main (function) -ida_ida.inf_get_margin (function) -ida_ida.inf_get_max_autoname_len (function) -ida_ida.inf_get_max_ea (function) -ida_ida.inf_get_maxref (function) -ida_ida.inf_get_min_ea (function) -ida_ida.inf_get_nametype (function) -ida_ida.inf_get_netdelta (function) -ida_ida.inf_get_omax_ea (function) -ida_ida.inf_get_omin_ea (function) -ida_ida.inf_get_ostype (function) -ida_ida.inf_get_outflags (function) -ida_ida.inf_get_pack_mode (function) -ida_ida.inf_get_prefflag (function) -ida_ida.inf_get_privrange (function) -ida_ida.inf_get_privrange_end_ea (function) -ida_ida.inf_get_privrange_start_ea (function) -ida_ida.inf_get_procname (function) -ida_ida.inf_get_refcmtnum (function) -ida_ida.inf_get_short_demnames (function) -ida_ida.inf_get_specsegs (function) -ida_ida.inf_get_start_cs (function) -ida_ida.inf_get_start_ea (function) -ida_ida.inf_get_start_ip (function) -ida_ida.inf_get_start_sp (function) -ida_ida.inf_get_start_ss (function) -ida_ida.inf_get_strlit_break (function) -ida_ida.inf_get_strlit_flags (function) -ida_ida.inf_get_strlit_pref (function) -ida_ida.inf_get_strlit_sernum (function) -ida_ida.inf_get_strlit_zeroes (function) -ida_ida.inf_get_strtype (function) -ida_ida.inf_get_type_xrefnum (function) -ida_ida.inf_get_version (function) -ida_ida.inf_get_xrefflag (function) -ida_ida.inf_get_xrefnum (function) -ida_ida.inf_guess_func_type (function) -ida_ida.inf_handle_eh (function) -ida_ida.inf_handle_rtti (function) -ida_ida.inf_hide_comments (function) -ida_ida.inf_hide_libfuncs (function) -ida_ida.inf_huge_arg_align (function) -ida_ida.inf_inc_database_change_count (function) -ida_ida.inf_is_16bit (function) -ida_ida.inf_is_32bit_exactly (function) -ida_ida.inf_is_32bit_or_higher (function) -ida_ida.inf_is_64bit (function) -ida_ida.inf_is_auto_enabled (function) -ida_ida.inf_is_be (function) -ida_ida.inf_is_dll (function) -ida_ida.inf_is_flat_off32 (function) -ida_ida.inf_is_graph_view (function) -ida_ida.inf_is_hard_float (function) -ida_ida.inf_is_kernel_mode (function) -ida_ida.inf_is_limiter_empty (function) -ida_ida.inf_is_limiter_thick (function) -ida_ida.inf_is_limiter_thin (function) -ida_ida.inf_is_mem_aligned4 (function) -ida_ida.inf_is_snapshot (function) -ida_ida.inf_is_wide_high_byte_first (function) -ida_ida.inf_like_binary (function) -ida_ida.inf_line_pref_with_seg (function) -ida_ida.inf_loading_idc (function) -ida_ida.inf_macros_enabled (function) -ida_ida.inf_map_stkargs (function) -ida_ida.inf_mark_code (function) -ida_ida.inf_merge_strlits (function) -ida_ida.inf_no_store_user_info (function) -ida_ida.inf_noflow_to_data (function) -ida_ida.inf_noret_ana (function) -ida_ida.inf_op_offset (function) -ida_ida.inf_pack_idb (function) -ida_ida.inf_pack_stkargs (function) -ida_ida.inf_postinc_strlit_sernum (function) -ida_ida.inf_prefix_show_funcoff (function) -ida_ida.inf_prefix_show_segaddr (function) -ida_ida.inf_prefix_show_stack (function) -ida_ida.inf_prefix_truncate_opcode_bytes (function) -ida_ida.inf_propagate_regargs (function) -ida_ida.inf_propagate_stkargs (function) -ida_ida.inf_readonly_idb (function) -ida_ida.inf_rename_jumpfunc (function) -ida_ida.inf_rename_nullsub (function) -ida_ida.inf_set_32bit (function) -ida_ida.inf_set_64bit (function) -ida_ida.inf_set_abi_set_by_user (function) -ida_ida.inf_set_abibits (function) -ida_ida.inf_set_af (function) -ida_ida.inf_set_af2 (function) -ida_ida.inf_set_af2_low (function) -ida_ida.inf_set_af_high (function) -ida_ida.inf_set_af_low (function) -ida_ida.inf_set_allow_non_matched_ops (function) -ida_ida.inf_set_allow_sigmulti (function) -ida_ida.inf_set_app_bitness (function) -ida_ida.inf_set_appcall_options (function) -ida_ida.inf_set_append_sigcmt (function) -ida_ida.inf_set_apptype (function) -ida_ida.inf_set_asmtype (function) -ida_ida.inf_set_auto_enabled (function) -ida_ida.inf_set_baseaddr (function) -ida_ida.inf_set_be (function) -ida_ida.inf_set_big_arg_align (function) -ida_ida.inf_set_bin_prefix_size (function) -ida_ida.inf_set_cc (function) -ida_ida.inf_set_cc_cm (function) -ida_ida.inf_set_cc_defalign (function) -ida_ida.inf_set_cc_id (function) -ida_ida.inf_set_cc_size_b (function) -ida_ida.inf_set_cc_size_e (function) -ida_ida.inf_set_cc_size_i (function) -ida_ida.inf_set_cc_size_l (function) -ida_ida.inf_set_cc_size_ldbl (function) -ida_ida.inf_set_cc_size_ll (function) -ida_ida.inf_set_cc_size_s (function) -ida_ida.inf_set_check_manual_ops (function) -ida_ida.inf_set_check_unicode_strlits (function) -ida_ida.inf_set_cmt_indent (function) -ida_ida.inf_set_cmtflg (function) -ida_ida.inf_set_coagulate_code (function) -ida_ida.inf_set_coagulate_data (function) -ida_ida.inf_set_compress_idb (function) -ida_ida.inf_set_create_all_xrefs (function) -ida_ida.inf_set_create_func_from_call (function) -ida_ida.inf_set_create_func_from_ptr (function) -ida_ida.inf_set_create_func_tails (function) -ida_ida.inf_set_create_jump_tables (function) -ida_ida.inf_set_create_off_on_dref (function) -ida_ida.inf_set_create_off_using_fixup (function) -ida_ida.inf_set_create_strlit_on_xref (function) -ida_ida.inf_set_data_offset (function) -ida_ida.inf_set_database_change_count (function) -ida_ida.inf_set_datatypes (function) -ida_ida.inf_set_dbg_no_store_path (function) -ida_ida.inf_set_decode_fpp (function) -ida_ida.inf_set_del_no_xref_insns (function) -ida_ida.inf_set_demnames (function) -ida_ida.inf_set_dll (function) -ida_ida.inf_set_filetype (function) -ida_ida.inf_set_final_pass (function) -ida_ida.inf_set_flat_off32 (function) -ida_ida.inf_set_full_sp_ana (function) -ida_ida.inf_set_gen_assume (function) -ida_ida.inf_set_gen_lzero (function) -ida_ida.inf_set_gen_null (function) -ida_ida.inf_set_gen_org (function) -ida_ida.inf_set_gen_tryblks (function) -ida_ida.inf_set_genflags (function) -ida_ida.inf_set_graph_view (function) -ida_ida.inf_set_guess_func_type (function) -ida_ida.inf_set_handle_eh (function) -ida_ida.inf_set_handle_rtti (function) -ida_ida.inf_set_hard_float (function) -ida_ida.inf_set_hide_comments (function) -ida_ida.inf_set_hide_libfuncs (function) -ida_ida.inf_set_highoff (function) -ida_ida.inf_set_huge_arg_align (function) -ida_ida.inf_set_indent (function) -ida_ida.inf_set_kernel_mode (function) -ida_ida.inf_set_lenxref (function) -ida_ida.inf_set_lflags (function) -ida_ida.inf_set_limiter (function) -ida_ida.inf_set_limiter_empty (function) -ida_ida.inf_set_limiter_thick (function) -ida_ida.inf_set_limiter_thin (function) -ida_ida.inf_set_line_pref_with_seg (function) -ida_ida.inf_set_listnames (function) -ida_ida.inf_set_loading_idc (function) -ida_ida.inf_set_long_demnames (function) -ida_ida.inf_set_lowoff (function) -ida_ida.inf_set_macros_enabled (function) -ida_ida.inf_set_main (function) -ida_ida.inf_set_map_stkargs (function) -ida_ida.inf_set_margin (function) -ida_ida.inf_set_mark_code (function) -ida_ida.inf_set_max_autoname_len (function) -ida_ida.inf_set_max_ea (function) -ida_ida.inf_set_maxref (function) -ida_ida.inf_set_mem_aligned4 (function) -ida_ida.inf_set_merge_strlits (function) -ida_ida.inf_set_min_ea (function) -ida_ida.inf_set_nametype (function) -ida_ida.inf_set_netdelta (function) -ida_ida.inf_set_no_store_user_info (function) -ida_ida.inf_set_noflow_to_data (function) -ida_ida.inf_set_noret_ana (function) -ida_ida.inf_set_omax_ea (function) -ida_ida.inf_set_omin_ea (function) -ida_ida.inf_set_op_offset (function) -ida_ida.inf_set_ostype (function) -ida_ida.inf_set_outflags (function) -ida_ida.inf_set_pack_idb (function) -ida_ida.inf_set_pack_mode (function) -ida_ida.inf_set_pack_stkargs (function) -ida_ida.inf_set_prefflag (function) -ida_ida.inf_set_prefix_show_funcoff (function) -ida_ida.inf_set_prefix_show_segaddr (function) -ida_ida.inf_set_prefix_show_stack (function) -ida_ida.inf_set_prefix_truncate_opcode_bytes (function) -ida_ida.inf_set_privrange (function) -ida_ida.inf_set_privrange_end_ea (function) -ida_ida.inf_set_privrange_start_ea (function) -ida_ida.inf_set_procname (function) -ida_ida.inf_set_propagate_regargs (function) -ida_ida.inf_set_propagate_stkargs (function) -ida_ida.inf_set_readonly_idb (function) -ida_ida.inf_set_refcmtnum (function) -ida_ida.inf_set_rename_jumpfunc (function) -ida_ida.inf_set_rename_nullsub (function) -ida_ida.inf_set_short_demnames (function) -ida_ida.inf_set_should_create_stkvars (function) -ida_ida.inf_set_should_trace_sp (function) -ida_ida.inf_set_show_all_comments (function) -ida_ida.inf_set_show_auto (function) -ida_ida.inf_set_show_hidden_funcs (function) -ida_ida.inf_set_show_hidden_insns (function) -ida_ida.inf_set_show_hidden_segms (function) -ida_ida.inf_set_show_line_pref (function) -ida_ida.inf_set_show_repeatables (function) -ida_ida.inf_set_show_src_linnum (function) -ida_ida.inf_set_show_void (function) -ida_ida.inf_set_show_xref_fncoff (function) -ida_ida.inf_set_show_xref_seg (function) -ida_ida.inf_set_show_xref_tmarks (function) -ida_ida.inf_set_show_xref_val (function) -ida_ida.inf_set_snapshot (function) -ida_ida.inf_set_specsegs (function) -ida_ida.inf_set_stack_ldbl (function) -ida_ida.inf_set_stack_varargs (function) -ida_ida.inf_set_start_cs (function) -ida_ida.inf_set_start_ea (function) -ida_ida.inf_set_start_ip (function) -ida_ida.inf_set_start_sp (function) -ida_ida.inf_set_start_ss (function) -ida_ida.inf_set_strlit_autocmt (function) -ida_ida.inf_set_strlit_break (function) -ida_ida.inf_set_strlit_flags (function) -ida_ida.inf_set_strlit_name_bit (function) -ida_ida.inf_set_strlit_names (function) -ida_ida.inf_set_strlit_pref (function) -ida_ida.inf_set_strlit_savecase (function) -ida_ida.inf_set_strlit_serial_names (function) -ida_ida.inf_set_strlit_sernum (function) -ida_ida.inf_set_strlit_zeroes (function) -ida_ida.inf_set_strtype (function) -ida_ida.inf_set_trace_flow (function) -ida_ida.inf_set_truncate_on_del (function) -ida_ida.inf_set_type_xrefnum (function) -ida_ida.inf_set_unicode_strlits (function) -ida_ida.inf_set_use_allasm (function) -ida_ida.inf_set_use_flirt (function) -ida_ida.inf_set_use_gcc_layout (function) -ida_ida.inf_set_version (function) -ida_ida.inf_set_wide_high_byte_first (function) -ida_ida.inf_set_xrefflag (function) -ida_ida.inf_set_xrefnum (function) -ida_ida.inf_should_create_stkvars (function) -ida_ida.inf_should_trace_sp (function) -ida_ida.inf_show_all_comments (function) -ida_ida.inf_show_auto (function) -ida_ida.inf_show_hidden_funcs (function) -ida_ida.inf_show_hidden_insns (function) -ida_ida.inf_show_hidden_segms (function) -ida_ida.inf_show_line_pref (function) -ida_ida.inf_show_repeatables (function) -ida_ida.inf_show_src_linnum (function) -ida_ida.inf_show_void (function) -ida_ida.inf_show_xref_fncoff (function) -ida_ida.inf_show_xref_seg (function) -ida_ida.inf_show_xref_tmarks (function) -ida_ida.inf_show_xref_val (function) -ida_ida.inf_stack_ldbl (function) -ida_ida.inf_stack_varargs (function) -ida_ida.inf_strlit_autocmt (function) -ida_ida.inf_strlit_name_bit (function) -ida_ida.inf_strlit_names (function) -ida_ida.inf_strlit_savecase (function) -ida_ida.inf_strlit_serial_names (function) -ida_ida.inf_test_mode (function) -ida_ida.inf_trace_flow (function) -ida_ida.inf_truncate_on_del (function) -ida_ida.inf_unicode_strlits (function) -ida_ida.inf_use_allasm (function) -ida_ida.inf_use_flirt (function) -ida_ida.inf_use_gcc_layout (function) -ida_ida.is_database_busy (function) -ida_ida.is_filetype_like_binary (function) -ida_ida.move_privrange (function) -ida_ida.switch_dbctx (function) -ida_ida.to_ea (function) -ida_ida.validate_idb (function) -ida_idaapi (module) -ida_idaapi.IDAPython_ExecScript (function) -ida_idaapi.IDAPython_ExecSystem (function) -ida_idaapi.IDAPython_FormatExc (function) -ida_idaapi.IDAPython_LoadProcMod (function) -ida_idaapi.IDAPython_UnLoadProcMod (function) -ida_idaapi.IDAPython_displayhook (class) -ida_idaapi.IDAPython_displayhook.__init__ (method) -ida_idaapi.IDAPython_displayhook._print_hex (method) -ida_idaapi.IDAPython_displayhook.displayhook (method) -ida_idaapi.IDAPython_displayhook.format_item (method) -ida_idaapi.IDAPython_displayhook.format_seq (method) -ida_idaapi.NW_CLOSEIDB (variable) -ida_idaapi.NW_INITIDA (variable) -ida_idaapi.NW_OPENIDB (variable) -ida_idaapi.NW_REMOVE (variable) -ida_idaapi.NW_TERMIDA (variable) -ida_idaapi.PY_ICID_BYREF (variable) -ida_idaapi.PY_ICID_INT64 (variable) -ida_idaapi.PY_ICID_OPAQUE (variable) -ida_idaapi.PyIdc_cvt_int64__ (class) -ida_idaapi.PyIdc_cvt_int64__.__add__ (method) -ida_idaapi.PyIdc_cvt_int64__.__div__ (method) -ida_idaapi.PyIdc_cvt_int64__.__init__ (method) -ida_idaapi.PyIdc_cvt_int64__.__mul__ (method) -ida_idaapi.PyIdc_cvt_int64__.__op (method) -ida_idaapi.PyIdc_cvt_int64__.__radd__ (method) -ida_idaapi.PyIdc_cvt_int64__.__rdiv__ (method) -ida_idaapi.PyIdc_cvt_int64__.__rmul__ (method) -ida_idaapi.PyIdc_cvt_int64__.__rsub__ (method) -ida_idaapi.PyIdc_cvt_int64__.__sub__ (method) -ida_idaapi.PyIdc_cvt_refclass__ (class) -ida_idaapi.PyIdc_cvt_refclass__.__init__ (method) -ida_idaapi.PyIdc_cvt_refclass__.cstr (method) -ida_idaapi.ST_OVER_DEBUG_SEG (variable) -ida_idaapi.ST_OVER_LIB_FUNC (variable) -ida_idaapi.TRUNC (function) -ida_idaapi.__IDAPython_Completion_Util (class) -ida_idaapi.__IDAPython_Completion_Util.__call__ (method) -ida_idaapi.__IDAPython_Completion_Util.__init__ (method) -ida_idaapi.__IDAPython_Completion_Util.debug (method) -ida_idaapi.__IDAPython_Completion_Util.dir_namespace (method) -ida_idaapi.__IDAPython_Completion_Util.get_candidates (method) -ida_idaapi.__IDAPython_Completion_Util.maybe_extend_syntactically (method) -ida_idaapi.__install_excepthook (function) -ida_idaapi._bounded_getitem_iterator (function) -ida_idaapi._listify_types (function) -ida_idaapi._make_missed_695bwcompat_property (function) -ida_idaapi._make_missed_695bwcompat_property._getter (function) -ida_idaapi._make_missed_695bwcompat_property._setter (function) -ida_idaapi._make_one_time_warning_message (function) -ida_idaapi._make_one_time_warning_message.f (function) -ida_idaapi._qvector_back (function) -ida_idaapi._qvector_front (function) -ida_idaapi._replace_module_function (function) -ida_idaapi.as_UTF16 (function) -ida_idaapi.as_cstr (function) -ida_idaapi.as_int32 (function) -ida_idaapi.as_signed (function) -ida_idaapi.as_uint32 (function) -ida_idaapi.copy_bits (function) -ida_idaapi.disable_script_timeout (function) -ida_idaapi.enable_extlang_python (function) -ida_idaapi.enable_python_cli (function) -ida_idaapi.format_basestring (function) -ida_idaapi.get_inf_structure (function) -ida_idaapi.loader_input_t (class) -ida_idaapi.loader_input_t.__init__ (method) -ida_idaapi.loader_input_t.close (method) -ida_idaapi.loader_input_t.file2base (method) -ida_idaapi.loader_input_t.filename (method) -ida_idaapi.loader_input_t.from_capsule (method) -ida_idaapi.loader_input_t.from_fp (method) -ida_idaapi.loader_input_t.from_linput (method) -ida_idaapi.loader_input_t.get_byte (method) -ida_idaapi.loader_input_t.get_linput (method) -ida_idaapi.loader_input_t.gets (method) -ida_idaapi.loader_input_t.getz (method) -ida_idaapi.loader_input_t.open (method) -ida_idaapi.loader_input_t.open_memory (method) -ida_idaapi.loader_input_t.opened (method) -ida_idaapi.loader_input_t.read (method) -ida_idaapi.loader_input_t.readbytes (method) -ida_idaapi.loader_input_t.seek (method) -ida_idaapi.loader_input_t.set_linput (method) -ida_idaapi.loader_input_t.size (method) -ida_idaapi.loader_input_t.tell (method) -ida_idaapi.loader_input_t_from_capsule (function) -ida_idaapi.loader_input_t_from_fp (function) -ida_idaapi.loader_input_t_from_linput (function) -ida_idaapi.notify_when (function) -ida_idaapi.object_t (class) -ida_idaapi.object_t.__getitem__ (method) -ida_idaapi.object_t.__init__ (method) -ida_idaapi.parse_command_line3 (function) -ida_idaapi.plugin_t (class) -ida_idaapi.plugin_t.run (method) -ida_idaapi.plugin_t.term (method) -ida_idaapi.plugmod_t (class) -ida_idaapi.py_clinked_object_t (class) -ida_idaapi.py_clinked_object_t.__del__ (method) -ida_idaapi.py_clinked_object_t.__init__ (method) -ida_idaapi.py_clinked_object_t._create_clink (method) -ida_idaapi.py_clinked_object_t._del_clink (method) -ida_idaapi.py_clinked_object_t._free (method) -ida_idaapi.py_clinked_object_t._get_clink_ptr (method) -ida_idaapi.py_clinked_object_t.assign (method) -ida_idaapi.py_clinked_object_t.clink (variable) -ida_idaapi.py_clinked_object_t.clink_ptr (variable) -ida_idaapi.py_clinked_object_t.copy (method) -ida_idaapi.pycim_get_widget (function) -ida_idaapi.pycim_view_close (function) -ida_idaapi.pygc_create_groups (function) -ida_idaapi.pygc_delete_groups (function) -ida_idaapi.pygc_refresh (function) -ida_idaapi.pygc_set_groups_visibility (function) -ida_idaapi.pyidc_cvt_helper__ (class) -ida_idaapi.pyidc_cvt_helper__.__get_value (method) -ida_idaapi.pyidc_cvt_helper__.__init__ (method) -ida_idaapi.pyidc_cvt_helper__.__set_value (method) -ida_idaapi.pyidc_opaque_object_t (class) -ida_idaapi.replfun (function) -ida_idaapi.require (function) -ida_idaapi.set_script_timeout (function) -ida_idaapi.struct_unpack (function) -ida_idc (module) -ida_idc.get_mark_comment (function) -ida_idc.get_marked_pos (function) -ida_idc.mark_position (function) -ida_idd (module) -ida_idd.APPCALL_DEBEV (variable) -ida_idd.APPCALL_MANUAL (variable) -ida_idd.APPCALL_TIMEOUT (variable) -ida_idd.Appcall__ (class) -ida_idd.Appcall__.APPCALL_DEBEV (variable) -ida_idd.Appcall__.APPCALL_MANUAL (variable) -ida_idd.Appcall__.APPCALL_TIMEOUT (variable) -ida_idd.Appcall__.Consts (variable) -ida_idd.Appcall__.UTF16 (method) -ida_idd.Appcall__.__get_consts (method) -ida_idd.Appcall__.__getattr__ (method) -ida_idd.Appcall__.__getitem__ (method) -ida_idd.Appcall__.__init__ (method) -ida_idd.Appcall__.__name_or_ea (method) -ida_idd.Appcall__.__typedecl_or_tinfo (method) -ida_idd.Appcall__.array (method) -ida_idd.Appcall__.buffer (method) -ida_idd.Appcall__.byref (method) -ida_idd.Appcall__.cleanup_appcall (method) -ida_idd.Appcall__.cstr (method) -ida_idd.Appcall__.get_appcall_options (method) -ida_idd.Appcall__.int64 (method) -ida_idd.Appcall__.obj (method) -ida_idd.Appcall__.proto (method) -ida_idd.Appcall__.set_appcall_options (method) -ida_idd.Appcall__.typedobj (method) -ida_idd.Appcall__.valueof (method) -ida_idd.Appcall_array__ (class) -ida_idd.Appcall_array__.__init__ (method) -ida_idd.Appcall_array__.pack (method) -ida_idd.Appcall_array__.try_to_convert_to_list (method) -ida_idd.Appcall_array__.unpack (method) -ida_idd.Appcall_callable__ (class) -ida_idd.Appcall_callable__.__call__ (method) -ida_idd.Appcall_callable__.__get_ea (method) -ida_idd.Appcall_callable__.__get_fields (method) -ida_idd.Appcall_callable__.__get_options (method) -ida_idd.Appcall_callable__.__get_size (method) -ida_idd.Appcall_callable__.__get_tif (method) -ida_idd.Appcall_callable__.__get_timeout (method) -ida_idd.Appcall_callable__.__get_type (method) -ida_idd.Appcall_callable__.__init__ (method) -ida_idd.Appcall_callable__.__set_ea (method) -ida_idd.Appcall_callable__.__set_options (method) -ida_idd.Appcall_callable__.__set_timeout (method) -ida_idd.Appcall_callable__.ea (variable) -ida_idd.Appcall_callable__.fields (variable) -ida_idd.Appcall_callable__.options (variable) -ida_idd.Appcall_callable__.retrieve (method) -ida_idd.Appcall_callable__.size (variable) -ida_idd.Appcall_callable__.store (method) -ida_idd.Appcall_callable__.tif (variable) -ida_idd.Appcall_callable__.timeout (variable) -ida_idd.Appcall_callable__.type (variable) -ida_idd.Appcall_consts__ (class) -ida_idd.Appcall_consts__.__getattr__ (method) -ida_idd.Appcall_consts__.__init__ (method) -ida_idd.BPT_BAD_ADDR (variable) -ida_idd.BPT_BAD_ALIGN (variable) -ida_idd.BPT_BAD_LEN (variable) -ida_idd.BPT_BAD_TYPE (variable) -ida_idd.BPT_DEFAULT (variable) -ida_idd.BPT_EXEC (variable) -ida_idd.BPT_INTERNAL_ERR (variable) -ida_idd.BPT_OK (variable) -ida_idd.BPT_PAGE_OK (variable) -ida_idd.BPT_RDWR (variable) -ida_idd.BPT_READ (variable) -ida_idd.BPT_READ_ERROR (variable) -ida_idd.BPT_SKIP (variable) -ida_idd.BPT_SOFT (variable) -ida_idd.BPT_TOO_MANY (variable) -ida_idd.BPT_WRITE (variable) -ida_idd.BPT_WRITE_ERROR (variable) -ida_idd.BREAKPOINT (variable) -ida_idd.DBG_FLAG_ADD_ENVS (variable) -ida_idd.DBG_FLAG_ANYSIZE_HWBPT (variable) -ida_idd.DBG_FLAG_CAN_CONT_BPT (variable) -ida_idd.DBG_FLAG_CLEAN_EXIT (variable) -ida_idd.DBG_FLAG_CONNSTRING (variable) -ida_idd.DBG_FLAG_DEBTHREAD (variable) -ida_idd.DBG_FLAG_DEBUG_DLL (variable) -ida_idd.DBG_FLAG_DONT_DISTURB (variable) -ida_idd.DBG_FLAG_EXITSHOTOK (variable) -ida_idd.DBG_FLAG_FAKE_ATTACH (variable) -ida_idd.DBG_FLAG_FAKE_MEMORY (variable) -ida_idd.DBG_FLAG_FAST_STEP (variable) -ida_idd.DBG_FLAG_HWDATBPT_ONE (variable) -ida_idd.DBG_FLAG_LAZY_WATCHPTS (variable) -ida_idd.DBG_FLAG_LOWCNDS (variable) -ida_idd.DBG_FLAG_MANMEMINFO (variable) -ida_idd.DBG_FLAG_MERGE_ENVS (variable) -ida_idd.DBG_FLAG_NEEDPORT (variable) -ida_idd.DBG_FLAG_NOHOST (variable) -ida_idd.DBG_FLAG_NOPARAMETERS (variable) -ida_idd.DBG_FLAG_NOPASSWORD (variable) -ida_idd.DBG_FLAG_NOSTARTDIR (variable) -ida_idd.DBG_FLAG_PREFER_SWBPTS (variable) -ida_idd.DBG_FLAG_REMOTE (variable) -ida_idd.DBG_FLAG_SAFE (variable) -ida_idd.DBG_FLAG_SMALLBLKS (variable) -ida_idd.DBG_FLAG_TRACER_MODULE (variable) -ida_idd.DBG_FLAG_USE_SREGS (variable) -ida_idd.DBG_FLAG_VIRTHREADS (variable) -ida_idd.DBG_HAS_APPCALL (variable) -ida_idd.DBG_HAS_ATTACH_PROCESS (variable) -ida_idd.DBG_HAS_CHECK_BPT (variable) -ida_idd.DBG_HAS_DETACH_PROCESS (variable) -ida_idd.DBG_HAS_GET_PROCESSES (variable) -ida_idd.DBG_HAS_MAP_ADDRESS (variable) -ida_idd.DBG_HAS_OPEN_FILE (variable) -ida_idd.DBG_HAS_REQUEST_PAUSE (variable) -ida_idd.DBG_HAS_REXEC (variable) -ida_idd.DBG_HAS_SET_EXCEPTION_INFO (variable) -ida_idd.DBG_HAS_SET_RESUME_MODE (variable) -ida_idd.DBG_HAS_THREAD_CONTINUE (variable) -ida_idd.DBG_HAS_THREAD_GET_SREG_BASE (variable) -ida_idd.DBG_HAS_THREAD_SUSPEND (variable) -ida_idd.DBG_HAS_UPDATE_CALL_STACK (variable) -ida_idd.DBG_HIDE_WINDOW (variable) -ida_idd.DBG_NO_ASLR (variable) -ida_idd.DBG_NO_TRACE (variable) -ida_idd.DBG_PROC_32BIT (variable) -ida_idd.DBG_PROC_64BIT (variable) -ida_idd.DBG_PROC_IS_DLL (variable) -ida_idd.DBG_PROC_IS_GUI (variable) -ida_idd.DBG_RESMOD_STEP_HANDLE (variable) -ida_idd.DBG_RESMOD_STEP_INTO (variable) -ida_idd.DBG_RESMOD_STEP_OUT (variable) -ida_idd.DBG_RESMOD_STEP_OVER (variable) -ida_idd.DBG_RESMOD_STEP_SRCINTO (variable) -ida_idd.DBG_RESMOD_STEP_SRCOUT (variable) -ida_idd.DBG_RESMOD_STEP_SRCOVER (variable) -ida_idd.DBG_RESMOD_STEP_USER (variable) -ida_idd.DBG_SUSPENDED (variable) -ida_idd.DEBUGGER_ID_6811_EMULATOR (variable) -ida_idd.DEBUGGER_ID_ARM_IPHONE_USER (variable) -ida_idd.DEBUGGER_ID_ARM_LINUX_USER (variable) -ida_idd.DEBUGGER_ID_ARM_MACOS_USER (variable) -ida_idd.DEBUGGER_ID_DALVIK_USER (variable) -ida_idd.DEBUGGER_ID_GDB_USER (variable) -ida_idd.DEBUGGER_ID_TRACE_REPLAYER (variable) -ida_idd.DEBUGGER_ID_WINDBG (variable) -ida_idd.DEBUGGER_ID_X86_DOSBOX_EMULATOR (variable) -ida_idd.DEBUGGER_ID_X86_IA32_BOCHS (variable) -ida_idd.DEBUGGER_ID_X86_IA32_LINUX_USER (variable) -ida_idd.DEBUGGER_ID_X86_IA32_MACOSX_USER (variable) -ida_idd.DEBUGGER_ID_X86_IA32_WIN32_USER (variable) -ida_idd.DEBUGGER_ID_X86_PIN_TRACER (variable) -ida_idd.DEBUGGER_ID_XNU_USER (variable) -ida_idd.DRC_CRC (variable) -ida_idd.DRC_ERROR (variable) -ida_idd.DRC_EVENTS (variable) -ida_idd.DRC_FAILED (variable) -ida_idd.DRC_IDBSEG (variable) -ida_idd.DRC_NETERR (variable) -ida_idd.DRC_NOCHG (variable) -ida_idd.DRC_NOFILE (variable) -ida_idd.DRC_NONE (variable) -ida_idd.DRC_NOPROC (variable) -ida_idd.DRC_OK (variable) -ida_idd.EXCEPTION (variable) -ida_idd.EXC_BREAK (variable) -ida_idd.EXC_HANDLE (variable) -ida_idd.EXC_MSG (variable) -ida_idd.EXC_SILENT (variable) -ida_idd.IDD_INTERFACE_VERSION (variable) -ida_idd.INFORMATION (variable) -ida_idd.LIB_LOADED (variable) -ida_idd.LIB_UNLOADED (variable) -ida_idd.NO_EVENT (variable) -ida_idd.NO_PROCESS (variable) -ida_idd.NO_THREAD (variable) -ida_idd.PROCESS_ATTACHED (variable) -ida_idd.PROCESS_DETACHED (variable) -ida_idd.PROCESS_EXITED (variable) -ida_idd.PROCESS_STARTED (variable) -ida_idd.PROCESS_SUSPENDED (variable) -ida_idd.REGISTER_ADDRESS (variable) -ida_idd.REGISTER_CS (variable) -ida_idd.REGISTER_CUSTFMT (variable) -ida_idd.REGISTER_FP (variable) -ida_idd.REGISTER_IP (variable) -ida_idd.REGISTER_NOLF (variable) -ida_idd.REGISTER_READONLY (variable) -ida_idd.REGISTER_SP (variable) -ida_idd.REGISTER_SS (variable) -ida_idd.RESMOD_HANDLE (variable) -ida_idd.RESMOD_INTO (variable) -ida_idd.RESMOD_NONE (variable) -ida_idd.RESMOD_OUT (variable) -ida_idd.RESMOD_OVER (variable) -ida_idd.RESMOD_SRCINTO (variable) -ida_idd.RESMOD_SRCOUT (variable) -ida_idd.RESMOD_SRCOVER (variable) -ida_idd.RESMOD_USER (variable) -ida_idd.RVT_FLOAT (variable) -ida_idd.RVT_INT (variable) -ida_idd.RVT_UNAVAILABLE (variable) -ida_idd.STEP (variable) -ida_idd.THREAD_EXITED (variable) -ida_idd.THREAD_STARTED (variable) -ida_idd.TRACE_FULL (variable) -ida_idd.appcall (function) -ida_idd.bptaddr_t (class) -ida_idd.bptaddr_t.__init__ (method) -ida_idd.bptaddr_t.hea (variable) -ida_idd.bptaddr_t.kea (variable) -ida_idd.call_stack_info_t (class) -ida_idd.call_stack_info_t.__eq__ (method) -ida_idd.call_stack_info_t.__init__ (method) -ida_idd.call_stack_info_t.__ne__ (method) -ida_idd.call_stack_info_t.callea (variable) -ida_idd.call_stack_info_t.fp (variable) -ida_idd.call_stack_info_t.funcea (variable) -ida_idd.call_stack_info_t.funcok (variable) -ida_idd.call_stack_info_vec_t (class) -ida_idd.call_stack_info_vec_t.__eq__ (method) -ida_idd.call_stack_info_vec_t.__getitem__ (method) -ida_idd.call_stack_info_vec_t.__init__ (method) -ida_idd.call_stack_info_vec_t.__len__ (method) -ida_idd.call_stack_info_vec_t.__ne__ (method) -ida_idd.call_stack_info_vec_t.__setitem__ (method) -ida_idd.call_stack_info_vec_t._del (method) -ida_idd.call_stack_info_vec_t.add_unique (method) -ida_idd.call_stack_info_vec_t.at (method) -ida_idd.call_stack_info_vec_t.begin (method) -ida_idd.call_stack_info_vec_t.capacity (method) -ida_idd.call_stack_info_vec_t.clear (method) -ida_idd.call_stack_info_vec_t.empty (method) -ida_idd.call_stack_info_vec_t.end (method) -ida_idd.call_stack_info_vec_t.erase (method) -ida_idd.call_stack_info_vec_t.extract (method) -ida_idd.call_stack_info_vec_t.find (method) -ida_idd.call_stack_info_vec_t.grow (method) -ida_idd.call_stack_info_vec_t.has (method) -ida_idd.call_stack_info_vec_t.inject (method) -ida_idd.call_stack_info_vec_t.insert (method) -ida_idd.call_stack_info_vec_t.pop_back (method) -ida_idd.call_stack_info_vec_t.push_back (method) -ida_idd.call_stack_info_vec_t.qclear (method) -ida_idd.call_stack_info_vec_t.reserve (method) -ida_idd.call_stack_info_vec_t.resize (method) -ida_idd.call_stack_info_vec_t.size (method) -ida_idd.call_stack_info_vec_t.swap (method) -ida_idd.call_stack_info_vec_t.truncate (method) -ida_idd.call_stack_t (class) -ida_idd.call_stack_t.__init__ (method) -ida_idd.can_exc_continue (function) -ida_idd.cleanup_appcall (function) -ida_idd.dbg_appcall (function) -ida_idd.dbg_get_memory_info (function) -ida_idd.dbg_get_name (function) -ida_idd.dbg_get_registers (function) -ida_idd.dbg_get_thread_sreg_base (function) -ida_idd.dbg_read_memory (function) -ida_idd.dbg_write_memory (function) -ida_idd.debapp_attrs_t (class) -ida_idd.debapp_attrs_t.__init__ (method) -ida_idd.debapp_attrs_t.addrsize (variable) -ida_idd.debapp_attrs_t.cbsize (variable) -ida_idd.debapp_attrs_t.platform (variable) -ida_idd.debug_event_t (class) -ida_idd.debug_event_t.__init__ (method) -ida_idd.debug_event_t.bpt (method) -ida_idd.debug_event_t.bpt_ea (method) -ida_idd.debug_event_t.clear (method) -ida_idd.debug_event_t.clear_all (method) -ida_idd.debug_event_t.copy (method) -ida_idd.debug_event_t.ea (variable) -ida_idd.debug_event_t.eid (method) -ida_idd.debug_event_t.exc (method) -ida_idd.debug_event_t.exit_code (method) -ida_idd.debug_event_t.handled (variable) -ida_idd.debug_event_t.info (method) -ida_idd.debug_event_t.modinfo (method) -ida_idd.debug_event_t.pid (variable) -ida_idd.debug_event_t.set_bpt (method) -ida_idd.debug_event_t.set_eid (method) -ida_idd.debug_event_t.set_exception (method) -ida_idd.debug_event_t.set_exit_code (method) -ida_idd.debug_event_t.set_info (method) -ida_idd.debug_event_t.set_modinfo (method) -ida_idd.debug_event_t.tid (variable) -ida_idd.debugger_t (class) -ida_idd.debugger_t.__get_bpt_bytes (method) -ida_idd.debugger_t.__get_nregs (method) -ida_idd.debugger_t.__get_regclasses (method) -ida_idd.debugger_t.__get_registers (method) -ida_idd.debugger_t.__init__ (method) -ida_idd.debugger_t.attach_process (method) -ida_idd.debugger_t.bin_search (method) -ida_idd.debugger_t.bpt_bytes (variable) -ida_idd.debugger_t.bpt_size (variable) -ida_idd.debugger_t.cache_block_size (method) -ida_idd.debugger_t.can_continue_from_bpt (method) -ida_idd.debugger_t.can_debug_standalone_dlls (method) -ida_idd.debugger_t.check_bpt (method) -ida_idd.debugger_t.cleanup_appcall (method) -ida_idd.debugger_t.close_file (method) -ida_idd.debugger_t.dbg_enable_trace (method) -ida_idd.debugger_t.default_regclasses (variable) -ida_idd.debugger_t.detach_process (method) -ida_idd.debugger_t.ev_appcall (variable) -ida_idd.debugger_t.ev_attach_process (variable) -ida_idd.debugger_t.ev_bin_search (variable) -ida_idd.debugger_t.ev_check_bpt (variable) -ida_idd.debugger_t.ev_cleanup_appcall (variable) -ida_idd.debugger_t.ev_close_file (variable) -ida_idd.debugger_t.ev_dbg_enable_trace (variable) -ida_idd.debugger_t.ev_detach_process (variable) -ida_idd.debugger_t.ev_eval_lowcnd (variable) -ida_idd.debugger_t.ev_exit_process (variable) -ida_idd.debugger_t.ev_get_debapp_attrs (variable) -ida_idd.debugger_t.ev_get_debmod_extensions (variable) -ida_idd.debugger_t.ev_get_debug_event (variable) -ida_idd.debugger_t.ev_get_memory_info (variable) -ida_idd.debugger_t.ev_get_processes (variable) -ida_idd.debugger_t.ev_get_srcinfo_path (variable) -ida_idd.debugger_t.ev_init_debugger (variable) -ida_idd.debugger_t.ev_is_tracing_enabled (variable) -ida_idd.debugger_t.ev_map_address (variable) -ida_idd.debugger_t.ev_open_file (variable) -ida_idd.debugger_t.ev_read_file (variable) -ida_idd.debugger_t.ev_read_memory (variable) -ida_idd.debugger_t.ev_read_registers (variable) -ida_idd.debugger_t.ev_rebase_if_required_to (variable) -ida_idd.debugger_t.ev_request_pause (variable) -ida_idd.debugger_t.ev_resume (variable) -ida_idd.debugger_t.ev_rexec (variable) -ida_idd.debugger_t.ev_send_ioctl (variable) -ida_idd.debugger_t.ev_set_exception_info (variable) -ida_idd.debugger_t.ev_set_resume_mode (variable) -ida_idd.debugger_t.ev_start_process (variable) -ida_idd.debugger_t.ev_suspended (variable) -ida_idd.debugger_t.ev_term_debugger (variable) -ida_idd.debugger_t.ev_thread_continue (variable) -ida_idd.debugger_t.ev_thread_get_sreg_base (variable) -ida_idd.debugger_t.ev_thread_suspend (variable) -ida_idd.debugger_t.ev_update_bpts (variable) -ida_idd.debugger_t.ev_update_call_stack (variable) -ida_idd.debugger_t.ev_update_lowcnds (variable) -ida_idd.debugger_t.ev_write_file (variable) -ida_idd.debugger_t.ev_write_memory (variable) -ida_idd.debugger_t.ev_write_register (variable) -ida_idd.debugger_t.eval_lowcnd (method) -ida_idd.debugger_t.exit_process (method) -ida_idd.debugger_t.fake_memory (method) -ida_idd.debugger_t.filetype (variable) -ida_idd.debugger_t.flags2 (variable) -ida_idd.debugger_t.get_debapp_attrs (method) -ida_idd.debugger_t.get_debmod_extensions (method) -ida_idd.debugger_t.get_debug_event (method) -ida_idd.debugger_t.get_memory_info (method) -ida_idd.debugger_t.get_processes (method) -ida_idd.debugger_t.get_srcinfo_path (method) -ida_idd.debugger_t.has_appcall (method) -ida_idd.debugger_t.has_attach_process (method) -ida_idd.debugger_t.has_check_bpt (method) -ida_idd.debugger_t.has_detach_process (method) -ida_idd.debugger_t.has_get_processes (method) -ida_idd.debugger_t.has_map_address (method) -ida_idd.debugger_t.has_open_file (method) -ida_idd.debugger_t.has_request_pause (method) -ida_idd.debugger_t.has_rexec (method) -ida_idd.debugger_t.has_set_exception_info (method) -ida_idd.debugger_t.has_set_resume_mode (method) -ida_idd.debugger_t.has_soft_bpt (method) -ida_idd.debugger_t.has_thread_continue (method) -ida_idd.debugger_t.has_thread_get_sreg_base (method) -ida_idd.debugger_t.has_thread_suspend (method) -ida_idd.debugger_t.has_update_call_stack (method) -ida_idd.debugger_t.id (variable) -ida_idd.debugger_t.init_debugger (method) -ida_idd.debugger_t.is_remote (method) -ida_idd.debugger_t.is_resmod_avail (method) -ida_idd.debugger_t.is_safe (method) -ida_idd.debugger_t.is_tracing_enabled (method) -ida_idd.debugger_t.map_address (method) -ida_idd.debugger_t.may_disturb (method) -ida_idd.debugger_t.may_take_exit_snapshot (method) -ida_idd.debugger_t.memory_page_size (variable) -ida_idd.debugger_t.must_have_hostname (method) -ida_idd.debugger_t.name (variable) -ida_idd.debugger_t.nregs (variable) -ida_idd.debugger_t.open_file (method) -ida_idd.debugger_t.processor (variable) -ida_idd.debugger_t.read_file (method) -ida_idd.debugger_t.read_memory (method) -ida_idd.debugger_t.read_registers (method) -ida_idd.debugger_t.rebase_if_required_to (method) -ida_idd.debugger_t.regclasses (variable) -ida_idd.debugger_t.registers (variable) -ida_idd.debugger_t.regs (method) -ida_idd.debugger_t.request_pause (method) -ida_idd.debugger_t.resume (method) -ida_idd.debugger_t.resume_modes (variable) -ida_idd.debugger_t.rexec (method) -ida_idd.debugger_t.send_ioctl (method) -ida_idd.debugger_t.set_exception_info (method) -ida_idd.debugger_t.set_resume_mode (method) -ida_idd.debugger_t.start_process (method) -ida_idd.debugger_t.supports_debthread (method) -ida_idd.debugger_t.supports_lowcnds (method) -ida_idd.debugger_t.suspended (method) -ida_idd.debugger_t.term_debugger (method) -ida_idd.debugger_t.thread_continue (method) -ida_idd.debugger_t.thread_get_sreg_base (method) -ida_idd.debugger_t.thread_suspend (method) -ida_idd.debugger_t.update_bpts (method) -ida_idd.debugger_t.update_call_stack (method) -ida_idd.debugger_t.update_lowcnds (method) -ida_idd.debugger_t.use_memregs (method) -ida_idd.debugger_t.use_sregs (method) -ida_idd.debugger_t.version (variable) -ida_idd.debugger_t.virtual_threads (method) -ida_idd.debugger_t.write_file (method) -ida_idd.debugger_t.write_memory (method) -ida_idd.debugger_t.write_register (method) -ida_idd.dyn_register_info_array (class) -ida_idd.dyn_register_info_array.__getitem__ (method) -ida_idd.dyn_register_info_array.__init__ (method) -ida_idd.dyn_register_info_array.__len__ (method) -ida_idd.dyn_register_info_array.__setitem__ (method) -ida_idd.exception_info_t (class) -ida_idd.exception_info_t.__init__ (method) -ida_idd.exception_info_t.break_on (method) -ida_idd.exception_info_t.code (variable) -ida_idd.exception_info_t.desc (variable) -ida_idd.exception_info_t.flags (variable) -ida_idd.exception_info_t.handle (method) -ida_idd.exception_info_t.name (variable) -ida_idd.excinfo_t (class) -ida_idd.excinfo_t.__init__ (method) -ida_idd.excinfo_t.can_cont (variable) -ida_idd.excinfo_t.code (variable) -ida_idd.excinfo_t.ea (variable) -ida_idd.excinfo_t.info (variable) -ida_idd.excvec_t (class) -ida_idd.excvec_t.__getitem__ (method) -ida_idd.excvec_t.__init__ (method) -ida_idd.excvec_t.__len__ (method) -ida_idd.excvec_t.__setitem__ (method) -ida_idd.excvec_t.at (method) -ida_idd.excvec_t.begin (method) -ida_idd.excvec_t.capacity (method) -ida_idd.excvec_t.clear (method) -ida_idd.excvec_t.empty (method) -ida_idd.excvec_t.end (method) -ida_idd.excvec_t.erase (method) -ida_idd.excvec_t.extract (method) -ida_idd.excvec_t.grow (method) -ida_idd.excvec_t.inject (method) -ida_idd.excvec_t.insert (method) -ida_idd.excvec_t.pop_back (method) -ida_idd.excvec_t.push_back (method) -ida_idd.excvec_t.qclear (method) -ida_idd.excvec_t.reserve (method) -ida_idd.excvec_t.resize (method) -ida_idd.excvec_t.size (method) -ida_idd.excvec_t.swap (method) -ida_idd.excvec_t.truncate (method) -ida_idd.get_dbg (function) -ida_idd.get_event_bpt_hea (function) -ida_idd.get_event_exc_code (function) -ida_idd.get_event_exc_ea (function) -ida_idd.get_event_exc_info (function) -ida_idd.get_event_info (function) -ida_idd.get_event_module_base (function) -ida_idd.get_event_module_name (function) -ida_idd.get_event_module_size (function) -ida_idd.launch_env_t (class) -ida_idd.launch_env_t.__init__ (method) -ida_idd.meminfo_vec_t (class) -ida_idd.meminfo_vec_t.__init__ (method) -ida_idd.meminfo_vec_template_t (class) -ida_idd.meminfo_vec_template_t.__eq__ (method) -ida_idd.meminfo_vec_template_t.__getitem__ (method) -ida_idd.meminfo_vec_template_t.__init__ (method) -ida_idd.meminfo_vec_template_t.__len__ (method) -ida_idd.meminfo_vec_template_t.__ne__ (method) -ida_idd.meminfo_vec_template_t.__setitem__ (method) -ida_idd.meminfo_vec_template_t._del (method) -ida_idd.meminfo_vec_template_t.add_unique (method) -ida_idd.meminfo_vec_template_t.at (method) -ida_idd.meminfo_vec_template_t.begin (method) -ida_idd.meminfo_vec_template_t.capacity (method) -ida_idd.meminfo_vec_template_t.clear (method) -ida_idd.meminfo_vec_template_t.empty (method) -ida_idd.meminfo_vec_template_t.end (method) -ida_idd.meminfo_vec_template_t.erase (method) -ida_idd.meminfo_vec_template_t.extract (method) -ida_idd.meminfo_vec_template_t.find (method) -ida_idd.meminfo_vec_template_t.grow (method) -ida_idd.meminfo_vec_template_t.has (method) -ida_idd.meminfo_vec_template_t.inject (method) -ida_idd.meminfo_vec_template_t.insert (method) -ida_idd.meminfo_vec_template_t.pop_back (method) -ida_idd.meminfo_vec_template_t.push_back (method) -ida_idd.meminfo_vec_template_t.qclear (method) -ida_idd.meminfo_vec_template_t.reserve (method) -ida_idd.meminfo_vec_template_t.resize (method) -ida_idd.meminfo_vec_template_t.size (method) -ida_idd.meminfo_vec_template_t.swap (method) -ida_idd.meminfo_vec_template_t.truncate (method) -ida_idd.memory_info_t (class) -ida_idd.memory_info_t.__eq__ (method) -ida_idd.memory_info_t.__init__ (method) -ida_idd.memory_info_t.__ne__ (method) -ida_idd.memory_info_t.bitness (variable) -ida_idd.memory_info_t.name (variable) -ida_idd.memory_info_t.perm (variable) -ida_idd.memory_info_t.sbase (variable) -ida_idd.memory_info_t.sclass (variable) -ida_idd.modinfo_t (class) -ida_idd.modinfo_t.__init__ (method) -ida_idd.modinfo_t.base (variable) -ida_idd.modinfo_t.name (variable) -ida_idd.modinfo_t.rebase_to (variable) -ida_idd.modinfo_t.size (variable) -ida_idd.process_info_t (class) -ida_idd.process_info_t.__init__ (method) -ida_idd.process_info_t.name (variable) -ida_idd.process_info_t.pid (variable) -ida_idd.procinfo_vec_t (class) -ida_idd.procinfo_vec_t.__getitem__ (method) -ida_idd.procinfo_vec_t.__init__ (method) -ida_idd.procinfo_vec_t.__len__ (method) -ida_idd.procinfo_vec_t.__setitem__ (method) -ida_idd.procinfo_vec_t.at (method) -ida_idd.procinfo_vec_t.begin (method) -ida_idd.procinfo_vec_t.capacity (method) -ida_idd.procinfo_vec_t.clear (method) -ida_idd.procinfo_vec_t.empty (method) -ida_idd.procinfo_vec_t.end (method) -ida_idd.procinfo_vec_t.erase (method) -ida_idd.procinfo_vec_t.extract (method) -ida_idd.procinfo_vec_t.grow (method) -ida_idd.procinfo_vec_t.inject (method) -ida_idd.procinfo_vec_t.insert (method) -ida_idd.procinfo_vec_t.pop_back (method) -ida_idd.procinfo_vec_t.push_back (method) -ida_idd.procinfo_vec_t.qclear (method) -ida_idd.procinfo_vec_t.reserve (method) -ida_idd.procinfo_vec_t.resize (method) -ida_idd.procinfo_vec_t.size (method) -ida_idd.procinfo_vec_t.swap (method) -ida_idd.procinfo_vec_t.truncate (method) -ida_idd.register_info_t (class) -ida_idd.register_info_t.__get_bit_strings (method) -ida_idd.register_info_t.__init__ (method) -ida_idd.register_info_t.bit_strings (variable) -ida_idd.register_info_t.default_bit_strings_mask (variable) -ida_idd.register_info_t.dtype (variable) -ida_idd.register_info_t.flags (variable) -ida_idd.register_info_t.name (variable) -ida_idd.register_info_t.register_class (variable) -ida_idd.regval_t (class) -ida_idd.regval_t.__eq__ (method) -ida_idd.regval_t.__init__ (method) -ida_idd.regval_t.__ne__ (method) -ida_idd.regval_t.bytes (method) -ida_idd.regval_t.clear (method) -ida_idd.regval_t.fval (variable) -ida_idd.regval_t.get_data (method) -ida_idd.regval_t.get_data_size (method) -ida_idd.regval_t.ival (variable) -ida_idd.regval_t.pyval (method) -ida_idd.regval_t.rvtype (variable) -ida_idd.regval_t.set_bytes (method) -ida_idd.regval_t.set_float (method) -ida_idd.regval_t.set_int (method) -ida_idd.regval_t.set_pyval (method) -ida_idd.regval_t.set_unavailable (method) -ida_idd.regval_t.swap (method) -ida_idd.regvals_t (class) -ida_idd.regvals_t.__eq__ (method) -ida_idd.regvals_t.__getitem__ (method) -ida_idd.regvals_t.__init__ (method) -ida_idd.regvals_t.__len__ (method) -ida_idd.regvals_t.__ne__ (method) -ida_idd.regvals_t.__setitem__ (method) -ida_idd.regvals_t._del (method) -ida_idd.regvals_t.add_unique (method) -ida_idd.regvals_t.at (method) -ida_idd.regvals_t.begin (method) -ida_idd.regvals_t.capacity (method) -ida_idd.regvals_t.clear (method) -ida_idd.regvals_t.empty (method) -ida_idd.regvals_t.end (method) -ida_idd.regvals_t.erase (method) -ida_idd.regvals_t.extract (method) -ida_idd.regvals_t.find (method) -ida_idd.regvals_t.grow (method) -ida_idd.regvals_t.has (method) -ida_idd.regvals_t.inject (method) -ida_idd.regvals_t.insert (method) -ida_idd.regvals_t.pop_back (method) -ida_idd.regvals_t.push_back (method) -ida_idd.regvals_t.qclear (method) -ida_idd.regvals_t.reserve (method) -ida_idd.regvals_t.resize (method) -ida_idd.regvals_t.size (method) -ida_idd.regvals_t.swap (method) -ida_idd.regvals_t.truncate (method) -ida_idd.scattered_segm_t (class) -ida_idd.scattered_segm_t.__init__ (method) -ida_idd.scattered_segm_t.name (variable) -ida_idd.set_debug_event_code (function) -ida_idd.thread_name_t (class) -ida_idd.thread_name_t.__init__ (method) -ida_idd.thread_name_t.name (variable) -ida_idd.thread_name_t.tid (variable) -ida_idp (module) -ida_idp.AS2_BRACE (variable) -ida_idp.AS2_BYTE1CHAR (variable) -ida_idp.AS2_COLONSUF (variable) -ida_idp.AS2_IDEALDSCR (variable) -ida_idp.AS2_STRINV (variable) -ida_idp.AS2_TERSESTR (variable) -ida_idp.AS2_YWORD (variable) -ida_idp.AS2_ZWORD (variable) -ida_idp.ASB_BINF0 (variable) -ida_idp.ASB_BINF1 (variable) -ida_idp.ASB_BINF2 (variable) -ida_idp.ASB_BINF3 (variable) -ida_idp.ASB_BINF4 (variable) -ida_idp.ASB_BINF5 (variable) -ida_idp.ASD_DECF0 (variable) -ida_idp.ASD_DECF1 (variable) -ida_idp.ASD_DECF2 (variable) -ida_idp.ASD_DECF3 (variable) -ida_idp.ASH_HEXF0 (variable) -ida_idp.ASH_HEXF1 (variable) -ida_idp.ASH_HEXF2 (variable) -ida_idp.ASH_HEXF3 (variable) -ida_idp.ASH_HEXF4 (variable) -ida_idp.ASH_HEXF5 (variable) -ida_idp.ASO_OCTF0 (variable) -ida_idp.ASO_OCTF1 (variable) -ida_idp.ASO_OCTF2 (variable) -ida_idp.ASO_OCTF3 (variable) -ida_idp.ASO_OCTF4 (variable) -ida_idp.ASO_OCTF5 (variable) -ida_idp.ASO_OCTF6 (variable) -ida_idp.ASO_OCTF7 (variable) -ida_idp.AS_1TEXT (variable) -ida_idp.AS_2CHRE (variable) -ida_idp.AS_ALIGN2 (variable) -ida_idp.AS_ASCIIC (variable) -ida_idp.AS_ASCIIZ (variable) -ida_idp.AS_BINFM (variable) -ida_idp.AS_COLON (variable) -ida_idp.AS_DECFM (variable) -ida_idp.AS_HEXFM (variable) -ida_idp.AS_LALIGN (variable) -ida_idp.AS_N2CHR (variable) -ida_idp.AS_NCHRE (variable) -ida_idp.AS_NCMAS (variable) -ida_idp.AS_NHIAS (variable) -ida_idp.AS_NOCODECLN (variable) -ida_idp.AS_NOSPACE (variable) -ida_idp.AS_NOXRF (variable) -ida_idp.AS_OCTFM (variable) -ida_idp.AS_OFFST (variable) -ida_idp.AS_ONEDUP (variable) -ida_idp.AS_RELSUP (variable) -ida_idp.AS_UDATA (variable) -ida_idp.AS_UNEQU (variable) -ida_idp.AS_XTRNTYPE (variable) -ida_idp.AssembleLine (function) -ida_idp.CF_CALL (variable) -ida_idp.CF_CHG1 (variable) -ida_idp.CF_CHG2 (variable) -ida_idp.CF_CHG3 (variable) -ida_idp.CF_CHG4 (variable) -ida_idp.CF_CHG5 (variable) -ida_idp.CF_CHG6 (variable) -ida_idp.CF_CHG7 (variable) -ida_idp.CF_CHG8 (variable) -ida_idp.CF_HLL (variable) -ida_idp.CF_JUMP (variable) -ida_idp.CF_SHFT (variable) -ida_idp.CF_STOP (variable) -ida_idp.CF_USE1 (variable) -ida_idp.CF_USE2 (variable) -ida_idp.CF_USE3 (variable) -ida_idp.CF_USE4 (variable) -ida_idp.CF_USE5 (variable) -ida_idp.CF_USE6 (variable) -ida_idp.CF_USE7 (variable) -ida_idp.CF_USE8 (variable) -ida_idp.CUSTOM_INSN_ITYPE (variable) -ida_idp.HKCB_GLOBAL (variable) -ida_idp.IDB_Hooks (class) -ida_idp.IDB_Hooks.__disown__ (method) -ida_idp.IDB_Hooks.__init__ (method) -ida_idp.IDB_Hooks.adding_segm (method) -ida_idp.IDB_Hooks.allsegs_moved (method) -ida_idp.IDB_Hooks.auto_empty (method) -ida_idp.IDB_Hooks.auto_empty_finally (method) -ida_idp.IDB_Hooks.bookmark_changed (method) -ida_idp.IDB_Hooks.byte_patched (method) -ida_idp.IDB_Hooks.callee_addr_changed (method) -ida_idp.IDB_Hooks.changing_cmt (method) -ida_idp.IDB_Hooks.changing_enum_bf (method) -ida_idp.IDB_Hooks.changing_enum_cmt (method) -ida_idp.IDB_Hooks.changing_op_ti (method) -ida_idp.IDB_Hooks.changing_op_type (method) -ida_idp.IDB_Hooks.changing_range_cmt (method) -ida_idp.IDB_Hooks.changing_segm_class (method) -ida_idp.IDB_Hooks.changing_segm_end (method) -ida_idp.IDB_Hooks.changing_segm_name (method) -ida_idp.IDB_Hooks.changing_segm_start (method) -ida_idp.IDB_Hooks.changing_struc_align (method) -ida_idp.IDB_Hooks.changing_struc_cmt (method) -ida_idp.IDB_Hooks.changing_struc_member (method) -ida_idp.IDB_Hooks.changing_ti (method) -ida_idp.IDB_Hooks.closebase (method) -ida_idp.IDB_Hooks.cmt_changed (method) -ida_idp.IDB_Hooks.compiler_changed (method) -ida_idp.IDB_Hooks.deleting_enum (method) -ida_idp.IDB_Hooks.deleting_enum_member (method) -ida_idp.IDB_Hooks.deleting_func (method) -ida_idp.IDB_Hooks.deleting_func_tail (method) -ida_idp.IDB_Hooks.deleting_segm (method) -ida_idp.IDB_Hooks.deleting_struc (method) -ida_idp.IDB_Hooks.deleting_struc_member (method) -ida_idp.IDB_Hooks.deleting_tryblks (method) -ida_idp.IDB_Hooks.destroyed_items (method) -ida_idp.IDB_Hooks.determined_main (method) -ida_idp.IDB_Hooks.dirtree_link (method) -ida_idp.IDB_Hooks.dirtree_mkdir (method) -ida_idp.IDB_Hooks.dirtree_move (method) -ida_idp.IDB_Hooks.dirtree_rank (method) -ida_idp.IDB_Hooks.dirtree_rmdir (method) -ida_idp.IDB_Hooks.dirtree_rminode (method) -ida_idp.IDB_Hooks.dirtree_segm_moved (method) -ida_idp.IDB_Hooks.enum_bf_changed (method) -ida_idp.IDB_Hooks.enum_cmt_changed (method) -ida_idp.IDB_Hooks.enum_created (method) -ida_idp.IDB_Hooks.enum_deleted (method) -ida_idp.IDB_Hooks.enum_flag_changed (method) -ida_idp.IDB_Hooks.enum_member_created (method) -ida_idp.IDB_Hooks.enum_member_deleted (method) -ida_idp.IDB_Hooks.enum_ordinal_changed (method) -ida_idp.IDB_Hooks.enum_renamed (method) -ida_idp.IDB_Hooks.enum_width_changed (method) -ida_idp.IDB_Hooks.expanding_struc (method) -ida_idp.IDB_Hooks.extlang_changed (method) -ida_idp.IDB_Hooks.extra_cmt_changed (method) -ida_idp.IDB_Hooks.flow_chart_created (method) -ida_idp.IDB_Hooks.frame_deleted (method) -ida_idp.IDB_Hooks.func_added (method) -ida_idp.IDB_Hooks.func_deleted (method) -ida_idp.IDB_Hooks.func_noret_changed (method) -ida_idp.IDB_Hooks.func_tail_appended (method) -ida_idp.IDB_Hooks.func_tail_deleted (method) -ida_idp.IDB_Hooks.func_updated (method) -ida_idp.IDB_Hooks.hook (method) -ida_idp.IDB_Hooks.idasgn_loaded (method) -ida_idp.IDB_Hooks.item_color_changed (method) -ida_idp.IDB_Hooks.kernel_config_loaded (method) -ida_idp.IDB_Hooks.loader_finished (method) -ida_idp.IDB_Hooks.local_types_changed (method) -ida_idp.IDB_Hooks.make_code (method) -ida_idp.IDB_Hooks.make_data (method) -ida_idp.IDB_Hooks.op_ti_changed (method) -ida_idp.IDB_Hooks.op_type_changed (method) -ida_idp.IDB_Hooks.range_cmt_changed (method) -ida_idp.IDB_Hooks.renamed (method) -ida_idp.IDB_Hooks.renaming_enum (method) -ida_idp.IDB_Hooks.renaming_struc (method) -ida_idp.IDB_Hooks.renaming_struc_member (method) -ida_idp.IDB_Hooks.savebase (method) -ida_idp.IDB_Hooks.segm_added (method) -ida_idp.IDB_Hooks.segm_attrs_updated (method) -ida_idp.IDB_Hooks.segm_class_changed (method) -ida_idp.IDB_Hooks.segm_deleted (method) -ida_idp.IDB_Hooks.segm_end_changed (method) -ida_idp.IDB_Hooks.segm_moved (method) -ida_idp.IDB_Hooks.segm_name_changed (method) -ida_idp.IDB_Hooks.segm_start_changed (method) -ida_idp.IDB_Hooks.set_func_end (method) -ida_idp.IDB_Hooks.set_func_start (method) -ida_idp.IDB_Hooks.sgr_changed (method) -ida_idp.IDB_Hooks.sgr_deleted (method) -ida_idp.IDB_Hooks.stkpnts_changed (method) -ida_idp.IDB_Hooks.struc_align_changed (method) -ida_idp.IDB_Hooks.struc_cmt_changed (method) -ida_idp.IDB_Hooks.struc_created (method) -ida_idp.IDB_Hooks.struc_deleted (method) -ida_idp.IDB_Hooks.struc_expanded (method) -ida_idp.IDB_Hooks.struc_member_changed (method) -ida_idp.IDB_Hooks.struc_member_created (method) -ida_idp.IDB_Hooks.struc_member_deleted (method) -ida_idp.IDB_Hooks.struc_member_renamed (method) -ida_idp.IDB_Hooks.struc_renamed (method) -ida_idp.IDB_Hooks.tail_owner_changed (method) -ida_idp.IDB_Hooks.thunk_func_created (method) -ida_idp.IDB_Hooks.ti_changed (method) -ida_idp.IDB_Hooks.tryblks_updated (method) -ida_idp.IDB_Hooks.unhook (method) -ida_idp.IDB_Hooks.updating_tryblks (method) -ida_idp.IDB_Hooks.upgraded (method) -ida_idp.IDP_Hooks (class) -ida_idp.IDP_Hooks.__disown__ (method) -ida_idp.IDP_Hooks.__init__ (method) -ida_idp.IDP_Hooks.ev_add_cref (method) -ida_idp.IDP_Hooks.ev_add_dref (method) -ida_idp.IDP_Hooks.ev_adjust_argloc (method) -ida_idp.IDP_Hooks.ev_adjust_libfunc_ea (method) -ida_idp.IDP_Hooks.ev_adjust_refinfo (method) -ida_idp.IDP_Hooks.ev_ana_insn (method) -ida_idp.IDP_Hooks.ev_analyze_prolog (method) -ida_idp.IDP_Hooks.ev_arch_changed (method) -ida_idp.IDP_Hooks.ev_arg_addrs_ready (method) -ida_idp.IDP_Hooks.ev_asm_installed (method) -ida_idp.IDP_Hooks.ev_assemble (method) -ida_idp.IDP_Hooks.ev_auto_queue_empty (method) -ida_idp.IDP_Hooks.ev_calc_arglocs (method) -ida_idp.IDP_Hooks.ev_calc_cdecl_purged_bytes (method) -ida_idp.IDP_Hooks.ev_calc_next_eas (method) -ida_idp.IDP_Hooks.ev_calc_purged_bytes (method) -ida_idp.IDP_Hooks.ev_calc_retloc (method) -ida_idp.IDP_Hooks.ev_calc_spdelta (method) -ida_idp.IDP_Hooks.ev_calc_step_over (method) -ida_idp.IDP_Hooks.ev_calc_switch_cases (method) -ida_idp.IDP_Hooks.ev_calc_varglocs (method) -ida_idp.IDP_Hooks.ev_calcrel (method) -ida_idp.IDP_Hooks.ev_can_have_type (method) -ida_idp.IDP_Hooks.ev_clean_tbit (method) -ida_idp.IDP_Hooks.ev_cmp_operands (method) -ida_idp.IDP_Hooks.ev_coagulate (method) -ida_idp.IDP_Hooks.ev_coagulate_dref (method) -ida_idp.IDP_Hooks.ev_create_flat_group (method) -ida_idp.IDP_Hooks.ev_create_func_frame (method) -ida_idp.IDP_Hooks.ev_create_merge_handlers (method) -ida_idp.IDP_Hooks.ev_create_switch_xrefs (method) -ida_idp.IDP_Hooks.ev_creating_segm (method) -ida_idp.IDP_Hooks.ev_cvt64_hashval (method) -ida_idp.IDP_Hooks.ev_cvt64_supval (method) -ida_idp.IDP_Hooks.ev_decorate_name (method) -ida_idp.IDP_Hooks.ev_del_cref (method) -ida_idp.IDP_Hooks.ev_del_dref (method) -ida_idp.IDP_Hooks.ev_delay_slot_insn (method) -ida_idp.IDP_Hooks.ev_demangle_name (method) -ida_idp.IDP_Hooks.ev_emu_insn (method) -ida_idp.IDP_Hooks.ev_endbinary (method) -ida_idp.IDP_Hooks.ev_ending_undo (method) -ida_idp.IDP_Hooks.ev_equal_reglocs (method) -ida_idp.IDP_Hooks.ev_extract_address (method) -ida_idp.IDP_Hooks.ev_find_op_value (method) -ida_idp.IDP_Hooks.ev_find_reg_value (method) -ida_idp.IDP_Hooks.ev_func_bounds (method) -ida_idp.IDP_Hooks.ev_gen_asm_or_lst (method) -ida_idp.IDP_Hooks.ev_gen_map_file (method) -ida_idp.IDP_Hooks.ev_gen_regvar_def (method) -ida_idp.IDP_Hooks.ev_gen_src_file_lnnum (method) -ida_idp.IDP_Hooks.ev_gen_stkvar_def (method) -ida_idp.IDP_Hooks.ev_get_abi_info (method) -ida_idp.IDP_Hooks.ev_get_autocmt (method) -ida_idp.IDP_Hooks.ev_get_bg_color (method) -ida_idp.IDP_Hooks.ev_get_cc_regs (method) -ida_idp.IDP_Hooks.ev_get_code16_mode (method) -ida_idp.IDP_Hooks.ev_get_dbr_opnum (method) -ida_idp.IDP_Hooks.ev_get_default_enum_size (method) -ida_idp.IDP_Hooks.ev_get_frame_retsize (method) -ida_idp.IDP_Hooks.ev_get_macro_insn_head (method) -ida_idp.IDP_Hooks.ev_get_operand_string (method) -ida_idp.IDP_Hooks.ev_get_procmod (method) -ida_idp.IDP_Hooks.ev_get_reg_accesses (method) -ida_idp.IDP_Hooks.ev_get_reg_info (method) -ida_idp.IDP_Hooks.ev_get_reg_name (method) -ida_idp.IDP_Hooks.ev_get_simd_types (method) -ida_idp.IDP_Hooks.ev_get_stkarg_area_info (method) -ida_idp.IDP_Hooks.ev_get_stkvar_scale_factor (method) -ida_idp.IDP_Hooks.ev_getreg (method) -ida_idp.IDP_Hooks.ev_init (method) -ida_idp.IDP_Hooks.ev_insn_reads_tbit (method) -ida_idp.IDP_Hooks.ev_is_align_insn (method) -ida_idp.IDP_Hooks.ev_is_alloca_probe (method) -ida_idp.IDP_Hooks.ev_is_basic_block_end (method) -ida_idp.IDP_Hooks.ev_is_call_insn (method) -ida_idp.IDP_Hooks.ev_is_cond_insn (method) -ida_idp.IDP_Hooks.ev_is_control_flow_guard (method) -ida_idp.IDP_Hooks.ev_is_far_jump (method) -ida_idp.IDP_Hooks.ev_is_indirect_jump (method) -ida_idp.IDP_Hooks.ev_is_insn_table_jump (method) -ida_idp.IDP_Hooks.ev_is_jump_func (method) -ida_idp.IDP_Hooks.ev_is_ret_insn (method) -ida_idp.IDP_Hooks.ev_is_sane_insn (method) -ida_idp.IDP_Hooks.ev_is_sp_based (method) -ida_idp.IDP_Hooks.ev_is_switch (method) -ida_idp.IDP_Hooks.ev_last_cb_before_loader (method) -ida_idp.IDP_Hooks.ev_loader (method) -ida_idp.IDP_Hooks.ev_lower_func_type (method) -ida_idp.IDP_Hooks.ev_max_ptr_size (method) -ida_idp.IDP_Hooks.ev_may_be_func (method) -ida_idp.IDP_Hooks.ev_may_show_sreg (method) -ida_idp.IDP_Hooks.ev_moving_segm (method) -ida_idp.IDP_Hooks.ev_newasm (method) -ida_idp.IDP_Hooks.ev_newbinary (method) -ida_idp.IDP_Hooks.ev_newfile (method) -ida_idp.IDP_Hooks.ev_newprc (method) -ida_idp.IDP_Hooks.ev_next_exec_insn (method) -ida_idp.IDP_Hooks.ev_oldfile (method) -ida_idp.IDP_Hooks.ev_out_assumes (method) -ida_idp.IDP_Hooks.ev_out_data (method) -ida_idp.IDP_Hooks.ev_out_footer (method) -ida_idp.IDP_Hooks.ev_out_header (method) -ida_idp.IDP_Hooks.ev_out_insn (method) -ida_idp.IDP_Hooks.ev_out_label (method) -ida_idp.IDP_Hooks.ev_out_mnem (method) -ida_idp.IDP_Hooks.ev_out_operand (method) -ida_idp.IDP_Hooks.ev_out_segend (method) -ida_idp.IDP_Hooks.ev_out_segstart (method) -ida_idp.IDP_Hooks.ev_out_special_item (method) -ida_idp.IDP_Hooks.ev_privrange_changed (method) -ida_idp.IDP_Hooks.ev_realcvt (method) -ida_idp.IDP_Hooks.ev_rename (method) -ida_idp.IDP_Hooks.ev_replaying_undo (method) -ida_idp.IDP_Hooks.ev_set_code16_mode (method) -ida_idp.IDP_Hooks.ev_set_idp_options (method) -ida_idp.IDP_Hooks.ev_set_proc_options (method) -ida_idp.IDP_Hooks.ev_setup_til (method) -ida_idp.IDP_Hooks.ev_str2reg (method) -ida_idp.IDP_Hooks.ev_term (method) -ida_idp.IDP_Hooks.ev_treat_hindering_item (method) -ida_idp.IDP_Hooks.ev_undefine (method) -ida_idp.IDP_Hooks.ev_update_call_stack (method) -ida_idp.IDP_Hooks.ev_use_arg_types (method) -ida_idp.IDP_Hooks.ev_use_regarg_type (method) -ida_idp.IDP_Hooks.ev_use_stkarg_type (method) -ida_idp.IDP_Hooks.ev_validate_flirt_func (method) -ida_idp.IDP_Hooks.ev_verify_noreturn (method) -ida_idp.IDP_Hooks.ev_verify_sp (method) -ida_idp.IDP_Hooks.hook (method) -ida_idp.IDP_Hooks.unhook (method) -ida_idp.IDP_INTERFACE_VERSION (variable) -ida_idp.OP_FP_BASED (variable) -ida_idp.OP_SP_ADD (variable) -ida_idp.OP_SP_BASED (variable) -ida_idp.OP_SP_SUB (variable) -ida_idp.PLFM_386 (variable) -ida_idp.PLFM_6502 (variable) -ida_idp.PLFM_65C816 (variable) -ida_idp.PLFM_6800 (variable) -ida_idp.PLFM_68K (variable) -ida_idp.PLFM_80196 (variable) -ida_idp.PLFM_8051 (variable) -ida_idp.PLFM_AD2106X (variable) -ida_idp.PLFM_AD218X (variable) -ida_idp.PLFM_ALPHA (variable) -ida_idp.PLFM_ARC (variable) -ida_idp.PLFM_ARM (variable) -ida_idp.PLFM_AVR (variable) -ida_idp.PLFM_C166 (variable) -ida_idp.PLFM_C39 (variable) -ida_idp.PLFM_CR16 (variable) -ida_idp.PLFM_DALVIK (variable) -ida_idp.PLFM_DSP56K (variable) -ida_idp.PLFM_DSP96K (variable) -ida_idp.PLFM_EBC (variable) -ida_idp.PLFM_F2MC (variable) -ida_idp.PLFM_FR (variable) -ida_idp.PLFM_H8 (variable) -ida_idp.PLFM_H8500 (variable) -ida_idp.PLFM_HPPA (variable) -ida_idp.PLFM_I860 (variable) -ida_idp.PLFM_I960 (variable) -ida_idp.PLFM_IA64 (variable) -ida_idp.PLFM_JAVA (variable) -ida_idp.PLFM_KR1878 (variable) -ida_idp.PLFM_M16C (variable) -ida_idp.PLFM_M32R (variable) -ida_idp.PLFM_M740 (variable) -ida_idp.PLFM_M7700 (variable) -ida_idp.PLFM_M7900 (variable) -ida_idp.PLFM_MC6812 (variable) -ida_idp.PLFM_MC6816 (variable) -ida_idp.PLFM_MIPS (variable) -ida_idp.PLFM_MN102L00 (variable) -ida_idp.PLFM_MSP430 (variable) -ida_idp.PLFM_NEC_78K0 (variable) -ida_idp.PLFM_NEC_78K0S (variable) -ida_idp.PLFM_NEC_V850X (variable) -ida_idp.PLFM_NET (variable) -ida_idp.PLFM_OAKDSP (variable) -ida_idp.PLFM_PDP (variable) -ida_idp.PLFM_PIC (variable) -ida_idp.PLFM_PIC16 (variable) -ida_idp.PLFM_PPC (variable) -ida_idp.PLFM_RISCV (variable) -ida_idp.PLFM_RL78 (variable) -ida_idp.PLFM_RX (variable) -ida_idp.PLFM_S390 (variable) -ida_idp.PLFM_SCR_ADPT (variable) -ida_idp.PLFM_SH (variable) -ida_idp.PLFM_SPARC (variable) -ida_idp.PLFM_SPC700 (variable) -ida_idp.PLFM_SPU (variable) -ida_idp.PLFM_ST20 (variable) -ida_idp.PLFM_ST7 (variable) -ida_idp.PLFM_ST9 (variable) -ida_idp.PLFM_TLCS900 (variable) -ida_idp.PLFM_TMS (variable) -ida_idp.PLFM_TMS320C1X (variable) -ida_idp.PLFM_TMS320C28 (variable) -ida_idp.PLFM_TMS320C3 (variable) -ida_idp.PLFM_TMS320C54 (variable) -ida_idp.PLFM_TMS320C55 (variable) -ida_idp.PLFM_TMSC6 (variable) -ida_idp.PLFM_TRICORE (variable) -ida_idp.PLFM_TRIMEDIA (variable) -ida_idp.PLFM_UNSP (variable) -ida_idp.PLFM_XTENSA (variable) -ida_idp.PLFM_Z8 (variable) -ida_idp.PLFM_Z80 (variable) -ida_idp.PR2_CODE16_BIT (variable) -ida_idp.PR2_FORCE_16BIT (variable) -ida_idp.PR2_IDP_OPTS (variable) -ida_idp.PR2_MACRO (variable) -ida_idp.PR2_MAPPINGS (variable) -ida_idp.PR2_REALCVT (variable) -ida_idp.PR2_REL_BITS (variable) -ida_idp.PR2_USE_CALCREL (variable) -ida_idp.PRN_BIN (variable) -ida_idp.PRN_DEC (variable) -ida_idp.PRN_HEX (variable) -ida_idp.PRN_OCT (variable) -ida_idp.PR_ADJSEGS (variable) -ida_idp.PR_ALIGN (variable) -ida_idp.PR_ALIGN_INSN (variable) -ida_idp.PR_ASSEMBLE (variable) -ida_idp.PR_BINMEM (variable) -ida_idp.PR_CHK_XREF (variable) -ida_idp.PR_CNDINSNS (variable) -ida_idp.PR_DEFNUM (variable) -ida_idp.PR_DEFSEG32 (variable) -ida_idp.PR_DEFSEG64 (variable) -ida_idp.PR_DELAYED (variable) -ida_idp.PR_NOCHANGE (variable) -ida_idp.PR_NO_SEGMOVE (variable) -ida_idp.PR_OUTER (variable) -ida_idp.PR_PURGING (variable) -ida_idp.PR_RNAMESOK (variable) -ida_idp.PR_SCALE_STKVARS (variable) -ida_idp.PR_SEGS (variable) -ida_idp.PR_SEGTRANS (variable) -ida_idp.PR_SGROTHER (variable) -ida_idp.PR_STACK_UP (variable) -ida_idp.PR_TYPEINFO (variable) -ida_idp.PR_USE32 (variable) -ida_idp.PR_USE64 (variable) -ida_idp.PR_USE_ARG_TYPES (variable) -ida_idp.PR_USE_TBYTE (variable) -ida_idp.PR_WORD_INS (variable) -ida_idp.REG_SPOIL (variable) -ida_idp.SETPROC_IDB (variable) -ida_idp.SETPROC_LOADER (variable) -ida_idp.SETPROC_LOADER_NON_FATAL (variable) -ida_idp.SETPROC_USER (variable) -ida_idp.__ph (class) -ida_idp._idp_cvar_t (class) -ida_idp._notify_when_dispatcher_t (class) -ida_idp._notify_when_dispatcher_t._IDB_Hooks (class) -ida_idp._notify_when_dispatcher_t._IDB_Hooks.__init__ (method) -ida_idp._notify_when_dispatcher_t._IDB_Hooks.closebase (method) -ida_idp._notify_when_dispatcher_t._IDP_Hooks (class) -ida_idp._notify_when_dispatcher_t._IDP_Hooks.__init__ (method) -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_newfile (method) -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_oldfile (method) -ida_idp._notify_when_dispatcher_t.__init__ (method) -ida_idp._notify_when_dispatcher_t._callback_t (class) -ida_idp._notify_when_dispatcher_t._callback_t.__init__ (method) -ida_idp._notify_when_dispatcher_t._find (method) -ida_idp._notify_when_dispatcher_t.dispatch (method) -ida_idp._notify_when_dispatcher_t.notify_when (method) -ida_idp._processor_t (class) -ida_idp._processor_t.__init__ (method) -ida_idp._processor_t.add_cref (method) -ida_idp._processor_t.add_dref (method) -ida_idp._processor_t.adjust_argloc (method) -ida_idp._processor_t.adjust_libfunc_ea (method) -ida_idp._processor_t.adjust_refinfo (method) -ida_idp._processor_t.ana_insn (method) -ida_idp._processor_t.analyze_prolog (method) -ida_idp._processor_t.arch_changed (method) -ida_idp._processor_t.arg_addrs_ready (method) -ida_idp._processor_t.asm_installed (method) -ida_idp._processor_t.assemble (method) -ida_idp._processor_t.auto_queue_empty (method) -ida_idp._processor_t.calc_arglocs (method) -ida_idp._processor_t.calc_cdecl_purged_bytes (method) -ida_idp._processor_t.calc_next_eas (method) -ida_idp._processor_t.calc_purged_bytes (method) -ida_idp._processor_t.calc_retloc (method) -ida_idp._processor_t.calc_spdelta (method) -ida_idp._processor_t.calc_step_over (method) -ida_idp._processor_t.calc_switch_cases (method) -ida_idp._processor_t.calc_varglocs (method) -ida_idp._processor_t.calcrel (method) -ida_idp._processor_t.calcrel_in_bits (method) -ida_idp._processor_t.can_have_type (method) -ida_idp._processor_t.cbsize (method) -ida_idp._processor_t.clean_tbit (method) -ida_idp._processor_t.cmp_operands (method) -ida_idp._processor_t.coagulate (method) -ida_idp._processor_t.coagulate_dref (method) -ida_idp._processor_t.create_flat_group (method) -ida_idp._processor_t.create_func_frame (method) -ida_idp._processor_t.create_merge_handlers (method) -ida_idp._processor_t.create_switch_xrefs (method) -ida_idp._processor_t.creating_segm (method) -ida_idp._processor_t.cvt64_hashval (method) -ida_idp._processor_t.cvt64_supval (method) -ida_idp._processor_t.dbsize (method) -ida_idp._processor_t.decorate_name (method) -ida_idp._processor_t.del_cref (method) -ida_idp._processor_t.del_dref (method) -ida_idp._processor_t.delay_slot_insn (method) -ida_idp._processor_t.demangle_name (method) -ida_idp._processor_t.emu_insn (method) -ida_idp._processor_t.endbinary (method) -ida_idp._processor_t.equal_reglocs (method) -ida_idp._processor_t.extract_address (method) -ida_idp._processor_t.find_op_value (method) -ida_idp._processor_t.find_reg_value (method) -ida_idp._processor_t.func_bounds (method) -ida_idp._processor_t.gen_asm_or_lst (method) -ida_idp._processor_t.gen_map_file (method) -ida_idp._processor_t.gen_regvar_def (method) -ida_idp._processor_t.gen_src_file_lnnum (method) -ida_idp._processor_t.gen_stkvar_def (method) -ida_idp._processor_t.get_abi_info (method) -ida_idp._processor_t.get_autocmt (method) -ida_idp._processor_t.get_bg_color (method) -ida_idp._processor_t.get_canon_feature (method) -ida_idp._processor_t.get_canon_mnem (method) -ida_idp._processor_t.get_cc_regs (method) -ida_idp._processor_t.get_code16_mode (method) -ida_idp._processor_t.get_dbr_opnum (method) -ida_idp._processor_t.get_default_segm_bitness (method) -ida_idp._processor_t.get_frame_retsize (method) -ida_idp._processor_t.get_idd_opinfo (method) -ida_idp._processor_t.get_macro_insn_head (method) -ida_idp._processor_t.get_operand_string (method) -ida_idp._processor_t.get_proc_index (method) -ida_idp._processor_t.get_reg_accesses (method) -ida_idp._processor_t.get_reg_info (method) -ida_idp._processor_t.get_reg_name (method) -ida_idp._processor_t.get_simd_types (method) -ida_idp._processor_t.get_stkarg_area_info (method) -ida_idp._processor_t.get_stkvar_scale (method) -ida_idp._processor_t.get_stkvar_scale_factor (method) -ida_idp._processor_t.getreg (method) -ida_idp._processor_t.has_code16_bit (method) -ida_idp._processor_t.has_idp_opts (method) -ida_idp._processor_t.has_realcvt (method) -ida_idp._processor_t.has_segregs (method) -ida_idp._processor_t.init (method) -ida_idp._processor_t.insn_reads_tbit (method) -ida_idp._processor_t.is_align_insn (method) -ida_idp._processor_t.is_alloca_probe (method) -ida_idp._processor_t.is_basic_block_end (method) -ida_idp._processor_t.is_call_insn (method) -ida_idp._processor_t.is_cond_insn (method) -ida_idp._processor_t.is_control_flow_guard (method) -ida_idp._processor_t.is_far_jump (method) -ida_idp._processor_t.is_indirect_jump (method) -ida_idp._processor_t.is_jump_func (method) -ida_idp._processor_t.is_ret_insn (method) -ida_idp._processor_t.is_sane_insn (method) -ida_idp._processor_t.is_sp_based (method) -ida_idp._processor_t.is_switch (method) -ida_idp._processor_t.loader_elf_machine (method) -ida_idp._processor_t.lower_func_type (method) -ida_idp._processor_t.max_ptr_size (method) -ida_idp._processor_t.may_be_func (method) -ida_idp._processor_t.may_show_sreg (method) -ida_idp._processor_t.moving_segm (method) -ida_idp._processor_t.newasm (method) -ida_idp._processor_t.newbinary (method) -ida_idp._processor_t.newfile (method) -ida_idp._processor_t.newprc (method) -ida_idp._processor_t.next_exec_insn (method) -ida_idp._processor_t.notify (method) -ida_idp._processor_t.oldfile (method) -ida_idp._processor_t.out_assumes (method) -ida_idp._processor_t.out_data (method) -ida_idp._processor_t.out_footer (method) -ida_idp._processor_t.out_header (method) -ida_idp._processor_t.out_insn (method) -ida_idp._processor_t.out_label (method) -ida_idp._processor_t.out_mnem (method) -ida_idp._processor_t.out_operand (method) -ida_idp._processor_t.out_segend (method) -ida_idp._processor_t.out_segstart (method) -ida_idp._processor_t.out_special_item (method) -ida_idp._processor_t.privrange_changed (method) -ida_idp._processor_t.realcvt (method) -ida_idp._processor_t.rename (method) -ida_idp._processor_t.set_code16_mode (method) -ida_idp._processor_t.set_idp_options (method) -ida_idp._processor_t.set_proc_options (method) -ida_idp._processor_t.setup_til (method) -ida_idp._processor_t.sizeof_ldbl (method) -ida_idp._processor_t.stkup (method) -ida_idp._processor_t.str2reg (method) -ida_idp._processor_t.supports_calcrel (method) -ida_idp._processor_t.supports_macros (method) -ida_idp._processor_t.term (method) -ida_idp._processor_t.ti (method) -ida_idp._processor_t.treat_hindering_item (method) -ida_idp._processor_t.undefine (method) -ida_idp._processor_t.update_call_stack (method) -ida_idp._processor_t.use32 (method) -ida_idp._processor_t.use64 (method) -ida_idp._processor_t.use_arg_types (method) -ida_idp._processor_t.use_mappings (method) -ida_idp._processor_t.use_regarg_type (method) -ida_idp._processor_t.use_stkarg_type (method) -ida_idp._processor_t.use_tbyte (method) -ida_idp._processor_t.validate_flirt_func (method) -ida_idp._processor_t.verify_noreturn (method) -ida_idp._processor_t.verify_sp (method) -ida_idp._processor_t_Trampoline_IDB_Hooks (class) -ida_idp._processor_t_Trampoline_IDB_Hooks.__dummy (method) -ida_idp._processor_t_Trampoline_IDB_Hooks.__init__ (method) -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller (method) -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller.call_parent (function) -ida_idp._processor_t_add_cref (function) -ida_idp._processor_t_add_dref (function) -ida_idp._processor_t_adjust_argloc (function) -ida_idp._processor_t_adjust_libfunc_ea (function) -ida_idp._processor_t_adjust_refinfo (function) -ida_idp._processor_t_ana_insn (function) -ida_idp._processor_t_analyze_prolog (function) -ida_idp._processor_t_arch_changed (function) -ida_idp._processor_t_arg_addrs_ready (function) -ida_idp._processor_t_asm_installed (function) -ida_idp._processor_t_assemble (function) -ida_idp._processor_t_auto_queue_empty (function) -ida_idp._processor_t_calc_arglocs (function) -ida_idp._processor_t_calc_cdecl_purged_bytes (function) -ida_idp._processor_t_calc_next_eas (function) -ida_idp._processor_t_calc_purged_bytes (function) -ida_idp._processor_t_calc_retloc (function) -ida_idp._processor_t_calc_spdelta (function) -ida_idp._processor_t_calc_step_over (function) -ida_idp._processor_t_calc_switch_cases (function) -ida_idp._processor_t_calc_varglocs (function) -ida_idp._processor_t_calcrel (function) -ida_idp._processor_t_can_have_type (function) -ida_idp._processor_t_clean_tbit (function) -ida_idp._processor_t_cmp_operands (function) -ida_idp._processor_t_coagulate (function) -ida_idp._processor_t_coagulate_dref (function) -ida_idp._processor_t_create_flat_group (function) -ida_idp._processor_t_create_func_frame (function) -ida_idp._processor_t_create_merge_handlers (function) -ida_idp._processor_t_create_switch_xrefs (function) -ida_idp._processor_t_creating_segm (function) -ida_idp._processor_t_decorate_name (function) -ida_idp._processor_t_del_cref (function) -ida_idp._processor_t_del_dref (function) -ida_idp._processor_t_demangle_name (function) -ida_idp._processor_t_emu_insn (function) -ida_idp._processor_t_endbinary (function) -ida_idp._processor_t_equal_reglocs (function) -ida_idp._processor_t_extract_address (function) -ida_idp._processor_t_find_op_value (function) -ida_idp._processor_t_find_reg_value (function) -ida_idp._processor_t_func_bounds (function) -ida_idp._processor_t_gen_asm_or_lst (function) -ida_idp._processor_t_gen_map_file (function) -ida_idp._processor_t_gen_regvar_def (function) -ida_idp._processor_t_gen_src_file_lnnum (function) -ida_idp._processor_t_gen_stkvar_def (function) -ida_idp._processor_t_get_abi_info (function) -ida_idp._processor_t_get_autocmt (function) -ida_idp._processor_t_get_bg_color (function) -ida_idp._processor_t_get_cc_regs (function) -ida_idp._processor_t_get_code16_mode (function) -ida_idp._processor_t_get_dbr_opnum (function) -ida_idp._processor_t_get_frame_retsize (function) -ida_idp._processor_t_get_idd_opinfo (function) -ida_idp._processor_t_get_macro_insn_head (function) -ida_idp._processor_t_get_operand_string (function) -ida_idp._processor_t_get_reg_accesses (function) -ida_idp._processor_t_get_reg_info (function) -ida_idp._processor_t_get_reg_name (function) -ida_idp._processor_t_get_simd_types (function) -ida_idp._processor_t_get_stkarg_area_info (function) -ida_idp._processor_t_get_stkvar_scale_factor (function) -ida_idp._processor_t_getreg (function) -ida_idp._processor_t_init (function) -ida_idp._processor_t_insn_reads_tbit (function) -ida_idp._processor_t_is_align_insn (function) -ida_idp._processor_t_is_alloca_probe (function) -ida_idp._processor_t_is_basic_block_end (function) -ida_idp._processor_t_is_call_insn (function) -ida_idp._processor_t_is_cond_insn (function) -ida_idp._processor_t_is_control_flow_guard (function) -ida_idp._processor_t_is_far_jump (function) -ida_idp._processor_t_is_indirect_jump (function) -ida_idp._processor_t_is_jump_func (function) -ida_idp._processor_t_is_ret_insn (function) -ida_idp._processor_t_is_sane_insn (function) -ida_idp._processor_t_is_sp_based (function) -ida_idp._processor_t_is_switch (function) -ida_idp._processor_t_loader_elf_machine (function) -ida_idp._processor_t_lower_func_type (function) -ida_idp._processor_t_max_ptr_size (function) -ida_idp._processor_t_may_be_func (function) -ida_idp._processor_t_may_show_sreg (function) -ida_idp._processor_t_moving_segm (function) -ida_idp._processor_t_newasm (function) -ida_idp._processor_t_newbinary (function) -ida_idp._processor_t_newfile (function) -ida_idp._processor_t_newprc (function) -ida_idp._processor_t_next_exec_insn (function) -ida_idp._processor_t_notify (function) -ida_idp._processor_t_oldfile (function) -ida_idp._processor_t_out_assumes (function) -ida_idp._processor_t_out_data (function) -ida_idp._processor_t_out_footer (function) -ida_idp._processor_t_out_header (function) -ida_idp._processor_t_out_insn (function) -ida_idp._processor_t_out_label (function) -ida_idp._processor_t_out_mnem (function) -ida_idp._processor_t_out_operand (function) -ida_idp._processor_t_out_segend (function) -ida_idp._processor_t_out_segstart (function) -ida_idp._processor_t_out_special_item (function) -ida_idp._processor_t_realcvt (function) -ida_idp._processor_t_rename (function) -ida_idp._processor_t_set_code16_mode (function) -ida_idp._processor_t_set_idp_options (function) -ida_idp._processor_t_set_proc_options (function) -ida_idp._processor_t_setup_til (function) -ida_idp._processor_t_str2reg (function) -ida_idp._processor_t_term (function) -ida_idp._processor_t_treat_hindering_item (function) -ida_idp._processor_t_undefine (function) -ida_idp._processor_t_update_call_stack (function) -ida_idp._processor_t_use_arg_types (function) -ida_idp._processor_t_use_regarg_type (function) -ida_idp._processor_t_use_stkarg_type (function) -ida_idp._processor_t_validate_flirt_func (function) -ida_idp._processor_t_verify_noreturn (function) -ida_idp._processor_t_verify_sp (function) -ida_idp.asm_t (class) -ida_idp.asm_t.__init__ (method) -ida_idp.asm_t.a_align (variable) -ida_idp.asm_t.a_ascii (variable) -ida_idp.asm_t.a_band (variable) -ida_idp.asm_t.a_bnot (variable) -ida_idp.asm_t.a_bor (variable) -ida_idp.asm_t.a_bss (variable) -ida_idp.asm_t.a_byte (variable) -ida_idp.asm_t.a_comdef (variable) -ida_idp.asm_t.a_curip (variable) -ida_idp.asm_t.a_double (variable) -ida_idp.asm_t.a_dups (variable) -ida_idp.asm_t.a_dword (variable) -ida_idp.asm_t.a_equ (variable) -ida_idp.asm_t.a_extrn (variable) -ida_idp.asm_t.a_float (variable) -ida_idp.asm_t.a_include_fmt (variable) -ida_idp.asm_t.a_mod (variable) -ida_idp.asm_t.a_oword (variable) -ida_idp.asm_t.a_packreal (variable) -ida_idp.asm_t.a_public (variable) -ida_idp.asm_t.a_qword (variable) -ida_idp.asm_t.a_rva (variable) -ida_idp.asm_t.a_seg (variable) -ida_idp.asm_t.a_shl (variable) -ida_idp.asm_t.a_shr (variable) -ida_idp.asm_t.a_sizeof_fmt (variable) -ida_idp.asm_t.a_tbyte (variable) -ida_idp.asm_t.a_vstruc_fmt (variable) -ida_idp.asm_t.a_weak (variable) -ida_idp.asm_t.a_word (variable) -ida_idp.asm_t.a_xor (variable) -ida_idp.asm_t.a_yword (variable) -ida_idp.asm_t.a_zword (variable) -ida_idp.asm_t.accsep (variable) -ida_idp.asm_t.ascsep (variable) -ida_idp.asm_t.cmnt (variable) -ida_idp.asm_t.cmnt2 (variable) -ida_idp.asm_t.end (variable) -ida_idp.asm_t.esccodes (variable) -ida_idp.asm_t.flag (variable) -ida_idp.asm_t.flag2 (variable) -ida_idp.asm_t.header (variable) -ida_idp.asm_t.help (variable) -ida_idp.asm_t.high16 (variable) -ida_idp.asm_t.high8 (variable) -ida_idp.asm_t.lbrace (variable) -ida_idp.asm_t.low16 (variable) -ida_idp.asm_t.low8 (variable) -ida_idp.asm_t.name (variable) -ida_idp.asm_t.origin (variable) -ida_idp.asm_t.rbrace (variable) -ida_idp.asm_t.uflag (variable) -ida_idp.assemble (function) -ida_idp.cfg_get_cc_header_path (function) -ida_idp.cfg_get_cc_parm (function) -ida_idp.cfg_get_cc_predefined_macros (function) -ida_idp.delay_slot_insn (function) -ida_idp.gen_idb_event (function) -ida_idp.get_ash (function) -ida_idp.get_config_value (function) -ida_idp.get_idb_notifier_addr (function) -ida_idp.get_idb_notifier_ud_addr (function) -ida_idp.get_idp_name (function) -ida_idp.get_idp_notifier_addr (function) -ida_idp.get_idp_notifier_ud_addr (function) -ida_idp.get_ph (function) -ida_idp.get_reg_info (function) -ida_idp.get_reg_name (function) -ida_idp.has_cf_chg (function) -ida_idp.has_cf_use (function) -ida_idp.has_insn_feature (function) -ida_idp.is_align_insn (function) -ida_idp.is_basic_block_end (function) -ida_idp.is_call_insn (function) -ida_idp.is_indirect_jump_insn (function) -ida_idp.is_ret_insn (function) -ida_idp.num_range_t (class) -ida_idp.num_range_t.__init__ (method) -ida_idp.params_t (class) -ida_idp.params_t.__init__ (method) -ida_idp.parse_reg_name (function) -ida_idp.ph_calcrel (function) -ida_idp.ph_find_op_value (function) -ida_idp.ph_find_reg_value (function) -ida_idp.ph_get_cnbits (function) -ida_idp.ph_get_dnbits (function) -ida_idp.ph_get_flag (function) -ida_idp.ph_get_icode_return (function) -ida_idp.ph_get_id (function) -ida_idp.ph_get_instruc (function) -ida_idp.ph_get_instruc_end (function) -ida_idp.ph_get_instruc_start (function) -ida_idp.ph_get_operand_info (function) -ida_idp.ph_get_reg_accesses (function) -ida_idp.ph_get_reg_code_sreg (function) -ida_idp.ph_get_reg_data_sreg (function) -ida_idp.ph_get_reg_first_sreg (function) -ida_idp.ph_get_reg_last_sreg (function) -ida_idp.ph_get_regnames (function) -ida_idp.ph_get_segreg_size (function) -ida_idp.ph_get_tbyte_size (function) -ida_idp.ph_get_version (function) -ida_idp.process_config_directive (function) -ida_idp.processor_t (class) -ida_idp.processor_t.__init__ (method) -ida_idp.processor_t._get_idb_notifier_addr (method) -ida_idp.processor_t._get_idb_notifier_ud_addr (method) -ida_idp.processor_t._get_idp_notifier_addr (method) -ida_idp.processor_t._get_idp_notifier_ud_addr (method) -ida_idp.processor_t._get_notify (method) -ida_idp.processor_t._make_forced_value_wrapper (method) -ida_idp.processor_t._make_forced_value_wrapper.f (function) -ida_idp.processor_t._make_int_returning_wrapper (method) -ida_idp.processor_t._make_int_returning_wrapper.f (function) -ida_idp.processor_t.auto_empty (method) -ida_idp.processor_t.auto_empty_finally (method) -ida_idp.processor_t.closebase (method) -ida_idp.processor_t.compiler_changed (method) -ida_idp.processor_t.deleting_func (method) -ida_idp.processor_t.determined_main (method) -ida_idp.processor_t.ev_ana_insn (method) -ida_idp.processor_t.ev_assemble (method) -ida_idp.processor_t.ev_auto_queue_empty (method) -ida_idp.processor_t.ev_calc_step_over (method) -ida_idp.processor_t.ev_can_have_type (method) -ida_idp.processor_t.ev_cmp_operands (method) -ida_idp.processor_t.ev_coagulate (method) -ida_idp.processor_t.ev_coagulate_dref (method) -ida_idp.processor_t.ev_create_func_frame (method) -ida_idp.processor_t.ev_create_switch_xrefs (method) -ida_idp.processor_t.ev_creating_segm (method) -ida_idp.processor_t.ev_emu_insn (method) -ida_idp.processor_t.ev_endbinary (method) -ida_idp.processor_t.ev_func_bounds (method) -ida_idp.processor_t.ev_gen_map_file (method) -ida_idp.processor_t.ev_gen_regvar_def (method) -ida_idp.processor_t.ev_gen_src_file_lnnum (method) -ida_idp.processor_t.ev_get_autocmt (method) -ida_idp.processor_t.ev_get_frame_retsize (method) -ida_idp.processor_t.ev_get_operand_string (method) -ida_idp.processor_t.ev_is_align_insn (method) -ida_idp.processor_t.ev_is_alloca_probe (method) -ida_idp.processor_t.ev_is_basic_block_end (method) -ida_idp.processor_t.ev_is_call_insn (method) -ida_idp.processor_t.ev_is_far_jump (method) -ida_idp.processor_t.ev_is_indirect_jump (method) -ida_idp.processor_t.ev_is_insn_table_jump (method) -ida_idp.processor_t.ev_is_ret_insn (method) -ida_idp.processor_t.ev_is_sane_insn (method) -ida_idp.processor_t.ev_is_sp_based (method) -ida_idp.processor_t.ev_is_switch (method) -ida_idp.processor_t.ev_may_be_func (method) -ida_idp.processor_t.ev_may_show_sreg (method) -ida_idp.processor_t.ev_moving_segm (method) -ida_idp.processor_t.ev_newbinary (method) -ida_idp.processor_t.ev_newfile (method) -ida_idp.processor_t.ev_newprc (method) -ida_idp.processor_t.ev_oldfile (method) -ida_idp.processor_t.ev_out_assumes (method) -ida_idp.processor_t.ev_out_data (method) -ida_idp.processor_t.ev_out_footer (method) -ida_idp.processor_t.ev_out_header (method) -ida_idp.processor_t.ev_out_insn (method) -ida_idp.processor_t.ev_out_label (method) -ida_idp.processor_t.ev_out_mnem (method) -ida_idp.processor_t.ev_out_operand (method) -ida_idp.processor_t.ev_out_segend (method) -ida_idp.processor_t.ev_out_segstart (method) -ida_idp.processor_t.ev_out_special_item (method) -ida_idp.processor_t.ev_rename (method) -ida_idp.processor_t.ev_set_idp_options (method) -ida_idp.processor_t.ev_set_proc_options (method) -ida_idp.processor_t.ev_str2reg (method) -ida_idp.processor_t.ev_treat_hindering_item (method) -ida_idp.processor_t.ev_undefine (method) -ida_idp.processor_t.ev_validate_flirt_func (method) -ida_idp.processor_t.ev_verify_noreturn (method) -ida_idp.processor_t.ev_verify_sp (method) -ida_idp.processor_t.func_added (method) -ida_idp.processor_t.get_auxpref (method) -ida_idp.processor_t.get_idpdesc (method) -ida_idp.processor_t.get_uFlag (method) -ida_idp.processor_t.idasgn_loaded (method) -ida_idp.processor_t.kernel_config_loaded (method) -ida_idp.processor_t.make_code (method) -ida_idp.processor_t.make_data (method) -ida_idp.processor_t.renamed (method) -ida_idp.processor_t.savebase (method) -ida_idp.processor_t.segm_moved (method) -ida_idp.processor_t.set_func_end (method) -ida_idp.processor_t.set_func_start (method) -ida_idp.processor_t.sgr_changed (method) -ida_idp.reg_access_t (class) -ida_idp.reg_access_t.__eq__ (method) -ida_idp.reg_access_t.__init__ (method) -ida_idp.reg_access_t.__ne__ (method) -ida_idp.reg_access_t.have_common_bits (method) -ida_idp.reg_access_t.opnum (variable) -ida_idp.reg_access_t.range (variable) -ida_idp.reg_access_t.regnum (variable) -ida_idp.reg_access_vec_t (class) -ida_idp.reg_access_vec_t.__eq__ (method) -ida_idp.reg_access_vec_t.__getitem__ (method) -ida_idp.reg_access_vec_t.__init__ (method) -ida_idp.reg_access_vec_t.__len__ (method) -ida_idp.reg_access_vec_t.__ne__ (method) -ida_idp.reg_access_vec_t.__setitem__ (method) -ida_idp.reg_access_vec_t._del (method) -ida_idp.reg_access_vec_t.add_unique (method) -ida_idp.reg_access_vec_t.at (method) -ida_idp.reg_access_vec_t.begin (method) -ida_idp.reg_access_vec_t.capacity (method) -ida_idp.reg_access_vec_t.clear (method) -ida_idp.reg_access_vec_t.empty (method) -ida_idp.reg_access_vec_t.end (method) -ida_idp.reg_access_vec_t.erase (method) -ida_idp.reg_access_vec_t.extract (method) -ida_idp.reg_access_vec_t.find (method) -ida_idp.reg_access_vec_t.grow (method) -ida_idp.reg_access_vec_t.has (method) -ida_idp.reg_access_vec_t.inject (method) -ida_idp.reg_access_vec_t.insert (method) -ida_idp.reg_access_vec_t.pop_back (method) -ida_idp.reg_access_vec_t.push_back (method) -ida_idp.reg_access_vec_t.qclear (method) -ida_idp.reg_access_vec_t.reserve (method) -ida_idp.reg_access_vec_t.resize (method) -ida_idp.reg_access_vec_t.size (method) -ida_idp.reg_access_vec_t.swap (method) -ida_idp.reg_access_vec_t.truncate (method) -ida_idp.reg_accesses_t (class) -ida_idp.reg_accesses_t.__init__ (method) -ida_idp.reg_info_t (class) -ida_idp.reg_info_t.__eq__ (method) -ida_idp.reg_info_t.__ge__ (method) -ida_idp.reg_info_t.__gt__ (method) -ida_idp.reg_info_t.__init__ (method) -ida_idp.reg_info_t.__le__ (method) -ida_idp.reg_info_t.__lt__ (method) -ida_idp.reg_info_t.__ne__ (method) -ida_idp.reg_info_t.compare (method) -ida_idp.reg_info_t.reg (variable) -ida_idp.reg_info_t.size (variable) -ida_idp.register_cfgopts (function) -ida_idp.set_processor_type (function) -ida_idp.set_target_assembler (function) -ida_idp.sizeof_ldbl (function) -ida_idp.str2reg (function) -ida_ieee (module) -ida_ieee.E_SPECIAL_EXP (variable) -ida_ieee.FPV_BADARG (variable) -ida_ieee.FPV_NAN (variable) -ida_ieee.FPV_NINF (variable) -ida_ieee.FPV_NORM (variable) -ida_ieee.FPV_PINF (variable) -ida_ieee.IEEE_EXONE (variable) -ida_ieee.REAL_ERROR_FPOVER (variable) -ida_ieee.REAL_ERROR_INTOVER (variable) -ida_ieee.REAL_ERROR_OK (variable) -ida_ieee.ecleaz (function) -ida_ieee.fpvalue_shorts_array_t (class) -ida_ieee.fpvalue_shorts_array_t.__getitem__ (method) -ida_ieee.fpvalue_shorts_array_t.__init__ (method) -ida_ieee.fpvalue_shorts_array_t.__len__ (method) -ida_ieee.fpvalue_shorts_array_t.__setitem__ (method) -ida_ieee.fpvalue_shorts_array_t._get_bytes (method) -ida_ieee.fpvalue_shorts_array_t._set_bytes (method) -ida_ieee.fpvalue_t (class) -ida_ieee.fpvalue_t.__add__ (method) -ida_ieee.fpvalue_t.__eq__ (method) -ida_ieee.fpvalue_t.__ge__ (method) -ida_ieee.fpvalue_t.__getitem__ (method) -ida_ieee.fpvalue_t.__gt__ (method) -ida_ieee.fpvalue_t.__init__ (method) -ida_ieee.fpvalue_t.__iter__ (method) -ida_ieee.fpvalue_t.__le__ (method) -ida_ieee.fpvalue_t.__lt__ (method) -ida_ieee.fpvalue_t.__mul__ (method) -ida_ieee.fpvalue_t.__ne__ (method) -ida_ieee.fpvalue_t.__setitem__ (method) -ida_ieee.fpvalue_t.__str__ (method) -ida_ieee.fpvalue_t.__sub__ (method) -ida_ieee.fpvalue_t.__truediv__ (method) -ida_ieee.fpvalue_t._get_10bytes (method) -ida_ieee.fpvalue_t._get_bytes (method) -ida_ieee.fpvalue_t._get_float (method) -ida_ieee.fpvalue_t._get_shorts (method) -ida_ieee.fpvalue_t._set_10bytes (method) -ida_ieee.fpvalue_t._set_bytes (method) -ida_ieee.fpvalue_t._set_float (method) -ida_ieee.fpvalue_t.assign (method) -ida_ieee.fpvalue_t.clear (method) -ida_ieee.fpvalue_t.compare (method) -ida_ieee.fpvalue_t.eabs (method) -ida_ieee.fpvalue_t.fadd (method) -ida_ieee.fpvalue_t.fdiv (method) -ida_ieee.fpvalue_t.fmul (method) -ida_ieee.fpvalue_t.from_10bytes (method) -ida_ieee.fpvalue_t.from_12bytes (method) -ida_ieee.fpvalue_t.from_int64 (method) -ida_ieee.fpvalue_t.from_str (method) -ida_ieee.fpvalue_t.from_sval (method) -ida_ieee.fpvalue_t.from_uint64 (method) -ida_ieee.fpvalue_t.fsub (method) -ida_ieee.fpvalue_t.get_kind (method) -ida_ieee.fpvalue_t.is_negative (method) -ida_ieee.fpvalue_t.mul_pow2 (method) -ida_ieee.fpvalue_t.negate (method) -ida_ieee.fpvalue_t.to_10bytes (method) -ida_ieee.fpvalue_t.to_12bytes (method) -ida_ieee.fpvalue_t.to_int64 (method) -ida_ieee.fpvalue_t.to_str (method) -ida_ieee.fpvalue_t.to_sval (method) -ida_ieee.fpvalue_t.to_uint64 (method) -ida_kernwin (module) -ida_kernwin.AA_CHECKABLE (variable) -ida_kernwin.AA_CHECKED (variable) -ida_kernwin.AA_ICON (variable) -ida_kernwin.AA_LABEL (variable) -ida_kernwin.AA_NONE (variable) -ida_kernwin.AA_SHORTCUT (variable) -ida_kernwin.AA_STATE (variable) -ida_kernwin.AA_TOOLTIP (variable) -ida_kernwin.AA_VISIBILITY (variable) -ida_kernwin.ACF_HAS_FIELD_DIRTREE_SELECTION (variable) -ida_kernwin.ACF_HAS_SELECTION (variable) -ida_kernwin.ACF_HAS_SOURCE (variable) -ida_kernwin.ACF_HAS_TYPE_REF (variable) -ida_kernwin.ACF_XTRN_EA (variable) -ida_kernwin.ADF_CHECKABLE (variable) -ida_kernwin.ADF_CHECKED (variable) -ida_kernwin.ADF_GLOBAL (variable) -ida_kernwin.ADF_NO_HIGHLIGHT (variable) -ida_kernwin.ADF_NO_UNDO (variable) -ida_kernwin.ADF_OT_MASK (variable) -ida_kernwin.ADF_OT_PLUGIN (variable) -ida_kernwin.ADF_OT_PLUGMOD (variable) -ida_kernwin.ADF_OT_PROCMOD (variable) -ida_kernwin.ADF_OWN_HANDLER (variable) -ida_kernwin.AHF_VERSION (variable) -ida_kernwin.AHF_VERSION_MASK (variable) -ida_kernwin.ASKBTN_BTN1 (variable) -ida_kernwin.ASKBTN_BTN2 (variable) -ida_kernwin.ASKBTN_BTN3 (variable) -ida_kernwin.ASKBTN_CANCEL (variable) -ida_kernwin.ASKBTN_NO (variable) -ida_kernwin.ASKBTN_YES (variable) -ida_kernwin.AST_DISABLE (variable) -ida_kernwin.AST_DISABLE_ALWAYS (variable) -ida_kernwin.AST_DISABLE_FOR_IDB (variable) -ida_kernwin.AST_DISABLE_FOR_WIDGET (variable) -ida_kernwin.AST_ENABLE (variable) -ida_kernwin.AST_ENABLE_ALWAYS (variable) -ida_kernwin.AST_ENABLE_FOR_IDB (variable) -ida_kernwin.AST_ENABLE_FOR_WIDGET (variable) -ida_kernwin.BWN_ADDRWATCH (variable) -ida_kernwin.BWN_BOOKMARKS (variable) -ida_kernwin.BWN_BPTS (variable) -ida_kernwin.BWN_CALLS (variable) -ida_kernwin.BWN_CALLS_CALLEES (variable) -ida_kernwin.BWN_CALLS_CALLERS (variable) -ida_kernwin.BWN_CALL_STACK (variable) -ida_kernwin.BWN_CHOOSER (variable) -ida_kernwin.BWN_CLI (variable) -ida_kernwin.BWN_CMDPALCSR (variable) -ida_kernwin.BWN_CMDPALWIN (variable) -ida_kernwin.BWN_CPUREGS (variable) -ida_kernwin.BWN_CUSTVIEW (variable) -ida_kernwin.BWN_CV_LINE_INFOS (variable) -ida_kernwin.BWN_DISASM (variable) -ida_kernwin.BWN_DISASMS (variable) -ida_kernwin.BWN_DISASM_ARROWS (variable) -ida_kernwin.BWN_DUMP (variable) -ida_kernwin.BWN_DUMPS (variable) -ida_kernwin.BWN_ENUMS (variable) -ida_kernwin.BWN_EXPORTS (variable) -ida_kernwin.BWN_FRAME (variable) -ida_kernwin.BWN_FUNCS (variable) -ida_kernwin.BWN_IMPORTS (variable) -ida_kernwin.BWN_LOCALS (variable) -ida_kernwin.BWN_LOCTYPS (variable) -ida_kernwin.BWN_MDVIEWCSR (variable) -ida_kernwin.BWN_MODULES (variable) -ida_kernwin.BWN_NAMES (variable) -ida_kernwin.BWN_NAVBAND (variable) -ida_kernwin.BWN_NOTEPAD (variable) -ida_kernwin.BWN_OUTPUT (variable) -ida_kernwin.BWN_PROBS (variable) -ida_kernwin.BWN_PSEUDOCODE (variable) -ida_kernwin.BWN_SCRIPTS_CSR (variable) -ida_kernwin.BWN_SEARCH (variable) -ida_kernwin.BWN_SEARCHS (variable) -ida_kernwin.BWN_SEGREGS (variable) -ida_kernwin.BWN_SEGS (variable) -ida_kernwin.BWN_SELS (variable) -ida_kernwin.BWN_SHORTCUTCSR (variable) -ida_kernwin.BWN_SHORTCUTWIN (variable) -ida_kernwin.BWN_SIGNS (variable) -ida_kernwin.BWN_SNIPPETS (variable) -ida_kernwin.BWN_SNIPPETS_CSR (variable) -ida_kernwin.BWN_SO_OFFSETS (variable) -ida_kernwin.BWN_SO_STRUCTS (variable) -ida_kernwin.BWN_SRCPTHMAP_CSR (variable) -ida_kernwin.BWN_SRCPTHUND_CSR (variable) -ida_kernwin.BWN_STACK (variable) -ida_kernwin.BWN_STKVIEW (variable) -ida_kernwin.BWN_STRINGS (variable) -ida_kernwin.BWN_STRUCTS (variable) -ida_kernwin.BWN_THREADS (variable) -ida_kernwin.BWN_TILIST (variable) -ida_kernwin.BWN_TILS (variable) -ida_kernwin.BWN_TRACE (variable) -ida_kernwin.BWN_UNDOHIST (variable) -ida_kernwin.BWN_UNKNOWN (variable) -ida_kernwin.BWN_WATCH (variable) -ida_kernwin.BWN_XREFS (variable) -ida_kernwin.CDVF_LINEICONS (variable) -ida_kernwin.CDVF_NOLINES (variable) -ida_kernwin.CDVF_STATUSBAR (variable) -ida_kernwin.CDVH_LINES_ALIGNMENT (variable) -ida_kernwin.CDVH_LINES_CLICK (variable) -ida_kernwin.CDVH_LINES_DBLCLICK (variable) -ida_kernwin.CDVH_LINES_DRAWICON (variable) -ida_kernwin.CDVH_LINES_ICONMARGIN (variable) -ida_kernwin.CDVH_LINES_LINENUM (variable) -ida_kernwin.CDVH_LINES_POPUP (variable) -ida_kernwin.CDVH_LINES_RADIX (variable) -ida_kernwin.CDVH_SRCVIEW (variable) -ida_kernwin.CDVH_USERDATA (variable) -ida_kernwin.CH2_LAZY_LOADED (variable) -ida_kernwin.CHCOL_DEC (variable) -ida_kernwin.CHCOL_DEFHIDDEN (variable) -ida_kernwin.CHCOL_DRAGHINT (variable) -ida_kernwin.CHCOL_EA (variable) -ida_kernwin.CHCOL_FNAME (variable) -ida_kernwin.CHCOL_FORMAT (variable) -ida_kernwin.CHCOL_HEX (variable) -ida_kernwin.CHCOL_INODENAME (variable) -ida_kernwin.CHCOL_PATH (variable) -ida_kernwin.CHCOL_PLAIN (variable) -ida_kernwin.CHITEM_BOLD (variable) -ida_kernwin.CHITEM_GRAY (variable) -ida_kernwin.CHITEM_ITALIC (variable) -ida_kernwin.CHITEM_STRIKE (variable) -ida_kernwin.CHITEM_UNDER (variable) -ida_kernwin.CHOOSER_NOMAINMENU (variable) -ida_kernwin.CHOOSER_NOSTATUSBAR (variable) -ida_kernwin.CH_ATTRS (variable) -ida_kernwin.CH_BUILTIN_MASK (variable) -ida_kernwin.CH_CAN_DEL (variable) -ida_kernwin.CH_CAN_EDIT (variable) -ida_kernwin.CH_CAN_INS (variable) -ida_kernwin.CH_CAN_REFRESH (variable) -ida_kernwin.CH_FORCE_DEFAULT (variable) -ida_kernwin.CH_HAS_DIFF (variable) -ida_kernwin.CH_HAS_DIRTREE (variable) -ida_kernwin.CH_KEEP (variable) -ida_kernwin.CH_MODAL (variable) -ida_kernwin.CH_MULTI (variable) -ida_kernwin.CH_MULTI_EDIT (variable) -ida_kernwin.CH_NOBTNS (variable) -ida_kernwin.CH_NON_PERSISTED_TREE (variable) -ida_kernwin.CH_NO_FILTER (variable) -ida_kernwin.CH_NO_SORT (variable) -ida_kernwin.CH_NO_STATUS_BAR (variable) -ida_kernwin.CH_QFLT (variable) -ida_kernwin.CH_QFTYP_DEFAULT (variable) -ida_kernwin.CH_QFTYP_FUZZY (variable) -ida_kernwin.CH_QFTYP_NORMAL (variable) -ida_kernwin.CH_QFTYP_REGEX (variable) -ida_kernwin.CH_QFTYP_WHOLE_WORDS (variable) -ida_kernwin.CH_RENAME_IS_EDIT (variable) -ida_kernwin.CH_RESTORE (variable) -ida_kernwin.CH_TM_FOLDERS_ONLY (variable) -ida_kernwin.CH_TM_FULL_TREE (variable) -ida_kernwin.CH_TM_NO_TREE (variable) -ida_kernwin.CK_EXTRA1 (variable) -ida_kernwin.CK_EXTRA10 (variable) -ida_kernwin.CK_EXTRA11 (variable) -ida_kernwin.CK_EXTRA12 (variable) -ida_kernwin.CK_EXTRA13 (variable) -ida_kernwin.CK_EXTRA14 (variable) -ida_kernwin.CK_EXTRA15 (variable) -ida_kernwin.CK_EXTRA16 (variable) -ida_kernwin.CK_EXTRA2 (variable) -ida_kernwin.CK_EXTRA3 (variable) -ida_kernwin.CK_EXTRA4 (variable) -ida_kernwin.CK_EXTRA5 (variable) -ida_kernwin.CK_EXTRA6 (variable) -ida_kernwin.CK_EXTRA7 (variable) -ida_kernwin.CK_EXTRA8 (variable) -ida_kernwin.CK_EXTRA9 (variable) -ida_kernwin.CK_TRACE (variable) -ida_kernwin.CK_TRACE_OVL (variable) -ida_kernwin.CLNL_FINDCMT (variable) -ida_kernwin.CLNL_LTRIM (variable) -ida_kernwin.CLNL_RTRIM (variable) -ida_kernwin.CREATETB_ADV (variable) -ida_kernwin.CVH_CLICK (variable) -ida_kernwin.CVH_CLOSE (variable) -ida_kernwin.CVH_CURPOS (variable) -ida_kernwin.CVH_DBLCLICK (variable) -ida_kernwin.CVH_HELP (variable) -ida_kernwin.CVH_KEYDOWN (variable) -ida_kernwin.CVH_MOUSEMOVE (variable) -ida_kernwin.CVH_POPUP (variable) -ida_kernwin.CVH_QT_AWARE (variable) -ida_kernwin.CVLF_USE_MOUSE (variable) -ida_kernwin.CVNF_ACT (variable) -ida_kernwin.CVNF_JUMP (variable) -ida_kernwin.CVNF_LAZY (variable) -ida_kernwin.Choose (class) -ida_kernwin.Choose.ALREADY_EXISTS (variable) -ida_kernwin.Choose.Activate (method) -ida_kernwin.Choose.AddCommand (method) -ida_kernwin.Choose.CH_CAN_DEL (variable) -ida_kernwin.Choose.CH_CAN_EDIT (variable) -ida_kernwin.Choose.CH_CAN_INS (variable) -ida_kernwin.Choose.CH_CAN_REFRESH (variable) -ida_kernwin.Choose.CH_FORCE_DEFAULT (variable) -ida_kernwin.Choose.CH_MODAL (variable) -ida_kernwin.Choose.CH_MULTI (variable) -ida_kernwin.Choose.CH_NOIDB (variable) -ida_kernwin.Choose.CH_NO_STATUS_BAR (variable) -ida_kernwin.Choose.CH_QFLT (variable) -ida_kernwin.Choose.CH_RENAME_IS_EDIT (variable) -ida_kernwin.Choose.CH_RESTORE (variable) -ida_kernwin.Choose.Close (method) -ida_kernwin.Choose.EMPTY_CHOOSER (variable) -ida_kernwin.Choose.Embedded (method) -ida_kernwin.Choose.GetEmbSelection (method) -ida_kernwin.Choose.GetWidget (method) -ida_kernwin.Choose.NO_ATTR (variable) -ida_kernwin.Choose.NO_SELECTION (variable) -ida_kernwin.Choose.OnClose (method) -ida_kernwin.Choose.OnDeleteLine (method) -ida_kernwin.Choose.OnEditLine (method) -ida_kernwin.Choose.OnGetDirTree (method) -ida_kernwin.Choose.OnGetEA (method) -ida_kernwin.Choose.OnGetIcon (method) -ida_kernwin.Choose.OnGetLine (method) -ida_kernwin.Choose.OnGetLineAttr (method) -ida_kernwin.Choose.OnGetSize (method) -ida_kernwin.Choose.OnIndexToDiffpos (method) -ida_kernwin.Choose.OnIndexToInode (method) -ida_kernwin.Choose.OnInit (method) -ida_kernwin.Choose.OnInsertLine (method) -ida_kernwin.Choose.OnLazyLoadDir (method) -ida_kernwin.Choose.OnPopup (method) -ida_kernwin.Choose.OnRefresh (method) -ida_kernwin.Choose.OnSelectLine (method) -ida_kernwin.Choose.OnSelectionChange (method) -ida_kernwin.Choose.Refresh (method) -ida_kernwin.Choose.Show (method) -ida_kernwin.Choose.UI_Hooks_Trampoline (class) -ida_kernwin.Choose.UI_Hooks_Trampoline.__init__ (method) -ida_kernwin.Choose.UI_Hooks_Trampoline.populating_widget_popup (method) -ida_kernwin.Choose.__init__ (method) -ida_kernwin.Choose.__init__._qccb (function) -ida_kernwin.Choose.adjust_last_item (method) -ida_kernwin.CustomIDAMemo (class) -ida_kernwin.CustomIDAMemo.CreateGroups (method) -ida_kernwin.CustomIDAMemo.DelNodesInfos (method) -ida_kernwin.CustomIDAMemo.DeleteGroups (method) -ida_kernwin.CustomIDAMemo.GetCurrentRendererType (method) -ida_kernwin.CustomIDAMemo.GetNodeInfo (method) -ida_kernwin.CustomIDAMemo.GetWidget (method) -ida_kernwin.CustomIDAMemo.GetWidgetAsGraphViewer (method) -ida_kernwin.CustomIDAMemo.Refresh (method) -ida_kernwin.CustomIDAMemo.SetCurrentRendererType (method) -ida_kernwin.CustomIDAMemo.SetGroupsVisibility (method) -ida_kernwin.CustomIDAMemo.SetNodeInfo (method) -ida_kernwin.CustomIDAMemo.SetNodesInfos (method) -ida_kernwin.CustomIDAMemo._OnBind (method) -ida_kernwin.CustomIDAMemo.__init__ (method) -ida_kernwin.CustomIDAMemo._dummy_cb (method) -ida_kernwin.CustomIDAMemo._get_cb (method) -ida_kernwin.CustomIDAMemo._get_cb_arity (method) -ida_kernwin.CustomIDAMemo._graph_item_tuple (method) -ida_kernwin.CustomIDAMemo.view_activated (method) -ida_kernwin.CustomIDAMemo.view_click (method) -ida_kernwin.CustomIDAMemo.view_close (method) -ida_kernwin.CustomIDAMemo.view_curpos (method) -ida_kernwin.CustomIDAMemo.view_dblclick (method) -ida_kernwin.CustomIDAMemo.view_deactivated (method) -ida_kernwin.CustomIDAMemo.view_keydown (method) -ida_kernwin.CustomIDAMemo.view_loc_changed (method) -ida_kernwin.CustomIDAMemo.view_mouse_moved (method) -ida_kernwin.CustomIDAMemo.view_mouse_over (method) -ida_kernwin.CustomIDAMemo.view_switched (method) -ida_kernwin.DP_BEFORE (variable) -ida_kernwin.DP_BOTTOM (variable) -ida_kernwin.DP_FLOATING (variable) -ida_kernwin.DP_INSIDE (variable) -ida_kernwin.DP_LEFT (variable) -ida_kernwin.DP_RIGHT (variable) -ida_kernwin.DP_SZHINT (variable) -ida_kernwin.DP_TAB (variable) -ida_kernwin.DP_TOP (variable) -ida_kernwin.Form (class) -ida_kernwin.Form.Add (method) -ida_kernwin.Form.AddControls (method) -ida_kernwin.Form.ButtonInput (class) -ida_kernwin.Form.ButtonInput.__init__ (method) -ida_kernwin.Form.ButtonInput.helper_cb (method) -ida_kernwin.Form.ButtonInput.is_input_field (method) -ida_kernwin.Form.ChkGroupControl (class) -ida_kernwin.Form.ChkGroupControl.ItemClass (variable) -ida_kernwin.Form.ChkGroupControl.__init__ (method) -ida_kernwin.Form.ChkGroupItemControl (class) -ida_kernwin.Form.ChkGroupItemControl.__get_value (method) -ida_kernwin.Form.ChkGroupItemControl.__init__ (method) -ida_kernwin.Form.ChkGroupItemControl.__set_value (method) -ida_kernwin.Form.ChkGroupItemControl.checked (variable) -ida_kernwin.Form.Close (method) -ida_kernwin.Form.ColorInput (class) -ida_kernwin.Form.ColorInput.__init__ (method) -ida_kernwin.Form.Compile (method) -ida_kernwin.Form.CompileEx (method) -ida_kernwin.Form.CompileEx.next_control (function) -ida_kernwin.Form.Compiled (method) -ida_kernwin.Form.Control (class) -ida_kernwin.Form.Control.__init__ (method) -ida_kernwin.Form.Control.free (method) -ida_kernwin.Form.Control.get_arg (method) -ida_kernwin.Form.Control.get_tag (method) -ida_kernwin.Form.Control.is_input_field (method) -ida_kernwin.Form.ControlToFieldTypeIdAndSize (method) -ida_kernwin.Form.DirInput (class) -ida_kernwin.Form.DirInput.__init__ (method) -ida_kernwin.Form.DropdownListControl (class) -ida_kernwin.Form.DropdownListControl.__get_selval (method) -ida_kernwin.Form.DropdownListControl.__init__ (method) -ida_kernwin.Form.DropdownListControl.__set_selval (method) -ida_kernwin.Form.DropdownListControl.free (method) -ida_kernwin.Form.DropdownListControl.selval (variable) -ida_kernwin.Form.DropdownListControl.set_items (method) -ida_kernwin.Form.EmbeddedChooserControl (class) -ida_kernwin.Form.EmbeddedChooserControl.__get_selection__ (method) -ida_kernwin.Form.EmbeddedChooserControl.__init__ (method) -ida_kernwin.Form.EmbeddedChooserControl.free (method) -ida_kernwin.Form.EmbeddedChooserControl.selection (variable) -ida_kernwin.Form.EmbeddedChooserControl.value (variable) -ida_kernwin.Form.EnableField (method) -ida_kernwin.Form.Execute (method) -ida_kernwin.Form.FT_ADDR (variable) -ida_kernwin.Form.FT_ASCII (variable) -ida_kernwin.Form.FT_BIN (variable) -ida_kernwin.Form.FT_BUTTON (variable) -ida_kernwin.Form.FT_CHAR (variable) -ida_kernwin.Form.FT_COLOR (variable) -ida_kernwin.Form.FT_DEC (variable) -ida_kernwin.Form.FT_DIR (variable) -ida_kernwin.Form.FT_DROPDOWN_LIST (variable) -ida_kernwin.Form.FT_ECHOOSER (variable) -ida_kernwin.Form.FT_FILE (variable) -ida_kernwin.Form.FT_FORMCHG (variable) -ida_kernwin.Form.FT_HEX (variable) -ida_kernwin.Form.FT_HTML_LABEL (variable) -ida_kernwin.Form.FT_IDENT (variable) -ida_kernwin.Form.FT_INT64 (variable) -ida_kernwin.Form.FT_MULTI_LINE_TEXT (variable) -ida_kernwin.Form.FT_OCT (variable) -ida_kernwin.Form.FT_RAWHEX (variable) -ida_kernwin.Form.FT_SEG (variable) -ida_kernwin.Form.FT_SHEX (variable) -ida_kernwin.Form.FT_TYPE (variable) -ida_kernwin.Form.FT_UINT64 (variable) -ida_kernwin.Form.FileInput (class) -ida_kernwin.Form.FileInput.__init__ (method) -ida_kernwin.Form.FindControlById (method) -ida_kernwin.Form.FormChangeCb (class) -ida_kernwin.Form.FormChangeCb.__init__ (method) -ida_kernwin.Form.FormChangeCb.free (method) -ida_kernwin.Form.FormChangeCb.get_tag (method) -ida_kernwin.Form.FormChangeCb.helper_cb (method) -ida_kernwin.Form.Free (method) -ida_kernwin.Form.GetControlValue (method) -ida_kernwin.Form.GetFocusedField (method) -ida_kernwin.Form.GroupControl (class) -ida_kernwin.Form.GroupControl.__init__ (method) -ida_kernwin.Form.GroupControl._reset (method) -ida_kernwin.Form.GroupControl.get_tag (method) -ida_kernwin.Form.GroupControl.next_child_pos (method) -ida_kernwin.Form.GroupItemControl (class) -ida_kernwin.Form.GroupItemControl.__init__ (method) -ida_kernwin.Form.GroupItemControl.assign_pos (method) -ida_kernwin.Form.GroupItemControl.get_tag (method) -ida_kernwin.Form.GroupItemControl.is_input_field (method) -ida_kernwin.Form.InputControl (class) -ida_kernwin.Form.InputControl.__init__ (method) -ida_kernwin.Form.InputControl.get_tag (method) -ida_kernwin.Form.InputControl.is_input_field (method) -ida_kernwin.Form.LabelControl (class) -ida_kernwin.Form.LabelControl.__init__ (method) -ida_kernwin.Form.LabelControl.get_tag (method) -ida_kernwin.Form.MoveField (method) -ida_kernwin.Form.MultiLineTextControl (class) -ida_kernwin.Form.MultiLineTextControl.__init__ (method) -ida_kernwin.Form.MultiLineTextControl.free (method) -ida_kernwin.Form.NumericArgument (class) -ida_kernwin.Form.NumericArgument.__init__ (method) -ida_kernwin.Form.NumericArgument.__set_value (method) -ida_kernwin.Form.NumericInput (class) -ida_kernwin.Form.NumericInput.__init__ (method) -ida_kernwin.Form.NumericLabel (class) -ida_kernwin.Form.NumericLabel.__init__ (method) -ida_kernwin.Form.Open (method) -ida_kernwin.Form.RadGroupControl (class) -ida_kernwin.Form.RadGroupControl.__init__ (method) -ida_kernwin.Form.RadGroupItemControl (class) -ida_kernwin.Form.RadGroupItemControl.__get_value (method) -ida_kernwin.Form.RadGroupItemControl.__init__ (method) -ida_kernwin.Form.RadGroupItemControl.__set_value (method) -ida_kernwin.Form.RadGroupItemControl.selected (variable) -ida_kernwin.Form.RefreshField (method) -ida_kernwin.Form.SetControlValue (method) -ida_kernwin.Form.SetFocusedField (method) -ida_kernwin.Form.ShowField (method) -ida_kernwin.Form.StringArgument (class) -ida_kernwin.Form.StringArgument.__get_value (method) -ida_kernwin.Form.StringArgument.__init__ (method) -ida_kernwin.Form.StringArgument.__set_value (method) -ida_kernwin.Form.StringInput (class) -ida_kernwin.Form.StringInput.__init__ (method) -ida_kernwin.Form.StringLabel (class) -ida_kernwin.Form.StringLabel.__init__ (method) -ida_kernwin.Form._AddGroup (method) -ida_kernwin.Form._ChkCompiled (method) -ida_kernwin.Form._FT_USHORT (variable) -ida_kernwin.Form._ParseFormTitle (method) -ida_kernwin.Form.__getitem__ (method) -ida_kernwin.Form.__init__ (method) -ida_kernwin.Form._reset (method) -ida_kernwin.Form.create_string_buffer (method) -ida_kernwin.Form.fieldtype_to_ctype (method) -ida_kernwin.GCRF_ALL (variable) -ida_kernwin.GCRF_CURRENT (variable) -ida_kernwin.GCRF_HEADER (variable) -ida_kernwin.GCRF_SELECTION (variable) -ida_kernwin.HIF_IDENTIFIER (variable) -ida_kernwin.HIF_LOCKED (variable) -ida_kernwin.HIF_NOCASE (variable) -ida_kernwin.HIF_REGISTER (variable) -ida_kernwin.HIF_SLOT_0 (variable) -ida_kernwin.HIF_SLOT_1 (variable) -ida_kernwin.HIF_SLOT_2 (variable) -ida_kernwin.HIF_SLOT_3 (variable) -ida_kernwin.HIF_SLOT_4 (variable) -ida_kernwin.HIF_SLOT_5 (variable) -ida_kernwin.HIF_SLOT_6 (variable) -ida_kernwin.HIF_SLOT_7 (variable) -ida_kernwin.HIF_SLOT_SHIFT (variable) -ida_kernwin.HIF_USE_SLOT (variable) -ida_kernwin.HIST_CMD (variable) -ida_kernwin.HIST_CMT (variable) -ida_kernwin.HIST_DIR (variable) -ida_kernwin.HIST_FILE (variable) -ida_kernwin.HIST_IDENT (variable) -ida_kernwin.HIST_IDENT2 (variable) -ida_kernwin.HIST_SEG (variable) -ida_kernwin.HIST_SRCH (variable) -ida_kernwin.HIST_TYPE (variable) -ida_kernwin.IDAViewWrapper (class) -ida_kernwin.IDAViewWrapper.Bind (method) -ida_kernwin.IDAViewWrapper.Unbind (method) -ida_kernwin.IDAViewWrapper.__init__ (method) -ida_kernwin.IDA_DEBUG_ACCESSIBILITY (variable) -ida_kernwin.IDA_DEBUG_ALREADY (variable) -ida_kernwin.IDA_DEBUG_ALWAYS (variable) -ida_kernwin.IDA_DEBUG_APPCALL (variable) -ida_kernwin.IDA_DEBUG_CHECKMEM (variable) -ida_kernwin.IDA_DEBUG_CONFIG (variable) -ida_kernwin.IDA_DEBUG_DBGINFO (variable) -ida_kernwin.IDA_DEBUG_DEBUGGER (variable) -ida_kernwin.IDA_DEBUG_DEMANGLE (variable) -ida_kernwin.IDA_DEBUG_DREFS (variable) -ida_kernwin.IDA_DEBUG_FLIRT (variable) -ida_kernwin.IDA_DEBUG_IDP (variable) -ida_kernwin.IDA_DEBUG_IDS (variable) -ida_kernwin.IDA_DEBUG_INTERNET (variable) -ida_kernwin.IDA_DEBUG_LDR (variable) -ida_kernwin.IDA_DEBUG_LICENSE (variable) -ida_kernwin.IDA_DEBUG_LUMINA (variable) -ida_kernwin.IDA_DEBUG_NETWORK (variable) -ida_kernwin.IDA_DEBUG_NOTIFY (variable) -ida_kernwin.IDA_DEBUG_OFFSET (variable) -ida_kernwin.IDA_DEBUG_PLUGIN (variable) -ida_kernwin.IDA_DEBUG_QUEUE (variable) -ida_kernwin.IDA_DEBUG_REGEX (variable) -ida_kernwin.IDA_DEBUG_ROLLBACK (variable) -ida_kernwin.IDA_DEBUG_SIMPLEX (variable) -ida_kernwin.IDA_DEBUG_SRCDBG (variable) -ida_kernwin.IDA_DEBUG_SUBPROC (variable) -ida_kernwin.IDA_DEBUG_THEMES (variable) -ida_kernwin.IDA_DEBUG_TIL (variable) -ida_kernwin.IDCHK_ARG (variable) -ida_kernwin.IDCHK_KEY (variable) -ida_kernwin.IDCHK_MAX (variable) -ida_kernwin.IDCHK_OK (variable) -ida_kernwin.IWID_ADDRWATCH (variable) -ida_kernwin.IWID_ALL (variable) -ida_kernwin.IWID_BOOKMARKS (variable) -ida_kernwin.IWID_BPTS (variable) -ida_kernwin.IWID_CALLS (variable) -ida_kernwin.IWID_CALLS_CALLEES (variable) -ida_kernwin.IWID_CALLS_CALLERS (variable) -ida_kernwin.IWID_CALL_STACK (variable) -ida_kernwin.IWID_CHOOSER (variable) -ida_kernwin.IWID_CLI (variable) -ida_kernwin.IWID_CMDPALCSR (variable) -ida_kernwin.IWID_CMDPALWIN (variable) -ida_kernwin.IWID_CPUREGS (variable) -ida_kernwin.IWID_CUSTVIEW (variable) -ida_kernwin.IWID_CV_LINE_INFOS (variable) -ida_kernwin.IWID_DISASM (variable) -ida_kernwin.IWID_DISASM_ARROWS (variable) -ida_kernwin.IWID_DUMP (variable) -ida_kernwin.IWID_ENUMS (variable) -ida_kernwin.IWID_EXPORTS (variable) -ida_kernwin.IWID_FRAME (variable) -ida_kernwin.IWID_FUNCS (variable) -ida_kernwin.IWID_IMPORTS (variable) -ida_kernwin.IWID_LOCALS (variable) -ida_kernwin.IWID_LOCTYPS (variable) -ida_kernwin.IWID_MDVIEWCSR (variable) -ida_kernwin.IWID_MODULES (variable) -ida_kernwin.IWID_NAMES (variable) -ida_kernwin.IWID_NAVBAND (variable) -ida_kernwin.IWID_NOTEPAD (variable) -ida_kernwin.IWID_OUTPUT (variable) -ida_kernwin.IWID_PROBS (variable) -ida_kernwin.IWID_PSEUDOCODE (variable) -ida_kernwin.IWID_SCRIPTS_CSR (variable) -ida_kernwin.IWID_SEARCH (variable) -ida_kernwin.IWID_SEGREGS (variable) -ida_kernwin.IWID_SEGS (variable) -ida_kernwin.IWID_SELS (variable) -ida_kernwin.IWID_SHORTCUTCSR (variable) -ida_kernwin.IWID_SHORTCUTWIN (variable) -ida_kernwin.IWID_SIGNS (variable) -ida_kernwin.IWID_SNIPPETS (variable) -ida_kernwin.IWID_SNIPPETS_CSR (variable) -ida_kernwin.IWID_SO_OFFSETS (variable) -ida_kernwin.IWID_SO_STRUCTS (variable) -ida_kernwin.IWID_SRCPTHMAP_CSR (variable) -ida_kernwin.IWID_SRCPTHUND_CSR (variable) -ida_kernwin.IWID_STACK (variable) -ida_kernwin.IWID_STKVIEW (variable) -ida_kernwin.IWID_STRINGS (variable) -ida_kernwin.IWID_STRUCTS (variable) -ida_kernwin.IWID_THREADS (variable) -ida_kernwin.IWID_TILIST (variable) -ida_kernwin.IWID_TILS (variable) -ida_kernwin.IWID_TRACE (variable) -ida_kernwin.IWID_UNDOHIST (variable) -ida_kernwin.IWID_WATCH (variable) -ida_kernwin.IWID_XREFS (variable) -ida_kernwin.LROEF_CPS_RANGE (variable) -ida_kernwin.LROEF_FULL_LINE (variable) -ida_kernwin.MFF_FAST (variable) -ida_kernwin.MFF_NOWAIT (variable) -ida_kernwin.MFF_READ (variable) -ida_kernwin.MFF_WRITE (variable) -ida_kernwin.PCF_EA_CAPABLE (variable) -ida_kernwin.PCF_MAKEPLACE_ALLOCATES (variable) -ida_kernwin.PluginForm (class) -ida_kernwin.PluginForm.Close (method) -ida_kernwin.PluginForm.GetWidget (method) -ida_kernwin.PluginForm.OnClose (method) -ida_kernwin.PluginForm.OnCreate (method) -ida_kernwin.PluginForm.QtWidgetToTWidget (method) -ida_kernwin.PluginForm.Show (method) -ida_kernwin.PluginForm.TWidgetToPyQtWidget (method) -ida_kernwin.PluginForm.TWidgetToPySideWidget (method) -ida_kernwin.PluginForm.WCLS_DELETE_LATER (variable) -ida_kernwin.PluginForm.WCLS_DONT_SAVE_SIZE (variable) -ida_kernwin.PluginForm.WCLS_NO_CONTEXT (variable) -ida_kernwin.PluginForm.WCLS_SAVE (variable) -ida_kernwin.PluginForm.WOPN_DP_BEFORE (variable) -ida_kernwin.PluginForm.WOPN_DP_BOTTOM (variable) -ida_kernwin.PluginForm.WOPN_DP_FLOATING (variable) -ida_kernwin.PluginForm.WOPN_DP_INSIDE (variable) -ida_kernwin.PluginForm.WOPN_DP_LEFT (variable) -ida_kernwin.PluginForm.WOPN_DP_RIGHT (variable) -ida_kernwin.PluginForm.WOPN_DP_SZHINT (variable) -ida_kernwin.PluginForm.WOPN_DP_TAB (variable) -ida_kernwin.PluginForm.WOPN_DP_TOP (variable) -ida_kernwin.PluginForm.WOPN_PERSIST (variable) -ida_kernwin.PluginForm.WOPN_RESTORE (variable) -ida_kernwin.PluginForm.__init__ (method) -ida_kernwin.PluginForm._ensure_widget_deps (method) -ida_kernwin.RENADDR_HR (variable) -ida_kernwin.RENADDR_IDA (variable) -ida_kernwin.S2EAOPT_NOCALC (variable) -ida_kernwin.SETMENU_APP (variable) -ida_kernwin.SETMENU_ENSURE_SEP (variable) -ida_kernwin.SETMENU_FIRST (variable) -ida_kernwin.SETMENU_INS (variable) -ida_kernwin.SVF_COPY_LINES (variable) -ida_kernwin.SVF_LINES_BYPTR (variable) -ida_kernwin.TCCPT_ENUMPLACE (variable) -ida_kernwin.TCCPT_IDAPLACE (variable) -ida_kernwin.TCCPT_INVALID (variable) -ida_kernwin.TCCPT_PLACE (variable) -ida_kernwin.TCCPT_SIMPLELINE_PLACE (variable) -ida_kernwin.TCCPT_STRUCTPLACE (variable) -ida_kernwin.TCCPT_TIPLACE (variable) -ida_kernwin.TCCRT_FLAT (variable) -ida_kernwin.TCCRT_GRAPH (variable) -ida_kernwin.TCCRT_INVALID (variable) -ida_kernwin.TCCRT_PROXIMITY (variable) -ida_kernwin.TWidget__from_ptrval__ (function) -ida_kernwin.UIJMP_ACTIVATE (variable) -ida_kernwin.UIJMP_ANYVIEW (variable) -ida_kernwin.UIJMP_DONTPUSH (variable) -ida_kernwin.UIJMP_IDAVIEW (variable) -ida_kernwin.UIJMP_IDAVIEW_NEW (variable) -ida_kernwin.UI_Hooks (class) -ida_kernwin.UI_Hooks.__disown__ (method) -ida_kernwin.UI_Hooks.__init__ (method) -ida_kernwin.UI_Hooks.create_desktop_widget (method) -ida_kernwin.UI_Hooks.current_widget_changed (method) -ida_kernwin.UI_Hooks.database_closed (method) -ida_kernwin.UI_Hooks.database_inited (method) -ida_kernwin.UI_Hooks.debugger_menu_change (method) -ida_kernwin.UI_Hooks.desktop_applied (method) -ida_kernwin.UI_Hooks.destroying_plugmod (method) -ida_kernwin.UI_Hooks.destroying_procmod (method) -ida_kernwin.UI_Hooks.finish_populating_widget_popup (method) -ida_kernwin.UI_Hooks.get_chooser_item_attrs (method) -ida_kernwin.UI_Hooks.get_custom_viewer_hint (method) -ida_kernwin.UI_Hooks.get_ea_hint (method) -ida_kernwin.UI_Hooks.get_item_hint (method) -ida_kernwin.UI_Hooks.get_lines_rendering_info (method) -ida_kernwin.UI_Hooks.get_widget_config (method) -ida_kernwin.UI_Hooks.hook (method) -ida_kernwin.UI_Hooks.idcstart (method) -ida_kernwin.UI_Hooks.idcstop (method) -ida_kernwin.UI_Hooks.initing_database (method) -ida_kernwin.UI_Hooks.plugin_loaded (method) -ida_kernwin.UI_Hooks.plugin_unloading (method) -ida_kernwin.UI_Hooks.populating_widget_popup (method) -ida_kernwin.UI_Hooks.postprocess_action (method) -ida_kernwin.UI_Hooks.preprocess_action (method) -ida_kernwin.UI_Hooks.range (method) -ida_kernwin.UI_Hooks.ready_to_run (method) -ida_kernwin.UI_Hooks.resume (method) -ida_kernwin.UI_Hooks.saved (method) -ida_kernwin.UI_Hooks.saving (method) -ida_kernwin.UI_Hooks.screen_ea_changed (method) -ida_kernwin.UI_Hooks.set_widget_config (method) -ida_kernwin.UI_Hooks.suspend (method) -ida_kernwin.UI_Hooks.unhook (method) -ida_kernwin.UI_Hooks.updated_actions (method) -ida_kernwin.UI_Hooks.updating_actions (method) -ida_kernwin.UI_Hooks.widget_closing (method) -ida_kernwin.UI_Hooks.widget_invisible (method) -ida_kernwin.UI_Hooks.widget_visible (method) -ida_kernwin.VES_SHIFT (variable) -ida_kernwin.VME_LEFT_BUTTON (variable) -ida_kernwin.VME_MID_BUTTON (variable) -ida_kernwin.VME_RIGHT_BUTTON (variable) -ida_kernwin.VME_UNKNOWN (variable) -ida_kernwin.View_Hooks (class) -ida_kernwin.View_Hooks.__disown__ (method) -ida_kernwin.View_Hooks.__init__ (method) -ida_kernwin.View_Hooks.hook (method) -ida_kernwin.View_Hooks.unhook (method) -ida_kernwin.View_Hooks.view_activated (method) -ida_kernwin.View_Hooks.view_click (method) -ida_kernwin.View_Hooks.view_close (method) -ida_kernwin.View_Hooks.view_created (method) -ida_kernwin.View_Hooks.view_curpos (method) -ida_kernwin.View_Hooks.view_dblclick (method) -ida_kernwin.View_Hooks.view_deactivated (method) -ida_kernwin.View_Hooks.view_keydown (method) -ida_kernwin.View_Hooks.view_loc_changed (method) -ida_kernwin.View_Hooks.view_mouse_moved (method) -ida_kernwin.View_Hooks.view_mouse_over (method) -ida_kernwin.View_Hooks.view_switched (method) -ida_kernwin.WCLS_DELETE_LATER (variable) -ida_kernwin.WCLS_DONT_SAVE_SIZE (variable) -ida_kernwin.WCLS_NO_CONTEXT (variable) -ida_kernwin.WCLS_SAVE (variable) -ida_kernwin.WOPN_CLOSED_BY_ESC (variable) -ida_kernwin.WOPN_DP_BEFORE (variable) -ida_kernwin.WOPN_DP_BOTTOM (variable) -ida_kernwin.WOPN_DP_FLOATING (variable) -ida_kernwin.WOPN_DP_INSIDE (variable) -ida_kernwin.WOPN_DP_LEFT (variable) -ida_kernwin.WOPN_DP_RIGHT (variable) -ida_kernwin.WOPN_DP_SZHINT (variable) -ida_kernwin.WOPN_DP_TAB (variable) -ida_kernwin.WOPN_DP_TOP (variable) -ida_kernwin.WOPN_NOT_CLOSED_BY_ESC (variable) -ida_kernwin.WOPN_PERSIST (variable) -ida_kernwin.WOPN_RESTORE (variable) -ida_kernwin.__qtimer_t (class) -ida_kernwin.__qtimer_t.__init__ (method) -ida_kernwin._ask_addr (function) -ida_kernwin._ask_long (function) -ida_kernwin._ask_seg (function) -ida_kernwin._kludge_force_declare_dirspec_t (function) -ida_kernwin._kludge_force_declare_dirtree_t (function) -ida_kernwin.action_ctx_base_cur_sel_t (class) -ida_kernwin.action_ctx_base_cur_sel_t.__init__ (method) -ida_kernwin.action_ctx_base_cur_sel_t.reset (method) -ida_kernwin.action_ctx_base_cur_sel_t.to (variable) -ida_kernwin.action_ctx_base_source_t (class) -ida_kernwin.action_ctx_base_source_t.__init__ (method) -ida_kernwin.action_ctx_base_source_t.reset (method) -ida_kernwin.action_ctx_base_t (class) -ida_kernwin.action_ctx_base_t.__init__ (method) -ida_kernwin.action_ctx_base_t.action (variable) -ida_kernwin.action_ctx_base_t.chooser_selection (variable) -ida_kernwin.action_ctx_base_t.cur_ea (variable) -ida_kernwin.action_ctx_base_t.cur_enum (variable) -ida_kernwin.action_ctx_base_t.cur_fchunk (variable) -ida_kernwin.action_ctx_base_t.cur_flags (variable) -ida_kernwin.action_ctx_base_t.cur_func (variable) -ida_kernwin.action_ctx_base_t.cur_seg (variable) -ida_kernwin.action_ctx_base_t.cur_sel (variable) -ida_kernwin.action_ctx_base_t.cur_strmem (variable) -ida_kernwin.action_ctx_base_t.cur_struc (variable) -ida_kernwin.action_ctx_base_t.cur_value (variable) -ida_kernwin.action_ctx_base_t.dirtree_selection (variable) -ida_kernwin.action_ctx_base_t.focus (variable) -ida_kernwin.action_ctx_base_t.graph_selection (variable) -ida_kernwin.action_ctx_base_t.has_flag (method) -ida_kernwin.action_ctx_base_t.regname (variable) -ida_kernwin.action_ctx_base_t.reset (method) -ida_kernwin.action_ctx_base_t.source (variable) -ida_kernwin.action_ctx_base_t.type_ref (variable) -ida_kernwin.action_ctx_base_t.widget_title (variable) -ida_kernwin.action_ctx_base_t.widget_type (variable) -ida_kernwin.action_desc_t (class) -ida_kernwin.action_desc_t.__init__ (method) -ida_kernwin.action_desc_t.cb (variable) -ida_kernwin.action_desc_t.flags (variable) -ida_kernwin.action_desc_t.icon (variable) -ida_kernwin.action_desc_t.label (variable) -ida_kernwin.action_desc_t.name (variable) -ida_kernwin.action_desc_t.owner (variable) -ida_kernwin.action_desc_t.shortcut (variable) -ida_kernwin.action_desc_t.tooltip (variable) -ida_kernwin.action_handler_t (class) -ida_kernwin.action_handler_t.__init__ (method) -ida_kernwin.action_handler_t.activate (method) -ida_kernwin.action_handler_t.update (method) -ida_kernwin.activate_widget (function) -ida_kernwin.add_hotkey (function) -ida_kernwin.add_idc_hotkey (function) -ida_kernwin.add_spaces (function) -ida_kernwin.addon_count (function) -ida_kernwin.addon_info_t (class) -ida_kernwin.addon_info_t.__init__ (method) -ida_kernwin.analyzer_options (function) -ida_kernwin.ask_addr (function) -ida_kernwin.ask_buttons (function) -ida_kernwin.ask_file (function) -ida_kernwin.ask_for_feedback (function) -ida_kernwin.ask_form (function) -ida_kernwin.ask_ident (function) -ida_kernwin.ask_ident2 (function) -ida_kernwin.ask_long (function) -ida_kernwin.ask_seg (function) -ida_kernwin.ask_str (function) -ida_kernwin.ask_text (function) -ida_kernwin.ask_yn (function) -ida_kernwin.atoea (function) -ida_kernwin.attach_action_to_menu (function) -ida_kernwin.attach_action_to_popup (function) -ida_kernwin.attach_action_to_toolbar (function) -ida_kernwin.attach_dynamic_action_to_popup (function) -ida_kernwin.banner (function) -ida_kernwin.beep (function) -ida_kernwin.call_nav_colorizer (function) -ida_kernwin.cancel_exec_request (function) -ida_kernwin.cancel_thread_exec_requests (function) -ida_kernwin.choose_activate (function) -ida_kernwin.choose_choose (function) -ida_kernwin.choose_close (function) -ida_kernwin.choose_create_embedded_chobj (function) -ida_kernwin.choose_entry (function) -ida_kernwin.choose_enum (function) -ida_kernwin.choose_enum_by_value (function) -ida_kernwin.choose_find (function) -ida_kernwin.choose_func (function) -ida_kernwin.choose_get_widget (function) -ida_kernwin.choose_idasgn (function) -ida_kernwin.choose_name (function) -ida_kernwin.choose_refresh (function) -ida_kernwin.choose_segm (function) -ida_kernwin.choose_srcp (function) -ida_kernwin.choose_stkvar_xref (function) -ida_kernwin.choose_struc (function) -ida_kernwin.choose_struct (function) -ida_kernwin.choose_til (function) -ida_kernwin.choose_xref (function) -ida_kernwin.chooser_base_t (class) -ida_kernwin.chooser_base_t.__init__ (method) -ida_kernwin.chooser_base_t.ask_item_attrs (method) -ida_kernwin.chooser_base_t.can_del (method) -ida_kernwin.chooser_base_t.can_edit (method) -ida_kernwin.chooser_base_t.can_filter (method) -ida_kernwin.chooser_base_t.can_ins (method) -ida_kernwin.chooser_base_t.can_refresh (method) -ida_kernwin.chooser_base_t.can_sort (method) -ida_kernwin.chooser_base_t.columns (variable) -ida_kernwin.chooser_base_t.deflt_col (variable) -ida_kernwin.chooser_base_t.get_builtin_number (method) -ida_kernwin.chooser_base_t.get_count (method) -ida_kernwin.chooser_base_t.get_ea (method) -ida_kernwin.chooser_base_t.get_quick_filter_initial_mode (method) -ida_kernwin.chooser_base_t.get_row (method) -ida_kernwin.chooser_base_t.has_diff_capability (method) -ida_kernwin.chooser_base_t.has_dirtree (method) -ida_kernwin.chooser_base_t.has_inode_to_index (method) -ida_kernwin.chooser_base_t.header (variable) -ida_kernwin.chooser_base_t.height (variable) -ida_kernwin.chooser_base_t.icon (variable) -ida_kernwin.chooser_base_t.is_dirtree_persisted (method) -ida_kernwin.chooser_base_t.is_force_default (method) -ida_kernwin.chooser_base_t.is_lazy_loaded (method) -ida_kernwin.chooser_base_t.is_modal (method) -ida_kernwin.chooser_base_t.is_multi (method) -ida_kernwin.chooser_base_t.is_quick_filter_visible_initially (method) -ida_kernwin.chooser_base_t.is_same (method) -ida_kernwin.chooser_base_t.is_status_bar_hidden (method) -ida_kernwin.chooser_base_t.popup_allowed (method) -ida_kernwin.chooser_base_t.popup_names (variable) -ida_kernwin.chooser_base_t.should_rename_trigger_edit (method) -ida_kernwin.chooser_base_t.should_restore_geometry (method) -ida_kernwin.chooser_base_t.title (variable) -ida_kernwin.chooser_base_t.width (variable) -ida_kernwin.chooser_base_t.widths (variable) -ida_kernwin.chooser_base_t.x0 (variable) -ida_kernwin.chooser_item_attrs_t (class) -ida_kernwin.chooser_item_attrs_t.__eq__ (method) -ida_kernwin.chooser_item_attrs_t.__init__ (method) -ida_kernwin.chooser_item_attrs_t.color (variable) -ida_kernwin.chooser_item_attrs_t.flags (variable) -ida_kernwin.chooser_item_attrs_t.reset (method) -ida_kernwin.chooser_row_info_t (class) -ida_kernwin.chooser_row_info_t.__eq__ (method) -ida_kernwin.chooser_row_info_t.__init__ (method) -ida_kernwin.chooser_row_info_t.__ne__ (method) -ida_kernwin.chooser_row_info_t.attrs (variable) -ida_kernwin.chooser_row_info_t.icon (variable) -ida_kernwin.chooser_row_info_t.texts (variable) -ida_kernwin.chooser_row_info_vec_t (class) -ida_kernwin.chooser_row_info_vec_t.__eq__ (method) -ida_kernwin.chooser_row_info_vec_t.__getitem__ (method) -ida_kernwin.chooser_row_info_vec_t.__init__ (method) -ida_kernwin.chooser_row_info_vec_t.__len__ (method) -ida_kernwin.chooser_row_info_vec_t.__ne__ (method) -ida_kernwin.chooser_row_info_vec_t.__setitem__ (method) -ida_kernwin.chooser_row_info_vec_t._del (method) -ida_kernwin.chooser_row_info_vec_t.add_unique (method) -ida_kernwin.chooser_row_info_vec_t.at (method) -ida_kernwin.chooser_row_info_vec_t.begin (method) -ida_kernwin.chooser_row_info_vec_t.capacity (method) -ida_kernwin.chooser_row_info_vec_t.clear (method) -ida_kernwin.chooser_row_info_vec_t.empty (method) -ida_kernwin.chooser_row_info_vec_t.end (method) -ida_kernwin.chooser_row_info_vec_t.erase (method) -ida_kernwin.chooser_row_info_vec_t.extract (method) -ida_kernwin.chooser_row_info_vec_t.find (method) -ida_kernwin.chooser_row_info_vec_t.grow (method) -ida_kernwin.chooser_row_info_vec_t.has (method) -ida_kernwin.chooser_row_info_vec_t.inject (method) -ida_kernwin.chooser_row_info_vec_t.insert (method) -ida_kernwin.chooser_row_info_vec_t.pop_back (method) -ida_kernwin.chooser_row_info_vec_t.push_back (method) -ida_kernwin.chooser_row_info_vec_t.qclear (method) -ida_kernwin.chooser_row_info_vec_t.reserve (method) -ida_kernwin.chooser_row_info_vec_t.resize (method) -ida_kernwin.chooser_row_info_vec_t.size (method) -ida_kernwin.chooser_row_info_vec_t.swap (method) -ida_kernwin.chooser_row_info_vec_t.truncate (method) -ida_kernwin.chooser_stdact_desc_t (class) -ida_kernwin.chooser_stdact_desc_t.__disown__ (method) -ida_kernwin.chooser_stdact_desc_t.__init__ (method) -ida_kernwin.chooser_stdact_desc_t.label (variable) -ida_kernwin.chooser_stdact_desc_t.ucb (method) -ida_kernwin.chooser_stdact_desc_t.version (variable) -ida_kernwin.chtype_entry (variable) -ida_kernwin.chtype_enum (variable) -ida_kernwin.chtype_enum_by_value (variable) -ida_kernwin.chtype_enum_by_value_and_size (variable) -ida_kernwin.chtype_func (variable) -ida_kernwin.chtype_generic (variable) -ida_kernwin.chtype_idasgn (variable) -ida_kernwin.chtype_idatil (variable) -ida_kernwin.chtype_name (variable) -ida_kernwin.chtype_obsolete_enum (variable) -ida_kernwin.chtype_obsolete_enum_by_value_and_size (variable) -ida_kernwin.chtype_obsolete_struc (variable) -ida_kernwin.chtype_segm (variable) -ida_kernwin.chtype_srcp (variable) -ida_kernwin.chtype_stkvar_xref (variable) -ida_kernwin.chtype_strpath (variable) -ida_kernwin.chtype_struct (variable) -ida_kernwin.chtype_xref (variable) -ida_kernwin.clear_refresh_request (function) -ida_kernwin.cli_t (class) -ida_kernwin.cli_t.OnCompleteLine (method) -ida_kernwin.cli_t.OnExecuteLine (method) -ida_kernwin.cli_t.OnKeydown (method) -ida_kernwin.cli_t.__del__ (method) -ida_kernwin.cli_t.__init__ (method) -ida_kernwin.cli_t.register (method) -ida_kernwin.cli_t.unregister (method) -ida_kernwin.close_chooser (function) -ida_kernwin.close_widget (function) -ida_kernwin.clr_cancelled (function) -ida_kernwin.create_code_viewer (function) -ida_kernwin.create_empty_widget (function) -ida_kernwin.create_menu (function) -ida_kernwin.create_toolbar (function) -ida_kernwin.custom_viewer_jump (function) -ida_kernwin.del_hotkey (function) -ida_kernwin.del_idc_hotkey (function) -ida_kernwin.delete_menu (function) -ida_kernwin.delete_toolbar (function) -ida_kernwin.detach_action_from_menu (function) -ida_kernwin.detach_action_from_popup (function) -ida_kernwin.detach_action_from_toolbar (function) -ida_kernwin.disabled_script_timeout_t (class) -ida_kernwin.disabled_script_timeout_t.__enter__ (method) -ida_kernwin.disabled_script_timeout_t.__exit__ (method) -ida_kernwin.disasm_line_t (class) -ida_kernwin.disasm_line_t.__init__ (method) -ida_kernwin.disasm_text_t (class) -ida_kernwin.disasm_text_t.__getitem__ (method) -ida_kernwin.disasm_text_t.__init__ (method) -ida_kernwin.disasm_text_t.__len__ (method) -ida_kernwin.disasm_text_t.__setitem__ (method) -ida_kernwin.disasm_text_t.at (method) -ida_kernwin.disasm_text_t.begin (method) -ida_kernwin.disasm_text_t.capacity (method) -ida_kernwin.disasm_text_t.clear (method) -ida_kernwin.disasm_text_t.empty (method) -ida_kernwin.disasm_text_t.end (method) -ida_kernwin.disasm_text_t.erase (method) -ida_kernwin.disasm_text_t.extract (method) -ida_kernwin.disasm_text_t.grow (method) -ida_kernwin.disasm_text_t.inject (method) -ida_kernwin.disasm_text_t.insert (method) -ida_kernwin.disasm_text_t.pop_back (method) -ida_kernwin.disasm_text_t.push_back (method) -ida_kernwin.disasm_text_t.qclear (method) -ida_kernwin.disasm_text_t.reserve (method) -ida_kernwin.disasm_text_t.resize (method) -ida_kernwin.disasm_text_t.size (method) -ida_kernwin.disasm_text_t.swap (method) -ida_kernwin.disasm_text_t.truncate (method) -ida_kernwin.display_copyright_warning (function) -ida_kernwin.display_widget (function) -ida_kernwin.ea2str (function) -ida_kernwin.ea_viewer_history_push_and_jump (function) -ida_kernwin.enable_chooser_item_attrs (function) -ida_kernwin.enumplace_t (class) -ida_kernwin.enumplace_t.__init__ (method) -ida_kernwin.enumplace_t.bmask (variable) -ida_kernwin.enumplace_t.idx (variable) -ida_kernwin.enumplace_t.serial (variable) -ida_kernwin.enumplace_t.value (variable) -ida_kernwin.error (function) -ida_kernwin.execute_sync (function) -ida_kernwin.execute_ui_requests (function) -ida_kernwin.find_widget (function) -ida_kernwin.formchgcbfa_close (function) -ida_kernwin.formchgcbfa_enable_field (function) -ida_kernwin.formchgcbfa_get_field_value (function) -ida_kernwin.formchgcbfa_get_focused_field (function) -ida_kernwin.formchgcbfa_move_field (function) -ida_kernwin.formchgcbfa_refresh_field (function) -ida_kernwin.formchgcbfa_set_field_value (function) -ida_kernwin.formchgcbfa_set_focused_field (function) -ida_kernwin.formchgcbfa_show_field (function) -ida_kernwin.free_custom_icon (function) -ida_kernwin.gen_disasm_text (function) -ida_kernwin.get_action_checkable (function) -ida_kernwin.get_action_checked (function) -ida_kernwin.get_action_icon (function) -ida_kernwin.get_action_label (function) -ida_kernwin.get_action_shortcut (function) -ida_kernwin.get_action_state (function) -ida_kernwin.get_action_tooltip (function) -ida_kernwin.get_action_visibility (function) -ida_kernwin.get_active_modal_widget (function) -ida_kernwin.get_addon_info (function) -ida_kernwin.get_addon_info_idx (function) -ida_kernwin.get_chooser_data (function) -ida_kernwin.get_chooser_obj (function) -ida_kernwin.get_chooser_rows (function) -ida_kernwin.get_curline (function) -ida_kernwin.get_current_viewer (function) -ida_kernwin.get_current_widget (function) -ida_kernwin.get_cursor (function) -ida_kernwin.get_custom_viewer_curline (function) -ida_kernwin.get_custom_viewer_location (function) -ida_kernwin.get_custom_viewer_place (function) -ida_kernwin.get_custom_viewer_place_xcoord (function) -ida_kernwin.get_ea_viewer_history_info (function) -ida_kernwin.get_hexdump_ea (function) -ida_kernwin.get_highlight (function) -ida_kernwin.get_icon_id_by_name (function) -ida_kernwin.get_kernel_version (function) -ida_kernwin.get_key_code (function) -ida_kernwin.get_navband_ea (function) -ida_kernwin.get_navband_pixel (function) -ida_kernwin.get_opnum (function) -ida_kernwin.get_output_curline (function) -ida_kernwin.get_output_cursor (function) -ida_kernwin.get_output_selected_text (function) -ida_kernwin.get_place_class (function) -ida_kernwin.get_place_class_id (function) -ida_kernwin.get_place_class_template (function) -ida_kernwin.get_registered_actions (function) -ida_kernwin.get_screen_ea (function) -ida_kernwin.get_synced_group (function) -ida_kernwin.get_tab_size (function) -ida_kernwin.get_user_input_event (function) -ida_kernwin.get_user_strlist_options (function) -ida_kernwin.get_view_renderer_type (function) -ida_kernwin.get_viewer_place_type (function) -ida_kernwin.get_viewer_user_data (function) -ida_kernwin.get_widget_title (function) -ida_kernwin.get_widget_type (function) -ida_kernwin.get_window_id (function) -ida_kernwin.hide_wait_box (function) -ida_kernwin.idaplace_t (class) -ida_kernwin.idaplace_t.__init__ (method) -ida_kernwin.idaplace_t.ea (variable) -ida_kernwin.info (function) -ida_kernwin.input_event_keyboard_data_t (class) -ida_kernwin.input_event_keyboard_data_t.__init__ (method) -ida_kernwin.input_event_mouse_data_t (class) -ida_kernwin.input_event_mouse_data_t.__init__ (method) -ida_kernwin.input_event_shortcut_data_t (class) -ida_kernwin.input_event_shortcut_data_t.__init__ (method) -ida_kernwin.input_event_t (class) -ida_kernwin.input_event_t.__init__ (method) -ida_kernwin.input_event_t._source_as_size (method) -ida_kernwin.input_event_t._target_as_size (method) -ida_kernwin.input_event_t.cb (variable) -ida_kernwin.input_event_t.get_source_QEvent (method) -ida_kernwin.input_event_t.get_target_QWidget (method) -ida_kernwin.input_event_t.kind (variable) -ida_kernwin.input_event_t.modifiers (variable) -ida_kernwin.input_event_t.source (variable) -ida_kernwin.input_event_t.target (variable) -ida_kernwin.install_command_interpreter (function) -ida_kernwin.internal_register_place_class (function) -ida_kernwin.is_action_enabled (function) -ida_kernwin.is_chooser_widget (function) -ida_kernwin.is_idaq (function) -ida_kernwin.is_idaview (function) -ida_kernwin.is_msg_inited (function) -ida_kernwin.is_place_class_ea_capable (function) -ida_kernwin.is_refresh_requested (function) -ida_kernwin.is_tif_cursor_footer (function) -ida_kernwin.is_tif_cursor_header (function) -ida_kernwin.is_tif_cursor_index (function) -ida_kernwin.jobj_wrapper_t (class) -ida_kernwin.jobj_wrapper_t.__init__ (method) -ida_kernwin.jobj_wrapper_t.get_dict (method) -ida_kernwin.jumpto (function) -ida_kernwin.l_compare2 (function) -ida_kernwin.line_rendering_output_entries_refs_t (class) -ida_kernwin.line_rendering_output_entries_refs_t.__eq__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__getitem__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__init__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__len__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__ne__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__setitem__ (method) -ida_kernwin.line_rendering_output_entries_refs_t._del (method) -ida_kernwin.line_rendering_output_entries_refs_t._internal_push_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.add_unique (method) -ida_kernwin.line_rendering_output_entries_refs_t.at (method) -ida_kernwin.line_rendering_output_entries_refs_t.begin (method) -ida_kernwin.line_rendering_output_entries_refs_t.capacity (method) -ida_kernwin.line_rendering_output_entries_refs_t.clear (method) -ida_kernwin.line_rendering_output_entries_refs_t.empty (method) -ida_kernwin.line_rendering_output_entries_refs_t.end (method) -ida_kernwin.line_rendering_output_entries_refs_t.erase (method) -ida_kernwin.line_rendering_output_entries_refs_t.extract (method) -ida_kernwin.line_rendering_output_entries_refs_t.find (method) -ida_kernwin.line_rendering_output_entries_refs_t.has (method) -ida_kernwin.line_rendering_output_entries_refs_t.inject (method) -ida_kernwin.line_rendering_output_entries_refs_t.insert (method) -ida_kernwin.line_rendering_output_entries_refs_t.pop_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.qclear (method) -ida_kernwin.line_rendering_output_entries_refs_t.reserve (method) -ida_kernwin.line_rendering_output_entries_refs_t.resize (method) -ida_kernwin.line_rendering_output_entries_refs_t.size (method) -ida_kernwin.line_rendering_output_entries_refs_t.swap (method) -ida_kernwin.line_rendering_output_entries_refs_t.truncate (method) -ida_kernwin.line_rendering_output_entry_t (class) -ida_kernwin.line_rendering_output_entry_t.__eq__ (method) -ida_kernwin.line_rendering_output_entry_t.__init__ (method) -ida_kernwin.line_rendering_output_entry_t.__ne__ (method) -ida_kernwin.line_rendering_output_entry_t.cpx (variable) -ida_kernwin.line_rendering_output_entry_t.flags (variable) -ida_kernwin.line_rendering_output_entry_t.is_bg_color_direct (method) -ida_kernwin.line_rendering_output_entry_t.is_bg_color_empty (method) -ida_kernwin.line_rendering_output_entry_t.is_bg_color_key (method) -ida_kernwin.line_rendering_output_entry_t.nchars (variable) -ida_kernwin.line_section_t (class) -ida_kernwin.line_section_t.__init__ (method) -ida_kernwin.line_section_t.contains (method) -ida_kernwin.line_section_t.is_closed (method) -ida_kernwin.line_section_t.is_open (method) -ida_kernwin.line_section_t.valid (method) -ida_kernwin.linearray_t (class) -ida_kernwin.linearray_t.__init__ (method) -ida_kernwin.linearray_t.beginning (method) -ida_kernwin.linearray_t.down (method) -ida_kernwin.linearray_t.ending (method) -ida_kernwin.linearray_t.get_bg_color (method) -ida_kernwin.linearray_t.get_dlnnum (method) -ida_kernwin.linearray_t.get_linecnt (method) -ida_kernwin.linearray_t.get_pfx_color (method) -ida_kernwin.linearray_t.get_place (method) -ida_kernwin.linearray_t.set_place (method) -ida_kernwin.linearray_t.set_userdata (method) -ida_kernwin.linearray_t.up (method) -ida_kernwin.linearray_t.userdata (method) -ida_kernwin.lines_rendering_input_t (class) -ida_kernwin.lines_rendering_input_t.__init__ (method) -ida_kernwin.lines_rendering_input_t.sections_lines (variable) -ida_kernwin.lines_rendering_input_t.sync_group (variable) -ida_kernwin.lines_rendering_output_t (class) -ida_kernwin.lines_rendering_output_t.__eq__ (method) -ida_kernwin.lines_rendering_output_t.__init__ (method) -ida_kernwin.lines_rendering_output_t.__ne__ (method) -ida_kernwin.lines_rendering_output_t.clear (method) -ida_kernwin.lines_rendering_output_t.swap (method) -ida_kernwin.listing_location_t (class) -ida_kernwin.listing_location_t.__init__ (method) -ida_kernwin.load_custom_icon (function) -ida_kernwin.load_dbg_dbginfo (function) -ida_kernwin.lookup_key_code (function) -ida_kernwin.mbox_internal (variable) -ida_kernwin.msg (function) -ida_kernwin.msg_activated (variable) -ida_kernwin.msg_clear (function) -ida_kernwin.msg_click (variable) -ida_kernwin.msg_closed (variable) -ida_kernwin.msg_dblclick (variable) -ida_kernwin.msg_deactivated (variable) -ida_kernwin.msg_get_lines (function) -ida_kernwin.msg_keydown (variable) -ida_kernwin.msg_save (function) -ida_kernwin.nomem (function) -ida_kernwin.open_bookmarks_window (function) -ida_kernwin.open_bpts_window (function) -ida_kernwin.open_calls_window (function) -ida_kernwin.open_disasm_window (function) -ida_kernwin.open_enums_window (function) -ida_kernwin.open_exports_window (function) -ida_kernwin.open_form (function) -ida_kernwin.open_frame_window (function) -ida_kernwin.open_funcs_window (function) -ida_kernwin.open_hexdump_window (function) -ida_kernwin.open_imports_window (function) -ida_kernwin.open_loctypes_window (function) -ida_kernwin.open_modules_window (function) -ida_kernwin.open_names_window (function) -ida_kernwin.open_navband_window (function) -ida_kernwin.open_notepad_window (function) -ida_kernwin.open_problems_window (function) -ida_kernwin.open_segments_window (function) -ida_kernwin.open_segregs_window (function) -ida_kernwin.open_selectors_window (function) -ida_kernwin.open_signatures_window (function) -ida_kernwin.open_stack_window (function) -ida_kernwin.open_strings_window (function) -ida_kernwin.open_structs_window (function) -ida_kernwin.open_threads_window (function) -ida_kernwin.open_tils_window (function) -ida_kernwin.open_trace_window (function) -ida_kernwin.open_url (function) -ida_kernwin.open_xrefs_window (function) -ida_kernwin.place_t (class) -ida_kernwin.place_t.__init__ (method) -ida_kernwin.place_t._print (method) -ida_kernwin.place_t.adjust (method) -ida_kernwin.place_t.as_enumplace_t (method) -ida_kernwin.place_t.as_idaplace_t (method) -ida_kernwin.place_t.as_simpleline_place_t (method) -ida_kernwin.place_t.as_structplace_t (method) -ida_kernwin.place_t.as_tiplace_t (method) -ida_kernwin.place_t.beginning (method) -ida_kernwin.place_t.clone (method) -ida_kernwin.place_t.compare (method) -ida_kernwin.place_t.compare2 (method) -ida_kernwin.place_t.copyfrom (method) -ida_kernwin.place_t.deserialize (method) -ida_kernwin.place_t.ending (method) -ida_kernwin.place_t.enter (method) -ida_kernwin.place_t.generate (method) -ida_kernwin.place_t.id (method) -ida_kernwin.place_t.leave (method) -ida_kernwin.place_t.lnnum (variable) -ida_kernwin.place_t.makeplace (method) -ida_kernwin.place_t.name (method) -ida_kernwin.place_t.next (method) -ida_kernwin.place_t.prev (method) -ida_kernwin.place_t.rebase (method) -ida_kernwin.place_t.serialize (method) -ida_kernwin.place_t.toea (method) -ida_kernwin.place_t.touval (method) -ida_kernwin.place_t_as_enumplace_t (function) -ida_kernwin.place_t_as_idaplace_t (function) -ida_kernwin.place_t_as_simpleline_place_t (function) -ida_kernwin.place_t_as_structplace_t (function) -ida_kernwin.place_t_as_tiplace_t (function) -ida_kernwin.plgform_close (function) -ida_kernwin.plgform_get_widget (function) -ida_kernwin.plgform_new (function) -ida_kernwin.plgform_show (function) -ida_kernwin.process_ui_action (function) -ida_kernwin.py_chooser_base_t_get_row (function) -ida_kernwin.py_get_ask_form (function) -ida_kernwin.py_get_open_form (function) -ida_kernwin.py_load_custom_icon_data (function) -ida_kernwin.py_load_custom_icon_fn (function) -ida_kernwin.py_register_compiled_form (function) -ida_kernwin.py_unregister_compiled_form (function) -ida_kernwin.pyidag_bind (function) -ida_kernwin.pyidag_unbind (function) -ida_kernwin.pyscv_add_line (function) -ida_kernwin.pyscv_clear_lines (function) -ida_kernwin.pyscv_close (function) -ida_kernwin.pyscv_count (function) -ida_kernwin.pyscv_del_line (function) -ida_kernwin.pyscv_edit_line (function) -ida_kernwin.pyscv_get_current_line (function) -ida_kernwin.pyscv_get_current_word (function) -ida_kernwin.pyscv_get_line (function) -ida_kernwin.pyscv_get_pos (function) -ida_kernwin.pyscv_get_selection (function) -ida_kernwin.pyscv_get_widget (function) -ida_kernwin.pyscv_init (function) -ida_kernwin.pyscv_insert_line (function) -ida_kernwin.pyscv_is_focused (function) -ida_kernwin.pyscv_jumpto (function) -ida_kernwin.pyscv_patch_line (function) -ida_kernwin.pyscv_refresh (function) -ida_kernwin.pyscv_show (function) -ida_kernwin.qcleanline (function) -ida_kernwin.quick_widget_commands_t (class) -ida_kernwin.quick_widget_commands_t.__init__ (method) -ida_kernwin.quick_widget_commands_t._ah_t (class) -ida_kernwin.quick_widget_commands_t._ah_t.__init__ (method) -ida_kernwin.quick_widget_commands_t._ah_t.activate (method) -ida_kernwin.quick_widget_commands_t._ah_t.update (method) -ida_kernwin.quick_widget_commands_t._cmd_t (class) -ida_kernwin.quick_widget_commands_t._cmd_t.__init__ (method) -ida_kernwin.quick_widget_commands_t.add (method) -ida_kernwin.quick_widget_commands_t.populate_popup (method) -ida_kernwin.read_range_selection (function) -ida_kernwin.read_selection (function) -ida_kernwin.refresh_chooser (function) -ida_kernwin.refresh_choosers (function) -ida_kernwin.refresh_custom_viewer (function) -ida_kernwin.refresh_idaview (function) -ida_kernwin.refresh_idaview_anyway (function) -ida_kernwin.refresh_navband (function) -ida_kernwin.register_action (function) -ida_kernwin.register_addon (function) -ida_kernwin.register_and_attach_to_menu (function) -ida_kernwin.register_timer (function) -ida_kernwin.remove_command_interpreter (function) -ida_kernwin.renderer_pos_info_t (class) -ida_kernwin.renderer_pos_info_t.__eq__ (method) -ida_kernwin.renderer_pos_info_t.__init__ (method) -ida_kernwin.renderer_pos_info_t.__ne__ (method) -ida_kernwin.renderer_pos_info_t.cx (variable) -ida_kernwin.renderer_pos_info_t.cy (variable) -ida_kernwin.renderer_pos_info_t.node (variable) -ida_kernwin.renderer_pos_info_t.sx (variable) -ida_kernwin.repaint_custom_viewer (function) -ida_kernwin.replace_wait_box (function) -ida_kernwin.request_refresh (function) -ida_kernwin.restore_database_snapshot (function) -ida_kernwin.section_lines_refs_t (class) -ida_kernwin.section_lines_refs_t.__eq__ (method) -ida_kernwin.section_lines_refs_t.__getitem__ (method) -ida_kernwin.section_lines_refs_t.__init__ (method) -ida_kernwin.section_lines_refs_t.__len__ (method) -ida_kernwin.section_lines_refs_t.__ne__ (method) -ida_kernwin.section_lines_refs_t.__setitem__ (method) -ida_kernwin.section_lines_refs_t._del (method) -ida_kernwin.section_lines_refs_t.add_unique (method) -ida_kernwin.section_lines_refs_t.at (method) -ida_kernwin.section_lines_refs_t.begin (method) -ida_kernwin.section_lines_refs_t.capacity (method) -ida_kernwin.section_lines_refs_t.clear (method) -ida_kernwin.section_lines_refs_t.empty (method) -ida_kernwin.section_lines_refs_t.end (method) -ida_kernwin.section_lines_refs_t.erase (method) -ida_kernwin.section_lines_refs_t.extract (method) -ida_kernwin.section_lines_refs_t.find (method) -ida_kernwin.section_lines_refs_t.has (method) -ida_kernwin.section_lines_refs_t.inject (method) -ida_kernwin.section_lines_refs_t.insert (method) -ida_kernwin.section_lines_refs_t.pop_back (method) -ida_kernwin.section_lines_refs_t.push_back (method) -ida_kernwin.section_lines_refs_t.qclear (method) -ida_kernwin.section_lines_refs_t.reserve (method) -ida_kernwin.section_lines_refs_t.resize (method) -ida_kernwin.section_lines_refs_t.size (method) -ida_kernwin.section_lines_refs_t.swap (method) -ida_kernwin.section_lines_refs_t.truncate (method) -ida_kernwin.sections_lines_refs_t (class) -ida_kernwin.sections_lines_refs_t.__eq__ (method) -ida_kernwin.sections_lines_refs_t.__getitem__ (method) -ida_kernwin.sections_lines_refs_t.__init__ (method) -ida_kernwin.sections_lines_refs_t.__len__ (method) -ida_kernwin.sections_lines_refs_t.__ne__ (method) -ida_kernwin.sections_lines_refs_t.__setitem__ (method) -ida_kernwin.sections_lines_refs_t._del (method) -ida_kernwin.sections_lines_refs_t.add_unique (method) -ida_kernwin.sections_lines_refs_t.at (method) -ida_kernwin.sections_lines_refs_t.begin (method) -ida_kernwin.sections_lines_refs_t.capacity (method) -ida_kernwin.sections_lines_refs_t.clear (method) -ida_kernwin.sections_lines_refs_t.empty (method) -ida_kernwin.sections_lines_refs_t.end (method) -ida_kernwin.sections_lines_refs_t.erase (method) -ida_kernwin.sections_lines_refs_t.extract (method) -ida_kernwin.sections_lines_refs_t.find (method) -ida_kernwin.sections_lines_refs_t.grow (method) -ida_kernwin.sections_lines_refs_t.has (method) -ida_kernwin.sections_lines_refs_t.inject (method) -ida_kernwin.sections_lines_refs_t.insert (method) -ida_kernwin.sections_lines_refs_t.pop_back (method) -ida_kernwin.sections_lines_refs_t.push_back (method) -ida_kernwin.sections_lines_refs_t.qclear (method) -ida_kernwin.sections_lines_refs_t.reserve (method) -ida_kernwin.sections_lines_refs_t.resize (method) -ida_kernwin.sections_lines_refs_t.size (method) -ida_kernwin.sections_lines_refs_t.swap (method) -ida_kernwin.sections_lines_refs_t.truncate (method) -ida_kernwin.set_cancelled (function) -ida_kernwin.set_code_viewer_handler (function) -ida_kernwin.set_code_viewer_is_source (function) -ida_kernwin.set_code_viewer_line_handlers (function) -ida_kernwin.set_code_viewer_lines_alignment (function) -ida_kernwin.set_code_viewer_lines_icon_margin (function) -ida_kernwin.set_code_viewer_lines_radix (function) -ida_kernwin.set_code_viewer_user_data (function) -ida_kernwin.set_custom_viewer_qt_aware (function) -ida_kernwin.set_dock_pos (function) -ida_kernwin.set_highlight (function) -ida_kernwin.set_nav_colorizer (function) -ida_kernwin.set_view_renderer_type (function) -ida_kernwin.show_wait_box (function) -ida_kernwin.simplecustviewer_t (class) -ida_kernwin.simplecustviewer_t.AddLine (method) -ida_kernwin.simplecustviewer_t.ClearLines (method) -ida_kernwin.simplecustviewer_t.Close (method) -ida_kernwin.simplecustviewer_t.Count (method) -ida_kernwin.simplecustviewer_t.Create (method) -ida_kernwin.simplecustviewer_t.DelLine (method) -ida_kernwin.simplecustviewer_t.EditLine (method) -ida_kernwin.simplecustviewer_t.GetCurrentLine (method) -ida_kernwin.simplecustviewer_t.GetCurrentWord (method) -ida_kernwin.simplecustviewer_t.GetLine (method) -ida_kernwin.simplecustviewer_t.GetLineNo (method) -ida_kernwin.simplecustviewer_t.GetPos (method) -ida_kernwin.simplecustviewer_t.GetSelection (method) -ida_kernwin.simplecustviewer_t.GetWidget (method) -ida_kernwin.simplecustviewer_t.InsertLine (method) -ida_kernwin.simplecustviewer_t.IsFocused (method) -ida_kernwin.simplecustviewer_t.Jump (method) -ida_kernwin.simplecustviewer_t.OnPopup (method) -ida_kernwin.simplecustviewer_t.PatchLine (method) -ida_kernwin.simplecustviewer_t.Refresh (method) -ida_kernwin.simplecustviewer_t.RefreshCurrent (method) -ida_kernwin.simplecustviewer_t.Show (method) -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline (class) -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.__init__ (method) -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.populating_widget_popup (method) -ida_kernwin.simplecustviewer_t.__init__ (method) -ida_kernwin.simplecustviewer_t.__make_sl_arg (method) -ida_kernwin.simpleline_place_t (class) -ida_kernwin.simpleline_place_t.__init__ (method) -ida_kernwin.simpleline_place_t.n (variable) -ida_kernwin.simpleline_t (class) -ida_kernwin.simpleline_t.__init__ (method) -ida_kernwin.simpleline_t.bgcolor (variable) -ida_kernwin.simpleline_t.color (variable) -ida_kernwin.simpleline_t.line (variable) -ida_kernwin.str2ea (function) -ida_kernwin.str2ea_ex (function) -ida_kernwin.strarray (function) -ida_kernwin.strarray_t (class) -ida_kernwin.strarray_t.__init__ (method) -ida_kernwin.structplace_t (class) -ida_kernwin.structplace_t.__init__ (method) -ida_kernwin.structplace_t.idx (variable) -ida_kernwin.structplace_t.offset (variable) -ida_kernwin.sync_source_t (class) -ida_kernwin.sync_source_t.__eq__ (method) -ida_kernwin.sync_source_t.__init__ (method) -ida_kernwin.sync_source_t.__ne__ (method) -ida_kernwin.sync_source_t.get_register (method) -ida_kernwin.sync_source_t.get_widget (method) -ida_kernwin.sync_source_t.is_register (method) -ida_kernwin.sync_source_t.is_widget (method) -ida_kernwin.sync_source_vec_t (class) -ida_kernwin.sync_source_vec_t.__eq__ (method) -ida_kernwin.sync_source_vec_t.__getitem__ (method) -ida_kernwin.sync_source_vec_t.__init__ (method) -ida_kernwin.sync_source_vec_t.__len__ (method) -ida_kernwin.sync_source_vec_t.__ne__ (method) -ida_kernwin.sync_source_vec_t.__setitem__ (method) -ida_kernwin.sync_source_vec_t._del (method) -ida_kernwin.sync_source_vec_t.add_unique (method) -ida_kernwin.sync_source_vec_t.at (method) -ida_kernwin.sync_source_vec_t.begin (method) -ida_kernwin.sync_source_vec_t.capacity (method) -ida_kernwin.sync_source_vec_t.clear (method) -ida_kernwin.sync_source_vec_t.empty (method) -ida_kernwin.sync_source_vec_t.end (method) -ida_kernwin.sync_source_vec_t.erase (method) -ida_kernwin.sync_source_vec_t.extract (method) -ida_kernwin.sync_source_vec_t.find (method) -ida_kernwin.sync_source_vec_t.has (method) -ida_kernwin.sync_source_vec_t.inject (method) -ida_kernwin.sync_source_vec_t.insert (method) -ida_kernwin.sync_source_vec_t.pop_back (method) -ida_kernwin.sync_source_vec_t.push_back (method) -ida_kernwin.sync_source_vec_t.qclear (method) -ida_kernwin.sync_source_vec_t.reserve (method) -ida_kernwin.sync_source_vec_t.size (method) -ida_kernwin.sync_source_vec_t.swap (method) -ida_kernwin.sync_source_vec_t.truncate (method) -ida_kernwin.sync_sources (function) -ida_kernwin.synced_group_t (class) -ida_kernwin.synced_group_t.__init__ (method) -ida_kernwin.synced_group_t.has (method) -ida_kernwin.synced_group_t.has_register (method) -ida_kernwin.synced_group_t.has_widget (method) -ida_kernwin.tagged_line_section_t (class) -ida_kernwin.tagged_line_section_t.__init__ (method) -ida_kernwin.tagged_line_section_t.substr (method) -ida_kernwin.tagged_line_section_t.valid (method) -ida_kernwin.tagged_line_section_t.valid_in (method) -ida_kernwin.tagged_line_sections_t (class) -ida_kernwin.tagged_line_sections_t.__init__ (method) -ida_kernwin.tagged_line_sections_t.find_in (method) -ida_kernwin.tagged_line_sections_t.nearest_at (method) -ida_kernwin.tagged_line_sections_t.sections_at (method) -ida_kernwin.take_database_snapshot (function) -ida_kernwin.text_t (class) -ida_kernwin.text_t.__getitem__ (method) -ida_kernwin.text_t.__init__ (method) -ida_kernwin.text_t.__len__ (method) -ida_kernwin.text_t.__setitem__ (method) -ida_kernwin.text_t.at (method) -ida_kernwin.text_t.begin (method) -ida_kernwin.text_t.capacity (method) -ida_kernwin.text_t.clear (method) -ida_kernwin.text_t.empty (method) -ida_kernwin.text_t.end (method) -ida_kernwin.text_t.erase (method) -ida_kernwin.text_t.extract (method) -ida_kernwin.text_t.grow (method) -ida_kernwin.text_t.inject (method) -ida_kernwin.text_t.insert (method) -ida_kernwin.text_t.pop_back (method) -ida_kernwin.text_t.push_back (method) -ida_kernwin.text_t.qclear (method) -ida_kernwin.text_t.reserve (method) -ida_kernwin.text_t.resize (method) -ida_kernwin.text_t.size (method) -ida_kernwin.text_t.swap (method) -ida_kernwin.text_t.truncate (method) -ida_kernwin.textctrl_info_t (class) -ida_kernwin.textctrl_info_t.TXTF_ACCEPTTABS (variable) -ida_kernwin.textctrl_info_t.TXTF_AUTOINDENT (variable) -ida_kernwin.textctrl_info_t.TXTF_FIXEDFONT (variable) -ida_kernwin.textctrl_info_t.TXTF_MODIFIED (variable) -ida_kernwin.textctrl_info_t.TXTF_READONLY (variable) -ida_kernwin.textctrl_info_t.TXTF_SELECTED (variable) -ida_kernwin.textctrl_info_t.__get_flags__ (method) -ida_kernwin.textctrl_info_t.__get_tabsize__ (method) -ida_kernwin.textctrl_info_t.__get_text (method) -ida_kernwin.textctrl_info_t.__init__ (method) -ida_kernwin.textctrl_info_t.__set_flags__ (method) -ida_kernwin.textctrl_info_t.__set_tabsize__ (method) -ida_kernwin.textctrl_info_t.__set_text (method) -ida_kernwin.textctrl_info_t._create_clink (method) -ida_kernwin.textctrl_info_t._del_clink (method) -ida_kernwin.textctrl_info_t._get_clink_ptr (method) -ida_kernwin.textctrl_info_t.assign (method) -ida_kernwin.textctrl_info_t.flags (variable) -ida_kernwin.textctrl_info_t.tabsize (variable) -ida_kernwin.textctrl_info_t.text (variable) -ida_kernwin.textctrl_info_t.value (variable) -ida_kernwin.textctrl_info_t_assign (function) -ida_kernwin.textctrl_info_t_create (function) -ida_kernwin.textctrl_info_t_destroy (function) -ida_kernwin.textctrl_info_t_get_clink (function) -ida_kernwin.textctrl_info_t_get_clink_ptr (function) -ida_kernwin.textctrl_info_t_get_flags (function) -ida_kernwin.textctrl_info_t_get_tabsize (function) -ida_kernwin.textctrl_info_t_get_text (function) -ida_kernwin.textctrl_info_t_set_flags (function) -ida_kernwin.textctrl_info_t_set_tabsize (function) -ida_kernwin.textctrl_info_t_set_text (function) -ida_kernwin.tiplace_t (class) -ida_kernwin.tiplace_t.__init__ (method) -ida_kernwin.tiplace_t.calc_udm_offset (method) -ida_kernwin.tiplace_t.fill_type_ref (method) -ida_kernwin.tiplace_t.get_kind (method) -ida_kernwin.tiplace_t.is_footer (method) -ida_kernwin.tiplace_t.is_header (method) -ida_kernwin.tiplace_t.is_index (method) -ida_kernwin.tiplace_t.reset (method) -ida_kernwin.tiplace_t.set_footer (method) -ida_kernwin.tiplace_t.set_header (method) -ida_kernwin.tiplace_t.set_index_by_offset (method) -ida_kernwin.tiplace_t.valid_ord (method) -ida_kernwin.twinline_t (class) -ida_kernwin.twinline_t.__init__ (method) -ida_kernwin.twinline_t.at (variable) -ida_kernwin.twinline_t.bg_color (variable) -ida_kernwin.twinline_t.is_default (variable) -ida_kernwin.twinline_t.line (variable) -ida_kernwin.twinline_t.prefix_color (variable) -ida_kernwin.twinpos_t (class) -ida_kernwin.twinpos_t.__init__ (method) -ida_kernwin.twinpos_t.at (variable) -ida_kernwin.twinpos_t.place (method) -ida_kernwin.twinpos_t.place_as_enumplace_t (method) -ida_kernwin.twinpos_t.place_as_idaplace_t (method) -ida_kernwin.twinpos_t.place_as_simpleline_place_t (method) -ida_kernwin.twinpos_t.place_as_structplace_t (method) -ida_kernwin.twinpos_t.place_as_tiplace_t (method) -ida_kernwin.twinpos_t.x (variable) -ida_kernwin.ui_load_new_file (function) -ida_kernwin.ui_requests_t (class) -ida_kernwin.ui_requests_t.__init__ (method) -ida_kernwin.ui_run_debugger (function) -ida_kernwin.unmark_selection (function) -ida_kernwin.unregister_action (function) -ida_kernwin.unregister_timer (function) -ida_kernwin.update_action_checkable (function) -ida_kernwin.update_action_checked (function) -ida_kernwin.update_action_icon (function) -ida_kernwin.update_action_label (function) -ida_kernwin.update_action_shortcut (function) -ida_kernwin.update_action_state (function) -ida_kernwin.update_action_tooltip (function) -ida_kernwin.update_action_visibility (function) -ida_kernwin.user_cancelled (function) -ida_kernwin.view_activated (variable) -ida_kernwin.view_click (variable) -ida_kernwin.view_close (variable) -ida_kernwin.view_created (variable) -ida_kernwin.view_curpos (variable) -ida_kernwin.view_dblclick (variable) -ida_kernwin.view_deactivated (variable) -ida_kernwin.view_keydown (variable) -ida_kernwin.view_loc_changed (variable) -ida_kernwin.view_mouse_event_location_t (class) -ida_kernwin.view_mouse_event_location_t.__init__ (method) -ida_kernwin.view_mouse_event_location_t.ea (variable) -ida_kernwin.view_mouse_event_location_t.item (variable) -ida_kernwin.view_mouse_event_t (class) -ida_kernwin.view_mouse_event_t.__init__ (method) -ida_kernwin.view_mouse_event_t.button (variable) -ida_kernwin.view_mouse_event_t.location (variable) -ida_kernwin.view_mouse_event_t.renderer_pos (variable) -ida_kernwin.view_mouse_event_t.rtype (variable) -ida_kernwin.view_mouse_event_t.state (variable) -ida_kernwin.view_mouse_event_t.x (variable) -ida_kernwin.view_mouse_event_t.y (variable) -ida_kernwin.view_mouse_moved (variable) -ida_kernwin.view_mouse_over (variable) -ida_kernwin.view_switched (variable) -ida_kernwin.warning (function) -ida_lines (module) -ida_lines.COLOR_ADDR (variable) -ida_lines.COLOR_ADDR_SIZE (variable) -ida_lines.COLOR_ALTOP (variable) -ida_lines.COLOR_ASMDIR (variable) -ida_lines.COLOR_AUTOCMT (variable) -ida_lines.COLOR_BG_MAX (variable) -ida_lines.COLOR_BINPREF (variable) -ida_lines.COLOR_CHAR (variable) -ida_lines.COLOR_CNAME (variable) -ida_lines.COLOR_CODE (variable) -ida_lines.COLOR_CODNAME (variable) -ida_lines.COLOR_COLLAPSED (variable) -ida_lines.COLOR_CREF (variable) -ida_lines.COLOR_CREFTAIL (variable) -ida_lines.COLOR_CURITEM (variable) -ida_lines.COLOR_CURLINE (variable) -ida_lines.COLOR_DATA (variable) -ida_lines.COLOR_DATNAME (variable) -ida_lines.COLOR_DCHAR (variable) -ida_lines.COLOR_DEFAULT (variable) -ida_lines.COLOR_DEMNAME (variable) -ida_lines.COLOR_DNAME (variable) -ida_lines.COLOR_DNUM (variable) -ida_lines.COLOR_DREF (variable) -ida_lines.COLOR_DREFTAIL (variable) -ida_lines.COLOR_DSTR (variable) -ida_lines.COLOR_ERROR (variable) -ida_lines.COLOR_ESC (variable) -ida_lines.COLOR_EXTERN (variable) -ida_lines.COLOR_EXTRA (variable) -ida_lines.COLOR_FG_MAX (variable) -ida_lines.COLOR_HIDLINE (variable) -ida_lines.COLOR_HIDNAME (variable) -ida_lines.COLOR_IMPNAME (variable) -ida_lines.COLOR_INSN (variable) -ida_lines.COLOR_INV (variable) -ida_lines.COLOR_KEYWORD (variable) -ida_lines.COLOR_LIBFUNC (variable) -ida_lines.COLOR_LIBNAME (variable) -ida_lines.COLOR_LOCNAME (variable) -ida_lines.COLOR_LUMFUNC (variable) -ida_lines.COLOR_LUMINA (variable) -ida_lines.COLOR_MACRO (variable) -ida_lines.COLOR_NUMBER (variable) -ida_lines.COLOR_OFF (variable) -ida_lines.COLOR_ON (variable) -ida_lines.COLOR_OPND1 (variable) -ida_lines.COLOR_OPND2 (variable) -ida_lines.COLOR_OPND3 (variable) -ida_lines.COLOR_OPND4 (variable) -ida_lines.COLOR_OPND5 (variable) -ida_lines.COLOR_OPND6 (variable) -ida_lines.COLOR_OPND7 (variable) -ida_lines.COLOR_OPND8 (variable) -ida_lines.COLOR_PREFIX (variable) -ida_lines.COLOR_REG (variable) -ida_lines.COLOR_REGCMT (variable) -ida_lines.COLOR_REGFUNC (variable) -ida_lines.COLOR_RESERVED1 (variable) -ida_lines.COLOR_RPTCMT (variable) -ida_lines.COLOR_SEGNAME (variable) -ida_lines.COLOR_SELECTED (variable) -ida_lines.COLOR_STRING (variable) -ida_lines.COLOR_SYMBOL (variable) -ida_lines.COLOR_UNAME (variable) -ida_lines.COLOR_UNKNAME (variable) -ida_lines.COLOR_UNKNOWN (variable) -ida_lines.COLOR_VOIDOP (variable) -ida_lines.COLSTR (function) -ida_lines.SCOLOR_ADDR (variable) -ida_lines.SCOLOR_ALTOP (variable) -ida_lines.SCOLOR_ASMDIR (variable) -ida_lines.SCOLOR_AUTOCMT (variable) -ida_lines.SCOLOR_BINPREF (variable) -ida_lines.SCOLOR_CHAR (variable) -ida_lines.SCOLOR_CNAME (variable) -ida_lines.SCOLOR_CODNAME (variable) -ida_lines.SCOLOR_COLLAPSED (variable) -ida_lines.SCOLOR_CREF (variable) -ida_lines.SCOLOR_CREFTAIL (variable) -ida_lines.SCOLOR_DATNAME (variable) -ida_lines.SCOLOR_DCHAR (variable) -ida_lines.SCOLOR_DEFAULT (variable) -ida_lines.SCOLOR_DEMNAME (variable) -ida_lines.SCOLOR_DNAME (variable) -ida_lines.SCOLOR_DNUM (variable) -ida_lines.SCOLOR_DREF (variable) -ida_lines.SCOLOR_DREFTAIL (variable) -ida_lines.SCOLOR_DSTR (variable) -ida_lines.SCOLOR_ERROR (variable) -ida_lines.SCOLOR_ESC (variable) -ida_lines.SCOLOR_EXTRA (variable) -ida_lines.SCOLOR_HIDNAME (variable) -ida_lines.SCOLOR_IMPNAME (variable) -ida_lines.SCOLOR_INSN (variable) -ida_lines.SCOLOR_INV (variable) -ida_lines.SCOLOR_KEYWORD (variable) -ida_lines.SCOLOR_LIBNAME (variable) -ida_lines.SCOLOR_LOCNAME (variable) -ida_lines.SCOLOR_MACRO (variable) -ida_lines.SCOLOR_NUMBER (variable) -ida_lines.SCOLOR_OFF (variable) -ida_lines.SCOLOR_ON (variable) -ida_lines.SCOLOR_PREFIX (variable) -ida_lines.SCOLOR_REG (variable) -ida_lines.SCOLOR_REGCMT (variable) -ida_lines.SCOLOR_RPTCMT (variable) -ida_lines.SCOLOR_SEGNAME (variable) -ida_lines.SCOLOR_STRING (variable) -ida_lines.SCOLOR_SYMBOL (variable) -ida_lines.SCOLOR_UNAME (variable) -ida_lines.SCOLOR_UNKNAME (variable) -ida_lines.SCOLOR_VOIDOP (variable) -ida_lines.add_extra_cmt (function) -ida_lines.add_extra_line (function) -ida_lines.add_pgm_cmt (function) -ida_lines.add_sourcefile (function) -ida_lines.calc_bg_color (function) -ida_lines.calc_prefix_color (function) -ida_lines.create_encoding_helper (function) -ida_lines.del_extra_cmt (function) -ida_lines.del_sourcefile (function) -ida_lines.delete_extra_cmts (function) -ida_lines.generate_disasm_line (function) -ida_lines.generate_disassembly (function) -ida_lines.get_extra_cmt (function) -ida_lines.get_first_free_extra_cmtidx (function) -ida_lines.get_sourcefile (function) -ida_lines.install_user_defined_prefix (function) -ida_lines.requires_color_esc (function) -ida_lines.set_user_defined_prefix (function) -ida_lines.tag_addr (function) -ida_lines.tag_advance (function) -ida_lines.tag_remove (function) -ida_lines.tag_skipcode (function) -ida_lines.tag_skipcodes (function) -ida_lines.tag_strlen (function) -ida_lines.update_extra_cmt (function) -ida_lines.user_defined_prefix_t (class) -ida_lines.user_defined_prefix_t.__disown__ (method) -ida_lines.user_defined_prefix_t.__init__ (method) -ida_lines.user_defined_prefix_t.get_user_defined_prefix (method) -ida_loader (module) -ida_loader.ACCEPT_ARCHIVE (variable) -ida_loader.ACCEPT_CONTINUE (variable) -ida_loader.ACCEPT_FIRST (variable) -ida_loader.DBFL_BAK (variable) -ida_loader.DBFL_COMP (variable) -ida_loader.DBFL_KILL (variable) -ida_loader.DBFL_TEMP (variable) -ida_loader.FILEREG_NOTPATCHABLE (variable) -ida_loader.FILEREG_PATCHABLE (variable) -ida_loader.GENFLG_ASMINC (variable) -ida_loader.GENFLG_ASMTYPE (variable) -ida_loader.GENFLG_GENHTML (variable) -ida_loader.LDRF_RELOAD (variable) -ida_loader.LDRF_REQ_PROC (variable) -ida_loader.MAX_DATABASE_DESCRIPTION (variable) -ida_loader.NEF_CODE (variable) -ida_loader.NEF_FILL (variable) -ida_loader.NEF_FIRST (variable) -ida_loader.NEF_FLAT (variable) -ida_loader.NEF_IMPS (variable) -ida_loader.NEF_LALL (variable) -ida_loader.NEF_LOPT (variable) -ida_loader.NEF_MAN (variable) -ida_loader.NEF_MINI (variable) -ida_loader.NEF_NAME (variable) -ida_loader.NEF_RELOAD (variable) -ida_loader.NEF_RSCS (variable) -ida_loader.NEF_SEGS (variable) -ida_loader.OFILE_ASM (variable) -ida_loader.OFILE_DIF (variable) -ida_loader.OFILE_EXE (variable) -ida_loader.OFILE_IDC (variable) -ida_loader.OFILE_LST (variable) -ida_loader.OFILE_MAP (variable) -ida_loader.PATH_TYPE_CMD (variable) -ida_loader.PATH_TYPE_ID0 (variable) -ida_loader.PATH_TYPE_IDB (variable) -ida_loader.PLUGIN_DLL (variable) -ida_loader.SSF_AUTOMATIC (variable) -ida_loader.SSUF_DESC (variable) -ida_loader.SSUF_FLAGS (variable) -ida_loader.SSUF_PATH (variable) -ida_loader.base2file (function) -ida_loader.build_snapshot_tree (function) -ida_loader.clr_database_flag (function) -ida_loader.extract_module_from_archive (function) -ida_loader.file2base (function) -ida_loader.find_plugin (function) -ida_loader.flush_buffers (function) -ida_loader.gen_exe_file (function) -ida_loader.gen_file (function) -ida_loader.get_basic_file_type (function) -ida_loader.get_elf_debug_file_directory (function) -ida_loader.get_file_type_name (function) -ida_loader.get_fileregion_ea (function) -ida_loader.get_fileregion_offset (function) -ida_loader.get_path (function) -ida_loader.get_plugin_options (function) -ida_loader.idp_desc_t (class) -ida_loader.idp_desc_t.__init__ (method) -ida_loader.idp_desc_t.checked (variable) -ida_loader.idp_desc_t.family (variable) -ida_loader.idp_desc_t.is_script (variable) -ida_loader.idp_desc_t.mtime (variable) -ida_loader.idp_desc_t.names (variable) -ida_loader.idp_desc_t.path (variable) -ida_loader.idp_name_t (class) -ida_loader.idp_name_t.__init__ (method) -ida_loader.idp_name_t.hidden (variable) -ida_loader.idp_name_t.lname (variable) -ida_loader.idp_name_t.sname (variable) -ida_loader.is_database_flag (function) -ida_loader.is_trusted_idb (function) -ida_loader.load_and_run_plugin (function) -ida_loader.load_binary_file (function) -ida_loader.load_ids_module (function) -ida_loader.load_plugin (function) -ida_loader.loader_t (class) -ida_loader.loader_t.__init__ (method) -ida_loader.loader_t.flags (variable) -ida_loader.loader_t.version (variable) -ida_loader.mem2base (function) -ida_loader.plugin_info_t (class) -ida_loader.plugin_info_t.__init__ (method) -ida_loader.plugin_info_t.arg (variable) -ida_loader.plugin_info_t.comment (variable) -ida_loader.plugin_info_t.entry (variable) -ida_loader.plugin_info_t.flags (variable) -ida_loader.plugin_info_t.hotkey (variable) -ida_loader.plugin_info_t.name (variable) -ida_loader.plugin_info_t.next (variable) -ida_loader.plugin_info_t.org_hotkey (variable) -ida_loader.plugin_info_t.org_name (variable) -ida_loader.plugin_info_t.path (variable) -ida_loader.process_archive (function) -ida_loader.qvector_snapshotvec_t (class) -ida_loader.qvector_snapshotvec_t.__eq__ (method) -ida_loader.qvector_snapshotvec_t.__getitem__ (method) -ida_loader.qvector_snapshotvec_t.__init__ (method) -ida_loader.qvector_snapshotvec_t.__len__ (method) -ida_loader.qvector_snapshotvec_t.__ne__ (method) -ida_loader.qvector_snapshotvec_t.__setitem__ (method) -ida_loader.qvector_snapshotvec_t._del (method) -ida_loader.qvector_snapshotvec_t.add_unique (method) -ida_loader.qvector_snapshotvec_t.at (method) -ida_loader.qvector_snapshotvec_t.begin (method) -ida_loader.qvector_snapshotvec_t.capacity (method) -ida_loader.qvector_snapshotvec_t.clear (method) -ida_loader.qvector_snapshotvec_t.empty (method) -ida_loader.qvector_snapshotvec_t.end (method) -ida_loader.qvector_snapshotvec_t.erase (method) -ida_loader.qvector_snapshotvec_t.extract (method) -ida_loader.qvector_snapshotvec_t.find (method) -ida_loader.qvector_snapshotvec_t.has (method) -ida_loader.qvector_snapshotvec_t.inject (method) -ida_loader.qvector_snapshotvec_t.insert (method) -ida_loader.qvector_snapshotvec_t.pop_back (method) -ida_loader.qvector_snapshotvec_t.push_back (method) -ida_loader.qvector_snapshotvec_t.qclear (method) -ida_loader.qvector_snapshotvec_t.reserve (method) -ida_loader.qvector_snapshotvec_t.resize (method) -ida_loader.qvector_snapshotvec_t.size (method) -ida_loader.qvector_snapshotvec_t.swap (method) -ida_loader.qvector_snapshotvec_t.truncate (method) -ida_loader.reload_file (function) -ida_loader.run_plugin (function) -ida_loader.save_database (function) -ida_loader.set_database_flag (function) -ida_loader.set_import_name (function) -ida_loader.set_import_ordinal (function) -ida_loader.set_path (function) -ida_loader.snapshot_t (class) -ida_loader.snapshot_t.__eq__ (method) -ida_loader.snapshot_t.__ge__ (method) -ida_loader.snapshot_t.__gt__ (method) -ida_loader.snapshot_t.__init__ (method) -ida_loader.snapshot_t.__le__ (method) -ida_loader.snapshot_t.__lt__ (method) -ida_loader.snapshot_t.__ne__ (method) -ida_loader.snapshot_t.children (variable) -ida_loader.snapshot_t.clear (method) -ida_loader.snapshot_t.desc (variable) -ida_loader.snapshot_t.filename (variable) -ida_loader.snapshot_t.flags (variable) -ida_loader.snapshot_t.id (variable) -ida_lumina (module) -ida_lumina.AMDF_FORCE (variable) -ida_lumina.AMDF_UPGRADE (variable) -ida_lumina.apply_metadata (function) -ida_lumina.backup_metadata (function) -ida_lumina.calc_func_metadata (function) -ida_lumina.diff_metadata (function) -ida_lumina.extra_cmt_t (class) -ida_lumina.extra_cmt_t.__init__ (method) -ida_lumina.extra_cmts_t (class) -ida_lumina.extra_cmts_t.__getitem__ (method) -ida_lumina.extra_cmts_t.__init__ (method) -ida_lumina.extra_cmts_t.__len__ (method) -ida_lumina.extra_cmts_t.__setitem__ (method) -ida_lumina.extra_cmts_t.at (method) -ida_lumina.extra_cmts_t.begin (method) -ida_lumina.extra_cmts_t.capacity (method) -ida_lumina.extra_cmts_t.clear (method) -ida_lumina.extra_cmts_t.empty (method) -ida_lumina.extra_cmts_t.end (method) -ida_lumina.extra_cmts_t.erase (method) -ida_lumina.extra_cmts_t.extract (method) -ida_lumina.extra_cmts_t.grow (method) -ida_lumina.extra_cmts_t.inject (method) -ida_lumina.extra_cmts_t.insert (method) -ida_lumina.extra_cmts_t.pop_back (method) -ida_lumina.extra_cmts_t.push_back (method) -ida_lumina.extra_cmts_t.qclear (method) -ida_lumina.extra_cmts_t.reserve (method) -ida_lumina.extra_cmts_t.resize (method) -ida_lumina.extra_cmts_t.size (method) -ida_lumina.extra_cmts_t.swap (method) -ida_lumina.extra_cmts_t.truncate (method) -ida_lumina.extract_extra_cmts_from_metadata (function) -ida_lumina.extract_frame_desc_from_metadata (function) -ida_lumina.extract_insn_cmts_from_metadata (function) -ida_lumina.extract_insn_opreprs_from_metadata (function) -ida_lumina.extract_insn_opreprs_from_metadata_ex (function) -ida_lumina.extract_type_from_metadata (function) -ida_lumina.extract_user_stkpnts_from_metadata (function) -ida_lumina.frame_desc_t (class) -ida_lumina.frame_desc_t.__init__ (method) -ida_lumina.frame_mem_t (class) -ida_lumina.frame_mem_t.__init__ (method) -ida_lumina.frame_mems_t (class) -ida_lumina.frame_mems_t.__getitem__ (method) -ida_lumina.frame_mems_t.__init__ (method) -ida_lumina.frame_mems_t.__len__ (method) -ida_lumina.frame_mems_t.__setitem__ (method) -ida_lumina.frame_mems_t.at (method) -ida_lumina.frame_mems_t.begin (method) -ida_lumina.frame_mems_t.capacity (method) -ida_lumina.frame_mems_t.clear (method) -ida_lumina.frame_mems_t.empty (method) -ida_lumina.frame_mems_t.end (method) -ida_lumina.frame_mems_t.erase (method) -ida_lumina.frame_mems_t.extract (method) -ida_lumina.frame_mems_t.grow (method) -ida_lumina.frame_mems_t.inject (method) -ida_lumina.frame_mems_t.insert (method) -ida_lumina.frame_mems_t.pop_back (method) -ida_lumina.frame_mems_t.push_back (method) -ida_lumina.frame_mems_t.qclear (method) -ida_lumina.frame_mems_t.reserve (method) -ida_lumina.frame_mems_t.resize (method) -ida_lumina.frame_mems_t.size (method) -ida_lumina.frame_mems_t.swap (method) -ida_lumina.frame_mems_t.truncate (method) -ida_lumina.func_info_and_frequency_t (class) -ida_lumina.func_info_and_frequency_t.__init__ (method) -ida_lumina.func_info_and_frequency_vec_t (class) -ida_lumina.func_info_and_frequency_vec_t.__getitem__ (method) -ida_lumina.func_info_and_frequency_vec_t.__init__ (method) -ida_lumina.func_info_and_frequency_vec_t.__len__ (method) -ida_lumina.func_info_and_frequency_vec_t.__setitem__ (method) -ida_lumina.func_info_and_frequency_vec_t.at (method) -ida_lumina.func_info_and_frequency_vec_t.begin (method) -ida_lumina.func_info_and_frequency_vec_t.capacity (method) -ida_lumina.func_info_and_frequency_vec_t.clear (method) -ida_lumina.func_info_and_frequency_vec_t.empty (method) -ida_lumina.func_info_and_frequency_vec_t.end (method) -ida_lumina.func_info_and_frequency_vec_t.erase (method) -ida_lumina.func_info_and_frequency_vec_t.extract (method) -ida_lumina.func_info_and_frequency_vec_t.grow (method) -ida_lumina.func_info_and_frequency_vec_t.inject (method) -ida_lumina.func_info_and_frequency_vec_t.insert (method) -ida_lumina.func_info_and_frequency_vec_t.pop_back (method) -ida_lumina.func_info_and_frequency_vec_t.push_back (method) -ida_lumina.func_info_and_frequency_vec_t.qclear (method) -ida_lumina.func_info_and_frequency_vec_t.reserve (method) -ida_lumina.func_info_and_frequency_vec_t.resize (method) -ida_lumina.func_info_and_frequency_vec_t.size (method) -ida_lumina.func_info_and_frequency_vec_t.swap (method) -ida_lumina.func_info_and_frequency_vec_t.truncate (method) -ida_lumina.func_info_and_pattern_t (class) -ida_lumina.func_info_and_pattern_t.__init__ (method) -ida_lumina.func_info_and_pattern_vec_t (class) -ida_lumina.func_info_and_pattern_vec_t.__getitem__ (method) -ida_lumina.func_info_and_pattern_vec_t.__init__ (method) -ida_lumina.func_info_and_pattern_vec_t.__len__ (method) -ida_lumina.func_info_and_pattern_vec_t.__setitem__ (method) -ida_lumina.func_info_and_pattern_vec_t.at (method) -ida_lumina.func_info_and_pattern_vec_t.begin (method) -ida_lumina.func_info_and_pattern_vec_t.capacity (method) -ida_lumina.func_info_and_pattern_vec_t.clear (method) -ida_lumina.func_info_and_pattern_vec_t.empty (method) -ida_lumina.func_info_and_pattern_vec_t.end (method) -ida_lumina.func_info_and_pattern_vec_t.erase (method) -ida_lumina.func_info_and_pattern_vec_t.extract (method) -ida_lumina.func_info_and_pattern_vec_t.grow (method) -ida_lumina.func_info_and_pattern_vec_t.inject (method) -ida_lumina.func_info_and_pattern_vec_t.insert (method) -ida_lumina.func_info_and_pattern_vec_t.pop_back (method) -ida_lumina.func_info_and_pattern_vec_t.push_back (method) -ida_lumina.func_info_and_pattern_vec_t.qclear (method) -ida_lumina.func_info_and_pattern_vec_t.reserve (method) -ida_lumina.func_info_and_pattern_vec_t.resize (method) -ida_lumina.func_info_and_pattern_vec_t.size (method) -ida_lumina.func_info_and_pattern_vec_t.swap (method) -ida_lumina.func_info_and_pattern_vec_t.truncate (method) -ida_lumina.func_info_base_t (class) -ida_lumina.func_info_base_t.__init__ (method) -ida_lumina.func_info_pattern_and_frequency_t (class) -ida_lumina.func_info_pattern_and_frequency_t.__init__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t (class) -ida_lumina.func_info_pattern_and_frequency_vec_t.__getitem__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.__init__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.__len__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.__setitem__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.at (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.begin (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.capacity (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.clear (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.empty (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.end (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.erase (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.extract (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.grow (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.inject (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.insert (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.pop_back (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.push_back (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.qclear (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.reserve (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.resize (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.size (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.swap (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.truncate (method) -ida_lumina.func_info_t (class) -ida_lumina.func_info_t.__init__ (method) -ida_lumina.func_info_vec_t (class) -ida_lumina.func_info_vec_t.__getitem__ (method) -ida_lumina.func_info_vec_t.__init__ (method) -ida_lumina.func_info_vec_t.__len__ (method) -ida_lumina.func_info_vec_t.__setitem__ (method) -ida_lumina.func_info_vec_t.at (method) -ida_lumina.func_info_vec_t.begin (method) -ida_lumina.func_info_vec_t.capacity (method) -ida_lumina.func_info_vec_t.clear (method) -ida_lumina.func_info_vec_t.empty (method) -ida_lumina.func_info_vec_t.end (method) -ida_lumina.func_info_vec_t.erase (method) -ida_lumina.func_info_vec_t.extract (method) -ida_lumina.func_info_vec_t.grow (method) -ida_lumina.func_info_vec_t.inject (method) -ida_lumina.func_info_vec_t.insert (method) -ida_lumina.func_info_vec_t.pop_back (method) -ida_lumina.func_info_vec_t.push_back (method) -ida_lumina.func_info_vec_t.qclear (method) -ida_lumina.func_info_vec_t.reserve (method) -ida_lumina.func_info_vec_t.resize (method) -ida_lumina.func_info_vec_t.size (method) -ida_lumina.func_info_vec_t.swap (method) -ida_lumina.func_info_vec_t.truncate (method) -ida_lumina.func_md_diff_handler_t (class) -ida_lumina.func_md_diff_handler_t.__disown__ (method) -ida_lumina.func_md_diff_handler_t.__init__ (method) -ida_lumina.func_md_diff_handler_t.on_comment_changed (method) -ida_lumina.func_md_diff_handler_t.on_extra_comment_changed (method) -ida_lumina.func_md_diff_handler_t.on_frame_member_changed (method) -ida_lumina.func_md_diff_handler_t.on_function_comment_changed (method) -ida_lumina.func_md_diff_handler_t.on_insn_ops_repr_changed (method) -ida_lumina.func_md_diff_handler_t.on_name_changed (method) -ida_lumina.func_md_diff_handler_t.on_proto_changed (method) -ida_lumina.func_md_diff_handler_t.on_score_changed (method) -ida_lumina.func_md_diff_handler_t.on_user_stkpnt_changed (method) -ida_lumina.get_lumina_rpc_packet_t_index_from_base (function) -ida_lumina.get_server_connection (function) -ida_lumina.get_server_connection2 (function) -ida_lumina.has_backup_metadata (function) -ida_lumina.input_file_t (class) -ida_lumina.input_file_t.__init__ (method) -ida_lumina.insn_cmt_t (class) -ida_lumina.insn_cmt_t.__init__ (method) -ida_lumina.insn_cmts_t (class) -ida_lumina.insn_cmts_t.__getitem__ (method) -ida_lumina.insn_cmts_t.__init__ (method) -ida_lumina.insn_cmts_t.__len__ (method) -ida_lumina.insn_cmts_t.__setitem__ (method) -ida_lumina.insn_cmts_t.at (method) -ida_lumina.insn_cmts_t.begin (method) -ida_lumina.insn_cmts_t.capacity (method) -ida_lumina.insn_cmts_t.clear (method) -ida_lumina.insn_cmts_t.empty (method) -ida_lumina.insn_cmts_t.end (method) -ida_lumina.insn_cmts_t.erase (method) -ida_lumina.insn_cmts_t.extract (method) -ida_lumina.insn_cmts_t.grow (method) -ida_lumina.insn_cmts_t.inject (method) -ida_lumina.insn_cmts_t.insert (method) -ida_lumina.insn_cmts_t.pop_back (method) -ida_lumina.insn_cmts_t.push_back (method) -ida_lumina.insn_cmts_t.qclear (method) -ida_lumina.insn_cmts_t.reserve (method) -ida_lumina.insn_cmts_t.resize (method) -ida_lumina.insn_cmts_t.size (method) -ida_lumina.insn_cmts_t.swap (method) -ida_lumina.insn_cmts_t.truncate (method) -ida_lumina.insn_ops_repr_t (class) -ida_lumina.insn_ops_repr_t.__init__ (method) -ida_lumina.insn_ops_reprs_t (class) -ida_lumina.insn_ops_reprs_t.__getitem__ (method) -ida_lumina.insn_ops_reprs_t.__init__ (method) -ida_lumina.insn_ops_reprs_t.__len__ (method) -ida_lumina.insn_ops_reprs_t.__setitem__ (method) -ida_lumina.insn_ops_reprs_t.at (method) -ida_lumina.insn_ops_reprs_t.begin (method) -ida_lumina.insn_ops_reprs_t.capacity (method) -ida_lumina.insn_ops_reprs_t.clear (method) -ida_lumina.insn_ops_reprs_t.empty (method) -ida_lumina.insn_ops_reprs_t.end (method) -ida_lumina.insn_ops_reprs_t.erase (method) -ida_lumina.insn_ops_reprs_t.extract (method) -ida_lumina.insn_ops_reprs_t.grow (method) -ida_lumina.insn_ops_reprs_t.inject (method) -ida_lumina.insn_ops_reprs_t.insert (method) -ida_lumina.insn_ops_reprs_t.pop_back (method) -ida_lumina.insn_ops_reprs_t.push_back (method) -ida_lumina.insn_ops_reprs_t.qclear (method) -ida_lumina.insn_ops_reprs_t.reserve (method) -ida_lumina.insn_ops_reprs_t.resize (method) -ida_lumina.insn_ops_reprs_t.size (method) -ida_lumina.insn_ops_reprs_t.swap (method) -ida_lumina.insn_ops_reprs_t.truncate (method) -ida_lumina.insn_site_t (class) -ida_lumina.insn_site_t.__init__ (method) -ida_lumina.insn_site_t.toea (method) -ida_lumina.lumina_client_t (class) -ida_lumina.lumina_client_t.__init__ (method) -ida_lumina.lumina_client_t.del_history (method) -ida_lumina.lumina_client_t.get_pop (method) -ida_lumina.lumina_client_t.is_pattern_id (method) -ida_lumina.lumina_client_t.pull_md (method) -ida_lumina.lumina_client_t.push_md (method) -ida_lumina.lumina_client_t.set_pattern_id_md5 (method) -ida_lumina.lumina_info_t (class) -ida_lumina.lumina_info_t.__init__ (method) -ida_lumina.lumina_op_res_vec_t (class) -ida_lumina.lumina_op_res_vec_t.__eq__ (method) -ida_lumina.lumina_op_res_vec_t.__getitem__ (method) -ida_lumina.lumina_op_res_vec_t.__init__ (method) -ida_lumina.lumina_op_res_vec_t.__len__ (method) -ida_lumina.lumina_op_res_vec_t.__ne__ (method) -ida_lumina.lumina_op_res_vec_t.__setitem__ (method) -ida_lumina.lumina_op_res_vec_t._del (method) -ida_lumina.lumina_op_res_vec_t.add_unique (method) -ida_lumina.lumina_op_res_vec_t.at (method) -ida_lumina.lumina_op_res_vec_t.begin (method) -ida_lumina.lumina_op_res_vec_t.capacity (method) -ida_lumina.lumina_op_res_vec_t.clear (method) -ida_lumina.lumina_op_res_vec_t.empty (method) -ida_lumina.lumina_op_res_vec_t.end (method) -ida_lumina.lumina_op_res_vec_t.erase (method) -ida_lumina.lumina_op_res_vec_t.extract (method) -ida_lumina.lumina_op_res_vec_t.find (method) -ida_lumina.lumina_op_res_vec_t.grow (method) -ida_lumina.lumina_op_res_vec_t.has (method) -ida_lumina.lumina_op_res_vec_t.inject (method) -ida_lumina.lumina_op_res_vec_t.insert (method) -ida_lumina.lumina_op_res_vec_t.pop_back (method) -ida_lumina.lumina_op_res_vec_t.push_back (method) -ida_lumina.lumina_op_res_vec_t.qclear (method) -ida_lumina.lumina_op_res_vec_t.reserve (method) -ida_lumina.lumina_op_res_vec_t.resize (method) -ida_lumina.lumina_op_res_vec_t.size (method) -ida_lumina.lumina_op_res_vec_t.swap (method) -ida_lumina.lumina_op_res_vec_t.truncate (method) -ida_lumina.lumina_server_info_t (class) -ida_lumina.lumina_server_info_t.__init__ (method) -ida_lumina.lumina_user_t (class) -ida_lumina.lumina_user_t.__init__ (method) -ida_lumina.lumina_user_t.can_del_history (method) -ida_lumina.lumina_user_t.is_admin (method) -ida_lumina.lumina_user_t.set_can_del_history (method) -ida_lumina.lumina_user_t.set_is_admin (method) -ida_lumina.md_type_parts_t (class) -ida_lumina.md_type_parts_t.__eq__ (method) -ida_lumina.md_type_parts_t.__init__ (method) -ida_lumina.md_type_parts_t.__ne__ (method) -ida_lumina.metadata_iterator_t (class) -ida_lumina.metadata_iterator_t.__init__ (method) -ida_lumina.metadata_iterator_t.data_end (method) -ida_lumina.metadata_iterator_t.next (method) -ida_lumina.new_packet (function) -ida_lumina.oprepr_t (class) -ida_lumina.oprepr_t.__init__ (method) -ida_lumina.pattern_id_t (class) -ida_lumina.pattern_id_t.__init__ (method) -ida_lumina.peer_conn_t (class) -ida_lumina.peer_conn_t.__init__ (method) -ida_lumina.pkt_get_lumina_info_result_t (class) -ida_lumina.pkt_get_lumina_info_result_t.__init__ (method) -ida_lumina.pkt_get_lumina_info_t (class) -ida_lumina.pkt_get_lumina_info_t.__init__ (method) -ida_lumina.pkt_get_pop_result_t (class) -ida_lumina.pkt_get_pop_result_t.__init__ (method) -ida_lumina.pkt_get_pop_t (class) -ida_lumina.pkt_get_pop_t.__init__ (method) -ida_lumina.pkt_helo_result_t (class) -ida_lumina.pkt_helo_result_t.__init__ (method) -ida_lumina.pkt_helo_t (class) -ida_lumina.pkt_helo_t.__init__ (method) -ida_lumina.pkt_pull_md_result_t (class) -ida_lumina.pkt_pull_md_result_t.__init__ (method) -ida_lumina.pkt_pull_md_t (class) -ida_lumina.pkt_pull_md_t.__init__ (method) -ida_lumina.pkt_push_md_result_t (class) -ida_lumina.pkt_push_md_result_t.__init__ (method) -ida_lumina.pkt_push_md_t (class) -ida_lumina.pkt_push_md_t.__init__ (method) -ida_lumina.pkt_rpc_fail_t (class) -ida_lumina.pkt_rpc_fail_t.__init__ (method) -ida_lumina.pkt_rpc_notify_t (class) -ida_lumina.pkt_rpc_notify_t.__init__ (method) -ida_lumina.pkt_rpc_ok_t (class) -ida_lumina.pkt_rpc_ok_t.__init__ (method) -ida_lumina.pop_fun_t (class) -ida_lumina.pop_fun_t.__init__ (method) -ida_lumina.push_md_opts_t (class) -ida_lumina.push_md_opts_t.__init__ (method) -ida_lumina.push_md_result_t (class) -ida_lumina.push_md_result_t.__init__ (method) -ida_lumina.revert_metadata (function) -ida_lumina.score_metadata (function) -ida_lumina.serialized_tinfo (class) -ida_lumina.serialized_tinfo.__init__ (method) -ida_lumina.simple_idb_diff_handler_t (class) -ida_lumina.simple_idb_diff_handler_t.__init__ (method) -ida_lumina.simple_idb_diff_handler_t.ensure_header_generated (method) -ida_lumina.simple_idb_diff_handler_t.format_extra_cmt (method) -ida_lumina.simple_idb_diff_handler_t.format_frame_member (method) -ida_lumina.simple_idb_diff_handler_t.format_insn_ops (method) -ida_lumina.simple_idb_diff_handler_t.format_stkpnt (method) -ida_lumina.simple_idb_diff_handler_t.format_type (method) -ida_lumina.simple_idb_diff_handler_t.indenter_t (class) -ida_lumina.simple_idb_diff_handler_t.indenter_t.__del__ (method) -ida_lumina.simple_idb_diff_handler_t.indenter_t.__init__ (method) -ida_lumina.simple_idb_diff_handler_t.on_comment_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_extra_comment_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_frame_member_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_function_comment_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_insn_ops_repr_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_name_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_proto_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_score_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_user_stkpnt_changed (method) -ida_lumina.simple_idb_diff_handler_t.put (method) -ida_lumina.simple_idb_diff_handler_t.put2 (method) -ida_lumina.simple_idb_diff_handler_t.where (method) -ida_lumina.skipped_func_t (class) -ida_lumina.skipped_func_t.__init__ (method) -ida_lumina.skipped_funcs_t (class) -ida_lumina.skipped_funcs_t.__getitem__ (method) -ida_lumina.skipped_funcs_t.__init__ (method) -ida_lumina.skipped_funcs_t.__len__ (method) -ida_lumina.skipped_funcs_t.__setitem__ (method) -ida_lumina.skipped_funcs_t.at (method) -ida_lumina.skipped_funcs_t.begin (method) -ida_lumina.skipped_funcs_t.capacity (method) -ida_lumina.skipped_funcs_t.clear (method) -ida_lumina.skipped_funcs_t.empty (method) -ida_lumina.skipped_funcs_t.end (method) -ida_lumina.skipped_funcs_t.erase (method) -ida_lumina.skipped_funcs_t.extract (method) -ida_lumina.skipped_funcs_t.grow (method) -ida_lumina.skipped_funcs_t.inject (method) -ida_lumina.skipped_funcs_t.insert (method) -ida_lumina.skipped_funcs_t.pop_back (method) -ida_lumina.skipped_funcs_t.push_back (method) -ida_lumina.skipped_funcs_t.qclear (method) -ida_lumina.skipped_funcs_t.reserve (method) -ida_lumina.skipped_funcs_t.resize (method) -ida_lumina.skipped_funcs_t.size (method) -ida_lumina.skipped_funcs_t.swap (method) -ida_lumina.skipped_funcs_t.truncate (method) -ida_lumina.split_metadata (function) -ida_lumina.user_license_info_t (class) -ida_lumina.user_license_info_t.__init__ (method) -ida_lumina.user_stkpnt_t (class) -ida_lumina.user_stkpnt_t.__init__ (method) -ida_lumina.user_stkpnts_t (class) -ida_lumina.user_stkpnts_t.__getitem__ (method) -ida_lumina.user_stkpnts_t.__init__ (method) -ida_lumina.user_stkpnts_t.__len__ (method) -ida_lumina.user_stkpnts_t.__setitem__ (method) -ida_lumina.user_stkpnts_t.at (method) -ida_lumina.user_stkpnts_t.begin (method) -ida_lumina.user_stkpnts_t.capacity (method) -ida_lumina.user_stkpnts_t.clear (method) -ida_lumina.user_stkpnts_t.empty (method) -ida_lumina.user_stkpnts_t.end (method) -ida_lumina.user_stkpnts_t.erase (method) -ida_lumina.user_stkpnts_t.extract (method) -ida_lumina.user_stkpnts_t.grow (method) -ida_lumina.user_stkpnts_t.inject (method) -ida_lumina.user_stkpnts_t.insert (method) -ida_lumina.user_stkpnts_t.pop_back (method) -ida_lumina.user_stkpnts_t.push_back (method) -ida_lumina.user_stkpnts_t.qclear (method) -ida_lumina.user_stkpnts_t.reserve (method) -ida_lumina.user_stkpnts_t.resize (method) -ida_lumina.user_stkpnts_t.size (method) -ida_lumina.user_stkpnts_t.swap (method) -ida_lumina.user_stkpnts_t.truncate (method) -ida_moves (module) -ida_moves.bookmarks_t (class) -ida_moves.bookmarks_t.__getitem__ (method) -ida_moves.bookmarks_t.__init__ (method) -ida_moves.bookmarks_t.__init__ (method) -ida_moves.bookmarks_t.__iter__ (method) -ida_moves.bookmarks_t.__len__ (method) -ida_moves.bookmarks_t.erase (method) -ida_moves.bookmarks_t.find_index (method) -ida_moves.bookmarks_t.get (method) -ida_moves.bookmarks_t.get_desc (method) -ida_moves.bookmarks_t.get_dirtree_id (method) -ida_moves.bookmarks_t.mark (method) -ida_moves.bookmarks_t.size (method) -ida_moves.bookmarks_t_erase (function) -ida_moves.bookmarks_t_find_index (function) -ida_moves.bookmarks_t_get (function) -ida_moves.bookmarks_t_get_desc (function) -ida_moves.bookmarks_t_get_dirtree_id (function) -ida_moves.bookmarks_t_mark (function) -ida_moves.bookmarks_t_size (function) -ida_moves.graph_location_info_t (class) -ida_moves.graph_location_info_t.__eq__ (method) -ida_moves.graph_location_info_t.__init__ (method) -ida_moves.graph_location_info_t.__ne__ (method) -ida_moves.lochist_entry_t (class) -ida_moves.lochist_entry_t.__init__ (method) -ida_moves.lochist_entry_t.acquire_place (method) -ida_moves.lochist_entry_t.is_valid (method) -ida_moves.lochist_entry_t.place (method) -ida_moves.lochist_entry_t.renderer_info (method) -ida_moves.lochist_entry_t.set_place (method) -ida_moves.lochist_t (class) -ida_moves.lochist_t.__init__ (method) -ida_moves.lochist_t.back (method) -ida_moves.lochist_t.clear (method) -ida_moves.lochist_t.current_index (method) -ida_moves.lochist_t.fwd (method) -ida_moves.lochist_t.get (method) -ida_moves.lochist_t.get_current (method) -ida_moves.lochist_t.get_place_id (method) -ida_moves.lochist_t.get_template_place (method) -ida_moves.lochist_t.init (method) -ida_moves.lochist_t.is_history_enabled (method) -ida_moves.lochist_t.jump (method) -ida_moves.lochist_t.netcode (method) -ida_moves.lochist_t.save (method) -ida_moves.lochist_t.seek (method) -ida_moves.lochist_t.set (method) -ida_moves.lochist_t.set_current (method) -ida_moves.lochist_t.size (method) -ida_moves.renderer_info_pos_t (class) -ida_moves.renderer_info_pos_t.__eq__ (method) -ida_moves.renderer_info_pos_t.__init__ (method) -ida_moves.renderer_info_pos_t.__ne__ (method) -ida_moves.renderer_info_t (class) -ida_moves.renderer_info_t.__eq__ (method) -ida_moves.renderer_info_t.__init__ (method) -ida_moves.renderer_info_t.__ne__ (method) -ida_moves.segm_move_info_t (class) -ida_moves.segm_move_info_t.__eq__ (method) -ida_moves.segm_move_info_t.__init__ (method) -ida_moves.segm_move_info_t.__ne__ (method) -ida_moves.segm_move_info_vec_t (class) -ida_moves.segm_move_info_vec_t.__eq__ (method) -ida_moves.segm_move_info_vec_t.__getitem__ (method) -ida_moves.segm_move_info_vec_t.__init__ (method) -ida_moves.segm_move_info_vec_t.__len__ (method) -ida_moves.segm_move_info_vec_t.__ne__ (method) -ida_moves.segm_move_info_vec_t.__setitem__ (method) -ida_moves.segm_move_info_vec_t._del (method) -ida_moves.segm_move_info_vec_t.add_unique (method) -ida_moves.segm_move_info_vec_t.at (method) -ida_moves.segm_move_info_vec_t.begin (method) -ida_moves.segm_move_info_vec_t.capacity (method) -ida_moves.segm_move_info_vec_t.clear (method) -ida_moves.segm_move_info_vec_t.empty (method) -ida_moves.segm_move_info_vec_t.end (method) -ida_moves.segm_move_info_vec_t.erase (method) -ida_moves.segm_move_info_vec_t.extract (method) -ida_moves.segm_move_info_vec_t.find (method) -ida_moves.segm_move_info_vec_t.grow (method) -ida_moves.segm_move_info_vec_t.has (method) -ida_moves.segm_move_info_vec_t.inject (method) -ida_moves.segm_move_info_vec_t.insert (method) -ida_moves.segm_move_info_vec_t.pop_back (method) -ida_moves.segm_move_info_vec_t.push_back (method) -ida_moves.segm_move_info_vec_t.qclear (method) -ida_moves.segm_move_info_vec_t.reserve (method) -ida_moves.segm_move_info_vec_t.resize (method) -ida_moves.segm_move_info_vec_t.size (method) -ida_moves.segm_move_info_vec_t.swap (method) -ida_moves.segm_move_info_vec_t.truncate (method) -ida_moves.segm_move_infos_t (class) -ida_moves.segm_move_infos_t.__init__ (method) -ida_moves.segm_move_infos_t.find (method) -ida_nalt (module) -ida_nalt.AFL_ALIGNFLOW (variable) -ida_nalt.AFL_BNOT0 (variable) -ida_nalt.AFL_BNOT1 (variable) -ida_nalt.AFL_COLORED (variable) -ida_nalt.AFL_FIXEDSPD (variable) -ida_nalt.AFL_HIDDEN (variable) -ida_nalt.AFL_HR_DETERMINED (variable) -ida_nalt.AFL_HR_GUESSED_DATA (variable) -ida_nalt.AFL_HR_GUESSED_FUNC (variable) -ida_nalt.AFL_IDA_GUESSED (variable) -ida_nalt.AFL_LIB (variable) -ida_nalt.AFL_LINNUM (variable) -ida_nalt.AFL_LNAME (variable) -ida_nalt.AFL_LZERO0 (variable) -ida_nalt.AFL_LZERO1 (variable) -ida_nalt.AFL_MANUAL (variable) -ida_nalt.AFL_NOBRD (variable) -ida_nalt.AFL_NORET (variable) -ida_nalt.AFL_NOTCODE (variable) -ida_nalt.AFL_NOTPROC (variable) -ida_nalt.AFL_PUBNAM (variable) -ida_nalt.AFL_RETFP (variable) -ida_nalt.AFL_TERSESTR (variable) -ida_nalt.AFL_TI (variable) -ida_nalt.AFL_TI0 (variable) -ida_nalt.AFL_TI1 (variable) -ida_nalt.AFL_TILCMT (variable) -ida_nalt.AFL_TYPE_GUESSED (variable) -ida_nalt.AFL_USEMODSP (variable) -ida_nalt.AFL_USERSP (variable) -ida_nalt.AFL_USERTI (variable) -ida_nalt.AFL_WEAKNAM (variable) -ida_nalt.AFL_ZSTROFF (variable) -ida_nalt.AP_ALLOWDUPS (variable) -ida_nalt.AP_ARRAY (variable) -ida_nalt.AP_IDXBASEMASK (variable) -ida_nalt.AP_IDXBIN (variable) -ida_nalt.AP_IDXDEC (variable) -ida_nalt.AP_IDXHEX (variable) -ida_nalt.AP_IDXOCT (variable) -ida_nalt.AP_INDEX (variable) -ida_nalt.AP_SIGNED (variable) -ida_nalt.IDB_DESKTOPS_NODE_NAME (variable) -ida_nalt.IDB_DESKTOPS_TAG (variable) -ida_nalt.MAXSTRUCPATH (variable) -ida_nalt.NALT_ABSBASE (variable) -ida_nalt.NALT_AFLAGS (variable) -ida_nalt.NALT_ALIGN (variable) -ida_nalt.NALT_COLOR (variable) -ida_nalt.NALT_CREF_FROM (variable) -ida_nalt.NALT_CREF_TO (variable) -ida_nalt.NALT_DREF_FROM (variable) -ida_nalt.NALT_DREF_TO (variable) -ida_nalt.NALT_ENUM0 (variable) -ida_nalt.NALT_ENUM1 (variable) -ida_nalt.NALT_GR_LAYX (variable) -ida_nalt.NALT_LINNUM (variable) -ida_nalt.NALT_PURGE (variable) -ida_nalt.NALT_STRTYPE (variable) -ida_nalt.NALT_STRUCT (variable) -ida_nalt.NALT_SWITCH (variable) -ida_nalt.NSUP_ARGEAS (variable) -ida_nalt.NSUP_ARRAY (variable) -ida_nalt.NSUP_CMT (variable) -ida_nalt.NSUP_CUSTDT (variable) -ida_nalt.NSUP_EX_FLAGS (variable) -ida_nalt.NSUP_FOP1 (variable) -ida_nalt.NSUP_FOP2 (variable) -ida_nalt.NSUP_FOP3 (variable) -ida_nalt.NSUP_FOP4 (variable) -ida_nalt.NSUP_FOP5 (variable) -ida_nalt.NSUP_FOP6 (variable) -ida_nalt.NSUP_FOP7 (variable) -ida_nalt.NSUP_FOP8 (variable) -ida_nalt.NSUP_FTAILS (variable) -ida_nalt.NSUP_GROUP (variable) -ida_nalt.NSUP_GR_INFO (variable) -ida_nalt.NSUP_GR_LAYT (variable) -ida_nalt.NSUP_JINFO (variable) -ida_nalt.NSUP_LLABEL (variable) -ida_nalt.NSUP_MANUAL (variable) -ida_nalt.NSUP_OPTYPES (variable) -ida_nalt.NSUP_OREF0 (variable) -ida_nalt.NSUP_OREF1 (variable) -ida_nalt.NSUP_OREF2 (variable) -ida_nalt.NSUP_OREF3 (variable) -ida_nalt.NSUP_OREF4 (variable) -ida_nalt.NSUP_OREF5 (variable) -ida_nalt.NSUP_OREF6 (variable) -ida_nalt.NSUP_OREF7 (variable) -ida_nalt.NSUP_ORIGFMD (variable) -ida_nalt.NSUP_POINTS (variable) -ida_nalt.NSUP_REF0 (variable) -ida_nalt.NSUP_REF1 (variable) -ida_nalt.NSUP_REF2 (variable) -ida_nalt.NSUP_REF3 (variable) -ida_nalt.NSUP_REF4 (variable) -ida_nalt.NSUP_REF5 (variable) -ida_nalt.NSUP_REF6 (variable) -ida_nalt.NSUP_REF7 (variable) -ida_nalt.NSUP_REGARG (variable) -ida_nalt.NSUP_REGVAR (variable) -ida_nalt.NSUP_REPCMT (variable) -ida_nalt.NSUP_SEGTRANS (variable) -ida_nalt.NSUP_SWITCH (variable) -ida_nalt.NSUP_TYPEINFO (variable) -ida_nalt.NSUP_XREFPOS (variable) -ida_nalt.PATCH_TAG (variable) -ida_nalt.REFINFO_CUSTOM (variable) -ida_nalt.REFINFO_NOBASE (variable) -ida_nalt.REFINFO_NO_ONES (variable) -ida_nalt.REFINFO_NO_ZEROS (variable) -ida_nalt.REFINFO_PASTEND (variable) -ida_nalt.REFINFO_RVAOFF (variable) -ida_nalt.REFINFO_SELFREF (variable) -ida_nalt.REFINFO_SIGNEDOP (variable) -ida_nalt.REFINFO_SUBTRACT (variable) -ida_nalt.REFINFO_TYPE (variable) -ida_nalt.REF_HIGH16 (variable) -ida_nalt.REF_HIGH8 (variable) -ida_nalt.REF_LOW16 (variable) -ida_nalt.REF_LOW8 (variable) -ida_nalt.REF_OFF16 (variable) -ida_nalt.REF_OFF32 (variable) -ida_nalt.REF_OFF64 (variable) -ida_nalt.REF_OFF8 (variable) -ida_nalt.RIDX_ABINAME (variable) -ida_nalt.RIDX_ARCHIVE_PATH (variable) -ida_nalt.RIDX_C_MACROS (variable) -ida_nalt.RIDX_DBG_BINPATHS (variable) -ida_nalt.RIDX_DUALOP_GRAPH (variable) -ida_nalt.RIDX_DUALOP_TEXT (variable) -ida_nalt.RIDX_FILE_FORMAT_NAME (variable) -ida_nalt.RIDX_GROUPS (variable) -ida_nalt.RIDX_H_PATH (variable) -ida_nalt.RIDX_IDA_VERSION (variable) -ida_nalt.RIDX_INCLUDE (variable) -ida_nalt.RIDX_MD5 (variable) -ida_nalt.RIDX_NOTEPAD (variable) -ida_nalt.RIDX_PROBLEMS (variable) -ida_nalt.RIDX_SELECTORS (variable) -ida_nalt.RIDX_SHA256 (variable) -ida_nalt.RIDX_SMALL_IDC (variable) -ida_nalt.RIDX_SMALL_IDC_OLD (variable) -ida_nalt.RIDX_SRCDBG_PATHS (variable) -ida_nalt.RIDX_SRCDBG_UNDESIRED (variable) -ida_nalt.RIDX_STR_ENCODINGS (variable) -ida_nalt.STRENC_DEFAULT (variable) -ida_nalt.STRENC_NONE (variable) -ida_nalt.STRTYPE_C (variable) -ida_nalt.STRTYPE_C_16 (variable) -ida_nalt.STRTYPE_C_32 (variable) -ida_nalt.STRTYPE_LEN2 (variable) -ida_nalt.STRTYPE_LEN2_16 (variable) -ida_nalt.STRTYPE_LEN2_32 (variable) -ida_nalt.STRTYPE_LEN4 (variable) -ida_nalt.STRTYPE_LEN4_16 (variable) -ida_nalt.STRTYPE_PASCAL (variable) -ida_nalt.STRTYPE_PASCAL_16 (variable) -ida_nalt.STRTYPE_PASCAL_32 (variable) -ida_nalt.STRTYPE_TERMCHR (variable) -ida_nalt.SWI_CUSTOM (variable) -ida_nalt.SWI_DEFRET (variable) -ida_nalt.SWI_DEF_IN_TBL (variable) -ida_nalt.SWI_ELBASE (variable) -ida_nalt.SWI_HXNOLOWCASE (variable) -ida_nalt.SWI_INDIRECT (variable) -ida_nalt.SWI_J32 (variable) -ida_nalt.SWI_JMPINSN (variable) -ida_nalt.SWI_JMP_INV (variable) -ida_nalt.SWI_JSIZE (variable) -ida_nalt.SWI_SELFREL (variable) -ida_nalt.SWI_SEPARATE (variable) -ida_nalt.SWI_SHIFT_MASK (variable) -ida_nalt.SWI_SIGNED (variable) -ida_nalt.SWI_SPARSE (variable) -ida_nalt.SWI_STDTBL (variable) -ida_nalt.SWI_SUBTRACT (variable) -ida_nalt.SWI_USER (variable) -ida_nalt.SWI_V32 (variable) -ida_nalt.SWI_VERSION (variable) -ida_nalt.SWI_VSIZE (variable) -ida_nalt.SWI_VSPLIT (variable) -ida_nalt.V695_REF_OFF8 (variable) -ida_nalt.V695_REF_VHIGH (variable) -ida_nalt.V695_REF_VLOW (variable) -ida_nalt.add_encoding (function) -ida_nalt.array_parameters_t (class) -ida_nalt.array_parameters_t.__init__ (method) -ida_nalt.array_parameters_t.alignment (variable) -ida_nalt.array_parameters_t.is_default (method) -ida_nalt.array_parameters_t.lineitems (variable) -ida_nalt.clr__bnot0 (function) -ida_nalt.clr__bnot1 (function) -ida_nalt.clr__invsign0 (function) -ida_nalt.clr__invsign1 (function) -ida_nalt.clr_abits (function) -ida_nalt.clr_align_flow (function) -ida_nalt.clr_colored_item (function) -ida_nalt.clr_fixed_spd (function) -ida_nalt.clr_has_lname (function) -ida_nalt.clr_has_ti (function) -ida_nalt.clr_has_ti0 (function) -ida_nalt.clr_has_ti1 (function) -ida_nalt.clr_libitem (function) -ida_nalt.clr_lzero0 (function) -ida_nalt.clr_lzero1 (function) -ida_nalt.clr_noret (function) -ida_nalt.clr_notcode (function) -ida_nalt.clr_notproc (function) -ida_nalt.clr_retfp (function) -ida_nalt.clr_terse_struc (function) -ida_nalt.clr_tilcmt (function) -ida_nalt.clr_usemodsp (function) -ida_nalt.clr_usersp (function) -ida_nalt.clr_userti (function) -ida_nalt.clr_zstroff (function) -ida_nalt.custom_data_type_ids_fids_array (class) -ida_nalt.custom_data_type_ids_fids_array.__getitem__ (method) -ida_nalt.custom_data_type_ids_fids_array.__init__ (method) -ida_nalt.custom_data_type_ids_fids_array.__len__ (method) -ida_nalt.custom_data_type_ids_fids_array.__setitem__ (method) -ida_nalt.custom_data_type_ids_fids_array._get_bytes (method) -ida_nalt.custom_data_type_ids_fids_array._set_bytes (method) -ida_nalt.custom_data_type_ids_t (class) -ida_nalt.custom_data_type_ids_t.__getFids (method) -ida_nalt.custom_data_type_ids_t.__init__ (method) -ida_nalt.custom_data_type_ids_t.dtid (variable) -ida_nalt.custom_data_type_ids_t.fids (variable) -ida_nalt.custom_data_type_ids_t.get_dtid (method) -ida_nalt.custom_data_type_ids_t.set (method) -ida_nalt.dbg_get_input_path (function) -ida_nalt.del_absbase (function) -ida_nalt.del_aflags (function) -ida_nalt.del_alignment (function) -ida_nalt.del_array_parameters (function) -ida_nalt.del_custom_data_type_ids (function) -ida_nalt.del_encoding (function) -ida_nalt.del_ind_purged (function) -ida_nalt.del_item_color (function) -ida_nalt.del_op_tinfo (function) -ida_nalt.del_refinfo (function) -ida_nalt.del_source_linnum (function) -ida_nalt.del_str_type (function) -ida_nalt.del_switch_info (function) -ida_nalt.del_switch_parent (function) -ida_nalt.del_tinfo (function) -ida_nalt.delete_imports (function) -ida_nalt.ea2node (function) -ida_nalt.encoding_from_strtype (function) -ida_nalt.end_ea2node (function) -ida_nalt.enum_const_t (class) -ida_nalt.enum_const_t.__init__ (method) -ida_nalt.enum_import_names (function) -ida_nalt.find_custom_refinfo (function) -ida_nalt.get_abi_name (function) -ida_nalt.get_absbase (function) -ida_nalt.get_aflags (function) -ida_nalt.get_alignment (function) -ida_nalt.get_archive_path (function) -ida_nalt.get_array_parameters (function) -ida_nalt.get_asm_inc_file (function) -ida_nalt.get_custom_data_type_ids (function) -ida_nalt.get_custom_refinfo (function) -ida_nalt.get_default_encoding_idx (function) -ida_nalt.get_elapsed_secs (function) -ida_nalt.get_encoding_bpu (function) -ida_nalt.get_encoding_bpu_by_name (function) -ida_nalt.get_encoding_name (function) -ida_nalt.get_encoding_qty (function) -ida_nalt.get_gotea (function) -ida_nalt.get_ida_notepad_text (function) -ida_nalt.get_idb_ctime (function) -ida_nalt.get_idb_nopens (function) -ida_nalt.get_ids_modnode (function) -ida_nalt.get_imagebase (function) -ida_nalt.get_import_module_name (function) -ida_nalt.get_import_module_qty (function) -ida_nalt.get_ind_purged (function) -ida_nalt.get_initial_ida_version (function) -ida_nalt.get_initial_idb_version (function) -ida_nalt.get_input_file_path (function) -ida_nalt.get_item_color (function) -ida_nalt.get_loader_format_name (function) -ida_nalt.get_op_tinfo (function) -ida_nalt.get_outfile_encoding_idx (function) -ida_nalt.get_refinfo (function) -ida_nalt.get_reftype_by_size (function) -ida_nalt.get_root_filename (function) -ida_nalt.get_source_linnum (function) -ida_nalt.get_srcdbg_paths (function) -ida_nalt.get_srcdbg_undesired_paths (function) -ida_nalt.get_str_encoding_idx (function) -ida_nalt.get_str_term1 (function) -ida_nalt.get_str_term2 (function) -ida_nalt.get_str_type (function) -ida_nalt.get_str_type_code (function) -ida_nalt.get_str_type_prefix_length (function) -ida_nalt.get_strid (function) -ida_nalt.get_strtype_bpu (function) -ida_nalt.get_switch_info (function) -ida_nalt.get_switch_info (function) -ida_nalt.get_switch_parent (function) -ida_nalt.get_tinfo (function) -ida_nalt.getnode (function) -ida_nalt.has_aflag_linnum (function) -ida_nalt.has_aflag_lname (function) -ida_nalt.has_aflag_ti (function) -ida_nalt.has_aflag_ti0 (function) -ida_nalt.has_aflag_ti1 (function) -ida_nalt.has_lname (function) -ida_nalt.has_ti (function) -ida_nalt.has_ti0 (function) -ida_nalt.has_ti1 (function) -ida_nalt.hide_border (function) -ida_nalt.hide_item (function) -ida_nalt.is__bnot0 (function) -ida_nalt.is__bnot1 (function) -ida_nalt.is__invsign0 (function) -ida_nalt.is__invsign1 (function) -ida_nalt.is_aflag__bnot0 (function) -ida_nalt.is_aflag__bnot1 (function) -ida_nalt.is_aflag__invsign0 (function) -ida_nalt.is_aflag__invsign1 (function) -ida_nalt.is_aflag_align_flow (function) -ida_nalt.is_aflag_colored_item (function) -ida_nalt.is_aflag_data_guessed_by_hexrays (function) -ida_nalt.is_aflag_fixed_spd (function) -ida_nalt.is_aflag_func_guessed_by_hexrays (function) -ida_nalt.is_aflag_hidden_border (function) -ida_nalt.is_aflag_hidden_item (function) -ida_nalt.is_aflag_libitem (function) -ida_nalt.is_aflag_lzero0 (function) -ida_nalt.is_aflag_lzero1 (function) -ida_nalt.is_aflag_manual_insn (function) -ida_nalt.is_aflag_noret (function) -ida_nalt.is_aflag_notcode (function) -ida_nalt.is_aflag_notproc (function) -ida_nalt.is_aflag_public_name (function) -ida_nalt.is_aflag_retfp (function) -ida_nalt.is_aflag_terse_struc (function) -ida_nalt.is_aflag_tilcmt (function) -ida_nalt.is_aflag_type_determined_by_hexrays (function) -ida_nalt.is_aflag_type_guessed_by_hexrays (function) -ida_nalt.is_aflag_type_guessed_by_ida (function) -ida_nalt.is_aflag_usersp (function) -ida_nalt.is_aflag_userti (function) -ida_nalt.is_aflag_weak_name (function) -ida_nalt.is_aflag_zstroff (function) -ida_nalt.is_align_flow (function) -ida_nalt.is_colored_item (function) -ida_nalt.is_data_guessed_by_hexrays (function) -ida_nalt.is_finally_visible_item (function) -ida_nalt.is_fixed_spd (function) -ida_nalt.is_func_guessed_by_hexrays (function) -ida_nalt.is_hidden_border (function) -ida_nalt.is_hidden_item (function) -ida_nalt.is_libitem (function) -ida_nalt.is_lzero0 (function) -ida_nalt.is_lzero1 (function) -ida_nalt.is_noret (function) -ida_nalt.is_notcode (function) -ida_nalt.is_notproc (function) -ida_nalt.is_pascal (function) -ida_nalt.is_reftype_target_optional (function) -ida_nalt.is_retfp (function) -ida_nalt.is_terse_struc (function) -ida_nalt.is_tilcmt (function) -ida_nalt.is_type_determined_by_hexrays (function) -ida_nalt.is_type_guessed_by_hexrays (function) -ida_nalt.is_type_guessed_by_ida (function) -ida_nalt.is_usersp (function) -ida_nalt.is_userti (function) -ida_nalt.is_visible_item (function) -ida_nalt.is_zstroff (function) -ida_nalt.make_str_type (function) -ida_nalt.node2ea (function) -ida_nalt.opinfo_t (class) -ida_nalt.opinfo_t.__init__ (method) -ida_nalt.opinfo_t.cd (variable) -ida_nalt.opinfo_t.ec (variable) -ida_nalt.opinfo_t.path (variable) -ida_nalt.opinfo_t.ri (variable) -ida_nalt.opinfo_t.strtype (variable) -ida_nalt.opinfo_t.tid (variable) -ida_nalt.printop_t (class) -ida_nalt.printop_t.__init__ (method) -ida_nalt.printop_t.get_ti (method) -ida_nalt.printop_t.is_aflags_initialized (method) -ida_nalt.printop_t.is_f64 (method) -ida_nalt.printop_t.is_ti_initialized (method) -ida_nalt.printop_t.set_aflags_initialized (method) -ida_nalt.printop_t.set_ti_initialized (method) -ida_nalt.refinfo_t (class) -ida_nalt.refinfo_t.__init__ (method) -ida_nalt.refinfo_t.base (variable) -ida_nalt.refinfo_t.flags (variable) -ida_nalt.refinfo_t.init (method) -ida_nalt.refinfo_t.is_custom (method) -ida_nalt.refinfo_t.is_no_ones (method) -ida_nalt.refinfo_t.is_no_zeros (method) -ida_nalt.refinfo_t.is_pastend (method) -ida_nalt.refinfo_t.is_rvaoff (method) -ida_nalt.refinfo_t.is_selfref (method) -ida_nalt.refinfo_t.is_signed (method) -ida_nalt.refinfo_t.is_subtract (method) -ida_nalt.refinfo_t.is_target_optional (method) -ida_nalt.refinfo_t.no_base_xref (method) -ida_nalt.refinfo_t.set_type (method) -ida_nalt.refinfo_t.target (variable) -ida_nalt.refinfo_t.tdelta (variable) -ida_nalt.refinfo_t.type (method) -ida_nalt.rename_encoding (function) -ida_nalt.retrieve_input_file_crc32 (function) -ida_nalt.retrieve_input_file_md5 (function) -ida_nalt.retrieve_input_file_sha256 (function) -ida_nalt.retrieve_input_file_size (function) -ida_nalt.set__bnot0 (function) -ida_nalt.set__bnot1 (function) -ida_nalt.set__invsign0 (function) -ida_nalt.set__invsign1 (function) -ida_nalt.set_abits (function) -ida_nalt.set_absbase (function) -ida_nalt.set_aflags (function) -ida_nalt.set_align_flow (function) -ida_nalt.set_alignment (function) -ida_nalt.set_archive_path (function) -ida_nalt.set_array_parameters (function) -ida_nalt.set_asm_inc_file (function) -ida_nalt.set_colored_item (function) -ida_nalt.set_custom_data_type_ids (function) -ida_nalt.set_data_guessed_by_hexrays (function) -ida_nalt.set_default_encoding_idx (function) -ida_nalt.set_fixed_spd (function) -ida_nalt.set_func_guessed_by_hexrays (function) -ida_nalt.set_gotea (function) -ida_nalt.set_has_lname (function) -ida_nalt.set_has_ti (function) -ida_nalt.set_has_ti0 (function) -ida_nalt.set_has_ti1 (function) -ida_nalt.set_ida_notepad_text (function) -ida_nalt.set_ids_modnode (function) -ida_nalt.set_imagebase (function) -ida_nalt.set_item_color (function) -ida_nalt.set_libitem (function) -ida_nalt.set_loader_format_name (function) -ida_nalt.set_lzero0 (function) -ida_nalt.set_lzero1 (function) -ida_nalt.set_noret (function) -ida_nalt.set_notcode (function) -ida_nalt.set_notproc (function) -ida_nalt.set_op_tinfo (function) -ida_nalt.set_outfile_encoding_idx (function) -ida_nalt.set_refinfo (function) -ida_nalt.set_refinfo_ex (function) -ida_nalt.set_retfp (function) -ida_nalt.set_root_filename (function) -ida_nalt.set_source_linnum (function) -ida_nalt.set_srcdbg_paths (function) -ida_nalt.set_srcdbg_undesired_paths (function) -ida_nalt.set_str_encoding_idx (function) -ida_nalt.set_str_type (function) -ida_nalt.set_switch_info (function) -ida_nalt.set_switch_parent (function) -ida_nalt.set_terse_struc (function) -ida_nalt.set_tilcmt (function) -ida_nalt.set_tinfo (function) -ida_nalt.set_type_determined_by_hexrays (function) -ida_nalt.set_type_guessed_by_ida (function) -ida_nalt.set_usemodsp (function) -ida_nalt.set_usersp (function) -ida_nalt.set_userti (function) -ida_nalt.set_visible_item (function) -ida_nalt.set_zstroff (function) -ida_nalt.strpath_ids_array (class) -ida_nalt.strpath_ids_array.__getitem__ (method) -ida_nalt.strpath_ids_array.__init__ (method) -ida_nalt.strpath_ids_array.__len__ (method) -ida_nalt.strpath_ids_array.__setitem__ (method) -ida_nalt.strpath_ids_array._get_bytes (method) -ida_nalt.strpath_ids_array._set_bytes (method) -ida_nalt.strpath_t (class) -ida_nalt.strpath_t.__getIds (method) -ida_nalt.strpath_t.__init__ (method) -ida_nalt.switch_info_t (class) -ida_nalt.switch_info_t.__init__ (method) -ida_nalt.switch_info_t._get_values_lowcase (method) -ida_nalt.switch_info_t._set_values_lowcase (method) -ida_nalt.switch_info_t.assign (method) -ida_nalt.switch_info_t.clear (method) -ida_nalt.switch_info_t.custom (variable) -ida_nalt.switch_info_t.defjump (variable) -ida_nalt.switch_info_t.elbase (variable) -ida_nalt.switch_info_t.expr_ea (variable) -ida_nalt.switch_info_t.flags (variable) -ida_nalt.switch_info_t.get_jrange_vrange (method) -ida_nalt.switch_info_t.get_jtable_element_size (method) -ida_nalt.switch_info_t.get_jtable_size (method) -ida_nalt.switch_info_t.get_lowcase (method) -ida_nalt.switch_info_t.get_shift (method) -ida_nalt.switch_info_t.get_version (method) -ida_nalt.switch_info_t.get_vtable_element_size (method) -ida_nalt.switch_info_t.has_default (method) -ida_nalt.switch_info_t.has_elbase (method) -ida_nalt.switch_info_t.is_custom (method) -ida_nalt.switch_info_t.is_indirect (method) -ida_nalt.switch_info_t.is_nolowcase (method) -ida_nalt.switch_info_t.is_sparse (method) -ida_nalt.switch_info_t.is_subtract (method) -ida_nalt.switch_info_t.is_user_defined (method) -ida_nalt.switch_info_t.jcases (variable) -ida_nalt.switch_info_t.jumps (variable) -ida_nalt.switch_info_t.lowcase (variable) -ida_nalt.switch_info_t.marks (variable) -ida_nalt.switch_info_t.ncases (variable) -ida_nalt.switch_info_t.regdtype (variable) -ida_nalt.switch_info_t.regnum (variable) -ida_nalt.switch_info_t.set_elbase (method) -ida_nalt.switch_info_t.set_expr (method) -ida_nalt.switch_info_t.set_jtable_element_size (method) -ida_nalt.switch_info_t.set_jtable_size (method) -ida_nalt.switch_info_t.set_shift (method) -ida_nalt.switch_info_t.set_vtable_element_size (method) -ida_nalt.switch_info_t.startea (variable) -ida_nalt.switch_info_t.use_std_table (method) -ida_nalt.switch_info_t.values (variable) -ida_nalt.switch_info_t__from_ptrval__ (function) -ida_nalt.unhide_border (function) -ida_nalt.unhide_item (function) -ida_nalt.upd_abits (function) -ida_nalt.uses_aflag_modsp (function) -ida_nalt.uses_modsp (function) -ida_nalt.validate_idb_names (function) -ida_name (module) -ida_name.DEBNAME_EXACT (variable) -ida_name.DEBNAME_LOWER (variable) -ida_name.DEBNAME_NICE (variable) -ida_name.DEBNAME_UPPER (variable) -ida_name.FUNC_IMPORT_PREFIX (variable) -ida_name.GETN_APPZERO (variable) -ida_name.GETN_NODUMMY (variable) -ida_name.GETN_NOFIXUP (variable) -ida_name.GNCN_NOCOLOR (variable) -ida_name.GNCN_NODBGNM (variable) -ida_name.GNCN_NOFUNC (variable) -ida_name.GNCN_NOLABEL (variable) -ida_name.GNCN_NOSEG (variable) -ida_name.GNCN_PREFDBG (variable) -ida_name.GNCN_REQFUNC (variable) -ida_name.GNCN_REQNAME (variable) -ida_name.GNCN_SEGNUM (variable) -ida_name.GNCN_SEG_FUNC (variable) -ida_name.GN_COLORED (variable) -ida_name.GN_DEMANGLED (variable) -ida_name.GN_ISRET (variable) -ida_name.GN_LOCAL (variable) -ida_name.GN_LONG (variable) -ida_name.GN_NOT_DUMMY (variable) -ida_name.GN_NOT_ISRET (variable) -ida_name.GN_SHORT (variable) -ida_name.GN_STRICT (variable) -ida_name.GN_VISIBLE (variable) -ida_name.MAXNAMELEN (variable) -ida_name.NT_ABS (variable) -ida_name.NT_BMASK (variable) -ida_name.NT_BYTE (variable) -ida_name.NT_ENUM (variable) -ida_name.NT_LOCAL (variable) -ida_name.NT_NONE (variable) -ida_name.NT_REGVAR (variable) -ida_name.NT_SEG (variable) -ida_name.NT_STKVAR (variable) -ida_name.NT_STROFF (variable) -ida_name.NearestName (class) -ida_name.NearestName.__getitem__ (method) -ida_name.NearestName.__init__ (method) -ida_name.NearestName.__iter__ (method) -ida_name.NearestName._get_item (method) -ida_name.NearestName.find (method) -ida_name.NearestName.update (method) -ida_name.SN_AUTO (variable) -ida_name.SN_CHECK (variable) -ida_name.SN_DELTAIL (variable) -ida_name.SN_FORCE (variable) -ida_name.SN_IDBENC (variable) -ida_name.SN_LOCAL (variable) -ida_name.SN_NOCHECK (variable) -ida_name.SN_NODUMMY (variable) -ida_name.SN_NOLIST (variable) -ida_name.SN_NON_AUTO (variable) -ida_name.SN_NON_PUBLIC (variable) -ida_name.SN_NON_WEAK (variable) -ida_name.SN_NOWARN (variable) -ida_name.SN_PUBLIC (variable) -ida_name.SN_WEAK (variable) -ida_name.append_struct_fields (function) -ida_name.calc_gtn_flags (function) -ida_name.cleanup_name (function) -ida_name.del_debug_names (function) -ida_name.del_global_name (function) -ida_name.del_local_name (function) -ida_name.demangle_name (function) -ida_name.ea_name_t (class) -ida_name.ea_name_t.__init__ (method) -ida_name.ea_name_vec_t (class) -ida_name.ea_name_vec_t.__getitem__ (method) -ida_name.ea_name_vec_t.__init__ (method) -ida_name.ea_name_vec_t.__len__ (method) -ida_name.ea_name_vec_t.__setitem__ (method) -ida_name.ea_name_vec_t.at (method) -ida_name.ea_name_vec_t.begin (method) -ida_name.ea_name_vec_t.capacity (method) -ida_name.ea_name_vec_t.clear (method) -ida_name.ea_name_vec_t.empty (method) -ida_name.ea_name_vec_t.end (method) -ida_name.ea_name_vec_t.erase (method) -ida_name.ea_name_vec_t.extract (method) -ida_name.ea_name_vec_t.grow (method) -ida_name.ea_name_vec_t.inject (method) -ida_name.ea_name_vec_t.insert (method) -ida_name.ea_name_vec_t.pop_back (method) -ida_name.ea_name_vec_t.push_back (method) -ida_name.ea_name_vec_t.qclear (method) -ida_name.ea_name_vec_t.reserve (method) -ida_name.ea_name_vec_t.resize (method) -ida_name.ea_name_vec_t.size (method) -ida_name.ea_name_vec_t.swap (method) -ida_name.ea_name_vec_t.truncate (method) -ida_name.extract_name (function) -ida_name.force_name (function) -ida_name.get_colored_demangled_name (function) -ida_name.get_colored_long_name (function) -ida_name.get_colored_name (function) -ida_name.get_colored_short_name (function) -ida_name.get_cp_validity (function) -ida_name.get_debug_name (function) -ida_name.get_debug_name_ea (function) -ida_name.get_debug_names (function) -ida_name.get_demangled_name (function) -ida_name.get_ea_name (function) -ida_name.get_long_name (function) -ida_name.get_mangled_name_type (function) -ida_name.get_name (function) -ida_name.get_name_base_ea (function) -ida_name.get_name_color (function) -ida_name.get_name_ea (function) -ida_name.get_name_expr (function) -ida_name.get_name_value (function) -ida_name.get_nice_colored_name (function) -ida_name.get_nlist_ea (function) -ida_name.get_nlist_idx (function) -ida_name.get_nlist_name (function) -ida_name.get_nlist_size (function) -ida_name.get_short_name (function) -ida_name.get_visible_name (function) -ida_name.hide_name (function) -ida_name.is_ident (function) -ida_name.is_ident_cp (function) -ida_name.is_in_nlist (function) -ida_name.is_name_defined_locally (function) -ida_name.is_public_name (function) -ida_name.is_strlit_cp (function) -ida_name.is_uname (function) -ida_name.is_valid_cp (function) -ida_name.is_valid_name (function) -ida_name.is_valid_typename (function) -ida_name.is_visible_cp (function) -ida_name.is_weak_name (function) -ida_name.make_name_auto (function) -ida_name.make_name_non_public (function) -ida_name.make_name_non_weak (function) -ida_name.make_name_public (function) -ida_name.make_name_user (function) -ida_name.make_name_weak (function) -ida_name.rebuild_nlist (function) -ida_name.reorder_dummy_names (function) -ida_name.set_cp_validity (function) -ida_name.set_debug_name (function) -ida_name.set_dummy_name (function) -ida_name.set_name (function) -ida_name.show_name (function) -ida_name.validate_name (function) -ida_netnode (module) -ida_netnode.BADNODE (variable) -ida_netnode.MAXNAMESIZE (variable) -ida_netnode.MAXSPECSIZE (variable) -ida_netnode.MAX_NODENAME_SIZE (variable) -ida_netnode.atag (variable) -ida_netnode.exist (function) -ida_netnode.htag (variable) -ida_netnode.ltag (variable) -ida_netnode.netnode (class) -ida_netnode.netnode.__eq__ (method) -ida_netnode.netnode.__init__ (method) -ida_netnode.netnode.__ne__ (method) -ida_netnode.netnode.altdel (method) -ida_netnode.netnode.altdel_all (method) -ida_netnode.netnode.altdel_ea (method) -ida_netnode.netnode.altdel_idx8 (method) -ida_netnode.netnode.altfirst (method) -ida_netnode.netnode.altfirst_idx8 (method) -ida_netnode.netnode.altlast (method) -ida_netnode.netnode.altlast_idx8 (method) -ida_netnode.netnode.altnext (method) -ida_netnode.netnode.altnext_idx8 (method) -ida_netnode.netnode.altprev (method) -ida_netnode.netnode.altprev_idx8 (method) -ida_netnode.netnode.altset (method) -ida_netnode.netnode.altset_ea (method) -ida_netnode.netnode.altset_idx8 (method) -ida_netnode.netnode.altshift (method) -ida_netnode.netnode.altval (method) -ida_netnode.netnode.altval_ea (method) -ida_netnode.netnode.altval_idx8 (method) -ida_netnode.netnode.blobshift (method) -ida_netnode.netnode.blobsize (method) -ida_netnode.netnode.blobsize_ea (method) -ida_netnode.netnode.chardel (method) -ida_netnode.netnode.chardel_ea (method) -ida_netnode.netnode.chardel_idx8 (method) -ida_netnode.netnode.charfirst (method) -ida_netnode.netnode.charfirst_idx8 (method) -ida_netnode.netnode.charlast (method) -ida_netnode.netnode.charlast_idx8 (method) -ida_netnode.netnode.charnext (method) -ida_netnode.netnode.charnext_idx8 (method) -ida_netnode.netnode.charprev (method) -ida_netnode.netnode.charprev_idx8 (method) -ida_netnode.netnode.charset (method) -ida_netnode.netnode.charset_ea (method) -ida_netnode.netnode.charset_idx8 (method) -ida_netnode.netnode.charshift (method) -ida_netnode.netnode.charval (method) -ida_netnode.netnode.charval_ea (method) -ida_netnode.netnode.charval_idx8 (method) -ida_netnode.netnode.copyto (method) -ida_netnode.netnode.create (method) -ida_netnode.netnode.delblob (method) -ida_netnode.netnode.delblob_ea (method) -ida_netnode.netnode.delvalue (method) -ida_netnode.netnode.eadel (method) -ida_netnode.netnode.eadel_idx8 (method) -ida_netnode.netnode.eaget (method) -ida_netnode.netnode.eaget_idx (method) -ida_netnode.netnode.eaget_idx8 (method) -ida_netnode.netnode.easet (method) -ida_netnode.netnode.easet_idx (method) -ida_netnode.netnode.easet_idx8 (method) -ida_netnode.netnode.end (method) -ida_netnode.netnode.exist (method) -ida_netnode.netnode.get_name (method) -ida_netnode.netnode.getblob (method) -ida_netnode.netnode.getblob_ea (method) -ida_netnode.netnode.getclob (method) -ida_netnode.netnode.hashdel (method) -ida_netnode.netnode.hashdel_all (method) -ida_netnode.netnode.hashfirst (method) -ida_netnode.netnode.hashlast (method) -ida_netnode.netnode.hashnext (method) -ida_netnode.netnode.hashprev (method) -ida_netnode.netnode.hashset (method) -ida_netnode.netnode.hashset_buf (method) -ida_netnode.netnode.hashset_idx (method) -ida_netnode.netnode.hashstr (method) -ida_netnode.netnode.hashstr_buf (method) -ida_netnode.netnode.hashval (method) -ida_netnode.netnode.hashval_long (method) -ida_netnode.netnode.index (method) -ida_netnode.netnode.kill (method) -ida_netnode.netnode.long_value (method) -ida_netnode.netnode.lower_bound (method) -ida_netnode.netnode.lower_bound_ea (method) -ida_netnode.netnode.lower_bound_idx8 (method) -ida_netnode.netnode.moveto (method) -ida_netnode.netnode.next (method) -ida_netnode.netnode.prev (method) -ida_netnode.netnode.rename (method) -ida_netnode.netnode.set (method) -ida_netnode.netnode.set_long (method) -ida_netnode.netnode.setblob (method) -ida_netnode.netnode.setblob_ea (method) -ida_netnode.netnode.start (method) -ida_netnode.netnode.supdel (method) -ida_netnode.netnode.supdel_all (method) -ida_netnode.netnode.supdel_ea (method) -ida_netnode.netnode.supdel_idx8 (method) -ida_netnode.netnode.supdel_range (method) -ida_netnode.netnode.supdel_range_idx8 (method) -ida_netnode.netnode.supfirst (method) -ida_netnode.netnode.supfirst_idx8 (method) -ida_netnode.netnode.suplast (method) -ida_netnode.netnode.suplast_idx8 (method) -ida_netnode.netnode.supnext (method) -ida_netnode.netnode.supnext_idx8 (method) -ida_netnode.netnode.supprev (method) -ida_netnode.netnode.supprev_idx8 (method) -ida_netnode.netnode.supset (method) -ida_netnode.netnode.supset_ea (method) -ida_netnode.netnode.supset_idx8 (method) -ida_netnode.netnode.supshift (method) -ida_netnode.netnode.supstr (method) -ida_netnode.netnode.supstr_ea (method) -ida_netnode.netnode.supstr_idx8 (method) -ida_netnode.netnode.supval (method) -ida_netnode.netnode.supval_ea (method) -ida_netnode.netnode.supval_idx8 (method) -ida_netnode.netnode.valobj (method) -ida_netnode.netnode.valstr (method) -ida_netnode.netnode.value_exists (method) -ida_netnode.netnode_exist (function) -ida_netnode.ntag (variable) -ida_netnode.stag (variable) -ida_netnode.vtag (variable) -ida_offset (module) -ida_offset.add_refinfo_dref (function) -ida_offset.calc_basevalue (function) -ida_offset.calc_offset_base (function) -ida_offset.calc_probable_base_by_value (function) -ida_offset.calc_reference_data (function) -ida_offset.calc_target (function) -ida_offset.can_be_off32 (function) -ida_offset.get_default_reftype (function) -ida_offset.get_offbase (function) -ida_offset.get_offset_expr (function) -ida_offset.get_offset_expression (function) -ida_offset.op_offset (function) -ida_offset.op_offset_ex (function) -ida_offset.op_plain_offset (function) -ida_pro (module) -ida_pro.CP_UTF16 (variable) -ida_pro.IDA_SDK_VERSION (variable) -ida_pro.IDBDEC_ESCAPE (variable) -ida_pro.IOREDIR_APPEND (variable) -ida_pro.IOREDIR_INPUT (variable) -ida_pro.IOREDIR_OUTPUT (variable) -ida_pro.IOREDIR_QUOTED (variable) -ida_pro.MAXSTR (variable) -ida_pro.SUBSTCHAR (variable) -ida_pro.__MF__ (variable) -ida_pro.__qmutex_t (class) -ida_pro.__qmutex_t.__init__ (method) -ida_pro.__qsemaphore_t (class) -ida_pro.__qsemaphore_t.__init__ (method) -ida_pro.__qthread_t (class) -ida_pro.__qthread_t.__init__ (method) -ida_pro._qstrvec_t (class) -ida_pro._qstrvec_t.__get_size (method) -ida_pro._qstrvec_t.__getitem__ (method) -ida_pro._qstrvec_t.__init__ (method) -ida_pro._qstrvec_t.__setitem__ (method) -ida_pro._qstrvec_t._create_clink (method) -ida_pro._qstrvec_t._del_clink (method) -ida_pro._qstrvec_t._get_clink_ptr (method) -ida_pro._qstrvec_t.add (method) -ida_pro._qstrvec_t.addressof (method) -ida_pro._qstrvec_t.assign (method) -ida_pro._qstrvec_t.clear (method) -ida_pro._qstrvec_t.from_list (method) -ida_pro._qstrvec_t.insert (method) -ida_pro._qstrvec_t.remove (method) -ida_pro._qstrvec_t.size (variable) -ida_pro.boolvec_t (class) -ida_pro.boolvec_t.__eq__ (method) -ida_pro.boolvec_t.__getitem__ (method) -ida_pro.boolvec_t.__init__ (method) -ida_pro.boolvec_t.__len__ (method) -ida_pro.boolvec_t.__ne__ (method) -ida_pro.boolvec_t.__setitem__ (method) -ida_pro.boolvec_t._del (method) -ida_pro.boolvec_t.add_unique (method) -ida_pro.boolvec_t.at (method) -ida_pro.boolvec_t.begin (method) -ida_pro.boolvec_t.capacity (method) -ida_pro.boolvec_t.clear (method) -ida_pro.boolvec_t.empty (method) -ida_pro.boolvec_t.end (method) -ida_pro.boolvec_t.erase (method) -ida_pro.boolvec_t.extract (method) -ida_pro.boolvec_t.find (method) -ida_pro.boolvec_t.grow (method) -ida_pro.boolvec_t.has (method) -ida_pro.boolvec_t.inject (method) -ida_pro.boolvec_t.insert (method) -ida_pro.boolvec_t.pop_back (method) -ida_pro.boolvec_t.push_back (method) -ida_pro.boolvec_t.qclear (method) -ida_pro.boolvec_t.reserve (method) -ida_pro.boolvec_t.resize (method) -ida_pro.boolvec_t.size (method) -ida_pro.boolvec_t.swap (method) -ida_pro.boolvec_t.truncate (method) -ida_pro.channel_redir_t (class) -ida_pro.channel_redir_t.__init__ (method) -ida_pro.channel_redir_t.fd (variable) -ida_pro.channel_redir_t.file (variable) -ida_pro.channel_redir_t.flags (variable) -ida_pro.channel_redir_t.is_append (method) -ida_pro.channel_redir_t.is_input (method) -ida_pro.channel_redir_t.is_output (method) -ida_pro.channel_redir_t.is_quoted (method) -ida_pro.channel_redir_t.length (variable) -ida_pro.channel_redir_t.start (variable) -ida_pro.check_process_exit (function) -ida_pro.ea_array (class) -ida_pro.ea_array.__getitem__ (method) -ida_pro.ea_array.__init__ (method) -ida_pro.ea_array.__setitem__ (method) -ida_pro.ea_array.cast (method) -ida_pro.ea_array.frompointer (method) -ida_pro.ea_array_frompointer (function) -ida_pro.ea_pointer (class) -ida_pro.ea_pointer.__init__ (method) -ida_pro.ea_pointer.assign (method) -ida_pro.ea_pointer.cast (method) -ida_pro.ea_pointer.frompointer (method) -ida_pro.ea_pointer.value (method) -ida_pro.ea_pointer_frompointer (function) -ida_pro.extend_sign (function) -ida_pro.instant_dbgopts_t (class) -ida_pro.instant_dbgopts_t.__init__ (method) -ida_pro.instant_dbgopts_t.attach (variable) -ida_pro.instant_dbgopts_t.debmod (variable) -ida_pro.instant_dbgopts_t.env (variable) -ida_pro.instant_dbgopts_t.event_id (variable) -ida_pro.instant_dbgopts_t.host (variable) -ida_pro.instant_dbgopts_t.pid (variable) -ida_pro.instant_dbgopts_t.port (variable) -ida_pro.int64vec_t (class) -ida_pro.int64vec_t.__eq__ (method) -ida_pro.int64vec_t.__getitem__ (method) -ida_pro.int64vec_t.__init__ (method) -ida_pro.int64vec_t.__len__ (method) -ida_pro.int64vec_t.__ne__ (method) -ida_pro.int64vec_t.__setitem__ (method) -ida_pro.int64vec_t._del (method) -ida_pro.int64vec_t.add_unique (method) -ida_pro.int64vec_t.at (method) -ida_pro.int64vec_t.begin (method) -ida_pro.int64vec_t.capacity (method) -ida_pro.int64vec_t.clear (method) -ida_pro.int64vec_t.empty (method) -ida_pro.int64vec_t.end (method) -ida_pro.int64vec_t.erase (method) -ida_pro.int64vec_t.extract (method) -ida_pro.int64vec_t.find (method) -ida_pro.int64vec_t.has (method) -ida_pro.int64vec_t.inject (method) -ida_pro.int64vec_t.insert (method) -ida_pro.int64vec_t.pop_back (method) -ida_pro.int64vec_t.push_back (method) -ida_pro.int64vec_t.qclear (method) -ida_pro.int64vec_t.reserve (method) -ida_pro.int64vec_t.resize (method) -ida_pro.int64vec_t.size (method) -ida_pro.int64vec_t.swap (method) -ida_pro.int64vec_t.truncate (method) -ida_pro.int_pointer (class) -ida_pro.int_pointer.__init__ (method) -ida_pro.int_pointer.assign (method) -ida_pro.int_pointer.cast (method) -ida_pro.int_pointer.frompointer (method) -ida_pro.int_pointer.value (method) -ida_pro.int_pointer_frompointer (function) -ida_pro.intvec_t (class) -ida_pro.intvec_t.__eq__ (method) -ida_pro.intvec_t.__getitem__ (method) -ida_pro.intvec_t.__init__ (method) -ida_pro.intvec_t.__len__ (method) -ida_pro.intvec_t.__ne__ (method) -ida_pro.intvec_t.__setitem__ (method) -ida_pro.intvec_t._del (method) -ida_pro.intvec_t.add_unique (method) -ida_pro.intvec_t.at (method) -ida_pro.intvec_t.begin (method) -ida_pro.intvec_t.capacity (method) -ida_pro.intvec_t.clear (method) -ida_pro.intvec_t.empty (method) -ida_pro.intvec_t.end (method) -ida_pro.intvec_t.erase (method) -ida_pro.intvec_t.extract (method) -ida_pro.intvec_t.find (method) -ida_pro.intvec_t.has (method) -ida_pro.intvec_t.inject (method) -ida_pro.intvec_t.insert (method) -ida_pro.intvec_t.pop_back (method) -ida_pro.intvec_t.push_back (method) -ida_pro.intvec_t.qclear (method) -ida_pro.intvec_t.reserve (method) -ida_pro.intvec_t.resize (method) -ida_pro.intvec_t.size (method) -ida_pro.intvec_t.swap (method) -ida_pro.intvec_t.truncate (method) -ida_pro.is_control_tty (function) -ida_pro.is_cvt64 (function) -ida_pro.is_main_thread (function) -ida_pro.log2ceil (function) -ida_pro.log2floor (function) -ida_pro.parse_dbgopts (function) -ida_pro.qatoll (function) -ida_pro.qcontrol_tty (function) -ida_pro.qdetach_tty (function) -ida_pro.qexit (function) -ida_pro.qmutex_locker_t (class) -ida_pro.qmutex_locker_t.__init__ (method) -ida_pro.qrefcnt_obj_t (class) -ida_pro.qrefcnt_obj_t.__init__ (method) -ida_pro.qrefcnt_obj_t.refcnt (variable) -ida_pro.qrefcnt_obj_t.release (method) -ida_pro.qstrvec_t_add (function) -ida_pro.qstrvec_t_addressof (function) -ida_pro.qstrvec_t_assign (function) -ida_pro.qstrvec_t_clear (function) -ida_pro.qstrvec_t_create (function) -ida_pro.qstrvec_t_destroy (function) -ida_pro.qstrvec_t_from_list (function) -ida_pro.qstrvec_t_get (function) -ida_pro.qstrvec_t_get_clink (function) -ida_pro.qstrvec_t_get_clink_ptr (function) -ida_pro.qstrvec_t_insert (function) -ida_pro.qstrvec_t_remove (function) -ida_pro.qstrvec_t_set (function) -ida_pro.qstrvec_t_size (function) -ida_pro.qthread_equal (function) -ida_pro.quote_cmdline_arg (function) -ida_pro.qvector_reserve (function) -ida_pro.readbytes (function) -ida_pro.reloc_value (function) -ida_pro.relocate_relobj (function) -ida_pro.sel_array (class) -ida_pro.sel_array.__getitem__ (method) -ida_pro.sel_array.__init__ (method) -ida_pro.sel_array.__setitem__ (method) -ida_pro.sel_array.cast (method) -ida_pro.sel_array.frompointer (method) -ida_pro.sel_array_frompointer (function) -ida_pro.sel_pointer (class) -ida_pro.sel_pointer.__init__ (method) -ida_pro.sel_pointer.assign (method) -ida_pro.sel_pointer.cast (method) -ida_pro.sel_pointer.frompointer (method) -ida_pro.sel_pointer.value (method) -ida_pro.sel_pointer_frompointer (function) -ida_pro.sizevec_t (class) -ida_pro.sizevec_t.__eq__ (method) -ida_pro.sizevec_t.__getitem__ (method) -ida_pro.sizevec_t.__init__ (method) -ida_pro.sizevec_t.__len__ (method) -ida_pro.sizevec_t.__ne__ (method) -ida_pro.sizevec_t.__setitem__ (method) -ida_pro.sizevec_t._del (method) -ida_pro.sizevec_t.add_unique (method) -ida_pro.sizevec_t.at (method) -ida_pro.sizevec_t.begin (method) -ida_pro.sizevec_t.capacity (method) -ida_pro.sizevec_t.clear (method) -ida_pro.sizevec_t.empty (method) -ida_pro.sizevec_t.end (method) -ida_pro.sizevec_t.erase (method) -ida_pro.sizevec_t.extract (method) -ida_pro.sizevec_t.find (method) -ida_pro.sizevec_t.grow (method) -ida_pro.sizevec_t.has (method) -ida_pro.sizevec_t.inject (method) -ida_pro.sizevec_t.insert (method) -ida_pro.sizevec_t.pop_back (method) -ida_pro.sizevec_t.push_back (method) -ida_pro.sizevec_t.qclear (method) -ida_pro.sizevec_t.reserve (method) -ida_pro.sizevec_t.resize (method) -ida_pro.sizevec_t.size (method) -ida_pro.sizevec_t.swap (method) -ida_pro.sizevec_t.truncate (method) -ida_pro.str2user (function) -ida_pro.strvec_t (class) -ida_pro.strvec_t.__getitem__ (method) -ida_pro.strvec_t.__init__ (method) -ida_pro.strvec_t.__len__ (method) -ida_pro.strvec_t.__setitem__ (method) -ida_pro.strvec_t.at (method) -ida_pro.strvec_t.begin (method) -ida_pro.strvec_t.capacity (method) -ida_pro.strvec_t.clear (method) -ida_pro.strvec_t.empty (method) -ida_pro.strvec_t.end (method) -ida_pro.strvec_t.erase (method) -ida_pro.strvec_t.extract (method) -ida_pro.strvec_t.grow (method) -ida_pro.strvec_t.inject (method) -ida_pro.strvec_t.insert (method) -ida_pro.strvec_t.pop_back (method) -ida_pro.strvec_t.push_back (method) -ida_pro.strvec_t.qclear (method) -ida_pro.strvec_t.reserve (method) -ida_pro.strvec_t.resize (method) -ida_pro.strvec_t.size (method) -ida_pro.strvec_t.swap (method) -ida_pro.strvec_t.truncate (method) -ida_pro.sval_pointer (class) -ida_pro.sval_pointer.__init__ (method) -ida_pro.sval_pointer.assign (method) -ida_pro.sval_pointer.cast (method) -ida_pro.sval_pointer.frompointer (method) -ida_pro.sval_pointer.value (method) -ida_pro.sval_pointer_frompointer (function) -ida_pro.tid_array (class) -ida_pro.tid_array.__getitem__ (method) -ida_pro.tid_array.__init__ (method) -ida_pro.tid_array.__setitem__ (method) -ida_pro.tid_array.cast (method) -ida_pro.tid_array.frompointer (method) -ida_pro.tid_array_frompointer (function) -ida_pro.uchar_array (class) -ida_pro.uchar_array.__getitem__ (method) -ida_pro.uchar_array.__init__ (method) -ida_pro.uchar_array.__setitem__ (method) -ida_pro.uchar_array.cast (method) -ida_pro.uchar_array.frompointer (method) -ida_pro.uchar_array_frompointer (function) -ida_pro.uint64vec_t (class) -ida_pro.uint64vec_t.__eq__ (method) -ida_pro.uint64vec_t.__getitem__ (method) -ida_pro.uint64vec_t.__init__ (method) -ida_pro.uint64vec_t.__len__ (method) -ida_pro.uint64vec_t.__ne__ (method) -ida_pro.uint64vec_t.__setitem__ (method) -ida_pro.uint64vec_t._del (method) -ida_pro.uint64vec_t.add_unique (method) -ida_pro.uint64vec_t.at (method) -ida_pro.uint64vec_t.begin (method) -ida_pro.uint64vec_t.capacity (method) -ida_pro.uint64vec_t.clear (method) -ida_pro.uint64vec_t.empty (method) -ida_pro.uint64vec_t.end (method) -ida_pro.uint64vec_t.erase (method) -ida_pro.uint64vec_t.extract (method) -ida_pro.uint64vec_t.find (method) -ida_pro.uint64vec_t.has (method) -ida_pro.uint64vec_t.inject (method) -ida_pro.uint64vec_t.insert (method) -ida_pro.uint64vec_t.pop_back (method) -ida_pro.uint64vec_t.push_back (method) -ida_pro.uint64vec_t.qclear (method) -ida_pro.uint64vec_t.reserve (method) -ida_pro.uint64vec_t.resize (method) -ida_pro.uint64vec_t.size (method) -ida_pro.uint64vec_t.swap (method) -ida_pro.uint64vec_t.truncate (method) -ida_pro.uintvec_t (class) -ida_pro.uintvec_t.__eq__ (method) -ida_pro.uintvec_t.__getitem__ (method) -ida_pro.uintvec_t.__init__ (method) -ida_pro.uintvec_t.__len__ (method) -ida_pro.uintvec_t.__ne__ (method) -ida_pro.uintvec_t.__setitem__ (method) -ida_pro.uintvec_t._del (method) -ida_pro.uintvec_t.add_unique (method) -ida_pro.uintvec_t.at (method) -ida_pro.uintvec_t.begin (method) -ida_pro.uintvec_t.capacity (method) -ida_pro.uintvec_t.clear (method) -ida_pro.uintvec_t.empty (method) -ida_pro.uintvec_t.end (method) -ida_pro.uintvec_t.erase (method) -ida_pro.uintvec_t.extract (method) -ida_pro.uintvec_t.find (method) -ida_pro.uintvec_t.has (method) -ida_pro.uintvec_t.inject (method) -ida_pro.uintvec_t.insert (method) -ida_pro.uintvec_t.pop_back (method) -ida_pro.uintvec_t.push_back (method) -ida_pro.uintvec_t.qclear (method) -ida_pro.uintvec_t.reserve (method) -ida_pro.uintvec_t.resize (method) -ida_pro.uintvec_t.size (method) -ida_pro.uintvec_t.swap (method) -ida_pro.uintvec_t.truncate (method) -ida_pro.uval_array (class) -ida_pro.uval_array.__getitem__ (method) -ida_pro.uval_array.__init__ (method) -ida_pro.uval_array.__setitem__ (method) -ida_pro.uval_array.cast (method) -ida_pro.uval_array.frompointer (method) -ida_pro.uval_array_frompointer (function) -ida_pro.writebytes (function) -ida_problems (module) -ida_problems.PR_ATTN (variable) -ida_problems.PR_BADSTACK (variable) -ida_problems.PR_COLLISION (variable) -ida_problems.PR_DECIMP (variable) -ida_problems.PR_DISASM (variable) -ida_problems.PR_END (variable) -ida_problems.PR_FINAL (variable) -ida_problems.PR_HEAD (variable) -ida_problems.PR_ILLADDR (variable) -ida_problems.PR_JUMP (variable) -ida_problems.PR_MANYLINES (variable) -ida_problems.PR_NOBASE (variable) -ida_problems.PR_NOCMT (variable) -ida_problems.PR_NOFOP (variable) -ida_problems.PR_NONAME (variable) -ida_problems.PR_NOXREFS (variable) -ida_problems.PR_ROLLED (variable) -ida_problems.forget_problem (function) -ida_problems.get_problem (function) -ida_problems.get_problem_desc (function) -ida_problems.get_problem_name (function) -ida_problems.is_problem_present (function) -ida_problems.remember_problem (function) -ida_problems.was_ida_decision (function) -ida_range (module) -ida_range.RANGE_KIND_FUNC (variable) -ida_range.RANGE_KIND_HIDDEN_RANGE (variable) -ida_range.RANGE_KIND_SEGMENT (variable) -ida_range.array_of_rangesets (class) -ida_range.array_of_rangesets.__eq__ (method) -ida_range.array_of_rangesets.__getitem__ (method) -ida_range.array_of_rangesets.__init__ (method) -ida_range.array_of_rangesets.__len__ (method) -ida_range.array_of_rangesets.__ne__ (method) -ida_range.array_of_rangesets.__setitem__ (method) -ida_range.array_of_rangesets._del (method) -ida_range.array_of_rangesets.add_unique (method) -ida_range.array_of_rangesets.at (method) -ida_range.array_of_rangesets.begin (method) -ida_range.array_of_rangesets.capacity (method) -ida_range.array_of_rangesets.clear (method) -ida_range.array_of_rangesets.empty (method) -ida_range.array_of_rangesets.end (method) -ida_range.array_of_rangesets.erase (method) -ida_range.array_of_rangesets.extract (method) -ida_range.array_of_rangesets.find (method) -ida_range.array_of_rangesets.grow (method) -ida_range.array_of_rangesets.has (method) -ida_range.array_of_rangesets.inject (method) -ida_range.array_of_rangesets.insert (method) -ida_range.array_of_rangesets.pop_back (method) -ida_range.array_of_rangesets.push_back (method) -ida_range.array_of_rangesets.qclear (method) -ida_range.array_of_rangesets.reserve (method) -ida_range.array_of_rangesets.resize (method) -ida_range.array_of_rangesets.size (method) -ida_range.array_of_rangesets.swap (method) -ida_range.array_of_rangesets.truncate (method) -ida_range.range_t (class) -ida_range.range_t.__eq__ (method) -ida_range.range_t.__ge__ (method) -ida_range.range_t.__gt__ (method) -ida_range.range_t.__init__ (method) -ida_range.range_t.__le__ (method) -ida_range.range_t.__lt__ (method) -ida_range.range_t.__ne__ (method) -ida_range.range_t._print (method) -ida_range.range_t.clear (method) -ida_range.range_t.compare (method) -ida_range.range_t.contains (method) -ida_range.range_t.empty (method) -ida_range.range_t.end_ea (variable) -ida_range.range_t.extend (method) -ida_range.range_t.intersect (method) -ida_range.range_t.overlaps (method) -ida_range.range_t.size (method) -ida_range.range_t.start_ea (variable) -ida_range.range_t_print (function) -ida_range.rangeset_t (class) -ida_range.rangeset_t.__eq__ (method) -ida_range.rangeset_t.__getitem__ (method) -ida_range.rangeset_t.__init__ (method) -ida_range.rangeset_t.__ne__ (method) -ida_range.rangeset_t._print (method) -ida_range.rangeset_t.add (method) -ida_range.rangeset_t.begin (method) -ida_range.rangeset_t.cached_range (method) -ida_range.rangeset_t.clear (method) -ida_range.rangeset_t.contains (method) -ida_range.rangeset_t.empty (method) -ida_range.rangeset_t.end (method) -ida_range.rangeset_t.find_range (method) -ida_range.rangeset_t.getrange (method) -ida_range.rangeset_t.has_common (method) -ida_range.rangeset_t.includes (method) -ida_range.rangeset_t.intersect (method) -ida_range.rangeset_t.is_equal (method) -ida_range.rangeset_t.is_subset_of (method) -ida_range.rangeset_t.lastrange (method) -ida_range.rangeset_t.next_addr (method) -ida_range.rangeset_t.next_range (method) -ida_range.rangeset_t.nranges (method) -ida_range.rangeset_t.prev_addr (method) -ida_range.rangeset_t.prev_range (method) -ida_range.rangeset_t.sub (method) -ida_range.rangeset_t.swap (method) -ida_range.rangevec_base_t (class) -ida_range.rangevec_base_t.__eq__ (method) -ida_range.rangevec_base_t.__getitem__ (method) -ida_range.rangevec_base_t.__init__ (method) -ida_range.rangevec_base_t.__len__ (method) -ida_range.rangevec_base_t.__ne__ (method) -ida_range.rangevec_base_t.__setitem__ (method) -ida_range.rangevec_base_t._del (method) -ida_range.rangevec_base_t.add_unique (method) -ida_range.rangevec_base_t.at (method) -ida_range.rangevec_base_t.begin (method) -ida_range.rangevec_base_t.capacity (method) -ida_range.rangevec_base_t.clear (method) -ida_range.rangevec_base_t.empty (method) -ida_range.rangevec_base_t.end (method) -ida_range.rangevec_base_t.erase (method) -ida_range.rangevec_base_t.extract (method) -ida_range.rangevec_base_t.find (method) -ida_range.rangevec_base_t.grow (method) -ida_range.rangevec_base_t.has (method) -ida_range.rangevec_base_t.inject (method) -ida_range.rangevec_base_t.insert (method) -ida_range.rangevec_base_t.pop_back (method) -ida_range.rangevec_base_t.push_back (method) -ida_range.rangevec_base_t.qclear (method) -ida_range.rangevec_base_t.reserve (method) -ida_range.rangevec_base_t.resize (method) -ida_range.rangevec_base_t.size (method) -ida_range.rangevec_base_t.swap (method) -ida_range.rangevec_base_t.truncate (method) -ida_range.rangevec_t (class) -ida_range.rangevec_t.__init__ (method) -ida_registry (module) -ida_registry.ROOT_KEY_NAME (variable) -ida_registry.reg_binary (variable) -ida_registry.reg_data_type (function) -ida_registry.reg_delete (function) -ida_registry.reg_delete_subkey (function) -ida_registry.reg_delete_tree (function) -ida_registry.reg_dword (variable) -ida_registry.reg_exists (function) -ida_registry.reg_flush (function) -ida_registry.reg_load (function) -ida_registry.reg_read_binary (function) -ida_registry.reg_read_bool (function) -ida_registry.reg_read_int (function) -ida_registry.reg_read_string (function) -ida_registry.reg_read_strlist (function) -ida_registry.reg_subkey_exists (function) -ida_registry.reg_subkey_subkeys (function) -ida_registry.reg_subkey_values (function) -ida_registry.reg_sz (variable) -ida_registry.reg_unknown (variable) -ida_registry.reg_update_filestrlist (function) -ida_registry.reg_update_strlist (function) -ida_registry.reg_write_binary (function) -ida_registry.reg_write_bool (function) -ida_registry.reg_write_int (function) -ida_registry.reg_write_string (function) -ida_registry.set_registry_root (function) -ida_regfinder (module) -ida_regfinder.find_nearest_rvi (function) -ida_regfinder.find_reg_value (function) -ida_regfinder.find_reg_value_info (function) -ida_regfinder.find_sp_value (function) -ida_regfinder.invalidate_regfinder_cache (function) -ida_regfinder.reg_value_def_t (class) -ida_regfinder.reg_value_def_t.LIKE_GOT (variable) -ida_regfinder.reg_value_def_t.NOVAL (variable) -ida_regfinder.reg_value_def_t.PC_BASED (variable) -ida_regfinder.reg_value_def_t.SHORT_INSN (variable) -ida_regfinder.reg_value_def_t.SPVAL (variable) -ida_regfinder.reg_value_def_t.UVAL (variable) -ida_regfinder.reg_value_def_t.__eq__ (method) -ida_regfinder.reg_value_def_t.__init__ (method) -ida_regfinder.reg_value_def_t.__lt__ (method) -ida_regfinder.reg_value_def_t.def_ea (variable) -ida_regfinder.reg_value_def_t.def_itype (variable) -ida_regfinder.reg_value_def_t.dstr (method) -ida_regfinder.reg_value_def_t.flags (variable) -ida_regfinder.reg_value_def_t.is_like_got (method) -ida_regfinder.reg_value_def_t.is_pc_based (method) -ida_regfinder.reg_value_def_t.is_short_insn (method) -ida_regfinder.reg_value_def_t.val (variable) -ida_regfinder.reg_value_info_t (class) -ida_regfinder.reg_value_info_t.CONTAINED (variable) -ida_regfinder.reg_value_info_t.CONTAINS (variable) -ida_regfinder.reg_value_info_t.EQUAL (variable) -ida_regfinder.reg_value_info_t.NOT_COMPARABLE (variable) -ida_regfinder.reg_value_info_t.__getitem__ (method) -ida_regfinder.reg_value_info_t.__init__ (method) -ida_regfinder.reg_value_info_t.__len__ (method) -ida_regfinder.reg_value_info_t.__str__ (method) -ida_regfinder.reg_value_info_t.aborted (method) -ida_regfinder.reg_value_info_t.add (method) -ida_regfinder.reg_value_info_t.add_num (method) -ida_regfinder.reg_value_info_t.band (method) -ida_regfinder.reg_value_info_t.bandnot (method) -ida_regfinder.reg_value_info_t.bnot (method) -ida_regfinder.reg_value_info_t.bor (method) -ida_regfinder.reg_value_info_t.bxor (method) -ida_regfinder.reg_value_info_t.clear (method) -ida_regfinder.reg_value_info_t.empty (method) -ida_regfinder.reg_value_info_t.extend (method) -ida_regfinder.reg_value_info_t.get_def_ea (method) -ida_regfinder.reg_value_info_t.get_def_itype (method) -ida_regfinder.reg_value_info_t.get_num (method) -ida_regfinder.reg_value_info_t.get_spd (method) -ida_regfinder.reg_value_info_t.have_all_vals_flag (method) -ida_regfinder.reg_value_info_t.is_all_vals_like_got (method) -ida_regfinder.reg_value_info_t.is_all_vals_pc_based (method) -ida_regfinder.reg_value_info_t.is_badinsn (method) -ida_regfinder.reg_value_info_t.is_dead_end (method) -ida_regfinder.reg_value_info_t.is_known (method) -ida_regfinder.reg_value_info_t.is_num (method) -ida_regfinder.reg_value_info_t.is_spd (method) -ida_regfinder.reg_value_info_t.is_special (method) -ida_regfinder.reg_value_info_t.is_unkfunc (method) -ida_regfinder.reg_value_info_t.is_unkinsn (method) -ida_regfinder.reg_value_info_t.is_unkloop (method) -ida_regfinder.reg_value_info_t.is_unkmult (method) -ida_regfinder.reg_value_info_t.is_unknown (method) -ida_regfinder.reg_value_info_t.is_value_unique (method) -ida_regfinder.reg_value_info_t.make_aborted (method) -ida_regfinder.reg_value_info_t.make_badinsn (method) -ida_regfinder.reg_value_info_t.make_dead_end (method) -ida_regfinder.reg_value_info_t.make_initial_sp (method) -ida_regfinder.reg_value_info_t.make_num (method) -ida_regfinder.reg_value_info_t.make_unkfunc (method) -ida_regfinder.reg_value_info_t.make_unkinsn (method) -ida_regfinder.reg_value_info_t.make_unkloop (method) -ida_regfinder.reg_value_info_t.make_unkmult (method) -ida_regfinder.reg_value_info_t.neg (method) -ida_regfinder.reg_value_info_t.set_aborted (method) -ida_regfinder.reg_value_info_t.set_badinsn (method) -ida_regfinder.reg_value_info_t.set_dead_end (method) -ida_regfinder.reg_value_info_t.set_num (method) -ida_regfinder.reg_value_info_t.set_unkfunc (method) -ida_regfinder.reg_value_info_t.set_unkinsn (method) -ida_regfinder.reg_value_info_t.set_unkloop (method) -ida_regfinder.reg_value_info_t.set_unkmult (method) -ida_regfinder.reg_value_info_t.shift_left (method) -ida_regfinder.reg_value_info_t.shift_right (method) -ida_regfinder.reg_value_info_t.sll (method) -ida_regfinder.reg_value_info_t.slr (method) -ida_regfinder.reg_value_info_t.sub (method) -ida_regfinder.reg_value_info_t.trunc_uval (method) -ida_regfinder.reg_value_info_t.vals_union (method) -ida_regfinder.reg_value_info_t_make_aborted (function) -ida_regfinder.reg_value_info_t_make_badinsn (function) -ida_regfinder.reg_value_info_t_make_dead_end (function) -ida_regfinder.reg_value_info_t_make_initial_sp (function) -ida_regfinder.reg_value_info_t_make_num (function) -ida_regfinder.reg_value_info_t_make_unkfunc (function) -ida_regfinder.reg_value_info_t_make_unkinsn (function) -ida_regfinder.reg_value_info_t_make_unkloop (function) -ida_regfinder.reg_value_info_t_make_unkmult (function) -ida_search (module) -ida_search.SEARCH_BRK (variable) -ida_search.SEARCH_CASE (variable) -ida_search.SEARCH_DOWN (variable) -ida_search.SEARCH_IDENT (variable) -ida_search.SEARCH_NEXT (variable) -ida_search.SEARCH_NOBRK (variable) -ida_search.SEARCH_NOSHOW (variable) -ida_search.SEARCH_REGEX (variable) -ida_search.SEARCH_UP (variable) -ida_search.SEARCH_USESEL (variable) -ida_search.find_binary (function) -ida_search.find_code (function) -ida_search.find_data (function) -ida_search.find_defined (function) -ida_search.find_error (function) -ida_search.find_imm (function) -ida_search.find_not_func (function) -ida_search.find_notype (function) -ida_search.find_reg_access (function) -ida_search.find_suspop (function) -ida_search.find_text (function) -ida_search.find_unknown (function) -ida_search.search_down (function) -ida_segment (module) -ida_segment.ADDSEG_FILLGAP (variable) -ida_segment.ADDSEG_IDBENC (variable) -ida_segment.ADDSEG_NOAA (variable) -ida_segment.ADDSEG_NOSREG (variable) -ida_segment.ADDSEG_NOTRUNC (variable) -ida_segment.ADDSEG_OR_DIE (variable) -ida_segment.ADDSEG_QUIET (variable) -ida_segment.ADDSEG_SPARSE (variable) -ida_segment.CSS_BREAK (variable) -ida_segment.CSS_NODBG (variable) -ida_segment.CSS_NOMEM (variable) -ida_segment.CSS_NORANGE (variable) -ida_segment.CSS_OK (variable) -ida_segment.MAX_GROUPS (variable) -ida_segment.MAX_SEGM_TRANSLATIONS (variable) -ida_segment.MOVE_SEGM_CHUNK (variable) -ida_segment.MOVE_SEGM_DEBUG (variable) -ida_segment.MOVE_SEGM_IDP (variable) -ida_segment.MOVE_SEGM_INVAL (variable) -ida_segment.MOVE_SEGM_LOADER (variable) -ida_segment.MOVE_SEGM_MAPPING (variable) -ida_segment.MOVE_SEGM_ODD (variable) -ida_segment.MOVE_SEGM_OK (variable) -ida_segment.MOVE_SEGM_ORPHAN (variable) -ida_segment.MOVE_SEGM_PARAM (variable) -ida_segment.MOVE_SEGM_ROOM (variable) -ida_segment.MOVE_SEGM_SOURCEFILES (variable) -ida_segment.MSF_FIXONCE (variable) -ida_segment.MSF_LDKEEP (variable) -ida_segment.MSF_NETNODES (variable) -ida_segment.MSF_NOFIX (variable) -ida_segment.MSF_PRIORITY (variable) -ida_segment.MSF_SILENT (variable) -ida_segment.SEGMOD_KEEP (variable) -ida_segment.SEGMOD_KEEP0 (variable) -ida_segment.SEGMOD_KEEPSEL (variable) -ida_segment.SEGMOD_KILL (variable) -ida_segment.SEGMOD_NOMOVE (variable) -ida_segment.SEGMOD_SILENT (variable) -ida_segment.SEGMOD_SPARSE (variable) -ida_segment.SEGPERM_EXEC (variable) -ida_segment.SEGPERM_READ (variable) -ida_segment.SEGPERM_WRITE (variable) -ida_segment.SEG_ABSSYM (variable) -ida_segment.SEG_BSS (variable) -ida_segment.SEG_CODE (variable) -ida_segment.SEG_COMM (variable) -ida_segment.SEG_DATA (variable) -ida_segment.SEG_GRP (variable) -ida_segment.SEG_IMEM (variable) -ida_segment.SEG_NORM (variable) -ida_segment.SEG_NULL (variable) -ida_segment.SEG_UNDF (variable) -ida_segment.SEG_XTRN (variable) -ida_segment.SFL_COMORG (variable) -ida_segment.SFL_DEBUG (variable) -ida_segment.SFL_HEADER (variable) -ida_segment.SFL_HIDDEN (variable) -ida_segment.SFL_HIDETYPE (variable) -ida_segment.SFL_LOADER (variable) -ida_segment.SFL_OBOK (variable) -ida_segment.SNAP_ALL_SEG (variable) -ida_segment.SNAP_CUR_SEG (variable) -ida_segment.SNAP_LOAD_SEG (variable) -ida_segment.SREG_NUM (variable) -ida_segment.add_segm (function) -ida_segment.add_segm_ex (function) -ida_segment.add_segment_translation (function) -ida_segment.allocate_selector (function) -ida_segment.change_segment_status (function) -ida_segment.del_segm (function) -ida_segment.del_segment_translations (function) -ida_segment.del_selector (function) -ida_segment.find_free_selector (function) -ida_segment.find_selector (function) -ida_segment.get_defsr (function) -ida_segment.get_first_seg (function) -ida_segment.get_group_selector (function) -ida_segment.get_last_seg (function) -ida_segment.get_next_seg (function) -ida_segment.get_prev_seg (function) -ida_segment.get_segm_base (function) -ida_segment.get_segm_by_name (function) -ida_segment.get_segm_by_sel (function) -ida_segment.get_segm_class (function) -ida_segment.get_segm_name (function) -ida_segment.get_segm_num (function) -ida_segment.get_segm_para (function) -ida_segment.get_segm_qty (function) -ida_segment.get_segment_alignment (function) -ida_segment.get_segment_cmt (function) -ida_segment.get_segment_combination (function) -ida_segment.get_segment_translations (function) -ida_segment.get_selector_qty (function) -ida_segment.get_visible_segm_name (function) -ida_segment.getn_selector (function) -ida_segment.getnseg (function) -ida_segment.getseg (function) -ida_segment.is_finally_visible_segm (function) -ida_segment.is_miniidb (function) -ida_segment.is_segm_locked (function) -ida_segment.is_spec_ea (function) -ida_segment.is_spec_segm (function) -ida_segment.is_visible_segm (function) -ida_segment.lock_segm (function) -ida_segment.lock_segment (class) -ida_segment.lock_segment.__init__ (method) -ida_segment.move_segm (function) -ida_segment.move_segm_start (function) -ida_segment.move_segm_strerror (function) -ida_segment.rebase_program (function) -ida_segment.saAbs (variable) -ida_segment.saGroup (variable) -ida_segment.saRel1024Bytes (variable) -ida_segment.saRel128Bytes (variable) -ida_segment.saRel2048Bytes (variable) -ida_segment.saRel32Bytes (variable) -ida_segment.saRel4K (variable) -ida_segment.saRel512Bytes (variable) -ida_segment.saRel64Bytes (variable) -ida_segment.saRelByte (variable) -ida_segment.saRelDble (variable) -ida_segment.saRelPage (variable) -ida_segment.saRelPara (variable) -ida_segment.saRelQword (variable) -ida_segment.saRelWord (variable) -ida_segment.scCommon (variable) -ida_segment.scGroup (variable) -ida_segment.scPriv (variable) -ida_segment.scPub (variable) -ida_segment.scPub2 (variable) -ida_segment.scPub3 (variable) -ida_segment.scStack (variable) -ida_segment.segm_adjust_diff (function) -ida_segment.segm_adjust_ea (function) -ida_segment.segment_defsr_array (class) -ida_segment.segment_defsr_array.__getitem__ (method) -ida_segment.segment_defsr_array.__init__ (method) -ida_segment.segment_defsr_array.__len__ (method) -ida_segment.segment_defsr_array.__setitem__ (method) -ida_segment.segment_defsr_array._get_bytes (method) -ida_segment.segment_defsr_array._set_bytes (method) -ida_segment.segment_t (class) -ida_segment.segment_t.__getDefsr (method) -ida_segment.segment_t.__init__ (method) -ida_segment.segment_t.abits (method) -ida_segment.segment_t.abytes (method) -ida_segment.segment_t.align (variable) -ida_segment.segment_t.bitness (variable) -ida_segment.segment_t.clr_comorg (method) -ida_segment.segment_t.clr_ob_ok (method) -ida_segment.segment_t.color (variable) -ida_segment.segment_t.comb (variable) -ida_segment.segment_t.comorg (method) -ida_segment.segment_t.defsr (variable) -ida_segment.segment_t.flags (variable) -ida_segment.segment_t.is_16bit (method) -ida_segment.segment_t.is_32bit (method) -ida_segment.segment_t.is_64bit (method) -ida_segment.segment_t.is_header_segm (method) -ida_segment.segment_t.is_hidden_segtype (method) -ida_segment.segment_t.is_loader_segm (method) -ida_segment.segment_t.is_visible_segm (method) -ida_segment.segment_t.name (variable) -ida_segment.segment_t.ob_ok (method) -ida_segment.segment_t.orgbase (variable) -ida_segment.segment_t.perm (variable) -ida_segment.segment_t.sclass (variable) -ida_segment.segment_t.sel (variable) -ida_segment.segment_t.set_comorg (method) -ida_segment.segment_t.set_debugger_segm (method) -ida_segment.segment_t.set_header_segm (method) -ida_segment.segment_t.set_hidden_segtype (method) -ida_segment.segment_t.set_loader_segm (method) -ida_segment.segment_t.set_ob_ok (method) -ida_segment.segment_t.set_visible_segm (method) -ida_segment.segment_t.type (variable) -ida_segment.segment_t.update (method) -ida_segment.segtype (function) -ida_segment.sel2ea (function) -ida_segment.sel2para (function) -ida_segment.set_defsr (function) -ida_segment.set_group_selector (function) -ida_segment.set_segm_addressing (function) -ida_segment.set_segm_base (function) -ida_segment.set_segm_class (function) -ida_segment.set_segm_end (function) -ida_segment.set_segm_name (function) -ida_segment.set_segm_start (function) -ida_segment.set_segment_cmt (function) -ida_segment.set_segment_translations (function) -ida_segment.set_selector (function) -ida_segment.set_visible_segm (function) -ida_segment.setup_selector (function) -ida_segment.std_out_segm_footer (function) -ida_segment.take_memory_snapshot (function) -ida_segment.update_segm (function) -ida_segregs (module) -ida_segregs.SR_auto (variable) -ida_segregs.SR_autostart (variable) -ida_segregs.SR_inherit (variable) -ida_segregs.SR_user (variable) -ida_segregs.copy_sreg_ranges (function) -ida_segregs.del_sreg_range (function) -ida_segregs.get_prev_sreg_range (function) -ida_segregs.get_sreg (function) -ida_segregs.get_sreg_range (function) -ida_segregs.get_sreg_range_num (function) -ida_segregs.get_sreg_ranges_qty (function) -ida_segregs.getn_sreg_range (function) -ida_segregs.set_default_dataseg (function) -ida_segregs.set_default_sreg_value (function) -ida_segregs.set_sreg_at_next_code (function) -ida_segregs.split_sreg_range (function) -ida_segregs.sreg_range_t (class) -ida_segregs.sreg_range_t.__init__ (method) -ida_segregs.sreg_range_t.tag (variable) -ida_segregs.sreg_range_t.val (variable) -ida_srclang (module) -ida_srclang.SRCLANG_C (variable) -ida_srclang.SRCLANG_CPP (variable) -ida_srclang.SRCLANG_GO (variable) -ida_srclang.SRCLANG_OBJC (variable) -ida_srclang.SRCLANG_SWIFT (variable) -ida_srclang.parse_decls_for_srclang (function) -ida_srclang.parse_decls_with_parser (function) -ida_srclang.select_parser_by_name (function) -ida_srclang.select_parser_by_srclang (function) -ida_srclang.set_parser_argv (function) -ida_strlist (module) -ida_strlist.build_strlist (function) -ida_strlist.clear_strlist (function) -ida_strlist.get_strlist_item (function) -ida_strlist.get_strlist_options (function) -ida_strlist.get_strlist_qty (function) -ida_strlist.string_info_t (class) -ida_strlist.string_info_t.__init__ (method) -ida_strlist.string_info_t.__lt__ (method) -ida_strlist.strwinsetup_t (class) -ida_strlist.strwinsetup_t.__init__ (method) -ida_strlist.strwinsetup_t._get_strtypes (method) -ida_strlist.strwinsetup_t._set_strtypes (method) -ida_struct (module) -ida_struct.MF_BASECLASS (variable) -ida_struct.MF_BYTIL (variable) -ida_struct.MF_DTOR (variable) -ida_struct.MF_DUPNAME (variable) -ida_struct.MF_HASTI (variable) -ida_struct.MF_HASUNI (variable) -ida_struct.MF_OK (variable) -ida_struct.MF_UNIMEM (variable) -ida_struct.SET_MEMTI_BYTIL (variable) -ida_struct.SET_MEMTI_COMPATIBLE (variable) -ida_struct.SET_MEMTI_FUNCARG (variable) -ida_struct.SET_MEMTI_MAY_DESTROY (variable) -ida_struct.SET_MEMTI_USERTI (variable) -ida_struct.SF_ALIGN (variable) -ida_struct.SF_FRAME (variable) -ida_struct.SF_GHOST (variable) -ida_struct.SF_HASUNI (variable) -ida_struct.SF_HIDDEN (variable) -ida_struct.SF_NOLIST (variable) -ida_struct.SF_TYPLIB (variable) -ida_struct.SF_UNION (variable) -ida_struct.SF_VAR (variable) -ida_struct.SMT_ARRAY (variable) -ida_struct.SMT_BADARG (variable) -ida_struct.SMT_FAILED (variable) -ida_struct.SMT_KEEP (variable) -ida_struct.SMT_NOCOMPAT (variable) -ida_struct.SMT_OVERLAP (variable) -ida_struct.SMT_SIZE (variable) -ida_struct.SMT_WORSE (variable) -ida_struct.STRNFL_REGEX (variable) -ida_struct.STRUC_ERROR_MEMBER_LTUDT (variable) -ida_struct.STRUC_ERROR_MEMBER_NAME (variable) -ida_struct.STRUC_ERROR_MEMBER_NESTED (variable) -ida_struct.STRUC_ERROR_MEMBER_OFFSET (variable) -ida_struct.STRUC_ERROR_MEMBER_OK (variable) -ida_struct.STRUC_ERROR_MEMBER_SIZE (variable) -ida_struct.STRUC_ERROR_MEMBER_STRUCT (variable) -ida_struct.STRUC_ERROR_MEMBER_TINFO (variable) -ida_struct.STRUC_ERROR_MEMBER_UNIVAR (variable) -ida_struct.STRUC_ERROR_MEMBER_VARLAST (variable) -ida_struct.STRUC_SEPARATOR (variable) -ida_struct.add_struc (function) -ida_struct.add_struc_member (function) -ida_struct.del_member_tinfo (function) -ida_struct.del_struc (function) -ida_struct.del_struc_member (function) -ida_struct.del_struc_members (function) -ida_struct.dyn_member_ref_array (class) -ida_struct.dyn_member_ref_array.__getitem__ (method) -ida_struct.dyn_member_ref_array.__init__ (method) -ida_struct.dyn_member_ref_array.__len__ (method) -ida_struct.dyn_member_ref_array.__setitem__ (method) -ida_struct.expand_struc (function) -ida_struct.get_best_fit_member (function) -ida_struct.get_first_struc_idx (function) -ida_struct.get_innermost_member (function) -ida_struct.get_last_struc_idx (function) -ida_struct.get_max_offset (function) -ida_struct.get_member (function) -ida_struct.get_member_by_fullname (function) -ida_struct.get_member_by_id (function) -ida_struct.get_member_by_name (function) -ida_struct.get_member_cmt (function) -ida_struct.get_member_fullname (function) -ida_struct.get_member_id (function) -ida_struct.get_member_name (function) -ida_struct.get_member_size (function) -ida_struct.get_member_struc (function) -ida_struct.get_member_tinfo (function) -ida_struct.get_next_member_idx (function) -ida_struct.get_next_struc_idx (function) -ida_struct.get_or_guess_member_tinfo (function) -ida_struct.get_prev_member_idx (function) -ida_struct.get_prev_struc_idx (function) -ida_struct.get_sptr (function) -ida_struct.get_struc (function) -ida_struct.get_struc_by_idx (function) -ida_struct.get_struc_cmt (function) -ida_struct.get_struc_first_offset (function) -ida_struct.get_struc_id (function) -ida_struct.get_struc_idx (function) -ida_struct.get_struc_last_offset (function) -ida_struct.get_struc_name (function) -ida_struct.get_struc_next_offset (function) -ida_struct.get_struc_prev_offset (function) -ida_struct.get_struc_qty (function) -ida_struct.get_struc_size (function) -ida_struct.is_anonymous_member_name (function) -ida_struct.is_dummy_member_name (function) -ida_struct.is_member_id (function) -ida_struct.is_special_member (function) -ida_struct.is_union (function) -ida_struct.is_varmember (function) -ida_struct.is_varstr (function) -ida_struct.member_t (class) -ida_struct.member_t.__init__ (method) -ida_struct.member_t.by_til (method) -ida_struct.member_t.eoff (variable) -ida_struct.member_t.flag (variable) -ida_struct.member_t.get_size (method) -ida_struct.member_t.get_soff (method) -ida_struct.member_t.has_ti (method) -ida_struct.member_t.has_union (method) -ida_struct.member_t.id (variable) -ida_struct.member_t.is_baseclass (method) -ida_struct.member_t.is_destructor (method) -ida_struct.member_t.is_dupname (method) -ida_struct.member_t.props (variable) -ida_struct.member_t.soff (variable) -ida_struct.member_t.unimem (method) -ida_struct.retrieve_member_info (function) -ida_struct.save_struc (function) -ida_struct.set_member_cmt (function) -ida_struct.set_member_name (function) -ida_struct.set_member_tinfo (function) -ida_struct.set_member_type (function) -ida_struct.set_struc_align (function) -ida_struct.set_struc_cmt (function) -ida_struct.set_struc_hidden (function) -ida_struct.set_struc_idx (function) -ida_struct.set_struc_listed (function) -ida_struct.set_struc_name (function) -ida_struct.stroff_as_size (function) -ida_struct.struc_t (class) -ida_struct.struc_t.__get_members__ (method) -ida_struct.struc_t.__init__ (method) -ida_struct.struc_t.age (variable) -ida_struct.struc_t.from_til (method) -ida_struct.struc_t.get_alignment (method) -ida_struct.struc_t.get_last_member (method) -ida_struct.struc_t.get_member (method) -ida_struct.struc_t.has_union (method) -ida_struct.struc_t.id (variable) -ida_struct.struc_t.is_choosable (method) -ida_struct.struc_t.is_copyof (method) -ida_struct.struc_t.is_frame (method) -ida_struct.struc_t.is_ghost (method) -ida_struct.struc_t.is_hidden (method) -ida_struct.struc_t.is_mappedto (method) -ida_struct.struc_t.is_synced (method) -ida_struct.struc_t.is_union (method) -ida_struct.struc_t.is_varstr (method) -ida_struct.struc_t.like_union (method) -ida_struct.struc_t.members (variable) -ida_struct.struc_t.memqty (variable) -ida_struct.struc_t.ordinal (variable) -ida_struct.struc_t.props (variable) -ida_struct.struc_t.set_alignment (method) -ida_struct.struct_field_visitor_t (class) -ida_struct.struct_field_visitor_t.__disown__ (method) -ida_struct.struct_field_visitor_t.__init__ (method) -ida_struct.struct_field_visitor_t.visit_field (method) -ida_struct.udm_visitor_t (class) -ida_struct.udm_visitor_t.__disown__ (method) -ida_struct.udm_visitor_t.__init__ (method) -ida_struct.udm_visitor_t.visit_udm (method) -ida_struct.unsync_and_delete_struc (function) -ida_struct.visit_stroff_fields (function) -ida_struct.visit_stroff_udms (function) -ida_tryblks (module) -ida_tryblks.TBERR_EMPTY (variable) -ida_tryblks.TBERR_END (variable) -ida_tryblks.TBERR_INTERSECT (variable) -ida_tryblks.TBERR_KIND (variable) -ida_tryblks.TBERR_NO_CATCHES (variable) -ida_tryblks.TBERR_OK (variable) -ida_tryblks.TBERR_ORDER (variable) -ida_tryblks.TBERR_START (variable) -ida_tryblks.add_tryblk (function) -ida_tryblks.catch_t (class) -ida_tryblks.catch_t.__init__ (method) -ida_tryblks.catchvec_t (class) -ida_tryblks.catchvec_t.__eq__ (method) -ida_tryblks.catchvec_t.__getitem__ (method) -ida_tryblks.catchvec_t.__init__ (method) -ida_tryblks.catchvec_t.__len__ (method) -ida_tryblks.catchvec_t.__ne__ (method) -ida_tryblks.catchvec_t.__setitem__ (method) -ida_tryblks.catchvec_t._del (method) -ida_tryblks.catchvec_t.add_unique (method) -ida_tryblks.catchvec_t.at (method) -ida_tryblks.catchvec_t.begin (method) -ida_tryblks.catchvec_t.capacity (method) -ida_tryblks.catchvec_t.clear (method) -ida_tryblks.catchvec_t.empty (method) -ida_tryblks.catchvec_t.end (method) -ida_tryblks.catchvec_t.erase (method) -ida_tryblks.catchvec_t.extract (method) -ida_tryblks.catchvec_t.find (method) -ida_tryblks.catchvec_t.grow (method) -ida_tryblks.catchvec_t.has (method) -ida_tryblks.catchvec_t.inject (method) -ida_tryblks.catchvec_t.insert (method) -ida_tryblks.catchvec_t.pop_back (method) -ida_tryblks.catchvec_t.push_back (method) -ida_tryblks.catchvec_t.qclear (method) -ida_tryblks.catchvec_t.reserve (method) -ida_tryblks.catchvec_t.resize (method) -ida_tryblks.catchvec_t.size (method) -ida_tryblks.catchvec_t.swap (method) -ida_tryblks.catchvec_t.truncate (method) -ida_tryblks.del_tryblks (function) -ida_tryblks.find_syseh (function) -ida_tryblks.get_tryblks (function) -ida_tryblks.is_ea_tryblks (function) -ida_tryblks.seh_t (class) -ida_tryblks.seh_t.__init__ (method) -ida_tryblks.seh_t.clear (method) -ida_tryblks.try_handler_t (class) -ida_tryblks.try_handler_t.__init__ (method) -ida_tryblks.try_handler_t.clear (method) -ida_tryblks.tryblk_t (class) -ida_tryblks.tryblk_t.__init__ (method) -ida_tryblks.tryblk_t.clear (method) -ida_tryblks.tryblk_t.cpp (method) -ida_tryblks.tryblk_t.empty (method) -ida_tryblks.tryblk_t.get_kind (method) -ida_tryblks.tryblk_t.is_cpp (method) -ida_tryblks.tryblk_t.is_seh (method) -ida_tryblks.tryblk_t.seh (method) -ida_tryblks.tryblk_t.set_cpp (method) -ida_tryblks.tryblk_t.set_seh (method) -ida_tryblks.tryblks_t (class) -ida_tryblks.tryblks_t.__eq__ (method) -ida_tryblks.tryblks_t.__getitem__ (method) -ida_tryblks.tryblks_t.__init__ (method) -ida_tryblks.tryblks_t.__len__ (method) -ida_tryblks.tryblks_t.__ne__ (method) -ida_tryblks.tryblks_t.__setitem__ (method) -ida_tryblks.tryblks_t._del (method) -ida_tryblks.tryblks_t.add_unique (method) -ida_tryblks.tryblks_t.at (method) -ida_tryblks.tryblks_t.begin (method) -ida_tryblks.tryblks_t.capacity (method) -ida_tryblks.tryblks_t.clear (method) -ida_tryblks.tryblks_t.empty (method) -ida_tryblks.tryblks_t.end (method) -ida_tryblks.tryblks_t.erase (method) -ida_tryblks.tryblks_t.extract (method) -ida_tryblks.tryblks_t.find (method) -ida_tryblks.tryblks_t.grow (method) -ida_tryblks.tryblks_t.has (method) -ida_tryblks.tryblks_t.inject (method) -ida_tryblks.tryblks_t.insert (method) -ida_tryblks.tryblks_t.pop_back (method) -ida_tryblks.tryblks_t.push_back (method) -ida_tryblks.tryblks_t.qclear (method) -ida_tryblks.tryblks_t.reserve (method) -ida_tryblks.tryblks_t.resize (method) -ida_tryblks.tryblks_t.size (method) -ida_tryblks.tryblks_t.swap (method) -ida_tryblks.tryblks_t.truncate (method) -ida_typeinf (module) -ida_typeinf.ADDTIL_ABORTED (variable) -ida_typeinf.ADDTIL_COMP (variable) -ida_typeinf.ADDTIL_DEFAULT (variable) -ida_typeinf.ADDTIL_FAILED (variable) -ida_typeinf.ADDTIL_INCOMP (variable) -ida_typeinf.ADDTIL_OK (variable) -ida_typeinf.ADDTIL_SILENT (variable) -ida_typeinf.ALOC_CUSTOM (variable) -ida_typeinf.ALOC_DIST (variable) -ida_typeinf.ALOC_NONE (variable) -ida_typeinf.ALOC_REG1 (variable) -ida_typeinf.ALOC_REG2 (variable) -ida_typeinf.ALOC_RREL (variable) -ida_typeinf.ALOC_STACK (variable) -ida_typeinf.ALOC_STATIC (variable) -ida_typeinf.ARGREGS_BY_SLOTS (variable) -ida_typeinf.ARGREGS_FP_CONSUME_GP (variable) -ida_typeinf.ARGREGS_GP_ONLY (variable) -ida_typeinf.ARGREGS_INDEPENDENT (variable) -ida_typeinf.ARGREGS_MIPS_O32 (variable) -ida_typeinf.BADSIZE (variable) -ida_typeinf.BFA_FUNC_EXT_FORMAT (variable) -ida_typeinf.BFA_FUNC_MARKER (variable) -ida_typeinf.BFA_HIGH (variable) -ida_typeinf.BFA_NORET (variable) -ida_typeinf.BFA_PURE (variable) -ida_typeinf.BFA_STATIC (variable) -ida_typeinf.BFA_VIRTUAL (variable) -ida_typeinf.BTE_ALWAYS (variable) -ida_typeinf.BTE_BITMASK (variable) -ida_typeinf.BTE_CHAR (variable) -ida_typeinf.BTE_HEX (variable) -ida_typeinf.BTE_OUT_MASK (variable) -ida_typeinf.BTE_RESERVED (variable) -ida_typeinf.BTE_SDEC (variable) -ida_typeinf.BTE_SIZE_MASK (variable) -ida_typeinf.BTE_UDEC (variable) -ida_typeinf.BTF_BOOL (variable) -ida_typeinf.BTF_BYTE (variable) -ida_typeinf.BTF_CHAR (variable) -ida_typeinf.BTF_DOUBLE (variable) -ida_typeinf.BTF_ENUM (variable) -ida_typeinf.BTF_FLOAT (variable) -ida_typeinf.BTF_INT (variable) -ida_typeinf.BTF_INT128 (variable) -ida_typeinf.BTF_INT16 (variable) -ida_typeinf.BTF_INT32 (variable) -ida_typeinf.BTF_INT64 (variable) -ida_typeinf.BTF_INT8 (variable) -ida_typeinf.BTF_LDOUBLE (variable) -ida_typeinf.BTF_SINT (variable) -ida_typeinf.BTF_STRUCT (variable) -ida_typeinf.BTF_TBYTE (variable) -ida_typeinf.BTF_TYPEDEF (variable) -ida_typeinf.BTF_UCHAR (variable) -ida_typeinf.BTF_UINT (variable) -ida_typeinf.BTF_UINT128 (variable) -ida_typeinf.BTF_UINT16 (variable) -ida_typeinf.BTF_UINT32 (variable) -ida_typeinf.BTF_UINT64 (variable) -ida_typeinf.BTF_UINT8 (variable) -ida_typeinf.BTF_UNION (variable) -ida_typeinf.BTF_UNK (variable) -ida_typeinf.BTF_VOID (variable) -ida_typeinf.BTMT_ARRESERV (variable) -ida_typeinf.BTMT_BFLDI16 (variable) -ida_typeinf.BTMT_BFLDI32 (variable) -ida_typeinf.BTMT_BFLDI64 (variable) -ida_typeinf.BTMT_BFLDI8 (variable) -ida_typeinf.BTMT_BOOL1 (variable) -ida_typeinf.BTMT_BOOL2 (variable) -ida_typeinf.BTMT_BOOL4 (variable) -ida_typeinf.BTMT_BOOL8 (variable) -ida_typeinf.BTMT_CHAR (variable) -ida_typeinf.BTMT_CLOSURE (variable) -ida_typeinf.BTMT_DEFBOOL (variable) -ida_typeinf.BTMT_DEFCALL (variable) -ida_typeinf.BTMT_DEFPTR (variable) -ida_typeinf.BTMT_DOUBLE (variable) -ida_typeinf.BTMT_FAR (variable) -ida_typeinf.BTMT_FARCALL (variable) -ida_typeinf.BTMT_FLOAT (variable) -ida_typeinf.BTMT_INTCALL (variable) -ida_typeinf.BTMT_LNGDBL (variable) -ida_typeinf.BTMT_NEAR (variable) -ida_typeinf.BTMT_NEARCALL (variable) -ida_typeinf.BTMT_NONBASED (variable) -ida_typeinf.BTMT_SIGNED (variable) -ida_typeinf.BTMT_SIZE0 (variable) -ida_typeinf.BTMT_SIZE12 (variable) -ida_typeinf.BTMT_SIZE128 (variable) -ida_typeinf.BTMT_SIZE48 (variable) -ida_typeinf.BTMT_SPECFLT (variable) -ida_typeinf.BTMT_TYPEDEF (variable) -ida_typeinf.BTMT_UNKSIGN (variable) -ida_typeinf.BTMT_USIGNED (variable) -ida_typeinf.BTM_CONST (variable) -ida_typeinf.BTM_VOLATILE (variable) -ida_typeinf.BT_ARRAY (variable) -ida_typeinf.BT_BITFIELD (variable) -ida_typeinf.BT_BOOL (variable) -ida_typeinf.BT_COMPLEX (variable) -ida_typeinf.BT_FLOAT (variable) -ida_typeinf.BT_FUNC (variable) -ida_typeinf.BT_INT (variable) -ida_typeinf.BT_INT128 (variable) -ida_typeinf.BT_INT16 (variable) -ida_typeinf.BT_INT32 (variable) -ida_typeinf.BT_INT64 (variable) -ida_typeinf.BT_INT8 (variable) -ida_typeinf.BT_PTR (variable) -ida_typeinf.BT_RESERVED (variable) -ida_typeinf.BT_SEGREG (variable) -ida_typeinf.BT_UNK (variable) -ida_typeinf.BT_UNKNOWN (variable) -ida_typeinf.BT_UNK_BYTE (variable) -ida_typeinf.BT_UNK_DWORD (variable) -ida_typeinf.BT_UNK_OWORD (variable) -ida_typeinf.BT_UNK_QWORD (variable) -ida_typeinf.BT_UNK_WORD (variable) -ida_typeinf.BT_VOID (variable) -ida_typeinf.CC_ALLOW_ARGPERM (variable) -ida_typeinf.CC_ALLOW_REGHOLES (variable) -ida_typeinf.CC_CDECL_OK (variable) -ida_typeinf.CC_GOLANG_OK (variable) -ida_typeinf.CC_HAS_ELLIPSIS (variable) -ida_typeinf.CM_CC_CDECL (variable) -ida_typeinf.CM_CC_ELLIPSIS (variable) -ida_typeinf.CM_CC_FASTCALL (variable) -ida_typeinf.CM_CC_GOLANG (variable) -ida_typeinf.CM_CC_INVALID (variable) -ida_typeinf.CM_CC_PASCAL (variable) -ida_typeinf.CM_CC_SPECIALE (variable) -ida_typeinf.CM_CC_SPECIALP (variable) -ida_typeinf.CM_CC_SPOILED (variable) -ida_typeinf.CM_CC_STDCALL (variable) -ida_typeinf.CM_CC_SWIFT (variable) -ida_typeinf.CM_CC_THISCALL (variable) -ida_typeinf.CM_CC_UNKNOWN (variable) -ida_typeinf.CM_CC_VOIDARG (variable) -ida_typeinf.CM_N16_F32 (variable) -ida_typeinf.CM_N32_F48 (variable) -ida_typeinf.CM_N64 (variable) -ida_typeinf.CM_N8_F16 (variable) -ida_typeinf.CM_UNKNOWN (variable) -ida_typeinf.COMP_BC (variable) -ida_typeinf.COMP_BP (variable) -ida_typeinf.COMP_GNU (variable) -ida_typeinf.COMP_MS (variable) -ida_typeinf.COMP_UNK (variable) -ida_typeinf.COMP_UNSURE (variable) -ida_typeinf.COMP_VISAGE (variable) -ida_typeinf.COMP_WATCOM (variable) -ida_typeinf.DEFMASK64 (variable) -ida_typeinf.ETF_ASMENUM (variable) -ida_typeinf.ETF_AUTONAME (variable) -ida_typeinf.ETF_COMPATIBLE (variable) -ida_typeinf.ETF_FORCENAME (variable) -ida_typeinf.ETF_FUNCARG (variable) -ida_typeinf.ETF_MAY_DESTROY (variable) -ida_typeinf.ETF_NO_IDBSYNC (variable) -ida_typeinf.ETF_NO_LAYOUT (variable) -ida_typeinf.ETF_NO_SAVE (variable) -ida_typeinf.FAH_BYTE (variable) -ida_typeinf.FAI_ARRAY (variable) -ida_typeinf.FAI_HIDDEN (variable) -ida_typeinf.FAI_RETPTR (variable) -ida_typeinf.FAI_STRUCT (variable) -ida_typeinf.FAI_UNUSED (variable) -ida_typeinf.FIRST_NONTRIVIAL_TYPID (variable) -ida_typeinf.FRB_CHAR (variable) -ida_typeinf.FRB_CUSTOM (variable) -ida_typeinf.FRB_ENUM (variable) -ida_typeinf.FRB_FLOAT (variable) -ida_typeinf.FRB_INVBITS (variable) -ida_typeinf.FRB_INVSIGN (variable) -ida_typeinf.FRB_LZERO (variable) -ida_typeinf.FRB_MASK (variable) -ida_typeinf.FRB_NUMB (variable) -ida_typeinf.FRB_NUMD (variable) -ida_typeinf.FRB_NUMH (variable) -ida_typeinf.FRB_NUMO (variable) -ida_typeinf.FRB_OFFSET (variable) -ida_typeinf.FRB_SEG (variable) -ida_typeinf.FRB_SIGNED (variable) -ida_typeinf.FRB_STRLIT (variable) -ida_typeinf.FRB_STROFF (variable) -ida_typeinf.FRB_TABFORM (variable) -ida_typeinf.FRB_UNK (variable) -ida_typeinf.FTI_ALL (variable) -ida_typeinf.FTI_ARGLOCS (variable) -ida_typeinf.FTI_CALLTYPE (variable) -ida_typeinf.FTI_CONST (variable) -ida_typeinf.FTI_CTOR (variable) -ida_typeinf.FTI_DEFCALL (variable) -ida_typeinf.FTI_DTOR (variable) -ida_typeinf.FTI_EXPLOCS (variable) -ida_typeinf.FTI_FARCALL (variable) -ida_typeinf.FTI_HIGH (variable) -ida_typeinf.FTI_INTCALL (variable) -ida_typeinf.FTI_NEARCALL (variable) -ida_typeinf.FTI_NORET (variable) -ida_typeinf.FTI_PURE (variable) -ida_typeinf.FTI_SPOILED (variable) -ida_typeinf.FTI_STATIC (variable) -ida_typeinf.FTI_VIRTUAL (variable) -ida_typeinf.GTD_CALC_ARGLOCS (variable) -ida_typeinf.GTD_CALC_LAYOUT (variable) -ida_typeinf.GTD_DEL_BITFLDS (variable) -ida_typeinf.GTD_NO_ARGLOCS (variable) -ida_typeinf.GTD_NO_LAYOUT (variable) -ida_typeinf.GTS_BASECLASS (variable) -ida_typeinf.GTS_NESTED (variable) -ida_typeinf.GUESS_FUNC_FAILED (variable) -ida_typeinf.GUESS_FUNC_OK (variable) -ida_typeinf.GUESS_FUNC_TRIVIAL (variable) -ida_typeinf.HTI_CPP (variable) -ida_typeinf.HTI_DCL (variable) -ida_typeinf.HTI_FIL (variable) -ida_typeinf.HTI_HIGH (variable) -ida_typeinf.HTI_LOWER (variable) -ida_typeinf.HTI_MAC (variable) -ida_typeinf.HTI_NDC (variable) -ida_typeinf.HTI_NER (variable) -ida_typeinf.HTI_NOBASE (variable) -ida_typeinf.HTI_NWR (variable) -ida_typeinf.HTI_PAK (variable) -ida_typeinf.HTI_PAK1 (variable) -ida_typeinf.HTI_PAK16 (variable) -ida_typeinf.HTI_PAK2 (variable) -ida_typeinf.HTI_PAK4 (variable) -ida_typeinf.HTI_PAK8 (variable) -ida_typeinf.HTI_PAKDEF (variable) -ida_typeinf.HTI_PAK_SHIFT (variable) -ida_typeinf.HTI_RAWARGS (variable) -ida_typeinf.HTI_RELAXED (variable) -ida_typeinf.HTI_TST (variable) -ida_typeinf.IMPTYPE_LOCAL (variable) -ida_typeinf.MAX_FUNC_ARGS (variable) -ida_typeinf.NTF_64BIT (variable) -ida_typeinf.NTF_CHKSYNC (variable) -ida_typeinf.NTF_COPY (variable) -ida_typeinf.NTF_FIXNAME (variable) -ida_typeinf.NTF_IDBENC (variable) -ida_typeinf.NTF_NOBASE (variable) -ida_typeinf.NTF_NOCUR (variable) -ida_typeinf.NTF_NO_NAMECHK (variable) -ida_typeinf.NTF_REPLACE (variable) -ida_typeinf.NTF_SYMM (variable) -ida_typeinf.NTF_SYMU (variable) -ida_typeinf.NTF_TYPE (variable) -ida_typeinf.NTF_UMANGLED (variable) -ida_typeinf.PDF_DEF_BASE (variable) -ida_typeinf.PDF_DEF_FWD (variable) -ida_typeinf.PDF_HEADER_CMT (variable) -ida_typeinf.PDF_INCL_DEPS (variable) -ida_typeinf.PIO_IGNORE_PTRS (variable) -ida_typeinf.PIO_NOATTR_FAIL (variable) -ida_typeinf.PRALOC_STKOFF (variable) -ida_typeinf.PRALOC_VERIFY (variable) -ida_typeinf.PRTYPE_1LINCMT (variable) -ida_typeinf.PRTYPE_1LINE (variable) -ida_typeinf.PRTYPE_COLORED (variable) -ida_typeinf.PRTYPE_CPP (variable) -ida_typeinf.PRTYPE_HEADER (variable) -ida_typeinf.PRTYPE_MAXSTR (variable) -ida_typeinf.PRTYPE_MULTI (variable) -ida_typeinf.PRTYPE_NOREGEX (variable) -ida_typeinf.PRTYPE_PRAGMA (variable) -ida_typeinf.PRTYPE_SEMI (variable) -ida_typeinf.PRTYPE_TYPE (variable) -ida_typeinf.PT_HIGH (variable) -ida_typeinf.PT_LOWER (variable) -ida_typeinf.PT_NDC (variable) -ida_typeinf.PT_PACKMASK (variable) -ida_typeinf.PT_RAWARGS (variable) -ida_typeinf.PT_RELAXED (variable) -ida_typeinf.PT_REPLACE (variable) -ida_typeinf.PT_SIL (variable) -ida_typeinf.PT_TYP (variable) -ida_typeinf.PT_VAR (variable) -ida_typeinf.RESERVED_BYTE (variable) -ida_typeinf.SC_AUTO (variable) -ida_typeinf.SC_EXT (variable) -ida_typeinf.SC_FRIEND (variable) -ida_typeinf.SC_REG (variable) -ida_typeinf.SC_STAT (variable) -ida_typeinf.SC_TYPE (variable) -ida_typeinf.SC_UNK (variable) -ida_typeinf.SC_VIRT (variable) -ida_typeinf.SETCOMP_BY_USER (variable) -ida_typeinf.SETCOMP_ONLY_ABI (variable) -ida_typeinf.SETCOMP_ONLY_ID (variable) -ida_typeinf.SETCOMP_OVERRIDE (variable) -ida_typeinf.STI_ACCHAR (variable) -ida_typeinf.STI_ACHAR (variable) -ida_typeinf.STI_ACUCHAR (variable) -ida_typeinf.STI_AEABI_LCMP (variable) -ida_typeinf.STI_AEABI_MEMCLR (variable) -ida_typeinf.STI_AEABI_MEMCPY (variable) -ida_typeinf.STI_AEABI_MEMSET (variable) -ida_typeinf.STI_AEABI_ULCMP (variable) -ida_typeinf.STI_AUCHAR (variable) -ida_typeinf.STI_COMPLEX128 (variable) -ida_typeinf.STI_COMPLEX64 (variable) -ida_typeinf.STI_DONT_USE (variable) -ida_typeinf.STI_FDELOP (variable) -ida_typeinf.STI_FPURGING (variable) -ida_typeinf.STI_MSGSEND (variable) -ida_typeinf.STI_PBYTE (variable) -ida_typeinf.STI_PCCHAR (variable) -ida_typeinf.STI_PCHAR (variable) -ida_typeinf.STI_PCUCHAR (variable) -ida_typeinf.STI_PCVOID (variable) -ida_typeinf.STI_PINT (variable) -ida_typeinf.STI_PPVOID (variable) -ida_typeinf.STI_PUCHAR (variable) -ida_typeinf.STI_PUINT (variable) -ida_typeinf.STI_PVOID (variable) -ida_typeinf.STI_RTC_CHECK_2 (variable) -ida_typeinf.STI_RTC_CHECK_4 (variable) -ida_typeinf.STI_RTC_CHECK_8 (variable) -ida_typeinf.STI_SIZE_T (variable) -ida_typeinf.STI_SSIZE_T (variable) -ida_typeinf.STRMEM_ANON (variable) -ida_typeinf.STRMEM_AUTO (variable) -ida_typeinf.STRMEM_CASTABLE_TO (variable) -ida_typeinf.STRMEM_INDEX (variable) -ida_typeinf.STRMEM_MAXS (variable) -ida_typeinf.STRMEM_MINS (variable) -ida_typeinf.STRMEM_NAME (variable) -ida_typeinf.STRMEM_OFFSET (variable) -ida_typeinf.STRMEM_SIZE (variable) -ida_typeinf.STRMEM_SKIP_EMPTY (variable) -ida_typeinf.STRMEM_TYPE (variable) -ida_typeinf.STRMEM_VFTABLE (variable) -ida_typeinf.SUDT_ALIGN (variable) -ida_typeinf.SUDT_CONST (variable) -ida_typeinf.SUDT_FAST (variable) -ida_typeinf.SUDT_GAPS (variable) -ida_typeinf.SUDT_SORT (variable) -ida_typeinf.SUDT_UNEX (variable) -ida_typeinf.SUDT_VOLATILE (variable) -ida_typeinf.TAFLD_METHOD (variable) -ida_typeinf.TAH_ALL (variable) -ida_typeinf.TAH_BYTE (variable) -ida_typeinf.TAH_HASATTRS (variable) -ida_typeinf.TA_FORMAT (variable) -ida_typeinf.TA_ORG_ARRDIM (variable) -ida_typeinf.TA_ORG_TYPEDEF (variable) -ida_typeinf.TA_VALUE_REPR (variable) -ida_typeinf.TCMP_ANYBASE (variable) -ida_typeinf.TCMP_AUTOCAST (variable) -ida_typeinf.TCMP_CALL (variable) -ida_typeinf.TCMP_DECL (variable) -ida_typeinf.TCMP_DELPTR (variable) -ida_typeinf.TCMP_EQUAL (variable) -ida_typeinf.TCMP_IGNMODS (variable) -ida_typeinf.TCMP_MANCAST (variable) -ida_typeinf.TCMP_SKIPTHIS (variable) -ida_typeinf.TERR_ALIEN_NAME (variable) -ida_typeinf.TERR_BAD_ARG (variable) -ida_typeinf.TERR_BAD_ARRAY (variable) -ida_typeinf.TERR_BAD_BASE (variable) -ida_typeinf.TERR_BAD_BF (variable) -ida_typeinf.TERR_BAD_BMASK (variable) -ida_typeinf.TERR_BAD_GAP (variable) -ida_typeinf.TERR_BAD_GROUPS (variable) -ida_typeinf.TERR_BAD_INDEX (variable) -ida_typeinf.TERR_BAD_LAYOUT (variable) -ida_typeinf.TERR_BAD_MSKVAL (variable) -ida_typeinf.TERR_BAD_NAME (variable) -ida_typeinf.TERR_BAD_OFFSET (variable) -ida_typeinf.TERR_BAD_REPR (variable) -ida_typeinf.TERR_BAD_SERIAL (variable) -ida_typeinf.TERR_BAD_SIZE (variable) -ida_typeinf.TERR_BAD_SUBTYPE (variable) -ida_typeinf.TERR_BAD_SYNC (variable) -ida_typeinf.TERR_BAD_TAH (variable) -ida_typeinf.TERR_BAD_TYPE (variable) -ida_typeinf.TERR_BAD_UNIVAR (variable) -ida_typeinf.TERR_BAD_VALUE (variable) -ida_typeinf.TERR_BAD_VARLAST (variable) -ida_typeinf.TERR_DUPNAME (variable) -ida_typeinf.TERR_ENUM_SIZE (variable) -ida_typeinf.TERR_GRP_NOEMPTY (variable) -ida_typeinf.TERR_NESTED (variable) -ida_typeinf.TERR_NOT_COMPAT (variable) -ida_typeinf.TERR_NOT_IMPL (variable) -ida_typeinf.TERR_NO_BMASK (variable) -ida_typeinf.TERR_OK (variable) -ida_typeinf.TERR_OVERLAP (variable) -ida_typeinf.TERR_SAVE_ERROR (variable) -ida_typeinf.TERR_SERIALIZE (variable) -ida_typeinf.TERR_STOCK (variable) -ida_typeinf.TERR_UNION_BF (variable) -ida_typeinf.TIL_ADD_ALREADY (variable) -ida_typeinf.TIL_ADD_FAILED (variable) -ida_typeinf.TIL_ADD_OK (variable) -ida_typeinf.TIL_ALI (variable) -ida_typeinf.TIL_ESI (variable) -ida_typeinf.TIL_MAC (variable) -ida_typeinf.TIL_MOD (variable) -ida_typeinf.TIL_ORD (variable) -ida_typeinf.TIL_SLD (variable) -ida_typeinf.TIL_STM (variable) -ida_typeinf.TIL_UNI (variable) -ida_typeinf.TIL_ZIP (variable) -ida_typeinf.TINFO_DEFINITE (variable) -ida_typeinf.TINFO_DELAYFUNC (variable) -ida_typeinf.TINFO_GUESSED (variable) -ida_typeinf.TINFO_STRICT (variable) -ida_typeinf.TVIS_CMT (variable) -ida_typeinf.TVIS_NAME (variable) -ida_typeinf.TVIS_RPTCMT (variable) -ida_typeinf.TVIS_TYPE (variable) -ida_typeinf.TVST_DEF (variable) -ida_typeinf.TVST_PRUNE (variable) -ida_typeinf.TYPE_BASE_MASK (variable) -ida_typeinf.TYPE_FLAGS_MASK (variable) -ida_typeinf.TYPE_FULL_MASK (variable) -ida_typeinf.TYPE_MODIF_MASK (variable) -ida_typeinf.TYPID_ISREF (variable) -ida_typeinf.TYPID_SHIFT (variable) -ida_typeinf.VALSTR_OPEN (variable) -ida_typeinf._BT_LAST_BASIC (variable) -ida_typeinf._wrap_cvar (class) -ida_typeinf._wrap_cvar.__getattr__ (method) -ida_typeinf._wrap_cvar.__setattr__ (method) -ida_typeinf.add_til (function) -ida_typeinf.alloc_type_ordinal (function) -ida_typeinf.alloc_type_ordinals (function) -ida_typeinf.aloc_visitor_t (class) -ida_typeinf.aloc_visitor_t.__disown__ (method) -ida_typeinf.aloc_visitor_t.__init__ (method) -ida_typeinf.aloc_visitor_t.visit_location (method) -ida_typeinf.append_abi_opts (function) -ida_typeinf.append_argloc (function) -ida_typeinf.append_tinfo_covered (function) -ida_typeinf.apply_callee_tinfo (function) -ida_typeinf.apply_cdecl (function) -ida_typeinf.apply_named_type (function) -ida_typeinf.apply_once_tinfo_and_name (function) -ida_typeinf.apply_tinfo (function) -ida_typeinf.apply_tinfo_to_stkarg (function) -ida_typeinf.apply_type (function) -ida_typeinf.argloc_t (class) -ida_typeinf.argloc_t.__eq__ (method) -ida_typeinf.argloc_t.__ge__ (method) -ida_typeinf.argloc_t.__gt__ (method) -ida_typeinf.argloc_t.__init__ (method) -ida_typeinf.argloc_t.__le__ (method) -ida_typeinf.argloc_t.__lt__ (method) -ida_typeinf.argloc_t.__ne__ (method) -ida_typeinf.argloc_t._consume_rrel (method) -ida_typeinf.argloc_t._consume_scattered (method) -ida_typeinf.argloc_t._set_badloc (method) -ida_typeinf.argloc_t._set_biggest (method) -ida_typeinf.argloc_t._set_custom (method) -ida_typeinf.argloc_t._set_ea (method) -ida_typeinf.argloc_t._set_reg1 (method) -ida_typeinf.argloc_t._set_reg2 (method) -ida_typeinf.argloc_t._set_stkoff (method) -ida_typeinf.argloc_t.advance (method) -ida_typeinf.argloc_t.align_reg_high (method) -ida_typeinf.argloc_t.align_stkoff_high (method) -ida_typeinf.argloc_t.atype (method) -ida_typeinf.argloc_t.calc_offset (method) -ida_typeinf.argloc_t.compare (method) -ida_typeinf.argloc_t.consume_rrel (method) -ida_typeinf.argloc_t.consume_scattered (method) -ida_typeinf.argloc_t.get_biggest (method) -ida_typeinf.argloc_t.get_custom (method) -ida_typeinf.argloc_t.get_ea (method) -ida_typeinf.argloc_t.get_reginfo (method) -ida_typeinf.argloc_t.get_rrel (method) -ida_typeinf.argloc_t.has_reg (method) -ida_typeinf.argloc_t.has_stkoff (method) -ida_typeinf.argloc_t.in_stack (method) -ida_typeinf.argloc_t.is_badloc (method) -ida_typeinf.argloc_t.is_custom (method) -ida_typeinf.argloc_t.is_ea (method) -ida_typeinf.argloc_t.is_fragmented (method) -ida_typeinf.argloc_t.is_mixed_scattered (method) -ida_typeinf.argloc_t.is_reg (method) -ida_typeinf.argloc_t.is_reg1 (method) -ida_typeinf.argloc_t.is_reg2 (method) -ida_typeinf.argloc_t.is_rrel (method) -ida_typeinf.argloc_t.is_scattered (method) -ida_typeinf.argloc_t.is_stkoff (method) -ida_typeinf.argloc_t.reg1 (method) -ida_typeinf.argloc_t.reg2 (method) -ida_typeinf.argloc_t.regoff (method) -ida_typeinf.argloc_t.scattered (method) -ida_typeinf.argloc_t.set_badloc (method) -ida_typeinf.argloc_t.set_ea (method) -ida_typeinf.argloc_t.set_reg1 (method) -ida_typeinf.argloc_t.set_reg2 (method) -ida_typeinf.argloc_t.set_stkoff (method) -ida_typeinf.argloc_t.stkoff (method) -ida_typeinf.argloc_t.swap (method) -ida_typeinf.argpart_t (class) -ida_typeinf.argpart_t.__init__ (method) -ida_typeinf.argpart_t.__lt__ (method) -ida_typeinf.argpart_t.bad_offset (method) -ida_typeinf.argpart_t.bad_size (method) -ida_typeinf.argpart_t.off (variable) -ida_typeinf.argpart_t.size (variable) -ida_typeinf.argpart_t.swap (method) -ida_typeinf.argpartvec_t (class) -ida_typeinf.argpartvec_t.__eq__ (method) -ida_typeinf.argpartvec_t.__getitem__ (method) -ida_typeinf.argpartvec_t.__init__ (method) -ida_typeinf.argpartvec_t.__len__ (method) -ida_typeinf.argpartvec_t.__ne__ (method) -ida_typeinf.argpartvec_t.__setitem__ (method) -ida_typeinf.argpartvec_t._del (method) -ida_typeinf.argpartvec_t.add_unique (method) -ida_typeinf.argpartvec_t.at (method) -ida_typeinf.argpartvec_t.begin (method) -ida_typeinf.argpartvec_t.capacity (method) -ida_typeinf.argpartvec_t.clear (method) -ida_typeinf.argpartvec_t.empty (method) -ida_typeinf.argpartvec_t.end (method) -ida_typeinf.argpartvec_t.erase (method) -ida_typeinf.argpartvec_t.extract (method) -ida_typeinf.argpartvec_t.find (method) -ida_typeinf.argpartvec_t.grow (method) -ida_typeinf.argpartvec_t.has (method) -ida_typeinf.argpartvec_t.inject (method) -ida_typeinf.argpartvec_t.insert (method) -ida_typeinf.argpartvec_t.pop_back (method) -ida_typeinf.argpartvec_t.push_back (method) -ida_typeinf.argpartvec_t.qclear (method) -ida_typeinf.argpartvec_t.reserve (method) -ida_typeinf.argpartvec_t.resize (method) -ida_typeinf.argpartvec_t.size (method) -ida_typeinf.argpartvec_t.swap (method) -ida_typeinf.argpartvec_t.truncate (method) -ida_typeinf.argtinfo_helper_t (class) -ida_typeinf.argtinfo_helper_t.__disown__ (method) -ida_typeinf.argtinfo_helper_t.__init__ (method) -ida_typeinf.argtinfo_helper_t.has_delay_slot (method) -ida_typeinf.argtinfo_helper_t.is_stkarg_load (method) -ida_typeinf.argtinfo_helper_t.set_op_tinfo (method) -ida_typeinf.argtinfo_helper_t.use_arg_tinfos (method) -ida_typeinf.array_type_data_t (class) -ida_typeinf.array_type_data_t.__init__ (method) -ida_typeinf.array_type_data_t.base (variable) -ida_typeinf.array_type_data_t.elem_type (variable) -ida_typeinf.array_type_data_t.nelems (variable) -ida_typeinf.array_type_data_t.swap (method) -ida_typeinf.begin_type_updating (function) -ida_typeinf.bitfield_type_data_t (class) -ida_typeinf.bitfield_type_data_t.__eq__ (method) -ida_typeinf.bitfield_type_data_t.__ge__ (method) -ida_typeinf.bitfield_type_data_t.__gt__ (method) -ida_typeinf.bitfield_type_data_t.__init__ (method) -ida_typeinf.bitfield_type_data_t.__le__ (method) -ida_typeinf.bitfield_type_data_t.__lt__ (method) -ida_typeinf.bitfield_type_data_t.__ne__ (method) -ida_typeinf.bitfield_type_data_t.compare (method) -ida_typeinf.bitfield_type_data_t.is_unsigned (variable) -ida_typeinf.bitfield_type_data_t.is_valid_bitfield (method) -ida_typeinf.bitfield_type_data_t.nbytes (variable) -ida_typeinf.bitfield_type_data_t.swap (method) -ida_typeinf.bitfield_type_data_t.width (variable) -ida_typeinf.calc_c_cpp_name (function) -ida_typeinf.calc_number_of_children (function) -ida_typeinf.calc_tinfo_gaps (function) -ida_typeinf.calc_type_size (function) -ida_typeinf.callregs_t (class) -ida_typeinf.callregs_t.__init__ (method) -ida_typeinf.callregs_t.by_slots (method) -ida_typeinf.callregs_t.fpregs (variable) -ida_typeinf.callregs_t.gpregs (variable) -ida_typeinf.callregs_t.init_regs (method) -ida_typeinf.callregs_t.nregs (variable) -ida_typeinf.callregs_t.policy (variable) -ida_typeinf.callregs_t.regcount (method) -ida_typeinf.callregs_t.reginds (method) -ida_typeinf.callregs_t.reset (method) -ida_typeinf.callregs_t.set (method) -ida_typeinf.callregs_t.swap (method) -ida_typeinf.callregs_t_regcount (function) -ida_typeinf.choose_local_tinfo (function) -ida_typeinf.choose_local_tinfo_and_delta (function) -ida_typeinf.choose_named_type (function) -ida_typeinf.clear_tinfo_t (function) -ida_typeinf.compact_til (function) -ida_typeinf.compare_tinfo (function) -ida_typeinf.const_aloc_visitor_t (class) -ida_typeinf.const_aloc_visitor_t.__disown__ (method) -ida_typeinf.const_aloc_visitor_t.__init__ (method) -ida_typeinf.const_aloc_visitor_t.visit_location (method) -ida_typeinf.convert_pt_flags_to_hti (function) -ida_typeinf.copy_named_type (function) -ida_typeinf.copy_tinfo_t (function) -ida_typeinf.create_enum_type (function) -ida_typeinf.create_numbered_type_name (function) -ida_typeinf.create_tinfo (function) -ida_typeinf.create_tinfo2 (function) -ida_typeinf.custom_data_type_info_t (class) -ida_typeinf.custom_data_type_info_t.__init__ (method) -ida_typeinf.custom_data_type_info_t.dtid (variable) -ida_typeinf.custom_data_type_info_t.fid (variable) -ida_typeinf.default_compiler (function) -ida_typeinf.del_named_type (function) -ida_typeinf.del_numbered_type (function) -ida_typeinf.del_til (function) -ida_typeinf.del_tinfo_attr (function) -ida_typeinf.del_vftable_ea (function) -ida_typeinf.deref_ptr (function) -ida_typeinf.deserialize_tinfo (function) -ida_typeinf.dstr_tinfo (function) -ida_typeinf.dump_func_type_data (function) -ida_typeinf.edm_t (class) -ida_typeinf.edm_t.__eq__ (method) -ida_typeinf.edm_t.__init__ (method) -ida_typeinf.edm_t.__ne__ (method) -ida_typeinf.edm_t.get_tid (method) -ida_typeinf.edm_t.swap (method) -ida_typeinf.edmvec_t (class) -ida_typeinf.edmvec_t.__eq__ (method) -ida_typeinf.edmvec_t.__getitem__ (method) -ida_typeinf.edmvec_t.__init__ (method) -ida_typeinf.edmvec_t.__len__ (method) -ida_typeinf.edmvec_t.__ne__ (method) -ida_typeinf.edmvec_t.__setitem__ (method) -ida_typeinf.edmvec_t._del (method) -ida_typeinf.edmvec_t.add_unique (method) -ida_typeinf.edmvec_t.at (method) -ida_typeinf.edmvec_t.begin (method) -ida_typeinf.edmvec_t.capacity (method) -ida_typeinf.edmvec_t.clear (method) -ida_typeinf.edmvec_t.empty (method) -ida_typeinf.edmvec_t.end (method) -ida_typeinf.edmvec_t.erase (method) -ida_typeinf.edmvec_t.extract (method) -ida_typeinf.edmvec_t.find (method) -ida_typeinf.edmvec_t.grow (method) -ida_typeinf.edmvec_t.has (method) -ida_typeinf.edmvec_t.inject (method) -ida_typeinf.edmvec_t.insert (method) -ida_typeinf.edmvec_t.pop_back (method) -ida_typeinf.edmvec_t.push_back (method) -ida_typeinf.edmvec_t.qclear (method) -ida_typeinf.edmvec_t.reserve (method) -ida_typeinf.edmvec_t.resize (method) -ida_typeinf.edmvec_t.size (method) -ida_typeinf.edmvec_t.swap (method) -ida_typeinf.edmvec_t.truncate (method) -ida_typeinf.enable_numbered_types (function) -ida_typeinf.end_type_updating (function) -ida_typeinf.enum_type_data_t (class) -ida_typeinf.enum_type_data_t.__init__ (method) -ida_typeinf.enum_type_data_t.add_constant (method) -ida_typeinf.enum_type_data_t.bte (variable) -ida_typeinf.enum_type_data_t.calc_mask (method) -ida_typeinf.enum_type_data_t.calc_nbytes (method) -ida_typeinf.enum_type_data_t.find_member (method) -ida_typeinf.enum_type_data_t.get_constant_group (method) -ida_typeinf.enum_type_data_t.get_enum_radix (method) -ida_typeinf.enum_type_data_t.group_sizes (variable) -ida_typeinf.enum_type_data_t.has_lzero (method) -ida_typeinf.enum_type_data_t.is_bf (method) -ida_typeinf.enum_type_data_t.is_bin (method) -ida_typeinf.enum_type_data_t.is_char (method) -ida_typeinf.enum_type_data_t.is_dec (method) -ida_typeinf.enum_type_data_t.is_group_mask_at (method) -ida_typeinf.enum_type_data_t.is_hex (method) -ida_typeinf.enum_type_data_t.is_number_signed (method) -ida_typeinf.enum_type_data_t.is_oct (method) -ida_typeinf.enum_type_data_t.is_sbin (method) -ida_typeinf.enum_type_data_t.is_shex (method) -ida_typeinf.enum_type_data_t.is_soct (method) -ida_typeinf.enum_type_data_t.is_udec (method) -ida_typeinf.enum_type_data_t.is_valid_group_sizes (method) -ida_typeinf.enum_type_data_t.set_enum_radix (method) -ida_typeinf.enum_type_data_t.set_lzero (method) -ida_typeinf.enum_type_data_t.set_nbytes (method) -ida_typeinf.enum_type_data_t.set_value_repr (method) -ida_typeinf.enum_type_data_t.store_64bit_values (method) -ida_typeinf.enum_type_data_t.swap (method) -ida_typeinf.enum_type_data_t.taenum_bits (variable) -ida_typeinf.enum_type_data_t__get_max_serial (function) -ida_typeinf.extract_argloc (function) -ida_typeinf.find_tinfo_udt_member (function) -ida_typeinf.first_named_type (function) -ida_typeinf.for_all_arglocs (function) -ida_typeinf.for_all_const_arglocs (function) -ida_typeinf.free_til (function) -ida_typeinf.func_has_stkframe_hole (function) -ida_typeinf.func_type_data_t (class) -ida_typeinf.func_type_data_t.__init__ (method) -ida_typeinf.func_type_data_t.cc (variable) -ida_typeinf.func_type_data_t.dump (method) -ida_typeinf.func_type_data_t.flags (variable) -ida_typeinf.func_type_data_t.get_call_method (method) -ida_typeinf.func_type_data_t.guess_cc (method) -ida_typeinf.func_type_data_t.is_const (method) -ida_typeinf.func_type_data_t.is_ctor (method) -ida_typeinf.func_type_data_t.is_dtor (method) -ida_typeinf.func_type_data_t.is_golang_cc (method) -ida_typeinf.func_type_data_t.is_high (method) -ida_typeinf.func_type_data_t.is_noret (method) -ida_typeinf.func_type_data_t.is_pure (method) -ida_typeinf.func_type_data_t.is_static (method) -ida_typeinf.func_type_data_t.is_swift_cc (method) -ida_typeinf.func_type_data_t.is_vararg_cc (method) -ida_typeinf.func_type_data_t.is_virtual (method) -ida_typeinf.func_type_data_t.retloc (variable) -ida_typeinf.func_type_data_t.rettype (variable) -ida_typeinf.func_type_data_t.spoiled (variable) -ida_typeinf.func_type_data_t.stkargs (variable) -ida_typeinf.func_type_data_t.swap (method) -ida_typeinf.funcarg_t (class) -ida_typeinf.funcarg_t.__eq__ (method) -ida_typeinf.funcarg_t.__init__ (method) -ida_typeinf.funcarg_t.__ne__ (method) -ida_typeinf.funcarg_t.argloc (variable) -ida_typeinf.funcarg_t.cmt (variable) -ida_typeinf.funcarg_t.flags (variable) -ida_typeinf.funcarg_t.name (variable) -ida_typeinf.funcarg_t.type (variable) -ida_typeinf.funcargvec_t (class) -ida_typeinf.funcargvec_t.__eq__ (method) -ida_typeinf.funcargvec_t.__getitem__ (method) -ida_typeinf.funcargvec_t.__init__ (method) -ida_typeinf.funcargvec_t.__len__ (method) -ida_typeinf.funcargvec_t.__ne__ (method) -ida_typeinf.funcargvec_t.__setitem__ (method) -ida_typeinf.funcargvec_t._del (method) -ida_typeinf.funcargvec_t.add_unique (method) -ida_typeinf.funcargvec_t.at (method) -ida_typeinf.funcargvec_t.begin (method) -ida_typeinf.funcargvec_t.capacity (method) -ida_typeinf.funcargvec_t.clear (method) -ida_typeinf.funcargvec_t.empty (method) -ida_typeinf.funcargvec_t.end (method) -ida_typeinf.funcargvec_t.erase (method) -ida_typeinf.funcargvec_t.extract (method) -ida_typeinf.funcargvec_t.find (method) -ida_typeinf.funcargvec_t.grow (method) -ida_typeinf.funcargvec_t.has (method) -ida_typeinf.funcargvec_t.inject (method) -ida_typeinf.funcargvec_t.insert (method) -ida_typeinf.funcargvec_t.pop_back (method) -ida_typeinf.funcargvec_t.push_back (method) -ida_typeinf.funcargvec_t.qclear (method) -ida_typeinf.funcargvec_t.reserve (method) -ida_typeinf.funcargvec_t.resize (method) -ida_typeinf.funcargvec_t.size (method) -ida_typeinf.funcargvec_t.swap (method) -ida_typeinf.funcargvec_t.truncate (method) -ida_typeinf.gcc_layout (function) -ida_typeinf.gen_decorate_name (function) -ida_typeinf.gen_use_arg_tinfos (function) -ida_typeinf.gen_use_arg_tinfos2 (function) -ida_typeinf.get_abi_name (function) -ida_typeinf.get_alias_target (function) -ida_typeinf.get_arg_addrs (function) -ida_typeinf.get_base_type (function) -ida_typeinf.get_c_header_path (function) -ida_typeinf.get_c_macros (function) -ida_typeinf.get_comp (function) -ida_typeinf.get_compiler_abbr (function) -ida_typeinf.get_compiler_name (function) -ida_typeinf.get_compilers (function) -ida_typeinf.get_enum_member_expr (function) -ida_typeinf.get_full_type (function) -ida_typeinf.get_idainfo64_by_type (function) -ida_typeinf.get_idainfo_by_type (function) -ida_typeinf.get_idati (function) -ida_typeinf.get_named_type (function) -ida_typeinf.get_named_type64 (function) -ida_typeinf.get_named_type_tid (function) -ida_typeinf.get_numbered_type (function) -ida_typeinf.get_numbered_type_name (function) -ida_typeinf.get_ordinal_count (function) -ida_typeinf.get_ordinal_from_idb_type (function) -ida_typeinf.get_ordinal_limit (function) -ida_typeinf.get_ordinal_qty (function) -ida_typeinf.get_scalar_bt (function) -ida_typeinf.get_stock_tinfo (function) -ida_typeinf.get_tid_name (function) -ida_typeinf.get_tid_ordinal (function) -ida_typeinf.get_tinfo_attr (function) -ida_typeinf.get_tinfo_attrs (function) -ida_typeinf.get_tinfo_by_flags (function) -ida_typeinf.get_tinfo_details (function) -ida_typeinf.get_tinfo_details2 (function) -ida_typeinf.get_tinfo_pdata (function) -ida_typeinf.get_tinfo_property (function) -ida_typeinf.get_tinfo_property4 (function) -ida_typeinf.get_tinfo_size (function) -ida_typeinf.get_tinfo_tid (function) -ida_typeinf.get_type_flags (function) -ida_typeinf.get_type_ordinal (function) -ida_typeinf.get_udm_by_fullname (function) -ida_typeinf.get_udm_tid (function) -ida_typeinf.get_vftable_ea (function) -ida_typeinf.get_vftable_ordinal (function) -ida_typeinf.guess_func_cc (function) -ida_typeinf.guess_tinfo (function) -ida_typeinf.ida_lowertype_helper_t (class) -ida_typeinf.ida_lowertype_helper_t.__init__ (method) -ida_typeinf.ida_lowertype_helper_t.func_has_stkframe_hole (method) -ida_typeinf.ida_lowertype_helper_t.get_func_purged_bytes (method) -ida_typeinf.idc_get_local_type (function) -ida_typeinf.idc_get_local_type_name (function) -ida_typeinf.idc_get_local_type_raw (function) -ida_typeinf.idc_get_type (function) -ida_typeinf.idc_get_type_raw (function) -ida_typeinf.idc_guess_type (function) -ida_typeinf.idc_parse_decl (function) -ida_typeinf.idc_parse_types (function) -ida_typeinf.idc_print_type (function) -ida_typeinf.idc_set_local_type (function) -ida_typeinf.import_type (function) -ida_typeinf.inf_big_arg_align (function) -ida_typeinf.inf_huge_arg_align (function) -ida_typeinf.inf_pack_stkargs (function) -ida_typeinf.is_autosync (function) -ida_typeinf.is_code_far (function) -ida_typeinf.is_comp_unsure (function) -ida_typeinf.is_data_far (function) -ida_typeinf.is_gcc (function) -ida_typeinf.is_gcc32 (function) -ida_typeinf.is_gcc64 (function) -ida_typeinf.is_golang_cc (function) -ida_typeinf.is_ordinal_name (function) -ida_typeinf.is_purging_cc (function) -ida_typeinf.is_restype_enum (function) -ida_typeinf.is_restype_struct (function) -ida_typeinf.is_restype_struni (function) -ida_typeinf.is_restype_void (function) -ida_typeinf.is_sdacl_byte (function) -ida_typeinf.is_swift_cc (function) -ida_typeinf.is_tah_byte (function) -ida_typeinf.is_type_arithmetic (function) -ida_typeinf.is_type_array (function) -ida_typeinf.is_type_bitfld (function) -ida_typeinf.is_type_bool (function) -ida_typeinf.is_type_char (function) -ida_typeinf.is_type_choosable (function) -ida_typeinf.is_type_complex (function) -ida_typeinf.is_type_const (function) -ida_typeinf.is_type_double (function) -ida_typeinf.is_type_enum (function) -ida_typeinf.is_type_ext_arithmetic (function) -ida_typeinf.is_type_ext_integral (function) -ida_typeinf.is_type_float (function) -ida_typeinf.is_type_floating (function) -ida_typeinf.is_type_func (function) -ida_typeinf.is_type_int (function) -ida_typeinf.is_type_int128 (function) -ida_typeinf.is_type_int16 (function) -ida_typeinf.is_type_int32 (function) -ida_typeinf.is_type_int64 (function) -ida_typeinf.is_type_integral (function) -ida_typeinf.is_type_ldouble (function) -ida_typeinf.is_type_paf (function) -ida_typeinf.is_type_partial (function) -ida_typeinf.is_type_ptr (function) -ida_typeinf.is_type_ptr_or_array (function) -ida_typeinf.is_type_struct (function) -ida_typeinf.is_type_struni (function) -ida_typeinf.is_type_sue (function) -ida_typeinf.is_type_tbyte (function) -ida_typeinf.is_type_typedef (function) -ida_typeinf.is_type_uchar (function) -ida_typeinf.is_type_uint (function) -ida_typeinf.is_type_uint128 (function) -ida_typeinf.is_type_uint16 (function) -ida_typeinf.is_type_uint32 (function) -ida_typeinf.is_type_uint64 (function) -ida_typeinf.is_type_union (function) -ida_typeinf.is_type_unknown (function) -ida_typeinf.is_type_void (function) -ida_typeinf.is_type_volatile (function) -ida_typeinf.is_typeid_last (function) -ida_typeinf.is_user_cc (function) -ida_typeinf.is_vararg_cc (function) -ida_typeinf.lexcompare_tinfo (function) -ida_typeinf.load_til (function) -ida_typeinf.load_til_header (function) -ida_typeinf.lower_type (function) -ida_typeinf.lowertype_helper_t (class) -ida_typeinf.lowertype_helper_t.__init__ (method) -ida_typeinf.lowertype_helper_t.func_has_stkframe_hole (method) -ida_typeinf.lowertype_helper_t.get_func_purged_bytes (method) -ida_typeinf.new_til (function) -ida_typeinf.next_named_type (function) -ida_typeinf.no_sign (variable) -ida_typeinf.optimize_argloc (function) -ida_typeinf.pack_idcobj_to_bv (function) -ida_typeinf.pack_idcobj_to_idb (function) -ida_typeinf.pack_object_to_bv (function) -ida_typeinf.pack_object_to_idb (function) -ida_typeinf.parse_decl (function) -ida_typeinf.parse_decls (function) -ida_typeinf.predicate_t (class) -ida_typeinf.predicate_t.__disown__ (method) -ida_typeinf.predicate_t.__init__ (method) -ida_typeinf.predicate_t.should_display (method) -ida_typeinf.print_argloc (function) -ida_typeinf.print_decls (function) -ida_typeinf.print_tinfo (function) -ida_typeinf.print_type (function) -ida_typeinf.ptr_type_data_t (class) -ida_typeinf.ptr_type_data_t.__eq__ (method) -ida_typeinf.ptr_type_data_t.__init__ (method) -ida_typeinf.ptr_type_data_t.__ne__ (method) -ida_typeinf.ptr_type_data_t.closure (variable) -ida_typeinf.ptr_type_data_t.delta (variable) -ida_typeinf.ptr_type_data_t.is_code_ptr (method) -ida_typeinf.ptr_type_data_t.is_shifted (method) -ida_typeinf.ptr_type_data_t.obj_type (variable) -ida_typeinf.ptr_type_data_t.parent (variable) -ida_typeinf.ptr_type_data_t.swap (method) -ida_typeinf.ptr_type_data_t.taptr_bits (variable) -ida_typeinf.read_tinfo_bitfield_value (function) -ida_typeinf.reginfovec_t (class) -ida_typeinf.reginfovec_t.__eq__ (method) -ida_typeinf.reginfovec_t.__getitem__ (method) -ida_typeinf.reginfovec_t.__init__ (method) -ida_typeinf.reginfovec_t.__len__ (method) -ida_typeinf.reginfovec_t.__ne__ (method) -ida_typeinf.reginfovec_t.__setitem__ (method) -ida_typeinf.reginfovec_t._del (method) -ida_typeinf.reginfovec_t.add_unique (method) -ida_typeinf.reginfovec_t.at (method) -ida_typeinf.reginfovec_t.begin (method) -ida_typeinf.reginfovec_t.capacity (method) -ida_typeinf.reginfovec_t.clear (method) -ida_typeinf.reginfovec_t.empty (method) -ida_typeinf.reginfovec_t.end (method) -ida_typeinf.reginfovec_t.erase (method) -ida_typeinf.reginfovec_t.extract (method) -ida_typeinf.reginfovec_t.find (method) -ida_typeinf.reginfovec_t.grow (method) -ida_typeinf.reginfovec_t.has (method) -ida_typeinf.reginfovec_t.inject (method) -ida_typeinf.reginfovec_t.insert (method) -ida_typeinf.reginfovec_t.pop_back (method) -ida_typeinf.reginfovec_t.push_back (method) -ida_typeinf.reginfovec_t.qclear (method) -ida_typeinf.reginfovec_t.reserve (method) -ida_typeinf.reginfovec_t.resize (method) -ida_typeinf.reginfovec_t.size (method) -ida_typeinf.reginfovec_t.swap (method) -ida_typeinf.reginfovec_t.truncate (method) -ida_typeinf.regobj_t (class) -ida_typeinf.regobj_t.__init__ (method) -ida_typeinf.regobj_t.regidx (variable) -ida_typeinf.regobj_t.relocate (variable) -ida_typeinf.regobj_t.size (method) -ida_typeinf.regobjs_t (class) -ida_typeinf.regobjs_t.__init__ (method) -ida_typeinf.regobjvec_t (class) -ida_typeinf.regobjvec_t.__getitem__ (method) -ida_typeinf.regobjvec_t.__init__ (method) -ida_typeinf.regobjvec_t.__len__ (method) -ida_typeinf.regobjvec_t.__setitem__ (method) -ida_typeinf.regobjvec_t.at (method) -ida_typeinf.regobjvec_t.begin (method) -ida_typeinf.regobjvec_t.capacity (method) -ida_typeinf.regobjvec_t.clear (method) -ida_typeinf.regobjvec_t.empty (method) -ida_typeinf.regobjvec_t.end (method) -ida_typeinf.regobjvec_t.erase (method) -ida_typeinf.regobjvec_t.extract (method) -ida_typeinf.regobjvec_t.grow (method) -ida_typeinf.regobjvec_t.inject (method) -ida_typeinf.regobjvec_t.insert (method) -ida_typeinf.regobjvec_t.pop_back (method) -ida_typeinf.regobjvec_t.push_back (method) -ida_typeinf.regobjvec_t.qclear (method) -ida_typeinf.regobjvec_t.reserve (method) -ida_typeinf.regobjvec_t.resize (method) -ida_typeinf.regobjvec_t.size (method) -ida_typeinf.regobjvec_t.swap (method) -ida_typeinf.regobjvec_t.truncate (method) -ida_typeinf.remove_abi_opts (function) -ida_typeinf.remove_pointer (function) -ida_typeinf.remove_tinfo_pointer (function) -ida_typeinf.replace_ordinal_typerefs (function) -ida_typeinf.resolve_typedef (function) -ida_typeinf.rrel_t (class) -ida_typeinf.rrel_t.__init__ (method) -ida_typeinf.rrel_t.off (variable) -ida_typeinf.rrel_t.reg (variable) -ida_typeinf.save_tinfo (function) -ida_typeinf.scattered_aloc_t (class) -ida_typeinf.scattered_aloc_t.__init__ (method) -ida_typeinf.score_tinfo (function) -ida_typeinf.serialize_tinfo (function) -ida_typeinf.set_abi_name (function) -ida_typeinf.set_c_header_path (function) -ida_typeinf.set_c_macros (function) -ida_typeinf.set_compiler (function) -ida_typeinf.set_compiler_id (function) -ida_typeinf.set_compiler_string (function) -ida_typeinf.set_numbered_type (function) -ida_typeinf.set_tinfo_attr (function) -ida_typeinf.set_tinfo_attrs (function) -ida_typeinf.set_tinfo_property (function) -ida_typeinf.set_tinfo_property4 (function) -ida_typeinf.set_type_alias (function) -ida_typeinf.set_type_choosable (function) -ida_typeinf.set_vftable_ea (function) -ida_typeinf.simd_info_t (class) -ida_typeinf.simd_info_t.__init__ (method) -ida_typeinf.simd_info_t.match_pattern (method) -ida_typeinf.simd_info_t.memtype (variable) -ida_typeinf.simd_info_t.name (variable) -ida_typeinf.simd_info_t.size (variable) -ida_typeinf.simd_info_t.tif (variable) -ida_typeinf.stkarg_area_info_t (class) -ida_typeinf.stkarg_area_info_t.__init__ (method) -ida_typeinf.stkarg_area_info_t.linkage_area (variable) -ida_typeinf.stkarg_area_info_t.shadow_size (variable) -ida_typeinf.stkarg_area_info_t.stkarg_offset (variable) -ida_typeinf.store_til (function) -ida_typeinf.switch_to_golang (function) -ida_typeinf.text_sink_t (class) -ida_typeinf.text_sink_t.__disown__ (method) -ida_typeinf.text_sink_t.__init__ (method) -ida_typeinf.text_sink_t._print (method) -ida_typeinf.til_symbol_t (class) -ida_typeinf.til_symbol_t.__init__ (method) -ida_typeinf.til_symbol_t.name (variable) -ida_typeinf.til_symbol_t.til (variable) -ida_typeinf.til_t (class) -ida_typeinf.til_t.__init__ (method) -ida_typeinf.til_t.base (method) -ida_typeinf.til_t.cc (variable) -ida_typeinf.til_t.desc (variable) -ida_typeinf.til_t.flags (variable) -ida_typeinf.til_t.is_dirty (method) -ida_typeinf.til_t.name (variable) -ida_typeinf.til_t.nbases (variable) -ida_typeinf.til_t.nrefs (variable) -ida_typeinf.til_t.nstreams (variable) -ida_typeinf.til_t.set_dirty (method) -ida_typeinf.til_t.streams (variable) -ida_typeinf.tinfo_errstr (function) -ida_typeinf.tinfo_t (class) -ida_typeinf.tinfo_t.ENUMBM_AUTO (variable) -ida_typeinf.tinfo_t.ENUMBM_OFF (variable) -ida_typeinf.tinfo_t.ENUMBM_ON (variable) -ida_typeinf.tinfo_t.__eq__ (method) -ida_typeinf.tinfo_t.__ge__ (method) -ida_typeinf.tinfo_t.__gt__ (method) -ida_typeinf.tinfo_t.__init__ (method) -ida_typeinf.tinfo_t.__le__ (method) -ida_typeinf.tinfo_t.__lt__ (method) -ida_typeinf.tinfo_t.__ne__ (method) -ida_typeinf.tinfo_t.__str__ (method) -ida_typeinf.tinfo_t._print (method) -ida_typeinf.tinfo_t.add_edm (method) -ida_typeinf.tinfo_t.add_udm (method) -ida_typeinf.tinfo_t.append_covered (method) -ida_typeinf.tinfo_t.calc_gaps (method) -ida_typeinf.tinfo_t.calc_purged_bytes (method) -ida_typeinf.tinfo_t.calc_score (method) -ida_typeinf.tinfo_t.calc_udt_aligns (method) -ida_typeinf.tinfo_t.change_sign (method) -ida_typeinf.tinfo_t.clear (method) -ida_typeinf.tinfo_t.clr_const (method) -ida_typeinf.tinfo_t.clr_const_volatile (method) -ida_typeinf.tinfo_t.clr_decl_const_volatile (method) -ida_typeinf.tinfo_t.clr_volatile (method) -ida_typeinf.tinfo_t.compare (method) -ida_typeinf.tinfo_t.compare_with (method) -ida_typeinf.tinfo_t.convert_array_to_ptr (method) -ida_typeinf.tinfo_t.copy (method) -ida_typeinf.tinfo_t.copy_type (method) -ida_typeinf.tinfo_t.create_array (method) -ida_typeinf.tinfo_t.create_bitfield (method) -ida_typeinf.tinfo_t.create_enum (method) -ida_typeinf.tinfo_t.create_forward_decl (method) -ida_typeinf.tinfo_t.create_func (method) -ida_typeinf.tinfo_t.create_ptr (method) -ida_typeinf.tinfo_t.create_simple_type (method) -ida_typeinf.tinfo_t.create_typedef (method) -ida_typeinf.tinfo_t.create_udt (method) -ida_typeinf.tinfo_t.del_attr (method) -ida_typeinf.tinfo_t.del_attrs (method) -ida_typeinf.tinfo_t.del_edm (method) -ida_typeinf.tinfo_t.del_edms (method) -ida_typeinf.tinfo_t.del_udm (method) -ida_typeinf.tinfo_t.del_udms (method) -ida_typeinf.tinfo_t.deserialize (method) -ida_typeinf.tinfo_t.dstr (method) -ida_typeinf.tinfo_t.edit_array (method) -ida_typeinf.tinfo_t.edit_bitfield (method) -ida_typeinf.tinfo_t.edit_edm (method) -ida_typeinf.tinfo_t.edit_enum (method) -ida_typeinf.tinfo_t.edit_func (method) -ida_typeinf.tinfo_t.edit_ptr (method) -ida_typeinf.tinfo_t.edit_udt (method) -ida_typeinf.tinfo_t.empty (method) -ida_typeinf.tinfo_t.equals_to (method) -ida_typeinf.tinfo_t.expand_udt (method) -ida_typeinf.tinfo_t.find_edm (method) -ida_typeinf.tinfo_t.find_udm (method) -ida_typeinf.tinfo_t.force_tid (method) -ida_typeinf.tinfo_t.get_alias_target (method) -ida_typeinf.tinfo_t.get_array_details (method) -ida_typeinf.tinfo_t.get_array_element (method) -ida_typeinf.tinfo_t.get_array_nelems (method) -ida_typeinf.tinfo_t.get_attr (method) -ida_typeinf.tinfo_t.get_attrs (method) -ida_typeinf.tinfo_t.get_bit_buckets (method) -ida_typeinf.tinfo_t.get_bitfield_details (method) -ida_typeinf.tinfo_t.get_declalign (method) -ida_typeinf.tinfo_t.get_decltype (method) -ida_typeinf.tinfo_t.get_edm (method) -ida_typeinf.tinfo_t.get_edm_by_tid (method) -ida_typeinf.tinfo_t.get_enum_base_type (method) -ida_typeinf.tinfo_t.get_enum_details (method) -ida_typeinf.tinfo_t.get_enum_radix (method) -ida_typeinf.tinfo_t.get_final_element (method) -ida_typeinf.tinfo_t.get_final_ordinal (method) -ida_typeinf.tinfo_t.get_final_type_name (method) -ida_typeinf.tinfo_t.get_forward_type (method) -ida_typeinf.tinfo_t.get_func_details (method) -ida_typeinf.tinfo_t.get_innermost_udm (method) -ida_typeinf.tinfo_t.get_methods (method) -ida_typeinf.tinfo_t.get_modifiers (method) -ida_typeinf.tinfo_t.get_named_type (method) -ida_typeinf.tinfo_t.get_nargs (method) -ida_typeinf.tinfo_t.get_next_type_name (method) -ida_typeinf.tinfo_t.get_nice_type_name (method) -ida_typeinf.tinfo_t.get_nth_arg (method) -ida_typeinf.tinfo_t.get_numbered_type (method) -ida_typeinf.tinfo_t.get_onemember_type (method) -ida_typeinf.tinfo_t.get_ordinal (method) -ida_typeinf.tinfo_t.get_pointed_object (method) -ida_typeinf.tinfo_t.get_ptr_details (method) -ida_typeinf.tinfo_t.get_ptrarr_object (method) -ida_typeinf.tinfo_t.get_ptrarr_objsize (method) -ida_typeinf.tinfo_t.get_realtype (method) -ida_typeinf.tinfo_t.get_rettype (method) -ida_typeinf.tinfo_t.get_sign (method) -ida_typeinf.tinfo_t.get_size (method) -ida_typeinf.tinfo_t.get_stock (method) -ida_typeinf.tinfo_t.get_tid (method) -ida_typeinf.tinfo_t.get_til (method) -ida_typeinf.tinfo_t.get_type_by_edm_name (method) -ida_typeinf.tinfo_t.get_type_by_tid (method) -ida_typeinf.tinfo_t.get_type_cmt (method) -ida_typeinf.tinfo_t.get_type_name (method) -ida_typeinf.tinfo_t.get_type_rptcmt (method) -ida_typeinf.tinfo_t.get_udm_by_tid (method) -ida_typeinf.tinfo_t.get_udm_tid (method) -ida_typeinf.tinfo_t.get_udt_details (method) -ida_typeinf.tinfo_t.get_udt_nmembers (method) -ida_typeinf.tinfo_t.get_unpadded_size (method) -ida_typeinf.tinfo_t.has_details (method) -ida_typeinf.tinfo_t.has_union (method) -ida_typeinf.tinfo_t.has_vftable (method) -ida_typeinf.tinfo_t.is_aliased (method) -ida_typeinf.tinfo_t.is_anonymous_udt (method) -ida_typeinf.tinfo_t.is_arithmetic (method) -ida_typeinf.tinfo_t.is_array (method) -ida_typeinf.tinfo_t.is_bitfield (method) -ida_typeinf.tinfo_t.is_bitmask_enum (method) -ida_typeinf.tinfo_t.is_bool (method) -ida_typeinf.tinfo_t.is_castable_to (method) -ida_typeinf.tinfo_t.is_char (method) -ida_typeinf.tinfo_t.is_complex (method) -ida_typeinf.tinfo_t.is_const (method) -ida_typeinf.tinfo_t.is_correct (method) -ida_typeinf.tinfo_t.is_decl_array (method) -ida_typeinf.tinfo_t.is_decl_bitfield (method) -ida_typeinf.tinfo_t.is_decl_bool (method) -ida_typeinf.tinfo_t.is_decl_char (method) -ida_typeinf.tinfo_t.is_decl_complex (method) -ida_typeinf.tinfo_t.is_decl_const (method) -ida_typeinf.tinfo_t.is_decl_double (method) -ida_typeinf.tinfo_t.is_decl_enum (method) -ida_typeinf.tinfo_t.is_decl_float (method) -ida_typeinf.tinfo_t.is_decl_floating (method) -ida_typeinf.tinfo_t.is_decl_func (method) -ida_typeinf.tinfo_t.is_decl_int (method) -ida_typeinf.tinfo_t.is_decl_int128 (method) -ida_typeinf.tinfo_t.is_decl_int16 (method) -ida_typeinf.tinfo_t.is_decl_int32 (method) -ida_typeinf.tinfo_t.is_decl_int64 (method) -ida_typeinf.tinfo_t.is_decl_last (method) -ida_typeinf.tinfo_t.is_decl_ldouble (method) -ida_typeinf.tinfo_t.is_decl_paf (method) -ida_typeinf.tinfo_t.is_decl_partial (method) -ida_typeinf.tinfo_t.is_decl_ptr (method) -ida_typeinf.tinfo_t.is_decl_struct (method) -ida_typeinf.tinfo_t.is_decl_sue (method) -ida_typeinf.tinfo_t.is_decl_tbyte (method) -ida_typeinf.tinfo_t.is_decl_typedef (method) -ida_typeinf.tinfo_t.is_decl_uchar (method) -ida_typeinf.tinfo_t.is_decl_udt (method) -ida_typeinf.tinfo_t.is_decl_uint (method) -ida_typeinf.tinfo_t.is_decl_uint128 (method) -ida_typeinf.tinfo_t.is_decl_uint16 (method) -ida_typeinf.tinfo_t.is_decl_uint32 (method) -ida_typeinf.tinfo_t.is_decl_uint64 (method) -ida_typeinf.tinfo_t.is_decl_union (method) -ida_typeinf.tinfo_t.is_decl_unknown (method) -ida_typeinf.tinfo_t.is_decl_void (method) -ida_typeinf.tinfo_t.is_decl_volatile (method) -ida_typeinf.tinfo_t.is_double (method) -ida_typeinf.tinfo_t.is_empty_udt (method) -ida_typeinf.tinfo_t.is_enum (method) -ida_typeinf.tinfo_t.is_ext_arithmetic (method) -ida_typeinf.tinfo_t.is_ext_integral (method) -ida_typeinf.tinfo_t.is_float (method) -ida_typeinf.tinfo_t.is_floating (method) -ida_typeinf.tinfo_t.is_forward_decl (method) -ida_typeinf.tinfo_t.is_forward_enum (method) -ida_typeinf.tinfo_t.is_forward_struct (method) -ida_typeinf.tinfo_t.is_forward_union (method) -ida_typeinf.tinfo_t.is_from_subtil (method) -ida_typeinf.tinfo_t.is_func (method) -ida_typeinf.tinfo_t.is_funcptr (method) -ida_typeinf.tinfo_t.is_high_func (method) -ida_typeinf.tinfo_t.is_int (method) -ida_typeinf.tinfo_t.is_int128 (method) -ida_typeinf.tinfo_t.is_int16 (method) -ida_typeinf.tinfo_t.is_int32 (method) -ida_typeinf.tinfo_t.is_int64 (method) -ida_typeinf.tinfo_t.is_integral (method) -ida_typeinf.tinfo_t.is_ldouble (method) -ida_typeinf.tinfo_t.is_manually_castable_to (method) -ida_typeinf.tinfo_t.is_one_fpval (method) -ida_typeinf.tinfo_t.is_paf (method) -ida_typeinf.tinfo_t.is_partial (method) -ida_typeinf.tinfo_t.is_ptr (method) -ida_typeinf.tinfo_t.is_ptr_or_array (method) -ida_typeinf.tinfo_t.is_purging_cc (method) -ida_typeinf.tinfo_t.is_pvoid (method) -ida_typeinf.tinfo_t.is_scalar (method) -ida_typeinf.tinfo_t.is_shifted_ptr (method) -ida_typeinf.tinfo_t.is_signed (method) -ida_typeinf.tinfo_t.is_small_udt (method) -ida_typeinf.tinfo_t.is_sse_type (method) -ida_typeinf.tinfo_t.is_struct (method) -ida_typeinf.tinfo_t.is_sue (method) -ida_typeinf.tinfo_t.is_tbyte (method) -ida_typeinf.tinfo_t.is_typedef (method) -ida_typeinf.tinfo_t.is_typeref (method) -ida_typeinf.tinfo_t.is_uchar (method) -ida_typeinf.tinfo_t.is_udt (method) -ida_typeinf.tinfo_t.is_uint (method) -ida_typeinf.tinfo_t.is_uint128 (method) -ida_typeinf.tinfo_t.is_uint16 (method) -ida_typeinf.tinfo_t.is_uint32 (method) -ida_typeinf.tinfo_t.is_uint64 (method) -ida_typeinf.tinfo_t.is_union (method) -ida_typeinf.tinfo_t.is_unknown (method) -ida_typeinf.tinfo_t.is_unsigned (method) -ida_typeinf.tinfo_t.is_user_cc (method) -ida_typeinf.tinfo_t.is_vararg_cc (method) -ida_typeinf.tinfo_t.is_varmember (method) -ida_typeinf.tinfo_t.is_varstruct (method) -ida_typeinf.tinfo_t.is_vftable (method) -ida_typeinf.tinfo_t.is_void (method) -ida_typeinf.tinfo_t.is_volatile (method) -ida_typeinf.tinfo_t.is_well_defined (method) -ida_typeinf.tinfo_t.parse (method) -ida_typeinf.tinfo_t.present (method) -ida_typeinf.tinfo_t.read_bitfield_value (method) -ida_typeinf.tinfo_t.remove_ptr_or_array (method) -ida_typeinf.tinfo_t.rename_edm (method) -ida_typeinf.tinfo_t.rename_type (method) -ida_typeinf.tinfo_t.rename_udm (method) -ida_typeinf.tinfo_t.requires_qualifier (method) -ida_typeinf.tinfo_t.save_type (method) -ida_typeinf.tinfo_t.serialize (method) -ida_typeinf.tinfo_t.set_attr (method) -ida_typeinf.tinfo_t.set_attrs (method) -ida_typeinf.tinfo_t.set_const (method) -ida_typeinf.tinfo_t.set_declalign (method) -ida_typeinf.tinfo_t.set_edm_cmt (method) -ida_typeinf.tinfo_t.set_enum_is_bitmask (method) -ida_typeinf.tinfo_t.set_enum_repr (method) -ida_typeinf.tinfo_t.set_enum_sign (method) -ida_typeinf.tinfo_t.set_enum_width (method) -ida_typeinf.tinfo_t.set_methods (method) -ida_typeinf.tinfo_t.set_modifiers (method) -ida_typeinf.tinfo_t.set_named_type (method) -ida_typeinf.tinfo_t.set_numbered_type (method) -ida_typeinf.tinfo_t.set_symbol_type (method) -ida_typeinf.tinfo_t.set_type_alias (method) -ida_typeinf.tinfo_t.set_type_alignment (method) -ida_typeinf.tinfo_t.set_type_cmt (method) -ida_typeinf.tinfo_t.set_udm_cmt (method) -ida_typeinf.tinfo_t.set_udm_repr (method) -ida_typeinf.tinfo_t.set_udm_type (method) -ida_typeinf.tinfo_t.set_udt_alignment (method) -ida_typeinf.tinfo_t.set_udt_pack (method) -ida_typeinf.tinfo_t.set_volatile (method) -ida_typeinf.tinfo_t.swap (method) -ida_typeinf.tinfo_t.write_bitfield_value (method) -ida_typeinf.tinfo_t_get_stock (function) -ida_typeinf.tinfo_visitor_t (class) -ida_typeinf.tinfo_visitor_t.__disown__ (method) -ida_typeinf.tinfo_visitor_t.__init__ (method) -ida_typeinf.tinfo_visitor_t.apply_to (method) -ida_typeinf.tinfo_visitor_t.prune_now (method) -ida_typeinf.tinfo_visitor_t.state (variable) -ida_typeinf.tinfo_visitor_t.visit_type (method) -ida_typeinf.type_attr_t (class) -ida_typeinf.type_attr_t.__ge__ (method) -ida_typeinf.type_attr_t.__init__ (method) -ida_typeinf.type_attr_t.__lt__ (method) -ida_typeinf.type_attr_t.key (variable) -ida_typeinf.type_attr_t.value (variable) -ida_typeinf.type_attrs_t (class) -ida_typeinf.type_attrs_t.__getitem__ (method) -ida_typeinf.type_attrs_t.__init__ (method) -ida_typeinf.type_attrs_t.__len__ (method) -ida_typeinf.type_attrs_t.__setitem__ (method) -ida_typeinf.type_attrs_t.at (method) -ida_typeinf.type_attrs_t.begin (method) -ida_typeinf.type_attrs_t.capacity (method) -ida_typeinf.type_attrs_t.clear (method) -ida_typeinf.type_attrs_t.empty (method) -ida_typeinf.type_attrs_t.end (method) -ida_typeinf.type_attrs_t.erase (method) -ida_typeinf.type_attrs_t.extract (method) -ida_typeinf.type_attrs_t.grow (method) -ida_typeinf.type_attrs_t.inject (method) -ida_typeinf.type_attrs_t.insert (method) -ida_typeinf.type_attrs_t.pop_back (method) -ida_typeinf.type_attrs_t.push_back (method) -ida_typeinf.type_attrs_t.qclear (method) -ida_typeinf.type_attrs_t.reserve (method) -ida_typeinf.type_attrs_t.resize (method) -ida_typeinf.type_attrs_t.size (method) -ida_typeinf.type_attrs_t.swap (method) -ida_typeinf.type_attrs_t.truncate (method) -ida_typeinf.type_mods_t (class) -ida_typeinf.type_mods_t.__init__ (method) -ida_typeinf.type_mods_t.clear (method) -ida_typeinf.type_mods_t.cmt (variable) -ida_typeinf.type_mods_t.flags (variable) -ida_typeinf.type_mods_t.has_cmt (method) -ida_typeinf.type_mods_t.has_info (method) -ida_typeinf.type_mods_t.has_name (method) -ida_typeinf.type_mods_t.has_type (method) -ida_typeinf.type_mods_t.is_rptcmt (method) -ida_typeinf.type_mods_t.name (variable) -ida_typeinf.type_mods_t.set_new_cmt (method) -ida_typeinf.type_mods_t.set_new_name (method) -ida_typeinf.type_mods_t.set_new_type (method) -ida_typeinf.type_mods_t.type (variable) -ida_typeinf.type_signed (variable) -ida_typeinf.type_unsigned (variable) -ida_typeinf.typedef_type_data_t (class) -ida_typeinf.typedef_type_data_t.__init__ (method) -ida_typeinf.typedef_type_data_t.is_ordref (variable) -ida_typeinf.typedef_type_data_t.name (variable) -ida_typeinf.typedef_type_data_t.ordinal (variable) -ida_typeinf.typedef_type_data_t.resolve (variable) -ida_typeinf.typedef_type_data_t.swap (method) -ida_typeinf.typedef_type_data_t.til (variable) -ida_typeinf.udm_t (class) -ida_typeinf.udm_t.__eq__ (method) -ida_typeinf.udm_t.__init__ (method) -ida_typeinf.udm_t.__lt__ (method) -ida_typeinf.udm_t.__ne__ (method) -ida_typeinf.udm_t.begin (method) -ida_typeinf.udm_t.can_be_dtor (method) -ida_typeinf.udm_t.can_rename (method) -ida_typeinf.udm_t.clr_baseclass (method) -ida_typeinf.udm_t.clr_method (method) -ida_typeinf.udm_t.clr_unaligned (method) -ida_typeinf.udm_t.clr_vftable (method) -ida_typeinf.udm_t.clr_virtbase (method) -ida_typeinf.udm_t.cmt (variable) -ida_typeinf.udm_t.effalign (variable) -ida_typeinf.udm_t.end (method) -ida_typeinf.udm_t.fda (variable) -ida_typeinf.udm_t.is_anonymous_udm (method) -ida_typeinf.udm_t.is_baseclass (method) -ida_typeinf.udm_t.is_bitfield (method) -ida_typeinf.udm_t.is_gap (method) -ida_typeinf.udm_t.is_method (method) -ida_typeinf.udm_t.is_regcmt (method) -ida_typeinf.udm_t.is_unaligned (method) -ida_typeinf.udm_t.is_vftable (method) -ida_typeinf.udm_t.is_virtbase (method) -ida_typeinf.udm_t.is_zero_bitfield (method) -ida_typeinf.udm_t.make_gap (method) -ida_typeinf.udm_t.name (variable) -ida_typeinf.udm_t.offset (variable) -ida_typeinf.udm_t.repr (variable) -ida_typeinf.udm_t.set_baseclass (method) -ida_typeinf.udm_t.set_method (method) -ida_typeinf.udm_t.set_regcmt (method) -ida_typeinf.udm_t.set_unaligned (method) -ida_typeinf.udm_t.set_value_repr (method) -ida_typeinf.udm_t.set_vftable (method) -ida_typeinf.udm_t.set_virtbase (method) -ida_typeinf.udm_t.size (variable) -ida_typeinf.udm_t.swap (method) -ida_typeinf.udm_t.tafld_bits (variable) -ida_typeinf.udm_t.type (variable) -ida_typeinf.udm_t__make_gap (function) -ida_typeinf.udt_type_data_t (class) -ida_typeinf.udt_type_data_t.__init__ (method) -ida_typeinf.udt_type_data_t.effalign (variable) -ida_typeinf.udt_type_data_t.find_member (method) -ida_typeinf.udt_type_data_t.get_best_fit_member (method) -ida_typeinf.udt_type_data_t.is_cppobj (method) -ida_typeinf.udt_type_data_t.is_last_baseclass (method) -ida_typeinf.udt_type_data_t.is_msstruct (method) -ida_typeinf.udt_type_data_t.is_unaligned (method) -ida_typeinf.udt_type_data_t.is_union (variable) -ida_typeinf.udt_type_data_t.is_vftable (method) -ida_typeinf.udt_type_data_t.pack (variable) -ida_typeinf.udt_type_data_t.sda (variable) -ida_typeinf.udt_type_data_t.set_vftable (method) -ida_typeinf.udt_type_data_t.swap (method) -ida_typeinf.udt_type_data_t.taudt_bits (variable) -ida_typeinf.udt_type_data_t.total_size (variable) -ida_typeinf.udt_type_data_t.unpadded_size (variable) -ida_typeinf.udt_type_data_t.version (variable) -ida_typeinf.udt_type_data_t__find_member (function) -ida_typeinf.udt_type_data_t__get_best_fit_member (function) -ida_typeinf.udtmembervec_t (class) -ida_typeinf.udtmembervec_t.__init__ (method) -ida_typeinf.udtmembervec_template_t (class) -ida_typeinf.udtmembervec_template_t.__eq__ (method) -ida_typeinf.udtmembervec_template_t.__getitem__ (method) -ida_typeinf.udtmembervec_template_t.__init__ (method) -ida_typeinf.udtmembervec_template_t.__len__ (method) -ida_typeinf.udtmembervec_template_t.__ne__ (method) -ida_typeinf.udtmembervec_template_t.__setitem__ (method) -ida_typeinf.udtmembervec_template_t._del (method) -ida_typeinf.udtmembervec_template_t.add_unique (method) -ida_typeinf.udtmembervec_template_t.at (method) -ida_typeinf.udtmembervec_template_t.begin (method) -ida_typeinf.udtmembervec_template_t.capacity (method) -ida_typeinf.udtmembervec_template_t.clear (method) -ida_typeinf.udtmembervec_template_t.empty (method) -ida_typeinf.udtmembervec_template_t.end (method) -ida_typeinf.udtmembervec_template_t.erase (method) -ida_typeinf.udtmembervec_template_t.extract (method) -ida_typeinf.udtmembervec_template_t.find (method) -ida_typeinf.udtmembervec_template_t.grow (method) -ida_typeinf.udtmembervec_template_t.has (method) -ida_typeinf.udtmembervec_template_t.inject (method) -ida_typeinf.udtmembervec_template_t.insert (method) -ida_typeinf.udtmembervec_template_t.pop_back (method) -ida_typeinf.udtmembervec_template_t.push_back (method) -ida_typeinf.udtmembervec_template_t.qclear (method) -ida_typeinf.udtmembervec_template_t.reserve (method) -ida_typeinf.udtmembervec_template_t.resize (method) -ida_typeinf.udtmembervec_template_t.size (method) -ida_typeinf.udtmembervec_template_t.swap (method) -ida_typeinf.udtmembervec_template_t.truncate (method) -ida_typeinf.unpack_idcobj_from_bv (function) -ida_typeinf.unpack_idcobj_from_idb (function) -ida_typeinf.unpack_object_from_bv (function) -ida_typeinf.unpack_object_from_idb (function) -ida_typeinf.use_golang_cc (function) -ida_typeinf.valstr_t (class) -ida_typeinf.valstr_t.__init__ (method) -ida_typeinf.valstr_t.info (variable) -ida_typeinf.valstr_t.length (variable) -ida_typeinf.valstr_t.members (variable) -ida_typeinf.valstr_t.oneline (variable) -ida_typeinf.valstr_t.props (variable) -ida_typeinf.valstrs_t (class) -ida_typeinf.valstrs_t.__init__ (method) -ida_typeinf.valstrvec_t (class) -ida_typeinf.valstrvec_t.__getitem__ (method) -ida_typeinf.valstrvec_t.__init__ (method) -ida_typeinf.valstrvec_t.__len__ (method) -ida_typeinf.valstrvec_t.__setitem__ (method) -ida_typeinf.valstrvec_t.at (method) -ida_typeinf.valstrvec_t.begin (method) -ida_typeinf.valstrvec_t.capacity (method) -ida_typeinf.valstrvec_t.clear (method) -ida_typeinf.valstrvec_t.empty (method) -ida_typeinf.valstrvec_t.end (method) -ida_typeinf.valstrvec_t.erase (method) -ida_typeinf.valstrvec_t.extract (method) -ida_typeinf.valstrvec_t.grow (method) -ida_typeinf.valstrvec_t.inject (method) -ida_typeinf.valstrvec_t.insert (method) -ida_typeinf.valstrvec_t.pop_back (method) -ida_typeinf.valstrvec_t.push_back (method) -ida_typeinf.valstrvec_t.qclear (method) -ida_typeinf.valstrvec_t.reserve (method) -ida_typeinf.valstrvec_t.resize (method) -ida_typeinf.valstrvec_t.size (method) -ida_typeinf.valstrvec_t.swap (method) -ida_typeinf.valstrvec_t.truncate (method) -ida_typeinf.value_repr_t (class) -ida_typeinf.value_repr_t.__init__ (method) -ida_typeinf.value_repr_t.__str__ (method) -ida_typeinf.value_repr_t._print (method) -ida_typeinf.value_repr_t.ap (variable) -ida_typeinf.value_repr_t.cd (variable) -ida_typeinf.value_repr_t.clear (method) -ida_typeinf.value_repr_t.delta (variable) -ida_typeinf.value_repr_t.empty (method) -ida_typeinf.value_repr_t.from_opinfo (method) -ida_typeinf.value_repr_t.get_vtype (method) -ida_typeinf.value_repr_t.has_lzeroes (method) -ida_typeinf.value_repr_t.has_tabform (method) -ida_typeinf.value_repr_t.init_ap (method) -ida_typeinf.value_repr_t.is_custom (method) -ida_typeinf.value_repr_t.is_enum (method) -ida_typeinf.value_repr_t.is_offset (method) -ida_typeinf.value_repr_t.is_signed (method) -ida_typeinf.value_repr_t.is_strlit (method) -ida_typeinf.value_repr_t.is_stroff (method) -ida_typeinf.value_repr_t.is_typref (method) -ida_typeinf.value_repr_t.parse_value_repr (method) -ida_typeinf.value_repr_t.ri (variable) -ida_typeinf.value_repr_t.set_ap (method) -ida_typeinf.value_repr_t.set_lzeroes (method) -ida_typeinf.value_repr_t.set_signed (method) -ida_typeinf.value_repr_t.set_tabform (method) -ida_typeinf.value_repr_t.set_vtype (method) -ida_typeinf.value_repr_t.strtype (variable) -ida_typeinf.value_repr_t.swap (method) -ida_typeinf.value_repr_t.type_ordinal (variable) -ida_typeinf.value_repr_t__from_opinfo (function) -ida_typeinf.value_repr_t__print_ (function) -ida_typeinf.verify_argloc (function) -ida_typeinf.verify_tinfo (function) -ida_typeinf.visit_subtypes (function) -ida_typeinf.write_tinfo_bitfield_value (function) -ida_ua (module) -ida_ua.FCBF_CONT (variable) -ida_ua.FCBF_DELIM (variable) -ida_ua.FCBF_ERR_REPL (variable) -ida_ua.FCBF_FF_LIT (variable) -ida_ua.INSN_64BIT (variable) -ida_ua.INSN_MACRO (variable) -ida_ua.INSN_MODMAC (variable) -ida_ua.OF_NO_BASE_DISP (variable) -ida_ua.OF_NUMBER (variable) -ida_ua.OF_OUTER_DISP (variable) -ida_ua.OF_SHOW (variable) -ida_ua.OOFS_IFSIGN (variable) -ida_ua.OOFS_NEEDSIGN (variable) -ida_ua.OOFS_NOSIGN (variable) -ida_ua.OOFW_16 (variable) -ida_ua.OOFW_24 (variable) -ida_ua.OOFW_32 (variable) -ida_ua.OOFW_64 (variable) -ida_ua.OOFW_8 (variable) -ida_ua.OOFW_IMM (variable) -ida_ua.OOF_ADDR (variable) -ida_ua.OOF_ANYSERIAL (variable) -ida_ua.OOF_LZEROES (variable) -ida_ua.OOF_NOBNOT (variable) -ida_ua.OOF_NO_LZEROES (variable) -ida_ua.OOF_NUMBER (variable) -ida_ua.OOF_OUTER (variable) -ida_ua.OOF_SIGNED (variable) -ida_ua.OOF_SIGNMASK (variable) -ida_ua.OOF_SPACES (variable) -ida_ua.OOF_WIDTHMASK (variable) -ida_ua.OOF_ZSTROFF (variable) -ida_ua.PACK_FORM_DEF (variable) -ida_ua.STKVAR_VALID_SIZE (variable) -ida_ua.calc_dataseg (function) -ida_ua.can_decode (function) -ida_ua.construct_macro (function) -ida_ua.construct_macro2 (function) -ida_ua.create_insn (function) -ida_ua.create_outctx (function) -ida_ua.decode_insn (function) -ida_ua.decode_preceding_insn (function) -ida_ua.decode_prev_insn (function) -ida_ua.dt_bitfild (variable) -ida_ua.dt_byte (variable) -ida_ua.dt_byte16 (variable) -ida_ua.dt_byte32 (variable) -ida_ua.dt_byte64 (variable) -ida_ua.dt_code (variable) -ida_ua.dt_double (variable) -ida_ua.dt_dword (variable) -ida_ua.dt_float (variable) -ida_ua.dt_fword (variable) -ida_ua.dt_half (variable) -ida_ua.dt_ldbl (variable) -ida_ua.dt_packreal (variable) -ida_ua.dt_qword (variable) -ida_ua.dt_string (variable) -ida_ua.dt_tbyte (variable) -ida_ua.dt_unicode (variable) -ida_ua.dt_void (variable) -ida_ua.dt_word (variable) -ida_ua.get_dtype_by_size (function) -ida_ua.get_dtype_flag (function) -ida_ua.get_dtype_size (function) -ida_ua.get_immvals (function) -ida_ua.get_lookback (function) -ida_ua.get_printable_immvals (function) -ida_ua.insn_add_cref (function) -ida_ua.insn_add_dref (function) -ida_ua.insn_add_off_drefs (function) -ida_ua.insn_create_stkvar (function) -ida_ua.insn_t (class) -ida_ua.insn_t.__get_auxpref__ (method) -ida_ua.insn_t.__get_operand__ (method) -ida_ua.insn_t.__get_ops__ (method) -ida_ua.insn_t.__getitem__ (method) -ida_ua.insn_t.__init__ (method) -ida_ua.insn_t.__iter__ (method) -ida_ua.insn_t.__set_auxpref__ (method) -ida_ua.insn_t.add_cref (method) -ida_ua.insn_t.add_dref (method) -ida_ua.insn_t.add_off_drefs (method) -ida_ua.insn_t.assign (method) -ida_ua.insn_t.auxpref (variable) -ida_ua.insn_t.create_op_data (method) -ida_ua.insn_t.create_stkvar (method) -ida_ua.insn_t.cs (variable) -ida_ua.insn_t.ea (variable) -ida_ua.insn_t.flags (variable) -ida_ua.insn_t.get_canon_feature (method) -ida_ua.insn_t.get_canon_mnem (method) -ida_ua.insn_t.get_next_byte (method) -ida_ua.insn_t.get_next_dword (method) -ida_ua.insn_t.get_next_qword (method) -ida_ua.insn_t.get_next_word (method) -ida_ua.insn_t.insnpref (variable) -ida_ua.insn_t.ip (variable) -ida_ua.insn_t.is_64bit (method) -ida_ua.insn_t.is_canon_insn (method) -ida_ua.insn_t.is_macro (method) -ida_ua.insn_t.itype (variable) -ida_ua.insn_t.ops (variable) -ida_ua.insn_t.segpref (variable) -ida_ua.insn_t.size (variable) -ida_ua.insn_t__from_ptrval__ (function) -ida_ua.is_floating_dtype (function) -ida_ua.macro_constructor_t (class) -ida_ua.macro_constructor_t.__disown__ (method) -ida_ua.macro_constructor_t.__init__ (method) -ida_ua.macro_constructor_t.build_macro (method) -ida_ua.map_code_ea (function) -ida_ua.map_data_ea (function) -ida_ua.map_ea (function) -ida_ua.o_displ (variable) -ida_ua.o_far (variable) -ida_ua.o_idpspec0 (variable) -ida_ua.o_idpspec1 (variable) -ida_ua.o_idpspec2 (variable) -ida_ua.o_idpspec3 (variable) -ida_ua.o_idpspec4 (variable) -ida_ua.o_idpspec5 (variable) -ida_ua.o_imm (variable) -ida_ua.o_mem (variable) -ida_ua.o_near (variable) -ida_ua.o_phrase (variable) -ida_ua.o_reg (variable) -ida_ua.o_void (variable) -ida_ua.op_t (class) -ida_ua.op_t.__get_addr__ (method) -ida_ua.op_t.__get_reg_phrase__ (method) -ida_ua.op_t.__get_specval__ (method) -ida_ua.op_t.__get_value64__ (method) -ida_ua.op_t.__get_value__ (method) -ida_ua.op_t.__init__ (method) -ida_ua.op_t.__set_addr__ (method) -ida_ua.op_t.__set_reg_phrase__ (method) -ida_ua.op_t.__set_specval__ (method) -ida_ua.op_t.__set_value64__ (method) -ida_ua.op_t.__set_value__ (method) -ida_ua.op_t.addr (variable) -ida_ua.op_t.assign (method) -ida_ua.op_t.clr_shown (method) -ida_ua.op_t.dtype (variable) -ida_ua.op_t.flags (variable) -ida_ua.op_t.has_reg (method) -ida_ua.op_t.is_imm (method) -ida_ua.op_t.is_reg (method) -ida_ua.op_t.n (variable) -ida_ua.op_t.offb (variable) -ida_ua.op_t.offo (variable) -ida_ua.op_t.phrase (variable) -ida_ua.op_t.reg (variable) -ida_ua.op_t.set_shown (method) -ida_ua.op_t.shown (method) -ida_ua.op_t.specval (variable) -ida_ua.op_t.type (variable) -ida_ua.op_t.value (variable) -ida_ua.op_t__from_ptrval__ (function) -ida_ua.operands_array (class) -ida_ua.operands_array.__getitem__ (method) -ida_ua.operands_array.__init__ (method) -ida_ua.operands_array.__len__ (method) -ida_ua.operands_array.__setitem__ (method) -ida_ua.operands_array._get_bytes (method) -ida_ua.operands_array._set_bytes (method) -ida_ua.outctx_base_t (class) -ida_ua.outctx_base_t.__init__ (method) -ida_ua.outctx_base_t.close_comment (method) -ida_ua.outctx_base_t.clr_gen_label (method) -ida_ua.outctx_base_t.display_voids (method) -ida_ua.outctx_base_t.flush_buf (method) -ida_ua.outctx_base_t.flush_outbuf (method) -ida_ua.outctx_base_t.forbid_annotations (method) -ida_ua.outctx_base_t.force_code (method) -ida_ua.outctx_base_t.gen_block_cmt (method) -ida_ua.outctx_base_t.gen_border_line (method) -ida_ua.outctx_base_t.gen_cmt_line (method) -ida_ua.outctx_base_t.gen_collapsed_line (method) -ida_ua.outctx_base_t.gen_empty_line (method) -ida_ua.outctx_base_t.gen_empty_line_without_annotations (method) -ida_ua.outctx_base_t.gen_printf (method) -ida_ua.outctx_base_t.gen_xref_lines (method) -ida_ua.outctx_base_t.getF (method) -ida_ua.outctx_base_t.get_stkvar (method) -ida_ua.outctx_base_t.init_lines_array (method) -ida_ua.outctx_base_t.multiline (method) -ida_ua.outctx_base_t.only_main_line (method) -ida_ua.outctx_base_t.out_addr_tag (method) -ida_ua.outctx_base_t.out_btoa (method) -ida_ua.outctx_base_t.out_char (method) -ida_ua.outctx_base_t.out_chars (method) -ida_ua.outctx_base_t.out_colored_register_line (method) -ida_ua.outctx_base_t.out_keyword (method) -ida_ua.outctx_base_t.out_line (method) -ida_ua.outctx_base_t.out_long (method) -ida_ua.outctx_base_t.out_name_expr (method) -ida_ua.outctx_base_t.out_printf (method) -ida_ua.outctx_base_t.out_register (method) -ida_ua.outctx_base_t.out_spaces (method) -ida_ua.outctx_base_t.out_symbol (method) -ida_ua.outctx_base_t.out_tagoff (method) -ida_ua.outctx_base_t.out_tagon (method) -ida_ua.outctx_base_t.out_value (method) -ida_ua.outctx_base_t.print_label_now (method) -ida_ua.outctx_base_t.restore_ctxflags (method) -ida_ua.outctx_base_t.retrieve_cmt (method) -ida_ua.outctx_base_t.retrieve_name (method) -ida_ua.outctx_base_t.set_comment_addr (method) -ida_ua.outctx_base_t.set_dlbind_opnd (method) -ida_ua.outctx_base_t.set_gen_cmt (method) -ida_ua.outctx_base_t.set_gen_demangled_label (method) -ida_ua.outctx_base_t.set_gen_label (method) -ida_ua.outctx_base_t.set_gen_xrefs (method) -ida_ua.outctx_base_t.setup_outctx (method) -ida_ua.outctx_base_t.stack_view (method) -ida_ua.outctx_base_t.term_outctx (method) -ida_ua.outctx_base_t__from_ptrval__ (function) -ida_ua.outctx_t (class) -ida_ua.outctx_t.__init__ (method) -ida_ua.outctx_t.gen_func_footer (method) -ida_ua.outctx_t.gen_func_header (method) -ida_ua.outctx_t.gen_header (method) -ida_ua.outctx_t.gen_header_extra (method) -ida_ua.outctx_t.gen_xref_lines (method) -ida_ua.outctx_t.out_btoa (method) -ida_ua.outctx_t.out_custom_mnem (method) -ida_ua.outctx_t.out_data (method) -ida_ua.outctx_t.out_fcref_names (method) -ida_ua.outctx_t.out_immchar_cmts (method) -ida_ua.outctx_t.out_mnem (method) -ida_ua.outctx_t.out_mnemonic (method) -ida_ua.outctx_t.out_one_operand (method) -ida_ua.outctx_t.out_specea (method) -ida_ua.outctx_t.retrieve_cmt (method) -ida_ua.outctx_t.retrieve_name (method) -ida_ua.outctx_t.set_bin_state (method) -ida_ua.outctx_t.setup_outctx (method) -ida_ua.outctx_t.term_outctx (method) -ida_ua.outctx_t__from_ptrval__ (function) -ida_ua.print_insn_mnem (function) -ida_ua.print_operand (function) -ida_xref (module) -ida_xref.XREF_ALL (variable) -ida_xref.XREF_BASE (variable) -ida_xref.XREF_DATA (variable) -ida_xref.XREF_FAR (variable) -ida_xref.XREF_MASK (variable) -ida_xref.XREF_PASTEND (variable) -ida_xref.XREF_TAIL (variable) -ida_xref.XREF_USER (variable) -ida_xref.add_cref (function) -ida_xref.add_dref (function) -ida_xref.calc_switch_cases (function) -ida_xref.cases_and_targets_t (class) -ida_xref.cases_and_targets_t.__init__ (method) -ida_xref.casevec_t (class) -ida_xref.casevec_t.__eq__ (method) -ida_xref.casevec_t.__getitem__ (method) -ida_xref.casevec_t.__init__ (method) -ida_xref.casevec_t.__len__ (method) -ida_xref.casevec_t.__ne__ (method) -ida_xref.casevec_t.__setitem__ (method) -ida_xref.casevec_t._del (method) -ida_xref.casevec_t.add_unique (method) -ida_xref.casevec_t.at (method) -ida_xref.casevec_t.begin (method) -ida_xref.casevec_t.capacity (method) -ida_xref.casevec_t.clear (method) -ida_xref.casevec_t.empty (method) -ida_xref.casevec_t.end (method) -ida_xref.casevec_t.erase (method) -ida_xref.casevec_t.extract (method) -ida_xref.casevec_t.find (method) -ida_xref.casevec_t.grow (method) -ida_xref.casevec_t.has (method) -ida_xref.casevec_t.inject (method) -ida_xref.casevec_t.insert (method) -ida_xref.casevec_t.pop_back (method) -ida_xref.casevec_t.push_back (method) -ida_xref.casevec_t.qclear (method) -ida_xref.casevec_t.reserve (method) -ida_xref.casevec_t.resize (method) -ida_xref.casevec_t.size (method) -ida_xref.casevec_t.swap (method) -ida_xref.casevec_t.truncate (method) -ida_xref.create_switch_table (function) -ida_xref.create_switch_xrefs (function) -ida_xref.del_cref (function) -ida_xref.del_dref (function) -ida_xref.delete_switch_table (function) -ida_xref.dr_I (variable) -ida_xref.dr_O (variable) -ida_xref.dr_R (variable) -ida_xref.dr_S (variable) -ida_xref.dr_T (variable) -ida_xref.dr_U (variable) -ida_xref.dr_W (variable) -ida_xref.fl_CF (variable) -ida_xref.fl_CN (variable) -ida_xref.fl_F (variable) -ida_xref.fl_JF (variable) -ida_xref.fl_JN (variable) -ida_xref.fl_U (variable) -ida_xref.fl_USobsolete (variable) -ida_xref.get_first_cref_from (function) -ida_xref.get_first_cref_to (function) -ida_xref.get_first_dref_from (function) -ida_xref.get_first_dref_to (function) -ida_xref.get_first_fcref_from (function) -ida_xref.get_first_fcref_to (function) -ida_xref.get_next_cref_from (function) -ida_xref.get_next_cref_to (function) -ida_xref.get_next_dref_from (function) -ida_xref.get_next_dref_to (function) -ida_xref.get_next_fcref_from (function) -ida_xref.get_next_fcref_to (function) -ida_xref.has_external_refs (function) -ida_xref.xrefblk_t (class) -ida_xref.xrefblk_t.__init__ (method) -ida_xref.xrefblk_t.crefs_from (method) -ida_xref.xrefblk_t.crefs_to (method) -ida_xref.xrefblk_t.drefs_from (method) -ida_xref.xrefblk_t.drefs_to (method) -ida_xref.xrefblk_t.fcrefs_from (method) -ida_xref.xrefblk_t.fcrefs_to (method) -ida_xref.xrefblk_t.first_from (method) -ida_xref.xrefblk_t.first_to (method) -ida_xref.xrefblk_t.iscode (variable) -ida_xref.xrefblk_t.next_from (method) -ida_xref.xrefblk_t.next_to (method) -ida_xref.xrefblk_t.refs_from (method) -ida_xref.xrefblk_t.refs_from._copy_xref (function) -ida_xref.xrefblk_t.refs_to (method) -ida_xref.xrefblk_t.refs_to._copy_xref (function) -ida_xref.xrefblk_t.to (variable) -ida_xref.xrefblk_t.type (variable) -ida_xref.xrefblk_t.user (variable) -ida_xref.xrefchar (function) -ida_mergemod (module) -ida_mergemod.create_std_modmerge_handlers (function) -ida_merge (module) -ida_merge.MERGE_KIND_AFLAGS_EA (variable) -ida_merge.MERGE_KIND_AUTOQ (variable) -ida_merge.MERGE_KIND_BOOKMARKS (variable) -ida_merge.MERGE_KIND_BPTS (variable) -ida_merge.MERGE_KIND_BYTEVAL (variable) -ida_merge.MERGE_KIND_CREFS (variable) -ida_merge.MERGE_KIND_CUSTDATA (variable) -ida_merge.MERGE_KIND_DBG_MEMREGS (variable) -ida_merge.MERGE_KIND_DEBUGGER (variable) -ida_merge.MERGE_KIND_DEKSTOPS (variable) -ida_merge.MERGE_KIND_DIRTREE (variable) -ida_merge.MERGE_KIND_DREFS (variable) -ida_merge.MERGE_KIND_ENCODINGS (variable) -ida_merge.MERGE_KIND_ENCODINGS2 (variable) -ida_merge.MERGE_KIND_END (variable) -ida_merge.MERGE_KIND_ENUMS (variable) -ida_merge.MERGE_KIND_EXPORTS (variable) -ida_merge.MERGE_KIND_EXTRACMT (variable) -ida_merge.MERGE_KIND_FILEREGIONS (variable) -ida_merge.MERGE_KIND_FIXUPS (variable) -ida_merge.MERGE_KIND_FLAGS (variable) -ida_merge.MERGE_KIND_FLOWS (variable) -ida_merge.MERGE_KIND_FRAME (variable) -ida_merge.MERGE_KIND_FRAMEMGR (variable) -ida_merge.MERGE_KIND_FUNC (variable) -ida_merge.MERGE_KIND_GHSTRCMT (variable) -ida_merge.MERGE_KIND_HIDDENRANGES (variable) -ida_merge.MERGE_KIND_IGNOREMICRO (variable) -ida_merge.MERGE_KIND_IMPORTS (variable) -ida_merge.MERGE_KIND_INF (variable) -ida_merge.MERGE_KIND_LAST (variable) -ida_merge.MERGE_KIND_LOADER (variable) -ida_merge.MERGE_KIND_LUMINA (variable) -ida_merge.MERGE_KIND_MAPPING (variable) -ida_merge.MERGE_KIND_NETNODE (variable) -ida_merge.MERGE_KIND_NOTEPAD (variable) -ida_merge.MERGE_KIND_ORPHANS (variable) -ida_merge.MERGE_KIND_PATCHES (variable) -ida_merge.MERGE_KIND_PROBLEMS (variable) -ida_merge.MERGE_KIND_SCRIPTS (variable) -ida_merge.MERGE_KIND_SCRIPTS2 (variable) -ida_merge.MERGE_KIND_SEGGRPS (variable) -ida_merge.MERGE_KIND_SEGMENTS (variable) -ida_merge.MERGE_KIND_SEGREGS (variable) -ida_merge.MERGE_KIND_SELECTORS (variable) -ida_merge.MERGE_KIND_SIGNATURES (variable) -ida_merge.MERGE_KIND_SOURCEFILES (variable) -ida_merge.MERGE_KIND_STKPNTS (variable) -ida_merge.MERGE_KIND_STRMEM (variable) -ida_merge.MERGE_KIND_STRMEMCMT (variable) -ida_merge.MERGE_KIND_STRUCTS (variable) -ida_merge.MERGE_KIND_STT (variable) -ida_merge.MERGE_KIND_TILS (variable) -ida_merge.MERGE_KIND_TINFO (variable) -ida_merge.MERGE_KIND_TRYBLKS (variable) -ida_merge.MERGE_KIND_UDTMEM (variable) -ida_merge.MERGE_KIND_UI (variable) -ida_merge.MERGE_KIND_VFTABLES (variable) -ida_merge.MERGE_KIND_WATCHPOINTS (variable) -ida_merge.MH_LISTEN (variable) -ida_merge.MH_TERSE (variable) -ida_merge.MH_UI_CHAR_MASK (variable) -ida_merge.MH_UI_COLONNAME (variable) -ida_merge.MH_UI_COMMANAME (variable) -ida_merge.MH_UI_COMPLEX (variable) -ida_merge.MH_UI_DP_NOLINEDIFF (variable) -ida_merge.MH_UI_DP_SHORTNAME (variable) -ida_merge.MH_UI_INDENT (variable) -ida_merge.MH_UI_NODETAILS (variable) -ida_merge.MH_UI_SPLITNAME (variable) -ida_merge.NDS_BLOB (variable) -ida_merge.NDS_EV_FUNC (variable) -ida_merge.NDS_EV_RANGE (variable) -ida_merge.NDS_INC (variable) -ida_merge.NDS_IS_BOOL (variable) -ida_merge.NDS_IS_EA (variable) -ida_merge.NDS_IS_RELATIVE (variable) -ida_merge.NDS_IS_STR (variable) -ida_merge.NDS_MAP_IDX (variable) -ida_merge.NDS_MAP_VAL (variable) -ida_merge.NDS_SUPVAL (variable) -ida_merge.NDS_VAL8 (variable) -ida_merge.create_nodeval_merge_handler (function) -ida_merge.create_nodeval_merge_handlers (function) -ida_merge.destroy_moddata_merge_handlers (function) -ida_merge.get_ea_diffpos_name (function) -ida_merge.is_diff_merge_mode (function) -ida_merge.item_block_locator_t (class) -ida_merge.item_block_locator_t.__disown__ (method) -ida_merge.item_block_locator_t.__init__ (method) -ida_merge.item_block_locator_t.get_block_head (method) -ida_merge.item_block_locator_t.setup_blocks (method) -ida_merge.merge_data_t (class) -ida_merge.merge_data_t.__init__ (method) -ida_merge.merge_data_t.add_event_handler (method) -ida_merge.merge_data_t.base_id (method) -ida_merge.merge_data_t.compare_merging_tifs (method) -ida_merge.merge_data_t.dbctx_ids (variable) -ida_merge.merge_data_t.ev_handlers (variable) -ida_merge.merge_data_t.get_block_head (method) -ida_merge.merge_data_t.has_existing_node (method) -ida_merge.merge_data_t.local_id (method) -ida_merge.merge_data_t.map_privrange_id (method) -ida_merge.merge_data_t.map_tinfo (method) -ida_merge.merge_data_t.nbases (variable) -ida_merge.merge_data_t.remote_id (method) -ida_merge.merge_data_t.remove_event_handler (method) -ida_merge.merge_data_t.set_dbctx_ids (method) -ida_merge.merge_data_t.setup_blocks (method) -ida_merge.merge_handler_params_t (class) -ida_merge.merge_handler_params_t.__init__ (method) -ida_merge.merge_handler_params_t.insert_after (variable) -ida_merge.merge_handler_params_t.kind (variable) -ida_merge.merge_handler_params_t.ui_complex_details (method) -ida_merge.merge_handler_params_t.ui_complex_name (method) -ida_merge.merge_handler_params_t.ui_dp_shortname (method) -ida_merge.merge_handler_params_t.ui_has_details (method) -ida_merge.merge_handler_params_t.ui_indent (method) -ida_merge.merge_handler_params_t.ui_linediff (method) -ida_merge.merge_handler_params_t.ui_split_char (method) -ida_merge.merge_handler_params_t.ui_split_str (method) -ida_merge.merge_node_helper_t (class) -ida_merge.merge_node_helper_t.__disown__ (method) -ida_merge.merge_node_helper_t.__init__ (method) -ida_merge.merge_node_helper_t.append_eavec (method) -ida_merge.merge_node_helper_t.get_column_headers (method) -ida_merge.merge_node_helper_t.get_netnode (method) -ida_merge.merge_node_helper_t.is_mergeable (method) -ida_merge.merge_node_helper_t.map_scalar (method) -ida_merge.merge_node_helper_t.map_string (method) -ida_merge.merge_node_helper_t.print_entry_details (method) -ida_merge.merge_node_helper_t.print_entry_name (method) -ida_merge.merge_node_helper_t.refresh (method) -ida_merge.merge_node_helper_t_append_eavec (function) -ida_merge.merge_node_info_t (class) -ida_merge.merge_node_info_t.__init__ (method) -ida_merge.merge_node_info_t.name (variable) -ida_merge.merge_node_info_t.nds_flags (variable) -ida_merge.merge_node_info_t.tag (variable) -ida_merge.moddata_diff_helper_t (class) -ida_merge.moddata_diff_helper_t.__disown__ (method) -ida_merge.moddata_diff_helper_t.__init__ (method) -ida_merge.moddata_diff_helper_t.additional_mh_flags (variable) -ida_merge.moddata_diff_helper_t.fields (variable) -ida_merge.moddata_diff_helper_t.get_struc_ptr (method) -ida_merge.moddata_diff_helper_t.merge_ending (method) -ida_merge.moddata_diff_helper_t.merge_starting (method) -ida_merge.moddata_diff_helper_t.module_name (variable) -ida_merge.moddata_diff_helper_t.netnode_name (variable) -ida_merge.moddata_diff_helper_t.nfields (variable) -ida_merge.moddata_diff_helper_t.print_diffpos_details (method) -ida_merge.moddata_diff_helper_t.str2val (method) -ida_merge.moddata_diff_helper_t.val2str (method) +ida_hexrays +ida_hexrays.ACFL_BLKOPT +ida_hexrays.ACFL_GLBDEL +ida_hexrays.ACFL_GLBPROP +ida_hexrays.ACFL_GUESS +ida_hexrays.ACFL_LOCOPT +ida_hexrays.ALLOW_UNUSED_LABELS +ida_hexrays.ANCHOR_BLKCMT +ida_hexrays.ANCHOR_CITEM +ida_hexrays.ANCHOR_ITP +ida_hexrays.ANCHOR_LVAR +ida_hexrays.ANY_FPSIZE +ida_hexrays.ANY_REGSIZE +ida_hexrays.BLT_0WAY +ida_hexrays.BLT_1WAY +ida_hexrays.BLT_2WAY +ida_hexrays.BLT_NONE +ida_hexrays.BLT_NWAY +ida_hexrays.BLT_STOP +ida_hexrays.BLT_XTRN +ida_hexrays.CALC_CURLY_BRACES +ida_hexrays.CFL_FINAL +ida_hexrays.CFL_HELPER +ida_hexrays.CFL_NORET +ida_hexrays.CFS_BOUNDS +ida_hexrays.CFS_LOCKED +ida_hexrays.CFS_LVARS_HIDDEN +ida_hexrays.CFS_TEXT +ida_hexrays.CHF_FAKE +ida_hexrays.CHF_INITED +ida_hexrays.CHF_OVER +ida_hexrays.CHF_PASSTHRU +ida_hexrays.CHF_REPLACED +ida_hexrays.CHF_TERM +ida_hexrays.CIT_COLLAPSED +ida_hexrays.CMAT_BUILT +ida_hexrays.CMAT_CASTED +ida_hexrays.CMAT_CPA +ida_hexrays.CMAT_FINAL +ida_hexrays.CMAT_NICE +ida_hexrays.CMAT_TRANS1 +ida_hexrays.CMAT_TRANS2 +ida_hexrays.CMAT_TRANS3 +ida_hexrays.CMAT_ZERO +ida_hexrays.CMT_ALL +ida_hexrays.CMT_BLOCK1 +ida_hexrays.CMT_BLOCK2 +ida_hexrays.CMT_FUNC +ida_hexrays.CMT_LVAR +ida_hexrays.CMT_NONE +ida_hexrays.CMT_TAIL +ida_hexrays.CPBLK_FAST +ida_hexrays.CPBLK_MINREF +ida_hexrays.CPBLK_OPTJMP +ida_hexrays.CV_FAST +ida_hexrays.CV_INSNS +ida_hexrays.CV_PARENTS +ida_hexrays.CV_POST +ida_hexrays.CV_PRUNE +ida_hexrays.CV_RESTART +ida_hexrays.DECOMP_ALL_BLKS +ida_hexrays.DECOMP_GXREFS_DEFLT +ida_hexrays.DECOMP_GXREFS_FORCE +ida_hexrays.DECOMP_GXREFS_NOUPD +ida_hexrays.DECOMP_NO_CACHE +ida_hexrays.DECOMP_NO_FRAME +ida_hexrays.DECOMP_NO_HIDE +ida_hexrays.DECOMP_NO_WAIT +ida_hexrays.DECOMP_OUTLINE +ida_hexrays.DECOMP_VOID_MBA +ida_hexrays.DECOMP_WARNINGS +ida_hexrays.DecompilationFailure +ida_hexrays.EQ_CMPDEST +ida_hexrays.EQ_IGNCODE +ida_hexrays.EQ_IGNSIZE +ida_hexrays.EQ_OPTINSN +ida_hexrays.EXFL_ALL +ida_hexrays.EXFL_ALONE +ida_hexrays.EXFL_CPADONE +ida_hexrays.EXFL_CSTR +ida_hexrays.EXFL_FPOP +ida_hexrays.EXFL_JUMPOUT +ida_hexrays.EXFL_LVALUE +ida_hexrays.EXFL_PARTIAL +ida_hexrays.EXFL_UNDEF +ida_hexrays.EXFL_VFTABLE +ida_hexrays.FCI_DEAD +ida_hexrays.FCI_EXPLOCS +ida_hexrays.FCI_FINAL +ida_hexrays.FCI_HASCALL +ida_hexrays.FCI_HASFMT +ida_hexrays.FCI_NORET +ida_hexrays.FCI_NOSIDE +ida_hexrays.FCI_PROP +ida_hexrays.FCI_PURE +ida_hexrays.FCI_SPLOK +ida_hexrays.FD_BACKWARD +ida_hexrays.FD_DEF +ida_hexrays.FD_DIRTY +ida_hexrays.FD_FORWARD +ida_hexrays.FD_USE +ida_hexrays.FORBID_UNUSED_LABELS +ida_hexrays.GCA_ALLOC +ida_hexrays.GCA_EMPTY +ida_hexrays.GCA_NALLOC +ida_hexrays.GCA_OFIRST +ida_hexrays.GCA_OLAST +ida_hexrays.GCA_SPEC +ida_hexrays.GCO_DEF +ida_hexrays.GCO_REG +ida_hexrays.GCO_STK +ida_hexrays.GCO_USE +ida_hexrays.GC_ASR +ida_hexrays.GC_DIRTY_ALL +ida_hexrays.GC_END +ida_hexrays.GC_REGS_AND_STKVARS +ida_hexrays.GC_XDSU +ida_hexrays.GLN_ALL +ida_hexrays.GLN_CURRENT +ida_hexrays.GLN_GOTO_TARGET +ida_hexrays.Hexrays_Hooks +ida_hexrays.Hexrays_Hooks.__disown__ +ida_hexrays.Hexrays_Hooks.__init__ +ida_hexrays.Hexrays_Hooks.begin_inlining +ida_hexrays.Hexrays_Hooks.build_callinfo +ida_hexrays.Hexrays_Hooks.callinfo_built +ida_hexrays.Hexrays_Hooks.calls_done +ida_hexrays.Hexrays_Hooks.close_pseudocode +ida_hexrays.Hexrays_Hooks.cmt_changed +ida_hexrays.Hexrays_Hooks.collect_warnings +ida_hexrays.Hexrays_Hooks.combine +ida_hexrays.Hexrays_Hooks.create_hint +ida_hexrays.Hexrays_Hooks.curpos +ida_hexrays.Hexrays_Hooks.double_click +ida_hexrays.Hexrays_Hooks.flowchart +ida_hexrays.Hexrays_Hooks.func_printed +ida_hexrays.Hexrays_Hooks.glbopt +ida_hexrays.Hexrays_Hooks.hook +ida_hexrays.Hexrays_Hooks.inlined_func +ida_hexrays.Hexrays_Hooks.inlining_func +ida_hexrays.Hexrays_Hooks.interr +ida_hexrays.Hexrays_Hooks.keyboard +ida_hexrays.Hexrays_Hooks.locopt +ida_hexrays.Hexrays_Hooks.lvar_cmt_changed +ida_hexrays.Hexrays_Hooks.lvar_mapping_changed +ida_hexrays.Hexrays_Hooks.lvar_name_changed +ida_hexrays.Hexrays_Hooks.lvar_type_changed +ida_hexrays.Hexrays_Hooks.maturity +ida_hexrays.Hexrays_Hooks.microcode +ida_hexrays.Hexrays_Hooks.open_pseudocode +ida_hexrays.Hexrays_Hooks.populating_popup +ida_hexrays.Hexrays_Hooks.pre_structural +ida_hexrays.Hexrays_Hooks.prealloc +ida_hexrays.Hexrays_Hooks.preoptimized +ida_hexrays.Hexrays_Hooks.print_func +ida_hexrays.Hexrays_Hooks.prolog +ida_hexrays.Hexrays_Hooks.refresh_pseudocode +ida_hexrays.Hexrays_Hooks.resolve_stkaddrs +ida_hexrays.Hexrays_Hooks.right_click +ida_hexrays.Hexrays_Hooks.stkpnts +ida_hexrays.Hexrays_Hooks.structural +ida_hexrays.Hexrays_Hooks.switch_pseudocode +ida_hexrays.Hexrays_Hooks.text_ready +ida_hexrays.Hexrays_Hooks.unhook +ida_hexrays.INLINE_DONTCOPY +ida_hexrays.INLINE_EXTFRAME +ida_hexrays.IPROP_ASSERT +ida_hexrays.IPROP_CLNPOP +ida_hexrays.IPROP_COMBINED +ida_hexrays.IPROP_DONT_COMB +ida_hexrays.IPROP_DONT_PROP +ida_hexrays.IPROP_EXTSTX +ida_hexrays.IPROP_FARCALL +ida_hexrays.IPROP_FPINSN +ida_hexrays.IPROP_IGNLOWSRC +ida_hexrays.IPROP_INV_JX +ida_hexrays.IPROP_MBARRIER +ida_hexrays.IPROP_MULTI_MOV +ida_hexrays.IPROP_OPTIONAL +ida_hexrays.IPROP_PERSIST +ida_hexrays.IPROP_SPLIT +ida_hexrays.IPROP_SPLIT1 +ida_hexrays.IPROP_SPLIT2 +ida_hexrays.IPROP_SPLIT4 +ida_hexrays.IPROP_SPLIT8 +ida_hexrays.IPROP_TAILCALL +ida_hexrays.IPROP_UNMERGED +ida_hexrays.IPROP_UNPAIRED +ida_hexrays.IPROP_WAS_NORET +ida_hexrays.IPROP_WILDMATCH +ida_hexrays.ITP_ARG1 +ida_hexrays.ITP_ASM +ida_hexrays.ITP_BLOCK1 +ida_hexrays.ITP_BLOCK2 +ida_hexrays.ITP_BRACE2 +ida_hexrays.ITP_CASE +ida_hexrays.ITP_COLON +ida_hexrays.ITP_CURLY1 +ida_hexrays.ITP_CURLY2 +ida_hexrays.ITP_DO +ida_hexrays.ITP_ELSE +ida_hexrays.ITP_EMPTY +ida_hexrays.ITP_SEMI +ida_hexrays.ITP_SIGN +ida_hexrays.ITP_TRY +ida_hexrays.LOCOPT_ALL +ida_hexrays.LOCOPT_REFINE +ida_hexrays.LOCOPT_REFINE2 +ida_hexrays.LVINF_KEEP +ida_hexrays.LVINF_NOMAP +ida_hexrays.LVINF_NOPTR +ida_hexrays.LVINF_SPLIT +ida_hexrays.LVINF_UNUSED +ida_hexrays.MBA2_ARGIDX_OK +ida_hexrays.MBA2_ARGIDX_SORTED +ida_hexrays.MBA2_CODE16_BIT +ida_hexrays.MBA2_DONT_VERIFY +ida_hexrays.MBA2_HAS_OUTLINES +ida_hexrays.MBA2_IS_CTR +ida_hexrays.MBA2_IS_DTR +ida_hexrays.MBA2_LVARNAMES_OK +ida_hexrays.MBA2_LVARS_RENAMED +ida_hexrays.MBA2_NO_DUP_CALLS +ida_hexrays.MBA2_NO_DUP_LVARS +ida_hexrays.MBA2_NO_FRAME +ida_hexrays.MBA2_OVER_CHAINS +ida_hexrays.MBA2_PROP_COMPLEX +ida_hexrays.MBA2_STACK_RETVAL +ida_hexrays.MBA2_UNDEF_RETVAR +ida_hexrays.MBA2_VALRNG_DONE +ida_hexrays.MBA_ASRPROP +ida_hexrays.MBA_ASRTOK +ida_hexrays.MBA_CALLS +ida_hexrays.MBA_CHVARS +ida_hexrays.MBA_CMBBLK +ida_hexrays.MBA_CMNSTK +ida_hexrays.MBA_COLGDL +ida_hexrays.MBA_DELPAIRS +ida_hexrays.MBA_GLBOPT +ida_hexrays.MBA_INSGDL +ida_hexrays.MBA_LOADED +ida_hexrays.MBA_LVARS0 +ida_hexrays.MBA_LVARS1 +ida_hexrays.MBA_NICE +ida_hexrays.MBA_NOFUNC +ida_hexrays.MBA_NUMADDR +ida_hexrays.MBA_PASSREGS +ida_hexrays.MBA_PATTERN +ida_hexrays.MBA_PRCDEFS +ida_hexrays.MBA_PREOPT +ida_hexrays.MBA_REFINE +ida_hexrays.MBA_RETFP +ida_hexrays.MBA_RETREF +ida_hexrays.MBA_SAVRST +ida_hexrays.MBA_SHORT +ida_hexrays.MBA_SPLINFO +ida_hexrays.MBA_THUNK +ida_hexrays.MBA_VALNUM +ida_hexrays.MBA_WINGR32 +ida_hexrays.MBL_BACKPROP +ida_hexrays.MBL_CALL +ida_hexrays.MBL_COMB +ida_hexrays.MBL_DEAD +ida_hexrays.MBL_DMT64 +ida_hexrays.MBL_DSLOT +ida_hexrays.MBL_EXTFRAME +ida_hexrays.MBL_FAKE +ida_hexrays.MBL_GOTO +ida_hexrays.MBL_INCONST +ida_hexrays.MBL_INLINED +ida_hexrays.MBL_KEEP +ida_hexrays.MBL_LIST +ida_hexrays.MBL_NONFAKE +ida_hexrays.MBL_NORET +ida_hexrays.MBL_PRIV +ida_hexrays.MBL_PROP +ida_hexrays.MBL_PUSH +ida_hexrays.MBL_TCAL +ida_hexrays.MBL_VALRANGES +ida_hexrays.MERR_BADARCH +ida_hexrays.MERR_BADBLK +ida_hexrays.MERR_BADCALL +ida_hexrays.MERR_BADFRAME +ida_hexrays.MERR_BADIDB +ida_hexrays.MERR_BADRANGES +ida_hexrays.MERR_BADSP +ida_hexrays.MERR_BITNESS +ida_hexrays.MERR_BLOCK +ida_hexrays.MERR_BUSY +ida_hexrays.MERR_CANCELED +ida_hexrays.MERR_CLOUD +ida_hexrays.MERR_COMPLEX +ida_hexrays.MERR_DSLOT +ida_hexrays.MERR_EXCEPTION +ida_hexrays.MERR_EXTERN +ida_hexrays.MERR_FARPTR +ida_hexrays.MERR_FUNCSIZE +ida_hexrays.MERR_HUGESTACK +ida_hexrays.MERR_INSN +ida_hexrays.MERR_INTERR +ida_hexrays.MERR_LICENSE +ida_hexrays.MERR_LOOP +ida_hexrays.MERR_LVARS +ida_hexrays.MERR_MEM +ida_hexrays.MERR_OK +ida_hexrays.MERR_ONLY32 +ida_hexrays.MERR_ONLY64 +ida_hexrays.MERR_OVERLAP +ida_hexrays.MERR_PARTINIT +ida_hexrays.MERR_PROLOG +ida_hexrays.MERR_RECDEPTH +ida_hexrays.MERR_REDO +ida_hexrays.MERR_SIZEOF +ida_hexrays.MERR_STOP +ida_hexrays.MERR_SWITCH +ida_hexrays.MERR_UNKTYPE +ida_hexrays.MLI_CLR_FLAGS +ida_hexrays.MLI_CMT +ida_hexrays.MLI_NAME +ida_hexrays.MLI_SET_FLAGS +ida_hexrays.MLI_TYPE +ida_hexrays.MMAT_CALLS +ida_hexrays.MMAT_GENERATED +ida_hexrays.MMAT_GLBOPT1 +ida_hexrays.MMAT_GLBOPT2 +ida_hexrays.MMAT_GLBOPT3 +ida_hexrays.MMAT_LOCOPT +ida_hexrays.MMAT_LVARS +ida_hexrays.MMAT_PREOPTIMIZED +ida_hexrays.MMAT_ZERO +ida_hexrays.MMIDX_ARGS +ida_hexrays.MMIDX_GLBHIGH +ida_hexrays.MMIDX_GLBLOW +ida_hexrays.MMIDX_LVARS +ida_hexrays.MMIDX_RETADDR +ida_hexrays.MMIDX_SHADOW +ida_hexrays.NALT_VD +ida_hexrays.NF_BINVDONE +ida_hexrays.NF_BITNOT +ida_hexrays.NF_FIXED +ida_hexrays.NF_NEGATE +ida_hexrays.NF_NEGDONE +ida_hexrays.NF_VALID +ida_hexrays.NOSIZE +ida_hexrays.NO_CURLY_BRACES +ida_hexrays.NO_SIDEFF +ida_hexrays.ONLY_SIDEFF +ida_hexrays.OPF_NEW_WINDOW +ida_hexrays.OPF_NO_WAIT +ida_hexrays.OPF_REUSE +ida_hexrays.OPF_REUSE_ACTIVE +ida_hexrays.OPROP_CCFLAGS +ida_hexrays.OPROP_FLOAT +ida_hexrays.OPROP_IMPDONE +ida_hexrays.OPROP_LOWADDR +ida_hexrays.OPROP_UDEFVAL +ida_hexrays.OPROP_UDT +ida_hexrays.OPTI_ADDREXPRS +ida_hexrays.OPTI_COMBINSNS +ida_hexrays.OPTI_MINSTKREF +ida_hexrays.OPTI_NO_LDXOPT +ida_hexrays.OPTI_NO_VALRNG +ida_hexrays.RETRIEVE_ALWAYS +ida_hexrays.RETRIEVE_ONCE +ida_hexrays.ROLE_3WAYCMP0 +ida_hexrays.ROLE_3WAYCMP1 +ida_hexrays.ROLE_ABS +ida_hexrays.ROLE_ALLOCA +ida_hexrays.ROLE_BITTEST +ida_hexrays.ROLE_BITTESTANDCOMPLEMENT +ida_hexrays.ROLE_BITTESTANDRESET +ida_hexrays.ROLE_BITTESTANDSET +ida_hexrays.ROLE_BSWAP +ida_hexrays.ROLE_BUG +ida_hexrays.ROLE_CFSUB3 +ida_hexrays.ROLE_CONTAINING_RECORD +ida_hexrays.ROLE_EMPTY +ida_hexrays.ROLE_FASTFAIL +ida_hexrays.ROLE_IS_MUL_OK +ida_hexrays.ROLE_MEMCPY +ida_hexrays.ROLE_MEMSET +ida_hexrays.ROLE_MEMSET32 +ida_hexrays.ROLE_MEMSET64 +ida_hexrays.ROLE_OFSUB3 +ida_hexrays.ROLE_PRESENT +ida_hexrays.ROLE_READFLAGS +ida_hexrays.ROLE_ROL +ida_hexrays.ROLE_ROR +ida_hexrays.ROLE_SATURATED_MUL +ida_hexrays.ROLE_SSE_CMP4 +ida_hexrays.ROLE_SSE_CMP8 +ida_hexrays.ROLE_STRCAT +ida_hexrays.ROLE_STRCPY +ida_hexrays.ROLE_STRLEN +ida_hexrays.ROLE_TAIL +ida_hexrays.ROLE_UNK +ida_hexrays.ROLE_VA_ARG +ida_hexrays.ROLE_VA_COPY +ida_hexrays.ROLE_VA_END +ida_hexrays.ROLE_VA_START +ida_hexrays.ROLE_WCSCAT +ida_hexrays.ROLE_WCSCPY +ida_hexrays.ROLE_WCSLEN +ida_hexrays.ROLE_WMEMCPY +ida_hexrays.ROLE_WMEMSET +ida_hexrays.SHINS_LDXEA +ida_hexrays.SHINS_NUMADDR +ida_hexrays.SHINS_SHORT +ida_hexrays.SHINS_VALNUM +ida_hexrays.ULV_PRECISE_DEFEA +ida_hexrays.USE_CURLY_BRACES +ida_hexrays.USE_KEYBOARD +ida_hexrays.USE_MOUSE +ida_hexrays.VDI_EXPR +ida_hexrays.VDI_FUNC +ida_hexrays.VDI_LVAR +ida_hexrays.VDI_NONE +ida_hexrays.VDI_TAIL +ida_hexrays.VDRUN_APPEND +ida_hexrays.VDRUN_CMDLINE +ida_hexrays.VDRUN_LUMINA +ida_hexrays.VDRUN_MAYSTOP +ida_hexrays.VDRUN_NEWFILE +ida_hexrays.VDRUN_ONLYNEW +ida_hexrays.VDRUN_SENDIDB +ida_hexrays.VDRUN_SILENT +ida_hexrays.VDRUN_STATS +ida_hexrays.VDUI_VALID +ida_hexrays.VDUI_VISIBLE +ida_hexrays.VR_AT_END +ida_hexrays.VR_AT_START +ida_hexrays.VR_EXACT +ida_hexrays.WARN_ADDR_OUTARGS +ida_hexrays.WARN_ARRAY_INARG +ida_hexrays.WARN_BAD_CALL_SP +ida_hexrays.WARN_BAD_FIELD_TYPE +ida_hexrays.WARN_BAD_INSN +ida_hexrays.WARN_BAD_MAPDST +ida_hexrays.WARN_BAD_PURGED +ida_hexrays.WARN_BAD_RETVAR +ida_hexrays.WARN_BAD_SHADOW +ida_hexrays.WARN_BAD_SP +ida_hexrays.WARN_BAD_STD_TYPE +ida_hexrays.WARN_BAD_STKPNT +ida_hexrays.WARN_BAD_STROFF +ida_hexrays.WARN_BAD_VALRNG +ida_hexrays.WARN_BAD_VARSIZE +ida_hexrays.WARN_CBUILD_LOOPS +ida_hexrays.WARN_CR_BADOFF +ida_hexrays.WARN_CR_NOFIELD +ida_hexrays.WARN_DEP_UNK_CALLS +ida_hexrays.WARN_EXP_LINVAR +ida_hexrays.WARN_FIXED_INSN +ida_hexrays.WARN_FRAG_LVAR +ida_hexrays.WARN_GUESSED_TYPE +ida_hexrays.WARN_HUGE_STKOFF +ida_hexrays.WARN_ILL_ELLIPSIS +ida_hexrays.WARN_ILL_FPU_STACK +ida_hexrays.WARN_ILL_FUNCTYPE +ida_hexrays.WARN_ILL_PURGED +ida_hexrays.WARN_JUMPOUT +ida_hexrays.WARN_MAX +ida_hexrays.WARN_MAX_ARGS +ida_hexrays.WARN_MISSED_SWITCH +ida_hexrays.WARN_MUST_RET_FP +ida_hexrays.WARN_NO_SAVE_REST +ida_hexrays.WARN_ODD_ABI +ida_hexrays.WARN_ODD_ADDR_USE +ida_hexrays.WARN_ODD_INPUT_REG +ida_hexrays.WARN_OPT_USELESS_JCND +ida_hexrays.WARN_OPT_VALRNG +ida_hexrays.WARN_OPT_VALRNG2 +ida_hexrays.WARN_OPT_VALRNG3 +ida_hexrays.WARN_RET_LOCREF +ida_hexrays.WARN_SELFREF_PROP +ida_hexrays.WARN_SUBFRAME_OVERFLOW +ida_hexrays.WARN_UNALIGNED_ARG +ida_hexrays.WARN_UNBALANCED_STACK +ida_hexrays.WARN_UNDEF_LVAR +ida_hexrays.WARN_UNINITED_REG +ida_hexrays.WARN_UNSUPP_REG +ida_hexrays.WARN_VARARG_MANY +ida_hexrays.WARN_VARARG_NOSTK +ida_hexrays.WARN_VARARG_REGS +ida_hexrays.WARN_VARARG_TCAL +ida_hexrays.WARN_WIDEN_CHAINS +ida_hexrays.WARN_WOULD_OVERLAP +ida_hexrays.WARN_WRITE_CONST +ida_hexrays.WARN_WRONG_VA_OFF +ida_hexrays.WITH_SIDEFF +ida_hexrays.__cbhooks_t +ida_hexrays.__cbhooks_t.__init__ +ida_hexrays.__cbhooks_t.close_pseudocode +ida_hexrays.__cbhooks_t.create_hint +ida_hexrays.__cbhooks_t.curpos +ida_hexrays.__cbhooks_t.double_click +ida_hexrays.__cbhooks_t.func_printed +ida_hexrays.__cbhooks_t.interr +ida_hexrays.__cbhooks_t.keyboard +ida_hexrays.__cbhooks_t.maturity +ida_hexrays.__cbhooks_t.open_pseudocode +ida_hexrays.__cbhooks_t.populating_popup +ida_hexrays.__cbhooks_t.print_func +ida_hexrays.__cbhooks_t.refresh_pseudocode +ida_hexrays.__cbhooks_t.right_click +ida_hexrays.__cbhooks_t.switch_pseudocode +ida_hexrays.__cbhooks_t.text_ready +ida_hexrays._call_with_transferrable_ownership +ida_hexrays._kludge_force_declare_TPopupMenu +ida_hexrays._ll_call_helper +ida_hexrays._ll_create_helper +ida_hexrays._ll_dereference +ida_hexrays._ll_lnot +ida_hexrays._ll_make_num +ida_hexrays._ll_make_ref +ida_hexrays._ll_new_block +ida_hexrays._map_as_dict +ida_hexrays._map_as_dict._map___contains__ +ida_hexrays._map_as_dict._map___delitem__ +ida_hexrays._map_as_dict._map___getitem__ +ida_hexrays._map_as_dict._map___iter__ +ida_hexrays._map_as_dict._map___setitem__ +ida_hexrays._map_as_dict._map_clear +ida_hexrays._map_as_dict._map_copy +ida_hexrays._map_as_dict._map_get +ida_hexrays._map_as_dict._map_has_key +ida_hexrays._map_as_dict._map_items +ida_hexrays._map_as_dict._map_iteritems +ida_hexrays._map_as_dict._map_iterkeys +ida_hexrays._map_as_dict._map_itervalues +ida_hexrays._map_as_dict._map_keys +ida_hexrays._map_as_dict._map_pop +ida_hexrays._map_as_dict._map_popitem +ida_hexrays._map_as_dict._map_setdefault +ida_hexrays._map_as_dict._map_values +ida_hexrays.accepts_small_udts +ida_hexrays.accepts_udts +ida_hexrays.arglocs_overlap +ida_hexrays.array_of_bitsets +ida_hexrays.array_of_bitsets.__eq__ +ida_hexrays.array_of_bitsets.__getitem__ +ida_hexrays.array_of_bitsets.__init__ +ida_hexrays.array_of_bitsets.__len__ +ida_hexrays.array_of_bitsets.__ne__ +ida_hexrays.array_of_bitsets.__setitem__ +ida_hexrays.array_of_bitsets._del +ida_hexrays.array_of_bitsets.add_unique +ida_hexrays.array_of_bitsets.append +ida_hexrays.array_of_bitsets.at +ida_hexrays.array_of_bitsets.begin +ida_hexrays.array_of_bitsets.capacity +ida_hexrays.array_of_bitsets.clear +ida_hexrays.array_of_bitsets.empty +ida_hexrays.array_of_bitsets.end +ida_hexrays.array_of_bitsets.erase +ida_hexrays.array_of_bitsets.extend +ida_hexrays.array_of_bitsets.extract +ida_hexrays.array_of_bitsets.find +ida_hexrays.array_of_bitsets.grow +ida_hexrays.array_of_bitsets.has +ida_hexrays.array_of_bitsets.inject +ida_hexrays.array_of_bitsets.insert +ida_hexrays.array_of_bitsets.pop_back +ida_hexrays.array_of_bitsets.push_back +ida_hexrays.array_of_bitsets.qclear +ida_hexrays.array_of_bitsets.reserve +ida_hexrays.array_of_bitsets.resize +ida_hexrays.array_of_bitsets.size +ida_hexrays.array_of_bitsets.swap +ida_hexrays.array_of_bitsets.truncate +ida_hexrays.array_of_ivlsets +ida_hexrays.array_of_ivlsets.__eq__ +ida_hexrays.array_of_ivlsets.__getitem__ +ida_hexrays.array_of_ivlsets.__init__ +ida_hexrays.array_of_ivlsets.__len__ +ida_hexrays.array_of_ivlsets.__ne__ +ida_hexrays.array_of_ivlsets.__setitem__ +ida_hexrays.array_of_ivlsets._del +ida_hexrays.array_of_ivlsets.add_unique +ida_hexrays.array_of_ivlsets.append +ida_hexrays.array_of_ivlsets.at +ida_hexrays.array_of_ivlsets.begin +ida_hexrays.array_of_ivlsets.capacity +ida_hexrays.array_of_ivlsets.clear +ida_hexrays.array_of_ivlsets.empty +ida_hexrays.array_of_ivlsets.end +ida_hexrays.array_of_ivlsets.erase +ida_hexrays.array_of_ivlsets.extend +ida_hexrays.array_of_ivlsets.extract +ida_hexrays.array_of_ivlsets.find +ida_hexrays.array_of_ivlsets.grow +ida_hexrays.array_of_ivlsets.has +ida_hexrays.array_of_ivlsets.inject +ida_hexrays.array_of_ivlsets.insert +ida_hexrays.array_of_ivlsets.pop_back +ida_hexrays.array_of_ivlsets.push_back +ida_hexrays.array_of_ivlsets.qclear +ida_hexrays.array_of_ivlsets.reserve +ida_hexrays.array_of_ivlsets.resize +ida_hexrays.array_of_ivlsets.size +ida_hexrays.array_of_ivlsets.swap +ida_hexrays.array_of_ivlsets.truncate +ida_hexrays.array_of_node_bitset_t +ida_hexrays.array_of_node_bitset_t.__init__ +ida_hexrays.asgop +ida_hexrays.asgop_revert +ida_hexrays.bit_bound_t +ida_hexrays.bit_bound_t.__init__ +ida_hexrays.bitset_t +ida_hexrays.bitset_t.__eq__ +ida_hexrays.bitset_t.__ge__ +ida_hexrays.bitset_t.__gt__ +ida_hexrays.bitset_t.__init__ +ida_hexrays.bitset_t.__iter__ +ida_hexrays.bitset_t.__le__ +ida_hexrays.bitset_t.__lt__ +ida_hexrays.bitset_t.__ne__ +ida_hexrays.bitset_t.add +ida_hexrays.bitset_t.back +ida_hexrays.bitset_t.begin +ida_hexrays.bitset_t.clear +ida_hexrays.bitset_t.compare +ida_hexrays.bitset_t.copy +ida_hexrays.bitset_t.count +ida_hexrays.bitset_t.cut_at +ida_hexrays.bitset_t.dstr +ida_hexrays.bitset_t.empty +ida_hexrays.bitset_t.end +ida_hexrays.bitset_t.fill_with_ones +ida_hexrays.bitset_t.front +ida_hexrays.bitset_t.has +ida_hexrays.bitset_t.has_all +ida_hexrays.bitset_t.has_any +ida_hexrays.bitset_t.has_common +ida_hexrays.bitset_t.inc +ida_hexrays.bitset_t.includes +ida_hexrays.bitset_t.intersect +ida_hexrays.bitset_t.is_subset_of +ida_hexrays.bitset_t.itat +ida_hexrays.bitset_t.itv +ida_hexrays.bitset_t.last +ida_hexrays.bitset_t.shift_down +ida_hexrays.bitset_t.sub +ida_hexrays.bitset_t.swap +ida_hexrays.block_chains_begin +ida_hexrays.block_chains_clear +ida_hexrays.block_chains_end +ida_hexrays.block_chains_erase +ida_hexrays.block_chains_find +ida_hexrays.block_chains_free +ida_hexrays.block_chains_get +ida_hexrays.block_chains_insert +ida_hexrays.block_chains_iterator_t +ida_hexrays.block_chains_iterator_t.__eq__ +ida_hexrays.block_chains_iterator_t.__init__ +ida_hexrays.block_chains_iterator_t.__ne__ +ida_hexrays.block_chains_new +ida_hexrays.block_chains_next +ida_hexrays.block_chains_prev +ida_hexrays.block_chains_size +ida_hexrays.block_chains_t +ida_hexrays.block_chains_t.__init__ +ida_hexrays.block_chains_t._print +ida_hexrays.block_chains_t.dstr +ida_hexrays.block_chains_t.get_chain +ida_hexrays.block_chains_t.get_reg_chain +ida_hexrays.block_chains_t.get_stk_chain +ida_hexrays.block_chains_vec_t +ida_hexrays.block_chains_vec_t.__getitem__ +ida_hexrays.block_chains_vec_t.__init__ +ida_hexrays.block_chains_vec_t.__len__ +ida_hexrays.block_chains_vec_t.__setitem__ +ida_hexrays.block_chains_vec_t.append +ida_hexrays.block_chains_vec_t.at +ida_hexrays.block_chains_vec_t.begin +ida_hexrays.block_chains_vec_t.capacity +ida_hexrays.block_chains_vec_t.clear +ida_hexrays.block_chains_vec_t.empty +ida_hexrays.block_chains_vec_t.end +ida_hexrays.block_chains_vec_t.erase +ida_hexrays.block_chains_vec_t.extend +ida_hexrays.block_chains_vec_t.extract +ida_hexrays.block_chains_vec_t.grow +ida_hexrays.block_chains_vec_t.inject +ida_hexrays.block_chains_vec_t.insert +ida_hexrays.block_chains_vec_t.pop_back +ida_hexrays.block_chains_vec_t.push_back +ida_hexrays.block_chains_vec_t.qclear +ida_hexrays.block_chains_vec_t.reserve +ida_hexrays.block_chains_vec_t.resize +ida_hexrays.block_chains_vec_t.size +ida_hexrays.block_chains_vec_t.swap +ida_hexrays.block_chains_vec_t.truncate +ida_hexrays.boundaries_begin +ida_hexrays.boundaries_clear +ida_hexrays.boundaries_end +ida_hexrays.boundaries_erase +ida_hexrays.boundaries_find +ida_hexrays.boundaries_first +ida_hexrays.boundaries_free +ida_hexrays.boundaries_insert +ida_hexrays.boundaries_iterator_t +ida_hexrays.boundaries_iterator_t.__eq__ +ida_hexrays.boundaries_iterator_t.__init__ +ida_hexrays.boundaries_iterator_t.__ne__ +ida_hexrays.boundaries_new +ida_hexrays.boundaries_next +ida_hexrays.boundaries_prev +ida_hexrays.boundaries_second +ida_hexrays.boundaries_size +ida_hexrays.boundaries_t +ida_hexrays.boundaries_t.__init__ +ida_hexrays.boundaries_t.at +ida_hexrays.boundaries_t.size +ida_hexrays.call_helper +ida_hexrays.carg_t +ida_hexrays.carg_t.__eq__ +ida_hexrays.carg_t.__ge__ +ida_hexrays.carg_t.__gt__ +ida_hexrays.carg_t.__init__ +ida_hexrays.carg_t.__le__ +ida_hexrays.carg_t.__lt__ +ida_hexrays.carg_t.__ne__ +ida_hexrays.carg_t.compare +ida_hexrays.carg_t.consume_cexpr +ida_hexrays.carg_t.formal_type +ida_hexrays.carg_t.is_vararg +ida_hexrays.carglist_t +ida_hexrays.carglist_t.__eq__ +ida_hexrays.carglist_t.__ge__ +ida_hexrays.carglist_t.__gt__ +ida_hexrays.carglist_t.__init__ +ida_hexrays.carglist_t.__le__ +ida_hexrays.carglist_t.__lt__ +ida_hexrays.carglist_t.__ne__ +ida_hexrays.carglist_t.compare +ida_hexrays.carglist_t.flags +ida_hexrays.carglist_t.functype +ida_hexrays.casm_t +ida_hexrays.casm_t.__eq__ +ida_hexrays.casm_t.__ge__ +ida_hexrays.casm_t.__gt__ +ida_hexrays.casm_t.__init__ +ida_hexrays.casm_t.__le__ +ida_hexrays.casm_t.__lt__ +ida_hexrays.casm_t.__ne__ +ida_hexrays.casm_t.compare +ida_hexrays.casm_t.one_insn +ida_hexrays.catchexpr_t +ida_hexrays.catchexpr_t.__eq__ +ida_hexrays.catchexpr_t.__ge__ +ida_hexrays.catchexpr_t.__gt__ +ida_hexrays.catchexpr_t.__init__ +ida_hexrays.catchexpr_t.__le__ +ida_hexrays.catchexpr_t.__lt__ +ida_hexrays.catchexpr_t.__ne__ +ida_hexrays.catchexpr_t.compare +ida_hexrays.catchexpr_t.fake_type +ida_hexrays.catchexpr_t.is_catch_all +ida_hexrays.catchexpr_t.obj +ida_hexrays.catchexpr_t.swap +ida_hexrays.cblock_pos_t +ida_hexrays.cblock_pos_t.__init__ +ida_hexrays.cblock_pos_t.insn +ida_hexrays.cblock_pos_t.is_first_insn +ida_hexrays.cblock_pos_t.prev_insn +ida_hexrays.cblock_posvec_t +ida_hexrays.cblock_posvec_t.__getitem__ +ida_hexrays.cblock_posvec_t.__init__ +ida_hexrays.cblock_posvec_t.__len__ +ida_hexrays.cblock_posvec_t.__setitem__ +ida_hexrays.cblock_posvec_t.append +ida_hexrays.cblock_posvec_t.at +ida_hexrays.cblock_posvec_t.begin +ida_hexrays.cblock_posvec_t.capacity +ida_hexrays.cblock_posvec_t.clear +ida_hexrays.cblock_posvec_t.empty +ida_hexrays.cblock_posvec_t.end +ida_hexrays.cblock_posvec_t.erase +ida_hexrays.cblock_posvec_t.extend +ida_hexrays.cblock_posvec_t.extract +ida_hexrays.cblock_posvec_t.grow +ida_hexrays.cblock_posvec_t.inject +ida_hexrays.cblock_posvec_t.insert +ida_hexrays.cblock_posvec_t.pop_back +ida_hexrays.cblock_posvec_t.push_back +ida_hexrays.cblock_posvec_t.qclear +ida_hexrays.cblock_posvec_t.reserve +ida_hexrays.cblock_posvec_t.resize +ida_hexrays.cblock_posvec_t.size +ida_hexrays.cblock_posvec_t.swap +ida_hexrays.cblock_posvec_t.truncate +ida_hexrays.cblock_t +ida_hexrays.cblock_t.__eq__ +ida_hexrays.cblock_t.__ge__ +ida_hexrays.cblock_t.__gt__ +ida_hexrays.cblock_t.__init__ +ida_hexrays.cblock_t.__le__ +ida_hexrays.cblock_t.__lt__ +ida_hexrays.cblock_t.__ne__ +ida_hexrays.cblock_t._deregister +ida_hexrays.cblock_t.compare +ida_hexrays.ccase_t +ida_hexrays.ccase_t.__eq__ +ida_hexrays.ccase_t.__ge__ +ida_hexrays.ccase_t.__gt__ +ida_hexrays.ccase_t.__init__ +ida_hexrays.ccase_t.__le__ +ida_hexrays.ccase_t.__lt__ +ida_hexrays.ccase_t.__ne__ +ida_hexrays.ccase_t.compare +ida_hexrays.ccase_t.size +ida_hexrays.ccase_t.value +ida_hexrays.ccase_t.values +ida_hexrays.ccases_t +ida_hexrays.ccases_t.__eq__ +ida_hexrays.ccases_t.__ge__ +ida_hexrays.ccases_t.__gt__ +ida_hexrays.ccases_t.__init__ +ida_hexrays.ccases_t.__le__ +ida_hexrays.ccases_t.__lt__ +ida_hexrays.ccases_t.__ne__ +ida_hexrays.ccases_t.compare +ida_hexrays.ccatch_t +ida_hexrays.ccatch_t.__eq__ +ida_hexrays.ccatch_t.__ge__ +ida_hexrays.ccatch_t.__gt__ +ida_hexrays.ccatch_t.__init__ +ida_hexrays.ccatch_t.__le__ +ida_hexrays.ccatch_t.__lt__ +ida_hexrays.ccatch_t.__ne__ +ida_hexrays.ccatch_t.compare +ida_hexrays.ccatch_t.is_catch_all +ida_hexrays.ccatch_t.swap +ida_hexrays.cdg_insn_iterator_t +ida_hexrays.cdg_insn_iterator_t.__init__ +ida_hexrays.cdg_insn_iterator_t.dslot_with_xrefs +ida_hexrays.cdg_insn_iterator_t.has_dslot +ida_hexrays.cdg_insn_iterator_t.is_severed_dslot +ida_hexrays.cdg_insn_iterator_t.next +ida_hexrays.cdg_insn_iterator_t.ok +ida_hexrays.cdg_insn_iterator_t.start +ida_hexrays.cdo_t +ida_hexrays.cdo_t.__eq__ +ida_hexrays.cdo_t.__ge__ +ida_hexrays.cdo_t.__gt__ +ida_hexrays.cdo_t.__init__ +ida_hexrays.cdo_t.__le__ +ida_hexrays.cdo_t.__lt__ +ida_hexrays.cdo_t.__ne__ +ida_hexrays.cdo_t.compare +ida_hexrays.ceinsn_t +ida_hexrays.ceinsn_t.__init__ +ida_hexrays.ceinsn_t.expr +ida_hexrays.cexpr_operands +ida_hexrays.cexpr_t +ida_hexrays.cexpr_t.__eq__ +ida_hexrays.cexpr_t.__ge__ +ida_hexrays.cexpr_t.__gt__ +ida_hexrays.cexpr_t.__init__ +ida_hexrays.cexpr_t.__le__ +ida_hexrays.cexpr_t.__lt__ +ida_hexrays.cexpr_t.__ne__ +ida_hexrays.cexpr_t._deregister +ida_hexrays.cexpr_t._get_a +ida_hexrays.cexpr_t._get_fpc +ida_hexrays.cexpr_t._get_helper +ida_hexrays.cexpr_t._get_insn +ida_hexrays.cexpr_t._get_m +ida_hexrays.cexpr_t._get_n +ida_hexrays.cexpr_t._get_obj_ea +ida_hexrays.cexpr_t._get_ptrsize +ida_hexrays.cexpr_t._get_refwidth +ida_hexrays.cexpr_t._get_string +ida_hexrays.cexpr_t._get_x +ida_hexrays.cexpr_t._get_y +ida_hexrays.cexpr_t._get_z +ida_hexrays.cexpr_t._register +ida_hexrays.cexpr_t._replace_by +ida_hexrays.cexpr_t._set_a +ida_hexrays.cexpr_t._set_fpc +ida_hexrays.cexpr_t._set_helper +ida_hexrays.cexpr_t._set_insn +ida_hexrays.cexpr_t._set_m +ida_hexrays.cexpr_t._set_n +ida_hexrays.cexpr_t._set_obj_ea +ida_hexrays.cexpr_t._set_ptrsize +ida_hexrays.cexpr_t._set_refwidth +ida_hexrays.cexpr_t._set_string +ida_hexrays.cexpr_t._set_x +ida_hexrays.cexpr_t._set_y +ida_hexrays.cexpr_t._set_z +ida_hexrays.cexpr_t.a +ida_hexrays.cexpr_t.assign +ida_hexrays.cexpr_t.calc_type +ida_hexrays.cexpr_t.cleanup +ida_hexrays.cexpr_t.compare +ida_hexrays.cexpr_t.contains_comma +ida_hexrays.cexpr_t.contains_comma_or_insn_or_label +ida_hexrays.cexpr_t.contains_insn +ida_hexrays.cexpr_t.contains_insn_or_label +ida_hexrays.cexpr_t.contains_operator +ida_hexrays.cexpr_t.cpadone +ida_hexrays.cexpr_t.dstr +ida_hexrays.cexpr_t.equal_effect +ida_hexrays.cexpr_t.exflags +ida_hexrays.cexpr_t.find_num_op +ida_hexrays.cexpr_t.find_op +ida_hexrays.cexpr_t.fpc +ida_hexrays.cexpr_t.get_1num_op +ida_hexrays.cexpr_t.get_const_value +ida_hexrays.cexpr_t.get_high_nbit_bound +ida_hexrays.cexpr_t.get_low_nbit_bound +ida_hexrays.cexpr_t.get_ptr_or_array +ida_hexrays.cexpr_t.get_type_sign +ida_hexrays.cexpr_t.get_v +ida_hexrays.cexpr_t.has_side_effects +ida_hexrays.cexpr_t.helper +ida_hexrays.cexpr_t.insn +ida_hexrays.cexpr_t.is_call_arg_of +ida_hexrays.cexpr_t.is_call_object_of +ida_hexrays.cexpr_t.is_child_of +ida_hexrays.cexpr_t.is_const_value +ida_hexrays.cexpr_t.is_cstr +ida_hexrays.cexpr_t.is_fpop +ida_hexrays.cexpr_t.is_jumpout +ida_hexrays.cexpr_t.is_negative_const +ida_hexrays.cexpr_t.is_nice_cond +ida_hexrays.cexpr_t.is_nice_expr +ida_hexrays.cexpr_t.is_non_negative_const +ida_hexrays.cexpr_t.is_non_zero_const +ida_hexrays.cexpr_t.is_odd_lvalue +ida_hexrays.cexpr_t.is_type_signed +ida_hexrays.cexpr_t.is_type_unsigned +ida_hexrays.cexpr_t.is_undef_val +ida_hexrays.cexpr_t.is_vftable +ida_hexrays.cexpr_t.is_zero_const +ida_hexrays.cexpr_t.m +ida_hexrays.cexpr_t.maybe_ptr +ida_hexrays.cexpr_t.n +ida_hexrays.cexpr_t.numval +ida_hexrays.cexpr_t.obj_ea +ida_hexrays.cexpr_t.print1 +ida_hexrays.cexpr_t.ptrsize +ida_hexrays.cexpr_t.put_number +ida_hexrays.cexpr_t.refwidth +ida_hexrays.cexpr_t.requires_lvalue +ida_hexrays.cexpr_t.set_cpadone +ida_hexrays.cexpr_t.set_v +ida_hexrays.cexpr_t.set_vftable +ida_hexrays.cexpr_t.string +ida_hexrays.cexpr_t.swap +ida_hexrays.cexpr_t.theother +ida_hexrays.cexpr_t.type +ida_hexrays.cexpr_t.v +ida_hexrays.cexpr_t.x +ida_hexrays.cexpr_t.y +ida_hexrays.cexpr_t.z +ida_hexrays.cfor_t +ida_hexrays.cfor_t.__eq__ +ida_hexrays.cfor_t.__ge__ +ida_hexrays.cfor_t.__gt__ +ida_hexrays.cfor_t.__init__ +ida_hexrays.cfor_t.__le__ +ida_hexrays.cfor_t.__lt__ +ida_hexrays.cfor_t.__ne__ +ida_hexrays.cfor_t.compare +ida_hexrays.cfor_t.init +ida_hexrays.cfor_t.step +ida_hexrays.cfunc_parentee_t +ida_hexrays.cfunc_parentee_t.__disown__ +ida_hexrays.cfunc_parentee_t.__init__ +ida_hexrays.cfunc_parentee_t.calc_rvalue_type +ida_hexrays.cfunc_parentee_t.func +ida_hexrays.cfunc_t +ida_hexrays.cfunc_t.__init__ +ida_hexrays.cfunc_t.__str__ +ida_hexrays.cfunc_t.argidx +ida_hexrays.cfunc_t.body +ida_hexrays.cfunc_t.build_c_tree +ida_hexrays.cfunc_t.del_orphan_cmts +ida_hexrays.cfunc_t.entry_ea +ida_hexrays.cfunc_t.find_item_coords +ida_hexrays.cfunc_t.find_label +ida_hexrays.cfunc_t.gather_derefs +ida_hexrays.cfunc_t.get_boundaries +ida_hexrays.cfunc_t.get_eamap +ida_hexrays.cfunc_t.get_func_type +ida_hexrays.cfunc_t.get_line_item +ida_hexrays.cfunc_t.get_lvars +ida_hexrays.cfunc_t.get_pseudocode +ida_hexrays.cfunc_t.get_stkoff_delta +ida_hexrays.cfunc_t.get_user_cmt +ida_hexrays.cfunc_t.get_user_iflags +ida_hexrays.cfunc_t.get_user_union_selection +ida_hexrays.cfunc_t.get_warnings +ida_hexrays.cfunc_t.has_orphan_cmts +ida_hexrays.cfunc_t.hdrlines +ida_hexrays.cfunc_t.locked +ida_hexrays.cfunc_t.maturity +ida_hexrays.cfunc_t.mba +ida_hexrays.cfunc_t.numforms +ida_hexrays.cfunc_t.print_dcl +ida_hexrays.cfunc_t.print_func +ida_hexrays.cfunc_t.refcnt +ida_hexrays.cfunc_t.refresh_func_ctext +ida_hexrays.cfunc_t.release +ida_hexrays.cfunc_t.remove_unused_labels +ida_hexrays.cfunc_t.save_user_cmts +ida_hexrays.cfunc_t.save_user_iflags +ida_hexrays.cfunc_t.save_user_labels +ida_hexrays.cfunc_t.save_user_numforms +ida_hexrays.cfunc_t.save_user_unions +ida_hexrays.cfunc_t.set_user_cmt +ida_hexrays.cfunc_t.set_user_iflags +ida_hexrays.cfunc_t.set_user_union_selection +ida_hexrays.cfunc_t.statebits +ida_hexrays.cfunc_t.treeitems +ida_hexrays.cfunc_t.user_cmts +ida_hexrays.cfunc_t.user_iflags +ida_hexrays.cfunc_t.user_labels +ida_hexrays.cfunc_t.user_unions +ida_hexrays.cfunc_t.verify +ida_hexrays.cfunc_type +ida_hexrays.cfuncptr_t +ida_hexrays.cfuncptr_t.__deref__ +ida_hexrays.cfuncptr_t.__init__ +ida_hexrays.cfuncptr_t.__ptrval__ +ida_hexrays.cfuncptr_t.__ref__ +ida_hexrays.cfuncptr_t.__str__ +ida_hexrays.cfuncptr_t.build_c_tree +ida_hexrays.cfuncptr_t.del_orphan_cmts +ida_hexrays.cfuncptr_t.find_item_coords +ida_hexrays.cfuncptr_t.find_label +ida_hexrays.cfuncptr_t.gather_derefs +ida_hexrays.cfuncptr_t.get_boundaries +ida_hexrays.cfuncptr_t.get_eamap +ida_hexrays.cfuncptr_t.get_func_type +ida_hexrays.cfuncptr_t.get_line_item +ida_hexrays.cfuncptr_t.get_lvars +ida_hexrays.cfuncptr_t.get_pseudocode +ida_hexrays.cfuncptr_t.get_stkoff_delta +ida_hexrays.cfuncptr_t.get_user_cmt +ida_hexrays.cfuncptr_t.get_user_iflags +ida_hexrays.cfuncptr_t.get_user_union_selection +ida_hexrays.cfuncptr_t.get_warnings +ida_hexrays.cfuncptr_t.has_orphan_cmts +ida_hexrays.cfuncptr_t.locked +ida_hexrays.cfuncptr_t.print_dcl +ida_hexrays.cfuncptr_t.print_func +ida_hexrays.cfuncptr_t.refresh_func_ctext +ida_hexrays.cfuncptr_t.release +ida_hexrays.cfuncptr_t.remove_unused_labels +ida_hexrays.cfuncptr_t.reset +ida_hexrays.cfuncptr_t.save_user_cmts +ida_hexrays.cfuncptr_t.save_user_iflags +ida_hexrays.cfuncptr_t.save_user_labels +ida_hexrays.cfuncptr_t.save_user_numforms +ida_hexrays.cfuncptr_t.save_user_unions +ida_hexrays.cfuncptr_t.set_user_cmt +ida_hexrays.cfuncptr_t.set_user_iflags +ida_hexrays.cfuncptr_t.set_user_union_selection +ida_hexrays.cfuncptr_t.verify +ida_hexrays.cgoto_t +ida_hexrays.cgoto_t.__eq__ +ida_hexrays.cgoto_t.__ge__ +ida_hexrays.cgoto_t.__gt__ +ida_hexrays.cgoto_t.__init__ +ida_hexrays.cgoto_t.__le__ +ida_hexrays.cgoto_t.__lt__ +ida_hexrays.cgoto_t.__ne__ +ida_hexrays.cgoto_t.compare +ida_hexrays.cgoto_t.label_num +ida_hexrays.chain_keeper_t +ida_hexrays.chain_keeper_t.__init__ +ida_hexrays.chain_keeper_t.back +ida_hexrays.chain_keeper_t.for_all_chains +ida_hexrays.chain_keeper_t.front +ida_hexrays.chain_t +ida_hexrays.chain_t.__init__ +ida_hexrays.chain_t.__lt__ +ida_hexrays.chain_t._print +ida_hexrays.chain_t.append_list +ida_hexrays.chain_t.clear_varnum +ida_hexrays.chain_t.dstr +ida_hexrays.chain_t.endoff +ida_hexrays.chain_t.flags +ida_hexrays.chain_t.get_reg +ida_hexrays.chain_t.get_stkoff +ida_hexrays.chain_t.includes +ida_hexrays.chain_t.is_fake +ida_hexrays.chain_t.is_inited +ida_hexrays.chain_t.is_overlapped +ida_hexrays.chain_t.is_passreg +ida_hexrays.chain_t.is_reg +ida_hexrays.chain_t.is_replaced +ida_hexrays.chain_t.is_stkoff +ida_hexrays.chain_t.is_term +ida_hexrays.chain_t.key +ida_hexrays.chain_t.overlap +ida_hexrays.chain_t.set_inited +ida_hexrays.chain_t.set_overlapped +ida_hexrays.chain_t.set_replaced +ida_hexrays.chain_t.set_term +ida_hexrays.chain_t.set_value +ida_hexrays.chain_t.varnum +ida_hexrays.chain_t.width +ida_hexrays.chain_visitor_t +ida_hexrays.chain_visitor_t.__disown__ +ida_hexrays.chain_visitor_t.__init__ +ida_hexrays.chain_visitor_t.parent +ida_hexrays.chain_visitor_t.visit_chain +ida_hexrays.change_hexrays_config +ida_hexrays.cif_t +ida_hexrays.cif_t.__eq__ +ida_hexrays.cif_t.__ge__ +ida_hexrays.cif_t.__gt__ +ida_hexrays.cif_t.__init__ +ida_hexrays.cif_t.__le__ +ida_hexrays.cif_t.__lt__ +ida_hexrays.cif_t.__ne__ +ida_hexrays.cif_t.assign +ida_hexrays.cif_t.cleanup +ida_hexrays.cif_t.compare +ida_hexrays.cif_t.ielse +ida_hexrays.cif_t.ithen +ida_hexrays.cinsn_details +ida_hexrays.cinsn_list_t +ida_hexrays.cinsn_list_t.__eq__ +ida_hexrays.cinsn_list_t.__getitem__ +ida_hexrays.cinsn_list_t.__init__ +ida_hexrays.cinsn_list_t.__len__ +ida_hexrays.cinsn_list_t.__ne__ +ida_hexrays.cinsn_list_t.__setitem__ +ida_hexrays.cinsn_list_t.at +ida_hexrays.cinsn_list_t.back +ida_hexrays.cinsn_list_t.begin +ida_hexrays.cinsn_list_t.clear +ida_hexrays.cinsn_list_t.empty +ida_hexrays.cinsn_list_t.end +ida_hexrays.cinsn_list_t.erase +ida_hexrays.cinsn_list_t.find +ida_hexrays.cinsn_list_t.front +ida_hexrays.cinsn_list_t.index +ida_hexrays.cinsn_list_t.insert +ida_hexrays.cinsn_list_t.pop_back +ida_hexrays.cinsn_list_t.pop_front +ida_hexrays.cinsn_list_t.push_back +ida_hexrays.cinsn_list_t.push_front +ida_hexrays.cinsn_list_t.rbegin +ida_hexrays.cinsn_list_t.remove +ida_hexrays.cinsn_list_t.rend +ida_hexrays.cinsn_list_t.size +ida_hexrays.cinsn_list_t.splice +ida_hexrays.cinsn_list_t.swap +ida_hexrays.cinsn_list_t_iterator +ida_hexrays.cinsn_list_t_iterator.__eq__ +ida_hexrays.cinsn_list_t_iterator.__init__ +ida_hexrays.cinsn_list_t_iterator.__ne__ +ida_hexrays.cinsn_list_t_iterator.__next__ +ida_hexrays.cinsn_t +ida_hexrays.cinsn_t.__eq__ +ida_hexrays.cinsn_t.__ge__ +ida_hexrays.cinsn_t.__gt__ +ida_hexrays.cinsn_t.__init__ +ida_hexrays.cinsn_t.__le__ +ida_hexrays.cinsn_t.__lt__ +ida_hexrays.cinsn_t.__ne__ +ida_hexrays.cinsn_t._deregister +ida_hexrays.cinsn_t._get_casm +ida_hexrays.cinsn_t._get_cblock +ida_hexrays.cinsn_t._get_cdo +ida_hexrays.cinsn_t._get_cexpr +ida_hexrays.cinsn_t._get_cfor +ida_hexrays.cinsn_t._get_cgoto +ida_hexrays.cinsn_t._get_cif +ida_hexrays.cinsn_t._get_creturn +ida_hexrays.cinsn_t._get_cswitch +ida_hexrays.cinsn_t._get_cwhile +ida_hexrays.cinsn_t._print +ida_hexrays.cinsn_t._register +ida_hexrays.cinsn_t._replace_by +ida_hexrays.cinsn_t._set_casm +ida_hexrays.cinsn_t._set_cblock +ida_hexrays.cinsn_t._set_cdo +ida_hexrays.cinsn_t._set_cexpr +ida_hexrays.cinsn_t._set_cfor +ida_hexrays.cinsn_t._set_cgoto +ida_hexrays.cinsn_t._set_cif +ida_hexrays.cinsn_t._set_creturn +ida_hexrays.cinsn_t._set_cswitch +ida_hexrays.cinsn_t._set_cwhile +ida_hexrays.cinsn_t.assign +ida_hexrays.cinsn_t.casm +ida_hexrays.cinsn_t.cblock +ida_hexrays.cinsn_t.cdo +ida_hexrays.cinsn_t.cexpr +ida_hexrays.cinsn_t.cfor +ida_hexrays.cinsn_t.cgoto +ida_hexrays.cinsn_t.cif +ida_hexrays.cinsn_t.cleanup +ida_hexrays.cinsn_t.collect_free_breaks +ida_hexrays.cinsn_t.collect_free_continues +ida_hexrays.cinsn_t.compare +ida_hexrays.cinsn_t.contains_free_break +ida_hexrays.cinsn_t.contains_free_continue +ida_hexrays.cinsn_t.contains_insn +ida_hexrays.cinsn_t.create_if +ida_hexrays.cinsn_t.creturn +ida_hexrays.cinsn_t.cswitch +ida_hexrays.cinsn_t.cthrow +ida_hexrays.cinsn_t.ctry +ida_hexrays.cinsn_t.cwhile +ida_hexrays.cinsn_t.dstr +ida_hexrays.cinsn_t.insn_is_epilog +ida_hexrays.cinsn_t.is_epilog +ida_hexrays.cinsn_t.is_ordinary_flow +ida_hexrays.cinsn_t.new_insn +ida_hexrays.cinsn_t.print1 +ida_hexrays.cinsn_t.swap +ida_hexrays.cinsn_t.zero +ida_hexrays.cinsnptrvec_t +ida_hexrays.cinsnptrvec_t.__eq__ +ida_hexrays.cinsnptrvec_t.__getitem__ +ida_hexrays.cinsnptrvec_t.__init__ +ida_hexrays.cinsnptrvec_t.__len__ +ida_hexrays.cinsnptrvec_t.__ne__ +ida_hexrays.cinsnptrvec_t.__setitem__ +ida_hexrays.cinsnptrvec_t._del +ida_hexrays.cinsnptrvec_t.add_unique +ida_hexrays.cinsnptrvec_t.append +ida_hexrays.cinsnptrvec_t.at +ida_hexrays.cinsnptrvec_t.begin +ida_hexrays.cinsnptrvec_t.capacity +ida_hexrays.cinsnptrvec_t.clear +ida_hexrays.cinsnptrvec_t.empty +ida_hexrays.cinsnptrvec_t.end +ida_hexrays.cinsnptrvec_t.erase +ida_hexrays.cinsnptrvec_t.extend +ida_hexrays.cinsnptrvec_t.extract +ida_hexrays.cinsnptrvec_t.find +ida_hexrays.cinsnptrvec_t.has +ida_hexrays.cinsnptrvec_t.inject +ida_hexrays.cinsnptrvec_t.insert +ida_hexrays.cinsnptrvec_t.pop_back +ida_hexrays.cinsnptrvec_t.push_back +ida_hexrays.cinsnptrvec_t.qclear +ida_hexrays.cinsnptrvec_t.reserve +ida_hexrays.cinsnptrvec_t.resize +ida_hexrays.cinsnptrvec_t.size +ida_hexrays.cinsnptrvec_t.swap +ida_hexrays.cinsnptrvec_t.truncate +ida_hexrays.cit_asm +ida_hexrays.cit_block +ida_hexrays.cit_break +ida_hexrays.cit_continue +ida_hexrays.cit_do +ida_hexrays.cit_empty +ida_hexrays.cit_expr +ida_hexrays.cit_for +ida_hexrays.cit_goto +ida_hexrays.cit_if +ida_hexrays.cit_return +ida_hexrays.cit_switch +ida_hexrays.cit_throw +ida_hexrays.cit_try +ida_hexrays.cit_while +ida_hexrays.citem_cmt_t +ida_hexrays.citem_cmt_t.__init__ +ida_hexrays.citem_cmt_t.__str__ +ida_hexrays.citem_cmt_t.c_str +ida_hexrays.citem_cmt_t.used +ida_hexrays.citem_locator_t +ida_hexrays.citem_locator_t.__eq__ +ida_hexrays.citem_locator_t.__ge__ +ida_hexrays.citem_locator_t.__gt__ +ida_hexrays.citem_locator_t.__init__ +ida_hexrays.citem_locator_t.__le__ +ida_hexrays.citem_locator_t.__lt__ +ida_hexrays.citem_locator_t.__ne__ +ida_hexrays.citem_locator_t.compare +ida_hexrays.citem_locator_t.ea +ida_hexrays.citem_locator_t.op +ida_hexrays.citem_t +ida_hexrays.citem_t.__dbg_get_meminfo +ida_hexrays.citem_t.__dbg_get_registered_kind +ida_hexrays.citem_t.__init__ +ida_hexrays.citem_t._acquire_ownership +ida_hexrays.citem_t._ensure_cond +ida_hexrays.citem_t._ensure_no_obj +ida_hexrays.citem_t._ensure_no_op +ida_hexrays.citem_t._ensure_ownership_transferrable +ida_hexrays.citem_t._get_op +ida_hexrays.citem_t._maybe_disown_and_deregister +ida_hexrays.citem_t._meminfo +ida_hexrays.citem_t._obj_id +ida_hexrays.citem_t._own_and_register +ida_hexrays.citem_t._set_op +ida_hexrays.citem_t.contains_expr +ida_hexrays.citem_t.contains_label +ida_hexrays.citem_t.ea +ida_hexrays.citem_t.find_closest_addr +ida_hexrays.citem_t.find_parent_of +ida_hexrays.citem_t.index +ida_hexrays.citem_t.is_expr +ida_hexrays.citem_t.label_num +ida_hexrays.citem_t.op +ida_hexrays.citem_t.print1 +ida_hexrays.citem_t.replace_by +ida_hexrays.citem_t.swap +ida_hexrays.citem_to_specific_type +ida_hexrays.clear_cached_cfuncs +ida_hexrays.cloop_t +ida_hexrays.cloop_t.__init__ +ida_hexrays.cloop_t.assign +ida_hexrays.cloop_t.cleanup +ida_hexrays.close_hexrays_waitbox +ida_hexrays.close_pseudocode +ida_hexrays.cnumber_t +ida_hexrays.cnumber_t.__eq__ +ida_hexrays.cnumber_t.__ge__ +ida_hexrays.cnumber_t.__gt__ +ida_hexrays.cnumber_t.__init__ +ida_hexrays.cnumber_t.__le__ +ida_hexrays.cnumber_t.__lt__ +ida_hexrays.cnumber_t.__ne__ +ida_hexrays.cnumber_t._print +ida_hexrays.cnumber_t._value +ida_hexrays.cnumber_t.assign +ida_hexrays.cnumber_t.compare +ida_hexrays.cnumber_t.nf +ida_hexrays.cnumber_t.value +ida_hexrays.codegen_t +ida_hexrays.codegen_t.__init__ +ida_hexrays.codegen_t.analyze_prolog +ida_hexrays.codegen_t.clear +ida_hexrays.codegen_t.emit +ida_hexrays.codegen_t.emit_micro_mvm +ida_hexrays.codegen_t.gen_micro +ida_hexrays.codegen_t.load_effective_address +ida_hexrays.codegen_t.load_operand +ida_hexrays.codegen_t.microgen_completed +ida_hexrays.codegen_t.prepare_gen_micro +ida_hexrays.codegen_t.store_operand +ida_hexrays.convert_to_user_call +ida_hexrays.cot_add +ida_hexrays.cot_asg +ida_hexrays.cot_asgadd +ida_hexrays.cot_asgband +ida_hexrays.cot_asgbor +ida_hexrays.cot_asgmul +ida_hexrays.cot_asgsdiv +ida_hexrays.cot_asgshl +ida_hexrays.cot_asgsmod +ida_hexrays.cot_asgsshr +ida_hexrays.cot_asgsub +ida_hexrays.cot_asgudiv +ida_hexrays.cot_asgumod +ida_hexrays.cot_asgushr +ida_hexrays.cot_asgxor +ida_hexrays.cot_band +ida_hexrays.cot_bnot +ida_hexrays.cot_bor +ida_hexrays.cot_call +ida_hexrays.cot_cast +ida_hexrays.cot_comma +ida_hexrays.cot_eq +ida_hexrays.cot_fadd +ida_hexrays.cot_fdiv +ida_hexrays.cot_fmul +ida_hexrays.cot_fneg +ida_hexrays.cot_fnum +ida_hexrays.cot_fsub +ida_hexrays.cot_helper +ida_hexrays.cot_idx +ida_hexrays.cot_insn +ida_hexrays.cot_land +ida_hexrays.cot_lnot +ida_hexrays.cot_lor +ida_hexrays.cot_memptr +ida_hexrays.cot_memref +ida_hexrays.cot_mul +ida_hexrays.cot_ne +ida_hexrays.cot_neg +ida_hexrays.cot_num +ida_hexrays.cot_obj +ida_hexrays.cot_postdec +ida_hexrays.cot_postinc +ida_hexrays.cot_predec +ida_hexrays.cot_preinc +ida_hexrays.cot_ptr +ida_hexrays.cot_ref +ida_hexrays.cot_sdiv +ida_hexrays.cot_sge +ida_hexrays.cot_sgt +ida_hexrays.cot_shl +ida_hexrays.cot_sizeof +ida_hexrays.cot_sle +ida_hexrays.cot_slt +ida_hexrays.cot_smod +ida_hexrays.cot_sshr +ida_hexrays.cot_str +ida_hexrays.cot_sub +ida_hexrays.cot_tern +ida_hexrays.cot_type +ida_hexrays.cot_udiv +ida_hexrays.cot_uge +ida_hexrays.cot_ugt +ida_hexrays.cot_ule +ida_hexrays.cot_ult +ida_hexrays.cot_umod +ida_hexrays.cot_ushr +ida_hexrays.cot_var +ida_hexrays.cot_xor +ida_hexrays.create_cfunc +ida_hexrays.create_empty_mba +ida_hexrays.create_field_name +ida_hexrays.create_helper +ida_hexrays.create_typedef +ida_hexrays.creturn_t +ida_hexrays.creturn_t.__eq__ +ida_hexrays.creturn_t.__ge__ +ida_hexrays.creturn_t.__gt__ +ida_hexrays.creturn_t.__init__ +ida_hexrays.creturn_t.__le__ +ida_hexrays.creturn_t.__lt__ +ida_hexrays.creturn_t.__ne__ +ida_hexrays.creturn_t.compare +ida_hexrays.cswitch_t +ida_hexrays.cswitch_t.__eq__ +ida_hexrays.cswitch_t.__ge__ +ida_hexrays.cswitch_t.__gt__ +ida_hexrays.cswitch_t.__init__ +ida_hexrays.cswitch_t.__le__ +ida_hexrays.cswitch_t.__lt__ +ida_hexrays.cswitch_t.__ne__ +ida_hexrays.cswitch_t.cases +ida_hexrays.cswitch_t.compare +ida_hexrays.cswitch_t.mvnf +ida_hexrays.ctext_position_t +ida_hexrays.ctext_position_t.__eq__ +ida_hexrays.ctext_position_t.__ge__ +ida_hexrays.ctext_position_t.__gt__ +ida_hexrays.ctext_position_t.__init__ +ida_hexrays.ctext_position_t.__le__ +ida_hexrays.ctext_position_t.__lt__ +ida_hexrays.ctext_position_t.__ne__ +ida_hexrays.ctext_position_t.compare +ida_hexrays.ctext_position_t.in_ctree +ida_hexrays.ctext_position_t.lnnum +ida_hexrays.ctext_position_t.x +ida_hexrays.ctext_position_t.y +ida_hexrays.cthrow_t +ida_hexrays.cthrow_t.__eq__ +ida_hexrays.cthrow_t.__ge__ +ida_hexrays.cthrow_t.__gt__ +ida_hexrays.cthrow_t.__init__ +ida_hexrays.cthrow_t.__le__ +ida_hexrays.cthrow_t.__lt__ +ida_hexrays.cthrow_t.__ne__ +ida_hexrays.cthrow_t.compare +ida_hexrays.ctree_anchor_t +ida_hexrays.ctree_anchor_t.__init__ +ida_hexrays.ctree_anchor_t.get_index +ida_hexrays.ctree_anchor_t.get_itp +ida_hexrays.ctree_anchor_t.is_blkcmt_anchor +ida_hexrays.ctree_anchor_t.is_citem_anchor +ida_hexrays.ctree_anchor_t.is_itp_anchor +ida_hexrays.ctree_anchor_t.is_lvar_anchor +ida_hexrays.ctree_anchor_t.is_valid_anchor +ida_hexrays.ctree_item_t +ida_hexrays.ctree_item_t.__init__ +ida_hexrays.ctree_item_t._get_e +ida_hexrays.ctree_item_t._get_f +ida_hexrays.ctree_item_t._get_i +ida_hexrays.ctree_item_t._get_it +ida_hexrays.ctree_item_t._get_l +ida_hexrays.ctree_item_t._print +ida_hexrays.ctree_item_t.citype +ida_hexrays.ctree_item_t.dstr +ida_hexrays.ctree_item_t.e +ida_hexrays.ctree_item_t.e +ida_hexrays.ctree_item_t.f +ida_hexrays.ctree_item_t.f +ida_hexrays.ctree_item_t.get_ea +ida_hexrays.ctree_item_t.get_edm +ida_hexrays.ctree_item_t.get_label_num +ida_hexrays.ctree_item_t.get_lvar +ida_hexrays.ctree_item_t.get_udm +ida_hexrays.ctree_item_t.i +ida_hexrays.ctree_item_t.i +ida_hexrays.ctree_item_t.is_citem +ida_hexrays.ctree_item_t.l +ida_hexrays.ctree_item_t.l +ida_hexrays.ctree_item_t.loc +ida_hexrays.ctree_items_t +ida_hexrays.ctree_items_t.__eq__ +ida_hexrays.ctree_items_t.__getitem__ +ida_hexrays.ctree_items_t.__init__ +ida_hexrays.ctree_items_t.__len__ +ida_hexrays.ctree_items_t.__ne__ +ida_hexrays.ctree_items_t.__setitem__ +ida_hexrays.ctree_items_t._del +ida_hexrays.ctree_items_t.add_unique +ida_hexrays.ctree_items_t.append +ida_hexrays.ctree_items_t.at +ida_hexrays.ctree_items_t.begin +ida_hexrays.ctree_items_t.capacity +ida_hexrays.ctree_items_t.clear +ida_hexrays.ctree_items_t.empty +ida_hexrays.ctree_items_t.end +ida_hexrays.ctree_items_t.erase +ida_hexrays.ctree_items_t.extend +ida_hexrays.ctree_items_t.extract +ida_hexrays.ctree_items_t.find +ida_hexrays.ctree_items_t.has +ida_hexrays.ctree_items_t.inject +ida_hexrays.ctree_items_t.insert +ida_hexrays.ctree_items_t.pop_back +ida_hexrays.ctree_items_t.push_back +ida_hexrays.ctree_items_t.qclear +ida_hexrays.ctree_items_t.reserve +ida_hexrays.ctree_items_t.resize +ida_hexrays.ctree_items_t.size +ida_hexrays.ctree_items_t.swap +ida_hexrays.ctree_items_t.truncate +ida_hexrays.ctree_parentee_t +ida_hexrays.ctree_parentee_t.__disown__ +ida_hexrays.ctree_parentee_t.__init__ +ida_hexrays.ctree_parentee_t.recalc_parent_types +ida_hexrays.ctree_visitor_t +ida_hexrays.ctree_visitor_t.__disown__ +ida_hexrays.ctree_visitor_t.__init__ +ida_hexrays.ctree_visitor_t.apply_to +ida_hexrays.ctree_visitor_t.apply_to_exprs +ida_hexrays.ctree_visitor_t.bposvec +ida_hexrays.ctree_visitor_t.clr_prune +ida_hexrays.ctree_visitor_t.clr_restart +ida_hexrays.ctree_visitor_t.cv_flags +ida_hexrays.ctree_visitor_t.is_postorder +ida_hexrays.ctree_visitor_t.leave_expr +ida_hexrays.ctree_visitor_t.leave_insn +ida_hexrays.ctree_visitor_t.maintain_parents +ida_hexrays.ctree_visitor_t.must_prune +ida_hexrays.ctree_visitor_t.must_restart +ida_hexrays.ctree_visitor_t.only_insns +ida_hexrays.ctree_visitor_t.parent_expr +ida_hexrays.ctree_visitor_t.parent_insn +ida_hexrays.ctree_visitor_t.parents +ida_hexrays.ctree_visitor_t.prune_now +ida_hexrays.ctree_visitor_t.set_restart +ida_hexrays.ctree_visitor_t.visit_expr +ida_hexrays.ctree_visitor_t.visit_insn +ida_hexrays.ctry_t +ida_hexrays.ctry_t.__eq__ +ida_hexrays.ctry_t.__ge__ +ida_hexrays.ctry_t.__gt__ +ida_hexrays.ctry_t.__init__ +ida_hexrays.ctry_t.__le__ +ida_hexrays.ctry_t.__lt__ +ida_hexrays.ctry_t.__ne__ +ida_hexrays.ctry_t.catchs +ida_hexrays.ctry_t.compare +ida_hexrays.ctry_t.is_wind +ida_hexrays.ctry_t.new_state +ida_hexrays.ctry_t.old_state +ida_hexrays.cwhile_t +ida_hexrays.cwhile_t.__eq__ +ida_hexrays.cwhile_t.__ge__ +ida_hexrays.cwhile_t.__gt__ +ida_hexrays.cwhile_t.__init__ +ida_hexrays.cwhile_t.__le__ +ida_hexrays.cwhile_t.__lt__ +ida_hexrays.cwhile_t.__ne__ +ida_hexrays.cwhile_t.compare +ida_hexrays.debug_hexrays_ctree +ida_hexrays.decompile +ida_hexrays.decompile +ida_hexrays.decompile_func +ida_hexrays.decompile_many +ida_hexrays.dereference +ida_hexrays.dstr +ida_hexrays.dummy_ptrtype +ida_hexrays.eamap_begin +ida_hexrays.eamap_clear +ida_hexrays.eamap_end +ida_hexrays.eamap_erase +ida_hexrays.eamap_find +ida_hexrays.eamap_first +ida_hexrays.eamap_free +ida_hexrays.eamap_insert +ida_hexrays.eamap_iterator_t +ida_hexrays.eamap_iterator_t.__eq__ +ida_hexrays.eamap_iterator_t.__init__ +ida_hexrays.eamap_iterator_t.__ne__ +ida_hexrays.eamap_new +ida_hexrays.eamap_next +ida_hexrays.eamap_prev +ida_hexrays.eamap_second +ida_hexrays.eamap_size +ida_hexrays.eamap_t +ida_hexrays.eamap_t.__init__ +ida_hexrays.eamap_t.at +ida_hexrays.eamap_t.size +ida_hexrays.fnumber_t +ida_hexrays.fnumber_t.__eq__ +ida_hexrays.fnumber_t.__ge__ +ida_hexrays.fnumber_t.__gt__ +ida_hexrays.fnumber_t.__init__ +ida_hexrays.fnumber_t.__le__ +ida_hexrays.fnumber_t.__lt__ +ida_hexrays.fnumber_t.__ne__ +ida_hexrays.fnumber_t._print +ida_hexrays.fnumber_t.calc_max_exp +ida_hexrays.fnumber_t.compare +ida_hexrays.fnumber_t.dereference_const_uint16 +ida_hexrays.fnumber_t.dereference_uint16 +ida_hexrays.fnumber_t.fnum +ida_hexrays.fnumber_t.is_nan +ida_hexrays.fnumber_t.nbytes +ida_hexrays.gco_info_t +ida_hexrays.gco_info_t.__init__ +ida_hexrays.gco_info_t.append_to_list +ida_hexrays.gco_info_t.cvt_to_ivl +ida_hexrays.gco_info_t.is_def +ida_hexrays.gco_info_t.is_reg +ida_hexrays.gco_info_t.is_use +ida_hexrays.gco_info_t.name +ida_hexrays.gco_info_t.regnum +ida_hexrays.gco_info_t.size +ida_hexrays.gco_info_t.stkoff +ida_hexrays.gen_microcode +ida_hexrays.get_ctype_name +ida_hexrays.get_current_operand +ida_hexrays.get_float_type +ida_hexrays.get_hexrays_version +ida_hexrays.get_int_type_by_width_and_sign +ida_hexrays.get_merror_desc +ida_hexrays.get_mreg_name +ida_hexrays.get_op_signness +ida_hexrays.get_signed_mcode +ida_hexrays.get_temp_regs +ida_hexrays.get_type +ida_hexrays.get_unk_type +ida_hexrays.get_unsigned_mcode +ida_hexrays.get_widget_vdui +ida_hexrays.getb_reginsn +ida_hexrays.getf_reginsn +ida_hexrays.graph_chains_t +ida_hexrays.graph_chains_t.__init__ +ida_hexrays.graph_chains_t.acquire +ida_hexrays.graph_chains_t.for_all_chains +ida_hexrays.graph_chains_t.is_locked +ida_hexrays.graph_chains_t.release +ida_hexrays.graph_chains_t.swap +ida_hexrays.has_cached_cfunc +ida_hexrays.has_mcode_seloff +ida_hexrays.hexrays_alloc +ida_hexrays.hexrays_failure_t +ida_hexrays.hexrays_failure_t.__init__ +ida_hexrays.hexrays_failure_t.code +ida_hexrays.hexrays_failure_t.desc +ida_hexrays.hexrays_failure_t.errea +ida_hexrays.hexrays_failure_t.str +ida_hexrays.hexrays_free +ida_hexrays.hexwarn_t +ida_hexrays.hexwarn_t.__eq__ +ida_hexrays.hexwarn_t.__ge__ +ida_hexrays.hexwarn_t.__gt__ +ida_hexrays.hexwarn_t.__init__ +ida_hexrays.hexwarn_t.__le__ +ida_hexrays.hexwarn_t.__lt__ +ida_hexrays.hexwarn_t.__ne__ +ida_hexrays.hexwarn_t.compare +ida_hexrays.hexwarn_t.ea +ida_hexrays.hexwarn_t.id +ida_hexrays.hexwarn_t.text +ida_hexrays.hexwarns_t +ida_hexrays.hexwarns_t.__eq__ +ida_hexrays.hexwarns_t.__getitem__ +ida_hexrays.hexwarns_t.__init__ +ida_hexrays.hexwarns_t.__len__ +ida_hexrays.hexwarns_t.__ne__ +ida_hexrays.hexwarns_t.__setitem__ +ida_hexrays.hexwarns_t._del +ida_hexrays.hexwarns_t.add_unique +ida_hexrays.hexwarns_t.append +ida_hexrays.hexwarns_t.at +ida_hexrays.hexwarns_t.begin +ida_hexrays.hexwarns_t.capacity +ida_hexrays.hexwarns_t.clear +ida_hexrays.hexwarns_t.empty +ida_hexrays.hexwarns_t.end +ida_hexrays.hexwarns_t.erase +ida_hexrays.hexwarns_t.extend +ida_hexrays.hexwarns_t.extract +ida_hexrays.hexwarns_t.find +ida_hexrays.hexwarns_t.grow +ida_hexrays.hexwarns_t.has +ida_hexrays.hexwarns_t.inject +ida_hexrays.hexwarns_t.insert +ida_hexrays.hexwarns_t.pop_back +ida_hexrays.hexwarns_t.push_back +ida_hexrays.hexwarns_t.qclear +ida_hexrays.hexwarns_t.reserve +ida_hexrays.hexwarns_t.resize +ida_hexrays.hexwarns_t.size +ida_hexrays.hexwarns_t.swap +ida_hexrays.hexwarns_t.truncate +ida_hexrays.history_item_t +ida_hexrays.history_item_t.__init__ +ida_hexrays.history_item_t.curr_ea +ida_hexrays.history_item_t.end +ida_hexrays.history_item_t.func_ea +ida_hexrays.history_t +ida_hexrays.history_t.__init__ +ida_hexrays.history_t.pop +ida_hexrays.history_t.push +ida_hexrays.history_t.top +ida_hexrays.hxe_begin_inlining +ida_hexrays.hxe_build_callinfo +ida_hexrays.hxe_callinfo_built +ida_hexrays.hxe_calls_done +ida_hexrays.hxe_close_pseudocode +ida_hexrays.hxe_cmt_changed +ida_hexrays.hxe_collect_warnings +ida_hexrays.hxe_combine +ida_hexrays.hxe_create_hint +ida_hexrays.hxe_curpos +ida_hexrays.hxe_double_click +ida_hexrays.hxe_flowchart +ida_hexrays.hxe_func_printed +ida_hexrays.hxe_glbopt +ida_hexrays.hxe_inlined_func +ida_hexrays.hxe_inlining_func +ida_hexrays.hxe_interr +ida_hexrays.hxe_keyboard +ida_hexrays.hxe_locopt +ida_hexrays.hxe_maturity +ida_hexrays.hxe_microcode +ida_hexrays.hxe_open_pseudocode +ida_hexrays.hxe_populating_popup +ida_hexrays.hxe_pre_structural +ida_hexrays.hxe_prealloc +ida_hexrays.hxe_preoptimized +ida_hexrays.hxe_print_func +ida_hexrays.hxe_prolog +ida_hexrays.hxe_refresh_pseudocode +ida_hexrays.hxe_resolve_stkaddrs +ida_hexrays.hxe_right_click +ida_hexrays.hxe_stkpnts +ida_hexrays.hxe_structural +ida_hexrays.hxe_switch_pseudocode +ida_hexrays.hxe_text_ready +ida_hexrays.init_hexrays_plugin +ida_hexrays.install_hexrays_callback +ida_hexrays.install_microcode_filter +ida_hexrays.is_additive +ida_hexrays.is_assignment +ida_hexrays.is_binary +ida_hexrays.is_bitop +ida_hexrays.is_bool_type +ida_hexrays.is_break_consumer +ida_hexrays.is_cmpop_with_eq +ida_hexrays.is_cmpop_without_eq +ida_hexrays.is_commutative +ida_hexrays.is_inplace_def +ida_hexrays.is_kreg +ida_hexrays.is_logical +ida_hexrays.is_loop +ida_hexrays.is_lvalue +ida_hexrays.is_may_access +ida_hexrays.is_mcode_addsub +ida_hexrays.is_mcode_call +ida_hexrays.is_mcode_commutative +ida_hexrays.is_mcode_convertible_to_jmp +ida_hexrays.is_mcode_convertible_to_set +ida_hexrays.is_mcode_divmod +ida_hexrays.is_mcode_fpu +ida_hexrays.is_mcode_j1 +ida_hexrays.is_mcode_jcond +ida_hexrays.is_mcode_propagatable +ida_hexrays.is_mcode_set +ida_hexrays.is_mcode_set1 +ida_hexrays.is_mcode_shift +ida_hexrays.is_mcode_xdsu +ida_hexrays.is_multiplicative +ida_hexrays.is_nonbool_type +ida_hexrays.is_paf +ida_hexrays.is_prepost +ida_hexrays.is_ptr_or_array +ida_hexrays.is_relational +ida_hexrays.is_signed_cmpop +ida_hexrays.is_signed_mcode +ida_hexrays.is_small_udt +ida_hexrays.is_type_correct +ida_hexrays.is_unary +ida_hexrays.is_unsigned_cmpop +ida_hexrays.is_unsigned_mcode +ida_hexrays.iterator +ida_hexrays.iterator.__eq__ +ida_hexrays.iterator.__init__ +ida_hexrays.iterator.__ne__ +ida_hexrays.iterator.__ref__ +ida_hexrays.ivl_t +ida_hexrays.ivl_t.__eq__ +ida_hexrays.ivl_t.__ge__ +ida_hexrays.ivl_t.__gt__ +ida_hexrays.ivl_t.__init__ +ida_hexrays.ivl_t.__le__ +ida_hexrays.ivl_t.__lt__ +ida_hexrays.ivl_t.__ne__ +ida_hexrays.ivl_t.clear +ida_hexrays.ivl_t.compare +ida_hexrays.ivl_t.contains +ida_hexrays.ivl_t.dstr +ida_hexrays.ivl_t.empty +ida_hexrays.ivl_t.extend_to_cover +ida_hexrays.ivl_t.includes +ida_hexrays.ivl_t.intersect +ida_hexrays.ivl_t.overlap +ida_hexrays.ivl_with_name_t +ida_hexrays.ivl_with_name_t.__init__ +ida_hexrays.ivlset_t +ida_hexrays.ivlset_t.__eq__ +ida_hexrays.ivlset_t.__ge__ +ida_hexrays.ivlset_t.__gt__ +ida_hexrays.ivlset_t.__init__ +ida_hexrays.ivlset_t.__le__ +ida_hexrays.ivlset_t.__lt__ +ida_hexrays.ivlset_t.__ne__ +ida_hexrays.ivlset_t._print +ida_hexrays.ivlset_t.add +ida_hexrays.ivlset_t.addmasked +ida_hexrays.ivlset_t.compare +ida_hexrays.ivlset_t.contains +ida_hexrays.ivlset_t.count +ida_hexrays.ivlset_t.dstr +ida_hexrays.ivlset_t.has_common +ida_hexrays.ivlset_t.includes +ida_hexrays.ivlset_t.intersect +ida_hexrays.ivlset_t.sub +ida_hexrays.jcnd2set +ida_hexrays.lexcompare +ida_hexrays.lnot +ida_hexrays.locate_lvar +ida_hexrays.lvar_locator_t +ida_hexrays.lvar_locator_t.__eq__ +ida_hexrays.lvar_locator_t.__ge__ +ida_hexrays.lvar_locator_t.__gt__ +ida_hexrays.lvar_locator_t.__init__ +ida_hexrays.lvar_locator_t.__le__ +ida_hexrays.lvar_locator_t.__lt__ +ida_hexrays.lvar_locator_t.__ne__ +ida_hexrays.lvar_locator_t.compare +ida_hexrays.lvar_locator_t.defea +ida_hexrays.lvar_locator_t.get_reg1 +ida_hexrays.lvar_locator_t.get_reg2 +ida_hexrays.lvar_locator_t.get_scattered +ida_hexrays.lvar_locator_t.get_stkoff +ida_hexrays.lvar_locator_t.is_reg1 +ida_hexrays.lvar_locator_t.is_reg2 +ida_hexrays.lvar_locator_t.is_reg_var +ida_hexrays.lvar_locator_t.is_scattered +ida_hexrays.lvar_locator_t.is_stk_var +ida_hexrays.lvar_locator_t.location +ida_hexrays.lvar_mapping_begin +ida_hexrays.lvar_mapping_clear +ida_hexrays.lvar_mapping_end +ida_hexrays.lvar_mapping_erase +ida_hexrays.lvar_mapping_find +ida_hexrays.lvar_mapping_first +ida_hexrays.lvar_mapping_free +ida_hexrays.lvar_mapping_insert +ida_hexrays.lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_iterator_t.__eq__ +ida_hexrays.lvar_mapping_iterator_t.__init__ +ida_hexrays.lvar_mapping_iterator_t.__ne__ +ida_hexrays.lvar_mapping_new +ida_hexrays.lvar_mapping_next +ida_hexrays.lvar_mapping_prev +ida_hexrays.lvar_mapping_second +ida_hexrays.lvar_mapping_size +ida_hexrays.lvar_mapping_t +ida_hexrays.lvar_mapping_t.__init__ +ida_hexrays.lvar_mapping_t.at +ida_hexrays.lvar_mapping_t.size +ida_hexrays.lvar_ref_t +ida_hexrays.lvar_ref_t.__eq__ +ida_hexrays.lvar_ref_t.__ge__ +ida_hexrays.lvar_ref_t.__gt__ +ida_hexrays.lvar_ref_t.__init__ +ida_hexrays.lvar_ref_t.__le__ +ida_hexrays.lvar_ref_t.__lt__ +ida_hexrays.lvar_ref_t.__ne__ +ida_hexrays.lvar_ref_t.compare +ida_hexrays.lvar_ref_t.idx +ida_hexrays.lvar_ref_t.mba +ida_hexrays.lvar_ref_t.off +ida_hexrays.lvar_ref_t.swap +ida_hexrays.lvar_ref_t.var +ida_hexrays.lvar_saved_info_t +ida_hexrays.lvar_saved_info_t.__eq__ +ida_hexrays.lvar_saved_info_t.__init__ +ida_hexrays.lvar_saved_info_t.__ne__ +ida_hexrays.lvar_saved_info_t.clear_keep +ida_hexrays.lvar_saved_info_t.clr_nomap_lvar +ida_hexrays.lvar_saved_info_t.clr_noptr_lvar +ida_hexrays.lvar_saved_info_t.clr_split_lvar +ida_hexrays.lvar_saved_info_t.clr_unused_lvar +ida_hexrays.lvar_saved_info_t.cmt +ida_hexrays.lvar_saved_info_t.flags +ida_hexrays.lvar_saved_info_t.has_info +ida_hexrays.lvar_saved_info_t.is_kept +ida_hexrays.lvar_saved_info_t.is_nomap_lvar +ida_hexrays.lvar_saved_info_t.is_noptr_lvar +ida_hexrays.lvar_saved_info_t.is_split_lvar +ida_hexrays.lvar_saved_info_t.is_unused_lvar +ida_hexrays.lvar_saved_info_t.ll +ida_hexrays.lvar_saved_info_t.name +ida_hexrays.lvar_saved_info_t.set_keep +ida_hexrays.lvar_saved_info_t.set_nomap_lvar +ida_hexrays.lvar_saved_info_t.set_noptr_lvar +ida_hexrays.lvar_saved_info_t.set_split_lvar +ida_hexrays.lvar_saved_info_t.set_unused_lvar +ida_hexrays.lvar_saved_info_t.size +ida_hexrays.lvar_saved_info_t.type +ida_hexrays.lvar_saved_infos_t +ida_hexrays.lvar_saved_infos_t.__eq__ +ida_hexrays.lvar_saved_infos_t.__getitem__ +ida_hexrays.lvar_saved_infos_t.__init__ +ida_hexrays.lvar_saved_infos_t.__len__ +ida_hexrays.lvar_saved_infos_t.__ne__ +ida_hexrays.lvar_saved_infos_t.__setitem__ +ida_hexrays.lvar_saved_infos_t._del +ida_hexrays.lvar_saved_infos_t.add_unique +ida_hexrays.lvar_saved_infos_t.append +ida_hexrays.lvar_saved_infos_t.at +ida_hexrays.lvar_saved_infos_t.begin +ida_hexrays.lvar_saved_infos_t.capacity +ida_hexrays.lvar_saved_infos_t.clear +ida_hexrays.lvar_saved_infos_t.empty +ida_hexrays.lvar_saved_infos_t.end +ida_hexrays.lvar_saved_infos_t.erase +ida_hexrays.lvar_saved_infos_t.extend +ida_hexrays.lvar_saved_infos_t.extract +ida_hexrays.lvar_saved_infos_t.find +ida_hexrays.lvar_saved_infos_t.grow +ida_hexrays.lvar_saved_infos_t.has +ida_hexrays.lvar_saved_infos_t.inject +ida_hexrays.lvar_saved_infos_t.insert +ida_hexrays.lvar_saved_infos_t.pop_back +ida_hexrays.lvar_saved_infos_t.push_back +ida_hexrays.lvar_saved_infos_t.qclear +ida_hexrays.lvar_saved_infos_t.reserve +ida_hexrays.lvar_saved_infos_t.resize +ida_hexrays.lvar_saved_infos_t.size +ida_hexrays.lvar_saved_infos_t.swap +ida_hexrays.lvar_saved_infos_t.truncate +ida_hexrays.lvar_t +ida_hexrays.lvar_t.__init__ +ida_hexrays.lvar_t.accepts_type +ida_hexrays.lvar_t.append_list +ida_hexrays.lvar_t.clear_used +ida_hexrays.lvar_t.clr_arg_var +ida_hexrays.lvar_t.clr_automapped +ida_hexrays.lvar_t.clr_decl_unused +ida_hexrays.lvar_t.clr_dummy_arg +ida_hexrays.lvar_t.clr_fake_var +ida_hexrays.lvar_t.clr_floating_var +ida_hexrays.lvar_t.clr_mapdst_var +ida_hexrays.lvar_t.clr_mreg_done +ida_hexrays.lvar_t.clr_noptr_var +ida_hexrays.lvar_t.clr_notarg +ida_hexrays.lvar_t.clr_overlapped_var +ida_hexrays.lvar_t.clr_scattered_arg +ida_hexrays.lvar_t.clr_shared +ida_hexrays.lvar_t.clr_split_var +ida_hexrays.lvar_t.clr_spoiled_var +ida_hexrays.lvar_t.clr_thisarg +ida_hexrays.lvar_t.clr_unknown_width +ida_hexrays.lvar_t.clr_used_byref +ida_hexrays.lvar_t.clr_user_info +ida_hexrays.lvar_t.clr_user_name +ida_hexrays.lvar_t.clr_user_type +ida_hexrays.lvar_t.cmt +ida_hexrays.lvar_t.defblk +ida_hexrays.lvar_t.divisor +ida_hexrays.lvar_t.has_common +ida_hexrays.lvar_t.has_common_bit +ida_hexrays.lvar_t.has_nice_name +ida_hexrays.lvar_t.has_regname +ida_hexrays.lvar_t.has_user_info +ida_hexrays.lvar_t.has_user_name +ida_hexrays.lvar_t.has_user_type +ida_hexrays.lvar_t.in_asm +ida_hexrays.lvar_t.is_aliasable +ida_hexrays.lvar_t.is_arg_var +ida_hexrays.lvar_t.is_automapped +ida_hexrays.lvar_t.is_decl_unused +ida_hexrays.lvar_t.is_dummy_arg +ida_hexrays.lvar_t.is_fake_var +ida_hexrays.lvar_t.is_floating_var +ida_hexrays.lvar_t.is_mapdst_var +ida_hexrays.lvar_t.is_noptr_var +ida_hexrays.lvar_t.is_notarg +ida_hexrays.lvar_t.is_overlapped_var +ida_hexrays.lvar_t.is_result_var +ida_hexrays.lvar_t.is_shared +ida_hexrays.lvar_t.is_split_var +ida_hexrays.lvar_t.is_spoiled_var +ida_hexrays.lvar_t.is_thisarg +ida_hexrays.lvar_t.is_unknown_width +ida_hexrays.lvar_t.is_used_byref +ida_hexrays.lvar_t.mreg_done +ida_hexrays.lvar_t.name +ida_hexrays.lvar_t.set_arg_var +ida_hexrays.lvar_t.set_automapped +ida_hexrays.lvar_t.set_decl_unused +ida_hexrays.lvar_t.set_dummy_arg +ida_hexrays.lvar_t.set_fake_var +ida_hexrays.lvar_t.set_final_lvar_type +ida_hexrays.lvar_t.set_floating_var +ida_hexrays.lvar_t.set_lvar_type +ida_hexrays.lvar_t.set_mapdst_var +ida_hexrays.lvar_t.set_mreg_done +ida_hexrays.lvar_t.set_non_typed +ida_hexrays.lvar_t.set_noptr_var +ida_hexrays.lvar_t.set_notarg +ida_hexrays.lvar_t.set_overlapped_var +ida_hexrays.lvar_t.set_scattered_arg +ida_hexrays.lvar_t.set_shared +ida_hexrays.lvar_t.set_split_var +ida_hexrays.lvar_t.set_spoiled_var +ida_hexrays.lvar_t.set_thisarg +ida_hexrays.lvar_t.set_typed +ida_hexrays.lvar_t.set_unknown_width +ida_hexrays.lvar_t.set_used +ida_hexrays.lvar_t.set_used_byref +ida_hexrays.lvar_t.set_user_name +ida_hexrays.lvar_t.set_user_type +ida_hexrays.lvar_t.set_width +ida_hexrays.lvar_t.tif +ida_hexrays.lvar_t.type +ida_hexrays.lvar_t.typed +ida_hexrays.lvar_t.used +ida_hexrays.lvar_t.was_scattered_arg +ida_hexrays.lvar_t.width +ida_hexrays.lvar_uservec_t +ida_hexrays.lvar_uservec_t.__init__ +ida_hexrays.lvar_uservec_t.clear +ida_hexrays.lvar_uservec_t.empty +ida_hexrays.lvar_uservec_t.find_info +ida_hexrays.lvar_uservec_t.keep_info +ida_hexrays.lvar_uservec_t.lmaps +ida_hexrays.lvar_uservec_t.lvvec +ida_hexrays.lvar_uservec_t.stkoff_delta +ida_hexrays.lvar_uservec_t.swap +ida_hexrays.lvar_uservec_t.ulv_flags +ida_hexrays.lvars_t +ida_hexrays.lvars_t.__init__ +ida_hexrays.lvars_t.find +ida_hexrays.lvars_t.find_input_lvar +ida_hexrays.lvars_t.find_input_reg +ida_hexrays.lvars_t.find_lvar +ida_hexrays.lvars_t.find_stkvar +ida_hexrays.lxe_lvar_cmt_changed +ida_hexrays.lxe_lvar_mapping_changed +ida_hexrays.lxe_lvar_name_changed +ida_hexrays.lxe_lvar_type_changed +ida_hexrays.make_num +ida_hexrays.make_pointer +ida_hexrays.make_ref +ida_hexrays.mark_cfunc_dirty +ida_hexrays.max_vlr_svalue +ida_hexrays.max_vlr_value +ida_hexrays.mba_range_iterator_t +ida_hexrays.mba_range_iterator_t.__init__ +ida_hexrays.mba_range_iterator_t.chunk +ida_hexrays.mba_range_iterator_t.is_snippet +ida_hexrays.mba_range_iterator_t.next +ida_hexrays.mba_range_iterator_t.set +ida_hexrays.mba_ranges_t +ida_hexrays.mba_ranges_t.__init__ +ida_hexrays.mba_ranges_t.clear +ida_hexrays.mba_ranges_t.empty +ida_hexrays.mba_ranges_t.is_fragmented +ida_hexrays.mba_ranges_t.is_snippet +ida_hexrays.mba_ranges_t.pfn +ida_hexrays.mba_ranges_t.ranges +ida_hexrays.mba_ranges_t.start +ida_hexrays.mba_t +ida_hexrays.mba_t.__init__ +ida_hexrays.mba_t._deregister +ida_hexrays.mba_t._print +ida_hexrays.mba_t._register +ida_hexrays.mba_t.aliased_memory +ida_hexrays.mba_t.alloc_fict_ea +ida_hexrays.mba_t.alloc_kreg +ida_hexrays.mba_t.alloc_lvars +ida_hexrays.mba_t.analyze_calls +ida_hexrays.mba_t.arg +ida_hexrays.mba_t.argbase +ida_hexrays.mba_t.argidx +ida_hexrays.mba_t.argidx_ok +ida_hexrays.mba_t.argidx_sorted +ida_hexrays.mba_t.bad_call_sp_detected +ida_hexrays.mba_t.blocks +ida_hexrays.mba_t.build_graph +ida_hexrays.mba_t.calc_shins_flags +ida_hexrays.mba_t.callinfo_built +ida_hexrays.mba_t.cc +ida_hexrays.mba_t.chain_varnums_ok +ida_hexrays.mba_t.clr_cdtr +ida_hexrays.mba_t.clr_mba_flags +ida_hexrays.mba_t.clr_mba_flags2 +ida_hexrays.mba_t.code16_bit_removed +ida_hexrays.mba_t.common_stkvars_stkargs +ida_hexrays.mba_t.consumed_argregs +ida_hexrays.mba_t.copy_block +ida_hexrays.mba_t.create_helper_call +ida_hexrays.mba_t.deleted_pairs +ida_hexrays.mba_t.deserialize +ida_hexrays.mba_t.display_numaddrs +ida_hexrays.mba_t.display_valnums +ida_hexrays.mba_t.dump +ida_hexrays.mba_t.dump_mba +ida_hexrays.mba_t.error_ea +ida_hexrays.mba_t.final_type +ida_hexrays.mba_t.find_mop +ida_hexrays.mba_t.for_all_insns +ida_hexrays.mba_t.for_all_ops +ida_hexrays.mba_t.for_all_topinsns +ida_hexrays.mba_t.fpd +ida_hexrays.mba_t.free_kreg +ida_hexrays.mba_t.frregs +ida_hexrays.mba_t.frsize +ida_hexrays.mba_t.fti_flags +ida_hexrays.mba_t.fullsize +ida_hexrays.mba_t.generated_asserts +ida_hexrays.mba_t.get_args_region +ida_hexrays.mba_t.get_curfunc +ida_hexrays.mba_t.get_func_output_lists +ida_hexrays.mba_t.get_graph +ida_hexrays.mba_t.get_ida_argloc +ida_hexrays.mba_t.get_lvars_region +ida_hexrays.mba_t.get_mba_flags +ida_hexrays.mba_t.get_mba_flags2 +ida_hexrays.mba_t.get_mblock +ida_hexrays.mba_t.get_shadow_region +ida_hexrays.mba_t.get_stack_region +ida_hexrays.mba_t.get_std_region +ida_hexrays.mba_t.gotoff_stkvars +ida_hexrays.mba_t.graph_insns +ida_hexrays.mba_t.has_bad_sp +ida_hexrays.mba_t.has_outlines +ida_hexrays.mba_t.has_over_chains +ida_hexrays.mba_t.has_passregs +ida_hexrays.mba_t.has_stack_retval +ida_hexrays.mba_t.idaloc2vd +ida_hexrays.mba_t.idb_spoiled +ida_hexrays.mba_t.idb_type +ida_hexrays.mba_t.inargoff +ida_hexrays.mba_t.inline_func +ida_hexrays.mba_t.insert_block +ida_hexrays.mba_t.is_cdtr +ida_hexrays.mba_t.is_ctr +ida_hexrays.mba_t.is_dtr +ida_hexrays.mba_t.is_pattern +ida_hexrays.mba_t.is_snippet +ida_hexrays.mba_t.is_stkarg +ida_hexrays.mba_t.is_thunk +ida_hexrays.mba_t.label +ida_hexrays.mba_t.loaded_gdl +ida_hexrays.mba_t.locate_stkpnt +ida_hexrays.mba_t.lvar_names_ok +ida_hexrays.mba_t.lvars_allocated +ida_hexrays.mba_t.lvars_renamed +ida_hexrays.mba_t.map_fict_ea +ida_hexrays.mba_t.mark_chains_dirty +ida_hexrays.mba_t.maturity +ida_hexrays.mba_t.may_refine_rettype +ida_hexrays.mba_t.merge_blocks +ida_hexrays.mba_t.minargref +ida_hexrays.mba_t.minstkref +ida_hexrays.mba_t.minstkref_ea +ida_hexrays.mba_t.natural +ida_hexrays.mba_t.nodel_memory +ida_hexrays.mba_t.npurged +ida_hexrays.mba_t.optimize_global +ida_hexrays.mba_t.optimize_local +ida_hexrays.mba_t.optimized +ida_hexrays.mba_t.pfn_flags +ida_hexrays.mba_t.precise_defeas +ida_hexrays.mba_t.prop_complex +ida_hexrays.mba_t.propagated_asserts +ida_hexrays.mba_t.qty +ida_hexrays.mba_t.really_alloc +ida_hexrays.mba_t.regargs_is_not_aligned +ida_hexrays.mba_t.remove_block +ida_hexrays.mba_t.remove_blocks +ida_hexrays.mba_t.remove_empty_and_unreachable_blocks +ida_hexrays.mba_t.reqmat +ida_hexrays.mba_t.retsize +ida_hexrays.mba_t.returns_fpval +ida_hexrays.mba_t.retvaridx +ida_hexrays.mba_t.rtype_refined +ida_hexrays.mba_t.save_snapshot +ida_hexrays.mba_t.saverest_done +ida_hexrays.mba_t.serialize +ida_hexrays.mba_t.set_lvar_name +ida_hexrays.mba_t.set_maturity +ida_hexrays.mba_t.set_mba_flags +ida_hexrays.mba_t.set_mba_flags2 +ida_hexrays.mba_t.set_nice_lvar_name +ida_hexrays.mba_t.set_user_lvar_name +ida_hexrays.mba_t.shadow_args +ida_hexrays.mba_t.short_display +ida_hexrays.mba_t.should_beautify +ida_hexrays.mba_t.show_reduction +ida_hexrays.mba_t.spd_adjust +ida_hexrays.mba_t.split_block +ida_hexrays.mba_t.spoiled_list +ida_hexrays.mba_t.stacksize +ida_hexrays.mba_t.std_ivls +ida_hexrays.mba_t.stkoff_ida2vd +ida_hexrays.mba_t.stkoff_vd2ida +ida_hexrays.mba_t.term +ida_hexrays.mba_t.tmpstk_size +ida_hexrays.mba_t.use_frame +ida_hexrays.mba_t.use_wingraph32 +ida_hexrays.mba_t.valranges_done +ida_hexrays.mba_t.vars +ida_hexrays.mba_t.vd2idaloc +ida_hexrays.mba_t.verify +ida_hexrays.mba_t.write_to_const_detected +ida_hexrays.mbl_graph_t +ida_hexrays.mbl_graph_t.__init__ +ida_hexrays.mbl_graph_t.get_chain_stamp +ida_hexrays.mbl_graph_t.get_du +ida_hexrays.mbl_graph_t.get_mblock +ida_hexrays.mbl_graph_t.get_ud +ida_hexrays.mbl_graph_t.is_du_chain_dirty +ida_hexrays.mbl_graph_t.is_redefined_globally +ida_hexrays.mbl_graph_t.is_ud_chain_dirty +ida_hexrays.mbl_graph_t.is_used_globally +ida_hexrays.mblock_t +ida_hexrays.mblock_t.__init__ +ida_hexrays.mblock_t._print +ida_hexrays.mblock_t.append_def_list +ida_hexrays.mblock_t.append_use_list +ida_hexrays.mblock_t.build_def_list +ida_hexrays.mblock_t.build_lists +ida_hexrays.mblock_t.build_use_list +ida_hexrays.mblock_t.dead_at_start +ida_hexrays.mblock_t.dnu +ida_hexrays.mblock_t.dump +ida_hexrays.mblock_t.dump_block +ida_hexrays.mblock_t.empty +ida_hexrays.mblock_t.end +ida_hexrays.mblock_t.find_access +ida_hexrays.mblock_t.find_def +ida_hexrays.mblock_t.find_first_use +ida_hexrays.mblock_t.find_redefinition +ida_hexrays.mblock_t.find_use +ida_hexrays.mblock_t.flags +ida_hexrays.mblock_t.for_all_insns +ida_hexrays.mblock_t.for_all_ops +ida_hexrays.mblock_t.for_all_uses +ida_hexrays.mblock_t.get_reginsn_qty +ida_hexrays.mblock_t.get_valranges +ida_hexrays.mblock_t.head +ida_hexrays.mblock_t.insert_into_block +ida_hexrays.mblock_t.is_branch +ida_hexrays.mblock_t.is_call_block +ida_hexrays.mblock_t.is_nway +ida_hexrays.mblock_t.is_redefined +ida_hexrays.mblock_t.is_rhs_redefined +ida_hexrays.mblock_t.is_simple_goto_block +ida_hexrays.mblock_t.is_simple_jcnd_block +ida_hexrays.mblock_t.is_unknown_call +ida_hexrays.mblock_t.is_used +ida_hexrays.mblock_t.lists_dirty +ida_hexrays.mblock_t.lists_ready +ida_hexrays.mblock_t.make_lists_ready +ida_hexrays.mblock_t.make_nop +ida_hexrays.mblock_t.mark_lists_dirty +ida_hexrays.mblock_t.maxbsp +ida_hexrays.mblock_t.maybdef +ida_hexrays.mblock_t.maybuse +ida_hexrays.mblock_t.mba +ida_hexrays.mblock_t.minbargref +ida_hexrays.mblock_t.minbstkref +ida_hexrays.mblock_t.mustbdef +ida_hexrays.mblock_t.mustbuse +ida_hexrays.mblock_t.needs_propagation +ida_hexrays.mblock_t.nextb +ida_hexrays.mblock_t.npred +ida_hexrays.mblock_t.nsucc +ida_hexrays.mblock_t.optimize_block +ida_hexrays.mblock_t.optimize_insn +ida_hexrays.mblock_t.optimize_useless_jump +ida_hexrays.mblock_t.pred +ida_hexrays.mblock_t.preds +ida_hexrays.mblock_t.predset +ida_hexrays.mblock_t.prevb +ida_hexrays.mblock_t.remove_from_block +ida_hexrays.mblock_t.request_demote64 +ida_hexrays.mblock_t.request_propagation +ida_hexrays.mblock_t.serial +ida_hexrays.mblock_t.start +ida_hexrays.mblock_t.succ +ida_hexrays.mblock_t.succs +ida_hexrays.mblock_t.succset +ida_hexrays.mblock_t.tail +ida_hexrays.mblock_t.type +ida_hexrays.mcallarg_t +ida_hexrays.mcallarg_t.__init__ +ida_hexrays.mcallarg_t._print +ida_hexrays.mcallarg_t.argloc +ida_hexrays.mcallarg_t.copy_mop +ida_hexrays.mcallarg_t.dstr +ida_hexrays.mcallarg_t.ea +ida_hexrays.mcallarg_t.flags +ida_hexrays.mcallarg_t.make_int +ida_hexrays.mcallarg_t.make_uint +ida_hexrays.mcallarg_t.name +ida_hexrays.mcallarg_t.set_regarg +ida_hexrays.mcallarg_t.type +ida_hexrays.mcallargs_t +ida_hexrays.mcallargs_t.__eq__ +ida_hexrays.mcallargs_t.__getitem__ +ida_hexrays.mcallargs_t.__init__ +ida_hexrays.mcallargs_t.__len__ +ida_hexrays.mcallargs_t.__ne__ +ida_hexrays.mcallargs_t.__setitem__ +ida_hexrays.mcallargs_t._del +ida_hexrays.mcallargs_t.add_unique +ida_hexrays.mcallargs_t.append +ida_hexrays.mcallargs_t.at +ida_hexrays.mcallargs_t.begin +ida_hexrays.mcallargs_t.capacity +ida_hexrays.mcallargs_t.clear +ida_hexrays.mcallargs_t.empty +ida_hexrays.mcallargs_t.end +ida_hexrays.mcallargs_t.erase +ida_hexrays.mcallargs_t.extend +ida_hexrays.mcallargs_t.extract +ida_hexrays.mcallargs_t.find +ida_hexrays.mcallargs_t.grow +ida_hexrays.mcallargs_t.has +ida_hexrays.mcallargs_t.inject +ida_hexrays.mcallargs_t.insert +ida_hexrays.mcallargs_t.pop_back +ida_hexrays.mcallargs_t.push_back +ida_hexrays.mcallargs_t.qclear +ida_hexrays.mcallargs_t.reserve +ida_hexrays.mcallargs_t.resize +ida_hexrays.mcallargs_t.size +ida_hexrays.mcallargs_t.swap +ida_hexrays.mcallargs_t.truncate +ida_hexrays.mcallinfo_t +ida_hexrays.mcallinfo_t.__init__ +ida_hexrays.mcallinfo_t._print +ida_hexrays.mcallinfo_t.args +ida_hexrays.mcallinfo_t.call_spd +ida_hexrays.mcallinfo_t.callee +ida_hexrays.mcallinfo_t.cc +ida_hexrays.mcallinfo_t.dead_regs +ida_hexrays.mcallinfo_t.dstr +ida_hexrays.mcallinfo_t.flags +ida_hexrays.mcallinfo_t.fti_attrs +ida_hexrays.mcallinfo_t.get_type +ida_hexrays.mcallinfo_t.is_vararg +ida_hexrays.mcallinfo_t.lexcompare +ida_hexrays.mcallinfo_t.pass_regs +ida_hexrays.mcallinfo_t.retregs +ida_hexrays.mcallinfo_t.return_argloc +ida_hexrays.mcallinfo_t.return_regs +ida_hexrays.mcallinfo_t.return_type +ida_hexrays.mcallinfo_t.role +ida_hexrays.mcallinfo_t.set_type +ida_hexrays.mcallinfo_t.solid_args +ida_hexrays.mcallinfo_t.spoiled +ida_hexrays.mcallinfo_t.stkargs_top +ida_hexrays.mcallinfo_t.visible_memory +ida_hexrays.mcases_t +ida_hexrays.mcases_t.__eq__ +ida_hexrays.mcases_t.__ge__ +ida_hexrays.mcases_t.__gt__ +ida_hexrays.mcases_t.__init__ +ida_hexrays.mcases_t.__le__ +ida_hexrays.mcases_t.__lt__ +ida_hexrays.mcases_t.__ne__ +ida_hexrays.mcases_t._print +ida_hexrays.mcases_t.compare +ida_hexrays.mcases_t.dstr +ida_hexrays.mcases_t.empty +ida_hexrays.mcases_t.resize +ida_hexrays.mcases_t.size +ida_hexrays.mcases_t.swap +ida_hexrays.mcases_t.targets +ida_hexrays.mcases_t.values +ida_hexrays.mcode_modifies_d +ida_hexrays.microcode_filter_t +ida_hexrays.microcode_filter_t.__disown__ +ida_hexrays.microcode_filter_t.__init__ +ida_hexrays.microcode_filter_t.apply +ida_hexrays.microcode_filter_t.match +ida_hexrays.min_vlr_svalue +ida_hexrays.minsn_t +ida_hexrays.minsn_t.__dbg_get_meminfo +ida_hexrays.minsn_t.__dbg_get_registered_kind +ida_hexrays.minsn_t.__init__ +ida_hexrays.minsn_t.__lt__ +ida_hexrays.minsn_t._acquire_ownership +ida_hexrays.minsn_t._deregister +ida_hexrays.minsn_t._ensure_cond +ida_hexrays.minsn_t._ensure_no_obj +ida_hexrays.minsn_t._ensure_ownership_transferrable +ida_hexrays.minsn_t._make_nop +ida_hexrays.minsn_t._maybe_disown_and_deregister +ida_hexrays.minsn_t._meminfo +ida_hexrays.minsn_t._obj_id +ida_hexrays.minsn_t._own_and_register +ida_hexrays.minsn_t._print +ida_hexrays.minsn_t._register +ida_hexrays.minsn_t.clr_assert +ida_hexrays.minsn_t.clr_combinable +ida_hexrays.minsn_t.clr_combined +ida_hexrays.minsn_t.clr_fpinsn +ida_hexrays.minsn_t.clr_ignlowsrc +ida_hexrays.minsn_t.clr_multimov +ida_hexrays.minsn_t.clr_noret_icall +ida_hexrays.minsn_t.clr_propagatable +ida_hexrays.minsn_t.clr_tailcall +ida_hexrays.minsn_t.contains_call +ida_hexrays.minsn_t.contains_opcode +ida_hexrays.minsn_t.d +ida_hexrays.minsn_t.deserialize +ida_hexrays.minsn_t.dstr +ida_hexrays.minsn_t.ea +ida_hexrays.minsn_t.equal_insns +ida_hexrays.minsn_t.find_call +ida_hexrays.minsn_t.find_ins_op +ida_hexrays.minsn_t.find_num_op +ida_hexrays.minsn_t.find_opcode +ida_hexrays.minsn_t.for_all_insns +ida_hexrays.minsn_t.for_all_ops +ida_hexrays.minsn_t.get_role +ida_hexrays.minsn_t.get_split_size +ida_hexrays.minsn_t.has_side_effects +ida_hexrays.minsn_t.iprops +ida_hexrays.minsn_t.is_after +ida_hexrays.minsn_t.is_alloca +ida_hexrays.minsn_t.is_assert +ida_hexrays.minsn_t.is_between +ida_hexrays.minsn_t.is_bswap +ida_hexrays.minsn_t.is_cleaning_pop +ida_hexrays.minsn_t.is_combinable +ida_hexrays.minsn_t.is_combined +ida_hexrays.minsn_t.is_extstx +ida_hexrays.minsn_t.is_farcall +ida_hexrays.minsn_t.is_fpinsn +ida_hexrays.minsn_t.is_helper +ida_hexrays.minsn_t.is_ignlowsrc +ida_hexrays.minsn_t.is_inverted_jx +ida_hexrays.minsn_t.is_like_move +ida_hexrays.minsn_t.is_mbarrier +ida_hexrays.minsn_t.is_memcpy +ida_hexrays.minsn_t.is_memset +ida_hexrays.minsn_t.is_mov +ida_hexrays.minsn_t.is_multimov +ida_hexrays.minsn_t.is_noret_call +ida_hexrays.minsn_t.is_optional +ida_hexrays.minsn_t.is_persistent +ida_hexrays.minsn_t.is_propagatable +ida_hexrays.minsn_t.is_readflags +ida_hexrays.minsn_t.is_tailcall +ida_hexrays.minsn_t.is_unknown_call +ida_hexrays.minsn_t.is_wild_match +ida_hexrays.minsn_t.l +ida_hexrays.minsn_t.lexcompare +ida_hexrays.minsn_t.may_use_aliased_memory +ida_hexrays.minsn_t.modifies_d +ida_hexrays.minsn_t.modifies_pair_mop +ida_hexrays.minsn_t.next +ida_hexrays.minsn_t.opcode +ida_hexrays.minsn_t.optimize_solo +ida_hexrays.minsn_t.optimize_subtree +ida_hexrays.minsn_t.prev +ida_hexrays.minsn_t.r +ida_hexrays.minsn_t.replace_by +ida_hexrays.minsn_t.serialize +ida_hexrays.minsn_t.set_assert +ida_hexrays.minsn_t.set_cleaning_pop +ida_hexrays.minsn_t.set_combinable +ida_hexrays.minsn_t.set_extstx +ida_hexrays.minsn_t.set_farcall +ida_hexrays.minsn_t.set_fpinsn +ida_hexrays.minsn_t.set_ignlowsrc +ida_hexrays.minsn_t.set_inverted_jx +ida_hexrays.minsn_t.set_mbarrier +ida_hexrays.minsn_t.set_multimov +ida_hexrays.minsn_t.set_noret_icall +ida_hexrays.minsn_t.set_optional +ida_hexrays.minsn_t.set_persistent +ida_hexrays.minsn_t.set_split_size +ida_hexrays.minsn_t.set_tailcall +ida_hexrays.minsn_t.set_unmerged +ida_hexrays.minsn_t.set_wild_match +ida_hexrays.minsn_t.setaddr +ida_hexrays.minsn_t.swap +ida_hexrays.minsn_t.was_noret_icall +ida_hexrays.minsn_t.was_split +ida_hexrays.minsn_t.was_unmerged +ida_hexrays.minsn_t.was_unpaired +ida_hexrays.minsn_visitor_t +ida_hexrays.minsn_visitor_t.__disown__ +ida_hexrays.minsn_visitor_t.__init__ +ida_hexrays.minsn_visitor_t.visit_minsn +ida_hexrays.mlist_mop_visitor_t +ida_hexrays.mlist_mop_visitor_t.__disown__ +ida_hexrays.mlist_mop_visitor_t.__init__ +ida_hexrays.mlist_mop_visitor_t.prune +ida_hexrays.mlist_mop_visitor_t.visit_mop +ida_hexrays.mlist_t +ida_hexrays.mlist_t.__eq__ +ida_hexrays.mlist_t.__ge__ +ida_hexrays.mlist_t.__gt__ +ida_hexrays.mlist_t.__init__ +ida_hexrays.mlist_t.__le__ +ida_hexrays.mlist_t.__lt__ +ida_hexrays.mlist_t.__ne__ +ida_hexrays.mlist_t._print +ida_hexrays.mlist_t.add +ida_hexrays.mlist_t.addmem +ida_hexrays.mlist_t.clear +ida_hexrays.mlist_t.compare +ida_hexrays.mlist_t.count +ida_hexrays.mlist_t.dstr +ida_hexrays.mlist_t.empty +ida_hexrays.mlist_t.has +ida_hexrays.mlist_t.has_all +ida_hexrays.mlist_t.has_any +ida_hexrays.mlist_t.has_common +ida_hexrays.mlist_t.has_memory +ida_hexrays.mlist_t.includes +ida_hexrays.mlist_t.intersect +ida_hexrays.mlist_t.is_subset_of +ida_hexrays.mlist_t.sub +ida_hexrays.mlist_t.swap +ida_hexrays.mnumber_t +ida_hexrays.mnumber_t.__eq__ +ida_hexrays.mnumber_t.__ge__ +ida_hexrays.mnumber_t.__gt__ +ida_hexrays.mnumber_t.__init__ +ida_hexrays.mnumber_t.__le__ +ida_hexrays.mnumber_t.__lt__ +ida_hexrays.mnumber_t.__ne__ +ida_hexrays.mnumber_t.compare +ida_hexrays.mnumber_t.update_value +ida_hexrays.modify_user_lvar_info +ida_hexrays.modify_user_lvars +ida_hexrays.mop_S +ida_hexrays.mop_a +ida_hexrays.mop_addr_t +ida_hexrays.mop_addr_t.__init__ +ida_hexrays.mop_addr_t.lexcompare +ida_hexrays.mop_b +ida_hexrays.mop_c +ida_hexrays.mop_d +ida_hexrays.mop_f +ida_hexrays.mop_fn +ida_hexrays.mop_h +ida_hexrays.mop_l +ida_hexrays.mop_n +ida_hexrays.mop_p +ida_hexrays.mop_pair_t +ida_hexrays.mop_pair_t.__init__ +ida_hexrays.mop_pair_t.hop +ida_hexrays.mop_pair_t.lop +ida_hexrays.mop_r +ida_hexrays.mop_sc +ida_hexrays.mop_str +ida_hexrays.mop_t +ida_hexrays.mop_t.__dbg_get_meminfo +ida_hexrays.mop_t.__dbg_get_registered_kind +ida_hexrays.mop_t.__eq__ +ida_hexrays.mop_t.__init__ +ida_hexrays.mop_t.__lt__ +ida_hexrays.mop_t.__ne__ +ida_hexrays.mop_t._acquire_ownership +ida_hexrays.mop_t._deregister +ida_hexrays.mop_t._ensure_cond +ida_hexrays.mop_t._ensure_no_obj +ida_hexrays.mop_t._ensure_no_t +ida_hexrays.mop_t._ensure_ownership_transferrable +ida_hexrays.mop_t._get_a +ida_hexrays.mop_t._get_b +ida_hexrays.mop_t._get_c +ida_hexrays.mop_t._get_cstr +ida_hexrays.mop_t._get_d +ida_hexrays.mop_t._get_f +ida_hexrays.mop_t._get_fpc +ida_hexrays.mop_t._get_g +ida_hexrays.mop_t._get_helper +ida_hexrays.mop_t._get_l +ida_hexrays.mop_t._get_nnn +ida_hexrays.mop_t._get_pair +ida_hexrays.mop_t._get_r +ida_hexrays.mop_t._get_s +ida_hexrays.mop_t._get_scif +ida_hexrays.mop_t._get_t +ida_hexrays.mop_t._make_blkref +ida_hexrays.mop_t._make_callinfo +ida_hexrays.mop_t._make_cases +ida_hexrays.mop_t._make_gvar +ida_hexrays.mop_t._make_insn +ida_hexrays.mop_t._make_lvar +ida_hexrays.mop_t._make_pair +ida_hexrays.mop_t._make_reg +ida_hexrays.mop_t._make_stkvar +ida_hexrays.mop_t._make_strlit +ida_hexrays.mop_t._maybe_disown_and_deregister +ida_hexrays.mop_t._meminfo +ida_hexrays.mop_t._obj_id +ida_hexrays.mop_t._own_and_register +ida_hexrays.mop_t._print +ida_hexrays.mop_t._register +ida_hexrays.mop_t._set_a +ida_hexrays.mop_t._set_b +ida_hexrays.mop_t._set_c +ida_hexrays.mop_t._set_cstr +ida_hexrays.mop_t._set_d +ida_hexrays.mop_t._set_f +ida_hexrays.mop_t._set_fpc +ida_hexrays.mop_t._set_g +ida_hexrays.mop_t._set_helper +ida_hexrays.mop_t._set_l +ida_hexrays.mop_t._set_nnn +ida_hexrays.mop_t._set_pair +ida_hexrays.mop_t._set_r +ida_hexrays.mop_t._set_s +ida_hexrays.mop_t._set_scif +ida_hexrays.mop_t._set_t +ida_hexrays.mop_t.apply_ld_mcode +ida_hexrays.mop_t.apply_xds +ida_hexrays.mop_t.apply_xdu +ida_hexrays.mop_t.assign +ida_hexrays.mop_t.change_size +ida_hexrays.mop_t.create_from_insn +ida_hexrays.mop_t.create_from_ivlset +ida_hexrays.mop_t.create_from_mlist +ida_hexrays.mop_t.create_from_scattered_vdloc +ida_hexrays.mop_t.create_from_vdloc +ida_hexrays.mop_t.double_size +ida_hexrays.mop_t.dstr +ida_hexrays.mop_t.empty +ida_hexrays.mop_t.equal_mops +ida_hexrays.mop_t.erase +ida_hexrays.mop_t.erase_but_keep_size +ida_hexrays.mop_t.for_all_ops +ida_hexrays.mop_t.for_all_scattered_submops +ida_hexrays.mop_t.get_insn +ida_hexrays.mop_t.get_stkoff +ida_hexrays.mop_t.get_stkvar +ida_hexrays.mop_t.has_side_effects +ida_hexrays.mop_t.is01 +ida_hexrays.mop_t.is_arglist +ida_hexrays.mop_t.is_bit_reg +ida_hexrays.mop_t.is_cc +ida_hexrays.mop_t.is_ccflags +ida_hexrays.mop_t.is_constant +ida_hexrays.mop_t.is_equal_to +ida_hexrays.mop_t.is_extended_from +ida_hexrays.mop_t.is_glbaddr +ida_hexrays.mop_t.is_glbaddr_from_fixup +ida_hexrays.mop_t.is_impptr_done +ida_hexrays.mop_t.is_insn +ida_hexrays.mop_t.is_kreg +ida_hexrays.mop_t.is_lowaddr +ida_hexrays.mop_t.is_mob +ida_hexrays.mop_t.is_negative_constant +ida_hexrays.mop_t.is_one +ida_hexrays.mop_t.is_pcval +ida_hexrays.mop_t.is_positive_constant +ida_hexrays.mop_t.is_reg +ida_hexrays.mop_t.is_scattered +ida_hexrays.mop_t.is_sign_extended_from +ida_hexrays.mop_t.is_stkaddr +ida_hexrays.mop_t.is_udt +ida_hexrays.mop_t.is_undef_val +ida_hexrays.mop_t.is_zero +ida_hexrays.mop_t.is_zero_extended_from +ida_hexrays.mop_t.lexcompare +ida_hexrays.mop_t.make_blkref +ida_hexrays.mop_t.make_first_half +ida_hexrays.mop_t.make_fpnum +ida_hexrays.mop_t.make_gvar +ida_hexrays.mop_t.make_helper +ida_hexrays.mop_t.make_high_half +ida_hexrays.mop_t.make_insn +ida_hexrays.mop_t.make_low_half +ida_hexrays.mop_t.make_number +ida_hexrays.mop_t.make_reg +ida_hexrays.mop_t.make_reg_pair +ida_hexrays.mop_t.make_second_half +ida_hexrays.mop_t.make_stkvar +ida_hexrays.mop_t.may_use_aliased_memory +ida_hexrays.mop_t.oprops +ida_hexrays.mop_t.preserve_side_effects +ida_hexrays.mop_t.probably_floating +ida_hexrays.mop_t.replace_by +ida_hexrays.mop_t.set_impptr_done +ida_hexrays.mop_t.set_lowaddr +ida_hexrays.mop_t.set_udt +ida_hexrays.mop_t.set_undef_val +ida_hexrays.mop_t.shift_mop +ida_hexrays.mop_t.signed_value +ida_hexrays.mop_t.size +ida_hexrays.mop_t.swap +ida_hexrays.mop_t.t +ida_hexrays.mop_t.t +ida_hexrays.mop_t.unsigned_value +ida_hexrays.mop_t.update_numop_value +ida_hexrays.mop_t.valnum +ida_hexrays.mop_t.value +ida_hexrays.mop_t.zero +ida_hexrays.mop_v +ida_hexrays.mop_visitor_t +ida_hexrays.mop_visitor_t.__disown__ +ida_hexrays.mop_visitor_t.__init__ +ida_hexrays.mop_visitor_t.prune +ida_hexrays.mop_visitor_t.visit_mop +ida_hexrays.mop_z +ida_hexrays.mopvec_t +ida_hexrays.mopvec_t.__eq__ +ida_hexrays.mopvec_t.__getitem__ +ida_hexrays.mopvec_t.__init__ +ida_hexrays.mopvec_t.__len__ +ida_hexrays.mopvec_t.__ne__ +ida_hexrays.mopvec_t.__setitem__ +ida_hexrays.mopvec_t._del +ida_hexrays.mopvec_t.add_unique +ida_hexrays.mopvec_t.append +ida_hexrays.mopvec_t.at +ida_hexrays.mopvec_t.begin +ida_hexrays.mopvec_t.capacity +ida_hexrays.mopvec_t.clear +ida_hexrays.mopvec_t.empty +ida_hexrays.mopvec_t.end +ida_hexrays.mopvec_t.erase +ida_hexrays.mopvec_t.extend +ida_hexrays.mopvec_t.extract +ida_hexrays.mopvec_t.find +ida_hexrays.mopvec_t.grow +ida_hexrays.mopvec_t.has +ida_hexrays.mopvec_t.inject +ida_hexrays.mopvec_t.insert +ida_hexrays.mopvec_t.pop_back +ida_hexrays.mopvec_t.push_back +ida_hexrays.mopvec_t.qclear +ida_hexrays.mopvec_t.reserve +ida_hexrays.mopvec_t.resize +ida_hexrays.mopvec_t.size +ida_hexrays.mopvec_t.swap +ida_hexrays.mopvec_t.truncate +ida_hexrays.mreg2reg +ida_hexrays.must_mcode_close_block +ida_hexrays.negate_mcode_relation +ida_hexrays.negated_relation +ida_hexrays.new_block +ida_hexrays.node_bitset_t +ida_hexrays.node_bitset_t.__init__ +ida_hexrays.number_format_t +ida_hexrays.number_format_t.__init__ +ida_hexrays.number_format_t.flags +ida_hexrays.number_format_t.flags32 +ida_hexrays.number_format_t.get_radix +ida_hexrays.number_format_t.has_unmutable_type +ida_hexrays.number_format_t.is_char +ida_hexrays.number_format_t.is_dec +ida_hexrays.number_format_t.is_enum +ida_hexrays.number_format_t.is_fixed +ida_hexrays.number_format_t.is_hex +ida_hexrays.number_format_t.is_numop +ida_hexrays.number_format_t.is_oct +ida_hexrays.number_format_t.is_stroff +ida_hexrays.number_format_t.needs_to_be_inverted +ida_hexrays.number_format_t.opnum +ida_hexrays.number_format_t.org_nbytes +ida_hexrays.number_format_t.props +ida_hexrays.number_format_t.serial +ida_hexrays.number_format_t.type_name +ida_hexrays.op_parent_info_t +ida_hexrays.op_parent_info_t.__disown__ +ida_hexrays.op_parent_info_t.__init__ +ida_hexrays.op_uses_x +ida_hexrays.op_uses_y +ida_hexrays.op_uses_z +ida_hexrays.open_pseudocode +ida_hexrays.operand_locator_t +ida_hexrays.operand_locator_t.__eq__ +ida_hexrays.operand_locator_t.__ge__ +ida_hexrays.operand_locator_t.__gt__ +ida_hexrays.operand_locator_t.__init__ +ida_hexrays.operand_locator_t.__le__ +ida_hexrays.operand_locator_t.__lt__ +ida_hexrays.operand_locator_t.__ne__ +ida_hexrays.operand_locator_t.compare +ida_hexrays.operand_locator_t.ea +ida_hexrays.operand_locator_t.opnum +ida_hexrays.optblock_t +ida_hexrays.optblock_t.__disown__ +ida_hexrays.optblock_t.__init__ +ida_hexrays.optblock_t.func +ida_hexrays.optblock_t.install +ida_hexrays.optblock_t.remove +ida_hexrays.optinsn_t +ida_hexrays.optinsn_t.__disown__ +ida_hexrays.optinsn_t.__init__ +ida_hexrays.optinsn_t.func +ida_hexrays.optinsn_t.install +ida_hexrays.optinsn_t.remove +ida_hexrays.parse_user_call +ida_hexrays.partial_type_num +ida_hexrays.print_vdloc +ida_hexrays.property_op_to_typename +ida_hexrays.qstring_printer_t +ida_hexrays.qstring_printer_t.__init__ +ida_hexrays.qstring_printer_t._print +ida_hexrays.qstring_printer_t.get_s +ida_hexrays.qstring_printer_t.s +ida_hexrays.qstring_printer_t.s +ida_hexrays.qstring_printer_t.with_tags +ida_hexrays.qswap +ida_hexrays.qvector_carg_t +ida_hexrays.qvector_carg_t.__eq__ +ida_hexrays.qvector_carg_t.__getitem__ +ida_hexrays.qvector_carg_t.__init__ +ida_hexrays.qvector_carg_t.__len__ +ida_hexrays.qvector_carg_t.__ne__ +ida_hexrays.qvector_carg_t.__setitem__ +ida_hexrays.qvector_carg_t._del +ida_hexrays.qvector_carg_t.add_unique +ida_hexrays.qvector_carg_t.append +ida_hexrays.qvector_carg_t.at +ida_hexrays.qvector_carg_t.begin +ida_hexrays.qvector_carg_t.capacity +ida_hexrays.qvector_carg_t.clear +ida_hexrays.qvector_carg_t.empty +ida_hexrays.qvector_carg_t.end +ida_hexrays.qvector_carg_t.erase +ida_hexrays.qvector_carg_t.extend +ida_hexrays.qvector_carg_t.extract +ida_hexrays.qvector_carg_t.find +ida_hexrays.qvector_carg_t.grow +ida_hexrays.qvector_carg_t.has +ida_hexrays.qvector_carg_t.inject +ida_hexrays.qvector_carg_t.insert +ida_hexrays.qvector_carg_t.pop_back +ida_hexrays.qvector_carg_t.push_back +ida_hexrays.qvector_carg_t.qclear +ida_hexrays.qvector_carg_t.reserve +ida_hexrays.qvector_carg_t.resize +ida_hexrays.qvector_carg_t.size +ida_hexrays.qvector_carg_t.swap +ida_hexrays.qvector_carg_t.truncate +ida_hexrays.qvector_catchexprs_t +ida_hexrays.qvector_catchexprs_t.__eq__ +ida_hexrays.qvector_catchexprs_t.__getitem__ +ida_hexrays.qvector_catchexprs_t.__init__ +ida_hexrays.qvector_catchexprs_t.__len__ +ida_hexrays.qvector_catchexprs_t.__ne__ +ida_hexrays.qvector_catchexprs_t.__setitem__ +ida_hexrays.qvector_catchexprs_t._del +ida_hexrays.qvector_catchexprs_t.add_unique +ida_hexrays.qvector_catchexprs_t.append +ida_hexrays.qvector_catchexprs_t.at +ida_hexrays.qvector_catchexprs_t.begin +ida_hexrays.qvector_catchexprs_t.capacity +ida_hexrays.qvector_catchexprs_t.clear +ida_hexrays.qvector_catchexprs_t.empty +ida_hexrays.qvector_catchexprs_t.end +ida_hexrays.qvector_catchexprs_t.erase +ida_hexrays.qvector_catchexprs_t.extend +ida_hexrays.qvector_catchexprs_t.extract +ida_hexrays.qvector_catchexprs_t.find +ida_hexrays.qvector_catchexprs_t.grow +ida_hexrays.qvector_catchexprs_t.has +ida_hexrays.qvector_catchexprs_t.inject +ida_hexrays.qvector_catchexprs_t.insert +ida_hexrays.qvector_catchexprs_t.pop_back +ida_hexrays.qvector_catchexprs_t.push_back +ida_hexrays.qvector_catchexprs_t.qclear +ida_hexrays.qvector_catchexprs_t.reserve +ida_hexrays.qvector_catchexprs_t.resize +ida_hexrays.qvector_catchexprs_t.size +ida_hexrays.qvector_catchexprs_t.swap +ida_hexrays.qvector_catchexprs_t.truncate +ida_hexrays.qvector_ccase_t +ida_hexrays.qvector_ccase_t.__eq__ +ida_hexrays.qvector_ccase_t.__getitem__ +ida_hexrays.qvector_ccase_t.__init__ +ida_hexrays.qvector_ccase_t.__len__ +ida_hexrays.qvector_ccase_t.__ne__ +ida_hexrays.qvector_ccase_t.__setitem__ +ida_hexrays.qvector_ccase_t._del +ida_hexrays.qvector_ccase_t.add_unique +ida_hexrays.qvector_ccase_t.append +ida_hexrays.qvector_ccase_t.at +ida_hexrays.qvector_ccase_t.begin +ida_hexrays.qvector_ccase_t.capacity +ida_hexrays.qvector_ccase_t.clear +ida_hexrays.qvector_ccase_t.empty +ida_hexrays.qvector_ccase_t.end +ida_hexrays.qvector_ccase_t.erase +ida_hexrays.qvector_ccase_t.extend +ida_hexrays.qvector_ccase_t.extract +ida_hexrays.qvector_ccase_t.find +ida_hexrays.qvector_ccase_t.grow +ida_hexrays.qvector_ccase_t.has +ida_hexrays.qvector_ccase_t.inject +ida_hexrays.qvector_ccase_t.insert +ida_hexrays.qvector_ccase_t.pop_back +ida_hexrays.qvector_ccase_t.push_back +ida_hexrays.qvector_ccase_t.qclear +ida_hexrays.qvector_ccase_t.reserve +ida_hexrays.qvector_ccase_t.resize +ida_hexrays.qvector_ccase_t.size +ida_hexrays.qvector_ccase_t.swap +ida_hexrays.qvector_ccase_t.truncate +ida_hexrays.qvector_ccatchvec_t +ida_hexrays.qvector_ccatchvec_t.__eq__ +ida_hexrays.qvector_ccatchvec_t.__getitem__ +ida_hexrays.qvector_ccatchvec_t.__init__ +ida_hexrays.qvector_ccatchvec_t.__len__ +ida_hexrays.qvector_ccatchvec_t.__ne__ +ida_hexrays.qvector_ccatchvec_t.__setitem__ +ida_hexrays.qvector_ccatchvec_t._del +ida_hexrays.qvector_ccatchvec_t.add_unique +ida_hexrays.qvector_ccatchvec_t.append +ida_hexrays.qvector_ccatchvec_t.at +ida_hexrays.qvector_ccatchvec_t.begin +ida_hexrays.qvector_ccatchvec_t.capacity +ida_hexrays.qvector_ccatchvec_t.clear +ida_hexrays.qvector_ccatchvec_t.empty +ida_hexrays.qvector_ccatchvec_t.end +ida_hexrays.qvector_ccatchvec_t.erase +ida_hexrays.qvector_ccatchvec_t.extend +ida_hexrays.qvector_ccatchvec_t.extract +ida_hexrays.qvector_ccatchvec_t.find +ida_hexrays.qvector_ccatchvec_t.grow +ida_hexrays.qvector_ccatchvec_t.has +ida_hexrays.qvector_ccatchvec_t.inject +ida_hexrays.qvector_ccatchvec_t.insert +ida_hexrays.qvector_ccatchvec_t.pop_back +ida_hexrays.qvector_ccatchvec_t.push_back +ida_hexrays.qvector_ccatchvec_t.qclear +ida_hexrays.qvector_ccatchvec_t.reserve +ida_hexrays.qvector_ccatchvec_t.resize +ida_hexrays.qvector_ccatchvec_t.size +ida_hexrays.qvector_ccatchvec_t.swap +ida_hexrays.qvector_ccatchvec_t.truncate +ida_hexrays.qvector_history_t +ida_hexrays.qvector_history_t.__eq__ +ida_hexrays.qvector_history_t.__getitem__ +ida_hexrays.qvector_history_t.__init__ +ida_hexrays.qvector_history_t.__len__ +ida_hexrays.qvector_history_t.__ne__ +ida_hexrays.qvector_history_t.__setitem__ +ida_hexrays.qvector_history_t._del +ida_hexrays.qvector_history_t.add_unique +ida_hexrays.qvector_history_t.append +ida_hexrays.qvector_history_t.at +ida_hexrays.qvector_history_t.begin +ida_hexrays.qvector_history_t.capacity +ida_hexrays.qvector_history_t.clear +ida_hexrays.qvector_history_t.empty +ida_hexrays.qvector_history_t.end +ida_hexrays.qvector_history_t.erase +ida_hexrays.qvector_history_t.extend +ida_hexrays.qvector_history_t.extract +ida_hexrays.qvector_history_t.find +ida_hexrays.qvector_history_t.grow +ida_hexrays.qvector_history_t.has +ida_hexrays.qvector_history_t.inject +ida_hexrays.qvector_history_t.insert +ida_hexrays.qvector_history_t.pop_back +ida_hexrays.qvector_history_t.push_back +ida_hexrays.qvector_history_t.qclear +ida_hexrays.qvector_history_t.reserve +ida_hexrays.qvector_history_t.resize +ida_hexrays.qvector_history_t.size +ida_hexrays.qvector_history_t.swap +ida_hexrays.qvector_history_t.truncate +ida_hexrays.qvector_lvar_t +ida_hexrays.qvector_lvar_t.__eq__ +ida_hexrays.qvector_lvar_t.__getitem__ +ida_hexrays.qvector_lvar_t.__init__ +ida_hexrays.qvector_lvar_t.__len__ +ida_hexrays.qvector_lvar_t.__ne__ +ida_hexrays.qvector_lvar_t.__setitem__ +ida_hexrays.qvector_lvar_t._del +ida_hexrays.qvector_lvar_t.add_unique +ida_hexrays.qvector_lvar_t.append +ida_hexrays.qvector_lvar_t.at +ida_hexrays.qvector_lvar_t.begin +ida_hexrays.qvector_lvar_t.capacity +ida_hexrays.qvector_lvar_t.clear +ida_hexrays.qvector_lvar_t.empty +ida_hexrays.qvector_lvar_t.end +ida_hexrays.qvector_lvar_t.erase +ida_hexrays.qvector_lvar_t.extend +ida_hexrays.qvector_lvar_t.extract +ida_hexrays.qvector_lvar_t.find +ida_hexrays.qvector_lvar_t.grow +ida_hexrays.qvector_lvar_t.has +ida_hexrays.qvector_lvar_t.inject +ida_hexrays.qvector_lvar_t.insert +ida_hexrays.qvector_lvar_t.pop_back +ida_hexrays.qvector_lvar_t.push_back +ida_hexrays.qvector_lvar_t.qclear +ida_hexrays.qvector_lvar_t.reserve +ida_hexrays.qvector_lvar_t.resize +ida_hexrays.qvector_lvar_t.size +ida_hexrays.qvector_lvar_t.swap +ida_hexrays.qvector_lvar_t.truncate +ida_hexrays.reg2mreg +ida_hexrays.remitem +ida_hexrays.remove_hexrays_callback +ida_hexrays.rename_lvar +ida_hexrays.restore_user_cmts +ida_hexrays.restore_user_defined_calls +ida_hexrays.restore_user_iflags +ida_hexrays.restore_user_labels +ida_hexrays.restore_user_lvar_settings +ida_hexrays.restore_user_numforms +ida_hexrays.restore_user_unions +ida_hexrays.rlist_t +ida_hexrays.rlist_t.__init__ +ida_hexrays.rlist_t.dstr +ida_hexrays.save_user_cmts +ida_hexrays.save_user_defined_calls +ida_hexrays.save_user_iflags +ida_hexrays.save_user_labels +ida_hexrays.save_user_lvar_settings +ida_hexrays.save_user_numforms +ida_hexrays.save_user_unions +ida_hexrays.scif_t +ida_hexrays.scif_t.__init__ +ida_hexrays.scif_t.mba +ida_hexrays.scif_t.name +ida_hexrays.scif_t.type +ida_hexrays.scif_visitor_t +ida_hexrays.scif_visitor_t.__disown__ +ida_hexrays.scif_visitor_t.__init__ +ida_hexrays.scif_visitor_t.visit_scif_mop +ida_hexrays.select_udt_by_offset +ida_hexrays.send_database +ida_hexrays.set2jcnd +ida_hexrays.set_type +ida_hexrays.simple_graph_t +ida_hexrays.simple_graph_t.__init__ +ida_hexrays.simple_graph_t.begin +ida_hexrays.simple_graph_t.compute_dominators +ida_hexrays.simple_graph_t.compute_immediate_dominators +ida_hexrays.simple_graph_t.depth_first_postorder +ida_hexrays.simple_graph_t.depth_first_preorder +ida_hexrays.simple_graph_t.end +ida_hexrays.simple_graph_t.front +ida_hexrays.simple_graph_t.goup +ida_hexrays.simple_graph_t.inc +ida_hexrays.stkvar_ref_t +ida_hexrays.stkvar_ref_t.__eq__ +ida_hexrays.stkvar_ref_t.__ge__ +ida_hexrays.stkvar_ref_t.__gt__ +ida_hexrays.stkvar_ref_t.__init__ +ida_hexrays.stkvar_ref_t.__le__ +ida_hexrays.stkvar_ref_t.__lt__ +ida_hexrays.stkvar_ref_t.__ne__ +ida_hexrays.stkvar_ref_t.compare +ida_hexrays.stkvar_ref_t.get_stkvar +ida_hexrays.stkvar_ref_t.mba +ida_hexrays.stkvar_ref_t.off +ida_hexrays.stkvar_ref_t.swap +ida_hexrays.swap_mcode_relation +ida_hexrays.swapped_relation +ida_hexrays.term_hexrays_plugin +ida_hexrays.treeloc_t +ida_hexrays.treeloc_t.__eq__ +ida_hexrays.treeloc_t.__init__ +ida_hexrays.treeloc_t.__lt__ +ida_hexrays.udc_filter_t +ida_hexrays.udc_filter_t.__disown__ +ida_hexrays.udc_filter_t.__init__ +ida_hexrays.udc_filter_t.apply +ida_hexrays.udc_filter_t.cleanup +ida_hexrays.udc_filter_t.empty +ida_hexrays.udc_filter_t.init +ida_hexrays.udc_filter_t.install +ida_hexrays.udc_filter_t.match +ida_hexrays.udc_filter_t.remove +ida_hexrays.udcall_map_begin +ida_hexrays.udcall_map_clear +ida_hexrays.udcall_map_end +ida_hexrays.udcall_map_erase +ida_hexrays.udcall_map_find +ida_hexrays.udcall_map_first +ida_hexrays.udcall_map_free +ida_hexrays.udcall_map_insert +ida_hexrays.udcall_map_iterator_t +ida_hexrays.udcall_map_iterator_t.__eq__ +ida_hexrays.udcall_map_iterator_t.__init__ +ida_hexrays.udcall_map_iterator_t.__ne__ +ida_hexrays.udcall_map_new +ida_hexrays.udcall_map_next +ida_hexrays.udcall_map_prev +ida_hexrays.udcall_map_second +ida_hexrays.udcall_map_size +ida_hexrays.udcall_t +ida_hexrays.udcall_t.__eq__ +ida_hexrays.udcall_t.__ge__ +ida_hexrays.udcall_t.__gt__ +ida_hexrays.udcall_t.__init__ +ida_hexrays.udcall_t.__le__ +ida_hexrays.udcall_t.__lt__ +ida_hexrays.udcall_t.__ne__ +ida_hexrays.udcall_t.compare +ida_hexrays.udcall_t.empty +ida_hexrays.ui_stroff_applicator_t +ida_hexrays.ui_stroff_applicator_t.__disown__ +ida_hexrays.ui_stroff_applicator_t.__init__ +ida_hexrays.ui_stroff_applicator_t.apply +ida_hexrays.ui_stroff_op_t +ida_hexrays.ui_stroff_op_t.__eq__ +ida_hexrays.ui_stroff_op_t.__init__ +ida_hexrays.ui_stroff_op_t.__ne__ +ida_hexrays.ui_stroff_op_t.offset +ida_hexrays.ui_stroff_op_t.text +ida_hexrays.ui_stroff_ops_t +ida_hexrays.ui_stroff_ops_t.__eq__ +ida_hexrays.ui_stroff_ops_t.__getitem__ +ida_hexrays.ui_stroff_ops_t.__init__ +ida_hexrays.ui_stroff_ops_t.__len__ +ida_hexrays.ui_stroff_ops_t.__ne__ +ida_hexrays.ui_stroff_ops_t.__setitem__ +ida_hexrays.ui_stroff_ops_t._del +ida_hexrays.ui_stroff_ops_t.add_unique +ida_hexrays.ui_stroff_ops_t.append +ida_hexrays.ui_stroff_ops_t.at +ida_hexrays.ui_stroff_ops_t.begin +ida_hexrays.ui_stroff_ops_t.capacity +ida_hexrays.ui_stroff_ops_t.clear +ida_hexrays.ui_stroff_ops_t.empty +ida_hexrays.ui_stroff_ops_t.end +ida_hexrays.ui_stroff_ops_t.erase +ida_hexrays.ui_stroff_ops_t.extend +ida_hexrays.ui_stroff_ops_t.extract +ida_hexrays.ui_stroff_ops_t.find +ida_hexrays.ui_stroff_ops_t.grow +ida_hexrays.ui_stroff_ops_t.has +ida_hexrays.ui_stroff_ops_t.inject +ida_hexrays.ui_stroff_ops_t.insert +ida_hexrays.ui_stroff_ops_t.pop_back +ida_hexrays.ui_stroff_ops_t.push_back +ida_hexrays.ui_stroff_ops_t.qclear +ida_hexrays.ui_stroff_ops_t.reserve +ida_hexrays.ui_stroff_ops_t.resize +ida_hexrays.ui_stroff_ops_t.size +ida_hexrays.ui_stroff_ops_t.swap +ida_hexrays.ui_stroff_ops_t.truncate +ida_hexrays.user_cmts_begin +ida_hexrays.user_cmts_clear +ida_hexrays.user_cmts_end +ida_hexrays.user_cmts_erase +ida_hexrays.user_cmts_find +ida_hexrays.user_cmts_first +ida_hexrays.user_cmts_free +ida_hexrays.user_cmts_insert +ida_hexrays.user_cmts_iterator_t +ida_hexrays.user_cmts_iterator_t.__eq__ +ida_hexrays.user_cmts_iterator_t.__init__ +ida_hexrays.user_cmts_iterator_t.__ne__ +ida_hexrays.user_cmts_new +ida_hexrays.user_cmts_next +ida_hexrays.user_cmts_prev +ida_hexrays.user_cmts_second +ida_hexrays.user_cmts_size +ida_hexrays.user_cmts_t +ida_hexrays.user_cmts_t.__init__ +ida_hexrays.user_cmts_t.at +ida_hexrays.user_cmts_t.size +ida_hexrays.user_iflags_begin +ida_hexrays.user_iflags_clear +ida_hexrays.user_iflags_end +ida_hexrays.user_iflags_erase +ida_hexrays.user_iflags_find +ida_hexrays.user_iflags_first +ida_hexrays.user_iflags_free +ida_hexrays.user_iflags_insert +ida_hexrays.user_iflags_iterator_t +ida_hexrays.user_iflags_iterator_t.__eq__ +ida_hexrays.user_iflags_iterator_t.__init__ +ida_hexrays.user_iflags_iterator_t.__ne__ +ida_hexrays.user_iflags_new +ida_hexrays.user_iflags_next +ida_hexrays.user_iflags_prev +ida_hexrays.user_iflags_second +ida_hexrays.user_iflags_size +ida_hexrays.user_iflags_t +ida_hexrays.user_iflags_t.__init__ +ida_hexrays.user_iflags_t.at +ida_hexrays.user_iflags_t.size +ida_hexrays.user_labels_begin +ida_hexrays.user_labels_clear +ida_hexrays.user_labels_end +ida_hexrays.user_labels_erase +ida_hexrays.user_labels_find +ida_hexrays.user_labels_first +ida_hexrays.user_labels_free +ida_hexrays.user_labels_insert +ida_hexrays.user_labels_iterator_t +ida_hexrays.user_labels_iterator_t.__eq__ +ida_hexrays.user_labels_iterator_t.__init__ +ida_hexrays.user_labels_iterator_t.__ne__ +ida_hexrays.user_labels_new +ida_hexrays.user_labels_next +ida_hexrays.user_labels_prev +ida_hexrays.user_labels_second +ida_hexrays.user_labels_size +ida_hexrays.user_labels_t +ida_hexrays.user_labels_t.__init__ +ida_hexrays.user_labels_t.at +ida_hexrays.user_labels_t.size +ida_hexrays.user_lvar_modifier_t +ida_hexrays.user_lvar_modifier_t.__disown__ +ida_hexrays.user_lvar_modifier_t.__init__ +ida_hexrays.user_lvar_modifier_t.modify_lvars +ida_hexrays.user_numforms_begin +ida_hexrays.user_numforms_clear +ida_hexrays.user_numforms_end +ida_hexrays.user_numforms_erase +ida_hexrays.user_numforms_find +ida_hexrays.user_numforms_first +ida_hexrays.user_numforms_free +ida_hexrays.user_numforms_insert +ida_hexrays.user_numforms_iterator_t +ida_hexrays.user_numforms_iterator_t.__eq__ +ida_hexrays.user_numforms_iterator_t.__init__ +ida_hexrays.user_numforms_iterator_t.__ne__ +ida_hexrays.user_numforms_new +ida_hexrays.user_numforms_next +ida_hexrays.user_numforms_prev +ida_hexrays.user_numforms_second +ida_hexrays.user_numforms_size +ida_hexrays.user_numforms_t +ida_hexrays.user_numforms_t.__init__ +ida_hexrays.user_numforms_t.at +ida_hexrays.user_numforms_t.size +ida_hexrays.user_unions_begin +ida_hexrays.user_unions_clear +ida_hexrays.user_unions_end +ida_hexrays.user_unions_erase +ida_hexrays.user_unions_find +ida_hexrays.user_unions_first +ida_hexrays.user_unions_free +ida_hexrays.user_unions_insert +ida_hexrays.user_unions_iterator_t +ida_hexrays.user_unions_iterator_t.__eq__ +ida_hexrays.user_unions_iterator_t.__init__ +ida_hexrays.user_unions_iterator_t.__ne__ +ida_hexrays.user_unions_new +ida_hexrays.user_unions_next +ida_hexrays.user_unions_prev +ida_hexrays.user_unions_second +ida_hexrays.user_unions_size +ida_hexrays.user_unions_t +ida_hexrays.user_unions_t.__init__ +ida_hexrays.user_unions_t.at +ida_hexrays.user_unions_t.size +ida_hexrays.uval_ivl_ivlset_t +ida_hexrays.uval_ivl_ivlset_t.__eq__ +ida_hexrays.uval_ivl_ivlset_t.__init__ +ida_hexrays.uval_ivl_ivlset_t.__ne__ +ida_hexrays.uval_ivl_ivlset_t.all_values +ida_hexrays.uval_ivl_ivlset_t.begin +ida_hexrays.uval_ivl_ivlset_t.clear +ida_hexrays.uval_ivl_ivlset_t.empty +ida_hexrays.uval_ivl_ivlset_t.end +ida_hexrays.uval_ivl_ivlset_t.getivl +ida_hexrays.uval_ivl_ivlset_t.lastivl +ida_hexrays.uval_ivl_ivlset_t.nivls +ida_hexrays.uval_ivl_ivlset_t.qclear +ida_hexrays.uval_ivl_ivlset_t.set_all_values +ida_hexrays.uval_ivl_ivlset_t.single_value +ida_hexrays.uval_ivl_ivlset_t.swap +ida_hexrays.uval_ivl_t +ida_hexrays.uval_ivl_t.__init__ +ida_hexrays.uval_ivl_t.end +ida_hexrays.uval_ivl_t.last +ida_hexrays.uval_ivl_t.valid +ida_hexrays.valrng_t +ida_hexrays.valrng_t.__eq__ +ida_hexrays.valrng_t.__ge__ +ida_hexrays.valrng_t.__gt__ +ida_hexrays.valrng_t.__init__ +ida_hexrays.valrng_t.__le__ +ida_hexrays.valrng_t.__lt__ +ida_hexrays.valrng_t.__ne__ +ida_hexrays.valrng_t._deregister +ida_hexrays.valrng_t._print +ida_hexrays.valrng_t._register +ida_hexrays.valrng_t.all_values +ida_hexrays.valrng_t.compare +ida_hexrays.valrng_t.cvt_to_cmp +ida_hexrays.valrng_t.cvt_to_single_value +ida_hexrays.valrng_t.dstr +ida_hexrays.valrng_t.empty +ida_hexrays.valrng_t.get_size +ida_hexrays.valrng_t.has +ida_hexrays.valrng_t.intersect_with +ida_hexrays.valrng_t.inverse +ida_hexrays.valrng_t.is_unknown +ida_hexrays.valrng_t.max_svalue +ida_hexrays.valrng_t.max_value +ida_hexrays.valrng_t.min_svalue +ida_hexrays.valrng_t.reduce_size +ida_hexrays.valrng_t.set_all +ida_hexrays.valrng_t.set_cmp +ida_hexrays.valrng_t.set_eq +ida_hexrays.valrng_t.set_none +ida_hexrays.valrng_t.set_unk +ida_hexrays.valrng_t.swap +ida_hexrays.valrng_t.unite_with +ida_hexrays.var_ref_t +ida_hexrays.var_ref_t.__eq__ +ida_hexrays.var_ref_t.__ge__ +ida_hexrays.var_ref_t.__gt__ +ida_hexrays.var_ref_t.__init__ +ida_hexrays.var_ref_t.__le__ +ida_hexrays.var_ref_t.__lt__ +ida_hexrays.var_ref_t.__ne__ +ida_hexrays.var_ref_t.compare +ida_hexrays.var_ref_t.getv +ida_hexrays.var_ref_t.idx +ida_hexrays.var_ref_t.mba +ida_hexrays.vc_printer_t +ida_hexrays.vc_printer_t.__disown__ +ida_hexrays.vc_printer_t.__init__ +ida_hexrays.vc_printer_t.func +ida_hexrays.vc_printer_t.lastchar +ida_hexrays.vc_printer_t.oneliner +ida_hexrays.vd_failure_t +ida_hexrays.vd_failure_t.__init__ +ida_hexrays.vd_failure_t.desc +ida_hexrays.vd_interr_t +ida_hexrays.vd_interr_t.__init__ +ida_hexrays.vd_printer_t +ida_hexrays.vd_printer_t.__disown__ +ida_hexrays.vd_printer_t.__init__ +ida_hexrays.vd_printer_t._print +ida_hexrays.vd_printer_t.hdrlines +ida_hexrays.vdloc_t +ida_hexrays.vdloc_t.__eq__ +ida_hexrays.vdloc_t.__ge__ +ida_hexrays.vdloc_t.__gt__ +ida_hexrays.vdloc_t.__init__ +ida_hexrays.vdloc_t.__le__ +ida_hexrays.vdloc_t.__lt__ +ida_hexrays.vdloc_t.__ne__ +ida_hexrays.vdloc_t._set_reg1 +ida_hexrays.vdloc_t.compare +ida_hexrays.vdloc_t.is_aliasable +ida_hexrays.vdloc_t.reg1 +ida_hexrays.vdloc_t.set_reg1 +ida_hexrays.vdui_t +ida_hexrays.vdui_t.__init__ +ida_hexrays.vdui_t.calc_cmt_type +ida_hexrays.vdui_t.cfunc +ida_hexrays.vdui_t.clear +ida_hexrays.vdui_t.collapse_item +ida_hexrays.vdui_t.collapse_lvars +ida_hexrays.vdui_t.cpos +ida_hexrays.vdui_t.ct +ida_hexrays.vdui_t.ctree_to_disasm +ida_hexrays.vdui_t.del_orphan_cmts +ida_hexrays.vdui_t.edit_cmt +ida_hexrays.vdui_t.edit_func_cmt +ida_hexrays.vdui_t.flags +ida_hexrays.vdui_t.get_current_item +ida_hexrays.vdui_t.get_current_label +ida_hexrays.vdui_t.get_number +ida_hexrays.vdui_t.head +ida_hexrays.vdui_t.in_ctree +ida_hexrays.vdui_t.invert_bits +ida_hexrays.vdui_t.invert_sign +ida_hexrays.vdui_t.item +ida_hexrays.vdui_t.jump_enter +ida_hexrays.vdui_t.last_code +ida_hexrays.vdui_t.locked +ida_hexrays.vdui_t.map_lvar +ida_hexrays.vdui_t.mba +ida_hexrays.vdui_t.refresh_cpos +ida_hexrays.vdui_t.refresh_ctext +ida_hexrays.vdui_t.refresh_view +ida_hexrays.vdui_t.rename_global +ida_hexrays.vdui_t.rename_label +ida_hexrays.vdui_t.rename_lvar +ida_hexrays.vdui_t.rename_udm +ida_hexrays.vdui_t.set_global_type +ida_hexrays.vdui_t.set_locked +ida_hexrays.vdui_t.set_lvar_cmt +ida_hexrays.vdui_t.set_lvar_type +ida_hexrays.vdui_t.set_noptr_lvar +ida_hexrays.vdui_t.set_num_enum +ida_hexrays.vdui_t.set_num_radix +ida_hexrays.vdui_t.set_num_stroff +ida_hexrays.vdui_t.set_udm_type +ida_hexrays.vdui_t.set_valid +ida_hexrays.vdui_t.set_visible +ida_hexrays.vdui_t.split_item +ida_hexrays.vdui_t.switch_to +ida_hexrays.vdui_t.tail +ida_hexrays.vdui_t.ui_edit_lvar_cmt +ida_hexrays.vdui_t.ui_map_lvar +ida_hexrays.vdui_t.ui_rename_lvar +ida_hexrays.vdui_t.ui_set_call_type +ida_hexrays.vdui_t.ui_set_lvar_type +ida_hexrays.vdui_t.ui_unmap_lvar +ida_hexrays.vdui_t.valid +ida_hexrays.vdui_t.view_idx +ida_hexrays.vdui_t.visible +ida_hexrays.vivl_t +ida_hexrays.vivl_t.__eq__ +ida_hexrays.vivl_t.__ge__ +ida_hexrays.vivl_t.__gt__ +ida_hexrays.vivl_t.__init__ +ida_hexrays.vivl_t.__le__ +ida_hexrays.vivl_t.__lt__ +ida_hexrays.vivl_t.__ne__ +ida_hexrays.vivl_t._print +ida_hexrays.vivl_t.compare +ida_hexrays.vivl_t.contains +ida_hexrays.vivl_t.dstr +ida_hexrays.vivl_t.extend_to_cover +ida_hexrays.vivl_t.includes +ida_hexrays.vivl_t.intersect +ida_hexrays.vivl_t.overlap +ida_hexrays.vivl_t.set +ida_hexrays.vivl_t.set_reg +ida_hexrays.vivl_t.set_stkoff +ida_hexrays.vivl_t.size +ida_hexrays.voff_t +ida_hexrays.voff_t.__eq__ +ida_hexrays.voff_t.__ge__ +ida_hexrays.voff_t.__gt__ +ida_hexrays.voff_t.__init__ +ida_hexrays.voff_t.__le__ +ida_hexrays.voff_t.__lt__ +ida_hexrays.voff_t.__ne__ +ida_hexrays.voff_t.add +ida_hexrays.voff_t.compare +ida_hexrays.voff_t.defined +ida_hexrays.voff_t.diff +ida_hexrays.voff_t.get_reg +ida_hexrays.voff_t.get_stkoff +ida_hexrays.voff_t.inc +ida_hexrays.voff_t.is_reg +ida_hexrays.voff_t.is_stkoff +ida_hexrays.voff_t.off +ida_hexrays.voff_t.set +ida_hexrays.voff_t.set_reg +ida_hexrays.voff_t.set_stkoff +ida_hexrays.voff_t.type +ida_hexrays.voff_t.undef +ida_allins +ida_auto +ida_auto.AU_CHLB +ida_auto.AU_CODE +ida_auto.AU_FCHUNK +ida_auto.AU_FINAL +ida_auto.AU_LBF2 +ida_auto.AU_LBF3 +ida_auto.AU_LIBF +ida_auto.AU_NONE +ida_auto.AU_PROC +ida_auto.AU_TAIL +ida_auto.AU_TYPE +ida_auto.AU_UNK +ida_auto.AU_USD2 +ida_auto.AU_USED +ida_auto.AU_WEAK +ida_auto.auto_apply_tail +ida_auto.auto_apply_type +ida_auto.auto_cancel +ida_auto.auto_display_t +ida_auto.auto_display_t.__init__ +ida_auto.auto_get +ida_auto.auto_is_ok +ida_auto.auto_make_code +ida_auto.auto_make_proc +ida_auto.auto_make_step +ida_auto.auto_mark +ida_auto.auto_mark_range +ida_auto.auto_postpone_analysis +ida_auto.auto_recreate_insn +ida_auto.auto_unmark +ida_auto.auto_wait +ida_auto.auto_wait_range +ida_auto.enable_auto +ida_auto.get_auto_display +ida_auto.get_auto_state +ida_auto.is_auto_enabled +ida_auto.may_create_stkvars +ida_auto.may_trace_sp +ida_auto.peek_auto_queue +ida_auto.plan_and_wait +ida_auto.plan_ea +ida_auto.plan_range +ida_auto.reanalyze_callers +ida_auto.revert_ida_decisions +ida_auto.set_auto_state +ida_auto.set_ida_state +ida_auto.show_addr +ida_auto.show_auto +ida_auto.st_Ready +ida_auto.st_Think +ida_auto.st_Waiting +ida_auto.st_Work +ida_bitrange +ida_bitrange.bitrange_t +ida_bitrange.bitrange_t.__eq__ +ida_bitrange.bitrange_t.__ge__ +ida_bitrange.bitrange_t.__gt__ +ida_bitrange.bitrange_t.__init__ +ida_bitrange.bitrange_t.__le__ +ida_bitrange.bitrange_t.__lt__ +ida_bitrange.bitrange_t.__ne__ +ida_bitrange.bitrange_t.__repr__ +ida_bitrange.bitrange_t.__str__ +ida_bitrange.bitrange_t.apply_mask +ida_bitrange.bitrange_t.bitoff +ida_bitrange.bitrange_t.bitsize +ida_bitrange.bitrange_t.bytesize +ida_bitrange.bitrange_t.compare +ida_bitrange.bitrange_t.create_union +ida_bitrange.bitrange_t.empty +ida_bitrange.bitrange_t.extract +ida_bitrange.bitrange_t.has_common +ida_bitrange.bitrange_t.init +ida_bitrange.bitrange_t.inject +ida_bitrange.bitrange_t.intersect +ida_bitrange.bitrange_t.mask64 +ida_bitrange.bitrange_t.reset +ida_bitrange.bitrange_t.shift_down +ida_bitrange.bitrange_t.shift_up +ida_bitrange.bitrange_t.sub +ida_bytes +ida_bytes.ALOPT_APPEND +ida_bytes.ALOPT_IGNCLT +ida_bytes.ALOPT_IGNHEADS +ida_bytes.ALOPT_IGNPRINT +ida_bytes.ALOPT_MAX4K +ida_bytes.ALOPT_ONLYTERM +ida_bytes.BIN_SEARCH_BACKWARD +ida_bytes.BIN_SEARCH_BITMASK +ida_bytes.BIN_SEARCH_CASE +ida_bytes.BIN_SEARCH_FORWARD +ida_bytes.BIN_SEARCH_INITED +ida_bytes.BIN_SEARCH_NOBREAK +ida_bytes.BIN_SEARCH_NOCASE +ida_bytes.BIN_SEARCH_NOSHOW +ida_bytes.DELIT_DELNAMES +ida_bytes.DELIT_EXPAND +ida_bytes.DELIT_KEEPFUNC +ida_bytes.DELIT_NOCMT +ida_bytes.DELIT_NOTRUNC +ida_bytes.DELIT_NOUNAME +ida_bytes.DELIT_SIMPLE +ida_bytes.DTP_NODUP +ida_bytes.DTP_NODUP +ida_bytes.DT_TYPE +ida_bytes.FF_ALIGN +ida_bytes.FF_ANYNAME +ida_bytes.FF_BNOT +ida_bytes.FF_BYTE +ida_bytes.FF_CODE +ida_bytes.FF_COMM +ida_bytes.FF_CUSTOM +ida_bytes.FF_DATA +ida_bytes.FF_DOUBLE +ida_bytes.FF_DWORD +ida_bytes.FF_FLOAT +ida_bytes.FF_FLOW +ida_bytes.FF_FUNC +ida_bytes.FF_IMMD +ida_bytes.FF_IVL +ida_bytes.FF_JUMP +ida_bytes.FF_LABL +ida_bytes.FF_LINE +ida_bytes.FF_NAME +ida_bytes.FF_N_CHAR +ida_bytes.FF_N_CUST +ida_bytes.FF_N_ENUM +ida_bytes.FF_N_FLT +ida_bytes.FF_N_FOP +ida_bytes.FF_N_NUMB +ida_bytes.FF_N_NUMD +ida_bytes.FF_N_NUMH +ida_bytes.FF_N_NUMO +ida_bytes.FF_N_OFF +ida_bytes.FF_N_SEG +ida_bytes.FF_N_STK +ida_bytes.FF_N_STRO +ida_bytes.FF_N_VOID +ida_bytes.FF_OWORD +ida_bytes.FF_PACKREAL +ida_bytes.FF_QWORD +ida_bytes.FF_REF +ida_bytes.FF_SIGN +ida_bytes.FF_STRLIT +ida_bytes.FF_STRUCT +ida_bytes.FF_TAIL +ida_bytes.FF_TBYTE +ida_bytes.FF_UNK +ida_bytes.FF_UNUSED +ida_bytes.FF_WORD +ida_bytes.FF_YWORD +ida_bytes.FF_ZWORD +ida_bytes.GFE_IDB_VALUE +ida_bytes.GFE_VALUE +ida_bytes.GMB_READALL +ida_bytes.GMB_WAITBOX +ida_bytes.ITEM_END_CANCEL +ida_bytes.ITEM_END_FIXUP +ida_bytes.ITEM_END_INITED +ida_bytes.ITEM_END_NAME +ida_bytes.ITEM_END_XREF +ida_bytes.MS_CLS +ida_bytes.MS_CODE +ida_bytes.MS_COMM +ida_bytes.MS_N_TYPE +ida_bytes.MS_VAL +ida_bytes.OPND_ALL +ida_bytes.OPND_MASK +ida_bytes.OPND_OUTER +ida_bytes.PBSENC_ALL +ida_bytes.PBSENC_DEF1BPU +ida_bytes.PSTF_ATTRIB +ida_bytes.PSTF_ENC +ida_bytes.PSTF_HOTKEY +ida_bytes.PSTF_ONLY_ENC +ida_bytes.PSTF_TBRIEF +ida_bytes.PSTF_TINLIN +ida_bytes.PSTF_TMASK +ida_bytes.PSTF_TNORM +ida_bytes.STRCONV_ESCAPE +ida_bytes.STRCONV_INCLLEN +ida_bytes.STRCONV_REPLCHAR +ida_bytes.__to_bytevec +ida_bytes.__walk_types_and_formats +ida_bytes.add_byte +ida_bytes.add_dword +ida_bytes.add_hidden_range +ida_bytes.add_mapping +ida_bytes.add_qword +ida_bytes.add_word +ida_bytes.align_flag +ida_bytes.append_cmt +ida_bytes.attach_custom_data_format +ida_bytes.bin_flag +ida_bytes.bin_search +ida_bytes.byte_flag +ida_bytes.bytesize +ida_bytes.calc_def_align +ida_bytes.calc_dflags +ida_bytes.calc_max_align +ida_bytes.calc_max_item_end +ida_bytes.calc_min_align +ida_bytes.can_define_item +ida_bytes.change_storage_type +ida_bytes.char_flag +ida_bytes.chunk_size +ida_bytes.chunk_start +ida_bytes.clr_lzero +ida_bytes.clr_op_type +ida_bytes.code_flag +ida_bytes.combine_flags +ida_bytes.compiled_binpat_t +ida_bytes.compiled_binpat_t.__eq__ +ida_bytes.compiled_binpat_t.__init__ +ida_bytes.compiled_binpat_t.__ne__ +ida_bytes.compiled_binpat_t.all_bytes_defined +ida_bytes.compiled_binpat_t.qclear +ida_bytes.compiled_binpat_vec_t +ida_bytes.compiled_binpat_vec_t.__eq__ +ida_bytes.compiled_binpat_vec_t.__getitem__ +ida_bytes.compiled_binpat_vec_t.__init__ +ida_bytes.compiled_binpat_vec_t.__len__ +ida_bytes.compiled_binpat_vec_t.__ne__ +ida_bytes.compiled_binpat_vec_t.__setitem__ +ida_bytes.compiled_binpat_vec_t._del +ida_bytes.compiled_binpat_vec_t.add_unique +ida_bytes.compiled_binpat_vec_t.append +ida_bytes.compiled_binpat_vec_t.at +ida_bytes.compiled_binpat_vec_t.begin +ida_bytes.compiled_binpat_vec_t.capacity +ida_bytes.compiled_binpat_vec_t.clear +ida_bytes.compiled_binpat_vec_t.empty +ida_bytes.compiled_binpat_vec_t.end +ida_bytes.compiled_binpat_vec_t.erase +ida_bytes.compiled_binpat_vec_t.extend +ida_bytes.compiled_binpat_vec_t.extract +ida_bytes.compiled_binpat_vec_t.find +ida_bytes.compiled_binpat_vec_t.grow +ida_bytes.compiled_binpat_vec_t.has +ida_bytes.compiled_binpat_vec_t.inject +ida_bytes.compiled_binpat_vec_t.insert +ida_bytes.compiled_binpat_vec_t.pop_back +ida_bytes.compiled_binpat_vec_t.push_back +ida_bytes.compiled_binpat_vec_t.qclear +ida_bytes.compiled_binpat_vec_t.reserve +ida_bytes.compiled_binpat_vec_t.resize +ida_bytes.compiled_binpat_vec_t.size +ida_bytes.compiled_binpat_vec_t.swap +ida_bytes.compiled_binpat_vec_t.truncate +ida_bytes.create_16bit_data +ida_bytes.create_32bit_data +ida_bytes.create_align +ida_bytes.create_byte +ida_bytes.create_custdata +ida_bytes.create_data +ida_bytes.create_double +ida_bytes.create_dword +ida_bytes.create_float +ida_bytes.create_oword +ida_bytes.create_packed_real +ida_bytes.create_qword +ida_bytes.create_strlit +ida_bytes.create_struct +ida_bytes.create_tbyte +ida_bytes.create_word +ida_bytes.create_yword +ida_bytes.create_zword +ida_bytes.cust_flag +ida_bytes.custfmt_flag +ida_bytes.data_format_t +ida_bytes.data_format_t.__get_id +ida_bytes.data_format_t.__init__ +ida_bytes.data_format_t.__init__ +ida_bytes.data_format_t.hotkey +ida_bytes.data_format_t.is_present_in_menus +ida_bytes.data_format_t.menu_name +ida_bytes.data_format_t.name +ida_bytes.data_format_t.props +ida_bytes.data_format_t.text_width +ida_bytes.data_format_t.value_size +ida_bytes.data_type_t +ida_bytes.data_type_t.__get_id +ida_bytes.data_type_t.__init__ +ida_bytes.data_type_t.__init__ +ida_bytes.data_type_t.asm_keyword +ida_bytes.data_type_t.hotkey +ida_bytes.data_type_t.is_present_in_menus +ida_bytes.data_type_t.menu_name +ida_bytes.data_type_t.name +ida_bytes.data_type_t.props +ida_bytes.data_type_t.value_size +ida_bytes.dec_flag +ida_bytes.del_hidden_range +ida_bytes.del_items +ida_bytes.del_mapping +ida_bytes.del_value +ida_bytes.detach_custom_data_format +ida_bytes.disable_flags +ida_bytes.double_flag +ida_bytes.dword_flag +ida_bytes.enable_flags +ida_bytes.enum_flag +ida_bytes.equal_bytes +ida_bytes.f_has_cmt +ida_bytes.f_has_dummy_name +ida_bytes.f_has_extra_cmts +ida_bytes.f_has_name +ida_bytes.f_has_user_name +ida_bytes.f_has_xref +ida_bytes.f_is_align +ida_bytes.f_is_byte +ida_bytes.f_is_code +ida_bytes.f_is_custom +ida_bytes.f_is_data +ida_bytes.f_is_double +ida_bytes.f_is_dword +ida_bytes.f_is_float +ida_bytes.f_is_head +ida_bytes.f_is_not_tail +ida_bytes.f_is_oword +ida_bytes.f_is_pack_real +ida_bytes.f_is_qword +ida_bytes.f_is_strlit +ida_bytes.f_is_struct +ida_bytes.f_is_tail +ida_bytes.f_is_tbyte +ida_bytes.f_is_word +ida_bytes.f_is_yword +ida_bytes.find_byte +ida_bytes.find_byter +ida_bytes.find_bytes +ida_bytes.find_custom_data_format +ida_bytes.find_custom_data_type +ida_bytes.find_free_chunk +ida_bytes.find_string +ida_bytes.float_flag +ida_bytes.flt_flag +ida_bytes.get_16bit +ida_bytes.get_32bit +ida_bytes.get_64bit +ida_bytes.get_byte +ida_bytes.get_bytes +ida_bytes.get_bytes_and_mask +ida_bytes.get_cmt +ida_bytes.get_custom_data_format +ida_bytes.get_custom_data_formats +ida_bytes.get_custom_data_type +ida_bytes.get_custom_data_types +ida_bytes.get_data_elsize +ida_bytes.get_data_value +ida_bytes.get_db_byte +ida_bytes.get_default_radix +ida_bytes.get_dword +ida_bytes.get_enum_id +ida_bytes.get_first_hidden_range +ida_bytes.get_flags +ida_bytes.get_flags_by_size +ida_bytes.get_flags_ex +ida_bytes.get_forced_operand +ida_bytes.get_full_data_elsize +ida_bytes.get_full_flags +ida_bytes.get_hidden_range +ida_bytes.get_hidden_range_num +ida_bytes.get_hidden_range_qty +ida_bytes.get_item_end +ida_bytes.get_item_flag +ida_bytes.get_item_head +ida_bytes.get_item_refinfo +ida_bytes.get_item_size +ida_bytes.get_last_hidden_range +ida_bytes.get_manual_insn +ida_bytes.get_mapping +ida_bytes.get_mappings_qty +ida_bytes.get_max_strlit_length +ida_bytes.get_next_hidden_range +ida_bytes.get_octet +ida_bytes.get_operand_flag +ida_bytes.get_operand_type_shift +ida_bytes.get_opinfo +ida_bytes.get_optype_flags0 +ida_bytes.get_optype_flags1 +ida_bytes.get_original_byte +ida_bytes.get_original_dword +ida_bytes.get_original_qword +ida_bytes.get_original_word +ida_bytes.get_possible_item_varsize +ida_bytes.get_predef_insn_cmt +ida_bytes.get_prev_hidden_range +ida_bytes.get_qword +ida_bytes.get_radix +ida_bytes.get_strlit_contents +ida_bytes.get_stroff_path +ida_bytes.get_wide_byte +ida_bytes.get_wide_dword +ida_bytes.get_wide_word +ida_bytes.get_word +ida_bytes.get_zero_ranges +ida_bytes.getn_hidden_range +ida_bytes.has_any_name +ida_bytes.has_auto_name +ida_bytes.has_cmt +ida_bytes.has_dummy_name +ida_bytes.has_extra_cmts +ida_bytes.has_immd +ida_bytes.has_name +ida_bytes.has_user_name +ida_bytes.has_value +ida_bytes.has_xref +ida_bytes.hex_flag +ida_bytes.hidden_range_t +ida_bytes.hidden_range_t.__init__ +ida_bytes.hidden_range_t.color +ida_bytes.hidden_range_t.description +ida_bytes.hidden_range_t.footer +ida_bytes.hidden_range_t.header +ida_bytes.hidden_range_t.visible +ida_bytes.is_align +ida_bytes.is_attached_custom_data_format +ida_bytes.is_bnot +ida_bytes.is_byte +ida_bytes.is_char +ida_bytes.is_char0 +ida_bytes.is_char1 +ida_bytes.is_code +ida_bytes.is_custfmt +ida_bytes.is_custfmt0 +ida_bytes.is_custfmt1 +ida_bytes.is_custom +ida_bytes.is_data +ida_bytes.is_defarg +ida_bytes.is_defarg0 +ida_bytes.is_defarg1 +ida_bytes.is_double +ida_bytes.is_dword +ida_bytes.is_enum +ida_bytes.is_enum0 +ida_bytes.is_enum1 +ida_bytes.is_flag_for_operand +ida_bytes.is_float +ida_bytes.is_float0 +ida_bytes.is_float1 +ida_bytes.is_flow +ida_bytes.is_fltnum +ida_bytes.is_forced_operand +ida_bytes.is_func +ida_bytes.is_head +ida_bytes.is_invsign +ida_bytes.is_loaded +ida_bytes.is_lzero +ida_bytes.is_manual +ida_bytes.is_manual_insn +ida_bytes.is_mapped +ida_bytes.is_not_tail +ida_bytes.is_numop +ida_bytes.is_numop0 +ida_bytes.is_numop1 +ida_bytes.is_off +ida_bytes.is_off0 +ida_bytes.is_off1 +ida_bytes.is_oword +ida_bytes.is_pack_real +ida_bytes.is_qword +ida_bytes.is_same_data_type +ida_bytes.is_seg +ida_bytes.is_seg0 +ida_bytes.is_seg1 +ida_bytes.is_stkvar +ida_bytes.is_stkvar0 +ida_bytes.is_stkvar1 +ida_bytes.is_strlit +ida_bytes.is_stroff +ida_bytes.is_stroff0 +ida_bytes.is_stroff1 +ida_bytes.is_struct +ida_bytes.is_suspop +ida_bytes.is_tail +ida_bytes.is_tbyte +ida_bytes.is_unknown +ida_bytes.is_varsize_item +ida_bytes.is_word +ida_bytes.is_yword +ida_bytes.is_zword +ida_bytes.leading_zero_important +ida_bytes.nbits +ida_bytes.next_addr +ida_bytes.next_chunk +ida_bytes.next_head +ida_bytes.next_inited +ida_bytes.next_not_tail +ida_bytes.next_that +ida_bytes.next_unknown +ida_bytes.next_visea +ida_bytes.num_flag +ida_bytes.oct_flag +ida_bytes.octet_generator_t +ida_bytes.octet_generator_t.__init__ +ida_bytes.octet_generator_t.invert_byte_order +ida_bytes.off_flag +ida_bytes.op_adds_xrefs +ida_bytes.op_based_stroff +ida_bytes.op_bin +ida_bytes.op_chr +ida_bytes.op_custfmt +ida_bytes.op_dec +ida_bytes.op_enum +ida_bytes.op_flt +ida_bytes.op_hex +ida_bytes.op_num +ida_bytes.op_oct +ida_bytes.op_seg +ida_bytes.op_stkvar +ida_bytes.op_stroff +ida_bytes.oword_flag +ida_bytes.packreal_flag +ida_bytes.parse_binpat_str +ida_bytes.patch_byte +ida_bytes.patch_bytes +ida_bytes.patch_dword +ida_bytes.patch_qword +ida_bytes.patch_word +ida_bytes.prev_addr +ida_bytes.prev_chunk +ida_bytes.prev_head +ida_bytes.prev_inited +ida_bytes.prev_not_tail +ida_bytes.prev_that +ida_bytes.prev_unknown +ida_bytes.prev_visea +ida_bytes.print_strlit_type +ida_bytes.put_byte +ida_bytes.put_bytes +ida_bytes.put_dword +ida_bytes.put_qword +ida_bytes.put_word +ida_bytes.qword_flag +ida_bytes.register_custom_data_format +ida_bytes.register_custom_data_type +ida_bytes.register_data_types_and_formats +ida_bytes.register_data_types_and_formats.__reg_format +ida_bytes.register_data_types_and_formats.__reg_type +ida_bytes.revert_byte +ida_bytes.seg_flag +ida_bytes.set_cmt +ida_bytes.set_forced_operand +ida_bytes.set_immd +ida_bytes.set_lzero +ida_bytes.set_manual_insn +ida_bytes.set_op_type +ida_bytes.set_opinfo +ida_bytes.stkvar_flag +ida_bytes.strlit_flag +ida_bytes.stroff_flag +ida_bytes.stru_flag +ida_bytes.tbyte_flag +ida_bytes.toggle_bnot +ida_bytes.toggle_lzero +ida_bytes.toggle_sign +ida_bytes.unregister_custom_data_format +ida_bytes.unregister_custom_data_type +ida_bytes.unregister_data_types_and_formats +ida_bytes.unregister_data_types_and_formats.__unreg_format +ida_bytes.unregister_data_types_and_formats.__unreg_type +ida_bytes.update_hidden_range +ida_bytes.use_mapping +ida_bytes.visit_patched_bytes +ida_bytes.word_flag +ida_bytes.yword_flag +ida_bytes.zword_flag +ida_dbg +ida_dbg.BKPT_ACTIVE +ida_dbg.BKPT_BADBPT +ida_dbg.BKPT_CNDREADY +ida_dbg.BKPT_FAKEPEND +ida_dbg.BKPT_LISTBPT +ida_dbg.BKPT_PAGE +ida_dbg.BKPT_PARTIAL +ida_dbg.BKPT_TRACE +ida_dbg.BPLT_ABS +ida_dbg.BPLT_REL +ida_dbg.BPLT_SRC +ida_dbg.BPLT_SYM +ida_dbg.BPTCK_ACT +ida_dbg.BPTCK_NO +ida_dbg.BPTCK_NONE +ida_dbg.BPTCK_YES +ida_dbg.BPTEV_ADDED +ida_dbg.BPTEV_CHANGED +ida_dbg.BPTEV_REMOVED +ida_dbg.BPT_BRK +ida_dbg.BPT_ELANG_SHIFT +ida_dbg.BPT_ENABLED +ida_dbg.BPT_LOWCND +ida_dbg.BPT_TRACE +ida_dbg.BPT_TRACEON +ida_dbg.BPT_TRACE_BBLK +ida_dbg.BPT_TRACE_FUNC +ida_dbg.BPT_TRACE_INSN +ida_dbg.BPT_TRACE_TYPES +ida_dbg.BPT_UPDMEM +ida_dbg.BT_LOG_INSTS +ida_dbg.DBGINV_ALL +ida_dbg.DBGINV_MEMCFG +ida_dbg.DBGINV_MEMORY +ida_dbg.DBGINV_NONE +ida_dbg.DBGINV_REDRAW +ida_dbg.DBGINV_REGS +ida_dbg.DBG_Hooks +ida_dbg.DBG_Hooks.__disown__ +ida_dbg.DBG_Hooks.__init__ +ida_dbg.DBG_Hooks.dbg_bpt +ida_dbg.DBG_Hooks.dbg_bpt_changed +ida_dbg.DBG_Hooks.dbg_exception +ida_dbg.DBG_Hooks.dbg_finished_loading_bpts +ida_dbg.DBG_Hooks.dbg_information +ida_dbg.DBG_Hooks.dbg_library_load +ida_dbg.DBG_Hooks.dbg_library_unload +ida_dbg.DBG_Hooks.dbg_process_attach +ida_dbg.DBG_Hooks.dbg_process_detach +ida_dbg.DBG_Hooks.dbg_process_exit +ida_dbg.DBG_Hooks.dbg_process_start +ida_dbg.DBG_Hooks.dbg_request_error +ida_dbg.DBG_Hooks.dbg_run_to +ida_dbg.DBG_Hooks.dbg_started_loading_bpts +ida_dbg.DBG_Hooks.dbg_step_into +ida_dbg.DBG_Hooks.dbg_step_over +ida_dbg.DBG_Hooks.dbg_step_until_ret +ida_dbg.DBG_Hooks.dbg_suspend_process +ida_dbg.DBG_Hooks.dbg_thread_exit +ida_dbg.DBG_Hooks.dbg_thread_start +ida_dbg.DBG_Hooks.dbg_trace +ida_dbg.DBG_Hooks.hook +ida_dbg.DBG_Hooks.unhook +ida_dbg.DEC_ERROR +ida_dbg.DEC_NOTASK +ida_dbg.DEC_TIMEOUT +ida_dbg.DOPT_BPT_MSGS +ida_dbg.DOPT_DISABLE_ASLR +ida_dbg.DOPT_END_BPT +ida_dbg.DOPT_ENTRY_BPT +ida_dbg.DOPT_EXCDLG +ida_dbg.DOPT_FAST_STEP +ida_dbg.DOPT_INFO_BPT +ida_dbg.DOPT_INFO_MSGS +ida_dbg.DOPT_LIB_BPT +ida_dbg.DOPT_LIB_MSGS +ida_dbg.DOPT_LOAD_DINFO +ida_dbg.DOPT_REAL_MEMORY +ida_dbg.DOPT_REDO_STACK +ida_dbg.DOPT_SEGM_MSGS +ida_dbg.DOPT_START_BPT +ida_dbg.DOPT_TEMP_HWBPT +ida_dbg.DOPT_THREAD_BPT +ida_dbg.DOPT_THREAD_MSGS +ida_dbg.DSTATE_NOTASK +ida_dbg.DSTATE_RUN +ida_dbg.DSTATE_SUSP +ida_dbg.EXCDLG_ALWAYS +ida_dbg.EXCDLG_NEVER +ida_dbg.EXCDLG_UNKNOWN +ida_dbg.FT_LOG_RET +ida_dbg.IT_LOG_SAME_IP +ida_dbg.MOVBPT_BAD_TYPE +ida_dbg.MOVBPT_DEST_BUSY +ida_dbg.MOVBPT_NOT_FOUND +ida_dbg.MOVBPT_OK +ida_dbg.SRCIT_EXPR +ida_dbg.SRCIT_FUNC +ida_dbg.SRCIT_LOCVAR +ida_dbg.SRCIT_MODULE +ida_dbg.SRCIT_NONE +ida_dbg.SRCIT_STMT +ida_dbg.SRCIT_STTVAR +ida_dbg.ST_ALREADY_LOGGED +ida_dbg.ST_DIFFERENTIAL +ida_dbg.ST_OPTIONS_MASK +ida_dbg.ST_OVER_DEBUG_SEG +ida_dbg.ST_OVER_LIB_FUNC +ida_dbg.ST_SKIP_LOOPS +ida_dbg.WFNE_ANY +ida_dbg.WFNE_CONT +ida_dbg.WFNE_NOWAIT +ida_dbg.WFNE_SILENT +ida_dbg.WFNE_SUSP +ida_dbg.WFNE_USEC +ida_dbg.add_bpt +ida_dbg.add_path_mapping +ida_dbg.add_virt_module +ida_dbg.attach_process +ida_dbg.bpt_location_t +ida_dbg.bpt_location_t.__eq__ +ida_dbg.bpt_location_t.__ge__ +ida_dbg.bpt_location_t.__gt__ +ida_dbg.bpt_location_t.__init__ +ida_dbg.bpt_location_t.__le__ +ida_dbg.bpt_location_t.__lt__ +ida_dbg.bpt_location_t.__ne__ +ida_dbg.bpt_location_t.compare +ida_dbg.bpt_location_t.ea +ida_dbg.bpt_location_t.is_empty_path +ida_dbg.bpt_location_t.lineno +ida_dbg.bpt_location_t.offset +ida_dbg.bpt_location_t.path +ida_dbg.bpt_location_t.set_abs_bpt +ida_dbg.bpt_location_t.set_rel_bpt +ida_dbg.bpt_location_t.set_src_bpt +ida_dbg.bpt_location_t.set_sym_bpt +ida_dbg.bpt_location_t.symbol +ida_dbg.bpt_location_t.type +ida_dbg.bpt_t +ida_dbg.bpt_t.__init__ +ida_dbg.bpt_t.badbpt +ida_dbg.bpt_t.bptid +ida_dbg.bpt_t.cb +ida_dbg.bpt_t.cndidx +ida_dbg.bpt_t.ea +ida_dbg.bpt_t.enabled +ida_dbg.bpt_t.flags +ida_dbg.bpt_t.get_cnd_elang_idx +ida_dbg.bpt_t.get_size +ida_dbg.bpt_t.is_absbpt +ida_dbg.bpt_t.is_active +ida_dbg.bpt_t.is_compiled +ida_dbg.bpt_t.is_hwbpt +ida_dbg.bpt_t.is_inactive +ida_dbg.bpt_t.is_low_level +ida_dbg.bpt_t.is_page_bpt +ida_dbg.bpt_t.is_partially_active +ida_dbg.bpt_t.is_relbpt +ida_dbg.bpt_t.is_srcbpt +ida_dbg.bpt_t.is_symbpt +ida_dbg.bpt_t.is_tracemodebpt +ida_dbg.bpt_t.is_traceoffbpt +ida_dbg.bpt_t.is_traceonbpt +ida_dbg.bpt_t.listbpt +ida_dbg.bpt_t.loc +ida_dbg.bpt_t.pass_count +ida_dbg.bpt_t.pid +ida_dbg.bpt_t.props +ida_dbg.bpt_t.set_abs_bpt +ida_dbg.bpt_t.set_rel_bpt +ida_dbg.bpt_t.set_src_bpt +ida_dbg.bpt_t.set_sym_bpt +ida_dbg.bpt_t.set_trace_action +ida_dbg.bpt_t.size +ida_dbg.bpt_t.tid +ida_dbg.bpt_t.type +ida_dbg.bpt_vec_t +ida_dbg.bpt_vec_t.__getitem__ +ida_dbg.bpt_vec_t.__init__ +ida_dbg.bpt_vec_t.__len__ +ida_dbg.bpt_vec_t.__setitem__ +ida_dbg.bpt_vec_t.append +ida_dbg.bpt_vec_t.at +ida_dbg.bpt_vec_t.begin +ida_dbg.bpt_vec_t.capacity +ida_dbg.bpt_vec_t.clear +ida_dbg.bpt_vec_t.empty +ida_dbg.bpt_vec_t.end +ida_dbg.bpt_vec_t.erase +ida_dbg.bpt_vec_t.extend +ida_dbg.bpt_vec_t.extract +ida_dbg.bpt_vec_t.grow +ida_dbg.bpt_vec_t.inject +ida_dbg.bpt_vec_t.insert +ida_dbg.bpt_vec_t.pop_back +ida_dbg.bpt_vec_t.push_back +ida_dbg.bpt_vec_t.qclear +ida_dbg.bpt_vec_t.reserve +ida_dbg.bpt_vec_t.resize +ida_dbg.bpt_vec_t.size +ida_dbg.bpt_vec_t.swap +ida_dbg.bpt_vec_t.truncate +ida_dbg.bptaddrs_t +ida_dbg.bptaddrs_t.__init__ +ida_dbg.bring_debugger_to_front +ida_dbg.check_bpt +ida_dbg.choose_trace_file +ida_dbg.clear_requests_queue +ida_dbg.clear_trace +ida_dbg.collect_stack_trace +ida_dbg.continue_backwards +ida_dbg.continue_process +ida_dbg.create_source_viewer +ida_dbg.dbg_add_bpt_tev +ida_dbg.dbg_add_call_tev +ida_dbg.dbg_add_debug_event +ida_dbg.dbg_add_insn_tev +ida_dbg.dbg_add_many_tevs +ida_dbg.dbg_add_ret_tev +ida_dbg.dbg_add_tev +ida_dbg.dbg_add_thread +ida_dbg.dbg_bin_search +ida_dbg.dbg_bpt +ida_dbg.dbg_bpt_changed +ida_dbg.dbg_can_query +ida_dbg.dbg_del_thread +ida_dbg.dbg_finished_loading_bpts +ida_dbg.dbg_is_loaded +ida_dbg.dbg_last +ida_dbg.dbg_request_error +ida_dbg.dbg_started_loading_bpts +ida_dbg.dbg_suspend_process +ida_dbg.dbg_trace +ida_dbg.define_exception +ida_dbg.del_bpt +ida_dbg.del_bptgrp +ida_dbg.del_virt_module +ida_dbg.detach_process +ida_dbg.diff_trace_file +ida_dbg.disable_bblk_trace +ida_dbg.disable_bpt +ida_dbg.disable_func_trace +ida_dbg.disable_insn_trace +ida_dbg.disable_step_trace +ida_dbg.edit_manual_regions +ida_dbg.enable_bblk_trace +ida_dbg.enable_bpt +ida_dbg.enable_bptgrp +ida_dbg.enable_func_trace +ida_dbg.enable_insn_trace +ida_dbg.enable_manual_regions +ida_dbg.enable_step_trace +ida_dbg.eval_ctx_t +ida_dbg.eval_ctx_t.__init__ +ida_dbg.exist_bpt +ida_dbg.exit_process +ida_dbg.find_bpt +ida_dbg.get_bblk_trace_options +ida_dbg.get_bpt +ida_dbg.get_bpt_group +ida_dbg.get_bpt_qty +ida_dbg.get_bpt_tev_ea +ida_dbg.get_bptloc_string +ida_dbg.get_call_tev_callee +ida_dbg.get_current_source_file +ida_dbg.get_current_source_line +ida_dbg.get_current_thread +ida_dbg.get_dbg_byte +ida_dbg.get_dbg_memory_info +ida_dbg.get_dbg_reg_info +ida_dbg.get_debug_event +ida_dbg.get_debugger_event_cond +ida_dbg.get_first_module +ida_dbg.get_func_trace_options +ida_dbg.get_global_var +ida_dbg.get_grp_bpts +ida_dbg.get_insn_tev_reg_mem +ida_dbg.get_insn_tev_reg_result +ida_dbg.get_insn_tev_reg_val +ida_dbg.get_insn_trace_options +ida_dbg.get_ip_val +ida_dbg.get_local_var +ida_dbg.get_local_vars +ida_dbg.get_manual_regions +ida_dbg.get_module_info +ida_dbg.get_next_module +ida_dbg.get_process_options +ida_dbg.get_process_options2 +ida_dbg.get_process_state +ida_dbg.get_processes +ida_dbg.get_reg_val +ida_dbg.get_reg_vals +ida_dbg.get_ret_tev_return +ida_dbg.get_running_notification +ida_dbg.get_running_request +ida_dbg.get_sp_val +ida_dbg.get_srcinfo_provider +ida_dbg.get_step_trace_options +ida_dbg.get_tev_ea +ida_dbg.get_tev_event +ida_dbg.get_tev_info +ida_dbg.get_tev_memory_info +ida_dbg.get_tev_qty +ida_dbg.get_tev_reg_mem +ida_dbg.get_tev_reg_mem_ea +ida_dbg.get_tev_reg_mem_qty +ida_dbg.get_tev_reg_val +ida_dbg.get_tev_tid +ida_dbg.get_tev_type +ida_dbg.get_thread_qty +ida_dbg.get_trace_base_address +ida_dbg.get_trace_dynamic_register_set +ida_dbg.get_trace_file_desc +ida_dbg.get_trace_platform +ida_dbg.getn_bpt +ida_dbg.getn_thread +ida_dbg.getn_thread_name +ida_dbg.graph_trace +ida_dbg.handle_debug_event +ida_dbg.hide_all_bpts +ida_dbg.internal_get_sreg_base +ida_dbg.internal_ioctl +ida_dbg.invalidate_dbg_state +ida_dbg.invalidate_dbgmem_config +ida_dbg.invalidate_dbgmem_contents +ida_dbg.is_bblk_trace_enabled +ida_dbg.is_debugger_busy +ida_dbg.is_debugger_memory +ida_dbg.is_debugger_on +ida_dbg.is_func_trace_enabled +ida_dbg.is_insn_trace_enabled +ida_dbg.is_reg_custom +ida_dbg.is_reg_float +ida_dbg.is_reg_integer +ida_dbg.is_request_running +ida_dbg.is_step_trace_enabled +ida_dbg.is_valid_dstate +ida_dbg.is_valid_trace_file +ida_dbg.list_bptgrps +ida_dbg.load_debugger +ida_dbg.load_trace_file +ida_dbg.memreg_info_t +ida_dbg.memreg_info_t.__init__ +ida_dbg.memreg_info_t.get_bytes +ida_dbg.memreg_infos_t +ida_dbg.memreg_infos_t.__getitem__ +ida_dbg.memreg_infos_t.__init__ +ida_dbg.memreg_infos_t.__len__ +ida_dbg.memreg_infos_t.__setitem__ +ida_dbg.memreg_infos_t.append +ida_dbg.memreg_infos_t.at +ida_dbg.memreg_infos_t.begin +ida_dbg.memreg_infos_t.capacity +ida_dbg.memreg_infos_t.clear +ida_dbg.memreg_infos_t.empty +ida_dbg.memreg_infos_t.end +ida_dbg.memreg_infos_t.erase +ida_dbg.memreg_infos_t.extend +ida_dbg.memreg_infos_t.extract +ida_dbg.memreg_infos_t.grow +ida_dbg.memreg_infos_t.inject +ida_dbg.memreg_infos_t.insert +ida_dbg.memreg_infos_t.pop_back +ida_dbg.memreg_infos_t.push_back +ida_dbg.memreg_infos_t.qclear +ida_dbg.memreg_infos_t.reserve +ida_dbg.memreg_infos_t.resize +ida_dbg.memreg_infos_t.size +ida_dbg.memreg_infos_t.swap +ida_dbg.memreg_infos_t.truncate +ida_dbg.put_dbg_byte +ida_dbg.read_dbg_memory +ida_dbg.refresh_debugger_memory +ida_dbg.rename_bptgrp +ida_dbg.request_add_bpt +ida_dbg.request_attach_process +ida_dbg.request_clear_trace +ida_dbg.request_continue_backwards +ida_dbg.request_continue_process +ida_dbg.request_del_bpt +ida_dbg.request_detach_process +ida_dbg.request_disable_bblk_trace +ida_dbg.request_disable_bpt +ida_dbg.request_disable_func_trace +ida_dbg.request_disable_insn_trace +ida_dbg.request_disable_step_trace +ida_dbg.request_enable_bblk_trace +ida_dbg.request_enable_bpt +ida_dbg.request_enable_func_trace +ida_dbg.request_enable_insn_trace +ida_dbg.request_enable_step_trace +ida_dbg.request_exit_process +ida_dbg.request_resume_thread +ida_dbg.request_run_to +ida_dbg.request_run_to_backwards +ida_dbg.request_select_thread +ida_dbg.request_set_bblk_trace_options +ida_dbg.request_set_func_trace_options +ida_dbg.request_set_insn_trace_options +ida_dbg.request_set_reg_val +ida_dbg.request_set_resume_mode +ida_dbg.request_set_step_trace_options +ida_dbg.request_start_process +ida_dbg.request_step_into +ida_dbg.request_step_into_backwards +ida_dbg.request_step_over +ida_dbg.request_step_over_backwards +ida_dbg.request_step_until_ret +ida_dbg.request_suspend_process +ida_dbg.request_suspend_thread +ida_dbg.resume_thread +ida_dbg.retrieve_exceptions +ida_dbg.run_requests +ida_dbg.run_to +ida_dbg.run_to_backwards +ida_dbg.save_trace_file +ida_dbg.select_thread +ida_dbg.send_dbg_command +ida_dbg.set_bblk_trace_options +ida_dbg.set_bpt_group +ida_dbg.set_bptloc_group +ida_dbg.set_bptloc_string +ida_dbg.set_debugger_event_cond +ida_dbg.set_debugger_options +ida_dbg.set_func_trace_options +ida_dbg.set_highlight_trace_options +ida_dbg.set_insn_trace_options +ida_dbg.set_manual_regions +ida_dbg.set_process_options +ida_dbg.set_process_state +ida_dbg.set_reg_val +ida_dbg.set_remote_debugger +ida_dbg.set_resume_mode +ida_dbg.set_step_trace_options +ida_dbg.set_trace_base_address +ida_dbg.set_trace_dynamic_register_set +ida_dbg.set_trace_file_desc +ida_dbg.set_trace_platform +ida_dbg.set_trace_size +ida_dbg.srcdbg_request_step_into +ida_dbg.srcdbg_request_step_over +ida_dbg.srcdbg_request_step_until_ret +ida_dbg.srcdbg_step_into +ida_dbg.srcdbg_step_over +ida_dbg.srcdbg_step_until_ret +ida_dbg.start_process +ida_dbg.step_into +ida_dbg.step_into_backwards +ida_dbg.step_over +ida_dbg.step_over_backwards +ida_dbg.step_until_ret +ida_dbg.store_exceptions +ida_dbg.suspend_process +ida_dbg.suspend_thread +ida_dbg.tev_bpt +ida_dbg.tev_call +ida_dbg.tev_event +ida_dbg.tev_info_reg_t +ida_dbg.tev_info_reg_t.__init__ +ida_dbg.tev_info_t +ida_dbg.tev_info_t.__init__ +ida_dbg.tev_info_t.ea +ida_dbg.tev_info_t.tid +ida_dbg.tev_info_t.type +ida_dbg.tev_insn +ida_dbg.tev_max +ida_dbg.tev_mem +ida_dbg.tev_none +ida_dbg.tev_reg_value_t +ida_dbg.tev_reg_value_t.__init__ +ida_dbg.tev_reg_values_t +ida_dbg.tev_reg_values_t.__getitem__ +ida_dbg.tev_reg_values_t.__init__ +ida_dbg.tev_reg_values_t.__len__ +ida_dbg.tev_reg_values_t.__setitem__ +ida_dbg.tev_reg_values_t.append +ida_dbg.tev_reg_values_t.at +ida_dbg.tev_reg_values_t.begin +ida_dbg.tev_reg_values_t.capacity +ida_dbg.tev_reg_values_t.clear +ida_dbg.tev_reg_values_t.empty +ida_dbg.tev_reg_values_t.end +ida_dbg.tev_reg_values_t.erase +ida_dbg.tev_reg_values_t.extend +ida_dbg.tev_reg_values_t.extract +ida_dbg.tev_reg_values_t.grow +ida_dbg.tev_reg_values_t.inject +ida_dbg.tev_reg_values_t.insert +ida_dbg.tev_reg_values_t.pop_back +ida_dbg.tev_reg_values_t.push_back +ida_dbg.tev_reg_values_t.qclear +ida_dbg.tev_reg_values_t.reserve +ida_dbg.tev_reg_values_t.resize +ida_dbg.tev_reg_values_t.size +ida_dbg.tev_reg_values_t.swap +ida_dbg.tev_reg_values_t.truncate +ida_dbg.tev_ret +ida_dbg.tevinforeg_vec_t +ida_dbg.tevinforeg_vec_t.__getitem__ +ida_dbg.tevinforeg_vec_t.__init__ +ida_dbg.tevinforeg_vec_t.__len__ +ida_dbg.tevinforeg_vec_t.__setitem__ +ida_dbg.tevinforeg_vec_t.append +ida_dbg.tevinforeg_vec_t.at +ida_dbg.tevinforeg_vec_t.begin +ida_dbg.tevinforeg_vec_t.capacity +ida_dbg.tevinforeg_vec_t.clear +ida_dbg.tevinforeg_vec_t.empty +ida_dbg.tevinforeg_vec_t.end +ida_dbg.tevinforeg_vec_t.erase +ida_dbg.tevinforeg_vec_t.extend +ida_dbg.tevinforeg_vec_t.extract +ida_dbg.tevinforeg_vec_t.grow +ida_dbg.tevinforeg_vec_t.inject +ida_dbg.tevinforeg_vec_t.insert +ida_dbg.tevinforeg_vec_t.pop_back +ida_dbg.tevinforeg_vec_t.push_back +ida_dbg.tevinforeg_vec_t.qclear +ida_dbg.tevinforeg_vec_t.reserve +ida_dbg.tevinforeg_vec_t.resize +ida_dbg.tevinforeg_vec_t.size +ida_dbg.tevinforeg_vec_t.swap +ida_dbg.tevinforeg_vec_t.truncate +ida_dbg.update_bpt +ida_dbg.wait_for_next_event +ida_dbg.write_dbg_memory +ida_diskio +ida_diskio.IDA_SUBDIR_IDADIR_FIRST +ida_diskio.IDA_SUBDIR_IDP +ida_diskio.IDA_SUBDIR_ONLY_EXISTING +ida_diskio.LOC_CLOSE +ida_diskio.LOC_KEEP +ida_diskio.LOC_UNMAKE +ida_diskio.VAULT_CACHE_FNAME +ida_diskio.VAULT_CACHE_SUBDIR +ida_diskio.choose_ioport_device2 +ida_diskio.choose_ioport_parser_t +ida_diskio.choose_ioport_parser_t.__disown__ +ida_diskio.choose_ioport_parser_t.__init__ +ida_diskio.choose_ioport_parser_t.parse +ida_diskio.close_linput +ida_diskio.create_bytearray_linput +ida_diskio.create_generic_linput +ida_diskio.create_memory_linput +ida_diskio.enumerate_files +ida_diskio.file_enumerator_t +ida_diskio.file_enumerator_t.__disown__ +ida_diskio.file_enumerator_t.__init__ +ida_diskio.file_enumerator_t.visit_file +ida_diskio.fopenA +ida_diskio.fopenM +ida_diskio.fopenRB +ida_diskio.fopenRT +ida_diskio.fopenWB +ida_diskio.fopenWT +ida_diskio.generic_linput_t +ida_diskio.generic_linput_t.__init__ +ida_diskio.generic_linput_t.read +ida_diskio.get_ida_subdirs +ida_diskio.get_linput_type +ida_diskio.get_special_folder +ida_diskio.get_user_idadir +ida_diskio.getsysfile +ida_diskio.idadir +ida_diskio.ioports_fallback_t +ida_diskio.ioports_fallback_t.__disown__ +ida_diskio.ioports_fallback_t.__init__ +ida_diskio.ioports_fallback_t.handle +ida_diskio.open_linput +ida_diskio.qlgetz +ida_diskio.read_ioports +ida_dirtree +ida_dirtree.DTE_ALREADY_EXISTS +ida_dirtree.DTE_BAD_PATH +ida_dirtree.DTE_CANT_RENAME +ida_dirtree.DTE_MAX_DIR +ida_dirtree.DTE_NOT_DIRECTORY +ida_dirtree.DTE_NOT_EMPTY +ida_dirtree.DTE_NOT_FOUND +ida_dirtree.DTE_OK +ida_dirtree.DTE_OWN_CHILD +ida_dirtree.DTN_DISPLAY_NAME +ida_dirtree.DTN_FULL_NAME +ida_dirtree.direntry_t +ida_dirtree.direntry_t.__eq__ +ida_dirtree.direntry_t.__init__ +ida_dirtree.direntry_t.__lt__ +ida_dirtree.direntry_t.__ne__ +ida_dirtree.direntry_t.idx +ida_dirtree.direntry_t.isdir +ida_dirtree.direntry_t.valid +ida_dirtree.direntry_vec_t +ida_dirtree.direntry_vec_t.__eq__ +ida_dirtree.direntry_vec_t.__getitem__ +ida_dirtree.direntry_vec_t.__init__ +ida_dirtree.direntry_vec_t.__len__ +ida_dirtree.direntry_vec_t.__ne__ +ida_dirtree.direntry_vec_t.__setitem__ +ida_dirtree.direntry_vec_t._del +ida_dirtree.direntry_vec_t.add_unique +ida_dirtree.direntry_vec_t.append +ida_dirtree.direntry_vec_t.at +ida_dirtree.direntry_vec_t.begin +ida_dirtree.direntry_vec_t.capacity +ida_dirtree.direntry_vec_t.clear +ida_dirtree.direntry_vec_t.empty +ida_dirtree.direntry_vec_t.end +ida_dirtree.direntry_vec_t.erase +ida_dirtree.direntry_vec_t.extend +ida_dirtree.direntry_vec_t.extract +ida_dirtree.direntry_vec_t.find +ida_dirtree.direntry_vec_t.grow +ida_dirtree.direntry_vec_t.has +ida_dirtree.direntry_vec_t.inject +ida_dirtree.direntry_vec_t.insert +ida_dirtree.direntry_vec_t.pop_back +ida_dirtree.direntry_vec_t.push_back +ida_dirtree.direntry_vec_t.qclear +ida_dirtree.direntry_vec_t.reserve +ida_dirtree.direntry_vec_t.resize +ida_dirtree.direntry_vec_t.size +ida_dirtree.direntry_vec_t.swap +ida_dirtree.direntry_vec_t.truncate +ida_dirtree.dirspec_t +ida_dirtree.dirspec_t.__disown__ +ida_dirtree.dirspec_t.__init__ +ida_dirtree.dirspec_t.get_attrs +ida_dirtree.dirspec_t.get_inode +ida_dirtree.dirspec_t.get_name +ida_dirtree.dirspec_t.is_orderable +ida_dirtree.dirspec_t.rename_inode +ida_dirtree.dirspec_t.unlink_inode +ida_dirtree.dirtree_cursor_t +ida_dirtree.dirtree_cursor_t.__eq__ +ida_dirtree.dirtree_cursor_t.__ge__ +ida_dirtree.dirtree_cursor_t.__gt__ +ida_dirtree.dirtree_cursor_t.__init__ +ida_dirtree.dirtree_cursor_t.__le__ +ida_dirtree.dirtree_cursor_t.__lt__ +ida_dirtree.dirtree_cursor_t.__ne__ +ida_dirtree.dirtree_cursor_t.compare +ida_dirtree.dirtree_cursor_t.is_root_cursor +ida_dirtree.dirtree_cursor_t.parent +ida_dirtree.dirtree_cursor_t.rank +ida_dirtree.dirtree_cursor_t.root_cursor +ida_dirtree.dirtree_cursor_t.set_root_cursor +ida_dirtree.dirtree_cursor_t.valid +ida_dirtree.dirtree_cursor_vec_t +ida_dirtree.dirtree_cursor_vec_t.__eq__ +ida_dirtree.dirtree_cursor_vec_t.__getitem__ +ida_dirtree.dirtree_cursor_vec_t.__init__ +ida_dirtree.dirtree_cursor_vec_t.__len__ +ida_dirtree.dirtree_cursor_vec_t.__ne__ +ida_dirtree.dirtree_cursor_vec_t.__setitem__ +ida_dirtree.dirtree_cursor_vec_t._del +ida_dirtree.dirtree_cursor_vec_t.add_unique +ida_dirtree.dirtree_cursor_vec_t.append +ida_dirtree.dirtree_cursor_vec_t.at +ida_dirtree.dirtree_cursor_vec_t.begin +ida_dirtree.dirtree_cursor_vec_t.capacity +ida_dirtree.dirtree_cursor_vec_t.clear +ida_dirtree.dirtree_cursor_vec_t.empty +ida_dirtree.dirtree_cursor_vec_t.end +ida_dirtree.dirtree_cursor_vec_t.erase +ida_dirtree.dirtree_cursor_vec_t.extend +ida_dirtree.dirtree_cursor_vec_t.extract +ida_dirtree.dirtree_cursor_vec_t.find +ida_dirtree.dirtree_cursor_vec_t.grow +ida_dirtree.dirtree_cursor_vec_t.has +ida_dirtree.dirtree_cursor_vec_t.inject +ida_dirtree.dirtree_cursor_vec_t.insert +ida_dirtree.dirtree_cursor_vec_t.pop_back +ida_dirtree.dirtree_cursor_vec_t.push_back +ida_dirtree.dirtree_cursor_vec_t.qclear +ida_dirtree.dirtree_cursor_vec_t.reserve +ida_dirtree.dirtree_cursor_vec_t.resize +ida_dirtree.dirtree_cursor_vec_t.size +ida_dirtree.dirtree_cursor_vec_t.swap +ida_dirtree.dirtree_cursor_vec_t.truncate +ida_dirtree.dirtree_iterator_t +ida_dirtree.dirtree_iterator_t.__init__ +ida_dirtree.dirtree_selection_t +ida_dirtree.dirtree_selection_t.__init__ +ida_dirtree.dirtree_t +ida_dirtree.dirtree_t.__init__ +ida_dirtree.dirtree_t.change_rank +ida_dirtree.dirtree_t.chdir +ida_dirtree.dirtree_t.errstr +ida_dirtree.dirtree_t.find_entry +ida_dirtree.dirtree_t.findfirst +ida_dirtree.dirtree_t.findnext +ida_dirtree.dirtree_t.get_abspath +ida_dirtree.dirtree_t.get_dir_size +ida_dirtree.dirtree_t.get_entry_attrs +ida_dirtree.dirtree_t.get_entry_name +ida_dirtree.dirtree_t.get_id +ida_dirtree.dirtree_t.get_parent_cursor +ida_dirtree.dirtree_t.get_rank +ida_dirtree.dirtree_t.getcwd +ida_dirtree.dirtree_t.is_dir_ordered +ida_dirtree.dirtree_t.is_orderable +ida_dirtree.dirtree_t.isdir +ida_dirtree.dirtree_t.isfile +ida_dirtree.dirtree_t.link +ida_dirtree.dirtree_t.load +ida_dirtree.dirtree_t.mkdir +ida_dirtree.dirtree_t.notify_dirtree +ida_dirtree.dirtree_t.rename +ida_dirtree.dirtree_t.resolve_cursor +ida_dirtree.dirtree_t.resolve_path +ida_dirtree.dirtree_t.rmdir +ida_dirtree.dirtree_t.save +ida_dirtree.dirtree_t.set_id +ida_dirtree.dirtree_t.set_natural_order +ida_dirtree.dirtree_t.traverse +ida_dirtree.dirtree_t.unlink +ida_dirtree.dirtree_visitor_t +ida_dirtree.dirtree_visitor_t.__disown__ +ida_dirtree.dirtree_visitor_t.__init__ +ida_dirtree.dirtree_visitor_t.visit +ida_dirtree.get_std_dirtree +ida_entry +ida_entry.AEF_IDBENC +ida_entry.AEF_NODUMMY +ida_entry.AEF_UTF8 +ida_entry.add_entry +ida_entry.get_entry +ida_entry.get_entry_forwarder +ida_entry.get_entry_name +ida_entry.get_entry_ordinal +ida_entry.get_entry_qty +ida_entry.rename_entry +ida_entry.set_entry_forwarder +ida_expr +ida_expr.CPL_DEL_MACROS +ida_expr.CPL_ONLY_SAFE +ida_expr.CPL_USE_LABELS +ida_expr.EXTFUN_BASE +ida_expr.EXTFUN_NORET +ida_expr.EXTFUN_SAFE +ida_expr.IDC_LANG_EXT +ida_expr.VARSLICE_SINGLE +ida_expr.VREF_COPY +ida_expr.VREF_LOOP +ida_expr.VREF_ONCE +ida_expr.VT_FLOAT +ida_expr.VT_FUNC +ida_expr.VT_INT64 +ida_expr.VT_LONG +ida_expr.VT_OBJ +ida_expr.VT_PVOID +ida_expr.VT_REF +ida_expr.VT_STR +ida_expr.VT_WILD +ida_expr._IdcFunction +ida_expr._IdcFunction.__call__ +ida_expr._IdcFunction.__init__ +ida_expr.add_idc_class +ida_expr.add_idc_func +ida_expr.add_idc_gvar +ida_expr.call_idc_func__ +ida_expr.compile_idc_file +ida_expr.compile_idc_snippet +ida_expr.compile_idc_text +ida_expr.copy_idcv +ida_expr.create_idcv_ref +ida_expr.deep_copy_idcv +ida_expr.del_idc_func +ida_expr.del_idcv_attr +ida_expr.deref_idcv +ida_expr.eExecThrow +ida_expr.eval_expr +ida_expr.eval_idc_expr +ida_expr.exec_idc_script +ida_expr.exec_system_script +ida_expr.find_idc_class +ida_expr.find_idc_func +ida_expr.find_idc_gvar +ida_expr.first_idcv_attr +ida_expr.free_idcv +ida_expr.get_idc_filename +ida_expr.get_idcv_attr +ida_expr.get_idcv_class_name +ida_expr.get_idcv_slice +ida_expr.highlighter_cbs_t +ida_expr.highlighter_cbs_t.__disown__ +ida_expr.highlighter_cbs_t.__init__ +ida_expr.highlighter_cbs_t.cur_block_state +ida_expr.highlighter_cbs_t.prev_block_state +ida_expr.highlighter_cbs_t.set_block_state +ida_expr.highlighter_cbs_t.set_style +ida_expr.idc_global_t +ida_expr.idc_global_t.__init__ +ida_expr.idc_value_t +ida_expr.idc_value_t.__init__ +ida_expr.idc_value_t._create_empty_string +ida_expr.idc_value_t.c_str +ida_expr.idc_value_t.clear +ida_expr.idc_value_t.create_empty_string +ida_expr.idc_value_t.e +ida_expr.idc_value_t.funcidx +ida_expr.idc_value_t.i64 +ida_expr.idc_value_t.is_convertible +ida_expr.idc_value_t.is_integral +ida_expr.idc_value_t.is_zero +ida_expr.idc_value_t.num +ida_expr.idc_value_t.pvoid +ida_expr.idc_value_t.qstr +ida_expr.idc_value_t.reserve +ida_expr.idc_value_t.set_float +ida_expr.idc_value_t.set_int64 +ida_expr.idc_value_t.set_long +ida_expr.idc_value_t.set_pvoid +ida_expr.idc_value_t.set_string +ida_expr.idc_value_t.swap +ida_expr.idc_value_t.u_str +ida_expr.idc_value_t.vtype +ida_expr.idc_values_t +ida_expr.idc_values_t.__getitem__ +ida_expr.idc_values_t.__init__ +ida_expr.idc_values_t.__len__ +ida_expr.idc_values_t.__setitem__ +ida_expr.idc_values_t.append +ida_expr.idc_values_t.at +ida_expr.idc_values_t.begin +ida_expr.idc_values_t.capacity +ida_expr.idc_values_t.clear +ida_expr.idc_values_t.empty +ida_expr.idc_values_t.end +ida_expr.idc_values_t.erase +ida_expr.idc_values_t.extend +ida_expr.idc_values_t.extract +ida_expr.idc_values_t.grow +ida_expr.idc_values_t.inject +ida_expr.idc_values_t.insert +ida_expr.idc_values_t.pop_back +ida_expr.idc_values_t.push_back +ida_expr.idc_values_t.qclear +ida_expr.idc_values_t.reserve +ida_expr.idc_values_t.resize +ida_expr.idc_values_t.size +ida_expr.idc_values_t.swap +ida_expr.idc_values_t.truncate +ida_expr.idcv_float +ida_expr.idcv_int64 +ida_expr.idcv_long +ida_expr.idcv_num +ida_expr.idcv_object +ida_expr.idcv_string +ida_expr.last_idcv_attr +ida_expr.move_idcv +ida_expr.next_idcv_attr +ida_expr.prev_idcv_attr +ida_expr.print_idcv +ida_expr.py_add_idc_func +ida_expr.py_get_call_idc_func +ida_expr.pyw_convert_defvals +ida_expr.pyw_register_idc_func +ida_expr.pyw_unregister_idc_func +ida_expr.set_header_path +ida_expr.set_idcv_attr +ida_expr.set_idcv_slice +ida_expr.swap_idcvs +ida_expr.throw_idc_exception +ida_fixup +ida_fixup.FIXUPF_CREATED +ida_fixup.FIXUPF_EXTDEF +ida_fixup.FIXUPF_LOADER_MASK +ida_fixup.FIXUPF_REL +ida_fixup.FIXUPF_UNUSED +ida_fixup.FIXUP_CUSTOM +ida_fixup.FIXUP_HI16 +ida_fixup.FIXUP_HI8 +ida_fixup.FIXUP_LOW16 +ida_fixup.FIXUP_LOW8 +ida_fixup.FIXUP_OFF16 +ida_fixup.FIXUP_OFF16S +ida_fixup.FIXUP_OFF32 +ida_fixup.FIXUP_OFF32S +ida_fixup.FIXUP_OFF64 +ida_fixup.FIXUP_OFF8 +ida_fixup.FIXUP_OFF8S +ida_fixup.FIXUP_PTR16 +ida_fixup.FIXUP_PTR32 +ida_fixup.FIXUP_SEG16 +ida_fixup.V695_FIXUP_VHIGH +ida_fixup.V695_FIXUP_VLOW +ida_fixup.calc_fixup_size +ida_fixup.contains_fixups +ida_fixup.del_fixup +ida_fixup.exists_fixup +ida_fixup.find_custom_fixup +ida_fixup.fixup_data_t +ida_fixup.fixup_data_t.__init__ +ida_fixup.fixup_data_t.calc_size +ida_fixup.fixup_data_t.clr_extdef +ida_fixup.fixup_data_t.clr_unused +ida_fixup.fixup_data_t.displacement +ida_fixup.fixup_data_t.get +ida_fixup.fixup_data_t.get_base +ida_fixup.fixup_data_t.get_desc +ida_fixup.fixup_data_t.get_flags +ida_fixup.fixup_data_t.get_handler +ida_fixup.fixup_data_t.get_type +ida_fixup.fixup_data_t.get_value +ida_fixup.fixup_data_t.has_base +ida_fixup.fixup_data_t.is_custom +ida_fixup.fixup_data_t.is_extdef +ida_fixup.fixup_data_t.is_unused +ida_fixup.fixup_data_t.off +ida_fixup.fixup_data_t.patch_value +ida_fixup.fixup_data_t.sel +ida_fixup.fixup_data_t.set +ida_fixup.fixup_data_t.set_base +ida_fixup.fixup_data_t.set_extdef +ida_fixup.fixup_data_t.set_sel +ida_fixup.fixup_data_t.set_target_sel +ida_fixup.fixup_data_t.set_type +ida_fixup.fixup_data_t.set_type_and_flags +ida_fixup.fixup_data_t.set_unused +ida_fixup.fixup_data_t.was_created +ida_fixup.fixup_info_t +ida_fixup.fixup_info_t.__init__ +ida_fixup.gen_fix_fixups +ida_fixup.get_first_fixup_ea +ida_fixup.get_fixup +ida_fixup.get_fixup_desc +ida_fixup.get_fixup_handler +ida_fixup.get_fixup_value +ida_fixup.get_fixups +ida_fixup.get_next_fixup_ea +ida_fixup.get_prev_fixup_ea +ida_fixup.handle_fixups_in_macro +ida_fixup.is_fixup_custom +ida_fixup.patch_fixup_value +ida_fixup.set_fixup +ida_fpro +ida_fpro.qfclose +ida_fpro.qfile_t +ida_fpro.qfile_t.__init__ +ida_fpro.qfile_t.close +ida_fpro.qfile_t.filename +ida_fpro.qfile_t.flush +ida_fpro.qfile_t.from_capsule +ida_fpro.qfile_t.from_fp +ida_fpro.qfile_t.get_byte +ida_fpro.qfile_t.get_fp +ida_fpro.qfile_t.gets +ida_fpro.qfile_t.open +ida_fpro.qfile_t.opened +ida_fpro.qfile_t.put_byte +ida_fpro.qfile_t.puts +ida_fpro.qfile_t.read +ida_fpro.qfile_t.readbytes +ida_fpro.qfile_t.seek +ida_fpro.qfile_t.size +ida_fpro.qfile_t.tell +ida_fpro.qfile_t.tmpfile +ida_fpro.qfile_t.write +ida_fpro.qfile_t.writebytes +ida_frame +ida_frame.REGVAR_ERROR_ARG +ida_frame.REGVAR_ERROR_NAME +ida_frame.REGVAR_ERROR_OK +ida_frame.REGVAR_ERROR_RANGE +ida_frame.STKVAR_VALID_SIZE +ida_frame.add_auto_stkpnt +ida_frame.add_frame +ida_frame.add_frame_member +ida_frame.add_regvar +ida_frame.add_user_stkpnt +ida_frame.build_stkvar_name +ida_frame.build_stkvar_xrefs +ida_frame.calc_frame_offset +ida_frame.calc_stkvar_struc_offset +ida_frame.define_stkvar +ida_frame.del_frame +ida_frame.del_regvar +ida_frame.del_stkpnt +ida_frame.delete_frame_members +ida_frame.find_regvar +ida_frame.frame_off_args +ida_frame.frame_off_lvars +ida_frame.frame_off_retaddr +ida_frame.frame_off_savregs +ida_frame.free_regvar +ida_frame.get_effective_spd +ida_frame.get_frame_part +ida_frame.get_frame_retsize +ida_frame.get_frame_size +ida_frame.get_func_frame +ida_frame.get_sp_delta +ida_frame.get_spd +ida_frame.has_regvar +ida_frame.is_anonymous_member_name +ida_frame.is_dummy_member_name +ida_frame.is_funcarg_off +ida_frame.is_special_frame_member +ida_frame.lvar_off +ida_frame.recalc_spd +ida_frame.recalc_spd_for_basic_block +ida_frame.regvar_t +ida_frame.regvar_t.__init__ +ida_frame.regvar_t.canon +ida_frame.regvar_t.cmt +ida_frame.regvar_t.swap +ida_frame.regvar_t.user +ida_frame.rename_regvar +ida_frame.set_auto_spd +ida_frame.set_frame_member_type +ida_frame.set_frame_size +ida_frame.set_purged +ida_frame.set_regvar_cmt +ida_frame.soff_to_fpoff +ida_frame.stkpnt_t +ida_frame.stkpnt_t.__eq__ +ida_frame.stkpnt_t.__ge__ +ida_frame.stkpnt_t.__gt__ +ida_frame.stkpnt_t.__init__ +ida_frame.stkpnt_t.__le__ +ida_frame.stkpnt_t.__lt__ +ida_frame.stkpnt_t.__ne__ +ida_frame.stkpnt_t.compare +ida_frame.stkpnts_t +ida_frame.stkpnts_t.__eq__ +ida_frame.stkpnts_t.__ge__ +ida_frame.stkpnts_t.__gt__ +ida_frame.stkpnts_t.__init__ +ida_frame.stkpnts_t.__le__ +ida_frame.stkpnts_t.__lt__ +ida_frame.stkpnts_t.__ne__ +ida_frame.stkpnts_t.compare +ida_frame.update_fpd +ida_frame.xreflist_entry_t +ida_frame.xreflist_entry_t.__eq__ +ida_frame.xreflist_entry_t.__ge__ +ida_frame.xreflist_entry_t.__gt__ +ida_frame.xreflist_entry_t.__init__ +ida_frame.xreflist_entry_t.__le__ +ida_frame.xreflist_entry_t.__lt__ +ida_frame.xreflist_entry_t.__ne__ +ida_frame.xreflist_entry_t.compare +ida_frame.xreflist_entry_t.ea +ida_frame.xreflist_entry_t.opnum +ida_frame.xreflist_entry_t.type +ida_frame.xreflist_t +ida_frame.xreflist_t.__eq__ +ida_frame.xreflist_t.__getitem__ +ida_frame.xreflist_t.__init__ +ida_frame.xreflist_t.__len__ +ida_frame.xreflist_t.__ne__ +ida_frame.xreflist_t.__setitem__ +ida_frame.xreflist_t._del +ida_frame.xreflist_t.add_unique +ida_frame.xreflist_t.append +ida_frame.xreflist_t.at +ida_frame.xreflist_t.begin +ida_frame.xreflist_t.capacity +ida_frame.xreflist_t.clear +ida_frame.xreflist_t.empty +ida_frame.xreflist_t.end +ida_frame.xreflist_t.erase +ida_frame.xreflist_t.extend +ida_frame.xreflist_t.extract +ida_frame.xreflist_t.find +ida_frame.xreflist_t.grow +ida_frame.xreflist_t.has +ida_frame.xreflist_t.inject +ida_frame.xreflist_t.insert +ida_frame.xreflist_t.pop_back +ida_frame.xreflist_t.push_back +ida_frame.xreflist_t.qclear +ida_frame.xreflist_t.reserve +ida_frame.xreflist_t.resize +ida_frame.xreflist_t.size +ida_frame.xreflist_t.swap +ida_frame.xreflist_t.truncate +ida_funcs +ida_funcs.FIND_FUNC_DEFINE +ida_funcs.FIND_FUNC_EXIST +ida_funcs.FIND_FUNC_IGNOREFN +ida_funcs.FIND_FUNC_KEEPBD +ida_funcs.FIND_FUNC_NORMAL +ida_funcs.FIND_FUNC_OK +ida_funcs.FIND_FUNC_UNDEF +ida_funcs.FUNC_BOTTOMBP +ida_funcs.FUNC_CATCH +ida_funcs.FUNC_FAR +ida_funcs.FUNC_FRAME +ida_funcs.FUNC_FUZZY_SP +ida_funcs.FUNC_HIDDEN +ida_funcs.FUNC_LIB +ida_funcs.FUNC_LUMINA +ida_funcs.FUNC_NORET +ida_funcs.FUNC_NORET_PENDING +ida_funcs.FUNC_OUTLINE +ida_funcs.FUNC_PROLOG_OK +ida_funcs.FUNC_PURGED_OK +ida_funcs.FUNC_REANALYZE +ida_funcs.FUNC_SP_READY +ida_funcs.FUNC_STATICDEF +ida_funcs.FUNC_TAIL +ida_funcs.FUNC_THUNK +ida_funcs.FUNC_UNWIND +ida_funcs.FUNC_USERFAR +ida_funcs.IDASGN_APPLIED +ida_funcs.IDASGN_BADARG +ida_funcs.IDASGN_CURRENT +ida_funcs.IDASGN_OK +ida_funcs.IDASGN_PLANNED +ida_funcs.LIBFUNC_DELAY +ida_funcs.LIBFUNC_FOUND +ida_funcs.LIBFUNC_NONE +ida_funcs.MOVE_FUNC_BADSTART +ida_funcs.MOVE_FUNC_NOCODE +ida_funcs.MOVE_FUNC_NOFUNC +ida_funcs.MOVE_FUNC_OK +ida_funcs.MOVE_FUNC_REFUSED +ida_funcs.add_func +ida_funcs.add_func_ex +ida_funcs.add_regarg +ida_funcs.append_func_tail +ida_funcs.apply_idasgn_to +ida_funcs.apply_startup_sig +ida_funcs.calc_func_size +ida_funcs.calc_idasgn_state +ida_funcs.calc_thunk_func_target +ida_funcs.calc_thunk_func_target +ida_funcs.del_func +ida_funcs.del_idasgn +ida_funcs.dyn_ea_array +ida_funcs.dyn_ea_array.__getitem__ +ida_funcs.dyn_ea_array.__init__ +ida_funcs.dyn_ea_array.__len__ +ida_funcs.dyn_ea_array.__setitem__ +ida_funcs.dyn_range_array +ida_funcs.dyn_range_array.__getitem__ +ida_funcs.dyn_range_array.__init__ +ida_funcs.dyn_range_array.__len__ +ida_funcs.dyn_range_array.__setitem__ +ida_funcs.dyn_regarg_array +ida_funcs.dyn_regarg_array.__getitem__ +ida_funcs.dyn_regarg_array.__init__ +ida_funcs.dyn_regarg_array.__len__ +ida_funcs.dyn_regarg_array.__setitem__ +ida_funcs.dyn_regvar_array +ida_funcs.dyn_regvar_array.__getitem__ +ida_funcs.dyn_regvar_array.__init__ +ida_funcs.dyn_regvar_array.__len__ +ida_funcs.dyn_regvar_array.__setitem__ +ida_funcs.dyn_stkpnt_array +ida_funcs.dyn_stkpnt_array.__getitem__ +ida_funcs.dyn_stkpnt_array.__init__ +ida_funcs.dyn_stkpnt_array.__len__ +ida_funcs.dyn_stkpnt_array.__setitem__ +ida_funcs.f_any +ida_funcs.find_func_bounds +ida_funcs.free_regarg +ida_funcs.func_contains +ida_funcs.func_does_return +ida_funcs.func_item_iterator_t +ida_funcs.func_item_iterator_t.__init__ +ida_funcs.func_item_iterator_t.__iter__ +ida_funcs.func_item_iterator_t.__next__ +ida_funcs.func_item_iterator_t.addresses +ida_funcs.func_item_iterator_t.chunk +ida_funcs.func_item_iterator_t.code_items +ida_funcs.func_item_iterator_t.current +ida_funcs.func_item_iterator_t.data_items +ida_funcs.func_item_iterator_t.decode_preceding_insn +ida_funcs.func_item_iterator_t.decode_prev_insn +ida_funcs.func_item_iterator_t.first +ida_funcs.func_item_iterator_t.head_items +ida_funcs.func_item_iterator_t.last +ida_funcs.func_item_iterator_t.next_addr +ida_funcs.func_item_iterator_t.next_code +ida_funcs.func_item_iterator_t.next_data +ida_funcs.func_item_iterator_t.next_head +ida_funcs.func_item_iterator_t.next_not_tail +ida_funcs.func_item_iterator_t.not_tails +ida_funcs.func_item_iterator_t.prev +ida_funcs.func_item_iterator_t.prev_addr +ida_funcs.func_item_iterator_t.prev_code +ida_funcs.func_item_iterator_t.prev_data +ida_funcs.func_item_iterator_t.prev_head +ida_funcs.func_item_iterator_t.prev_not_tail +ida_funcs.func_item_iterator_t.set +ida_funcs.func_item_iterator_t.set_ea +ida_funcs.func_item_iterator_t.set_range +ida_funcs.func_item_iterator_t.succ +ida_funcs.func_item_iterator_t.succ_code +ida_funcs.func_parent_iterator_set +ida_funcs.func_parent_iterator_t +ida_funcs.func_parent_iterator_t.__init__ +ida_funcs.func_parent_iterator_t.__iter__ +ida_funcs.func_parent_iterator_t.__next__ +ida_funcs.func_parent_iterator_t.first +ida_funcs.func_parent_iterator_t.last +ida_funcs.func_parent_iterator_t.parent +ida_funcs.func_parent_iterator_t.prev +ida_funcs.func_parent_iterator_t.reset_fnt +ida_funcs.func_parent_iterator_t.set +ida_funcs.func_t +ida_funcs.func_t.__get_points__ +ida_funcs.func_t.__get_referers__ +ida_funcs.func_t.__get_regargs__ +ida_funcs.func_t.__get_regvars__ +ida_funcs.func_t.__get_tails__ +ida_funcs.func_t.__init__ +ida_funcs.func_t.__iter__ +ida_funcs.func_t.addresses +ida_funcs.func_t.analyzed_sp +ida_funcs.func_t.argsize +ida_funcs.func_t.code_items +ida_funcs.func_t.color +ida_funcs.func_t.data_items +ida_funcs.func_t.does_return +ida_funcs.func_t.flags +ida_funcs.func_t.fpd +ida_funcs.func_t.frame +ida_funcs.func_t.frregs +ida_funcs.func_t.frsize +ida_funcs.func_t.get_frame_object +ida_funcs.func_t.get_name +ida_funcs.func_t.get_prototype +ida_funcs.func_t.head_items +ida_funcs.func_t.is_far +ida_funcs.func_t.need_prolog_analysis +ida_funcs.func_t.not_tails +ida_funcs.func_t.owner +ida_funcs.func_t.pntqty +ida_funcs.func_t.points +ida_funcs.func_t.points +ida_funcs.func_t.referers +ida_funcs.func_t.referers +ida_funcs.func_t.refqty +ida_funcs.func_t.regargqty +ida_funcs.func_t.regargs +ida_funcs.func_t.regargs +ida_funcs.func_t.regvarqty +ida_funcs.func_t.regvars +ida_funcs.func_t.regvars +ida_funcs.func_t.tailqty +ida_funcs.func_t.tails +ida_funcs.func_t.tails +ida_funcs.func_t__from_ptrval__ +ida_funcs.func_tail_iterator_set +ida_funcs.func_tail_iterator_set_ea +ida_funcs.func_tail_iterator_t +ida_funcs.func_tail_iterator_t.__init__ +ida_funcs.func_tail_iterator_t.__iter__ +ida_funcs.func_tail_iterator_t.__next__ +ida_funcs.func_tail_iterator_t.chunk +ida_funcs.func_tail_iterator_t.first +ida_funcs.func_tail_iterator_t.last +ida_funcs.func_tail_iterator_t.main +ida_funcs.func_tail_iterator_t.prev +ida_funcs.func_tail_iterator_t.set +ida_funcs.func_tail_iterator_t.set_ea +ida_funcs.func_tail_iterator_t.set_range +ida_funcs.get_current_idasgn +ida_funcs.get_fchunk +ida_funcs.get_fchunk_num +ida_funcs.get_fchunk_qty +ida_funcs.get_fchunk_referer +ida_funcs.get_func +ida_funcs.get_func_bitness +ida_funcs.get_func_bits +ida_funcs.get_func_bytes +ida_funcs.get_func_chunknum +ida_funcs.get_func_cmt +ida_funcs.get_func_name +ida_funcs.get_func_num +ida_funcs.get_func_qty +ida_funcs.get_func_ranges +ida_funcs.get_idasgn_desc +ida_funcs.get_idasgn_desc_with_matches +ida_funcs.get_idasgn_qty +ida_funcs.get_idasgn_title +ida_funcs.get_next_fchunk +ida_funcs.get_next_func +ida_funcs.get_next_func_addr +ida_funcs.get_prev_fchunk +ida_funcs.get_prev_func +ida_funcs.get_prev_func_addr +ida_funcs.getn_fchunk +ida_funcs.getn_func +ida_funcs.is_finally_visible_func +ida_funcs.is_func_entry +ida_funcs.is_func_locked +ida_funcs.is_func_tail +ida_funcs.is_same_func +ida_funcs.is_visible_func +ida_funcs.lock_func +ida_funcs.lock_func.__init__ +ida_funcs.lock_func_range +ida_funcs.lock_func_with_tails_t +ida_funcs.lock_func_with_tails_t.__init__ +ida_funcs.plan_to_apply_idasgn +ida_funcs.read_regargs +ida_funcs.reanalyze_function +ida_funcs.reanalyze_noret_flag +ida_funcs.regarg_t +ida_funcs.regarg_t.__init__ +ida_funcs.regarg_t.swap +ida_funcs.remove_func_tail +ida_funcs.set_func_cmt +ida_funcs.set_func_end +ida_funcs.set_func_name_if_jumpfunc +ida_funcs.set_func_start +ida_funcs.set_noret_insn +ida_funcs.set_tail_owner +ida_funcs.set_visible_func +ida_funcs.try_to_add_libfunc +ida_funcs.update_func +ida_gdl +ida_gdl.BasicBlock +ida_gdl.BasicBlock.__init__ +ida_gdl.BasicBlock.preds +ida_gdl.BasicBlock.succs +ida_gdl.CHART_FOLLOW_DIRECTION +ida_gdl.CHART_GEN_DOT +ida_gdl.CHART_GEN_GDL +ida_gdl.CHART_IGNORE_LIB_FROM +ida_gdl.CHART_IGNORE_LIB_TO +ida_gdl.CHART_NOLIBFUNCS +ida_gdl.CHART_PRINT_DOTS +ida_gdl.CHART_PRINT_NAMES +ida_gdl.CHART_RECURSIVE +ida_gdl.CHART_REFERENCED +ida_gdl.CHART_REFERENCING +ida_gdl.CHART_WINGRAPH +ida_gdl.FC_APPND +ida_gdl.FC_CALL_ENDS +ida_gdl.FC_CHKBREAK +ida_gdl.FC_NOEXT +ida_gdl.FC_NOPREDS +ida_gdl.FC_OUTLINES +ida_gdl.FC_PRINT +ida_gdl.FC_RESERVED +ida_gdl.FlowChart +ida_gdl.FlowChart.__getitem__ +ida_gdl.FlowChart.__init__ +ida_gdl.FlowChart.__iter__ +ida_gdl.FlowChart._getitem +ida_gdl.FlowChart.refresh +ida_gdl.FlowChart.size +ida_gdl.cancellable_graph_t +ida_gdl.cancellable_graph_t.__disown__ +ida_gdl.cancellable_graph_t.__init__ +ida_gdl.display_gdl +ida_gdl.edge_t +ida_gdl.edge_t.__eq__ +ida_gdl.edge_t.__init__ +ida_gdl.edge_t.__lt__ +ida_gdl.edge_t.__ne__ +ida_gdl.edge_t.dst +ida_gdl.edge_t.src +ida_gdl.edgevec_t +ida_gdl.edgevec_t.__init__ +ida_gdl.fcb_cndret +ida_gdl.fcb_enoret +ida_gdl.fcb_error +ida_gdl.fcb_extern +ida_gdl.fcb_indjump +ida_gdl.fcb_noret +ida_gdl.fcb_normal +ida_gdl.fcb_ret +ida_gdl.gdl_graph_t +ida_gdl.gdl_graph_t.__disown__ +ida_gdl.gdl_graph_t.__init__ +ida_gdl.gdl_graph_t.begin +ida_gdl.gdl_graph_t.edge +ida_gdl.gdl_graph_t.empty +ida_gdl.gdl_graph_t.end +ida_gdl.gdl_graph_t.entry +ida_gdl.gdl_graph_t.exists +ida_gdl.gdl_graph_t.exit +ida_gdl.gdl_graph_t.front +ida_gdl.gdl_graph_t.get_edge_color +ida_gdl.gdl_graph_t.get_node_color +ida_gdl.gdl_graph_t.get_node_label +ida_gdl.gdl_graph_t.nedge +ida_gdl.gdl_graph_t.node_qty +ida_gdl.gdl_graph_t.npred +ida_gdl.gdl_graph_t.nsucc +ida_gdl.gdl_graph_t.pred +ida_gdl.gdl_graph_t.print_edge +ida_gdl.gdl_graph_t.print_graph_attributes +ida_gdl.gdl_graph_t.print_node +ida_gdl.gdl_graph_t.print_node_attributes +ida_gdl.gdl_graph_t.size +ida_gdl.gdl_graph_t.succ +ida_gdl.gen_complex_call_chart +ida_gdl.gen_flow_graph +ida_gdl.gen_gdl +ida_gdl.gen_simple_call_chart +ida_gdl.is_noret_block +ida_gdl.is_ret_block +ida_gdl.node_iterator +ida_gdl.node_iterator.__eq__ +ida_gdl.node_iterator.__init__ +ida_gdl.node_iterator.__ne__ +ida_gdl.node_iterator.__ref__ +ida_gdl.node_ordering_t +ida_gdl.node_ordering_t.__init__ +ida_gdl.node_ordering_t.clear +ida_gdl.node_ordering_t.clr +ida_gdl.node_ordering_t.node +ida_gdl.node_ordering_t.order +ida_gdl.node_ordering_t.resize +ida_gdl.node_ordering_t.set +ida_gdl.node_ordering_t.size +ida_gdl.qbasic_block_t +ida_gdl.qbasic_block_t.__init__ +ida_gdl.qflow_chart_t +ida_gdl.qflow_chart_t.__getitem__ +ida_gdl.qflow_chart_t.__init__ +ida_gdl.qflow_chart_t.append_to_flowchart +ida_gdl.qflow_chart_t.bounds +ida_gdl.qflow_chart_t.calc_block_type +ida_gdl.qflow_chart_t.create +ida_gdl.qflow_chart_t.flags +ida_gdl.qflow_chart_t.get_node_label +ida_gdl.qflow_chart_t.is_noret_block +ida_gdl.qflow_chart_t.is_ret_block +ida_gdl.qflow_chart_t.npred +ida_gdl.qflow_chart_t.nproper +ida_gdl.qflow_chart_t.nsucc +ida_gdl.qflow_chart_t.pfn +ida_gdl.qflow_chart_t.pred +ida_gdl.qflow_chart_t.print_names +ida_gdl.qflow_chart_t.print_node_attributes +ida_gdl.qflow_chart_t.refresh +ida_gdl.qflow_chart_t.size +ida_gdl.qflow_chart_t.succ +ida_graph +ida_graph.GLICTL_CENTER +ida_graph.GraphViewer +ida_graph.GraphViewer.AddCommand +ida_graph.GraphViewer.AddEdge +ida_graph.GraphViewer.AddNode +ida_graph.GraphViewer.Clear +ida_graph.GraphViewer.Close +ida_graph.GraphViewer.Count +ida_graph.GraphViewer.OnCommand +ida_graph.GraphViewer.OnPopup +ida_graph.GraphViewer.OnRefresh +ida_graph.GraphViewer.Select +ida_graph.GraphViewer.Show +ida_graph.GraphViewer.UI_Hooks_Trampoline +ida_graph.GraphViewer.UI_Hooks_Trampoline.__init__ +ida_graph.GraphViewer.UI_Hooks_Trampoline.populating_widget_popup +ida_graph.GraphViewer._OnBind +ida_graph.GraphViewer.__getitem__ +ida_graph.GraphViewer.__init__ +ida_graph.GraphViewer.__init__._qccb +ida_graph.GraphViewer.__iter__ +ida_graph.MTG_DOT_NODE +ida_graph.MTG_GROUP_NODE +ida_graph.MTG_NON_DISPLAYABLE_NODE +ida_graph.NIF_BG_COLOR +ida_graph.NIF_EA +ida_graph.NIF_FLAGS +ida_graph.NIF_FRAME_COLOR +ida_graph.NIF_TEXT +ida_graph.TPointDouble +ida_graph.TPointDouble.__eq__ +ida_graph.TPointDouble.__init__ +ida_graph.TPointDouble.__ne__ +ida_graph.TPointDouble.add +ida_graph.TPointDouble.negate +ida_graph.TPointDouble.sub +ida_graph.calc_dist +ida_graph.clr_node_info +ida_graph.create_disasm_graph +ida_graph.create_graph_viewer +ida_graph.create_interactive_graph +ida_graph.create_user_graph_place +ida_graph.del_node_info +ida_graph.delete_interactive_graph +ida_graph.drawable_graph_t +ida_graph.drawable_graph_t.__disown__ +ida_graph.drawable_graph_t.__init__ +ida_graph.drawable_graph_t.callback_ud +ida_graph.drawable_graph_t.circle_center +ida_graph.drawable_graph_t.circle_radius +ida_graph.drawable_graph_t.create_circle_layout +ida_graph.drawable_graph_t.create_tree_layout +ida_graph.drawable_graph_t.current_layout +ida_graph.drawable_graph_t.get_edge +ida_graph.drawable_graph_t.grcall +ida_graph.drawable_graph_t.nrect +ida_graph.drawable_graph_t.rect_edges_made +ida_graph.drawable_graph_t.set_callback +ida_graph.drawable_graph_t.title +ida_graph.edge_info_t +ida_graph.edge_info_t.__init__ +ida_graph.edge_info_t.color +ida_graph.edge_info_t.dstoff +ida_graph.edge_info_t.layout +ida_graph.edge_info_t.reverse_layout +ida_graph.edge_info_t.srcoff +ida_graph.edge_info_t.width +ida_graph.edge_infos_wrapper_t +ida_graph.edge_infos_wrapper_t.__init__ +ida_graph.edge_infos_wrapper_t.clear +ida_graph.edge_layout_point_t +ida_graph.edge_layout_point_t.__eq__ +ida_graph.edge_layout_point_t.__init__ +ida_graph.edge_layout_point_t.__ne__ +ida_graph.edge_layout_point_t.compare +ida_graph.edge_layout_point_t.e +ida_graph.edge_layout_point_t.pidx +ida_graph.edge_segment_t +ida_graph.edge_segment_t.__init__ +ida_graph.edge_segment_t.__lt__ +ida_graph.edge_segment_t.length +ida_graph.edge_segment_t.toright +ida_graph.get_graph_viewer +ida_graph.get_node_info +ida_graph.get_viewer_graph +ida_graph.git_edge +ida_graph.git_elp +ida_graph.git_node +ida_graph.git_none +ida_graph.git_text +ida_graph.git_tool +ida_graph.graph_item_t +ida_graph.graph_item_t.__init__ +ida_graph.graph_item_t.b +ida_graph.graph_item_t.e +ida_graph.graph_item_t.elp +ida_graph.graph_item_t.is_edge +ida_graph.graph_item_t.is_node +ida_graph.graph_item_t.n +ida_graph.graph_item_t.p +ida_graph.graph_item_t.type +ida_graph.graph_node_visitor_t +ida_graph.graph_node_visitor_t.__disown__ +ida_graph.graph_node_visitor_t.__init__ +ida_graph.graph_node_visitor_t.is_forbidden_edge +ida_graph.graph_node_visitor_t.is_visited +ida_graph.graph_node_visitor_t.reinit +ida_graph.graph_node_visitor_t.set_visited +ida_graph.graph_node_visitor_t.visit_node +ida_graph.graph_path_visitor_t +ida_graph.graph_path_visitor_t.__disown__ +ida_graph.graph_path_visitor_t.__init__ +ida_graph.graph_path_visitor_t.path +ida_graph.graph_path_visitor_t.prune +ida_graph.graph_path_visitor_t.walk_backward +ida_graph.graph_path_visitor_t.walk_forward +ida_graph.graph_visitor_t +ida_graph.graph_visitor_t.__disown__ +ida_graph.graph_visitor_t.__init__ +ida_graph.graph_visitor_t.visit_edge +ida_graph.graph_visitor_t.visit_node +ida_graph.grcode_calculating_layout +ida_graph.grcode_center_on +ida_graph.grcode_change_group_visibility +ida_graph.grcode_changed_graph +ida_graph.grcode_clear +ida_graph.grcode_clicked +ida_graph.grcode_create_circle_layout +ida_graph.grcode_create_digraph_layout +ida_graph.grcode_create_disasm_graph1 +ida_graph.grcode_create_disasm_graph2 +ida_graph.grcode_create_graph_viewer +ida_graph.grcode_create_group +ida_graph.grcode_create_interactive_graph +ida_graph.grcode_create_tree_layout +ida_graph.grcode_create_user_graph_place +ida_graph.grcode_creating_group +ida_graph.grcode_dblclicked +ida_graph.grcode_del_custom_layout +ida_graph.grcode_del_node_info +ida_graph.grcode_delete_group +ida_graph.grcode_delete_interactive_graph +ida_graph.grcode_deleting_group +ida_graph.grcode_destroyed +ida_graph.grcode_edge_infos_wrapper_clear +ida_graph.grcode_edge_infos_wrapper_copy +ida_graph.grcode_empty +ida_graph.grcode_find_subgraph_node +ida_graph.grcode_fit_window +ida_graph.grcode_get_curnode +ida_graph.grcode_get_custom_layout +ida_graph.grcode_get_gli +ida_graph.grcode_get_graph_groups +ida_graph.grcode_get_graph_viewer +ida_graph.grcode_get_node_info +ida_graph.grcode_get_node_representative +ida_graph.grcode_get_selection +ida_graph.grcode_get_viewer_graph +ida_graph.grcode_gotfocus +ida_graph.grcode_group_visibility +ida_graph.grcode_is_visible_node +ida_graph.grcode_layout_calculated +ida_graph.grcode_lostfocus +ida_graph.grcode_node_qty +ida_graph.grcode_nrect +ida_graph.grcode_refresh_viewer +ida_graph.grcode_set_custom_layout +ida_graph.grcode_set_edge +ida_graph.grcode_set_gli +ida_graph.grcode_set_graph_groups +ida_graph.grcode_set_node_info +ida_graph.grcode_set_titlebar_height +ida_graph.grcode_set_viewer_graph +ida_graph.grcode_user_draw +ida_graph.grcode_user_hint +ida_graph.grcode_user_refresh +ida_graph.grcode_user_size +ida_graph.grcode_user_text +ida_graph.grcode_user_title +ida_graph.grcode_viewer_create_groups_vec +ida_graph.grcode_viewer_delete_groups_vec +ida_graph.grcode_viewer_groups_visibility_vec +ida_graph.group_crinfo_t +ida_graph.group_crinfo_t.__init__ +ida_graph.interactive_graph_t +ida_graph.interactive_graph_t.__init__ +ida_graph.interactive_graph_t.add_edge +ida_graph.interactive_graph_t.add_node +ida_graph.interactive_graph_t.belongs +ida_graph.interactive_graph_t.calc_group_ea +ida_graph.interactive_graph_t.change_group_visibility +ida_graph.interactive_graph_t.create_digraph_layout +ida_graph.interactive_graph_t.create_group +ida_graph.interactive_graph_t.del_custom_layout +ida_graph.interactive_graph_t.del_edge +ida_graph.interactive_graph_t.del_node +ida_graph.interactive_graph_t.delete_group +ida_graph.interactive_graph_t.empty +ida_graph.interactive_graph_t.exists +ida_graph.interactive_graph_t.get_custom_layout +ida_graph.interactive_graph_t.get_first_subgraph_node +ida_graph.interactive_graph_t.get_graph_groups +ida_graph.interactive_graph_t.get_next_subgraph_node +ida_graph.interactive_graph_t.get_node_group +ida_graph.interactive_graph_t.get_node_representative +ida_graph.interactive_graph_t.gid +ida_graph.interactive_graph_t.is_collapsed_node +ida_graph.interactive_graph_t.is_deleted_node +ida_graph.interactive_graph_t.is_displayable_node +ida_graph.interactive_graph_t.is_dot_node +ida_graph.interactive_graph_t.is_group_node +ida_graph.interactive_graph_t.is_simple_node +ida_graph.interactive_graph_t.is_subgraph_node +ida_graph.interactive_graph_t.is_uncollapsed_node +ida_graph.interactive_graph_t.is_user_graph +ida_graph.interactive_graph_t.is_visible_node +ida_graph.interactive_graph_t.node_flags +ida_graph.interactive_graph_t.node_qty +ida_graph.interactive_graph_t.npred +ida_graph.interactive_graph_t.nsucc +ida_graph.interactive_graph_t.pred +ida_graph.interactive_graph_t.predset +ida_graph.interactive_graph_t.redo_layout +ida_graph.interactive_graph_t.refresh +ida_graph.interactive_graph_t.replace_edge +ida_graph.interactive_graph_t.reset +ida_graph.interactive_graph_t.resize +ida_graph.interactive_graph_t.set_custom_layout +ida_graph.interactive_graph_t.set_deleted_node +ida_graph.interactive_graph_t.set_edge +ida_graph.interactive_graph_t.set_graph_groups +ida_graph.interactive_graph_t.set_node_group +ida_graph.interactive_graph_t.set_nrect +ida_graph.interactive_graph_t.size +ida_graph.interactive_graph_t.succ +ida_graph.interactive_graph_t.succset +ida_graph.interval_t +ida_graph.interval_t.__eq__ +ida_graph.interval_t.__init__ +ida_graph.interval_t.__ne__ +ida_graph.interval_t.contains +ida_graph.interval_t.empty +ida_graph.interval_t.intersect +ida_graph.interval_t.length +ida_graph.interval_t.make_union +ida_graph.interval_t.move_by +ida_graph.node_info_t +ida_graph.node_info_t.__init__ +ida_graph.node_info_t.bg_color +ida_graph.node_info_t.ea +ida_graph.node_info_t.flags +ida_graph.node_info_t.frame_color +ida_graph.node_info_t.get_flags_for_valid +ida_graph.node_info_t.text +ida_graph.node_info_t.valid_bg_color +ida_graph.node_info_t.valid_ea +ida_graph.node_info_t.valid_flags +ida_graph.node_info_t.valid_frame_color +ida_graph.node_info_t.valid_text +ida_graph.node_layout_t +ida_graph.node_layout_t.__eq__ +ida_graph.node_layout_t.__getitem__ +ida_graph.node_layout_t.__init__ +ida_graph.node_layout_t.__len__ +ida_graph.node_layout_t.__ne__ +ida_graph.node_layout_t.__setitem__ +ida_graph.node_layout_t._del +ida_graph.node_layout_t.add_unique +ida_graph.node_layout_t.append +ida_graph.node_layout_t.at +ida_graph.node_layout_t.begin +ida_graph.node_layout_t.capacity +ida_graph.node_layout_t.clear +ida_graph.node_layout_t.empty +ida_graph.node_layout_t.end +ida_graph.node_layout_t.erase +ida_graph.node_layout_t.extend +ida_graph.node_layout_t.extract +ida_graph.node_layout_t.find +ida_graph.node_layout_t.grow +ida_graph.node_layout_t.has +ida_graph.node_layout_t.inject +ida_graph.node_layout_t.insert +ida_graph.node_layout_t.pop_back +ida_graph.node_layout_t.push_back +ida_graph.node_layout_t.qclear +ida_graph.node_layout_t.reserve +ida_graph.node_layout_t.resize +ida_graph.node_layout_t.size +ida_graph.node_layout_t.swap +ida_graph.node_layout_t.truncate +ida_graph.point_t +ida_graph.point_t.__eq__ +ida_graph.point_t.__init__ +ida_graph.point_t.__ne__ +ida_graph.point_t.add +ida_graph.point_t.negate +ida_graph.point_t.sub +ida_graph.pointseq_t +ida_graph.pointseq_t.__init__ +ida_graph.pointvec_t +ida_graph.pointvec_t.__eq__ +ida_graph.pointvec_t.__getitem__ +ida_graph.pointvec_t.__init__ +ida_graph.pointvec_t.__len__ +ida_graph.pointvec_t.__ne__ +ida_graph.pointvec_t.__setitem__ +ida_graph.pointvec_t._del +ida_graph.pointvec_t.add_unique +ida_graph.pointvec_t.append +ida_graph.pointvec_t.at +ida_graph.pointvec_t.begin +ida_graph.pointvec_t.capacity +ida_graph.pointvec_t.clear +ida_graph.pointvec_t.empty +ida_graph.pointvec_t.end +ida_graph.pointvec_t.erase +ida_graph.pointvec_t.extend +ida_graph.pointvec_t.extract +ida_graph.pointvec_t.find +ida_graph.pointvec_t.grow +ida_graph.pointvec_t.has +ida_graph.pointvec_t.inject +ida_graph.pointvec_t.insert +ida_graph.pointvec_t.pop_back +ida_graph.pointvec_t.push_back +ida_graph.pointvec_t.qclear +ida_graph.pointvec_t.reserve +ida_graph.pointvec_t.resize +ida_graph.pointvec_t.size +ida_graph.pointvec_t.swap +ida_graph.pointvec_t.truncate +ida_graph.pyg_close +ida_graph.pyg_select_node +ida_graph.pyg_show +ida_graph.rect_t +ida_graph.rect_t.__eq__ +ida_graph.rect_t.__init__ +ida_graph.rect_t.__ne__ +ida_graph.rect_t.area +ida_graph.rect_t.bottomright +ida_graph.rect_t.center +ida_graph.rect_t.contains +ida_graph.rect_t.empty +ida_graph.rect_t.grow +ida_graph.rect_t.height +ida_graph.rect_t.intersect +ida_graph.rect_t.is_intersection_empty +ida_graph.rect_t.make_union +ida_graph.rect_t.move_by +ida_graph.rect_t.move_to +ida_graph.rect_t.topleft +ida_graph.rect_t.verify +ida_graph.rect_t.width +ida_graph.refresh_viewer +ida_graph.row_info_t +ida_graph.row_info_t.__init__ +ida_graph.row_info_t.bottom +ida_graph.row_info_t.height +ida_graph.row_info_t.nodes +ida_graph.row_info_t.top +ida_graph.screen_graph_selection_base_t +ida_graph.screen_graph_selection_base_t.__eq__ +ida_graph.screen_graph_selection_base_t.__getitem__ +ida_graph.screen_graph_selection_base_t.__init__ +ida_graph.screen_graph_selection_base_t.__len__ +ida_graph.screen_graph_selection_base_t.__ne__ +ida_graph.screen_graph_selection_base_t.__setitem__ +ida_graph.screen_graph_selection_base_t._del +ida_graph.screen_graph_selection_base_t.add_unique +ida_graph.screen_graph_selection_base_t.append +ida_graph.screen_graph_selection_base_t.at +ida_graph.screen_graph_selection_base_t.begin +ida_graph.screen_graph_selection_base_t.capacity +ida_graph.screen_graph_selection_base_t.clear +ida_graph.screen_graph_selection_base_t.empty +ida_graph.screen_graph_selection_base_t.end +ida_graph.screen_graph_selection_base_t.erase +ida_graph.screen_graph_selection_base_t.extend +ida_graph.screen_graph_selection_base_t.extract +ida_graph.screen_graph_selection_base_t.find +ida_graph.screen_graph_selection_base_t.grow +ida_graph.screen_graph_selection_base_t.has +ida_graph.screen_graph_selection_base_t.inject +ida_graph.screen_graph_selection_base_t.insert +ida_graph.screen_graph_selection_base_t.pop_back +ida_graph.screen_graph_selection_base_t.push_back +ida_graph.screen_graph_selection_base_t.qclear +ida_graph.screen_graph_selection_base_t.reserve +ida_graph.screen_graph_selection_base_t.resize +ida_graph.screen_graph_selection_base_t.size +ida_graph.screen_graph_selection_base_t.swap +ida_graph.screen_graph_selection_base_t.truncate +ida_graph.screen_graph_selection_t +ida_graph.screen_graph_selection_t.__init__ +ida_graph.screen_graph_selection_t.add +ida_graph.screen_graph_selection_t.add_node +ida_graph.screen_graph_selection_t.add_point +ida_graph.screen_graph_selection_t.del_node +ida_graph.screen_graph_selection_t.del_point +ida_graph.screen_graph_selection_t.has +ida_graph.screen_graph_selection_t.items_count +ida_graph.screen_graph_selection_t.nodes_count +ida_graph.screen_graph_selection_t.points_count +ida_graph.screen_graph_selection_t.sub +ida_graph.selection_item_t +ida_graph.selection_item_t.__eq__ +ida_graph.selection_item_t.__init__ +ida_graph.selection_item_t.__lt__ +ida_graph.selection_item_t.__ne__ +ida_graph.selection_item_t.compare +ida_graph.selection_item_t.elp +ida_graph.selection_item_t.is_node +ida_graph.selection_item_t.node +ida_graph.set_node_info +ida_graph.set_viewer_graph +ida_graph.user_graph_place_t +ida_graph.user_graph_place_t.__init__ +ida_graph.viewer_attach_menu_item +ida_graph.viewer_center_on +ida_graph.viewer_create_groups +ida_graph.viewer_del_node_info +ida_graph.viewer_delete_groups +ida_graph.viewer_fit_window +ida_graph.viewer_get_curnode +ida_graph.viewer_get_gli +ida_graph.viewer_get_node_info +ida_graph.viewer_get_selection +ida_graph.viewer_set_gli +ida_graph.viewer_set_groups_visibility +ida_graph.viewer_set_node_info +ida_graph.viewer_set_titlebar_height +ida_ida +ida_ida.ABI_8ALIGN4 +ida_ida.ABI_BIGARG_ALIGN +ida_ida.ABI_GCC_LAYOUT +ida_ida.ABI_HARD_FLOAT +ida_ida.ABI_HUGEARG_ALIGN +ida_ida.ABI_MAP_STKARGS +ida_ida.ABI_PACK_STKARGS +ida_ida.ABI_SET_BY_USER +ida_ida.ABI_STACK_LDBL +ida_ida.ABI_STACK_VARARGS +ida_ida.AF2_DOEH +ida_ida.AF2_DORTTI +ida_ida.AF2_MACRO +ida_ida.AF2_MERGESTR +ida_ida.AF_ANORET +ida_ida.AF_CHKUNI +ida_ida.AF_CODE +ida_ida.AF_DATOFF +ida_ida.AF_DOCODE +ida_ida.AF_DODATA +ida_ida.AF_DREFOFF +ida_ida.AF_FINAL +ida_ida.AF_FIXUP +ida_ida.AF_FLIRT +ida_ida.AF_FTAIL +ida_ida.AF_HFLIRT +ida_ida.AF_IMMOFF +ida_ida.AF_JFUNC +ida_ida.AF_JUMPTBL +ida_ida.AF_LVAR +ida_ida.AF_MARKCODE +ida_ida.AF_MEMFUNC +ida_ida.AF_NULLSUB +ida_ida.AF_PROC +ida_ida.AF_PROCPTR +ida_ida.AF_PURDAT +ida_ida.AF_REGARG +ida_ida.AF_SIGCMT +ida_ida.AF_SIGMLT +ida_ida.AF_STKARG +ida_ida.AF_STRLIT +ida_ida.AF_TRACE +ida_ida.AF_TRFUNC +ida_ida.AF_UNK +ida_ida.AF_USED +ida_ida.AF_VERSP +ida_ida.DEMNAM_CMNT +ida_ida.DEMNAM_FIRST +ida_ida.DEMNAM_GCC3 +ida_ida.DEMNAM_MASK +ida_ida.DEMNAM_NAME +ida_ida.DEMNAM_NONE +ida_ida.IDAINFO_TAG_SIZE +ida_ida.IDB_COMPRESSED +ida_ida.IDB_PACKED +ida_ida.IDB_UNPACKED +ida_ida.IDI_ALTVAL +ida_ida.IDI_BITMAP +ida_ida.IDI_BLOB +ida_ida.IDI_BYTEARRAY +ida_ida.IDI_CSTR +ida_ida.IDI_DEC +ida_ida.IDI_EA_HEX +ida_ida.IDI_HASH +ida_ida.IDI_HEX +ida_ida.IDI_HLPSTRUC +ida_ida.IDI_INC +ida_ida.IDI_MAP_VAL +ida_ida.IDI_NOMERGE +ida_ida.IDI_ONOFF +ida_ida.IDI_QSTRING +ida_ida.IDI_READONLY +ida_ida.IDI_SCALAR +ida_ida.IDI_STRUCFLD +ida_ida.IDI_SUPVAL +ida_ida.IDI_VALOBJ +ida_ida.INFFL_ALLASM +ida_ida.INFFL_AUTO +ida_ida.INFFL_CHKOPS +ida_ida.INFFL_GRAPH_VIEW +ida_ida.INFFL_LOADIDC +ida_ida.INFFL_NMOPS +ida_ida.INFFL_NOUSER +ida_ida.INFFL_READONLY +ida_ida.INF_ABINAME +ida_ida.INF_ARCHIVE_PATH +ida_ida.INF_CRC32 +ida_ida.INF_CTIME +ida_ida.INF_C_MACROS +ida_ida.INF_DBG_BINPATHS +ida_ida.INF_DUALOP_GRAPH +ida_ida.INF_DUALOP_TEXT +ida_ida.INF_ELAPSED +ida_ida.INF_FILE_FORMAT_NAME +ida_ida.INF_FSIZE +ida_ida.INF_GROUPS +ida_ida.INF_H_PATH +ida_ida.INF_IDA_VERSION +ida_ida.INF_IDSNODE +ida_ida.INF_IMAGEBASE +ida_ida.INF_INCLUDE +ida_ida.INF_INITIAL_VERSION +ida_ida.INF_MD5 +ida_ida.INF_NOPENS +ida_ida.INF_NOTEPAD +ida_ida.INF_OUTFILEENC +ida_ida.INF_PROBLEMS +ida_ida.INF_SELECTORS +ida_ida.INF_SHA256 +ida_ida.INF_SRCDBG_PATHS +ida_ida.INF_SRCDBG_UNDESIRED +ida_ida.INF_STR_ENCODINGS +ida_ida.LFLG_64BIT +ida_ida.LFLG_COMPRESS +ida_ida.LFLG_DBG_NOPATH +ida_ida.LFLG_FLAT_OFF32 +ida_ida.LFLG_ILP32 +ida_ida.LFLG_IS_DLL +ida_ida.LFLG_KERNMODE +ida_ida.LFLG_MSF +ida_ida.LFLG_PACK +ida_ida.LFLG_PC_FLAT +ida_ida.LFLG_PC_FPP +ida_ida.LFLG_SNAPSHOT +ida_ida.LFLG_WIDE_HBF +ida_ida.LMT_EMPTY +ida_ida.LMT_THICK +ida_ida.LMT_THIN +ida_ida.LN_AUTO +ida_ida.LN_NORMAL +ida_ida.LN_PUBLIC +ida_ida.LN_WEAK +ida_ida.OFLG_GEN_ASSUME +ida_ida.OFLG_GEN_NULL +ida_ida.OFLG_GEN_ORG +ida_ida.OFLG_GEN_TRYBLKS +ida_ida.OFLG_LZERO +ida_ida.OFLG_PREF_SEG +ida_ida.OFLG_SHOW_AUTO +ida_ida.OFLG_SHOW_PREF +ida_ida.OFLG_SHOW_VOID +ida_ida.PREF_FNCOFF +ida_ida.PREF_PFXTRUNC +ida_ida.PREF_SEGADR +ida_ida.PREF_STACK +ida_ida.SCF_ALLCMT +ida_ida.SCF_LINNUM +ida_ida.SCF_NOCMT +ida_ida.SCF_RPTCMT +ida_ida.SCF_SHHID_FUNC +ida_ida.SCF_SHHID_ITEM +ida_ida.SCF_SHHID_SEGM +ida_ida.SCF_TESTMODE +ida_ida.STRF_AUTO +ida_ida.STRF_COMMENT +ida_ida.STRF_GEN +ida_ida.STRF_SAVECASE +ida_ida.STRF_SERIAL +ida_ida.STRF_UNICODE +ida_ida.STT_CUR +ida_ida.STT_DBG +ida_ida.STT_MM +ida_ida.STT_VA +ida_ida.SW_SEGXRF +ida_ida.SW_XRFFNC +ida_ida.SW_XRFMRK +ida_ida.SW_XRFVAL +ida_ida.UA_MAXOP +ida_ida.VLD_AUTO_REPAIR +ida_ida.VLD_DIALOG +ida_ida.VLD_SILENT +ida_ida.__make_idainfo_accessors +ida_ida.__make_idainfo_bound +ida_ida.__make_idainfo_bound.__func +ida_ida.__make_idainfo_getter +ida_ida.__set_module_dynattrs +ida_ida.__wrap_hooks_callback +ida_ida.__wrap_hooks_callback.__wrapper +ida_ida.calc_default_idaplace_flags +ida_ida.compiler_info_t +ida_ida.compiler_info_t.__init__ +ida_ida.compiler_info_t.cm +ida_ida.compiler_info_t.defalign +ida_ida.compiler_info_t.id +ida_ida.compiler_info_t.size_b +ida_ida.compiler_info_t.size_e +ida_ida.compiler_info_t.size_i +ida_ida.compiler_info_t.size_l +ida_ida.compiler_info_t.size_ldbl +ida_ida.compiler_info_t.size_ll +ida_ida.compiler_info_t.size_s +ida_ida.delinf +ida_ida.f_AIXAR +ida_ida.f_AOUT +ida_ida.f_AR +ida_ida.f_BIN +ida_ida.f_COFF +ida_ida.f_COM +ida_ida.f_COM_old +ida_ida.f_DRV +ida_ida.f_ELF +ida_ida.f_EXE +ida_ida.f_EXE_old +ida_ida.f_HEX +ida_ida.f_LE +ida_ida.f_LOADER +ida_ida.f_LX +ida_ida.f_MACHO +ida_ida.f_MD1IMG +ida_ida.f_MEX +ida_ida.f_NLM +ida_ida.f_OMF +ida_ida.f_OMFLIB +ida_ida.f_PE +ida_ida.f_PRC +ida_ida.f_PSXOBJ +ida_ida.f_SREC +ida_ida.f_W32RUN +ida_ida.f_WIN +ida_ida.f_ZIP +ida_ida.get_dbctx_id +ida_ida.get_dbctx_qty +ida_ida.getinf_str +ida_ida.idainfo +ida_ida.idainfo.__init__ +ida_ida.idainfo._get_lflags +ida_ida.idainfo._set_lflags +ida_ida.idainfo.abibits +ida_ida.idainfo.af +ida_ida.idainfo.af2 +ida_ida.idainfo.appcall_options +ida_ida.idainfo.apptype +ida_ida.idainfo.asmtype +ida_ida.idainfo.baseaddr +ida_ida.idainfo.bin_prefix_size +ida_ida.idainfo.cc +ida_ida.idainfo.cmt_indent +ida_ida.idainfo.database_change_count +ida_ida.idainfo.datatypes +ida_ida.idainfo.demnames +ida_ida.idainfo.filetype +ida_ida.idainfo.get_abiname +ida_ida.idainfo.highoff +ida_ida.idainfo.indent +ida_ida.idainfo.lenxref +ida_ida.idainfo.lflags +ida_ida.idainfo.listnames +ida_ida.idainfo.long_demnames +ida_ida.idainfo.lowoff +ida_ida.idainfo.main +ida_ida.idainfo.margin +ida_ida.idainfo.max_autoname_len +ida_ida.idainfo.max_ea +ida_ida.idainfo.maxref +ida_ida.idainfo.min_ea +ida_ida.idainfo.nametype +ida_ida.idainfo.omax_ea +ida_ida.idainfo.omin_ea +ida_ida.idainfo.ostype +ida_ida.idainfo.outflags +ida_ida.idainfo.procname +ida_ida.idainfo.refcmtnum +ida_ida.idainfo.s_cmtflg +ida_ida.idainfo.s_genflags +ida_ida.idainfo.s_limiter +ida_ida.idainfo.s_prefflag +ida_ida.idainfo.s_xrefflag +ida_ida.idainfo.short_demnames +ida_ida.idainfo.specsegs +ida_ida.idainfo.start_cs +ida_ida.idainfo.start_ea +ida_ida.idainfo.start_ip +ida_ida.idainfo.start_sp +ida_ida.idainfo.start_ss +ida_ida.idainfo.strlit_break +ida_ida.idainfo.strlit_flags +ida_ida.idainfo.strlit_pref +ida_ida.idainfo.strlit_sernum +ida_ida.idainfo.strlit_zeroes +ida_ida.idainfo.strtype +ida_ida.idainfo.tag +ida_ida.idainfo.type_xrefnum +ida_ida.idainfo.version +ida_ida.idainfo.xrefnum +ida_ida.idainfo_is_32bit +ida_ida.idbattr_info_t +ida_ida.idbattr_info_t.__init__ +ida_ida.idbattr_info_t.__lt__ +ida_ida.idbattr_info_t.bitmask +ida_ida.idbattr_info_t.has_individual_node +ida_ida.idbattr_info_t.hashname +ida_ida.idbattr_info_t.individual_node +ida_ida.idbattr_info_t.is_bitfield +ida_ida.idbattr_info_t.is_bitmap +ida_ida.idbattr_info_t.is_boolean +ida_ida.idbattr_info_t.is_buf_var +ida_ida.idbattr_info_t.is_bytearray +ida_ida.idbattr_info_t.is_cstr +ida_ida.idbattr_info_t.is_decimal +ida_ida.idbattr_info_t.is_hash +ida_ida.idbattr_info_t.is_hexadecimal +ida_ida.idbattr_info_t.is_incremented +ida_ida.idbattr_info_t.is_node_altval +ida_ida.idbattr_info_t.is_node_blob +ida_ida.idbattr_info_t.is_node_supval +ida_ida.idbattr_info_t.is_node_valobj +ida_ida.idbattr_info_t.is_node_var +ida_ida.idbattr_info_t.is_onoff +ida_ida.idbattr_info_t.is_qstring +ida_ida.idbattr_info_t.is_readonly_var +ida_ida.idbattr_info_t.is_scalar_var +ida_ida.idbattr_info_t.is_struc_field +ida_ida.idbattr_info_t.is_val_mapped +ida_ida.idbattr_info_t.maxsize +ida_ida.idbattr_info_t.name +ida_ida.idbattr_info_t.offset +ida_ida.idbattr_info_t.ridx +ida_ida.idbattr_info_t.str_false +ida_ida.idbattr_info_t.str_true +ida_ida.idbattr_info_t.tag +ida_ida.idbattr_info_t.use_hlpstruc +ida_ida.idbattr_info_t.vmap +ida_ida.idbattr_info_t.width +ida_ida.idbattr_valmap_t +ida_ida.idbattr_valmap_t.__init__ +ida_ida.inf_abi_set_by_user +ida_ida.inf_allow_non_matched_ops +ida_ida.inf_allow_sigmulti +ida_ida.inf_append_sigcmt +ida_ida.inf_big_arg_align +ida_ida.inf_check_manual_ops +ida_ida.inf_check_unicode_strlits +ida_ida.inf_coagulate_code +ida_ida.inf_coagulate_data +ida_ida.inf_compress_idb +ida_ida.inf_create_all_xrefs +ida_ida.inf_create_func_from_call +ida_ida.inf_create_func_from_ptr +ida_ida.inf_create_func_tails +ida_ida.inf_create_jump_tables +ida_ida.inf_create_off_on_dref +ida_ida.inf_create_off_using_fixup +ida_ida.inf_create_strlit_on_xref +ida_ida.inf_data_offset +ida_ida.inf_dbg_no_store_path +ida_ida.inf_decode_fpp +ida_ida.inf_del_no_xref_insns +ida_ida.inf_final_pass +ida_ida.inf_full_sp_ana +ida_ida.inf_gen_assume +ida_ida.inf_gen_lzero +ida_ida.inf_gen_null +ida_ida.inf_gen_org +ida_ida.inf_gen_tryblks +ida_ida.inf_get_abibits +ida_ida.inf_get_af +ida_ida.inf_get_af2 +ida_ida.inf_get_af2_low +ida_ida.inf_get_af_high +ida_ida.inf_get_af_low +ida_ida.inf_get_app_bitness +ida_ida.inf_get_appcall_options +ida_ida.inf_get_apptype +ida_ida.inf_get_asmtype +ida_ida.inf_get_baseaddr +ida_ida.inf_get_bin_prefix_size +ida_ida.inf_get_cc +ida_ida.inf_get_cc_cm +ida_ida.inf_get_cc_defalign +ida_ida.inf_get_cc_id +ida_ida.inf_get_cc_size_b +ida_ida.inf_get_cc_size_e +ida_ida.inf_get_cc_size_i +ida_ida.inf_get_cc_size_l +ida_ida.inf_get_cc_size_ldbl +ida_ida.inf_get_cc_size_ll +ida_ida.inf_get_cc_size_s +ida_ida.inf_get_cmt_indent +ida_ida.inf_get_cmtflg +ida_ida.inf_get_database_change_count +ida_ida.inf_get_datatypes +ida_ida.inf_get_demname_form +ida_ida.inf_get_demnames +ida_ida.inf_get_filetype +ida_ida.inf_get_genflags +ida_ida.inf_get_highoff +ida_ida.inf_get_indent +ida_ida.inf_get_lenxref +ida_ida.inf_get_lflags +ida_ida.inf_get_limiter +ida_ida.inf_get_listnames +ida_ida.inf_get_long_demnames +ida_ida.inf_get_lowoff +ida_ida.inf_get_main +ida_ida.inf_get_margin +ida_ida.inf_get_max_autoname_len +ida_ida.inf_get_max_ea +ida_ida.inf_get_maxref +ida_ida.inf_get_min_ea +ida_ida.inf_get_nametype +ida_ida.inf_get_netdelta +ida_ida.inf_get_omax_ea +ida_ida.inf_get_omin_ea +ida_ida.inf_get_ostype +ida_ida.inf_get_outflags +ida_ida.inf_get_pack_mode +ida_ida.inf_get_prefflag +ida_ida.inf_get_privrange +ida_ida.inf_get_privrange_end_ea +ida_ida.inf_get_privrange_start_ea +ida_ida.inf_get_procname +ida_ida.inf_get_refcmtnum +ida_ida.inf_get_short_demnames +ida_ida.inf_get_specsegs +ida_ida.inf_get_start_cs +ida_ida.inf_get_start_ea +ida_ida.inf_get_start_ip +ida_ida.inf_get_start_sp +ida_ida.inf_get_start_ss +ida_ida.inf_get_strlit_break +ida_ida.inf_get_strlit_flags +ida_ida.inf_get_strlit_pref +ida_ida.inf_get_strlit_sernum +ida_ida.inf_get_strlit_zeroes +ida_ida.inf_get_strtype +ida_ida.inf_get_type_xrefnum +ida_ida.inf_get_version +ida_ida.inf_get_xrefflag +ida_ida.inf_get_xrefnum +ida_ida.inf_guess_func_type +ida_ida.inf_handle_eh +ida_ida.inf_handle_rtti +ida_ida.inf_hide_comments +ida_ida.inf_hide_libfuncs +ida_ida.inf_huge_arg_align +ida_ida.inf_inc_database_change_count +ida_ida.inf_is_16bit +ida_ida.inf_is_32bit_exactly +ida_ida.inf_is_32bit_or_higher +ida_ida.inf_is_64bit +ida_ida.inf_is_auto_enabled +ida_ida.inf_is_be +ida_ida.inf_is_dll +ida_ida.inf_is_flat_off32 +ida_ida.inf_is_graph_view +ida_ida.inf_is_hard_float +ida_ida.inf_is_ilp32 +ida_ida.inf_is_kernel_mode +ida_ida.inf_is_limiter_empty +ida_ida.inf_is_limiter_thick +ida_ida.inf_is_limiter_thin +ida_ida.inf_is_mem_aligned4 +ida_ida.inf_is_snapshot +ida_ida.inf_is_wide_high_byte_first +ida_ida.inf_like_binary +ida_ida.inf_line_pref_with_seg +ida_ida.inf_loading_idc +ida_ida.inf_macros_enabled +ida_ida.inf_map_stkargs +ida_ida.inf_mark_code +ida_ida.inf_merge_strlits +ida_ida.inf_no_store_user_info +ida_ida.inf_noflow_to_data +ida_ida.inf_noret_ana +ida_ida.inf_op_offset +ida_ida.inf_pack_idb +ida_ida.inf_pack_stkargs +ida_ida.inf_postinc_strlit_sernum +ida_ida.inf_prefix_show_funcoff +ida_ida.inf_prefix_show_segaddr +ida_ida.inf_prefix_show_stack +ida_ida.inf_prefix_truncate_opcode_bytes +ida_ida.inf_propagate_regargs +ida_ida.inf_propagate_stkargs +ida_ida.inf_readonly_idb +ida_ida.inf_rename_jumpfunc +ida_ida.inf_rename_nullsub +ida_ida.inf_set_32bit +ida_ida.inf_set_64bit +ida_ida.inf_set_abi_set_by_user +ida_ida.inf_set_abibits +ida_ida.inf_set_af +ida_ida.inf_set_af2 +ida_ida.inf_set_af2_low +ida_ida.inf_set_af_high +ida_ida.inf_set_af_low +ida_ida.inf_set_allow_non_matched_ops +ida_ida.inf_set_allow_sigmulti +ida_ida.inf_set_app_bitness +ida_ida.inf_set_appcall_options +ida_ida.inf_set_append_sigcmt +ida_ida.inf_set_apptype +ida_ida.inf_set_asmtype +ida_ida.inf_set_auto_enabled +ida_ida.inf_set_baseaddr +ida_ida.inf_set_be +ida_ida.inf_set_big_arg_align +ida_ida.inf_set_bin_prefix_size +ida_ida.inf_set_cc +ida_ida.inf_set_cc_cm +ida_ida.inf_set_cc_defalign +ida_ida.inf_set_cc_id +ida_ida.inf_set_cc_size_b +ida_ida.inf_set_cc_size_e +ida_ida.inf_set_cc_size_i +ida_ida.inf_set_cc_size_l +ida_ida.inf_set_cc_size_ldbl +ida_ida.inf_set_cc_size_ll +ida_ida.inf_set_cc_size_s +ida_ida.inf_set_check_manual_ops +ida_ida.inf_set_check_unicode_strlits +ida_ida.inf_set_cmt_indent +ida_ida.inf_set_cmtflg +ida_ida.inf_set_coagulate_code +ida_ida.inf_set_coagulate_data +ida_ida.inf_set_compress_idb +ida_ida.inf_set_create_all_xrefs +ida_ida.inf_set_create_func_from_call +ida_ida.inf_set_create_func_from_ptr +ida_ida.inf_set_create_func_tails +ida_ida.inf_set_create_jump_tables +ida_ida.inf_set_create_off_on_dref +ida_ida.inf_set_create_off_using_fixup +ida_ida.inf_set_create_strlit_on_xref +ida_ida.inf_set_data_offset +ida_ida.inf_set_database_change_count +ida_ida.inf_set_datatypes +ida_ida.inf_set_dbg_no_store_path +ida_ida.inf_set_decode_fpp +ida_ida.inf_set_del_no_xref_insns +ida_ida.inf_set_demnames +ida_ida.inf_set_dll +ida_ida.inf_set_filetype +ida_ida.inf_set_final_pass +ida_ida.inf_set_flat_off32 +ida_ida.inf_set_full_sp_ana +ida_ida.inf_set_gen_assume +ida_ida.inf_set_gen_lzero +ida_ida.inf_set_gen_null +ida_ida.inf_set_gen_org +ida_ida.inf_set_gen_tryblks +ida_ida.inf_set_genflags +ida_ida.inf_set_graph_view +ida_ida.inf_set_guess_func_type +ida_ida.inf_set_handle_eh +ida_ida.inf_set_handle_rtti +ida_ida.inf_set_hard_float +ida_ida.inf_set_hide_comments +ida_ida.inf_set_hide_libfuncs +ida_ida.inf_set_highoff +ida_ida.inf_set_huge_arg_align +ida_ida.inf_set_ilp32 +ida_ida.inf_set_indent +ida_ida.inf_set_kernel_mode +ida_ida.inf_set_lenxref +ida_ida.inf_set_lflags +ida_ida.inf_set_limiter +ida_ida.inf_set_limiter_empty +ida_ida.inf_set_limiter_thick +ida_ida.inf_set_limiter_thin +ida_ida.inf_set_line_pref_with_seg +ida_ida.inf_set_listnames +ida_ida.inf_set_loading_idc +ida_ida.inf_set_long_demnames +ida_ida.inf_set_lowoff +ida_ida.inf_set_macros_enabled +ida_ida.inf_set_main +ida_ida.inf_set_map_stkargs +ida_ida.inf_set_margin +ida_ida.inf_set_mark_code +ida_ida.inf_set_max_autoname_len +ida_ida.inf_set_max_ea +ida_ida.inf_set_maxref +ida_ida.inf_set_mem_aligned4 +ida_ida.inf_set_merge_strlits +ida_ida.inf_set_min_ea +ida_ida.inf_set_nametype +ida_ida.inf_set_netdelta +ida_ida.inf_set_no_store_user_info +ida_ida.inf_set_noflow_to_data +ida_ida.inf_set_noret_ana +ida_ida.inf_set_omax_ea +ida_ida.inf_set_omin_ea +ida_ida.inf_set_op_offset +ida_ida.inf_set_ostype +ida_ida.inf_set_outflags +ida_ida.inf_set_pack_idb +ida_ida.inf_set_pack_mode +ida_ida.inf_set_pack_stkargs +ida_ida.inf_set_prefflag +ida_ida.inf_set_prefix_show_funcoff +ida_ida.inf_set_prefix_show_segaddr +ida_ida.inf_set_prefix_show_stack +ida_ida.inf_set_prefix_truncate_opcode_bytes +ida_ida.inf_set_privrange +ida_ida.inf_set_privrange_end_ea +ida_ida.inf_set_privrange_start_ea +ida_ida.inf_set_procname +ida_ida.inf_set_propagate_regargs +ida_ida.inf_set_propagate_stkargs +ida_ida.inf_set_readonly_idb +ida_ida.inf_set_refcmtnum +ida_ida.inf_set_rename_jumpfunc +ida_ida.inf_set_rename_nullsub +ida_ida.inf_set_short_demnames +ida_ida.inf_set_should_create_stkvars +ida_ida.inf_set_should_trace_sp +ida_ida.inf_set_show_all_comments +ida_ida.inf_set_show_auto +ida_ida.inf_set_show_hidden_funcs +ida_ida.inf_set_show_hidden_insns +ida_ida.inf_set_show_hidden_segms +ida_ida.inf_set_show_line_pref +ida_ida.inf_set_show_repeatables +ida_ida.inf_set_show_src_linnum +ida_ida.inf_set_show_void +ida_ida.inf_set_show_xref_fncoff +ida_ida.inf_set_show_xref_seg +ida_ida.inf_set_show_xref_tmarks +ida_ida.inf_set_show_xref_val +ida_ida.inf_set_snapshot +ida_ida.inf_set_specsegs +ida_ida.inf_set_stack_ldbl +ida_ida.inf_set_stack_varargs +ida_ida.inf_set_start_cs +ida_ida.inf_set_start_ea +ida_ida.inf_set_start_ip +ida_ida.inf_set_start_sp +ida_ida.inf_set_start_ss +ida_ida.inf_set_strlit_autocmt +ida_ida.inf_set_strlit_break +ida_ida.inf_set_strlit_flags +ida_ida.inf_set_strlit_name_bit +ida_ida.inf_set_strlit_names +ida_ida.inf_set_strlit_pref +ida_ida.inf_set_strlit_savecase +ida_ida.inf_set_strlit_serial_names +ida_ida.inf_set_strlit_sernum +ida_ida.inf_set_strlit_zeroes +ida_ida.inf_set_strtype +ida_ida.inf_set_trace_flow +ida_ida.inf_set_truncate_on_del +ida_ida.inf_set_type_xrefnum +ida_ida.inf_set_unicode_strlits +ida_ida.inf_set_use_allasm +ida_ida.inf_set_use_flirt +ida_ida.inf_set_use_gcc_layout +ida_ida.inf_set_version +ida_ida.inf_set_wide_high_byte_first +ida_ida.inf_set_xrefflag +ida_ida.inf_set_xrefnum +ida_ida.inf_should_create_stkvars +ida_ida.inf_should_trace_sp +ida_ida.inf_show_all_comments +ida_ida.inf_show_auto +ida_ida.inf_show_hidden_funcs +ida_ida.inf_show_hidden_insns +ida_ida.inf_show_hidden_segms +ida_ida.inf_show_line_pref +ida_ida.inf_show_repeatables +ida_ida.inf_show_src_linnum +ida_ida.inf_show_void +ida_ida.inf_show_xref_fncoff +ida_ida.inf_show_xref_seg +ida_ida.inf_show_xref_tmarks +ida_ida.inf_show_xref_val +ida_ida.inf_stack_ldbl +ida_ida.inf_stack_varargs +ida_ida.inf_strlit_autocmt +ida_ida.inf_strlit_name_bit +ida_ida.inf_strlit_names +ida_ida.inf_strlit_savecase +ida_ida.inf_strlit_serial_names +ida_ida.inf_test_mode +ida_ida.inf_trace_flow +ida_ida.inf_truncate_on_del +ida_ida.inf_unicode_strlits +ida_ida.inf_use_allasm +ida_ida.inf_use_flirt +ida_ida.inf_use_gcc_layout +ida_ida.is_database_busy +ida_ida.is_filetype_like_binary +ida_ida.move_privrange +ida_ida.switch_dbctx +ida_ida.to_ea +ida_ida.validate_idb +ida_idaapi +ida_idaapi.IDAPython_ExecScript +ida_idaapi.IDAPython_ExecSystem +ida_idaapi.IDAPython_FormatExc +ida_idaapi.IDAPython_GetDocstrings +ida_idaapi.IDAPython_GetDocstrings._dedent +ida_idaapi.IDAPython_GetDocstrings._nodes +ida_idaapi.IDAPython_GetDocstrings._nodes_iter +ida_idaapi.IDAPython_GetDocstrings._pairwise_longest +ida_idaapi.IDAPython_GetDocstrings._walk_tree +ida_idaapi.IDAPython_LoadProcMod +ida_idaapi.IDAPython_UnLoadProcMod +ida_idaapi.IDAPython_displayhook +ida_idaapi.IDAPython_displayhook.__init__ +ida_idaapi.IDAPython_displayhook._print_hex +ida_idaapi.IDAPython_displayhook.displayhook +ida_idaapi.IDAPython_displayhook.displayhook_format +ida_idaapi.IDAPython_displayhook.format_item +ida_idaapi.IDAPython_displayhook.format_seq +ida_idaapi.NW_CLOSEIDB +ida_idaapi.NW_INITIDA +ida_idaapi.NW_OPENIDB +ida_idaapi.NW_REMOVE +ida_idaapi.NW_TERMIDA +ida_idaapi.PY_ICID_BYREF +ida_idaapi.PY_ICID_INT64 +ida_idaapi.PY_ICID_OPAQUE +ida_idaapi.PyIdc_cvt_int64__ +ida_idaapi.PyIdc_cvt_int64__.__add__ +ida_idaapi.PyIdc_cvt_int64__.__div__ +ida_idaapi.PyIdc_cvt_int64__.__init__ +ida_idaapi.PyIdc_cvt_int64__.__mul__ +ida_idaapi.PyIdc_cvt_int64__.__op +ida_idaapi.PyIdc_cvt_int64__.__radd__ +ida_idaapi.PyIdc_cvt_int64__.__rdiv__ +ida_idaapi.PyIdc_cvt_int64__.__rmul__ +ida_idaapi.PyIdc_cvt_int64__.__rsub__ +ida_idaapi.PyIdc_cvt_int64__.__sub__ +ida_idaapi.PyIdc_cvt_refclass__ +ida_idaapi.PyIdc_cvt_refclass__.__init__ +ida_idaapi.PyIdc_cvt_refclass__.cstr +ida_idaapi.ST_OVER_DEBUG_SEG +ida_idaapi.ST_OVER_LIB_FUNC +ida_idaapi.TRUNC +ida_idaapi.__IDAPython_Completion_Util +ida_idaapi.__IDAPython_Completion_Util.__call__ +ida_idaapi.__IDAPython_Completion_Util.__init__ +ida_idaapi.__IDAPython_Completion_Util.__parse_arg +ida_idaapi.__IDAPython_Completion_Util.__proto_from_argspec +ida_idaapi.__IDAPython_Completion_Util.__proto_from_argspec.__repr_type +ida_idaapi.__IDAPython_Completion_Util.__proto_from_docstring +ida_idaapi.__IDAPython_Completion_Util.__render_args +ida_idaapi.__IDAPython_Completion_Util.__render_constant +ida_idaapi.__IDAPython_Completion_Util.__render_default +ida_idaapi.__IDAPython_Completion_Util.__render_docstr +ida_idaapi.__IDAPython_Completion_Util.__render_int_member +ida_idaapi.__IDAPython_Completion_Util.__render_proto +ida_idaapi.__IDAPython_Completion_Util.__render_rets +ida_idaapi.__IDAPython_Completion_Util.__resolve_type +ida_idaapi.__IDAPython_Completion_Util.build_hints +ida_idaapi.__IDAPython_Completion_Util.debug +ida_idaapi.__IDAPython_Completion_Util.dir_namespace +ida_idaapi.__IDAPython_Completion_Util.get_candidates +ida_idaapi.__IDAPython_Completion_Util.maybe_extend_syntactically +ida_idaapi.__install_excepthook +ida_idaapi._bounded_getitem_iterator +ida_idaapi._listify_types +ida_idaapi._make_missed_695bwcompat_property +ida_idaapi._make_missed_695bwcompat_property._getter +ida_idaapi._make_missed_695bwcompat_property._setter +ida_idaapi._make_one_time_warning_message +ida_idaapi._make_one_time_warning_message.f +ida_idaapi._qvector_back +ida_idaapi._qvector_front +ida_idaapi._replace_module_function +ida_idaapi.as_UTF16 +ida_idaapi.as_cstr +ida_idaapi.as_int32 +ida_idaapi.as_signed +ida_idaapi.as_uint32 +ida_idaapi.copy_bits +ida_idaapi.disable_script_timeout +ida_idaapi.enable_extlang_python +ida_idaapi.enable_python_cli +ida_idaapi.format_basestring +ida_idaapi.loader_input_t +ida_idaapi.loader_input_t.__init__ +ida_idaapi.loader_input_t.close +ida_idaapi.loader_input_t.file2base +ida_idaapi.loader_input_t.filename +ida_idaapi.loader_input_t.from_capsule +ida_idaapi.loader_input_t.from_fp +ida_idaapi.loader_input_t.from_linput +ida_idaapi.loader_input_t.get_byte +ida_idaapi.loader_input_t.get_linput +ida_idaapi.loader_input_t.gets +ida_idaapi.loader_input_t.getz +ida_idaapi.loader_input_t.open +ida_idaapi.loader_input_t.open_memory +ida_idaapi.loader_input_t.opened +ida_idaapi.loader_input_t.read +ida_idaapi.loader_input_t.readbytes +ida_idaapi.loader_input_t.seek +ida_idaapi.loader_input_t.set_linput +ida_idaapi.loader_input_t.size +ida_idaapi.loader_input_t.tell +ida_idaapi.notify_when +ida_idaapi.object_t +ida_idaapi.object_t.__getitem__ +ida_idaapi.object_t.__init__ +ida_idaapi.parse_command_line3 +ida_idaapi.plugin_t +ida_idaapi.plugin_t.run +ida_idaapi.plugin_t.term +ida_idaapi.plugmod_t +ida_idaapi.py_clinked_object_t +ida_idaapi.py_clinked_object_t.__del__ +ida_idaapi.py_clinked_object_t.__init__ +ida_idaapi.py_clinked_object_t._create_clink +ida_idaapi.py_clinked_object_t._del_clink +ida_idaapi.py_clinked_object_t._free +ida_idaapi.py_clinked_object_t._get_clink_ptr +ida_idaapi.py_clinked_object_t.assign +ida_idaapi.py_clinked_object_t.clink +ida_idaapi.py_clinked_object_t.clink_ptr +ida_idaapi.py_clinked_object_t.copy +ida_idaapi.pycim_get_widget +ida_idaapi.pycim_view_close +ida_idaapi.pygc_create_groups +ida_idaapi.pygc_delete_groups +ida_idaapi.pygc_refresh +ida_idaapi.pygc_set_groups_visibility +ida_idaapi.pyidc_cvt_helper__ +ida_idaapi.pyidc_cvt_helper__.__get_value +ida_idaapi.pyidc_cvt_helper__.__init__ +ida_idaapi.pyidc_cvt_helper__.__set_value +ida_idaapi.pyidc_opaque_object_t +ida_idaapi.replfun +ida_idaapi.require +ida_idaapi.set_script_timeout +ida_idaapi.struct_unpack +ida_idc +ida_idc.get_mark_comment +ida_idc.get_marked_pos +ida_idc.mark_position +ida_idd +ida_idd.APPCALL_DEBEV +ida_idd.APPCALL_MANUAL +ida_idd.APPCALL_TIMEOUT +ida_idd.Appcall__ +ida_idd.Appcall__.APPCALL_DEBEV +ida_idd.Appcall__.APPCALL_MANUAL +ida_idd.Appcall__.APPCALL_TIMEOUT +ida_idd.Appcall__.Consts +ida_idd.Appcall__.UTF16 +ida_idd.Appcall__.__get_consts +ida_idd.Appcall__.__getattr__ +ida_idd.Appcall__.__getitem__ +ida_idd.Appcall__.__init__ +ida_idd.Appcall__.__name_or_ea +ida_idd.Appcall__.__typedecl_or_tinfo +ida_idd.Appcall__.array +ida_idd.Appcall__.buffer +ida_idd.Appcall__.byref +ida_idd.Appcall__.cleanup_appcall +ida_idd.Appcall__.cstr +ida_idd.Appcall__.get_appcall_options +ida_idd.Appcall__.int64 +ida_idd.Appcall__.obj +ida_idd.Appcall__.proto +ida_idd.Appcall__.set_appcall_options +ida_idd.Appcall__.typedobj +ida_idd.Appcall__.valueof +ida_idd.Appcall_array__ +ida_idd.Appcall_array__.__init__ +ida_idd.Appcall_array__.pack +ida_idd.Appcall_array__.try_to_convert_to_list +ida_idd.Appcall_array__.unpack +ida_idd.Appcall_callable__ +ida_idd.Appcall_callable__.__call__ +ida_idd.Appcall_callable__.__get_ea +ida_idd.Appcall_callable__.__get_fields +ida_idd.Appcall_callable__.__get_options +ida_idd.Appcall_callable__.__get_size +ida_idd.Appcall_callable__.__get_tif +ida_idd.Appcall_callable__.__get_timeout +ida_idd.Appcall_callable__.__get_type +ida_idd.Appcall_callable__.__init__ +ida_idd.Appcall_callable__.__set_ea +ida_idd.Appcall_callable__.__set_options +ida_idd.Appcall_callable__.__set_timeout +ida_idd.Appcall_callable__.ea +ida_idd.Appcall_callable__.fields +ida_idd.Appcall_callable__.options +ida_idd.Appcall_callable__.retrieve +ida_idd.Appcall_callable__.size +ida_idd.Appcall_callable__.store +ida_idd.Appcall_callable__.tif +ida_idd.Appcall_callable__.timeout +ida_idd.Appcall_callable__.type +ida_idd.Appcall_consts__ +ida_idd.Appcall_consts__.__getattr__ +ida_idd.Appcall_consts__.__init__ +ida_idd.BBLK_TRACE +ida_idd.BITNESS_CHANGED +ida_idd.BPT_BAD_ADDR +ida_idd.BPT_BAD_ALIGN +ida_idd.BPT_BAD_LEN +ida_idd.BPT_BAD_TYPE +ida_idd.BPT_DEFAULT +ida_idd.BPT_EXEC +ida_idd.BPT_INTERNAL_ERR +ida_idd.BPT_OK +ida_idd.BPT_PAGE_OK +ida_idd.BPT_RDWR +ida_idd.BPT_READ +ida_idd.BPT_READ_ERROR +ida_idd.BPT_SKIP +ida_idd.BPT_SOFT +ida_idd.BPT_TOO_MANY +ida_idd.BPT_WRITE +ida_idd.BPT_WRITE_ERROR +ida_idd.BREAKPOINT +ida_idd.DBG_FLAG_ADD_ENVS +ida_idd.DBG_FLAG_ANYSIZE_HWBPT +ida_idd.DBG_FLAG_CAN_CONT_BPT +ida_idd.DBG_FLAG_CLEAN_EXIT +ida_idd.DBG_FLAG_CONNSTRING +ida_idd.DBG_FLAG_DEBTHREAD +ida_idd.DBG_FLAG_DEBUG_DLL +ida_idd.DBG_FLAG_DISABLE_ASLR +ida_idd.DBG_FLAG_DONT_DISTURB +ida_idd.DBG_FLAG_EXITSHOTOK +ida_idd.DBG_FLAG_FAKE_ATTACH +ida_idd.DBG_FLAG_FAKE_MEMORY +ida_idd.DBG_FLAG_FAST_STEP +ida_idd.DBG_FLAG_FULL_INSTR_BPT +ida_idd.DBG_FLAG_HWDATBPT_ONE +ida_idd.DBG_FLAG_LAZY_WATCHPTS +ida_idd.DBG_FLAG_LOWCNDS +ida_idd.DBG_FLAG_MANMEMINFO +ida_idd.DBG_FLAG_MERGE_ENVS +ida_idd.DBG_FLAG_NEEDPORT +ida_idd.DBG_FLAG_NOHOST +ida_idd.DBG_FLAG_NOPARAMETERS +ida_idd.DBG_FLAG_NOPASSWORD +ida_idd.DBG_FLAG_NOSTARTDIR +ida_idd.DBG_FLAG_PREFER_SWBPTS +ida_idd.DBG_FLAG_REMOTE +ida_idd.DBG_FLAG_SAFE +ida_idd.DBG_FLAG_SMALLBLKS +ida_idd.DBG_FLAG_TRACER_MODULE +ida_idd.DBG_FLAG_TTD +ida_idd.DBG_FLAG_USE_SREGS +ida_idd.DBG_FLAG_VIRTHREADS +ida_idd.DBG_HAS_APPCALL +ida_idd.DBG_HAS_ATTACH_PROCESS +ida_idd.DBG_HAS_CHECK_BPT +ida_idd.DBG_HAS_DETACH_PROCESS +ida_idd.DBG_HAS_GET_PROCESSES +ida_idd.DBG_HAS_MAP_ADDRESS +ida_idd.DBG_HAS_OPEN_FILE +ida_idd.DBG_HAS_REQUEST_PAUSE +ida_idd.DBG_HAS_REXEC +ida_idd.DBG_HAS_SET_EXCEPTION_INFO +ida_idd.DBG_HAS_SET_RESUME_MODE +ida_idd.DBG_HAS_THREAD_CONTINUE +ida_idd.DBG_HAS_THREAD_GET_SREG_BASE +ida_idd.DBG_HAS_THREAD_SUSPEND +ida_idd.DBG_HAS_UPDATE_CALL_STACK +ida_idd.DBG_HIDE_WINDOW +ida_idd.DBG_NO_ASLR +ida_idd.DBG_NO_TRACE +ida_idd.DBG_PROC_32BIT +ida_idd.DBG_PROC_64BIT +ida_idd.DBG_PROC_IS_DLL +ida_idd.DBG_PROC_IS_GUI +ida_idd.DBG_RESMOD_STEP_BACKINTO +ida_idd.DBG_RESMOD_STEP_HANDLE +ida_idd.DBG_RESMOD_STEP_INTO +ida_idd.DBG_RESMOD_STEP_OUT +ida_idd.DBG_RESMOD_STEP_OVER +ida_idd.DBG_RESMOD_STEP_SRCINTO +ida_idd.DBG_RESMOD_STEP_SRCOUT +ida_idd.DBG_RESMOD_STEP_SRCOVER +ida_idd.DBG_RESMOD_STEP_USER +ida_idd.DBG_SUSPENDED +ida_idd.DEBUGGER_ID_6811_EMULATOR +ida_idd.DEBUGGER_ID_ARM_IPHONE_USER +ida_idd.DEBUGGER_ID_ARM_LINUX_USER +ida_idd.DEBUGGER_ID_ARM_MACOS_USER +ida_idd.DEBUGGER_ID_DALVIK_USER +ida_idd.DEBUGGER_ID_GDB_USER +ida_idd.DEBUGGER_ID_TRACE_REPLAYER +ida_idd.DEBUGGER_ID_WINDBG +ida_idd.DEBUGGER_ID_X86_DOSBOX_EMULATOR +ida_idd.DEBUGGER_ID_X86_IA32_BOCHS +ida_idd.DEBUGGER_ID_X86_IA32_LINUX_USER +ida_idd.DEBUGGER_ID_X86_IA32_MACOSX_USER +ida_idd.DEBUGGER_ID_X86_IA32_WIN32_USER +ida_idd.DEBUGGER_ID_X86_PIN_TRACER +ida_idd.DEBUGGER_ID_XNU_USER +ida_idd.DRC_CRC +ida_idd.DRC_ERROR +ida_idd.DRC_EVENTS +ida_idd.DRC_FAILED +ida_idd.DRC_IDBSEG +ida_idd.DRC_NETERR +ida_idd.DRC_NOCHG +ida_idd.DRC_NOFILE +ida_idd.DRC_NONE +ida_idd.DRC_NOPROC +ida_idd.DRC_OK +ida_idd.EXCEPTION +ida_idd.EXC_BREAK +ida_idd.EXC_HANDLE +ida_idd.EXC_MSG +ida_idd.EXC_SILENT +ida_idd.FUNC_TRACE +ida_idd.IDD_INTERFACE_VERSION +ida_idd.INFORMATION +ida_idd.INSN_TRACE +ida_idd.LIB_LOADED +ida_idd.LIB_UNLOADED +ida_idd.NO_EVENT +ida_idd.NO_PROCESS +ida_idd.NO_THREAD +ida_idd.NO_THREAD +ida_idd.PROCESS_ATTACHED +ida_idd.PROCESS_DETACHED +ida_idd.PROCESS_EXITED +ida_idd.PROCESS_STARTED +ida_idd.PROCESS_SUSPENDED +ida_idd.REGISTER_ADDRESS +ida_idd.REGISTER_CS +ida_idd.REGISTER_CUSTFMT +ida_idd.REGISTER_FP +ida_idd.REGISTER_IP +ida_idd.REGISTER_NOLF +ida_idd.REGISTER_READONLY +ida_idd.REGISTER_SP +ida_idd.REGISTER_SS +ida_idd.RESMOD_BACKINTO +ida_idd.RESMOD_HANDLE +ida_idd.RESMOD_INTO +ida_idd.RESMOD_NONE +ida_idd.RESMOD_OUT +ida_idd.RESMOD_OVER +ida_idd.RESMOD_SRCINTO +ida_idd.RESMOD_SRCOUT +ida_idd.RESMOD_SRCOVER +ida_idd.RESMOD_USER +ida_idd.RQ_IDAIDLE +ida_idd.RQ_IGNWERR +ida_idd.RQ_MASKING +ida_idd.RQ_NOSUSP +ida_idd.RQ_PROCEXIT +ida_idd.RQ_RESMOD +ida_idd.RQ_RESUME +ida_idd.RQ_SILENT +ida_idd.RQ_SUSPEND +ida_idd.RQ_SUSPRUN +ida_idd.RQ_SWSCREEN +ida_idd.RQ_VERBOSE +ida_idd.RQ__NOTHRRF +ida_idd.RVT_FLOAT +ida_idd.RVT_INT +ida_idd.RVT_UNAVAILABLE +ida_idd.STATUS_MASK +ida_idd.STEP +ida_idd.STEP_TRACE +ida_idd.THREAD_EXITED +ida_idd.THREAD_STARTED +ida_idd.TRACE_FULL +ida_idd.appcall +ida_idd.bptaddr_t +ida_idd.bptaddr_t.__init__ +ida_idd.bptaddr_t.hea +ida_idd.bptaddr_t.kea +ida_idd.call_stack_info_t +ida_idd.call_stack_info_t.__eq__ +ida_idd.call_stack_info_t.__init__ +ida_idd.call_stack_info_t.__ne__ +ida_idd.call_stack_info_t.callea +ida_idd.call_stack_info_t.fp +ida_idd.call_stack_info_t.funcea +ida_idd.call_stack_info_t.funcok +ida_idd.call_stack_info_vec_t +ida_idd.call_stack_info_vec_t.__eq__ +ida_idd.call_stack_info_vec_t.__getitem__ +ida_idd.call_stack_info_vec_t.__init__ +ida_idd.call_stack_info_vec_t.__len__ +ida_idd.call_stack_info_vec_t.__ne__ +ida_idd.call_stack_info_vec_t.__setitem__ +ida_idd.call_stack_info_vec_t._del +ida_idd.call_stack_info_vec_t.add_unique +ida_idd.call_stack_info_vec_t.append +ida_idd.call_stack_info_vec_t.at +ida_idd.call_stack_info_vec_t.begin +ida_idd.call_stack_info_vec_t.capacity +ida_idd.call_stack_info_vec_t.clear +ida_idd.call_stack_info_vec_t.empty +ida_idd.call_stack_info_vec_t.end +ida_idd.call_stack_info_vec_t.erase +ida_idd.call_stack_info_vec_t.extend +ida_idd.call_stack_info_vec_t.extract +ida_idd.call_stack_info_vec_t.find +ida_idd.call_stack_info_vec_t.grow +ida_idd.call_stack_info_vec_t.has +ida_idd.call_stack_info_vec_t.inject +ida_idd.call_stack_info_vec_t.insert +ida_idd.call_stack_info_vec_t.pop_back +ida_idd.call_stack_info_vec_t.push_back +ida_idd.call_stack_info_vec_t.qclear +ida_idd.call_stack_info_vec_t.reserve +ida_idd.call_stack_info_vec_t.resize +ida_idd.call_stack_info_vec_t.size +ida_idd.call_stack_info_vec_t.swap +ida_idd.call_stack_info_vec_t.truncate +ida_idd.call_stack_t +ida_idd.call_stack_t.__init__ +ida_idd.can_exc_continue +ida_idd.cleanup_appcall +ida_idd.cpu2ieee +ida_idd.dbg_appcall +ida_idd.dbg_get_memory_info +ida_idd.dbg_get_name +ida_idd.dbg_get_registers +ida_idd.dbg_get_thread_sreg_base +ida_idd.dbg_read_memory +ida_idd.dbg_write_memory +ida_idd.debapp_attrs_t +ida_idd.debapp_attrs_t.__init__ +ida_idd.debapp_attrs_t.addrsize +ida_idd.debapp_attrs_t.cbsize +ida_idd.debapp_attrs_t.platform +ida_idd.debug_event_t +ida_idd.debug_event_t.__init__ +ida_idd.debug_event_t.bpt +ida_idd.debug_event_t.bpt_ea +ida_idd.debug_event_t.clear +ida_idd.debug_event_t.clear_all +ida_idd.debug_event_t.copy +ida_idd.debug_event_t.ea +ida_idd.debug_event_t.eid +ida_idd.debug_event_t.exc +ida_idd.debug_event_t.exit_code +ida_idd.debug_event_t.handled +ida_idd.debug_event_t.info +ida_idd.debug_event_t.is_bitness_changed +ida_idd.debug_event_t.modinfo +ida_idd.debug_event_t.pid +ida_idd.debug_event_t.set_bitness_changed +ida_idd.debug_event_t.set_bpt +ida_idd.debug_event_t.set_eid +ida_idd.debug_event_t.set_exception +ida_idd.debug_event_t.set_exit_code +ida_idd.debug_event_t.set_info +ida_idd.debug_event_t.set_modinfo +ida_idd.debug_event_t.tid +ida_idd.debugger_t +ida_idd.debugger_t.__get_bpt_bytes +ida_idd.debugger_t.__get_nregisters +ida_idd.debugger_t.__get_regclasses +ida_idd.debugger_t.__get_registers +ida_idd.debugger_t.__init__ +ida_idd.debugger_t.attach_process +ida_idd.debugger_t.bin_search +ida_idd.debugger_t.bpt_bytes +ida_idd.debugger_t.bpt_size +ida_idd.debugger_t.cache_block_size +ida_idd.debugger_t.can_continue_from_bpt +ida_idd.debugger_t.can_debug_standalone_dlls +ida_idd.debugger_t.check_bpt +ida_idd.debugger_t.cleanup_appcall +ida_idd.debugger_t.close_file +ida_idd.debugger_t.dbg_enable_trace +ida_idd.debugger_t.default_regclasses +ida_idd.debugger_t.detach_process +ida_idd.debugger_t.ev_appcall +ida_idd.debugger_t.ev_attach_process +ida_idd.debugger_t.ev_bin_search +ida_idd.debugger_t.ev_check_bpt +ida_idd.debugger_t.ev_cleanup_appcall +ida_idd.debugger_t.ev_dbg_enable_trace +ida_idd.debugger_t.ev_detach_process +ida_idd.debugger_t.ev_eval_lowcnd +ida_idd.debugger_t.ev_exit_process +ida_idd.debugger_t.ev_get_debapp_attrs +ida_idd.debugger_t.ev_get_debmod_extensions +ida_idd.debugger_t.ev_get_debug_event +ida_idd.debugger_t.ev_get_dynamic_register_set +ida_idd.debugger_t.ev_get_memory_info +ida_idd.debugger_t.ev_get_processes +ida_idd.debugger_t.ev_get_srcinfo_path +ida_idd.debugger_t.ev_init_debugger +ida_idd.debugger_t.ev_is_tracing_enabled +ida_idd.debugger_t.ev_map_address +ida_idd.debugger_t.ev_read_memory +ida_idd.debugger_t.ev_read_registers +ida_idd.debugger_t.ev_rebase_if_required_to +ida_idd.debugger_t.ev_request_pause +ida_idd.debugger_t.ev_resume +ida_idd.debugger_t.ev_rexec +ida_idd.debugger_t.ev_send_ioctl +ida_idd.debugger_t.ev_set_backwards +ida_idd.debugger_t.ev_set_dbg_options +ida_idd.debugger_t.ev_set_exception_info +ida_idd.debugger_t.ev_set_resume_mode +ida_idd.debugger_t.ev_start_process +ida_idd.debugger_t.ev_suspended +ida_idd.debugger_t.ev_term_debugger +ida_idd.debugger_t.ev_thread_continue +ida_idd.debugger_t.ev_thread_get_sreg_base +ida_idd.debugger_t.ev_thread_suspend +ida_idd.debugger_t.ev_update_bpts +ida_idd.debugger_t.ev_update_call_stack +ida_idd.debugger_t.ev_update_lowcnds +ida_idd.debugger_t.ev_write_memory +ida_idd.debugger_t.ev_write_register +ida_idd.debugger_t.eval_lowcnd +ida_idd.debugger_t.exit_process +ida_idd.debugger_t.fake_memory +ida_idd.debugger_t.filetype +ida_idd.debugger_t.get_debapp_attrs +ida_idd.debugger_t.get_debmod_extensions +ida_idd.debugger_t.get_debug_event +ida_idd.debugger_t.get_dynamic_register_set +ida_idd.debugger_t.get_memory_info +ida_idd.debugger_t.get_processes +ida_idd.debugger_t.get_srcinfo_path +ida_idd.debugger_t.has_appcall +ida_idd.debugger_t.has_attach_process +ida_idd.debugger_t.has_check_bpt +ida_idd.debugger_t.has_detach_process +ida_idd.debugger_t.has_get_processes +ida_idd.debugger_t.has_map_address +ida_idd.debugger_t.has_open_file +ida_idd.debugger_t.has_request_pause +ida_idd.debugger_t.has_rexec +ida_idd.debugger_t.has_set_exception_info +ida_idd.debugger_t.has_set_resume_mode +ida_idd.debugger_t.has_soft_bpt +ida_idd.debugger_t.has_thread_continue +ida_idd.debugger_t.has_thread_get_sreg_base +ida_idd.debugger_t.has_thread_suspend +ida_idd.debugger_t.has_update_call_stack +ida_idd.debugger_t.have_set_options +ida_idd.debugger_t.id +ida_idd.debugger_t.init_debugger +ida_idd.debugger_t.is_remote +ida_idd.debugger_t.is_resmod_avail +ida_idd.debugger_t.is_safe +ida_idd.debugger_t.is_tracing_enabled +ida_idd.debugger_t.is_ttd +ida_idd.debugger_t.map_address +ida_idd.debugger_t.may_disturb +ida_idd.debugger_t.may_take_exit_snapshot +ida_idd.debugger_t.memory_page_size +ida_idd.debugger_t.must_have_hostname +ida_idd.debugger_t.name +ida_idd.debugger_t.nregisters +ida_idd.debugger_t.open_file +ida_idd.debugger_t.processor +ida_idd.debugger_t.read_file +ida_idd.debugger_t.read_memory +ida_idd.debugger_t.read_registers +ida_idd.debugger_t.rebase_if_required_to +ida_idd.debugger_t.regclasses +ida_idd.debugger_t.registers +ida_idd.debugger_t.regs +ida_idd.debugger_t.request_pause +ida_idd.debugger_t.resume +ida_idd.debugger_t.resume_modes +ida_idd.debugger_t.rexec +ida_idd.debugger_t.send_ioctl +ida_idd.debugger_t.set_backwards +ida_idd.debugger_t.set_exception_info +ida_idd.debugger_t.set_resume_mode +ida_idd.debugger_t.start_process +ida_idd.debugger_t.supports_debthread +ida_idd.debugger_t.supports_lowcnds +ida_idd.debugger_t.suspended +ida_idd.debugger_t.term_debugger +ida_idd.debugger_t.thread_continue +ida_idd.debugger_t.thread_get_sreg_base +ida_idd.debugger_t.thread_suspend +ida_idd.debugger_t.update_bpts +ida_idd.debugger_t.update_call_stack +ida_idd.debugger_t.update_lowcnds +ida_idd.debugger_t.use_memregs +ida_idd.debugger_t.use_sregs +ida_idd.debugger_t.version +ida_idd.debugger_t.virtual_threads +ida_idd.debugger_t.write_file +ida_idd.debugger_t.write_memory +ida_idd.debugger_t.write_register +ida_idd.dyn_register_info_array +ida_idd.dyn_register_info_array.__getitem__ +ida_idd.dyn_register_info_array.__init__ +ida_idd.dyn_register_info_array.__len__ +ida_idd.dyn_register_info_array.__setitem__ +ida_idd.exception_info_t +ida_idd.exception_info_t.__init__ +ida_idd.exception_info_t.break_on +ida_idd.exception_info_t.code +ida_idd.exception_info_t.desc +ida_idd.exception_info_t.flags +ida_idd.exception_info_t.handle +ida_idd.exception_info_t.name +ida_idd.excinfo_t +ida_idd.excinfo_t.__init__ +ida_idd.excinfo_t.can_cont +ida_idd.excinfo_t.code +ida_idd.excinfo_t.ea +ida_idd.excinfo_t.info +ida_idd.excvec_t +ida_idd.excvec_t.__getitem__ +ida_idd.excvec_t.__init__ +ida_idd.excvec_t.__len__ +ida_idd.excvec_t.__setitem__ +ida_idd.excvec_t.append +ida_idd.excvec_t.at +ida_idd.excvec_t.begin +ida_idd.excvec_t.capacity +ida_idd.excvec_t.clear +ida_idd.excvec_t.empty +ida_idd.excvec_t.end +ida_idd.excvec_t.erase +ida_idd.excvec_t.extend +ida_idd.excvec_t.extract +ida_idd.excvec_t.grow +ida_idd.excvec_t.inject +ida_idd.excvec_t.insert +ida_idd.excvec_t.pop_back +ida_idd.excvec_t.push_back +ida_idd.excvec_t.qclear +ida_idd.excvec_t.reserve +ida_idd.excvec_t.resize +ida_idd.excvec_t.size +ida_idd.excvec_t.swap +ida_idd.excvec_t.truncate +ida_idd.get_dbg +ida_idd.get_debug_event_name +ida_idd.get_event_bpt_hea +ida_idd.get_event_exc_code +ida_idd.get_event_exc_ea +ida_idd.get_event_exc_info +ida_idd.get_event_info +ida_idd.get_event_module_base +ida_idd.get_event_module_name +ida_idd.get_event_module_size +ida_idd.ieee2cpu +ida_idd.launch_env_t +ida_idd.launch_env_t.__init__ +ida_idd.launch_env_t.envs +ida_idd.launch_env_t.set +ida_idd.meminfo_vec_t +ida_idd.meminfo_vec_t.__init__ +ida_idd.meminfo_vec_template_t +ida_idd.meminfo_vec_template_t.__eq__ +ida_idd.meminfo_vec_template_t.__getitem__ +ida_idd.meminfo_vec_template_t.__init__ +ida_idd.meminfo_vec_template_t.__len__ +ida_idd.meminfo_vec_template_t.__ne__ +ida_idd.meminfo_vec_template_t.__setitem__ +ida_idd.meminfo_vec_template_t._del +ida_idd.meminfo_vec_template_t.add_unique +ida_idd.meminfo_vec_template_t.append +ida_idd.meminfo_vec_template_t.at +ida_idd.meminfo_vec_template_t.begin +ida_idd.meminfo_vec_template_t.capacity +ida_idd.meminfo_vec_template_t.clear +ida_idd.meminfo_vec_template_t.empty +ida_idd.meminfo_vec_template_t.end +ida_idd.meminfo_vec_template_t.erase +ida_idd.meminfo_vec_template_t.extend +ida_idd.meminfo_vec_template_t.extract +ida_idd.meminfo_vec_template_t.find +ida_idd.meminfo_vec_template_t.grow +ida_idd.meminfo_vec_template_t.has +ida_idd.meminfo_vec_template_t.inject +ida_idd.meminfo_vec_template_t.insert +ida_idd.meminfo_vec_template_t.pop_back +ida_idd.meminfo_vec_template_t.push_back +ida_idd.meminfo_vec_template_t.qclear +ida_idd.meminfo_vec_template_t.reserve +ida_idd.meminfo_vec_template_t.resize +ida_idd.meminfo_vec_template_t.size +ida_idd.meminfo_vec_template_t.swap +ida_idd.meminfo_vec_template_t.truncate +ida_idd.memory_info_t +ida_idd.memory_info_t.__eq__ +ida_idd.memory_info_t.__init__ +ida_idd.memory_info_t.__ne__ +ida_idd.memory_info_t.bitness +ida_idd.memory_info_t.name +ida_idd.memory_info_t.perm +ida_idd.memory_info_t.sbase +ida_idd.memory_info_t.sclass +ida_idd.modinfo_t +ida_idd.modinfo_t.__init__ +ida_idd.modinfo_t.base +ida_idd.modinfo_t.name +ida_idd.modinfo_t.rebase_to +ida_idd.modinfo_t.size +ida_idd.process_info_t +ida_idd.process_info_t.__init__ +ida_idd.process_info_t.name +ida_idd.process_info_t.pid +ida_idd.procinfo_vec_t +ida_idd.procinfo_vec_t.__getitem__ +ida_idd.procinfo_vec_t.__init__ +ida_idd.procinfo_vec_t.__len__ +ida_idd.procinfo_vec_t.__setitem__ +ida_idd.procinfo_vec_t.append +ida_idd.procinfo_vec_t.at +ida_idd.procinfo_vec_t.begin +ida_idd.procinfo_vec_t.capacity +ida_idd.procinfo_vec_t.clear +ida_idd.procinfo_vec_t.empty +ida_idd.procinfo_vec_t.end +ida_idd.procinfo_vec_t.erase +ida_idd.procinfo_vec_t.extend +ida_idd.procinfo_vec_t.extract +ida_idd.procinfo_vec_t.grow +ida_idd.procinfo_vec_t.inject +ida_idd.procinfo_vec_t.insert +ida_idd.procinfo_vec_t.pop_back +ida_idd.procinfo_vec_t.push_back +ida_idd.procinfo_vec_t.qclear +ida_idd.procinfo_vec_t.reserve +ida_idd.procinfo_vec_t.resize +ida_idd.procinfo_vec_t.size +ida_idd.procinfo_vec_t.swap +ida_idd.procinfo_vec_t.truncate +ida_idd.register_info_t +ida_idd.register_info_t.__get_bit_strings +ida_idd.register_info_t.__init__ +ida_idd.register_info_t.bit_strings +ida_idd.register_info_t.default_bit_strings_mask +ida_idd.register_info_t.dtype +ida_idd.register_info_t.flags +ida_idd.register_info_t.name +ida_idd.register_info_t.register_class +ida_idd.regval_t +ida_idd.regval_t.__eq__ +ida_idd.regval_t.__init__ +ida_idd.regval_t.__ne__ +ida_idd.regval_t.bytes +ida_idd.regval_t.clear +ida_idd.regval_t.get_data +ida_idd.regval_t.get_data_size +ida_idd.regval_t.ival +ida_idd.regval_t.pyval +ida_idd.regval_t.rvtype +ida_idd.regval_t.set_bytes +ida_idd.regval_t.set_float +ida_idd.regval_t.set_int +ida_idd.regval_t.set_pyval +ida_idd.regval_t.set_unavailable +ida_idd.regval_t.swap +ida_idd.regval_t.use_bytevec +ida_idd.regvals_t +ida_idd.regvals_t.__eq__ +ida_idd.regvals_t.__getitem__ +ida_idd.regvals_t.__init__ +ida_idd.regvals_t.__len__ +ida_idd.regvals_t.__ne__ +ida_idd.regvals_t.__setitem__ +ida_idd.regvals_t._del +ida_idd.regvals_t.add_unique +ida_idd.regvals_t.append +ida_idd.regvals_t.at +ida_idd.regvals_t.begin +ida_idd.regvals_t.capacity +ida_idd.regvals_t.clear +ida_idd.regvals_t.empty +ida_idd.regvals_t.end +ida_idd.regvals_t.erase +ida_idd.regvals_t.extend +ida_idd.regvals_t.extract +ida_idd.regvals_t.find +ida_idd.regvals_t.grow +ida_idd.regvals_t.has +ida_idd.regvals_t.inject +ida_idd.regvals_t.insert +ida_idd.regvals_t.pop_back +ida_idd.regvals_t.push_back +ida_idd.regvals_t.qclear +ida_idd.regvals_t.reserve +ida_idd.regvals_t.resize +ida_idd.regvals_t.size +ida_idd.regvals_t.swap +ida_idd.regvals_t.truncate +ida_idd.scattered_segm_t +ida_idd.scattered_segm_t.__init__ +ida_idd.scattered_segm_t.name +ida_idd.set_debug_event_code +ida_idd.thread_name_t +ida_idd.thread_name_t.__init__ +ida_idd.thread_name_t.name +ida_idd.thread_name_t.tid +ida_idp +ida_idp.AS2_BRACE +ida_idp.AS2_BYTE1CHAR +ida_idp.AS2_COLONSUF +ida_idp.AS2_IDEALDSCR +ida_idp.AS2_STRINV +ida_idp.AS2_TERSESTR +ida_idp.AS2_YWORD +ida_idp.AS2_ZWORD +ida_idp.ASB_BINF0 +ida_idp.ASB_BINF1 +ida_idp.ASB_BINF2 +ida_idp.ASB_BINF3 +ida_idp.ASB_BINF4 +ida_idp.ASB_BINF5 +ida_idp.ASD_DECF0 +ida_idp.ASD_DECF1 +ida_idp.ASD_DECF2 +ida_idp.ASD_DECF3 +ida_idp.ASH_HEXF0 +ida_idp.ASH_HEXF1 +ida_idp.ASH_HEXF2 +ida_idp.ASH_HEXF3 +ida_idp.ASH_HEXF4 +ida_idp.ASH_HEXF5 +ida_idp.ASO_OCTF0 +ida_idp.ASO_OCTF1 +ida_idp.ASO_OCTF2 +ida_idp.ASO_OCTF3 +ida_idp.ASO_OCTF4 +ida_idp.ASO_OCTF5 +ida_idp.ASO_OCTF6 +ida_idp.ASO_OCTF7 +ida_idp.AS_1TEXT +ida_idp.AS_2CHRE +ida_idp.AS_ALIGN2 +ida_idp.AS_ASCIIC +ida_idp.AS_ASCIIZ +ida_idp.AS_BINFM +ida_idp.AS_COLON +ida_idp.AS_DECFM +ida_idp.AS_HEXFM +ida_idp.AS_LALIGN +ida_idp.AS_N2CHR +ida_idp.AS_NCHRE +ida_idp.AS_NCMAS +ida_idp.AS_NHIAS +ida_idp.AS_NOCODECLN +ida_idp.AS_NOSPACE +ida_idp.AS_NOXRF +ida_idp.AS_OCTFM +ida_idp.AS_OFFST +ida_idp.AS_ONEDUP +ida_idp.AS_RELSUP +ida_idp.AS_UDATA +ida_idp.AS_UNEQU +ida_idp.AS_XTRNTYPE +ida_idp.AssembleLine +ida_idp.CF_CALL +ida_idp.CF_CHG1 +ida_idp.CF_CHG2 +ida_idp.CF_CHG3 +ida_idp.CF_CHG4 +ida_idp.CF_CHG5 +ida_idp.CF_CHG6 +ida_idp.CF_CHG7 +ida_idp.CF_CHG8 +ida_idp.CF_HLL +ida_idp.CF_JUMP +ida_idp.CF_SHFT +ida_idp.CF_STOP +ida_idp.CF_USE1 +ida_idp.CF_USE2 +ida_idp.CF_USE3 +ida_idp.CF_USE4 +ida_idp.CF_USE5 +ida_idp.CF_USE6 +ida_idp.CF_USE7 +ida_idp.CF_USE8 +ida_idp.CUSTOM_INSN_ITYPE +ida_idp.HKCB_GLOBAL +ida_idp.IDB_Hooks +ida_idp.IDB_Hooks.__disown__ +ida_idp.IDB_Hooks.__init__ +ida_idp.IDB_Hooks.adding_segm +ida_idp.IDB_Hooks.allsegs_moved +ida_idp.IDB_Hooks.auto_empty +ida_idp.IDB_Hooks.auto_empty_finally +ida_idp.IDB_Hooks.bookmark_changed +ida_idp.IDB_Hooks.byte_patched +ida_idp.IDB_Hooks.callee_addr_changed +ida_idp.IDB_Hooks.changing_cmt +ida_idp.IDB_Hooks.changing_op_ti +ida_idp.IDB_Hooks.changing_op_type +ida_idp.IDB_Hooks.changing_range_cmt +ida_idp.IDB_Hooks.changing_segm_class +ida_idp.IDB_Hooks.changing_segm_end +ida_idp.IDB_Hooks.changing_segm_name +ida_idp.IDB_Hooks.changing_segm_start +ida_idp.IDB_Hooks.changing_ti +ida_idp.IDB_Hooks.closebase +ida_idp.IDB_Hooks.cmt_changed +ida_idp.IDB_Hooks.compiler_changed +ida_idp.IDB_Hooks.deleting_func +ida_idp.IDB_Hooks.deleting_func_tail +ida_idp.IDB_Hooks.deleting_segm +ida_idp.IDB_Hooks.deleting_tryblks +ida_idp.IDB_Hooks.destroyed_items +ida_idp.IDB_Hooks.determined_main +ida_idp.IDB_Hooks.dirtree_link +ida_idp.IDB_Hooks.dirtree_mkdir +ida_idp.IDB_Hooks.dirtree_move +ida_idp.IDB_Hooks.dirtree_rank +ida_idp.IDB_Hooks.dirtree_rmdir +ida_idp.IDB_Hooks.dirtree_rminode +ida_idp.IDB_Hooks.dirtree_segm_moved +ida_idp.IDB_Hooks.extlang_changed +ida_idp.IDB_Hooks.extra_cmt_changed +ida_idp.IDB_Hooks.flow_chart_created +ida_idp.IDB_Hooks.frame_created +ida_idp.IDB_Hooks.frame_deleted +ida_idp.IDB_Hooks.frame_expanded +ida_idp.IDB_Hooks.frame_udm_changed +ida_idp.IDB_Hooks.frame_udm_created +ida_idp.IDB_Hooks.frame_udm_deleted +ida_idp.IDB_Hooks.frame_udm_renamed +ida_idp.IDB_Hooks.func_added +ida_idp.IDB_Hooks.func_deleted +ida_idp.IDB_Hooks.func_noret_changed +ida_idp.IDB_Hooks.func_tail_appended +ida_idp.IDB_Hooks.func_tail_deleted +ida_idp.IDB_Hooks.func_updated +ida_idp.IDB_Hooks.hook +ida_idp.IDB_Hooks.idasgn_loaded +ida_idp.IDB_Hooks.idasgn_matched_ea +ida_idp.IDB_Hooks.item_color_changed +ida_idp.IDB_Hooks.kernel_config_loaded +ida_idp.IDB_Hooks.loader_finished +ida_idp.IDB_Hooks.local_types_changed +ida_idp.IDB_Hooks.lt_edm_changed +ida_idp.IDB_Hooks.lt_edm_created +ida_idp.IDB_Hooks.lt_edm_deleted +ida_idp.IDB_Hooks.lt_edm_renamed +ida_idp.IDB_Hooks.lt_udm_changed +ida_idp.IDB_Hooks.lt_udm_created +ida_idp.IDB_Hooks.lt_udm_deleted +ida_idp.IDB_Hooks.lt_udm_renamed +ida_idp.IDB_Hooks.lt_udt_expanded +ida_idp.IDB_Hooks.make_code +ida_idp.IDB_Hooks.make_data +ida_idp.IDB_Hooks.op_ti_changed +ida_idp.IDB_Hooks.op_type_changed +ida_idp.IDB_Hooks.range_cmt_changed +ida_idp.IDB_Hooks.renamed +ida_idp.IDB_Hooks.savebase +ida_idp.IDB_Hooks.segm_added +ida_idp.IDB_Hooks.segm_attrs_updated +ida_idp.IDB_Hooks.segm_class_changed +ida_idp.IDB_Hooks.segm_deleted +ida_idp.IDB_Hooks.segm_end_changed +ida_idp.IDB_Hooks.segm_moved +ida_idp.IDB_Hooks.segm_name_changed +ida_idp.IDB_Hooks.segm_start_changed +ida_idp.IDB_Hooks.set_func_end +ida_idp.IDB_Hooks.set_func_start +ida_idp.IDB_Hooks.sgr_changed +ida_idp.IDB_Hooks.sgr_deleted +ida_idp.IDB_Hooks.stkpnts_changed +ida_idp.IDB_Hooks.tail_owner_changed +ida_idp.IDB_Hooks.thunk_func_created +ida_idp.IDB_Hooks.ti_changed +ida_idp.IDB_Hooks.tryblks_updated +ida_idp.IDB_Hooks.unhook +ida_idp.IDB_Hooks.updating_tryblks +ida_idp.IDB_Hooks.upgraded +ida_idp.IDP_Hooks +ida_idp.IDP_Hooks.__disown__ +ida_idp.IDP_Hooks.__init__ +ida_idp.IDP_Hooks.ev_add_cref +ida_idp.IDP_Hooks.ev_add_dref +ida_idp.IDP_Hooks.ev_adjust_argloc +ida_idp.IDP_Hooks.ev_adjust_libfunc_ea +ida_idp.IDP_Hooks.ev_adjust_refinfo +ida_idp.IDP_Hooks.ev_ana_insn +ida_idp.IDP_Hooks.ev_analyze_prolog +ida_idp.IDP_Hooks.ev_arch_changed +ida_idp.IDP_Hooks.ev_arg_addrs_ready +ida_idp.IDP_Hooks.ev_asm_installed +ida_idp.IDP_Hooks.ev_assemble +ida_idp.IDP_Hooks.ev_auto_queue_empty +ida_idp.IDP_Hooks.ev_calc_arglocs +ida_idp.IDP_Hooks.ev_calc_cdecl_purged_bytes +ida_idp.IDP_Hooks.ev_calc_next_eas +ida_idp.IDP_Hooks.ev_calc_purged_bytes +ida_idp.IDP_Hooks.ev_calc_retloc +ida_idp.IDP_Hooks.ev_calc_spdelta +ida_idp.IDP_Hooks.ev_calc_step_over +ida_idp.IDP_Hooks.ev_calc_switch_cases +ida_idp.IDP_Hooks.ev_calc_varglocs +ida_idp.IDP_Hooks.ev_calcrel +ida_idp.IDP_Hooks.ev_can_have_type +ida_idp.IDP_Hooks.ev_clean_tbit +ida_idp.IDP_Hooks.ev_cmp_operands +ida_idp.IDP_Hooks.ev_coagulate +ida_idp.IDP_Hooks.ev_coagulate_dref +ida_idp.IDP_Hooks.ev_create_flat_group +ida_idp.IDP_Hooks.ev_create_func_frame +ida_idp.IDP_Hooks.ev_create_merge_handlers +ida_idp.IDP_Hooks.ev_create_switch_xrefs +ida_idp.IDP_Hooks.ev_creating_segm +ida_idp.IDP_Hooks.ev_cvt64_hashval +ida_idp.IDP_Hooks.ev_cvt64_supval +ida_idp.IDP_Hooks.ev_decorate_name +ida_idp.IDP_Hooks.ev_del_cref +ida_idp.IDP_Hooks.ev_del_dref +ida_idp.IDP_Hooks.ev_delay_slot_insn +ida_idp.IDP_Hooks.ev_demangle_name +ida_idp.IDP_Hooks.ev_emu_insn +ida_idp.IDP_Hooks.ev_endbinary +ida_idp.IDP_Hooks.ev_ending_undo +ida_idp.IDP_Hooks.ev_equal_reglocs +ida_idp.IDP_Hooks.ev_extract_address +ida_idp.IDP_Hooks.ev_find_op_value +ida_idp.IDP_Hooks.ev_find_reg_value +ida_idp.IDP_Hooks.ev_func_bounds +ida_idp.IDP_Hooks.ev_gen_asm_or_lst +ida_idp.IDP_Hooks.ev_gen_map_file +ida_idp.IDP_Hooks.ev_gen_regvar_def +ida_idp.IDP_Hooks.ev_gen_src_file_lnnum +ida_idp.IDP_Hooks.ev_gen_stkvar_def +ida_idp.IDP_Hooks.ev_get_abi_info +ida_idp.IDP_Hooks.ev_get_autocmt +ida_idp.IDP_Hooks.ev_get_bg_color +ida_idp.IDP_Hooks.ev_get_cc_regs +ida_idp.IDP_Hooks.ev_get_code16_mode +ida_idp.IDP_Hooks.ev_get_dbr_opnum +ida_idp.IDP_Hooks.ev_get_default_enum_size +ida_idp.IDP_Hooks.ev_get_frame_retsize +ida_idp.IDP_Hooks.ev_get_macro_insn_head +ida_idp.IDP_Hooks.ev_get_operand_string +ida_idp.IDP_Hooks.ev_get_procmod +ida_idp.IDP_Hooks.ev_get_reg_accesses +ida_idp.IDP_Hooks.ev_get_reg_info +ida_idp.IDP_Hooks.ev_get_reg_name +ida_idp.IDP_Hooks.ev_get_simd_types +ida_idp.IDP_Hooks.ev_get_stkarg_area_info +ida_idp.IDP_Hooks.ev_get_stkvar_scale_factor +ida_idp.IDP_Hooks.ev_getreg +ida_idp.IDP_Hooks.ev_init +ida_idp.IDP_Hooks.ev_insn_reads_tbit +ida_idp.IDP_Hooks.ev_is_align_insn +ida_idp.IDP_Hooks.ev_is_alloca_probe +ida_idp.IDP_Hooks.ev_is_basic_block_end +ida_idp.IDP_Hooks.ev_is_call_insn +ida_idp.IDP_Hooks.ev_is_cond_insn +ida_idp.IDP_Hooks.ev_is_control_flow_guard +ida_idp.IDP_Hooks.ev_is_far_jump +ida_idp.IDP_Hooks.ev_is_indirect_jump +ida_idp.IDP_Hooks.ev_is_insn_table_jump +ida_idp.IDP_Hooks.ev_is_jump_func +ida_idp.IDP_Hooks.ev_is_ret_insn +ida_idp.IDP_Hooks.ev_is_sane_insn +ida_idp.IDP_Hooks.ev_is_sp_based +ida_idp.IDP_Hooks.ev_is_switch +ida_idp.IDP_Hooks.ev_last_cb_before_loader +ida_idp.IDP_Hooks.ev_loader +ida_idp.IDP_Hooks.ev_lower_func_type +ida_idp.IDP_Hooks.ev_max_ptr_size +ida_idp.IDP_Hooks.ev_may_be_func +ida_idp.IDP_Hooks.ev_may_show_sreg +ida_idp.IDP_Hooks.ev_moving_segm +ida_idp.IDP_Hooks.ev_newasm +ida_idp.IDP_Hooks.ev_newbinary +ida_idp.IDP_Hooks.ev_newfile +ida_idp.IDP_Hooks.ev_newprc +ida_idp.IDP_Hooks.ev_next_exec_insn +ida_idp.IDP_Hooks.ev_oldfile +ida_idp.IDP_Hooks.ev_out_assumes +ida_idp.IDP_Hooks.ev_out_data +ida_idp.IDP_Hooks.ev_out_footer +ida_idp.IDP_Hooks.ev_out_header +ida_idp.IDP_Hooks.ev_out_insn +ida_idp.IDP_Hooks.ev_out_label +ida_idp.IDP_Hooks.ev_out_mnem +ida_idp.IDP_Hooks.ev_out_operand +ida_idp.IDP_Hooks.ev_out_segend +ida_idp.IDP_Hooks.ev_out_segstart +ida_idp.IDP_Hooks.ev_out_special_item +ida_idp.IDP_Hooks.ev_privrange_changed +ida_idp.IDP_Hooks.ev_realcvt +ida_idp.IDP_Hooks.ev_rename +ida_idp.IDP_Hooks.ev_replaying_undo +ida_idp.IDP_Hooks.ev_set_code16_mode +ida_idp.IDP_Hooks.ev_set_idp_options +ida_idp.IDP_Hooks.ev_set_proc_options +ida_idp.IDP_Hooks.ev_setup_til +ida_idp.IDP_Hooks.ev_str2reg +ida_idp.IDP_Hooks.ev_term +ida_idp.IDP_Hooks.ev_treat_hindering_item +ida_idp.IDP_Hooks.ev_undefine +ida_idp.IDP_Hooks.ev_update_call_stack +ida_idp.IDP_Hooks.ev_use_arg_types +ida_idp.IDP_Hooks.ev_use_regarg_type +ida_idp.IDP_Hooks.ev_use_stkarg_type +ida_idp.IDP_Hooks.ev_validate_flirt_func +ida_idp.IDP_Hooks.ev_verify_noreturn +ida_idp.IDP_Hooks.ev_verify_sp +ida_idp.IDP_Hooks.hook +ida_idp.IDP_Hooks.unhook +ida_idp.IDP_INTERFACE_VERSION +ida_idp.IRI_EXTENDED +ida_idp.IRI_RET_LITERALLY +ida_idp.IRI_SKIP_RETTARGET +ida_idp.LTC_ADDED +ida_idp.LTC_ALIASED +ida_idp.LTC_COMPILER +ida_idp.LTC_DELETED +ida_idp.LTC_EDITED +ida_idp.LTC_NONE +ida_idp.LTC_TIL_COMPACTED +ida_idp.LTC_TIL_LOADED +ida_idp.LTC_TIL_UNLOADED +ida_idp.OP_FP_BASED +ida_idp.OP_SP_ADD +ida_idp.OP_SP_BASED +ida_idp.OP_SP_SUB +ida_idp.PLFM_386 +ida_idp.PLFM_6502 +ida_idp.PLFM_65C816 +ida_idp.PLFM_6800 +ida_idp.PLFM_68K +ida_idp.PLFM_80196 +ida_idp.PLFM_8051 +ida_idp.PLFM_AD2106X +ida_idp.PLFM_AD218X +ida_idp.PLFM_ALPHA +ida_idp.PLFM_ARC +ida_idp.PLFM_ARM +ida_idp.PLFM_AVR +ida_idp.PLFM_C166 +ida_idp.PLFM_C39 +ida_idp.PLFM_CR16 +ida_idp.PLFM_DALVIK +ida_idp.PLFM_DSP56K +ida_idp.PLFM_DSP96K +ida_idp.PLFM_EBC +ida_idp.PLFM_F2MC +ida_idp.PLFM_FR +ida_idp.PLFM_H8 +ida_idp.PLFM_H8500 +ida_idp.PLFM_HPPA +ida_idp.PLFM_I860 +ida_idp.PLFM_I960 +ida_idp.PLFM_IA64 +ida_idp.PLFM_JAVA +ida_idp.PLFM_KR1878 +ida_idp.PLFM_M16C +ida_idp.PLFM_M32R +ida_idp.PLFM_M740 +ida_idp.PLFM_M7700 +ida_idp.PLFM_M7900 +ida_idp.PLFM_MC6812 +ida_idp.PLFM_MC6816 +ida_idp.PLFM_MIPS +ida_idp.PLFM_MN102L00 +ida_idp.PLFM_MSP430 +ida_idp.PLFM_NEC_78K0 +ida_idp.PLFM_NEC_78K0S +ida_idp.PLFM_NEC_V850X +ida_idp.PLFM_NET +ida_idp.PLFM_OAKDSP +ida_idp.PLFM_PDP +ida_idp.PLFM_PIC +ida_idp.PLFM_PIC16 +ida_idp.PLFM_PPC +ida_idp.PLFM_RISCV +ida_idp.PLFM_RL78 +ida_idp.PLFM_RX +ida_idp.PLFM_S390 +ida_idp.PLFM_SCR_ADPT +ida_idp.PLFM_SH +ida_idp.PLFM_SPARC +ida_idp.PLFM_SPC700 +ida_idp.PLFM_SPU +ida_idp.PLFM_ST20 +ida_idp.PLFM_ST7 +ida_idp.PLFM_ST9 +ida_idp.PLFM_TLCS900 +ida_idp.PLFM_TMS +ida_idp.PLFM_TMS320C1X +ida_idp.PLFM_TMS320C28 +ida_idp.PLFM_TMS320C3 +ida_idp.PLFM_TMS320C54 +ida_idp.PLFM_TMS320C55 +ida_idp.PLFM_TMSC6 +ida_idp.PLFM_TRICORE +ida_idp.PLFM_TRIMEDIA +ida_idp.PLFM_UNSP +ida_idp.PLFM_WASM +ida_idp.PLFM_XTENSA +ida_idp.PLFM_Z8 +ida_idp.PLFM_Z80 +ida_idp.PR2_CODE16_BIT +ida_idp.PR2_FORCE_16BIT +ida_idp.PR2_IDP_OPTS +ida_idp.PR2_MACRO +ida_idp.PR2_MAPPINGS +ida_idp.PR2_REL_BITS +ida_idp.PR2_USE_CALCREL +ida_idp.PRN_BIN +ida_idp.PRN_DEC +ida_idp.PRN_HEX +ida_idp.PRN_OCT +ida_idp.PR_ADJSEGS +ida_idp.PR_ALIGN +ida_idp.PR_ALIGN_INSN +ida_idp.PR_ASSEMBLE +ida_idp.PR_BINMEM +ida_idp.PR_CHK_XREF +ida_idp.PR_CNDINSNS +ida_idp.PR_DEFNUM +ida_idp.PR_DEFSEG32 +ida_idp.PR_DEFSEG64 +ida_idp.PR_DELAYED +ida_idp.PR_NOCHANGE +ida_idp.PR_NO_SEGMOVE +ida_idp.PR_OUTER +ida_idp.PR_PURGING +ida_idp.PR_RNAMESOK +ida_idp.PR_SCALE_STKVARS +ida_idp.PR_SEGS +ida_idp.PR_SEGTRANS +ida_idp.PR_SGROTHER +ida_idp.PR_STACK_UP +ida_idp.PR_TYPEINFO +ida_idp.PR_USE32 +ida_idp.PR_USE64 +ida_idp.PR_USE_ARG_TYPES +ida_idp.PR_USE_TBYTE +ida_idp.PR_WORD_INS +ida_idp.REG_SPOIL +ida_idp.SETPROC_IDB +ida_idp.SETPROC_LOADER +ida_idp.SETPROC_LOADER_NON_FATAL +ida_idp.SETPROC_USER +ida_idp.__ph +ida_idp._notify_when_dispatcher_t +ida_idp._notify_when_dispatcher_t._IDB_Hooks +ida_idp._notify_when_dispatcher_t._IDB_Hooks.__init__ +ida_idp._notify_when_dispatcher_t._IDB_Hooks.closebase +ida_idp._notify_when_dispatcher_t._IDP_Hooks +ida_idp._notify_when_dispatcher_t._IDP_Hooks.__init__ +ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_newfile +ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_oldfile +ida_idp._notify_when_dispatcher_t.__init__ +ida_idp._notify_when_dispatcher_t._callback_t +ida_idp._notify_when_dispatcher_t._callback_t.__init__ +ida_idp._notify_when_dispatcher_t._find +ida_idp._notify_when_dispatcher_t.dispatch +ida_idp._notify_when_dispatcher_t.notify_when +ida_idp._processor_t +ida_idp._processor_t.__init__ +ida_idp._processor_t.add_cref +ida_idp._processor_t.add_dref +ida_idp._processor_t.adjust_argloc +ida_idp._processor_t.adjust_libfunc_ea +ida_idp._processor_t.adjust_refinfo +ida_idp._processor_t.ana_insn +ida_idp._processor_t.analyze_prolog +ida_idp._processor_t.arch_changed +ida_idp._processor_t.arg_addrs_ready +ida_idp._processor_t.asm_installed +ida_idp._processor_t.assemble +ida_idp._processor_t.auto_queue_empty +ida_idp._processor_t.calc_arglocs +ida_idp._processor_t.calc_cdecl_purged_bytes +ida_idp._processor_t.calc_next_eas +ida_idp._processor_t.calc_purged_bytes +ida_idp._processor_t.calc_retloc +ida_idp._processor_t.calc_spdelta +ida_idp._processor_t.calc_step_over +ida_idp._processor_t.calc_switch_cases +ida_idp._processor_t.calc_varglocs +ida_idp._processor_t.calcrel +ida_idp._processor_t.calcrel_in_bits +ida_idp._processor_t.can_have_type +ida_idp._processor_t.cbsize +ida_idp._processor_t.clean_tbit +ida_idp._processor_t.cmp_operands +ida_idp._processor_t.coagulate +ida_idp._processor_t.coagulate_dref +ida_idp._processor_t.create_flat_group +ida_idp._processor_t.create_func_frame +ida_idp._processor_t.create_merge_handlers +ida_idp._processor_t.create_switch_xrefs +ida_idp._processor_t.creating_segm +ida_idp._processor_t.cvt64_hashval +ida_idp._processor_t.cvt64_supval +ida_idp._processor_t.dbsize +ida_idp._processor_t.decorate_name +ida_idp._processor_t.del_cref +ida_idp._processor_t.del_dref +ida_idp._processor_t.delay_slot_insn +ida_idp._processor_t.demangle_name +ida_idp._processor_t.emu_insn +ida_idp._processor_t.endbinary +ida_idp._processor_t.equal_reglocs +ida_idp._processor_t.extract_address +ida_idp._processor_t.find_op_value +ida_idp._processor_t.find_reg_value +ida_idp._processor_t.func_bounds +ida_idp._processor_t.gen_asm_or_lst +ida_idp._processor_t.gen_map_file +ida_idp._processor_t.gen_regvar_def +ida_idp._processor_t.gen_src_file_lnnum +ida_idp._processor_t.gen_stkvar_def +ida_idp._processor_t.get_abi_info +ida_idp._processor_t.get_autocmt +ida_idp._processor_t.get_bg_color +ida_idp._processor_t.get_canon_feature +ida_idp._processor_t.get_canon_mnem +ida_idp._processor_t.get_cc_regs +ida_idp._processor_t.get_code16_mode +ida_idp._processor_t.get_dbr_opnum +ida_idp._processor_t.get_default_segm_bitness +ida_idp._processor_t.get_frame_retsize +ida_idp._processor_t.get_idd_opinfo +ida_idp._processor_t.get_macro_insn_head +ida_idp._processor_t.get_operand_string +ida_idp._processor_t.get_proc_index +ida_idp._processor_t.get_reg_accesses +ida_idp._processor_t.get_reg_info +ida_idp._processor_t.get_reg_name +ida_idp._processor_t.get_simd_types +ida_idp._processor_t.get_stkarg_area_info +ida_idp._processor_t.get_stkvar_scale +ida_idp._processor_t.get_stkvar_scale_factor +ida_idp._processor_t.getreg +ida_idp._processor_t.has_code16_bit +ida_idp._processor_t.has_idp_opts +ida_idp._processor_t.has_segregs +ida_idp._processor_t.init +ida_idp._processor_t.insn_reads_tbit +ida_idp._processor_t.is_align_insn +ida_idp._processor_t.is_alloca_probe +ida_idp._processor_t.is_basic_block_end +ida_idp._processor_t.is_call_insn +ida_idp._processor_t.is_cond_insn +ida_idp._processor_t.is_control_flow_guard +ida_idp._processor_t.is_far_jump +ida_idp._processor_t.is_indirect_jump +ida_idp._processor_t.is_jump_func +ida_idp._processor_t.is_ret_insn +ida_idp._processor_t.is_sane_insn +ida_idp._processor_t.is_sp_based +ida_idp._processor_t.is_switch +ida_idp._processor_t.loader_elf_machine +ida_idp._processor_t.lower_func_type +ida_idp._processor_t.max_ptr_size +ida_idp._processor_t.may_be_func +ida_idp._processor_t.may_show_sreg +ida_idp._processor_t.moving_segm +ida_idp._processor_t.newasm +ida_idp._processor_t.newbinary +ida_idp._processor_t.newfile +ida_idp._processor_t.newprc +ida_idp._processor_t.next_exec_insn +ida_idp._processor_t.notify +ida_idp._processor_t.oldfile +ida_idp._processor_t.out_assumes +ida_idp._processor_t.out_data +ida_idp._processor_t.out_footer +ida_idp._processor_t.out_header +ida_idp._processor_t.out_insn +ida_idp._processor_t.out_label +ida_idp._processor_t.out_mnem +ida_idp._processor_t.out_operand +ida_idp._processor_t.out_segend +ida_idp._processor_t.out_segstart +ida_idp._processor_t.out_special_item +ida_idp._processor_t.privrange_changed +ida_idp._processor_t.realcvt +ida_idp._processor_t.rename +ida_idp._processor_t.set_code16_mode +ida_idp._processor_t.set_idp_options +ida_idp._processor_t.set_proc_options +ida_idp._processor_t.setup_til +ida_idp._processor_t.sizeof_ldbl +ida_idp._processor_t.stkup +ida_idp._processor_t.str2reg +ida_idp._processor_t.supports_calcrel +ida_idp._processor_t.supports_macros +ida_idp._processor_t.term +ida_idp._processor_t.ti +ida_idp._processor_t.treat_hindering_item +ida_idp._processor_t.undefine +ida_idp._processor_t.update_call_stack +ida_idp._processor_t.use32 +ida_idp._processor_t.use64 +ida_idp._processor_t.use_arg_types +ida_idp._processor_t.use_mappings +ida_idp._processor_t.use_regarg_type +ida_idp._processor_t.use_stkarg_type +ida_idp._processor_t.use_tbyte +ida_idp._processor_t.validate_flirt_func +ida_idp._processor_t.verify_noreturn +ida_idp._processor_t.verify_sp +ida_idp._processor_t_Trampoline_IDB_Hooks +ida_idp._processor_t_Trampoline_IDB_Hooks.__dummy +ida_idp._processor_t_Trampoline_IDB_Hooks.__init__ +ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller +ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller.call_parent +ida_idp.asm_t +ida_idp.asm_t.__init__ +ida_idp.asm_t.a_align +ida_idp.asm_t.a_ascii +ida_idp.asm_t.a_band +ida_idp.asm_t.a_bnot +ida_idp.asm_t.a_bor +ida_idp.asm_t.a_bss +ida_idp.asm_t.a_byte +ida_idp.asm_t.a_comdef +ida_idp.asm_t.a_curip +ida_idp.asm_t.a_double +ida_idp.asm_t.a_dups +ida_idp.asm_t.a_dword +ida_idp.asm_t.a_equ +ida_idp.asm_t.a_extrn +ida_idp.asm_t.a_float +ida_idp.asm_t.a_include_fmt +ida_idp.asm_t.a_mod +ida_idp.asm_t.a_oword +ida_idp.asm_t.a_packreal +ida_idp.asm_t.a_public +ida_idp.asm_t.a_qword +ida_idp.asm_t.a_rva +ida_idp.asm_t.a_seg +ida_idp.asm_t.a_shl +ida_idp.asm_t.a_shr +ida_idp.asm_t.a_sizeof_fmt +ida_idp.asm_t.a_tbyte +ida_idp.asm_t.a_vstruc_fmt +ida_idp.asm_t.a_weak +ida_idp.asm_t.a_word +ida_idp.asm_t.a_xor +ida_idp.asm_t.a_yword +ida_idp.asm_t.a_zword +ida_idp.asm_t.accsep +ida_idp.asm_t.ascsep +ida_idp.asm_t.cmnt +ida_idp.asm_t.cmnt2 +ida_idp.asm_t.end +ida_idp.asm_t.esccodes +ida_idp.asm_t.flag +ida_idp.asm_t.flag2 +ida_idp.asm_t.header +ida_idp.asm_t.help +ida_idp.asm_t.high16 +ida_idp.asm_t.high8 +ida_idp.asm_t.lbrace +ida_idp.asm_t.low16 +ida_idp.asm_t.low8 +ida_idp.asm_t.name +ida_idp.asm_t.origin +ida_idp.asm_t.rbrace +ida_idp.asm_t.uflag +ida_idp.assemble +ida_idp.cfg_get_cc_header_path +ida_idp.cfg_get_cc_parm +ida_idp.cfg_get_cc_predefined_macros +ida_idp.delay_slot_insn +ida_idp.gen_idb_event +ida_idp.get_ash +ida_idp.get_config_value +ida_idp.get_idb_notifier_addr +ida_idp.get_idb_notifier_ud_addr +ida_idp.get_idp_name +ida_idp.get_idp_notifier_addr +ida_idp.get_idp_notifier_ud_addr +ida_idp.get_ph +ida_idp.get_reg_info +ida_idp.get_reg_name +ida_idp.has_cf_chg +ida_idp.has_cf_use +ida_idp.has_insn_feature +ida_idp.is_align_insn +ida_idp.is_basic_block_end +ida_idp.is_call_insn +ida_idp.is_indirect_jump_insn +ida_idp.is_ret_insn +ida_idp.num_range_t +ida_idp.num_range_t.__init__ +ida_idp.params_t +ida_idp.params_t.__init__ +ida_idp.parse_reg_name +ida_idp.ph_calcrel +ida_idp.ph_find_op_value +ida_idp.ph_find_reg_value +ida_idp.ph_get_abi_info +ida_idp.ph_get_cnbits +ida_idp.ph_get_dnbits +ida_idp.ph_get_flag +ida_idp.ph_get_icode_return +ida_idp.ph_get_id +ida_idp.ph_get_instruc +ida_idp.ph_get_instruc_end +ida_idp.ph_get_instruc_start +ida_idp.ph_get_operand_info +ida_idp.ph_get_reg_accesses +ida_idp.ph_get_reg_code_sreg +ida_idp.ph_get_reg_data_sreg +ida_idp.ph_get_reg_first_sreg +ida_idp.ph_get_reg_last_sreg +ida_idp.ph_get_regnames +ida_idp.ph_get_segreg_size +ida_idp.ph_get_tbyte_size +ida_idp.ph_get_version +ida_idp.process_config_directive +ida_idp.processor_t +ida_idp.processor_t.__idc_cvt_id__ +ida_idp.processor_t.__init__ +ida_idp.processor_t._get_idb_notifier_addr +ida_idp.processor_t._get_idb_notifier_ud_addr +ida_idp.processor_t._get_idp_notifier_addr +ida_idp.processor_t._get_idp_notifier_ud_addr +ida_idp.processor_t._get_notify +ida_idp.processor_t._make_forced_value_wrapper +ida_idp.processor_t._make_forced_value_wrapper.f +ida_idp.processor_t._make_int_returning_wrapper +ida_idp.processor_t._make_int_returning_wrapper.f +ida_idp.processor_t.auto_empty +ida_idp.processor_t.auto_empty_finally +ida_idp.processor_t.closebase +ida_idp.processor_t.compiler_changed +ida_idp.processor_t.deleting_func +ida_idp.processor_t.determined_main +ida_idp.processor_t.ev_ana_insn +ida_idp.processor_t.ev_assemble +ida_idp.processor_t.ev_auto_queue_empty +ida_idp.processor_t.ev_calc_step_over +ida_idp.processor_t.ev_can_have_type +ida_idp.processor_t.ev_cmp_operands +ida_idp.processor_t.ev_coagulate +ida_idp.processor_t.ev_coagulate_dref +ida_idp.processor_t.ev_create_func_frame +ida_idp.processor_t.ev_create_switch_xrefs +ida_idp.processor_t.ev_creating_segm +ida_idp.processor_t.ev_emu_insn +ida_idp.processor_t.ev_endbinary +ida_idp.processor_t.ev_func_bounds +ida_idp.processor_t.ev_gen_map_file +ida_idp.processor_t.ev_gen_regvar_def +ida_idp.processor_t.ev_gen_src_file_lnnum +ida_idp.processor_t.ev_get_autocmt +ida_idp.processor_t.ev_get_frame_retsize +ida_idp.processor_t.ev_get_operand_string +ida_idp.processor_t.ev_is_align_insn +ida_idp.processor_t.ev_is_alloca_probe +ida_idp.processor_t.ev_is_basic_block_end +ida_idp.processor_t.ev_is_call_insn +ida_idp.processor_t.ev_is_far_jump +ida_idp.processor_t.ev_is_indirect_jump +ida_idp.processor_t.ev_is_insn_table_jump +ida_idp.processor_t.ev_is_ret_insn +ida_idp.processor_t.ev_is_sane_insn +ida_idp.processor_t.ev_is_sp_based +ida_idp.processor_t.ev_is_switch +ida_idp.processor_t.ev_may_be_func +ida_idp.processor_t.ev_may_show_sreg +ida_idp.processor_t.ev_moving_segm +ida_idp.processor_t.ev_newbinary +ida_idp.processor_t.ev_newfile +ida_idp.processor_t.ev_newprc +ida_idp.processor_t.ev_oldfile +ida_idp.processor_t.ev_out_assumes +ida_idp.processor_t.ev_out_data +ida_idp.processor_t.ev_out_footer +ida_idp.processor_t.ev_out_header +ida_idp.processor_t.ev_out_insn +ida_idp.processor_t.ev_out_label +ida_idp.processor_t.ev_out_mnem +ida_idp.processor_t.ev_out_operand +ida_idp.processor_t.ev_out_segend +ida_idp.processor_t.ev_out_segstart +ida_idp.processor_t.ev_out_special_item +ida_idp.processor_t.ev_rename +ida_idp.processor_t.ev_set_idp_options +ida_idp.processor_t.ev_set_proc_options +ida_idp.processor_t.ev_str2reg +ida_idp.processor_t.ev_treat_hindering_item +ida_idp.processor_t.ev_undefine +ida_idp.processor_t.ev_validate_flirt_func +ida_idp.processor_t.ev_verify_noreturn +ida_idp.processor_t.ev_verify_sp +ida_idp.processor_t.func_added +ida_idp.processor_t.get_auxpref +ida_idp.processor_t.get_idpdesc +ida_idp.processor_t.idasgn_loaded +ida_idp.processor_t.kernel_config_loaded +ida_idp.processor_t.make_code +ida_idp.processor_t.make_data +ida_idp.processor_t.renamed +ida_idp.processor_t.savebase +ida_idp.processor_t.segm_moved +ida_idp.processor_t.set_func_end +ida_idp.processor_t.set_func_start +ida_idp.processor_t.sgr_changed +ida_idp.reg_access_t +ida_idp.reg_access_t.__eq__ +ida_idp.reg_access_t.__init__ +ida_idp.reg_access_t.__ne__ +ida_idp.reg_access_t.have_common_bits +ida_idp.reg_access_t.opnum +ida_idp.reg_access_t.range +ida_idp.reg_access_t.regnum +ida_idp.reg_access_vec_t +ida_idp.reg_access_vec_t.__eq__ +ida_idp.reg_access_vec_t.__getitem__ +ida_idp.reg_access_vec_t.__init__ +ida_idp.reg_access_vec_t.__len__ +ida_idp.reg_access_vec_t.__ne__ +ida_idp.reg_access_vec_t.__setitem__ +ida_idp.reg_access_vec_t._del +ida_idp.reg_access_vec_t.add_unique +ida_idp.reg_access_vec_t.append +ida_idp.reg_access_vec_t.at +ida_idp.reg_access_vec_t.begin +ida_idp.reg_access_vec_t.capacity +ida_idp.reg_access_vec_t.clear +ida_idp.reg_access_vec_t.empty +ida_idp.reg_access_vec_t.end +ida_idp.reg_access_vec_t.erase +ida_idp.reg_access_vec_t.extend +ida_idp.reg_access_vec_t.extract +ida_idp.reg_access_vec_t.find +ida_idp.reg_access_vec_t.grow +ida_idp.reg_access_vec_t.has +ida_idp.reg_access_vec_t.inject +ida_idp.reg_access_vec_t.insert +ida_idp.reg_access_vec_t.pop_back +ida_idp.reg_access_vec_t.push_back +ida_idp.reg_access_vec_t.qclear +ida_idp.reg_access_vec_t.reserve +ida_idp.reg_access_vec_t.resize +ida_idp.reg_access_vec_t.size +ida_idp.reg_access_vec_t.swap +ida_idp.reg_access_vec_t.truncate +ida_idp.reg_accesses_t +ida_idp.reg_accesses_t.__init__ +ida_idp.reg_info_t +ida_idp.reg_info_t.__eq__ +ida_idp.reg_info_t.__ge__ +ida_idp.reg_info_t.__gt__ +ida_idp.reg_info_t.__init__ +ida_idp.reg_info_t.__le__ +ida_idp.reg_info_t.__lt__ +ida_idp.reg_info_t.__ne__ +ida_idp.reg_info_t.compare +ida_idp.reg_info_t.reg +ida_idp.reg_info_t.size +ida_idp.register_cfgopts +ida_idp.set_processor_type +ida_idp.set_target_assembler +ida_idp.sizeof_ldbl +ida_idp.str2reg +ida_idp.str2sreg +ida_ieee +ida_ieee.E_SPECIAL_EXP +ida_ieee.FPVAL_NWORDS +ida_ieee.FPV_BADARG +ida_ieee.FPV_NAN +ida_ieee.FPV_NINF +ida_ieee.FPV_NORM +ida_ieee.FPV_PINF +ida_ieee.IEEE_E +ida_ieee.IEEE_EXONE +ida_ieee.IEEE_M +ida_ieee.IEEE_NI +ida_ieee.REAL_ERROR_BADDATA +ida_ieee.REAL_ERROR_BADSTR +ida_ieee.REAL_ERROR_FORMAT +ida_ieee.REAL_ERROR_FPOVER +ida_ieee.REAL_ERROR_INTOVER +ida_ieee.REAL_ERROR_OK +ida_ieee.REAL_ERROR_RANGE +ida_ieee.REAL_ERROR_ZERODIV +ida_ieee.ecleaz +ida_ieee.fpvalue_shorts_array_t +ida_ieee.fpvalue_shorts_array_t.__getitem__ +ida_ieee.fpvalue_shorts_array_t.__init__ +ida_ieee.fpvalue_shorts_array_t.__len__ +ida_ieee.fpvalue_shorts_array_t.__setitem__ +ida_ieee.fpvalue_shorts_array_t._get_bytes +ida_ieee.fpvalue_shorts_array_t._set_bytes +ida_ieee.fpvalue_t +ida_ieee.fpvalue_t.__add__ +ida_ieee.fpvalue_t.__eq__ +ida_ieee.fpvalue_t.__ge__ +ida_ieee.fpvalue_t.__getitem__ +ida_ieee.fpvalue_t.__gt__ +ida_ieee.fpvalue_t.__init__ +ida_ieee.fpvalue_t.__iter__ +ida_ieee.fpvalue_t.__le__ +ida_ieee.fpvalue_t.__lt__ +ida_ieee.fpvalue_t.__mul__ +ida_ieee.fpvalue_t.__ne__ +ida_ieee.fpvalue_t.__repr__ +ida_ieee.fpvalue_t.__setitem__ +ida_ieee.fpvalue_t.__str__ +ida_ieee.fpvalue_t.__sub__ +ida_ieee.fpvalue_t.__truediv__ +ida_ieee.fpvalue_t._get_bytes +ida_ieee.fpvalue_t._get_float +ida_ieee.fpvalue_t._get_shorts +ida_ieee.fpvalue_t._set_bytes +ida_ieee.fpvalue_t._set_float +ida_ieee.fpvalue_t.assign +ida_ieee.fpvalue_t.clear +ida_ieee.fpvalue_t.compare +ida_ieee.fpvalue_t.copy +ida_ieee.fpvalue_t.eabs +ida_ieee.fpvalue_t.fadd +ida_ieee.fpvalue_t.fdiv +ida_ieee.fpvalue_t.fmul +ida_ieee.fpvalue_t.from_10bytes +ida_ieee.fpvalue_t.from_12bytes +ida_ieee.fpvalue_t.from_int64 +ida_ieee.fpvalue_t.from_str +ida_ieee.fpvalue_t.from_sval +ida_ieee.fpvalue_t.from_uint64 +ida_ieee.fpvalue_t.fsub +ida_ieee.fpvalue_t.get_kind +ida_ieee.fpvalue_t.is_negative +ida_ieee.fpvalue_t.mul_pow2 +ida_ieee.fpvalue_t.negate +ida_ieee.fpvalue_t.new_from_str +ida_ieee.fpvalue_t.to_10bytes +ida_ieee.fpvalue_t.to_12bytes +ida_ieee.fpvalue_t.to_int64 +ida_ieee.fpvalue_t.to_str +ida_ieee.fpvalue_t.to_sval +ida_ieee.fpvalue_t.to_uint64 +ida_kernwin +ida_kernwin.AA_CHECKABLE +ida_kernwin.AA_CHECKED +ida_kernwin.AA_ICON +ida_kernwin.AA_LABEL +ida_kernwin.AA_NONE +ida_kernwin.AA_SHORTCUT +ida_kernwin.AA_STATE +ida_kernwin.AA_TOOLTIP +ida_kernwin.AA_VISIBILITY +ida_kernwin.ACF_HAS_FIELD_DIRTREE_SELECTION +ida_kernwin.ACF_HAS_SELECTION +ida_kernwin.ACF_HAS_SOURCE +ida_kernwin.ACF_HAS_TYPE_REF +ida_kernwin.ACF_XTRN_EA +ida_kernwin.ADF_CHECKABLE +ida_kernwin.ADF_CHECKED +ida_kernwin.ADF_GLOBAL +ida_kernwin.ADF_NO_HIGHLIGHT +ida_kernwin.ADF_NO_UNDO +ida_kernwin.ADF_OT_MASK +ida_kernwin.ADF_OT_PLUGIN +ida_kernwin.ADF_OT_PLUGMOD +ida_kernwin.ADF_OT_PROCMOD +ida_kernwin.ADF_OWN_HANDLER +ida_kernwin.AHF_VERSION +ida_kernwin.AHF_VERSION_MASK +ida_kernwin.ASKBTN_BTN1 +ida_kernwin.ASKBTN_BTN2 +ida_kernwin.ASKBTN_BTN3 +ida_kernwin.ASKBTN_CANCEL +ida_kernwin.ASKBTN_NO +ida_kernwin.ASKBTN_YES +ida_kernwin.AST_DISABLE +ida_kernwin.AST_DISABLE_ALWAYS +ida_kernwin.AST_DISABLE_FOR_IDB +ida_kernwin.AST_DISABLE_FOR_WIDGET +ida_kernwin.AST_ENABLE +ida_kernwin.AST_ENABLE_ALWAYS +ida_kernwin.AST_ENABLE_FOR_IDB +ida_kernwin.AST_ENABLE_FOR_WIDGET +ida_kernwin.BWN_ADDRWATCH +ida_kernwin.BWN_BOOKMARKS +ida_kernwin.BWN_BPTS +ida_kernwin.BWN_CALLS +ida_kernwin.BWN_CALLS_CALLEES +ida_kernwin.BWN_CALLS_CALLERS +ida_kernwin.BWN_CALL_STACK +ida_kernwin.BWN_CHOOSER +ida_kernwin.BWN_CLI +ida_kernwin.BWN_CMDPALCSR +ida_kernwin.BWN_CMDPALWIN +ida_kernwin.BWN_CPUREGS +ida_kernwin.BWN_CUSTVIEW +ida_kernwin.BWN_CV_LINE_INFOS +ida_kernwin.BWN_DISASM +ida_kernwin.BWN_DISASM_ARROWS +ida_kernwin.BWN_EXPORTS +ida_kernwin.BWN_FRAME +ida_kernwin.BWN_FUNCS +ida_kernwin.BWN_HEXVIEW +ida_kernwin.BWN_IMPORTS +ida_kernwin.BWN_LOCALS +ida_kernwin.BWN_MDVIEWCSR +ida_kernwin.BWN_MODULES +ida_kernwin.BWN_NAMES +ida_kernwin.BWN_NAVBAND +ida_kernwin.BWN_NOTEPAD +ida_kernwin.BWN_OUTPUT +ida_kernwin.BWN_PROBS +ida_kernwin.BWN_PSEUDOCODE +ida_kernwin.BWN_SCRIPTS_CSR +ida_kernwin.BWN_SEARCH +ida_kernwin.BWN_SEGREGS +ida_kernwin.BWN_SEGS +ida_kernwin.BWN_SELS +ida_kernwin.BWN_SHORTCUTCSR +ida_kernwin.BWN_SHORTCUTWIN +ida_kernwin.BWN_SIGNS +ida_kernwin.BWN_SNIPPETS +ida_kernwin.BWN_SNIPPETS_CSR +ida_kernwin.BWN_SO_OFFSETS +ida_kernwin.BWN_SO_STRUCTS +ida_kernwin.BWN_SRCPTHMAP_CSR +ida_kernwin.BWN_SRCPTHUND_CSR +ida_kernwin.BWN_STKVIEW +ida_kernwin.BWN_STRINGS +ida_kernwin.BWN_THREADS +ida_kernwin.BWN_TICSR +ida_kernwin.BWN_TILIST +ida_kernwin.BWN_TILS +ida_kernwin.BWN_TIL_VIEW +ida_kernwin.BWN_TRACE +ida_kernwin.BWN_UNDOHIST +ida_kernwin.BWN_UNKNOWN +ida_kernwin.BWN_WATCH +ida_kernwin.BWN_XREFS +ida_kernwin.CDVF_LINEICONS +ida_kernwin.CDVF_NOLINES +ida_kernwin.CDVF_STATUSBAR +ida_kernwin.CDVH_LINES_ALIGNMENT +ida_kernwin.CDVH_LINES_CLICK +ida_kernwin.CDVH_LINES_DBLCLICK +ida_kernwin.CDVH_LINES_DRAWICON +ida_kernwin.CDVH_LINES_ICONMARGIN +ida_kernwin.CDVH_LINES_LINENUM +ida_kernwin.CDVH_LINES_POPUP +ida_kernwin.CDVH_LINES_RADIX +ida_kernwin.CDVH_SRCVIEW +ida_kernwin.CDVH_USERDATA +ida_kernwin.CH2_LAZY_LOADED +ida_kernwin.CHCOL_DEC +ida_kernwin.CHCOL_DEFHIDDEN +ida_kernwin.CHCOL_DRAGHINT +ida_kernwin.CHCOL_EA +ida_kernwin.CHCOL_FNAME +ida_kernwin.CHCOL_FORMAT +ida_kernwin.CHCOL_HEX +ida_kernwin.CHCOL_INODENAME +ida_kernwin.CHCOL_PATH +ida_kernwin.CHCOL_PLAIN +ida_kernwin.CHITEM_BOLD +ida_kernwin.CHITEM_GRAY +ida_kernwin.CHITEM_ITALIC +ida_kernwin.CHITEM_STRIKE +ida_kernwin.CHITEM_UNDER +ida_kernwin.CHOOSER_NOMAINMENU +ida_kernwin.CHOOSER_NOSTATUSBAR +ida_kernwin.CH_ATTRS +ida_kernwin.CH_BUILTIN_MASK +ida_kernwin.CH_CAN_DEL +ida_kernwin.CH_CAN_EDIT +ida_kernwin.CH_CAN_INS +ida_kernwin.CH_CAN_REFRESH +ida_kernwin.CH_FORCE_DEFAULT +ida_kernwin.CH_HAS_DIFF +ida_kernwin.CH_HAS_DIRTREE +ida_kernwin.CH_KEEP +ida_kernwin.CH_MODAL +ida_kernwin.CH_MULTI +ida_kernwin.CH_MULTI_EDIT +ida_kernwin.CH_NOBTNS +ida_kernwin.CH_NON_PERSISTED_TREE +ida_kernwin.CH_NO_FILTER +ida_kernwin.CH_NO_SORT +ida_kernwin.CH_NO_STATUS_BAR +ida_kernwin.CH_QFLT +ida_kernwin.CH_QFTYP_DEFAULT +ida_kernwin.CH_QFTYP_FUZZY +ida_kernwin.CH_QFTYP_NORMAL +ida_kernwin.CH_QFTYP_REGEX +ida_kernwin.CH_QFTYP_WHOLE_WORDS +ida_kernwin.CH_RENAME_IS_EDIT +ida_kernwin.CH_RESTORE +ida_kernwin.CH_TM_FOLDERS_ONLY +ida_kernwin.CH_TM_FULL_TREE +ida_kernwin.CH_TM_NO_TREE +ida_kernwin.CK_EXTRA1 +ida_kernwin.CK_EXTRA10 +ida_kernwin.CK_EXTRA11 +ida_kernwin.CK_EXTRA12 +ida_kernwin.CK_EXTRA13 +ida_kernwin.CK_EXTRA14 +ida_kernwin.CK_EXTRA15 +ida_kernwin.CK_EXTRA16 +ida_kernwin.CK_EXTRA2 +ida_kernwin.CK_EXTRA3 +ida_kernwin.CK_EXTRA4 +ida_kernwin.CK_EXTRA5 +ida_kernwin.CK_EXTRA6 +ida_kernwin.CK_EXTRA7 +ida_kernwin.CK_EXTRA8 +ida_kernwin.CK_EXTRA9 +ida_kernwin.CK_TRACE +ida_kernwin.CK_TRACE_OVL +ida_kernwin.CLNL_FINDCMT +ida_kernwin.CLNL_LTRIM +ida_kernwin.CLNL_RTRIM +ida_kernwin.CREATETB_ADV +ida_kernwin.CVH_CLICK +ida_kernwin.CVH_CLOSE +ida_kernwin.CVH_CURPOS +ida_kernwin.CVH_DBLCLICK +ida_kernwin.CVH_HELP +ida_kernwin.CVH_KEYDOWN +ida_kernwin.CVH_MOUSEMOVE +ida_kernwin.CVH_POPUP +ida_kernwin.CVH_QT_AWARE +ida_kernwin.CVLF_USE_MOUSE +ida_kernwin.CVNF_ACT +ida_kernwin.CVNF_JUMP +ida_kernwin.CVNF_LAZY +ida_kernwin.Choose +ida_kernwin.Choose.ALREADY_EXISTS +ida_kernwin.Choose.Activate +ida_kernwin.Choose.AddCommand +ida_kernwin.Choose.CHCOL_DEC +ida_kernwin.Choose.CHCOL_DEFHIDDEN +ida_kernwin.Choose.CHCOL_DRAGHINT +ida_kernwin.Choose.CHCOL_EA +ida_kernwin.Choose.CHCOL_FNAME +ida_kernwin.Choose.CHCOL_FORMAT +ida_kernwin.Choose.CHCOL_HEX +ida_kernwin.Choose.CHCOL_INODENAME +ida_kernwin.Choose.CHCOL_PATH +ida_kernwin.Choose.CHCOL_PLAIN +ida_kernwin.Choose.CH_ATTRS +ida_kernwin.Choose.CH_BUILTIN_MASK +ida_kernwin.Choose.CH_CAN_DEL +ida_kernwin.Choose.CH_CAN_EDIT +ida_kernwin.Choose.CH_CAN_INS +ida_kernwin.Choose.CH_CAN_REFRESH +ida_kernwin.Choose.CH_FORCE_DEFAULT +ida_kernwin.Choose.CH_HAS_DIFF +ida_kernwin.Choose.CH_HAS_DIRTREE +ida_kernwin.Choose.CH_MODAL +ida_kernwin.Choose.CH_MULTI +ida_kernwin.Choose.CH_NOBTNS +ida_kernwin.Choose.CH_NOIDB +ida_kernwin.Choose.CH_NO_STATUS_BAR +ida_kernwin.Choose.CH_QFLT +ida_kernwin.Choose.CH_QFTYP_DEFAULT +ida_kernwin.Choose.CH_QFTYP_FUZZY +ida_kernwin.Choose.CH_QFTYP_NORMAL +ida_kernwin.Choose.CH_QFTYP_REGEX +ida_kernwin.Choose.CH_QFTYP_WHOLE_WORDS +ida_kernwin.Choose.CH_RENAME_IS_EDIT +ida_kernwin.Choose.CH_RESTORE +ida_kernwin.Choose.Close +ida_kernwin.Choose.EMPTY_CHOOSER +ida_kernwin.Choose.Embedded +ida_kernwin.Choose.GetEmbSelection +ida_kernwin.Choose.GetWidget +ida_kernwin.Choose.NO_ATTR +ida_kernwin.Choose.NO_SELECTION +ida_kernwin.Choose.OnClose +ida_kernwin.Choose.OnDeleteLine +ida_kernwin.Choose.OnEditLine +ida_kernwin.Choose.OnGetDirTree +ida_kernwin.Choose.OnGetEA +ida_kernwin.Choose.OnGetIcon +ida_kernwin.Choose.OnGetLine +ida_kernwin.Choose.OnGetLineAttr +ida_kernwin.Choose.OnGetSize +ida_kernwin.Choose.OnIndexToDiffpos +ida_kernwin.Choose.OnIndexToInode +ida_kernwin.Choose.OnInit +ida_kernwin.Choose.OnInsertLine +ida_kernwin.Choose.OnLazyLoadDir +ida_kernwin.Choose.OnPopup +ida_kernwin.Choose.OnRefresh +ida_kernwin.Choose.OnSelectLine +ida_kernwin.Choose.OnSelectionChange +ida_kernwin.Choose.Refresh +ida_kernwin.Choose.Show +ida_kernwin.Choose.UI_Hooks_Trampoline +ida_kernwin.Choose.UI_Hooks_Trampoline.__init__ +ida_kernwin.Choose.UI_Hooks_Trampoline.populating_widget_popup +ida_kernwin.Choose.__init__ +ida_kernwin.Choose.__init__._qccb +ida_kernwin.Choose.adjust_last_item +ida_kernwin.CustomIDAMemo +ida_kernwin.CustomIDAMemo.CreateGroups +ida_kernwin.CustomIDAMemo.DelNodesInfos +ida_kernwin.CustomIDAMemo.DeleteGroups +ida_kernwin.CustomIDAMemo.GetCurrentRendererType +ida_kernwin.CustomIDAMemo.GetNodeInfo +ida_kernwin.CustomIDAMemo.GetWidget +ida_kernwin.CustomIDAMemo.GetWidgetAsGraphViewer +ida_kernwin.CustomIDAMemo.Refresh +ida_kernwin.CustomIDAMemo.SetCurrentRendererType +ida_kernwin.CustomIDAMemo.SetGroupsVisibility +ida_kernwin.CustomIDAMemo.SetNodeInfo +ida_kernwin.CustomIDAMemo.SetNodesInfos +ida_kernwin.CustomIDAMemo._OnBind +ida_kernwin.CustomIDAMemo.__init__ +ida_kernwin.CustomIDAMemo._dummy_cb +ida_kernwin.CustomIDAMemo._get_cb +ida_kernwin.CustomIDAMemo._get_cb_arity +ida_kernwin.CustomIDAMemo._graph_item_tuple +ida_kernwin.CustomIDAMemo.view_activated +ida_kernwin.CustomIDAMemo.view_click +ida_kernwin.CustomIDAMemo.view_close +ida_kernwin.CustomIDAMemo.view_curpos +ida_kernwin.CustomIDAMemo.view_dblclick +ida_kernwin.CustomIDAMemo.view_deactivated +ida_kernwin.CustomIDAMemo.view_keydown +ida_kernwin.CustomIDAMemo.view_loc_changed +ida_kernwin.CustomIDAMemo.view_mouse_moved +ida_kernwin.CustomIDAMemo.view_mouse_over +ida_kernwin.CustomIDAMemo.view_switched +ida_kernwin.DP_BEFORE +ida_kernwin.DP_BOTTOM +ida_kernwin.DP_FLOATING +ida_kernwin.DP_INSIDE +ida_kernwin.DP_LEFT +ida_kernwin.DP_RIGHT +ida_kernwin.DP_SZHINT +ida_kernwin.DP_TAB +ida_kernwin.DP_TOP +ida_kernwin.Form +ida_kernwin.Form.Add +ida_kernwin.Form.AddControls +ida_kernwin.Form.ButtonInput +ida_kernwin.Form.ButtonInput.__init__ +ida_kernwin.Form.ButtonInput.helper_cb +ida_kernwin.Form.ButtonInput.is_input_field +ida_kernwin.Form.ChkGroupControl +ida_kernwin.Form.ChkGroupControl.ItemClass +ida_kernwin.Form.ChkGroupControl.__init__ +ida_kernwin.Form.ChkGroupItemControl +ida_kernwin.Form.ChkGroupItemControl.__get_value +ida_kernwin.Form.ChkGroupItemControl.__init__ +ida_kernwin.Form.ChkGroupItemControl.__set_value +ida_kernwin.Form.ChkGroupItemControl.checked +ida_kernwin.Form.Close +ida_kernwin.Form.ColorInput +ida_kernwin.Form.ColorInput.__init__ +ida_kernwin.Form.Compile +ida_kernwin.Form.CompileEx +ida_kernwin.Form.CompileEx.next_control +ida_kernwin.Form.Compiled +ida_kernwin.Form.Control +ida_kernwin.Form.Control.__init__ +ida_kernwin.Form.Control.free +ida_kernwin.Form.Control.get_arg +ida_kernwin.Form.Control.get_tag +ida_kernwin.Form.Control.is_input_field +ida_kernwin.Form.ControlToFieldTypeIdAndSize +ida_kernwin.Form.DirInput +ida_kernwin.Form.DirInput.__init__ +ida_kernwin.Form.DropdownListControl +ida_kernwin.Form.DropdownListControl.__get_selval +ida_kernwin.Form.DropdownListControl.__init__ +ida_kernwin.Form.DropdownListControl.__set_selval +ida_kernwin.Form.DropdownListControl.free +ida_kernwin.Form.DropdownListControl.selval +ida_kernwin.Form.DropdownListControl.set_items +ida_kernwin.Form.EmbeddedChooserControl +ida_kernwin.Form.EmbeddedChooserControl.__get_selection__ +ida_kernwin.Form.EmbeddedChooserControl.__init__ +ida_kernwin.Form.EmbeddedChooserControl.free +ida_kernwin.Form.EmbeddedChooserControl.selection +ida_kernwin.Form.EmbeddedChooserControl.value +ida_kernwin.Form.EnableField +ida_kernwin.Form.Execute +ida_kernwin.Form.FT_ADDR +ida_kernwin.Form.FT_ASCII +ida_kernwin.Form.FT_BIN +ida_kernwin.Form.FT_BUTTON +ida_kernwin.Form.FT_CHAR +ida_kernwin.Form.FT_COLOR +ida_kernwin.Form.FT_DEC +ida_kernwin.Form.FT_DIR +ida_kernwin.Form.FT_DROPDOWN_LIST +ida_kernwin.Form.FT_ECHOOSER +ida_kernwin.Form.FT_FILE +ida_kernwin.Form.FT_FORMCHG +ida_kernwin.Form.FT_HEX +ida_kernwin.Form.FT_HTML_LABEL +ida_kernwin.Form.FT_IDENT +ida_kernwin.Form.FT_INT64 +ida_kernwin.Form.FT_MULTI_LINE_TEXT +ida_kernwin.Form.FT_OCT +ida_kernwin.Form.FT_RAWHEX +ida_kernwin.Form.FT_SEG +ida_kernwin.Form.FT_SHEX +ida_kernwin.Form.FT_TYPE +ida_kernwin.Form.FT_UINT64 +ida_kernwin.Form.FileInput +ida_kernwin.Form.FileInput.__init__ +ida_kernwin.Form.FindControlById +ida_kernwin.Form.FormChangeCb +ida_kernwin.Form.FormChangeCb.__init__ +ida_kernwin.Form.FormChangeCb.free +ida_kernwin.Form.FormChangeCb.get_tag +ida_kernwin.Form.FormChangeCb.helper_cb +ida_kernwin.Form.Free +ida_kernwin.Form.GetControlValue +ida_kernwin.Form.GetFocusedField +ida_kernwin.Form.GroupControl +ida_kernwin.Form.GroupControl.__init__ +ida_kernwin.Form.GroupControl._reset +ida_kernwin.Form.GroupControl.get_tag +ida_kernwin.Form.GroupControl.next_child_pos +ida_kernwin.Form.GroupItemControl +ida_kernwin.Form.GroupItemControl.__init__ +ida_kernwin.Form.GroupItemControl.assign_pos +ida_kernwin.Form.GroupItemControl.get_tag +ida_kernwin.Form.GroupItemControl.is_input_field +ida_kernwin.Form.InputControl +ida_kernwin.Form.InputControl.__init__ +ida_kernwin.Form.InputControl.get_tag +ida_kernwin.Form.InputControl.is_input_field +ida_kernwin.Form.LabelControl +ida_kernwin.Form.LabelControl.__init__ +ida_kernwin.Form.LabelControl.get_tag +ida_kernwin.Form.MoveField +ida_kernwin.Form.MultiLineTextControl +ida_kernwin.Form.MultiLineTextControl.__init__ +ida_kernwin.Form.MultiLineTextControl.free +ida_kernwin.Form.NumericArgument +ida_kernwin.Form.NumericArgument.__init__ +ida_kernwin.Form.NumericArgument.__set_value +ida_kernwin.Form.NumericInput +ida_kernwin.Form.NumericInput.__init__ +ida_kernwin.Form.NumericLabel +ida_kernwin.Form.NumericLabel.__init__ +ida_kernwin.Form.Open +ida_kernwin.Form.RadGroupControl +ida_kernwin.Form.RadGroupControl.__init__ +ida_kernwin.Form.RadGroupItemControl +ida_kernwin.Form.RadGroupItemControl.__get_value +ida_kernwin.Form.RadGroupItemControl.__init__ +ida_kernwin.Form.RadGroupItemControl.__set_value +ida_kernwin.Form.RadGroupItemControl.selected +ida_kernwin.Form.RefreshField +ida_kernwin.Form.SetControlValue +ida_kernwin.Form.SetFocusedField +ida_kernwin.Form.ShowField +ida_kernwin.Form.StringArgument +ida_kernwin.Form.StringArgument.__get_value +ida_kernwin.Form.StringArgument.__init__ +ida_kernwin.Form.StringArgument.__set_value +ida_kernwin.Form.StringInput +ida_kernwin.Form.StringInput.__init__ +ida_kernwin.Form.StringLabel +ida_kernwin.Form.StringLabel.__init__ +ida_kernwin.Form._AddGroup +ida_kernwin.Form._ChkCompiled +ida_kernwin.Form._FT_USHORT +ida_kernwin.Form._ParseFormTitle +ida_kernwin.Form.__getitem__ +ida_kernwin.Form.__init__ +ida_kernwin.Form._reset +ida_kernwin.Form.create_string_buffer +ida_kernwin.Form.fieldtype_to_ctype +ida_kernwin.GCRF_ALL +ida_kernwin.GCRF_CURRENT +ida_kernwin.GCRF_HEADER +ida_kernwin.GCRF_SELECTION +ida_kernwin.HIF_IDENTIFIER +ida_kernwin.HIF_LOCKED +ida_kernwin.HIF_NOCASE +ida_kernwin.HIF_REGISTER +ida_kernwin.HIF_SLOT_0 +ida_kernwin.HIF_SLOT_1 +ida_kernwin.HIF_SLOT_2 +ida_kernwin.HIF_SLOT_3 +ida_kernwin.HIF_SLOT_4 +ida_kernwin.HIF_SLOT_5 +ida_kernwin.HIF_SLOT_6 +ida_kernwin.HIF_SLOT_7 +ida_kernwin.HIF_SLOT_SHIFT +ida_kernwin.HIF_USE_SLOT +ida_kernwin.HIST_CMD +ida_kernwin.HIST_CMT +ida_kernwin.HIST_DIR +ida_kernwin.HIST_FILE +ida_kernwin.HIST_IDENT +ida_kernwin.HIST_IDENT2 +ida_kernwin.HIST_SEG +ida_kernwin.HIST_SRCH +ida_kernwin.HIST_TYPE +ida_kernwin.IDAViewWrapper +ida_kernwin.IDAViewWrapper.Bind +ida_kernwin.IDAViewWrapper.Unbind +ida_kernwin.IDAViewWrapper.__init__ +ida_kernwin.IDA_DEBUG_ACCESSIBILITY +ida_kernwin.IDA_DEBUG_ALREADY +ida_kernwin.IDA_DEBUG_ALWAYS +ida_kernwin.IDA_DEBUG_APPCALL +ida_kernwin.IDA_DEBUG_CHECKMEM +ida_kernwin.IDA_DEBUG_CONFIG +ida_kernwin.IDA_DEBUG_DBGINFO +ida_kernwin.IDA_DEBUG_DEBUGGER +ida_kernwin.IDA_DEBUG_DEMANGLE +ida_kernwin.IDA_DEBUG_DREFS +ida_kernwin.IDA_DEBUG_FLIRT +ida_kernwin.IDA_DEBUG_IDP +ida_kernwin.IDA_DEBUG_IDS +ida_kernwin.IDA_DEBUG_INTERNET +ida_kernwin.IDA_DEBUG_LDR +ida_kernwin.IDA_DEBUG_LICENSE +ida_kernwin.IDA_DEBUG_LUMINA +ida_kernwin.IDA_DEBUG_NETWORK +ida_kernwin.IDA_DEBUG_NOTIFY +ida_kernwin.IDA_DEBUG_OFFSET +ida_kernwin.IDA_DEBUG_PLUGIN +ida_kernwin.IDA_DEBUG_QUEUE +ida_kernwin.IDA_DEBUG_RANGECB +ida_kernwin.IDA_DEBUG_REGEX +ida_kernwin.IDA_DEBUG_ROLLBACK +ida_kernwin.IDA_DEBUG_SIMPLEX +ida_kernwin.IDA_DEBUG_SRCDBG +ida_kernwin.IDA_DEBUG_SUBPROC +ida_kernwin.IDA_DEBUG_THEMES +ida_kernwin.IDA_DEBUG_TIL +ida_kernwin.IDCHK_ARG +ida_kernwin.IDCHK_KEY +ida_kernwin.IDCHK_MAX +ida_kernwin.IDCHK_OK +ida_kernwin.IWID_ADDRWATCH +ida_kernwin.IWID_ALL +ida_kernwin.IWID_ANY_LISTING +ida_kernwin.IWID_BOOKMARKS +ida_kernwin.IWID_BPTS +ida_kernwin.IWID_CALLS +ida_kernwin.IWID_CALLS_CALLEES +ida_kernwin.IWID_CALLS_CALLERS +ida_kernwin.IWID_CALL_STACK +ida_kernwin.IWID_CHOOSER +ida_kernwin.IWID_CLI +ida_kernwin.IWID_CMDPALCSR +ida_kernwin.IWID_CMDPALWIN +ida_kernwin.IWID_CPUREGS +ida_kernwin.IWID_CUSTVIEW +ida_kernwin.IWID_CV_LINE_INFOS +ida_kernwin.IWID_DISASM +ida_kernwin.IWID_DISASM_ARROWS +ida_kernwin.IWID_EA_LISTING +ida_kernwin.IWID_EXPORTS +ida_kernwin.IWID_FRAME +ida_kernwin.IWID_FUNCS +ida_kernwin.IWID_HEXVIEW +ida_kernwin.IWID_IMPORTS +ida_kernwin.IWID_LOCALS +ida_kernwin.IWID_MDVIEWCSR +ida_kernwin.IWID_MODULES +ida_kernwin.IWID_NAMES +ida_kernwin.IWID_NAVBAND +ida_kernwin.IWID_NOTEPAD +ida_kernwin.IWID_OUTPUT +ida_kernwin.IWID_PROBS +ida_kernwin.IWID_PSEUDOCODE +ida_kernwin.IWID_SCRIPTS_CSR +ida_kernwin.IWID_SEARCH +ida_kernwin.IWID_SEGREGS +ida_kernwin.IWID_SEGS +ida_kernwin.IWID_SELS +ida_kernwin.IWID_SHORTCUTCSR +ida_kernwin.IWID_SHORTCUTWIN +ida_kernwin.IWID_SIGNS +ida_kernwin.IWID_SNIPPETS +ida_kernwin.IWID_SNIPPETS_CSR +ida_kernwin.IWID_SO_OFFSETS +ida_kernwin.IWID_SO_STRUCTS +ida_kernwin.IWID_SRCPTHMAP_CSR +ida_kernwin.IWID_SRCPTHUND_CSR +ida_kernwin.IWID_STKVIEW +ida_kernwin.IWID_STRINGS +ida_kernwin.IWID_THREADS +ida_kernwin.IWID_TICSR +ida_kernwin.IWID_TILIST +ida_kernwin.IWID_TILS +ida_kernwin.IWID_TIL_VIEW +ida_kernwin.IWID_TRACE +ida_kernwin.IWID_UNDOHIST +ida_kernwin.IWID_WATCH +ida_kernwin.IWID_XREFS +ida_kernwin.LROEF_CPS_RANGE +ida_kernwin.LROEF_FULL_LINE +ida_kernwin.MFF_FAST +ida_kernwin.MFF_NOWAIT +ida_kernwin.MFF_READ +ida_kernwin.MFF_WRITE +ida_kernwin.PCF_EA_CAPABLE +ida_kernwin.PCF_MAKEPLACE_ALLOCATES +ida_kernwin.PluginForm +ida_kernwin.PluginForm.Close +ida_kernwin.PluginForm.GetWidget +ida_kernwin.PluginForm.OnClose +ida_kernwin.PluginForm.OnCreate +ida_kernwin.PluginForm.QtWidgetToTWidget +ida_kernwin.PluginForm.Show +ida_kernwin.PluginForm.WCLS_DELETE_LATER +ida_kernwin.PluginForm.WCLS_DONT_SAVE_SIZE +ida_kernwin.PluginForm.WCLS_NO_CONTEXT +ida_kernwin.PluginForm.WCLS_SAVE +ida_kernwin.PluginForm.WOPN_DP_BEFORE +ida_kernwin.PluginForm.WOPN_DP_BOTTOM +ida_kernwin.PluginForm.WOPN_DP_FLOATING +ida_kernwin.PluginForm.WOPN_DP_INSIDE +ida_kernwin.PluginForm.WOPN_DP_LEFT +ida_kernwin.PluginForm.WOPN_DP_RIGHT +ida_kernwin.PluginForm.WOPN_DP_SZHINT +ida_kernwin.PluginForm.WOPN_DP_TAB +ida_kernwin.PluginForm.WOPN_DP_TOP +ida_kernwin.PluginForm.WOPN_PERSIST +ida_kernwin.PluginForm.WOPN_RESTORE +ida_kernwin.PluginForm.__init__ +ida_kernwin.PluginForm._ensure_widget_deps +ida_kernwin.RENADDR_HR +ida_kernwin.RENADDR_IDA +ida_kernwin.S2EAOPT_NOCALC +ida_kernwin.SETMENU_APP +ida_kernwin.SETMENU_ENSURE_SEP +ida_kernwin.SETMENU_FIRST +ida_kernwin.SETMENU_INS +ida_kernwin.SVF_COPY_LINES +ida_kernwin.SVF_LINES_BYPTR +ida_kernwin.TCCPT_IDAPLACE +ida_kernwin.TCCPT_INVALID +ida_kernwin.TCCPT_PLACE +ida_kernwin.TCCPT_SIMPLELINE_PLACE +ida_kernwin.TCCPT_TIPLACE +ida_kernwin.TCCRT_FLAT +ida_kernwin.TCCRT_GRAPH +ida_kernwin.TCCRT_INVALID +ida_kernwin.TCCRT_PROXIMITY +ida_kernwin.TWidget__from_ptrval__ +ida_kernwin.UIJMP_ACTIVATE +ida_kernwin.UIJMP_ANYVIEW +ida_kernwin.UIJMP_DONTPUSH +ida_kernwin.UIJMP_IDAVIEW +ida_kernwin.UIJMP_IDAVIEW_NEW +ida_kernwin.UI_Hooks +ida_kernwin.UI_Hooks.__disown__ +ida_kernwin.UI_Hooks.__init__ +ida_kernwin.UI_Hooks.create_desktop_widget +ida_kernwin.UI_Hooks.current_widget_changed +ida_kernwin.UI_Hooks.database_closed +ida_kernwin.UI_Hooks.database_inited +ida_kernwin.UI_Hooks.debugger_menu_change +ida_kernwin.UI_Hooks.desktop_applied +ida_kernwin.UI_Hooks.destroying_plugmod +ida_kernwin.UI_Hooks.destroying_procmod +ida_kernwin.UI_Hooks.finish_populating_widget_popup +ida_kernwin.UI_Hooks.get_chooser_item_attrs +ida_kernwin.UI_Hooks.get_custom_viewer_hint +ida_kernwin.UI_Hooks.get_ea_hint +ida_kernwin.UI_Hooks.get_item_hint +ida_kernwin.UI_Hooks.get_lines_rendering_info +ida_kernwin.UI_Hooks.get_widget_config +ida_kernwin.UI_Hooks.hook +ida_kernwin.UI_Hooks.idcstart +ida_kernwin.UI_Hooks.idcstop +ida_kernwin.UI_Hooks.initing_database +ida_kernwin.UI_Hooks.plugin_loaded +ida_kernwin.UI_Hooks.plugin_unloading +ida_kernwin.UI_Hooks.populating_widget_popup +ida_kernwin.UI_Hooks.postprocess_action +ida_kernwin.UI_Hooks.preprocess_action +ida_kernwin.UI_Hooks.range +ida_kernwin.UI_Hooks.ready_to_run +ida_kernwin.UI_Hooks.resume +ida_kernwin.UI_Hooks.saved +ida_kernwin.UI_Hooks.saving +ida_kernwin.UI_Hooks.screen_ea_changed +ida_kernwin.UI_Hooks.set_widget_config +ida_kernwin.UI_Hooks.suspend +ida_kernwin.UI_Hooks.unhook +ida_kernwin.UI_Hooks.updated_actions +ida_kernwin.UI_Hooks.updating_actions +ida_kernwin.UI_Hooks.widget_closing +ida_kernwin.UI_Hooks.widget_invisible +ida_kernwin.UI_Hooks.widget_visible +ida_kernwin.VES_SHIFT +ida_kernwin.VME_LEFT_BUTTON +ida_kernwin.VME_MID_BUTTON +ida_kernwin.VME_RIGHT_BUTTON +ida_kernwin.VME_UNKNOWN +ida_kernwin.View_Hooks +ida_kernwin.View_Hooks.__disown__ +ida_kernwin.View_Hooks.__init__ +ida_kernwin.View_Hooks.hook +ida_kernwin.View_Hooks.unhook +ida_kernwin.View_Hooks.view_activated +ida_kernwin.View_Hooks.view_click +ida_kernwin.View_Hooks.view_close +ida_kernwin.View_Hooks.view_created +ida_kernwin.View_Hooks.view_curpos +ida_kernwin.View_Hooks.view_dblclick +ida_kernwin.View_Hooks.view_deactivated +ida_kernwin.View_Hooks.view_keydown +ida_kernwin.View_Hooks.view_loc_changed +ida_kernwin.View_Hooks.view_mouse_moved +ida_kernwin.View_Hooks.view_mouse_over +ida_kernwin.View_Hooks.view_switched +ida_kernwin.WCLS_DELETE_LATER +ida_kernwin.WCLS_DONT_SAVE_SIZE +ida_kernwin.WCLS_NO_CONTEXT +ida_kernwin.WCLS_SAVE +ida_kernwin.WOPN_CLOSED_BY_ESC +ida_kernwin.WOPN_DP_BEFORE +ida_kernwin.WOPN_DP_BOTTOM +ida_kernwin.WOPN_DP_FLOATING +ida_kernwin.WOPN_DP_INSIDE +ida_kernwin.WOPN_DP_LEFT +ida_kernwin.WOPN_DP_RIGHT +ida_kernwin.WOPN_DP_SZHINT +ida_kernwin.WOPN_DP_TAB +ida_kernwin.WOPN_DP_TOP +ida_kernwin.WOPN_NOT_CLOSED_BY_ESC +ida_kernwin.WOPN_PERSIST +ida_kernwin.WOPN_RESTORE +ida_kernwin.__qtimer_t +ida_kernwin.__qtimer_t.__init__ +ida_kernwin._ask_addr +ida_kernwin._ask_long +ida_kernwin._ask_seg +ida_kernwin._kludge_force_declare_dirspec_t +ida_kernwin._kludge_force_declare_dirtree_t +ida_kernwin.action_ctx_base_cur_sel_t +ida_kernwin.action_ctx_base_cur_sel_t.__init__ +ida_kernwin.action_ctx_base_cur_sel_t.reset +ida_kernwin.action_ctx_base_cur_sel_t.to +ida_kernwin.action_ctx_base_t +ida_kernwin.action_ctx_base_t.__init__ +ida_kernwin.action_ctx_base_t.action +ida_kernwin.action_ctx_base_t.chooser +ida_kernwin.action_ctx_base_t.chooser_selection +ida_kernwin.action_ctx_base_t.cur_ea +ida_kernwin.action_ctx_base_t.cur_fchunk +ida_kernwin.action_ctx_base_t.cur_flags +ida_kernwin.action_ctx_base_t.cur_func +ida_kernwin.action_ctx_base_t.cur_seg +ida_kernwin.action_ctx_base_t.cur_sel +ida_kernwin.action_ctx_base_t.cur_value +ida_kernwin.action_ctx_base_t.dirtree_selection +ida_kernwin.action_ctx_base_t.focus +ida_kernwin.action_ctx_base_t.graph +ida_kernwin.action_ctx_base_t.graph_selection +ida_kernwin.action_ctx_base_t.has_flag +ida_kernwin.action_ctx_base_t.hovered +ida_kernwin.action_ctx_base_t.regname +ida_kernwin.action_ctx_base_t.reset +ida_kernwin.action_ctx_base_t.type_ref +ida_kernwin.action_ctx_base_t.widget_title +ida_kernwin.action_ctx_base_t.widget_type +ida_kernwin.action_desc_t +ida_kernwin.action_desc_t.__init__ +ida_kernwin.action_desc_t.cb +ida_kernwin.action_desc_t.flags +ida_kernwin.action_desc_t.icon +ida_kernwin.action_desc_t.label +ida_kernwin.action_desc_t.name +ida_kernwin.action_desc_t.owner +ida_kernwin.action_desc_t.shortcut +ida_kernwin.action_desc_t.tooltip +ida_kernwin.action_handler_t +ida_kernwin.action_handler_t.__init__ +ida_kernwin.action_handler_t.activate +ida_kernwin.action_handler_t.update +ida_kernwin.activate_widget +ida_kernwin.add_hotkey +ida_kernwin.add_idc_hotkey +ida_kernwin.add_spaces +ida_kernwin.addon_count +ida_kernwin.addon_info_t +ida_kernwin.addon_info_t.__init__ +ida_kernwin.analyzer_options +ida_kernwin.ask_addr +ida_kernwin.ask_buttons +ida_kernwin.ask_file +ida_kernwin.ask_for_feedback +ida_kernwin.ask_form +ida_kernwin.ask_ident +ida_kernwin.ask_ident2 +ida_kernwin.ask_long +ida_kernwin.ask_seg +ida_kernwin.ask_str +ida_kernwin.ask_text +ida_kernwin.ask_yn +ida_kernwin.atoea +ida_kernwin.attach_action_to_menu +ida_kernwin.attach_action_to_popup +ida_kernwin.attach_action_to_toolbar +ida_kernwin.attach_dynamic_action_to_popup +ida_kernwin.banner +ida_kernwin.beep +ida_kernwin.call_nav_colorizer +ida_kernwin.cancel_exec_request +ida_kernwin.cancel_thread_exec_requests +ida_kernwin.choose_activate +ida_kernwin.choose_choose +ida_kernwin.choose_close +ida_kernwin.choose_create_embedded_chobj +ida_kernwin.choose_entry +ida_kernwin.choose_enum +ida_kernwin.choose_enum_by_value +ida_kernwin.choose_find +ida_kernwin.choose_func +ida_kernwin.choose_get_widget +ida_kernwin.choose_idasgn +ida_kernwin.choose_name +ida_kernwin.choose_refresh +ida_kernwin.choose_segm +ida_kernwin.choose_srcp +ida_kernwin.choose_stkvar_xref +ida_kernwin.choose_struct +ida_kernwin.choose_til +ida_kernwin.choose_xref +ida_kernwin.chooser_base_t +ida_kernwin.chooser_base_t.__init__ +ida_kernwin.chooser_base_t.ask_item_attrs +ida_kernwin.chooser_base_t.can_del +ida_kernwin.chooser_base_t.can_edit +ida_kernwin.chooser_base_t.can_filter +ida_kernwin.chooser_base_t.can_ins +ida_kernwin.chooser_base_t.can_refresh +ida_kernwin.chooser_base_t.can_sort +ida_kernwin.chooser_base_t.columns +ida_kernwin.chooser_base_t.deflt_col +ida_kernwin.chooser_base_t.get_builtin_number +ida_kernwin.chooser_base_t.get_count +ida_kernwin.chooser_base_t.get_ea +ida_kernwin.chooser_base_t.get_quick_filter_initial_mode +ida_kernwin.chooser_base_t.get_row +ida_kernwin.chooser_base_t.has_diff_capability +ida_kernwin.chooser_base_t.has_dirtree +ida_kernwin.chooser_base_t.has_inode_to_index +ida_kernwin.chooser_base_t.has_widget_lifecycle +ida_kernwin.chooser_base_t.header +ida_kernwin.chooser_base_t.height +ida_kernwin.chooser_base_t.icon +ida_kernwin.chooser_base_t.is_dirtree_persisted +ida_kernwin.chooser_base_t.is_force_default +ida_kernwin.chooser_base_t.is_lazy_loaded +ida_kernwin.chooser_base_t.is_modal +ida_kernwin.chooser_base_t.is_multi +ida_kernwin.chooser_base_t.is_quick_filter_visible_initially +ida_kernwin.chooser_base_t.is_same +ida_kernwin.chooser_base_t.is_status_bar_hidden +ida_kernwin.chooser_base_t.popup_allowed +ida_kernwin.chooser_base_t.popup_names +ida_kernwin.chooser_base_t.should_rename_trigger_edit +ida_kernwin.chooser_base_t.should_restore_geometry +ida_kernwin.chooser_base_t.title +ida_kernwin.chooser_base_t.width +ida_kernwin.chooser_base_t.widths +ida_kernwin.chooser_base_t.x0 +ida_kernwin.chooser_item_attrs_t +ida_kernwin.chooser_item_attrs_t.__eq__ +ida_kernwin.chooser_item_attrs_t.__init__ +ida_kernwin.chooser_item_attrs_t.color +ida_kernwin.chooser_item_attrs_t.flags +ida_kernwin.chooser_item_attrs_t.reset +ida_kernwin.chooser_row_info_t +ida_kernwin.chooser_row_info_t.__eq__ +ida_kernwin.chooser_row_info_t.__init__ +ida_kernwin.chooser_row_info_t.__ne__ +ida_kernwin.chooser_row_info_t.attrs +ida_kernwin.chooser_row_info_t.icon +ida_kernwin.chooser_row_info_t.texts +ida_kernwin.chooser_row_info_vec_t +ida_kernwin.chooser_row_info_vec_t.__eq__ +ida_kernwin.chooser_row_info_vec_t.__getitem__ +ida_kernwin.chooser_row_info_vec_t.__init__ +ida_kernwin.chooser_row_info_vec_t.__len__ +ida_kernwin.chooser_row_info_vec_t.__ne__ +ida_kernwin.chooser_row_info_vec_t.__setitem__ +ida_kernwin.chooser_row_info_vec_t._del +ida_kernwin.chooser_row_info_vec_t.add_unique +ida_kernwin.chooser_row_info_vec_t.append +ida_kernwin.chooser_row_info_vec_t.at +ida_kernwin.chooser_row_info_vec_t.begin +ida_kernwin.chooser_row_info_vec_t.capacity +ida_kernwin.chooser_row_info_vec_t.clear +ida_kernwin.chooser_row_info_vec_t.empty +ida_kernwin.chooser_row_info_vec_t.end +ida_kernwin.chooser_row_info_vec_t.erase +ida_kernwin.chooser_row_info_vec_t.extend +ida_kernwin.chooser_row_info_vec_t.extract +ida_kernwin.chooser_row_info_vec_t.find +ida_kernwin.chooser_row_info_vec_t.grow +ida_kernwin.chooser_row_info_vec_t.has +ida_kernwin.chooser_row_info_vec_t.inject +ida_kernwin.chooser_row_info_vec_t.insert +ida_kernwin.chooser_row_info_vec_t.pop_back +ida_kernwin.chooser_row_info_vec_t.push_back +ida_kernwin.chooser_row_info_vec_t.qclear +ida_kernwin.chooser_row_info_vec_t.reserve +ida_kernwin.chooser_row_info_vec_t.resize +ida_kernwin.chooser_row_info_vec_t.size +ida_kernwin.chooser_row_info_vec_t.swap +ida_kernwin.chooser_row_info_vec_t.truncate +ida_kernwin.chooser_stdact_desc_t +ida_kernwin.chooser_stdact_desc_t.__disown__ +ida_kernwin.chooser_stdact_desc_t.__init__ +ida_kernwin.chooser_stdact_desc_t.label +ida_kernwin.chooser_stdact_desc_t.ucb +ida_kernwin.chooser_stdact_desc_t.version +ida_kernwin.chtype_entry +ida_kernwin.chtype_enum +ida_kernwin.chtype_enum_by_value_and_size +ida_kernwin.chtype_func +ida_kernwin.chtype_generic +ida_kernwin.chtype_idasgn +ida_kernwin.chtype_idatil +ida_kernwin.chtype_name +ida_kernwin.chtype_segm +ida_kernwin.chtype_srcp +ida_kernwin.chtype_stkvar_xref +ida_kernwin.chtype_strpath +ida_kernwin.chtype_struct +ida_kernwin.chtype_xref +ida_kernwin.clear_refresh_request +ida_kernwin.cli_t +ida_kernwin.cli_t.OnExecuteLine +ida_kernwin.cli_t.OnFindCompletions +ida_kernwin.cli_t.OnKeydown +ida_kernwin.cli_t.__del__ +ida_kernwin.cli_t.__init__ +ida_kernwin.cli_t.register +ida_kernwin.cli_t.unregister +ida_kernwin.close_chooser +ida_kernwin.close_widget +ida_kernwin.clr_cancelled +ida_kernwin.create_code_viewer +ida_kernwin.create_empty_widget +ida_kernwin.create_menu +ida_kernwin.create_toolbar +ida_kernwin.custom_viewer_jump +ida_kernwin.del_hotkey +ida_kernwin.del_idc_hotkey +ida_kernwin.delete_menu +ida_kernwin.delete_toolbar +ida_kernwin.detach_action_from_menu +ida_kernwin.detach_action_from_popup +ida_kernwin.detach_action_from_toolbar +ida_kernwin.disabled_script_timeout_t +ida_kernwin.disabled_script_timeout_t.__enter__ +ida_kernwin.disabled_script_timeout_t.__exit__ +ida_kernwin.disasm_line_t +ida_kernwin.disasm_line_t.__init__ +ida_kernwin.disasm_text_t +ida_kernwin.disasm_text_t.__getitem__ +ida_kernwin.disasm_text_t.__init__ +ida_kernwin.disasm_text_t.__len__ +ida_kernwin.disasm_text_t.__setitem__ +ida_kernwin.disasm_text_t.append +ida_kernwin.disasm_text_t.at +ida_kernwin.disasm_text_t.begin +ida_kernwin.disasm_text_t.capacity +ida_kernwin.disasm_text_t.clear +ida_kernwin.disasm_text_t.empty +ida_kernwin.disasm_text_t.end +ida_kernwin.disasm_text_t.erase +ida_kernwin.disasm_text_t.extend +ida_kernwin.disasm_text_t.extract +ida_kernwin.disasm_text_t.grow +ida_kernwin.disasm_text_t.inject +ida_kernwin.disasm_text_t.insert +ida_kernwin.disasm_text_t.pop_back +ida_kernwin.disasm_text_t.push_back +ida_kernwin.disasm_text_t.qclear +ida_kernwin.disasm_text_t.reserve +ida_kernwin.disasm_text_t.resize +ida_kernwin.disasm_text_t.size +ida_kernwin.disasm_text_t.swap +ida_kernwin.disasm_text_t.truncate +ida_kernwin.display_copyright_warning +ida_kernwin.display_widget +ida_kernwin.ea2str +ida_kernwin.ea_viewer_history_push_and_jump +ida_kernwin.enable_chooser_item_attrs +ida_kernwin.error +ida_kernwin.execute_sync +ida_kernwin.execute_ui_requests +ida_kernwin.find_widget +ida_kernwin.formchgcbfa_close +ida_kernwin.formchgcbfa_enable_field +ida_kernwin.formchgcbfa_get_field_value +ida_kernwin.formchgcbfa_get_focused_field +ida_kernwin.formchgcbfa_move_field +ida_kernwin.formchgcbfa_refresh_field +ida_kernwin.formchgcbfa_set_field_value +ida_kernwin.formchgcbfa_set_focused_field +ida_kernwin.formchgcbfa_show_field +ida_kernwin.free_custom_icon +ida_kernwin.gen_disasm_text +ida_kernwin.get_action_checkable +ida_kernwin.get_action_checked +ida_kernwin.get_action_icon +ida_kernwin.get_action_label +ida_kernwin.get_action_shortcut +ida_kernwin.get_action_state +ida_kernwin.get_action_tooltip +ida_kernwin.get_action_visibility +ida_kernwin.get_active_modal_widget +ida_kernwin.get_addon_info +ida_kernwin.get_addon_info_idx +ida_kernwin.get_chooser_data +ida_kernwin.get_chooser_obj +ida_kernwin.get_chooser_rows +ida_kernwin.get_curline +ida_kernwin.get_current_viewer +ida_kernwin.get_current_widget +ida_kernwin.get_cursor +ida_kernwin.get_custom_viewer_curline +ida_kernwin.get_custom_viewer_location +ida_kernwin.get_custom_viewer_place +ida_kernwin.get_custom_viewer_place_xcoord +ida_kernwin.get_ea_viewer_history_info +ida_kernwin.get_hexdump_ea +ida_kernwin.get_highlight +ida_kernwin.get_icon_id_by_name +ida_kernwin.get_kernel_version +ida_kernwin.get_key_code +ida_kernwin.get_last_widget +ida_kernwin.get_navband_ea +ida_kernwin.get_navband_pixel +ida_kernwin.get_opnum +ida_kernwin.get_output_curline +ida_kernwin.get_output_cursor +ida_kernwin.get_output_selected_text +ida_kernwin.get_place_class +ida_kernwin.get_place_class_id +ida_kernwin.get_place_class_template +ida_kernwin.get_registered_actions +ida_kernwin.get_screen_ea +ida_kernwin.get_synced_group +ida_kernwin.get_tab_size +ida_kernwin.get_user_input_event +ida_kernwin.get_user_strlist_options +ida_kernwin.get_view_renderer_type +ida_kernwin.get_viewer_place_type +ida_kernwin.get_viewer_user_data +ida_kernwin.get_widget_title +ida_kernwin.get_widget_type +ida_kernwin.get_window_id +ida_kernwin.hide_wait_box +ida_kernwin.idaplace_t +ida_kernwin.idaplace_t.__init__ +ida_kernwin.idaplace_t.ea +ida_kernwin.info +ida_kernwin.input_event_keyboard_data_t +ida_kernwin.input_event_keyboard_data_t.__init__ +ida_kernwin.input_event_mouse_data_t +ida_kernwin.input_event_mouse_data_t.__init__ +ida_kernwin.input_event_shortcut_data_t +ida_kernwin.input_event_shortcut_data_t.__init__ +ida_kernwin.input_event_t +ida_kernwin.input_event_t.__init__ +ida_kernwin.input_event_t._source_as_size +ida_kernwin.input_event_t._target_as_size +ida_kernwin.input_event_t.cb +ida_kernwin.input_event_t.get_source_QEvent +ida_kernwin.input_event_t.get_target_QWidget +ida_kernwin.input_event_t.kind +ida_kernwin.input_event_t.modifiers +ida_kernwin.input_event_t.source +ida_kernwin.input_event_t.target +ida_kernwin.install_command_interpreter +ida_kernwin.internal_register_place_class +ida_kernwin.is_action_enabled +ida_kernwin.is_chooser_widget +ida_kernwin.is_ida_library +ida_kernwin.is_idaq +ida_kernwin.is_idaview +ida_kernwin.is_msg_inited +ida_kernwin.is_place_class_ea_capable +ida_kernwin.is_refresh_requested +ida_kernwin.is_tif_cursor_footer +ida_kernwin.is_tif_cursor_header +ida_kernwin.is_tif_cursor_index +ida_kernwin.jobj_wrapper_t +ida_kernwin.jobj_wrapper_t.__init__ +ida_kernwin.jobj_wrapper_t.get_dict +ida_kernwin.jumpto +ida_kernwin.l_compare2 +ida_kernwin.line_rendering_output_entries_refs_t +ida_kernwin.line_rendering_output_entries_refs_t.__eq__ +ida_kernwin.line_rendering_output_entries_refs_t.__getitem__ +ida_kernwin.line_rendering_output_entries_refs_t.__init__ +ida_kernwin.line_rendering_output_entries_refs_t.__len__ +ida_kernwin.line_rendering_output_entries_refs_t.__ne__ +ida_kernwin.line_rendering_output_entries_refs_t.__setitem__ +ida_kernwin.line_rendering_output_entries_refs_t._del +ida_kernwin.line_rendering_output_entries_refs_t._internal_push_back +ida_kernwin.line_rendering_output_entries_refs_t.add_unique +ida_kernwin.line_rendering_output_entries_refs_t.append +ida_kernwin.line_rendering_output_entries_refs_t.at +ida_kernwin.line_rendering_output_entries_refs_t.begin +ida_kernwin.line_rendering_output_entries_refs_t.capacity +ida_kernwin.line_rendering_output_entries_refs_t.clear +ida_kernwin.line_rendering_output_entries_refs_t.empty +ida_kernwin.line_rendering_output_entries_refs_t.end +ida_kernwin.line_rendering_output_entries_refs_t.erase +ida_kernwin.line_rendering_output_entries_refs_t.extend +ida_kernwin.line_rendering_output_entries_refs_t.extract +ida_kernwin.line_rendering_output_entries_refs_t.find +ida_kernwin.line_rendering_output_entries_refs_t.has +ida_kernwin.line_rendering_output_entries_refs_t.inject +ida_kernwin.line_rendering_output_entries_refs_t.insert +ida_kernwin.line_rendering_output_entries_refs_t.pop_back +ida_kernwin.line_rendering_output_entries_refs_t.push_back +ida_kernwin.line_rendering_output_entries_refs_t.push_back +ida_kernwin.line_rendering_output_entries_refs_t.qclear +ida_kernwin.line_rendering_output_entries_refs_t.reserve +ida_kernwin.line_rendering_output_entries_refs_t.resize +ida_kernwin.line_rendering_output_entries_refs_t.size +ida_kernwin.line_rendering_output_entries_refs_t.swap +ida_kernwin.line_rendering_output_entries_refs_t.truncate +ida_kernwin.line_rendering_output_entry_t +ida_kernwin.line_rendering_output_entry_t.__eq__ +ida_kernwin.line_rendering_output_entry_t.__init__ +ida_kernwin.line_rendering_output_entry_t.__ne__ +ida_kernwin.line_rendering_output_entry_t.cpx +ida_kernwin.line_rendering_output_entry_t.flags +ida_kernwin.line_rendering_output_entry_t.is_bg_color_direct +ida_kernwin.line_rendering_output_entry_t.is_bg_color_empty +ida_kernwin.line_rendering_output_entry_t.is_bg_color_key +ida_kernwin.line_rendering_output_entry_t.nchars +ida_kernwin.line_section_t +ida_kernwin.line_section_t.__eq__ +ida_kernwin.line_section_t.__init__ +ida_kernwin.line_section_t.__ne__ +ida_kernwin.line_section_t.contains +ida_kernwin.line_section_t.is_closed +ida_kernwin.line_section_t.is_open +ida_kernwin.line_section_t.valid +ida_kernwin.linearray_t +ida_kernwin.linearray_t.__init__ +ida_kernwin.linearray_t.beginning +ida_kernwin.linearray_t.down +ida_kernwin.linearray_t.ending +ida_kernwin.linearray_t.get_bg_color +ida_kernwin.linearray_t.get_dlnnum +ida_kernwin.linearray_t.get_linecnt +ida_kernwin.linearray_t.get_pfx_color +ida_kernwin.linearray_t.get_place +ida_kernwin.linearray_t.set_place +ida_kernwin.linearray_t.set_userdata +ida_kernwin.linearray_t.up +ida_kernwin.linearray_t.userdata +ida_kernwin.lines_rendering_input_t +ida_kernwin.lines_rendering_input_t.__init__ +ida_kernwin.lines_rendering_input_t.sections_lines +ida_kernwin.lines_rendering_input_t.sync_group +ida_kernwin.lines_rendering_output_t +ida_kernwin.lines_rendering_output_t.__eq__ +ida_kernwin.lines_rendering_output_t.__init__ +ida_kernwin.lines_rendering_output_t.__ne__ +ida_kernwin.lines_rendering_output_t.clear +ida_kernwin.lines_rendering_output_t.swap +ida_kernwin.listing_location_t +ida_kernwin.listing_location_t.__init__ +ida_kernwin.load_custom_icon +ida_kernwin.load_dbg_dbginfo +ida_kernwin.lookup_key_code +ida_kernwin.mbox_internal +ida_kernwin.msg +ida_kernwin.msg_activated +ida_kernwin.msg_clear +ida_kernwin.msg_click +ida_kernwin.msg_closed +ida_kernwin.msg_dblclick +ida_kernwin.msg_deactivated +ida_kernwin.msg_get_lines +ida_kernwin.msg_keydown +ida_kernwin.msg_save +ida_kernwin.nomem +ida_kernwin.open_bookmarks_window +ida_kernwin.open_bpts_window +ida_kernwin.open_calls_window +ida_kernwin.open_disasm_window +ida_kernwin.open_exports_window +ida_kernwin.open_form +ida_kernwin.open_frame_window +ida_kernwin.open_funcs_window +ida_kernwin.open_hexdump_window +ida_kernwin.open_imports_window +ida_kernwin.open_loctypes_window +ida_kernwin.open_modules_window +ida_kernwin.open_names_window +ida_kernwin.open_navband_window +ida_kernwin.open_notepad_window +ida_kernwin.open_problems_window +ida_kernwin.open_segments_window +ida_kernwin.open_segregs_window +ida_kernwin.open_selectors_window +ida_kernwin.open_signatures_window +ida_kernwin.open_stack_window +ida_kernwin.open_strings_window +ida_kernwin.open_threads_window +ida_kernwin.open_til_view_window +ida_kernwin.open_tils_window +ida_kernwin.open_trace_window +ida_kernwin.open_url +ida_kernwin.open_xrefs_window +ida_kernwin.parse_tagged_line_sections +ida_kernwin.place_t +ida_kernwin.place_t.__init__ +ida_kernwin.place_t._print +ida_kernwin.place_t.adjust +ida_kernwin.place_t.as_idaplace_t +ida_kernwin.place_t.as_simpleline_place_t +ida_kernwin.place_t.as_tiplace_t +ida_kernwin.place_t.beginning +ida_kernwin.place_t.clone +ida_kernwin.place_t.compare +ida_kernwin.place_t.compare2 +ida_kernwin.place_t.copyfrom +ida_kernwin.place_t.deserialize +ida_kernwin.place_t.ending +ida_kernwin.place_t.enter +ida_kernwin.place_t.generate +ida_kernwin.place_t.id +ida_kernwin.place_t.leave +ida_kernwin.place_t.lnnum +ida_kernwin.place_t.makeplace +ida_kernwin.place_t.name +ida_kernwin.place_t.next +ida_kernwin.place_t.prev +ida_kernwin.place_t.rebase +ida_kernwin.place_t.serialize +ida_kernwin.place_t.toea +ida_kernwin.place_t.touval +ida_kernwin.plgform_close +ida_kernwin.plgform_get_widget +ida_kernwin.plgform_new +ida_kernwin.plgform_show +ida_kernwin.process_ui_action +ida_kernwin.prompt_function_prototype +ida_kernwin.py_chooser_base_t_get_row +ida_kernwin.py_get_ask_form +ida_kernwin.py_get_open_form +ida_kernwin.py_load_custom_icon_data +ida_kernwin.py_load_custom_icon_fn +ida_kernwin.py_register_compiled_form +ida_kernwin.py_unregister_compiled_form +ida_kernwin.pyidag_bind +ida_kernwin.pyidag_unbind +ida_kernwin.pyscv_add_line +ida_kernwin.pyscv_clear_lines +ida_kernwin.pyscv_close +ida_kernwin.pyscv_count +ida_kernwin.pyscv_del_line +ida_kernwin.pyscv_edit_line +ida_kernwin.pyscv_get_current_line +ida_kernwin.pyscv_get_current_word +ida_kernwin.pyscv_get_line +ida_kernwin.pyscv_get_pos +ida_kernwin.pyscv_get_selection +ida_kernwin.pyscv_get_widget +ida_kernwin.pyscv_init +ida_kernwin.pyscv_insert_line +ida_kernwin.pyscv_is_focused +ida_kernwin.pyscv_jumpto +ida_kernwin.pyscv_patch_line +ida_kernwin.pyscv_refresh +ida_kernwin.pyscv_show +ida_kernwin.qcleanline +ida_kernwin.quick_widget_commands_t +ida_kernwin.quick_widget_commands_t.__init__ +ida_kernwin.quick_widget_commands_t._ah_t +ida_kernwin.quick_widget_commands_t._ah_t.__init__ +ida_kernwin.quick_widget_commands_t._ah_t.activate +ida_kernwin.quick_widget_commands_t._ah_t.update +ida_kernwin.quick_widget_commands_t._cmd_t +ida_kernwin.quick_widget_commands_t._cmd_t.__init__ +ida_kernwin.quick_widget_commands_t.add +ida_kernwin.quick_widget_commands_t.populate_popup +ida_kernwin.read_range_selection +ida_kernwin.read_selection +ida_kernwin.refresh_chooser +ida_kernwin.refresh_choosers +ida_kernwin.refresh_custom_viewer +ida_kernwin.refresh_idaview +ida_kernwin.refresh_idaview_anyway +ida_kernwin.refresh_navband +ida_kernwin.register_action +ida_kernwin.register_addon +ida_kernwin.register_and_attach_to_menu +ida_kernwin.register_timer +ida_kernwin.remove_command_interpreter +ida_kernwin.renderer_pos_info_t +ida_kernwin.renderer_pos_info_t.__eq__ +ida_kernwin.renderer_pos_info_t.__init__ +ida_kernwin.renderer_pos_info_t.__ne__ +ida_kernwin.renderer_pos_info_t.cx +ida_kernwin.renderer_pos_info_t.cy +ida_kernwin.renderer_pos_info_t.node +ida_kernwin.renderer_pos_info_t.sx +ida_kernwin.repaint_custom_viewer +ida_kernwin.replace_wait_box +ida_kernwin.request_refresh +ida_kernwin.restore_database_snapshot +ida_kernwin.section_lines_refs_t +ida_kernwin.section_lines_refs_t.__eq__ +ida_kernwin.section_lines_refs_t.__getitem__ +ida_kernwin.section_lines_refs_t.__init__ +ida_kernwin.section_lines_refs_t.__len__ +ida_kernwin.section_lines_refs_t.__ne__ +ida_kernwin.section_lines_refs_t.__setitem__ +ida_kernwin.section_lines_refs_t._del +ida_kernwin.section_lines_refs_t.add_unique +ida_kernwin.section_lines_refs_t.append +ida_kernwin.section_lines_refs_t.at +ida_kernwin.section_lines_refs_t.begin +ida_kernwin.section_lines_refs_t.capacity +ida_kernwin.section_lines_refs_t.clear +ida_kernwin.section_lines_refs_t.empty +ida_kernwin.section_lines_refs_t.end +ida_kernwin.section_lines_refs_t.erase +ida_kernwin.section_lines_refs_t.extend +ida_kernwin.section_lines_refs_t.extract +ida_kernwin.section_lines_refs_t.find +ida_kernwin.section_lines_refs_t.has +ida_kernwin.section_lines_refs_t.inject +ida_kernwin.section_lines_refs_t.insert +ida_kernwin.section_lines_refs_t.pop_back +ida_kernwin.section_lines_refs_t.push_back +ida_kernwin.section_lines_refs_t.qclear +ida_kernwin.section_lines_refs_t.reserve +ida_kernwin.section_lines_refs_t.resize +ida_kernwin.section_lines_refs_t.size +ida_kernwin.section_lines_refs_t.swap +ida_kernwin.section_lines_refs_t.truncate +ida_kernwin.sections_lines_refs_t +ida_kernwin.sections_lines_refs_t.__eq__ +ida_kernwin.sections_lines_refs_t.__getitem__ +ida_kernwin.sections_lines_refs_t.__init__ +ida_kernwin.sections_lines_refs_t.__len__ +ida_kernwin.sections_lines_refs_t.__ne__ +ida_kernwin.sections_lines_refs_t.__setitem__ +ida_kernwin.sections_lines_refs_t._del +ida_kernwin.sections_lines_refs_t.add_unique +ida_kernwin.sections_lines_refs_t.append +ida_kernwin.sections_lines_refs_t.at +ida_kernwin.sections_lines_refs_t.begin +ida_kernwin.sections_lines_refs_t.capacity +ida_kernwin.sections_lines_refs_t.clear +ida_kernwin.sections_lines_refs_t.empty +ida_kernwin.sections_lines_refs_t.end +ida_kernwin.sections_lines_refs_t.erase +ida_kernwin.sections_lines_refs_t.extend +ida_kernwin.sections_lines_refs_t.extract +ida_kernwin.sections_lines_refs_t.find +ida_kernwin.sections_lines_refs_t.grow +ida_kernwin.sections_lines_refs_t.has +ida_kernwin.sections_lines_refs_t.inject +ida_kernwin.sections_lines_refs_t.insert +ida_kernwin.sections_lines_refs_t.pop_back +ida_kernwin.sections_lines_refs_t.push_back +ida_kernwin.sections_lines_refs_t.qclear +ida_kernwin.sections_lines_refs_t.reserve +ida_kernwin.sections_lines_refs_t.resize +ida_kernwin.sections_lines_refs_t.size +ida_kernwin.sections_lines_refs_t.swap +ida_kernwin.sections_lines_refs_t.truncate +ida_kernwin.set_cancelled +ida_kernwin.set_code_viewer_handler +ida_kernwin.set_code_viewer_is_source +ida_kernwin.set_code_viewer_line_handlers +ida_kernwin.set_code_viewer_lines_alignment +ida_kernwin.set_code_viewer_lines_icon_margin +ida_kernwin.set_code_viewer_lines_radix +ida_kernwin.set_code_viewer_user_data +ida_kernwin.set_custom_viewer_qt_aware +ida_kernwin.set_dock_pos +ida_kernwin.set_execute_sync_availability +ida_kernwin.set_highlight +ida_kernwin.set_nav_colorizer +ida_kernwin.set_view_renderer_type +ida_kernwin.show_wait_box +ida_kernwin.simplecustviewer_t +ida_kernwin.simplecustviewer_t.AddLine +ida_kernwin.simplecustviewer_t.ClearLines +ida_kernwin.simplecustviewer_t.Close +ida_kernwin.simplecustviewer_t.Count +ida_kernwin.simplecustviewer_t.Create +ida_kernwin.simplecustviewer_t.DelLine +ida_kernwin.simplecustviewer_t.EditLine +ida_kernwin.simplecustviewer_t.GetCurrentLine +ida_kernwin.simplecustviewer_t.GetCurrentWord +ida_kernwin.simplecustviewer_t.GetLine +ida_kernwin.simplecustviewer_t.GetLineNo +ida_kernwin.simplecustviewer_t.GetPos +ida_kernwin.simplecustviewer_t.GetSelection +ida_kernwin.simplecustviewer_t.GetWidget +ida_kernwin.simplecustviewer_t.InsertLine +ida_kernwin.simplecustviewer_t.IsFocused +ida_kernwin.simplecustviewer_t.Jump +ida_kernwin.simplecustviewer_t.OnPopup +ida_kernwin.simplecustviewer_t.PatchLine +ida_kernwin.simplecustviewer_t.Refresh +ida_kernwin.simplecustviewer_t.RefreshCurrent +ida_kernwin.simplecustviewer_t.Show +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.__init__ +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.populating_widget_popup +ida_kernwin.simplecustviewer_t.__init__ +ida_kernwin.simplecustviewer_t.__make_sl_arg +ida_kernwin.simpleline_place_t +ida_kernwin.simpleline_place_t.__init__ +ida_kernwin.simpleline_place_t.n +ida_kernwin.simpleline_t +ida_kernwin.simpleline_t.__init__ +ida_kernwin.simpleline_t.bgcolor +ida_kernwin.simpleline_t.color +ida_kernwin.simpleline_t.line +ida_kernwin.str2ea +ida_kernwin.str2ea_ex +ida_kernwin.strarray +ida_kernwin.strarray_t +ida_kernwin.strarray_t.__init__ +ida_kernwin.sync_source_t +ida_kernwin.sync_source_t.__eq__ +ida_kernwin.sync_source_t.__init__ +ida_kernwin.sync_source_t.__ne__ +ida_kernwin.sync_source_t.get_register +ida_kernwin.sync_source_t.get_widget +ida_kernwin.sync_source_t.is_register +ida_kernwin.sync_source_t.is_widget +ida_kernwin.sync_source_vec_t +ida_kernwin.sync_source_vec_t.__eq__ +ida_kernwin.sync_source_vec_t.__getitem__ +ida_kernwin.sync_source_vec_t.__init__ +ida_kernwin.sync_source_vec_t.__len__ +ida_kernwin.sync_source_vec_t.__ne__ +ida_kernwin.sync_source_vec_t.__setitem__ +ida_kernwin.sync_source_vec_t._del +ida_kernwin.sync_source_vec_t.add_unique +ida_kernwin.sync_source_vec_t.append +ida_kernwin.sync_source_vec_t.at +ida_kernwin.sync_source_vec_t.begin +ida_kernwin.sync_source_vec_t.capacity +ida_kernwin.sync_source_vec_t.clear +ida_kernwin.sync_source_vec_t.empty +ida_kernwin.sync_source_vec_t.end +ida_kernwin.sync_source_vec_t.erase +ida_kernwin.sync_source_vec_t.extend +ida_kernwin.sync_source_vec_t.extract +ida_kernwin.sync_source_vec_t.find +ida_kernwin.sync_source_vec_t.has +ida_kernwin.sync_source_vec_t.inject +ida_kernwin.sync_source_vec_t.insert +ida_kernwin.sync_source_vec_t.pop_back +ida_kernwin.sync_source_vec_t.push_back +ida_kernwin.sync_source_vec_t.qclear +ida_kernwin.sync_source_vec_t.reserve +ida_kernwin.sync_source_vec_t.size +ida_kernwin.sync_source_vec_t.swap +ida_kernwin.sync_source_vec_t.truncate +ida_kernwin.sync_sources +ida_kernwin.synced_group_t +ida_kernwin.synced_group_t.__init__ +ida_kernwin.synced_group_t.has +ida_kernwin.synced_group_t.has_register +ida_kernwin.synced_group_t.has_widget +ida_kernwin.tagged_line_section_t +ida_kernwin.tagged_line_section_t.__eq__ +ida_kernwin.tagged_line_section_t.__init__ +ida_kernwin.tagged_line_section_t.__ne__ +ida_kernwin.tagged_line_section_t.__str__ +ida_kernwin.tagged_line_section_t.substr +ida_kernwin.tagged_line_section_t.valid +ida_kernwin.tagged_line_section_t.valid_in +ida_kernwin.tagged_line_section_vec_t +ida_kernwin.tagged_line_section_vec_t.__eq__ +ida_kernwin.tagged_line_section_vec_t.__getitem__ +ida_kernwin.tagged_line_section_vec_t.__init__ +ida_kernwin.tagged_line_section_vec_t.__len__ +ida_kernwin.tagged_line_section_vec_t.__ne__ +ida_kernwin.tagged_line_section_vec_t.__setitem__ +ida_kernwin.tagged_line_section_vec_t._del +ida_kernwin.tagged_line_section_vec_t.add_unique +ida_kernwin.tagged_line_section_vec_t.append +ida_kernwin.tagged_line_section_vec_t.at +ida_kernwin.tagged_line_section_vec_t.begin +ida_kernwin.tagged_line_section_vec_t.capacity +ida_kernwin.tagged_line_section_vec_t.clear +ida_kernwin.tagged_line_section_vec_t.empty +ida_kernwin.tagged_line_section_vec_t.end +ida_kernwin.tagged_line_section_vec_t.erase +ida_kernwin.tagged_line_section_vec_t.extend +ida_kernwin.tagged_line_section_vec_t.extract +ida_kernwin.tagged_line_section_vec_t.find +ida_kernwin.tagged_line_section_vec_t.grow +ida_kernwin.tagged_line_section_vec_t.has +ida_kernwin.tagged_line_section_vec_t.inject +ida_kernwin.tagged_line_section_vec_t.insert +ida_kernwin.tagged_line_section_vec_t.pop_back +ida_kernwin.tagged_line_section_vec_t.push_back +ida_kernwin.tagged_line_section_vec_t.qclear +ida_kernwin.tagged_line_section_vec_t.reserve +ida_kernwin.tagged_line_section_vec_t.resize +ida_kernwin.tagged_line_section_vec_t.size +ida_kernwin.tagged_line_section_vec_t.swap +ida_kernwin.tagged_line_section_vec_t.truncate +ida_kernwin.tagged_line_sections_t +ida_kernwin.tagged_line_sections_t.__init__ +ida_kernwin.tagged_line_sections_t.first +ida_kernwin.tagged_line_sections_t.nearest_after +ida_kernwin.tagged_line_sections_t.nearest_at +ida_kernwin.tagged_line_sections_t.nearest_before +ida_kernwin.tagged_line_sections_t.sections_at +ida_kernwin.take_database_snapshot +ida_kernwin.text_t +ida_kernwin.text_t.__getitem__ +ida_kernwin.text_t.__init__ +ida_kernwin.text_t.__len__ +ida_kernwin.text_t.__setitem__ +ida_kernwin.text_t.append +ida_kernwin.text_t.at +ida_kernwin.text_t.begin +ida_kernwin.text_t.capacity +ida_kernwin.text_t.clear +ida_kernwin.text_t.empty +ida_kernwin.text_t.end +ida_kernwin.text_t.erase +ida_kernwin.text_t.extend +ida_kernwin.text_t.extract +ida_kernwin.text_t.grow +ida_kernwin.text_t.inject +ida_kernwin.text_t.insert +ida_kernwin.text_t.pop_back +ida_kernwin.text_t.push_back +ida_kernwin.text_t.qclear +ida_kernwin.text_t.reserve +ida_kernwin.text_t.resize +ida_kernwin.text_t.size +ida_kernwin.text_t.swap +ida_kernwin.text_t.truncate +ida_kernwin.textctrl_info_t +ida_kernwin.textctrl_info_t.TXTF_ACCEPTTABS +ida_kernwin.textctrl_info_t.TXTF_AUTOINDENT +ida_kernwin.textctrl_info_t.TXTF_FIXEDFONT +ida_kernwin.textctrl_info_t.TXTF_MODIFIED +ida_kernwin.textctrl_info_t.TXTF_READONLY +ida_kernwin.textctrl_info_t.TXTF_SELECTED +ida_kernwin.textctrl_info_t.__get_flags__ +ida_kernwin.textctrl_info_t.__get_tabsize__ +ida_kernwin.textctrl_info_t.__get_text +ida_kernwin.textctrl_info_t.__init__ +ida_kernwin.textctrl_info_t.__set_flags__ +ida_kernwin.textctrl_info_t.__set_tabsize__ +ida_kernwin.textctrl_info_t.__set_text +ida_kernwin.textctrl_info_t._create_clink +ida_kernwin.textctrl_info_t._del_clink +ida_kernwin.textctrl_info_t._get_clink_ptr +ida_kernwin.textctrl_info_t.assign +ida_kernwin.textctrl_info_t.flags +ida_kernwin.textctrl_info_t.tabsize +ida_kernwin.textctrl_info_t.text +ida_kernwin.textctrl_info_t.value +ida_kernwin.textctrl_info_t_assign +ida_kernwin.textctrl_info_t_create +ida_kernwin.textctrl_info_t_destroy +ida_kernwin.textctrl_info_t_get_clink +ida_kernwin.textctrl_info_t_get_clink_ptr +ida_kernwin.textctrl_info_t_get_flags +ida_kernwin.textctrl_info_t_get_tabsize +ida_kernwin.textctrl_info_t_get_text +ida_kernwin.textctrl_info_t_set_flags +ida_kernwin.textctrl_info_t_set_tabsize +ida_kernwin.textctrl_info_t_set_text +ida_kernwin.tiplace_t +ida_kernwin.tiplace_t.__init__ +ida_kernwin.tiplace_t.calc_udm_offset +ida_kernwin.tiplace_t.fill_type_ref +ida_kernwin.tiplace_t.get_kind +ida_kernwin.tiplace_t.is_footer +ida_kernwin.tiplace_t.is_header +ida_kernwin.tiplace_t.is_index +ida_kernwin.tiplace_t.reset +ida_kernwin.tiplace_t.set_footer +ida_kernwin.tiplace_t.set_header +ida_kernwin.tiplace_t.set_index_by_offset +ida_kernwin.tiplace_t.valid_ord +ida_kernwin.twinline_t +ida_kernwin.twinline_t.__init__ +ida_kernwin.twinline_t.at +ida_kernwin.twinline_t.bg_color +ida_kernwin.twinline_t.is_default +ida_kernwin.twinline_t.line +ida_kernwin.twinline_t.prefix_color +ida_kernwin.twinpos_t +ida_kernwin.twinpos_t.__init__ +ida_kernwin.twinpos_t.at +ida_kernwin.twinpos_t.place +ida_kernwin.twinpos_t.place_as_idaplace_t +ida_kernwin.twinpos_t.place_as_simpleline_place_t +ida_kernwin.twinpos_t.place_as_tiplace_t +ida_kernwin.twinpos_t.x +ida_kernwin.ui_load_new_file +ida_kernwin.ui_requests_t +ida_kernwin.ui_requests_t.__init__ +ida_kernwin.ui_run_debugger +ida_kernwin.unmark_selection +ida_kernwin.unregister_action +ida_kernwin.unregister_timer +ida_kernwin.update_action_checkable +ida_kernwin.update_action_checked +ida_kernwin.update_action_icon +ida_kernwin.update_action_label +ida_kernwin.update_action_shortcut +ida_kernwin.update_action_state +ida_kernwin.update_action_tooltip +ida_kernwin.update_action_visibility +ida_kernwin.user_cancelled +ida_kernwin.view_activated +ida_kernwin.view_click +ida_kernwin.view_close +ida_kernwin.view_created +ida_kernwin.view_curpos +ida_kernwin.view_dblclick +ida_kernwin.view_deactivated +ida_kernwin.view_keydown +ida_kernwin.view_loc_changed +ida_kernwin.view_mouse_event_location_t +ida_kernwin.view_mouse_event_location_t.__init__ +ida_kernwin.view_mouse_event_location_t.ea +ida_kernwin.view_mouse_event_location_t.item +ida_kernwin.view_mouse_event_t +ida_kernwin.view_mouse_event_t.__init__ +ida_kernwin.view_mouse_event_t.button +ida_kernwin.view_mouse_event_t.location +ida_kernwin.view_mouse_event_t.renderer_pos +ida_kernwin.view_mouse_event_t.rtype +ida_kernwin.view_mouse_event_t.state +ida_kernwin.view_mouse_event_t.x +ida_kernwin.view_mouse_event_t.y +ida_kernwin.view_mouse_moved +ida_kernwin.view_mouse_over +ida_kernwin.view_switched +ida_kernwin.warning +ida_libfuncs +ida_libfuncs.get_idasgn_header_by_short_name +ida_libfuncs.get_idasgn_path_by_short_name +ida_libfuncs.idasgn_header_t +ida_libfuncs.idasgn_header_t.__init__ +ida_lines +ida_lines.COLOR_ADDR +ida_lines.COLOR_ADDR_SIZE +ida_lines.COLOR_ALTOP +ida_lines.COLOR_ASMDIR +ida_lines.COLOR_AUTOCMT +ida_lines.COLOR_BG_MAX +ida_lines.COLOR_BINPREF +ida_lines.COLOR_CHAR +ida_lines.COLOR_CNAME +ida_lines.COLOR_CODE +ida_lines.COLOR_CODNAME +ida_lines.COLOR_COLLAPSED +ida_lines.COLOR_CREF +ida_lines.COLOR_CREFTAIL +ida_lines.COLOR_CURITEM +ida_lines.COLOR_CURLINE +ida_lines.COLOR_DATA +ida_lines.COLOR_DATNAME +ida_lines.COLOR_DCHAR +ida_lines.COLOR_DEFAULT +ida_lines.COLOR_DEMNAME +ida_lines.COLOR_DNAME +ida_lines.COLOR_DNUM +ida_lines.COLOR_DREF +ida_lines.COLOR_DREFTAIL +ida_lines.COLOR_DSTR +ida_lines.COLOR_ERROR +ida_lines.COLOR_ESC +ida_lines.COLOR_EXTERN +ida_lines.COLOR_EXTRA +ida_lines.COLOR_FG_MAX +ida_lines.COLOR_HIDLINE +ida_lines.COLOR_HIDNAME +ida_lines.COLOR_IMPNAME +ida_lines.COLOR_INSN +ida_lines.COLOR_INV +ida_lines.COLOR_KEYWORD +ida_lines.COLOR_LIBFUNC +ida_lines.COLOR_LIBNAME +ida_lines.COLOR_LOCNAME +ida_lines.COLOR_LUMFUNC +ida_lines.COLOR_LUMINA +ida_lines.COLOR_MACRO +ida_lines.COLOR_NUMBER +ida_lines.COLOR_OFF +ida_lines.COLOR_ON +ida_lines.COLOR_OPND1 +ida_lines.COLOR_OPND2 +ida_lines.COLOR_OPND3 +ida_lines.COLOR_OPND4 +ida_lines.COLOR_OPND5 +ida_lines.COLOR_OPND6 +ida_lines.COLOR_OPND7 +ida_lines.COLOR_OPND8 +ida_lines.COLOR_PREFIX +ida_lines.COLOR_REG +ida_lines.COLOR_REGCMT +ida_lines.COLOR_REGFUNC +ida_lines.COLOR_RESERVED1 +ida_lines.COLOR_RPTCMT +ida_lines.COLOR_SEGNAME +ida_lines.COLOR_SELECTED +ida_lines.COLOR_STRING +ida_lines.COLOR_SYMBOL +ida_lines.COLOR_UNAME +ida_lines.COLOR_UNKNAME +ida_lines.COLOR_UNKNOWN +ida_lines.COLOR_VOIDOP +ida_lines.COLSTR +ida_lines.SCOLOR_ADDR +ida_lines.SCOLOR_ALTOP +ida_lines.SCOLOR_ASMDIR +ida_lines.SCOLOR_AUTOCMT +ida_lines.SCOLOR_BINPREF +ida_lines.SCOLOR_CHAR +ida_lines.SCOLOR_CNAME +ida_lines.SCOLOR_CODNAME +ida_lines.SCOLOR_COLLAPSED +ida_lines.SCOLOR_CREF +ida_lines.SCOLOR_CREFTAIL +ida_lines.SCOLOR_DATNAME +ida_lines.SCOLOR_DCHAR +ida_lines.SCOLOR_DEFAULT +ida_lines.SCOLOR_DEMNAME +ida_lines.SCOLOR_DNAME +ida_lines.SCOLOR_DNUM +ida_lines.SCOLOR_DREF +ida_lines.SCOLOR_DREFTAIL +ida_lines.SCOLOR_DSTR +ida_lines.SCOLOR_ERROR +ida_lines.SCOLOR_ESC +ida_lines.SCOLOR_EXTRA +ida_lines.SCOLOR_HIDNAME +ida_lines.SCOLOR_IMPNAME +ida_lines.SCOLOR_INSN +ida_lines.SCOLOR_INV +ida_lines.SCOLOR_KEYWORD +ida_lines.SCOLOR_LIBNAME +ida_lines.SCOLOR_LOCNAME +ida_lines.SCOLOR_MACRO +ida_lines.SCOLOR_NUMBER +ida_lines.SCOLOR_OFF +ida_lines.SCOLOR_ON +ida_lines.SCOLOR_PREFIX +ida_lines.SCOLOR_REG +ida_lines.SCOLOR_REGCMT +ida_lines.SCOLOR_RPTCMT +ida_lines.SCOLOR_SEGNAME +ida_lines.SCOLOR_STRING +ida_lines.SCOLOR_SYMBOL +ida_lines.SCOLOR_UNAME +ida_lines.SCOLOR_UNKNAME +ida_lines.SCOLOR_VOIDOP +ida_lines.VEL_CMT +ida_lines.VEL_POST +ida_lines.add_extra_cmt +ida_lines.add_extra_line +ida_lines.add_pgm_cmt +ida_lines.add_sourcefile +ida_lines.calc_bg_color +ida_lines.calc_prefix_color +ida_lines.create_encoding_helper +ida_lines.del_extra_cmt +ida_lines.del_sourcefile +ida_lines.delete_extra_cmts +ida_lines.generate_disasm_line +ida_lines.generate_disassembly +ida_lines.get_extra_cmt +ida_lines.get_first_free_extra_cmtidx +ida_lines.get_sourcefile +ida_lines.install_user_defined_prefix +ida_lines.requires_color_esc +ida_lines.tag_addr +ida_lines.tag_advance +ida_lines.tag_remove +ida_lines.tag_skipcode +ida_lines.tag_skipcodes +ida_lines.tag_strlen +ida_lines.update_extra_cmt +ida_lines.user_defined_prefix_t +ida_lines.user_defined_prefix_t.__disown__ +ida_lines.user_defined_prefix_t.__init__ +ida_lines.user_defined_prefix_t.get_user_defined_prefix +ida_loader +ida_loader.ACCEPT_ARCHIVE +ida_loader.ACCEPT_CONTINUE +ida_loader.ACCEPT_FIRST +ida_loader.DBFL_BAK +ida_loader.DBFL_COMP +ida_loader.DBFL_KILL +ida_loader.DBFL_TEMP +ida_loader.FILEREG_NOTPATCHABLE +ida_loader.FILEREG_PATCHABLE +ida_loader.GENFLG_ASMINC +ida_loader.GENFLG_ASMTYPE +ida_loader.GENFLG_GENHTML +ida_loader.GENFLG_IDCTYPE +ida_loader.GENFLG_MAPDMNG +ida_loader.GENFLG_MAPLOC +ida_loader.GENFLG_MAPNAME +ida_loader.GENFLG_MAPSEG +ida_loader.LDRF_RELOAD +ida_loader.LDRF_REQ_PROC +ida_loader.MAX_DATABASE_DESCRIPTION +ida_loader.NEF_CODE +ida_loader.NEF_FILL +ida_loader.NEF_FIRST +ida_loader.NEF_FLAT +ida_loader.NEF_IMPS +ida_loader.NEF_LALL +ida_loader.NEF_LOPT +ida_loader.NEF_MAN +ida_loader.NEF_MINI +ida_loader.NEF_NAME +ida_loader.NEF_RELOAD +ida_loader.NEF_RSCS +ida_loader.NEF_SEGS +ida_loader.OFILE_ASM +ida_loader.OFILE_DIF +ida_loader.OFILE_EXE +ida_loader.OFILE_IDC +ida_loader.OFILE_LST +ida_loader.OFILE_MAP +ida_loader.PATH_TYPE_CMD +ida_loader.PATH_TYPE_ID0 +ida_loader.PATH_TYPE_IDB +ida_loader.PLUGIN_DLL +ida_loader.SSF_AUTOMATIC +ida_loader.SSUF_DESC +ida_loader.SSUF_FLAGS +ida_loader.SSUF_PATH +ida_loader.base2file +ida_loader.build_snapshot_tree +ida_loader.clr_database_flag +ida_loader.extract_module_from_archive +ida_loader.file2base +ida_loader.find_plugin +ida_loader.flush_buffers +ida_loader.gen_exe_file +ida_loader.gen_file +ida_loader.get_basic_file_type +ida_loader.get_elf_debug_file_directory +ida_loader.get_file_type_name +ida_loader.get_fileregion_ea +ida_loader.get_fileregion_offset +ida_loader.get_path +ida_loader.get_plugin_options +ida_loader.idp_desc_t +ida_loader.idp_desc_t.__init__ +ida_loader.idp_desc_t.checked +ida_loader.idp_desc_t.family +ida_loader.idp_desc_t.is_script +ida_loader.idp_desc_t.mtime +ida_loader.idp_desc_t.names +ida_loader.idp_desc_t.path +ida_loader.idp_name_t +ida_loader.idp_name_t.__init__ +ida_loader.idp_name_t.hidden +ida_loader.idp_name_t.lname +ida_loader.idp_name_t.sname +ida_loader.is_database_flag +ida_loader.is_trusted_idb +ida_loader.load_and_run_plugin +ida_loader.load_binary_file +ida_loader.load_ids_module +ida_loader.load_plugin +ida_loader.loader_t +ida_loader.loader_t.__init__ +ida_loader.loader_t.flags +ida_loader.loader_t.version +ida_loader.mem2base +ida_loader.plugin_info_t +ida_loader.plugin_info_t.__init__ +ida_loader.plugin_info_t.arg +ida_loader.plugin_info_t.comment +ida_loader.plugin_info_t.entry +ida_loader.plugin_info_t.flags +ida_loader.plugin_info_t.hotkey +ida_loader.plugin_info_t.idaplg_name +ida_loader.plugin_info_t.name +ida_loader.plugin_info_t.next +ida_loader.plugin_info_t.org_hotkey +ida_loader.plugin_info_t.org_name +ida_loader.plugin_info_t.path +ida_loader.process_archive +ida_loader.qvector_snapshotvec_t +ida_loader.qvector_snapshotvec_t.__eq__ +ida_loader.qvector_snapshotvec_t.__getitem__ +ida_loader.qvector_snapshotvec_t.__init__ +ida_loader.qvector_snapshotvec_t.__len__ +ida_loader.qvector_snapshotvec_t.__ne__ +ida_loader.qvector_snapshotvec_t.__setitem__ +ida_loader.qvector_snapshotvec_t._del +ida_loader.qvector_snapshotvec_t.add_unique +ida_loader.qvector_snapshotvec_t.append +ida_loader.qvector_snapshotvec_t.at +ida_loader.qvector_snapshotvec_t.begin +ida_loader.qvector_snapshotvec_t.capacity +ida_loader.qvector_snapshotvec_t.clear +ida_loader.qvector_snapshotvec_t.empty +ida_loader.qvector_snapshotvec_t.end +ida_loader.qvector_snapshotvec_t.erase +ida_loader.qvector_snapshotvec_t.extend +ida_loader.qvector_snapshotvec_t.extract +ida_loader.qvector_snapshotvec_t.find +ida_loader.qvector_snapshotvec_t.has +ida_loader.qvector_snapshotvec_t.inject +ida_loader.qvector_snapshotvec_t.insert +ida_loader.qvector_snapshotvec_t.pop_back +ida_loader.qvector_snapshotvec_t.push_back +ida_loader.qvector_snapshotvec_t.qclear +ida_loader.qvector_snapshotvec_t.reserve +ida_loader.qvector_snapshotvec_t.resize +ida_loader.qvector_snapshotvec_t.size +ida_loader.qvector_snapshotvec_t.swap +ida_loader.qvector_snapshotvec_t.truncate +ida_loader.reload_file +ida_loader.run_plugin +ida_loader.save_database +ida_loader.set_database_flag +ida_loader.set_import_name +ida_loader.set_import_ordinal +ida_loader.set_path +ida_loader.snapshot_t +ida_loader.snapshot_t.__eq__ +ida_loader.snapshot_t.__ge__ +ida_loader.snapshot_t.__gt__ +ida_loader.snapshot_t.__init__ +ida_loader.snapshot_t.__le__ +ida_loader.snapshot_t.__lt__ +ida_loader.snapshot_t.__ne__ +ida_loader.snapshot_t.children +ida_loader.snapshot_t.clear +ida_loader.snapshot_t.desc +ida_loader.snapshot_t.filename +ida_loader.snapshot_t.flags +ida_loader.snapshot_t.id +ida_lumina +ida_lumina.AMDF_FORCE +ida_lumina.AMDF_UPGRADE +ida_lumina.apply_metadata +ida_lumina.backup_metadata +ida_lumina.calc_func_metadata +ida_lumina.diff_metadata +ida_lumina.extra_cmt_t +ida_lumina.extra_cmt_t.__init__ +ida_lumina.extra_cmts_t +ida_lumina.extra_cmts_t.__getitem__ +ida_lumina.extra_cmts_t.__init__ +ida_lumina.extra_cmts_t.__len__ +ida_lumina.extra_cmts_t.__setitem__ +ida_lumina.extra_cmts_t.append +ida_lumina.extra_cmts_t.at +ida_lumina.extra_cmts_t.begin +ida_lumina.extra_cmts_t.capacity +ida_lumina.extra_cmts_t.clear +ida_lumina.extra_cmts_t.empty +ida_lumina.extra_cmts_t.end +ida_lumina.extra_cmts_t.erase +ida_lumina.extra_cmts_t.extend +ida_lumina.extra_cmts_t.extract +ida_lumina.extra_cmts_t.grow +ida_lumina.extra_cmts_t.inject +ida_lumina.extra_cmts_t.insert +ida_lumina.extra_cmts_t.pop_back +ida_lumina.extra_cmts_t.push_back +ida_lumina.extra_cmts_t.qclear +ida_lumina.extra_cmts_t.reserve +ida_lumina.extra_cmts_t.resize +ida_lumina.extra_cmts_t.size +ida_lumina.extra_cmts_t.swap +ida_lumina.extra_cmts_t.truncate +ida_lumina.extract_extra_cmts_from_metadata +ida_lumina.extract_frame_desc_from_metadata +ida_lumina.extract_insn_cmts_from_metadata +ida_lumina.extract_insn_opreprs_from_metadata +ida_lumina.extract_insn_opreprs_from_metadata_ex +ida_lumina.extract_type_from_metadata +ida_lumina.extract_user_stkpnts_from_metadata +ida_lumina.frame_desc_t +ida_lumina.frame_desc_t.__init__ +ida_lumina.frame_mem_t +ida_lumina.frame_mem_t.__init__ +ida_lumina.frame_mems_t +ida_lumina.frame_mems_t.__getitem__ +ida_lumina.frame_mems_t.__init__ +ida_lumina.frame_mems_t.__len__ +ida_lumina.frame_mems_t.__setitem__ +ida_lumina.frame_mems_t.append +ida_lumina.frame_mems_t.at +ida_lumina.frame_mems_t.begin +ida_lumina.frame_mems_t.capacity +ida_lumina.frame_mems_t.clear +ida_lumina.frame_mems_t.empty +ida_lumina.frame_mems_t.end +ida_lumina.frame_mems_t.erase +ida_lumina.frame_mems_t.extend +ida_lumina.frame_mems_t.extract +ida_lumina.frame_mems_t.grow +ida_lumina.frame_mems_t.inject +ida_lumina.frame_mems_t.insert +ida_lumina.frame_mems_t.pop_back +ida_lumina.frame_mems_t.push_back +ida_lumina.frame_mems_t.qclear +ida_lumina.frame_mems_t.reserve +ida_lumina.frame_mems_t.resize +ida_lumina.frame_mems_t.size +ida_lumina.frame_mems_t.swap +ida_lumina.frame_mems_t.truncate +ida_lumina.func_info_and_frequency_t +ida_lumina.func_info_and_frequency_t.__init__ +ida_lumina.func_info_and_frequency_vec_t +ida_lumina.func_info_and_frequency_vec_t.__getitem__ +ida_lumina.func_info_and_frequency_vec_t.__init__ +ida_lumina.func_info_and_frequency_vec_t.__len__ +ida_lumina.func_info_and_frequency_vec_t.__setitem__ +ida_lumina.func_info_and_frequency_vec_t.append +ida_lumina.func_info_and_frequency_vec_t.at +ida_lumina.func_info_and_frequency_vec_t.begin +ida_lumina.func_info_and_frequency_vec_t.capacity +ida_lumina.func_info_and_frequency_vec_t.clear +ida_lumina.func_info_and_frequency_vec_t.empty +ida_lumina.func_info_and_frequency_vec_t.end +ida_lumina.func_info_and_frequency_vec_t.erase +ida_lumina.func_info_and_frequency_vec_t.extend +ida_lumina.func_info_and_frequency_vec_t.extract +ida_lumina.func_info_and_frequency_vec_t.grow +ida_lumina.func_info_and_frequency_vec_t.inject +ida_lumina.func_info_and_frequency_vec_t.insert +ida_lumina.func_info_and_frequency_vec_t.pop_back +ida_lumina.func_info_and_frequency_vec_t.push_back +ida_lumina.func_info_and_frequency_vec_t.qclear +ida_lumina.func_info_and_frequency_vec_t.reserve +ida_lumina.func_info_and_frequency_vec_t.resize +ida_lumina.func_info_and_frequency_vec_t.size +ida_lumina.func_info_and_frequency_vec_t.swap +ida_lumina.func_info_and_frequency_vec_t.truncate +ida_lumina.func_info_and_pattern_t +ida_lumina.func_info_and_pattern_t.__init__ +ida_lumina.func_info_and_pattern_vec_t +ida_lumina.func_info_and_pattern_vec_t.__getitem__ +ida_lumina.func_info_and_pattern_vec_t.__init__ +ida_lumina.func_info_and_pattern_vec_t.__len__ +ida_lumina.func_info_and_pattern_vec_t.__setitem__ +ida_lumina.func_info_and_pattern_vec_t.append +ida_lumina.func_info_and_pattern_vec_t.at +ida_lumina.func_info_and_pattern_vec_t.begin +ida_lumina.func_info_and_pattern_vec_t.capacity +ida_lumina.func_info_and_pattern_vec_t.clear +ida_lumina.func_info_and_pattern_vec_t.empty +ida_lumina.func_info_and_pattern_vec_t.end +ida_lumina.func_info_and_pattern_vec_t.erase +ida_lumina.func_info_and_pattern_vec_t.extend +ida_lumina.func_info_and_pattern_vec_t.extract +ida_lumina.func_info_and_pattern_vec_t.grow +ida_lumina.func_info_and_pattern_vec_t.inject +ida_lumina.func_info_and_pattern_vec_t.insert +ida_lumina.func_info_and_pattern_vec_t.pop_back +ida_lumina.func_info_and_pattern_vec_t.push_back +ida_lumina.func_info_and_pattern_vec_t.qclear +ida_lumina.func_info_and_pattern_vec_t.reserve +ida_lumina.func_info_and_pattern_vec_t.resize +ida_lumina.func_info_and_pattern_vec_t.size +ida_lumina.func_info_and_pattern_vec_t.swap +ida_lumina.func_info_and_pattern_vec_t.truncate +ida_lumina.func_info_base_t +ida_lumina.func_info_base_t.__init__ +ida_lumina.func_info_pattern_and_frequency_t +ida_lumina.func_info_pattern_and_frequency_t.__init__ +ida_lumina.func_info_pattern_and_frequency_vec_t +ida_lumina.func_info_pattern_and_frequency_vec_t.__getitem__ +ida_lumina.func_info_pattern_and_frequency_vec_t.__init__ +ida_lumina.func_info_pattern_and_frequency_vec_t.__len__ +ida_lumina.func_info_pattern_and_frequency_vec_t.__setitem__ +ida_lumina.func_info_pattern_and_frequency_vec_t.append +ida_lumina.func_info_pattern_and_frequency_vec_t.at +ida_lumina.func_info_pattern_and_frequency_vec_t.begin +ida_lumina.func_info_pattern_and_frequency_vec_t.capacity +ida_lumina.func_info_pattern_and_frequency_vec_t.clear +ida_lumina.func_info_pattern_and_frequency_vec_t.empty +ida_lumina.func_info_pattern_and_frequency_vec_t.end +ida_lumina.func_info_pattern_and_frequency_vec_t.erase +ida_lumina.func_info_pattern_and_frequency_vec_t.extend +ida_lumina.func_info_pattern_and_frequency_vec_t.extract +ida_lumina.func_info_pattern_and_frequency_vec_t.grow +ida_lumina.func_info_pattern_and_frequency_vec_t.inject +ida_lumina.func_info_pattern_and_frequency_vec_t.insert +ida_lumina.func_info_pattern_and_frequency_vec_t.pop_back +ida_lumina.func_info_pattern_and_frequency_vec_t.push_back +ida_lumina.func_info_pattern_and_frequency_vec_t.qclear +ida_lumina.func_info_pattern_and_frequency_vec_t.reserve +ida_lumina.func_info_pattern_and_frequency_vec_t.resize +ida_lumina.func_info_pattern_and_frequency_vec_t.size +ida_lumina.func_info_pattern_and_frequency_vec_t.swap +ida_lumina.func_info_pattern_and_frequency_vec_t.truncate +ida_lumina.func_info_t +ida_lumina.func_info_t.__init__ +ida_lumina.func_info_vec_t +ida_lumina.func_info_vec_t.__getitem__ +ida_lumina.func_info_vec_t.__init__ +ida_lumina.func_info_vec_t.__len__ +ida_lumina.func_info_vec_t.__setitem__ +ida_lumina.func_info_vec_t.append +ida_lumina.func_info_vec_t.at +ida_lumina.func_info_vec_t.begin +ida_lumina.func_info_vec_t.capacity +ida_lumina.func_info_vec_t.clear +ida_lumina.func_info_vec_t.empty +ida_lumina.func_info_vec_t.end +ida_lumina.func_info_vec_t.erase +ida_lumina.func_info_vec_t.extend +ida_lumina.func_info_vec_t.extract +ida_lumina.func_info_vec_t.grow +ida_lumina.func_info_vec_t.inject +ida_lumina.func_info_vec_t.insert +ida_lumina.func_info_vec_t.pop_back +ida_lumina.func_info_vec_t.push_back +ida_lumina.func_info_vec_t.qclear +ida_lumina.func_info_vec_t.reserve +ida_lumina.func_info_vec_t.resize +ida_lumina.func_info_vec_t.size +ida_lumina.func_info_vec_t.swap +ida_lumina.func_info_vec_t.truncate +ida_lumina.func_md_diff_handler_t +ida_lumina.func_md_diff_handler_t.__disown__ +ida_lumina.func_md_diff_handler_t.__init__ +ida_lumina.func_md_diff_handler_t.on_comment_changed +ida_lumina.func_md_diff_handler_t.on_extra_comment_changed +ida_lumina.func_md_diff_handler_t.on_frame_member_changed +ida_lumina.func_md_diff_handler_t.on_function_comment_changed +ida_lumina.func_md_diff_handler_t.on_insn_ops_repr_changed +ida_lumina.func_md_diff_handler_t.on_name_changed +ida_lumina.func_md_diff_handler_t.on_proto_changed +ida_lumina.func_md_diff_handler_t.on_score_changed +ida_lumina.func_md_diff_handler_t.on_user_stkpnt_changed +ida_lumina.get_lumina_rpc_packet_t_index_from_base +ida_lumina.get_server_connection +ida_lumina.get_server_connection2 +ida_lumina.has_backup_metadata +ida_lumina.input_file_t +ida_lumina.input_file_t.__init__ +ida_lumina.insn_cmt_t +ida_lumina.insn_cmt_t.__init__ +ida_lumina.insn_cmts_t +ida_lumina.insn_cmts_t.__getitem__ +ida_lumina.insn_cmts_t.__init__ +ida_lumina.insn_cmts_t.__len__ +ida_lumina.insn_cmts_t.__setitem__ +ida_lumina.insn_cmts_t.append +ida_lumina.insn_cmts_t.at +ida_lumina.insn_cmts_t.begin +ida_lumina.insn_cmts_t.capacity +ida_lumina.insn_cmts_t.clear +ida_lumina.insn_cmts_t.empty +ida_lumina.insn_cmts_t.end +ida_lumina.insn_cmts_t.erase +ida_lumina.insn_cmts_t.extend +ida_lumina.insn_cmts_t.extract +ida_lumina.insn_cmts_t.grow +ida_lumina.insn_cmts_t.inject +ida_lumina.insn_cmts_t.insert +ida_lumina.insn_cmts_t.pop_back +ida_lumina.insn_cmts_t.push_back +ida_lumina.insn_cmts_t.qclear +ida_lumina.insn_cmts_t.reserve +ida_lumina.insn_cmts_t.resize +ida_lumina.insn_cmts_t.size +ida_lumina.insn_cmts_t.swap +ida_lumina.insn_cmts_t.truncate +ida_lumina.insn_ops_repr_t +ida_lumina.insn_ops_repr_t.__init__ +ida_lumina.insn_ops_reprs_t +ida_lumina.insn_ops_reprs_t.__getitem__ +ida_lumina.insn_ops_reprs_t.__init__ +ida_lumina.insn_ops_reprs_t.__len__ +ida_lumina.insn_ops_reprs_t.__setitem__ +ida_lumina.insn_ops_reprs_t.append +ida_lumina.insn_ops_reprs_t.at +ida_lumina.insn_ops_reprs_t.begin +ida_lumina.insn_ops_reprs_t.capacity +ida_lumina.insn_ops_reprs_t.clear +ida_lumina.insn_ops_reprs_t.empty +ida_lumina.insn_ops_reprs_t.end +ida_lumina.insn_ops_reprs_t.erase +ida_lumina.insn_ops_reprs_t.extend +ida_lumina.insn_ops_reprs_t.extract +ida_lumina.insn_ops_reprs_t.grow +ida_lumina.insn_ops_reprs_t.inject +ida_lumina.insn_ops_reprs_t.insert +ida_lumina.insn_ops_reprs_t.pop_back +ida_lumina.insn_ops_reprs_t.push_back +ida_lumina.insn_ops_reprs_t.qclear +ida_lumina.insn_ops_reprs_t.reserve +ida_lumina.insn_ops_reprs_t.resize +ida_lumina.insn_ops_reprs_t.size +ida_lumina.insn_ops_reprs_t.swap +ida_lumina.insn_ops_reprs_t.truncate +ida_lumina.insn_site_t +ida_lumina.insn_site_t.__init__ +ida_lumina.insn_site_t.toea +ida_lumina.lumina_client_t +ida_lumina.lumina_client_t.__init__ +ida_lumina.lumina_client_t.del_history +ida_lumina.lumina_client_t.get_pop +ida_lumina.lumina_client_t.is_pattern_id +ida_lumina.lumina_client_t.pull_md +ida_lumina.lumina_client_t.push_md +ida_lumina.lumina_client_t.set_pattern_id_md5 +ida_lumina.lumina_info_t +ida_lumina.lumina_info_t.__init__ +ida_lumina.lumina_op_res_vec_t +ida_lumina.lumina_op_res_vec_t.__eq__ +ida_lumina.lumina_op_res_vec_t.__getitem__ +ida_lumina.lumina_op_res_vec_t.__init__ +ida_lumina.lumina_op_res_vec_t.__len__ +ida_lumina.lumina_op_res_vec_t.__ne__ +ida_lumina.lumina_op_res_vec_t.__setitem__ +ida_lumina.lumina_op_res_vec_t._del +ida_lumina.lumina_op_res_vec_t.add_unique +ida_lumina.lumina_op_res_vec_t.append +ida_lumina.lumina_op_res_vec_t.at +ida_lumina.lumina_op_res_vec_t.begin +ida_lumina.lumina_op_res_vec_t.capacity +ida_lumina.lumina_op_res_vec_t.clear +ida_lumina.lumina_op_res_vec_t.empty +ida_lumina.lumina_op_res_vec_t.end +ida_lumina.lumina_op_res_vec_t.erase +ida_lumina.lumina_op_res_vec_t.extend +ida_lumina.lumina_op_res_vec_t.extract +ida_lumina.lumina_op_res_vec_t.find +ida_lumina.lumina_op_res_vec_t.grow +ida_lumina.lumina_op_res_vec_t.has +ida_lumina.lumina_op_res_vec_t.inject +ida_lumina.lumina_op_res_vec_t.insert +ida_lumina.lumina_op_res_vec_t.pop_back +ida_lumina.lumina_op_res_vec_t.push_back +ida_lumina.lumina_op_res_vec_t.qclear +ida_lumina.lumina_op_res_vec_t.reserve +ida_lumina.lumina_op_res_vec_t.resize +ida_lumina.lumina_op_res_vec_t.size +ida_lumina.lumina_op_res_vec_t.swap +ida_lumina.lumina_op_res_vec_t.truncate +ida_lumina.lumina_server_info_t +ida_lumina.lumina_server_info_t.__init__ +ida_lumina.lumina_user_t +ida_lumina.lumina_user_t.__init__ +ida_lumina.lumina_user_t.can_del_history +ida_lumina.lumina_user_t.is_admin +ida_lumina.lumina_user_t.set_can_del_history +ida_lumina.lumina_user_t.set_is_admin +ida_lumina.md_type_parts_t +ida_lumina.md_type_parts_t.__eq__ +ida_lumina.md_type_parts_t.__init__ +ida_lumina.md_type_parts_t.__ne__ +ida_lumina.metadata_iterator_t +ida_lumina.metadata_iterator_t.__init__ +ida_lumina.metadata_iterator_t.data_end +ida_lumina.metadata_iterator_t.next +ida_lumina.new_packet +ida_lumina.oprepr_t +ida_lumina.oprepr_t.__init__ +ida_lumina.pattern_id_t +ida_lumina.pattern_id_t.__init__ +ida_lumina.peer_conn_t +ida_lumina.peer_conn_t.__init__ +ida_lumina.pkt_get_lumina_info_result_t +ida_lumina.pkt_get_lumina_info_result_t.__init__ +ida_lumina.pkt_get_lumina_info_t +ida_lumina.pkt_get_lumina_info_t.__init__ +ida_lumina.pkt_get_pop_result_t +ida_lumina.pkt_get_pop_result_t.__init__ +ida_lumina.pkt_get_pop_t +ida_lumina.pkt_get_pop_t.__init__ +ida_lumina.pkt_helo_result_t +ida_lumina.pkt_helo_result_t.__init__ +ida_lumina.pkt_helo_t +ida_lumina.pkt_helo_t.__init__ +ida_lumina.pkt_pull_md_result_t +ida_lumina.pkt_pull_md_result_t.__init__ +ida_lumina.pkt_pull_md_t +ida_lumina.pkt_pull_md_t.__init__ +ida_lumina.pkt_push_md_result_t +ida_lumina.pkt_push_md_result_t.__init__ +ida_lumina.pkt_push_md_t +ida_lumina.pkt_push_md_t.__init__ +ida_lumina.pkt_rpc_fail_t +ida_lumina.pkt_rpc_fail_t.__init__ +ida_lumina.pkt_rpc_notify_t +ida_lumina.pkt_rpc_notify_t.__init__ +ida_lumina.pkt_rpc_ok_t +ida_lumina.pkt_rpc_ok_t.__init__ +ida_lumina.pop_fun_t +ida_lumina.pop_fun_t.__init__ +ida_lumina.push_md_opts_t +ida_lumina.push_md_opts_t.__init__ +ida_lumina.push_md_result_t +ida_lumina.push_md_result_t.__init__ +ida_lumina.revert_metadata +ida_lumina.score_metadata +ida_lumina.serialized_tinfo +ida_lumina.serialized_tinfo.__init__ +ida_lumina.simple_idb_diff_handler_t +ida_lumina.simple_idb_diff_handler_t.__init__ +ida_lumina.simple_idb_diff_handler_t.ensure_header_generated +ida_lumina.simple_idb_diff_handler_t.format_extra_cmt +ida_lumina.simple_idb_diff_handler_t.format_frame_member +ida_lumina.simple_idb_diff_handler_t.format_insn_ops +ida_lumina.simple_idb_diff_handler_t.format_stkpnt +ida_lumina.simple_idb_diff_handler_t.format_type +ida_lumina.simple_idb_diff_handler_t.indenter_t +ida_lumina.simple_idb_diff_handler_t.indenter_t.__del__ +ida_lumina.simple_idb_diff_handler_t.indenter_t.__init__ +ida_lumina.simple_idb_diff_handler_t.on_comment_changed +ida_lumina.simple_idb_diff_handler_t.on_extra_comment_changed +ida_lumina.simple_idb_diff_handler_t.on_frame_member_changed +ida_lumina.simple_idb_diff_handler_t.on_function_comment_changed +ida_lumina.simple_idb_diff_handler_t.on_insn_ops_repr_changed +ida_lumina.simple_idb_diff_handler_t.on_name_changed +ida_lumina.simple_idb_diff_handler_t.on_proto_changed +ida_lumina.simple_idb_diff_handler_t.on_score_changed +ida_lumina.simple_idb_diff_handler_t.on_user_stkpnt_changed +ida_lumina.simple_idb_diff_handler_t.put +ida_lumina.simple_idb_diff_handler_t.put2 +ida_lumina.simple_idb_diff_handler_t.where +ida_lumina.skipped_func_t +ida_lumina.skipped_func_t.__init__ +ida_lumina.skipped_funcs_t +ida_lumina.skipped_funcs_t.__getitem__ +ida_lumina.skipped_funcs_t.__init__ +ida_lumina.skipped_funcs_t.__len__ +ida_lumina.skipped_funcs_t.__setitem__ +ida_lumina.skipped_funcs_t.append +ida_lumina.skipped_funcs_t.at +ida_lumina.skipped_funcs_t.begin +ida_lumina.skipped_funcs_t.capacity +ida_lumina.skipped_funcs_t.clear +ida_lumina.skipped_funcs_t.empty +ida_lumina.skipped_funcs_t.end +ida_lumina.skipped_funcs_t.erase +ida_lumina.skipped_funcs_t.extend +ida_lumina.skipped_funcs_t.extract +ida_lumina.skipped_funcs_t.grow +ida_lumina.skipped_funcs_t.inject +ida_lumina.skipped_funcs_t.insert +ida_lumina.skipped_funcs_t.pop_back +ida_lumina.skipped_funcs_t.push_back +ida_lumina.skipped_funcs_t.qclear +ida_lumina.skipped_funcs_t.reserve +ida_lumina.skipped_funcs_t.resize +ida_lumina.skipped_funcs_t.size +ida_lumina.skipped_funcs_t.swap +ida_lumina.skipped_funcs_t.truncate +ida_lumina.split_metadata +ida_lumina.user_license_info_t +ida_lumina.user_license_info_t.__init__ +ida_lumina.user_stkpnt_t +ida_lumina.user_stkpnt_t.__init__ +ida_lumina.user_stkpnts_t +ida_lumina.user_stkpnts_t.__getitem__ +ida_lumina.user_stkpnts_t.__init__ +ida_lumina.user_stkpnts_t.__len__ +ida_lumina.user_stkpnts_t.__setitem__ +ida_lumina.user_stkpnts_t.append +ida_lumina.user_stkpnts_t.at +ida_lumina.user_stkpnts_t.begin +ida_lumina.user_stkpnts_t.capacity +ida_lumina.user_stkpnts_t.clear +ida_lumina.user_stkpnts_t.empty +ida_lumina.user_stkpnts_t.end +ida_lumina.user_stkpnts_t.erase +ida_lumina.user_stkpnts_t.extend +ida_lumina.user_stkpnts_t.extract +ida_lumina.user_stkpnts_t.grow +ida_lumina.user_stkpnts_t.inject +ida_lumina.user_stkpnts_t.insert +ida_lumina.user_stkpnts_t.pop_back +ida_lumina.user_stkpnts_t.push_back +ida_lumina.user_stkpnts_t.qclear +ida_lumina.user_stkpnts_t.reserve +ida_lumina.user_stkpnts_t.resize +ida_lumina.user_stkpnts_t.size +ida_lumina.user_stkpnts_t.swap +ida_lumina.user_stkpnts_t.truncate +ida_moves +ida_moves.UNHID_FUNC +ida_moves.UNHID_RANGE +ida_moves.UNHID_SEGM +ida_moves.bookmarks_t +ida_moves.bookmarks_t.__getitem__ +ida_moves.bookmarks_t.__init__ +ida_moves.bookmarks_t.__init__ +ida_moves.bookmarks_t.__iter__ +ida_moves.bookmarks_t.__len__ +ida_moves.bookmarks_t.erase +ida_moves.bookmarks_t.find_index +ida_moves.bookmarks_t.get +ida_moves.bookmarks_t.get_desc +ida_moves.bookmarks_t.get_dirtree_id +ida_moves.bookmarks_t.mark +ida_moves.bookmarks_t.size +ida_moves.graph_location_info_t +ida_moves.graph_location_info_t.__eq__ +ida_moves.graph_location_info_t.__init__ +ida_moves.graph_location_info_t.__ne__ +ida_moves.lochist_entry_t +ida_moves.lochist_entry_t.__init__ +ida_moves.lochist_entry_t.acquire_place +ida_moves.lochist_entry_t.is_valid +ida_moves.lochist_entry_t.place +ida_moves.lochist_entry_t.renderer_info +ida_moves.lochist_entry_t.set_place +ida_moves.lochist_t +ida_moves.lochist_t.__init__ +ida_moves.lochist_t.back +ida_moves.lochist_t.clear +ida_moves.lochist_t.current_index +ida_moves.lochist_t.fwd +ida_moves.lochist_t.get +ida_moves.lochist_t.get_current +ida_moves.lochist_t.get_place_id +ida_moves.lochist_t.get_template_place +ida_moves.lochist_t.init +ida_moves.lochist_t.is_history_enabled +ida_moves.lochist_t.jump +ida_moves.lochist_t.netcode +ida_moves.lochist_t.save +ida_moves.lochist_t.seek +ida_moves.lochist_t.set +ida_moves.lochist_t.set_current +ida_moves.lochist_t.size +ida_moves.renderer_info_pos_t +ida_moves.renderer_info_pos_t.__eq__ +ida_moves.renderer_info_pos_t.__init__ +ida_moves.renderer_info_pos_t.__ne__ +ida_moves.renderer_info_t +ida_moves.renderer_info_t.__eq__ +ida_moves.renderer_info_t.__init__ +ida_moves.renderer_info_t.__ne__ +ida_moves.segm_move_info_t +ida_moves.segm_move_info_t.__eq__ +ida_moves.segm_move_info_t.__init__ +ida_moves.segm_move_info_t.__ne__ +ida_moves.segm_move_info_vec_t +ida_moves.segm_move_info_vec_t.__eq__ +ida_moves.segm_move_info_vec_t.__getitem__ +ida_moves.segm_move_info_vec_t.__init__ +ida_moves.segm_move_info_vec_t.__len__ +ida_moves.segm_move_info_vec_t.__ne__ +ida_moves.segm_move_info_vec_t.__setitem__ +ida_moves.segm_move_info_vec_t._del +ida_moves.segm_move_info_vec_t.add_unique +ida_moves.segm_move_info_vec_t.append +ida_moves.segm_move_info_vec_t.at +ida_moves.segm_move_info_vec_t.begin +ida_moves.segm_move_info_vec_t.capacity +ida_moves.segm_move_info_vec_t.clear +ida_moves.segm_move_info_vec_t.empty +ida_moves.segm_move_info_vec_t.end +ida_moves.segm_move_info_vec_t.erase +ida_moves.segm_move_info_vec_t.extend +ida_moves.segm_move_info_vec_t.extract +ida_moves.segm_move_info_vec_t.find +ida_moves.segm_move_info_vec_t.grow +ida_moves.segm_move_info_vec_t.has +ida_moves.segm_move_info_vec_t.inject +ida_moves.segm_move_info_vec_t.insert +ida_moves.segm_move_info_vec_t.pop_back +ida_moves.segm_move_info_vec_t.push_back +ida_moves.segm_move_info_vec_t.qclear +ida_moves.segm_move_info_vec_t.reserve +ida_moves.segm_move_info_vec_t.resize +ida_moves.segm_move_info_vec_t.size +ida_moves.segm_move_info_vec_t.swap +ida_moves.segm_move_info_vec_t.truncate +ida_moves.segm_move_infos_t +ida_moves.segm_move_infos_t.__init__ +ida_moves.segm_move_infos_t.find +ida_nalt +ida_nalt.AFL_ALIGNFLOW +ida_nalt.AFL_BNOT0 +ida_nalt.AFL_BNOT1 +ida_nalt.AFL_COLORED +ida_nalt.AFL_FIXEDSPD +ida_nalt.AFL_HIDDEN +ida_nalt.AFL_HR_DETERMINED +ida_nalt.AFL_HR_GUESSED_DATA +ida_nalt.AFL_HR_GUESSED_FUNC +ida_nalt.AFL_IDA_GUESSED +ida_nalt.AFL_LIB +ida_nalt.AFL_LINNUM +ida_nalt.AFL_LNAME +ida_nalt.AFL_LZERO0 +ida_nalt.AFL_LZERO1 +ida_nalt.AFL_MANUAL +ida_nalt.AFL_NOBRD +ida_nalt.AFL_NORET +ida_nalt.AFL_NOTCODE +ida_nalt.AFL_NOTPROC +ida_nalt.AFL_PUBNAM +ida_nalt.AFL_RETFP +ida_nalt.AFL_SIGN0 +ida_nalt.AFL_SIGN1 +ida_nalt.AFL_TERSESTR +ida_nalt.AFL_TI +ida_nalt.AFL_TI0 +ida_nalt.AFL_TI1 +ida_nalt.AFL_TILCMT +ida_nalt.AFL_TYPE_GUESSED +ida_nalt.AFL_USEMODSP +ida_nalt.AFL_USERSP +ida_nalt.AFL_USERTI +ida_nalt.AFL_WEAKNAM +ida_nalt.AFL_ZSTROFF +ida_nalt.AP_ALLOWDUPS +ida_nalt.AP_ARRAY +ida_nalt.AP_IDXBASEMASK +ida_nalt.AP_IDXBIN +ida_nalt.AP_IDXDEC +ida_nalt.AP_IDXHEX +ida_nalt.AP_IDXOCT +ida_nalt.AP_INDEX +ida_nalt.AP_SIGNED +ida_nalt.GOTEA_NODE_NAME +ida_nalt.IDB_DESKTOPS_NODE_NAME +ida_nalt.IDB_DESKTOPS_TAG +ida_nalt.MAXSTRUCPATH +ida_nalt.NALT_ABSBASE +ida_nalt.NALT_AFLAGS +ida_nalt.NALT_ALIGN +ida_nalt.NALT_COLOR +ida_nalt.NALT_CREF_FROM +ida_nalt.NALT_CREF_TO +ida_nalt.NALT_DREF_FROM +ida_nalt.NALT_DREF_TO +ida_nalt.NALT_ENUM0 +ida_nalt.NALT_ENUM1 +ida_nalt.NALT_GR_LAYX +ida_nalt.NALT_LINNUM +ida_nalt.NALT_PURGE +ida_nalt.NALT_STRTYPE +ida_nalt.NALT_STRUCT +ida_nalt.NALT_SWITCH +ida_nalt.NSUP_ARGEAS +ida_nalt.NSUP_ARRAY +ida_nalt.NSUP_CMT +ida_nalt.NSUP_CUSTDT +ida_nalt.NSUP_EX_FLAGS +ida_nalt.NSUP_FOP1 +ida_nalt.NSUP_FOP2 +ida_nalt.NSUP_FOP3 +ida_nalt.NSUP_FOP4 +ida_nalt.NSUP_FOP5 +ida_nalt.NSUP_FOP6 +ida_nalt.NSUP_FOP7 +ida_nalt.NSUP_FOP8 +ida_nalt.NSUP_FRAME +ida_nalt.NSUP_FTAILS +ida_nalt.NSUP_GROUP +ida_nalt.NSUP_GROUPS +ida_nalt.NSUP_GR_INFO +ida_nalt.NSUP_GR_LAYT +ida_nalt.NSUP_JINFO +ida_nalt.NSUP_LLABEL +ida_nalt.NSUP_MANUAL +ida_nalt.NSUP_OMFGRP +ida_nalt.NSUP_OPTYPES +ida_nalt.NSUP_OREF0 +ida_nalt.NSUP_OREF1 +ida_nalt.NSUP_OREF2 +ida_nalt.NSUP_OREF3 +ida_nalt.NSUP_OREF4 +ida_nalt.NSUP_OREF5 +ida_nalt.NSUP_OREF6 +ida_nalt.NSUP_OREF7 +ida_nalt.NSUP_ORIGFMD +ida_nalt.NSUP_POINTS +ida_nalt.NSUP_REF0 +ida_nalt.NSUP_REF1 +ida_nalt.NSUP_REF2 +ida_nalt.NSUP_REF3 +ida_nalt.NSUP_REF4 +ida_nalt.NSUP_REF5 +ida_nalt.NSUP_REF6 +ida_nalt.NSUP_REF7 +ida_nalt.NSUP_REGARG +ida_nalt.NSUP_REGVAR +ida_nalt.NSUP_REPCMT +ida_nalt.NSUP_SEGTRANS +ida_nalt.NSUP_STROFF0 +ida_nalt.NSUP_STROFF1 +ida_nalt.NSUP_SWITCH +ida_nalt.NSUP_TYPEINFO +ida_nalt.NSUP_XREFPOS +ida_nalt.PATCH_TAG +ida_nalt.REFINFO_CUSTOM +ida_nalt.REFINFO_NOBASE +ida_nalt.REFINFO_NO_ONES +ida_nalt.REFINFO_NO_ZEROS +ida_nalt.REFINFO_PASTEND +ida_nalt.REFINFO_RVAOFF +ida_nalt.REFINFO_SELFREF +ida_nalt.REFINFO_SIGNEDOP +ida_nalt.REFINFO_SUBTRACT +ida_nalt.REFINFO_TYPE +ida_nalt.REF_HIGH16 +ida_nalt.REF_HIGH8 +ida_nalt.REF_LOW16 +ida_nalt.REF_LOW8 +ida_nalt.REF_OFF16 +ida_nalt.REF_OFF32 +ida_nalt.REF_OFF64 +ida_nalt.REF_OFF8 +ida_nalt.RIDX_ABINAME +ida_nalt.RIDX_ARCHIVE_PATH +ida_nalt.RIDX_C_MACROS +ida_nalt.RIDX_DBG_BINPATHS +ida_nalt.RIDX_DUALOP_GRAPH +ida_nalt.RIDX_DUALOP_TEXT +ida_nalt.RIDX_FILE_FORMAT_NAME +ida_nalt.RIDX_GROUPS +ida_nalt.RIDX_H_PATH +ida_nalt.RIDX_IDA_VERSION +ida_nalt.RIDX_INCLUDE +ida_nalt.RIDX_MD5 +ida_nalt.RIDX_NOTEPAD +ida_nalt.RIDX_PROBLEMS +ida_nalt.RIDX_SELECTORS +ida_nalt.RIDX_SHA256 +ida_nalt.RIDX_SMALL_IDC +ida_nalt.RIDX_SMALL_IDC_OLD +ida_nalt.RIDX_SRCDBG_PATHS +ida_nalt.RIDX_SRCDBG_UNDESIRED +ida_nalt.RIDX_STR_ENCODINGS +ida_nalt.STRENC_DEFAULT +ida_nalt.STRENC_NONE +ida_nalt.STRTYPE_C +ida_nalt.STRTYPE_C_16 +ida_nalt.STRTYPE_C_32 +ida_nalt.STRTYPE_LEN2 +ida_nalt.STRTYPE_LEN2_16 +ida_nalt.STRTYPE_LEN2_32 +ida_nalt.STRTYPE_LEN4 +ida_nalt.STRTYPE_LEN4_16 +ida_nalt.STRTYPE_PASCAL +ida_nalt.STRTYPE_PASCAL_16 +ida_nalt.STRTYPE_PASCAL_32 +ida_nalt.STRTYPE_TERMCHR +ida_nalt.SWI_CUSTOM +ida_nalt.SWI_DEFRET +ida_nalt.SWI_DEF_IN_TBL +ida_nalt.SWI_ELBASE +ida_nalt.SWI_HXNOLOWCASE +ida_nalt.SWI_INDIRECT +ida_nalt.SWI_J32 +ida_nalt.SWI_JMPINSN +ida_nalt.SWI_JMP_INV +ida_nalt.SWI_JSIZE +ida_nalt.SWI_SELFREL +ida_nalt.SWI_SEPARATE +ida_nalt.SWI_SHIFT_MASK +ida_nalt.SWI_SIGNED +ida_nalt.SWI_SPARSE +ida_nalt.SWI_STDTBL +ida_nalt.SWI_SUBTRACT +ida_nalt.SWI_USER +ida_nalt.SWI_V32 +ida_nalt.SWI_VERSION +ida_nalt.SWI_VSIZE +ida_nalt.SWI_VSPLIT +ida_nalt.V695_REF_OFF8 +ida_nalt.V695_REF_VHIGH +ida_nalt.V695_REF_VLOW +ida_nalt.add_encoding +ida_nalt.array_parameters_t +ida_nalt.array_parameters_t.__init__ +ida_nalt.array_parameters_t.alignment +ida_nalt.array_parameters_t.is_default +ida_nalt.array_parameters_t.lineitems +ida_nalt.clr__bnot0 +ida_nalt.clr__bnot1 +ida_nalt.clr__invsign0 +ida_nalt.clr__invsign1 +ida_nalt.clr_abits +ida_nalt.clr_align_flow +ida_nalt.clr_colored_item +ida_nalt.clr_fixed_spd +ida_nalt.clr_has_lname +ida_nalt.clr_has_ti +ida_nalt.clr_has_ti0 +ida_nalt.clr_has_ti1 +ida_nalt.clr_libitem +ida_nalt.clr_lzero0 +ida_nalt.clr_lzero1 +ida_nalt.clr_noret +ida_nalt.clr_notcode +ida_nalt.clr_notproc +ida_nalt.clr_retfp +ida_nalt.clr_terse_struc +ida_nalt.clr_tilcmt +ida_nalt.clr_usemodsp +ida_nalt.clr_usersp +ida_nalt.clr_userti +ida_nalt.clr_zstroff +ida_nalt.custom_data_type_ids_fids_array +ida_nalt.custom_data_type_ids_fids_array.__getitem__ +ida_nalt.custom_data_type_ids_fids_array.__init__ +ida_nalt.custom_data_type_ids_fids_array.__len__ +ida_nalt.custom_data_type_ids_fids_array.__setitem__ +ida_nalt.custom_data_type_ids_fids_array._get_bytes +ida_nalt.custom_data_type_ids_fids_array._set_bytes +ida_nalt.custom_data_type_ids_t +ida_nalt.custom_data_type_ids_t.__getFids +ida_nalt.custom_data_type_ids_t.__init__ +ida_nalt.custom_data_type_ids_t.dtid +ida_nalt.custom_data_type_ids_t.fids +ida_nalt.custom_data_type_ids_t.fids +ida_nalt.custom_data_type_ids_t.get_dtid +ida_nalt.custom_data_type_ids_t.set +ida_nalt.dbg_get_input_path +ida_nalt.del_absbase +ida_nalt.del_aflags +ida_nalt.del_alignment +ida_nalt.del_array_parameters +ida_nalt.del_custom_data_type_ids +ida_nalt.del_encoding +ida_nalt.del_ind_purged +ida_nalt.del_item_color +ida_nalt.del_op_tinfo +ida_nalt.del_refinfo +ida_nalt.del_source_linnum +ida_nalt.del_str_type +ida_nalt.del_switch_info +ida_nalt.del_switch_parent +ida_nalt.del_tinfo +ida_nalt.delete_imports +ida_nalt.ea2node +ida_nalt.encoding_from_strtype +ida_nalt.end_ea2node +ida_nalt.enum_const_t +ida_nalt.enum_const_t.__init__ +ida_nalt.enum_import_names +ida_nalt.find_custom_refinfo +ida_nalt.get_abi_name +ida_nalt.get_absbase +ida_nalt.get_aflags +ida_nalt.get_alignment +ida_nalt.get_archive_path +ida_nalt.get_array_parameters +ida_nalt.get_asm_inc_file +ida_nalt.get_custom_data_type_ids +ida_nalt.get_custom_refinfo +ida_nalt.get_default_encoding_idx +ida_nalt.get_elapsed_secs +ida_nalt.get_encoding_bpu +ida_nalt.get_encoding_bpu_by_name +ida_nalt.get_encoding_name +ida_nalt.get_encoding_qty +ida_nalt.get_gotea +ida_nalt.get_ida_notepad_text +ida_nalt.get_idb_ctime +ida_nalt.get_idb_nopens +ida_nalt.get_ids_modnode +ida_nalt.get_imagebase +ida_nalt.get_import_module_name +ida_nalt.get_import_module_qty +ida_nalt.get_ind_purged +ida_nalt.get_initial_ida_version +ida_nalt.get_initial_idb_version +ida_nalt.get_input_file_path +ida_nalt.get_item_color +ida_nalt.get_loader_format_name +ida_nalt.get_op_tinfo +ida_nalt.get_outfile_encoding_idx +ida_nalt.get_refinfo +ida_nalt.get_reftype_by_size +ida_nalt.get_root_filename +ida_nalt.get_source_linnum +ida_nalt.get_srcdbg_paths +ida_nalt.get_srcdbg_undesired_paths +ida_nalt.get_str_encoding_idx +ida_nalt.get_str_term1 +ida_nalt.get_str_term2 +ida_nalt.get_str_type +ida_nalt.get_str_type_code +ida_nalt.get_str_type_prefix_length +ida_nalt.get_strid +ida_nalt.get_strtype_bpu +ida_nalt.get_switch_info +ida_nalt.get_switch_info +ida_nalt.get_switch_parent +ida_nalt.get_tinfo +ida_nalt.getnode +ida_nalt.has_aflag_linnum +ida_nalt.has_aflag_lname +ida_nalt.has_aflag_ti +ida_nalt.has_aflag_ti0 +ida_nalt.has_aflag_ti1 +ida_nalt.has_lname +ida_nalt.has_ti +ida_nalt.has_ti0 +ida_nalt.has_ti1 +ida_nalt.hide_border +ida_nalt.hide_item +ida_nalt.is__bnot0 +ida_nalt.is__bnot1 +ida_nalt.is__invsign0 +ida_nalt.is__invsign1 +ida_nalt.is_aflag__bnot0 +ida_nalt.is_aflag__bnot1 +ida_nalt.is_aflag__invsign0 +ida_nalt.is_aflag__invsign1 +ida_nalt.is_aflag_align_flow +ida_nalt.is_aflag_colored_item +ida_nalt.is_aflag_data_guessed_by_hexrays +ida_nalt.is_aflag_fixed_spd +ida_nalt.is_aflag_func_guessed_by_hexrays +ida_nalt.is_aflag_hidden_border +ida_nalt.is_aflag_hidden_item +ida_nalt.is_aflag_libitem +ida_nalt.is_aflag_lzero0 +ida_nalt.is_aflag_lzero1 +ida_nalt.is_aflag_manual_insn +ida_nalt.is_aflag_noret +ida_nalt.is_aflag_notcode +ida_nalt.is_aflag_notproc +ida_nalt.is_aflag_public_name +ida_nalt.is_aflag_retfp +ida_nalt.is_aflag_terse_struc +ida_nalt.is_aflag_tilcmt +ida_nalt.is_aflag_type_determined_by_hexrays +ida_nalt.is_aflag_type_guessed_by_hexrays +ida_nalt.is_aflag_type_guessed_by_ida +ida_nalt.is_aflag_usersp +ida_nalt.is_aflag_userti +ida_nalt.is_aflag_weak_name +ida_nalt.is_aflag_zstroff +ida_nalt.is_align_flow +ida_nalt.is_colored_item +ida_nalt.is_data_guessed_by_hexrays +ida_nalt.is_finally_visible_item +ida_nalt.is_fixed_spd +ida_nalt.is_func_guessed_by_hexrays +ida_nalt.is_hidden_border +ida_nalt.is_hidden_item +ida_nalt.is_libitem +ida_nalt.is_lzero0 +ida_nalt.is_lzero1 +ida_nalt.is_noret +ida_nalt.is_notcode +ida_nalt.is_notproc +ida_nalt.is_pascal +ida_nalt.is_reftype_target_optional +ida_nalt.is_retfp +ida_nalt.is_terse_struc +ida_nalt.is_tilcmt +ida_nalt.is_type_determined_by_hexrays +ida_nalt.is_type_guessed_by_hexrays +ida_nalt.is_type_guessed_by_ida +ida_nalt.is_usersp +ida_nalt.is_userti +ida_nalt.is_visible_item +ida_nalt.is_zstroff +ida_nalt.make_str_type +ida_nalt.node2ea +ida_nalt.opinfo_t +ida_nalt.opinfo_t.__init__ +ida_nalt.opinfo_t.cd +ida_nalt.opinfo_t.ec +ida_nalt.opinfo_t.path +ida_nalt.opinfo_t.ri +ida_nalt.opinfo_t.strtype +ida_nalt.opinfo_t.tid +ida_nalt.printop_t +ida_nalt.printop_t.__init__ +ida_nalt.printop_t.get_ti +ida_nalt.printop_t.is_aflags_initialized +ida_nalt.printop_t.is_f64 +ida_nalt.printop_t.is_ti_initialized +ida_nalt.printop_t.set_aflags_initialized +ida_nalt.printop_t.set_ti_initialized +ida_nalt.refinfo_t +ida_nalt.refinfo_t.__init__ +ida_nalt.refinfo_t.base +ida_nalt.refinfo_t.flags +ida_nalt.refinfo_t.init +ida_nalt.refinfo_t.is_custom +ida_nalt.refinfo_t.is_no_ones +ida_nalt.refinfo_t.is_no_zeros +ida_nalt.refinfo_t.is_pastend +ida_nalt.refinfo_t.is_rvaoff +ida_nalt.refinfo_t.is_selfref +ida_nalt.refinfo_t.is_signed +ida_nalt.refinfo_t.is_subtract +ida_nalt.refinfo_t.is_target_optional +ida_nalt.refinfo_t.no_base_xref +ida_nalt.refinfo_t.set_type +ida_nalt.refinfo_t.target +ida_nalt.refinfo_t.tdelta +ida_nalt.refinfo_t.type +ida_nalt.rename_encoding +ida_nalt.retrieve_input_file_crc32 +ida_nalt.retrieve_input_file_md5 +ida_nalt.retrieve_input_file_sha256 +ida_nalt.retrieve_input_file_size +ida_nalt.set__bnot0 +ida_nalt.set__bnot1 +ida_nalt.set__invsign0 +ida_nalt.set__invsign1 +ida_nalt.set_abits +ida_nalt.set_absbase +ida_nalt.set_aflags +ida_nalt.set_align_flow +ida_nalt.set_alignment +ida_nalt.set_archive_path +ida_nalt.set_array_parameters +ida_nalt.set_asm_inc_file +ida_nalt.set_colored_item +ida_nalt.set_custom_data_type_ids +ida_nalt.set_data_guessed_by_hexrays +ida_nalt.set_default_encoding_idx +ida_nalt.set_fixed_spd +ida_nalt.set_func_guessed_by_hexrays +ida_nalt.set_gotea +ida_nalt.set_has_lname +ida_nalt.set_has_ti +ida_nalt.set_has_ti0 +ida_nalt.set_has_ti1 +ida_nalt.set_ida_notepad_text +ida_nalt.set_ids_modnode +ida_nalt.set_imagebase +ida_nalt.set_item_color +ida_nalt.set_libitem +ida_nalt.set_loader_format_name +ida_nalt.set_lzero0 +ida_nalt.set_lzero1 +ida_nalt.set_noret +ida_nalt.set_notcode +ida_nalt.set_notproc +ida_nalt.set_op_tinfo +ida_nalt.set_outfile_encoding_idx +ida_nalt.set_refinfo +ida_nalt.set_refinfo_ex +ida_nalt.set_retfp +ida_nalt.set_root_filename +ida_nalt.set_source_linnum +ida_nalt.set_srcdbg_paths +ida_nalt.set_srcdbg_undesired_paths +ida_nalt.set_str_encoding_idx +ida_nalt.set_str_type +ida_nalt.set_switch_info +ida_nalt.set_switch_parent +ida_nalt.set_terse_struc +ida_nalt.set_tilcmt +ida_nalt.set_tinfo +ida_nalt.set_type_determined_by_hexrays +ida_nalt.set_type_guessed_by_ida +ida_nalt.set_usemodsp +ida_nalt.set_usersp +ida_nalt.set_userti +ida_nalt.set_visible_item +ida_nalt.set_zstroff +ida_nalt.strpath_ids_array +ida_nalt.strpath_ids_array.__getitem__ +ida_nalt.strpath_ids_array.__init__ +ida_nalt.strpath_ids_array.__len__ +ida_nalt.strpath_ids_array.__setitem__ +ida_nalt.strpath_ids_array._get_bytes +ida_nalt.strpath_ids_array._set_bytes +ida_nalt.strpath_t +ida_nalt.strpath_t.__getIds +ida_nalt.strpath_t.__init__ +ida_nalt.switch_info_t +ida_nalt.switch_info_t.__init__ +ida_nalt.switch_info_t._get_values_lowcase +ida_nalt.switch_info_t._set_values_lowcase +ida_nalt.switch_info_t.assign +ida_nalt.switch_info_t.clear +ida_nalt.switch_info_t.custom +ida_nalt.switch_info_t.defjump +ida_nalt.switch_info_t.elbase +ida_nalt.switch_info_t.expr_ea +ida_nalt.switch_info_t.flags +ida_nalt.switch_info_t.get_jrange_vrange +ida_nalt.switch_info_t.get_jtable_element_size +ida_nalt.switch_info_t.get_jtable_size +ida_nalt.switch_info_t.get_lowcase +ida_nalt.switch_info_t.get_shift +ida_nalt.switch_info_t.get_version +ida_nalt.switch_info_t.get_vtable_element_size +ida_nalt.switch_info_t.has_default +ida_nalt.switch_info_t.has_elbase +ida_nalt.switch_info_t.is_custom +ida_nalt.switch_info_t.is_indirect +ida_nalt.switch_info_t.is_nolowcase +ida_nalt.switch_info_t.is_sparse +ida_nalt.switch_info_t.is_subtract +ida_nalt.switch_info_t.is_user_defined +ida_nalt.switch_info_t.jcases +ida_nalt.switch_info_t.jumps +ida_nalt.switch_info_t.lowcase +ida_nalt.switch_info_t.lowcase +ida_nalt.switch_info_t.marks +ida_nalt.switch_info_t.ncases +ida_nalt.switch_info_t.regdtype +ida_nalt.switch_info_t.regnum +ida_nalt.switch_info_t.set_elbase +ida_nalt.switch_info_t.set_expr +ida_nalt.switch_info_t.set_jtable_element_size +ida_nalt.switch_info_t.set_jtable_size +ida_nalt.switch_info_t.set_shift +ida_nalt.switch_info_t.set_vtable_element_size +ida_nalt.switch_info_t.startea +ida_nalt.switch_info_t.use_std_table +ida_nalt.switch_info_t.values +ida_nalt.switch_info_t.values +ida_nalt.switch_info_t__from_ptrval__ +ida_nalt.unhide_border +ida_nalt.unhide_item +ida_nalt.upd_abits +ida_nalt.uses_aflag_modsp +ida_nalt.uses_modsp +ida_name +ida_name.CN_KEEP_TRAILING_DIGITS +ida_name.CN_KEEP_UNDERSCORES +ida_name.DEBNAME_EXACT +ida_name.DEBNAME_LOWER +ida_name.DEBNAME_NICE +ida_name.DEBNAME_UPPER +ida_name.DQT_COMPILER +ida_name.DQT_FULL +ida_name.DQT_NAME_TYPE +ida_name.DQT_NPURGED_2 +ida_name.DQT_NPURGED_4 +ida_name.DQT_NPURGED_8 +ida_name.FUNC_IMPORT_PREFIX +ida_name.GETN_APPZERO +ida_name.GETN_NODUMMY +ida_name.GETN_NOFIXUP +ida_name.GNCN_NOCOLOR +ida_name.GNCN_NODBGNM +ida_name.GNCN_NOFUNC +ida_name.GNCN_NOLABEL +ida_name.GNCN_NOSEG +ida_name.GNCN_PREFDBG +ida_name.GNCN_REQFUNC +ida_name.GNCN_REQNAME +ida_name.GNCN_SEGNUM +ida_name.GNCN_SEG_FUNC +ida_name.GN_COLORED +ida_name.GN_DEMANGLED +ida_name.GN_ISRET +ida_name.GN_LOCAL +ida_name.GN_LONG +ida_name.GN_NOT_DUMMY +ida_name.GN_NOT_ISRET +ida_name.GN_SHORT +ida_name.GN_STRICT +ida_name.GN_VISIBLE +ida_name.MAXNAMELEN +ida_name.NT_ABS +ida_name.NT_BMASK +ida_name.NT_BYTE +ida_name.NT_ENUM +ida_name.NT_LOCAL +ida_name.NT_NONE +ida_name.NT_REGVAR +ida_name.NT_SEG +ida_name.NT_STKVAR +ida_name.NT_STROFF +ida_name.NearestName +ida_name.NearestName.__getitem__ +ida_name.NearestName.__init__ +ida_name.NearestName.__iter__ +ida_name.NearestName._get_item +ida_name.NearestName.find +ida_name.NearestName.update +ida_name.SN_AUTO +ida_name.SN_CHECK +ida_name.SN_DELTAIL +ida_name.SN_FORCE +ida_name.SN_IDBENC +ida_name.SN_LOCAL +ida_name.SN_NOCHECK +ida_name.SN_NODUMMY +ida_name.SN_NOLIST +ida_name.SN_NON_AUTO +ida_name.SN_NON_PUBLIC +ida_name.SN_NON_WEAK +ida_name.SN_NOWARN +ida_name.SN_PUBLIC +ida_name.SN_WEAK +ida_name.UCDR_MANGLED +ida_name.UCDR_NAME +ida_name.UCDR_STRLIT +ida_name.UCDR_TYPE +ida_name.VNT_IDENT +ida_name.VNT_STRLIT +ida_name.VNT_TYPE +ida_name.VNT_UDTMEM +ida_name.VNT_VISIBLE +ida_name.append_struct_fields +ida_name.calc_gtn_flags +ida_name.cleanup_name +ida_name.del_debug_names +ida_name.del_global_name +ida_name.del_local_name +ida_name.demangle_name +ida_name.ea_name_t +ida_name.ea_name_t.__init__ +ida_name.ea_name_vec_t +ida_name.ea_name_vec_t.__getitem__ +ida_name.ea_name_vec_t.__init__ +ida_name.ea_name_vec_t.__len__ +ida_name.ea_name_vec_t.__setitem__ +ida_name.ea_name_vec_t.append +ida_name.ea_name_vec_t.at +ida_name.ea_name_vec_t.begin +ida_name.ea_name_vec_t.capacity +ida_name.ea_name_vec_t.clear +ida_name.ea_name_vec_t.empty +ida_name.ea_name_vec_t.end +ida_name.ea_name_vec_t.erase +ida_name.ea_name_vec_t.extend +ida_name.ea_name_vec_t.extract +ida_name.ea_name_vec_t.grow +ida_name.ea_name_vec_t.inject +ida_name.ea_name_vec_t.insert +ida_name.ea_name_vec_t.pop_back +ida_name.ea_name_vec_t.push_back +ida_name.ea_name_vec_t.qclear +ida_name.ea_name_vec_t.reserve +ida_name.ea_name_vec_t.resize +ida_name.ea_name_vec_t.size +ida_name.ea_name_vec_t.swap +ida_name.ea_name_vec_t.truncate +ida_name.extract_name +ida_name.force_name +ida_name.get_colored_demangled_name +ida_name.get_colored_long_name +ida_name.get_colored_name +ida_name.get_colored_short_name +ida_name.get_cp_validity +ida_name.get_debug_name +ida_name.get_debug_name_ea +ida_name.get_debug_names +ida_name.get_demangled_name +ida_name.get_ea_name +ida_name.get_long_name +ida_name.get_mangled_name_type +ida_name.get_name +ida_name.get_name_base_ea +ida_name.get_name_color +ida_name.get_name_ea +ida_name.get_name_expr +ida_name.get_name_value +ida_name.get_nice_colored_name +ida_name.get_nlist_ea +ida_name.get_nlist_idx +ida_name.get_nlist_name +ida_name.get_nlist_size +ida_name.get_short_name +ida_name.get_visible_name +ida_name.hide_name +ida_name.is_ident +ida_name.is_ident_cp +ida_name.is_in_nlist +ida_name.is_name_defined_locally +ida_name.is_public_name +ida_name.is_strlit_cp +ida_name.is_uname +ida_name.is_valid_cp +ida_name.is_valid_typename +ida_name.is_visible_cp +ida_name.is_weak_name +ida_name.make_name_auto +ida_name.make_name_non_public +ida_name.make_name_non_weak +ida_name.make_name_public +ida_name.make_name_user +ida_name.make_name_weak +ida_name.rebuild_nlist +ida_name.reorder_dummy_names +ida_name.set_cp_validity +ida_name.set_debug_name +ida_name.set_dummy_name +ida_name.set_name +ida_name.show_name +ida_name.validate_name +ida_netnode +ida_netnode.BADNODE +ida_netnode.MAXNAMESIZE +ida_netnode.MAXSPECSIZE +ida_netnode.MAX_NODENAME_SIZE +ida_netnode.atag +ida_netnode.exist +ida_netnode.htag +ida_netnode.ltag +ida_netnode.netnode +ida_netnode.netnode.__eq__ +ida_netnode.netnode.__init__ +ida_netnode.netnode.__ne__ +ida_netnode.netnode.altdel +ida_netnode.netnode.altdel_all +ida_netnode.netnode.altdel_ea +ida_netnode.netnode.altdel_idx8 +ida_netnode.netnode.altfirst +ida_netnode.netnode.altfirst_idx8 +ida_netnode.netnode.altlast +ida_netnode.netnode.altlast_idx8 +ida_netnode.netnode.altnext +ida_netnode.netnode.altnext_idx8 +ida_netnode.netnode.altprev +ida_netnode.netnode.altprev_idx8 +ida_netnode.netnode.altset +ida_netnode.netnode.altset_ea +ida_netnode.netnode.altset_idx8 +ida_netnode.netnode.altshift +ida_netnode.netnode.altval +ida_netnode.netnode.altval_ea +ida_netnode.netnode.altval_idx8 +ida_netnode.netnode.blobshift +ida_netnode.netnode.blobsize +ida_netnode.netnode.blobsize_ea +ida_netnode.netnode.chardel +ida_netnode.netnode.chardel_ea +ida_netnode.netnode.chardel_idx8 +ida_netnode.netnode.charfirst +ida_netnode.netnode.charfirst_idx8 +ida_netnode.netnode.charlast +ida_netnode.netnode.charlast_idx8 +ida_netnode.netnode.charnext +ida_netnode.netnode.charnext_idx8 +ida_netnode.netnode.charprev +ida_netnode.netnode.charprev_idx8 +ida_netnode.netnode.charset +ida_netnode.netnode.charset_ea +ida_netnode.netnode.charset_idx8 +ida_netnode.netnode.charshift +ida_netnode.netnode.charval +ida_netnode.netnode.charval_ea +ida_netnode.netnode.charval_idx8 +ida_netnode.netnode.copyto +ida_netnode.netnode.create +ida_netnode.netnode.delblob +ida_netnode.netnode.delblob_ea +ida_netnode.netnode.delvalue +ida_netnode.netnode.eadel +ida_netnode.netnode.eadel_idx8 +ida_netnode.netnode.eaget +ida_netnode.netnode.eaget_idx +ida_netnode.netnode.eaget_idx8 +ida_netnode.netnode.easet +ida_netnode.netnode.easet_idx +ida_netnode.netnode.easet_idx8 +ida_netnode.netnode.end +ida_netnode.netnode.exist +ida_netnode.netnode.get_name +ida_netnode.netnode.getblob +ida_netnode.netnode.getblob_ea +ida_netnode.netnode.getclob +ida_netnode.netnode.hashdel +ida_netnode.netnode.hashdel_all +ida_netnode.netnode.hashfirst +ida_netnode.netnode.hashlast +ida_netnode.netnode.hashnext +ida_netnode.netnode.hashprev +ida_netnode.netnode.hashset +ida_netnode.netnode.hashset_buf +ida_netnode.netnode.hashset_idx +ida_netnode.netnode.hashstr +ida_netnode.netnode.hashstr_buf +ida_netnode.netnode.hashval +ida_netnode.netnode.hashval_long +ida_netnode.netnode.index +ida_netnode.netnode.kill +ida_netnode.netnode.long_value +ida_netnode.netnode.lower_bound +ida_netnode.netnode.lower_bound_ea +ida_netnode.netnode.lower_bound_idx8 +ida_netnode.netnode.moveto +ida_netnode.netnode.next +ida_netnode.netnode.prev +ida_netnode.netnode.rename +ida_netnode.netnode.set +ida_netnode.netnode.set_long +ida_netnode.netnode.setblob +ida_netnode.netnode.setblob_ea +ida_netnode.netnode.start +ida_netnode.netnode.supdel +ida_netnode.netnode.supdel_all +ida_netnode.netnode.supdel_ea +ida_netnode.netnode.supdel_idx8 +ida_netnode.netnode.supdel_range +ida_netnode.netnode.supdel_range_idx8 +ida_netnode.netnode.supfirst +ida_netnode.netnode.supfirst_idx8 +ida_netnode.netnode.suplast +ida_netnode.netnode.suplast_idx8 +ida_netnode.netnode.supnext +ida_netnode.netnode.supnext_idx8 +ida_netnode.netnode.supprev +ida_netnode.netnode.supprev_idx8 +ida_netnode.netnode.supset +ida_netnode.netnode.supset_ea +ida_netnode.netnode.supset_idx8 +ida_netnode.netnode.supshift +ida_netnode.netnode.supstr +ida_netnode.netnode.supstr_ea +ida_netnode.netnode.supstr_idx8 +ida_netnode.netnode.supval +ida_netnode.netnode.supval_ea +ida_netnode.netnode.supval_idx8 +ida_netnode.netnode.valobj +ida_netnode.netnode.valstr +ida_netnode.netnode.value_exists +ida_netnode.ntag +ida_netnode.stag +ida_netnode.vtag +ida_offset +ida_offset.add_refinfo_dref +ida_offset.calc_basevalue +ida_offset.calc_offset_base +ida_offset.calc_probable_base_by_value +ida_offset.calc_reference_data +ida_offset.calc_target +ida_offset.can_be_off32 +ida_offset.get_default_reftype +ida_offset.get_offbase +ida_offset.get_offset_expr +ida_offset.get_offset_expression +ida_offset.op_offset +ida_offset.op_offset_ex +ida_offset.op_plain_offset +ida_pro +ida_pro.CP_UTF16 +ida_pro.IDA_SDK_VERSION +ida_pro.IDBDEC_ESCAPE +ida_pro.IOREDIR_APPEND +ida_pro.IOREDIR_INPUT +ida_pro.IOREDIR_OUTPUT +ida_pro.IOREDIR_QUOTED +ida_pro.MAXSTR +ida_pro.SUBSTCHAR +ida_pro.__MF__ +ida_pro.__qmutex_t +ida_pro.__qmutex_t.__init__ +ida_pro.__qsemaphore_t +ida_pro.__qsemaphore_t.__init__ +ida_pro.__qthread_t +ida_pro.__qthread_t.__init__ +ida_pro._qstrvec_t +ida_pro._qstrvec_t.__get_size +ida_pro._qstrvec_t.__getitem__ +ida_pro._qstrvec_t.__init__ +ida_pro._qstrvec_t.__setitem__ +ida_pro._qstrvec_t._create_clink +ida_pro._qstrvec_t._del_clink +ida_pro._qstrvec_t._get_clink_ptr +ida_pro._qstrvec_t.add +ida_pro._qstrvec_t.addressof +ida_pro._qstrvec_t.assign +ida_pro._qstrvec_t.clear +ida_pro._qstrvec_t.from_list +ida_pro._qstrvec_t.insert +ida_pro._qstrvec_t.remove +ida_pro._qstrvec_t.size +ida_pro.adiff_pointer +ida_pro.adiff_pointer.__init__ +ida_pro.adiff_pointer.assign +ida_pro.adiff_pointer.cast +ida_pro.adiff_pointer.frompointer +ida_pro.adiff_pointer.value +ida_pro.asize_pointer +ida_pro.asize_pointer.__init__ +ida_pro.asize_pointer.assign +ida_pro.asize_pointer.cast +ida_pro.asize_pointer.frompointer +ida_pro.asize_pointer.value +ida_pro.bool_pointer +ida_pro.bool_pointer.__init__ +ida_pro.bool_pointer.assign +ida_pro.bool_pointer.cast +ida_pro.bool_pointer.frompointer +ida_pro.bool_pointer.value +ida_pro.boolvec_t +ida_pro.boolvec_t.__eq__ +ida_pro.boolvec_t.__getitem__ +ida_pro.boolvec_t.__init__ +ida_pro.boolvec_t.__len__ +ida_pro.boolvec_t.__ne__ +ida_pro.boolvec_t.__setitem__ +ida_pro.boolvec_t._del +ida_pro.boolvec_t.add_unique +ida_pro.boolvec_t.append +ida_pro.boolvec_t.at +ida_pro.boolvec_t.begin +ida_pro.boolvec_t.capacity +ida_pro.boolvec_t.clear +ida_pro.boolvec_t.empty +ida_pro.boolvec_t.end +ida_pro.boolvec_t.erase +ida_pro.boolvec_t.extend +ida_pro.boolvec_t.extract +ida_pro.boolvec_t.find +ida_pro.boolvec_t.grow +ida_pro.boolvec_t.has +ida_pro.boolvec_t.inject +ida_pro.boolvec_t.insert +ida_pro.boolvec_t.pop_back +ida_pro.boolvec_t.push_back +ida_pro.boolvec_t.qclear +ida_pro.boolvec_t.reserve +ida_pro.boolvec_t.resize +ida_pro.boolvec_t.size +ida_pro.boolvec_t.swap +ida_pro.boolvec_t.truncate +ida_pro.channel_redir_t +ida_pro.channel_redir_t.__init__ +ida_pro.channel_redir_t.fd +ida_pro.channel_redir_t.file +ida_pro.channel_redir_t.flags +ida_pro.channel_redir_t.is_append +ida_pro.channel_redir_t.is_input +ida_pro.channel_redir_t.is_output +ida_pro.channel_redir_t.is_quoted +ida_pro.channel_redir_t.length +ida_pro.channel_redir_t.start +ida_pro.char_pointer +ida_pro.char_pointer.__init__ +ida_pro.char_pointer.assign +ida_pro.char_pointer.cast +ida_pro.char_pointer.frompointer +ida_pro.char_pointer.value +ida_pro.check_process_exit +ida_pro.ea32_pointer +ida_pro.ea32_pointer.__init__ +ida_pro.ea32_pointer.assign +ida_pro.ea32_pointer.cast +ida_pro.ea32_pointer.frompointer +ida_pro.ea32_pointer.value +ida_pro.ea64_pointer +ida_pro.ea64_pointer.__init__ +ida_pro.ea64_pointer.assign +ida_pro.ea64_pointer.cast +ida_pro.ea64_pointer.frompointer +ida_pro.ea64_pointer.value +ida_pro.ea_array +ida_pro.ea_array.__getitem__ +ida_pro.ea_array.__init__ +ida_pro.ea_array.__setitem__ +ida_pro.ea_array.cast +ida_pro.ea_array.frompointer +ida_pro.ea_pointer +ida_pro.ea_pointer.__init__ +ida_pro.ea_pointer.assign +ida_pro.ea_pointer.cast +ida_pro.ea_pointer.frompointer +ida_pro.ea_pointer.value +ida_pro.extend_sign +ida_pro.flags64_pointer +ida_pro.flags64_pointer.__init__ +ida_pro.flags64_pointer.assign +ida_pro.flags64_pointer.cast +ida_pro.flags64_pointer.frompointer +ida_pro.flags64_pointer.value +ida_pro.flags_pointer +ida_pro.flags_pointer.__init__ +ida_pro.flags_pointer.assign +ida_pro.flags_pointer.cast +ida_pro.flags_pointer.frompointer +ida_pro.flags_pointer.value +ida_pro.get_available_core_count +ida_pro.get_logical_core_count +ida_pro.get_login_name +ida_pro.get_physical_core_count +ida_pro.instant_dbgopts_t +ida_pro.instant_dbgopts_t.__init__ +ida_pro.instant_dbgopts_t.attach +ida_pro.instant_dbgopts_t.debmod +ida_pro.instant_dbgopts_t.env +ida_pro.instant_dbgopts_t.event_id +ida_pro.instant_dbgopts_t.host +ida_pro.instant_dbgopts_t.pid +ida_pro.instant_dbgopts_t.port +ida_pro.int16_pointer +ida_pro.int16_pointer.__init__ +ida_pro.int16_pointer.assign +ida_pro.int16_pointer.cast +ida_pro.int16_pointer.frompointer +ida_pro.int16_pointer.value +ida_pro.int32_pointer +ida_pro.int32_pointer.__init__ +ida_pro.int32_pointer.assign +ida_pro.int32_pointer.cast +ida_pro.int32_pointer.frompointer +ida_pro.int32_pointer.value +ida_pro.int64_pointer +ida_pro.int64_pointer.__init__ +ida_pro.int64_pointer.assign +ida_pro.int64_pointer.cast +ida_pro.int64_pointer.frompointer +ida_pro.int64_pointer.value +ida_pro.int64vec_t +ida_pro.int64vec_t.__eq__ +ida_pro.int64vec_t.__getitem__ +ida_pro.int64vec_t.__init__ +ida_pro.int64vec_t.__len__ +ida_pro.int64vec_t.__ne__ +ida_pro.int64vec_t.__setitem__ +ida_pro.int64vec_t._del +ida_pro.int64vec_t.add_unique +ida_pro.int64vec_t.append +ida_pro.int64vec_t.at +ida_pro.int64vec_t.begin +ida_pro.int64vec_t.capacity +ida_pro.int64vec_t.clear +ida_pro.int64vec_t.empty +ida_pro.int64vec_t.end +ida_pro.int64vec_t.erase +ida_pro.int64vec_t.extend +ida_pro.int64vec_t.extract +ida_pro.int64vec_t.find +ida_pro.int64vec_t.has +ida_pro.int64vec_t.inject +ida_pro.int64vec_t.insert +ida_pro.int64vec_t.pop_back +ida_pro.int64vec_t.push_back +ida_pro.int64vec_t.qclear +ida_pro.int64vec_t.reserve +ida_pro.int64vec_t.resize +ida_pro.int64vec_t.size +ida_pro.int64vec_t.swap +ida_pro.int64vec_t.truncate +ida_pro.int8_pointer +ida_pro.int8_pointer.__init__ +ida_pro.int8_pointer.assign +ida_pro.int8_pointer.cast +ida_pro.int8_pointer.frompointer +ida_pro.int8_pointer.value +ida_pro.int_pointer +ida_pro.int_pointer.__init__ +ida_pro.int_pointer.assign +ida_pro.int_pointer.cast +ida_pro.int_pointer.frompointer +ida_pro.int_pointer.value +ida_pro.intvec_t +ida_pro.intvec_t.__eq__ +ida_pro.intvec_t.__getitem__ +ida_pro.intvec_t.__init__ +ida_pro.intvec_t.__len__ +ida_pro.intvec_t.__ne__ +ida_pro.intvec_t.__setitem__ +ida_pro.intvec_t._del +ida_pro.intvec_t.add_unique +ida_pro.intvec_t.append +ida_pro.intvec_t.at +ida_pro.intvec_t.begin +ida_pro.intvec_t.capacity +ida_pro.intvec_t.clear +ida_pro.intvec_t.empty +ida_pro.intvec_t.end +ida_pro.intvec_t.erase +ida_pro.intvec_t.extend +ida_pro.intvec_t.extract +ida_pro.intvec_t.find +ida_pro.intvec_t.has +ida_pro.intvec_t.inject +ida_pro.intvec_t.insert +ida_pro.intvec_t.pop_back +ida_pro.intvec_t.push_back +ida_pro.intvec_t.qclear +ida_pro.intvec_t.reserve +ida_pro.intvec_t.resize +ida_pro.intvec_t.size +ida_pro.intvec_t.swap +ida_pro.intvec_t.truncate +ida_pro.is_control_tty +ida_pro.is_cvt64 +ida_pro.is_main_thread +ida_pro.log2ceil +ida_pro.log2floor +ida_pro.parse_dbgopts +ida_pro.plugin_options_t +ida_pro.plugin_options_t.__init__ +ida_pro.plugin_options_t.erase +ida_pro.plugin_options_t.find +ida_pro.qatoll +ida_pro.qcontrol_tty +ida_pro.qdetach_tty +ida_pro.qexit +ida_pro.qmutex_locker_t +ida_pro.qmutex_locker_t.__init__ +ida_pro.qrefcnt_obj_t +ida_pro.qrefcnt_obj_t.__init__ +ida_pro.qrefcnt_obj_t.refcnt +ida_pro.qrefcnt_obj_t.release +ida_pro.qstrvec_t_add +ida_pro.qstrvec_t_addressof +ida_pro.qstrvec_t_assign +ida_pro.qstrvec_t_clear +ida_pro.qstrvec_t_create +ida_pro.qstrvec_t_destroy +ida_pro.qstrvec_t_from_list +ida_pro.qstrvec_t_get +ida_pro.qstrvec_t_get_clink +ida_pro.qstrvec_t_get_clink_ptr +ida_pro.qstrvec_t_insert +ida_pro.qstrvec_t_remove +ida_pro.qstrvec_t_set +ida_pro.qstrvec_t_size +ida_pro.qthread_equal +ida_pro.quote_cmdline_arg +ida_pro.qvector_reserve +ida_pro.readbytes +ida_pro.reloc_value +ida_pro.relocate_relobj +ida_pro.sel_array +ida_pro.sel_array.__getitem__ +ida_pro.sel_array.__init__ +ida_pro.sel_array.__setitem__ +ida_pro.sel_array.cast +ida_pro.sel_array.frompointer +ida_pro.sel_pointer +ida_pro.sel_pointer.__init__ +ida_pro.sel_pointer.assign +ida_pro.sel_pointer.cast +ida_pro.sel_pointer.frompointer +ida_pro.sel_pointer.value +ida_pro.short_pointer +ida_pro.short_pointer.__init__ +ida_pro.short_pointer.assign +ida_pro.short_pointer.cast +ida_pro.short_pointer.frompointer +ida_pro.short_pointer.value +ida_pro.sint8_pointer +ida_pro.sint8_pointer.__init__ +ida_pro.sint8_pointer.assign +ida_pro.sint8_pointer.cast +ida_pro.sint8_pointer.frompointer +ida_pro.sint8_pointer.value +ida_pro.sizevec_t +ida_pro.sizevec_t.__eq__ +ida_pro.sizevec_t.__getitem__ +ida_pro.sizevec_t.__init__ +ida_pro.sizevec_t.__len__ +ida_pro.sizevec_t.__ne__ +ida_pro.sizevec_t.__setitem__ +ida_pro.sizevec_t._del +ida_pro.sizevec_t.add_unique +ida_pro.sizevec_t.append +ida_pro.sizevec_t.at +ida_pro.sizevec_t.begin +ida_pro.sizevec_t.capacity +ida_pro.sizevec_t.clear +ida_pro.sizevec_t.empty +ida_pro.sizevec_t.end +ida_pro.sizevec_t.erase +ida_pro.sizevec_t.extend +ida_pro.sizevec_t.extract +ida_pro.sizevec_t.find +ida_pro.sizevec_t.grow +ida_pro.sizevec_t.has +ida_pro.sizevec_t.inject +ida_pro.sizevec_t.insert +ida_pro.sizevec_t.pop_back +ida_pro.sizevec_t.push_back +ida_pro.sizevec_t.qclear +ida_pro.sizevec_t.reserve +ida_pro.sizevec_t.resize +ida_pro.sizevec_t.size +ida_pro.sizevec_t.swap +ida_pro.sizevec_t.truncate +ida_pro.ssize_pointer +ida_pro.ssize_pointer.__init__ +ida_pro.ssize_pointer.assign +ida_pro.ssize_pointer.cast +ida_pro.ssize_pointer.frompointer +ida_pro.ssize_pointer.value +ida_pro.str2user +ida_pro.strvec_t +ida_pro.strvec_t.__getitem__ +ida_pro.strvec_t.__init__ +ida_pro.strvec_t.__len__ +ida_pro.strvec_t.__setitem__ +ida_pro.strvec_t.append +ida_pro.strvec_t.at +ida_pro.strvec_t.begin +ida_pro.strvec_t.capacity +ida_pro.strvec_t.clear +ida_pro.strvec_t.empty +ida_pro.strvec_t.end +ida_pro.strvec_t.erase +ida_pro.strvec_t.extend +ida_pro.strvec_t.extract +ida_pro.strvec_t.grow +ida_pro.strvec_t.inject +ida_pro.strvec_t.insert +ida_pro.strvec_t.pop_back +ida_pro.strvec_t.push_back +ida_pro.strvec_t.qclear +ida_pro.strvec_t.reserve +ida_pro.strvec_t.resize +ida_pro.strvec_t.size +ida_pro.strvec_t.swap +ida_pro.strvec_t.truncate +ida_pro.sval_pointer +ida_pro.sval_pointer.__init__ +ida_pro.sval_pointer.assign +ida_pro.sval_pointer.cast +ida_pro.sval_pointer.frompointer +ida_pro.sval_pointer.value +ida_pro.tid_array +ida_pro.tid_array.__getitem__ +ida_pro.tid_array.__init__ +ida_pro.tid_array.__setitem__ +ida_pro.tid_array.cast +ida_pro.tid_array.frompointer +ida_pro.tid_pointer +ida_pro.tid_pointer.__init__ +ida_pro.tid_pointer.assign +ida_pro.tid_pointer.cast +ida_pro.tid_pointer.frompointer +ida_pro.tid_pointer.value +ida_pro.uchar_array +ida_pro.uchar_array.__getitem__ +ida_pro.uchar_array.__init__ +ida_pro.uchar_array.__setitem__ +ida_pro.uchar_array.cast +ida_pro.uchar_array.frompointer +ida_pro.uchar_pointer +ida_pro.uchar_pointer.__init__ +ida_pro.uchar_pointer.assign +ida_pro.uchar_pointer.cast +ida_pro.uchar_pointer.frompointer +ida_pro.uchar_pointer.value +ida_pro.uint16_pointer +ida_pro.uint16_pointer.__init__ +ida_pro.uint16_pointer.assign +ida_pro.uint16_pointer.cast +ida_pro.uint16_pointer.frompointer +ida_pro.uint16_pointer.value +ida_pro.uint32_pointer +ida_pro.uint32_pointer.__init__ +ida_pro.uint32_pointer.assign +ida_pro.uint32_pointer.cast +ida_pro.uint32_pointer.frompointer +ida_pro.uint32_pointer.value +ida_pro.uint64_pointer +ida_pro.uint64_pointer.__init__ +ida_pro.uint64_pointer.assign +ida_pro.uint64_pointer.cast +ida_pro.uint64_pointer.frompointer +ida_pro.uint64_pointer.value +ida_pro.uint64vec_t +ida_pro.uint64vec_t.__eq__ +ida_pro.uint64vec_t.__getitem__ +ida_pro.uint64vec_t.__init__ +ida_pro.uint64vec_t.__len__ +ida_pro.uint64vec_t.__ne__ +ida_pro.uint64vec_t.__setitem__ +ida_pro.uint64vec_t._del +ida_pro.uint64vec_t.add_unique +ida_pro.uint64vec_t.append +ida_pro.uint64vec_t.at +ida_pro.uint64vec_t.begin +ida_pro.uint64vec_t.capacity +ida_pro.uint64vec_t.clear +ida_pro.uint64vec_t.empty +ida_pro.uint64vec_t.end +ida_pro.uint64vec_t.erase +ida_pro.uint64vec_t.extend +ida_pro.uint64vec_t.extract +ida_pro.uint64vec_t.find +ida_pro.uint64vec_t.has +ida_pro.uint64vec_t.inject +ida_pro.uint64vec_t.insert +ida_pro.uint64vec_t.pop_back +ida_pro.uint64vec_t.push_back +ida_pro.uint64vec_t.qclear +ida_pro.uint64vec_t.reserve +ida_pro.uint64vec_t.resize +ida_pro.uint64vec_t.size +ida_pro.uint64vec_t.swap +ida_pro.uint64vec_t.truncate +ida_pro.uint8_pointer +ida_pro.uint8_pointer.__init__ +ida_pro.uint8_pointer.assign +ida_pro.uint8_pointer.cast +ida_pro.uint8_pointer.frompointer +ida_pro.uint8_pointer.value +ida_pro.uint_pointer +ida_pro.uint_pointer.__init__ +ida_pro.uint_pointer.assign +ida_pro.uint_pointer.cast +ida_pro.uint_pointer.frompointer +ida_pro.uint_pointer.value +ida_pro.uintvec_t +ida_pro.uintvec_t.__eq__ +ida_pro.uintvec_t.__getitem__ +ida_pro.uintvec_t.__init__ +ida_pro.uintvec_t.__len__ +ida_pro.uintvec_t.__ne__ +ida_pro.uintvec_t.__setitem__ +ida_pro.uintvec_t._del +ida_pro.uintvec_t.add_unique +ida_pro.uintvec_t.append +ida_pro.uintvec_t.at +ida_pro.uintvec_t.begin +ida_pro.uintvec_t.capacity +ida_pro.uintvec_t.clear +ida_pro.uintvec_t.empty +ida_pro.uintvec_t.end +ida_pro.uintvec_t.erase +ida_pro.uintvec_t.extend +ida_pro.uintvec_t.extract +ida_pro.uintvec_t.find +ida_pro.uintvec_t.has +ida_pro.uintvec_t.inject +ida_pro.uintvec_t.insert +ida_pro.uintvec_t.pop_back +ida_pro.uintvec_t.push_back +ida_pro.uintvec_t.qclear +ida_pro.uintvec_t.reserve +ida_pro.uintvec_t.resize +ida_pro.uintvec_t.size +ida_pro.uintvec_t.swap +ida_pro.uintvec_t.truncate +ida_pro.ushort_pointer +ida_pro.ushort_pointer.__init__ +ida_pro.ushort_pointer.assign +ida_pro.ushort_pointer.cast +ida_pro.ushort_pointer.frompointer +ida_pro.ushort_pointer.value +ida_pro.uval_array +ida_pro.uval_array.__getitem__ +ida_pro.uval_array.__init__ +ida_pro.uval_array.__setitem__ +ida_pro.uval_array.cast +ida_pro.uval_array.frompointer +ida_pro.uval_pointer +ida_pro.uval_pointer.__init__ +ida_pro.uval_pointer.assign +ida_pro.uval_pointer.cast +ida_pro.uval_pointer.frompointer +ida_pro.uval_pointer.value +ida_pro.writebytes +ida_problems +ida_problems.PR_ATTN +ida_problems.PR_BADSTACK +ida_problems.PR_COLLISION +ida_problems.PR_DECIMP +ida_problems.PR_DISASM +ida_problems.PR_END +ida_problems.PR_FINAL +ida_problems.PR_HEAD +ida_problems.PR_ILLADDR +ida_problems.PR_JUMP +ida_problems.PR_MANYLINES +ida_problems.PR_NOBASE +ida_problems.PR_NOCMT +ida_problems.PR_NOFOP +ida_problems.PR_NONAME +ida_problems.PR_NOXREFS +ida_problems.PR_ROLLED +ida_problems.forget_problem +ida_problems.get_problem +ida_problems.get_problem_desc +ida_problems.get_problem_name +ida_problems.is_problem_present +ida_problems.remember_problem +ida_problems.was_ida_decision +ida_range +ida_range.RANGE_KIND_FUNC +ida_range.RANGE_KIND_HIDDEN_RANGE +ida_range.RANGE_KIND_SEGMENT +ida_range.array_of_rangesets +ida_range.array_of_rangesets.__eq__ +ida_range.array_of_rangesets.__getitem__ +ida_range.array_of_rangesets.__init__ +ida_range.array_of_rangesets.__len__ +ida_range.array_of_rangesets.__ne__ +ida_range.array_of_rangesets.__setitem__ +ida_range.array_of_rangesets._del +ida_range.array_of_rangesets.add_unique +ida_range.array_of_rangesets.append +ida_range.array_of_rangesets.at +ida_range.array_of_rangesets.begin +ida_range.array_of_rangesets.capacity +ida_range.array_of_rangesets.clear +ida_range.array_of_rangesets.empty +ida_range.array_of_rangesets.end +ida_range.array_of_rangesets.erase +ida_range.array_of_rangesets.extend +ida_range.array_of_rangesets.extract +ida_range.array_of_rangesets.find +ida_range.array_of_rangesets.grow +ida_range.array_of_rangesets.has +ida_range.array_of_rangesets.inject +ida_range.array_of_rangesets.insert +ida_range.array_of_rangesets.pop_back +ida_range.array_of_rangesets.push_back +ida_range.array_of_rangesets.qclear +ida_range.array_of_rangesets.reserve +ida_range.array_of_rangesets.resize +ida_range.array_of_rangesets.size +ida_range.array_of_rangesets.swap +ida_range.array_of_rangesets.truncate +ida_range.range_t +ida_range.range_t.__eq__ +ida_range.range_t.__ge__ +ida_range.range_t.__gt__ +ida_range.range_t.__init__ +ida_range.range_t.__le__ +ida_range.range_t.__lt__ +ida_range.range_t.__ne__ +ida_range.range_t._print +ida_range.range_t.clear +ida_range.range_t.compare +ida_range.range_t.contains +ida_range.range_t.empty +ida_range.range_t.end_ea +ida_range.range_t.extend +ida_range.range_t.intersect +ida_range.range_t.overlaps +ida_range.range_t.size +ida_range.range_t.start_ea +ida_range.range_t_print +ida_range.rangeset_t +ida_range.rangeset_t.__eq__ +ida_range.rangeset_t.__getitem__ +ida_range.rangeset_t.__init__ +ida_range.rangeset_t.__ne__ +ida_range.rangeset_t._print +ida_range.rangeset_t.add +ida_range.rangeset_t.begin +ida_range.rangeset_t.cached_range +ida_range.rangeset_t.clear +ida_range.rangeset_t.contains +ida_range.rangeset_t.empty +ida_range.rangeset_t.end +ida_range.rangeset_t.find_range +ida_range.rangeset_t.getrange +ida_range.rangeset_t.has_common +ida_range.rangeset_t.includes +ida_range.rangeset_t.intersect +ida_range.rangeset_t.is_equal +ida_range.rangeset_t.is_subset_of +ida_range.rangeset_t.lastrange +ida_range.rangeset_t.next_addr +ida_range.rangeset_t.next_range +ida_range.rangeset_t.nranges +ida_range.rangeset_t.prev_addr +ida_range.rangeset_t.prev_range +ida_range.rangeset_t.sub +ida_range.rangeset_t.swap +ida_range.rangevec_base_t +ida_range.rangevec_base_t.__eq__ +ida_range.rangevec_base_t.__getitem__ +ida_range.rangevec_base_t.__init__ +ida_range.rangevec_base_t.__len__ +ida_range.rangevec_base_t.__ne__ +ida_range.rangevec_base_t.__setitem__ +ida_range.rangevec_base_t._del +ida_range.rangevec_base_t.add_unique +ida_range.rangevec_base_t.append +ida_range.rangevec_base_t.at +ida_range.rangevec_base_t.begin +ida_range.rangevec_base_t.capacity +ida_range.rangevec_base_t.clear +ida_range.rangevec_base_t.empty +ida_range.rangevec_base_t.end +ida_range.rangevec_base_t.erase +ida_range.rangevec_base_t.extend +ida_range.rangevec_base_t.extract +ida_range.rangevec_base_t.find +ida_range.rangevec_base_t.grow +ida_range.rangevec_base_t.has +ida_range.rangevec_base_t.inject +ida_range.rangevec_base_t.insert +ida_range.rangevec_base_t.pop_back +ida_range.rangevec_base_t.push_back +ida_range.rangevec_base_t.qclear +ida_range.rangevec_base_t.reserve +ida_range.rangevec_base_t.resize +ida_range.rangevec_base_t.size +ida_range.rangevec_base_t.swap +ida_range.rangevec_base_t.truncate +ida_range.rangevec_t +ida_range.rangevec_t.__init__ +ida_registry +ida_registry.ROOT_KEY_NAME +ida_registry.reg_binary +ida_registry.reg_data_type +ida_registry.reg_delete +ida_registry.reg_delete_subkey +ida_registry.reg_delete_tree +ida_registry.reg_dword +ida_registry.reg_exists +ida_registry.reg_read_binary +ida_registry.reg_read_bool +ida_registry.reg_read_int +ida_registry.reg_read_string +ida_registry.reg_read_strlist +ida_registry.reg_subkey_exists +ida_registry.reg_subkey_subkeys +ida_registry.reg_subkey_values +ida_registry.reg_sz +ida_registry.reg_unknown +ida_registry.reg_update_filestrlist +ida_registry.reg_update_strlist +ida_registry.reg_write_binary +ida_registry.reg_write_bool +ida_registry.reg_write_int +ida_registry.reg_write_string +ida_registry.reg_write_strlist +ida_registry.set_registry_name +ida_regfinder +ida_regfinder.find_nearest_rvi +ida_regfinder.find_reg_value +ida_regfinder.find_reg_value_info +ida_regfinder.find_sp_value +ida_regfinder.invalidate_regfinder_cache +ida_regfinder.reg_value_def_t +ida_regfinder.reg_value_def_t.LIKE_GOT +ida_regfinder.reg_value_def_t.NOVAL +ida_regfinder.reg_value_def_t.PC_BASED +ida_regfinder.reg_value_def_t.SHORT_INSN +ida_regfinder.reg_value_def_t.SPVAL +ida_regfinder.reg_value_def_t.UVAL +ida_regfinder.reg_value_def_t.__eq__ +ida_regfinder.reg_value_def_t.__init__ +ida_regfinder.reg_value_def_t.__lt__ +ida_regfinder.reg_value_def_t.def_ea +ida_regfinder.reg_value_def_t.def_itype +ida_regfinder.reg_value_def_t.dstr +ida_regfinder.reg_value_def_t.flags +ida_regfinder.reg_value_def_t.is_like_got +ida_regfinder.reg_value_def_t.is_pc_based +ida_regfinder.reg_value_def_t.is_short_insn +ida_regfinder.reg_value_def_t.val +ida_regfinder.reg_value_info_t +ida_regfinder.reg_value_info_t.CONTAINED +ida_regfinder.reg_value_info_t.CONTAINS +ida_regfinder.reg_value_info_t.EQUAL +ida_regfinder.reg_value_info_t.NOT_COMPARABLE +ida_regfinder.reg_value_info_t.__getitem__ +ida_regfinder.reg_value_info_t.__init__ +ida_regfinder.reg_value_info_t.__len__ +ida_regfinder.reg_value_info_t.__str__ +ida_regfinder.reg_value_info_t.aborted +ida_regfinder.reg_value_info_t.add +ida_regfinder.reg_value_info_t.add_num +ida_regfinder.reg_value_info_t.band +ida_regfinder.reg_value_info_t.bandnot +ida_regfinder.reg_value_info_t.bnot +ida_regfinder.reg_value_info_t.bor +ida_regfinder.reg_value_info_t.bxor +ida_regfinder.reg_value_info_t.clear +ida_regfinder.reg_value_info_t.empty +ida_regfinder.reg_value_info_t.extend +ida_regfinder.reg_value_info_t.get_def_ea +ida_regfinder.reg_value_info_t.get_def_itype +ida_regfinder.reg_value_info_t.get_num +ida_regfinder.reg_value_info_t.get_spd +ida_regfinder.reg_value_info_t.has_any_vals_flag +ida_regfinder.reg_value_info_t.have_all_vals_flag +ida_regfinder.reg_value_info_t.is_all_vals_like_got +ida_regfinder.reg_value_info_t.is_all_vals_pc_based +ida_regfinder.reg_value_info_t.is_any_vals_like_got +ida_regfinder.reg_value_info_t.is_any_vals_pc_based +ida_regfinder.reg_value_info_t.is_badinsn +ida_regfinder.reg_value_info_t.is_dead_end +ida_regfinder.reg_value_info_t.is_known +ida_regfinder.reg_value_info_t.is_num +ida_regfinder.reg_value_info_t.is_spd +ida_regfinder.reg_value_info_t.is_special +ida_regfinder.reg_value_info_t.is_unkfunc +ida_regfinder.reg_value_info_t.is_unkinsn +ida_regfinder.reg_value_info_t.is_unkloop +ida_regfinder.reg_value_info_t.is_unkmult +ida_regfinder.reg_value_info_t.is_unknown +ida_regfinder.reg_value_info_t.is_unkvals +ida_regfinder.reg_value_info_t.is_unkxref +ida_regfinder.reg_value_info_t.is_value_unique +ida_regfinder.reg_value_info_t.make_aborted +ida_regfinder.reg_value_info_t.make_badinsn +ida_regfinder.reg_value_info_t.make_dead_end +ida_regfinder.reg_value_info_t.make_initial_sp +ida_regfinder.reg_value_info_t.make_num +ida_regfinder.reg_value_info_t.make_unkfunc +ida_regfinder.reg_value_info_t.make_unkinsn +ida_regfinder.reg_value_info_t.make_unkloop +ida_regfinder.reg_value_info_t.make_unkmult +ida_regfinder.reg_value_info_t.make_unkvals +ida_regfinder.reg_value_info_t.make_unkxref +ida_regfinder.reg_value_info_t.movt +ida_regfinder.reg_value_info_t.neg +ida_regfinder.reg_value_info_t.set_aborted +ida_regfinder.reg_value_info_t.set_all_vals_flag +ida_regfinder.reg_value_info_t.set_all_vals_got_based +ida_regfinder.reg_value_info_t.set_all_vals_pc_based +ida_regfinder.reg_value_info_t.set_badinsn +ida_regfinder.reg_value_info_t.set_dead_end +ida_regfinder.reg_value_info_t.set_num +ida_regfinder.reg_value_info_t.set_unkfunc +ida_regfinder.reg_value_info_t.set_unkinsn +ida_regfinder.reg_value_info_t.set_unkloop +ida_regfinder.reg_value_info_t.set_unkmult +ida_regfinder.reg_value_info_t.set_unkvals +ida_regfinder.reg_value_info_t.set_unkxref +ida_regfinder.reg_value_info_t.shift_left +ida_regfinder.reg_value_info_t.shift_right +ida_regfinder.reg_value_info_t.sll +ida_regfinder.reg_value_info_t.slr +ida_regfinder.reg_value_info_t.sub +ida_regfinder.reg_value_info_t.swap +ida_regfinder.reg_value_info_t.trunc_uval +ida_regfinder.reg_value_info_t.vals_union +ida_search +ida_search.SEARCH_BRK +ida_search.SEARCH_CASE +ida_search.SEARCH_DEF +ida_search.SEARCH_DOWN +ida_search.SEARCH_IDENT +ida_search.SEARCH_NEXT +ida_search.SEARCH_NOBRK +ida_search.SEARCH_NOSHOW +ida_search.SEARCH_REGEX +ida_search.SEARCH_UP +ida_search.SEARCH_USE +ida_search.SEARCH_USESEL +ida_search.find_code +ida_search.find_data +ida_search.find_defined +ida_search.find_error +ida_search.find_imm +ida_search.find_not_func +ida_search.find_notype +ida_search.find_reg_access +ida_search.find_suspop +ida_search.find_text +ida_search.find_unknown +ida_search.search_down +ida_segment +ida_segment.ADDSEG_FILLGAP +ida_segment.ADDSEG_IDBENC +ida_segment.ADDSEG_NOAA +ida_segment.ADDSEG_NOSREG +ida_segment.ADDSEG_NOTRUNC +ida_segment.ADDSEG_OR_DIE +ida_segment.ADDSEG_QUIET +ida_segment.ADDSEG_SPARSE +ida_segment.CSS_BREAK +ida_segment.CSS_NODBG +ida_segment.CSS_NOMEM +ida_segment.CSS_NORANGE +ida_segment.CSS_OK +ida_segment.MAX_GROUPS +ida_segment.MAX_SEGM_TRANSLATIONS +ida_segment.MOVE_SEGM_CHUNK +ida_segment.MOVE_SEGM_DEBUG +ida_segment.MOVE_SEGM_IDP +ida_segment.MOVE_SEGM_INVAL +ida_segment.MOVE_SEGM_LOADER +ida_segment.MOVE_SEGM_MAPPING +ida_segment.MOVE_SEGM_ODD +ida_segment.MOVE_SEGM_OK +ida_segment.MOVE_SEGM_ORPHAN +ida_segment.MOVE_SEGM_PARAM +ida_segment.MOVE_SEGM_ROOM +ida_segment.MOVE_SEGM_SOURCEFILES +ida_segment.MSF_FIXONCE +ida_segment.MSF_LDKEEP +ida_segment.MSF_NETNODES +ida_segment.MSF_NOFIX +ida_segment.MSF_PRIORITY +ida_segment.MSF_SILENT +ida_segment.SEGMOD_KEEP +ida_segment.SEGMOD_KEEP0 +ida_segment.SEGMOD_KEEPSEL +ida_segment.SEGMOD_KILL +ida_segment.SEGMOD_NOMOVE +ida_segment.SEGMOD_SILENT +ida_segment.SEGMOD_SPARSE +ida_segment.SEGPERM_EXEC +ida_segment.SEGPERM_MAXVAL +ida_segment.SEGPERM_READ +ida_segment.SEGPERM_WRITE +ida_segment.SEG_ABSSYM +ida_segment.SEG_BSS +ida_segment.SEG_CODE +ida_segment.SEG_COMM +ida_segment.SEG_DATA +ida_segment.SEG_GRP +ida_segment.SEG_IMEM +ida_segment.SEG_IMP +ida_segment.SEG_MAX_BITNESS_CODE +ida_segment.SEG_MAX_SEGTYPE_CODE +ida_segment.SEG_NORM +ida_segment.SEG_NULL +ida_segment.SEG_UNDF +ida_segment.SEG_XTRN +ida_segment.SFL_COMORG +ida_segment.SFL_DEBUG +ida_segment.SFL_HEADER +ida_segment.SFL_HIDDEN +ida_segment.SFL_HIDETYPE +ida_segment.SFL_LOADER +ida_segment.SFL_OBOK +ida_segment.SNAP_ALL_SEG +ida_segment.SNAP_CUR_SEG +ida_segment.SNAP_LOAD_SEG +ida_segment.SREG_NUM +ida_segment.add_segm +ida_segment.add_segm_ex +ida_segment.add_segment_translation +ida_segment.allocate_selector +ida_segment.change_segment_status +ida_segment.del_segm +ida_segment.del_segment_translations +ida_segment.del_selector +ida_segment.find_free_selector +ida_segment.find_selector +ida_segment.get_defsr +ida_segment.get_first_seg +ida_segment.get_group_selector +ida_segment.get_last_seg +ida_segment.get_next_seg +ida_segment.get_prev_seg +ida_segment.get_segm_base +ida_segment.get_segm_by_name +ida_segment.get_segm_by_sel +ida_segment.get_segm_class +ida_segment.get_segm_name +ida_segment.get_segm_num +ida_segment.get_segm_para +ida_segment.get_segm_qty +ida_segment.get_segment_alignment +ida_segment.get_segment_cmt +ida_segment.get_segment_combination +ida_segment.get_segment_translations +ida_segment.get_selector_qty +ida_segment.get_visible_segm_name +ida_segment.getn_selector +ida_segment.getnseg +ida_segment.getseg +ida_segment.is_finally_visible_segm +ida_segment.is_miniidb +ida_segment.is_segm_locked +ida_segment.is_spec_ea +ida_segment.is_spec_segm +ida_segment.is_visible_segm +ida_segment.lock_segm +ida_segment.lock_segment +ida_segment.lock_segment.__init__ +ida_segment.move_segm +ida_segment.move_segm_start +ida_segment.move_segm_strerror +ida_segment.rebase_program +ida_segment.saAbs +ida_segment.saGroup +ida_segment.saRel1024Bytes +ida_segment.saRel128Bytes +ida_segment.saRel2048Bytes +ida_segment.saRel32Bytes +ida_segment.saRel4K +ida_segment.saRel512Bytes +ida_segment.saRel64Bytes +ida_segment.saRelByte +ida_segment.saRelDble +ida_segment.saRelPage +ida_segment.saRelPara +ida_segment.saRelQword +ida_segment.saRelWord +ida_segment.scCommon +ida_segment.scGroup +ida_segment.scPriv +ida_segment.scPub +ida_segment.scPub2 +ida_segment.scPub3 +ida_segment.scStack +ida_segment.segm_adjust_diff +ida_segment.segm_adjust_ea +ida_segment.segment_defsr_array +ida_segment.segment_defsr_array.__getitem__ +ida_segment.segment_defsr_array.__init__ +ida_segment.segment_defsr_array.__len__ +ida_segment.segment_defsr_array.__setitem__ +ida_segment.segment_defsr_array._get_bytes +ida_segment.segment_defsr_array._set_bytes +ida_segment.segment_t +ida_segment.segment_t.__getDefsr +ida_segment.segment_t.__init__ +ida_segment.segment_t.abits +ida_segment.segment_t.abytes +ida_segment.segment_t.align +ida_segment.segment_t.bitness +ida_segment.segment_t.clr_comorg +ida_segment.segment_t.clr_ob_ok +ida_segment.segment_t.color +ida_segment.segment_t.comb +ida_segment.segment_t.comorg +ida_segment.segment_t.defsr +ida_segment.segment_t.defsr +ida_segment.segment_t.flags +ida_segment.segment_t.is_16bit +ida_segment.segment_t.is_32bit +ida_segment.segment_t.is_64bit +ida_segment.segment_t.is_header_segm +ida_segment.segment_t.is_hidden_segtype +ida_segment.segment_t.is_loader_segm +ida_segment.segment_t.is_visible_segm +ida_segment.segment_t.name +ida_segment.segment_t.ob_ok +ida_segment.segment_t.orgbase +ida_segment.segment_t.perm +ida_segment.segment_t.sclass +ida_segment.segment_t.sel +ida_segment.segment_t.set_comorg +ida_segment.segment_t.set_debugger_segm +ida_segment.segment_t.set_header_segm +ida_segment.segment_t.set_hidden_segtype +ida_segment.segment_t.set_loader_segm +ida_segment.segment_t.set_ob_ok +ida_segment.segment_t.set_visible_segm +ida_segment.segment_t.type +ida_segment.segment_t.update +ida_segment.segtype +ida_segment.sel2ea +ida_segment.sel2para +ida_segment.set_defsr +ida_segment.set_group_selector +ida_segment.set_segm_addressing +ida_segment.set_segm_base +ida_segment.set_segm_class +ida_segment.set_segm_end +ida_segment.set_segm_name +ida_segment.set_segm_start +ida_segment.set_segment_cmt +ida_segment.set_segment_translations +ida_segment.set_selector +ida_segment.set_visible_segm +ida_segment.setup_selector +ida_segment.std_out_segm_footer +ida_segment.take_memory_snapshot +ida_segment.update_segm +ida_segregs +ida_segregs.SR_auto +ida_segregs.SR_autostart +ida_segregs.SR_inherit +ida_segregs.SR_user +ida_segregs.copy_sreg_ranges +ida_segregs.del_sreg_range +ida_segregs.get_prev_sreg_range +ida_segregs.get_sreg +ida_segregs.get_sreg_range +ida_segregs.get_sreg_range_num +ida_segregs.get_sreg_ranges_qty +ida_segregs.getn_sreg_range +ida_segregs.set_default_dataseg +ida_segregs.set_default_sreg_value +ida_segregs.set_sreg_at_next_code +ida_segregs.split_sreg_range +ida_segregs.sreg_range_t +ida_segregs.sreg_range_t.__init__ +ida_segregs.sreg_range_t.tag +ida_segregs.sreg_range_t.val +ida_srclang +ida_srclang.SRCLANG_C +ida_srclang.SRCLANG_CPP +ida_srclang.SRCLANG_GO +ida_srclang.SRCLANG_OBJC +ida_srclang.SRCLANG_SWIFT +ida_srclang.parse_decls_for_srclang +ida_srclang.parse_decls_with_parser +ida_srclang.select_parser_by_name +ida_srclang.select_parser_by_srclang +ida_srclang.set_parser_argv +ida_strlist +ida_strlist.build_strlist +ida_strlist.clear_strlist +ida_strlist.get_strlist_item +ida_strlist.get_strlist_options +ida_strlist.get_strlist_qty +ida_strlist.string_info_t +ida_strlist.string_info_t.__init__ +ida_strlist.string_info_t.__lt__ +ida_strlist.strwinsetup_t +ida_strlist.strwinsetup_t.__init__ +ida_strlist.strwinsetup_t._get_strtypes +ida_strlist.strwinsetup_t._set_strtypes +ida_tryblks +ida_tryblks.TBEA_CATCH +ida_tryblks.TBEA_FALLTHRU +ida_tryblks.TBEA_SEHFILT +ida_tryblks.TBEA_SEHLPAD +ida_tryblks.TBEA_SEHTRY +ida_tryblks.TBEA_TRY +ida_tryblks.TBERR_EMPTY +ida_tryblks.TBERR_END +ida_tryblks.TBERR_INTERSECT +ida_tryblks.TBERR_KIND +ida_tryblks.TBERR_NO_CATCHES +ida_tryblks.TBERR_OK +ida_tryblks.TBERR_ORDER +ida_tryblks.TBERR_START +ida_tryblks.add_tryblk +ida_tryblks.catch_t +ida_tryblks.catch_t.__init__ +ida_tryblks.catchvec_t +ida_tryblks.catchvec_t.__eq__ +ida_tryblks.catchvec_t.__getitem__ +ida_tryblks.catchvec_t.__init__ +ida_tryblks.catchvec_t.__len__ +ida_tryblks.catchvec_t.__ne__ +ida_tryblks.catchvec_t.__setitem__ +ida_tryblks.catchvec_t._del +ida_tryblks.catchvec_t.add_unique +ida_tryblks.catchvec_t.append +ida_tryblks.catchvec_t.at +ida_tryblks.catchvec_t.begin +ida_tryblks.catchvec_t.capacity +ida_tryblks.catchvec_t.clear +ida_tryblks.catchvec_t.empty +ida_tryblks.catchvec_t.end +ida_tryblks.catchvec_t.erase +ida_tryblks.catchvec_t.extend +ida_tryblks.catchvec_t.extract +ida_tryblks.catchvec_t.find +ida_tryblks.catchvec_t.grow +ida_tryblks.catchvec_t.has +ida_tryblks.catchvec_t.inject +ida_tryblks.catchvec_t.insert +ida_tryblks.catchvec_t.pop_back +ida_tryblks.catchvec_t.push_back +ida_tryblks.catchvec_t.qclear +ida_tryblks.catchvec_t.reserve +ida_tryblks.catchvec_t.resize +ida_tryblks.catchvec_t.size +ida_tryblks.catchvec_t.swap +ida_tryblks.catchvec_t.truncate +ida_tryblks.del_tryblks +ida_tryblks.find_syseh +ida_tryblks.get_tryblks +ida_tryblks.is_ea_tryblks +ida_tryblks.seh_t +ida_tryblks.seh_t.__init__ +ida_tryblks.seh_t.clear +ida_tryblks.try_handler_t +ida_tryblks.try_handler_t.__init__ +ida_tryblks.try_handler_t.clear +ida_tryblks.tryblk_t +ida_tryblks.tryblk_t.__init__ +ida_tryblks.tryblk_t.clear +ida_tryblks.tryblk_t.cpp +ida_tryblks.tryblk_t.empty +ida_tryblks.tryblk_t.get_kind +ida_tryblks.tryblk_t.is_cpp +ida_tryblks.tryblk_t.is_seh +ida_tryblks.tryblk_t.seh +ida_tryblks.tryblk_t.set_cpp +ida_tryblks.tryblk_t.set_seh +ida_tryblks.tryblks_t +ida_tryblks.tryblks_t.__eq__ +ida_tryblks.tryblks_t.__getitem__ +ida_tryblks.tryblks_t.__init__ +ida_tryblks.tryblks_t.__len__ +ida_tryblks.tryblks_t.__ne__ +ida_tryblks.tryblks_t.__setitem__ +ida_tryblks.tryblks_t._del +ida_tryblks.tryblks_t.add_unique +ida_tryblks.tryblks_t.append +ida_tryblks.tryblks_t.at +ida_tryblks.tryblks_t.begin +ida_tryblks.tryblks_t.capacity +ida_tryblks.tryblks_t.clear +ida_tryblks.tryblks_t.empty +ida_tryblks.tryblks_t.end +ida_tryblks.tryblks_t.erase +ida_tryblks.tryblks_t.extend +ida_tryblks.tryblks_t.extract +ida_tryblks.tryblks_t.find +ida_tryblks.tryblks_t.grow +ida_tryblks.tryblks_t.has +ida_tryblks.tryblks_t.inject +ida_tryblks.tryblks_t.insert +ida_tryblks.tryblks_t.pop_back +ida_tryblks.tryblks_t.push_back +ida_tryblks.tryblks_t.qclear +ida_tryblks.tryblks_t.reserve +ida_tryblks.tryblks_t.resize +ida_tryblks.tryblks_t.size +ida_tryblks.tryblks_t.swap +ida_tryblks.tryblks_t.truncate +ida_typeinf +ida_typeinf.ADDTIL_ABORTED +ida_typeinf.ADDTIL_COMP +ida_typeinf.ADDTIL_DEFAULT +ida_typeinf.ADDTIL_FAILED +ida_typeinf.ADDTIL_INCOMP +ida_typeinf.ADDTIL_OK +ida_typeinf.ADDTIL_SILENT +ida_typeinf.ALOC_CUSTOM +ida_typeinf.ALOC_DIST +ida_typeinf.ALOC_NONE +ida_typeinf.ALOC_REG1 +ida_typeinf.ALOC_REG2 +ida_typeinf.ALOC_RREL +ida_typeinf.ALOC_STACK +ida_typeinf.ALOC_STATIC +ida_typeinf.ARGREGS_BY_SLOTS +ida_typeinf.ARGREGS_FP_MASKS_GP +ida_typeinf.ARGREGS_GP_ONLY +ida_typeinf.ARGREGS_INDEPENDENT +ida_typeinf.ARGREGS_MIPS_O32 +ida_typeinf.ARGREGS_RISCV +ida_typeinf.BADSIZE +ida_typeinf.BFA_FUNC_EXT_FORMAT +ida_typeinf.BFA_FUNC_MARKER +ida_typeinf.BFA_HIGH +ida_typeinf.BFA_NORET +ida_typeinf.BFA_PURE +ida_typeinf.BFA_STATIC +ida_typeinf.BFA_VIRTUAL +ida_typeinf.BTE_ALWAYS +ida_typeinf.BTE_BITMASK +ida_typeinf.BTE_CHAR +ida_typeinf.BTE_HEX +ida_typeinf.BTE_OUT_MASK +ida_typeinf.BTE_RESERVED +ida_typeinf.BTE_SDEC +ida_typeinf.BTE_SIZE_MASK +ida_typeinf.BTE_UDEC +ida_typeinf.BTF_BOOL +ida_typeinf.BTF_BYTE +ida_typeinf.BTF_CHAR +ida_typeinf.BTF_DOUBLE +ida_typeinf.BTF_ENUM +ida_typeinf.BTF_FLOAT +ida_typeinf.BTF_INT +ida_typeinf.BTF_INT128 +ida_typeinf.BTF_INT16 +ida_typeinf.BTF_INT32 +ida_typeinf.BTF_INT64 +ida_typeinf.BTF_INT8 +ida_typeinf.BTF_LDOUBLE +ida_typeinf.BTF_SINT +ida_typeinf.BTF_STRUCT +ida_typeinf.BTF_TBYTE +ida_typeinf.BTF_TYPEDEF +ida_typeinf.BTF_UCHAR +ida_typeinf.BTF_UINT +ida_typeinf.BTF_UINT128 +ida_typeinf.BTF_UINT16 +ida_typeinf.BTF_UINT32 +ida_typeinf.BTF_UINT64 +ida_typeinf.BTF_UINT8 +ida_typeinf.BTF_UNION +ida_typeinf.BTF_UNK +ida_typeinf.BTF_VOID +ida_typeinf.BTMT_ARRESERV +ida_typeinf.BTMT_BFLDI16 +ida_typeinf.BTMT_BFLDI32 +ida_typeinf.BTMT_BFLDI64 +ida_typeinf.BTMT_BFLDI8 +ida_typeinf.BTMT_BOOL1 +ida_typeinf.BTMT_BOOL2 +ida_typeinf.BTMT_BOOL4 +ida_typeinf.BTMT_BOOL8 +ida_typeinf.BTMT_CHAR +ida_typeinf.BTMT_CLOSURE +ida_typeinf.BTMT_DEFBOOL +ida_typeinf.BTMT_DEFCALL +ida_typeinf.BTMT_DEFPTR +ida_typeinf.BTMT_DOUBLE +ida_typeinf.BTMT_ENUM +ida_typeinf.BTMT_FAR +ida_typeinf.BTMT_FARCALL +ida_typeinf.BTMT_FLOAT +ida_typeinf.BTMT_INTCALL +ida_typeinf.BTMT_LNGDBL +ida_typeinf.BTMT_NEAR +ida_typeinf.BTMT_NEARCALL +ida_typeinf.BTMT_NONBASED +ida_typeinf.BTMT_SIGNED +ida_typeinf.BTMT_SIZE0 +ida_typeinf.BTMT_SIZE12 +ida_typeinf.BTMT_SIZE128 +ida_typeinf.BTMT_SIZE48 +ida_typeinf.BTMT_SPECFLT +ida_typeinf.BTMT_STRUCT +ida_typeinf.BTMT_TYPEDEF +ida_typeinf.BTMT_UNION +ida_typeinf.BTMT_UNKSIGN +ida_typeinf.BTMT_USIGNED +ida_typeinf.BTM_CONST +ida_typeinf.BTM_VOLATILE +ida_typeinf.BT_ARRAY +ida_typeinf.BT_BITFIELD +ida_typeinf.BT_BOOL +ida_typeinf.BT_COMPLEX +ida_typeinf.BT_FLOAT +ida_typeinf.BT_FUNC +ida_typeinf.BT_INT +ida_typeinf.BT_INT128 +ida_typeinf.BT_INT16 +ida_typeinf.BT_INT32 +ida_typeinf.BT_INT64 +ida_typeinf.BT_INT8 +ida_typeinf.BT_PTR +ida_typeinf.BT_RESERVED +ida_typeinf.BT_SEGREG +ida_typeinf.BT_UNK +ida_typeinf.BT_UNKNOWN +ida_typeinf.BT_UNK_BYTE +ida_typeinf.BT_UNK_DWORD +ida_typeinf.BT_UNK_OWORD +ida_typeinf.BT_UNK_QWORD +ida_typeinf.BT_UNK_WORD +ida_typeinf.BT_VOID +ida_typeinf.CC_ALLOW_ARGPERM +ida_typeinf.CC_ALLOW_REGHOLES +ida_typeinf.CC_CDECL_OK +ida_typeinf.CC_GOLANG_OK +ida_typeinf.CC_HAS_ELLIPSIS +ida_typeinf.CM_CC_CDECL +ida_typeinf.CM_CC_ELLIPSIS +ida_typeinf.CM_CC_FASTCALL +ida_typeinf.CM_CC_GOLANG +ida_typeinf.CM_CC_INVALID +ida_typeinf.CM_CC_PASCAL +ida_typeinf.CM_CC_SPECIAL +ida_typeinf.CM_CC_SPECIALE +ida_typeinf.CM_CC_SPECIALP +ida_typeinf.CM_CC_SPOILED +ida_typeinf.CM_CC_STDCALL +ida_typeinf.CM_CC_SWIFT +ida_typeinf.CM_CC_THISCALL +ida_typeinf.CM_CC_UNKNOWN +ida_typeinf.CM_CC_VOIDARG +ida_typeinf.CM_M_FF +ida_typeinf.CM_M_FN +ida_typeinf.CM_M_NF +ida_typeinf.CM_M_NN +ida_typeinf.CM_N16_F32 +ida_typeinf.CM_N32_F48 +ida_typeinf.CM_N64 +ida_typeinf.CM_N8_F16 +ida_typeinf.CM_UNKNOWN +ida_typeinf.COMP_BC +ida_typeinf.COMP_BP +ida_typeinf.COMP_GNU +ida_typeinf.COMP_MS +ida_typeinf.COMP_UNK +ida_typeinf.COMP_UNSURE +ida_typeinf.COMP_VISAGE +ida_typeinf.COMP_WATCOM +ida_typeinf.DEFMASK64 +ida_typeinf.ETF_AUTONAME +ida_typeinf.ETF_BYTIL +ida_typeinf.ETF_COMPATIBLE +ida_typeinf.ETF_FORCENAME +ida_typeinf.ETF_FUNCARG +ida_typeinf.ETF_MAY_DESTROY +ida_typeinf.ETF_NO_ARRAY +ida_typeinf.ETF_NO_LAYOUT +ida_typeinf.ETF_NO_SAVE +ida_typeinf.FAH_BYTE +ida_typeinf.FAI_ARRAY +ida_typeinf.FAI_HIDDEN +ida_typeinf.FAI_RETPTR +ida_typeinf.FAI_STRUCT +ida_typeinf.FAI_UNUSED +ida_typeinf.FIRST_NONTRIVIAL_TYPID +ida_typeinf.FRB_CHAR +ida_typeinf.FRB_CUSTOM +ida_typeinf.FRB_ENUM +ida_typeinf.FRB_FLOAT +ida_typeinf.FRB_INVBITS +ida_typeinf.FRB_INVSIGN +ida_typeinf.FRB_LZERO +ida_typeinf.FRB_MASK +ida_typeinf.FRB_NUMB +ida_typeinf.FRB_NUMD +ida_typeinf.FRB_NUMH +ida_typeinf.FRB_NUMO +ida_typeinf.FRB_OFFSET +ida_typeinf.FRB_SEG +ida_typeinf.FRB_SIGNED +ida_typeinf.FRB_STRLIT +ida_typeinf.FRB_STROFF +ida_typeinf.FRB_TABFORM +ida_typeinf.FRB_UNK +ida_typeinf.FTI_ALL +ida_typeinf.FTI_ARGLOCS +ida_typeinf.FTI_CALLTYPE +ida_typeinf.FTI_CONST +ida_typeinf.FTI_CTOR +ida_typeinf.FTI_DEFCALL +ida_typeinf.FTI_DTOR +ida_typeinf.FTI_EXPLOCS +ida_typeinf.FTI_FARCALL +ida_typeinf.FTI_HIGH +ida_typeinf.FTI_INTCALL +ida_typeinf.FTI_NEARCALL +ida_typeinf.FTI_NORET +ida_typeinf.FTI_PURE +ida_typeinf.FTI_SPOILED +ida_typeinf.FTI_STATIC +ida_typeinf.FTI_VIRTUAL +ida_typeinf.GTD_CALC_ARGLOCS +ida_typeinf.GTD_CALC_LAYOUT +ida_typeinf.GTD_DEL_BITFLDS +ida_typeinf.GTD_NO_ARGLOCS +ida_typeinf.GTD_NO_LAYOUT +ida_typeinf.GTS_BASECLASS +ida_typeinf.GTS_NESTED +ida_typeinf.GUESS_FUNC_FAILED +ida_typeinf.GUESS_FUNC_OK +ida_typeinf.GUESS_FUNC_TRIVIAL +ida_typeinf.HTI_CPP +ida_typeinf.HTI_DCL +ida_typeinf.HTI_EXT +ida_typeinf.HTI_FIL +ida_typeinf.HTI_HIGH +ida_typeinf.HTI_INT +ida_typeinf.HTI_LEX +ida_typeinf.HTI_LOWER +ida_typeinf.HTI_MAC +ida_typeinf.HTI_NDC +ida_typeinf.HTI_NER +ida_typeinf.HTI_NOBASE +ida_typeinf.HTI_NWR +ida_typeinf.HTI_PAK +ida_typeinf.HTI_PAK1 +ida_typeinf.HTI_PAK16 +ida_typeinf.HTI_PAK2 +ida_typeinf.HTI_PAK4 +ida_typeinf.HTI_PAK8 +ida_typeinf.HTI_PAKDEF +ida_typeinf.HTI_PAK_SHIFT +ida_typeinf.HTI_RAWARGS +ida_typeinf.HTI_RELAXED +ida_typeinf.HTI_SEMICOLON +ida_typeinf.HTI_TST +ida_typeinf.HTI_UNP +ida_typeinf.MAX_ENUM_SERIAL +ida_typeinf.MAX_FUNC_ARGS +ida_typeinf.NTF_64BIT +ida_typeinf.NTF_CHKSYNC +ida_typeinf.NTF_COPY +ida_typeinf.NTF_FIXNAME +ida_typeinf.NTF_IDBENC +ida_typeinf.NTF_NOBASE +ida_typeinf.NTF_NOCUR +ida_typeinf.NTF_NO_NAMECHK +ida_typeinf.NTF_REPLACE +ida_typeinf.NTF_SYMM +ida_typeinf.NTF_SYMU +ida_typeinf.NTF_TYPE +ida_typeinf.NTF_UMANGLED +ida_typeinf.PDF_DEF_BASE +ida_typeinf.PDF_DEF_FWD +ida_typeinf.PDF_HEADER_CMT +ida_typeinf.PDF_INCL_DEPS +ida_typeinf.PIO_IGNORE_PTRS +ida_typeinf.PIO_NOATTR_FAIL +ida_typeinf.PRALOC_STKOFF +ida_typeinf.PRALOC_VERIFY +ida_typeinf.PRTYPE_1LINCMT +ida_typeinf.PRTYPE_1LINE +ida_typeinf.PRTYPE_ARGLOCS +ida_typeinf.PRTYPE_COLORED +ida_typeinf.PRTYPE_CPP +ida_typeinf.PRTYPE_DEF +ida_typeinf.PRTYPE_HEADER +ida_typeinf.PRTYPE_MAXSTR +ida_typeinf.PRTYPE_METHODS +ida_typeinf.PRTYPE_MULTI +ida_typeinf.PRTYPE_NOARGS +ida_typeinf.PRTYPE_NOARRS +ida_typeinf.PRTYPE_NOREGEX +ida_typeinf.PRTYPE_NORES +ida_typeinf.PRTYPE_OFFSETS +ida_typeinf.PRTYPE_PRAGMA +ida_typeinf.PRTYPE_RESTORE +ida_typeinf.PRTYPE_SEMI +ida_typeinf.PRTYPE_TAIL +ida_typeinf.PRTYPE_TYPE +ida_typeinf.PT_EMPTY +ida_typeinf.PT_HIGH +ida_typeinf.PT_LOWER +ida_typeinf.PT_NDC +ida_typeinf.PT_PACKMASK +ida_typeinf.PT_RAWARGS +ida_typeinf.PT_RELAXED +ida_typeinf.PT_REPLACE +ida_typeinf.PT_SEMICOLON +ida_typeinf.PT_SIL +ida_typeinf.PT_TYP +ida_typeinf.PT_VAR +ida_typeinf.RESERVED_BYTE +ida_typeinf.SC_AUTO +ida_typeinf.SC_EXT +ida_typeinf.SC_FRIEND +ida_typeinf.SC_REG +ida_typeinf.SC_STAT +ida_typeinf.SC_TYPE +ida_typeinf.SC_UNK +ida_typeinf.SC_VIRT +ida_typeinf.SETCOMP_BY_USER +ida_typeinf.SETCOMP_ONLY_ABI +ida_typeinf.SETCOMP_ONLY_ID +ida_typeinf.SETCOMP_OVERRIDE +ida_typeinf.STI_ACCHAR +ida_typeinf.STI_ACHAR +ida_typeinf.STI_ACUCHAR +ida_typeinf.STI_AEABI_LCMP +ida_typeinf.STI_AEABI_MEMCLR +ida_typeinf.STI_AEABI_MEMCPY +ida_typeinf.STI_AEABI_MEMSET +ida_typeinf.STI_AEABI_ULCMP +ida_typeinf.STI_AUCHAR +ida_typeinf.STI_COMPLEX128 +ida_typeinf.STI_COMPLEX64 +ida_typeinf.STI_DONT_USE +ida_typeinf.STI_FDELOP +ida_typeinf.STI_FPURGING +ida_typeinf.STI_MSGSEND +ida_typeinf.STI_PBYTE +ida_typeinf.STI_PCCHAR +ida_typeinf.STI_PCHAR +ida_typeinf.STI_PCUCHAR +ida_typeinf.STI_PCVOID +ida_typeinf.STI_PINT +ida_typeinf.STI_PPVOID +ida_typeinf.STI_PUCHAR +ida_typeinf.STI_PUINT +ida_typeinf.STI_PUNKNOWN +ida_typeinf.STI_PVOID +ida_typeinf.STI_RTC_CHECK_2 +ida_typeinf.STI_RTC_CHECK_4 +ida_typeinf.STI_RTC_CHECK_8 +ida_typeinf.STI_SIZE_T +ida_typeinf.STI_SSIZE_T +ida_typeinf.STRMEM_ANON +ida_typeinf.STRMEM_AUTO +ida_typeinf.STRMEM_CASTABLE_TO +ida_typeinf.STRMEM_INDEX +ida_typeinf.STRMEM_LOWBND +ida_typeinf.STRMEM_MAXS +ida_typeinf.STRMEM_MINS +ida_typeinf.STRMEM_NAME +ida_typeinf.STRMEM_NEXT +ida_typeinf.STRMEM_OFFSET +ida_typeinf.STRMEM_SIZE +ida_typeinf.STRMEM_SKIP_EMPTY +ida_typeinf.STRMEM_SKIP_GAPS +ida_typeinf.STRMEM_TYPE +ida_typeinf.STRMEM_VFTABLE +ida_typeinf.STRUC_SEPARATOR +ida_typeinf.SUDT_ALIGN +ida_typeinf.SUDT_CONST +ida_typeinf.SUDT_FAST +ida_typeinf.SUDT_GAPS +ida_typeinf.SUDT_SERDEF +ida_typeinf.SUDT_SORT +ida_typeinf.SUDT_TRUNC +ida_typeinf.SUDT_UNEX +ida_typeinf.SUDT_VOLATILE +ida_typeinf.TAENUM_64BIT +ida_typeinf.TAENUM_BIN +ida_typeinf.TAENUM_LZERO +ida_typeinf.TAENUM_NUMSIGN +ida_typeinf.TAENUM_OCT +ida_typeinf.TAENUM_SIGNED +ida_typeinf.TAENUM_UNSIGNED +ida_typeinf.TAFLD_BASECLASS +ida_typeinf.TAFLD_BYTIL +ida_typeinf.TAFLD_FRAME_R +ida_typeinf.TAFLD_FRAME_S +ida_typeinf.TAFLD_GAP +ida_typeinf.TAFLD_METHOD +ida_typeinf.TAFLD_REGCMT +ida_typeinf.TAFLD_UNALIGNED +ida_typeinf.TAFLD_VFTABLE +ida_typeinf.TAFLD_VIRTBASE +ida_typeinf.TAH_ALL +ida_typeinf.TAH_BYTE +ida_typeinf.TAH_HASATTRS +ida_typeinf.TAPTR_PTR32 +ida_typeinf.TAPTR_PTR64 +ida_typeinf.TAPTR_RESTRICT +ida_typeinf.TAPTR_SHIFTED +ida_typeinf.TAUDT_CPPOBJ +ida_typeinf.TAUDT_FIXED +ida_typeinf.TAUDT_MSSTRUCT +ida_typeinf.TAUDT_UNALIGNED +ida_typeinf.TAUDT_VFTABLE +ida_typeinf.TA_FORMAT +ida_typeinf.TA_ORG_ARRDIM +ida_typeinf.TA_ORG_TYPEDEF +ida_typeinf.TA_VALUE_REPR +ida_typeinf.TCMP_ANYBASE +ida_typeinf.TCMP_AUTOCAST +ida_typeinf.TCMP_CALL +ida_typeinf.TCMP_DECL +ida_typeinf.TCMP_DELPTR +ida_typeinf.TCMP_EQUAL +ida_typeinf.TCMP_IGNMODS +ida_typeinf.TCMP_MANCAST +ida_typeinf.TCMP_SKIPTHIS +ida_typeinf.TERR_ALIEN_NAME +ida_typeinf.TERR_BAD_ARG +ida_typeinf.TERR_BAD_ARRAY +ida_typeinf.TERR_BAD_BASE +ida_typeinf.TERR_BAD_BF +ida_typeinf.TERR_BAD_BMASK +ida_typeinf.TERR_BAD_FX_SIZE +ida_typeinf.TERR_BAD_GAP +ida_typeinf.TERR_BAD_GROUPS +ida_typeinf.TERR_BAD_INDEX +ida_typeinf.TERR_BAD_LAYOUT +ida_typeinf.TERR_BAD_MSKVAL +ida_typeinf.TERR_BAD_NAME +ida_typeinf.TERR_BAD_OFFSET +ida_typeinf.TERR_BAD_REPR +ida_typeinf.TERR_BAD_SERIAL +ida_typeinf.TERR_BAD_SIZE +ida_typeinf.TERR_BAD_SUBTYPE +ida_typeinf.TERR_BAD_TAH +ida_typeinf.TERR_BAD_TYPE +ida_typeinf.TERR_BAD_UNIVAR +ida_typeinf.TERR_BAD_VALUE +ida_typeinf.TERR_BAD_VARLAST +ida_typeinf.TERR_DUPNAME +ida_typeinf.TERR_ENUM_SIZE +ida_typeinf.TERR_GRP_NOEMPTY +ida_typeinf.TERR_NESTED +ida_typeinf.TERR_NOT_COMPAT +ida_typeinf.TERR_NOT_FOUND +ida_typeinf.TERR_NOT_IMPL +ida_typeinf.TERR_NO_BMASK +ida_typeinf.TERR_OK +ida_typeinf.TERR_OVERLAP +ida_typeinf.TERR_SAVE_ERROR +ida_typeinf.TERR_SERIALIZE +ida_typeinf.TERR_STOCK +ida_typeinf.TERR_STRUCT_SIZE +ida_typeinf.TERR_TYPE_WORSE +ida_typeinf.TERR_UNION_BF +ida_typeinf.TIL_ADD_ALREADY +ida_typeinf.TIL_ADD_FAILED +ida_typeinf.TIL_ADD_OK +ida_typeinf.TIL_ALI +ida_typeinf.TIL_ESI +ida_typeinf.TIL_MAC +ida_typeinf.TIL_MOD +ida_typeinf.TIL_ORD +ida_typeinf.TIL_SLD +ida_typeinf.TIL_STM +ida_typeinf.TIL_UNI +ida_typeinf.TIL_ZIP +ida_typeinf.TINFO_DEFINITE +ida_typeinf.TINFO_DELAYFUNC +ida_typeinf.TINFO_GUESSED +ida_typeinf.TINFO_STRICT +ida_typeinf.TVIS_CMT +ida_typeinf.TVIS_NAME +ida_typeinf.TVIS_RPTCMT +ida_typeinf.TVIS_TYPE +ida_typeinf.TVST_DEF +ida_typeinf.TVST_PRUNE +ida_typeinf.TYPE_BASE_MASK +ida_typeinf.TYPE_FLAGS_MASK +ida_typeinf.TYPE_FULL_MASK +ida_typeinf.TYPE_MODIF_MASK +ida_typeinf.TYPID_ISREF +ida_typeinf.TYPID_SHIFT +ida_typeinf.VALSTR_OPEN +ida_typeinf._BT_LAST_BASIC +ida_typeinf._wrap_cvar +ida_typeinf._wrap_cvar.__getattr__ +ida_typeinf._wrap_cvar.__setattr__ +ida_typeinf.add_til +ida_typeinf.alloc_type_ordinal +ida_typeinf.alloc_type_ordinals +ida_typeinf.aloc_visitor_t +ida_typeinf.aloc_visitor_t.__disown__ +ida_typeinf.aloc_visitor_t.__init__ +ida_typeinf.aloc_visitor_t.visit_location +ida_typeinf.append_abi_opts +ida_typeinf.append_argloc +ida_typeinf.append_tinfo_covered +ida_typeinf.apply_callee_tinfo +ida_typeinf.apply_cdecl +ida_typeinf.apply_named_type +ida_typeinf.apply_once_tinfo_and_name +ida_typeinf.apply_tinfo +ida_typeinf.apply_tinfo_to_stkarg +ida_typeinf.apply_type +ida_typeinf.argloc_t +ida_typeinf.argloc_t.__eq__ +ida_typeinf.argloc_t.__ge__ +ida_typeinf.argloc_t.__gt__ +ida_typeinf.argloc_t.__init__ +ida_typeinf.argloc_t.__le__ +ida_typeinf.argloc_t.__lt__ +ida_typeinf.argloc_t.__ne__ +ida_typeinf.argloc_t._consume_rrel +ida_typeinf.argloc_t._consume_scattered +ida_typeinf.argloc_t._set_badloc +ida_typeinf.argloc_t._set_biggest +ida_typeinf.argloc_t._set_custom +ida_typeinf.argloc_t._set_ea +ida_typeinf.argloc_t._set_reg1 +ida_typeinf.argloc_t._set_reg2 +ida_typeinf.argloc_t._set_stkoff +ida_typeinf.argloc_t.advance +ida_typeinf.argloc_t.align_reg_high +ida_typeinf.argloc_t.align_stkoff_high +ida_typeinf.argloc_t.atype +ida_typeinf.argloc_t.calc_offset +ida_typeinf.argloc_t.compare +ida_typeinf.argloc_t.consume_rrel +ida_typeinf.argloc_t.consume_scattered +ida_typeinf.argloc_t.get_biggest +ida_typeinf.argloc_t.get_custom +ida_typeinf.argloc_t.get_ea +ida_typeinf.argloc_t.get_reginfo +ida_typeinf.argloc_t.get_rrel +ida_typeinf.argloc_t.has_reg +ida_typeinf.argloc_t.has_stkoff +ida_typeinf.argloc_t.in_stack +ida_typeinf.argloc_t.is_badloc +ida_typeinf.argloc_t.is_custom +ida_typeinf.argloc_t.is_ea +ida_typeinf.argloc_t.is_fragmented +ida_typeinf.argloc_t.is_mixed_scattered +ida_typeinf.argloc_t.is_reg +ida_typeinf.argloc_t.is_reg1 +ida_typeinf.argloc_t.is_reg2 +ida_typeinf.argloc_t.is_rrel +ida_typeinf.argloc_t.is_scattered +ida_typeinf.argloc_t.is_stkoff +ida_typeinf.argloc_t.reg1 +ida_typeinf.argloc_t.reg2 +ida_typeinf.argloc_t.regoff +ida_typeinf.argloc_t.scattered +ida_typeinf.argloc_t.set_badloc +ida_typeinf.argloc_t.set_ea +ida_typeinf.argloc_t.set_reg1 +ida_typeinf.argloc_t.set_reg2 +ida_typeinf.argloc_t.set_stkoff +ida_typeinf.argloc_t.stkoff +ida_typeinf.argloc_t.swap +ida_typeinf.argpart_t +ida_typeinf.argpart_t.__init__ +ida_typeinf.argpart_t.__lt__ +ida_typeinf.argpart_t.bad_offset +ida_typeinf.argpart_t.bad_size +ida_typeinf.argpart_t.off +ida_typeinf.argpart_t.size +ida_typeinf.argpart_t.swap +ida_typeinf.argpartvec_t +ida_typeinf.argpartvec_t.__eq__ +ida_typeinf.argpartvec_t.__getitem__ +ida_typeinf.argpartvec_t.__init__ +ida_typeinf.argpartvec_t.__len__ +ida_typeinf.argpartvec_t.__ne__ +ida_typeinf.argpartvec_t.__setitem__ +ida_typeinf.argpartvec_t._del +ida_typeinf.argpartvec_t.add_unique +ida_typeinf.argpartvec_t.append +ida_typeinf.argpartvec_t.at +ida_typeinf.argpartvec_t.begin +ida_typeinf.argpartvec_t.capacity +ida_typeinf.argpartvec_t.clear +ida_typeinf.argpartvec_t.empty +ida_typeinf.argpartvec_t.end +ida_typeinf.argpartvec_t.erase +ida_typeinf.argpartvec_t.extend +ida_typeinf.argpartvec_t.extract +ida_typeinf.argpartvec_t.find +ida_typeinf.argpartvec_t.grow +ida_typeinf.argpartvec_t.has +ida_typeinf.argpartvec_t.inject +ida_typeinf.argpartvec_t.insert +ida_typeinf.argpartvec_t.pop_back +ida_typeinf.argpartvec_t.push_back +ida_typeinf.argpartvec_t.qclear +ida_typeinf.argpartvec_t.reserve +ida_typeinf.argpartvec_t.resize +ida_typeinf.argpartvec_t.size +ida_typeinf.argpartvec_t.swap +ida_typeinf.argpartvec_t.truncate +ida_typeinf.argtinfo_helper_t +ida_typeinf.argtinfo_helper_t.__disown__ +ida_typeinf.argtinfo_helper_t.__init__ +ida_typeinf.argtinfo_helper_t.has_delay_slot +ida_typeinf.argtinfo_helper_t.is_stkarg_load +ida_typeinf.argtinfo_helper_t.set_op_tinfo +ida_typeinf.argtinfo_helper_t.use_arg_tinfos +ida_typeinf.array_type_data_t +ida_typeinf.array_type_data_t.__init__ +ida_typeinf.array_type_data_t.base +ida_typeinf.array_type_data_t.elem_type +ida_typeinf.array_type_data_t.nelems +ida_typeinf.array_type_data_t.swap +ida_typeinf.begin_type_updating +ida_typeinf.bitfield_type_data_t +ida_typeinf.bitfield_type_data_t.__eq__ +ida_typeinf.bitfield_type_data_t.__ge__ +ida_typeinf.bitfield_type_data_t.__gt__ +ida_typeinf.bitfield_type_data_t.__init__ +ida_typeinf.bitfield_type_data_t.__le__ +ida_typeinf.bitfield_type_data_t.__lt__ +ida_typeinf.bitfield_type_data_t.__ne__ +ida_typeinf.bitfield_type_data_t.compare +ida_typeinf.bitfield_type_data_t.is_unsigned +ida_typeinf.bitfield_type_data_t.is_valid_bitfield +ida_typeinf.bitfield_type_data_t.nbytes +ida_typeinf.bitfield_type_data_t.swap +ida_typeinf.bitfield_type_data_t.width +ida_typeinf.calc_c_cpp_name +ida_typeinf.calc_number_of_children +ida_typeinf.calc_tinfo_gaps +ida_typeinf.calc_type_size +ida_typeinf.callregs_t +ida_typeinf.callregs_t.__init__ +ida_typeinf.callregs_t.by_slots +ida_typeinf.callregs_t.fpregs +ida_typeinf.callregs_t.gpregs +ida_typeinf.callregs_t.init_regs +ida_typeinf.callregs_t.nregs +ida_typeinf.callregs_t.policy +ida_typeinf.callregs_t.regcount +ida_typeinf.callregs_t.reginds +ida_typeinf.callregs_t.reset +ida_typeinf.callregs_t.set +ida_typeinf.callregs_t.set_registers +ida_typeinf.callregs_t.swap +ida_typeinf.choose_local_tinfo +ida_typeinf.choose_local_tinfo_and_delta +ida_typeinf.choose_named_type +ida_typeinf.clear_tinfo_t +ida_typeinf.compact_til +ida_typeinf.compare_tinfo +ida_typeinf.const_aloc_visitor_t +ida_typeinf.const_aloc_visitor_t.__disown__ +ida_typeinf.const_aloc_visitor_t.__init__ +ida_typeinf.const_aloc_visitor_t.visit_location +ida_typeinf.convert_pt_flags_to_hti +ida_typeinf.copy_named_type +ida_typeinf.copy_tinfo_t +ida_typeinf.create_enum_type +ida_typeinf.create_numbered_type_name +ida_typeinf.create_tinfo +ida_typeinf.custom_data_type_info_t +ida_typeinf.custom_data_type_info_t.__init__ +ida_typeinf.custom_data_type_info_t.dtid +ida_typeinf.custom_data_type_info_t.fid +ida_typeinf.default_compiler +ida_typeinf.del_named_type +ida_typeinf.del_numbered_type +ida_typeinf.del_til +ida_typeinf.del_tinfo_attr +ida_typeinf.del_vftable_ea +ida_typeinf.deref_ptr +ida_typeinf.deserialize_tinfo +ida_typeinf.detach_tinfo_t +ida_typeinf.dstr_tinfo +ida_typeinf.dump_func_type_data +ida_typeinf.edm_t +ida_typeinf.edm_t.__eq__ +ida_typeinf.edm_t.__init__ +ida_typeinf.edm_t.__ne__ +ida_typeinf.edm_t.empty +ida_typeinf.edm_t.get_tid +ida_typeinf.edm_t.swap +ida_typeinf.edmvec_t +ida_typeinf.edmvec_t.__eq__ +ida_typeinf.edmvec_t.__getitem__ +ida_typeinf.edmvec_t.__init__ +ida_typeinf.edmvec_t.__len__ +ida_typeinf.edmvec_t.__ne__ +ida_typeinf.edmvec_t.__setitem__ +ida_typeinf.edmvec_t._del +ida_typeinf.edmvec_t.add_unique +ida_typeinf.edmvec_t.append +ida_typeinf.edmvec_t.at +ida_typeinf.edmvec_t.begin +ida_typeinf.edmvec_t.capacity +ida_typeinf.edmvec_t.clear +ida_typeinf.edmvec_t.empty +ida_typeinf.edmvec_t.end +ida_typeinf.edmvec_t.erase +ida_typeinf.edmvec_t.extend +ida_typeinf.edmvec_t.extract +ida_typeinf.edmvec_t.find +ida_typeinf.edmvec_t.grow +ida_typeinf.edmvec_t.has +ida_typeinf.edmvec_t.inject +ida_typeinf.edmvec_t.insert +ida_typeinf.edmvec_t.pop_back +ida_typeinf.edmvec_t.push_back +ida_typeinf.edmvec_t.qclear +ida_typeinf.edmvec_t.reserve +ida_typeinf.edmvec_t.resize +ida_typeinf.edmvec_t.size +ida_typeinf.edmvec_t.swap +ida_typeinf.edmvec_t.truncate +ida_typeinf.enable_numbered_types +ida_typeinf.end_type_updating +ida_typeinf.enum_type_data_t +ida_typeinf.enum_type_data_t.__init__ +ida_typeinf.enum_type_data_t.add_constant +ida_typeinf.enum_type_data_t.all_constants +ida_typeinf.enum_type_data_t.all_groups +ida_typeinf.enum_type_data_t.bte +ida_typeinf.enum_type_data_t.calc_mask +ida_typeinf.enum_type_data_t.calc_nbytes +ida_typeinf.enum_type_data_t.find_member +ida_typeinf.enum_type_data_t.get_constant_group +ida_typeinf.enum_type_data_t.get_enum_radix +ida_typeinf.enum_type_data_t.get_max_serial +ida_typeinf.enum_type_data_t.get_serial +ida_typeinf.enum_type_data_t.get_value_repr +ida_typeinf.enum_type_data_t.group_sizes +ida_typeinf.enum_type_data_t.has_lzero +ida_typeinf.enum_type_data_t.is_bf +ida_typeinf.enum_type_data_t.is_bin +ida_typeinf.enum_type_data_t.is_char +ida_typeinf.enum_type_data_t.is_dec +ida_typeinf.enum_type_data_t.is_group_mask_at +ida_typeinf.enum_type_data_t.is_hex +ida_typeinf.enum_type_data_t.is_number_signed +ida_typeinf.enum_type_data_t.is_oct +ida_typeinf.enum_type_data_t.is_sbin +ida_typeinf.enum_type_data_t.is_shex +ida_typeinf.enum_type_data_t.is_soct +ida_typeinf.enum_type_data_t.is_udec +ida_typeinf.enum_type_data_t.is_valid_group_sizes +ida_typeinf.enum_type_data_t.set_enum_radix +ida_typeinf.enum_type_data_t.set_lzero +ida_typeinf.enum_type_data_t.set_nbytes +ida_typeinf.enum_type_data_t.set_value_repr +ida_typeinf.enum_type_data_t.store_64bit_values +ida_typeinf.enum_type_data_t.swap +ida_typeinf.enum_type_data_t.taenum_bits +ida_typeinf.extract_argloc +ida_typeinf.find_tinfo_udt_member +ida_typeinf.first_named_type +ida_typeinf.for_all_arglocs +ida_typeinf.for_all_const_arglocs +ida_typeinf.free_til +ida_typeinf.func_has_stkframe_hole +ida_typeinf.func_type_data_t +ida_typeinf.func_type_data_t.__init__ +ida_typeinf.func_type_data_t.cc +ida_typeinf.func_type_data_t.dump +ida_typeinf.func_type_data_t.find_argument +ida_typeinf.func_type_data_t.flags +ida_typeinf.func_type_data_t.get_call_method +ida_typeinf.func_type_data_t.guess_cc +ida_typeinf.func_type_data_t.is_const +ida_typeinf.func_type_data_t.is_ctor +ida_typeinf.func_type_data_t.is_dtor +ida_typeinf.func_type_data_t.is_golang_cc +ida_typeinf.func_type_data_t.is_high +ida_typeinf.func_type_data_t.is_noret +ida_typeinf.func_type_data_t.is_pure +ida_typeinf.func_type_data_t.is_static +ida_typeinf.func_type_data_t.is_swift_cc +ida_typeinf.func_type_data_t.is_vararg_cc +ida_typeinf.func_type_data_t.is_virtual +ida_typeinf.func_type_data_t.retloc +ida_typeinf.func_type_data_t.rettype +ida_typeinf.func_type_data_t.spoiled +ida_typeinf.func_type_data_t.stkargs +ida_typeinf.func_type_data_t.swap +ida_typeinf.funcarg_t +ida_typeinf.funcarg_t.__eq__ +ida_typeinf.funcarg_t.__init__ +ida_typeinf.funcarg_t.__ne__ +ida_typeinf.funcarg_t.argloc +ida_typeinf.funcarg_t.cmt +ida_typeinf.funcarg_t.flags +ida_typeinf.funcarg_t.name +ida_typeinf.funcarg_t.type +ida_typeinf.funcargvec_t +ida_typeinf.funcargvec_t.__eq__ +ida_typeinf.funcargvec_t.__getitem__ +ida_typeinf.funcargvec_t.__init__ +ida_typeinf.funcargvec_t.__len__ +ida_typeinf.funcargvec_t.__ne__ +ida_typeinf.funcargvec_t.__setitem__ +ida_typeinf.funcargvec_t._del +ida_typeinf.funcargvec_t.add_unique +ida_typeinf.funcargvec_t.append +ida_typeinf.funcargvec_t.at +ida_typeinf.funcargvec_t.begin +ida_typeinf.funcargvec_t.capacity +ida_typeinf.funcargvec_t.clear +ida_typeinf.funcargvec_t.empty +ida_typeinf.funcargvec_t.end +ida_typeinf.funcargvec_t.erase +ida_typeinf.funcargvec_t.extend +ida_typeinf.funcargvec_t.extract +ida_typeinf.funcargvec_t.find +ida_typeinf.funcargvec_t.grow +ida_typeinf.funcargvec_t.has +ida_typeinf.funcargvec_t.inject +ida_typeinf.funcargvec_t.insert +ida_typeinf.funcargvec_t.pop_back +ida_typeinf.funcargvec_t.push_back +ida_typeinf.funcargvec_t.qclear +ida_typeinf.funcargvec_t.reserve +ida_typeinf.funcargvec_t.resize +ida_typeinf.funcargvec_t.size +ida_typeinf.funcargvec_t.swap +ida_typeinf.funcargvec_t.truncate +ida_typeinf.gcc_layout +ida_typeinf.gen_decorate_name +ida_typeinf.gen_use_arg_tinfos +ida_typeinf.get_abi_name +ida_typeinf.get_alias_target +ida_typeinf.get_arg_addrs +ida_typeinf.get_base_type +ida_typeinf.get_c_header_path +ida_typeinf.get_c_macros +ida_typeinf.get_comp +ida_typeinf.get_compiler_abbr +ida_typeinf.get_compiler_name +ida_typeinf.get_compilers +ida_typeinf.get_enum_member_expr +ida_typeinf.get_full_type +ida_typeinf.get_idainfo_by_type +ida_typeinf.get_idainfo_by_udm +ida_typeinf.get_idati +ida_typeinf.get_named_type +ida_typeinf.get_named_type64 +ida_typeinf.get_named_type_tid +ida_typeinf.get_numbered_type +ida_typeinf.get_numbered_type_name +ida_typeinf.get_ordinal_count +ida_typeinf.get_ordinal_limit +ida_typeinf.get_scalar_bt +ida_typeinf.get_stock_tinfo +ida_typeinf.get_tid_name +ida_typeinf.get_tid_ordinal +ida_typeinf.get_tinfo_attr +ida_typeinf.get_tinfo_attrs +ida_typeinf.get_tinfo_by_edm_name +ida_typeinf.get_tinfo_by_flags +ida_typeinf.get_tinfo_details +ida_typeinf.get_tinfo_pdata +ida_typeinf.get_tinfo_property +ida_typeinf.get_tinfo_property4 +ida_typeinf.get_tinfo_size +ida_typeinf.get_type_flags +ida_typeinf.get_type_ordinal +ida_typeinf.get_udm_by_fullname +ida_typeinf.get_vftable_ea +ida_typeinf.get_vftable_ordinal +ida_typeinf.guess_func_cc +ida_typeinf.guess_tinfo +ida_typeinf.ida_lowertype_helper_t +ida_typeinf.ida_lowertype_helper_t.__init__ +ida_typeinf.ida_lowertype_helper_t.func_has_stkframe_hole +ida_typeinf.ida_lowertype_helper_t.get_func_purged_bytes +ida_typeinf.idc_get_local_type +ida_typeinf.idc_get_local_type_name +ida_typeinf.idc_get_local_type_raw +ida_typeinf.idc_get_type +ida_typeinf.idc_get_type_raw +ida_typeinf.idc_guess_type +ida_typeinf.idc_parse_decl +ida_typeinf.idc_parse_types +ida_typeinf.idc_print_type +ida_typeinf.idc_set_local_type +ida_typeinf.inf_big_arg_align +ida_typeinf.inf_huge_arg_align +ida_typeinf.inf_pack_stkargs +ida_typeinf.is_code_far +ida_typeinf.is_comp_unsure +ida_typeinf.is_data_far +ida_typeinf.is_gcc +ida_typeinf.is_gcc32 +ida_typeinf.is_gcc64 +ida_typeinf.is_golang_cc +ida_typeinf.is_one_bit_mask +ida_typeinf.is_ordinal_name +ida_typeinf.is_purging_cc +ida_typeinf.is_restype_enum +ida_typeinf.is_restype_struct +ida_typeinf.is_restype_struni +ida_typeinf.is_restype_void +ida_typeinf.is_sdacl_byte +ida_typeinf.is_swift_cc +ida_typeinf.is_tah_byte +ida_typeinf.is_type_arithmetic +ida_typeinf.is_type_array +ida_typeinf.is_type_bitfld +ida_typeinf.is_type_bool +ida_typeinf.is_type_char +ida_typeinf.is_type_choosable +ida_typeinf.is_type_complex +ida_typeinf.is_type_const +ida_typeinf.is_type_double +ida_typeinf.is_type_enum +ida_typeinf.is_type_ext_arithmetic +ida_typeinf.is_type_ext_integral +ida_typeinf.is_type_float +ida_typeinf.is_type_floating +ida_typeinf.is_type_func +ida_typeinf.is_type_int +ida_typeinf.is_type_int128 +ida_typeinf.is_type_int16 +ida_typeinf.is_type_int32 +ida_typeinf.is_type_int64 +ida_typeinf.is_type_integral +ida_typeinf.is_type_ldouble +ida_typeinf.is_type_paf +ida_typeinf.is_type_partial +ida_typeinf.is_type_ptr +ida_typeinf.is_type_ptr_or_array +ida_typeinf.is_type_struct +ida_typeinf.is_type_struni +ida_typeinf.is_type_sue +ida_typeinf.is_type_tbyte +ida_typeinf.is_type_typedef +ida_typeinf.is_type_uchar +ida_typeinf.is_type_uint +ida_typeinf.is_type_uint128 +ida_typeinf.is_type_uint16 +ida_typeinf.is_type_uint32 +ida_typeinf.is_type_uint64 +ida_typeinf.is_type_union +ida_typeinf.is_type_unknown +ida_typeinf.is_type_void +ida_typeinf.is_type_volatile +ida_typeinf.is_typeid_last +ida_typeinf.is_user_cc +ida_typeinf.is_vararg_cc +ida_typeinf.lexcompare_tinfo +ida_typeinf.load_til +ida_typeinf.load_til_header +ida_typeinf.lower_type +ida_typeinf.lowertype_helper_t +ida_typeinf.lowertype_helper_t.__init__ +ida_typeinf.lowertype_helper_t.func_has_stkframe_hole +ida_typeinf.lowertype_helper_t.get_func_purged_bytes +ida_typeinf.new_til +ida_typeinf.next_named_type +ida_typeinf.no_sign +ida_typeinf.optimize_argloc +ida_typeinf.pack_idcobj_to_bv +ida_typeinf.pack_idcobj_to_idb +ida_typeinf.pack_object_to_bv +ida_typeinf.pack_object_to_idb +ida_typeinf.parse_decl +ida_typeinf.parse_decls +ida_typeinf.predicate_t +ida_typeinf.predicate_t.__disown__ +ida_typeinf.predicate_t.__init__ +ida_typeinf.predicate_t.should_display +ida_typeinf.print_argloc +ida_typeinf.print_decls +ida_typeinf.print_tinfo +ida_typeinf.print_type +ida_typeinf.ptr_type_data_t +ida_typeinf.ptr_type_data_t.__eq__ +ida_typeinf.ptr_type_data_t.__init__ +ida_typeinf.ptr_type_data_t.__ne__ +ida_typeinf.ptr_type_data_t.closure +ida_typeinf.ptr_type_data_t.delta +ida_typeinf.ptr_type_data_t.is_code_ptr +ida_typeinf.ptr_type_data_t.is_shifted +ida_typeinf.ptr_type_data_t.obj_type +ida_typeinf.ptr_type_data_t.parent +ida_typeinf.ptr_type_data_t.swap +ida_typeinf.ptr_type_data_t.taptr_bits +ida_typeinf.read_tinfo_bitfield_value +ida_typeinf.reginfovec_t +ida_typeinf.reginfovec_t.__eq__ +ida_typeinf.reginfovec_t.__getitem__ +ida_typeinf.reginfovec_t.__init__ +ida_typeinf.reginfovec_t.__len__ +ida_typeinf.reginfovec_t.__ne__ +ida_typeinf.reginfovec_t.__setitem__ +ida_typeinf.reginfovec_t._del +ida_typeinf.reginfovec_t.add_unique +ida_typeinf.reginfovec_t.append +ida_typeinf.reginfovec_t.at +ida_typeinf.reginfovec_t.begin +ida_typeinf.reginfovec_t.capacity +ida_typeinf.reginfovec_t.clear +ida_typeinf.reginfovec_t.empty +ida_typeinf.reginfovec_t.end +ida_typeinf.reginfovec_t.erase +ida_typeinf.reginfovec_t.extend +ida_typeinf.reginfovec_t.extract +ida_typeinf.reginfovec_t.find +ida_typeinf.reginfovec_t.grow +ida_typeinf.reginfovec_t.has +ida_typeinf.reginfovec_t.inject +ida_typeinf.reginfovec_t.insert +ida_typeinf.reginfovec_t.pop_back +ida_typeinf.reginfovec_t.push_back +ida_typeinf.reginfovec_t.qclear +ida_typeinf.reginfovec_t.reserve +ida_typeinf.reginfovec_t.resize +ida_typeinf.reginfovec_t.size +ida_typeinf.reginfovec_t.swap +ida_typeinf.reginfovec_t.truncate +ida_typeinf.regobj_t +ida_typeinf.regobj_t.__init__ +ida_typeinf.regobj_t.regidx +ida_typeinf.regobj_t.relocate +ida_typeinf.regobj_t.size +ida_typeinf.regobjs_t +ida_typeinf.regobjs_t.__init__ +ida_typeinf.regobjvec_t +ida_typeinf.regobjvec_t.__getitem__ +ida_typeinf.regobjvec_t.__init__ +ida_typeinf.regobjvec_t.__len__ +ida_typeinf.regobjvec_t.__setitem__ +ida_typeinf.regobjvec_t.append +ida_typeinf.regobjvec_t.at +ida_typeinf.regobjvec_t.begin +ida_typeinf.regobjvec_t.capacity +ida_typeinf.regobjvec_t.clear +ida_typeinf.regobjvec_t.empty +ida_typeinf.regobjvec_t.end +ida_typeinf.regobjvec_t.erase +ida_typeinf.regobjvec_t.extend +ida_typeinf.regobjvec_t.extract +ida_typeinf.regobjvec_t.grow +ida_typeinf.regobjvec_t.inject +ida_typeinf.regobjvec_t.insert +ida_typeinf.regobjvec_t.pop_back +ida_typeinf.regobjvec_t.push_back +ida_typeinf.regobjvec_t.qclear +ida_typeinf.regobjvec_t.reserve +ida_typeinf.regobjvec_t.resize +ida_typeinf.regobjvec_t.size +ida_typeinf.regobjvec_t.swap +ida_typeinf.regobjvec_t.truncate +ida_typeinf.remove_abi_opts +ida_typeinf.remove_pointer +ida_typeinf.remove_tinfo_pointer +ida_typeinf.replace_ordinal_typerefs +ida_typeinf.resolve_typedef +ida_typeinf.rrel_t +ida_typeinf.rrel_t.__init__ +ida_typeinf.rrel_t.off +ida_typeinf.rrel_t.reg +ida_typeinf.save_tinfo +ida_typeinf.scattered_aloc_t +ida_typeinf.scattered_aloc_t.__init__ +ida_typeinf.score_tinfo +ida_typeinf.serialize_tinfo +ida_typeinf.set_abi_name +ida_typeinf.set_c_header_path +ida_typeinf.set_c_macros +ida_typeinf.set_compiler +ida_typeinf.set_compiler_id +ida_typeinf.set_compiler_string +ida_typeinf.set_numbered_type +ida_typeinf.set_tinfo_attr +ida_typeinf.set_tinfo_attrs +ida_typeinf.set_tinfo_property +ida_typeinf.set_tinfo_property4 +ida_typeinf.set_type_alias +ida_typeinf.set_type_choosable +ida_typeinf.set_vftable_ea +ida_typeinf.simd_info_t +ida_typeinf.simd_info_t.__init__ +ida_typeinf.simd_info_t.match_pattern +ida_typeinf.simd_info_t.memtype +ida_typeinf.simd_info_t.name +ida_typeinf.simd_info_t.size +ida_typeinf.simd_info_t.tif +ida_typeinf.stkarg_area_info_t +ida_typeinf.stkarg_area_info_t.__init__ +ida_typeinf.stkarg_area_info_t.linkage_area +ida_typeinf.stkarg_area_info_t.shadow_size +ida_typeinf.stkarg_area_info_t.stkarg_offset +ida_typeinf.store_til +ida_typeinf.stroff_as_size +ida_typeinf.switch_to_golang +ida_typeinf.text_sink_t +ida_typeinf.text_sink_t.__disown__ +ida_typeinf.text_sink_t.__init__ +ida_typeinf.text_sink_t._print +ida_typeinf.til_symbol_t +ida_typeinf.til_symbol_t.__init__ +ida_typeinf.til_symbol_t.name +ida_typeinf.til_symbol_t.til +ida_typeinf.til_t +ida_typeinf.til_t.__eq__ +ida_typeinf.til_t.__init__ +ida_typeinf.til_t.__ne__ +ida_typeinf.til_t.base +ida_typeinf.til_t.cc +ida_typeinf.til_t.desc +ida_typeinf.til_t.find_base +ida_typeinf.til_t.flags +ida_typeinf.til_t.get_named_type +ida_typeinf.til_t.get_numbered_type +ida_typeinf.til_t.get_type_names +ida_typeinf.til_t.import_type +ida_typeinf.til_t.is_dirty +ida_typeinf.til_t.name +ida_typeinf.til_t.named_types +ida_typeinf.til_t.nbases +ida_typeinf.til_t.nrefs +ida_typeinf.til_t.nstreams +ida_typeinf.til_t.numbered_types +ida_typeinf.til_t.set_dirty +ida_typeinf.til_t.streams +ida_typeinf.til_type_ref_t +ida_typeinf.til_type_ref_t.__init__ +ida_typeinf.til_type_ref_t.clear +ida_typeinf.til_type_ref_t.edm +ida_typeinf.til_type_ref_t.fa +ida_typeinf.til_type_ref_t.is_enum +ida_typeinf.til_type_ref_t.is_func +ida_typeinf.til_type_ref_t.is_struct +ida_typeinf.til_type_ref_t.is_typedef +ida_typeinf.til_type_ref_t.is_udt +ida_typeinf.til_type_ref_t.is_union +ida_typeinf.til_type_ref_t.on_member +ida_typeinf.til_type_ref_t.udm +ida_typeinf.tinfo_errstr +ida_typeinf.tinfo_t +ida_typeinf.tinfo_t.ENUMBM_AUTO +ida_typeinf.tinfo_t.ENUMBM_OFF +ida_typeinf.tinfo_t.ENUMBM_ON +ida_typeinf.tinfo_t.__eq__ +ida_typeinf.tinfo_t.__ge__ +ida_typeinf.tinfo_t.__gt__ +ida_typeinf.tinfo_t.__init__ +ida_typeinf.tinfo_t.__le__ +ida_typeinf.tinfo_t.__lt__ +ida_typeinf.tinfo_t.__ne__ +ida_typeinf.tinfo_t.__repr__ +ida_typeinf.tinfo_t.__str__ +ida_typeinf.tinfo_t._print +ida_typeinf.tinfo_t.add_edm +ida_typeinf.tinfo_t.add_funcarg +ida_typeinf.tinfo_t.add_udm +ida_typeinf.tinfo_t.append_covered +ida_typeinf.tinfo_t.calc_enum_mask +ida_typeinf.tinfo_t.calc_gaps +ida_typeinf.tinfo_t.calc_purged_bytes +ida_typeinf.tinfo_t.calc_score +ida_typeinf.tinfo_t.calc_udt_aligns +ida_typeinf.tinfo_t.change_sign +ida_typeinf.tinfo_t.clear +ida_typeinf.tinfo_t.clr_const +ida_typeinf.tinfo_t.clr_const_volatile +ida_typeinf.tinfo_t.clr_decl_const_volatile +ida_typeinf.tinfo_t.clr_volatile +ida_typeinf.tinfo_t.compare +ida_typeinf.tinfo_t.compare_with +ida_typeinf.tinfo_t.convert_array_to_ptr +ida_typeinf.tinfo_t.copy +ida_typeinf.tinfo_t.copy_type +ida_typeinf.tinfo_t.create_array +ida_typeinf.tinfo_t.create_bitfield +ida_typeinf.tinfo_t.create_enum +ida_typeinf.tinfo_t.create_forward_decl +ida_typeinf.tinfo_t.create_func +ida_typeinf.tinfo_t.create_ptr +ida_typeinf.tinfo_t.create_simple_type +ida_typeinf.tinfo_t.create_typedef +ida_typeinf.tinfo_t.create_udt +ida_typeinf.tinfo_t.del_attr +ida_typeinf.tinfo_t.del_attrs +ida_typeinf.tinfo_t.del_edm +ida_typeinf.tinfo_t.del_edm_by_value +ida_typeinf.tinfo_t.del_edms +ida_typeinf.tinfo_t.del_funcarg +ida_typeinf.tinfo_t.del_funcargs +ida_typeinf.tinfo_t.del_udm +ida_typeinf.tinfo_t.del_udms +ida_typeinf.tinfo_t.deserialize +ida_typeinf.tinfo_t.detach +ida_typeinf.tinfo_t.dstr +ida_typeinf.tinfo_t.edit_edm +ida_typeinf.tinfo_t.empty +ida_typeinf.tinfo_t.equals_to +ida_typeinf.tinfo_t.expand_udt +ida_typeinf.tinfo_t.find_edm +ida_typeinf.tinfo_t.find_udm +ida_typeinf.tinfo_t.force_tid +ida_typeinf.tinfo_t.get_alias_target +ida_typeinf.tinfo_t.get_alignment +ida_typeinf.tinfo_t.get_array_details +ida_typeinf.tinfo_t.get_array_element +ida_typeinf.tinfo_t.get_array_nelems +ida_typeinf.tinfo_t.get_attr +ida_typeinf.tinfo_t.get_attrs +ida_typeinf.tinfo_t.get_bit_buckets +ida_typeinf.tinfo_t.get_bitfield_details +ida_typeinf.tinfo_t.get_by_edm_name +ida_typeinf.tinfo_t.get_declalign +ida_typeinf.tinfo_t.get_decltype +ida_typeinf.tinfo_t.get_edm +ida_typeinf.tinfo_t.get_edm_by_tid +ida_typeinf.tinfo_t.get_edm_by_value +ida_typeinf.tinfo_t.get_edm_tid +ida_typeinf.tinfo_t.get_enum_base_type +ida_typeinf.tinfo_t.get_enum_details +ida_typeinf.tinfo_t.get_enum_nmembers +ida_typeinf.tinfo_t.get_enum_radix +ida_typeinf.tinfo_t.get_enum_repr +ida_typeinf.tinfo_t.get_enum_width +ida_typeinf.tinfo_t.get_final_element +ida_typeinf.tinfo_t.get_final_ordinal +ida_typeinf.tinfo_t.get_final_type_name +ida_typeinf.tinfo_t.get_forward_type +ida_typeinf.tinfo_t.get_frame_func +ida_typeinf.tinfo_t.get_func_details +ida_typeinf.tinfo_t.get_func_frame +ida_typeinf.tinfo_t.get_innermost_member_type +ida_typeinf.tinfo_t.get_innermost_udm +ida_typeinf.tinfo_t.get_methods +ida_typeinf.tinfo_t.get_modifiers +ida_typeinf.tinfo_t.get_named_type +ida_typeinf.tinfo_t.get_nargs +ida_typeinf.tinfo_t.get_next_type_name +ida_typeinf.tinfo_t.get_nice_type_name +ida_typeinf.tinfo_t.get_nth_arg +ida_typeinf.tinfo_t.get_numbered_type +ida_typeinf.tinfo_t.get_onemember_type +ida_typeinf.tinfo_t.get_ordinal +ida_typeinf.tinfo_t.get_pointed_object +ida_typeinf.tinfo_t.get_ptr_details +ida_typeinf.tinfo_t.get_ptrarr_object +ida_typeinf.tinfo_t.get_ptrarr_objsize +ida_typeinf.tinfo_t.get_realtype +ida_typeinf.tinfo_t.get_rettype +ida_typeinf.tinfo_t.get_sign +ida_typeinf.tinfo_t.get_size +ida_typeinf.tinfo_t.get_stkvar +ida_typeinf.tinfo_t.get_stock +ida_typeinf.tinfo_t.get_tid +ida_typeinf.tinfo_t.get_til +ida_typeinf.tinfo_t.get_type_by_tid +ida_typeinf.tinfo_t.get_type_cmt +ida_typeinf.tinfo_t.get_type_name +ida_typeinf.tinfo_t.get_type_rptcmt +ida_typeinf.tinfo_t.get_udm +ida_typeinf.tinfo_t.get_udm_by_offset +ida_typeinf.tinfo_t.get_udm_by_tid +ida_typeinf.tinfo_t.get_udm_tid +ida_typeinf.tinfo_t.get_udt_details +ida_typeinf.tinfo_t.get_udt_nmembers +ida_typeinf.tinfo_t.get_unpadded_size +ida_typeinf.tinfo_t.has_details +ida_typeinf.tinfo_t.has_union +ida_typeinf.tinfo_t.has_vftable +ida_typeinf.tinfo_t.is_aliased +ida_typeinf.tinfo_t.is_anonymous_udt +ida_typeinf.tinfo_t.is_arithmetic +ida_typeinf.tinfo_t.is_array +ida_typeinf.tinfo_t.is_bitfield +ida_typeinf.tinfo_t.is_bitmask_enum +ida_typeinf.tinfo_t.is_bool +ida_typeinf.tinfo_t.is_castable_to +ida_typeinf.tinfo_t.is_char +ida_typeinf.tinfo_t.is_complex +ida_typeinf.tinfo_t.is_const +ida_typeinf.tinfo_t.is_correct +ida_typeinf.tinfo_t.is_decl_array +ida_typeinf.tinfo_t.is_decl_bitfield +ida_typeinf.tinfo_t.is_decl_bool +ida_typeinf.tinfo_t.is_decl_char +ida_typeinf.tinfo_t.is_decl_complex +ida_typeinf.tinfo_t.is_decl_const +ida_typeinf.tinfo_t.is_decl_double +ida_typeinf.tinfo_t.is_decl_enum +ida_typeinf.tinfo_t.is_decl_float +ida_typeinf.tinfo_t.is_decl_floating +ida_typeinf.tinfo_t.is_decl_func +ida_typeinf.tinfo_t.is_decl_int +ida_typeinf.tinfo_t.is_decl_int128 +ida_typeinf.tinfo_t.is_decl_int16 +ida_typeinf.tinfo_t.is_decl_int32 +ida_typeinf.tinfo_t.is_decl_int64 +ida_typeinf.tinfo_t.is_decl_last +ida_typeinf.tinfo_t.is_decl_ldouble +ida_typeinf.tinfo_t.is_decl_paf +ida_typeinf.tinfo_t.is_decl_partial +ida_typeinf.tinfo_t.is_decl_ptr +ida_typeinf.tinfo_t.is_decl_struct +ida_typeinf.tinfo_t.is_decl_sue +ida_typeinf.tinfo_t.is_decl_tbyte +ida_typeinf.tinfo_t.is_decl_typedef +ida_typeinf.tinfo_t.is_decl_uchar +ida_typeinf.tinfo_t.is_decl_udt +ida_typeinf.tinfo_t.is_decl_uint +ida_typeinf.tinfo_t.is_decl_uint128 +ida_typeinf.tinfo_t.is_decl_uint16 +ida_typeinf.tinfo_t.is_decl_uint32 +ida_typeinf.tinfo_t.is_decl_uint64 +ida_typeinf.tinfo_t.is_decl_union +ida_typeinf.tinfo_t.is_decl_unknown +ida_typeinf.tinfo_t.is_decl_void +ida_typeinf.tinfo_t.is_decl_volatile +ida_typeinf.tinfo_t.is_double +ida_typeinf.tinfo_t.is_empty_enum +ida_typeinf.tinfo_t.is_empty_udt +ida_typeinf.tinfo_t.is_enum +ida_typeinf.tinfo_t.is_ext_arithmetic +ida_typeinf.tinfo_t.is_ext_integral +ida_typeinf.tinfo_t.is_fixed_struct +ida_typeinf.tinfo_t.is_float +ida_typeinf.tinfo_t.is_floating +ida_typeinf.tinfo_t.is_forward_decl +ida_typeinf.tinfo_t.is_forward_enum +ida_typeinf.tinfo_t.is_forward_struct +ida_typeinf.tinfo_t.is_forward_union +ida_typeinf.tinfo_t.is_frame +ida_typeinf.tinfo_t.is_from_subtil +ida_typeinf.tinfo_t.is_func +ida_typeinf.tinfo_t.is_funcptr +ida_typeinf.tinfo_t.is_high_func +ida_typeinf.tinfo_t.is_int +ida_typeinf.tinfo_t.is_int128 +ida_typeinf.tinfo_t.is_int16 +ida_typeinf.tinfo_t.is_int32 +ida_typeinf.tinfo_t.is_int64 +ida_typeinf.tinfo_t.is_integral +ida_typeinf.tinfo_t.is_ldouble +ida_typeinf.tinfo_t.is_manually_castable_to +ida_typeinf.tinfo_t.is_one_fpval +ida_typeinf.tinfo_t.is_paf +ida_typeinf.tinfo_t.is_partial +ida_typeinf.tinfo_t.is_ptr +ida_typeinf.tinfo_t.is_ptr_or_array +ida_typeinf.tinfo_t.is_punknown +ida_typeinf.tinfo_t.is_purging_cc +ida_typeinf.tinfo_t.is_pvoid +ida_typeinf.tinfo_t.is_scalar +ida_typeinf.tinfo_t.is_shifted_ptr +ida_typeinf.tinfo_t.is_signed +ida_typeinf.tinfo_t.is_small_udt +ida_typeinf.tinfo_t.is_sse_type +ida_typeinf.tinfo_t.is_struct +ida_typeinf.tinfo_t.is_sue +ida_typeinf.tinfo_t.is_tbyte +ida_typeinf.tinfo_t.is_typedef +ida_typeinf.tinfo_t.is_typeref +ida_typeinf.tinfo_t.is_uchar +ida_typeinf.tinfo_t.is_udm_by_til +ida_typeinf.tinfo_t.is_udt +ida_typeinf.tinfo_t.is_uint +ida_typeinf.tinfo_t.is_uint128 +ida_typeinf.tinfo_t.is_uint16 +ida_typeinf.tinfo_t.is_uint32 +ida_typeinf.tinfo_t.is_uint64 +ida_typeinf.tinfo_t.is_union +ida_typeinf.tinfo_t.is_unknown +ida_typeinf.tinfo_t.is_unsigned +ida_typeinf.tinfo_t.is_user_cc +ida_typeinf.tinfo_t.is_vararg_cc +ida_typeinf.tinfo_t.is_varmember +ida_typeinf.tinfo_t.is_varstruct +ida_typeinf.tinfo_t.is_vftable +ida_typeinf.tinfo_t.is_void +ida_typeinf.tinfo_t.is_volatile +ida_typeinf.tinfo_t.is_well_defined +ida_typeinf.tinfo_t.iter_enum +ida_typeinf.tinfo_t.iter_func +ida_typeinf.tinfo_t.iter_struct +ida_typeinf.tinfo_t.iter_udt +ida_typeinf.tinfo_t.iter_union +ida_typeinf.tinfo_t.parse +ida_typeinf.tinfo_t.present +ida_typeinf.tinfo_t.read_bitfield_value +ida_typeinf.tinfo_t.remove_ptr_or_array +ida_typeinf.tinfo_t.rename_edm +ida_typeinf.tinfo_t.rename_funcarg +ida_typeinf.tinfo_t.rename_type +ida_typeinf.tinfo_t.rename_udm +ida_typeinf.tinfo_t.requires_qualifier +ida_typeinf.tinfo_t.save_type +ida_typeinf.tinfo_t.serialize +ida_typeinf.tinfo_t.set_attr +ida_typeinf.tinfo_t.set_attrs +ida_typeinf.tinfo_t.set_const +ida_typeinf.tinfo_t.set_declalign +ida_typeinf.tinfo_t.set_edm_cmt +ida_typeinf.tinfo_t.set_enum_is_bitmask +ida_typeinf.tinfo_t.set_enum_radix +ida_typeinf.tinfo_t.set_enum_repr +ida_typeinf.tinfo_t.set_enum_sign +ida_typeinf.tinfo_t.set_enum_width +ida_typeinf.tinfo_t.set_fixed_struct +ida_typeinf.tinfo_t.set_func_cc +ida_typeinf.tinfo_t.set_func_retloc +ida_typeinf.tinfo_t.set_func_rettype +ida_typeinf.tinfo_t.set_funcarg_loc +ida_typeinf.tinfo_t.set_funcarg_type +ida_typeinf.tinfo_t.set_methods +ida_typeinf.tinfo_t.set_modifiers +ida_typeinf.tinfo_t.set_named_type +ida_typeinf.tinfo_t.set_numbered_type +ida_typeinf.tinfo_t.set_struct_size +ida_typeinf.tinfo_t.set_symbol_type +ida_typeinf.tinfo_t.set_type_alias +ida_typeinf.tinfo_t.set_type_alignment +ida_typeinf.tinfo_t.set_type_cmt +ida_typeinf.tinfo_t.set_udm_by_til +ida_typeinf.tinfo_t.set_udm_cmt +ida_typeinf.tinfo_t.set_udm_repr +ida_typeinf.tinfo_t.set_udm_type +ida_typeinf.tinfo_t.set_udt_alignment +ida_typeinf.tinfo_t.set_udt_pack +ida_typeinf.tinfo_t.set_volatile +ida_typeinf.tinfo_t.swap +ida_typeinf.tinfo_t.write_bitfield_value +ida_typeinf.tinfo_visitor_t +ida_typeinf.tinfo_visitor_t.__disown__ +ida_typeinf.tinfo_visitor_t.__init__ +ida_typeinf.tinfo_visitor_t.apply_to +ida_typeinf.tinfo_visitor_t.prune_now +ida_typeinf.tinfo_visitor_t.state +ida_typeinf.tinfo_visitor_t.visit_type +ida_typeinf.type_attr_t +ida_typeinf.type_attr_t.__ge__ +ida_typeinf.type_attr_t.__init__ +ida_typeinf.type_attr_t.__lt__ +ida_typeinf.type_attr_t.key +ida_typeinf.type_attr_t.value +ida_typeinf.type_attrs_t +ida_typeinf.type_attrs_t.__getitem__ +ida_typeinf.type_attrs_t.__init__ +ida_typeinf.type_attrs_t.__len__ +ida_typeinf.type_attrs_t.__setitem__ +ida_typeinf.type_attrs_t.append +ida_typeinf.type_attrs_t.at +ida_typeinf.type_attrs_t.begin +ida_typeinf.type_attrs_t.capacity +ida_typeinf.type_attrs_t.clear +ida_typeinf.type_attrs_t.empty +ida_typeinf.type_attrs_t.end +ida_typeinf.type_attrs_t.erase +ida_typeinf.type_attrs_t.extend +ida_typeinf.type_attrs_t.extract +ida_typeinf.type_attrs_t.grow +ida_typeinf.type_attrs_t.inject +ida_typeinf.type_attrs_t.insert +ida_typeinf.type_attrs_t.pop_back +ida_typeinf.type_attrs_t.push_back +ida_typeinf.type_attrs_t.qclear +ida_typeinf.type_attrs_t.reserve +ida_typeinf.type_attrs_t.resize +ida_typeinf.type_attrs_t.size +ida_typeinf.type_attrs_t.swap +ida_typeinf.type_attrs_t.truncate +ida_typeinf.type_mods_t +ida_typeinf.type_mods_t.__init__ +ida_typeinf.type_mods_t.clear +ida_typeinf.type_mods_t.cmt +ida_typeinf.type_mods_t.flags +ida_typeinf.type_mods_t.has_cmt +ida_typeinf.type_mods_t.has_info +ida_typeinf.type_mods_t.has_name +ida_typeinf.type_mods_t.has_type +ida_typeinf.type_mods_t.is_rptcmt +ida_typeinf.type_mods_t.name +ida_typeinf.type_mods_t.set_new_cmt +ida_typeinf.type_mods_t.set_new_name +ida_typeinf.type_mods_t.set_new_type +ida_typeinf.type_mods_t.type +ida_typeinf.type_signed +ida_typeinf.type_unsigned +ida_typeinf.typedef_type_data_t +ida_typeinf.typedef_type_data_t.__init__ +ida_typeinf.typedef_type_data_t.is_ordref +ida_typeinf.typedef_type_data_t.name +ida_typeinf.typedef_type_data_t.ordinal +ida_typeinf.typedef_type_data_t.resolve +ida_typeinf.typedef_type_data_t.swap +ida_typeinf.typedef_type_data_t.til +ida_typeinf.udm_t +ida_typeinf.udm_t.__eq__ +ida_typeinf.udm_t.__init__ +ida_typeinf.udm_t.__lt__ +ida_typeinf.udm_t.__ne__ +ida_typeinf.udm_t.begin +ida_typeinf.udm_t.can_be_dtor +ida_typeinf.udm_t.can_rename +ida_typeinf.udm_t.clr_baseclass +ida_typeinf.udm_t.clr_method +ida_typeinf.udm_t.clr_unaligned +ida_typeinf.udm_t.clr_vftable +ida_typeinf.udm_t.clr_virtbase +ida_typeinf.udm_t.cmt +ida_typeinf.udm_t.effalign +ida_typeinf.udm_t.empty +ida_typeinf.udm_t.end +ida_typeinf.udm_t.fda +ida_typeinf.udm_t.is_anonymous_udm +ida_typeinf.udm_t.is_baseclass +ida_typeinf.udm_t.is_bitfield +ida_typeinf.udm_t.is_by_til +ida_typeinf.udm_t.is_gap +ida_typeinf.udm_t.is_method +ida_typeinf.udm_t.is_regcmt +ida_typeinf.udm_t.is_retaddr +ida_typeinf.udm_t.is_savregs +ida_typeinf.udm_t.is_special_member +ida_typeinf.udm_t.is_unaligned +ida_typeinf.udm_t.is_vftable +ida_typeinf.udm_t.is_virtbase +ida_typeinf.udm_t.is_zero_bitfield +ida_typeinf.udm_t.name +ida_typeinf.udm_t.offset +ida_typeinf.udm_t.repr +ida_typeinf.udm_t.set_baseclass +ida_typeinf.udm_t.set_by_til +ida_typeinf.udm_t.set_method +ida_typeinf.udm_t.set_regcmt +ida_typeinf.udm_t.set_retaddr +ida_typeinf.udm_t.set_savregs +ida_typeinf.udm_t.set_unaligned +ida_typeinf.udm_t.set_value_repr +ida_typeinf.udm_t.set_vftable +ida_typeinf.udm_t.set_virtbase +ida_typeinf.udm_t.size +ida_typeinf.udm_t.swap +ida_typeinf.udm_t.tafld_bits +ida_typeinf.udm_t.type +ida_typeinf.udm_visitor_t +ida_typeinf.udm_visitor_t.__disown__ +ida_typeinf.udm_visitor_t.__init__ +ida_typeinf.udm_visitor_t.visit_udm +ida_typeinf.udt_type_data_t +ida_typeinf.udt_type_data_t.__init__ +ida_typeinf.udt_type_data_t.add_member +ida_typeinf.udt_type_data_t.effalign +ida_typeinf.udt_type_data_t.find_member +ida_typeinf.udt_type_data_t.get_best_fit_member +ida_typeinf.udt_type_data_t.is_cppobj +ida_typeinf.udt_type_data_t.is_fixed +ida_typeinf.udt_type_data_t.is_last_baseclass +ida_typeinf.udt_type_data_t.is_msstruct +ida_typeinf.udt_type_data_t.is_unaligned +ida_typeinf.udt_type_data_t.is_union +ida_typeinf.udt_type_data_t.is_vftable +ida_typeinf.udt_type_data_t.pack +ida_typeinf.udt_type_data_t.sda +ida_typeinf.udt_type_data_t.set_fixed +ida_typeinf.udt_type_data_t.set_vftable +ida_typeinf.udt_type_data_t.swap +ida_typeinf.udt_type_data_t.taudt_bits +ida_typeinf.udt_type_data_t.total_size +ida_typeinf.udt_type_data_t.unpadded_size +ida_typeinf.udt_type_data_t.version +ida_typeinf.udt_type_data_t__find_member +ida_typeinf.udt_type_data_t__get_best_fit_member +ida_typeinf.udtmembervec_t +ida_typeinf.udtmembervec_t.__init__ +ida_typeinf.udtmembervec_template_t +ida_typeinf.udtmembervec_template_t.__eq__ +ida_typeinf.udtmembervec_template_t.__getitem__ +ida_typeinf.udtmembervec_template_t.__init__ +ida_typeinf.udtmembervec_template_t.__len__ +ida_typeinf.udtmembervec_template_t.__ne__ +ida_typeinf.udtmembervec_template_t.__setitem__ +ida_typeinf.udtmembervec_template_t._del +ida_typeinf.udtmembervec_template_t.add_unique +ida_typeinf.udtmembervec_template_t.append +ida_typeinf.udtmembervec_template_t.at +ida_typeinf.udtmembervec_template_t.begin +ida_typeinf.udtmembervec_template_t.capacity +ida_typeinf.udtmembervec_template_t.clear +ida_typeinf.udtmembervec_template_t.empty +ida_typeinf.udtmembervec_template_t.end +ida_typeinf.udtmembervec_template_t.erase +ida_typeinf.udtmembervec_template_t.extend +ida_typeinf.udtmembervec_template_t.extract +ida_typeinf.udtmembervec_template_t.find +ida_typeinf.udtmembervec_template_t.grow +ida_typeinf.udtmembervec_template_t.has +ida_typeinf.udtmembervec_template_t.inject +ida_typeinf.udtmembervec_template_t.insert +ida_typeinf.udtmembervec_template_t.pop_back +ida_typeinf.udtmembervec_template_t.push_back +ida_typeinf.udtmembervec_template_t.qclear +ida_typeinf.udtmembervec_template_t.reserve +ida_typeinf.udtmembervec_template_t.resize +ida_typeinf.udtmembervec_template_t.size +ida_typeinf.udtmembervec_template_t.swap +ida_typeinf.udtmembervec_template_t.truncate +ida_typeinf.unpack_idcobj_from_bv +ida_typeinf.unpack_idcobj_from_idb +ida_typeinf.unpack_object_from_bv +ida_typeinf.unpack_object_from_idb +ida_typeinf.use_golang_cc +ida_typeinf.valstr_t +ida_typeinf.valstr_t.__init__ +ida_typeinf.valstr_t.info +ida_typeinf.valstr_t.length +ida_typeinf.valstr_t.members +ida_typeinf.valstr_t.oneline +ida_typeinf.valstr_t.props +ida_typeinf.valstrs_t +ida_typeinf.valstrs_t.__init__ +ida_typeinf.valstrvec_t +ida_typeinf.valstrvec_t.__getitem__ +ida_typeinf.valstrvec_t.__init__ +ida_typeinf.valstrvec_t.__len__ +ida_typeinf.valstrvec_t.__setitem__ +ida_typeinf.valstrvec_t.append +ida_typeinf.valstrvec_t.at +ida_typeinf.valstrvec_t.begin +ida_typeinf.valstrvec_t.capacity +ida_typeinf.valstrvec_t.clear +ida_typeinf.valstrvec_t.empty +ida_typeinf.valstrvec_t.end +ida_typeinf.valstrvec_t.erase +ida_typeinf.valstrvec_t.extend +ida_typeinf.valstrvec_t.extract +ida_typeinf.valstrvec_t.grow +ida_typeinf.valstrvec_t.inject +ida_typeinf.valstrvec_t.insert +ida_typeinf.valstrvec_t.pop_back +ida_typeinf.valstrvec_t.push_back +ida_typeinf.valstrvec_t.qclear +ida_typeinf.valstrvec_t.reserve +ida_typeinf.valstrvec_t.resize +ida_typeinf.valstrvec_t.size +ida_typeinf.valstrvec_t.swap +ida_typeinf.valstrvec_t.truncate +ida_typeinf.value_repr_t +ida_typeinf.value_repr_t.__init__ +ida_typeinf.value_repr_t.__str__ +ida_typeinf.value_repr_t._print +ida_typeinf.value_repr_t.ap +ida_typeinf.value_repr_t.cd +ida_typeinf.value_repr_t.clear +ida_typeinf.value_repr_t.delta +ida_typeinf.value_repr_t.empty +ida_typeinf.value_repr_t.from_opinfo +ida_typeinf.value_repr_t.get_vtype +ida_typeinf.value_repr_t.has_lzeroes +ida_typeinf.value_repr_t.has_tabform +ida_typeinf.value_repr_t.init_ap +ida_typeinf.value_repr_t.is_custom +ida_typeinf.value_repr_t.is_enum +ida_typeinf.value_repr_t.is_offset +ida_typeinf.value_repr_t.is_signed +ida_typeinf.value_repr_t.is_strlit +ida_typeinf.value_repr_t.is_stroff +ida_typeinf.value_repr_t.is_typref +ida_typeinf.value_repr_t.parse_value_repr +ida_typeinf.value_repr_t.ri +ida_typeinf.value_repr_t.set_ap +ida_typeinf.value_repr_t.set_lzeroes +ida_typeinf.value_repr_t.set_signed +ida_typeinf.value_repr_t.set_tabform +ida_typeinf.value_repr_t.set_vtype +ida_typeinf.value_repr_t.strtype +ida_typeinf.value_repr_t.swap +ida_typeinf.value_repr_t.type_ordinal +ida_typeinf.value_repr_t__from_opinfo +ida_typeinf.value_repr_t__print_ +ida_typeinf.verify_argloc +ida_typeinf.verify_tinfo +ida_typeinf.visit_stroff_udms +ida_typeinf.visit_subtypes +ida_typeinf.write_tinfo_bitfield_value +ida_ua +ida_ua.BINOPSTATE_DONE +ida_ua.BINOPSTATE_GO +ida_ua.BINOPSTATE_NONE +ida_ua.COMMSTATE_DONE +ida_ua.COMMSTATE_GO +ida_ua.COMMSTATE_NONE +ida_ua.CTXF_BINOP_STATE +ida_ua.CTXF_BIT_PREFIX +ida_ua.CTXF_CMT_STATE +ida_ua.CTXF_CODE +ida_ua.CTXF_DBLIND_OPND +ida_ua.CTXF_DEMANGLED_LABEL +ida_ua.CTXF_DEMANGLED_OK +ida_ua.CTXF_GEN_CMT +ida_ua.CTXF_GEN_XREFS +ida_ua.CTXF_HIDDEN_ADDR +ida_ua.CTXF_LABEL_OK +ida_ua.CTXF_MAIN +ida_ua.CTXF_MULTI +ida_ua.CTXF_NORMAL_LABEL +ida_ua.CTXF_OUTCTX_T +ida_ua.CTXF_OVSTORE_PRNT +ida_ua.CTXF_STACK +ida_ua.CTXF_VOIDS +ida_ua.CTXF_XREF_STATE +ida_ua.FCBF_CONT +ida_ua.FCBF_DELIM +ida_ua.FCBF_ERR_REPL +ida_ua.FCBF_FF_LIT +ida_ua.GH_BYTESEX_HAS_HIGHBYTE +ida_ua.GH_PRINT_ASM +ida_ua.GH_PRINT_BYTESEX +ida_ua.GH_PRINT_HEADER +ida_ua.GH_PRINT_PROC +ida_ua.INSN_64BIT +ida_ua.INSN_MACRO +ida_ua.INSN_MODMAC +ida_ua.MAKELINE_BINPREF +ida_ua.MAKELINE_STACK +ida_ua.MAKELINE_VOID +ida_ua.OF_NO_BASE_DISP +ida_ua.OF_NUMBER +ida_ua.OF_OUTER_DISP +ida_ua.OF_SHOW +ida_ua.OOFS_IFSIGN +ida_ua.OOFS_NEEDSIGN +ida_ua.OOFS_NOSIGN +ida_ua.OOFW_16 +ida_ua.OOFW_24 +ida_ua.OOFW_32 +ida_ua.OOFW_64 +ida_ua.OOFW_8 +ida_ua.OOFW_IMM +ida_ua.OOF_ADDR +ida_ua.OOF_ANYSERIAL +ida_ua.OOF_LZEROES +ida_ua.OOF_NOBNOT +ida_ua.OOF_NO_LZEROES +ida_ua.OOF_NUMBER +ida_ua.OOF_OUTER +ida_ua.OOF_SIGNED +ida_ua.OOF_SIGNMASK +ida_ua.OOF_SPACES +ida_ua.OOF_WIDTHMASK +ida_ua.OOF_ZSTROFF +ida_ua.PACK_FORM_DEF +ida_ua.STKVAR_VALID_SIZE +ida_ua.XREFSTATE_DONE +ida_ua.XREFSTATE_GO +ida_ua.XREFSTATE_NONE +ida_ua.calc_dataseg +ida_ua.can_decode +ida_ua.construct_macro +ida_ua.create_insn +ida_ua.create_outctx +ida_ua.decode_insn +ida_ua.decode_preceding_insn +ida_ua.decode_prev_insn +ida_ua.dt_bitfild +ida_ua.dt_byte +ida_ua.dt_byte16 +ida_ua.dt_byte32 +ida_ua.dt_byte64 +ida_ua.dt_code +ida_ua.dt_double +ida_ua.dt_dword +ida_ua.dt_float +ida_ua.dt_fword +ida_ua.dt_half +ida_ua.dt_ldbl +ida_ua.dt_packreal +ida_ua.dt_qword +ida_ua.dt_string +ida_ua.dt_tbyte +ida_ua.dt_unicode +ida_ua.dt_void +ida_ua.dt_word +ida_ua.get_dtype_by_size +ida_ua.get_dtype_flag +ida_ua.get_dtype_size +ida_ua.get_immvals +ida_ua.get_lookback +ida_ua.get_printable_immvals +ida_ua.insn_add_cref +ida_ua.insn_add_dref +ida_ua.insn_add_off_drefs +ida_ua.insn_create_stkvar +ida_ua.insn_t +ida_ua.insn_t.__get_auxpref__ +ida_ua.insn_t.__get_operand__ +ida_ua.insn_t.__get_ops__ +ida_ua.insn_t.__getitem__ +ida_ua.insn_t.__init__ +ida_ua.insn_t.__iter__ +ida_ua.insn_t.__set_auxpref__ +ida_ua.insn_t.add_cref +ida_ua.insn_t.add_dref +ida_ua.insn_t.add_off_drefs +ida_ua.insn_t.assign +ida_ua.insn_t.auxpref +ida_ua.insn_t.auxpref +ida_ua.insn_t.create_op_data +ida_ua.insn_t.create_stkvar +ida_ua.insn_t.cs +ida_ua.insn_t.ea +ida_ua.insn_t.flags +ida_ua.insn_t.get_canon_feature +ida_ua.insn_t.get_canon_mnem +ida_ua.insn_t.get_next_byte +ida_ua.insn_t.get_next_dword +ida_ua.insn_t.get_next_qword +ida_ua.insn_t.get_next_word +ida_ua.insn_t.insnpref +ida_ua.insn_t.ip +ida_ua.insn_t.is_64bit +ida_ua.insn_t.is_canon_insn +ida_ua.insn_t.is_macro +ida_ua.insn_t.itype +ida_ua.insn_t.ops +ida_ua.insn_t.ops +ida_ua.insn_t.segpref +ida_ua.insn_t.size +ida_ua.insn_t__from_ptrval__ +ida_ua.is_floating_dtype +ida_ua.macro_constructor_t +ida_ua.macro_constructor_t.__disown__ +ida_ua.macro_constructor_t.__init__ +ida_ua.macro_constructor_t.build_macro +ida_ua.macro_constructor_t.construct_macro +ida_ua.map_code_ea +ida_ua.map_data_ea +ida_ua.map_ea +ida_ua.o_displ +ida_ua.o_far +ida_ua.o_idpspec0 +ida_ua.o_idpspec1 +ida_ua.o_idpspec2 +ida_ua.o_idpspec3 +ida_ua.o_idpspec4 +ida_ua.o_idpspec5 +ida_ua.o_imm +ida_ua.o_mem +ida_ua.o_near +ida_ua.o_phrase +ida_ua.o_reg +ida_ua.o_void +ida_ua.op_t +ida_ua.op_t.__get_addr__ +ida_ua.op_t.__get_reg_phrase__ +ida_ua.op_t.__get_specval__ +ida_ua.op_t.__get_value64__ +ida_ua.op_t.__get_value__ +ida_ua.op_t.__init__ +ida_ua.op_t.__set_addr__ +ida_ua.op_t.__set_reg_phrase__ +ida_ua.op_t.__set_specval__ +ida_ua.op_t.__set_value64__ +ida_ua.op_t.__set_value__ +ida_ua.op_t.addr +ida_ua.op_t.addr +ida_ua.op_t.assign +ida_ua.op_t.clr_shown +ida_ua.op_t.dtype +ida_ua.op_t.flags +ida_ua.op_t.has_reg +ida_ua.op_t.is_imm +ida_ua.op_t.is_reg +ida_ua.op_t.n +ida_ua.op_t.offb +ida_ua.op_t.offo +ida_ua.op_t.phrase +ida_ua.op_t.phrase +ida_ua.op_t.reg +ida_ua.op_t.reg +ida_ua.op_t.set_shown +ida_ua.op_t.shown +ida_ua.op_t.specval +ida_ua.op_t.specval +ida_ua.op_t.type +ida_ua.op_t.value +ida_ua.op_t.value +ida_ua.op_t__from_ptrval__ +ida_ua.operands_array +ida_ua.operands_array.__getitem__ +ida_ua.operands_array.__init__ +ida_ua.operands_array.__len__ +ida_ua.operands_array.__setitem__ +ida_ua.operands_array._get_bytes +ida_ua.operands_array._set_bytes +ida_ua.outctx_base_t +ida_ua.outctx_base_t.F32 +ida_ua.outctx_base_t.__init__ +ida_ua.outctx_base_t.close_comment +ida_ua.outctx_base_t.clr_gen_label +ida_ua.outctx_base_t.default_lnnum +ida_ua.outctx_base_t.display_voids +ida_ua.outctx_base_t.flush_buf +ida_ua.outctx_base_t.flush_outbuf +ida_ua.outctx_base_t.forbid_annotations +ida_ua.outctx_base_t.force_code +ida_ua.outctx_base_t.gen_block_cmt +ida_ua.outctx_base_t.gen_border_line +ida_ua.outctx_base_t.gen_cmt_line +ida_ua.outctx_base_t.gen_collapsed_line +ida_ua.outctx_base_t.gen_empty_line +ida_ua.outctx_base_t.gen_empty_line_without_annotations +ida_ua.outctx_base_t.gen_printf +ida_ua.outctx_base_t.gen_xref_lines +ida_ua.outctx_base_t.getF +ida_ua.outctx_base_t.get_stkvar +ida_ua.outctx_base_t.init_lines_array +ida_ua.outctx_base_t.multiline +ida_ua.outctx_base_t.only_main_line +ida_ua.outctx_base_t.out_addr_tag +ida_ua.outctx_base_t.out_btoa +ida_ua.outctx_base_t.out_char +ida_ua.outctx_base_t.out_chars +ida_ua.outctx_base_t.out_colored_register_line +ida_ua.outctx_base_t.out_keyword +ida_ua.outctx_base_t.out_line +ida_ua.outctx_base_t.out_long +ida_ua.outctx_base_t.out_lvar +ida_ua.outctx_base_t.out_name_expr +ida_ua.outctx_base_t.out_printf +ida_ua.outctx_base_t.out_register +ida_ua.outctx_base_t.out_spaces +ida_ua.outctx_base_t.out_symbol +ida_ua.outctx_base_t.out_tagoff +ida_ua.outctx_base_t.out_tagon +ida_ua.outctx_base_t.out_value +ida_ua.outctx_base_t.outbuf +ida_ua.outctx_base_t.print_label_now +ida_ua.outctx_base_t.restore_ctxflags +ida_ua.outctx_base_t.retrieve_cmt +ida_ua.outctx_base_t.retrieve_name +ida_ua.outctx_base_t.set_comment_addr +ida_ua.outctx_base_t.set_dlbind_opnd +ida_ua.outctx_base_t.set_gen_cmt +ida_ua.outctx_base_t.set_gen_demangled_label +ida_ua.outctx_base_t.set_gen_label +ida_ua.outctx_base_t.set_gen_xrefs +ida_ua.outctx_base_t.setup_outctx +ida_ua.outctx_base_t.stack_view +ida_ua.outctx_base_t.term_outctx +ida_ua.outctx_base_t__from_ptrval__ +ida_ua.outctx_t +ida_ua.outctx_t.__init__ +ida_ua.outctx_t.gen_func_footer +ida_ua.outctx_t.gen_func_header +ida_ua.outctx_t.gen_header +ida_ua.outctx_t.gen_header_extra +ida_ua.outctx_t.gen_xref_lines +ida_ua.outctx_t.out_btoa +ida_ua.outctx_t.out_custom_mnem +ida_ua.outctx_t.out_data +ida_ua.outctx_t.out_fcref_names +ida_ua.outctx_t.out_immchar_cmts +ida_ua.outctx_t.out_mnem +ida_ua.outctx_t.out_mnemonic +ida_ua.outctx_t.out_one_operand +ida_ua.outctx_t.out_specea +ida_ua.outctx_t.retrieve_cmt +ida_ua.outctx_t.retrieve_name +ida_ua.outctx_t.set_bin_state +ida_ua.outctx_t.setup_outctx +ida_ua.outctx_t.term_outctx +ida_ua.outctx_t__from_ptrval__ +ida_ua.print_insn_mnem +ida_ua.print_operand +ida_xref +ida_xref.XREF_BASE +ida_xref.XREF_CODE +ida_xref.XREF_DATA +ida_xref.XREF_EA +ida_xref.XREF_FLOW +ida_xref.XREF_MASK +ida_xref.XREF_NOFLOW +ida_xref.XREF_PASTEND +ida_xref.XREF_TAIL +ida_xref.XREF_TID +ida_xref.XREF_USER +ida_xref.add_cref +ida_xref.add_dref +ida_xref.calc_switch_cases +ida_xref.cases_and_targets_t +ida_xref.cases_and_targets_t.__init__ +ida_xref.casevec_t +ida_xref.casevec_t.__eq__ +ida_xref.casevec_t.__getitem__ +ida_xref.casevec_t.__init__ +ida_xref.casevec_t.__len__ +ida_xref.casevec_t.__ne__ +ida_xref.casevec_t.__setitem__ +ida_xref.casevec_t._del +ida_xref.casevec_t.add_unique +ida_xref.casevec_t.append +ida_xref.casevec_t.at +ida_xref.casevec_t.begin +ida_xref.casevec_t.capacity +ida_xref.casevec_t.clear +ida_xref.casevec_t.empty +ida_xref.casevec_t.end +ida_xref.casevec_t.erase +ida_xref.casevec_t.extend +ida_xref.casevec_t.extract +ida_xref.casevec_t.find +ida_xref.casevec_t.grow +ida_xref.casevec_t.has +ida_xref.casevec_t.inject +ida_xref.casevec_t.insert +ida_xref.casevec_t.pop_back +ida_xref.casevec_t.push_back +ida_xref.casevec_t.qclear +ida_xref.casevec_t.reserve +ida_xref.casevec_t.resize +ida_xref.casevec_t.size +ida_xref.casevec_t.swap +ida_xref.casevec_t.truncate +ida_xref.create_switch_table +ida_xref.create_switch_xrefs +ida_xref.del_cref +ida_xref.del_dref +ida_xref.delete_switch_table +ida_xref.dr_I +ida_xref.dr_O +ida_xref.dr_R +ida_xref.dr_S +ida_xref.dr_T +ida_xref.dr_U +ida_xref.dr_W +ida_xref.fl_CF +ida_xref.fl_CN +ida_xref.fl_F +ida_xref.fl_JF +ida_xref.fl_JN +ida_xref.fl_U +ida_xref.fl_USobsolete +ida_xref.get_first_cref_from +ida_xref.get_first_cref_to +ida_xref.get_first_dref_from +ida_xref.get_first_dref_to +ida_xref.get_first_fcref_from +ida_xref.get_first_fcref_to +ida_xref.get_next_cref_from +ida_xref.get_next_cref_to +ida_xref.get_next_dref_from +ida_xref.get_next_dref_to +ida_xref.get_next_fcref_from +ida_xref.get_next_fcref_to +ida_xref.has_external_refs +ida_xref.has_jump_or_flow_xref +ida_xref.xrefblk_t +ida_xref.xrefblk_t.__init__ +ida_xref.xrefblk_t.crefs_from +ida_xref.xrefblk_t.crefs_to +ida_xref.xrefblk_t.drefs_from +ida_xref.xrefblk_t.drefs_to +ida_xref.xrefblk_t.fcrefs_from +ida_xref.xrefblk_t.fcrefs_to +ida_xref.xrefblk_t.first_from +ida_xref.xrefblk_t.first_to +ida_xref.xrefblk_t.iscode +ida_xref.xrefblk_t.next_from +ida_xref.xrefblk_t.next_to +ida_xref.xrefblk_t.refs_from +ida_xref.xrefblk_t.refs_from._copy_xref +ida_xref.xrefblk_t.refs_to +ida_xref.xrefblk_t.refs_to._copy_xref +ida_xref.xrefblk_t.to +ida_xref.xrefblk_t.type +ida_xref.xrefblk_t.user +ida_xref.xrefchar +ida_mergemod +ida_mergemod.create_std_modmerge_handlers +ida_merge +ida_merge.MERGE_KIND_AFLAGS_EA +ida_merge.MERGE_KIND_AUTOQ +ida_merge.MERGE_KIND_BOOKMARKS +ida_merge.MERGE_KIND_BPTS +ida_merge.MERGE_KIND_BYTEVAL +ida_merge.MERGE_KIND_CREFS +ida_merge.MERGE_KIND_CUSTDATA +ida_merge.MERGE_KIND_DBG_MEMREGS +ida_merge.MERGE_KIND_DEBUGGER +ida_merge.MERGE_KIND_DEKSTOPS +ida_merge.MERGE_KIND_DIRTREE +ida_merge.MERGE_KIND_DREFS +ida_merge.MERGE_KIND_ENCODINGS +ida_merge.MERGE_KIND_ENCODINGS2 +ida_merge.MERGE_KIND_END +ida_merge.MERGE_KIND_ENUMS +ida_merge.MERGE_KIND_EXPORTS +ida_merge.MERGE_KIND_EXTRACMT +ida_merge.MERGE_KIND_FILEREGIONS +ida_merge.MERGE_KIND_FIXUPS +ida_merge.MERGE_KIND_FLAGS +ida_merge.MERGE_KIND_FLOWS +ida_merge.MERGE_KIND_FRAME +ida_merge.MERGE_KIND_FRAMEMGR +ida_merge.MERGE_KIND_FUNC +ida_merge.MERGE_KIND_GHSTRCMT +ida_merge.MERGE_KIND_HIDDENRANGES +ida_merge.MERGE_KIND_IGNOREMICRO +ida_merge.MERGE_KIND_IMPORTS +ida_merge.MERGE_KIND_INF +ida_merge.MERGE_KIND_LAST +ida_merge.MERGE_KIND_LOADER +ida_merge.MERGE_KIND_LUMINA +ida_merge.MERGE_KIND_MAPPING +ida_merge.MERGE_KIND_NETNODE +ida_merge.MERGE_KIND_NOTEPAD +ida_merge.MERGE_KIND_ORPHANS +ida_merge.MERGE_KIND_PATCHES +ida_merge.MERGE_KIND_PROBLEMS +ida_merge.MERGE_KIND_SCRIPTS +ida_merge.MERGE_KIND_SCRIPTS2 +ida_merge.MERGE_KIND_SEGGRPS +ida_merge.MERGE_KIND_SEGMENTS +ida_merge.MERGE_KIND_SEGREGS +ida_merge.MERGE_KIND_SELECTORS +ida_merge.MERGE_KIND_SIGNATURES +ida_merge.MERGE_KIND_SOURCEFILES +ida_merge.MERGE_KIND_STKPNTS +ida_merge.MERGE_KIND_STRMEM +ida_merge.MERGE_KIND_STRMEMCMT +ida_merge.MERGE_KIND_STRUCTS +ida_merge.MERGE_KIND_STT +ida_merge.MERGE_KIND_TILS +ida_merge.MERGE_KIND_TINFO +ida_merge.MERGE_KIND_TRYBLKS +ida_merge.MERGE_KIND_UDTMEM +ida_merge.MERGE_KIND_UI +ida_merge.MERGE_KIND_VFTABLES +ida_merge.MERGE_KIND_WATCHPOINTS +ida_merge.MH_LISTEN +ida_merge.MH_TERSE +ida_merge.MH_UI_CHAR_MASK +ida_merge.MH_UI_COLONNAME +ida_merge.MH_UI_COMMANAME +ida_merge.MH_UI_COMPLEX +ida_merge.MH_UI_DP_NOLINEDIFF +ida_merge.MH_UI_DP_SHORTNAME +ida_merge.MH_UI_INDENT +ida_merge.MH_UI_NODETAILS +ida_merge.MH_UI_SPLITNAME +ida_merge.NDS_BLOB +ida_merge.NDS_EV_FUNC +ida_merge.NDS_EV_RANGE +ida_merge.NDS_INC +ida_merge.NDS_IS_BOOL +ida_merge.NDS_IS_EA +ida_merge.NDS_IS_RELATIVE +ida_merge.NDS_IS_STR +ida_merge.NDS_MAP_IDX +ida_merge.NDS_MAP_VAL +ida_merge.NDS_SUPVAL +ida_merge.NDS_UI_ND +ida_merge.NDS_VAL8 +ida_merge.create_nodeval_merge_handler +ida_merge.create_nodeval_merge_handlers +ida_merge.destroy_moddata_merge_handlers +ida_merge.get_ea_diffpos_name +ida_merge.is_diff_merge_mode +ida_merge.item_block_locator_t +ida_merge.item_block_locator_t.__disown__ +ida_merge.item_block_locator_t.__init__ +ida_merge.item_block_locator_t.get_block_head +ida_merge.item_block_locator_t.setup_blocks +ida_merge.merge_data_t +ida_merge.merge_data_t.__init__ +ida_merge.merge_data_t.add_event_handler +ida_merge.merge_data_t.base_id +ida_merge.merge_data_t.compare_merging_tifs +ida_merge.merge_data_t.dbctx_ids +ida_merge.merge_data_t.ev_handlers +ida_merge.merge_data_t.get_block_head +ida_merge.merge_data_t.has_existing_node +ida_merge.merge_data_t.local_id +ida_merge.merge_data_t.map_privrange_id +ida_merge.merge_data_t.map_tinfo +ida_merge.merge_data_t.nbases +ida_merge.merge_data_t.remote_id +ida_merge.merge_data_t.remove_event_handler +ida_merge.merge_data_t.set_dbctx_ids +ida_merge.merge_data_t.setup_blocks +ida_merge.merge_handler_params_t +ida_merge.merge_handler_params_t.__init__ +ida_merge.merge_handler_params_t.insert_after +ida_merge.merge_handler_params_t.kind +ida_merge.merge_handler_params_t.ui_complex_details +ida_merge.merge_handler_params_t.ui_complex_name +ida_merge.merge_handler_params_t.ui_dp_shortname +ida_merge.merge_handler_params_t.ui_has_details +ida_merge.merge_handler_params_t.ui_indent +ida_merge.merge_handler_params_t.ui_linediff +ida_merge.merge_handler_params_t.ui_split_char +ida_merge.merge_handler_params_t.ui_split_str +ida_merge.merge_node_helper_t +ida_merge.merge_node_helper_t.__disown__ +ida_merge.merge_node_helper_t.__init__ +ida_merge.merge_node_helper_t.append_eavec +ida_merge.merge_node_helper_t.get_column_headers +ida_merge.merge_node_helper_t.get_netnode +ida_merge.merge_node_helper_t.is_mergeable +ida_merge.merge_node_helper_t.map_scalar +ida_merge.merge_node_helper_t.map_string +ida_merge.merge_node_helper_t.print_entry_details +ida_merge.merge_node_helper_t.print_entry_name +ida_merge.merge_node_helper_t.refresh +ida_merge.merge_node_info_t +ida_merge.merge_node_info_t.__init__ +ida_merge.merge_node_info_t.name +ida_merge.merge_node_info_t.nds_flags +ida_merge.merge_node_info_t.tag +ida_merge.moddata_diff_helper_t +ida_merge.moddata_diff_helper_t.__disown__ +ida_merge.moddata_diff_helper_t.__init__ +ida_merge.moddata_diff_helper_t.additional_mh_flags +ida_merge.moddata_diff_helper_t.fields +ida_merge.moddata_diff_helper_t.get_struc_ptr +ida_merge.moddata_diff_helper_t.merge_ending +ida_merge.moddata_diff_helper_t.merge_starting +ida_merge.moddata_diff_helper_t.module_name +ida_merge.moddata_diff_helper_t.netnode_name +ida_merge.moddata_diff_helper_t.nfields +ida_merge.moddata_diff_helper_t.print_diffpos_details +ida_merge.moddata_diff_helper_t.str2val +ida_merge.moddata_diff_helper_t.val2str +ida_undo +ida_undo.create_undo_point +ida_undo.get_redo_action_label +ida_undo.get_undo_action_label +ida_undo.perform_redo +ida_undo.perform_undo diff --git a/api_contents.full b/api_contents.full index 28e0e4a..79ae432 100644 --- a/api_contents.full +++ b/api_contents.full @@ -1,16968 +1,11506 @@ -ida_hexrays (module) +ida_hexrays array used for translating cexpr_t->op type to their names. -ida_hexrays.ACFL_BLKOPT (variable) +ida_hexrays.ACFL_BLKOPT perform interblock transformations -ida_hexrays.ACFL_GLBDEL (variable) +ida_hexrays.ACFL_GLBDEL perform dead code eliminition -ida_hexrays.ACFL_GLBPROP (variable) +ida_hexrays.ACFL_GLBPROP perform global propagation -ida_hexrays.ACFL_GUESS (variable) +ida_hexrays.ACFL_GUESS may guess calling conventions -ida_hexrays.ACFL_LOCOPT (variable) +ida_hexrays.ACFL_LOCOPT perform local propagation (requires ACFL_BLKOPT) -ida_hexrays.ALLOW_UNUSED_LABELS (variable) +ida_hexrays.ALLOW_UNUSED_LABELS Unused labels are permitted. -ida_hexrays.ANCHOR_BLKCMT (variable) +ida_hexrays.ANCHOR_BLKCMT block comment (for ctree items) -ida_hexrays.ANCHOR_CITEM (variable) +ida_hexrays.ANCHOR_CITEM c-tree item -ida_hexrays.ANCHOR_ITP (variable) +ida_hexrays.ANCHOR_ITP item type preciser -ida_hexrays.ANCHOR_LVAR (variable) +ida_hexrays.ANCHOR_LVAR declaration of local variable -ida_hexrays.ANY_FPSIZE (variable) +ida_hexrays.ANY_FPSIZE any size of floating operand is permitted -ida_hexrays.ANY_REGSIZE (variable) +ida_hexrays.ANY_REGSIZE any register size is permitted -ida_hexrays.BLT_0WAY (variable) +ida_hexrays.BLT_0WAY does not have successors (tail is a noret function) -ida_hexrays.BLT_1WAY (variable) +ida_hexrays.BLT_1WAY passes execution to one block (regular or goto block) -ida_hexrays.BLT_2WAY (variable) +ida_hexrays.BLT_2WAY passes execution to two blocks (conditional jump) -ida_hexrays.BLT_NONE (variable) +ida_hexrays.BLT_NONE unknown block type -ida_hexrays.BLT_NWAY (variable) +ida_hexrays.BLT_NWAY passes execution to many blocks (switch idiom) -ida_hexrays.BLT_STOP (variable) +ida_hexrays.BLT_STOP stops execution regularly (must be the last block) -ida_hexrays.BLT_XTRN (variable) +ida_hexrays.BLT_XTRN external block (out of function address) -ida_hexrays.CALC_CURLY_BRACES (variable) +ida_hexrays.CALC_CURLY_BRACES print curly braces if necessary -ida_hexrays.CFL_FINAL (variable) +ida_hexrays.CFL_FINAL call type is final, should not be changed -ida_hexrays.CFL_HELPER (variable) +ida_hexrays.CFL_HELPER created from a decompiler helper function -ida_hexrays.CFL_NORET (variable) +ida_hexrays.CFL_NORET call does not return -ida_hexrays.CFS_BOUNDS (variable) +ida_hexrays.CFS_BOUNDS 'eamap' and 'boundaries' are ready -ida_hexrays.CFS_LOCKED (variable) +ida_hexrays.CFS_LOCKED cfunc is temporarily locked -ida_hexrays.CFS_LVARS_HIDDEN (variable) +ida_hexrays.CFS_LVARS_HIDDEN local variable definitions are collapsed -ida_hexrays.CFS_TEXT (variable) +ida_hexrays.CFS_TEXT 'sv' is ready (and hdrlines) -ida_hexrays.CHF_FAKE (variable) +ida_hexrays.CHF_FAKE fake chain created by widen_chains() -ida_hexrays.CHF_INITED (variable) +ida_hexrays.CHF_INITED is chain initialized? (valid only after lvar allocation) -ida_hexrays.CHF_OVER (variable) +ida_hexrays.CHF_OVER overlapped chain -ida_hexrays.CHF_PASSTHRU (variable) +ida_hexrays.CHF_PASSTHRU pass-thru chain, must use the input variable to the block -ida_hexrays.CHF_REPLACED (variable) +ida_hexrays.CHF_REPLACED chain operands have been replaced? -ida_hexrays.CHF_TERM (variable) +ida_hexrays.CHF_TERM terminating chain; the variable does not survive across the block -ida_hexrays.CIT_COLLAPSED (variable) +ida_hexrays.CIT_COLLAPSED display ctree item in collapsed form -ida_hexrays.CMAT_BUILT (variable) +ida_hexrays.CMAT_BUILT just generated -ida_hexrays.CMAT_CASTED (variable) +ida_hexrays.CMAT_CASTED added necessary casts -ida_hexrays.CMAT_CPA (variable) +ida_hexrays.CMAT_CPA corrected pointer arithmetic -ida_hexrays.CMAT_FINAL (variable) +ida_hexrays.CMAT_FINAL ready-to-use -ida_hexrays.CMAT_NICE (variable) +ida_hexrays.CMAT_NICE nicefied expressions -ida_hexrays.CMAT_TRANS1 (variable) +ida_hexrays.CMAT_TRANS1 applied first wave of transformations -ida_hexrays.CMAT_TRANS2 (variable) +ida_hexrays.CMAT_TRANS2 applied second wave of transformations -ida_hexrays.CMAT_TRANS3 (variable) +ida_hexrays.CMAT_TRANS3 applied third wave of transformations -ida_hexrays.CMAT_ZERO (variable) +ida_hexrays.CMAT_ZERO does not exist -ida_hexrays.CMT_ALL (variable) +ida_hexrays.CMT_ALL All comments. -ida_hexrays.CMT_BLOCK1 (variable) +ida_hexrays.CMT_BLOCK1 Anterioir block comment. -ida_hexrays.CMT_BLOCK2 (variable) +ida_hexrays.CMT_BLOCK2 Posterior block comment. -ida_hexrays.CMT_FUNC (variable) +ida_hexrays.CMT_FUNC Function comment. -ida_hexrays.CMT_LVAR (variable) +ida_hexrays.CMT_LVAR Local variable comment. -ida_hexrays.CMT_NONE (variable) +ida_hexrays.CMT_NONE No comment is possible. -ida_hexrays.CMT_TAIL (variable) +ida_hexrays.CMT_TAIL Indented comment. -ida_hexrays.CPBLK_FAST (variable) +ida_hexrays.CPBLK_FAST do not update minbstkref and minbargref -ida_hexrays.CPBLK_MINREF (variable) +ida_hexrays.CPBLK_MINREF update minbstkref and minbargref -ida_hexrays.CPBLK_OPTJMP (variable) - del the jump insn at the end of the block if it becomes useless +ida_hexrays.CPBLK_OPTJMP + del the jump insn at the end of the block if it becomes useless + -ida_hexrays.CV_FAST (variable) +ida_hexrays.CV_FAST do not maintain parent information -ida_hexrays.CV_INSNS (variable) - visit only statements, prune all expressions do not use before the final ctree - maturity because expressions may contain statements at intermediate stages (see - cot_insn). Otherwise you risk missing statements embedded into expressions. +ida_hexrays.CV_INSNS + visit only statements, prune all expressions do not use before the final ctree maturity because expressions may contain statements at intermediate stages (see cot_insn). Otherwise you risk missing statements embedded into expressions. + -ida_hexrays.CV_PARENTS (variable) +ida_hexrays.CV_PARENTS maintain parent information -ida_hexrays.CV_POST (variable) +ida_hexrays.CV_POST call the leave...() functions -ida_hexrays.CV_PRUNE (variable) +ida_hexrays.CV_PRUNE this bit is set by visit...() to prune the walk -ida_hexrays.CV_RESTART (variable) +ida_hexrays.CV_RESTART restart enumeration at the top expr (apply_to_exprs) -ida_hexrays.DECOMP_ALL_BLKS (variable) +ida_hexrays.DECOMP_ALL_BLKS generate microcode for unreachable blocks -ida_hexrays.DECOMP_GXREFS_DEFLT (variable) - the default behavior: do not update the global xrefs cache upon decompile() - call, but when the pseudocode text is generated (e.g., through - cfunc_t.get_pseudocode()) +ida_hexrays.DECOMP_GXREFS_DEFLT + the default behavior: do not update the global xrefs cache upon decompile() call, but when the pseudocode text is generated (e.g., through cfunc_t.get_pseudocode()) + -ida_hexrays.DECOMP_GXREFS_FORCE (variable) +ida_hexrays.DECOMP_GXREFS_FORCE update the global xrefs cache immediately -ida_hexrays.DECOMP_GXREFS_NOUPD (variable) +ida_hexrays.DECOMP_GXREFS_NOUPD do not update the global xrefs cache -ida_hexrays.DECOMP_NO_CACHE (variable) +ida_hexrays.DECOMP_NO_CACHE do not use decompilation cache (snippets are never cached) -ida_hexrays.DECOMP_NO_FRAME (variable) +ida_hexrays.DECOMP_NO_FRAME do not use function frame info (only snippet mode) -ida_hexrays.DECOMP_NO_HIDE (variable) +ida_hexrays.DECOMP_NO_HIDE do not close display waitbox. see close_hexrays_waitboxes() -ida_hexrays.DECOMP_NO_WAIT (variable) +ida_hexrays.DECOMP_NO_WAIT do not display waitbox -ida_hexrays.DECOMP_NO_XREFS (variable) - Obsolete. Use DECOMP_GXREFS_NOUPD. +ida_hexrays.DECOMP_OUTLINE + generate code for an outline -ida_hexrays.DECOMP_VOID_MBA (variable) +ida_hexrays.DECOMP_VOID_MBA return empty mba object (to be used with gen_microcode) -ida_hexrays.DECOMP_WARNINGS (variable) +ida_hexrays.DECOMP_WARNINGS display warnings in the output window -ida_hexrays.DecompilationFailure (class) +ida_hexrays.DecompilationFailure -ida_hexrays.EQ_CMPDEST (variable) +ida_hexrays.EQ_CMPDEST compare instruction destinations -ida_hexrays.EQ_IGNCODE (variable) +ida_hexrays.EQ_IGNCODE ignore instruction opcodes -ida_hexrays.EQ_IGNSIZE (variable) +ida_hexrays.EQ_IGNSIZE ignore source operand sizes -ida_hexrays.EQ_OPTINSN (variable) +ida_hexrays.EQ_OPTINSN optimize mop_d operands -ida_hexrays.EXFL_ALL (variable) +ida_hexrays.EXFL_ALL all currently defined bits -ida_hexrays.EXFL_ALONE (variable) +ida_hexrays.EXFL_ALONE standalone helper -ida_hexrays.EXFL_CPADONE (variable) +ida_hexrays.EXFL_CPADONE pointer arithmetic correction done -ida_hexrays.EXFL_CSTR (variable) +ida_hexrays.EXFL_CSTR string literal -ida_hexrays.EXFL_FPOP (variable) +ida_hexrays.EXFL_FPOP floating point operation -ida_hexrays.EXFL_JUMPOUT (variable) +ida_hexrays.EXFL_JUMPOUT jump out-of-function -ida_hexrays.EXFL_LVALUE (variable) +ida_hexrays.EXFL_LVALUE expression is lvalue even if it doesn't look like it -ida_hexrays.EXFL_PARTIAL (variable) +ida_hexrays.EXFL_PARTIAL type of the expression is considered partial -ida_hexrays.EXFL_UNDEF (variable) +ida_hexrays.EXFL_UNDEF expression uses undefined value -ida_hexrays.EXFL_VFTABLE (variable) +ida_hexrays.EXFL_VFTABLE is ptr to vftable (used for cot_memptr, cot_memref) -ida_hexrays.FCI_DEAD (variable) +ida_hexrays.FCI_DEAD some return registers were determined dead -ida_hexrays.FCI_EXPLOCS (variable) +ida_hexrays.FCI_EXPLOCS all arglocs are specified explicitly -ida_hexrays.FCI_FINAL (variable) +ida_hexrays.FCI_FINAL call type is final, should not be changed -ida_hexrays.FCI_HASCALL (variable) - A function is an synthetic helper combined from several instructions and at - least one of them was a call to a real functions +ida_hexrays.FCI_HASCALL + A function is an synthetic helper combined from several instructions and at least one of them was a call to a real functions + -ida_hexrays.FCI_HASFMT (variable) - A variadic function with recognized printf- or scanf-style format string +ida_hexrays.FCI_HASFMT + A variadic function with recognized printf- or scanf-style format string + -ida_hexrays.FCI_NORET (variable) +ida_hexrays.FCI_NORET call does not return -ida_hexrays.FCI_NOSIDE (variable) +ida_hexrays.FCI_NOSIDE call does not have side effects -ida_hexrays.FCI_PROP (variable) +ida_hexrays.FCI_PROP call has been propagated -ida_hexrays.FCI_PURE (variable) +ida_hexrays.FCI_PURE pure function -ida_hexrays.FCI_SPLOK (variable) - spoiled/visible_memory lists have been optimized. for some functions we can - reduce them as soon as information about the arguments becomes available. in - order not to try optimize them again we use this bit. +ida_hexrays.FCI_SPLOK + spoiled/visible_memory lists have been optimized. for some functions we can reduce them as soon as information about the arguments becomes available. in order not to try optimize them again we use this bit. + -ida_hexrays.FD_BACKWARD (variable) +ida_hexrays.FD_BACKWARD search direction -ida_hexrays.FD_DEF (variable) +ida_hexrays.FD_DEF look for definition -ida_hexrays.FD_DIRTY (variable) - ignore possible implicit definitions by function calls and indirect memory - access +ida_hexrays.FD_DIRTY + ignore possible implicit definitions by function calls and indirect memory access + -ida_hexrays.FD_FORWARD (variable) +ida_hexrays.FD_FORWARD search direction -ida_hexrays.FD_USE (variable) +ida_hexrays.FD_USE look for use -ida_hexrays.FORBID_UNUSED_LABELS (variable) +ida_hexrays.FORBID_UNUSED_LABELS Unused labels cause interr. -ida_hexrays.GCA_ALLOC (variable) +ida_hexrays.GCA_ALLOC enumerate only allocated chains -ida_hexrays.GCA_EMPTY (variable) +ida_hexrays.GCA_EMPTY include empty chains -ida_hexrays.GCA_NALLOC (variable) +ida_hexrays.GCA_NALLOC enumerate only non-allocated chains -ida_hexrays.GCA_OFIRST (variable) +ida_hexrays.GCA_OFIRST consider only chains of the first block -ida_hexrays.GCA_OLAST (variable) +ida_hexrays.GCA_OLAST consider only chains of the last block -ida_hexrays.GCA_SPEC (variable) +ida_hexrays.GCA_SPEC include chains for special registers -ida_hexrays.GCO_DEF (variable) +ida_hexrays.GCO_DEF is destination operand? -ida_hexrays.GCO_REG (variable) +ida_hexrays.GCO_REG is register? otherwise a stack variable -ida_hexrays.GCO_STK (variable) +ida_hexrays.GCO_STK a stack variable -ida_hexrays.GCO_USE (variable) +ida_hexrays.GCO_USE is source operand? -ida_hexrays.GC_ASR (variable) +ida_hexrays.GC_ASR all the above and assertions -ida_hexrays.GC_DIRTY_ALL (variable) +ida_hexrays.GC_DIRTY_ALL bitmask to represent all chains -ida_hexrays.GC_END (variable) +ida_hexrays.GC_END number of chain types -ida_hexrays.GC_REGS_AND_STKVARS (variable) +ida_hexrays.GC_REGS_AND_STKVARS registers and stkvars (restricted memory only) -ida_hexrays.GC_XDSU (variable) +ida_hexrays.GC_XDSU only registers calculated with FULL_XDSU -ida_hexrays.GLN_ALL (variable) +ida_hexrays.GLN_ALL get both -ida_hexrays.GLN_CURRENT (variable) +ida_hexrays.GLN_CURRENT get label of the current item -ida_hexrays.GLN_GOTO_TARGET (variable) +ida_hexrays.GLN_GOTO_TARGET get goto target -ida_hexrays.Hexrays_Hooks (class) - Proxy of C++ Hexrays_Hooks class. +ida_hexrays.Hexrays_Hooks -ida_hexrays.Hexrays_Hooks.__disown__ (method) +ida_hexrays.Hexrays_Hooks.__disown__(self) -ida_hexrays.Hexrays_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> Hexrays_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 +ida_hexrays.Hexrays_Hooks.__init__(self, _flags: int = 0, _hkcb_flags: int = 1) -ida_hexrays.Hexrays_Hooks.build_callinfo (method) - build_callinfo(self, blk, type) -> PyObject * - Analyzing a call instruction. - +ida_hexrays.Hexrays_Hooks.begin_inlining(self, cdg: "codegen_t", decomp_flags: int) -> int + Starting to inline outlined functions. + + @param cdg: (codegen_t *) + @param decomp_flags: (int) + @returns Microcode error codes code This is an opportunity to inline other ranges. + +ida_hexrays.Hexrays_Hooks.build_callinfo(self, blk: "mblock_t", type: "tinfo_t") -> "PyObject *" + Analyzing a call instruction. + @param blk: (mblock_t *) blk->tail is the call. @param type: (tinfo_t *) buffer for the output type. -ida_hexrays.Hexrays_Hooks.callinfo_built (method) - callinfo_built(self, blk) -> int - A call instruction has been anallyzed. - +ida_hexrays.Hexrays_Hooks.callinfo_built(self, blk: "mblock_t") -> int + A call instruction has been anallyzed. + @param blk: (mblock_t *) blk->tail is the call. -ida_hexrays.Hexrays_Hooks.calls_done (method) - calls_done(self, mba) -> int - All calls have been analyzed. - - @param mba: (mba_t *) This event is generated immediately after analyzing all - calls, before any optimizitions, call unmerging and block merging. +ida_hexrays.Hexrays_Hooks.calls_done(self, mba: "mba_t") -> int + All calls have been analyzed. + + @param mba: (mba_t *) This event is generated immediately after analyzing all calls, before any optimizitions, call unmerging and block merging. -ida_hexrays.Hexrays_Hooks.close_pseudocode (method) - close_pseudocode(self, vu) -> int - Pseudocode view is being closed. - +ida_hexrays.Hexrays_Hooks.close_pseudocode(self, vu: "vdui_t") -> int + Pseudocode view is being closed. + @param vu: (vdui_t *) -ida_hexrays.Hexrays_Hooks.cmt_changed (method) - cmt_changed(self, cfunc, loc, cmt) -> int - Comment got changed. - +ida_hexrays.Hexrays_Hooks.cmt_changed(self, cfunc: "cfunc_t", loc: "treeloc_t", cmt: str) -> int + Comment got changed. + @param cfunc: (cfunc_t *) @param loc: (const treeloc_t *) @param cmt: (const char *) -ida_hexrays.Hexrays_Hooks.combine (method) - combine(self, blk, insn) -> int - Trying to combine instructions of basic block. - - @param blk: (mblock_t *) - @param insn: (minsn_t *) Should return: 1 if combined the current instruction - with a preceding one -1 if the instruction should not be combined 0 - else +ida_hexrays.Hexrays_Hooks.collect_warnings(self, cfunc: "cfunc_t") -> int + Collect warning messages from plugins. These warnings will be displayed at the function header, after the user-defined comments. + + @param cfunc: (cfunc_t *) -ida_hexrays.Hexrays_Hooks.create_hint (method) - create_hint(self, vu) -> PyObject * - Create a hint for the current item. - @see: ui_get_custom_viewer_hint - +ida_hexrays.Hexrays_Hooks.combine(self, blk: "mblock_t", insn: "minsn_t") -> int + Trying to combine instructions of basic block. + + @param blk: (mblock_t *) + @param insn: (minsn_t *) Should return: 1 if combined the current instruction with a preceding one -1 if the instruction should not be combined 0 else + +ida_hexrays.Hexrays_Hooks.create_hint(self, vu: "vdui_t") -> "PyObject *" + Create a hint for the current item. + @param vu: (vdui_t *) @retval 0: continue collecting hints with other subscribers @retval 1: stop collecting hints -ida_hexrays.Hexrays_Hooks.curpos (method) - curpos(self, vu) -> int - Current cursor position has been changed. (for example, by left-clicking or - using keyboard) +ida_hexrays.Hexrays_Hooks.curpos(self, vu: "vdui_t") -> int + Current cursor position has been changed. (for example, by left-clicking or using keyboard) + @param vu: (vdui_t *) -ida_hexrays.Hexrays_Hooks.double_click (method) - double_click(self, vu, shift_state) -> int - Mouse double click. - +ida_hexrays.Hexrays_Hooks.double_click(self, vu: "vdui_t", shift_state: int) -> int + Mouse double click. + @param vu: (vdui_t *) @param shift_state: (int) Should return: 1 if the event has been handled -ida_hexrays.Hexrays_Hooks.flowchart (method) - flowchart(self, fc) -> int - Flowchart has been generated. - +ida_hexrays.Hexrays_Hooks.flowchart(self, fc: "qflow_chart_t", mba: "mba_t", reachable_blocks: "bitset_t", decomp_flags: int) -> int + Flowchart has been generated. + @param fc: (qflow_chart_t *) + @param mba: (mba_t *) + @param reachable_blocks: (bitset_t *) + @param decomp_flags: (int) + @returns Microcode error codes code -ida_hexrays.Hexrays_Hooks.func_printed (method) - func_printed(self, cfunc) -> int - Function text has been generated. Plugins may modify the text in cfunc_t::sv. - The text uses regular color codes (see lines.hpp) COLOR_ADDR is used to store - pointers to ctree items. - +ida_hexrays.Hexrays_Hooks.func_printed(self, cfunc: "cfunc_t") -> int + Function text has been generated. Plugins may modify the text in cfunc_t::sv. However, it is too late to modify the ctree or microcode. The text uses regular color codes (see lines.hpp) COLOR_ADDR is used to store pointers to ctree items. + @param cfunc: (cfunc_t *) -ida_hexrays.Hexrays_Hooks.glbopt (method) - glbopt(self, mba) -> int - Global optimization has been finished. If microcode is modified, MERR_LOOP must - be returned. It will cause a complete restart of the optimization. - - @param mba: (mba_t *) return Microcode error codes code +ida_hexrays.Hexrays_Hooks.glbopt(self, mba: "mba_t") -> int + Global optimization has been finished. If microcode is modified, MERR_LOOP must be returned. It will cause a complete restart of the optimization. + + @param mba: (mba_t *) + @returns Microcode error codes code -ida_hexrays.Hexrays_Hooks.hook (method) - hook(self) -> bool +ida_hexrays.Hexrays_Hooks.hook(self) -> bool -ida_hexrays.Hexrays_Hooks.interr (method) - interr(self, errcode) -> int - Internal error has occurred. - +ida_hexrays.Hexrays_Hooks.inlined_func(self, cdg: "codegen_t", blk: int, mbr: "mba_ranges_t", i1: int, i2: int) -> int + A set of ranges got inlined. + + @param cdg: (codegen_t *) + @param blk: (int) the block containing call/jump to inline + @param mbr: (mba_ranges_t *) the range to inline + @param i1: (int) blknum of the first inlined block + @param i2: (int) blknum of the last inlined block (excluded) + +ida_hexrays.Hexrays_Hooks.inlining_func(self, cdg: "codegen_t", blk: int, mbr: "mba_ranges_t") -> int + A set of ranges is going to be inlined. + + @param cdg: (codegen_t *) + @param blk: (int) the block containing call/jump to inline + @param mbr: (mba_ranges_t *) the range to inline + +ida_hexrays.Hexrays_Hooks.interr(self, errcode: int) -> int + Internal error has occurred. + @param errcode: (int ) -ida_hexrays.Hexrays_Hooks.keyboard (method) - keyboard(self, vu, key_code, shift_state) -> int - Keyboard has been hit. - +ida_hexrays.Hexrays_Hooks.keyboard(self, vu: "vdui_t", key_code: int, shift_state: int) -> int + Keyboard has been hit. + @param vu: (vdui_t *) @param key_code: (int) VK_... @param shift_state: (int) Should return: 1 if the event has been handled -ida_hexrays.Hexrays_Hooks.locopt (method) - locopt(self, mba) -> int - Basic block level optimization has been finished. - - @param mba: (mba_t *) return Microcode error codes code +ida_hexrays.Hexrays_Hooks.locopt(self, mba: "mba_t") -> int + Basic block level optimization has been finished. + + @param mba: (mba_t *) + @returns Microcode error codes code -ida_hexrays.Hexrays_Hooks.lvar_cmt_changed (method) - lvar_cmt_changed(self, vu, v, cmt) -> int - Local variable comment got changed. - +ida_hexrays.Hexrays_Hooks.lvar_cmt_changed(self, vu: "vdui_t", v: "lvar_t", cmt: str) -> int + Local variable comment got changed. + @param vu: (vdui_t *) @param v: (lvar_t *) - @param cmt: (const char *) Please note that it is possible to read/write user - settings for lvars directly from the idb. + @param cmt: (const char *) Please note that it is possible to read/write user settings for lvars directly from the idb. -ida_hexrays.Hexrays_Hooks.lvar_mapping_changed (method) - lvar_mapping_changed(self, vu, frm, to) -> int - Local variable mapping got changed. - +ida_hexrays.Hexrays_Hooks.lvar_mapping_changed(self, vu: "vdui_t", frm: "lvar_t", to: "lvar_t") -> int + Local variable mapping got changed. + @param vu: (vdui_t *) - @param from: lvar_t * - @param to: (lvar_t *) Please note that it is possible to read/write user - settings for lvars directly from the idb. + @param to: (lvar_t *) Please note that it is possible to read/write user settings for lvars directly from the idb. -ida_hexrays.Hexrays_Hooks.lvar_name_changed (method) - lvar_name_changed(self, vu, v, name, is_user_name) -> int - Local variable got renamed. - +ida_hexrays.Hexrays_Hooks.lvar_name_changed(self, vu: "vdui_t", v: "lvar_t", name: str, is_user_name: bool) -> int + Local variable got renamed. + @param vu: (vdui_t *) @param v: (lvar_t *) @param name: (const char *) - @param is_user_name: (bool) Please note that it is possible to read/write user - settings for lvars directly from the idb. + @param is_user_name: (bool) Please note that it is possible to read/write user settings for lvars directly from the idb. -ida_hexrays.Hexrays_Hooks.lvar_type_changed (method) - lvar_type_changed(self, vu, v, tinfo) -> int - Local variable type got changed. - +ida_hexrays.Hexrays_Hooks.lvar_type_changed(self, vu: "vdui_t", v: "lvar_t", tinfo: "tinfo_t") -> int + Local variable type got changed. + @param vu: (vdui_t *) @param v: (lvar_t *) - @param tinfo: (const tinfo_t *) Please note that it is possible to read/write - user settings for lvars directly from the idb. + @param tinfo: (const tinfo_t *) Please note that it is possible to read/write user settings for lvars directly from the idb. -ida_hexrays.Hexrays_Hooks.maturity (method) - maturity(self, cfunc, new_maturity) -> int - Ctree maturity level is being changed. - +ida_hexrays.Hexrays_Hooks.maturity(self, cfunc: "cfunc_t", new_maturity: "ctree_maturity_t") -> int + Ctree maturity level is being changed. + @param cfunc: (cfunc_t *) @param new_maturity: (ctree_maturity_t) -ida_hexrays.Hexrays_Hooks.microcode (method) - microcode(self, mba) -> int - Microcode has been generated. - - @param mba: (mba_t *) return Microcode error codes code +ida_hexrays.Hexrays_Hooks.microcode(self, mba: "mba_t") -> int + Microcode has been generated. + + @param mba: (mba_t *) + @returns Microcode error codes code -ida_hexrays.Hexrays_Hooks.open_pseudocode (method) - open_pseudocode(self, vu) -> int - New pseudocode view has been opened. - +ida_hexrays.Hexrays_Hooks.open_pseudocode(self, vu: "vdui_t") -> int + New pseudocode view has been opened. + @param vu: (vdui_t *) -ida_hexrays.Hexrays_Hooks.populating_popup (method) - populating_popup(self, widget, popup_handle, vu) -> int - Populating popup menu. We can add menu items now. - +ida_hexrays.Hexrays_Hooks.populating_popup(self, widget: "TWidget *", popup_handle: "TPopupMenu *", vu: "vdui_t") -> int + Populating popup menu. We can add menu items now. + @param widget: (TWidget *) @param popup_handle: (TPopupMenu *) @param vu: (vdui_t *) -ida_hexrays.Hexrays_Hooks.prealloc (method) - prealloc(self, mba) -> int - Local variables: preallocation step begins. - - @param mba: (mba_t *) This event may occur several times. Should return: 1 if - modified microcode Negative values are Microcode error codes error - codes +ida_hexrays.Hexrays_Hooks.pre_structural(self, ct: "control_graph_t *", cfunc: "cfunc_t", g: "simple_graph_t") -> int + Structure analysis is starting. + + @param ct: (control_graph_t *) in/out: control graph + @param cfunc: (cfunc_t *) in: the current function + @param g: (const simple_graph_t *) in: control flow graph + @returns Microcode error codes code; MERR_BLOCK means that the analysis has been performed by a plugin -ida_hexrays.Hexrays_Hooks.preoptimized (method) - preoptimized(self, mba) -> int - Microcode has been preoptimized. - - @param mba: (mba_t *) return Microcode error codes code +ida_hexrays.Hexrays_Hooks.prealloc(self, mba: "mba_t") -> int + Local variables: preallocation step begins. + + @param mba: (mba_t *) This event may occur several times. Should return: 1 if modified microcode Negative values are Microcode error codes error codes -ida_hexrays.Hexrays_Hooks.print_func (method) - print_func(self, cfunc, vp) -> int - Printing ctree and generating text. - +ida_hexrays.Hexrays_Hooks.preoptimized(self, mba: "mba_t") -> int + Microcode has been preoptimized. + + @param mba: (mba_t *) + @returns Microcode error codes code + +ida_hexrays.Hexrays_Hooks.print_func(self, cfunc: "cfunc_t", vp: "vc_printer_t") -> int + Printing ctree and generating text. + @param cfunc: (cfunc_t *) - @param vp: (vc_printer_t *) Returns: 1 if text has been generated by the plugin - It is forbidden to modify ctree at this event. + @param vp: (vc_printer_t *) Returns: 1 if text has been generated by the plugin It is forbidden to modify ctree at this event. -ida_hexrays.Hexrays_Hooks.prolog (method) - prolog(self, mba, fc, reachable_blocks, decomp_flags) -> int - Prolog analysis has been finished. - +ida_hexrays.Hexrays_Hooks.prolog(self, mba: "mba_t", fc: "qflow_chart_t", reachable_blocks: "bitset_t", decomp_flags: int) -> int + Prolog analysis has been finished. + @param mba: (mba_t *) @param fc: (qflow_chart_t *) - @param reachable_blocks: (bitset_t *) - @param decomp_flags: (int) return Microcode error codes code + @param reachable_blocks: (const bitset_t *) + @param decomp_flags: (int) + @returns Microcode error codes code This event is generated for each inlined range as well. -ida_hexrays.Hexrays_Hooks.refresh_pseudocode (method) - refresh_pseudocode(self, vu) -> int - Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is - forbidden in this event. - +ida_hexrays.Hexrays_Hooks.refresh_pseudocode(self, vu: "vdui_t") -> int + Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is forbidden in this event. + @param vu: (vdui_t *) See also hxe_text_ready, which happens earlier -ida_hexrays.Hexrays_Hooks.resolve_stkaddrs (method) - resolve_stkaddrs(self, mba) -> int - The optimizer is about to resolve stack addresses. - +ida_hexrays.Hexrays_Hooks.resolve_stkaddrs(self, mba: "mba_t") -> int + The optimizer is about to resolve stack addresses. + @param mba: (mba_t *) -ida_hexrays.Hexrays_Hooks.right_click (method) - right_click(self, vu) -> int - Mouse right click. Use hxe_populating_popup instead, in case you want to add - items in the popup menu. - +ida_hexrays.Hexrays_Hooks.right_click(self, vu: "vdui_t") -> int + Mouse right click. Use hxe_populating_popup instead, in case you want to add items in the popup menu. + @param vu: (vdui_t *) -ida_hexrays.Hexrays_Hooks.stkpnts (method) - stkpnts(self, mba, _sps) -> int - SP change points have been calculated. - +ida_hexrays.Hexrays_Hooks.stkpnts(self, mba: "mba_t", _sps: "stkpnts_t *") -> int + SP change points have been calculated. + @param mba: (mba_t *) - @param stkpnts: (stkpnts_t *) return Microcode error codes code + @returns Microcode error codes code This event is generated for each inlined range as well. -ida_hexrays.Hexrays_Hooks.structural (method) - structural(self, ct) -> int - Structural analysis has been finished. - +ida_hexrays.Hexrays_Hooks.structural(self, ct: "control_graph_t *") -> int + Structural analysis has been finished. + @param ct: (control_graph_t *) -ida_hexrays.Hexrays_Hooks.switch_pseudocode (method) - switch_pseudocode(self, vu) -> int - Existing pseudocode view has been reloaded with a new function. Its text has not - been refreshed yet, only cfunc and mba pointers are ready. - +ida_hexrays.Hexrays_Hooks.switch_pseudocode(self, vu: "vdui_t") -> int + Existing pseudocode view has been reloaded with a new function. Its text has not been refreshed yet, only cfunc and mba pointers are ready. + @param vu: (vdui_t *) -ida_hexrays.Hexrays_Hooks.text_ready (method) - text_ready(self, vu) -> int - Decompiled text is ready. - - @param vu: (vdui_t *) This event can be used to modify the output text (sv). - Obsolete. Please use hxe_func_printed instead. +ida_hexrays.Hexrays_Hooks.text_ready(self, vu: "vdui_t") -> int + Decompiled text is ready. + + @param vu: (vdui_t *) This event can be used to modify the output text (sv). Obsolete. Please use hxe_func_printed instead. -ida_hexrays.Hexrays_Hooks.unhook (method) - unhook(self) -> bool +ida_hexrays.Hexrays_Hooks.unhook(self) -> bool -ida_hexrays.IPROP_CLNPOP (variable) - the purpose of the instruction is to clean stack (e.g. "pop ecx" is often used - for that) +ida_hexrays.INLINE_DONTCOPY + Do not reuse old inlined copy even if it exists. -ida_hexrays.IPROP_COMBINED (variable) +ida_hexrays.INLINE_EXTFRAME + Inlined function has its own (external) frame. + +ida_hexrays.IPROP_ASSERT + assertion: usually mov #val, op. assertions are used to help the optimizer. assertions are ignored when generating ctree + + +ida_hexrays.IPROP_CLNPOP + the purpose of the instruction is to clean stack (e.g. "pop ecx" is often used for that) + + +ida_hexrays.IPROP_COMBINED insn has been modified because of a partial reference -ida_hexrays.IPROP_DONT_COMB (variable) +ida_hexrays.IPROP_DONT_COMB may not combine this instruction with others -ida_hexrays.IPROP_DONT_PROP (variable) +ida_hexrays.IPROP_DONT_PROP may not propagate -ida_hexrays.IPROP_EXTSTX (variable) +ida_hexrays.IPROP_EXTSTX this is m_ext propagated into m_stx -ida_hexrays.IPROP_FARCALL (variable) +ida_hexrays.IPROP_FARCALL call of a far function using push cs/call sequence -ida_hexrays.IPROP_FPINSN (variable) +ida_hexrays.IPROP_FPINSN floating point insn -ida_hexrays.IPROP_IGNLOWSRC (variable) - low part of the instruction source operand has been created artificially (this - bit is used only for 'and x, 80...') +ida_hexrays.IPROP_IGNLOWSRC + low part of the instruction source operand has been created artificially (this bit is used only for 'and x, 80...') + -ida_hexrays.IPROP_INV_JX (variable) +ida_hexrays.IPROP_INV_JX inverted conditional jump -ida_hexrays.IPROP_MBARRIER (variable) - this instruction acts as a memory barrier (instructions accessing memory may not - be reordered past it) +ida_hexrays.IPROP_MBARRIER + this instruction acts as a memory barrier (instructions accessing memory may not be reordered past it) + -ida_hexrays.IPROP_MULTI_MOV (variable) +ida_hexrays.IPROP_MULTI_MOV bits that can be set by plugins: - the minsn was generated as part of insn that moves multiple registers (example: - STM on ARM may transfer multiple registers) + the minsn was generated as part of insn that moves multiple registers (example: STM on ARM may transfer multiple registers) + -ida_hexrays.IPROP_OPTIONAL (variable) +ida_hexrays.IPROP_OPTIONAL optional instruction -ida_hexrays.IPROP_PERSIST (variable) +ida_hexrays.IPROP_PERSIST persistent insn; they are not destroyed -ida_hexrays.IPROP_SPLIT (variable) +ida_hexrays.IPROP_SPLIT the instruction has been split: -ida_hexrays.IPROP_SPLIT1 (variable) +ida_hexrays.IPROP_SPLIT1 into 1 byte -ida_hexrays.IPROP_SPLIT2 (variable) +ida_hexrays.IPROP_SPLIT2 into 2 bytes -ida_hexrays.IPROP_SPLIT4 (variable) +ida_hexrays.IPROP_SPLIT4 into 4 bytes -ida_hexrays.IPROP_SPLIT8 (variable) +ida_hexrays.IPROP_SPLIT8 into 8 bytes -ida_hexrays.IPROP_TAILCALL (variable) +ida_hexrays.IPROP_TAILCALL tail call -ida_hexrays.IPROP_UNMERGED (variable) +ida_hexrays.IPROP_UNMERGED 'goto' instruction was transformed info 'call' -ida_hexrays.IPROP_WAS_NORET (variable) +ida_hexrays.IPROP_UNPAIRED + instruction is a result of del_dest_pairs() transformation + +ida_hexrays.IPROP_WAS_NORET was noret icall -ida_hexrays.IPROP_WILDMATCH (variable) +ida_hexrays.IPROP_WILDMATCH match multiple insns -ida_hexrays.ITP_ARG1 (variable) +ida_hexrays.ITP_ARG1 , (64 entries are reserved for 64 call arguments) -ida_hexrays.ITP_ASM (variable) +ida_hexrays.ITP_ASM __asm-line -ida_hexrays.ITP_BLOCK1 (variable) - opening block comment. this comment is printed before the item (other comments - are indented and printed after the item) +ida_hexrays.ITP_BLOCK1 + opening block comment. this comment is printed before the item (other comments are indented and printed after the item) + -ida_hexrays.ITP_BLOCK2 (variable) +ida_hexrays.ITP_BLOCK2 closing block comment. -ida_hexrays.ITP_BRACE2 (variable) +ida_hexrays.ITP_BRACE2 ) -ida_hexrays.ITP_CASE (variable) +ida_hexrays.ITP_CASE bit for switch cases -ida_hexrays.ITP_COLON (variable) +ida_hexrays.ITP_COLON : (label) -ida_hexrays.ITP_CURLY1 (variable) +ida_hexrays.ITP_CURLY1 { -ida_hexrays.ITP_CURLY2 (variable) +ida_hexrays.ITP_CURLY2 } -ida_hexrays.ITP_DO (variable) +ida_hexrays.ITP_DO do-line -ida_hexrays.ITP_ELSE (variable) +ida_hexrays.ITP_ELSE else-line -ida_hexrays.ITP_EMPTY (variable) +ida_hexrays.ITP_EMPTY nothing -ida_hexrays.ITP_SEMI (variable) +ida_hexrays.ITP_SEMI semicolon -ida_hexrays.ITP_SIGN (variable) +ida_hexrays.ITP_SIGN if this bit is set too, then we have a negative case value -ida_hexrays.LOCOPT_ALL (variable) - redo optimization for all blocks. if this bit is not set, only dirty blocks will - be optimized +ida_hexrays.ITP_TRY + C++ try statement. -ida_hexrays.LOCOPT_REFINE (variable) +ida_hexrays.LOCOPT_ALL + redo optimization for all blocks. if this bit is not set, only dirty blocks will be optimized + + +ida_hexrays.LOCOPT_REFINE refine return type, ok to fail -ida_hexrays.LOCOPT_REFINE2 (variable) +ida_hexrays.LOCOPT_REFINE2 refine return type, try harder -ida_hexrays.LVINF_KEEP (variable) - preserve saved user settings regardless of vars for example, if a var loses all - its user-defined attributes or even gets destroyed, keep its lvar_saved_info_t. - this is used for ephemeral variables that get destroyed by macro recognition. +ida_hexrays.LVINF_KEEP + preserve saved user settings regardless of vars for example, if a var loses all its user-defined attributes or even gets destroyed, keep its lvar_saved_info_t. this is used for ephemeral variables that get destroyed by macro recognition. + -ida_hexrays.LVINF_NOMAP (variable) +ida_hexrays.LVINF_NOMAP forbid automatic mapping of the variable -ida_hexrays.LVINF_NOPTR (variable) +ida_hexrays.LVINF_NOPTR variable type should not be a pointer -ida_hexrays.LVINF_SPLIT (variable) - split allocation of a new variable. forces the decompiler to create a new - variable at ll.defea +ida_hexrays.LVINF_SPLIT + split allocation of a new variable. forces the decompiler to create a new variable at ll.defea + -ida_hexrays.LVINF_UNUSED (variable) +ida_hexrays.LVINF_UNUSED unused argument, corresponds to CVAR_UNUSED -ida_hexrays.MBA2_ARGIDX_OK (variable) +ida_hexrays.MBA2_ARGIDX_OK may verify input argument list? -ida_hexrays.MBA2_ARGIDX_SORTED (variable) - args finally sorted according to ABI (e.g. reverse stkarg order in Borland) +ida_hexrays.MBA2_ARGIDX_SORTED + args finally sorted according to ABI (e.g. reverse stkarg order in Borland) + -ida_hexrays.MBA2_CODE16_BIT (variable) - the code16 bit removed +ida_hexrays.MBA2_CODE16_BIT + the code16 bit got removed -ida_hexrays.MBA2_DONT_VERIFY (variable) - Do not verify microcode. This flag is recomended to be set only when debugging - decompiler plugins +ida_hexrays.MBA2_DONT_VERIFY + Do not verify microcode. This flag is recomended to be set only when debugging decompiler plugins + -ida_hexrays.MBA2_HAS_OUTLINES (variable) +ida_hexrays.MBA2_HAS_OUTLINES calls to outlined code have been inlined -ida_hexrays.MBA2_IS_CTR (variable) +ida_hexrays.MBA2_IS_CTR is constructor? -ida_hexrays.MBA2_IS_DTR (variable) +ida_hexrays.MBA2_IS_DTR is destructor? -ida_hexrays.MBA2_LVARNAMES_OK (variable) +ida_hexrays.MBA2_LVARNAMES_OK may verify lvar_names? -ida_hexrays.MBA2_LVARS_RENAMED (variable) +ida_hexrays.MBA2_LVARS_RENAMED accept empty names now? -ida_hexrays.MBA2_NO_DUP_CALLS (variable) +ida_hexrays.MBA2_NO_DUP_CALLS forbid multiple calls with the same ea -ida_hexrays.MBA2_NO_DUP_LVARS (variable) +ida_hexrays.MBA2_NO_DUP_LVARS forbid multiple lvars with the same ea -ida_hexrays.MBA2_NO_FRAME (variable) +ida_hexrays.MBA2_NO_FRAME do not use function frame info (only snippet mode) -ida_hexrays.MBA2_OVER_CHAINS (variable) +ida_hexrays.MBA2_OVER_CHAINS has overlapped chains? -ida_hexrays.MBA2_PROP_COMPLEX (variable) +ida_hexrays.MBA2_PROP_COMPLEX allow propagation of more complex variable definitions -ida_hexrays.MBA2_STACK_RETVAL (variable) +ida_hexrays.MBA2_STACK_RETVAL the return value is on the stack -ida_hexrays.MBA2_UNDEF_RETVAR (variable) +ida_hexrays.MBA2_UNDEF_RETVAR return value is undefined -ida_hexrays.MBA2_VALRNG_DONE (variable) +ida_hexrays.MBA2_VALRNG_DONE calculated valranges? -ida_hexrays.MBA_ASRPROP (variable) +ida_hexrays.MBA_ASRPROP assertion have been propagated -ida_hexrays.MBA_ASRTOK (variable) +ida_hexrays.MBA_ASRTOK assertions have been generated -ida_hexrays.MBA_CALLS (variable) +ida_hexrays.MBA_CALLS callinfo has been built -ida_hexrays.MBA_CHVARS (variable) +ida_hexrays.MBA_CHVARS can verify chain varnums -ida_hexrays.MBA_CMBBLK (variable) +ida_hexrays.MBA_CMBBLK request to combine blocks -ida_hexrays.MBA_CMNSTK (variable) +ida_hexrays.MBA_CMNSTK stkvars+stkargs should be considered as one area -ida_hexrays.MBA_COLGDL (variable) +ida_hexrays.MBA_COLGDL display graph after each reduction -ida_hexrays.MBA_DELPAIRS (variable) +ida_hexrays.MBA_DELPAIRS pairs have been deleted once -ida_hexrays.MBA_GLBOPT (variable) +ida_hexrays.MBA_GLBOPT microcode has been optimized globally -ida_hexrays.MBA_INSGDL (variable) +ida_hexrays.MBA_INSGDL display instruction in graphs -ida_hexrays.MBA_LOADED (variable) +ida_hexrays.MBA_LOADED loaded gdl, no instructions (debugging) -ida_hexrays.MBA_LVARS0 (variable) +ida_hexrays.MBA_LVARS0 lvar pre-allocation has been performed -ida_hexrays.MBA_LVARS1 (variable) +ida_hexrays.MBA_LVARS1 lvar real allocation has been performed -ida_hexrays.MBA_NICE (variable) +ida_hexrays.MBA_NICE apply transformations to c code -ida_hexrays.MBA_NOFUNC (variable) +ida_hexrays.MBA_NOFUNC function is not present, addresses might be wrong -ida_hexrays.MBA_NUMADDR (variable) +ida_hexrays.MBA_NUMADDR display definition addresses for numbers -ida_hexrays.MBA_PASSREGS (variable) +ida_hexrays.MBA_PASSREGS has mcallinfo_t::pass_regs -ida_hexrays.MBA_PATTERN (variable) +ida_hexrays.MBA_PATTERN microcode pattern, callinfo is present -ida_hexrays.MBA_PRCDEFS (variable) +ida_hexrays.MBA_PRCDEFS use precise defeas for chain-allocated lvars -ida_hexrays.MBA_PREOPT (variable) +ida_hexrays.MBA_PREOPT preoptimization stage complete -ida_hexrays.MBA_REFINE (variable) +ida_hexrays.MBA_REFINE may refine return value size -ida_hexrays.MBA_RETFP (variable) +ida_hexrays.MBA_RETFP function returns floating point value -ida_hexrays.MBA_RETREF (variable) +ida_hexrays.MBA_RETREF return type has been refined -ida_hexrays.MBA_SAVRST (variable) +ida_hexrays.MBA_SAVRST save-restore analysis has been performed -ida_hexrays.MBA_SHORT (variable) +ida_hexrays.MBA_SHORT use short display -ida_hexrays.MBA_SPLINFO (variable) +ida_hexrays.MBA_SPLINFO (final_type ? idb_spoiled : spoiled_regs) is valid -ida_hexrays.MBA_THUNK (variable) +ida_hexrays.MBA_THUNK thunk function -ida_hexrays.MBA_VALNUM (variable) +ida_hexrays.MBA_VALNUM display value numbers -ida_hexrays.MBA_WINGR32 (variable) +ida_hexrays.MBA_WINGR32 use wingraph32 -ida_hexrays.MBL_BACKPROP (variable) +ida_hexrays.MBL_BACKPROP performed backprop_cc -ida_hexrays.MBL_CALL (variable) +ida_hexrays.MBL_CALL call information has been built -ida_hexrays.MBL_COMB (variable) +ida_hexrays.MBL_COMB needs "combine" pass -ida_hexrays.MBL_DEAD (variable) +ida_hexrays.MBL_DEAD needs "eliminate deads" pass -ida_hexrays.MBL_DMT64 (variable) +ida_hexrays.MBL_DMT64 needs "demote 64bits" -ida_hexrays.MBL_DSLOT (variable) +ida_hexrays.MBL_DSLOT block for delay slot -ida_hexrays.MBL_FAKE (variable) +ida_hexrays.MBL_EXTFRAME + an inlined block with an external frame + +ida_hexrays.MBL_FAKE fake block -ida_hexrays.MBL_GOTO (variable) +ida_hexrays.MBL_GOTO this block is a goto target -ida_hexrays.MBL_INCONST (variable) +ida_hexrays.MBL_INCONST inconsistent lists: we are building them -ida_hexrays.MBL_KEEP (variable) +ida_hexrays.MBL_INLINED + block was inlined, not originally part of mbr + +ida_hexrays.MBL_KEEP do not remove even if unreachable -ida_hexrays.MBL_LIST (variable) +ida_hexrays.MBL_LIST use/def lists are ready (not dirty) -ida_hexrays.MBL_NONFAKE (variable) +ida_hexrays.MBL_NONFAKE regular block -ida_hexrays.MBL_NORET (variable) +ida_hexrays.MBL_NORET dead end block: doesn't return execution control -ida_hexrays.MBL_PRIV (variable) - private block - no instructions except the specified are accepted (used in - patterns) +ida_hexrays.MBL_PRIV + private block - no instructions except the specified are accepted (used in patterns) + -ida_hexrays.MBL_PROP (variable) +ida_hexrays.MBL_PROP needs 'propagation' pass -ida_hexrays.MBL_PUSH (variable) +ida_hexrays.MBL_PUSH needs "convert push/pop instructions" -ida_hexrays.MBL_TCAL (variable) +ida_hexrays.MBL_TCAL aritifical call block for tail calls -ida_hexrays.MBL_VALRANGES (variable) +ida_hexrays.MBL_VALRANGES should optimize using value ranges -ida_hexrays.MERR_BADARCH (variable) +ida_hexrays.MERR_BADARCH current architecture is not supported -ida_hexrays.MERR_BADBLK (variable) +ida_hexrays.MERR_BADBLK bad block found -ida_hexrays.MERR_BADCALL (variable) +ida_hexrays.MERR_BADCALL could not determine call arguments -ida_hexrays.MERR_BADFRAME (variable) +ida_hexrays.MERR_BADFRAME function frame is wrong -ida_hexrays.MERR_BADIDB (variable) +ida_hexrays.MERR_BADIDB inconsistent database information -ida_hexrays.MERR_BADRANGES (variable) +ida_hexrays.MERR_BADRANGES bad input ranges -ida_hexrays.MERR_BADSP (variable) +ida_hexrays.MERR_BADSP positive sp value has been found -ida_hexrays.MERR_BITNESS (variable) +ida_hexrays.MERR_BITNESS 16-bit functions cannot be decompiled -ida_hexrays.MERR_BLOCK (variable) +ida_hexrays.MERR_BLOCK no error, switch to new block -ida_hexrays.MERR_BUSY (variable) +ida_hexrays.MERR_BUSY already decompiling a function -ida_hexrays.MERR_CANCELED (variable) +ida_hexrays.MERR_CANCELED decompilation has been cancelled -ida_hexrays.MERR_COMPLEX (variable) +ida_hexrays.MERR_CLOUD + cloud: s + +ida_hexrays.MERR_COMPLEX too complex function -ida_hexrays.MERR_DSLOT (variable) +ida_hexrays.MERR_DSLOT bad instruction in the delay slot -ida_hexrays.MERR_EXCEPTION (variable) +ida_hexrays.MERR_EXCEPTION exception analysis failed -ida_hexrays.MERR_EXTERN (variable) +ida_hexrays.MERR_EXTERN special segments cannot be decompiled -ida_hexrays.MERR_FARPTR (variable) +ida_hexrays.MERR_FARPTR far memory model is supported only for pc -ida_hexrays.MERR_FUNCSIZE (variable) +ida_hexrays.MERR_FUNCSIZE too big function -ida_hexrays.MERR_HUGESTACK (variable) +ida_hexrays.MERR_HUGESTACK stack frame is too big -ida_hexrays.MERR_INSN (variable) +ida_hexrays.MERR_INSN cannot convert to microcode -ida_hexrays.MERR_INTERR (variable) +ida_hexrays.MERR_INTERR internal error -ida_hexrays.MERR_LICENSE (variable) +ida_hexrays.MERR_LICENSE no license available -ida_hexrays.MERR_LOOP (variable) +ida_hexrays.MERR_LOOP internal code: redo last loop (never reported) -ida_hexrays.MERR_LVARS (variable) +ida_hexrays.MERR_LVARS local variable allocation failed -ida_hexrays.MERR_MEM (variable) +ida_hexrays.MERR_MEM not enough memory -ida_hexrays.MERR_OK (variable) +ida_hexrays.MERR_OK ok -ida_hexrays.MERR_ONLY32 (variable) +ida_hexrays.MERR_ONLY32 only 32-bit functions can be decompiled for the current database -ida_hexrays.MERR_ONLY64 (variable) +ida_hexrays.MERR_ONLY64 only 64-bit functions can be decompiled for the current database -ida_hexrays.MERR_OVERLAP (variable) +ida_hexrays.MERR_OVERLAP variables would overlap: s -ida_hexrays.MERR_PARTINIT (variable) +ida_hexrays.MERR_PARTINIT partially initialized variable s -ida_hexrays.MERR_PROLOG (variable) +ida_hexrays.MERR_PROLOG prolog analysis failed -ida_hexrays.MERR_RECDEPTH (variable) +ida_hexrays.MERR_RECDEPTH max recursion depth reached during lvar allocation -ida_hexrays.MERR_REDO (variable) +ida_hexrays.MERR_REDO redecompilation has been requested -ida_hexrays.MERR_SIZEOF (variable) +ida_hexrays.MERR_SIZEOF wrong basic type sizes in compiler settings -ida_hexrays.MERR_STOP (variable) +ida_hexrays.MERR_STOP no error, stop the analysis -ida_hexrays.MERR_SWITCH (variable) +ida_hexrays.MERR_SWITCH wrong switch idiom -ida_hexrays.MERR_UNKTYPE (variable) +ida_hexrays.MERR_UNKTYPE undefined type s (currently unused error code) -ida_hexrays.MLI_CLR_FLAGS (variable) +ida_hexrays.MLI_CLR_FLAGS clear LVINF_... bits -ida_hexrays.MLI_CMT (variable) +ida_hexrays.MLI_CMT apply lvar comment -ida_hexrays.MLI_NAME (variable) +ida_hexrays.MLI_NAME apply lvar name -ida_hexrays.MLI_SET_FLAGS (variable) +ida_hexrays.MLI_SET_FLAGS set LVINF_... bits -ida_hexrays.MLI_TYPE (variable) +ida_hexrays.MLI_TYPE apply lvar type -ida_hexrays.MMAT_CALLS (variable) +ida_hexrays.MMAT_CALLS detected call arguments. see also hxe_calls_done -ida_hexrays.MMAT_GENERATED (variable) +ida_hexrays.MMAT_GENERATED generated microcode -ida_hexrays.MMAT_GLBOPT1 (variable) +ida_hexrays.MMAT_GLBOPT1 performed the first pass of global optimization -ida_hexrays.MMAT_GLBOPT2 (variable) +ida_hexrays.MMAT_GLBOPT2 most global optimization passes are done -ida_hexrays.MMAT_GLBOPT3 (variable) +ida_hexrays.MMAT_GLBOPT3 completed all global optimization. microcode is fixed now. -ida_hexrays.MMAT_LOCOPT (variable) - local optimization of each basic block is complete. control flow graph is ready - too. +ida_hexrays.MMAT_LOCOPT + local optimization of each basic block is complete. control flow graph is ready too. + -ida_hexrays.MMAT_LVARS (variable) +ida_hexrays.MMAT_LVARS allocated local variables -ida_hexrays.MMAT_PREOPTIMIZED (variable) +ida_hexrays.MMAT_PREOPTIMIZED preoptimized pass is complete -ida_hexrays.MMAT_ZERO (variable) +ida_hexrays.MMAT_ZERO microcode does not exist -ida_hexrays.MMIDX_GLBHIGH (variable) +ida_hexrays.MMIDX_ARGS + stack: regular stack arguments + +ida_hexrays.MMIDX_GLBHIGH global memory: high part -ida_hexrays.MMIDX_GLBLOW (variable) +ida_hexrays.MMIDX_GLBLOW global memory: low part -ida_hexrays.NALT_VD (variable) +ida_hexrays.MMIDX_LVARS + stack: local variables + +ida_hexrays.MMIDX_RETADDR + stack: return address + +ida_hexrays.MMIDX_SHADOW + stack: shadow arguments + +ida_hexrays.NALT_VD this index is not used by ida -ida_hexrays.NF_BINVDONE (variable) +ida_hexrays.NF_BINVDONE temporary internal bit: inverting bits is done -ida_hexrays.NF_BITNOT (variable) +ida_hexrays.NF_BITNOT The user asked to invert bits of the constant. -ida_hexrays.NF_FIXED (variable) +ida_hexrays.NF_FIXED number format has been defined by the user -ida_hexrays.NF_NEGATE (variable) +ida_hexrays.NF_NEGATE The user asked to negate the constant. -ida_hexrays.NF_NEGDONE (variable) +ida_hexrays.NF_NEGDONE temporary internal bit: negation has been performed -ida_hexrays.NF_VALID (variable) - internal bit: stroff or enum is valid for enums: this bit is set immediately for - stroffs: this bit is set at the end of decompilation +ida_hexrays.NF_VALID + internal bit: stroff or enum is valid for enums: this bit is set immediately for stroffs: this bit is set at the end of decompilation + -ida_hexrays.NOSIZE (variable) +ida_hexrays.NOSIZE wrong or unexisting operand size -ida_hexrays.NO_CURLY_BRACES (variable) +ida_hexrays.NO_CURLY_BRACES don't print curly braces -ida_hexrays.NO_SIDEFF (variable) - change operand size but ignore side effects if you decide to keep the changed - operand, handle_new_size() must be called +ida_hexrays.NO_SIDEFF + change operand size but ignore side effects if you decide to keep the changed operand, handle_new_size() must be called + -ida_hexrays.ONLY_SIDEFF (variable) +ida_hexrays.ONLY_SIDEFF only handle side effects -ida_hexrays.OPF_NEW_WINDOW (variable) +ida_hexrays.OPF_NEW_WINDOW open new window -ida_hexrays.OPF_NO_WAIT (variable) +ida_hexrays.OPF_NO_WAIT do not display waitbox if decompilation happens -ida_hexrays.OPF_REUSE (variable) +ida_hexrays.OPF_REUSE reuse existing window -ida_hexrays.OPF_REUSE_ACTIVE (variable) - reuse existing window, only if the currently active widget is a pseudocode view +ida_hexrays.OPF_REUSE_ACTIVE + reuse existing window, only if the currently active widget is a pseudocode view + -ida_hexrays.OPROP_FLOAT (variable) +ida_hexrays.OPROP_CCFLAGS + mop_n: a pc-relative value mop_a: an address obtained from a relocation else: value of a condition code register (like mr_cc) + + +ida_hexrays.OPROP_FLOAT possibly floating value -ida_hexrays.OPROP_IMPDONE (variable) +ida_hexrays.OPROP_IMPDONE imported operand (a pointer) has been dereferenced -ida_hexrays.OPROP_LOWADDR (variable) +ida_hexrays.OPROP_LOWADDR a low address offset -ida_hexrays.OPROP_UDEFVAL (variable) +ida_hexrays.OPROP_UDEFVAL uses undefined value -ida_hexrays.OPROP_UDT (variable) +ida_hexrays.OPROP_UDT a struct or union -ida_hexrays.OPTI_ADDREXPRS (variable) +ida_hexrays.OPTI_ADDREXPRS optimize all address expressions (&x+N; &x-&y) -ida_hexrays.OPTI_COMBINSNS (variable) +ida_hexrays.OPTI_COMBINSNS may combine insns (only for optimize_insn) -ida_hexrays.OPTI_MINSTKREF (variable) +ida_hexrays.OPTI_MINSTKREF may update minstkref -ida_hexrays.OPTI_NO_LDXOPT (variable) - the function is called after the propagation attempt, we do not optimize - low/high(ldx) in this case +ida_hexrays.OPTI_NO_LDXOPT + the function is called after the propagation attempt, we do not optimize low/high(ldx) in this case + -ida_hexrays.RETRIEVE_ALWAYS (variable) +ida_hexrays.OPTI_NO_VALRNG + forbid using valranges + +ida_hexrays.RETRIEVE_ALWAYS Retrieve comment even if it has been used. -ida_hexrays.RETRIEVE_ONCE (variable) +ida_hexrays.RETRIEVE_ONCE Retrieve comment if it has not been used yet. -ida_hexrays.ROLE_3WAYCMP0 (variable) +ida_hexrays.ROLE_3WAYCMP0 3-way compare helper, returns -1/0/1 -ida_hexrays.ROLE_3WAYCMP1 (variable) +ida_hexrays.ROLE_3WAYCMP1 3-way compare helper, returns 0/1/2 -ida_hexrays.ROLE_ABS (variable) +ida_hexrays.ROLE_ABS integer absolute value -ida_hexrays.ROLE_ALLOCA (variable) +ida_hexrays.ROLE_ALLOCA alloca() function -ida_hexrays.ROLE_BITTEST (variable) +ida_hexrays.ROLE_BITTEST [lock] bt -ida_hexrays.ROLE_BITTESTANDCOMPLEMENT (variable) +ida_hexrays.ROLE_BITTESTANDCOMPLEMENT [lock] btc -ida_hexrays.ROLE_BITTESTANDRESET (variable) +ida_hexrays.ROLE_BITTESTANDRESET [lock] btr -ida_hexrays.ROLE_BITTESTANDSET (variable) +ida_hexrays.ROLE_BITTESTANDSET [lock] bts -ida_hexrays.ROLE_BSWAP (variable) +ida_hexrays.ROLE_BSWAP bswap() function (any size) -ida_hexrays.ROLE_BUG (variable) +ida_hexrays.ROLE_BUG BUG() helper macro: never returns, causes exception. -ida_hexrays.ROLE_CFSUB3 (variable) +ida_hexrays.ROLE_CFSUB3 carry flag after subtract with carry -ida_hexrays.ROLE_CONTAINING_RECORD (variable) +ida_hexrays.ROLE_CONTAINING_RECORD CONTAINING_RECORD() macro. -ida_hexrays.ROLE_EMPTY (variable) +ida_hexrays.ROLE_EMPTY empty, does not do anything (maybe spoils regs) -ida_hexrays.ROLE_FASTFAIL (variable) +ida_hexrays.ROLE_FASTFAIL __fastfail() -ida_hexrays.ROLE_IS_MUL_OK (variable) +ida_hexrays.ROLE_IS_MUL_OK is_mul_ok -ida_hexrays.ROLE_MEMCPY (variable) +ida_hexrays.ROLE_MEMCPY memcpy(void *dst, const void *src, size_t count); -ida_hexrays.ROLE_MEMSET (variable) +ida_hexrays.ROLE_MEMSET memset(void *dst, uchar value, size_t count); -ida_hexrays.ROLE_MEMSET32 (variable) +ida_hexrays.ROLE_MEMSET32 memset32(void *dst, uint32 value, size_t count); -ida_hexrays.ROLE_MEMSET64 (variable) +ida_hexrays.ROLE_MEMSET64 memset64(void *dst, uint64 value, size_t count); -ida_hexrays.ROLE_OFSUB3 (variable) +ida_hexrays.ROLE_OFSUB3 overflow flag after subtract with carry -ida_hexrays.ROLE_PRESENT (variable) +ida_hexrays.ROLE_PRESENT present() function (used in patterns) -ida_hexrays.ROLE_READFLAGS (variable) +ida_hexrays.ROLE_READFLAGS __readeflags, __readcallersflags -ida_hexrays.ROLE_ROL (variable) +ida_hexrays.ROLE_ROL rotate left -ida_hexrays.ROLE_ROR (variable) +ida_hexrays.ROLE_ROR rotate right -ida_hexrays.ROLE_SATURATED_MUL (variable) +ida_hexrays.ROLE_SATURATED_MUL saturated_mul -ida_hexrays.ROLE_SSE_CMP4 (variable) +ida_hexrays.ROLE_SSE_CMP4 e.g. _mm_cmpgt_ss -ida_hexrays.ROLE_SSE_CMP8 (variable) +ida_hexrays.ROLE_SSE_CMP8 e.g. _mm_cmpgt_sd -ida_hexrays.ROLE_STRCAT (variable) +ida_hexrays.ROLE_STRCAT strcat(char *dst, const char *src); -ida_hexrays.ROLE_STRCPY (variable) +ida_hexrays.ROLE_STRCPY strcpy(char *dst, const char *src); -ida_hexrays.ROLE_STRLEN (variable) +ida_hexrays.ROLE_STRLEN strlen(const char *src); -ida_hexrays.ROLE_TAIL (variable) +ida_hexrays.ROLE_TAIL char *tail(const char *str); -ida_hexrays.ROLE_UNK (variable) +ida_hexrays.ROLE_UNK unknown function role -ida_hexrays.ROLE_VA_ARG (variable) +ida_hexrays.ROLE_VA_ARG va_arg() macro -ida_hexrays.ROLE_VA_COPY (variable) +ida_hexrays.ROLE_VA_COPY va_copy() function -ida_hexrays.ROLE_VA_END (variable) +ida_hexrays.ROLE_VA_END va_end() function -ida_hexrays.ROLE_VA_START (variable) +ida_hexrays.ROLE_VA_START va_start() function -ida_hexrays.ROLE_WCSCAT (variable) +ida_hexrays.ROLE_WCSCAT wchar_t *wcscat(wchar_t *dst, const wchar_t *src) -ida_hexrays.ROLE_WCSCPY (variable) +ida_hexrays.ROLE_WCSCPY wchar_t *wcscpy(wchar_t *dst, const wchar_t *src); -ida_hexrays.ROLE_WCSLEN (variable) +ida_hexrays.ROLE_WCSLEN size_t wcslen(const wchar_t *s) -ida_hexrays.ROLE_WMEMCPY (variable) +ida_hexrays.ROLE_WMEMCPY wchar_t *wmemcpy(wchar_t *dst, const wchar_t *src, size_t n) -ida_hexrays.ROLE_WMEMSET (variable) +ida_hexrays.ROLE_WMEMSET wchar_t *wmemset(wchar_t *dst, wchar_t wc, size_t n) -ida_hexrays.SHINS_LDXEA (variable) +ida_hexrays.SHINS_LDXEA display address of ldx expressions (not used) -ida_hexrays.SHINS_NUMADDR (variable) +ida_hexrays.SHINS_NUMADDR display definition addresses for numbers -ida_hexrays.SHINS_SHORT (variable) +ida_hexrays.SHINS_SHORT do not display use-def chains and other attrs -ida_hexrays.SHINS_VALNUM (variable) +ida_hexrays.SHINS_VALNUM display value numbers -ida_hexrays.ULV_PRECISE_DEFEA (variable) +ida_hexrays.ULV_PRECISE_DEFEA Use precise defea's for lvar locations. -ida_hexrays.USE_CURLY_BRACES (variable) +ida_hexrays.USE_CURLY_BRACES print curly braces without any checks -ida_hexrays.USE_KEYBOARD (variable) +ida_hexrays.USE_KEYBOARD Keyboard. -ida_hexrays.USE_MOUSE (variable) +ida_hexrays.USE_MOUSE Mouse. -ida_hexrays.VDI_EXPR (variable) +ida_hexrays.VDI_EXPR c-tree item -ida_hexrays.VDI_FUNC (variable) +ida_hexrays.VDI_FUNC the function itself (the very first line with the function prototype) -ida_hexrays.VDI_LVAR (variable) +ida_hexrays.VDI_LVAR declaration of local variable -ida_hexrays.VDI_NONE (variable) +ida_hexrays.VDI_NONE undefined -ida_hexrays.VDI_TAIL (variable) +ida_hexrays.VDI_TAIL cursor is at (beyond) the line end (commentable line) -ida_hexrays.VDRUN_APPEND (variable) +ida_hexrays.VDRUN_APPEND Create a new file or append to existing file. -ida_hexrays.VDRUN_CMDLINE (variable) +ida_hexrays.VDRUN_CMDLINE Called from ida's command line. -ida_hexrays.VDRUN_LUMINA (variable) +ida_hexrays.VDRUN_LUMINA Use lumina server. -ida_hexrays.VDRUN_MAYSTOP (variable) +ida_hexrays.VDRUN_MAYSTOP The user can cancel decompilation. -ida_hexrays.VDRUN_NEWFILE (variable) +ida_hexrays.VDRUN_NEWFILE Create a new file or overwrite existing file. -ida_hexrays.VDRUN_ONLYNEW (variable) +ida_hexrays.VDRUN_ONLYNEW Fail if output file already exists. -ida_hexrays.VDRUN_SENDIDB (variable) +ida_hexrays.VDRUN_SENDIDB Send problematic databases to hex-rays.com. -ida_hexrays.VDRUN_SILENT (variable) +ida_hexrays.VDRUN_SILENT Silent decompilation. -ida_hexrays.VDRUN_STATS (variable) +ida_hexrays.VDRUN_STATS Print statistics into vd_stats.txt. -ida_hexrays.VDUI_VALID (variable) +ida_hexrays.VDUI_VALID is valid? -ida_hexrays.VDUI_VISIBLE (variable) +ida_hexrays.VDUI_VISIBLE is visible? -ida_hexrays.VR_AT_END (variable) - get value ranges after the instruction or at the block end, just after the last - instruction (if M is nullptr) +ida_hexrays.VR_AT_END + get value ranges after the instruction or at the block end, just after the last instruction (if M is nullptr) + -ida_hexrays.VR_AT_START (variable) - get value ranges before the instruction or at the block start (if M is nullptr) +ida_hexrays.VR_AT_START + get value ranges before the instruction or at the block start (if M is nullptr) + -ida_hexrays.VR_EXACT (variable) - find exact match. if not set, the returned valrng size will be >= vivl.size +ida_hexrays.VR_EXACT + find exact match. if not set, the returned valrng size will be >= vivl.size + -ida_hexrays.WARN_ADDR_OUTARGS (variable) - 6 cannot handle address arithmetics in outgoing argument area of stack frame - - unused +ida_hexrays.WARN_ADDR_OUTARGS + 6 cannot handle address arithmetics in outgoing argument area of stack frame - unused -ida_hexrays.WARN_ARRAY_INARG (variable) +ida_hexrays.WARN_ARRAY_INARG 21 array has been used for an input argument -ida_hexrays.WARN_BAD_CALL_SP (variable) +ida_hexrays.WARN_BAD_CALL_SP 38 bad sp value at call -ida_hexrays.WARN_BAD_FIELD_TYPE (variable) +ida_hexrays.WARN_BAD_FIELD_TYPE 23 incorrect structure member type for s::s, ignored -ida_hexrays.WARN_BAD_INSN (variable) +ida_hexrays.WARN_BAD_INSN 49 bad instruction -ida_hexrays.WARN_BAD_MAPDST (variable) +ida_hexrays.WARN_BAD_MAPDST 48 too short map destination 's' for variable 's' -ida_hexrays.WARN_BAD_PURGED (variable) +ida_hexrays.WARN_BAD_PURGED 12 inconsistent function type and number of purged bytes -ida_hexrays.WARN_BAD_RETVAR (variable) +ida_hexrays.WARN_BAD_RETVAR 25 wrong return variable -ida_hexrays.WARN_BAD_SHADOW (variable) +ida_hexrays.WARN_BAD_SHADOW 45 ignored the value written to the shadow area of the succeeding call -ida_hexrays.WARN_BAD_SP (variable) +ida_hexrays.WARN_BAD_SP 40 positive sp value a has been found -ida_hexrays.WARN_BAD_STD_TYPE (variable) +ida_hexrays.WARN_BAD_STD_TYPE 37 corrupted or unexisting local type 's' -ida_hexrays.WARN_BAD_STKPNT (variable) +ida_hexrays.WARN_BAD_STKPNT 41 wrong sp change point -ida_hexrays.WARN_BAD_STROFF (variable) +ida_hexrays.WARN_BAD_STROFF 33 user specified stroff has not been processed: s -ida_hexrays.WARN_BAD_VALRNG (variable) +ida_hexrays.WARN_BAD_VALRNG 44 values range analysis failed -ida_hexrays.WARN_BAD_VARSIZE (variable) +ida_hexrays.WARN_BAD_VARSIZE 34 inconsistent variable size for 's' -ida_hexrays.WARN_CBUILD_LOOPS (variable) +ida_hexrays.WARN_CBUILD_LOOPS 13 too many cbuild loops -ida_hexrays.WARN_CR_BADOFF (variable) +ida_hexrays.WARN_CR_BADOFF 32 CONTAINING_RECORD: too small offset d for struct 's' -ida_hexrays.WARN_CR_NOFIELD (variable) +ida_hexrays.WARN_CR_NOFIELD 31 CONTAINING_RECORD: no field 's' in struct 's' at d -ida_hexrays.WARN_DEP_UNK_CALLS (variable) +ida_hexrays.WARN_DEP_UNK_CALLS 7 found interdependent unknown calls -ida_hexrays.WARN_EXP_LINVAR (variable) +ida_hexrays.WARN_EXP_LINVAR 10 failed to expand a linear variable -ida_hexrays.WARN_FIXED_MACRO (variable) - 29 fixed broken macro-insn +ida_hexrays.WARN_FIXED_INSN + 29 fixed broken insn -ida_hexrays.WARN_FRAG_LVAR (variable) +ida_hexrays.WARN_FRAG_LVAR 26 fragmented variable at s may be wrong -ida_hexrays.WARN_GUESSED_TYPE (variable) +ida_hexrays.WARN_GUESSED_TYPE 9 using guessed type s; -ida_hexrays.WARN_HUGE_STKOFF (variable) +ida_hexrays.WARN_HUGE_STKOFF 27 exceedingly huge offset into the stack frame -ida_hexrays.WARN_ILL_ELLIPSIS (variable) +ida_hexrays.WARN_ILL_ELLIPSIS 8 erroneously detected ellipsis type has been ignored -ida_hexrays.WARN_ILL_FPU_STACK (variable) +ida_hexrays.WARN_ILL_FPU_STACK 18 inconsistent fpu stack -ida_hexrays.WARN_ILL_FUNCTYPE (variable) +ida_hexrays.WARN_ILL_FUNCTYPE 2 invalid function type 's' has been ignored -ida_hexrays.WARN_ILL_PURGED (variable) +ida_hexrays.WARN_ILL_PURGED 1 odd caller purged bytes d, correcting -ida_hexrays.WARN_JUMPOUT (variable) +ida_hexrays.WARN_JUMPOUT 43 control flows out of bounds -ida_hexrays.WARN_MAX (variable) - may be used in notes as a placeholder when the warning id is not available +ida_hexrays.WARN_MAX + may be used in notes as a placeholder when the warning id is not available + -ida_hexrays.WARN_MAX_ARGS (variable) +ida_hexrays.WARN_MAX_ARGS 22 too many input arguments, some ignored -ida_hexrays.WARN_MISSED_SWITCH (variable) +ida_hexrays.WARN_MISSED_SWITCH 39 wrong markup of switch jump, skipped it -ida_hexrays.WARN_MUST_RET_FP (variable) +ida_hexrays.WARN_MUST_RET_FP 17 function return type is incorrect (must be floating point) -ida_hexrays.WARN_NO_SAVE_REST (variable) +ida_hexrays.WARN_NO_SAVE_REST 14 could not find valid save-restore pair for s -ida_hexrays.WARN_ODD_ABI (variable) +ida_hexrays.WARN_ODD_ABI 50 encountered odd instruction for the current ABI -ida_hexrays.WARN_ODD_ADDR_USE (variable) +ida_hexrays.WARN_ODD_ADDR_USE 16 odd use of a variable address -ida_hexrays.WARN_ODD_INPUT_REG (variable) +ida_hexrays.WARN_ODD_INPUT_REG 15 odd input register s -ida_hexrays.WARN_OPT_USELESS_JCND (variable) +ida_hexrays.WARN_OPT_USELESS_JCND 54 simplified comparisons for 's': s became s -ida_hexrays.WARN_OPT_VALRNG (variable) +ida_hexrays.WARN_OPT_VALRNG 46 conditional instruction was optimized away because s -ida_hexrays.WARN_OPT_VALRNG2 (variable) +ida_hexrays.WARN_OPT_VALRNG2 52 mask 0xX is shortened because s <= 0xX" -ida_hexrays.WARN_OPT_VALRNG3 (variable) +ida_hexrays.WARN_OPT_VALRNG3 53 masking with 0XX was optimized away because s <= 0xX -ida_hexrays.WARN_RET_LOCREF (variable) +ida_hexrays.WARN_RET_LOCREF 47 returning address of temporary local variable 's' -ida_hexrays.WARN_SELFREF_PROP (variable) +ida_hexrays.WARN_SELFREF_PROP 19 self-referencing variable has been detected -ida_hexrays.WARN_UNALIGNED_ARG (variable) +ida_hexrays.WARN_SUBFRAME_OVERFLOW + 55 call arguments overflow the function chunk frame + +ida_hexrays.WARN_UNALIGNED_ARG 36 unaligned function argument 's' -ida_hexrays.WARN_UNBALANCED_STACK (variable) +ida_hexrays.WARN_UNBALANCED_STACK 51 unbalanced stack, ignored a potential tail call -ida_hexrays.WARN_UNDEF_LVAR (variable) +ida_hexrays.WARN_UNDEF_LVAR 42 variable 's' is possibly undefined -ida_hexrays.WARN_UNINITED_REG (variable) +ida_hexrays.WARN_UNINITED_REG 28 reference to an uninitialized register has been removed: s -ida_hexrays.WARN_UNSUPP_REG (variable) +ida_hexrays.WARN_UNSUPP_REG 35 unsupported processor register 's' -ida_hexrays.WARN_VARARG_MANY (variable) +ida_hexrays.WARN_VARARG_MANY 5 too many varargs, some ignored -ida_hexrays.WARN_VARARG_NOSTK (variable) +ida_hexrays.WARN_VARARG_NOSTK 4 call vararg without local stack -ida_hexrays.WARN_VARARG_REGS (variable) +ida_hexrays.WARN_VARARG_REGS 0 cannot handle register arguments in vararg function, discarded them -ida_hexrays.WARN_VARARG_TCAL (variable) +ida_hexrays.WARN_VARARG_TCAL 3 cannot handle tail call to vararg -ida_hexrays.WARN_WIDEN_CHAINS (variable) +ida_hexrays.WARN_WIDEN_CHAINS 11 failed to widen chains -ida_hexrays.WARN_WOULD_OVERLAP (variable) +ida_hexrays.WARN_WOULD_OVERLAP 20 variables would overlap: s -ida_hexrays.WARN_WRITE_CONST (variable) +ida_hexrays.WARN_WRITE_CONST 24 write access to const memory at a has been detected -ida_hexrays.WARN_WRONG_VA_OFF (variable) +ida_hexrays.WARN_WRONG_VA_OFF 30 wrong offset of va_list variable -ida_hexrays.WITH_SIDEFF (variable) +ida_hexrays.WITH_SIDEFF change operand size and handle side effects -ida_hexrays.__cbhooks_t (class) +ida_hexrays.__cbhooks_t -ida_hexrays.__cbhooks_t.__init__ (method) +ida_hexrays.__cbhooks_t.__init__(self, callback) -ida_hexrays.__cbhooks_t.close_pseudocode (method) +ida_hexrays.__cbhooks_t.close_pseudocode(self, *args) + Close pseudocode window. + + @param f: pointer to window + @returns false if failed -ida_hexrays.__cbhooks_t.create_hint (method) +ida_hexrays.__cbhooks_t.create_hint(self, *args) -ida_hexrays.__cbhooks_t.curpos (method) +ida_hexrays.__cbhooks_t.curpos(self, *args) -ida_hexrays.__cbhooks_t.double_click (method) +ida_hexrays.__cbhooks_t.double_click(self, *args) -ida_hexrays.__cbhooks_t.func_printed (method) +ida_hexrays.__cbhooks_t.func_printed(self, *args) -ida_hexrays.__cbhooks_t.interr (method) +ida_hexrays.__cbhooks_t.interr(self, *args) -ida_hexrays.__cbhooks_t.keyboard (method) +ida_hexrays.__cbhooks_t.keyboard(self, *args) -ida_hexrays.__cbhooks_t.maturity (method) +ida_hexrays.__cbhooks_t.maturity(self, *args) -ida_hexrays.__cbhooks_t.open_pseudocode (method) +ida_hexrays.__cbhooks_t.open_pseudocode(self, *args) + Open pseudocode window. The specified function is decompiled and the pseudocode window is opened. + + @param ea: function to decompile + @param flags: a combination of OPF_ flags + @returns false if failed -ida_hexrays.__cbhooks_t.populating_popup (method) +ida_hexrays.__cbhooks_t.populating_popup(self, *args) -ida_hexrays.__cbhooks_t.print_func (method) +ida_hexrays.__cbhooks_t.print_func(self, *args) -ida_hexrays.__cbhooks_t.refresh_pseudocode (method) +ida_hexrays.__cbhooks_t.refresh_pseudocode(self, *args) -ida_hexrays.__cbhooks_t.right_click (method) +ida_hexrays.__cbhooks_t.right_click(self, *args) -ida_hexrays.__cbhooks_t.switch_pseudocode (method) +ida_hexrays.__cbhooks_t.switch_pseudocode(self, *args) -ida_hexrays.__cbhooks_t.text_ready (method) +ida_hexrays.__cbhooks_t.text_ready(self, *args) -ida_hexrays._call_with_transferrable_ownership (function) +ida_hexrays._call_with_transferrable_ownership(fun, *args) -ida_hexrays._kludge_force_declare_TPopupMenu (function) - _kludge_force_declare_TPopupMenu(arg1) - - Parameters - ---------- - arg1: TPopupMenu const * +ida_hexrays._kludge_force_declare_TPopupMenu(arg1: "TPopupMenu const *") -> None -ida_hexrays._ll_call_helper (function) - _ll_call_helper(rettype, args, format) -> cexpr_t - - Parameters - ---------- - rettype: tinfo_t const & - args: carglist_t * - format: char const * +ida_hexrays._ll_call_helper(*args) -> "cexpr_t *" -ida_hexrays._ll_create_helper (function) - _ll_create_helper(standalone, type, format) -> cexpr_t - - Parameters - ---------- - standalone: bool - type: tinfo_t const & - format: char const * +ida_hexrays._ll_create_helper(*args) -> "cexpr_t *" -ida_hexrays._ll_dereference (function) - _ll_dereference(e, ptrsize, is_flt=False) -> cexpr_t - - Parameters - ---------- - e: cexpr_t * - ptrsize: int - is_flt: bool +ida_hexrays._ll_dereference(e: "cexpr_t", ptrsize: int, is_flt: bool = False) -> "cexpr_t *" -ida_hexrays._ll_lnot (function) - _ll_lnot(e) -> cexpr_t - - Parameters - ---------- - e: cexpr_t * +ida_hexrays._ll_lnot(e: "cexpr_t") -> "cexpr_t *" -ida_hexrays._ll_make_num (function) - _ll_make_num(n, func=None, ea=BADADDR, opnum=0, sign=no_sign, size=0) -> cexpr_t - - Parameters - ---------- - n: uint64 - func: cfunc_t * - ea: ea_t - opnum: int - sign: type_sign_t - size: int +ida_hexrays._ll_make_num(*args) -> "cexpr_t *" -ida_hexrays._ll_make_ref (function) - _ll_make_ref(e) -> cexpr_t - - Parameters - ---------- - e: cexpr_t * +ida_hexrays._ll_make_ref(e: "cexpr_t") -> "cexpr_t *" -ida_hexrays._ll_new_block (function) - _ll_new_block() -> cinsn_t +ida_hexrays._ll_new_block() -> "cinsn_t *" -ida_hexrays._map_as_dict (function) +ida_hexrays._map_as_dict(maptype, name, keytype, valuetype) -ida_hexrays._map_as_dict._map___contains__ (function) +ida_hexrays._map_as_dict._map___contains__(self, key) Returns true if the specified key exists in the . -ida_hexrays._map_as_dict._map___delitem__ (function) +ida_hexrays._map_as_dict._map___delitem__(self, key) Removes the value associated with the provided key. -ida_hexrays._map_as_dict._map___getitem__ (function) +ida_hexrays._map_as_dict._map___getitem__(self, key) Returns the value associated with the provided key. -ida_hexrays._map_as_dict._map___iter__ (function) +ida_hexrays._map_as_dict._map___iter__(self) Iterate over dictionary keys. -ida_hexrays._map_as_dict._map___setitem__ (function) +ida_hexrays._map_as_dict._map___setitem__(self, key, value) Returns the value associated with the provided key. -ida_hexrays._map_as_dict._map_clear (function) +ida_hexrays._map_as_dict._map_clear(self) -ida_hexrays._map_as_dict._map_copy (function) +ida_hexrays._map_as_dict._map_copy(self) -ida_hexrays._map_as_dict._map_get (function) +ida_hexrays._map_as_dict._map_get(self, key, default = None) -ida_hexrays._map_as_dict._map_has_key (function) +ida_hexrays._map_as_dict._map_has_key(self, key) -ida_hexrays._map_as_dict._map_items (function) +ida_hexrays._map_as_dict._map_items(self) -ida_hexrays._map_as_dict._map_iteritems (function) +ida_hexrays._map_as_dict._map_iteritems(self) -ida_hexrays._map_as_dict._map_iterkeys (function) +ida_hexrays._map_as_dict._map_iterkeys(self) -ida_hexrays._map_as_dict._map_itervalues (function) +ida_hexrays._map_as_dict._map_itervalues(self) -ida_hexrays._map_as_dict._map_keys (function) +ida_hexrays._map_as_dict._map_keys(self) -ida_hexrays._map_as_dict._map_pop (function) +ida_hexrays._map_as_dict._map_pop(self, key) Sets the value associated with the provided key. -ida_hexrays._map_as_dict._map_popitem (function) +ida_hexrays._map_as_dict._map_popitem(self) Sets the value associated with the provided key. -ida_hexrays._map_as_dict._map_setdefault (function) +ida_hexrays._map_as_dict._map_setdefault(self, key, default = None) Sets the value associated with the provided key. -ida_hexrays._map_as_dict._map_values (function) +ida_hexrays._map_as_dict._map_values(self) -ida_hexrays.accepts_small_udts (function) - accepts_small_udts(op) -> bool +ida_hexrays.accepts_small_udts(op: "ctype_t") -> bool Is the operator allowed on small structure or union? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.accepts_udts (function) - accepts_udts(op) -> bool - - @param op: enum ctype_t +ida_hexrays.accepts_udts(op: "ctype_t") -> bool -ida_hexrays.arglocs_overlap (function) - arglocs_overlap(loc1, w1, loc2, w2) -> bool +ida_hexrays.arglocs_overlap(loc1: "vdloc_t", w1: "size_t", loc2: "vdloc_t", w2: "size_t") -> bool Do two arglocs overlap? - - @param loc1: (C++: const vdloc_t &) vdloc_t const & - @param w1: (C++: size_t) - @param loc2: (C++: const vdloc_t &) vdloc_t const & - @param w2: (C++: size_t) -ida_hexrays.array_of_bitsets (class) - Proxy of C++ qvector< bitset_t > class. +ida_hexrays.array_of_bitsets -ida_hexrays.array_of_bitsets.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< bitset_t > const & +ida_hexrays.array_of_bitsets.__eq__(self, r: "array_of_bitsets") -> bool -ida_hexrays.array_of_bitsets.__getitem__ (method) - __getitem__(self, i) -> bitset_t - - @param i: size_t +ida_hexrays.array_of_bitsets.__getitem__(self, i: "size_t") -> "bitset_t const &" -ida_hexrays.array_of_bitsets.__init__ (method) - __init__(self) -> array_of_bitsets - __init__(self, x) -> array_of_bitsets - - @param x: qvector< bitset_t > const & +ida_hexrays.array_of_bitsets.__init__(self, *args) -ida_hexrays.array_of_bitsets.__len__ (method) - __len__(self) -> size_t +ida_hexrays.array_of_bitsets.__len__(self) -> "size_t" -ida_hexrays.array_of_bitsets.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< bitset_t > const & +ida_hexrays.array_of_bitsets.__ne__(self, r: "array_of_bitsets") -> bool -ida_hexrays.array_of_bitsets.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: bitset_t const & +ida_hexrays.array_of_bitsets.__setitem__(self, i: "size_t", v: "bitset_t") -> None -ida_hexrays.array_of_bitsets._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: bitset_t const & +ida_hexrays.array_of_bitsets._del(self, x: "bitset_t") -> bool -ida_hexrays.array_of_bitsets.add_unique (method) - add_unique(self, x) -> bool - - @param x: bitset_t const & +ida_hexrays.array_of_bitsets.add_unique(self, x: "bitset_t") -> bool -ida_hexrays.array_of_bitsets.at (method) - at(self, _idx) -> bitset_t - - @param _idx: size_t +ida_hexrays.array_of_bitsets.append(self, x: "bitset_t") -> None -ida_hexrays.array_of_bitsets.begin (method) - begin(self) -> bitset_t +ida_hexrays.array_of_bitsets.at(self, _idx: "size_t") -> "bitset_t const &" -ida_hexrays.array_of_bitsets.capacity (method) - capacity(self) -> size_t +ida_hexrays.array_of_bitsets.begin(self, *args) -> "qvector< bitset_t >::const_iterator" -ida_hexrays.array_of_bitsets.clear (method) - clear(self) +ida_hexrays.array_of_bitsets.capacity(self) -> "size_t" -ida_hexrays.array_of_bitsets.empty (method) - empty(self) -> bool +ida_hexrays.array_of_bitsets.clear(self) -> None -ida_hexrays.array_of_bitsets.end (method) - end(self) -> bitset_t +ida_hexrays.array_of_bitsets.empty(self) -> bool -ida_hexrays.array_of_bitsets.erase (method) - erase(self, it) -> bitset_t - - @param it: qvector< bitset_t >::iterator - - erase(self, first, last) -> bitset_t - - @param first: qvector< bitset_t >::iterator - @param last: qvector< bitset_t >::iterator +ida_hexrays.array_of_bitsets.end(self, *args) -> "qvector< bitset_t >::const_iterator" -ida_hexrays.array_of_bitsets.extract (method) - extract(self) -> bitset_t +ida_hexrays.array_of_bitsets.erase(self, *args) -> "qvector< bitset_t >::iterator" -ida_hexrays.array_of_bitsets.find (method) - find(self, x) -> bitset_t - - @param x: bitset_t const & +ida_hexrays.array_of_bitsets.extend(self, x: "array_of_bitsets") -> None -ida_hexrays.array_of_bitsets.grow (method) - grow(self, x=bitset_t()) - - @param x: bitset_t const & +ida_hexrays.array_of_bitsets.extract(self) -> "bitset_t *" -ida_hexrays.array_of_bitsets.has (method) - has(self, x) -> bool - - @param x: bitset_t const & +ida_hexrays.array_of_bitsets.find(self, *args) -> "qvector< bitset_t >::const_iterator" -ida_hexrays.array_of_bitsets.inject (method) - inject(self, s, len) - - @param s: bitset_t * - @param len: size_t +ida_hexrays.array_of_bitsets.grow(self, *args) -> None -ida_hexrays.array_of_bitsets.insert (method) - insert(self, it, x) -> bitset_t - - @param it: qvector< bitset_t >::iterator - @param x: bitset_t const & +ida_hexrays.array_of_bitsets.has(self, x: "bitset_t") -> bool -ida_hexrays.array_of_bitsets.pop_back (method) - pop_back(self) +ida_hexrays.array_of_bitsets.inject(self, s: "bitset_t", len: "size_t") -> None -ida_hexrays.array_of_bitsets.push_back (method) - push_back(self, x) - - @param x: bitset_t const & - - push_back(self) -> bitset_t +ida_hexrays.array_of_bitsets.insert(self, it: "bitset_t", x: "bitset_t") -> "qvector< bitset_t >::iterator" -ida_hexrays.array_of_bitsets.qclear (method) - qclear(self) +ida_hexrays.array_of_bitsets.pop_back(self) -> None -ida_hexrays.array_of_bitsets.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.array_of_bitsets.push_back(self, *args) -> "bitset_t &" -ida_hexrays.array_of_bitsets.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: bitset_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.array_of_bitsets.qclear(self) -> None -ida_hexrays.array_of_bitsets.size (method) - size(self) -> size_t +ida_hexrays.array_of_bitsets.reserve(self, cnt: "size_t") -> None -ida_hexrays.array_of_bitsets.swap (method) - swap(self, r) - - @param r: qvector< bitset_t > & +ida_hexrays.array_of_bitsets.resize(self, *args) -> None -ida_hexrays.array_of_bitsets.truncate (method) - truncate(self) +ida_hexrays.array_of_bitsets.size(self) -> "size_t" -ida_hexrays.array_of_ivlsets (class) - Proxy of C++ qvector< ivlset_t > class. +ida_hexrays.array_of_bitsets.swap(self, r: "array_of_bitsets") -> None -ida_hexrays.array_of_ivlsets.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< ivlset_t > const & +ida_hexrays.array_of_bitsets.truncate(self) -> None -ida_hexrays.array_of_ivlsets.__getitem__ (method) - __getitem__(self, i) -> ivlset_t - - @param i: size_t +ida_hexrays.array_of_ivlsets -ida_hexrays.array_of_ivlsets.__init__ (method) - __init__(self) -> array_of_ivlsets - __init__(self, x) -> array_of_ivlsets - - @param x: qvector< ivlset_t > const & +ida_hexrays.array_of_ivlsets.__eq__(self, r: "array_of_ivlsets") -> bool -ida_hexrays.array_of_ivlsets.__len__ (method) - __len__(self) -> size_t +ida_hexrays.array_of_ivlsets.__getitem__(self, i: "size_t") -> "ivlset_t const &" -ida_hexrays.array_of_ivlsets.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< ivlset_t > const & +ida_hexrays.array_of_ivlsets.__init__(self, *args) -ida_hexrays.array_of_ivlsets.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ivlset_t const & +ida_hexrays.array_of_ivlsets.__len__(self) -> "size_t" -ida_hexrays.array_of_ivlsets._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: ivlset_t const & +ida_hexrays.array_of_ivlsets.__ne__(self, r: "array_of_ivlsets") -> bool -ida_hexrays.array_of_ivlsets.add_unique (method) - add_unique(self, x) -> bool - - @param x: ivlset_t const & +ida_hexrays.array_of_ivlsets.__setitem__(self, i: "size_t", v: "ivlset_t") -> None -ida_hexrays.array_of_ivlsets.at (method) - at(self, _idx) -> ivlset_t - - @param _idx: size_t +ida_hexrays.array_of_ivlsets._del(self, x: "ivlset_t") -> bool -ida_hexrays.array_of_ivlsets.begin (method) - begin(self) -> ivlset_t +ida_hexrays.array_of_ivlsets.add_unique(self, x: "ivlset_t") -> bool -ida_hexrays.array_of_ivlsets.capacity (method) - capacity(self) -> size_t +ida_hexrays.array_of_ivlsets.append(self, x: "ivlset_t") -> None -ida_hexrays.array_of_ivlsets.clear (method) - clear(self) +ida_hexrays.array_of_ivlsets.at(self, _idx: "size_t") -> "ivlset_t const &" -ida_hexrays.array_of_ivlsets.empty (method) - empty(self) -> bool +ida_hexrays.array_of_ivlsets.begin(self, *args) -> "qvector< ivlset_t >::const_iterator" -ida_hexrays.array_of_ivlsets.end (method) - end(self) -> ivlset_t +ida_hexrays.array_of_ivlsets.capacity(self) -> "size_t" -ida_hexrays.array_of_ivlsets.erase (method) - erase(self, it) -> ivlset_t - - @param it: qvector< ivlset_t >::iterator - - erase(self, first, last) -> ivlset_t - - @param first: qvector< ivlset_t >::iterator - @param last: qvector< ivlset_t >::iterator +ida_hexrays.array_of_ivlsets.clear(self) -> None -ida_hexrays.array_of_ivlsets.extract (method) - extract(self) -> ivlset_t +ida_hexrays.array_of_ivlsets.empty(self) -> bool -ida_hexrays.array_of_ivlsets.find (method) - find(self, x) -> ivlset_t - - @param x: ivlset_t const & +ida_hexrays.array_of_ivlsets.end(self, *args) -> "qvector< ivlset_t >::const_iterator" -ida_hexrays.array_of_ivlsets.grow (method) - grow(self, x=ivlset_t()) - - @param x: ivlset_t const & +ida_hexrays.array_of_ivlsets.erase(self, *args) -> "qvector< ivlset_t >::iterator" -ida_hexrays.array_of_ivlsets.has (method) - has(self, x) -> bool - - @param x: ivlset_t const & +ida_hexrays.array_of_ivlsets.extend(self, x: "array_of_ivlsets") -> None -ida_hexrays.array_of_ivlsets.inject (method) - inject(self, s, len) - - @param s: ivlset_t * - @param len: size_t +ida_hexrays.array_of_ivlsets.extract(self) -> "ivlset_t *" -ida_hexrays.array_of_ivlsets.insert (method) - insert(self, it, x) -> ivlset_t - - @param it: qvector< ivlset_t >::iterator - @param x: ivlset_t const & +ida_hexrays.array_of_ivlsets.find(self, *args) -> "qvector< ivlset_t >::const_iterator" -ida_hexrays.array_of_ivlsets.pop_back (method) - pop_back(self) +ida_hexrays.array_of_ivlsets.grow(self, *args) -> None -ida_hexrays.array_of_ivlsets.push_back (method) - push_back(self, x) - - @param x: ivlset_t const & - - push_back(self) -> ivlset_t +ida_hexrays.array_of_ivlsets.has(self, x: "ivlset_t") -> bool -ida_hexrays.array_of_ivlsets.qclear (method) - qclear(self) +ida_hexrays.array_of_ivlsets.inject(self, s: "ivlset_t", len: "size_t") -> None -ida_hexrays.array_of_ivlsets.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.array_of_ivlsets.insert(self, it: "ivlset_t", x: "ivlset_t") -> "qvector< ivlset_t >::iterator" -ida_hexrays.array_of_ivlsets.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ivlset_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.array_of_ivlsets.pop_back(self) -> None -ida_hexrays.array_of_ivlsets.size (method) - size(self) -> size_t +ida_hexrays.array_of_ivlsets.push_back(self, *args) -> "ivlset_t &" -ida_hexrays.array_of_ivlsets.swap (method) - swap(self, r) - - @param r: qvector< ivlset_t > & +ida_hexrays.array_of_ivlsets.qclear(self) -> None -ida_hexrays.array_of_ivlsets.truncate (method) - truncate(self) +ida_hexrays.array_of_ivlsets.reserve(self, cnt: "size_t") -> None -ida_hexrays.asgop (function) - asgop(cop) -> ctype_t - Convert plain operator into assignment operator. For example, cot_add returns - cot_asgadd. - - @param cop: (C++: ctype_t) enum ctype_t +ida_hexrays.array_of_ivlsets.resize(self, *args) -> None -ida_hexrays.asgop_revert (function) - asgop_revert(cop) -> ctype_t - Convert assignment operator into plain operator. For example, cot_asgadd returns - cot_add - - @param cop: (C++: ctype_t) enum ctype_t - @return: cot_empty is the input operator is not an assignment operator. +ida_hexrays.array_of_ivlsets.size(self) -> "size_t" -ida_hexrays.bit_bound_t (class) - Proxy of C++ bit_bound_t class. +ida_hexrays.array_of_ivlsets.swap(self, r: "array_of_ivlsets") -> None -ida_hexrays.bit_bound_t.__init__ (method) - __init__(self, n=0, s=0) -> bit_bound_t - - @param n: int - @param s: int +ida_hexrays.array_of_ivlsets.truncate(self) -> None -ida_hexrays.bitset_t (class) - Proxy of C++ bitset_t class. +ida_hexrays.array_of_node_bitset_t -ida_hexrays.bitset_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bitset_t const & +ida_hexrays.array_of_node_bitset_t.__init__(self) -ida_hexrays.bitset_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bitset_t const & +ida_hexrays.asgop(cop: "ctype_t") -> "ctype_t" + Convert plain operator into assignment operator. For example, cot_add returns cot_asgadd. -ida_hexrays.bitset_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bitset_t const & +ida_hexrays.asgop_revert(cop: "ctype_t") -> "ctype_t" + Convert assignment operator into plain operator. For example, cot_asgadd returns cot_add + + @returns cot_empty is the input operator is not an assignment operator. -ida_hexrays.bitset_t.__init__ (method) - __init__(self) -> bitset_t - __init__(self, m) -> bitset_t - - @param m: bitset_t const & +ida_hexrays.bit_bound_t -ida_hexrays.bitset_t.__iter__ (method) +ida_hexrays.bit_bound_t.__init__(self, n: int = 0, s: int = 0) -ida_hexrays.bitset_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bitset_t const & +ida_hexrays.bitset_t -ida_hexrays.bitset_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bitset_t const & +ida_hexrays.bitset_t.__eq__(self, r: "bitset_t") -> bool -ida_hexrays.bitset_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bitset_t const & +ida_hexrays.bitset_t.__ge__(self, r: "bitset_t") -> bool + +ida_hexrays.bitset_t.__gt__(self, r: "bitset_t") -> bool + +ida_hexrays.bitset_t.__init__(self, *args) + +ida_hexrays.bitset_t.__iter__(self) + +ida_hexrays.bitset_t.__le__(self, r: "bitset_t") -> bool + +ida_hexrays.bitset_t.__lt__(self, r: "bitset_t") -> bool + +ida_hexrays.bitset_t.__ne__(self, r: "bitset_t") -> bool -ida_hexrays.bitset_t.add (method) - add(self, bit) -> bool +ida_hexrays.bitset_t.add(self, *args) -> bool + This function has the following signatures: - @param bit: int + 0. add(bit: int) -> bool + 1. add(bit: int, width: int) -> bool + 2. add(ml: const bitset_t &) -> bool - add(self, bit, width) -> bool + # 0: add(bit: int) -> bool - @param bit: int - @param width: int - add(self, ml) -> bool + # 1: add(bit: int, width: int) -> bool - @param ml: bitset_t const & + + # 2: add(ml: const bitset_t &) -> bool -ida_hexrays.bitset_t.back (method) - back(self) -> int +ida_hexrays.bitset_t.back(self) -> int -ida_hexrays.bitset_t.begin (method) - begin(self) -> iterator +ida_hexrays.bitset_t.begin(self) -> "bitset_t::iterator" -ida_hexrays.bitset_t.clear (method) - clear(self) +ida_hexrays.bitset_t.clear(self) -> None -ida_hexrays.bitset_t.compare (method) - compare(self, r) -> int - - @param r: bitset_t const & +ida_hexrays.bitset_t.compare(self, r: "bitset_t") -> int -ida_hexrays.bitset_t.copy (method) - copy(self, m) -> bitset_t - - @param m: bitset_t const & +ida_hexrays.bitset_t.copy(self, m: "bitset_t") -> "bitset_t &" -ida_hexrays.bitset_t.count (method) - count(self) -> int - count(self, bit) -> int +ida_hexrays.bitset_t.count(self, *args) -> int + This function has the following signatures: + + 0. count() -> int + 1. count(bit: int) -> int + + # 0: count() -> int - @param bit: int - -ida_hexrays.bitset_t.cut_at (method) - cut_at(self, maxbit) -> bool - @param maxbit: int + # 1: count(bit: int) -> int -ida_hexrays.bitset_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.bitset_t.cut_at(self, maxbit: int) -> bool -ida_hexrays.bitset_t.empty (method) - empty(self) -> bool +ida_hexrays.bitset_t.dstr(self) -> str -ida_hexrays.bitset_t.end (method) - end(self) -> iterator +ida_hexrays.bitset_t.empty(self) -> bool -ida_hexrays.bitset_t.fill_with_ones (method) - fill_with_ones(self, maxbit) - - @param maxbit: int +ida_hexrays.bitset_t.end(self) -> "bitset_t::iterator" -ida_hexrays.bitset_t.front (method) - front(self) -> int +ida_hexrays.bitset_t.fill_with_ones(self, maxbit: int) -> None -ida_hexrays.bitset_t.has (method) - has(self, bit) -> bool - - @param bit: int +ida_hexrays.bitset_t.front(self) -> int -ida_hexrays.bitset_t.has_all (method) - has_all(self, bit, width) -> bool - - @param bit: int - @param width: int +ida_hexrays.bitset_t.has(self, bit: int) -> bool -ida_hexrays.bitset_t.has_any (method) - has_any(self, bit, width) -> bool - - @param bit: int - @param width: int +ida_hexrays.bitset_t.has_all(self, bit: int, width: int) -> bool -ida_hexrays.bitset_t.has_common (method) - has_common(self, ml) -> bool - - @param ml: bitset_t const & +ida_hexrays.bitset_t.has_any(self, bit: int, width: int) -> bool -ida_hexrays.bitset_t.inc (method) - inc(self, p, n=1) - - @param p: bitset_t::iterator & - @param n: int +ida_hexrays.bitset_t.has_common(self, ml: "bitset_t") -> bool -ida_hexrays.bitset_t.includes (method) - includes(self, ml) -> bool - - @param ml: bitset_t const & +ida_hexrays.bitset_t.inc(self, p: "iterator", n: int = 1) -> None -ida_hexrays.bitset_t.intersect (method) - intersect(self, ml) -> bool - - @param ml: bitset_t const & +ida_hexrays.bitset_t.includes(self, ml: "bitset_t") -> bool -ida_hexrays.bitset_t.is_subset_of (method) - is_subset_of(self, ml) -> bool - - @param ml: bitset_t const & +ida_hexrays.bitset_t.intersect(self, ml: "bitset_t") -> bool -ida_hexrays.bitset_t.itat (method) - itat(self, n) -> iterator - - @param n: int +ida_hexrays.bitset_t.is_subset_of(self, ml: "bitset_t") -> bool -ida_hexrays.bitset_t.itv (method) - itv(self, it) -> int - - @param it: bitset_t::const_iterator +ida_hexrays.bitset_t.itat(self, n: int) -> "bitset_t::iterator" -ida_hexrays.bitset_t.last (method) - last(self) -> int +ida_hexrays.bitset_t.itv(self, it: "iterator") -> int -ida_hexrays.bitset_t.shift_down (method) - shift_down(self, shift) - - @param shift: int +ida_hexrays.bitset_t.last(self) -> int + +ida_hexrays.bitset_t.shift_down(self, shift: int) -> None -ida_hexrays.bitset_t.sub (method) - sub(self, bit) -> bool +ida_hexrays.bitset_t.sub(self, *args) -> bool + This function has the following signatures: - @param bit: int + 0. sub(bit: int) -> bool + 1. sub(bit: int, width: int) -> bool + 2. sub(ml: const bitset_t &) -> bool - sub(self, bit, width) -> bool + # 0: sub(bit: int) -> bool - @param bit: int - @param width: int - sub(self, ml) -> bool + # 1: sub(bit: int, width: int) -> bool - @param ml: bitset_t const & - -ida_hexrays.bitset_t.swap (method) - swap(self, r) - @param r: bitset_t & + # 2: sub(ml: const bitset_t &) -> bool + +ida_hexrays.bitset_t.swap(self, r: "bitset_t") -> None -ida_hexrays.block_chains_begin (function) - block_chains_begin(set) -> block_chains_iterator_t +ida_hexrays.block_chains_begin(set: "block_chains_t") -> "block_chains_iterator_t" Get iterator pointing to the beginning of block_chains_t. - - @param set: (C++: const block_chains_t *) block_chains_t const * -ida_hexrays.block_chains_clear (function) - block_chains_clear(set) +ida_hexrays.block_chains_clear(set: "block_chains_t") -> None Clear block_chains_t. - - @param set: (C++: block_chains_t *) -ida_hexrays.block_chains_end (function) - block_chains_end(set) -> block_chains_iterator_t +ida_hexrays.block_chains_end(set: "block_chains_t") -> "block_chains_iterator_t" Get iterator pointing to the end of block_chains_t. - - @param set: (C++: const block_chains_t *) block_chains_t const * -ida_hexrays.block_chains_erase (function) - block_chains_erase(set, p) +ida_hexrays.block_chains_erase(set: "block_chains_t", p: "block_chains_iterator_t") -> None Erase current element from block_chains_t. - - @param set: (C++: block_chains_t *) - @param p: (C++: block_chains_iterator_t) -ida_hexrays.block_chains_find (function) - block_chains_find(set, val) -> block_chains_iterator_t +ida_hexrays.block_chains_find(set: "block_chains_t", val: "chain_t") -> "block_chains_iterator_t" Find the specified key in set block_chains_t. - - @param set: (C++: const block_chains_t *) block_chains_t const * - @param val: (C++: const chain_t &) chain_t const & -ida_hexrays.block_chains_free (function) - block_chains_free(set) +ida_hexrays.block_chains_free(set: "block_chains_t") -> None Delete block_chains_t instance. - - @param set: (C++: block_chains_t *) -ida_hexrays.block_chains_get (function) - block_chains_get(p) -> chain_t +ida_hexrays.block_chains_get(p: "block_chains_iterator_t") -> "chain_t &" Get reference to the current set value. - - @param p: (C++: block_chains_iterator_t) -ida_hexrays.block_chains_insert (function) - block_chains_insert(set, val) -> block_chains_iterator_t +ida_hexrays.block_chains_insert(set: "block_chains_t", val: "chain_t") -> "block_chains_iterator_t" Insert new (chain_t) into set block_chains_t. - - @param set: (C++: block_chains_t *) - @param val: (C++: const chain_t &) chain_t const & -ida_hexrays.block_chains_iterator_t (class) - Proxy of C++ block_chains_iterator_t class. +ida_hexrays.block_chains_iterator_t -ida_hexrays.block_chains_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: block_chains_iterator_t const & +ida_hexrays.block_chains_iterator_t.__eq__(self, p: "block_chains_iterator_t") -> bool -ida_hexrays.block_chains_iterator_t.__init__ (method) - __init__(self) -> block_chains_iterator_t +ida_hexrays.block_chains_iterator_t.__init__(self) -ida_hexrays.block_chains_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: block_chains_iterator_t const & +ida_hexrays.block_chains_iterator_t.__ne__(self, p: "block_chains_iterator_t") -> bool -ida_hexrays.block_chains_new (function) - block_chains_new() -> block_chains_t +ida_hexrays.block_chains_new() -> "block_chains_t *" Create a new block_chains_t instance. -ida_hexrays.block_chains_next (function) - block_chains_next(p) -> block_chains_iterator_t +ida_hexrays.block_chains_next(p: "block_chains_iterator_t") -> "block_chains_iterator_t" Move to the next element. - - @param p: (C++: block_chains_iterator_t) -ida_hexrays.block_chains_prev (function) - block_chains_prev(p) -> block_chains_iterator_t +ida_hexrays.block_chains_prev(p: "block_chains_iterator_t") -> "block_chains_iterator_t" Move to the previous element. - - @param p: (C++: block_chains_iterator_t) -ida_hexrays.block_chains_size (function) - block_chains_size(set) -> size_t +ida_hexrays.block_chains_size(set: "block_chains_t") -> "size_t" Get size of block_chains_t. + +ida_hexrays.block_chains_t + +ida_hexrays.block_chains_t.__init__(self) + +ida_hexrays.block_chains_t._print(self) -> None + +ida_hexrays.block_chains_t.dstr(self) -> str + +ida_hexrays.block_chains_t.get_chain(self, *args) -> "chain_t *" + This function has the following signatures: - @param set: (C++: block_chains_t *) - -ida_hexrays.block_chains_t (class) - Proxy of C++ block_chains_t class. - -ida_hexrays.block_chains_t.__init__ (method) - __init__(self) -> block_chains_t - -ida_hexrays.block_chains_t._print (method) - _print(self) - -ida_hexrays.block_chains_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.block_chains_t.get_chain (method) - get_chain(self, k, width=1) -> chain_t + 0. get_chain(k: const voff_t &, width: int=1) -> const chain_t * + 1. get_chain(k: const voff_t &, width: int=1) -> chain_t * + 2. get_chain(ch: const chain_t &) -> const chain_t * + 3. get_chain(ch: const chain_t &) -> chain_t * - @param k: voff_t const & - @param width: int + # 0: get_chain(k: const voff_t &, width: int=1) -> const chain_t * - get_chain(self, ch) -> chain_t + Get chain for the specified value offset. + - @param ch: chain_t const & - -ida_hexrays.block_chains_t.get_reg_chain (method) - get_reg_chain(self, reg, width=1) -> chain_t + # 1: get_chain(k: const voff_t &, width: int=1) -> chain_t * - @param reg: mreg_t - @param width: int - -ida_hexrays.block_chains_t.get_stk_chain (method) - get_stk_chain(self, off, width=1) -> chain_t - @param off: sval_t - @param width: int - -ida_hexrays.block_chains_vec_t (class) - Proxy of C++ qvector< block_chains_t > class. - -ida_hexrays.block_chains_vec_t.__getitem__ (method) - __getitem__(self, i) -> block_chains_t + # 2: get_chain(ch: const chain_t &) -> const chain_t * - @param i: size_t - -ida_hexrays.block_chains_vec_t.__init__ (method) - __init__(self) -> block_chains_vec_t - __init__(self, x) -> block_chains_vec_t + Get chain similar to the specified chain + - @param x: qvector< block_chains_t > const & + # 3: get_chain(ch: const chain_t &) -> chain_t * -ida_hexrays.block_chains_vec_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.block_chains_t.get_reg_chain(self, reg: "mreg_t", width: int = 1) -> "chain_t *" + Get chain for the specified register + + @param reg: register number + @param width: size of register in bytes -ida_hexrays.block_chains_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: block_chains_t const & +ida_hexrays.block_chains_t.get_stk_chain(self, off: int, width: int = 1) -> "chain_t *" + Get chain for the specified stack offset + + @param off: stack offset + @param width: size of stack value in bytes -ida_hexrays.block_chains_vec_t.at (method) - at(self, _idx) -> block_chains_t - - @param _idx: size_t +ida_hexrays.block_chains_vec_t -ida_hexrays.block_chains_vec_t.begin (method) - begin(self) -> block_chains_t +ida_hexrays.block_chains_vec_t.__getitem__(self, i: "size_t") -> "block_chains_t const &" -ida_hexrays.block_chains_vec_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.block_chains_vec_t.__init__(self, *args) -ida_hexrays.block_chains_vec_t.clear (method) - clear(self) +ida_hexrays.block_chains_vec_t.__len__(self) -> "size_t" -ida_hexrays.block_chains_vec_t.empty (method) - empty(self) -> bool +ida_hexrays.block_chains_vec_t.__setitem__(self, i: "size_t", v: "block_chains_t") -> None -ida_hexrays.block_chains_vec_t.end (method) - end(self) -> block_chains_t +ida_hexrays.block_chains_vec_t.append(self, x: "block_chains_t") -> None -ida_hexrays.block_chains_vec_t.erase (method) - erase(self, it) -> block_chains_t - - @param it: qvector< block_chains_t >::iterator - - erase(self, first, last) -> block_chains_t - - @param first: qvector< block_chains_t >::iterator - @param last: qvector< block_chains_t >::iterator +ida_hexrays.block_chains_vec_t.at(self, _idx: "size_t") -> "block_chains_t const &" -ida_hexrays.block_chains_vec_t.extract (method) - extract(self) -> block_chains_t +ida_hexrays.block_chains_vec_t.begin(self, *args) -> "qvector< block_chains_t >::const_iterator" -ida_hexrays.block_chains_vec_t.grow (method) - grow(self, x=block_chains_t()) - - @param x: block_chains_t const & +ida_hexrays.block_chains_vec_t.capacity(self) -> "size_t" -ida_hexrays.block_chains_vec_t.inject (method) - inject(self, s, len) - - @param s: block_chains_t * - @param len: size_t +ida_hexrays.block_chains_vec_t.clear(self) -> None -ida_hexrays.block_chains_vec_t.insert (method) - insert(self, it, x) -> block_chains_t - - @param it: qvector< block_chains_t >::iterator - @param x: block_chains_t const & +ida_hexrays.block_chains_vec_t.empty(self) -> bool -ida_hexrays.block_chains_vec_t.pop_back (method) - pop_back(self) +ida_hexrays.block_chains_vec_t.end(self, *args) -> "qvector< block_chains_t >::const_iterator" -ida_hexrays.block_chains_vec_t.push_back (method) - push_back(self, x) - - @param x: block_chains_t const & - - push_back(self) -> block_chains_t +ida_hexrays.block_chains_vec_t.erase(self, *args) -> "qvector< block_chains_t >::iterator" -ida_hexrays.block_chains_vec_t.qclear (method) - qclear(self) +ida_hexrays.block_chains_vec_t.extend(self, x: "block_chains_vec_t") -> None -ida_hexrays.block_chains_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.block_chains_vec_t.extract(self) -> "block_chains_t *" -ida_hexrays.block_chains_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: block_chains_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.block_chains_vec_t.grow(self, *args) -> None -ida_hexrays.block_chains_vec_t.size (method) - size(self) -> size_t +ida_hexrays.block_chains_vec_t.inject(self, s: "block_chains_t", len: "size_t") -> None -ida_hexrays.block_chains_vec_t.swap (method) - swap(self, r) - - @param r: qvector< block_chains_t > & +ida_hexrays.block_chains_vec_t.insert(self, it: "block_chains_t", x: "block_chains_t") -> "qvector< block_chains_t >::iterator" -ida_hexrays.block_chains_vec_t.truncate (method) - truncate(self) +ida_hexrays.block_chains_vec_t.pop_back(self) -> None -ida_hexrays.boundaries_begin (function) - boundaries_begin(map) -> boundaries_iterator_t +ida_hexrays.block_chains_vec_t.push_back(self, *args) -> "block_chains_t &" + +ida_hexrays.block_chains_vec_t.qclear(self) -> None + +ida_hexrays.block_chains_vec_t.reserve(self, cnt: "size_t") -> None + +ida_hexrays.block_chains_vec_t.resize(self, *args) -> None + +ida_hexrays.block_chains_vec_t.size(self) -> "size_t" + +ida_hexrays.block_chains_vec_t.swap(self, r: "block_chains_vec_t") -> None + +ida_hexrays.block_chains_vec_t.truncate(self) -> None + +ida_hexrays.boundaries_begin(map: "boundaries_t") -> "boundaries_iterator_t" Get iterator pointing to the beginning of boundaries_t. - - @param map: (C++: const boundaries_t *) boundaries_t const * -ida_hexrays.boundaries_clear (function) - boundaries_clear(map) +ida_hexrays.boundaries_clear(map: "boundaries_t") -> None Clear boundaries_t. - - @param map: (C++: boundaries_t *) -ida_hexrays.boundaries_end (function) - boundaries_end(map) -> boundaries_iterator_t +ida_hexrays.boundaries_end(map: "boundaries_t") -> "boundaries_iterator_t" Get iterator pointing to the end of boundaries_t. - - @param map: (C++: const boundaries_t *) boundaries_t const * -ida_hexrays.boundaries_erase (function) - boundaries_erase(map, p) +ida_hexrays.boundaries_erase(map: "boundaries_t", p: "boundaries_iterator_t") -> None Erase current element from boundaries_t. - - @param map: (C++: boundaries_t *) - @param p: (C++: boundaries_iterator_t) -ida_hexrays.boundaries_find (function) - boundaries_find(map, key) -> boundaries_iterator_t +ida_hexrays.boundaries_find(map: "boundaries_t", key: "cinsn_t") -> "boundaries_iterator_t" Find the specified key in boundaries_t. - - @param map: (C++: const boundaries_t *) boundaries_t const * - @param key: (C++: const cinsn_t *&) cinsn_t const * -ida_hexrays.boundaries_first (function) - boundaries_first(p) -> cinsn_t +ida_hexrays.boundaries_first(p: "boundaries_iterator_t") -> "cinsn_t *const &" Get reference to the current map key. - - @param p: (C++: boundaries_iterator_t) -ida_hexrays.boundaries_free (function) - boundaries_free(map) +ida_hexrays.boundaries_free(map: "boundaries_t") -> None Delete boundaries_t instance. - - @param map: (C++: boundaries_t *) -ida_hexrays.boundaries_insert (function) - boundaries_insert(map, key, val) -> boundaries_iterator_t +ida_hexrays.boundaries_insert(map: "boundaries_t", key: "cinsn_t", val: "rangeset_t") -> "boundaries_iterator_t" Insert new (cinsn_t *, rangeset_t) pair into boundaries_t. - - @param map: (C++: boundaries_t *) - @param key: (C++: const cinsn_t *&) cinsn_t const * - @param val: (C++: const rangeset_t &) rangeset_t const & -ida_hexrays.boundaries_iterator_t (class) - Proxy of C++ boundaries_iterator_t class. +ida_hexrays.boundaries_iterator_t -ida_hexrays.boundaries_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: boundaries_iterator_t const & +ida_hexrays.boundaries_iterator_t.__eq__(self, p: "boundaries_iterator_t") -> bool -ida_hexrays.boundaries_iterator_t.__init__ (method) - __init__(self) -> boundaries_iterator_t +ida_hexrays.boundaries_iterator_t.__init__(self) -ida_hexrays.boundaries_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: boundaries_iterator_t const & +ida_hexrays.boundaries_iterator_t.__ne__(self, p: "boundaries_iterator_t") -> bool -ida_hexrays.boundaries_new (function) - boundaries_new() -> boundaries_t +ida_hexrays.boundaries_new() -> "boundaries_t *" Create a new boundaries_t instance. -ida_hexrays.boundaries_next (function) - boundaries_next(p) -> boundaries_iterator_t +ida_hexrays.boundaries_next(p: "boundaries_iterator_t") -> "boundaries_iterator_t" Move to the next element. - - @param p: (C++: boundaries_iterator_t) -ida_hexrays.boundaries_prev (function) - boundaries_prev(p) -> boundaries_iterator_t +ida_hexrays.boundaries_prev(p: "boundaries_iterator_t") -> "boundaries_iterator_t" Move to the previous element. - - @param p: (C++: boundaries_iterator_t) -ida_hexrays.boundaries_second (function) - boundaries_second(p) -> rangeset_t +ida_hexrays.boundaries_second(p: "boundaries_iterator_t") -> "rangeset_t &" Get reference to the current map value. - - @param p: (C++: boundaries_iterator_t) -ida_hexrays.boundaries_size (function) - boundaries_size(map) -> size_t +ida_hexrays.boundaries_size(map: "boundaries_t") -> "size_t" Get size of boundaries_t. - - @param map: (C++: boundaries_t *) -ida_hexrays.boundaries_t (class) - Proxy of C++ std::map< cinsn_t *,rangeset_t > class. +ida_hexrays.boundaries_t -ida_hexrays.boundaries_t.__init__ (method) - __init__(self) -> boundaries_t +ida_hexrays.boundaries_t.__init__(self) -ida_hexrays.boundaries_t.at (method) - at(self, _Keyval) -> rangeset_t - - @param _Keyval: cinsn_t *const & +ida_hexrays.boundaries_t.at(self, _Keyval: "cinsn_t") -> "rangeset_t &" -ida_hexrays.boundaries_t.size (method) - size(self) -> size_t +ida_hexrays.boundaries_t.size(self) -> "size_t" -ida_hexrays.call_helper (function) +ida_hexrays.call_helper(rettype, args, *rest) Create a helper call. -ida_hexrays.carg_t (class) - Proxy of C++ carg_t class. +ida_hexrays.carg_t -ida_hexrays.carg_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: carg_t const & +ida_hexrays.carg_t.__eq__(self, r: "carg_t") -> bool -ida_hexrays.carg_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: carg_t const & +ida_hexrays.carg_t.__ge__(self, r: "carg_t") -> bool -ida_hexrays.carg_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: carg_t const & +ida_hexrays.carg_t.__gt__(self, r: "carg_t") -> bool -ida_hexrays.carg_t.__init__ (method) - __init__(self) -> carg_t +ida_hexrays.carg_t.__init__(self) -ida_hexrays.carg_t.__le__ (method) - __le__(self, r) -> bool - - @param r: carg_t const & +ida_hexrays.carg_t.__le__(self, r: "carg_t") -> bool -ida_hexrays.carg_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: carg_t const & +ida_hexrays.carg_t.__lt__(self, r: "carg_t") -> bool -ida_hexrays.carg_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: carg_t const & +ida_hexrays.carg_t.__ne__(self, r: "carg_t") -> bool -ida_hexrays.carg_t.compare (method) - compare(self, r) -> int - - @param r: carg_t const & +ida_hexrays.carg_t.compare(self, r: "carg_t") -> int -ida_hexrays.carg_t.consume_cexpr (method) - consume_cexpr(self, e) - - @param e: cexpr_t * +ida_hexrays.carg_t.consume_cexpr(self, e: "cexpr_t") -> None -ida_hexrays.carg_t.formal_type (variable) +ida_hexrays.carg_t.formal_type formal parameter type (if known) -ida_hexrays.carg_t.is_vararg (variable) +ida_hexrays.carg_t.is_vararg is a vararg (matches ...) -ida_hexrays.carglist_t (class) - Proxy of C++ carglist_t class. +ida_hexrays.carglist_t -ida_hexrays.carglist_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: carglist_t const & +ida_hexrays.carglist_t.__eq__(self, r: "carglist_t") -> bool -ida_hexrays.carglist_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: carglist_t const & +ida_hexrays.carglist_t.__ge__(self, r: "carglist_t") -> bool -ida_hexrays.carglist_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: carglist_t const & +ida_hexrays.carglist_t.__gt__(self, r: "carglist_t") -> bool -ida_hexrays.carglist_t.__init__ (method) - __init__(self) -> carglist_t - __init__(self, ftype, fl=0) -> carglist_t - - @param ftype: tinfo_t const & - @param fl: int +ida_hexrays.carglist_t.__init__(self, *args) -ida_hexrays.carglist_t.__le__ (method) - __le__(self, r) -> bool - - @param r: carglist_t const & +ida_hexrays.carglist_t.__le__(self, r: "carglist_t") -> bool -ida_hexrays.carglist_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: carglist_t const & +ida_hexrays.carglist_t.__lt__(self, r: "carglist_t") -> bool -ida_hexrays.carglist_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: carglist_t const & +ida_hexrays.carglist_t.__ne__(self, r: "carglist_t") -> bool -ida_hexrays.carglist_t.compare (method) - compare(self, r) -> int - - @param r: carglist_t const & +ida_hexrays.carglist_t.compare(self, r: "carglist_t") -> int -ida_hexrays.carglist_t.flags (variable) +ida_hexrays.carglist_t.flags call flags -ida_hexrays.carglist_t.functype (variable) +ida_hexrays.carglist_t.functype function object type -ida_hexrays.casm_t (class) - Proxy of C++ casm_t class. +ida_hexrays.casm_t -ida_hexrays.casm_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: casm_t const & +ida_hexrays.casm_t.__eq__(self, r: "casm_t") -> bool -ida_hexrays.casm_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: casm_t const & +ida_hexrays.casm_t.__ge__(self, r: "casm_t") -> bool -ida_hexrays.casm_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: casm_t const & +ida_hexrays.casm_t.__gt__(self, r: "casm_t") -> bool -ida_hexrays.casm_t.__init__ (method) - __init__(self, ea) -> casm_t - - @param ea: ea_t - - __init__(self, r) -> casm_t - - @param r: casm_t const & +ida_hexrays.casm_t.__init__(self, *args) -ida_hexrays.casm_t.__le__ (method) - __le__(self, r) -> bool - - @param r: casm_t const & +ida_hexrays.casm_t.__le__(self, r: "casm_t") -> bool -ida_hexrays.casm_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: casm_t const & +ida_hexrays.casm_t.__lt__(self, r: "casm_t") -> bool -ida_hexrays.casm_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: casm_t const & +ida_hexrays.casm_t.__ne__(self, r: "casm_t") -> bool -ida_hexrays.casm_t.compare (method) - compare(self, r) -> int - - @param r: casm_t const & +ida_hexrays.casm_t.compare(self, r: "casm_t") -> int -ida_hexrays.casm_t.one_insn (method) - one_insn(self) -> bool +ida_hexrays.casm_t.one_insn(self) -> bool -ida_hexrays.cblock_t (class) - Proxy of C++ cblock_t class. +ida_hexrays.catchexpr_t -ida_hexrays.cblock_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cblock_t const & +ida_hexrays.catchexpr_t.__eq__(self, r: "catchexpr_t") -> bool -ida_hexrays.cblock_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cblock_t const & +ida_hexrays.catchexpr_t.__ge__(self, r: "catchexpr_t") -> bool -ida_hexrays.cblock_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cblock_t const & +ida_hexrays.catchexpr_t.__gt__(self, r: "catchexpr_t") -> bool -ida_hexrays.cblock_t.__init__ (method) - __init__(self) -> cblock_t +ida_hexrays.catchexpr_t.__init__(self) -ida_hexrays.cblock_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cblock_t const & +ida_hexrays.catchexpr_t.__le__(self, r: "catchexpr_t") -> bool -ida_hexrays.cblock_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cblock_t const & +ida_hexrays.catchexpr_t.__lt__(self, r: "catchexpr_t") -> bool -ida_hexrays.cblock_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cblock_t const & +ida_hexrays.catchexpr_t.__ne__(self, r: "catchexpr_t") -> bool -ida_hexrays.cblock_t._deregister (method) - _deregister(self) +ida_hexrays.catchexpr_t.compare(self, r: "catchexpr_t") -> int -ida_hexrays.cblock_t.compare (method) - compare(self, r) -> int - - @param r: cblock_t const & +ida_hexrays.catchexpr_t.fake_type + if not empty, type of the caught object. ideally, obj.type should be enough. however, in some cases the detailed type info is not available. + -ida_hexrays.ccase_t (class) - Proxy of C++ ccase_t class. +ida_hexrays.catchexpr_t.is_catch_all(self) -> bool -ida_hexrays.ccase_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ccase_t const & +ida_hexrays.catchexpr_t.obj + the caught object. if obj.op==cot_empty, no object. ideally, obj.op==cot_var + -ida_hexrays.ccase_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ccase_t const & +ida_hexrays.catchexpr_t.swap(self, r: "catchexpr_t") -> None -ida_hexrays.ccase_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ccase_t const & +ida_hexrays.cblock_pos_t -ida_hexrays.ccase_t.__init__ (method) - __init__(self) -> ccase_t +ida_hexrays.cblock_pos_t.__init__(self) -ida_hexrays.ccase_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ccase_t const & +ida_hexrays.cblock_pos_t.insn(self) -> "cinsn_t *" -ida_hexrays.ccase_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ccase_t const & +ida_hexrays.cblock_pos_t.is_first_insn(self) -> bool -ida_hexrays.ccase_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ccase_t const & +ida_hexrays.cblock_pos_t.prev_insn(self) -> "cinsn_t *" -ida_hexrays.ccase_t.compare (method) - compare(self, r) -> int - - @param r: ccase_t const & +ida_hexrays.cblock_posvec_t -ida_hexrays.ccase_t.size (method) - size(self) -> size_t +ida_hexrays.cblock_posvec_t.__getitem__(self, i: "size_t") -> "cblock_pos_t const &" -ida_hexrays.ccase_t.value (method) - value(self, i) -> uint64 const & - - @param i: int +ida_hexrays.cblock_posvec_t.__init__(self, *args) -ida_hexrays.ccase_t.values (variable) - List of case values. if empty, then 'default' case +ida_hexrays.cblock_posvec_t.__len__(self) -> "size_t" -ida_hexrays.ccases_t (class) - Proxy of C++ ccases_t class. +ida_hexrays.cblock_posvec_t.__setitem__(self, i: "size_t", v: "cblock_pos_t") -> None -ida_hexrays.ccases_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ccases_t const & +ida_hexrays.cblock_posvec_t.append(self, x: "cblock_pos_t") -> None -ida_hexrays.ccases_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ccases_t const & +ida_hexrays.cblock_posvec_t.at(self, _idx: "size_t") -> "cblock_pos_t const &" -ida_hexrays.ccases_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ccases_t const & +ida_hexrays.cblock_posvec_t.begin(self, *args) -> "qvector< cblock_pos_t >::const_iterator" -ida_hexrays.ccases_t.__init__ (method) - __init__(self) -> ccases_t +ida_hexrays.cblock_posvec_t.capacity(self) -> "size_t" -ida_hexrays.ccases_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ccases_t const & +ida_hexrays.cblock_posvec_t.clear(self) -> None -ida_hexrays.ccases_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ccases_t const & +ida_hexrays.cblock_posvec_t.empty(self) -> bool -ida_hexrays.ccases_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ccases_t const & +ida_hexrays.cblock_posvec_t.end(self, *args) -> "qvector< cblock_pos_t >::const_iterator" -ida_hexrays.ccases_t.compare (method) - compare(self, r) -> int - - @param r: ccases_t const & +ida_hexrays.cblock_posvec_t.erase(self, *args) -> "qvector< cblock_pos_t >::iterator" -ida_hexrays.cdg_insn_iterator_t (class) - Proxy of C++ cdg_insn_iterator_t class. +ida_hexrays.cblock_posvec_t.extend(self, x: "cblock_posvec_t") -> None -ida_hexrays.cdg_insn_iterator_t.__init__ (method) - __init__(self, mba_) -> cdg_insn_iterator_t - - @param mba_: mba_t const * - - __init__(self, r) -> cdg_insn_iterator_t - - @param r: cdg_insn_iterator_t const & +ida_hexrays.cblock_posvec_t.extract(self) -> "cblock_pos_t *" -ida_hexrays.cdg_insn_iterator_t.dslot_with_xrefs (method) - dslot_with_xrefs(self) -> bool +ida_hexrays.cblock_posvec_t.grow(self, *args) -> None -ida_hexrays.cdg_insn_iterator_t.has_dslot (method) - has_dslot(self) -> bool +ida_hexrays.cblock_posvec_t.inject(self, s: "cblock_pos_t", len: "size_t") -> None -ida_hexrays.cdg_insn_iterator_t.is_severed_dslot (method) - is_severed_dslot(self) -> bool +ida_hexrays.cblock_posvec_t.insert(self, it: "cblock_pos_t", x: "cblock_pos_t") -> "qvector< cblock_pos_t >::iterator" -ida_hexrays.cdg_insn_iterator_t.next (method) - next(self, ins) -> merror_t - - @param ins: insn_t * +ida_hexrays.cblock_posvec_t.pop_back(self) -> None -ida_hexrays.cdg_insn_iterator_t.ok (method) - ok(self) -> bool +ida_hexrays.cblock_posvec_t.push_back(self, *args) -> "cblock_pos_t &" -ida_hexrays.cdg_insn_iterator_t.start (method) - start(self, rng) - - @param rng: range_t const & +ida_hexrays.cblock_posvec_t.qclear(self) -> None -ida_hexrays.cdo_t (class) - Proxy of C++ cdo_t class. +ida_hexrays.cblock_posvec_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.cdo_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cdo_t const & +ida_hexrays.cblock_posvec_t.resize(self, *args) -> None -ida_hexrays.cdo_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cdo_t const & +ida_hexrays.cblock_posvec_t.size(self) -> "size_t" -ida_hexrays.cdo_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cdo_t const & +ida_hexrays.cblock_posvec_t.swap(self, r: "cblock_posvec_t") -> None -ida_hexrays.cdo_t.__init__ (method) - __init__(self) -> cdo_t +ida_hexrays.cblock_posvec_t.truncate(self) -> None -ida_hexrays.cdo_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cdo_t const & +ida_hexrays.cblock_t -ida_hexrays.cdo_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cdo_t const & +ida_hexrays.cblock_t.__eq__(self, r: "cblock_t") -> bool -ida_hexrays.cdo_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cdo_t const & +ida_hexrays.cblock_t.__ge__(self, r: "cblock_t") -> bool -ida_hexrays.cdo_t.compare (method) - compare(self, r) -> int - - @param r: cdo_t const & +ida_hexrays.cblock_t.__gt__(self, r: "cblock_t") -> bool -ida_hexrays.ceinsn_t (class) - Proxy of C++ ceinsn_t class. +ida_hexrays.cblock_t.__init__(self) -ida_hexrays.ceinsn_t.__init__ (method) - __init__(self) -> ceinsn_t +ida_hexrays.cblock_t.__le__(self, r: "cblock_t") -> bool -ida_hexrays.ceinsn_t.expr (variable) +ida_hexrays.cblock_t.__lt__(self, r: "cblock_t") -> bool + +ida_hexrays.cblock_t.__ne__(self, r: "cblock_t") -> bool + +ida_hexrays.cblock_t._deregister(self) -> None + +ida_hexrays.cblock_t.compare(self, r: "cblock_t") -> int + +ida_hexrays.ccase_t + +ida_hexrays.ccase_t.__eq__(self, r: "ccase_t") -> bool + +ida_hexrays.ccase_t.__ge__(self, r: "ccase_t") -> bool + +ida_hexrays.ccase_t.__gt__(self, r: "ccase_t") -> bool + +ida_hexrays.ccase_t.__init__(self) + +ida_hexrays.ccase_t.__le__(self, r: "ccase_t") -> bool + +ida_hexrays.ccase_t.__lt__(self, r: "ccase_t") -> bool + +ida_hexrays.ccase_t.__ne__(self, r: "ccase_t") -> bool + +ida_hexrays.ccase_t.compare(self, r: "ccase_t") -> int + +ida_hexrays.ccase_t.size(self) -> "size_t" + +ida_hexrays.ccase_t.value(self, i: int) -> "uint64 const &" + +ida_hexrays.ccase_t.values + List of case values. if empty, then 'default' case + + +ida_hexrays.ccases_t + +ida_hexrays.ccases_t.__eq__(self, r: "ccases_t") -> bool + +ida_hexrays.ccases_t.__ge__(self, r: "ccases_t") -> bool + +ida_hexrays.ccases_t.__gt__(self, r: "ccases_t") -> bool + +ida_hexrays.ccases_t.__init__(self) + +ida_hexrays.ccases_t.__le__(self, r: "ccases_t") -> bool + +ida_hexrays.ccases_t.__lt__(self, r: "ccases_t") -> bool + +ida_hexrays.ccases_t.__ne__(self, r: "ccases_t") -> bool + +ida_hexrays.ccases_t.compare(self, r: "ccases_t") -> int + +ida_hexrays.ccatch_t + +ida_hexrays.ccatch_t.__eq__(self, r: "ccatch_t") -> bool + +ida_hexrays.ccatch_t.__ge__(self, r: "ccatch_t") -> bool + +ida_hexrays.ccatch_t.__gt__(self, r: "ccatch_t") -> bool + +ida_hexrays.ccatch_t.__init__(self, *args, **kwargs) + +ida_hexrays.ccatch_t.__le__(self, r: "ccatch_t") -> bool + +ida_hexrays.ccatch_t.__lt__(self, r: "ccatch_t") -> bool + +ida_hexrays.ccatch_t.__ne__(self, r: "ccatch_t") -> bool + +ida_hexrays.ccatch_t.compare(self, r: "ccatch_t") -> int + +ida_hexrays.ccatch_t.is_catch_all(self) -> bool + +ida_hexrays.ccatch_t.swap(self, r: "ccatch_t") -> None + +ida_hexrays.cdg_insn_iterator_t + +ida_hexrays.cdg_insn_iterator_t.__init__(self, *args) + +ida_hexrays.cdg_insn_iterator_t.dslot_with_xrefs(self) -> bool + +ida_hexrays.cdg_insn_iterator_t.has_dslot(self) -> bool + +ida_hexrays.cdg_insn_iterator_t.is_severed_dslot(self) -> bool + +ida_hexrays.cdg_insn_iterator_t.next(self, ins: "insn_t *") -> "merror_t" + +ida_hexrays.cdg_insn_iterator_t.ok(self) -> bool + +ida_hexrays.cdg_insn_iterator_t.start(self, rng: "range_t") -> None + +ida_hexrays.cdo_t + +ida_hexrays.cdo_t.__eq__(self, r: "cdo_t") -> bool + +ida_hexrays.cdo_t.__ge__(self, r: "cdo_t") -> bool + +ida_hexrays.cdo_t.__gt__(self, r: "cdo_t") -> bool + +ida_hexrays.cdo_t.__init__(self) + +ida_hexrays.cdo_t.__le__(self, r: "cdo_t") -> bool + +ida_hexrays.cdo_t.__lt__(self, r: "cdo_t") -> bool + +ida_hexrays.cdo_t.__ne__(self, r: "cdo_t") -> bool + +ida_hexrays.cdo_t.compare(self, r: "cdo_t") -> int + +ida_hexrays.ceinsn_t + +ida_hexrays.ceinsn_t.__init__(self) + +ida_hexrays.ceinsn_t.expr Expression of the statement. -ida_hexrays.cexpr_operands (function) +ida_hexrays.cexpr_operands(self) return a dictionary with the operands of a cexpr_t. -ida_hexrays.cexpr_t (class) - Proxy of C++ cexpr_t class. +ida_hexrays.cexpr_t -ida_hexrays.cexpr_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.__eq__(self, r: "cexpr_t") -> bool -ida_hexrays.cexpr_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.__ge__(self, r: "cexpr_t") -> bool -ida_hexrays.cexpr_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.__gt__(self, r: "cexpr_t") -> bool -ida_hexrays.cexpr_t.__init__ (method) - __init__(self) -> cexpr_t - __init__(self, cexpr_op, _x, _y=None, _z=None) -> cexpr_t - - @param cexpr_op: enum ctype_t - @param _x: cexpr_t * - @param _y: cexpr_t * - @param _z: cexpr_t * - - __init__(self, r) -> cexpr_t - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.__init__(self, *args) -ida_hexrays.cexpr_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.__le__(self, r: "cexpr_t") -> bool -ida_hexrays.cexpr_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.__lt__(self, r: "cexpr_t") -> bool -ida_hexrays.cexpr_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.__ne__(self, r: "cexpr_t") -> bool -ida_hexrays.cexpr_t._deregister (method) - _deregister(self) +ida_hexrays.cexpr_t._deregister(self) -> None -ida_hexrays.cexpr_t._get_a (method) - _get_a(self) -> carglist_t +ida_hexrays.cexpr_t._get_a(self) -> "carglist_t *" -ida_hexrays.cexpr_t._get_fpc (method) - _get_fpc(self) -> fnumber_t +ida_hexrays.cexpr_t._get_fpc(self) -> "fnumber_t *" -ida_hexrays.cexpr_t._get_helper (method) - _get_helper(self) -> char const * +ida_hexrays.cexpr_t._get_helper(self) -> str -ida_hexrays.cexpr_t._get_insn (method) - _get_insn(self) -> cinsn_t +ida_hexrays.cexpr_t._get_insn(self) -> "cinsn_t *" -ida_hexrays.cexpr_t._get_m (method) - _get_m(self) -> int +ida_hexrays.cexpr_t._get_m(self) -> int -ida_hexrays.cexpr_t._get_n (method) - _get_n(self) -> cnumber_t +ida_hexrays.cexpr_t._get_n(self) -> "cnumber_t *" -ida_hexrays.cexpr_t._get_obj_ea (method) - _get_obj_ea(self) -> ea_t +ida_hexrays.cexpr_t._get_obj_ea(self) -> ida_idaapi.ea_t -ida_hexrays.cexpr_t._get_ptrsize (method) - _get_ptrsize(self) -> int +ida_hexrays.cexpr_t._get_ptrsize(self) -> int -ida_hexrays.cexpr_t._get_refwidth (method) - _get_refwidth(self) -> int +ida_hexrays.cexpr_t._get_refwidth(self) -> int -ida_hexrays.cexpr_t._get_string (method) - _get_string(self) -> char const * +ida_hexrays.cexpr_t._get_string(self) -> str -ida_hexrays.cexpr_t._get_x (method) - _get_x(self) -> cexpr_t +ida_hexrays.cexpr_t._get_x(self) -> "cexpr_t *" -ida_hexrays.cexpr_t._get_y (method) - _get_y(self) -> cexpr_t +ida_hexrays.cexpr_t._get_y(self) -> "cexpr_t *" -ida_hexrays.cexpr_t._get_z (method) - _get_z(self) -> cexpr_t +ida_hexrays.cexpr_t._get_z(self) -> "cexpr_t *" -ida_hexrays.cexpr_t._register (method) - _register(self) +ida_hexrays.cexpr_t._register(self) -> None -ida_hexrays.cexpr_t._replace_by (method) - _replace_by(self, r) - - Parameters - ---------- - r: cexpr_t * +ida_hexrays.cexpr_t._replace_by(self, r: "cexpr_t") -> None -ida_hexrays.cexpr_t._set_a (method) - _set_a(self, _v) - - Parameters - ---------- - _v: carglist_t * +ida_hexrays.cexpr_t._set_a(self, _v: "carglist_t") -> None -ida_hexrays.cexpr_t._set_fpc (method) - _set_fpc(self, _v) - - Parameters - ---------- - _v: fnumber_t * +ida_hexrays.cexpr_t._set_fpc(self, _v: "fnumber_t") -> None -ida_hexrays.cexpr_t._set_helper (method) - _set_helper(self, _v) - - Parameters - ---------- - _v: char const * +ida_hexrays.cexpr_t._set_helper(self, _v: str) -> None -ida_hexrays.cexpr_t._set_insn (method) - _set_insn(self, _v) - - Parameters - ---------- - _v: cinsn_t * +ida_hexrays.cexpr_t._set_insn(self, _v: "cinsn_t") -> None -ida_hexrays.cexpr_t._set_m (method) - _set_m(self, _v) - - Parameters - ---------- - _v: int +ida_hexrays.cexpr_t._set_m(self, _v: int) -> None -ida_hexrays.cexpr_t._set_n (method) - _set_n(self, _v) - - Parameters - ---------- - _v: cnumber_t * +ida_hexrays.cexpr_t._set_n(self, _v: "cnumber_t") -> None -ida_hexrays.cexpr_t._set_obj_ea (method) - _set_obj_ea(self, _v) - - Parameters - ---------- - _v: ea_t +ida_hexrays.cexpr_t._set_obj_ea(self, _v: ida_idaapi.ea_t) -> None -ida_hexrays.cexpr_t._set_ptrsize (method) - _set_ptrsize(self, _v) - - Parameters - ---------- - _v: int +ida_hexrays.cexpr_t._set_ptrsize(self, _v: int) -> None -ida_hexrays.cexpr_t._set_refwidth (method) - _set_refwidth(self, _v) - - Parameters - ---------- - _v: int +ida_hexrays.cexpr_t._set_refwidth(self, _v: int) -> None -ida_hexrays.cexpr_t._set_string (method) - _set_string(self, _v) - - Parameters - ---------- - _v: char const * +ida_hexrays.cexpr_t._set_string(self, _v: str) -> None -ida_hexrays.cexpr_t._set_x (method) - _set_x(self, _v) - - Parameters - ---------- - _v: cexpr_t * +ida_hexrays.cexpr_t._set_x(self, _v: "cexpr_t") -> None -ida_hexrays.cexpr_t._set_y (method) - _set_y(self, _v) - - Parameters - ---------- - _v: cexpr_t * +ida_hexrays.cexpr_t._set_y(self, _v: "cexpr_t") -> None -ida_hexrays.cexpr_t._set_z (method) - _set_z(self, _v) - - Parameters - ---------- - _v: cexpr_t * +ida_hexrays.cexpr_t._set_z(self, _v: "cexpr_t") -> None -ida_hexrays.cexpr_t.a (variable) +ida_hexrays.cexpr_t.a argument list (used for cot_call) -ida_hexrays.cexpr_t.assign (method) - assign(self, r) -> cexpr_t - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.assign(self, r: "cexpr_t") -> "cexpr_t &" -ida_hexrays.cexpr_t.calc_type (method) - calc_type(self, recursive) - Calculate the type of the expression. Use this function to calculate the - expression type when a new expression is built - - @param recursive: (C++: bool) if true, types of all children expression will be calculated - before calculating our type +ida_hexrays.cexpr_t.calc_type(self, recursive: bool) -> None + Calculate the type of the expression. Use this function to calculate the expression type when a new expression is built + + @param recursive: if true, types of all children expression will be calculated before calculating our type -ida_hexrays.cexpr_t.cleanup (method) - cleanup(self) - Cleanup the expression. This function properly deletes all children and sets the - item type to cot_empty. +ida_hexrays.cexpr_t.cleanup(self) -> None + Cleanup the expression. This function properly deletes all children and sets the item type to cot_empty. + -ida_hexrays.cexpr_t.compare (method) - compare(self, r) -> int - - @param r: cexpr_t const & +ida_hexrays.cexpr_t.compare(self, r: "cexpr_t") -> int -ida_hexrays.cexpr_t.contains_comma (method) - contains_comma(self, times=1) -> bool +ida_hexrays.cexpr_t.contains_comma(self, times: int = 1) -> bool Does the expression contain a comma operator? - - @param times: (C++: int) -ida_hexrays.cexpr_t.contains_comma_or_insn_or_label (method) - contains_comma_or_insn_or_label(self, maxcommas=1) -> bool - Does the expression contain a comma operator or an embedded statement operator - or a label? - - @param maxcommas: (C++: int) +ida_hexrays.cexpr_t.contains_comma_or_insn_or_label(self, maxcommas: int = 1) -> bool + Does the expression contain a comma operator or an embedded statement operator or a label? -ida_hexrays.cexpr_t.contains_insn (method) - contains_insn(self, times=1) -> bool +ida_hexrays.cexpr_t.contains_insn(self, times: int = 1) -> bool Does the expression contain an embedded statement operator? - - @param times: (C++: int) -ida_hexrays.cexpr_t.contains_insn_or_label (method) - contains_insn_or_label(self) -> bool +ida_hexrays.cexpr_t.contains_insn_or_label(self) -> bool Does the expression contain an embedded statement operator or a label? -ida_hexrays.cexpr_t.contains_operator (method) - contains_operator(self, needed_op, times=1) -> bool - Check if the expression contains the specified operator. - - @param needed_op: (C++: ctype_t) operator code to search for - @param times: (C++: int) how many times the operator code should be present - @return: true if the expression has at least TIMES children with NEEDED_OP +ida_hexrays.cexpr_t.contains_operator(self, needed_op: "ctype_t", times: int = 1) -> bool + Check if the expression contains the specified operator. + + @param needed_op: operator code to search for + @param times: how many times the operator code should be present + @returns true if the expression has at least TIMES children with NEEDED_OP -ida_hexrays.cexpr_t.cpadone (method) - cpadone(self) -> bool +ida_hexrays.cexpr_t.cpadone(self) -> bool Pointer arithmetic correction done for this expression? -ida_hexrays.cexpr_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.cexpr_t.dstr(self) -> str -ida_hexrays.cexpr_t.equal_effect (method) - equal_effect(self, r) -> bool - Compare two expressions. This function tries to compare two expressions in an - 'intelligent' manner. For example, it knows about commutitive operators and can - ignore useless casts. - - @param r: (C++: const cexpr_t &) the expression to compare against the current expression - @return: true expressions can be considered equal +ida_hexrays.cexpr_t.equal_effect(self, r: "cexpr_t") -> bool + Compare two expressions. This function tries to compare two expressions in an 'intelligent' manner. For example, it knows about commutitive operators and can ignore useless casts. + + @param r: the expression to compare against the current expression + @returns true expressions can be considered equal -ida_hexrays.cexpr_t.exflags (variable) - Expression attributes +ida_hexrays.cexpr_t.exflags + Expression attributes + -ida_hexrays.cexpr_t.find_num_op (method) - find_num_op(self) -> cexpr_t +ida_hexrays.cexpr_t.find_num_op(self) -> "cexpr_t *" + Find the operand with a numeric value. -ida_hexrays.cexpr_t.find_op (method) - find_op(self, _op) -> cexpr_t - - @param _op: enum ctype_t +ida_hexrays.cexpr_t.find_op(self, _op: "ctype_t") -> "cexpr_t *" + Find the child with the specified operator. -ida_hexrays.cexpr_t.fpc (variable) +ida_hexrays.cexpr_t.fpc used for cot_fnum -ida_hexrays.cexpr_t.get_1num_op (method) - get_1num_op(self, o1, o2) -> bool - - @param o1: cexpr_t ** - @param o2: cexpr_t ** +ida_hexrays.cexpr_t.get_1num_op(self, o1: "cexpr_t **", o2: "cexpr_t **") -> bool + Get pointers to operands. at last one operand should be a number o1 will be pointer to the number + -ida_hexrays.cexpr_t.get_const_value (method) - get_const_value(self) -> bool - Get expression value. - - @return: true if the expression is a number. +ida_hexrays.cexpr_t.get_const_value(self) -> bool + Get expression value. + + @returns true if the expression is a number. -ida_hexrays.cexpr_t.get_high_nbit_bound (method) - get_high_nbit_bound(self) -> bit_bound_t - Get max number of bits that can really be used by the expression. For example, x - % 16 can yield only 4 non-zero bits, higher bits are zero +ida_hexrays.cexpr_t.get_high_nbit_bound(self) -> "bit_bound_t" + Get max number of bits that can really be used by the expression. For example, x % 16 can yield only 4 non-zero bits, higher bits are zero + -ida_hexrays.cexpr_t.get_low_nbit_bound (method) - get_low_nbit_bound(self) -> int - Get min number of bits that are certainly required to represent the expression. - For example, constant 16 always uses 5 bits: 10000. +ida_hexrays.cexpr_t.get_low_nbit_bound(self) -> int + Get min number of bits that are certainly required to represent the expression. For example, constant 16 always uses 5 bits: 10000. + -ida_hexrays.cexpr_t.get_ptr_or_array (method) - get_ptr_or_array(self) -> cexpr_t +ida_hexrays.cexpr_t.get_ptr_or_array(self) -> "cexpr_t *" Find pointer or array child. -ida_hexrays.cexpr_t.get_type_sign (method) - get_type_sign(self) -> type_sign_t +ida_hexrays.cexpr_t.get_type_sign(self) -> "type_sign_t" Get expression sign. -ida_hexrays.cexpr_t.get_v (method) - get_v(self) -> var_ref_t +ida_hexrays.cexpr_t.get_v(self) -> "var_ref_t *" -ida_hexrays.cexpr_t.has_side_effects (method) - has_side_effects(self) -> bool - Check if the expression has side effects. Calls, pre/post inc/dec, and - assignments have side effects. +ida_hexrays.cexpr_t.has_side_effects(self) -> bool + Check if the expression has side effects. Calls, pre/post inc/dec, and assignments have side effects. + -ida_hexrays.cexpr_t.helper (variable) +ida_hexrays.cexpr_t.helper helper name (used for cot_helper) -ida_hexrays.cexpr_t.insn (variable) - an embedded statement, they are prohibited at the final maturity stage - (CMAT_FINAL) +ida_hexrays.cexpr_t.insn + an embedded statement, they are prohibited at the final maturity stage (CMAT_FINAL) + -ida_hexrays.cexpr_t.is_call_arg_of (method) - is_call_arg_of(self, parent) -> bool - Is call argument? - - @param parent: (C++: const citem_t *) citem_t const * - @return: true if our expression is a call argument of the specified parent - expression. +ida_hexrays.cexpr_t.is_call_arg_of(self, parent: "citem_t") -> bool + Is call argument? + + @returns true if our expression is a call argument of the specified parent expression. -ida_hexrays.cexpr_t.is_call_object_of (method) - is_call_object_of(self, parent) -> bool - Is call object? - - @param parent: (C++: const citem_t *) citem_t const * - @return: true if our expression is the call object of the specified parent - expression. +ida_hexrays.cexpr_t.is_call_object_of(self, parent: "citem_t") -> bool + Is call object? + + @returns true if our expression is the call object of the specified parent expression. -ida_hexrays.cexpr_t.is_child_of (method) - is_child_of(self, parent) -> bool - Verify if the specified item is our parent. - - @param parent: (C++: const citem_t *) possible parent item - @return: true if the specified item is our parent +ida_hexrays.cexpr_t.is_child_of(self, parent: "citem_t") -> bool + Verify if the specified item is our parent. + + @param parent: possible parent item + @returns true if the specified item is our parent -ida_hexrays.cexpr_t.is_const_value (method) - is_const_value(self, _v) -> bool +ida_hexrays.cexpr_t.is_const_value(self, _v: "uint64") -> bool Check if the expression is a number with the specified value. - - @param _v: (C++: uint64) -ida_hexrays.cexpr_t.is_cstr (method) - is_cstr(self) -> bool +ida_hexrays.cexpr_t.is_cstr(self) -> bool -ida_hexrays.cexpr_t.is_fpop (method) - is_fpop(self) -> bool +ida_hexrays.cexpr_t.is_fpop(self) -> bool -ida_hexrays.cexpr_t.is_jumpout (method) - is_jumpout(self) -> bool +ida_hexrays.cexpr_t.is_jumpout(self) -> bool -ida_hexrays.cexpr_t.is_negative_const (method) - is_negative_const(self) -> bool +ida_hexrays.cexpr_t.is_negative_const(self) -> bool Check if the expression is a negative number. -ida_hexrays.cexpr_t.is_nice_cond (method) - is_nice_cond(self) -> bool - Is nice condition?. Nice condition is a nice expression of the boolean type. +ida_hexrays.cexpr_t.is_nice_cond(self) -> bool + Is nice condition?. Nice condition is a nice expression of the boolean type. + -ida_hexrays.cexpr_t.is_nice_expr (method) - is_nice_expr(self) -> bool - Is nice expression? Nice expressions do not contain comma operators, embedded - statements, or labels. +ida_hexrays.cexpr_t.is_nice_expr(self) -> bool + Is nice expression? Nice expressions do not contain comma operators, embedded statements, or labels. + -ida_hexrays.cexpr_t.is_non_negative_const (method) - is_non_negative_const(self) -> bool +ida_hexrays.cexpr_t.is_non_negative_const(self) -> bool Check if the expression is a non-negative number. -ida_hexrays.cexpr_t.is_non_zero_const (method) - is_non_zero_const(self) -> bool +ida_hexrays.cexpr_t.is_non_zero_const(self) -> bool Check if the expression is a non-zero number. -ida_hexrays.cexpr_t.is_odd_lvalue (method) - is_odd_lvalue(self) -> bool +ida_hexrays.cexpr_t.is_odd_lvalue(self) -> bool -ida_hexrays.cexpr_t.is_type_signed (method) - is_type_signed(self) -> bool +ida_hexrays.cexpr_t.is_type_signed(self) -> bool Is expression signed? -ida_hexrays.cexpr_t.is_type_unsigned (method) - is_type_unsigned(self) -> bool +ida_hexrays.cexpr_t.is_type_unsigned(self) -> bool Is expression unsigned? -ida_hexrays.cexpr_t.is_undef_val (method) - is_undef_val(self) -> bool +ida_hexrays.cexpr_t.is_undef_val(self) -> bool -ida_hexrays.cexpr_t.is_vftable (method) - is_vftable(self) -> bool +ida_hexrays.cexpr_t.is_vftable(self) -> bool -ida_hexrays.cexpr_t.is_zero_const (method) - is_zero_const(self) -> bool +ida_hexrays.cexpr_t.is_zero_const(self) -> bool Check if the expression is a zero. -ida_hexrays.cexpr_t.m (variable) - member offset (used for cot_memptr, cot_memref) for unions, the member number +ida_hexrays.cexpr_t.m + member offset (used for cot_memptr, cot_memref) for unions, the member number + -ida_hexrays.cexpr_t.maybe_ptr (method) - maybe_ptr(self) -> bool +ida_hexrays.cexpr_t.maybe_ptr(self) -> bool May the expression be a pointer? -ida_hexrays.cexpr_t.n (variable) +ida_hexrays.cexpr_t.n used for cot_num -ida_hexrays.cexpr_t.numval (method) - numval(self) -> uint64 - Get numeric value of the expression. This function can be called only on cot_num - expressions! +ida_hexrays.cexpr_t.numval(self) -> "uint64" + Get numeric value of the expression. This function can be called only on cot_num expressions! + -ida_hexrays.cexpr_t.obj_ea (variable) +ida_hexrays.cexpr_t.obj_ea used for cot_obj -ida_hexrays.cexpr_t.print1 (method) - print1(self, func) - Print expression into one line. - - @param func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced - variable names. +ida_hexrays.cexpr_t.print1(self, func: "cfunc_t") -> None + Print expression into one line. + + @param func: parent function. This argument is used to find out the referenced variable names. -ida_hexrays.cexpr_t.ptrsize (variable) +ida_hexrays.cexpr_t.ptrsize memory access size (used for cot_ptr, cot_memptr) -ida_hexrays.cexpr_t.put_number (method) - put_number(self, func, value, nbytes, sign=no_sign) - Assign a number to the expression. - - @param func: (C++: cfunc_t *) current function - @param value: (C++: uint64) number value - @param nbytes: (C++: int) size of the number in bytes - @param sign: (C++: type_sign_t) number sign +ida_hexrays.cexpr_t.put_number(self, *args) -> None + Assign a number to the expression. + + @param func: current function + @param value: number value + @param nbytes: size of the number in bytes + @param sign: number sign -ida_hexrays.cexpr_t.refwidth (variable) +ida_hexrays.cexpr_t.refwidth how many bytes are accessed? (-1: none) -ida_hexrays.cexpr_t.requires_lvalue (method) - requires_lvalue(self, child) -> bool - Check if the expression requires an lvalue. - - @param child: (C++: const cexpr_t *) The function will check if this child of our expression must be an - lvalue. - @return: true if child must be an lvalue. +ida_hexrays.cexpr_t.requires_lvalue(self, child: "cexpr_t") -> bool + Check if the expression requires an lvalue. + + @param child: The function will check if this child of our expression must be an lvalue. + @returns true if child must be an lvalue. -ida_hexrays.cexpr_t.set_cpadone (method) - set_cpadone(self) +ida_hexrays.cexpr_t.set_cpadone(self) -> None -ida_hexrays.cexpr_t.set_v (method) - set_v(self, v) - - @param v: var_ref_t const * +ida_hexrays.cexpr_t.set_v(self, v: "var_ref_t") -> None -ida_hexrays.cexpr_t.set_vftable (method) - set_vftable(self) +ida_hexrays.cexpr_t.set_vftable(self) -> None -ida_hexrays.cexpr_t.string (variable) +ida_hexrays.cexpr_t.string utf8 string constant, user representation (used for cot_str) -ida_hexrays.cexpr_t.swap (method) - swap(self, r) - - @param r: cexpr_t & +ida_hexrays.cexpr_t.swap(self, r: "cexpr_t") -> None -ida_hexrays.cexpr_t.theother (method) - theother(self, what) -> cexpr_t - - @param what: cexpr_t const * +ida_hexrays.cexpr_t.theother(self, what: "cexpr_t") -> "cexpr_t *" + Get the other operand. This function returns the other operand (not the specified one) for binary expressions. + -ida_hexrays.cexpr_t.type (variable) +ida_hexrays.cexpr_t.type expression type. must be carefully maintained -ida_hexrays.cexpr_t.v (variable) +ida_hexrays.cexpr_t.v used for cot_var -ida_hexrays.cexpr_t.x (variable) +ida_hexrays.cexpr_t.x the first operand of the expression -ida_hexrays.cexpr_t.y (variable) +ida_hexrays.cexpr_t.y the second operand of the expression -ida_hexrays.cexpr_t.z (variable) +ida_hexrays.cexpr_t.z the third operand of the expression -ida_hexrays.cfor_t (class) - Proxy of C++ cfor_t class. +ida_hexrays.cfor_t -ida_hexrays.cfor_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cfor_t const & +ida_hexrays.cfor_t.__eq__(self, r: "cfor_t") -> bool -ida_hexrays.cfor_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cfor_t const & +ida_hexrays.cfor_t.__ge__(self, r: "cfor_t") -> bool -ida_hexrays.cfor_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cfor_t const & +ida_hexrays.cfor_t.__gt__(self, r: "cfor_t") -> bool -ida_hexrays.cfor_t.__init__ (method) - __init__(self) -> cfor_t +ida_hexrays.cfor_t.__init__(self) -ida_hexrays.cfor_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cfor_t const & +ida_hexrays.cfor_t.__le__(self, r: "cfor_t") -> bool -ida_hexrays.cfor_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cfor_t const & +ida_hexrays.cfor_t.__lt__(self, r: "cfor_t") -> bool -ida_hexrays.cfor_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cfor_t const & +ida_hexrays.cfor_t.__ne__(self, r: "cfor_t") -> bool -ida_hexrays.cfor_t.compare (method) - compare(self, r) -> int - - @param r: cfor_t const & +ida_hexrays.cfor_t.compare(self, r: "cfor_t") -> int -ida_hexrays.cfor_t.init (variable) +ida_hexrays.cfor_t.init Initialization expression. -ida_hexrays.cfor_t.step (variable) +ida_hexrays.cfor_t.step Step expression. -ida_hexrays.cfunc_parentee_t (class) - Proxy of C++ cfunc_parentee_t class. +ida_hexrays.cfunc_parentee_t -ida_hexrays.cfunc_parentee_t.__disown__ (method) +ida_hexrays.cfunc_parentee_t.__disown__(self) -ida_hexrays.cfunc_parentee_t.__init__ (method) - __init__(self, f, post=False) -> cfunc_parentee_t - - @param f: cfunc_t * - @param post: bool +ida_hexrays.cfunc_parentee_t.__init__(self, f: "cfunc_t", post: bool = False) -ida_hexrays.cfunc_parentee_t.calc_rvalue_type (method) - calc_rvalue_type(self, target, e) -> bool - Calculate rvalue type. This function tries to determine the type of the - specified item based on its context. For example, if the current expression is - the right side of an assignment operator, the type of its left side will be - returned. This function can be used to determine the 'best' type of the - specified expression. - - @param target: (C++: tinfo_t *) 'best' type of the expression will be returned here - @param e: (C++: const cexpr_t *) expression to determine the desired type - @return: false if failed +ida_hexrays.cfunc_parentee_t.calc_rvalue_type(self, target: "tinfo_t", e: "cexpr_t") -> bool + Calculate rvalue type. This function tries to determine the type of the specified item based on its context. For example, if the current expression is the right side of an assignment operator, the type of its left side will be returned. This function can be used to determine the 'best' type of the specified expression. + + @param target: 'best' type of the expression will be returned here + @param e: expression to determine the desired type + @returns false if failed -ida_hexrays.cfunc_parentee_t.func (variable) +ida_hexrays.cfunc_parentee_t.func Pointer to current function. -ida_hexrays.cfunc_t (class) - Proxy of C++ cfunc_t class. +ida_hexrays.cfunc_t -ida_hexrays.cfunc_t.__init__ (method) +ida_hexrays.cfunc_t.__init__(self, *args, **kwargs) -ida_hexrays.cfunc_t.__str__ (method) - __str__(self) -> qstring +ida_hexrays.cfunc_t.__str__(self) -> str -ida_hexrays.cfunc_t.argidx (variable) +ida_hexrays.cfunc_t.argidx list of arguments (indexes into vars) -ida_hexrays.cfunc_t.body (variable) +ida_hexrays.cfunc_t.body function body, must be a block -ida_hexrays.cfunc_t.build_c_tree (method) - build_c_tree(self) - Generate the function body. This function (re)generates the function body from - the underlying microcode. +ida_hexrays.cfunc_t.build_c_tree(self) -> None + Generate the function body. This function (re)generates the function body from the underlying microcode. + -ida_hexrays.cfunc_t.del_orphan_cmts (method) - del_orphan_cmts(self) -> int - Delete all orphan comments. The save_user_cmts() function must be called after - this call. +ida_hexrays.cfunc_t.del_orphan_cmts(self) -> int + Delete all orphan comments. The save_user_cmts() function must be called after this call. + -ida_hexrays.cfunc_t.entry_ea (variable) +ida_hexrays.cfunc_t.entry_ea function entry address -ida_hexrays.cfunc_t.find_item_coords (method) - find_item_coords(self, item, px, py) -> bool +ida_hexrays.cfunc_t.find_item_coords(self, *args) + This method has the following signatures: - @param item: citem_t const * - @param px: int * - @param py: int * + 1. find_item_coords(item: citem_t) -> Tuple[int, int] + 2. find_item_coords(item: citem_t, x: int_pointer, y: int_pointer) -> bool - find_item_coords(self, item) -> PyObject * + NOTE: The second form is retained for backward-compatibility, + but we strongly recommend using the first. - @param item: citem_t const * + @param item The item to find coordinates for in the pseudocode listing -ida_hexrays.cfunc_t.find_label (method) - find_label(self, label) -> citem_t - Find the label. - - @param label: (C++: int) - @return: pointer to the ctree item with the specified label number. +ida_hexrays.cfunc_t.find_label(self, label: int) -> "citem_t *" + Find the label. + + @returns pointer to the ctree item with the specified label number. -ida_hexrays.cfunc_t.gather_derefs (method) - gather_derefs(self, ci, udm=None) -> bool - - @param ci: ctree_item_t const & - @param udm: udt_type_data_t * +ida_hexrays.cfunc_t.gather_derefs(self, ci: "ctree_item_t", udm: "udt_type_data_t" = None) -> bool -ida_hexrays.cfunc_t.get_boundaries (method) - get_boundaries(self) -> boundaries_t - Get pointer to map of instruction boundaries. This function initializes the - boundary map if not done yet. +ida_hexrays.cfunc_t.get_boundaries(self) -> "boundaries_t &" + Get pointer to map of instruction boundaries. This function initializes the boundary map if not done yet. + -ida_hexrays.cfunc_t.get_eamap (method) - get_eamap(self) -> eamap_t - Get pointer to ea->insn map. This function initializes eamap if not done yet. +ida_hexrays.cfunc_t.get_eamap(self) -> "eamap_t &" + Get pointer to ea->insn map. This function initializes eamap if not done yet. + -ida_hexrays.cfunc_t.get_func_type (method) - get_func_type(self, type) -> bool - Get the function type. - - @param type: (C++: tinfo_t *) variable where the function type is returned - @return: false if failure +ida_hexrays.cfunc_t.get_func_type(self, type: "tinfo_t") -> bool + Get the function type. + + @param type: variable where the function type is returned + @returns false if failure -ida_hexrays.cfunc_t.get_line_item (method) - get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool - Get ctree item for the specified cursor position. - - @param line: (C++: const char *) line of decompilation text (element of sv) - @param x: (C++: int) x cursor coordinate in the line - @param is_ctree_line: (C++: bool) does the line belong to statement area? (if not, it is - assumed to belong to the declaration area) - @param phead: (C++: ctree_item_t *) ptr to the first item on the line (used to attach block comments). - May be nullptr - @param pitem: (C++: ctree_item_t *) ptr to the current item. May be nullptr - @param ptail: (C++: ctree_item_t *) ptr to the last item on the line (used to attach indented - comments). May be nullptr - @see: vdui_t::get_current_item() - @return: false if failed to get the current item +ida_hexrays.cfunc_t.get_line_item(self, line: str, x: int, is_ctree_line: bool, phead: "ctree_item_t", pitem: "ctree_item_t", ptail: "ctree_item_t") -> bool + Get ctree item for the specified cursor position. + + @param line: line of decompilation text (element of sv) + @param x: x cursor coordinate in the line + @param is_ctree_line: does the line belong to statement area? (if not, it is assumed to belong to the declaration area) + @param phead: ptr to the first item on the line (used to attach block comments). May be nullptr + @param pitem: ptr to the current item. May be nullptr + @param ptail: ptr to the last item on the line (used to attach indented comments). May be nullptr + @returns false if failed to get the current item -ida_hexrays.cfunc_t.get_lvars (method) - get_lvars(self) -> lvars_t - Get vector of local variables. - - @return: pointer to the vector of local variables. If you modify this vector, - the ctree must be regenerated in order to have correct cast operators. - Use build_c_tree() for that. Removing lvars should be done carefully: - all references in ctree and microcode must be corrected after that. +ida_hexrays.cfunc_t.get_lvars(self) -> "lvars_t *" + Get vector of local variables. + + @returns pointer to the vector of local variables. If you modify this vector, the ctree must be regenerated in order to have correct cast operators. Use build_c_tree() for that. Removing lvars should be done carefully: all references in ctree and microcode must be corrected after that. -ida_hexrays.cfunc_t.get_pseudocode (method) - get_pseudocode(self) -> strvec_t - Get pointer to decompilation output: the pseudocode. This function generates - pseudocode if not done yet. +ida_hexrays.cfunc_t.get_pseudocode(self) -> "strvec_t const &" + Get pointer to decompilation output: the pseudocode. This function generates pseudocode if not done yet. + -ida_hexrays.cfunc_t.get_stkoff_delta (method) - get_stkoff_delta(self) -> sval_t - Get stack offset delta. The local variable stack offsets retrieved by - v.location.stkoff() should be adjusted before being used as stack frame offsets - in IDA. - - @return: the delta to apply. example: ida_stkoff = v.location.stkoff() - - f->get_stkoff_delta() +ida_hexrays.cfunc_t.get_stkoff_delta(self) -> int + Get stack offset delta. The local variable stack offsets retrieved by v.location.stkoff() should be adjusted before being used as stack frame offsets in IDA. + + @returns the delta to apply. example: ida_stkoff = v.location.stkoff() - f->get_stkoff_delta() -ida_hexrays.cfunc_t.get_user_cmt (method) - get_user_cmt(self, loc, rt) -> char const * - Retrieve a user defined comment. - - @param loc: (C++: const treeloc_t &) ctree location - @param rt: (C++: cmt_retrieval_type_t) should already retrieved comments retrieved again? - @return: pointer to the comment string or nullptr +ida_hexrays.cfunc_t.get_user_cmt(self, loc: "treeloc_t", rt: "cmt_retrieval_type_t") -> str + Retrieve a user defined comment. + + @param loc: ctree location + @param rt: should already retrieved comments retrieved again? + @returns pointer to the comment string or nullptr -ida_hexrays.cfunc_t.get_user_iflags (method) - get_user_iflags(self, loc) -> int32 - Retrieve citem iflags. - - @param loc: (C++: const citem_locator_t &) citem locator - @return: ctree item iflags bits or 0 +ida_hexrays.cfunc_t.get_user_iflags(self, loc: "citem_locator_t") -> int + Retrieve citem iflags. + + @param loc: citem locator + @returns ctree item iflags bits or 0 -ida_hexrays.cfunc_t.get_user_union_selection (method) - get_user_union_selection(self, ea, path) -> bool - Retrieve a user defined union field selection. - - @param ea: (C++: ea_t) address - @param path: (C++: intvec_t *) out: path describing the union selection. - @return: pointer to the path or nullptr +ida_hexrays.cfunc_t.get_user_union_selection(self, ea: ida_idaapi.ea_t, path: "intvec_t") -> bool + Retrieve a user defined union field selection. + + @param ea: address + @param path: out: path describing the union selection. + @returns pointer to the path or nullptr -ida_hexrays.cfunc_t.get_warnings (method) - get_warnings(self) -> hexwarns_t - Get information about decompilation warnings. - - @return: reference to the vector of warnings +ida_hexrays.cfunc_t.get_warnings(self) -> "hexwarns_t &" + Get information about decompilation warnings. + + @returns reference to the vector of warnings -ida_hexrays.cfunc_t.has_orphan_cmts (method) - has_orphan_cmts(self) -> bool +ida_hexrays.cfunc_t.has_orphan_cmts(self) -> bool Check if there are orphan comments. -ida_hexrays.cfunc_t.hdrlines (variable) +ida_hexrays.cfunc_t.hdrlines number of lines in the declaration area -ida_hexrays.cfunc_t.locked (method) - locked(self) -> bool +ida_hexrays.cfunc_t.locked(self) -> bool -ida_hexrays.cfunc_t.maturity (variable) +ida_hexrays.cfunc_t.maturity maturity level -ida_hexrays.cfunc_t.mba (variable) +ida_hexrays.cfunc_t.mba underlying microcode -ida_hexrays.cfunc_t.numforms (variable) +ida_hexrays.cfunc_t.numforms user-defined number formats. -ida_hexrays.cfunc_t.print_dcl (method) - print_dcl(self) - Print function prototype. +ida_hexrays.cfunc_t.print_dcl(self) -> None + Print function prototype. + -ida_hexrays.cfunc_t.print_func (method) - print_func(self, vp) - Print function text. - - @param vp: (C++: vc_printer_t &) printer helper class to receive the generated text. +ida_hexrays.cfunc_t.print_func(self, vp: "vc_printer_t") -> None + Print function text. + + @param vp: printer helper class to receive the generated text. -ida_hexrays.cfunc_t.refcnt (variable) +ida_hexrays.cfunc_t.refcnt reference count to this object. use cfuncptr_t -ida_hexrays.cfunc_t.refresh_func_ctext (method) - refresh_func_ctext(self) - Refresh ctext after a ctree modification. This function informs the decompiler - that ctree (body) have been modified and ctext (sv) does not correspond to it - anymore. It also refreshes the pseudocode windows if there is any. +ida_hexrays.cfunc_t.refresh_func_ctext(self) -> None + Refresh ctext after a ctree modification. This function informs the decompiler that ctree (body) have been modified and ctext (sv) does not correspond to it anymore. It also refreshes the pseudocode windows if there is any. + -ida_hexrays.cfunc_t.release (method) - release(self) +ida_hexrays.cfunc_t.release(self) -> None -ida_hexrays.cfunc_t.remove_unused_labels (method) - remove_unused_labels(self) - Remove unused labels. This function checks what labels are really used by the - function and removes the unused ones. You must call it after deleting a goto - statement. +ida_hexrays.cfunc_t.remove_unused_labels(self) -> None + Remove unused labels. This function checks what labels are really used by the function and removes the unused ones. You must call it after deleting a goto statement. + -ida_hexrays.cfunc_t.save_user_cmts (method) - save_user_cmts(self) +ida_hexrays.cfunc_t.save_user_cmts(self) -> None Save user-defined comments into the database. -ida_hexrays.cfunc_t.save_user_iflags (method) - save_user_iflags(self) +ida_hexrays.cfunc_t.save_user_iflags(self) -> None Save user-defined iflags into the database. -ida_hexrays.cfunc_t.save_user_labels (method) - save_user_labels(self) +ida_hexrays.cfunc_t.save_user_labels(self) -> None Save user-defined labels into the database. -ida_hexrays.cfunc_t.save_user_numforms (method) - save_user_numforms(self) +ida_hexrays.cfunc_t.save_user_numforms(self) -> None Save user-defined number formats into the database. -ida_hexrays.cfunc_t.save_user_unions (method) - save_user_unions(self) +ida_hexrays.cfunc_t.save_user_unions(self) -> None Save user-defined union field selections into the database. -ida_hexrays.cfunc_t.set_user_cmt (method) - set_user_cmt(self, loc, cmt) - Set a user defined comment. This function stores the specified comment in the - cfunc_t structure. The save_user_cmts() function must be called after it. - - @param loc: (C++: const treeloc_t &) ctree location - @param cmt: (C++: const char *) new comment. if empty or nullptr, then an existing comment is - deleted. +ida_hexrays.cfunc_t.set_user_cmt(self, loc: "treeloc_t", cmt: str) -> None + Set a user defined comment. This function stores the specified comment in the cfunc_t structure. The save_user_cmts() function must be called after it. + + @param loc: ctree location + @param cmt: new comment. if empty or nullptr, then an existing comment is deleted. -ida_hexrays.cfunc_t.set_user_iflags (method) - set_user_iflags(self, loc, iflags) - Set citem iflags. - - @param loc: (C++: const citem_locator_t &) citem locator - @param iflags: (C++: int32) new iflags +ida_hexrays.cfunc_t.set_user_iflags(self, loc: "citem_locator_t", iflags: int) -> None + Set citem iflags. + + @param loc: citem locator + @param iflags: new iflags -ida_hexrays.cfunc_t.set_user_union_selection (method) - set_user_union_selection(self, ea, path) - Set a union field selection. The save_user_unions() function must be called - after calling this function. - - @param ea: (C++: ea_t) address - @param path: (C++: const intvec_t &) in: path describing the union selection. +ida_hexrays.cfunc_t.set_user_union_selection(self, ea: ida_idaapi.ea_t, path: "intvec_t") -> None + Set a union field selection. The save_user_unions() function must be called after calling this function. + + @param ea: address + @param path: in: path describing the union selection. -ida_hexrays.cfunc_t.statebits (variable) - current cfunc_t state. see cfunc state bits +ida_hexrays.cfunc_t.statebits + current cfunc_t state. see cfunc state bits + -ida_hexrays.cfunc_t.treeitems (variable) - vector of ctree items +ida_hexrays.cfunc_t.treeitems + vector of pointers to citem_t objects (nodes constituting the ctree) -ida_hexrays.cfunc_t.user_cmts (variable) +ida_hexrays.cfunc_t.user_cmts user-defined comments. -ida_hexrays.cfunc_t.user_iflags (variable) +ida_hexrays.cfunc_t.user_iflags user-defined item flags ctree item iflags bits -ida_hexrays.cfunc_t.user_labels (variable) +ida_hexrays.cfunc_t.user_labels user-defined labels. -ida_hexrays.cfunc_t.user_unions (variable) - user-defined union field selections. +ida_hexrays.cfunc_t.user_unions + user-defined union field selections. + -ida_hexrays.cfunc_t.verify (method) - verify(self, aul, even_without_debugger) - Verify the ctree. This function verifies the ctree. If the ctree is malformed, - an internal error is generated. Use it to verify the ctree after your - modifications. - - @param aul: (C++: allow_unused_labels_t) Are unused labels acceptable? - @param even_without_debugger: (C++: bool) if false and there is no debugger, the - verification will be skipped +ida_hexrays.cfunc_t.verify(self, aul: "allow_unused_labels_t", even_without_debugger: bool) -> None + Verify the ctree. This function verifies the ctree. If the ctree is malformed, an internal error is generated. Use it to verify the ctree after your modifications. + + @param aul: Are unused labels acceptable? + @param even_without_debugger: if false and there is no debugger, the verification will be skipped -ida_hexrays.cfunc_type (function) +ida_hexrays.cfunc_type(self) Get the function's return type tinfo_t object. -ida_hexrays.cfuncptr_t (class) - Proxy of C++ qrefcnt_t< cfunc_t > class. +ida_hexrays.cfuncptr_t -ida_hexrays.cfuncptr_t.__deref__ (method) - __deref__(self) -> cfunc_t +ida_hexrays.cfuncptr_t.__deref__(self) -> "cfunc_t *" -ida_hexrays.cfuncptr_t.__init__ (method) - __init__(self, p) -> cfuncptr_t +ida_hexrays.cfuncptr_t.__init__(self, *args) + +ida_hexrays.cfuncptr_t.__ptrval__(self) -> "size_t" + +ida_hexrays.cfuncptr_t.__ref__(self) -> "cfunc_t &" + +ida_hexrays.cfuncptr_t.__str__(self) -> str + +ida_hexrays.cfuncptr_t.build_c_tree(self) -> None + +ida_hexrays.cfuncptr_t.del_orphan_cmts(self) -> int + +ida_hexrays.cfuncptr_t.find_item_coords(self, *args) + This method has the following signatures: - @param p: cfunc_t * + 1. find_item_coords(item: citem_t) -> Tuple[int, int] + 2. find_item_coords(item: citem_t, x: int_pointer, y: int_pointer) -> bool - __init__(self, r) -> cfuncptr_t + NOTE: The second form is retained for backward-compatibility, + but we strongly recommend using the first. - @param r: qrefcnt_t< cfunc_t > const & + @param item The item to find coordinates for in the pseudocode listing -ida_hexrays.cfuncptr_t.__ptrval__ (method) - __ptrval__(self) -> size_t +ida_hexrays.cfuncptr_t.find_label(self, label: int) -> "citem_t *" -ida_hexrays.cfuncptr_t.__ref__ (method) - __ref__(self) -> cfunc_t +ida_hexrays.cfuncptr_t.gather_derefs(self, ci: "ctree_item_t", udm: "udt_type_data_t" = None) -> bool -ida_hexrays.cfuncptr_t.__str__ (method) - __str__(self) -> qstring +ida_hexrays.cfuncptr_t.get_boundaries(self) -> "boundaries_t &" -ida_hexrays.cfuncptr_t.build_c_tree (method) - build_c_tree(self) +ida_hexrays.cfuncptr_t.get_eamap(self) -> "eamap_t &" -ida_hexrays.cfuncptr_t.del_orphan_cmts (method) - del_orphan_cmts(self) -> int +ida_hexrays.cfuncptr_t.get_func_type(self, type: "tinfo_t") -> bool -ida_hexrays.cfuncptr_t.find_item_coords (method) - find_item_coords(self, item, px, py) -> bool - - @param item: citem_t const * - @param px: int * - @param py: int * - - find_item_coords(self, item) -> (int, int), bool - - @param item: citem_t const * +ida_hexrays.cfuncptr_t.get_line_item(self, line: str, x: int, is_ctree_line: bool, phead: "ctree_item_t", pitem: "ctree_item_t", ptail: "ctree_item_t") -> bool -ida_hexrays.cfuncptr_t.find_label (method) - find_label(self, label) -> citem_t - - @param label: int +ida_hexrays.cfuncptr_t.get_lvars(self) -> "lvars_t *" -ida_hexrays.cfuncptr_t.gather_derefs (method) - gather_derefs(self, ci, udm=None) -> bool - - @param ci: ctree_item_t const & - @param udm: udt_type_data_t * +ida_hexrays.cfuncptr_t.get_pseudocode(self) -> "strvec_t const &" -ida_hexrays.cfuncptr_t.get_boundaries (method) - get_boundaries(self) -> boundaries_t +ida_hexrays.cfuncptr_t.get_stkoff_delta(self) -> int -ida_hexrays.cfuncptr_t.get_eamap (method) - get_eamap(self) -> eamap_t +ida_hexrays.cfuncptr_t.get_user_cmt(self, loc: "treeloc_t", rt: "cmt_retrieval_type_t") -> str -ida_hexrays.cfuncptr_t.get_func_type (method) - get_func_type(self, type) -> bool - - @param type: tinfo_t * +ida_hexrays.cfuncptr_t.get_user_iflags(self, loc: "citem_locator_t") -> int -ida_hexrays.cfuncptr_t.get_line_item (method) - get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool - - @param line: char const * - @param x: int - @param is_ctree_line: bool - @param phead: ctree_item_t * - @param pitem: ctree_item_t * - @param ptail: ctree_item_t * +ida_hexrays.cfuncptr_t.get_user_union_selection(self, ea: ida_idaapi.ea_t, path: "intvec_t") -> bool -ida_hexrays.cfuncptr_t.get_lvars (method) - get_lvars(self) -> lvars_t +ida_hexrays.cfuncptr_t.get_warnings(self) -> "hexwarns_t &" -ida_hexrays.cfuncptr_t.get_pseudocode (method) - get_pseudocode(self) -> strvec_t +ida_hexrays.cfuncptr_t.has_orphan_cmts(self) -> bool -ida_hexrays.cfuncptr_t.get_stkoff_delta (method) - get_stkoff_delta(self) -> sval_t +ida_hexrays.cfuncptr_t.locked(self) -> bool -ida_hexrays.cfuncptr_t.get_user_cmt (method) - get_user_cmt(self, loc, rt) -> char const * - - @param loc: treeloc_t const & - @param rt: enum cmt_retrieval_type_t +ida_hexrays.cfuncptr_t.print_dcl(self) -> None -ida_hexrays.cfuncptr_t.get_user_iflags (method) - get_user_iflags(self, loc) -> int32 - - @param loc: citem_locator_t const & +ida_hexrays.cfuncptr_t.print_func(self, vp: "vc_printer_t") -> None -ida_hexrays.cfuncptr_t.get_user_union_selection (method) - get_user_union_selection(self, ea, path) -> bool - - @param ea: ea_t - @param path: intvec_t * +ida_hexrays.cfuncptr_t.refresh_func_ctext(self) -> None -ida_hexrays.cfuncptr_t.get_warnings (method) - get_warnings(self) -> hexwarns_t +ida_hexrays.cfuncptr_t.release(self) -> None -ida_hexrays.cfuncptr_t.has_orphan_cmts (method) - has_orphan_cmts(self) -> bool +ida_hexrays.cfuncptr_t.remove_unused_labels(self) -> None -ida_hexrays.cfuncptr_t.locked (method) - locked(self) -> bool +ida_hexrays.cfuncptr_t.reset(self) -> None -ida_hexrays.cfuncptr_t.print_dcl (method) - print_dcl(self) +ida_hexrays.cfuncptr_t.save_user_cmts(self) -> None + Save user defined comments into the database. + -ida_hexrays.cfuncptr_t.print_func (method) - print_func(self, vp) - - @param vp: vc_printer_t & +ida_hexrays.cfuncptr_t.save_user_iflags(self) -> None + Save user defined citem iflags into the database. + -ida_hexrays.cfuncptr_t.refresh_func_ctext (method) - refresh_func_ctext(self) +ida_hexrays.cfuncptr_t.save_user_labels(self) -> None + Save user defined labels into the database. + -ida_hexrays.cfuncptr_t.release (method) - release(self) +ida_hexrays.cfuncptr_t.save_user_numforms(self) -> None + Save user defined number formats into the database. + -ida_hexrays.cfuncptr_t.remove_unused_labels (method) - remove_unused_labels(self) +ida_hexrays.cfuncptr_t.save_user_unions(self) -> None + Save user defined union field selections into the database. + -ida_hexrays.cfuncptr_t.reset (method) - reset(self) +ida_hexrays.cfuncptr_t.set_user_cmt(self, loc: "treeloc_t", cmt: str) -> None -ida_hexrays.cfuncptr_t.save_user_cmts (method) - save_user_cmts(self) +ida_hexrays.cfuncptr_t.set_user_iflags(self, loc: "citem_locator_t", iflags: int) -> None -ida_hexrays.cfuncptr_t.save_user_iflags (method) - save_user_iflags(self) +ida_hexrays.cfuncptr_t.set_user_union_selection(self, ea: ida_idaapi.ea_t, path: "intvec_t") -> None -ida_hexrays.cfuncptr_t.save_user_labels (method) - save_user_labels(self) +ida_hexrays.cfuncptr_t.verify(self, aul: "allow_unused_labels_t", even_without_debugger: bool) -> None -ida_hexrays.cfuncptr_t.save_user_numforms (method) - save_user_numforms(self) +ida_hexrays.cgoto_t -ida_hexrays.cfuncptr_t.save_user_unions (method) - save_user_unions(self) +ida_hexrays.cgoto_t.__eq__(self, r: "cgoto_t") -> bool -ida_hexrays.cfuncptr_t.set_user_cmt (method) - set_user_cmt(self, loc, cmt) - - @param loc: treeloc_t const & - @param cmt: char const * +ida_hexrays.cgoto_t.__ge__(self, r: "cgoto_t") -> bool -ida_hexrays.cfuncptr_t.set_user_iflags (method) - set_user_iflags(self, loc, iflags) - - @param loc: citem_locator_t const & - @param iflags: int32 +ida_hexrays.cgoto_t.__gt__(self, r: "cgoto_t") -> bool -ida_hexrays.cfuncptr_t.set_user_union_selection (method) - set_user_union_selection(self, ea, path) - - @param ea: ea_t - @param path: intvec_t const & +ida_hexrays.cgoto_t.__init__(self) -ida_hexrays.cfuncptr_t.verify (method) - verify(self, aul, even_without_debugger) - - @param aul: enum allow_unused_labels_t - @param even_without_debugger: bool +ida_hexrays.cgoto_t.__le__(self, r: "cgoto_t") -> bool -ida_hexrays.cgoto_t (class) - Proxy of C++ cgoto_t class. +ida_hexrays.cgoto_t.__lt__(self, r: "cgoto_t") -> bool -ida_hexrays.cgoto_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cgoto_t const & +ida_hexrays.cgoto_t.__ne__(self, r: "cgoto_t") -> bool -ida_hexrays.cgoto_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cgoto_t const & +ida_hexrays.cgoto_t.compare(self, r: "cgoto_t") -> int -ida_hexrays.cgoto_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__init__ (method) - __init__(self) -> cgoto_t - -ida_hexrays.cgoto_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.compare (method) - compare(self, r) -> int - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.label_num (variable) +ida_hexrays.cgoto_t.label_num Target label number. -ida_hexrays.chain_keeper_t (class) - Proxy of C++ chain_keeper_t class. +ida_hexrays.chain_keeper_t -ida_hexrays.chain_keeper_t.__init__ (method) - __init__(self, _gc) -> chain_keeper_t - - @param _gc: graph_chains_t * +ida_hexrays.chain_keeper_t.__init__(self, _gc: "graph_chains_t") -ida_hexrays.chain_keeper_t.back (method) - back(self) -> block_chains_t +ida_hexrays.chain_keeper_t.back(self) -> "block_chains_t &" -ida_hexrays.chain_keeper_t.for_all_chains (method) - for_all_chains(self, cv, gca) -> int - - @param cv: chain_visitor_t & - @param gca: int +ida_hexrays.chain_keeper_t.for_all_chains(self, cv: "chain_visitor_t", gca: int) -> int -ida_hexrays.chain_keeper_t.front (method) - front(self) -> block_chains_t +ida_hexrays.chain_keeper_t.front(self) -> "block_chains_t &" -ida_hexrays.chain_t (class) - Proxy of C++ chain_t class. +ida_hexrays.chain_t -ida_hexrays.chain_t.__init__ (method) - __init__(self) -> chain_t - __init__(self, t, off, w=1, v=-1) -> chain_t - - @param t: mopt_t - @param off: sval_t - @param w: int - @param v: int - - __init__(self, _k, w=1) -> chain_t - - @param _k: voff_t const & - @param w: int +ida_hexrays.chain_t.__init__(self, *args) -ida_hexrays.chain_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: chain_t const & +ida_hexrays.chain_t.__lt__(self, r: "chain_t") -> bool -ida_hexrays.chain_t._print (method) - _print(self) +ida_hexrays.chain_t._print(self) -> None -ida_hexrays.chain_t.append_list (method) - append_list(self, mba, list) +ida_hexrays.chain_t.append_list(self, mba: "mba_t", list: "mlist_t") -> None Append the contents of the chain to the specified list of locations. - - @param mba: (C++: const mba_t *) mba_t const * - @param list: (C++: mlist_t *) -ida_hexrays.chain_t.clear_varnum (method) - clear_varnum(self) +ida_hexrays.chain_t.clear_varnum(self) -> None -ida_hexrays.chain_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.chain_t.dstr(self) -> str -ida_hexrays.chain_t.endoff (method) - endoff(self) -> voff_t +ida_hexrays.chain_t.endoff(self) -> "voff_t const" -ida_hexrays.chain_t.flags (variable) - combination Chain properties bits +ida_hexrays.chain_t.flags + combination Chain properties bits + -ida_hexrays.chain_t.get_reg (method) - get_reg(self) -> mreg_t +ida_hexrays.chain_t.get_reg(self) -> "mreg_t" -ida_hexrays.chain_t.get_stkoff (method) - get_stkoff(self) -> sval_t +ida_hexrays.chain_t.get_stkoff(self) -> int -ida_hexrays.chain_t.includes (method) - includes(self, r) -> bool - - @param r: chain_t const & +ida_hexrays.chain_t.includes(self, r: "chain_t") -> bool -ida_hexrays.chain_t.is_fake (method) - is_fake(self) -> bool +ida_hexrays.chain_t.is_fake(self) -> bool -ida_hexrays.chain_t.is_inited (method) - is_inited(self) -> bool +ida_hexrays.chain_t.is_inited(self) -> bool -ida_hexrays.chain_t.is_overlapped (method) - is_overlapped(self) -> bool +ida_hexrays.chain_t.is_overlapped(self) -> bool -ida_hexrays.chain_t.is_passreg (method) - is_passreg(self) -> bool +ida_hexrays.chain_t.is_passreg(self) -> bool -ida_hexrays.chain_t.is_reg (method) - is_reg(self) -> bool +ida_hexrays.chain_t.is_reg(self) -> bool -ida_hexrays.chain_t.is_replaced (method) - is_replaced(self) -> bool +ida_hexrays.chain_t.is_replaced(self) -> bool -ida_hexrays.chain_t.is_stkoff (method) - is_stkoff(self) -> bool +ida_hexrays.chain_t.is_stkoff(self) -> bool -ida_hexrays.chain_t.is_term (method) - is_term(self) -> bool +ida_hexrays.chain_t.is_term(self) -> bool -ida_hexrays.chain_t.key (method) - key(self) -> voff_t +ida_hexrays.chain_t.key(self) -> "voff_t const &" -ida_hexrays.chain_t.overlap (method) - overlap(self, r) -> bool - - @param r: chain_t const & +ida_hexrays.chain_t.overlap(self, r: "chain_t") -> bool -ida_hexrays.chain_t.set_inited (method) - set_inited(self, b) - - @param b: bool +ida_hexrays.chain_t.set_inited(self, b: bool) -> None -ida_hexrays.chain_t.set_overlapped (method) - set_overlapped(self, b) - - @param b: bool +ida_hexrays.chain_t.set_overlapped(self, b: bool) -> None -ida_hexrays.chain_t.set_replaced (method) - set_replaced(self, b) - - @param b: bool +ida_hexrays.chain_t.set_replaced(self, b: bool) -> None -ida_hexrays.chain_t.set_term (method) - set_term(self, b) - - @param b: bool +ida_hexrays.chain_t.set_term(self, b: bool) -> None -ida_hexrays.chain_t.set_value (method) - set_value(self, r) - - @param r: chain_t const & +ida_hexrays.chain_t.set_value(self, r: "chain_t") -> None -ida_hexrays.chain_t.varnum (variable) +ida_hexrays.chain_t.varnum allocated variable index (-1 - not allocated yet) -ida_hexrays.chain_t.width (variable) +ida_hexrays.chain_t.width size of the value in bytes -ida_hexrays.chain_visitor_t (class) - Proxy of C++ chain_visitor_t class. +ida_hexrays.chain_visitor_t -ida_hexrays.chain_visitor_t.__disown__ (method) +ida_hexrays.chain_visitor_t.__disown__(self) -ida_hexrays.chain_visitor_t.__init__ (method) - __init__(self) -> chain_visitor_t - - @param self: PyObject * +ida_hexrays.chain_visitor_t.__init__(self) -ida_hexrays.chain_visitor_t.parent (variable) +ida_hexrays.chain_visitor_t.parent parent of the current chain -ida_hexrays.chain_visitor_t.visit_chain (method) - visit_chain(self, nblock, ch) -> int - - @param nblock: int - @param ch: chain_t & +ida_hexrays.chain_visitor_t.visit_chain(self, nblock: int, ch: "chain_t") -> int -ida_hexrays.change_hexrays_config (function) - change_hexrays_config(directive) -> bool - Parse DIRECTIVE and update the current configuration variables. For the syntax - see hexrays.cfg - - @param directive: (C++: const char *) char const * +ida_hexrays.change_hexrays_config(directive: str) -> bool + Parse DIRECTIVE and update the current configuration variables. For the syntax see hexrays.cfg + -ida_hexrays.checkout_hexrays_license (function) - checkout_hexrays_license(silent) -> bool - Check out a floating decompiler license. This function will display a dialog box - if the license is not available. For non-floating licenses this function is - effectively no-op. It is not necessary to call this function before decompiling. - If the license was not checked out, the decompiler will automatically do it. - This function can be used to check out a license in advance and ensure that a - license is available. - - @param silent: (C++: bool) silently fail if the license cannot be checked out. - @return: false if failed +ida_hexrays.cif_t -ida_hexrays.cif_t (class) - Proxy of C++ cif_t class. +ida_hexrays.cif_t.__eq__(self, r: "cif_t") -> bool -ida_hexrays.cif_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cif_t const & +ida_hexrays.cif_t.__ge__(self, r: "cif_t") -> bool -ida_hexrays.cif_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cif_t const & +ida_hexrays.cif_t.__gt__(self, r: "cif_t") -> bool -ida_hexrays.cif_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cif_t const & +ida_hexrays.cif_t.__init__(self, *args) -ida_hexrays.cif_t.__init__ (method) - __init__(self) -> cif_t - __init__(self, r) -> cif_t - - @param r: cif_t const & +ida_hexrays.cif_t.__le__(self, r: "cif_t") -> bool -ida_hexrays.cif_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cif_t const & +ida_hexrays.cif_t.__lt__(self, r: "cif_t") -> bool -ida_hexrays.cif_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cif_t const & +ida_hexrays.cif_t.__ne__(self, r: "cif_t") -> bool -ida_hexrays.cif_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cif_t const & +ida_hexrays.cif_t.assign(self, r: "cif_t") -> "cif_t &" -ida_hexrays.cif_t.assign (method) - assign(self, r) -> cif_t - - @param r: cif_t const & +ida_hexrays.cif_t.cleanup(self) -> None -ida_hexrays.cif_t.cleanup (method) - cleanup(self) +ida_hexrays.cif_t.compare(self, r: "cif_t") -> int -ida_hexrays.cif_t.compare (method) - compare(self, r) -> int - - @param r: cif_t const & - -ida_hexrays.cif_t.ielse (variable) +ida_hexrays.cif_t.ielse Else-branch of the if-statement. May be nullptr. -ida_hexrays.cif_t.ithen (variable) +ida_hexrays.cif_t.ithen Then-branch of the if-statement. -ida_hexrays.cinsn_details (function) +ida_hexrays.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. -ida_hexrays.cinsn_list_t (class) - Proxy of C++ qlist< cinsn_t > class. - -ida_hexrays.cinsn_list_t.__eq__ (method) - __eq__(self, x) -> bool - - @param x: qlist< cinsn_t > const & - -ida_hexrays.cinsn_list_t.__getitem__ (method) - __getitem__(self, i) -> cinsn_t - - @param i: size_t - -ida_hexrays.cinsn_list_t.__init__ (method) - __init__(self) -> cinsn_list_t - __init__(self, x) -> cinsn_list_t - - @param x: qlist< cinsn_t > const & - -ida_hexrays.cinsn_list_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.cinsn_list_t.__ne__ (method) - __ne__(self, x) -> bool - - @param x: qlist< cinsn_t > const & - -ida_hexrays.cinsn_list_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: cinsn_t const & - -ida_hexrays.cinsn_list_t.at (method) +ida_hexrays.cinsn_list_t -ida_hexrays.cinsn_list_t.back (method) - back(self) -> cinsn_t - -ida_hexrays.cinsn_list_t.begin (method) - begin(self) -> cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t.clear (method) - clear(self) - -ida_hexrays.cinsn_list_t.empty (method) - empty(self) -> bool - -ida_hexrays.cinsn_list_t.end (method) - end(self) -> cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t.erase (method) - erase(self, p) - - @param p: cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t.find (method) - -ida_hexrays.cinsn_list_t.front (method) - front(self) -> cinsn_t - -ida_hexrays.cinsn_list_t.index (method) - -ida_hexrays.cinsn_list_t.insert (method) - insert(self, i, v) - - @param i: size_t - @param v: cinsn_t const & - - insert(self, p, x) -> cinsn_list_t_iterator - - @param p: cinsn_list_t_iterator - @param x: cinsn_t const & - -ida_hexrays.cinsn_list_t.pop_back (method) - pop_back(self) - -ida_hexrays.cinsn_list_t.pop_front (method) - pop_front(self) - -ida_hexrays.cinsn_list_t.push_back (method) - push_back(self, x) - - @param x: cinsn_t const & - - push_back(self) -> cinsn_t - -ida_hexrays.cinsn_list_t.push_front (method) - push_front(self, x) - - @param x: cinsn_t const & +ida_hexrays.cinsn_list_t.__eq__(self, x: "cinsn_list_t") -> bool -ida_hexrays.cinsn_list_t.rbegin (method) - rbegin(self) -> qlist< cinsn_t >::reverse_iterator - rbegin(self) -> qlist< cinsn_t >::const_reverse_iterator +ida_hexrays.cinsn_list_t.__getitem__(self, i: "size_t") -> "cinsn_t const &" -ida_hexrays.cinsn_list_t.remove (method) - remove(self, v) -> bool - - @param v: cinsn_t const & +ida_hexrays.cinsn_list_t.__init__(self, *args) -ida_hexrays.cinsn_list_t.rend (method) - rend(self) -> qlist< cinsn_t >::reverse_iterator - rend(self) -> qlist< cinsn_t >::const_reverse_iterator +ida_hexrays.cinsn_list_t.__len__(self) -> "size_t" -ida_hexrays.cinsn_list_t.size (method) - size(self) -> size_t +ida_hexrays.cinsn_list_t.__ne__(self, x: "cinsn_list_t") -> bool -ida_hexrays.cinsn_list_t.swap (method) - swap(self, x) - - @param x: qlist< cinsn_t > & +ida_hexrays.cinsn_list_t.__setitem__(self, i: "size_t", v: "cinsn_t") -> None -ida_hexrays.cinsn_list_t_iterator (class) - Proxy of C++ cinsn_list_t_iterator class. +ida_hexrays.cinsn_list_t.at(self, index) -ida_hexrays.cinsn_list_t_iterator.__eq__ (method) - __eq__(self, x) -> bool - - @param x: cinsn_list_t_iterator const * - -ida_hexrays.cinsn_list_t_iterator.__init__ (method) - __init__(self) -> cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t_iterator.__ne__ (method) - __ne__(self, x) -> bool - - @param x: cinsn_list_t_iterator const * - -ida_hexrays.cinsn_list_t_iterator.__next__ (method) - __next__(self) - -ida_hexrays.cinsn_t (class) - Proxy of C++ cinsn_t class. - -ida_hexrays.cinsn_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__init__ (method) - __init__(self) -> cinsn_t - __init__(self, r) -> cinsn_t - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t._deregister (method) - _deregister(self) - -ida_hexrays.cinsn_t._get_casm (method) - _get_casm(self) -> casm_t - -ida_hexrays.cinsn_t._get_cblock (method) - _get_cblock(self) -> cblock_t - -ida_hexrays.cinsn_t._get_cdo (method) - _get_cdo(self) -> cdo_t - -ida_hexrays.cinsn_t._get_cexpr (method) - _get_cexpr(self) -> cexpr_t - -ida_hexrays.cinsn_t._get_cfor (method) - _get_cfor(self) -> cfor_t - -ida_hexrays.cinsn_t._get_cgoto (method) - _get_cgoto(self) -> cgoto_t - -ida_hexrays.cinsn_t._get_cif (method) - _get_cif(self) -> cif_t - -ida_hexrays.cinsn_t._get_creturn (method) - _get_creturn(self) -> creturn_t - -ida_hexrays.cinsn_t._get_cswitch (method) - _get_cswitch(self) -> cswitch_t - -ida_hexrays.cinsn_t._get_cwhile (method) - _get_cwhile(self) -> cwhile_t - -ida_hexrays.cinsn_t._print (method) - _print(self, indent, vp, use_curly=CALC_CURLY_BRACES) - - Parameters - ---------- - indent: int - vp: vc_printer_t & - use_curly: enum use_curly_t - -ida_hexrays.cinsn_t._register (method) - _register(self) - -ida_hexrays.cinsn_t._replace_by (method) - _replace_by(self, r) - - Parameters - ---------- - r: cinsn_t * - -ida_hexrays.cinsn_t._set_casm (method) - _set_casm(self, _v) - - Parameters - ---------- - _v: casm_t * - -ida_hexrays.cinsn_t._set_cblock (method) - _set_cblock(self, _v) - - Parameters - ---------- - _v: cblock_t * - -ida_hexrays.cinsn_t._set_cdo (method) - _set_cdo(self, _v) - - Parameters - ---------- - _v: cdo_t * - -ida_hexrays.cinsn_t._set_cexpr (method) - _set_cexpr(self, _v) - - Parameters - ---------- - _v: cexpr_t * - -ida_hexrays.cinsn_t._set_cfor (method) - _set_cfor(self, _v) - - Parameters - ---------- - _v: cfor_t * - -ida_hexrays.cinsn_t._set_cgoto (method) - _set_cgoto(self, _v) - - Parameters - ---------- - _v: cgoto_t * - -ida_hexrays.cinsn_t._set_cif (method) - _set_cif(self, _v) - - Parameters - ---------- - _v: cif_t * - -ida_hexrays.cinsn_t._set_creturn (method) - _set_creturn(self, _v) - - Parameters - ---------- - _v: creturn_t * - -ida_hexrays.cinsn_t._set_cswitch (method) - _set_cswitch(self, _v) - - Parameters - ---------- - _v: cswitch_t * - -ida_hexrays.cinsn_t._set_cwhile (method) - _set_cwhile(self, _v) - - Parameters - ---------- - _v: cwhile_t * - -ida_hexrays.cinsn_t.assign (method) - assign(self, r) -> cinsn_t - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.casm (variable) +ida_hexrays.cinsn_list_t.back(self, *args) -> "cinsn_t const &" + +ida_hexrays.cinsn_list_t.begin(self) -> "cinsn_list_t_iterator" + +ida_hexrays.cinsn_list_t.clear(self) -> None + +ida_hexrays.cinsn_list_t.empty(self) -> bool + +ida_hexrays.cinsn_list_t.end(self) -> "cinsn_list_t_iterator" + +ida_hexrays.cinsn_list_t.erase(self, p: "cinsn_list_t_iterator") -> None + +ida_hexrays.cinsn_list_t.find(self, item) + +ida_hexrays.cinsn_list_t.front(self, *args) -> "cinsn_t const &" + +ida_hexrays.cinsn_list_t.index(self, item) + +ida_hexrays.cinsn_list_t.insert(self, *args) -> "cinsn_list_t_iterator" + +ida_hexrays.cinsn_list_t.pop_back(self) -> None + +ida_hexrays.cinsn_list_t.pop_front(self) -> None + +ida_hexrays.cinsn_list_t.push_back(self, *args) -> "cinsn_t &" + +ida_hexrays.cinsn_list_t.push_front(self, x: "cinsn_t") -> None + +ida_hexrays.cinsn_list_t.rbegin(self, *args) -> "qlist< cinsn_t >::const_reverse_iterator" + +ida_hexrays.cinsn_list_t.remove(self, v: "cinsn_t") -> bool + +ida_hexrays.cinsn_list_t.rend(self, *args) -> "qlist< cinsn_t >::const_reverse_iterator" + +ida_hexrays.cinsn_list_t.size(self) -> "size_t" + +ida_hexrays.cinsn_list_t.splice(self, pos: "qlist< cinsn_t >::iterator", other: "cinsn_list_t", first: "qlist< cinsn_t >::iterator", last: "qlist< cinsn_t >::iterator") -> None + +ida_hexrays.cinsn_list_t.swap(self, x: "cinsn_list_t") -> None + +ida_hexrays.cinsn_list_t_iterator + +ida_hexrays.cinsn_list_t_iterator.__eq__(self, x: "cinsn_list_t_iterator") -> bool + +ida_hexrays.cinsn_list_t_iterator.__init__(self) + +ida_hexrays.cinsn_list_t_iterator.__ne__(self, x: "cinsn_list_t_iterator") -> bool + +ida_hexrays.cinsn_list_t_iterator.__next__(self) -> None + +ida_hexrays.cinsn_t + +ida_hexrays.cinsn_t.__eq__(self, r: "cinsn_t") -> bool + +ida_hexrays.cinsn_t.__ge__(self, r: "cinsn_t") -> bool + +ida_hexrays.cinsn_t.__gt__(self, r: "cinsn_t") -> bool + +ida_hexrays.cinsn_t.__init__(self, *args) + +ida_hexrays.cinsn_t.__le__(self, r: "cinsn_t") -> bool + +ida_hexrays.cinsn_t.__lt__(self, r: "cinsn_t") -> bool + +ida_hexrays.cinsn_t.__ne__(self, r: "cinsn_t") -> bool + +ida_hexrays.cinsn_t._deregister(self) -> None + +ida_hexrays.cinsn_t._get_casm(self) -> "casm_t *" + +ida_hexrays.cinsn_t._get_cblock(self) -> "cblock_t *" + +ida_hexrays.cinsn_t._get_cdo(self) -> "cdo_t *" + +ida_hexrays.cinsn_t._get_cexpr(self) -> "cexpr_t *" + +ida_hexrays.cinsn_t._get_cfor(self) -> "cfor_t *" + +ida_hexrays.cinsn_t._get_cgoto(self) -> "cgoto_t *" + +ida_hexrays.cinsn_t._get_cif(self) -> "cif_t *" + +ida_hexrays.cinsn_t._get_creturn(self) -> "creturn_t *" + +ida_hexrays.cinsn_t._get_cswitch(self) -> "cswitch_t *" + +ida_hexrays.cinsn_t._get_cwhile(self) -> "cwhile_t *" + +ida_hexrays.cinsn_t._print(self, indent: int, vp: "vc_printer_t", use_curly: "use_curly_t" = CALC_CURLY_BRACES) -> None + +ida_hexrays.cinsn_t._register(self) -> None + +ida_hexrays.cinsn_t._replace_by(self, r: "cinsn_t") -> None + +ida_hexrays.cinsn_t._set_casm(self, _v: "casm_t") -> None + +ida_hexrays.cinsn_t._set_cblock(self, _v: "cblock_t") -> None + +ida_hexrays.cinsn_t._set_cdo(self, _v: "cdo_t") -> None + +ida_hexrays.cinsn_t._set_cexpr(self, _v: "cexpr_t") -> None + +ida_hexrays.cinsn_t._set_cfor(self, _v: "cfor_t") -> None + +ida_hexrays.cinsn_t._set_cgoto(self, _v: "cgoto_t") -> None + +ida_hexrays.cinsn_t._set_cif(self, _v: "cif_t") -> None + +ida_hexrays.cinsn_t._set_creturn(self, _v: "creturn_t") -> None + +ida_hexrays.cinsn_t._set_cswitch(self, _v: "cswitch_t") -> None + +ida_hexrays.cinsn_t._set_cwhile(self, _v: "cwhile_t") -> None + +ida_hexrays.cinsn_t.assign(self, r: "cinsn_t") -> "cinsn_t &" + +ida_hexrays.cinsn_t.casm details of asm-statement -ida_hexrays.cinsn_t.cblock (variable) +ida_hexrays.cinsn_t.cblock details of block-statement -ida_hexrays.cinsn_t.cdo (variable) +ida_hexrays.cinsn_t.cdo details of do-statement -ida_hexrays.cinsn_t.cexpr (variable) +ida_hexrays.cinsn_t.cexpr details of expression-statement -ida_hexrays.cinsn_t.cfor (variable) +ida_hexrays.cinsn_t.cfor details of for-statement -ida_hexrays.cinsn_t.cgoto (variable) +ida_hexrays.cinsn_t.cgoto details of goto-statement -ida_hexrays.cinsn_t.cif (variable) +ida_hexrays.cinsn_t.cif details of if-statement -ida_hexrays.cinsn_t.cleanup (method) - cleanup(self) - Cleanup the statement. This function properly deletes all children and sets the - item type to cit_empty. +ida_hexrays.cinsn_t.cleanup(self) -> None + Cleanup the statement. This function properly deletes all children and sets the item type to cit_empty. + -ida_hexrays.cinsn_t.collect_free_breaks (method) - collect_free_breaks(self, breaks) -> bool - Collect free break statements. This function finds all free break statements - within the current statement. A break statement is free if it does not have a - loop or switch parent that that is also within the current statement. - - @param breaks: (C++: cinsnptrvec_t *) pointer to the variable where the vector of all found free break - statements is returned. This argument can be nullptr. - @return: true if some free break statements have been found +ida_hexrays.cinsn_t.collect_free_breaks(self, breaks: "cinsnptrvec_t") -> bool + Collect free `break` statements. This function finds all free `break` statements within the current statement. A `break` statement is free if it does not have a loop or switch parent that that is also within the current statement. + + @param breaks: pointer to the variable where the vector of all found free `break` statements is returned. This argument can be nullptr. + @returns true if some free `break` statements have been found -ida_hexrays.cinsn_t.collect_free_continues (method) - collect_free_continues(self, continues) -> bool - Collect free continue statements. This function finds all free continue - statements within the current statement. A continue statement is free if it does - not have a loop parent that that is also within the current statement. - - @param continues: (C++: cinsnptrvec_t *) pointer to the variable where the vector of all found free - continue statements is returned. This argument can be nullptr. - @return: true if some free continue statements have been found +ida_hexrays.cinsn_t.collect_free_continues(self, continues: "cinsnptrvec_t") -> bool + Collect free `continue` statements. This function finds all free `continue` statements within the current statement. A `continue` statement is free if it does not have a loop parent that that is also within the current statement. + + @param continues: pointer to the variable where the vector of all found free `continue` statements is returned. This argument can be nullptr. + @returns true if some free `continue` statements have been found -ida_hexrays.cinsn_t.compare (method) - compare(self, r) -> int - - @param r: cinsn_t const & +ida_hexrays.cinsn_t.compare(self, r: "cinsn_t") -> int -ida_hexrays.cinsn_t.contains_free_break (method) - contains_free_break(self) -> bool - Check if the statement has free break statements. +ida_hexrays.cinsn_t.contains_free_break(self) -> bool + Check if the statement has free `break` statements. -ida_hexrays.cinsn_t.contains_free_continue (method) - contains_free_continue(self) -> bool - Check if the statement has free continue statements. +ida_hexrays.cinsn_t.contains_free_continue(self) -> bool + Check if the statement has free `continue` statements. -ida_hexrays.cinsn_t.contains_insn (method) - contains_insn(self, type, times=1) -> bool - Check if the statement contains a statement of the specified type. - - @param type: (C++: ctype_t) statement opcode to look for - @param times: (C++: int) how many times TYPE should be present - @return: true if the statement has at least TIMES children with opcode == TYPE +ida_hexrays.cinsn_t.contains_insn(self, type: "ctype_t", times: int = 1) -> bool + Check if the statement contains a statement of the specified type. + + @param type: statement opcode to look for + @param times: how many times TYPE should be present + @returns true if the statement has at least TIMES children with opcode == TYPE -ida_hexrays.cinsn_t.create_if (method) - create_if(self, cnd) -> cif_t - Create a new if-statement. The current statement must be a block. The new - statement will be appended to it. - - @param cnd: (C++: cexpr_t *) if condition. It will be deleted after being copied. +ida_hexrays.cinsn_t.create_if(self, cnd: "cexpr_t") -> "cif_t &" + Create a new if-statement. The current statement must be a block. The new statement will be appended to it. + + @param cnd: if condition. It will be deleted after being copied. -ida_hexrays.cinsn_t.creturn (variable) +ida_hexrays.cinsn_t.creturn details of return-statement -ida_hexrays.cinsn_t.cswitch (variable) +ida_hexrays.cinsn_t.cswitch details of switch-statement -ida_hexrays.cinsn_t.cwhile (variable) +ida_hexrays.cinsn_t.cthrow + details of throw-statement + +ida_hexrays.cinsn_t.ctry + details of try-statement + +ida_hexrays.cinsn_t.cwhile details of while-statement -ida_hexrays.cinsn_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.cinsn_t.dstr(self) -> str -ida_hexrays.cinsn_t.insn_is_epilog (method) - insn_is_epilog(insn) -> bool - - @param insn: cinsn_t const * +ida_hexrays.cinsn_t.insn_is_epilog(insn: "cinsn_t") -> bool -ida_hexrays.cinsn_t.is_epilog (method) +ida_hexrays.cinsn_t.is_epilog(self) -ida_hexrays.cinsn_t.is_ordinary_flow (method) - is_ordinary_flow(self) -> bool - Check if the statement passes execution to the next statement. - - @return: false if the statement breaks the control flow (like goto, return, etc) +ida_hexrays.cinsn_t.is_ordinary_flow(self) -> bool + Check if the statement passes execution to the next statement. + + @returns false if the statement breaks the control flow (like goto, return, etc) -ida_hexrays.cinsn_t.new_insn (method) - new_insn(self, insn_ea) -> cinsn_t - Create a new statement. The current statement must be a block. The new statement - will be appended to it. - - @param insn_ea: (C++: ea_t) statement address +ida_hexrays.cinsn_t.new_insn(self, insn_ea: ida_idaapi.ea_t) -> "cinsn_t &" + Create a new statement. The current statement must be a block. The new statement will be appended to it. + + @param insn_ea: statement address -ida_hexrays.cinsn_t.print1 (method) - print1(self, func) - Print the statement into one line. Currently this function is not available. - - @param func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced - variable names. +ida_hexrays.cinsn_t.print1(self, func: "cfunc_t") -> None + Print the statement into one line. Currently this function is not available. + + @param func: parent function. This argument is used to find out the referenced variable names. -ida_hexrays.cinsn_t.swap (method) - swap(self, r) - - @param r: cinsn_t & +ida_hexrays.cinsn_t.swap(self, r: "cinsn_t") -> None -ida_hexrays.cinsn_t.zero (method) - zero(self) +ida_hexrays.cinsn_t.zero(self) -> None Overwrite with zeroes without cleaning memory or deleting children. -ida_hexrays.cinsn_t_insn_is_epilog (function) - cinsn_t_insn_is_epilog(insn) -> bool - - @param insn: cinsn_t const * +ida_hexrays.cinsnptrvec_t -ida_hexrays.cinsnptrvec_t (class) - Proxy of C++ qvector< cinsn_t * > class. +ida_hexrays.cinsnptrvec_t.__eq__(self, r: "cinsnptrvec_t") -> bool -ida_hexrays.cinsnptrvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< cinsn_t * > const & +ida_hexrays.cinsnptrvec_t.__getitem__(self, i: "size_t") -> "cinsn_t *const &" -ida_hexrays.cinsnptrvec_t.__getitem__ (method) - __getitem__(self, i) -> cinsn_t - - @param i: size_t +ida_hexrays.cinsnptrvec_t.__init__(self, *args) -ida_hexrays.cinsnptrvec_t.__init__ (method) - __init__(self) -> cinsnptrvec_t - __init__(self, x) -> cinsnptrvec_t - - @param x: qvector< cinsn_t * > const & +ida_hexrays.cinsnptrvec_t.__len__(self) -> "size_t" -ida_hexrays.cinsnptrvec_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.cinsnptrvec_t.__ne__(self, r: "cinsnptrvec_t") -> bool -ida_hexrays.cinsnptrvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< cinsn_t * > const & +ida_hexrays.cinsnptrvec_t.__setitem__(self, i: "size_t", v: "cinsn_t") -> None -ida_hexrays.cinsnptrvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: cinsn_t *const & +ida_hexrays.cinsnptrvec_t._del(self, x: "cinsn_t") -> bool -ida_hexrays.cinsnptrvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: cinsn_t *const & +ida_hexrays.cinsnptrvec_t.add_unique(self, x: "cinsn_t") -> bool -ida_hexrays.cinsnptrvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: cinsn_t *const & +ida_hexrays.cinsnptrvec_t.append(self, x: "cinsn_t") -> None -ida_hexrays.cinsnptrvec_t.at (method) - at(self, _idx) -> cinsn_t - - @param _idx: size_t +ida_hexrays.cinsnptrvec_t.at(self, _idx: "size_t") -> "cinsn_t *const &" -ida_hexrays.cinsnptrvec_t.begin (method) - begin(self) -> qvector< cinsn_t * >::iterator - begin(self) -> qvector< cinsn_t * >::const_iterator +ida_hexrays.cinsnptrvec_t.begin(self, *args) -> "qvector< cinsn_t * >::const_iterator" -ida_hexrays.cinsnptrvec_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.cinsnptrvec_t.capacity(self) -> "size_t" -ida_hexrays.cinsnptrvec_t.clear (method) - clear(self) +ida_hexrays.cinsnptrvec_t.clear(self) -> None -ida_hexrays.cinsnptrvec_t.empty (method) - empty(self) -> bool +ida_hexrays.cinsnptrvec_t.empty(self) -> bool -ida_hexrays.cinsnptrvec_t.end (method) - end(self) -> qvector< cinsn_t * >::iterator - end(self) -> qvector< cinsn_t * >::const_iterator +ida_hexrays.cinsnptrvec_t.end(self, *args) -> "qvector< cinsn_t * >::const_iterator" -ida_hexrays.cinsnptrvec_t.erase (method) - erase(self, it) -> qvector< cinsn_t * >::iterator - - @param it: qvector< cinsn_t * >::iterator - - erase(self, first, last) -> qvector< cinsn_t * >::iterator - - @param first: qvector< cinsn_t * >::iterator - @param last: qvector< cinsn_t * >::iterator +ida_hexrays.cinsnptrvec_t.erase(self, *args) -> "qvector< cinsn_t * >::iterator" -ida_hexrays.cinsnptrvec_t.extract (method) - extract(self) -> cinsn_t ** +ida_hexrays.cinsnptrvec_t.extend(self, x: "cinsnptrvec_t") -> None -ida_hexrays.cinsnptrvec_t.find (method) - find(self, x) -> qvector< cinsn_t * >::iterator - - @param x: cinsn_t *const & - - find(self, x) -> qvector< cinsn_t * >::const_iterator - - @param x: cinsn_t *const & +ida_hexrays.cinsnptrvec_t.extract(self) -> "cinsn_t **" -ida_hexrays.cinsnptrvec_t.has (method) - has(self, x) -> bool - - @param x: cinsn_t *const & +ida_hexrays.cinsnptrvec_t.find(self, *args) -> "qvector< cinsn_t * >::const_iterator" -ida_hexrays.cinsnptrvec_t.inject (method) - inject(self, s, len) - - @param s: cinsn_t ** - @param len: size_t +ida_hexrays.cinsnptrvec_t.has(self, x: "cinsn_t") -> bool -ida_hexrays.cinsnptrvec_t.insert (method) - insert(self, it, x) -> qvector< cinsn_t * >::iterator - - @param it: qvector< cinsn_t * >::iterator - @param x: cinsn_t *const & +ida_hexrays.cinsnptrvec_t.inject(self, s: "cinsn_t **", len: "size_t") -> None -ida_hexrays.cinsnptrvec_t.pop_back (method) - pop_back(self) +ida_hexrays.cinsnptrvec_t.insert(self, it: "qvector< cinsn_t * >::iterator", x: "cinsn_t") -> "qvector< cinsn_t * >::iterator" -ida_hexrays.cinsnptrvec_t.push_back (method) - push_back(self, x) - - @param x: cinsn_t *const & - - push_back(self) -> cinsn_t *& +ida_hexrays.cinsnptrvec_t.pop_back(self) -> None -ida_hexrays.cinsnptrvec_t.qclear (method) - qclear(self) +ida_hexrays.cinsnptrvec_t.push_back(self, *args) -> "cinsn_t *&" -ida_hexrays.cinsnptrvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.cinsnptrvec_t.qclear(self) -> None -ida_hexrays.cinsnptrvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: cinsn_t *const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.cinsnptrvec_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.cinsnptrvec_t.size (method) - size(self) -> size_t +ida_hexrays.cinsnptrvec_t.resize(self, *args) -> None -ida_hexrays.cinsnptrvec_t.swap (method) - swap(self, r) - - @param r: qvector< cinsn_t * > & +ida_hexrays.cinsnptrvec_t.size(self) -> "size_t" -ida_hexrays.cinsnptrvec_t.truncate (method) - truncate(self) +ida_hexrays.cinsnptrvec_t.swap(self, r: "cinsnptrvec_t") -> None -ida_hexrays.cit_asm (variable) +ida_hexrays.cinsnptrvec_t.truncate(self) -> None + +ida_hexrays.cit_asm asm-statement -ida_hexrays.cit_block (variable) +ida_hexrays.cit_block block-statement: { ... } -ida_hexrays.cit_break (variable) +ida_hexrays.cit_break break-statement -ida_hexrays.cit_continue (variable) +ida_hexrays.cit_continue continue-statement -ida_hexrays.cit_do (variable) +ida_hexrays.cit_do do-statement -ida_hexrays.cit_empty (variable) +ida_hexrays.cit_empty instruction types start here -ida_hexrays.cit_expr (variable) +ida_hexrays.cit_expr expression-statement: expr; -ida_hexrays.cit_for (variable) +ida_hexrays.cit_for for-statement -ida_hexrays.cit_goto (variable) +ida_hexrays.cit_goto goto-statement -ida_hexrays.cit_if (variable) +ida_hexrays.cit_if if-statement -ida_hexrays.cit_return (variable) +ida_hexrays.cit_return return-statement -ida_hexrays.cit_switch (variable) +ida_hexrays.cit_switch switch-statement -ida_hexrays.cit_while (variable) +ida_hexrays.cit_throw + C++ throw-statement. + +ida_hexrays.cit_try + C++ try-statement. + +ida_hexrays.cit_while while-statement -ida_hexrays.citem_cmt_t (class) - Proxy of C++ citem_cmt_t class. +ida_hexrays.citem_cmt_t -ida_hexrays.citem_cmt_t.__init__ (method) - __init__(self) -> citem_cmt_t - __init__(self, s) -> citem_cmt_t - - @param s: char const * +ida_hexrays.citem_cmt_t.__init__(self, *args) -ida_hexrays.citem_cmt_t.__str__ (method) - __str__(self) -> char const * +ida_hexrays.citem_cmt_t.__str__(self) -> str -ida_hexrays.citem_cmt_t.c_str (method) - c_str(self) -> char const * +ida_hexrays.citem_cmt_t.c_str(self) -> str -ida_hexrays.citem_cmt_t.used (variable) +ida_hexrays.citem_cmt_t.used the comment has been retrieved? -ida_hexrays.citem_locator_t (class) - Proxy of C++ citem_locator_t class. +ida_hexrays.citem_locator_t -ida_hexrays.citem_locator_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: citem_locator_t const & +ida_hexrays.citem_locator_t.__eq__(self, r: "citem_locator_t") -> bool -ida_hexrays.citem_locator_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: citem_locator_t const & +ida_hexrays.citem_locator_t.__ge__(self, r: "citem_locator_t") -> bool -ida_hexrays.citem_locator_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: citem_locator_t const & +ida_hexrays.citem_locator_t.__gt__(self, r: "citem_locator_t") -> bool -ida_hexrays.citem_locator_t.__init__ (method) - __init__(self, _ea, _op) -> citem_locator_t - - @param _ea: ea_t - @param _op: enum ctype_t - - __init__(self, i) -> citem_locator_t - - @param i: citem_t const * +ida_hexrays.citem_locator_t.__init__(self, *args) -ida_hexrays.citem_locator_t.__le__ (method) - __le__(self, r) -> bool - - @param r: citem_locator_t const & +ida_hexrays.citem_locator_t.__le__(self, r: "citem_locator_t") -> bool -ida_hexrays.citem_locator_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: citem_locator_t const & +ida_hexrays.citem_locator_t.__lt__(self, r: "citem_locator_t") -> bool -ida_hexrays.citem_locator_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: citem_locator_t const & +ida_hexrays.citem_locator_t.__ne__(self, r: "citem_locator_t") -> bool -ida_hexrays.citem_locator_t.compare (method) - compare(self, r) -> int - - @param r: citem_locator_t const & +ida_hexrays.citem_locator_t.compare(self, r: "citem_locator_t") -> int -ida_hexrays.citem_locator_t.ea (variable) +ida_hexrays.citem_locator_t.ea citem address -ida_hexrays.citem_locator_t.op (variable) +ida_hexrays.citem_locator_t.op citem operation -ida_hexrays.citem_t (class) - Proxy of C++ citem_t class. +ida_hexrays.citem_t -ida_hexrays.citem_t.__dbg_get_meminfo (method) - __dbg_get_meminfo(self) -> qstring +ida_hexrays.citem_t.__dbg_get_meminfo(self) -> str -ida_hexrays.citem_t.__dbg_get_registered_kind (method) - __dbg_get_registered_kind(self) -> int +ida_hexrays.citem_t.__dbg_get_registered_kind(self) -> int -ida_hexrays.citem_t.__init__ (method) - __init__(self, o=cot_empty) -> citem_t - - @param o: enum ctype_t +ida_hexrays.citem_t.__init__(self, o: "ctype_t" = cot_empty) -ida_hexrays.citem_t._acquire_ownership (method) +ida_hexrays.citem_t._acquire_ownership(self, v, acquire) -ida_hexrays.citem_t._ensure_cond (method) +ida_hexrays.citem_t._ensure_cond(self, ok, cond_str) -ida_hexrays.citem_t._ensure_no_obj (method) +ida_hexrays.citem_t._ensure_no_obj(self, o, attr, attr_is_acquired) -ida_hexrays.citem_t._ensure_no_op (method) +ida_hexrays.citem_t._ensure_no_op(self) -ida_hexrays.citem_t._ensure_ownership_transferrable (method) +ida_hexrays.citem_t._ensure_ownership_transferrable(self, v) -ida_hexrays.citem_t._get_op (method) - _get_op(self) -> ctype_t +ida_hexrays.citem_t._get_op(self) -> "ctype_t" -ida_hexrays.citem_t._maybe_disown_and_deregister (method) +ida_hexrays.citem_t._maybe_disown_and_deregister(self) -ida_hexrays.citem_t._meminfo (method) +ida_hexrays.citem_t._meminfo(self) -ida_hexrays.citem_t._obj_id (method) - _obj_id(self) -> PyObject * +ida_hexrays.citem_t._obj_id(self) -> "PyObject *" -ida_hexrays.citem_t._own_and_register (method) +ida_hexrays.citem_t._own_and_register(self) -ida_hexrays.citem_t._set_op (method) - _set_op(self, v) - - Parameters - ---------- - v: enum ctype_t +ida_hexrays.citem_t._set_op(self, v: "ctype_t") -> None -ida_hexrays.citem_t.contains_expr (method) - contains_expr(self, e) -> bool +ida_hexrays.citem_t.contains_expr(self, e: "cexpr_t") -> bool Does the item contain an expression? - - @param e: (C++: const cexpr_t *) cexpr_t const * -ida_hexrays.citem_t.contains_label (method) - contains_label(self) -> bool +ida_hexrays.citem_t.contains_label(self) -> bool Does the item contain a label? -ida_hexrays.citem_t.ea (variable) +ida_hexrays.citem_t.ea address that corresponds to the item. may be BADADDR -ida_hexrays.citem_t.find_closest_addr (method) - find_closest_addr(self, _ea) -> citem_t - - @param _ea: ea_t +ida_hexrays.citem_t.find_closest_addr(self, _ea: ida_idaapi.ea_t) -> "citem_t *" -ida_hexrays.citem_t.find_parent_of (method) - find_parent_of(self, sitem) -> citem_t - - @param sitem: citem_t const * - - find_parent_of(self, item) -> citem_t - - @param item: citem_t const * +ida_hexrays.citem_t.find_parent_of(self, item: "citem_t") -> "citem_t *" + Find parent of the specified item. + + @param item: Item to find the parent of. The search will be performed among the children of the item pointed by `this`. + @returns nullptr if not found -ida_hexrays.citem_t.index (variable) - an index in cfunc_t::treeitems. meaningful only after print_func() +ida_hexrays.citem_t.index + an index in cfunc_t::treeitems. meaningful only after print_func() + -ida_hexrays.citem_t.is_expr (method) - is_expr(self) -> bool +ida_hexrays.citem_t.is_expr(self) -> bool Is an expression? -ida_hexrays.citem_t.label_num (variable) - label number. -1 means no label. items of the expression types (cot_...) should - not have labels at the final maturity level, but at the intermediate levels any - ctree item may have a label. Labels must be unique. Usually they correspond to - the basic block numbers. +ida_hexrays.citem_t.label_num + label number. -1 means no label. items of the expression types (cot_...) should not have labels at the final maturity level, but at the intermediate levels any ctree item may have a label. Labels must be unique. Usually they correspond to the basic block numbers. + -ida_hexrays.citem_t.op (variable) +ida_hexrays.citem_t.op item type -ida_hexrays.citem_t.print1 (method) - print1(self, func) - Print item into one line. - - @param func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced - variable names. - @return: length of the generated text. +ida_hexrays.citem_t.print1(self, func: "cfunc_t") -> None + Print item into one line. + + @param func: parent function. This argument is used to find out the referenced variable names. + @returns length of the generated text. -ida_hexrays.citem_t.replace_by (method) +ida_hexrays.citem_t.replace_by(self, o) -ida_hexrays.citem_t.swap (method) - swap(self, r) +ida_hexrays.citem_t.swap(self, r: "citem_t") -> None Swap two citem_t. - - @param r: (C++: citem_t &) -ida_hexrays.citem_to_specific_type (function) +ida_hexrays.citem_to_specific_type(self) cast the citem_t object to its more specific type, either cexpr_t or cinsn_t. -ida_hexrays.clear_cached_cfuncs (function) - clear_cached_cfuncs() +ida_hexrays.clear_cached_cfuncs() -> None Flush all cached decompilation results. -ida_hexrays.cloop_t (class) - Proxy of C++ cloop_t class. +ida_hexrays.cloop_t -ida_hexrays.cloop_t.__init__ (method) - __init__(self, b=None) -> cloop_t - - @param b: cinsn_t * - - __init__(self, r) -> cloop_t - - @param r: cloop_t const & +ida_hexrays.cloop_t.__init__(self, *args) -ida_hexrays.cloop_t.assign (method) - assign(self, r) -> cloop_t - - @param r: cloop_t const & +ida_hexrays.cloop_t.assign(self, r: "cloop_t") -> "cloop_t &" -ida_hexrays.cloop_t.cleanup (method) - cleanup(self) +ida_hexrays.cloop_t.cleanup(self) -> None -ida_hexrays.close_hexrays_waitbox (function) - close_hexrays_waitbox() - Close the waitbox displayed by the decompiler. Useful if DECOMP_NO_HIDE was used - during decompilation. +ida_hexrays.close_hexrays_waitbox() -> None + Close the waitbox displayed by the decompiler. Useful if DECOMP_NO_HIDE was used during decompilation. + -ida_hexrays.close_pseudocode (function) - close_pseudocode(f) -> bool - Close pseudocode window. - - @param f: (C++: TWidget *) pointer to window - @return: false if failed +ida_hexrays.close_pseudocode(f: "TWidget *") -> bool + Close pseudocode window. + + @param f: pointer to window + @returns false if failed -ida_hexrays.cnumber_t (class) - Proxy of C++ cnumber_t class. +ida_hexrays.cnumber_t -ida_hexrays.cnumber_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cnumber_t const & +ida_hexrays.cnumber_t.__eq__(self, r: "cnumber_t") -> bool -ida_hexrays.cnumber_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cnumber_t const & +ida_hexrays.cnumber_t.__ge__(self, r: "cnumber_t") -> bool -ida_hexrays.cnumber_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cnumber_t const & +ida_hexrays.cnumber_t.__gt__(self, r: "cnumber_t") -> bool -ida_hexrays.cnumber_t.__init__ (method) - __init__(self, _opnum=0) -> cnumber_t - - @param _opnum: int +ida_hexrays.cnumber_t.__init__(self, _opnum: int = 0) -ida_hexrays.cnumber_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cnumber_t const & +ida_hexrays.cnumber_t.__le__(self, r: "cnumber_t") -> bool -ida_hexrays.cnumber_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cnumber_t const & +ida_hexrays.cnumber_t.__lt__(self, r: "cnumber_t") -> bool -ida_hexrays.cnumber_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cnumber_t const & +ida_hexrays.cnumber_t.__ne__(self, r: "cnumber_t") -> bool -ida_hexrays.cnumber_t._print (method) - _print(self, type, parent=None, nice_stroff=None) - - Parameters - ---------- - type: tinfo_t const & - parent: citem_t const * - nice_stroff: bool * +ida_hexrays.cnumber_t._print(self, type: "tinfo_t", parent: "citem_t" = None, nice_stroff: "bool *" = None) -> None -ida_hexrays.cnumber_t._value (variable) +ida_hexrays.cnumber_t._value its value -ida_hexrays.cnumber_t.assign (method) - assign(self, v, nbytes, sign) - Assign new value - - @param v: (C++: uint64) new value - @param nbytes: (C++: int) size of the new value in bytes - @param sign: (C++: type_sign_t) sign of the value +ida_hexrays.cnumber_t.assign(self, v: "uint64", nbytes: int, sign: "type_sign_t") -> None + Assign new value + + @param v: new value + @param nbytes: size of the new value in bytes + @param sign: sign of the value -ida_hexrays.cnumber_t.compare (method) - compare(self, r) -> int - - @param r: cnumber_t const & +ida_hexrays.cnumber_t.compare(self, r: "cnumber_t") -> int -ida_hexrays.cnumber_t.nf (variable) +ida_hexrays.cnumber_t.nf how to represent it -ida_hexrays.cnumber_t.value (method) - value(self, type) -> uint64 - Get value. This function will properly extend the number sign to 64bits - depending on the type sign. - - @param type: (C++: const tinfo_t &) tinfo_t const & +ida_hexrays.cnumber_t.value(self, type: "tinfo_t") -> "uint64" + Get value. This function will properly extend the number sign to 64bits depending on the type sign. + -ida_hexrays.codegen_t (class) - Proxy of C++ codegen_t class. +ida_hexrays.codegen_t -ida_hexrays.codegen_t.__init__ (method) +ida_hexrays.codegen_t.__init__(self, *args, **kwargs) -ida_hexrays.codegen_t.analyze_prolog (method) - analyze_prolog(self, fc, reachable) -> merror_t - Analyze prolog/epilog of the function to decompile. If prolog is found, allocate - and fill 'mba->pi' structure. - - @param fc: (C++: const class qflow_chart_t &) flow chart - @param reachable: (C++: const class bitset_t &) bitmap of reachable blocks - @return: error code +ida_hexrays.codegen_t.analyze_prolog(self, fc: "qflow_chart_t", reachable: "bitset_t") -> "merror_t" + Analyze prolog/epilog of the function to decompile. If prolog is found, allocate and fill 'mba->pi' structure. + + @param fc: flow chart + @param reachable: bitmap of reachable blocks + @returns error code -ida_hexrays.codegen_t.emit (method) - emit(self, code, width, l, r, d, offsize) -> minsn_t - Emit one microinstruction. This variant accepts pointers to operands. It is more - difficult to use but permits to create virtually any instruction. Operands may - be nullptr when it makes sense. - - @param code: (C++: mcode_t) enum mcode_t - @param width: int - @param l: (C++: const mop_t *) uval_t - @param r: (C++: const mop_t *) uval_t - @param d: (C++: const mop_t *) uval_t - @param offsize: int - - emit(self, code, l, r, d) -> minsn_t - - @param code: enum mcode_t - @param l: mop_t const * - @param r: mop_t const * - @param d: mop_t const * +ida_hexrays.codegen_t.clear(self) -> None -ida_hexrays.codegen_t.emit_micro_mvm (method) - emit_micro_mvm(self, code, dtype, l, r, d, offsize) -> minsn_t - Emit one microinstruction. This variant takes a data type not a size. +ida_hexrays.codegen_t.emit(self, *args) -> "minsn_t *" + This function has the following signatures: - @param code: (C++: mcode_t) enum mcode_t - @param dtype: (C++: op_dtype_t) - @param l: (C++: uval_t) - @param r: (C++: uval_t) - @param d: (C++: uval_t) - @param offsize: (C++: int) - -ida_hexrays.codegen_t.gen_micro (method) - gen_micro(self) -> merror_t - Generate microcode for one instruction. The instruction is in INSN + 0. emit(code: mcode_t, width: int, l: int, r: int, d: int, offsize: int) -> minsn_t * + 1. emit(code: mcode_t, l: const mop_t *, r: const mop_t *, d: const mop_t *) -> minsn_t * - @return: MERR_OK - all ok MERR_BLOCK - all ok, need to switch to new block - MERR_BADBLK - delete current block and continue other error codes are - fatal - -ida_hexrays.codegen_t.load_effective_address (method) - load_effective_address(self, n, flags=0) -> mreg_t - Generate microcode to calculate the address of a memory operand. + # 0: emit(code: mcode_t, width: int, l: int, r: int, d: int, offsize: int) -> minsn_t * - @param n: (C++: int) - number of INSN operand - @param flags: (C++: int) - reserved for future use - @return: register containing the operand address. mr_none - failed (not a memory - operand) - -ida_hexrays.codegen_t.load_operand (method) - load_operand(self, opnum, flags=0) -> mreg_t - Generate microcode to load one operand. + Emit one microinstruction. The L, R, D arguments usually mean the register number. However, they depend on CODE. For example: + * for m_goto and m_jcnd L is the target address + * for m_ldc L is the constant value to load - @param opnum: (C++: int) number of INSN operand - @param flags: (C++: int) reserved for future use - @return: register containing the operand. + + + @returns created microinstruction. can be nullptr if the instruction got immediately optimized away. + + # 1: emit(code: mcode_t, l: const mop_t *, r: const mop_t *, d: const mop_t *) -> minsn_t * + + Emit one microinstruction. This variant accepts pointers to operands. It is more difficult to use but permits to create virtually any instruction. Operands may be nullptr when it makes sense. + -ida_hexrays.codegen_t.microgen_completed (method) - microgen_completed(self) +ida_hexrays.codegen_t.emit_micro_mvm(self, code: "mcode_t", dtype: "op_dtype_t", l: int, r: int, d: int, offsize: int) -> "minsn_t *" + Emit one microinstruction. This variant takes a data type not a size. + + +ida_hexrays.codegen_t.gen_micro(self) -> "merror_t" + Generate microcode for one instruction. The instruction is in INSN + + @returns MERR_OK - all ok MERR_BLOCK - all ok, need to switch to new block MERR_BADBLK - delete current block and continue other error codes are fatal + +ida_hexrays.codegen_t.load_effective_address(self, n: int, flags: int = 0) -> "mreg_t" + Generate microcode to calculate the address of a memory operand. + + @param n: - number of INSN operand + @param flags: - reserved for future use + @returns register containing the operand address. mr_none - failed (not a memory operand) + +ida_hexrays.codegen_t.load_operand(self, opnum: int, flags: int = 0) -> "mreg_t" + Generate microcode to load one operand. + + @param opnum: number of INSN operand + @param flags: reserved for future use + @returns register containing the operand. + +ida_hexrays.codegen_t.microgen_completed(self) -> None This method is called when the microcode generation is done. -ida_hexrays.codegen_t.prepare_gen_micro (method) - prepare_gen_micro(self) -> merror_t - Setup internal data to handle new instruction. This method should be called - before calling gen_micro(). Usually gen_micro() is called by the decompiler. You - have to call this function explicitly only if you yourself call gen_micro(). The - instruction is in INSN - - @return: MERR_OK - all ok other error codes are fatal +ida_hexrays.codegen_t.prepare_gen_micro(self) -> "merror_t" + Setup internal data to handle new instruction. This method should be called before calling gen_micro(). Usually gen_micro() is called by the decompiler. You have to call this function explicitly only if you yourself call gen_micro(). The instruction is in INSN + + @returns MERR_OK - all ok other error codes are fatal -ida_hexrays.codegen_t.store_operand (method) - store_operand(self, n, mop, flags=0, outins=None) -> bool - Generate microcode to store an operand. In case of success an arbitrary number - of instructions can be generated (and even no instruction if the source and - target are the same) - - @param n: (C++: int) - number of target INSN operand - @param mop: (C++: const mop_t &) - operand to be stored - @param flags: (C++: int) - reserved for future use - @param outins: (C++: minsn_t **) - (OUT) the last generated instruction - @return: success +ida_hexrays.codegen_t.store_operand(self, n: int, mop: "mop_t", flags: int = 0, outins: "minsn_t **" = None) -> bool + Generate microcode to store an operand. In case of success an arbitrary number of instructions can be generated (and even no instruction if the source and target are the same) + + @param n: - number of target INSN operand + @param mop: - operand to be stored + @param flags: - reserved for future use + @param outins: - (OUT) the last generated instruction + @returns success -ida_hexrays.convert_to_user_call (function) - convert_to_user_call(udc, cdg) -> merror_t - try to generate user-defined call for an instruction - - @param udc: (C++: const udcall_t &) udcall_t const & - @param cdg: (C++: codegen_t &) - @return: Microcode error codes code: MERR_OK - user-defined call generated else - - error (MERR_INSN == inacceptable udc.tif) +ida_hexrays.convert_to_user_call(udc: "udcall_t", cdg: "codegen_t") -> "merror_t" + try to generate user-defined call for an instruction + + @returns Microcode error codes code: MERR_OK - user-defined call generated else - error (MERR_INSN == inacceptable udc.tif) -ida_hexrays.cot_add (variable) +ida_hexrays.cot_add x + y -ida_hexrays.cot_asg (variable) +ida_hexrays.cot_asg x = y -ida_hexrays.cot_asgadd (variable) +ida_hexrays.cot_asgadd x += y -ida_hexrays.cot_asgband (variable) +ida_hexrays.cot_asgband x &= y -ida_hexrays.cot_asgbor (variable) +ida_hexrays.cot_asgbor x |= y -ida_hexrays.cot_asgmul (variable) +ida_hexrays.cot_asgmul x *= y -ida_hexrays.cot_asgsdiv (variable) +ida_hexrays.cot_asgsdiv x /= y signed -ida_hexrays.cot_asgshl (variable) +ida_hexrays.cot_asgshl x <<= y -ida_hexrays.cot_asgsmod (variable) +ida_hexrays.cot_asgsmod x %= y signed -ida_hexrays.cot_asgsshr (variable) +ida_hexrays.cot_asgsshr x >>= y signed -ida_hexrays.cot_asgsub (variable) +ida_hexrays.cot_asgsub x -= y -ida_hexrays.cot_asgudiv (variable) +ida_hexrays.cot_asgudiv x /= y unsigned -ida_hexrays.cot_asgumod (variable) +ida_hexrays.cot_asgumod x %= y unsigned -ida_hexrays.cot_asgushr (variable) +ida_hexrays.cot_asgushr x >>= y unsigned -ida_hexrays.cot_asgxor (variable) +ida_hexrays.cot_asgxor x ^= y -ida_hexrays.cot_band (variable) +ida_hexrays.cot_band x & y -ida_hexrays.cot_bnot (variable) +ida_hexrays.cot_bnot ~x -ida_hexrays.cot_bor (variable) +ida_hexrays.cot_bor x | y -ida_hexrays.cot_call (variable) +ida_hexrays.cot_call x(...) -ida_hexrays.cot_cast (variable) +ida_hexrays.cot_cast (type)x -ida_hexrays.cot_comma (variable) +ida_hexrays.cot_comma x, y -ida_hexrays.cot_eq (variable) +ida_hexrays.cot_eq x == y int or fpu (see EXFL_FPOP) -ida_hexrays.cot_fadd (variable) +ida_hexrays.cot_fadd x + y fp -ida_hexrays.cot_fdiv (variable) +ida_hexrays.cot_fdiv x / y fp -ida_hexrays.cot_fmul (variable) +ida_hexrays.cot_fmul x * y fp -ida_hexrays.cot_fneg (variable) +ida_hexrays.cot_fneg -x fp -ida_hexrays.cot_fnum (variable) +ida_hexrays.cot_fnum fpc -ida_hexrays.cot_fsub (variable) +ida_hexrays.cot_fsub x - y fp -ida_hexrays.cot_helper (variable) +ida_hexrays.cot_helper arbitrary name -ida_hexrays.cot_idx (variable) +ida_hexrays.cot_idx x[y] -ida_hexrays.cot_insn (variable) +ida_hexrays.cot_insn instruction in expression, internal representation only -ida_hexrays.cot_land (variable) +ida_hexrays.cot_land x && y -ida_hexrays.cot_lnot (variable) +ida_hexrays.cot_lnot !x -ida_hexrays.cot_lor (variable) +ida_hexrays.cot_lor x || y -ida_hexrays.cot_memptr (variable) +ida_hexrays.cot_memptr x->m, access size in 'ptrsize' -ida_hexrays.cot_memref (variable) +ida_hexrays.cot_memref x.m -ida_hexrays.cot_mul (variable) +ida_hexrays.cot_mul x * y -ida_hexrays.cot_ne (variable) +ida_hexrays.cot_ne x != y int or fpu (see EXFL_FPOP) -ida_hexrays.cot_neg (variable) +ida_hexrays.cot_neg -x -ida_hexrays.cot_num (variable) +ida_hexrays.cot_num n -ida_hexrays.cot_obj (variable) +ida_hexrays.cot_obj obj_ea -ida_hexrays.cot_postdec (variable) +ida_hexrays.cot_postdec x- -ida_hexrays.cot_postinc (variable) +ida_hexrays.cot_postinc x++ -ida_hexrays.cot_predec (variable) +ida_hexrays.cot_predec -x -ida_hexrays.cot_preinc (variable) +ida_hexrays.cot_preinc ++x -ida_hexrays.cot_ptr (variable) +ida_hexrays.cot_ptr *x, access size in 'ptrsize' -ida_hexrays.cot_ref (variable) +ida_hexrays.cot_ref &x -ida_hexrays.cot_sdiv (variable) +ida_hexrays.cot_sdiv x / y signed -ida_hexrays.cot_sge (variable) +ida_hexrays.cot_sge x >= y signed or fpu (see EXFL_FPOP) -ida_hexrays.cot_sgt (variable) +ida_hexrays.cot_sgt x > y signed or fpu (see EXFL_FPOP) -ida_hexrays.cot_shl (variable) +ida_hexrays.cot_shl x << y -ida_hexrays.cot_sizeof (variable) +ida_hexrays.cot_sizeof sizeof(x) -ida_hexrays.cot_sle (variable) +ida_hexrays.cot_sle x <= y signed or fpu (see EXFL_FPOP) -ida_hexrays.cot_slt (variable) +ida_hexrays.cot_slt x < y signed or fpu (see EXFL_FPOP) -ida_hexrays.cot_smod (variable) +ida_hexrays.cot_smod x % y signed -ida_hexrays.cot_sshr (variable) +ida_hexrays.cot_sshr x >> y signed -ida_hexrays.cot_str (variable) +ida_hexrays.cot_str string constant (user representation) -ida_hexrays.cot_sub (variable) +ida_hexrays.cot_sub x - y -ida_hexrays.cot_tern (variable) +ida_hexrays.cot_tern x ? y : z -ida_hexrays.cot_type (variable) +ida_hexrays.cot_type arbitrary type -ida_hexrays.cot_udiv (variable) +ida_hexrays.cot_udiv x / y unsigned -ida_hexrays.cot_uge (variable) +ida_hexrays.cot_uge x >= y unsigned -ida_hexrays.cot_ugt (variable) +ida_hexrays.cot_ugt x > y unsigned -ida_hexrays.cot_ule (variable) +ida_hexrays.cot_ule x <= y unsigned -ida_hexrays.cot_ult (variable) +ida_hexrays.cot_ult x < y unsigned -ida_hexrays.cot_umod (variable) +ida_hexrays.cot_umod x % y unsigned -ida_hexrays.cot_ushr (variable) +ida_hexrays.cot_ushr x >> y unsigned -ida_hexrays.cot_var (variable) +ida_hexrays.cot_var v -ida_hexrays.cot_xor (variable) +ida_hexrays.cot_xor x ^ y -ida_hexrays.create_cfunc (function) - create_cfunc(mba) -> cfuncptr_t - Create a new cfunc_t object. - - @param mba: (C++: mba_t *) microcode object. After creating the cfunc object it takes the - ownership of MBA. +ida_hexrays.create_cfunc(mba: "mba_t") -> "cfuncptr_t" + Create a new cfunc_t object. + + @param mba: microcode object. After creating the cfunc object it takes the ownership of MBA. -ida_hexrays.create_empty_mba (function) - create_empty_mba(mbr, hf=None) -> mba_t +ida_hexrays.create_empty_mba(mbr: "mba_ranges_t", hf: "hexrays_failure_t" = None) -> "mba_t *" Create an empty microcode object. - - @param mbr: (C++: const mba_ranges_t &) mba_ranges_t const & - @param hf: (C++: hexrays_failure_t *) -ida_hexrays.create_field_name (function) - create_field_name(type, offset=BADADDR) -> qstring - - @param type: tinfo_t const & - @param offset: uval_t +ida_hexrays.create_field_name(*args) -> str -ida_hexrays.create_helper (function) +ida_hexrays.create_helper(*args) Create a helper object.. -ida_hexrays.create_typedef (function) - create_typedef(name) -> tinfo_t - Create a reference to an ordinal type. +ida_hexrays.create_typedef(*args) -> "tinfo_t" + This function has the following signatures: - @param name: char const * + 0. create_typedef(name: str) -> tinfo_t + 1. create_typedef(n: int) -> tinfo_t - @return: type which refers to the specified ordinal. For example, if n is 1, the - type info which refers to ordinal type 1 is created. - create_typedef(n) -> tinfo_t + # 0: create_typedef(name: str) -> tinfo_t - @param n: int - -ida_hexrays.creturn_t (class) - Proxy of C++ creturn_t class. - -ida_hexrays.creturn_t.__eq__ (method) - __eq__(self, r) -> bool + Create a reference to a named type. + + @returns type which refers to the specified name. For example, if name is "DWORD", the type info which refers to "DWORD" is created. - @param r: creturn_t const & - -ida_hexrays.creturn_t.__ge__ (method) - __ge__(self, r) -> bool + # 1: create_typedef(n: int) -> tinfo_t - @param r: creturn_t const & + Create a reference to an ordinal type. + + @returns type which refers to the specified ordinal. For example, if n is 1, the type info which refers to ordinal type 1 is created. -ida_hexrays.creturn_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: creturn_t const & +ida_hexrays.creturn_t -ida_hexrays.creturn_t.__init__ (method) - __init__(self) -> creturn_t +ida_hexrays.creturn_t.__eq__(self, r: "creturn_t") -> bool -ida_hexrays.creturn_t.__le__ (method) - __le__(self, r) -> bool - - @param r: creturn_t const & +ida_hexrays.creturn_t.__ge__(self, r: "creturn_t") -> bool -ida_hexrays.creturn_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: creturn_t const & +ida_hexrays.creturn_t.__gt__(self, r: "creturn_t") -> bool -ida_hexrays.creturn_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: creturn_t const & +ida_hexrays.creturn_t.__init__(self) -ida_hexrays.creturn_t.compare (method) - compare(self, r) -> int - - @param r: creturn_t const & +ida_hexrays.creturn_t.__le__(self, r: "creturn_t") -> bool -ida_hexrays.cswitch_t (class) - Proxy of C++ cswitch_t class. +ida_hexrays.creturn_t.__lt__(self, r: "creturn_t") -> bool -ida_hexrays.cswitch_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cswitch_t const & +ida_hexrays.creturn_t.__ne__(self, r: "creturn_t") -> bool -ida_hexrays.cswitch_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cswitch_t const & +ida_hexrays.creturn_t.compare(self, r: "creturn_t") -> int -ida_hexrays.cswitch_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cswitch_t const & +ida_hexrays.cswitch_t -ida_hexrays.cswitch_t.__init__ (method) - __init__(self) -> cswitch_t +ida_hexrays.cswitch_t.__eq__(self, r: "cswitch_t") -> bool -ida_hexrays.cswitch_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cswitch_t const & +ida_hexrays.cswitch_t.__ge__(self, r: "cswitch_t") -> bool -ida_hexrays.cswitch_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cswitch_t const & +ida_hexrays.cswitch_t.__gt__(self, r: "cswitch_t") -> bool -ida_hexrays.cswitch_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cswitch_t const & +ida_hexrays.cswitch_t.__init__(self) -ida_hexrays.cswitch_t.cases (variable) +ida_hexrays.cswitch_t.__le__(self, r: "cswitch_t") -> bool + +ida_hexrays.cswitch_t.__lt__(self, r: "cswitch_t") -> bool + +ida_hexrays.cswitch_t.__ne__(self, r: "cswitch_t") -> bool + +ida_hexrays.cswitch_t.cases Switch cases: values and instructions. -ida_hexrays.cswitch_t.compare (method) - compare(self, r) -> int - - @param r: cswitch_t const & +ida_hexrays.cswitch_t.compare(self, r: "cswitch_t") -> int -ida_hexrays.cswitch_t.mvnf (variable) +ida_hexrays.cswitch_t.mvnf Maximal switch value and number format. -ida_hexrays.ctext_position_t (class) - Proxy of C++ ctext_position_t class. +ida_hexrays.ctext_position_t -ida_hexrays.ctext_position_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ctext_position_t const & +ida_hexrays.ctext_position_t.__eq__(self, r: "ctext_position_t") -> bool -ida_hexrays.ctext_position_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ctext_position_t const & +ida_hexrays.ctext_position_t.__ge__(self, r: "ctext_position_t") -> bool -ida_hexrays.ctext_position_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ctext_position_t const & +ida_hexrays.ctext_position_t.__gt__(self, r: "ctext_position_t") -> bool -ida_hexrays.ctext_position_t.__init__ (method) - __init__(self, _lnnum=-1, _x=0, _y=0) -> ctext_position_t - - @param _lnnum: int - @param _x: int - @param _y: int +ida_hexrays.ctext_position_t.__init__(self, _lnnum: int = -1, _x: int = 0, _y: int = 0) -ida_hexrays.ctext_position_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ctext_position_t const & +ida_hexrays.ctext_position_t.__le__(self, r: "ctext_position_t") -> bool -ida_hexrays.ctext_position_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ctext_position_t const & +ida_hexrays.ctext_position_t.__lt__(self, r: "ctext_position_t") -> bool -ida_hexrays.ctext_position_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ctext_position_t const & +ida_hexrays.ctext_position_t.__ne__(self, r: "ctext_position_t") -> bool -ida_hexrays.ctext_position_t.compare (method) - compare(self, r) -> int - - @param r: ctext_position_t const & +ida_hexrays.ctext_position_t.compare(self, r: "ctext_position_t") -> int -ida_hexrays.ctext_position_t.in_ctree (method) - in_ctree(self, hdrlines) -> bool - Is the cursor in the variable/type declaration area? - - @param hdrlines: (C++: int) Number of lines of the declaration area +ida_hexrays.ctext_position_t.in_ctree(self, hdrlines: int) -> bool + Is the cursor in the variable/type declaration area? + + @param hdrlines: Number of lines of the declaration area -ida_hexrays.ctext_position_t.lnnum (variable) +ida_hexrays.ctext_position_t.lnnum Line number. -ida_hexrays.ctext_position_t.x (variable) +ida_hexrays.ctext_position_t.x x coordinate of the cursor within the window -ida_hexrays.ctext_position_t.y (variable) - y coordinate of the cursor within the window +ida_hexrays.ctext_position_t.y + y coordinate of the cursor within the window + -ida_hexrays.ctree_anchor_t (class) - Proxy of C++ ctree_anchor_t class. +ida_hexrays.cthrow_t -ida_hexrays.ctree_anchor_t.__init__ (method) - __init__(self) -> ctree_anchor_t +ida_hexrays.cthrow_t.__eq__(self, r: "cthrow_t") -> bool -ida_hexrays.ctree_anchor_t.get_index (method) - get_index(self) -> int +ida_hexrays.cthrow_t.__ge__(self, r: "cthrow_t") -> bool -ida_hexrays.ctree_anchor_t.get_itp (method) - get_itp(self) -> item_preciser_t +ida_hexrays.cthrow_t.__gt__(self, r: "cthrow_t") -> bool -ida_hexrays.ctree_anchor_t.is_blkcmt_anchor (method) - is_blkcmt_anchor(self) -> bool +ida_hexrays.cthrow_t.__init__(self) -ida_hexrays.ctree_anchor_t.is_citem_anchor (method) - is_citem_anchor(self) -> bool +ida_hexrays.cthrow_t.__le__(self, r: "cthrow_t") -> bool -ida_hexrays.ctree_anchor_t.is_itp_anchor (method) - is_itp_anchor(self) -> bool +ida_hexrays.cthrow_t.__lt__(self, r: "cthrow_t") -> bool -ida_hexrays.ctree_anchor_t.is_lvar_anchor (method) - is_lvar_anchor(self) -> bool +ida_hexrays.cthrow_t.__ne__(self, r: "cthrow_t") -> bool -ida_hexrays.ctree_anchor_t.is_valid_anchor (method) - is_valid_anchor(self) -> bool +ida_hexrays.cthrow_t.compare(self, r: "cthrow_t") -> int -ida_hexrays.ctree_item_t (class) - Proxy of C++ ctree_item_t class. +ida_hexrays.ctree_anchor_t -ida_hexrays.ctree_item_t.__init__ (method) - __init__(self) -> ctree_item_t +ida_hexrays.ctree_anchor_t.__init__(self) -ida_hexrays.ctree_item_t._get_e (method) - _get_e(self) -> cexpr_t +ida_hexrays.ctree_anchor_t.get_index(self) -> int -ida_hexrays.ctree_item_t._get_f (method) - _get_f(self) -> cfunc_t +ida_hexrays.ctree_anchor_t.get_itp(self) -> "item_preciser_t" -ida_hexrays.ctree_item_t._get_i (method) - _get_i(self) -> cinsn_t +ida_hexrays.ctree_anchor_t.is_blkcmt_anchor(self) -> bool -ida_hexrays.ctree_item_t._get_it (method) - _get_it(self) -> citem_t +ida_hexrays.ctree_anchor_t.is_citem_anchor(self) -> bool -ida_hexrays.ctree_item_t._get_l (method) - _get_l(self) -> lvar_t +ida_hexrays.ctree_anchor_t.is_itp_anchor(self) -> bool -ida_hexrays.ctree_item_t._print (method) - _print(self) +ida_hexrays.ctree_anchor_t.is_lvar_anchor(self) -> bool -ida_hexrays.ctree_item_t.citype (variable) +ida_hexrays.ctree_anchor_t.is_valid_anchor(self) -> bool + +ida_hexrays.ctree_item_t + +ida_hexrays.ctree_item_t.__init__(self) + +ida_hexrays.ctree_item_t._get_e(self) -> "cexpr_t *" + +ida_hexrays.ctree_item_t._get_f(self) -> "cfunc_t *" + +ida_hexrays.ctree_item_t._get_i(self) -> "cinsn_t *" + +ida_hexrays.ctree_item_t._get_it(self) -> "citem_t *" + +ida_hexrays.ctree_item_t._get_l(self) -> "lvar_t *" + +ida_hexrays.ctree_item_t._print(self) -> None + +ida_hexrays.ctree_item_t.citype Item type. -ida_hexrays.ctree_item_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.ctree_item_t.dstr(self) -> str -ida_hexrays.ctree_item_t.get_ea (method) - get_ea(self) -> ea_t - Get address of the current item. Each ctree item has an address. - - @return: BADADDR if failed +ida_hexrays.ctree_item_t.e + VDI_EXPR: Expression. -ida_hexrays.ctree_item_t.get_edm (method) - get_edm(self, parent) -> int - Get type of an enum member. If the current item is a symbolic constant, this - function will return information about it. - - @param parent: (C++: tinfo_t *) pointer to buffer for the enum type. - @return: member index or -1 if failed +ida_hexrays.ctree_item_t.e + VDI_EXPR: Expression. -ida_hexrays.ctree_item_t.get_label_num (method) - get_label_num(self, gln_flags) -> int - Get label number of the current item. - - @param gln_flags: (C++: int) Combination of get_label_num control bits - @return: -1 if failed or no label +ida_hexrays.ctree_item_t.f + VDI_FUNC: Function. -ida_hexrays.ctree_item_t.get_lvar (method) - get_lvar(self) -> lvar_t - Get pointer to local variable. If the current item is a local variable, this - function will return pointer to its definition. - - @return: nullptr if failed +ida_hexrays.ctree_item_t.f + VDI_FUNC: Function. -ida_hexrays.ctree_item_t.get_memptr (method) - get_memptr(self, p_sptr=None) -> member_t * - Get pointer to structure member. If the current item is a structure field, this - function will return pointer to its definition. - - @param p_sptr: (C++: struc_t **) pointer to the variable where the pointer to the parent structure - is returned. This parameter can be nullptr. - @return: nullptr if failed OBSOLETE FUNCTION, do not use! +ida_hexrays.ctree_item_t.get_ea(self) -> ida_idaapi.ea_t + Get address of the current item. Each ctree item has an address. + + @returns BADADDR if failed -ida_hexrays.ctree_item_t.get_udm (method) - get_udm(self, udm=None, parent=None, p_offset=None) -> int - Get type of a structure field. If the current item is a structure/union field, - this function will return information about it. - - @param udm: (C++: udm_t *) pointer to buffer for the udt member info. - @param parent: (C++: tinfo_t *) pointer to buffer for the struct/union type. - @param p_offset: (C++: uint64 *) pointer to the offset in bits inside udt. - @return: member index or -1 if failed Both output parameters can be nullptr. +ida_hexrays.ctree_item_t.get_edm(self, parent: "tinfo_t") -> int + Get type of an enum member. If the current item is a symbolic constant, this function will return information about it. + + @param parent: pointer to buffer for the enum type. + @returns member index or -1 if failed -ida_hexrays.ctree_item_t.is_citem (method) - is_citem(self) -> bool +ida_hexrays.ctree_item_t.get_label_num(self, gln_flags: int) -> int + Get label number of the current item. + + @param gln_flags: Combination of get_label_num control bits + @returns -1 if failed or no label + +ida_hexrays.ctree_item_t.get_lvar(self) -> "lvar_t *" + Get pointer to local variable. If the current item is a local variable, this function will return pointer to its definition. + + @returns nullptr if failed + +ida_hexrays.ctree_item_t.get_udm(self, udm: "udm_t" = None, parent: "tinfo_t" = None, p_offset: "uint64 *" = None) -> int + Get type of a structure field. If the current item is a structure/union field, this function will return information about it. + + @param udm: pointer to buffer for the udt member info. + @param parent: pointer to buffer for the struct/union type. + @param p_offset: pointer to the offset in bits inside udt. + @returns member index or -1 if failed Both output parameters can be nullptr. + +ida_hexrays.ctree_item_t.i + VDI_EXPR: Statement. + +ida_hexrays.ctree_item_t.i + VDI_EXPR: Statement. + +ida_hexrays.ctree_item_t.is_citem(self) -> bool Is the current item is a ctree item? -ida_hexrays.ctree_items_t (class) - Proxy of C++ qvector< citem_t * > class. +ida_hexrays.ctree_item_t.l + VDI_LVAR: Local variable. -ida_hexrays.ctree_items_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< citem_t * > const & +ida_hexrays.ctree_item_t.l + VDI_LVAR: Local variable. -ida_hexrays.ctree_items_t.__getitem__ (method) - __getitem__(self, i) -> citem_t - - @param i: size_t +ida_hexrays.ctree_item_t.loc + VDI_TAIL: Line tail. -ida_hexrays.ctree_items_t.__init__ (method) - __init__(self) -> ctree_items_t - __init__(self, x) -> ctree_items_t - - @param x: qvector< citem_t * > const & +ida_hexrays.ctree_items_t -ida_hexrays.ctree_items_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.ctree_items_t.__eq__(self, r: "ctree_items_t") -> bool -ida_hexrays.ctree_items_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< citem_t * > const & +ida_hexrays.ctree_items_t.__getitem__(self, i: "size_t") -> "citem_t *const &" -ida_hexrays.ctree_items_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: citem_t *const & +ida_hexrays.ctree_items_t.__init__(self, *args) -ida_hexrays.ctree_items_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: citem_t *const & +ida_hexrays.ctree_items_t.__len__(self) -> "size_t" -ida_hexrays.ctree_items_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: citem_t *const & +ida_hexrays.ctree_items_t.__ne__(self, r: "ctree_items_t") -> bool -ida_hexrays.ctree_items_t.at (method) - at(self, _idx) -> citem_t - - @param _idx: size_t +ida_hexrays.ctree_items_t.__setitem__(self, i: "size_t", v: "citem_t") -> None -ida_hexrays.ctree_items_t.begin (method) - begin(self) -> qvector< citem_t * >::iterator - begin(self) -> qvector< citem_t * >::const_iterator +ida_hexrays.ctree_items_t._del(self, x: "citem_t") -> bool -ida_hexrays.ctree_items_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.ctree_items_t.add_unique(self, x: "citem_t") -> bool -ida_hexrays.ctree_items_t.clear (method) - clear(self) +ida_hexrays.ctree_items_t.append(self, x: "citem_t") -> None -ida_hexrays.ctree_items_t.empty (method) - empty(self) -> bool +ida_hexrays.ctree_items_t.at(self, _idx: "size_t") -> "citem_t *const &" -ida_hexrays.ctree_items_t.end (method) - end(self) -> qvector< citem_t * >::iterator - end(self) -> qvector< citem_t * >::const_iterator +ida_hexrays.ctree_items_t.begin(self, *args) -> "qvector< citem_t * >::const_iterator" -ida_hexrays.ctree_items_t.erase (method) - erase(self, it) -> qvector< citem_t * >::iterator - - @param it: qvector< citem_t * >::iterator - - erase(self, first, last) -> qvector< citem_t * >::iterator - - @param first: qvector< citem_t * >::iterator - @param last: qvector< citem_t * >::iterator +ida_hexrays.ctree_items_t.capacity(self) -> "size_t" -ida_hexrays.ctree_items_t.extract (method) - extract(self) -> citem_t ** +ida_hexrays.ctree_items_t.clear(self) -> None -ida_hexrays.ctree_items_t.find (method) - find(self, x) -> qvector< citem_t * >::iterator - - @param x: citem_t *const & - - find(self, x) -> qvector< citem_t * >::const_iterator - - @param x: citem_t *const & +ida_hexrays.ctree_items_t.empty(self) -> bool -ida_hexrays.ctree_items_t.has (method) - has(self, x) -> bool - - @param x: citem_t *const & +ida_hexrays.ctree_items_t.end(self, *args) -> "qvector< citem_t * >::const_iterator" -ida_hexrays.ctree_items_t.inject (method) - inject(self, s, len) - - @param s: citem_t ** - @param len: size_t +ida_hexrays.ctree_items_t.erase(self, *args) -> "qvector< citem_t * >::iterator" -ida_hexrays.ctree_items_t.insert (method) - insert(self, it, x) -> qvector< citem_t * >::iterator - - @param it: qvector< citem_t * >::iterator - @param x: citem_t *const & +ida_hexrays.ctree_items_t.extend(self, x: "ctree_items_t") -> None -ida_hexrays.ctree_items_t.pop_back (method) - pop_back(self) +ida_hexrays.ctree_items_t.extract(self) -> "citem_t **" -ida_hexrays.ctree_items_t.push_back (method) - push_back(self, x) - - @param x: citem_t *const & - - push_back(self) -> citem_t *& +ida_hexrays.ctree_items_t.find(self, *args) -> "qvector< citem_t * >::const_iterator" -ida_hexrays.ctree_items_t.qclear (method) - qclear(self) +ida_hexrays.ctree_items_t.has(self, x: "citem_t") -> bool -ida_hexrays.ctree_items_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.ctree_items_t.inject(self, s: "citem_t **", len: "size_t") -> None -ida_hexrays.ctree_items_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: citem_t *const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.ctree_items_t.insert(self, it: "qvector< citem_t * >::iterator", x: "citem_t") -> "qvector< citem_t * >::iterator" -ida_hexrays.ctree_items_t.size (method) - size(self) -> size_t +ida_hexrays.ctree_items_t.pop_back(self) -> None -ida_hexrays.ctree_items_t.swap (method) - swap(self, r) - - @param r: qvector< citem_t * > & +ida_hexrays.ctree_items_t.push_back(self, *args) -> "citem_t *&" -ida_hexrays.ctree_items_t.truncate (method) - truncate(self) +ida_hexrays.ctree_items_t.qclear(self) -> None -ida_hexrays.ctree_parentee_t (class) - Proxy of C++ ctree_parentee_t class. +ida_hexrays.ctree_items_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.ctree_parentee_t.__disown__ (method) +ida_hexrays.ctree_items_t.resize(self, *args) -> None -ida_hexrays.ctree_parentee_t.__init__ (method) - __init__(self, post=False) -> ctree_parentee_t - - @param post: bool +ida_hexrays.ctree_items_t.size(self) -> "size_t" -ida_hexrays.ctree_parentee_t.get_block (method) - get_block(self) -> cblock_t - Get pointer to the parent block of the currently visited item. This function - should be called only when the parent is a block. +ida_hexrays.ctree_items_t.swap(self, r: "ctree_items_t") -> None -ida_hexrays.ctree_parentee_t.recalc_parent_types (method) - recalc_parent_types(self) -> bool - Recalculate type of parent nodes. If a node type has been changed, the visitor - must recalculate all parent types, otherwise the ctree becomes inconsistent. If - during this recalculation a parent node is added/deleted, this function returns - true. In this case the traversal must be stopped because the information about - parent nodes is stale. - - @return: false-ok to continue the traversal, true-must stop. +ida_hexrays.ctree_items_t.truncate(self) -> None -ida_hexrays.ctree_visitor_t (class) - Proxy of C++ ctree_visitor_t class. +ida_hexrays.ctree_parentee_t -ida_hexrays.ctree_visitor_t.__disown__ (method) +ida_hexrays.ctree_parentee_t.__disown__(self) -ida_hexrays.ctree_visitor_t.__init__ (method) - __init__(self, _flags) -> ctree_visitor_t - - @param _flags: int +ida_hexrays.ctree_parentee_t.__init__(self, post: bool = False) -ida_hexrays.ctree_visitor_t.apply_to (method) - apply_to(self, item, parent) -> int - Traverse ctree. The traversal will start at the specified item and continue - until of one the visit_...() functions return a non-zero value. - - @param item: (C++: citem_t *) root of the ctree to traverse - @param parent: (C++: citem_t *) parent of the specified item. can be specified as nullptr. - @return: 0 or a non-zero value returned by a visit_...() function +ida_hexrays.ctree_parentee_t.recalc_parent_types(self) -> bool + Recalculate type of parent nodes. If a node type has been changed, the visitor must recalculate all parent types, otherwise the ctree becomes inconsistent. If during this recalculation a parent node is added/deleted, this function returns true. In this case the traversal must be stopped because the information about parent nodes is stale. + + @returns false-ok to continue the traversal, true-must stop. -ida_hexrays.ctree_visitor_t.apply_to_exprs (method) - apply_to_exprs(self, item, parent) -> int - Traverse only expressions. The traversal will start at the specified item and - continue until of one the visit_...() functions return a non-zero value. - - @param item: (C++: citem_t *) root of the ctree to traverse - @param parent: (C++: citem_t *) parent of the specified item. can be specified as nullptr. - @return: 0 or a non-zero value returned by a visit_...() function +ida_hexrays.ctree_visitor_t -ida_hexrays.ctree_visitor_t.clr_prune (method) - clr_prune(self) +ida_hexrays.ctree_visitor_t.__disown__(self) + +ida_hexrays.ctree_visitor_t.__init__(self, _flags: int) + +ida_hexrays.ctree_visitor_t.apply_to(self, item: "citem_t", parent: "citem_t") -> int + Traverse ctree. The traversal will start at the specified item and continue until of one the visit_...() functions return a non-zero value. + + @param item: root of the ctree to traverse + @param parent: parent of the specified item. can be specified as nullptr. + @returns 0 or a non-zero value returned by a visit_...() function + +ida_hexrays.ctree_visitor_t.apply_to_exprs(self, item: "citem_t", parent: "citem_t") -> int + Traverse only expressions. The traversal will start at the specified item and continue until of one the visit_...() functions return a non-zero value. + + @param item: root of the ctree to traverse + @param parent: parent of the specified item. can be specified as nullptr. + @returns 0 or a non-zero value returned by a visit_...() function + +ida_hexrays.ctree_visitor_t.bposvec + Vector of block positions. Only cit_block and cit_try parents have the corresponding element in this vector. + + +ida_hexrays.ctree_visitor_t.clr_prune(self) -> None Do not prune children. This is an internal function, no need to call it. -ida_hexrays.ctree_visitor_t.clr_restart (method) - clr_restart(self) +ida_hexrays.ctree_visitor_t.clr_restart(self) -> None Do not restart. This is an internal function, no need to call it. -ida_hexrays.ctree_visitor_t.cv_flags (variable) - Ctree visitor property bits +ida_hexrays.ctree_visitor_t.cv_flags + Ctree visitor property bits + -ida_hexrays.ctree_visitor_t.is_postorder (method) - is_postorder(self) -> bool +ida_hexrays.ctree_visitor_t.is_postorder(self) -> bool Should the leave...() functions be called? -ida_hexrays.ctree_visitor_t.leave_expr (method) - leave_expr(self, arg0) -> int - Visit an expression after having visited its children. This is a visitor - function which should be overridden by a derived class to do some useful work. - This visitor performs post-order traserval, i.e. an item is visited after its - children. - - @param arg0: cexpr_t * - @return: 0 to continue the traversal, nonzero to stop. +ida_hexrays.ctree_visitor_t.leave_expr(self, arg0: "cexpr_t") -> int + Visit an expression after having visited its children. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs post-order traserval, i.e. an item is visited after its children. + + @returns 0 to continue the traversal, nonzero to stop. -ida_hexrays.ctree_visitor_t.leave_insn (method) - leave_insn(self, arg0) -> int - Visit a statement after having visited its children. This is a visitor function - which should be overridden by a derived class to do some useful work. This - visitor performs post-order traserval, i.e. an item is visited after its - children. - - @param arg0: cinsn_t * - @return: 0 to continue the traversal, nonzero to stop. +ida_hexrays.ctree_visitor_t.leave_insn(self, arg0: "cinsn_t") -> int + Visit a statement after having visited its children. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs post-order traserval, i.e. an item is visited after its children. + + @returns 0 to continue the traversal, nonzero to stop. -ida_hexrays.ctree_visitor_t.maintain_parents (method) - maintain_parents(self) -> bool +ida_hexrays.ctree_visitor_t.maintain_parents(self) -> bool Should the parent information by maintained? -ida_hexrays.ctree_visitor_t.must_prune (method) - must_prune(self) -> bool +ida_hexrays.ctree_visitor_t.must_prune(self) -> bool Should the traversal skip the children of the current item? -ida_hexrays.ctree_visitor_t.must_restart (method) - must_restart(self) -> bool +ida_hexrays.ctree_visitor_t.must_restart(self) -> bool Should the traversal restart? -ida_hexrays.ctree_visitor_t.only_insns (method) - only_insns(self) -> bool +ida_hexrays.ctree_visitor_t.only_insns(self) -> bool Should all expressions be automatically pruned? -ida_hexrays.ctree_visitor_t.parent_expr (method) - parent_expr(self) -> cexpr_t +ida_hexrays.ctree_visitor_t.parent_expr(self) -> "cexpr_t *" Get parent of the current item as an expression. -ida_hexrays.ctree_visitor_t.parent_insn (method) - parent_insn(self) -> cinsn_t +ida_hexrays.ctree_visitor_t.parent_insn(self) -> "cinsn_t *" Get parent of the current item as a statement. -ida_hexrays.ctree_visitor_t.parents (variable) +ida_hexrays.ctree_visitor_t.parents Vector of parents of the current item. -ida_hexrays.ctree_visitor_t.prune_now (method) - prune_now(self) - Prune children. This function may be called by a visitor() to skip all children - of the current item. +ida_hexrays.ctree_visitor_t.prune_now(self) -> None + Prune children. This function may be called by a visitor() to skip all children of the current item. + -ida_hexrays.ctree_visitor_t.set_restart (method) - set_restart(self) +ida_hexrays.ctree_visitor_t.set_restart(self) -> None Restart the travesal. Meaningful only in apply_to_exprs() -ida_hexrays.ctree_visitor_t.visit_expr (method) - visit_expr(self, arg0) -> int - Visit an expression. This is a visitor function which should be overridden by a - derived class to do some useful work. This visitor performs pre-order traserval, - i.e. an item is visited before its children. - - @param arg0: cexpr_t * - @return: 0 to continue the traversal, nonzero to stop. +ida_hexrays.ctree_visitor_t.visit_expr(self, arg0: "cexpr_t") -> int + Visit an expression. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs pre-order traserval, i.e. an item is visited before its children. + + @returns 0 to continue the traversal, nonzero to stop. -ida_hexrays.ctree_visitor_t.visit_insn (method) - visit_insn(self, arg0) -> int - Visit a statement. This is a visitor function which should be overridden by a - derived class to do some useful work. This visitor performs pre-order traserval, - i.e. an item is visited before its children. - - @param arg0: cinsn_t * - @return: 0 to continue the traversal, nonzero to stop. +ida_hexrays.ctree_visitor_t.visit_insn(self, arg0: "cinsn_t") -> int + Visit a statement. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs pre-order traserval, i.e. an item is visited before its children. + + @returns 0 to continue the traversal, nonzero to stop. -ida_hexrays.cwhile_t (class) - Proxy of C++ cwhile_t class. +ida_hexrays.ctry_t -ida_hexrays.cwhile_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cwhile_t const & +ida_hexrays.ctry_t.__eq__(self, r: "ctry_t") -> bool -ida_hexrays.cwhile_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cwhile_t const & +ida_hexrays.ctry_t.__ge__(self, r: "ctry_t") -> bool -ida_hexrays.cwhile_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cwhile_t const & +ida_hexrays.ctry_t.__gt__(self, r: "ctry_t") -> bool -ida_hexrays.cwhile_t.__init__ (method) - __init__(self) -> cwhile_t +ida_hexrays.ctry_t.__init__(self, *args, **kwargs) -ida_hexrays.cwhile_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cwhile_t const & +ida_hexrays.ctry_t.__le__(self, r: "ctry_t") -> bool -ida_hexrays.cwhile_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cwhile_t const & +ida_hexrays.ctry_t.__lt__(self, r: "ctry_t") -> bool -ida_hexrays.cwhile_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cwhile_t const & +ida_hexrays.ctry_t.__ne__(self, r: "ctry_t") -> bool -ida_hexrays.cwhile_t.compare (method) - compare(self, r) -> int - - @param r: cwhile_t const & +ida_hexrays.ctry_t.catchs + "catch all", if present, must be the last element. wind-statements must have "catch all" and nothing else. + -ida_hexrays.debug_hexrays_ctree (function) - debug_hexrays_ctree(level, msg) - - @param level: int - @param msg: char const * +ida_hexrays.ctry_t.compare(self, r: "ctry_t") -> int -ida_hexrays.decompile (function) - decompile(mbr, hf=None, decomp_flags=0) -> cfuncptr_t - Decompile a snippet or a function. - - @param mbr: (C++: const mba_ranges_t &) what to decompile - @param hf: (C++: hexrays_failure_t *) extended error information (if failed) - @param decomp_flags: (C++: int) bitwise combination of decompile() flags... bits - @return: pointer to the decompilation result (a reference counted pointer). - nullptr if failed. +ida_hexrays.ctry_t.is_wind + Is C++ wind statement? (not part of the C++ language) MSVC generates code like the following to keep track of constructed objects and destroy them upon an exception. Example: + // an object is constructed at this point __wind { // some other code that may throw an exception } __unwind { // this code is executed only if there was an exception // in the __wind block. normally here we destroy the object // after that the exception is passed to the // exception handler, regular control flow is interrupted here. } // regular logic continues here, if there were no exceptions // also the object's destructor is called + -ida_hexrays.decompile (function) - Decompile a function. - - @param ea an address belonging to the function, or an ida_funcs.func_t object - @param hf extended error information (if failed) - @param flags decomp_flags bitwise combination of `DECOMP_...` bits - @return the decompilation result (a `ida_hexrays.cfunc_t` wrapper), or None +ida_hexrays.ctry_t.new_state + new state number (internal, MSVC related) -ida_hexrays.decompile_func (function) - decompile_func(pfn, hf=None, decomp_flags=0) -> cfuncptr_t - Decompile a function. Multiple decompilations of the same function return the - same object. - - @param pfn: (C++: func_t *) pointer to function to decompile - @param hf: (C++: hexrays_failure_t *) extended error information (if failed) - @param decomp_flags: (C++: int) bitwise combination of decompile() flags... bits - @return: pointer to the decompilation result (a reference counted pointer). - nullptr if failed. +ida_hexrays.ctry_t.old_state + old state number (internal, MSVC related) -ida_hexrays.decompile_many (function) - decompile_many(outfile, funcaddrs, flags) -> bool - Batch decompilation. Decompile all or the specified functions - - @param outfile: (C++: const char *) name of the output file - @param funcaddrs: (C++: const eavec_t *) list of functions to decompile. If nullptr or empty, then - decompile all nonlib functions - @param flags: (C++: int) Batch decompilation bits - @return: true if no internal error occurred and the user has not cancelled - decompilation +ida_hexrays.cwhile_t -ida_hexrays.dereference (function) - Dereference a pointer. This function dereferences a pointer expression. It - performs the following conversion: "ptr" => "*ptr" It can handle discrepancies - in the pointer type and the access size. - - @return: dereferenced expression +ida_hexrays.cwhile_t.__eq__(self, r: "cwhile_t") -> bool -ida_hexrays.dstr (function) - dstr(tif) -> char const * - Print the specified type info. This function can be used from a debugger by - typing "tif->dstr()" - - @param tif: (C++: const tinfo_t *) tinfo_t const * +ida_hexrays.cwhile_t.__ge__(self, r: "cwhile_t") -> bool -ida_hexrays.dummy_ptrtype (function) - dummy_ptrtype(ptrsize, isfp) -> tinfo_t - Generate a dummy pointer type - - @param ptrsize: (C++: int) size of pointed object - @param isfp: (C++: bool) is floating point object? +ida_hexrays.cwhile_t.__gt__(self, r: "cwhile_t") -> bool -ida_hexrays.eamap_begin (function) - eamap_begin(map) -> eamap_iterator_t +ida_hexrays.cwhile_t.__init__(self) + +ida_hexrays.cwhile_t.__le__(self, r: "cwhile_t") -> bool + +ida_hexrays.cwhile_t.__lt__(self, r: "cwhile_t") -> bool + +ida_hexrays.cwhile_t.__ne__(self, r: "cwhile_t") -> bool + +ida_hexrays.cwhile_t.compare(self, r: "cwhile_t") -> int + +ida_hexrays.debug_hexrays_ctree(level: int, msg: str) -> None + +ida_hexrays.decompile(mbr: "mba_ranges_t", hf: "hexrays_failure_t" = None, decomp_flags: int = 0) -> "cfuncptr_t" + Decompile a snippet or a function. + + @param mbr: what to decompile + @param hf: extended error information (if failed) + @param decomp_flags: bitwise combination of decompile() flags... bits + @returns pointer to the decompilation result (a reference counted pointer). nullptr if failed. + +ida_hexrays.decompile(ea, hf = None, flags = 0) + Decompile a snippet or a function. + + @param hf: extended error information (if failed) + @returns pointer to the decompilation result (a reference counted pointer). nullptr if failed. + +ida_hexrays.decompile_func(pfn: "func_t *", hf: "hexrays_failure_t" = None, decomp_flags: int = 0) -> "cfuncptr_t" + Decompile a function. Multiple decompilations of the same function return the same object. + + @param pfn: pointer to function to decompile + @param hf: extended error information (if failed) + @param decomp_flags: bitwise combination of decompile() flags... bits + @returns pointer to the decompilation result (a reference counted pointer). nullptr if failed. + +ida_hexrays.decompile_many(outfile: str, funcaddrs: "uint64vec_t", flags: int) -> bool + Batch decompilation. Decompile all or the specified functions + + @param outfile: name of the output file + @param funcaddrs: list of functions to decompile. If nullptr or empty, then decompile all nonlib functions + @param flags: Batch decompilation bits + @returns true if no internal error occurred and the user has not cancelled decompilation + +ida_hexrays.dereference(e, ptrsize, is_float = False) + Dereference a pointer. This function dereferences a pointer expression. It performs the following conversion: "ptr" => "*ptr" It can handle discrepancies in the pointer type and the access size. + + @param e: expression to deference + @param ptrsize: access size + @returns dereferenced expression + +ida_hexrays.dstr(tif: "tinfo_t") -> str + Print the specified type info. This function can be used from a debugger by typing "tif->dstr()" + + +ida_hexrays.dummy_ptrtype(ptrsize: int, isfp: bool) -> "tinfo_t" + Generate a dummy pointer type + + @param ptrsize: size of pointed object + @param isfp: is floating point object? + +ida_hexrays.eamap_begin(map: "eamap_t") -> "eamap_iterator_t" Get iterator pointing to the beginning of eamap_t. - - @param map: (C++: const eamap_t *) eamap_t const * -ida_hexrays.eamap_clear (function) - eamap_clear(map) +ida_hexrays.eamap_clear(map: "eamap_t") -> None Clear eamap_t. - - @param map: (C++: eamap_t *) -ida_hexrays.eamap_end (function) - eamap_end(map) -> eamap_iterator_t +ida_hexrays.eamap_end(map: "eamap_t") -> "eamap_iterator_t" Get iterator pointing to the end of eamap_t. - - @param map: (C++: const eamap_t *) eamap_t const * -ida_hexrays.eamap_erase (function) - eamap_erase(map, p) +ida_hexrays.eamap_erase(map: "eamap_t", p: "eamap_iterator_t") -> None Erase current element from eamap_t. - - @param map: (C++: eamap_t *) - @param p: (C++: eamap_iterator_t) -ida_hexrays.eamap_find (function) - eamap_find(map, key) -> eamap_iterator_t +ida_hexrays.eamap_find(map: "eamap_t", key: "ea_t const &") -> "eamap_iterator_t" Find the specified key in eamap_t. - - @param map: (C++: const eamap_t *) eamap_t const * - @param key: (C++: const ea_t &) ea_t const & -ida_hexrays.eamap_first (function) - eamap_first(p) -> ea_t const & +ida_hexrays.eamap_first(p: "eamap_iterator_t") -> "ea_t const &" Get reference to the current map key. - - @param p: (C++: eamap_iterator_t) -ida_hexrays.eamap_free (function) - eamap_free(map) +ida_hexrays.eamap_free(map: "eamap_t") -> None Delete eamap_t instance. - - @param map: (C++: eamap_t *) -ida_hexrays.eamap_insert (function) - eamap_insert(map, key, val) -> eamap_iterator_t +ida_hexrays.eamap_insert(map: "eamap_t", key: "ea_t const &", val: "cinsnptrvec_t") -> "eamap_iterator_t" Insert new (ea_t, cinsnptrvec_t) pair into eamap_t. - - @param map: (C++: eamap_t *) - @param key: (C++: const ea_t &) ea_t const & - @param val: (C++: const cinsnptrvec_t &) cinsnptrvec_t const & -ida_hexrays.eamap_iterator_t (class) - Proxy of C++ eamap_iterator_t class. +ida_hexrays.eamap_iterator_t -ida_hexrays.eamap_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: eamap_iterator_t const & +ida_hexrays.eamap_iterator_t.__eq__(self, p: "eamap_iterator_t") -> bool -ida_hexrays.eamap_iterator_t.__init__ (method) - __init__(self) -> eamap_iterator_t +ida_hexrays.eamap_iterator_t.__init__(self) -ida_hexrays.eamap_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: eamap_iterator_t const & +ida_hexrays.eamap_iterator_t.__ne__(self, p: "eamap_iterator_t") -> bool -ida_hexrays.eamap_new (function) - eamap_new() -> eamap_t +ida_hexrays.eamap_new() -> "eamap_t *" Create a new eamap_t instance. -ida_hexrays.eamap_next (function) - eamap_next(p) -> eamap_iterator_t +ida_hexrays.eamap_next(p: "eamap_iterator_t") -> "eamap_iterator_t" Move to the next element. - - @param p: (C++: eamap_iterator_t) -ida_hexrays.eamap_prev (function) - eamap_prev(p) -> eamap_iterator_t +ida_hexrays.eamap_prev(p: "eamap_iterator_t") -> "eamap_iterator_t" Move to the previous element. - - @param p: (C++: eamap_iterator_t) -ida_hexrays.eamap_second (function) - eamap_second(p) -> cinsnptrvec_t +ida_hexrays.eamap_second(p: "eamap_iterator_t") -> "cinsnptrvec_t &" Get reference to the current map value. - - @param p: (C++: eamap_iterator_t) -ida_hexrays.eamap_size (function) - eamap_size(map) -> size_t +ida_hexrays.eamap_size(map: "eamap_t") -> "size_t" Get size of eamap_t. - - @param map: (C++: eamap_t *) -ida_hexrays.eamap_t (class) - Proxy of C++ std::map< ea_t,cinsnptrvec_t > class. +ida_hexrays.eamap_t -ida_hexrays.eamap_t.__init__ (method) - __init__(self) -> eamap_t +ida_hexrays.eamap_t.__init__(self) -ida_hexrays.eamap_t.at (method) - at(self, _Keyval) -> cinsnptrvec_t - - @param _Keyval: unsigned-ea-like-numeric-type const & +ida_hexrays.eamap_t.at(self, _Keyval: "unsigned long long const &") -> "cinsnptrvec_t &" -ida_hexrays.eamap_t.size (method) - size(self) -> size_t +ida_hexrays.eamap_t.size(self) -> "size_t" -ida_hexrays.fnumber_t (class) - Proxy of C++ fnumber_t class. +ida_hexrays.fnumber_t -ida_hexrays.fnumber_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: fnumber_t const & +ida_hexrays.fnumber_t.__eq__(self, r: "fnumber_t") -> bool -ida_hexrays.fnumber_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: fnumber_t const & +ida_hexrays.fnumber_t.__ge__(self, r: "fnumber_t") -> bool -ida_hexrays.fnumber_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: fnumber_t const & +ida_hexrays.fnumber_t.__gt__(self, r: "fnumber_t") -> bool -ida_hexrays.fnumber_t.__init__ (method) - __init__(self) -> fnumber_t +ida_hexrays.fnumber_t.__init__(self) -ida_hexrays.fnumber_t.__le__ (method) - __le__(self, r) -> bool - - @param r: fnumber_t const & +ida_hexrays.fnumber_t.__le__(self, r: "fnumber_t") -> bool -ida_hexrays.fnumber_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: fnumber_t const & +ida_hexrays.fnumber_t.__lt__(self, r: "fnumber_t") -> bool -ida_hexrays.fnumber_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: fnumber_t const & +ida_hexrays.fnumber_t.__ne__(self, r: "fnumber_t") -> bool -ida_hexrays.fnumber_t._print (method) - _print(self) +ida_hexrays.fnumber_t._print(self) -> None -ida_hexrays.fnumber_t.compare (method) - compare(self, r) -> int - - @param r: fnumber_t const & +ida_hexrays.fnumber_t.calc_max_exp(self) -> int -ida_hexrays.fnumber_t.dereference_const_uint16 (method) - dereference_const_uint16(self) -> uint16 const * +ida_hexrays.fnumber_t.compare(self, r: "fnumber_t") -> int -ida_hexrays.fnumber_t.dereference_uint16 (method) - dereference_uint16(self) -> uint16 * +ida_hexrays.fnumber_t.dereference_const_uint16(self) -> "uint16 const *" -ida_hexrays.fnumber_t.fnum (variable) +ida_hexrays.fnumber_t.dereference_uint16(self) -> "uint16 *" + +ida_hexrays.fnumber_t.fnum Internal representation of the number. -ida_hexrays.fnumber_t.nbytes (variable) +ida_hexrays.fnumber_t.is_nan(self) -> bool + +ida_hexrays.fnumber_t.nbytes Original size of the constant in bytes. -ida_hexrays.gco_info_t (class) - Proxy of C++ gco_info_t class. +ida_hexrays.gco_info_t -ida_hexrays.gco_info_t.__init__ (method) - __init__(self) -> gco_info_t +ida_hexrays.gco_info_t.__init__(self) -ida_hexrays.gco_info_t.append_to_list (method) - append_to_list(self, list, mba) -> bool - Append operand info to LIST. This function converts IDA register number or stack - offset to a decompiler list. - - @param list: (C++: mlist_t *) list to append to - @param mba: (C++: const mba_t *) microcode object +ida_hexrays.gco_info_t.append_to_list(self, list: "mlist_t", mba: "mba_t") -> bool + Append operand info to LIST. This function converts IDA register number or stack offset to a decompiler list. + + @param list: list to append to + @param mba: microcode object -ida_hexrays.gco_info_t.cvt_to_ivl (method) - cvt_to_ivl(self) -> vivl_t - Convert operand info to VIVL. The returned VIVL can be used, for example, in a - call of get_valranges(). +ida_hexrays.gco_info_t.cvt_to_ivl(self) -> "vivl_t" + Convert operand info to VIVL. The returned VIVL can be used, for example, in a call of get_valranges(). + -ida_hexrays.gco_info_t.is_def (method) - is_def(self) -> bool +ida_hexrays.gco_info_t.is_def(self) -> bool -ida_hexrays.gco_info_t.is_reg (method) - is_reg(self) -> bool +ida_hexrays.gco_info_t.is_reg(self) -> bool -ida_hexrays.gco_info_t.is_use (method) - is_use(self) -> bool +ida_hexrays.gco_info_t.is_use(self) -> bool -ida_hexrays.gco_info_t.name (variable) +ida_hexrays.gco_info_t.name register or stkvar name -ida_hexrays.gco_info_t.regnum (variable) +ida_hexrays.gco_info_t.regnum if register, the register id -ida_hexrays.gco_info_t.size (variable) +ida_hexrays.gco_info_t.size operand size -ida_hexrays.gco_info_t.stkoff (variable) +ida_hexrays.gco_info_t.stkoff if stkvar, stack offset -ida_hexrays.gen_microcode (function) - gen_microcode(mbr, hf=None, retlist=None, decomp_flags=0, reqmat=MMAT_GLBOPT3) -> mba_t - Generate microcode of an arbitrary code snippet - - @param mbr: (C++: const mba_ranges_t &) snippet ranges - @param hf: (C++: hexrays_failure_t *) extended error information (if failed) - @param retlist: (C++: const mlist_t *) list of registers the snippet returns - @param decomp_flags: (C++: int) bitwise combination of decompile() flags... bits - @param reqmat: (C++: mba_maturity_t) required microcode maturity - @return: pointer to the microcode, nullptr if failed. +ida_hexrays.gen_microcode(mbr: "mba_ranges_t", hf: "hexrays_failure_t" = None, retlist: "mlist_t" = None, decomp_flags: int = 0, reqmat: "mba_maturity_t" = MMAT_GLBOPT3) -> "mba_t *" + Generate microcode of an arbitrary code snippet + + @param mbr: snippet ranges + @param hf: extended error information (if failed) + @param retlist: list of registers the snippet returns + @param decomp_flags: bitwise combination of decompile() flags... bits + @param reqmat: required microcode maturity + @returns pointer to the microcode, nullptr if failed. -ida_hexrays.get_ctype_name (function) - get_ctype_name(op) -> char const * - - @param op: enum ctype_t +ida_hexrays.get_ctype_name(op: "ctype_t") -> str -ida_hexrays.get_current_operand (function) - get_current_operand(out) -> bool - Get the instruction operand under the cursor. This function determines the - operand that is under the cursor in the active disassembly listing. If the - operand refers to a register or stack variable, it returns true. - - @param out: (C++: gco_info_t *) [out]: output buffer +ida_hexrays.get_current_operand(out: "gco_info_t") -> bool + Get the instruction operand under the cursor. This function determines the operand that is under the cursor in the active disassembly listing. If the operand refers to a register or stack variable, it returns true. + -ida_hexrays.get_float_type (function) - get_float_type(width) -> tinfo_t - Get a type of a floating point value with the specified width - - @param width: (C++: int) width of the desired type - @return: type info object +ida_hexrays.get_float_type(width: int) -> "tinfo_t" + Get a type of a floating point value with the specified width + + @param width: width of the desired type + @returns type info object -ida_hexrays.get_hexrays_version (function) - get_hexrays_version() -> char const * - Get decompiler version. The returned string is of the form - ... - - @return: pointer to version string. For example: "2.0.0.140605" +ida_hexrays.get_hexrays_version() -> str + Get decompiler version. The returned string is of the form ... + + @returns pointer to version string. For example: "2.0.0.140605" -ida_hexrays.get_int_type_by_width_and_sign (function) - get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t - Create a type info by width and sign. Returns a simple type (examples: int, - short) with the given width and sign. - - @param srcwidth: (C++: int) size of the type in bytes - @param sign: (C++: type_sign_t) sign of the type +ida_hexrays.get_int_type_by_width_and_sign(srcwidth: int, sign: "type_sign_t") -> "tinfo_t" + Create a type info by width and sign. Returns a simple type (examples: int, short) with the given width and sign. + + @param srcwidth: size of the type in bytes + @param sign: sign of the type -ida_hexrays.get_member_type (function) - get_member_type(mptr, type) -> bool - Get type of a structure field. This function performs validity checks of the - field type. Wrong types are rejected. - - @param mptr: (C++: const member_t *) structure field - @param type: (C++: tinfo_t *) pointer to the variable where the type is returned. This parameter - can be nullptr. - @return: false if failed +ida_hexrays.get_merror_desc(code: "merror_t", mba: "mba_t") -> str + Get textual description of an error code + + @param code: Microcode error codes + @param mba: the microcode array + @returns the error address -ida_hexrays.get_merror_desc (function) - get_merror_desc(code, mba) -> str - Get textual description of an error code - - @param code: (C++: merror_t) Microcode error codes - @param mba: (C++: mba_t *) the microcode array - @return: the error address +ida_hexrays.get_mreg_name(reg: "mreg_t", width: int, ud: "void *" = None) -> str + Get the microregister name. + + @param reg: microregister number + @param width: size of microregister in bytes. may be bigger than the real register size. + @param ud: reserved, must be nullptr + @returns width of the printed register. this value may be less than the WIDTH argument. -ida_hexrays.get_mreg_name (function) - get_mreg_name(reg, width, ud=None) -> str - Get the microregister name. - - @param reg: (C++: mreg_t) microregister number - @param width: (C++: int) size of microregister in bytes. may be bigger than the real - register size. - @param ud: (C++: void *) reserved, must be nullptr - @return: width of the printed register. this value may be less than the WIDTH - argument. - -ida_hexrays.get_op_signness (function) - get_op_signness(op) -> type_sign_t +ida_hexrays.get_op_signness(op: "ctype_t") -> "type_sign_t" Get operator sign. Meaningful for sign-dependent operators, like cot_sdiv. - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.get_signed_mcode (function) - get_signed_mcode(code) -> mcode_t - - @param code: enum mcode_t +ida_hexrays.get_signed_mcode(code: "mcode_t") -> "mcode_t" -ida_hexrays.get_temp_regs (function) - get_temp_regs() -> mlist_t - Get list of temporary registers. Tempregs are temporary registers that are used - during code generation. They do not map to regular processor registers. They are - used only to store temporary values during execution of one instruction. - Tempregs may not be used to pass a value from one block to another. In other - words, at the end of a block all tempregs must be dead. +ida_hexrays.get_temp_regs() -> "mlist_t const &" + Get list of temporary registers. Tempregs are temporary registers that are used during code generation. They do not map to regular processor registers. They are used only to store temporary values during execution of one instruction. Tempregs may not be used to pass a value from one block to another. In other words, at the end of a block all tempregs must be dead. + -ida_hexrays.get_type (function) - get_type(id, tif, guess) -> bool - Get a global type. Global types are types of addressable objects and - struct/union/enum types - - @param id: (C++: uval_t) address or id of the object - @param tif: (C++: tinfo_t *) buffer for the answer - @param guess: (C++: type_source_t) what kind of types to consider - @return: success +ida_hexrays.get_type(id: int, tif: "tinfo_t", guess: "type_source_t") -> bool + Get a global type. Global types are types of addressable objects and struct/union/enum types + + @param id: address or id of the object + @param tif: buffer for the answer + @param guess: what kind of types to consider + @returns success -ida_hexrays.get_unk_type (function) - get_unk_type(size) -> tinfo_t - Create a partial type info by width. Returns a partially defined type (examples: - _DWORD, _BYTE) with the given width. - - @param size: (C++: int) size of the type in bytes +ida_hexrays.get_unk_type(size: int) -> "tinfo_t" + Create a partial type info by width. Returns a partially defined type (examples: _DWORD, _BYTE) with the given width. + + @param size: size of the type in bytes -ida_hexrays.get_unsigned_mcode (function) - get_unsigned_mcode(code) -> mcode_t - - @param code: enum mcode_t +ida_hexrays.get_unsigned_mcode(code: "mcode_t") -> "mcode_t" -ida_hexrays.get_widget_vdui (function) - get_widget_vdui(f) -> vdui_t - Get the vdui_t instance associated to the TWidget - - @param f: (C++: TWidget *) pointer to window - @return: a vdui_t *, or nullptr +ida_hexrays.get_widget_vdui(f: "TWidget *") -> "vdui_t *" + Get the vdui_t instance associated to the TWidget + + @param f: pointer to window + @returns a vdui_t *, or nullptr -ida_hexrays.getb_reginsn (function) - getb_reginsn(ins) -> minsn_t - - @param ins: minsn_t * +ida_hexrays.getb_reginsn(ins: "minsn_t") -> "minsn_t *" + Skip assertions backward. -ida_hexrays.getf_reginsn (function) - getf_reginsn(ins) -> minsn_t - - @param ins: minsn_t * +ida_hexrays.getf_reginsn(ins: "minsn_t") -> "minsn_t *" + Skip assertions forward. -ida_hexrays.graph_chains_t (class) - Proxy of C++ graph_chains_t class. +ida_hexrays.graph_chains_t -ida_hexrays.graph_chains_t.__init__ (method) - __init__(self) -> graph_chains_t +ida_hexrays.graph_chains_t.__init__(self) -ida_hexrays.graph_chains_t.acquire (method) - acquire(self) +ida_hexrays.graph_chains_t.acquire(self) -> None Lock the chains. -ida_hexrays.graph_chains_t.for_all_chains (method) - for_all_chains(self, cv, gca_flags) -> int - Visit all chains - - @param cv: (C++: chain_visitor_t &) chain visitor - @param gca_flags: (C++: int) combination of GCA_ bits +ida_hexrays.graph_chains_t.for_all_chains(self, cv: "chain_visitor_t", gca_flags: int) -> int + Visit all chains + + @param cv: chain visitor + @param gca_flags: combination of GCA_ bits -ida_hexrays.graph_chains_t.is_locked (method) - is_locked(self) -> bool - Are the chains locked? It is a good idea to lock the chains before using them. - This ensures that they won't be recalculated and reallocated during the use. See - the chain_keeper_t class for that. +ida_hexrays.graph_chains_t.is_locked(self) -> bool + Are the chains locked? It is a good idea to lock the chains before using them. This ensures that they won't be recalculated and reallocated during the use. See the chain_keeper_t class for that. + -ida_hexrays.graph_chains_t.release (method) - release(self) +ida_hexrays.graph_chains_t.release(self) -> None Unlock the chains. -ida_hexrays.graph_chains_t.swap (method) - swap(self, r) - - @param r: graph_chains_t & +ida_hexrays.graph_chains_t.swap(self, r: "graph_chains_t") -> None -ida_hexrays.has_cached_cfunc (function) - has_cached_cfunc(ea) -> bool +ida_hexrays.has_cached_cfunc(ea: ida_idaapi.ea_t) -> bool Do we have a cached decompilation result for 'ea'? - - @param ea: (C++: ea_t) -ida_hexrays.has_mcode_seloff (function) - has_mcode_seloff(op) -> bool - - @param op: enum mcode_t +ida_hexrays.has_mcode_seloff(op: "mcode_t") -> bool -ida_hexrays.hexrays_alloc (function) - hexrays_alloc(size) -> void * - - @param size: size_t +ida_hexrays.hexrays_alloc(size: "size_t") -> "void *" -ida_hexrays.hexrays_failure_t (class) - Proxy of C++ hexrays_failure_t class. +ida_hexrays.hexrays_failure_t -ida_hexrays.hexrays_failure_t.__init__ (method) - __init__(self) -> hexrays_failure_t - __init__(self, c, ea, buf=None) -> hexrays_failure_t - - @param c: enum merror_t - @param ea: ea_t - @param buf: char const * - - __init__(self, c, ea, buf) -> hexrays_failure_t - - @param c: enum merror_t - @param ea: ea_t - @param buf: qstring const & +ida_hexrays.hexrays_failure_t.__init__(self, *args) -ida_hexrays.hexrays_failure_t.code (variable) +ida_hexrays.hexrays_failure_t.code Microcode error codes -ida_hexrays.hexrays_failure_t.desc (method) - desc(self) -> qstring +ida_hexrays.hexrays_failure_t.desc(self) -> str -ida_hexrays.hexrays_failure_t.errea (variable) +ida_hexrays.hexrays_failure_t.errea associated address -ida_hexrays.hexrays_failure_t.str (variable) +ida_hexrays.hexrays_failure_t.str string information -ida_hexrays.hexrays_free (function) - hexrays_free(ptr) - - @param ptr: void * +ida_hexrays.hexrays_free(ptr: "void *") -> None -ida_hexrays.hexwarn_t (class) - Proxy of C++ hexwarn_t class. +ida_hexrays.hexwarn_t -ida_hexrays.hexwarn_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: hexwarn_t const & +ida_hexrays.hexwarn_t.__eq__(self, r: "hexwarn_t") -> bool -ida_hexrays.hexwarn_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: hexwarn_t const & +ida_hexrays.hexwarn_t.__ge__(self, r: "hexwarn_t") -> bool -ida_hexrays.hexwarn_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: hexwarn_t const & +ida_hexrays.hexwarn_t.__gt__(self, r: "hexwarn_t") -> bool -ida_hexrays.hexwarn_t.__init__ (method) - __init__(self) -> hexwarn_t +ida_hexrays.hexwarn_t.__init__(self) -ida_hexrays.hexwarn_t.__le__ (method) - __le__(self, r) -> bool - - @param r: hexwarn_t const & +ida_hexrays.hexwarn_t.__le__(self, r: "hexwarn_t") -> bool -ida_hexrays.hexwarn_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: hexwarn_t const & +ida_hexrays.hexwarn_t.__lt__(self, r: "hexwarn_t") -> bool -ida_hexrays.hexwarn_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: hexwarn_t const & +ida_hexrays.hexwarn_t.__ne__(self, r: "hexwarn_t") -> bool -ida_hexrays.hexwarn_t.compare (method) - compare(self, r) -> int - - @param r: hexwarn_t const & +ida_hexrays.hexwarn_t.compare(self, r: "hexwarn_t") -> int -ida_hexrays.hexwarn_t.ea (variable) +ida_hexrays.hexwarn_t.ea Address where the warning occurred. -ida_hexrays.hexwarn_t.id (variable) +ida_hexrays.hexwarn_t.id Warning id. -ida_hexrays.hexwarn_t.text (variable) +ida_hexrays.hexwarn_t.text Fully formatted text of the warning. -ida_hexrays.hexwarns_t (class) - Proxy of C++ qvector< hexwarn_t > class. +ida_hexrays.hexwarns_t -ida_hexrays.hexwarns_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< hexwarn_t > const & +ida_hexrays.hexwarns_t.__eq__(self, r: "hexwarns_t") -> bool -ida_hexrays.hexwarns_t.__getitem__ (method) - __getitem__(self, i) -> hexwarn_t - - @param i: size_t +ida_hexrays.hexwarns_t.__getitem__(self, i: "size_t") -> "hexwarn_t const &" -ida_hexrays.hexwarns_t.__init__ (method) - __init__(self) -> hexwarns_t - __init__(self, x) -> hexwarns_t - - @param x: qvector< hexwarn_t > const & +ida_hexrays.hexwarns_t.__init__(self, *args) -ida_hexrays.hexwarns_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.hexwarns_t.__len__(self) -> "size_t" -ida_hexrays.hexwarns_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< hexwarn_t > const & +ida_hexrays.hexwarns_t.__ne__(self, r: "hexwarns_t") -> bool -ida_hexrays.hexwarns_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: hexwarn_t const & +ida_hexrays.hexwarns_t.__setitem__(self, i: "size_t", v: "hexwarn_t") -> None -ida_hexrays.hexwarns_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: hexwarn_t const & +ida_hexrays.hexwarns_t._del(self, x: "hexwarn_t") -> bool -ida_hexrays.hexwarns_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: hexwarn_t const & +ida_hexrays.hexwarns_t.add_unique(self, x: "hexwarn_t") -> bool -ida_hexrays.hexwarns_t.at (method) - at(self, _idx) -> hexwarn_t - - @param _idx: size_t +ida_hexrays.hexwarns_t.append(self, x: "hexwarn_t") -> None -ida_hexrays.hexwarns_t.begin (method) - begin(self) -> hexwarn_t +ida_hexrays.hexwarns_t.at(self, _idx: "size_t") -> "hexwarn_t const &" -ida_hexrays.hexwarns_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.hexwarns_t.begin(self, *args) -> "qvector< hexwarn_t >::const_iterator" -ida_hexrays.hexwarns_t.clear (method) - clear(self) +ida_hexrays.hexwarns_t.capacity(self) -> "size_t" -ida_hexrays.hexwarns_t.empty (method) - empty(self) -> bool +ida_hexrays.hexwarns_t.clear(self) -> None -ida_hexrays.hexwarns_t.end (method) - end(self) -> hexwarn_t +ida_hexrays.hexwarns_t.empty(self) -> bool -ida_hexrays.hexwarns_t.erase (method) - erase(self, it) -> hexwarn_t - - @param it: qvector< hexwarn_t >::iterator - - erase(self, first, last) -> hexwarn_t - - @param first: qvector< hexwarn_t >::iterator - @param last: qvector< hexwarn_t >::iterator +ida_hexrays.hexwarns_t.end(self, *args) -> "qvector< hexwarn_t >::const_iterator" -ida_hexrays.hexwarns_t.extract (method) - extract(self) -> hexwarn_t +ida_hexrays.hexwarns_t.erase(self, *args) -> "qvector< hexwarn_t >::iterator" -ida_hexrays.hexwarns_t.find (method) - find(self, x) -> hexwarn_t - - @param x: hexwarn_t const & +ida_hexrays.hexwarns_t.extend(self, x: "hexwarns_t") -> None -ida_hexrays.hexwarns_t.grow (method) - grow(self, x=hexwarn_t()) - - @param x: hexwarn_t const & +ida_hexrays.hexwarns_t.extract(self) -> "hexwarn_t *" -ida_hexrays.hexwarns_t.has (method) - has(self, x) -> bool - - @param x: hexwarn_t const & +ida_hexrays.hexwarns_t.find(self, *args) -> "qvector< hexwarn_t >::const_iterator" -ida_hexrays.hexwarns_t.inject (method) - inject(self, s, len) - - @param s: hexwarn_t * - @param len: size_t +ida_hexrays.hexwarns_t.grow(self, *args) -> None -ida_hexrays.hexwarns_t.insert (method) - insert(self, it, x) -> hexwarn_t - - @param it: qvector< hexwarn_t >::iterator - @param x: hexwarn_t const & +ida_hexrays.hexwarns_t.has(self, x: "hexwarn_t") -> bool -ida_hexrays.hexwarns_t.pop_back (method) - pop_back(self) +ida_hexrays.hexwarns_t.inject(self, s: "hexwarn_t", len: "size_t") -> None -ida_hexrays.hexwarns_t.push_back (method) - push_back(self, x) - - @param x: hexwarn_t const & - - push_back(self) -> hexwarn_t +ida_hexrays.hexwarns_t.insert(self, it: "hexwarn_t", x: "hexwarn_t") -> "qvector< hexwarn_t >::iterator" -ida_hexrays.hexwarns_t.qclear (method) - qclear(self) +ida_hexrays.hexwarns_t.pop_back(self) -> None -ida_hexrays.hexwarns_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.hexwarns_t.push_back(self, *args) -> "hexwarn_t &" -ida_hexrays.hexwarns_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: hexwarn_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.hexwarns_t.qclear(self) -> None -ida_hexrays.hexwarns_t.size (method) - size(self) -> size_t +ida_hexrays.hexwarns_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.hexwarns_t.swap (method) - swap(self, r) - - @param r: qvector< hexwarn_t > & +ida_hexrays.hexwarns_t.resize(self, *args) -> None -ida_hexrays.hexwarns_t.truncate (method) - truncate(self) +ida_hexrays.hexwarns_t.size(self) -> "size_t" -ida_hexrays.history_item_t (class) - Proxy of C++ history_item_t class. +ida_hexrays.hexwarns_t.swap(self, r: "hexwarns_t") -> None -ida_hexrays.history_item_t.__init__ (method) - __init__(self, _ea=BADADDR, _lnnum=-1, _x=0, _y=0) -> history_item_t - - @param _ea: ea_t - @param _lnnum: int - @param _x: int - @param _y: int - - __init__(self, _ea, p) -> history_item_t - - @param _ea: ea_t - @param p: ctext_position_t const & +ida_hexrays.hexwarns_t.truncate(self) -> None -ida_hexrays.history_item_t.ea (variable) +ida_hexrays.history_item_t + +ida_hexrays.history_item_t.__init__(self, *args) + +ida_hexrays.history_item_t.curr_ea + Current address. + +ida_hexrays.history_item_t.end + BADADDR-decompile a function; otherwise end of the range. + +ida_hexrays.history_item_t.func_ea The entry address of the decompiled function. -ida_hexrays.history_item_t.end (variable) - BADADDR-decompile function; otherwise end of the range. +ida_hexrays.history_t -ida_hexrays.history_t (class) - Proxy of C++ qstack< history_item_t > class. +ida_hexrays.history_t.__init__(self) -ida_hexrays.history_t.__init__ (method) - __init__(self) -> history_t +ida_hexrays.history_t.pop(self) -> "history_item_t" -ida_hexrays.history_t.pop (method) - pop(self) -> history_item_t +ida_hexrays.history_t.push(self, v: "history_item_t") -> None -ida_hexrays.history_t.push (method) - push(self, v) +ida_hexrays.history_t.top(self, *args) -> "history_item_t &" + +ida_hexrays.hxe_begin_inlining + Starting to inline outlined functions. + + +ida_hexrays.hxe_build_callinfo + Analyzing a call instruction. + + +ida_hexrays.hxe_callinfo_built + A call instruction has been anallyzed. + + +ida_hexrays.hxe_calls_done + All calls have been analyzed. + + +ida_hexrays.hxe_close_pseudocode + Pseudocode view is being closed. + + +ida_hexrays.hxe_cmt_changed + Comment got changed. + + +ida_hexrays.hxe_collect_warnings + Collect warning messages from plugins. These warnings will be displayed at the function header, after the user-defined comments. + + +ida_hexrays.hxe_combine + Trying to combine instructions of basic block. + + +ida_hexrays.hxe_create_hint + Create a hint for the current item. + + +ida_hexrays.hxe_curpos + Current cursor position has been changed. (for example, by left-clicking or using keyboard) - @param v: history_item_t const & + -ida_hexrays.history_t.top (method) - top(self) -> history_item_t +ida_hexrays.hxe_double_click + Mouse double click. + -ida_hexrays.hxe_build_callinfo (variable) - Analyzing a call instruction. +ida_hexrays.hxe_flowchart + Flowchart has been generated. + -ida_hexrays.hxe_callinfo_built (variable) - A call instruction has been anallyzed. +ida_hexrays.hxe_func_printed + Function text has been generated. Plugins may modify the text in cfunc_t::sv. However, it is too late to modify the ctree or microcode. The text uses regular color codes (see lines.hpp) COLOR_ADDR is used to store pointers to ctree items. + -ida_hexrays.hxe_calls_done (variable) - All calls have been analyzed. +ida_hexrays.hxe_glbopt + Global optimization has been finished. If microcode is modified, MERR_LOOP must be returned. It will cause a complete restart of the optimization. + -ida_hexrays.hxe_close_pseudocode (variable) - Pseudocode view is being closed. +ida_hexrays.hxe_inlined_func + A set of ranges got inlined. + -ida_hexrays.hxe_cmt_changed (variable) - Comment got changed. +ida_hexrays.hxe_inlining_func + A set of ranges is going to be inlined. + -ida_hexrays.hxe_combine (variable) - Trying to combine instructions of basic block. +ida_hexrays.hxe_interr + Internal error has occurred. + -ida_hexrays.hxe_create_hint (variable) - Create a hint for the current item. - @see: ui_get_custom_viewer_hint - - @retval 0: continue collecting hints with other subscribers - @retval 1: stop collecting hints +ida_hexrays.hxe_keyboard + Keyboard has been hit. + -ida_hexrays.hxe_curpos (variable) - Current cursor position has been changed. (for example, by left-clicking or - using keyboard) +ida_hexrays.hxe_locopt + Basic block level optimization has been finished. + -ida_hexrays.hxe_double_click (variable) - Mouse double click. +ida_hexrays.hxe_maturity + Ctree maturity level is being changed. + -ida_hexrays.hxe_flowchart (variable) - Flowchart has been generated. +ida_hexrays.hxe_microcode + Microcode has been generated. + -ida_hexrays.hxe_func_printed (variable) - Function text has been generated. Plugins may modify the text in cfunc_t::sv. - The text uses regular color codes (see lines.hpp) COLOR_ADDR is used to store - pointers to ctree items. +ida_hexrays.hxe_open_pseudocode + New pseudocode view has been opened. + -ida_hexrays.hxe_glbopt (variable) - Global optimization has been finished. If microcode is modified, MERR_LOOP must - be returned. It will cause a complete restart of the optimization. +ida_hexrays.hxe_populating_popup + Populating popup menu. We can add menu items now. + -ida_hexrays.hxe_interr (variable) - Internal error has occurred. +ida_hexrays.hxe_pre_structural + Structure analysis is starting. + -ida_hexrays.hxe_keyboard (variable) - Keyboard has been hit. +ida_hexrays.hxe_prealloc + Local variables: preallocation step begins. + -ida_hexrays.hxe_locopt (variable) - Basic block level optimization has been finished. +ida_hexrays.hxe_preoptimized + Microcode has been preoptimized. + -ida_hexrays.hxe_maturity (variable) - Ctree maturity level is being changed. +ida_hexrays.hxe_print_func + Printing ctree and generating text. + -ida_hexrays.hxe_microcode (variable) - Microcode has been generated. +ida_hexrays.hxe_prolog + Prolog analysis has been finished. + -ida_hexrays.hxe_open_pseudocode (variable) - New pseudocode view has been opened. +ida_hexrays.hxe_refresh_pseudocode + Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is forbidden in this event. + -ida_hexrays.hxe_populating_popup (variable) - Populating popup menu. We can add menu items now. +ida_hexrays.hxe_resolve_stkaddrs + The optimizer is about to resolve stack addresses. + -ida_hexrays.hxe_prealloc (variable) - Local variables: preallocation step begins. +ida_hexrays.hxe_right_click + Mouse right click. Use hxe_populating_popup instead, in case you want to add items in the popup menu. + -ida_hexrays.hxe_preoptimized (variable) - Microcode has been preoptimized. +ida_hexrays.hxe_stkpnts + SP change points have been calculated. + -ida_hexrays.hxe_print_func (variable) - Printing ctree and generating text. +ida_hexrays.hxe_structural + Structural analysis has been finished. + -ida_hexrays.hxe_prolog (variable) - Prolog analysis has been finished. +ida_hexrays.hxe_switch_pseudocode + Existing pseudocode view has been reloaded with a new function. Its text has not been refreshed yet, only cfunc and mba pointers are ready. + -ida_hexrays.hxe_refresh_pseudocode (variable) - Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is - forbidden in this event. +ida_hexrays.hxe_text_ready + Decompiled text is ready. + -ida_hexrays.hxe_resolve_stkaddrs (variable) - The optimizer is about to resolve stack addresses. +ida_hexrays.init_hexrays_plugin(flags: int = 0) -> bool + Check that your plugin is compatible with hex-rays decompiler. This function must be called before calling any other decompiler function. + + @param flags: reserved, must be 0 + @returns true if the decompiler exists and is compatible with your plugin -ida_hexrays.hxe_right_click (variable) - Mouse right click. Use hxe_populating_popup instead, in case you want to add - items in the popup menu. +ida_hexrays.install_hexrays_callback(callback) + Install handler for decompiler events. + + @param callback: handler to install + @returns false if failed -ida_hexrays.hxe_stkpnts (variable) - SP change points have been calculated. +ida_hexrays.install_microcode_filter(filter: "microcode_filter_t", install: bool = True) -> bool + register/unregister non-standard microcode generator + + @param filter: - microcode generator object + @param install: - TRUE - register the object, FALSE - unregister + @returns success -ida_hexrays.hxe_structural (variable) - Structural analysis has been finished. - -ida_hexrays.hxe_switch_pseudocode (variable) - Existing pseudocode view has been reloaded with a new function. Its text has not - been refreshed yet, only cfunc and mba pointers are ready. - -ida_hexrays.hxe_text_ready (variable) - Decompiled text is ready. - -ida_hexrays.init_hexrays_plugin (function) - init_hexrays_plugin(flags=0) -> bool - Check that your plugin is compatible with hex-rays decompiler. This function - must be called before calling any other decompiler function. - - @param flags: (C++: int) reserved, must be 0 - @return: true if the decompiler exists and is compatible with your plugin - -ida_hexrays.install_hexrays_callback (function) - Deprecated. Please use Hexrays_Hooks instead - Install handler for decompiler events. - - @return: false if failed - -ida_hexrays.install_microcode_filter (function) - install_microcode_filter(filter, install=True) -> bool - register/unregister non-standard microcode generator - - @param filter: (C++: microcode_filter_t *) - microcode generator object - @param install: (C++: bool) - TRUE - register the object, FALSE - unregister - @return: success - -ida_hexrays.is_additive (function) - is_additive(op) -> bool +ida_hexrays.is_additive(op: "ctype_t") -> bool Is additive operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_assignment (function) - is_assignment(op) -> bool +ida_hexrays.is_assignment(op: "ctype_t") -> bool Is assignment operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_binary (function) - is_binary(op) -> bool +ida_hexrays.is_binary(op: "ctype_t") -> bool Is binary operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_bitop (function) - is_bitop(op) -> bool +ida_hexrays.is_bitop(op: "ctype_t") -> bool Is bit related operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_bool_type (function) - is_bool_type(type) -> bool - Is a boolean type? - - @param type: (C++: const tinfo_t &) tinfo_t const & - @return: true if the type is a boolean type +ida_hexrays.is_bool_type(type: "tinfo_t") -> bool + Is a boolean type? + + @returns true if the type is a boolean type -ida_hexrays.is_break_consumer (function) - is_break_consumer(op) -> bool +ida_hexrays.is_break_consumer(op: "ctype_t") -> bool Does a break statement influence the specified statement code? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_commutative (function) - is_commutative(op) -> bool +ida_hexrays.is_cmpop_with_eq(cmpop: "cmpop_t") -> bool + +ida_hexrays.is_cmpop_without_eq(cmpop: "cmpop_t") -> bool + +ida_hexrays.is_commutative(op: "ctype_t") -> bool Is commutative operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_inplace_def (function) - is_inplace_def(type) -> bool +ida_hexrays.is_inplace_def(type: "tinfo_t") -> bool Is struct/union/enum definition (not declaration)? - - @param type: (C++: const tinfo_t &) tinfo_t const & -ida_hexrays.is_kreg (function) - is_kreg(r) -> bool - Is a kernel register? Kernel registers are temporary registers that can be used - freely. They may be used to store values that cross instruction or basic block - boundaries. Kernel registers do not map to regular processor registers. See also - mba_t::alloc_kreg() - - @param r: (C++: mreg_t) +ida_hexrays.is_kreg(r: "mreg_t") -> bool + Is a kernel register? Kernel registers are temporary registers that can be used freely. They may be used to store values that cross instruction or basic block boundaries. Kernel registers do not map to regular processor registers. See also mba_t::alloc_kreg() + -ida_hexrays.is_logical (function) - is_logical(op) -> bool +ida_hexrays.is_logical(op: "ctype_t") -> bool Is logical operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_loop (function) - is_loop(op) -> bool +ida_hexrays.is_loop(op: "ctype_t") -> bool Is loop statement code? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_lvalue (function) - is_lvalue(op) -> bool +ida_hexrays.is_lvalue(op: "ctype_t") -> bool Is Lvalue operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_may_access (function) - is_may_access(maymust) -> bool - - @param maymust: maymust_t +ida_hexrays.is_may_access(maymust: "maymust_t") -> bool -ida_hexrays.is_mcode_addsub (function) - is_mcode_addsub(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_addsub(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_call (function) - is_mcode_call(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_call(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_commutative (function) - is_mcode_commutative(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_commutative(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_convertible_to_jmp (function) - is_mcode_convertible_to_jmp(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_convertible_to_jmp(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_convertible_to_set (function) - is_mcode_convertible_to_set(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_convertible_to_set(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_divmod (function) - is_mcode_divmod(op) -> bool - - @param op: enum mcode_t +ida_hexrays.is_mcode_divmod(op: "mcode_t") -> bool -ida_hexrays.is_mcode_fpu (function) - is_mcode_fpu(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_fpu(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_j1 (function) - is_mcode_j1(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_j1(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_jcond (function) - is_mcode_jcond(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_jcond(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_propagatable (function) - is_mcode_propagatable(mcode) -> bool - May opcode be propagated? Such opcodes can be used in sub-instructions (nested - instructions) There is a handful of non-propagatable opcodes, like jumps, ret, - nop, etc All other regular opcodes are propagatable and may appear in a nested - instruction. - - @param mcode: (C++: mcode_t) enum mcode_t +ida_hexrays.is_mcode_propagatable(mcode: "mcode_t") -> bool + May opcode be propagated? Such opcodes can be used in sub-instructions (nested instructions) There is a handful of non-propagatable opcodes, like jumps, ret, nop, etc All other regular opcodes are propagatable and may appear in a nested instruction. + -ida_hexrays.is_mcode_set (function) - is_mcode_set(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_set(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_set1 (function) - is_mcode_set1(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_set1(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_shift (function) - is_mcode_shift(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_shift(mcode: "mcode_t") -> bool -ida_hexrays.is_mcode_xdsu (function) - is_mcode_xdsu(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.is_mcode_xdsu(mcode: "mcode_t") -> bool -ida_hexrays.is_multiplicative (function) - is_multiplicative(op) -> bool +ida_hexrays.is_multiplicative(op: "ctype_t") -> bool Is multiplicative operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_nonbool_type (function) - is_nonbool_type(type) -> bool - Is definitely a non-boolean type? - - @param type: (C++: const tinfo_t &) tinfo_t const & - @return: true if the type is a non-boolean type (non bool and well defined) +ida_hexrays.is_nonbool_type(type: "tinfo_t") -> bool + Is definitely a non-boolean type? + + @returns true if the type is a non-boolean type (non bool and well defined) -ida_hexrays.is_paf (function) - is_paf(t) -> bool +ida_hexrays.is_paf(t: "type_t") -> bool Is a pointer, array, or function type? - - @param t: (C++: type_t) -ida_hexrays.is_prepost (function) - is_prepost(op) -> bool +ida_hexrays.is_prepost(op: "ctype_t") -> bool Is pre/post increment/decrement operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_ptr_or_array (function) - is_ptr_or_array(t) -> bool +ida_hexrays.is_ptr_or_array(t: "type_t") -> bool Is a pointer or array type? - - @param t: (C++: type_t) -ida_hexrays.is_relational (function) - is_relational(op) -> bool +ida_hexrays.is_relational(op: "ctype_t") -> bool Is comparison operator? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.is_signed_mcode (function) - is_signed_mcode(code) -> bool - - @param code: enum mcode_t +ida_hexrays.is_signed_cmpop(cmpop: "cmpop_t") -> bool -ida_hexrays.is_small_udt (function) - is_small_udt(tif) -> bool - Is a small structure or union? - - @param tif: (C++: const tinfo_t &) tinfo_t const & - @return: true if the type is a small UDT (user defined type). Small UDTs fit - into a register (or pair or registers) as a rule. +ida_hexrays.is_signed_mcode(code: "mcode_t") -> bool -ida_hexrays.is_type_correct (function) - is_type_correct(ptr) -> bool - Verify a type string. - - @param ptr: (C++: const type_t *) type_t const * - @return: true if type string is correct +ida_hexrays.is_small_udt(tif: "tinfo_t") -> bool + Is a small structure or union? + + @returns true if the type is a small UDT (user defined type). Small UDTs fit into a register (or pair or registers) as a rule. -ida_hexrays.is_unary (function) - is_unary(op) -> bool +ida_hexrays.is_type_correct(ptr: "type_t const *") -> bool + Verify a type string. + + @returns true if type string is correct + +ida_hexrays.is_unary(op: "ctype_t") -> bool Is unary operator? + +ida_hexrays.is_unsigned_cmpop(cmpop: "cmpop_t") -> bool + +ida_hexrays.is_unsigned_mcode(code: "mcode_t") -> bool + +ida_hexrays.iterator + +ida_hexrays.iterator.__eq__(self, n: "iterator") -> bool + +ida_hexrays.iterator.__init__(self, n: int = -1) + +ida_hexrays.iterator.__ne__(self, n: "iterator") -> bool + +ida_hexrays.iterator.__ref__(self) -> int + +ida_hexrays.ivl_t + +ida_hexrays.ivl_t.__eq__(self, r: "ivl_t") -> bool + +ida_hexrays.ivl_t.__ge__(self, r: "ivl_t") -> bool + +ida_hexrays.ivl_t.__gt__(self, r: "ivl_t") -> bool + +ida_hexrays.ivl_t.__init__(self, _off: int = 0, _size: int = 0) + +ida_hexrays.ivl_t.__le__(self, r: "ivl_t") -> bool + +ida_hexrays.ivl_t.__lt__(self, r: "ivl_t") -> bool + +ida_hexrays.ivl_t.__ne__(self, r: "ivl_t") -> bool + +ida_hexrays.ivl_t.clear(self) -> None + +ida_hexrays.ivl_t.compare(self, r: "ivl_t") -> int + +ida_hexrays.ivl_t.contains(self, off2: int) -> bool + +ida_hexrays.ivl_t.dstr(self) -> str + +ida_hexrays.ivl_t.empty(self) -> bool + +ida_hexrays.ivl_t.extend_to_cover(self, r: "ivl_t") -> bool + +ida_hexrays.ivl_t.includes(self, ivl: "ivl_t") -> bool + +ida_hexrays.ivl_t.intersect(self, r: "ivl_t") -> None + +ida_hexrays.ivl_t.overlap(self, ivl: "ivl_t") -> bool + +ida_hexrays.ivl_with_name_t + +ida_hexrays.ivl_with_name_t.__init__(self) + +ida_hexrays.ivlset_t + +ida_hexrays.ivlset_t.__eq__(self, r: "ivlset_t") -> bool + +ida_hexrays.ivlset_t.__ge__(self, r: "ivlset_t") -> bool + +ida_hexrays.ivlset_t.__gt__(self, r: "ivlset_t") -> bool + +ida_hexrays.ivlset_t.__init__(self, *args) + +ida_hexrays.ivlset_t.__le__(self, r: "ivlset_t") -> bool + +ida_hexrays.ivlset_t.__lt__(self, r: "ivlset_t") -> bool + +ida_hexrays.ivlset_t.__ne__(self, r: "ivlset_t") -> bool + +ida_hexrays.ivlset_t._print(self) -> None + +ida_hexrays.ivlset_t.add(self, *args) -> bool + This function has the following signatures: - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_unsigned_mcode (function) - is_unsigned_mcode(code) -> bool + 0. add(ivl: const ivl_t &) -> bool + 1. add(ea: ida_idaapi.ea_t, size: asize_t) -> bool + 2. add(ivs: const ivlset_t &) -> bool - @param code: enum mcode_t - -ida_hexrays.iterator (class) - Proxy of C++ bitset_t::iterator class. - -ida_hexrays.iterator.__eq__ (method) - __eq__(self, n) -> bool + # 0: add(ivl: const ivl_t &) -> bool - @param n: bitset_t::iterator const & - -ida_hexrays.iterator.__init__ (method) - __init__(self, n=-1) -> iterator - @param n: int - -ida_hexrays.iterator.__ne__ (method) - __ne__(self, n) -> bool + # 1: add(ea: ida_idaapi.ea_t, size: asize_t) -> bool - @param n: bitset_t::iterator const & - -ida_hexrays.iterator.__ref__ (method) - __ref__(self) -> int - -ida_hexrays.ivl_t (class) - Proxy of C++ ivl_t class. - -ida_hexrays.ivl_t.__eq__ (method) - __eq__(self, r) -> bool - @param r: ivl_t const & + # 2: add(ivs: const ivlset_t &) -> bool -ida_hexrays.ivl_t.__ge__ (method) - __ge__(self, r) -> bool +ida_hexrays.ivlset_t.addmasked(self, ivs: "ivlset_t", mask: "ivl_t") -> bool + +ida_hexrays.ivlset_t.compare(self, r: "ivlset_t") -> int + +ida_hexrays.ivlset_t.contains(self, off: int) -> bool + +ida_hexrays.ivlset_t.count(self) -> "asize_t" + +ida_hexrays.ivlset_t.dstr(self) -> str + +ida_hexrays.ivlset_t.has_common(self, *args) -> bool + This function has the following signatures: - @param r: ivl_t const & - -ida_hexrays.ivl_t.__gt__ (method) - __gt__(self, r) -> bool + 0. has_common(ivl: const ivl_t &, strict: bool=false) -> bool + 1. has_common(ivs: const ivlset_t &) -> bool - @param r: ivl_t const & - -ida_hexrays.ivl_t.__init__ (method) - __init__(self, _off=0, _size=0) -> ivl_t + # 0: has_common(ivl: const ivl_t &, strict: bool=false) -> bool - @param _off: uval_t - @param _size: uval_t - -ida_hexrays.ivl_t.__le__ (method) - __le__(self, r) -> bool - @param r: ivl_t const & + # 1: has_common(ivs: const ivlset_t &) -> bool -ida_hexrays.ivl_t.__lt__ (method) - __lt__(self, r) -> bool +ida_hexrays.ivlset_t.includes(self, ivs: "ivlset_t") -> bool + +ida_hexrays.ivlset_t.intersect(self, ivs: "ivlset_t") -> bool + +ida_hexrays.ivlset_t.sub(self, *args) -> bool + This function has the following signatures: - @param r: ivl_t const & - -ida_hexrays.ivl_t.__ne__ (method) - __ne__(self, r) -> bool + 0. sub(ivl: const ivl_t &) -> bool + 1. sub(ea: ida_idaapi.ea_t, size: asize_t) -> bool + 2. sub(ivs: const ivlset_t &) -> bool - @param r: ivl_t const & - -ida_hexrays.ivl_t.clear (method) - clear(self) - -ida_hexrays.ivl_t.compare (method) - compare(self, r) -> int + # 0: sub(ivl: const ivl_t &) -> bool - @param r: ivl_t const & - -ida_hexrays.ivl_t.contains (method) - contains(self, off2) -> bool - @param off2: uval_t - -ida_hexrays.ivl_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.ivl_t.empty (method) - empty(self) -> bool - -ida_hexrays.ivl_t.extend_to_cover (method) - extend_to_cover(self, r) -> bool + # 1: sub(ea: ida_idaapi.ea_t, size: asize_t) -> bool - @param r: ivl_t const & + + # 2: sub(ivs: const ivlset_t &) -> bool -ida_hexrays.ivl_t.includes (method) - includes(self, ivl) -> bool - - @param ivl: ivl_t const & +ida_hexrays.jcnd2set(code: "mcode_t") -> "mcode_t" -ida_hexrays.ivl_t.intersect (method) - intersect(self, r) - - @param r: ivl_t const & +ida_hexrays.lexcompare(a: "mop_t", b: "mop_t") -> int -ida_hexrays.ivl_t.overlap (method) - overlap(self, ivl) -> bool - - @param ivl: ivl_t const & +ida_hexrays.lnot(e) + Logically negate the specified expression. The specified expression will be logically negated. For example, "x == y" is converted into "x != y" by this function. + + @param e: expression to negate. After the call, e must not be used anymore because it can be changed by the function. The function return value must be used to refer to the expression. + @returns logically negated expression. -ida_hexrays.ivl_with_name_t (class) - Proxy of C++ ivl_with_name_t class. +ida_hexrays.locate_lvar(out: "lvar_locator_t", func_ea: ida_idaapi.ea_t, varname: str) -> bool + Find a variable by name. + + @param out: output buffer for the variable locator + @param func_ea: function start address + @param varname: variable name + @returns success Since VARNAME is not always enough to find the variable, it may decompile the function. -ida_hexrays.ivl_with_name_t.__init__ (method) - __init__(self) -> ivl_with_name_t +ida_hexrays.lvar_locator_t -ida_hexrays.ivlset_t (class) - Proxy of C++ ivlset_t class. +ida_hexrays.lvar_locator_t.__eq__(self, r: "lvar_locator_t") -> bool -ida_hexrays.ivlset_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ivlset_t const & +ida_hexrays.lvar_locator_t.__ge__(self, r: "lvar_locator_t") -> bool -ida_hexrays.ivlset_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ivlset_t const & +ida_hexrays.lvar_locator_t.__gt__(self, r: "lvar_locator_t") -> bool -ida_hexrays.ivlset_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ivlset_t const & +ida_hexrays.lvar_locator_t.__init__(self, *args) -ida_hexrays.ivlset_t.__init__ (method) - __init__(self) -> ivlset_t - __init__(self, ivl) -> ivlset_t - - @param ivl: ivl_t const & +ida_hexrays.lvar_locator_t.__le__(self, r: "lvar_locator_t") -> bool -ida_hexrays.ivlset_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ivlset_t const & +ida_hexrays.lvar_locator_t.__lt__(self, r: "lvar_locator_t") -> bool -ida_hexrays.ivlset_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ivlset_t const & +ida_hexrays.lvar_locator_t.__ne__(self, r: "lvar_locator_t") -> bool -ida_hexrays.ivlset_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ivlset_t const & +ida_hexrays.lvar_locator_t.compare(self, r: "lvar_locator_t") -> int -ida_hexrays.ivlset_t._print (method) - _print(self) +ida_hexrays.lvar_locator_t.defea + Definition address. Usually, this is the address of the instruction that initializes the variable. In some cases it can be a fictional address. + -ida_hexrays.ivlset_t.add (method) - add(self, ivl) -> bool - - @param ivl: ivl_t const & - - add(self, ea, size) -> bool - - @param ea: ea_t - @param size: asize_t - - add(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.addmasked (method) - addmasked(self, ivs, mask) -> bool - - @param ivs: ivlset_t const & - @param mask: ivl_t const & - -ida_hexrays.ivlset_t.compare (method) - compare(self, r) -> int - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t.contains (method) - contains(self, off) -> bool - - @param off: uval_t - -ida_hexrays.ivlset_t.count (method) - count(self) -> asize_t - -ida_hexrays.ivlset_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.ivlset_t.has_common (method) - has_common(self, ivl, strict=False) -> bool - - @param ivl: ivl_t const & - @param strict: bool - - has_common(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.includes (method) - includes(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.intersect (method) - intersect(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.sub (method) - sub(self, ivl) -> bool - - @param ivl: ivl_t const & - - sub(self, ea, size) -> bool - - @param ea: ea_t - @param size: asize_t - - sub(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.jcnd2set (function) - jcnd2set(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.lexcompare (function) - lexcompare(a, b) -> int - - @param a: mop_t const & - @param b: mop_t const & - -ida_hexrays.lnot (function) - Logically negate the specified expression. The specified expression will be - logically negated. For example, "x == y" is converted into "x != y" by this - function. - - @return: logically negated expression. - -ida_hexrays.locate_lvar (function) - locate_lvar(out, func_ea, varname) -> bool - Find a variable by name. - - @param out: (C++: lvar_locator_t *) output buffer for the variable locator - @param func_ea: (C++: ea_t) function start address - @param varname: (C++: const char *) variable name - @return: success Since VARNAME is not always enough to find the variable, it may - decompile the function. - -ida_hexrays.lvar_locator_t (class) - Proxy of C++ lvar_locator_t class. - -ida_hexrays.lvar_locator_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__init__ (method) - __init__(self) -> lvar_locator_t - __init__(self, loc, ea) -> lvar_locator_t - - @param loc: vdloc_t const & - @param ea: ea_t - -ida_hexrays.lvar_locator_t.__le__ (method) - __le__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.compare (method) - compare(self, r) -> int - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.defea (variable) - Definition address. Usually, this is the address of the instruction that - initializes the variable. In some cases it can be a fictional address. - -ida_hexrays.lvar_locator_t.get_reg1 (method) - get_reg1(self) -> mreg_t +ida_hexrays.lvar_locator_t.get_reg1(self) -> "mreg_t" Get the register number of the variable. -ida_hexrays.lvar_locator_t.get_reg2 (method) - get_reg2(self) -> mreg_t +ida_hexrays.lvar_locator_t.get_reg2(self) -> "mreg_t" Get the number of the second register (works only for ALOC_REG2 lvars) -ida_hexrays.lvar_locator_t.get_scattered (method) - get_scattered(self) -> scattered_aloc_t +ida_hexrays.lvar_locator_t.get_scattered(self) -> "scattered_aloc_t &" + Get information about scattered variable. -ida_hexrays.lvar_locator_t.get_stkoff (method) - get_stkoff(self) -> sval_t - Get offset of the varialbe in the stack frame. - - @return: a non-negative value for stack variables. The value is an offset from - the bottom of the stack frame in terms of vd-offsets. negative values - mean error (not a stack variable) +ida_hexrays.lvar_locator_t.get_stkoff(self) -> int + Get offset of the varialbe in the stack frame. + + @returns a non-negative value for stack variables. The value is an offset from the bottom of the stack frame in terms of vd-offsets. negative values mean error (not a stack variable) -ida_hexrays.lvar_locator_t.is_reg1 (method) - is_reg1(self) -> bool +ida_hexrays.lvar_locator_t.is_reg1(self) -> bool Is variable located on one register? -ida_hexrays.lvar_locator_t.is_reg2 (method) - is_reg2(self) -> bool +ida_hexrays.lvar_locator_t.is_reg2(self) -> bool Is variable located on two registers? -ida_hexrays.lvar_locator_t.is_reg_var (method) - is_reg_var(self) -> bool +ida_hexrays.lvar_locator_t.is_reg_var(self) -> bool Is variable located on register(s)? -ida_hexrays.lvar_locator_t.is_scattered (method) - is_scattered(self) -> bool +ida_hexrays.lvar_locator_t.is_scattered(self) -> bool Is variable scattered? -ida_hexrays.lvar_locator_t.is_stk_var (method) - is_stk_var(self) -> bool +ida_hexrays.lvar_locator_t.is_stk_var(self) -> bool Is variable located on the stack? -ida_hexrays.lvar_locator_t.location (variable) +ida_hexrays.lvar_locator_t.location Variable location. -ida_hexrays.lvar_mapping_begin (function) - lvar_mapping_begin(map) -> lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_begin(map: "lvar_mapping_t") -> "lvar_mapping_iterator_t" Get iterator pointing to the beginning of lvar_mapping_t. - - @param map: (C++: const lvar_mapping_t *) lvar_mapping_t const * -ida_hexrays.lvar_mapping_clear (function) - lvar_mapping_clear(map) +ida_hexrays.lvar_mapping_clear(map: "lvar_mapping_t") -> None Clear lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) -ida_hexrays.lvar_mapping_end (function) - lvar_mapping_end(map) -> lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_end(map: "lvar_mapping_t") -> "lvar_mapping_iterator_t" Get iterator pointing to the end of lvar_mapping_t. - - @param map: (C++: const lvar_mapping_t *) lvar_mapping_t const * -ida_hexrays.lvar_mapping_erase (function) - lvar_mapping_erase(map, p) +ida_hexrays.lvar_mapping_erase(map: "lvar_mapping_t", p: "lvar_mapping_iterator_t") -> None Erase current element from lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) - @param p: (C++: lvar_mapping_iterator_t) -ida_hexrays.lvar_mapping_find (function) - lvar_mapping_find(map, key) -> lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_find(map: "lvar_mapping_t", key: "lvar_locator_t") -> "lvar_mapping_iterator_t" Find the specified key in lvar_mapping_t. - - @param map: (C++: const lvar_mapping_t *) lvar_mapping_t const * - @param key: (C++: const lvar_locator_t &) lvar_locator_t const & -ida_hexrays.lvar_mapping_first (function) - lvar_mapping_first(p) -> lvar_locator_t +ida_hexrays.lvar_mapping_first(p: "lvar_mapping_iterator_t") -> "lvar_locator_t const &" Get reference to the current map key. - - @param p: (C++: lvar_mapping_iterator_t) -ida_hexrays.lvar_mapping_free (function) - lvar_mapping_free(map) +ida_hexrays.lvar_mapping_free(map: "lvar_mapping_t") -> None Delete lvar_mapping_t instance. - - @param map: (C++: lvar_mapping_t *) -ida_hexrays.lvar_mapping_insert (function) - lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_insert(map: "lvar_mapping_t", key: "lvar_locator_t", val: "lvar_locator_t") -> "lvar_mapping_iterator_t" Insert new (lvar_locator_t, lvar_locator_t) pair into lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) - @param key: (C++: const lvar_locator_t &) lvar_locator_t const & - @param val: (C++: const lvar_locator_t &) lvar_locator_t const & -ida_hexrays.lvar_mapping_iterator_t (class) - Proxy of C++ lvar_mapping_iterator_t class. +ida_hexrays.lvar_mapping_iterator_t -ida_hexrays.lvar_mapping_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: lvar_mapping_iterator_t const & +ida_hexrays.lvar_mapping_iterator_t.__eq__(self, p: "lvar_mapping_iterator_t") -> bool -ida_hexrays.lvar_mapping_iterator_t.__init__ (method) - __init__(self) -> lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_iterator_t.__init__(self) -ida_hexrays.lvar_mapping_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: lvar_mapping_iterator_t const & +ida_hexrays.lvar_mapping_iterator_t.__ne__(self, p: "lvar_mapping_iterator_t") -> bool -ida_hexrays.lvar_mapping_new (function) - lvar_mapping_new() -> lvar_mapping_t +ida_hexrays.lvar_mapping_new() -> "lvar_mapping_t *" Create a new lvar_mapping_t instance. -ida_hexrays.lvar_mapping_next (function) - lvar_mapping_next(p) -> lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_next(p: "lvar_mapping_iterator_t") -> "lvar_mapping_iterator_t" Move to the next element. - - @param p: (C++: lvar_mapping_iterator_t) -ida_hexrays.lvar_mapping_prev (function) - lvar_mapping_prev(p) -> lvar_mapping_iterator_t +ida_hexrays.lvar_mapping_prev(p: "lvar_mapping_iterator_t") -> "lvar_mapping_iterator_t" Move to the previous element. - - @param p: (C++: lvar_mapping_iterator_t) -ida_hexrays.lvar_mapping_second (function) - lvar_mapping_second(p) -> lvar_locator_t +ida_hexrays.lvar_mapping_second(p: "lvar_mapping_iterator_t") -> "lvar_locator_t &" Get reference to the current map value. - - @param p: (C++: lvar_mapping_iterator_t) -ida_hexrays.lvar_mapping_size (function) - lvar_mapping_size(map) -> size_t +ida_hexrays.lvar_mapping_size(map: "lvar_mapping_t") -> "size_t" Get size of lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) -ida_hexrays.lvar_mapping_t (class) - Proxy of C++ std::map< lvar_locator_t,lvar_locator_t > class. +ida_hexrays.lvar_mapping_t -ida_hexrays.lvar_mapping_t.__init__ (method) - __init__(self) -> lvar_mapping_t +ida_hexrays.lvar_mapping_t.__init__(self) -ida_hexrays.lvar_mapping_t.at (method) - at(self, _Keyval) -> lvar_locator_t - - @param _Keyval: lvar_locator_t const & +ida_hexrays.lvar_mapping_t.at(self, _Keyval: "lvar_locator_t") -> "lvar_locator_t &" -ida_hexrays.lvar_mapping_t.size (method) - size(self) -> size_t +ida_hexrays.lvar_mapping_t.size(self) -> "size_t" -ida_hexrays.lvar_ref_t (class) - Proxy of C++ lvar_ref_t class. +ida_hexrays.lvar_ref_t -ida_hexrays.lvar_ref_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.__eq__(self, r: "lvar_ref_t") -> bool -ida_hexrays.lvar_ref_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.__ge__(self, r: "lvar_ref_t") -> bool -ida_hexrays.lvar_ref_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.__gt__(self, r: "lvar_ref_t") -> bool -ida_hexrays.lvar_ref_t.__init__ (method) - __init__(self, m, i, o=0) -> lvar_ref_t - - @param m: mba_t * - @param i: int - @param o: sval_t - - __init__(self, r) -> lvar_ref_t - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.__init__(self, *args) -ida_hexrays.lvar_ref_t.__le__ (method) - __le__(self, r) -> bool - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.__le__(self, r: "lvar_ref_t") -> bool -ida_hexrays.lvar_ref_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.__lt__(self, r: "lvar_ref_t") -> bool -ida_hexrays.lvar_ref_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.__ne__(self, r: "lvar_ref_t") -> bool -ida_hexrays.lvar_ref_t.compare (method) - compare(self, r) -> int - - @param r: lvar_ref_t const & +ida_hexrays.lvar_ref_t.compare(self, r: "lvar_ref_t") -> int -ida_hexrays.lvar_ref_t.idx (variable) +ida_hexrays.lvar_ref_t.idx index into mba->vars -ida_hexrays.lvar_ref_t.mba (variable) - Pointer to the parent mba_t object. Since we need to access the 'mba->vars' - array in order to retrieve the referenced variable, we keep a pointer to mba_t - here. Note: this means this class and consequently mop_t, minsn_t, mblock_t are - specific to a mba_t object and cannot migrate between them. fortunately this is - not something we need to do. second, lvar_ref_t's appear only after MMAT_LVARS. +ida_hexrays.lvar_ref_t.mba + Pointer to the parent mba_t object. Since we need to access the 'mba->vars' array in order to retrieve the referenced variable, we keep a pointer to mba_t here. Note: this means this class and consequently mop_t, minsn_t, mblock_t are specific to a mba_t object and cannot migrate between them. fortunately this is not something we need to do. second, lvar_ref_t's appear only after MMAT_LVARS. + -ida_hexrays.lvar_ref_t.off (variable) +ida_hexrays.lvar_ref_t.off offset from the beginning of the variable -ida_hexrays.lvar_ref_t.swap (method) - swap(self, r) - - @param r: lvar_ref_t & +ida_hexrays.lvar_ref_t.swap(self, r: "lvar_ref_t") -> None -ida_hexrays.lvar_ref_t.var (method) - var(self) -> lvar_t +ida_hexrays.lvar_ref_t.var(self) -> "lvar_t &" Retrieve the referenced variable. -ida_hexrays.lvar_saved_info_t (class) - Proxy of C++ lvar_saved_info_t class. +ida_hexrays.lvar_saved_info_t -ida_hexrays.lvar_saved_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lvar_saved_info_t const & +ida_hexrays.lvar_saved_info_t.__eq__(self, r: "lvar_saved_info_t") -> bool -ida_hexrays.lvar_saved_info_t.__init__ (method) - __init__(self) -> lvar_saved_info_t +ida_hexrays.lvar_saved_info_t.__init__(self) -ida_hexrays.lvar_saved_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lvar_saved_info_t const & +ida_hexrays.lvar_saved_info_t.__ne__(self, r: "lvar_saved_info_t") -> bool -ida_hexrays.lvar_saved_info_t.clear_keep (method) - clear_keep(self) +ida_hexrays.lvar_saved_info_t.clear_keep(self) -> None -ida_hexrays.lvar_saved_info_t.clr_nomap_lvar (method) - clr_nomap_lvar(self) +ida_hexrays.lvar_saved_info_t.clr_nomap_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.clr_noptr_lvar (method) - clr_noptr_lvar(self) +ida_hexrays.lvar_saved_info_t.clr_noptr_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.clr_split_lvar (method) - clr_split_lvar(self) +ida_hexrays.lvar_saved_info_t.clr_split_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.clr_unused_lvar (method) - clr_unused_lvar(self) +ida_hexrays.lvar_saved_info_t.clr_unused_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.cmt (variable) +ida_hexrays.lvar_saved_info_t.cmt Comment. -ida_hexrays.lvar_saved_info_t.flags (variable) - saved user lvar info property bits +ida_hexrays.lvar_saved_info_t.flags + saved user lvar info property bits + -ida_hexrays.lvar_saved_info_t.has_info (method) - has_info(self) -> bool +ida_hexrays.lvar_saved_info_t.has_info(self) -> bool -ida_hexrays.lvar_saved_info_t.is_kept (method) - is_kept(self) -> bool +ida_hexrays.lvar_saved_info_t.is_kept(self) -> bool -ida_hexrays.lvar_saved_info_t.is_nomap_lvar (method) - is_nomap_lvar(self) -> bool +ida_hexrays.lvar_saved_info_t.is_nomap_lvar(self) -> bool -ida_hexrays.lvar_saved_info_t.is_noptr_lvar (method) - is_noptr_lvar(self) -> bool +ida_hexrays.lvar_saved_info_t.is_noptr_lvar(self) -> bool -ida_hexrays.lvar_saved_info_t.is_split_lvar (method) - is_split_lvar(self) -> bool +ida_hexrays.lvar_saved_info_t.is_split_lvar(self) -> bool -ida_hexrays.lvar_saved_info_t.is_unused_lvar (method) - is_unused_lvar(self) -> bool +ida_hexrays.lvar_saved_info_t.is_unused_lvar(self) -> bool -ida_hexrays.lvar_saved_info_t.ll (variable) +ida_hexrays.lvar_saved_info_t.ll Variable locator. -ida_hexrays.lvar_saved_info_t.name (variable) +ida_hexrays.lvar_saved_info_t.name Name. -ida_hexrays.lvar_saved_info_t.set_keep (method) - set_keep(self) +ida_hexrays.lvar_saved_info_t.set_keep(self) -> None -ida_hexrays.lvar_saved_info_t.set_nomap_lvar (method) - set_nomap_lvar(self) +ida_hexrays.lvar_saved_info_t.set_nomap_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.set_noptr_lvar (method) - set_noptr_lvar(self) +ida_hexrays.lvar_saved_info_t.set_noptr_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.set_split_lvar (method) - set_split_lvar(self) +ida_hexrays.lvar_saved_info_t.set_split_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.set_unused_lvar (method) - set_unused_lvar(self) +ida_hexrays.lvar_saved_info_t.set_unused_lvar(self) -> None -ida_hexrays.lvar_saved_info_t.size (variable) +ida_hexrays.lvar_saved_info_t.size Type size (if not initialized then -1) -ida_hexrays.lvar_saved_info_t.type (variable) +ida_hexrays.lvar_saved_info_t.type Type. -ida_hexrays.lvar_saved_infos_t (class) - Proxy of C++ qvector< lvar_saved_info_t > class. +ida_hexrays.lvar_saved_infos_t -ida_hexrays.lvar_saved_infos_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< lvar_saved_info_t > const & +ida_hexrays.lvar_saved_infos_t.__eq__(self, r: "lvar_saved_infos_t") -> bool -ida_hexrays.lvar_saved_infos_t.__getitem__ (method) - __getitem__(self, i) -> lvar_saved_info_t - - @param i: size_t +ida_hexrays.lvar_saved_infos_t.__getitem__(self, i: "size_t") -> "lvar_saved_info_t const &" -ida_hexrays.lvar_saved_infos_t.__init__ (method) - __init__(self) -> lvar_saved_infos_t - __init__(self, x) -> lvar_saved_infos_t - - @param x: qvector< lvar_saved_info_t > const & +ida_hexrays.lvar_saved_infos_t.__init__(self, *args) -ida_hexrays.lvar_saved_infos_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.lvar_saved_infos_t.__len__(self) -> "size_t" -ida_hexrays.lvar_saved_infos_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< lvar_saved_info_t > const & +ida_hexrays.lvar_saved_infos_t.__ne__(self, r: "lvar_saved_infos_t") -> bool -ida_hexrays.lvar_saved_infos_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: lvar_saved_info_t const & +ida_hexrays.lvar_saved_infos_t.__setitem__(self, i: "size_t", v: "lvar_saved_info_t") -> None -ida_hexrays.lvar_saved_infos_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: lvar_saved_info_t const & +ida_hexrays.lvar_saved_infos_t._del(self, x: "lvar_saved_info_t") -> bool -ida_hexrays.lvar_saved_infos_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: lvar_saved_info_t const & +ida_hexrays.lvar_saved_infos_t.add_unique(self, x: "lvar_saved_info_t") -> bool -ida_hexrays.lvar_saved_infos_t.at (method) - at(self, _idx) -> lvar_saved_info_t - - @param _idx: size_t +ida_hexrays.lvar_saved_infos_t.append(self, x: "lvar_saved_info_t") -> None -ida_hexrays.lvar_saved_infos_t.begin (method) - begin(self) -> lvar_saved_info_t +ida_hexrays.lvar_saved_infos_t.at(self, _idx: "size_t") -> "lvar_saved_info_t const &" -ida_hexrays.lvar_saved_infos_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.lvar_saved_infos_t.begin(self, *args) -> "qvector< lvar_saved_info_t >::const_iterator" -ida_hexrays.lvar_saved_infos_t.clear (method) - clear(self) +ida_hexrays.lvar_saved_infos_t.capacity(self) -> "size_t" -ida_hexrays.lvar_saved_infos_t.empty (method) - empty(self) -> bool +ida_hexrays.lvar_saved_infos_t.clear(self) -> None -ida_hexrays.lvar_saved_infos_t.end (method) - end(self) -> lvar_saved_info_t +ida_hexrays.lvar_saved_infos_t.empty(self) -> bool -ida_hexrays.lvar_saved_infos_t.erase (method) - erase(self, it) -> lvar_saved_info_t - - @param it: qvector< lvar_saved_info_t >::iterator - - erase(self, first, last) -> lvar_saved_info_t - - @param first: qvector< lvar_saved_info_t >::iterator - @param last: qvector< lvar_saved_info_t >::iterator +ida_hexrays.lvar_saved_infos_t.end(self, *args) -> "qvector< lvar_saved_info_t >::const_iterator" -ida_hexrays.lvar_saved_infos_t.extract (method) - extract(self) -> lvar_saved_info_t +ida_hexrays.lvar_saved_infos_t.erase(self, *args) -> "qvector< lvar_saved_info_t >::iterator" -ida_hexrays.lvar_saved_infos_t.find (method) - find(self, x) -> lvar_saved_info_t - - @param x: lvar_saved_info_t const & +ida_hexrays.lvar_saved_infos_t.extend(self, x: "lvar_saved_infos_t") -> None -ida_hexrays.lvar_saved_infos_t.grow (method) - grow(self, x=lvar_saved_info_t()) - - @param x: lvar_saved_info_t const & +ida_hexrays.lvar_saved_infos_t.extract(self) -> "lvar_saved_info_t *" -ida_hexrays.lvar_saved_infos_t.has (method) - has(self, x) -> bool - - @param x: lvar_saved_info_t const & +ida_hexrays.lvar_saved_infos_t.find(self, *args) -> "qvector< lvar_saved_info_t >::const_iterator" -ida_hexrays.lvar_saved_infos_t.inject (method) - inject(self, s, len) - - @param s: lvar_saved_info_t * - @param len: size_t +ida_hexrays.lvar_saved_infos_t.grow(self, *args) -> None -ida_hexrays.lvar_saved_infos_t.insert (method) - insert(self, it, x) -> lvar_saved_info_t - - @param it: qvector< lvar_saved_info_t >::iterator - @param x: lvar_saved_info_t const & +ida_hexrays.lvar_saved_infos_t.has(self, x: "lvar_saved_info_t") -> bool -ida_hexrays.lvar_saved_infos_t.pop_back (method) - pop_back(self) +ida_hexrays.lvar_saved_infos_t.inject(self, s: "lvar_saved_info_t", len: "size_t") -> None -ida_hexrays.lvar_saved_infos_t.push_back (method) - push_back(self, x) - - @param x: lvar_saved_info_t const & - - push_back(self) -> lvar_saved_info_t +ida_hexrays.lvar_saved_infos_t.insert(self, it: "lvar_saved_info_t", x: "lvar_saved_info_t") -> "qvector< lvar_saved_info_t >::iterator" -ida_hexrays.lvar_saved_infos_t.qclear (method) - qclear(self) +ida_hexrays.lvar_saved_infos_t.pop_back(self) -> None -ida_hexrays.lvar_saved_infos_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.lvar_saved_infos_t.push_back(self, *args) -> "lvar_saved_info_t &" -ida_hexrays.lvar_saved_infos_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: lvar_saved_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.lvar_saved_infos_t.qclear(self) -> None -ida_hexrays.lvar_saved_infos_t.size (method) - size(self) -> size_t +ida_hexrays.lvar_saved_infos_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.lvar_saved_infos_t.swap (method) - swap(self, r) - - @param r: qvector< lvar_saved_info_t > & +ida_hexrays.lvar_saved_infos_t.resize(self, *args) -> None -ida_hexrays.lvar_saved_infos_t.truncate (method) - truncate(self) +ida_hexrays.lvar_saved_infos_t.size(self) -> "size_t" -ida_hexrays.lvar_t (class) - Proxy of C++ lvar_t class. +ida_hexrays.lvar_saved_infos_t.swap(self, r: "lvar_saved_infos_t") -> None -ida_hexrays.lvar_t.__init__ (method) +ida_hexrays.lvar_saved_infos_t.truncate(self) -> None -ida_hexrays.lvar_t.accepts_type (method) - accepts_type(self, t, may_change_thisarg=False) -> bool - Check if the variable accept the specified type. Some types are forbidden (void, - function types, wrong arrays, etc) - - @param t: (C++: const tinfo_t &) tinfo_t const & - @param may_change_thisarg: (C++: bool) +ida_hexrays.lvar_t -ida_hexrays.lvar_t.append_list (method) - append_list(self, mba, lst, pad_if_scattered=False) - Append local variable to mlist. - - @param mba: (C++: const mba_t *) ptr to the current mba_t - @param lst: (C++: mlist_t *) list to append to - @param pad_if_scattered: (C++: bool) if true, append padding bytes in case of scattered lvar +ida_hexrays.lvar_t.__init__(self, *args, **kwargs) -ida_hexrays.lvar_t.clear_used (method) - clear_used(self) +ida_hexrays.lvar_t.accepts_type(self, t: "tinfo_t", may_change_thisarg: bool = False) -> bool + Check if the variable accept the specified type. Some types are forbidden (void, function types, wrong arrays, etc) + -ida_hexrays.lvar_t.clr_arg_var (method) - clr_arg_var(self) +ida_hexrays.lvar_t.append_list(self, mba: "mba_t", lst: "mlist_t", pad_if_scattered: bool = False) -> None + Append local variable to mlist. + + @param mba: ptr to the current mba_t + @param lst: list to append to + @param pad_if_scattered: if true, append padding bytes in case of scattered lvar -ida_hexrays.lvar_t.clr_automapped (method) - clr_automapped(self) +ida_hexrays.lvar_t.clear_used(self) -> None -ida_hexrays.lvar_t.clr_decl_unused (method) - clr_decl_unused(self) +ida_hexrays.lvar_t.clr_arg_var(self) -> None -ida_hexrays.lvar_t.clr_dummy_arg (method) - clr_dummy_arg(self) +ida_hexrays.lvar_t.clr_automapped(self) -> None -ida_hexrays.lvar_t.clr_fake_var (method) - clr_fake_var(self) +ida_hexrays.lvar_t.clr_decl_unused(self) -> None -ida_hexrays.lvar_t.clr_floating_var (method) - clr_floating_var(self) +ida_hexrays.lvar_t.clr_dummy_arg(self) -> None -ida_hexrays.lvar_t.clr_mapdst_var (method) - clr_mapdst_var(self) +ida_hexrays.lvar_t.clr_fake_var(self) -> None -ida_hexrays.lvar_t.clr_mreg_done (method) - clr_mreg_done(self) +ida_hexrays.lvar_t.clr_floating_var(self) -> None -ida_hexrays.lvar_t.clr_noptr_var (method) - clr_noptr_var(self) +ida_hexrays.lvar_t.clr_mapdst_var(self) -> None -ida_hexrays.lvar_t.clr_notarg (method) - clr_notarg(self) +ida_hexrays.lvar_t.clr_mreg_done(self) -> None -ida_hexrays.lvar_t.clr_overlapped_var (method) - clr_overlapped_var(self) +ida_hexrays.lvar_t.clr_noptr_var(self) -> None -ida_hexrays.lvar_t.clr_shared (method) - clr_shared(self) +ida_hexrays.lvar_t.clr_notarg(self) -> None -ida_hexrays.lvar_t.clr_split_var (method) - clr_split_var(self) +ida_hexrays.lvar_t.clr_overlapped_var(self) -> None -ida_hexrays.lvar_t.clr_spoiled_var (method) - clr_spoiled_var(self) +ida_hexrays.lvar_t.clr_scattered_arg(self) -> None -ida_hexrays.lvar_t.clr_thisarg (method) - clr_thisarg(self) +ida_hexrays.lvar_t.clr_shared(self) -> None -ida_hexrays.lvar_t.clr_unknown_width (method) - clr_unknown_width(self) +ida_hexrays.lvar_t.clr_split_var(self) -> None -ida_hexrays.lvar_t.clr_used_byref (method) - clr_used_byref(self) +ida_hexrays.lvar_t.clr_spoiled_var(self) -> None -ida_hexrays.lvar_t.clr_user_info (method) - clr_user_info(self) +ida_hexrays.lvar_t.clr_thisarg(self) -> None -ida_hexrays.lvar_t.clr_user_name (method) - clr_user_name(self) +ida_hexrays.lvar_t.clr_unknown_width(self) -> None -ida_hexrays.lvar_t.clr_user_type (method) - clr_user_type(self) +ida_hexrays.lvar_t.clr_used_byref(self) -> None -ida_hexrays.lvar_t.cmt (variable) +ida_hexrays.lvar_t.clr_user_info(self) -> None + +ida_hexrays.lvar_t.clr_user_name(self) -> None + +ida_hexrays.lvar_t.clr_user_type(self) -> None + +ida_hexrays.lvar_t.cmt variable comment string -ida_hexrays.lvar_t.defblk (variable) - first block defining the variable. 0 for args, -1 if unknown +ida_hexrays.lvar_t.defblk + first block defining the variable. 0 for args, -1 if unknown + -ida_hexrays.lvar_t.divisor (variable) +ida_hexrays.lvar_t.divisor max known divisor of the variable -ida_hexrays.lvar_t.has_common (method) - has_common(self, v) -> bool +ida_hexrays.lvar_t.has_common(self, v: "lvar_t") -> bool Do variables overlap? - - @param v: (C++: const lvar_t &) lvar_t const & -ida_hexrays.lvar_t.has_common_bit (method) - has_common_bit(self, loc, width2) -> bool +ida_hexrays.lvar_t.has_common_bit(self, loc: "vdloc_t", width2: "asize_t") -> bool Does the variable overlap with the specified location? - - @param loc: (C++: const vdloc_t &) vdloc_t const & - @param width2: (C++: asize_t) -ida_hexrays.lvar_t.has_nice_name (method) - has_nice_name(self) -> bool +ida_hexrays.lvar_t.has_nice_name(self) -> bool Does the variable have a nice name? -ida_hexrays.lvar_t.has_regname (method) - has_regname(self) -> bool +ida_hexrays.lvar_t.has_regname(self) -> bool Has a register name? (like _RAX) -ida_hexrays.lvar_t.has_user_info (method) - has_user_info(self) -> bool +ida_hexrays.lvar_t.has_user_info(self) -> bool Has any user-defined information? -ida_hexrays.lvar_t.has_user_name (method) - has_user_name(self) -> bool +ida_hexrays.lvar_t.has_user_name(self) -> bool Has user-defined name? -ida_hexrays.lvar_t.has_user_type (method) - has_user_type(self) -> bool +ida_hexrays.lvar_t.has_user_type(self) -> bool Has user-defined type? -ida_hexrays.lvar_t.in_asm (method) - in_asm(self) -> bool +ida_hexrays.lvar_t.in_asm(self) -> bool Is variable used in an instruction translated into __asm? -ida_hexrays.lvar_t.is_aliasable (method) - is_aliasable(self, mba) -> bool - Is the variable aliasable? - - @param mba: (C++: const mba_t *) ptr to the current mba_t Aliasable variables may be modified - indirectly (through a pointer) +ida_hexrays.lvar_t.is_aliasable(self, mba: "mba_t") -> bool + Is the variable aliasable? + + @param mba: ptr to the current mba_t Aliasable variables may be modified indirectly (through a pointer) -ida_hexrays.lvar_t.is_arg_var (method) - is_arg_var(self) -> bool +ida_hexrays.lvar_t.is_arg_var(self) -> bool Is the function argument? -ida_hexrays.lvar_t.is_automapped (method) - is_automapped(self) -> bool +ida_hexrays.lvar_t.is_automapped(self) -> bool Was the variable automatically mapped to another variable? -ida_hexrays.lvar_t.is_decl_unused (method) - is_decl_unused(self) -> bool +ida_hexrays.lvar_t.is_decl_unused(self) -> bool Was declared as __unused by the user? See CVAR_UNUSED. -ida_hexrays.lvar_t.is_dummy_arg (method) - is_dummy_arg(self) -> bool +ida_hexrays.lvar_t.is_dummy_arg(self) -> bool Is a dummy argument (added to fill a hole in the argument list) -ida_hexrays.lvar_t.is_fake_var (method) - is_fake_var(self) -> bool +ida_hexrays.lvar_t.is_fake_var(self) -> bool Is fake return variable? -ida_hexrays.lvar_t.is_floating_var (method) - is_floating_var(self) -> bool +ida_hexrays.lvar_t.is_floating_var(self) -> bool Used by a fpu insn? -ida_hexrays.lvar_t.is_mapdst_var (method) - is_mapdst_var(self) -> bool +ida_hexrays.lvar_t.is_mapdst_var(self) -> bool Other variable(s) map to this var? -ida_hexrays.lvar_t.is_noptr_var (method) - is_noptr_var(self) -> bool +ida_hexrays.lvar_t.is_noptr_var(self) -> bool Variable type should not be a pointer. -ida_hexrays.lvar_t.is_notarg (method) - is_notarg(self) -> bool +ida_hexrays.lvar_t.is_notarg(self) -> bool Is a local variable? (local variable cannot be an input argument) -ida_hexrays.lvar_t.is_overlapped_var (method) - is_overlapped_var(self) -> bool +ida_hexrays.lvar_t.is_overlapped_var(self) -> bool Is overlapped variable? -ida_hexrays.lvar_t.is_result_var (method) - is_result_var(self) -> bool +ida_hexrays.lvar_t.is_result_var(self) -> bool Is the function result? -ida_hexrays.lvar_t.is_shared (method) - is_shared(self) -> bool +ida_hexrays.lvar_t.is_shared(self) -> bool Is lvar mapped to several chains. -ida_hexrays.lvar_t.is_split_var (method) - is_split_var(self) -> bool +ida_hexrays.lvar_t.is_split_var(self) -> bool Is a split variable? -ida_hexrays.lvar_t.is_spoiled_var (method) - is_spoiled_var(self) -> bool +ida_hexrays.lvar_t.is_spoiled_var(self) -> bool Is spoiled var? (meaningful only during lvar allocation) -ida_hexrays.lvar_t.is_thisarg (method) - is_thisarg(self) -> bool +ida_hexrays.lvar_t.is_thisarg(self) -> bool Is 'this' argument of a C++ member function? -ida_hexrays.lvar_t.is_unknown_width (method) - is_unknown_width(self) -> bool +ida_hexrays.lvar_t.is_unknown_width(self) -> bool Do we know the width of the variable? -ida_hexrays.lvar_t.is_used_byref (method) - is_used_byref(self) -> bool +ida_hexrays.lvar_t.is_used_byref(self) -> bool Was the address of the variable taken? -ida_hexrays.lvar_t.mreg_done (method) - mreg_done(self) -> bool +ida_hexrays.lvar_t.mreg_done(self) -> bool Have corresponding microregs been replaced by references to this variable? -ida_hexrays.lvar_t.name (variable) - variable name. use mba_t::set_nice_lvar_name() and mba_t::set_user_lvar_name() - to modify it +ida_hexrays.lvar_t.name + variable name. use mba_t::set_nice_lvar_name() and mba_t::set_user_lvar_name() to modify it + -ida_hexrays.lvar_t.set_arg_var (method) - set_arg_var(self) +ida_hexrays.lvar_t.set_arg_var(self) -> None -ida_hexrays.lvar_t.set_automapped (method) - set_automapped(self) +ida_hexrays.lvar_t.set_automapped(self) -> None -ida_hexrays.lvar_t.set_decl_unused (method) - set_decl_unused(self) +ida_hexrays.lvar_t.set_decl_unused(self) -> None -ida_hexrays.lvar_t.set_dummy_arg (method) - set_dummy_arg(self) +ida_hexrays.lvar_t.set_dummy_arg(self) -> None -ida_hexrays.lvar_t.set_fake_var (method) - set_fake_var(self) +ida_hexrays.lvar_t.set_fake_var(self) -> None -ida_hexrays.lvar_t.set_final_lvar_type (method) - set_final_lvar_type(self, t) +ida_hexrays.lvar_t.set_final_lvar_type(self, t: "tinfo_t") -> None Set final variable type. - - @param t: (C++: const tinfo_t &) tinfo_t const & -ida_hexrays.lvar_t.set_floating_var (method) - set_floating_var(self) +ida_hexrays.lvar_t.set_floating_var(self) -> None -ida_hexrays.lvar_t.set_lvar_type (method) - set_lvar_type(self, t, may_fail=False) -> bool - Set variable type Note: this function does not modify the idb, only the lvar - instance in the memory. For permanent changes see modify_user_lvars() Also, the - variable type is not considered as final by the decompiler and may be modified - later by the type derivation. In some cases set_final_var_type() may work - better, but it does not do persistent changes to the database neither. - - @param t: (C++: const tinfo_t &) new type - @param may_fail: (C++: bool) if false and type is bad, interr - @return: success +ida_hexrays.lvar_t.set_lvar_type(self, t: "tinfo_t", may_fail: bool = False) -> bool + Set variable type Note: this function does not modify the idb, only the lvar instance in the memory. For permanent changes see modify_user_lvars() Also, the variable type is not considered as final by the decompiler and may be modified later by the type derivation. In some cases set_final_var_type() may work better, but it does not do persistent changes to the database neither. + + @param t: new type + @param may_fail: if false and type is bad, interr + @returns success -ida_hexrays.lvar_t.set_mapdst_var (method) - set_mapdst_var(self) +ida_hexrays.lvar_t.set_mapdst_var(self) -> None -ida_hexrays.lvar_t.set_mreg_done (method) - set_mreg_done(self) +ida_hexrays.lvar_t.set_mreg_done(self) -> None -ida_hexrays.lvar_t.set_non_typed (method) - set_non_typed(self) +ida_hexrays.lvar_t.set_non_typed(self) -> None -ida_hexrays.lvar_t.set_noptr_var (method) - set_noptr_var(self) +ida_hexrays.lvar_t.set_noptr_var(self) -> None -ida_hexrays.lvar_t.set_notarg (method) - set_notarg(self) +ida_hexrays.lvar_t.set_notarg(self) -> None -ida_hexrays.lvar_t.set_overlapped_var (method) - set_overlapped_var(self) +ida_hexrays.lvar_t.set_overlapped_var(self) -> None -ida_hexrays.lvar_t.set_shared (method) - set_shared(self) +ida_hexrays.lvar_t.set_scattered_arg(self) -> None -ida_hexrays.lvar_t.set_split_var (method) - set_split_var(self) +ida_hexrays.lvar_t.set_shared(self) -> None -ida_hexrays.lvar_t.set_spoiled_var (method) - set_spoiled_var(self) +ida_hexrays.lvar_t.set_split_var(self) -> None -ida_hexrays.lvar_t.set_thisarg (method) - set_thisarg(self) +ida_hexrays.lvar_t.set_spoiled_var(self) -> None -ida_hexrays.lvar_t.set_typed (method) - set_typed(self) +ida_hexrays.lvar_t.set_thisarg(self) -> None -ida_hexrays.lvar_t.set_unknown_width (method) - set_unknown_width(self) +ida_hexrays.lvar_t.set_typed(self) -> None -ida_hexrays.lvar_t.set_used (method) - set_used(self) +ida_hexrays.lvar_t.set_unknown_width(self) -> None -ida_hexrays.lvar_t.set_used_byref (method) - set_used_byref(self) +ida_hexrays.lvar_t.set_used(self) -> None -ida_hexrays.lvar_t.set_user_name (method) - set_user_name(self) +ida_hexrays.lvar_t.set_used_byref(self) -> None -ida_hexrays.lvar_t.set_user_type (method) - set_user_type(self) +ida_hexrays.lvar_t.set_user_name(self) -> None -ida_hexrays.lvar_t.set_width (method) - set_width(self, w, svw_flags=0) -> bool - Change the variable width. We call the variable size 'width', it is represents - the number of bytes. This function may change the variable type using - set_lvar_type(). - - @param w: (C++: int) new width - @param svw_flags: (C++: int) combination of SVW_... bits - @return: success +ida_hexrays.lvar_t.set_user_type(self) -> None -ida_hexrays.lvar_t.tif (variable) +ida_hexrays.lvar_t.set_width(self, w: int, svw_flags: int = 0) -> bool + Change the variable width. We call the variable size 'width', it is represents the number of bytes. This function may change the variable type using set_lvar_type(). + + @param w: new width + @param svw_flags: combination of SVW_... bits + @returns success + +ida_hexrays.lvar_t.tif variable type -ida_hexrays.lvar_t.type (method) - type(self) -> tinfo_t +ida_hexrays.lvar_t.type(self) -> "tinfo_t &" + Get variable type. -ida_hexrays.lvar_t.typed (method) - typed(self) -> bool +ida_hexrays.lvar_t.typed(self) -> bool Has the variable a type? -ida_hexrays.lvar_t.used (method) - used(self) -> bool +ida_hexrays.lvar_t.used(self) -> bool Is the variable used in the code? -ida_hexrays.lvar_t.width (variable) +ida_hexrays.lvar_t.was_scattered_arg(self) -> bool + Was lvar transformed from a scattered argument? + +ida_hexrays.lvar_t.width variable size in bytes -ida_hexrays.lvar_uservec_t (class) - Proxy of C++ lvar_uservec_t class. +ida_hexrays.lvar_uservec_t -ida_hexrays.lvar_uservec_t.__init__ (method) - __init__(self) -> lvar_uservec_t +ida_hexrays.lvar_uservec_t.__init__(self) -ida_hexrays.lvar_uservec_t.clear (method) - clear(self) +ida_hexrays.lvar_uservec_t.clear(self) -> None -ida_hexrays.lvar_uservec_t.empty (method) - empty(self) -> bool +ida_hexrays.lvar_uservec_t.empty(self) -> bool -ida_hexrays.lvar_uservec_t.find_info (method) - find_info(self, vloc) -> lvar_saved_info_t +ida_hexrays.lvar_uservec_t.find_info(self, vloc: "lvar_locator_t") -> "lvar_saved_info_t *" find saved user settings for given var - - @param vloc: (C++: const lvar_locator_t &) lvar_locator_t const & -ida_hexrays.lvar_uservec_t.keep_info (method) - keep_info(self, v) +ida_hexrays.lvar_uservec_t.keep_info(self, v: "lvar_t") -> None Preserve user settings for given var. - - @param v: (C++: const lvar_t &) lvar_t const & -ida_hexrays.lvar_uservec_t.lmaps (variable) +ida_hexrays.lvar_uservec_t.lmaps Local variable mapping (used for merging variables) -ida_hexrays.lvar_uservec_t.lvvec (variable) - User-specified names, types, comments for lvars. Variables without user- - specified info are not present in this vector. +ida_hexrays.lvar_uservec_t.lvvec + User-specified names, types, comments for lvars. Variables without user-specified info are not present in this vector. + -ida_hexrays.lvar_uservec_t.stkoff_delta (variable) - Delta to add to IDA stack offset to calculate Hex-Rays stack offsets. Should be - set by the caller before calling save_user_lvar_settings(); +ida_hexrays.lvar_uservec_t.stkoff_delta + Delta to add to IDA stack offset to calculate Hex-Rays stack offsets. Should be set by the caller before calling save_user_lvar_settings(); + -ida_hexrays.lvar_uservec_t.swap (method) - swap(self, r) - - @param r: lvar_uservec_t & +ida_hexrays.lvar_uservec_t.swap(self, r: "lvar_uservec_t") -> None -ida_hexrays.lvar_uservec_t.ulv_flags (variable) +ida_hexrays.lvar_uservec_t.ulv_flags Various flags. Possible values are from lvar_uservec_t property bits. -ida_hexrays.lvars_t (class) - Proxy of C++ lvars_t class. +ida_hexrays.lvars_t -ida_hexrays.lvars_t.__init__ (method) - __init__(self) -> lvars_t +ida_hexrays.lvars_t.__init__(self) -ida_hexrays.lvars_t.find (method) - find(self, ll) -> lvar_t - Find variable at the specified location. - - @param ll: (C++: const lvar_locator_t &) variable location - @return: pointer to variable or nullptr +ida_hexrays.lvars_t.find(self, ll: "lvar_locator_t") -> "lvar_t *" + Find a variable at the specified location. + + @param ll: variable location + @returns pointer to variable or nullptr -ida_hexrays.lvars_t.find_input_lvar (method) - find_input_lvar(self, argloc, _size) -> int - Find input variable at the specified location. - - @param argloc: (C++: const vdloc_t &) variable location - @param _size: (C++: int) variable size - @return: -1 if failed, otherwise the index into the variables vector. +ida_hexrays.lvars_t.find_input_lvar(self, argloc: "vdloc_t", _size: int) -> int + Find an input variable at the specified location. + + @param argloc: variable location + @param _size: variable size in bytes + @returns -1 if failed, otherwise an index into 'vars' -ida_hexrays.lvars_t.find_lvar (method) - find_lvar(self, location, width, defblk=-1) -> int - Find variable at the specified location. - - @param location: (C++: const vdloc_t &) variable location - @param width: (C++: int) variable size - @param defblk: (C++: int) definition block of the lvar. -1 means any block - @return: -1 if failed, otherwise the index into the variables vector. +ida_hexrays.lvars_t.find_input_reg(self, reg: int, _size: int = 1) -> int + Find an input register variable. + + @param reg: register to find + @param _size: variable size in bytes + @returns -1 if failed, otherwise an index into 'vars' -ida_hexrays.lvars_t.find_stkvar (method) - find_stkvar(self, spoff, width) -> int - Find stack variable at the specified location. - - @param spoff: (C++: sval_t) offset from the minimal sp - @param width: (C++: int) variable size - @return: -1 if failed, otherwise the index into the variables vector. +ida_hexrays.lvars_t.find_lvar(self, location: "vdloc_t", width: int, defblk: int = -1) -> int + Find a variable at the specified location. + + @param location: variable location + @param width: variable size in bytes + @param defblk: definition block of the lvar. -1 means any block + @returns -1 if failed, otherwise an index into 'vars' -ida_hexrays.lxe_lvar_cmt_changed (variable) - Local variable comment got changed. +ida_hexrays.lvars_t.find_stkvar(self, spoff: int, width: int) -> int + Find a stack variable at the specified location. + + @param spoff: offset from the minimal sp + @param width: variable size in bytes + @returns -1 if failed, otherwise an index into 'vars' -ida_hexrays.lxe_lvar_mapping_changed (variable) - Local variable mapping got changed. +ida_hexrays.lxe_lvar_cmt_changed + Local variable comment got changed. + -ida_hexrays.lxe_lvar_name_changed (variable) - Local variable got renamed. +ida_hexrays.lxe_lvar_mapping_changed + Local variable mapping got changed. + -ida_hexrays.lxe_lvar_type_changed (variable) - Local variable type got changed. +ida_hexrays.lxe_lvar_name_changed + Local variable got renamed. + -ida_hexrays.make_num (function) - Create a number expression +ida_hexrays.lxe_lvar_type_changed + Local variable type got changed. + -ida_hexrays.make_pointer (function) - make_pointer(type) -> tinfo_t - Create a pointer type. This function performs the following conversion: "type" - -> "type*" - - @param type: (C++: const tinfo_t &) object type. - @return: "type*". for example, if 'char' is passed as the argument, +ida_hexrays.make_num(*args) + Create a number expression + + @param n: value + @param func: current function + @param ea: definition address of the number + @param opnum: operand number of the number (in the disassembly listing) + @param sign: number sign + @param size: size of number in bytes Please note that the type of the resulting expression can be anything because it can be inherited from the disassembly listing or taken from the user specified number representation in the pseudocode view. -ida_hexrays.make_ref (function) - Create a reference. This function performs the following conversion: "obj" => - "&obj". It can handle casts, annihilate "&*", and process other special cases. +ida_hexrays.make_pointer(type: "tinfo_t") -> "tinfo_t" + Create a pointer type. This function performs the following conversion: "type" -> "type*" + + @param type: object type. + @returns "type*". for example, if 'char' is passed as the argument, -ida_hexrays.mark_cfunc_dirty (function) - mark_cfunc_dirty(ea, close_views=False) -> bool - Flush the cached decompilation results. Erases a cache entry for the specified - function. - - @param ea: (C++: ea_t) function to erase from the cache - @param close_views: (C++: bool) close pseudocode windows that show the function - @return: if a cache entry existed. +ida_hexrays.make_ref(e) + Create a reference. This function performs the following conversion: "obj" => "&obj". It can handle casts, annihilate "&*", and process other special cases. + -ida_hexrays.mba_range_iterator_t (class) - Proxy of C++ mba_range_iterator_t class. +ida_hexrays.mark_cfunc_dirty(ea: ida_idaapi.ea_t, close_views: bool = False) -> bool + Flush the cached decompilation results. Erases a cache entry for the specified function. + + @param ea: function to erase from the cache + @param close_views: close pseudocode windows that show the function + @returns if a cache entry existed. -ida_hexrays.mba_range_iterator_t.__init__ (method) - __init__(self) -> mba_range_iterator_t +ida_hexrays.max_vlr_svalue(size: int) -> "uvlr_t" -ida_hexrays.mba_range_iterator_t.chunk (method) - chunk(self) -> range_t +ida_hexrays.max_vlr_value(size: int) -> "uvlr_t" -ida_hexrays.mba_range_iterator_t.is_snippet (method) - is_snippet(self) -> bool +ida_hexrays.mba_range_iterator_t -ida_hexrays.mba_range_iterator_t.next (method) - next(self) -> bool +ida_hexrays.mba_range_iterator_t.__init__(self) -ida_hexrays.mba_range_iterator_t.set (method) - set(self, mbr) -> bool - - @param mbr: mba_ranges_t const & +ida_hexrays.mba_range_iterator_t.chunk(self) -> "range_t const &" -ida_hexrays.mba_ranges_t (class) - Proxy of C++ mba_ranges_t class. +ida_hexrays.mba_range_iterator_t.is_snippet(self) -> bool -ida_hexrays.mba_ranges_t.__init__ (method) - __init__(self, _pfn=None) -> mba_ranges_t - - @param _pfn: func_t * - - __init__(self, r) -> mba_ranges_t - - @param r: rangevec_t const & +ida_hexrays.mba_range_iterator_t.next(self) -> bool -ida_hexrays.mba_ranges_t.clear (method) - clear(self) +ida_hexrays.mba_range_iterator_t.set(self, mbr: "mba_ranges_t") -> bool -ida_hexrays.mba_ranges_t.empty (method) - empty(self) -> bool +ida_hexrays.mba_ranges_t -ida_hexrays.mba_ranges_t.is_fragmented (method) - is_fragmented(self) -> bool +ida_hexrays.mba_ranges_t.__init__(self, *args) -ida_hexrays.mba_ranges_t.is_snippet (method) - is_snippet(self) -> bool +ida_hexrays.mba_ranges_t.clear(self) -> None -ida_hexrays.mba_ranges_t.pfn (variable) +ida_hexrays.mba_ranges_t.empty(self) -> bool + +ida_hexrays.mba_ranges_t.is_fragmented(self) -> bool + +ida_hexrays.mba_ranges_t.is_snippet(self) -> bool + +ida_hexrays.mba_ranges_t.pfn function to decompile. if not null, then function mode. -ida_hexrays.mba_ranges_t.ranges (variable) - snippet mode: ranges to decompile. function mode: list of outlined ranges +ida_hexrays.mba_ranges_t.ranges + snippet mode: ranges to decompile. function mode: list of outlined ranges + -ida_hexrays.mba_ranges_t.start (method) - start(self) -> ea_t +ida_hexrays.mba_ranges_t.start(self) -> ida_idaapi.ea_t -ida_hexrays.mba_t (class) +ida_hexrays.mba_t Deprecated. Please do not use. -ida_hexrays.mba_t.__init__ (method) +ida_hexrays.mba_t.__init__(self, *args, **kwargs) -ida_hexrays.mba_t._deregister (method) - _deregister(self) +ida_hexrays.mba_t._deregister(self) -> None -ida_hexrays.mba_t._print (method) - _print(self, vp) - - Parameters - ---------- - vp: vd_printer_t & +ida_hexrays.mba_t._print(self, vp: "vd_printer_t") -> None -ida_hexrays.mba_t._register (method) - _register(self) +ida_hexrays.mba_t._register(self) -> None -ida_hexrays.mba_t.aliased_args (variable) - Aliased stkarg locations. - -ida_hexrays.mba_t.aliased_memory (variable) +ida_hexrays.mba_t.aliased_memory aliased_memory+restricted_memory=ALLMEM -ida_hexrays.mba_t.aliased_vars (variable) - Aliased stkvar locations. - -ida_hexrays.mba_t.alloc_fict_ea (method) - alloc_fict_ea(self, real_ea) -> ea_t - Allocate a fictional address. This function can be used to allocate a new unique - address for a new instruction, if re-using any existing address leads to - conflicts. For example, if the last instruction of the function modifies R0 and - falls through to the next function, it will be a tail call: LDM R0!, {R4,R7} end - of the function start of another function In this case R0 generates two - different lvars at the same address: +ida_hexrays.mba_t.alloc_fict_ea(self, real_ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Allocate a fictional address. This function can be used to allocate a new unique address for a new instruction, if re-using any existing address leads to conflicts. For example, if the last instruction of the function modifies R0 and falls through to the next function, it will be a tail call: LDM R0!, {R4,R7} end of the function start of another function In this case R0 generates two different lvars at the same address: * one modified by LDM - * another that represents the return value from the tail call Another example: a - third-party plugin makes a copy of an instruction. This may lead to the - generation of two variables at the same address. Example 3: fictional addresses - can be used for new instructions created while modifying the microcode. This - function can be used to allocate a new unique address for a new instruction or a - variable. The fictional address is selected from an unallocated address range. + * another that represents the return value from the tail call - @param real_ea: (C++: ea_t) real instruction address (BADADDR is ok too) - @return: a unique fictional address - -ida_hexrays.mba_t.alloc_kreg (method) - alloc_kreg(self, size, check_size=True) -> mreg_t - Allocate a kernel register. - @param size: (C++: size_t) size of the register in bytes - @param check_size: (C++: bool) if true, only the sizes that correspond to a size of a basic - type will be accepted. - @return: allocated register. mr_none means failure. + Another example: a third-party plugin makes a copy of an instruction. This may lead to the generation of two variables at the same address. Example 3: fictional addresses can be used for new instructions created while modifying the microcode. This function can be used to allocate a new unique address for a new instruction or a variable. The fictional address is selected from an unallocated address range. + + @param real_ea: real instruction address (BADADDR is ok too) + @returns a unique fictional address -ida_hexrays.mba_t.alloc_lvars (method) - alloc_lvars(self) - Allocate local variables. Must be called only immediately after - optimize_global(), with no modifications to the microcode. Converts registers, - stack variables, and similar operands into mop_l. This call will not fail - because all necessary checks were performed in optimize_global(). After this - call the microcode reaches its final state. +ida_hexrays.mba_t.alloc_kreg(self, size: "size_t", check_size: bool = True) -> "mreg_t" + Allocate a kernel register. + + @param size: size of the register in bytes + @param check_size: if true, only the sizes that correspond to a size of a basic type will be accepted. + @returns allocated register. mr_none means failure. -ida_hexrays.mba_t.analyze_calls (method) - analyze_calls(self, acflags) -> int - Analyze calls and determine calling conventions. - - @param acflags: (C++: int) permitted actions that are necessary for successful detection of - calling conventions. See Bits for analyze_calls() - @return: number of calls. -1 means error. +ida_hexrays.mba_t.alloc_lvars(self) -> None + Allocate local variables. Must be called only immediately after optimize_global(), with no modifications to the microcode. Converts registers, stack variables, and similar operands into mop_l. This call will not fail because all necessary checks were performed in optimize_global(). After this call the microcode reaches its final state. + -ida_hexrays.mba_t.arg (method) - arg(self, n) -> lvar_t - - @param n: int +ida_hexrays.mba_t.analyze_calls(self, acflags: int) -> int + Analyze calls and determine calling conventions. + + @param acflags: permitted actions that are necessary for successful detection of calling conventions. See Bits for analyze_calls() + @returns number of calls. -1 means error. -ida_hexrays.mba_t.argbase (method) - argbase(self) -> sval_t +ida_hexrays.mba_t.arg(self, n: int) -> "lvar_t &" + Get input argument of the decompiled function. + + @param n: argument number (0..nargs-1) -ida_hexrays.mba_t.argidx (variable) +ida_hexrays.mba_t.argbase(self) -> int + +ida_hexrays.mba_t.argidx input arguments (indexes into 'vars') -ida_hexrays.mba_t.argidx_ok (method) - argidx_ok(self) -> bool +ida_hexrays.mba_t.argidx_ok(self) -> bool -ida_hexrays.mba_t.argidx_sorted (method) - argidx_sorted(self) -> bool +ida_hexrays.mba_t.argidx_sorted(self) -> bool -ida_hexrays.mba_t.bad_call_sp_detected (method) - bad_call_sp_detected(self) -> bool +ida_hexrays.mba_t.bad_call_sp_detected(self) -> bool -ida_hexrays.mba_t.blocks (variable) +ida_hexrays.mba_t.blocks double linked list of blocks -ida_hexrays.mba_t.build_graph (method) - build_graph(self) -> merror_t - Build control flow graph. This function may be called only once. It calculates - the type of each basic block and the adjacency list. optimize_local() calls this - function if necessary. You need to call this function only before MMAT_LOCOPT. - - @return: error code +ida_hexrays.mba_t.build_graph(self) -> "merror_t" + Build control flow graph. This function may be called only once. It calculates the type of each basic block and the adjacency list. optimize_local() calls this function if necessary. You need to call this function only before MMAT_LOCOPT. + + @returns error code -ida_hexrays.mba_t.calc_shins_flags (method) - calc_shins_flags(self) -> int +ida_hexrays.mba_t.calc_shins_flags(self) -> int -ida_hexrays.mba_t.callinfo_built (method) - callinfo_built(self) -> bool +ida_hexrays.mba_t.callinfo_built(self) -> bool -ida_hexrays.mba_t.cc (variable) +ida_hexrays.mba_t.cc calling convention -ida_hexrays.mba_t.chain_varnums_ok (method) - chain_varnums_ok(self) -> bool +ida_hexrays.mba_t.chain_varnums_ok(self) -> bool -ida_hexrays.mba_t.clr_cdtr (method) - clr_cdtr(self) +ida_hexrays.mba_t.clr_cdtr(self) -> None -ida_hexrays.mba_t.clr_mba_flags (method) - clr_mba_flags(self, f) - - @param f: int +ida_hexrays.mba_t.clr_mba_flags(self, f: int) -> None -ida_hexrays.mba_t.clr_mba_flags2 (method) - clr_mba_flags2(self, f) - - @param f: int +ida_hexrays.mba_t.clr_mba_flags2(self, f: int) -> None -ida_hexrays.mba_t.code16_bit_removed (method) - code16_bit_removed(self) -> bool +ida_hexrays.mba_t.code16_bit_removed(self) -> bool -ida_hexrays.mba_t.combine_blocks (method) - combine_blocks(self) -> bool - Combine blocks. This function merges blocks constituting linear flow. It calls - remove_empty_and_unreachable_blocks() as well. - - @return: true if changed any blocks +ida_hexrays.mba_t.common_stkvars_stkargs(self) -> bool -ida_hexrays.mba_t.common_stkvars_stkargs (method) - common_stkvars_stkargs(self) -> bool - -ida_hexrays.mba_t.consumed_argregs (variable) +ida_hexrays.mba_t.consumed_argregs registers converted into stack arguments, should not be used as arguments -ida_hexrays.mba_t.copy_block (method) - copy_block(self, blk, new_serial, cpblk_flags=3) -> mblock_t - Make a copy of a block. This function makes a simple copy of the block. It does - not fix the predecessor and successor lists, they must be fixed if necessary. - - @param blk: (C++: mblock_t *) block to copy - @param new_serial: (C++: int) position of the copied block - @param cpblk_flags: (C++: int) combination of Batch decompilation bits... bits - @return: pointer to the new copy +ida_hexrays.mba_t.copy_block(self, blk: "mblock_t", new_serial: int, cpblk_flags: int = 3) -> "mblock_t *" + Make a copy of a block. This function makes a simple copy of the block. It does not fix the predecessor and successor lists, they must be fixed if necessary. + + @param blk: block to copy + @param new_serial: position of the copied block + @param cpblk_flags: combination of Batch decompilation bits... bits + @returns pointer to the new copy -ida_hexrays.mba_t.create_helper_call (method) - create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t - Create a call of a helper function. - - @param ea: (C++: ea_t) The desired address of the instruction - @param helper: (C++: const char *) The helper name - @param rettype: (C++: const tinfo_t *) The return type (nullptr or empty type means 'void') - @param callargs: (C++: const mcallargs_t *) The helper arguments (nullptr-no arguments) - @param out: (C++: const mop_t *) The operand where the call result should be stored. If this argument - is not nullptr, "mov helper_call(), out" will be generated. - Otherwise "call helper()" will be generated. Note: the size of this - operand must be equal to the RETTYPE size - @return: pointer to the created instruction or nullptr if error +ida_hexrays.mba_t.create_helper_call(self, ea: ida_idaapi.ea_t, helper: str, rettype: "tinfo_t" = None, callargs: "mcallargs_t" = None, out: "mop_t" = None) -> "minsn_t *" + Create a call of a helper function. + + @param ea: The desired address of the instruction + @param helper: The helper name + @param rettype: The return type (nullptr or empty type means 'void') + @param callargs: The helper arguments (nullptr-no arguments) + @param out: The operand where the call result should be stored. If this argument is not nullptr, "mov helper_call(), out" will be generated. Otherwise "call helper()" will be generated. Note: the size of this operand must be equal to the RETTYPE size + @returns pointer to the created instruction or nullptr if error -ida_hexrays.mba_t.deleted_pairs (method) - deleted_pairs(self) -> bool +ida_hexrays.mba_t.deleted_pairs(self) -> bool -ida_hexrays.mba_t.deprecated_idb_node (variable) - netnode with additional decompiler info. deprecated, do not use it anymore. it - may get stale after undo. +ida_hexrays.mba_t.deserialize(bytes: "uchar const *") -> "mba_t *" + Deserialize a byte sequence into mbl array. + + @param bytes: pointer to the beginning of the byte sequence. + @returns new mbl array -ida_hexrays.mba_t.deserialize (method) - deserialize(bytes) -> mba_t - Deserialize a byte sequence into mbl array. - - @param bytes: (C++: const uchar *) pointer to the beginning of the byte sequence. - @return: new mbl array +ida_hexrays.mba_t.display_numaddrs(self) -> bool -ida_hexrays.mba_t.display_numaddrs (method) - display_numaddrs(self) -> bool +ida_hexrays.mba_t.display_valnums(self) -> bool -ida_hexrays.mba_t.display_valnums (method) - display_valnums(self) -> bool +ida_hexrays.mba_t.dump(self) -> None + Dump microcode to a file. The file will be created in the directory pointed by IDA_DUMPDIR envvar. Dump will be created only if IDA is run under debugger. + -ida_hexrays.mba_t.dump (method) - dump(self) - Dump microcode to a file. The file will be created in the directory pointed by - IDA_DUMPDIR envvar. Dump will be created only if IDA is run under debugger. +ida_hexrays.mba_t.dump_mba(self, _verify: bool, title: str) -> None -ida_hexrays.mba_t.dump_mba (method) - dump_mba(self, _verify, title) - - @param _verify: bool - @param title: char const * - -ida_hexrays.mba_t.error_ea (variable) +ida_hexrays.mba_t.error_ea during microcode generation holds ins.ea -ida_hexrays.mba_t.final_type (variable) +ida_hexrays.mba_t.final_type is the function type final? (specified by the user) -ida_hexrays.mba_t.find_mop (method) - find_mop(self, ctx, ea, is_dest, list) -> mop_t - Find an operand in the microcode. This function tries to find the operand that - matches LIST. Any operand that overlaps with LIST is considered as a match. - - @param ctx: (C++: op_parent_info_t *) context information for the result - @param ea: (C++: ea_t) desired address of the operand. BADADDR means to accept any address. - @param is_dest: (C++: bool) search for destination operand? this argument may be ignored if - the exact match could not be found - @param list: (C++: const mlist_t &) list of locations the correspond to the operand - @return: pointer to the operand or nullptr. +ida_hexrays.mba_t.find_mop(self, ctx: "op_parent_info_t", ea: ida_idaapi.ea_t, is_dest: bool, list: "mlist_t") -> "mop_t *" + Find an operand in the microcode. This function tries to find the operand that matches LIST. Any operand that overlaps with LIST is considered as a match. + + @param ctx: context information for the result + @param ea: desired address of the operand. BADADDR means to accept any address. + @param is_dest: search for destination operand? this argument may be ignored if the exact match could not be found + @param list: list of locations the correspond to the operand + @returns pointer to the operand or nullptr. -ida_hexrays.mba_t.for_all_insns (method) - for_all_insns(self, mv) -> int - Visit all instructions. This function visits all instruction and - subinstructions. - - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: non-zero value returned by mv.visit_mop() or zero +ida_hexrays.mba_t.for_all_insns(self, mv: "minsn_visitor_t") -> int + Visit all instructions. This function visits all instruction and subinstructions. + + @param mv: instruction visitor + @returns non-zero value returned by mv.visit_mop() or zero -ida_hexrays.mba_t.for_all_ops (method) - for_all_ops(self, mv) -> int - Visit all operands of all instructions. - - @param mv: (C++: mop_visitor_t &) operand visitor - @return: non-zero value returned by mv.visit_mop() or zero +ida_hexrays.mba_t.for_all_ops(self, mv: "mop_visitor_t") -> int + Visit all operands of all instructions. + + @param mv: operand visitor + @returns non-zero value returned by mv.visit_mop() or zero -ida_hexrays.mba_t.for_all_topinsns (method) - for_all_topinsns(self, mv) -> int - Visit all top level instructions. - - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: non-zero value returned by mv.visit_mop() or zero +ida_hexrays.mba_t.for_all_topinsns(self, mv: "minsn_visitor_t") -> int + Visit all top level instructions. + + @param mv: instruction visitor + @returns non-zero value returned by mv.visit_mop() or zero -ida_hexrays.mba_t.fpd (variable) +ida_hexrays.mba_t.fpd frame pointer delta -ida_hexrays.mba_t.free_kreg (method) - free_kreg(self, reg, size) - Free a kernel register. If wrong arguments are passed, this function will - generate an internal error. - - @param reg: (C++: mreg_t) a previously allocated kernel register - @param size: (C++: size_t) size of the register in bytes +ida_hexrays.mba_t.free_kreg(self, reg: "mreg_t", size: "size_t") -> None + Free a kernel register. If wrong arguments are passed, this function will generate an internal error. + + @param reg: a previously allocated kernel register + @param size: size of the register in bytes -ida_hexrays.mba_t.frregs (variable) +ida_hexrays.mba_t.frregs size of saved registers range in the stack frame -ida_hexrays.mba_t.frsize (variable) +ida_hexrays.mba_t.frsize size of local stkvars range in the stack frame -ida_hexrays.mba_t.fti_flags (variable) +ida_hexrays.mba_t.fti_flags FTI_... constants for the current function. -ida_hexrays.mba_t.fullsize (variable) +ida_hexrays.mba_t.fullsize Full stack size including incoming args. -ida_hexrays.mba_t.generated_asserts (method) - generated_asserts(self) -> bool +ida_hexrays.mba_t.generated_asserts(self) -> bool -ida_hexrays.mba_t.get_args_region (method) - get_args_region(self) -> ivl_t +ida_hexrays.mba_t.get_args_region(self) -> "ivl_t const &" -ida_hexrays.mba_t.get_curfunc (method) - get_curfunc(self) -> func_t * +ida_hexrays.mba_t.get_curfunc(self) -> "func_t *" -ida_hexrays.mba_t.get_func_output_lists (method) - get_func_output_lists(self, return_regs, spoiled, type, call_ea=BADADDR, tail_call=False) - Prepare the lists of registers & memory that are defined/killed by a function - - @param return_regs: (C++: mlist_t *) defined regs to return (eax,edx) - @param spoiled: (C++: mlist_t *) spoiled regs (flags,ecx,mem) - @param type: (C++: const tinfo_t &) the function type - @param call_ea: (C++: ea_t) the call insn address (if known) - @param tail_call: (C++: bool) is it the tail call? +ida_hexrays.mba_t.get_func_output_lists(self, *args) -> None + Prepare the lists of registers & memory that are defined/killed by a function + + @param return_regs: defined regs to return (eax,edx) + @param spoiled: spoiled regs (flags,ecx,mem) + @param type: the function type + @param call_ea: the call insn address (if known) + @param tail_call: is it the tail call? -ida_hexrays.mba_t.get_graph (method) - get_graph(self) -> mbl_graph_t - Get control graph. Call build_graph() if you need the graph before MMAT_LOCOPT. +ida_hexrays.mba_t.get_graph(self) -> "mbl_graph_t *" + Get control graph. Call build_graph() if you need the graph before MMAT_LOCOPT. + -ida_hexrays.mba_t.get_ida_argloc (method) - get_ida_argloc(self, v) -> argloc_t - - @param v: lvar_t const & +ida_hexrays.mba_t.get_ida_argloc(self, v: "lvar_t") -> "argloc_t" -ida_hexrays.mba_t.get_lvars_region (method) - get_lvars_region(self) -> ivl_t +ida_hexrays.mba_t.get_lvars_region(self) -> "ivl_t const &" -ida_hexrays.mba_t.get_mba_flags (method) - get_mba_flags(self) -> int +ida_hexrays.mba_t.get_mba_flags(self) -> int -ida_hexrays.mba_t.get_mba_flags2 (method) - get_mba_flags2(self) -> int +ida_hexrays.mba_t.get_mba_flags2(self) -> int -ida_hexrays.mba_t.get_mblock (method) - get_mblock(self, n) -> mblock_t - - @param n: int +ida_hexrays.mba_t.get_mblock(self, n: "uint") -> "mblock_t *" + Get basic block by its serial number. -ida_hexrays.mba_t.get_shadow_region (method) - get_shadow_region(self) -> ivl_t +ida_hexrays.mba_t.get_shadow_region(self) -> "ivl_t const &" -ida_hexrays.mba_t.get_stack_region (method) - get_stack_region(self) -> ivl_t +ida_hexrays.mba_t.get_stack_region(self) -> "ivl_t" -ida_hexrays.mba_t.get_std_region (method) - get_std_region(self, idx) -> ivl_t - Get information about various memory regions. We map the stack frame to the - global memory, to some unused range. - - @param idx: (C++: memreg_index_t) enum memreg_index_t +ida_hexrays.mba_t.get_std_region(self, idx: "memreg_index_t") -> "ivl_t const &" + Get information about various memory regions. We map the stack frame to the global memory, to some unused range. + -ida_hexrays.mba_t.gotoff_stkvars (variable) +ida_hexrays.mba_t.gotoff_stkvars stkvars that hold .got offsets. considered to be unaliasable -ida_hexrays.mba_t.graph_insns (method) - graph_insns(self) -> bool +ida_hexrays.mba_t.graph_insns(self) -> bool -ida_hexrays.mba_t.has_bad_sp (method) - has_bad_sp(self) -> bool +ida_hexrays.mba_t.has_bad_sp(self) -> bool -ida_hexrays.mba_t.has_outlines (method) - has_outlines(self) -> bool +ida_hexrays.mba_t.has_outlines(self) -> bool -ida_hexrays.mba_t.has_over_chains (method) - has_over_chains(self) -> bool +ida_hexrays.mba_t.has_over_chains(self) -> bool -ida_hexrays.mba_t.has_passregs (method) - has_passregs(self) -> bool +ida_hexrays.mba_t.has_passregs(self) -> bool -ida_hexrays.mba_t.has_stack_retval (method) - has_stack_retval(self) -> bool +ida_hexrays.mba_t.has_stack_retval(self) -> bool -ida_hexrays.mba_t.idaloc2vd (method) - idaloc2vd(self, loc, width) -> vdloc_t - - @param loc: argloc_t const & - @param width: int +ida_hexrays.mba_t.idaloc2vd(self, loc: "argloc_t", width: int) -> "vdloc_t" -ida_hexrays.mba_t.idb_spoiled (variable) +ida_hexrays.mba_t.idb_spoiled MBA_SPLINFO && final_type: info in ida format. -ida_hexrays.mba_t.idb_type (variable) +ida_hexrays.mba_t.idb_type function type as retrieved from the database -ida_hexrays.mba_t.inargoff (variable) - offset of the first stack argument; after fix_scattered_movs() INARGOFF may be - less than STACKSIZE +ida_hexrays.mba_t.inargoff + offset of the first stack argument; after fix_scattered_movs() INARGOFF may be less than STACKSIZE + -ida_hexrays.mba_t.insert_block (method) - insert_block(self, bblk) -> mblock_t - Insert a block in the middle of the mbl array. The very first block of microcode - must be empty, it is the entry block. The very last block of microcode must be - BLT_STOP, it is the exit block. Therefore inserting a new block before the entry - point or after the exit block is not a good idea. - - @param bblk: (C++: int) the new block will be inserted before BBLK - @return: ptr to the new block +ida_hexrays.mba_t.inline_func(self, cdg: "codegen_t", blknum: int, ranges: "mba_ranges_t", decomp_flags: int = 0, inline_flags: int = 0) -> "merror_t" + Inline a range. Currently only functions are supported, not arbitrary ranges. This function may be called only during the initial microcode generation phase. + + @param cdg: the codegenerator object + @param blknum: the block contaning the call/jump instruction to inline + @param ranges: the set of ranges to inline + @param decomp_flags: combination of decompile() flags bits + @param inline_flags: combination of inline_func() flags bits + @returns error code -ida_hexrays.mba_t.is_cdtr (method) - is_cdtr(self) -> bool +ida_hexrays.mba_t.insert_block(self, bblk: int) -> "mblock_t *" + Insert a block in the middle of the mbl array. The very first block of microcode must be empty, it is the entry block. The very last block of microcode must be BLT_STOP, it is the exit block. Therefore inserting a new block before the entry point or after the exit block is not a good idea. + + @param bblk: the new block will be inserted before BBLK + @returns ptr to the new block -ida_hexrays.mba_t.is_ctr (method) - is_ctr(self) -> bool +ida_hexrays.mba_t.is_cdtr(self) -> bool -ida_hexrays.mba_t.is_dtr (method) - is_dtr(self) -> bool +ida_hexrays.mba_t.is_ctr(self) -> bool -ida_hexrays.mba_t.is_pattern (method) - is_pattern(self) -> bool +ida_hexrays.mba_t.is_dtr(self) -> bool -ida_hexrays.mba_t.is_snippet (method) - is_snippet(self) -> bool +ida_hexrays.mba_t.is_pattern(self) -> bool -ida_hexrays.mba_t.is_stkarg (method) - is_stkarg(self, v) -> bool - - @param v: lvar_t const & +ida_hexrays.mba_t.is_snippet(self) -> bool -ida_hexrays.mba_t.is_thunk (method) - is_thunk(self) -> bool +ida_hexrays.mba_t.is_stkarg(self, v: "lvar_t") -> bool -ida_hexrays.mba_t.label (variable) +ida_hexrays.mba_t.is_thunk(self) -> bool + +ida_hexrays.mba_t.label name of the function or pattern (colored) -ida_hexrays.mba_t.loaded_gdl (method) - loaded_gdl(self) -> bool +ida_hexrays.mba_t.loaded_gdl(self) -> bool -ida_hexrays.mba_t.lvar_names_ok (method) - lvar_names_ok(self) -> bool +ida_hexrays.mba_t.locate_stkpnt(self, ea: ida_idaapi.ea_t) -> "stkpnt_t const *" -ida_hexrays.mba_t.lvars_allocated (method) - lvars_allocated(self) -> bool +ida_hexrays.mba_t.lvar_names_ok(self) -> bool -ida_hexrays.mba_t.lvars_renamed (method) - lvars_renamed(self) -> bool +ida_hexrays.mba_t.lvars_allocated(self) -> bool -ida_hexrays.mba_t.map_fict_ea (method) - map_fict_ea(self, fict_ea) -> ea_t - Resolve a fictional address. This function provides a reverse of the mapping - made by alloc_fict_ea(). - - @param fict_ea: (C++: ea_t) fictional definition address - @return: the real instruction address +ida_hexrays.mba_t.lvars_renamed(self) -> bool -ida_hexrays.mba_t.mark_chains_dirty (method) - mark_chains_dirty(self) - Mark the microcode use-def chains dirty. Call this function is any inter-block - data dependencies got changed because of your modifications to the microcode. - Failing to do so may cause an internal error. +ida_hexrays.mba_t.map_fict_ea(self, fict_ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Resolve a fictional address. This function provides a reverse of the mapping made by alloc_fict_ea(). + + @param fict_ea: fictional definition address + @returns the real instruction address -ida_hexrays.mba_t.maturity (variable) +ida_hexrays.mba_t.mark_chains_dirty(self) -> None + Mark the microcode use-def chains dirty. Call this function is any inter-block data dependencies got changed because of your modifications to the microcode. Failing to do so may cause an internal error. + + +ida_hexrays.mba_t.maturity current maturity level -ida_hexrays.mba_t.may_refine_rettype (method) - may_refine_rettype(self) -> bool +ida_hexrays.mba_t.may_refine_rettype(self) -> bool -ida_hexrays.mba_t.minargref (variable) - The lowest stack argument location whose address was taken This location and - locations above it can be aliased It controls locations >= inargoff-shadow_args +ida_hexrays.mba_t.merge_blocks(self) -> bool + Merge blocks. This function merges blocks constituting linear flow. It calls remove_empty_and_unreachable_blocks() as well. + + @returns true if changed any blocks -ida_hexrays.mba_t.minstkref (variable) +ida_hexrays.mba_t.minargref + The lowest stack argument location whose address was taken This location and locations above it can be aliased It controls locations >= inargoff-shadow_args + + +ida_hexrays.mba_t.minstkref The lowest stack location whose address was taken. -ida_hexrays.mba_t.minstkref_ea (variable) +ida_hexrays.mba_t.minstkref_ea address with lowest minstkref (for debugging) -ida_hexrays.mba_t.natural (variable) +ida_hexrays.mba_t.natural natural order of blocks -ida_hexrays.mba_t.nodel_memory (variable) +ida_hexrays.mba_t.nodel_memory global dead elimination may not delete references to this area -ida_hexrays.mba_t.npurged (variable) +ida_hexrays.mba_t.npurged -1 - unknown -ida_hexrays.mba_t.optimize_global (method) - optimize_global(self) -> merror_t - Optimize microcode globally. This function applies various optimization methods - until we reach the fixed point. After that it preallocates lvars unless reqmat - forbids it. - - @return: error code +ida_hexrays.mba_t.optimize_global(self) -> "merror_t" + Optimize microcode globally. This function applies various optimization methods until we reach the fixed point. After that it preallocates lvars unless reqmat forbids it. + + @returns error code -ida_hexrays.mba_t.optimize_local (method) - optimize_local(self, locopt_bits) -> int - Optimize each basic block locally - - @param locopt_bits: (C++: int) combination of Bits for optimize_local() bits - @return: number of changes. 0 means nothing changed This function is called by - the decompiler, usually there is no need to call it explicitly. +ida_hexrays.mba_t.optimize_local(self, locopt_bits: int) -> int + Optimize each basic block locally + + @param locopt_bits: combination of Bits for optimize_local() bits + @returns number of changes. 0 means nothing changed This function is called by the decompiler, usually there is no need to call it explicitly. -ida_hexrays.mba_t.optimized (method) - optimized(self) -> bool +ida_hexrays.mba_t.optimized(self) -> bool -ida_hexrays.mba_t.pfn_flags (variable) +ida_hexrays.mba_t.pfn_flags copy of func_t::flags -ida_hexrays.mba_t.precise_defeas (method) - precise_defeas(self) -> bool +ida_hexrays.mba_t.precise_defeas(self) -> bool -ida_hexrays.mba_t.prop_complex (method) - prop_complex(self) -> bool +ida_hexrays.mba_t.prop_complex(self) -> bool -ida_hexrays.mba_t.propagated_asserts (method) - propagated_asserts(self) -> bool +ida_hexrays.mba_t.propagated_asserts(self) -> bool -ida_hexrays.mba_t.qty (variable) +ida_hexrays.mba_t.qty number of basic blocks -ida_hexrays.mba_t.really_alloc (method) - really_alloc(self) -> bool +ida_hexrays.mba_t.really_alloc(self) -> bool -ida_hexrays.mba_t.regargs_is_not_aligned (method) - regargs_is_not_aligned(self) -> bool +ida_hexrays.mba_t.regargs_is_not_aligned(self) -> bool -ida_hexrays.mba_t.remove_block (method) - remove_block(self, blk) -> bool - Delete a block. - - @param blk: (C++: mblock_t *) block to delete - @return: true if at least one of the other blocks became empty or unreachable +ida_hexrays.mba_t.remove_block(self, blk: "mblock_t") -> bool + Delete a block. + + @param blk: block to delete + @returns true if at least one of the other blocks became empty or unreachable -ida_hexrays.mba_t.remove_empty_and_unreachable_blocks (method) - remove_empty_and_unreachable_blocks(self) -> bool - Delete all empty and unreachable blocks. Blocks marked with MBL_KEEP won't be - deleted. +ida_hexrays.mba_t.remove_blocks(self, start_blk: int, end_blk: int) -> bool -ida_hexrays.mba_t.reqmat (variable) +ida_hexrays.mba_t.remove_empty_and_unreachable_blocks(self) -> bool + Delete all empty and unreachable blocks. Blocks marked with MBL_KEEP won't be deleted. + + +ida_hexrays.mba_t.reqmat required maturity level -ida_hexrays.mba_t.retsize (variable) +ida_hexrays.mba_t.retsize size of return address in the stack frame -ida_hexrays.mba_t.returns_fpval (method) - returns_fpval(self) -> bool +ida_hexrays.mba_t.returns_fpval(self) -> bool -ida_hexrays.mba_t.retvaridx (variable) - index of variable holding the return value -1 means none +ida_hexrays.mba_t.retvaridx + index of variable holding the return value -1 means none + -ida_hexrays.mba_t.rtype_refined (method) - rtype_refined(self) -> bool +ida_hexrays.mba_t.rtype_refined(self) -> bool -ida_hexrays.mba_t.save_snapshot (method) - save_snapshot(self, description) +ida_hexrays.mba_t.save_snapshot(self, description: str) -> None Create and save microcode snapshot. - - @param description: (C++: const char *) char const * -ida_hexrays.mba_t.saverest_done (method) - saverest_done(self) -> bool +ida_hexrays.mba_t.saverest_done(self) -> bool -ida_hexrays.mba_t.serialize (method) - serialize(self) +ida_hexrays.mba_t.serialize(self) -> None Serialize mbl array into a sequence of bytes. -ida_hexrays.mba_t.set_lvar_name (method) - set_lvar_name(self, v, name, flagbits) -> bool - - @param v: lvar_t & - @param name: char const * - @param flagbits: int +ida_hexrays.mba_t.set_lvar_name(self, v: "lvar_t", name: str, flagbits: int) -> bool -ida_hexrays.mba_t.set_maturity (method) - set_maturity(self, mat) -> bool - Set maturity level. - - @param mat: (C++: mba_maturity_t) new maturity level - @return: true if it is time to stop analysis Plugins may use this function to - skip some parts of the analysis. The maturity level cannot be - decreased. +ida_hexrays.mba_t.set_maturity(self, mat: "mba_maturity_t") -> bool + Set maturity level. + + @param mat: new maturity level + @returns true if it is time to stop analysis Plugins may use this function to skip some parts of the analysis. The maturity level cannot be decreased. -ida_hexrays.mba_t.set_mba_flags (method) - set_mba_flags(self, f) - - @param f: int +ida_hexrays.mba_t.set_mba_flags(self, f: int) -> None -ida_hexrays.mba_t.set_mba_flags2 (method) - set_mba_flags2(self, f) - - @param f: int +ida_hexrays.mba_t.set_mba_flags2(self, f: int) -> None -ida_hexrays.mba_t.set_nice_lvar_name (method) - set_nice_lvar_name(self, v, name) -> bool - - @param v: lvar_t & - @param name: char const * +ida_hexrays.mba_t.set_nice_lvar_name(self, v: "lvar_t", name: str) -> bool -ida_hexrays.mba_t.set_user_lvar_name (method) - set_user_lvar_name(self, v, name) -> bool - - @param v: lvar_t & - @param name: char const * +ida_hexrays.mba_t.set_user_lvar_name(self, v: "lvar_t", name: str) -> bool -ida_hexrays.mba_t.shadow_args (variable) +ida_hexrays.mba_t.shadow_args size of shadow argument area -ida_hexrays.mba_t.short_display (method) - short_display(self) -> bool +ida_hexrays.mba_t.short_display(self) -> bool -ida_hexrays.mba_t.should_beautify (method) - should_beautify(self) -> bool +ida_hexrays.mba_t.should_beautify(self) -> bool -ida_hexrays.mba_t.show_reduction (method) - show_reduction(self) -> bool +ida_hexrays.mba_t.show_reduction(self) -> bool -ida_hexrays.mba_t.spd_adjust (variable) +ida_hexrays.mba_t.spd_adjust If sp>0, the max positive sp value. -ida_hexrays.mba_t.spoiled_list (variable) +ida_hexrays.mba_t.split_block(self, blk: "mblock_t", start_insn: "minsn_t") -> "mblock_t *" + Split a block: insert a new one after the block, move some instructions to new block + + @param blk: block to be split + @param start_insn: all instructions to be moved to new block: starting with this one up to the end + @returns ptr to the new block + +ida_hexrays.mba_t.spoiled_list MBA_SPLINFO && !final_type: info in vd format. -ida_hexrays.mba_t.stacksize (variable) - The maximal size of the function stack including bytes allocated for outgoing - call arguments (up to retaddr) +ida_hexrays.mba_t.stacksize + The maximal size of the function stack including bytes allocated for outgoing call arguments (up to retaddr) + -ida_hexrays.mba_t.std_ivls (variable) - we treat memory as consisting of 6 parts see memreg_index_t +ida_hexrays.mba_t.std_ivls + we treat memory as consisting of 6 parts see memreg_index_t + -ida_hexrays.mba_t.stkoff_ida2vd (method) - stkoff_ida2vd(self, off) -> sval_t - - @param off: sval_t +ida_hexrays.mba_t.stkoff_ida2vd(self, off: int) -> int -ida_hexrays.mba_t.stkoff_vd2ida (method) - stkoff_vd2ida(self, off) -> sval_t - - @param off: sval_t +ida_hexrays.mba_t.stkoff_vd2ida(self, off: int) -> int -ida_hexrays.mba_t.term (method) - term(self) +ida_hexrays.mba_t.term(self) -> None -ida_hexrays.mba_t.tmpstk_size (variable) - size of the temporary stack part (which dynamically changes with push/pops) +ida_hexrays.mba_t.tmpstk_size + size of the temporary stack part (which dynamically changes with push/pops) + -ida_hexrays.mba_t.use_frame (method) - use_frame(self) -> bool +ida_hexrays.mba_t.use_frame(self) -> bool -ida_hexrays.mba_t.use_wingraph32 (method) - use_wingraph32(self) -> bool +ida_hexrays.mba_t.use_wingraph32(self) -> bool -ida_hexrays.mba_t.valranges_done (method) - valranges_done(self) -> bool +ida_hexrays.mba_t.valranges_done(self) -> bool -ida_hexrays.mba_t.vars (variable) +ida_hexrays.mba_t.vars local variables -ida_hexrays.mba_t.vd2idaloc (method) - vd2idaloc(self, loc, width, spd) -> argloc_t +ida_hexrays.mba_t.vd2idaloc(self, *args) -> "argloc_t" + This function has the following signatures: - @param loc: vdloc_t const & - @param width: int - @param spd: sval_t + 0. vd2idaloc(loc: const vdloc_t &, width: int) -> argloc_t + 1. vd2idaloc(loc: const vdloc_t &, width: int, spd: int) -> argloc_t - vd2idaloc(self, loc, width) -> argloc_t + # 0: vd2idaloc(loc: const vdloc_t &, width: int) -> argloc_t - @param loc: vdloc_t const & - @param width: int - -ida_hexrays.mba_t.verify (method) - verify(self, always) - Verify microcode consistency. - @param always: (C++: bool) if false, the check will be performed only if ida runs under - debugger If any inconsistency is discovered, an internal error - will be generated. We strongly recommend you to call this - function before returing control to the decompiler from your - callbacks, in the case if you modified the microcode. If the - microcode is inconsistent, this function will generate an - internal error. We provide the source code of this function in - the plugins/hexrays_sdk/verifier directory for your reference. + # 1: vd2idaloc(loc: const vdloc_t &, width: int, spd: int) -> argloc_t -ida_hexrays.mba_t.write_to_const_detected (method) - write_to_const_detected(self) -> bool +ida_hexrays.mba_t.verify(self, always: bool) -> None + Verify microcode consistency. + + @param always: if false, the check will be performed only if ida runs under debugger If any inconsistency is discovered, an internal error will be generated. We strongly recommend you to call this function before returing control to the decompiler from your callbacks, in the case if you modified the microcode. If the microcode is inconsistent, this function will generate an internal error. We provide the source code of this function in the plugins/hexrays_sdk/verifier directory for your reference. -ida_hexrays.mba_t_deserialize (function) - mba_t_deserialize(bytes) -> mba_t - - @param bytes: uchar const * +ida_hexrays.mba_t.write_to_const_detected(self) -> bool -ida_hexrays.mbl_graph_t (class) - Proxy of C++ mbl_graph_t class. +ida_hexrays.mbl_graph_t -ida_hexrays.mbl_graph_t.__init__ (method) +ida_hexrays.mbl_graph_t.__init__(self, *args, **kwargs) -ida_hexrays.mbl_graph_t.get_chain_stamp (method) - get_chain_stamp(self) -> int +ida_hexrays.mbl_graph_t.get_chain_stamp(self) -> int -ida_hexrays.mbl_graph_t.get_du (method) - get_du(self, gctype) -> graph_chains_t +ida_hexrays.mbl_graph_t.get_du(self, gctype: "gctype_t") -> "graph_chains_t *" Get def-use chains. - - @param gctype: (C++: gctype_t) enum gctype_t -ida_hexrays.mbl_graph_t.get_mblock (method) - get_mblock(self, n) -> mblock_t - - @param n: int +ida_hexrays.mbl_graph_t.get_mblock(self, n: int) -> "mblock_t *" -ida_hexrays.mbl_graph_t.get_ud (method) - get_ud(self, gctype) -> graph_chains_t +ida_hexrays.mbl_graph_t.get_ud(self, gctype: "gctype_t") -> "graph_chains_t *" Get use-def chains. - - @param gctype: (C++: gctype_t) enum gctype_t -ida_hexrays.mbl_graph_t.is_du_chain_dirty (method) - is_du_chain_dirty(self, gctype) -> bool +ida_hexrays.mbl_graph_t.is_du_chain_dirty(self, gctype: "gctype_t") -> bool Is the def-use chain of the specified kind dirty? - - @param gctype: (C++: gctype_t) enum gctype_t -ida_hexrays.mbl_graph_t.is_redefined_globally (method) - is_redefined_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool +ida_hexrays.mbl_graph_t.is_redefined_globally(self, *args) -> bool Is LIST redefined in the graph? - - @param list: (C++: const mlist_t &) mlist_t const & - @param b1: (C++: int) - @param b2: (C++: int) - @param m1: (C++: const minsn_t *) minsn_t const * - @param m2: (C++: const minsn_t *) minsn_t const * - @param maymust: (C++: maymust_t) -ida_hexrays.mbl_graph_t.is_ud_chain_dirty (method) - is_ud_chain_dirty(self, gctype) -> bool +ida_hexrays.mbl_graph_t.is_ud_chain_dirty(self, gctype: "gctype_t") -> bool Is the use-def chain of the specified kind dirty? - - @param gctype: (C++: gctype_t) enum gctype_t -ida_hexrays.mbl_graph_t.is_used_globally (method) - is_used_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool +ida_hexrays.mbl_graph_t.is_used_globally(self, *args) -> bool Is LIST used in the graph? - - @param list: (C++: const mlist_t &) mlist_t const & - @param b1: (C++: int) - @param b2: (C++: int) - @param m1: (C++: const minsn_t *) minsn_t const * - @param m2: (C++: const minsn_t *) minsn_t const * - @param maymust: (C++: maymust_t) -ida_hexrays.mblock_t (class) - Proxy of C++ mblock_t class. +ida_hexrays.mblock_t -ida_hexrays.mblock_t.__init__ (method) +ida_hexrays.mblock_t.__init__(self, *args, **kwargs) -ida_hexrays.mblock_t._print (method) - _print(self, vp) - - Parameters - ---------- - vp: vd_printer_t & +ida_hexrays.mblock_t._print(self, vp: "vd_printer_t") -> None -ida_hexrays.mblock_t.append_def_list (method) - append_def_list(self, list, op, maymust) - Append def-list of an operand. This function calculates list of locations that - may or must be modified by the operand and appends it to LIST. - - @param list: (C++: mlist_t *) ptr to the output buffer. we will append to it. - @param op: (C++: const mop_t &) operand to calculate the def list of - @param maymust: (C++: maymust_t) should we calculate 'may-def' or 'must-def' list? see maymust_t - for more details. +ida_hexrays.mblock_t.append_def_list(self, list: "mlist_t", op: "mop_t", maymust: "maymust_t") -> None + Append def-list of an operand. This function calculates list of locations that may or must be modified by the operand and appends it to LIST. + + @param list: ptr to the output buffer. we will append to it. + @param op: operand to calculate the def list of + @param maymust: should we calculate 'may-def' or 'must-def' list? see maymust_t for more details. -ida_hexrays.mblock_t.append_use_list (method) - append_use_list(self, list, op, maymust, mask=bitrange_t(0, USHRT_MAX)) - Append use-list of an operand. This function calculates list of locations that - may or must be used by the operand and appends it to LIST. - - @param list: (C++: mlist_t *) ptr to the output buffer. we will append to it. - @param op: (C++: const mop_t &) operand to calculate the use list of - @param maymust: (C++: maymust_t) should we calculate 'may-use' or 'must-use' list? see maymust_t - for more details. - @param mask: (C++: bitrange_t) if only part of the operand should be considered, a bitmask can be - used to specify which part. example: op=AX,mask=0xFF means that we - will consider only AL. +ida_hexrays.mblock_t.append_use_list(self, *args) -> None + Append use-list of an operand. This function calculates list of locations that may or must be used by the operand and appends it to LIST. + + @param list: ptr to the output buffer. we will append to it. + @param op: operand to calculate the use list of + @param maymust: should we calculate 'may-use' or 'must-use' list? see maymust_t for more details. + @param mask: if only part of the operand should be considered, a bitmask can be used to specify which part. example: op=AX,mask=0xFF means that we will consider only AL. -ida_hexrays.mblock_t.build_def_list (method) - build_def_list(self, ins, maymust) -> mlist_t - Build def-list of an instruction. This function calculates list of locations - that may or must be modified by the instruction. Examples: "stx ebx.4, ds.2, - eax.4", may-list: all aliasable memory "stx ebx.4, ds.2, eax.4", must-list: - empty Since STX uses EAX for indirect access, it may modify any aliasable - memory. On the other hand, we cannot tell for sure which memory cells will be - modified, this is why the must-list is empty. - - @param ins: (C++: const minsn_t &) instruction to calculate the def list of - @param maymust: (C++: maymust_t) should we calculate 'may-def' or 'must-def' list? see maymust_t - for more details. - @return: the calculated def-list +ida_hexrays.mblock_t.build_def_list(self, ins: "minsn_t", maymust: "maymust_t") -> "mlist_t" + Build def-list of an instruction. This function calculates list of locations that may or must be modified by the instruction. Examples: "stx ebx.4, ds.2, eax.4", may-list: all aliasable memory "stx ebx.4, ds.2, eax.4", must-list: empty Since STX uses EAX for indirect access, it may modify any aliasable memory. On the other hand, we cannot tell for sure which memory cells will be modified, this is why the must-list is empty. + + @param ins: instruction to calculate the def list of + @param maymust: should we calculate 'may-def' or 'must-def' list? see maymust_t for more details. + @returns the calculated def-list -ida_hexrays.mblock_t.build_lists (method) - build_lists(self, kill_deads) -> int - Build def-use lists and eliminate deads. - - @param kill_deads: (C++: bool) do delete dead instructions? - @return: the number of eliminated instructions Better mblock_t::call - make_lists_ready() rather than this function. +ida_hexrays.mblock_t.build_lists(self, kill_deads: bool) -> int + Build def-use lists and eliminate deads. + + @param kill_deads: do delete dead instructions? + @returns the number of eliminated instructions Better mblock_t::call make_lists_ready() rather than this function. -ida_hexrays.mblock_t.build_use_list (method) - build_use_list(self, ins, maymust) -> mlist_t - Build use-list of an instruction. This function calculates list of locations - that may or must be used by the instruction. Examples: "ldx ds.2, eax.4, ebx.4", - may-list: all aliasable memory "ldx ds.2, eax.4, ebx.4", must-list: empty Since - LDX uses EAX for indirect access, it may access any aliasable memory. On the - other hand, we cannot tell for sure which memory cells will be accessed, this is - why the must-list is empty. - - @param ins: (C++: const minsn_t &) instruction to calculate the use list of - @param maymust: (C++: maymust_t) should we calculate 'may-use' or 'must-use' list? see maymust_t - for more details. - @return: the calculated use-list +ida_hexrays.mblock_t.build_use_list(self, ins: "minsn_t", maymust: "maymust_t") -> "mlist_t" + Build use-list of an instruction. This function calculates list of locations that may or must be used by the instruction. Examples: "ldx ds.2, eax.4, ebx.4", may-list: all aliasable memory "ldx ds.2, eax.4, ebx.4", must-list: empty Since LDX uses EAX for indirect access, it may access any aliasable memory. On the other hand, we cannot tell for sure which memory cells will be accessed, this is why the must-list is empty. + + @param ins: instruction to calculate the use list of + @param maymust: should we calculate 'may-use' or 'must-use' list? see maymust_t for more details. + @returns the calculated use-list -ida_hexrays.mblock_t.dead_at_start (variable) +ida_hexrays.mblock_t.dead_at_start data that is dead at the block entry -ida_hexrays.mblock_t.dnu (variable) +ida_hexrays.mblock_t.dnu data that is defined but not used in the block -ida_hexrays.mblock_t.dump (method) - dump(self) - Dump block info. This function is useful for debugging, see mba_t::dump for info +ida_hexrays.mblock_t.dump(self) -> None + Dump block info. This function is useful for debugging, see mba_t::dump for info + -ida_hexrays.mblock_t.dump_block (method) - dump_block(self, title) +ida_hexrays.mblock_t.dump_block(self, title: str) -> None + +ida_hexrays.mblock_t.empty(self) -> bool + +ida_hexrays.mblock_t.end + end address note: we cannot rely on start/end addresses very much because instructions are propagated between blocks + + +ida_hexrays.mblock_t.find_access(self, op: "mop_t", parent: "minsn_t **", mend: "minsn_t", fdflags: int) -> "minsn_t *" + Find the instruction that accesses the specified operand. This function search inside one block. + + @param op: operand to search for + @param parent: ptr to ptr to a top level instruction. in: denotes the beginning of the search range. out: denotes the parent of the found instruction. + @param mend: end instruction of the range (must be a top level insn) mend is excluded from the range. it can be specified as nullptr. parent and mend must belong to the same block. + @param fdflags: combination of bits for mblock_t::find_access bits + @returns the instruction that accesses the operand. this instruction may be a sub-instruction. to find out the top level instruction, check out *parent. nullptr means 'not found'. + +ida_hexrays.mblock_t.find_def(self, op: "mop_t", p_i1: "minsn_t **", i2: "minsn_t", fdflags: int) -> "minsn_t *" + +ida_hexrays.mblock_t.find_first_use(self, *args) -> "minsn_t *" + This function has the following signatures: - @param title: char const * - -ida_hexrays.mblock_t.empty (method) - empty(self) -> bool - -ida_hexrays.mblock_t.end (variable) - end address note: we cannot rely on start/end addresses very much because - instructions are propagated between blocks - -ida_hexrays.mblock_t.find_access (method) - find_access(self, op, parent, mend, fdflags) -> minsn_t - Find the instruction that accesses the specified operand. This function search - inside one block. + 0. find_first_use(list: mlist_t *, i1: const minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> const minsn_t * + 1. find_first_use(list: mlist_t *, i1: minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> minsn_t * - @param op: (C++: const mop_t &) operand to search for - @param parent: (C++: minsn_t **) ptr to ptr to a top level instruction. denotes the beginning of - the search range. - @param mend: (C++: const minsn_t *) end instruction of the range (must be a top level insn) mend is - excluded from the range. it can be specified as nullptr. parent and - mend must belong to the same block. - @param fdflags: (C++: int) combination of bits for mblock_t::find_access bits - @return: the instruction that accesses the operand. this instruction may be a - sub-instruction. to find out the top level instruction, check out - *p_i1. nullptr means 'not found'. - -ida_hexrays.mblock_t.find_def (method) - find_def(self, op, p_i1, i2, fdflags) -> minsn_t + # 0: find_first_use(list: mlist_t *, i1: const minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> const minsn_t * - @param op: mop_t const & - @param p_i1: minsn_t ** - @param i2: minsn_t const * - @param fdflags: int - -ida_hexrays.mblock_t.find_first_use (method) - find_first_use(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t + Find the first insn that uses the specified list in the insn range. + + @returns pointer to such instruction or nullptr. Upon return LIST will contain only locations not redefined by insns [i1..result] - @param list: mlist_t * - @param i1: minsn_t * - @param i2: minsn_t const * - @param maymust: maymust_t + # 1: find_first_use(list: mlist_t *, i1: minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> minsn_t * -ida_hexrays.mblock_t.find_redefinition (method) - find_redefinition(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t +ida_hexrays.mblock_t.find_redefinition(self, *args) -> "minsn_t *" + This function has the following signatures: - @param list: mlist_t const & - @param i1: minsn_t * - @param i2: minsn_t const * - @param maymust: maymust_t - -ida_hexrays.mblock_t.find_use (method) - find_use(self, op, p_i1, i2, fdflags) -> minsn_t + 0. find_redefinition(list: const mlist_t &, i1: const minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> const minsn_t * + 1. find_redefinition(list: const mlist_t &, i1: minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> minsn_t * - @param op: mop_t const & - @param p_i1: minsn_t ** - @param i2: minsn_t const * - @param fdflags: int - -ida_hexrays.mblock_t.flags (variable) - combination of Basic block properties bits - -ida_hexrays.mblock_t.for_all_insns (method) - for_all_insns(self, mv) -> int - Visit all instructions. This function visits subinstructions too. + # 0: find_redefinition(list: const mlist_t &, i1: const minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> const minsn_t * - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: zero or the value returned by mv.visit_insn() See also - mba_t::for_all_topinsns() - -ida_hexrays.mblock_t.for_all_ops (method) - for_all_ops(self, mv) -> int - Visit all operands. This function visit subinstruction operands too. + Find the first insn that redefines any part of the list in the insn range. + + @returns pointer to such instruction or nullptr. - @param mv: (C++: mop_visitor_t &) operand visitor - @return: zero or the value returned by mv.visit_mop() + # 1: find_redefinition(list: const mlist_t &, i1: minsn_t *, i2: const minsn_t *, maymust: maymust_t=MAY_ACCESS) -> minsn_t * -ida_hexrays.mblock_t.for_all_uses (method) - for_all_uses(self, list, i1, i2, mmv) -> int - Visit all operands that use LIST. - - @param list: (C++: mlist_t *) ptr to the list of locations. it may be modified: parts that get - redefined by the instructions in [i1,i2) will be deleted. - @param i1: (C++: minsn_t *) starting instruction. must be a top level insn. - @param i2: (C++: minsn_t *) ending instruction (excluded). must be a top level insn. - @param mmv: (C++: mlist_mop_visitor_t &) operand visitor - @return: zero or the value returned by mmv.visit_mop() +ida_hexrays.mblock_t.find_use(self, op: "mop_t", p_i1: "minsn_t **", i2: "minsn_t", fdflags: int) -> "minsn_t *" -ida_hexrays.mblock_t.get_reginsn_qty (method) - get_reginsn_qty(self) -> size_t - Calculate number of regular instructions in the block. Assertions are skipped by - this function. - - @return: Number of non-assertion instructions in the block. +ida_hexrays.mblock_t.flags + combination of Basic block properties bits + -ida_hexrays.mblock_t.get_valranges (method) - get_valranges(self, res, vivl, vrflags) -> bool - Find possible values for an instruction. - - @param res: (C++: valrng_t *) set of value ranges - @param vivl: (C++: const vivl_t &) what to search for - @param vrflags: (C++: int) combination of bits for get_valranges bits - get_valranges(self, res, vivl, m, vrflags) -> bool - - @param res: valrng_t * - @param vivl: vivl_t const & - @param m: minsn_t const * - @param vrflags: int +ida_hexrays.mblock_t.for_all_insns(self, mv: "minsn_visitor_t") -> int + Visit all instructions. This function visits subinstructions too. + + @param mv: instruction visitor + @returns zero or the value returned by mv.visit_insn() See also mba_t::for_all_topinsns() -ida_hexrays.mblock_t.head (variable) +ida_hexrays.mblock_t.for_all_ops(self, mv: "mop_visitor_t") -> int + Visit all operands. This function visit subinstruction operands too. + + @param mv: operand visitor + @returns zero or the value returned by mv.visit_mop() + +ida_hexrays.mblock_t.for_all_uses(self, list: "mlist_t", i1: "minsn_t", i2: "minsn_t", mmv: "mlist_mop_visitor_t") -> int + Visit all operands that use LIST. + + @param list: ptr to the list of locations. it may be modified: parts that get redefined by the instructions in [i1,i2) will be deleted. + @param i1: starting instruction. must be a top level insn. + @param i2: ending instruction (excluded). must be a top level insn. + @param mmv: operand visitor + @returns zero or the value returned by mmv.visit_mop() + +ida_hexrays.mblock_t.get_reginsn_qty(self) -> "size_t" + Calculate number of regular instructions in the block. Assertions are skipped by this function. + + @returns Number of non-assertion instructions in the block. + +ida_hexrays.mblock_t.get_valranges(self, *args) -> bool + This function has the following signatures: + + 0. get_valranges(res: valrng_t *, vivl: const vivl_t &, vrflags: int) -> bool + 1. get_valranges(res: valrng_t *, vivl: const vivl_t &, m: const minsn_t *, vrflags: int) -> bool + + # 0: get_valranges(res: valrng_t *, vivl: const vivl_t &, vrflags: int) -> bool + + Find possible values for a block. + + + # 1: get_valranges(res: valrng_t *, vivl: const vivl_t &, m: const minsn_t *, vrflags: int) -> bool + + Find possible values for an instruction. + + +ida_hexrays.mblock_t.head pointer to the first instruction of the block -ida_hexrays.mblock_t.insert_into_block (method) - insert_into_block(self, nm, om) -> minsn_t - Insert instruction into the doubly linked list - - @param nm: (C++: minsn_t *) new instruction - @param om: (C++: minsn_t *) existing instruction, part of the doubly linked list if nullptr, then - the instruction will be inserted at the beginning of the list NM will - be inserted immediately after OM - @return: pointer to NM +ida_hexrays.mblock_t.insert_into_block(self, nm: "minsn_t", om: "minsn_t") -> "minsn_t *" + Insert instruction into the doubly linked list + + @param nm: new instruction + @param om: existing instruction, part of the doubly linked list if nullptr, then the instruction will be inserted at the beginning of the list NM will be inserted immediately after OM + @returns pointer to NM -ida_hexrays.mblock_t.is_branch (method) - is_branch(self) -> bool +ida_hexrays.mblock_t.is_branch(self) -> bool -ida_hexrays.mblock_t.is_call_block (method) - is_call_block(self) -> bool +ida_hexrays.mblock_t.is_call_block(self) -> bool -ida_hexrays.mblock_t.is_nway (method) - is_nway(self) -> bool +ida_hexrays.mblock_t.is_nway(self) -> bool -ida_hexrays.mblock_t.is_redefined (method) - is_redefined(self, list, i1, i2, maymust=MAY_ACCESS) -> bool - Is the list redefined by the specified instructions? - - @param list: (C++: const mlist_t &) list of locations to check. - @param i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn) - @param i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is - excluded from the range. it can be specified as nullptr. i1 and i2 - must belong to the same block. - @param maymust: (C++: maymust_t) should we search in 'may-access' or 'must-access' mode? +ida_hexrays.mblock_t.is_redefined(self, *args) -> bool + Is the list redefined by the specified instructions? + + @param list: list of locations to check. + @param i1: starting instruction of the range (must be a top level insn) + @param i2: end instruction of the range (must be a top level insn) i2 is excluded from the range. it can be specified as nullptr. i1 and i2 must belong to the same block. + @param maymust: should we search in 'may-access' or 'must-access' mode? -ida_hexrays.mblock_t.is_rhs_redefined (method) - is_rhs_redefined(self, ins, i1, i2) -> bool - Is the right hand side of the instruction redefined the insn range? "right hand - side" corresponds to the source operands of the instruction. - - @param ins: (C++: const minsn_t *) instruction to consider - @param i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn) - @param i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is - excluded from the range. it can be specified as nullptr. i1 and i2 - must belong to the same block. +ida_hexrays.mblock_t.is_rhs_redefined(self, ins: "minsn_t", i1: "minsn_t", i2: "minsn_t") -> bool + Is the right hand side of the instruction redefined the insn range? "right hand side" corresponds to the source operands of the instruction. + + @param ins: instruction to consider + @param i1: starting instruction of the range (must be a top level insn) + @param i2: end instruction of the range (must be a top level insn) i2 is excluded from the range. it can be specified as nullptr. i1 and i2 must belong to the same block. -ida_hexrays.mblock_t.is_simple_goto_block (method) - is_simple_goto_block(self) -> bool +ida_hexrays.mblock_t.is_simple_goto_block(self) -> bool -ida_hexrays.mblock_t.is_simple_jcnd_block (method) - is_simple_jcnd_block(self) -> bool +ida_hexrays.mblock_t.is_simple_jcnd_block(self) -> bool -ida_hexrays.mblock_t.is_unknown_call (method) - is_unknown_call(self) -> bool +ida_hexrays.mblock_t.is_unknown_call(self) -> bool -ida_hexrays.mblock_t.is_used (method) - is_used(self, list, i1, i2, maymust=MAY_ACCESS) -> bool - Is the list used by the specified instruction range? - - @param list: (C++: mlist_t *) list of locations. LIST may be modified by the function: redefined - locations will be removed from it. - @param i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn) - @param i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is - excluded from the range. it can be specified as nullptr. i1 and i2 - must belong to the same block. - @param maymust: (C++: maymust_t) should we search in 'may-access' or 'must-access' mode? +ida_hexrays.mblock_t.is_used(self, *args) -> bool + Is the list used by the specified instruction range? + + @param list: list of locations. LIST may be modified by the function: redefined locations will be removed from it. + @param i1: starting instruction of the range (must be a top level insn) + @param i2: end instruction of the range (must be a top level insn) i2 is excluded from the range. it can be specified as nullptr. i1 and i2 must belong to the same block. + @param maymust: should we search in 'may-access' or 'must-access' mode? -ida_hexrays.mblock_t.lists_dirty (method) - lists_dirty(self) -> bool +ida_hexrays.mblock_t.lists_dirty(self) -> bool -ida_hexrays.mblock_t.lists_ready (method) - lists_ready(self) -> bool +ida_hexrays.mblock_t.lists_ready(self) -> bool -ida_hexrays.mblock_t.make_lists_ready (method) - make_lists_ready(self) -> int +ida_hexrays.mblock_t.make_lists_ready(self) -> int -ida_hexrays.mblock_t.make_nop (method) - make_nop(self, m) - Erase the instruction (convert it to nop) and mark the lists dirty. This is the - recommended function to use because it also marks the block use-def lists dirty. - - @param m: (C++: minsn_t *) +ida_hexrays.mblock_t.make_nop(self, m: "minsn_t") -> None + Erase the instruction (convert it to nop) and mark the lists dirty. This is the recommended function to use because it also marks the block use-def lists dirty. + -ida_hexrays.mblock_t.mark_lists_dirty (method) - mark_lists_dirty(self) +ida_hexrays.mblock_t.mark_lists_dirty(self) -> None -ida_hexrays.mblock_t.maxbsp (variable) +ida_hexrays.mblock_t.maxbsp maximal sp value in the block (0...stacksize) -ida_hexrays.mblock_t.maybdef (variable) +ida_hexrays.mblock_t.maybdef data that may be defined by the block -ida_hexrays.mblock_t.maybuse (variable) +ida_hexrays.mblock_t.maybuse data that may be used by the block -ida_hexrays.mblock_t.mba (variable) +ida_hexrays.mblock_t.mba the parent micro block array -ida_hexrays.mblock_t.minbargref (variable) +ida_hexrays.mblock_t.minbargref the same for arguments -ida_hexrays.mblock_t.minbstkref (variable) - lowest stack location accessible with indirect addressing (offset from the stack - bottom) initially it is 0 (not computed) +ida_hexrays.mblock_t.minbstkref + lowest stack location accessible with indirect addressing (offset from the stack bottom) initially it is 0 (not computed) + -ida_hexrays.mblock_t.mustbdef (variable) +ida_hexrays.mblock_t.mustbdef data that must be defined by the block -ida_hexrays.mblock_t.mustbuse (variable) +ida_hexrays.mblock_t.mustbuse data that must be used by the block -ida_hexrays.mblock_t.needs_propagation (method) - needs_propagation(self) -> bool +ida_hexrays.mblock_t.needs_propagation(self) -> bool -ida_hexrays.mblock_t.nextb (variable) +ida_hexrays.mblock_t.nextb next block in the doubly linked list -ida_hexrays.mblock_t.npred (method) - npred(self) -> int +ida_hexrays.mblock_t.npred(self) -> int Get number of block predecessors. -ida_hexrays.mblock_t.nsucc (method) - nsucc(self) -> int +ida_hexrays.mblock_t.nsucc(self) -> int Get number of block successors. -ida_hexrays.mblock_t.optimize_block (method) - optimize_block(self) -> int - Optimize a basic block. Usually there is no need to call this function - explicitly because the decompiler will call it itself if optinsn_t::func or - optblock_t::func return non-zero. - - @return: number of changes made to the block +ida_hexrays.mblock_t.optimize_block(self) -> int + Optimize a basic block. Usually there is no need to call this function explicitly because the decompiler will call it itself if optinsn_t::func or optblock_t::func return non-zero. + + @returns number of changes made to the block -ida_hexrays.mblock_t.optimize_insn (method) - optimize_insn(self, m, optflags=0x0002|0x0004) -> int - Optimize one instruction in the context of the block. - - @param m: (C++: minsn_t *) pointer to a top level instruction - @param optflags: (C++: int) combination of optimization flags bits - @return: number of changes made to the block This function may change other - instructions in the block too. However, it will not destroy top level - instructions (it may convert them to nop's). This function performs - only intrablock modifications. See also minsn_t::optimize_solo() +ida_hexrays.mblock_t.optimize_insn(self, *args) -> int + Optimize one instruction in the context of the block. + + @param m: pointer to a top level instruction + @param optflags: combination of optimization flags bits + @returns number of changes made to the block This function may change other instructions in the block too. However, it will not destroy top level instructions (it may convert them to nop's). This function performs only intrablock modifications. See also minsn_t::optimize_solo() -ida_hexrays.mblock_t.optimize_useless_jump (method) - optimize_useless_jump(self) -> int - Remove a jump at the end of the block if it is useless. This function preserves - any side effects when removing a useless jump. Both conditional and - unconditional jumps are handled (and jtbl too). This function deletes useless - jumps, not only replaces them with a nop. (please note that \optimize_insn does - not handle useless jumps). - - @return: number of changes made to the block +ida_hexrays.mblock_t.optimize_useless_jump(self) -> int + Remove a jump at the end of the block if it is useless. This function preserves any side effects when removing a useless jump. Both conditional and unconditional jumps are handled (and jtbl too). This function deletes useless jumps, not only replaces them with a nop. (please note that \optimize_insn does not handle useless jumps). + + @returns number of changes made to the block -ida_hexrays.mblock_t.pred (method) - pred(self, n) -> int - - @param n: int +ida_hexrays.mblock_t.pred(self, n: int) -> int -ida_hexrays.mblock_t.preds (method) +ida_hexrays.mblock_t.preds(self) Iterates the list of predecessor blocks -ida_hexrays.mblock_t.predset (variable) - control flow graph: list of our predecessors use npred() and pred() to access it +ida_hexrays.mblock_t.predset + control flow graph: list of our predecessors use npred() and pred() to access it + -ida_hexrays.mblock_t.prevb (variable) +ida_hexrays.mblock_t.prevb previous block in the doubly linked list -ida_hexrays.mblock_t.remove_from_block (method) - remove_from_block(self, m) -> minsn_t - Remove instruction from the doubly linked list - - @param m: (C++: minsn_t *) instruction to remove The removed instruction is not deleted, the - caller gets its ownership - @return: pointer to the next instruction +ida_hexrays.mblock_t.remove_from_block(self, m: "minsn_t") -> "minsn_t *" + Remove instruction from the doubly linked list + + @param m: instruction to remove The removed instruction is not deleted, the caller gets its ownership + @returns pointer to the next instruction -ida_hexrays.mblock_t.request_demote64 (method) - request_demote64(self) +ida_hexrays.mblock_t.request_demote64(self) -> None -ida_hexrays.mblock_t.request_propagation (method) - request_propagation(self) +ida_hexrays.mblock_t.request_propagation(self) -> None -ida_hexrays.mblock_t.serial (variable) +ida_hexrays.mblock_t.serial block number -ida_hexrays.mblock_t.start (variable) +ida_hexrays.mblock_t.start start address -ida_hexrays.mblock_t.succ (method) - succ(self, n) -> int - - @param n: int +ida_hexrays.mblock_t.succ(self, n: int) -> int -ida_hexrays.mblock_t.succs (method) +ida_hexrays.mblock_t.succs(self) Iterates the list of successor blocks -ida_hexrays.mblock_t.succset (variable) - control flow graph: list of our successors use nsucc() and succ() to access it +ida_hexrays.mblock_t.succset + control flow graph: list of our successors use nsucc() and succ() to access it + -ida_hexrays.mblock_t.tail (variable) +ida_hexrays.mblock_t.tail pointer to the last instruction of the block -ida_hexrays.mblock_t.type (variable) +ida_hexrays.mblock_t.type block type (BLT_NONE - not computed yet) -ida_hexrays.mcallarg_t (class) - Proxy of C++ mcallarg_t class. +ida_hexrays.mcallarg_t -ida_hexrays.mcallarg_t.__init__ (method) - __init__(self) -> mcallarg_t - __init__(self, rarg) -> mcallarg_t - - @param rarg: mop_t const & +ida_hexrays.mcallarg_t.__init__(self, *args) -ida_hexrays.mcallarg_t._print (method) - _print(self, shins_flags=0x04|0x02) - - Parameters - ---------- - shins_flags: int +ida_hexrays.mcallarg_t._print(self, *args) -> None -ida_hexrays.mcallarg_t.argloc (variable) +ida_hexrays.mcallarg_t.argloc ida argloc -ida_hexrays.mcallarg_t.copy_mop (method) - copy_mop(self, op) - - @param op: mop_t const & +ida_hexrays.mcallarg_t.copy_mop(self, op: "mop_t") -> None -ida_hexrays.mcallarg_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.mcallarg_t.dstr(self) -> str -ida_hexrays.mcallarg_t.ea (variable) - address where the argument was initialized. BADADDR means unknown. +ida_hexrays.mcallarg_t.ea + address where the argument was initialized. BADADDR means unknown. + -ida_hexrays.mcallarg_t.flags (variable) +ida_hexrays.mcallarg_t.flags FAI_... -ida_hexrays.mcallarg_t.make_int (method) - make_int(self, val, val_ea, opno=0) - - @param val: int - @param val_ea: ea_t - @param opno: int +ida_hexrays.mcallarg_t.make_int(self, val: int, val_ea: ida_idaapi.ea_t, opno: int = 0) -> None -ida_hexrays.mcallarg_t.make_uint (method) - make_uint(self, val, val_ea, opno=0) - - @param val: int - @param val_ea: ea_t - @param opno: int +ida_hexrays.mcallarg_t.make_uint(self, val: int, val_ea: ida_idaapi.ea_t, opno: int = 0) -> None -ida_hexrays.mcallarg_t.name (variable) +ida_hexrays.mcallarg_t.name formal argument name -ida_hexrays.mcallarg_t.set_regarg (method) - set_regarg(self, mr, sz, tif) +ida_hexrays.mcallarg_t.set_regarg(self, *args) -> None + This function has the following signatures: - @param mr: mreg_t - @param sz: int - @param tif: tinfo_t const & + 0. set_regarg(mr: mreg_t, sz: int, tif: const tinfo_t &) -> None + 1. set_regarg(mr: mreg_t, tif: const tinfo_t &) -> None + 2. set_regarg(mr: mreg_t, dt: char, sign: type_sign_t=type_unsigned) -> None - set_regarg(self, mr, tif) + # 0: set_regarg(mr: mreg_t, sz: int, tif: const tinfo_t &) -> None - @param mr: mreg_t - @param tif: tinfo_t const & - set_regarg(self, mr, dt, sign=type_unsigned) + # 1: set_regarg(mr: mreg_t, tif: const tinfo_t &) -> None - @param mr: mreg_t - @param dt: char - @param sign: type_sign_t + + # 2: set_regarg(mr: mreg_t, dt: char, sign: type_sign_t=type_unsigned) -> None -ida_hexrays.mcallarg_t.type (variable) +ida_hexrays.mcallarg_t.type formal argument type -ida_hexrays.mcallargs_t (class) - Proxy of C++ qvector< mcallarg_t > class. +ida_hexrays.mcallargs_t -ida_hexrays.mcallargs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< mcallarg_t > const & +ida_hexrays.mcallargs_t.__eq__(self, r: "mcallargs_t") -> bool -ida_hexrays.mcallargs_t.__getitem__ (method) - __getitem__(self, i) -> mcallarg_t - - @param i: size_t +ida_hexrays.mcallargs_t.__getitem__(self, i: "size_t") -> "mcallarg_t const &" -ida_hexrays.mcallargs_t.__init__ (method) - __init__(self) -> mcallargs_t - __init__(self, x) -> mcallargs_t - - @param x: qvector< mcallarg_t > const & +ida_hexrays.mcallargs_t.__init__(self, *args) -ida_hexrays.mcallargs_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.mcallargs_t.__len__(self) -> "size_t" -ida_hexrays.mcallargs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< mcallarg_t > const & +ida_hexrays.mcallargs_t.__ne__(self, r: "mcallargs_t") -> bool -ida_hexrays.mcallargs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: mcallarg_t const & +ida_hexrays.mcallargs_t.__setitem__(self, i: "size_t", v: "mcallarg_t") -> None -ida_hexrays.mcallargs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: mcallarg_t const & +ida_hexrays.mcallargs_t._del(self, x: "mcallarg_t") -> bool -ida_hexrays.mcallargs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: mcallarg_t const & +ida_hexrays.mcallargs_t.add_unique(self, x: "mcallarg_t") -> bool -ida_hexrays.mcallargs_t.at (method) - at(self, _idx) -> mcallarg_t - - @param _idx: size_t +ida_hexrays.mcallargs_t.append(self, x: "mcallarg_t") -> None -ida_hexrays.mcallargs_t.begin (method) - begin(self) -> mcallarg_t +ida_hexrays.mcallargs_t.at(self, _idx: "size_t") -> "mcallarg_t const &" -ida_hexrays.mcallargs_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.mcallargs_t.begin(self, *args) -> "qvector< mcallarg_t >::const_iterator" -ida_hexrays.mcallargs_t.clear (method) - clear(self) +ida_hexrays.mcallargs_t.capacity(self) -> "size_t" -ida_hexrays.mcallargs_t.empty (method) - empty(self) -> bool +ida_hexrays.mcallargs_t.clear(self) -> None -ida_hexrays.mcallargs_t.end (method) - end(self) -> mcallarg_t +ida_hexrays.mcallargs_t.empty(self) -> bool -ida_hexrays.mcallargs_t.erase (method) - erase(self, it) -> mcallarg_t - - @param it: qvector< mcallarg_t >::iterator - - erase(self, first, last) -> mcallarg_t - - @param first: qvector< mcallarg_t >::iterator - @param last: qvector< mcallarg_t >::iterator +ida_hexrays.mcallargs_t.end(self, *args) -> "qvector< mcallarg_t >::const_iterator" -ida_hexrays.mcallargs_t.extract (method) - extract(self) -> mcallarg_t +ida_hexrays.mcallargs_t.erase(self, *args) -> "qvector< mcallarg_t >::iterator" -ida_hexrays.mcallargs_t.find (method) - find(self, x) -> mcallarg_t - - @param x: mcallarg_t const & +ida_hexrays.mcallargs_t.extend(self, x: "mcallargs_t") -> None -ida_hexrays.mcallargs_t.grow (method) - grow(self, x=mcallarg_t()) - - @param x: mcallarg_t const & +ida_hexrays.mcallargs_t.extract(self) -> "mcallarg_t *" -ida_hexrays.mcallargs_t.has (method) - has(self, x) -> bool - - @param x: mcallarg_t const & +ida_hexrays.mcallargs_t.find(self, *args) -> "qvector< mcallarg_t >::const_iterator" -ida_hexrays.mcallargs_t.inject (method) - inject(self, s, len) - - @param s: mcallarg_t * - @param len: size_t +ida_hexrays.mcallargs_t.grow(self, *args) -> None -ida_hexrays.mcallargs_t.insert (method) - insert(self, it, x) -> mcallarg_t - - @param it: qvector< mcallarg_t >::iterator - @param x: mcallarg_t const & +ida_hexrays.mcallargs_t.has(self, x: "mcallarg_t") -> bool -ida_hexrays.mcallargs_t.pop_back (method) - pop_back(self) +ida_hexrays.mcallargs_t.inject(self, s: "mcallarg_t", len: "size_t") -> None -ida_hexrays.mcallargs_t.push_back (method) - push_back(self, x) - - @param x: mcallarg_t const & - - push_back(self) -> mcallarg_t +ida_hexrays.mcallargs_t.insert(self, it: "mcallarg_t", x: "mcallarg_t") -> "qvector< mcallarg_t >::iterator" -ida_hexrays.mcallargs_t.qclear (method) - qclear(self) +ida_hexrays.mcallargs_t.pop_back(self) -> None -ida_hexrays.mcallargs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.mcallargs_t.push_back(self, *args) -> "mcallarg_t &" -ida_hexrays.mcallargs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: mcallarg_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.mcallargs_t.qclear(self) -> None -ida_hexrays.mcallargs_t.size (method) - size(self) -> size_t +ida_hexrays.mcallargs_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.mcallargs_t.swap (method) - swap(self, r) - - @param r: qvector< mcallarg_t > & +ida_hexrays.mcallargs_t.resize(self, *args) -> None -ida_hexrays.mcallargs_t.truncate (method) - truncate(self) +ida_hexrays.mcallargs_t.size(self) -> "size_t" -ida_hexrays.mcallinfo_t (class) - Proxy of C++ mcallinfo_t class. +ida_hexrays.mcallargs_t.swap(self, r: "mcallargs_t") -> None -ida_hexrays.mcallinfo_t.__init__ (method) - __init__(self, _callee=BADADDR, _sargs=0) -> mcallinfo_t - - @param _callee: ea_t - @param _sargs: int +ida_hexrays.mcallargs_t.truncate(self) -> None -ida_hexrays.mcallinfo_t._print (method) - _print(self, size=-1, shins_flags=0x04|0x02) - - Parameters - ---------- - size: int - shins_flags: int +ida_hexrays.mcallinfo_t -ida_hexrays.mcallinfo_t.args (variable) +ida_hexrays.mcallinfo_t.__init__(self, *args) + +ida_hexrays.mcallinfo_t._print(self, *args) -> None + +ida_hexrays.mcallinfo_t.args call arguments -ida_hexrays.mcallinfo_t.call_spd (variable) +ida_hexrays.mcallinfo_t.call_spd sp value at call insn -ida_hexrays.mcallinfo_t.callee (variable) +ida_hexrays.mcallinfo_t.callee address of the called function, if known -ida_hexrays.mcallinfo_t.cc (variable) +ida_hexrays.mcallinfo_t.cc calling convention -ida_hexrays.mcallinfo_t.dead_regs (variable) - registers defined by the function but never used. upon propagation we do the - following: +ida_hexrays.mcallinfo_t.dead_regs + registers defined by the function but never used. upon propagation we do the following: * dead_regs += return_regs - * retregs.clear() since the call is propagated + * retregs.clear() since the call is propagated + + + -ida_hexrays.mcallinfo_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.mcallinfo_t.dstr(self) -> str -ida_hexrays.mcallinfo_t.flags (variable) - combination of Call properties... bits +ida_hexrays.mcallinfo_t.flags + combination of Call properties... bits + -ida_hexrays.mcallinfo_t.fti_attrs (variable) +ida_hexrays.mcallinfo_t.fti_attrs extended function attributes -ida_hexrays.mcallinfo_t.get_type (method) - get_type(self) -> tinfo_t +ida_hexrays.mcallinfo_t.get_type(self) -> "tinfo_t" -ida_hexrays.mcallinfo_t.is_vararg (method) - is_vararg(self) -> bool +ida_hexrays.mcallinfo_t.is_vararg(self) -> bool -ida_hexrays.mcallinfo_t.lexcompare (method) - lexcompare(self, f) -> int - - @param f: mcallinfo_t const & +ida_hexrays.mcallinfo_t.lexcompare(self, f: "mcallinfo_t") -> int -ida_hexrays.mcallinfo_t.pass_regs (variable) - passthrough registers: registers that depend on input values (subset of spoiled) +ida_hexrays.mcallinfo_t.pass_regs + passthrough registers: registers that depend on input values (subset of spoiled) + -ida_hexrays.mcallinfo_t.retregs (variable) - return register(s) (e.g., AX, AX:DX, etc.) this vector is built from return_regs +ida_hexrays.mcallinfo_t.retregs + return register(s) (e.g., AX, AX:DX, etc.) this vector is built from return_regs + -ida_hexrays.mcallinfo_t.return_argloc (variable) +ida_hexrays.mcallinfo_t.return_argloc location of the returned value -ida_hexrays.mcallinfo_t.return_regs (variable) +ida_hexrays.mcallinfo_t.return_regs list of values returned by the function -ida_hexrays.mcallinfo_t.return_type (variable) +ida_hexrays.mcallinfo_t.return_type type of the returned value -ida_hexrays.mcallinfo_t.role (variable) +ida_hexrays.mcallinfo_t.role function role -ida_hexrays.mcallinfo_t.set_type (method) - set_type(self, type) -> bool - - @param type: tinfo_t const & +ida_hexrays.mcallinfo_t.set_type(self, type: "tinfo_t") -> bool -ida_hexrays.mcallinfo_t.solid_args (variable) - number of solid args. there may be variadic args in addtion +ida_hexrays.mcallinfo_t.solid_args + number of solid args. there may be variadic args in addtion + -ida_hexrays.mcallinfo_t.spoiled (variable) +ida_hexrays.mcallinfo_t.spoiled list of spoiled locations (includes return_regs) -ida_hexrays.mcallinfo_t.stkargs_top (variable) +ida_hexrays.mcallinfo_t.stkargs_top first offset past stack arguments -ida_hexrays.mcallinfo_t.visible_memory (variable) +ida_hexrays.mcallinfo_t.visible_memory what memory is visible to the call? -ida_hexrays.mcases_t (class) - Proxy of C++ mcases_t class. +ida_hexrays.mcases_t -ida_hexrays.mcases_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: mcases_t const & +ida_hexrays.mcases_t.__eq__(self, r: "mcases_t") -> bool -ida_hexrays.mcases_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: mcases_t const & +ida_hexrays.mcases_t.__ge__(self, r: "mcases_t") -> bool -ida_hexrays.mcases_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: mcases_t const & +ida_hexrays.mcases_t.__gt__(self, r: "mcases_t") -> bool -ida_hexrays.mcases_t.__init__ (method) - __init__(self) -> mcases_t +ida_hexrays.mcases_t.__init__(self) -ida_hexrays.mcases_t.__le__ (method) - __le__(self, r) -> bool - - @param r: mcases_t const & +ida_hexrays.mcases_t.__le__(self, r: "mcases_t") -> bool -ida_hexrays.mcases_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: mcases_t const & +ida_hexrays.mcases_t.__lt__(self, r: "mcases_t") -> bool -ida_hexrays.mcases_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: mcases_t const & +ida_hexrays.mcases_t.__ne__(self, r: "mcases_t") -> bool -ida_hexrays.mcases_t._print (method) - _print(self) +ida_hexrays.mcases_t._print(self) -> None -ida_hexrays.mcases_t.compare (method) - compare(self, r) -> int - - @param r: mcases_t const & +ida_hexrays.mcases_t.compare(self, r: "mcases_t") -> int -ida_hexrays.mcases_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.mcases_t.dstr(self) -> str -ida_hexrays.mcases_t.empty (method) - empty(self) -> bool +ida_hexrays.mcases_t.empty(self) -> bool -ida_hexrays.mcases_t.resize (method) - resize(self, s) - - @param s: int +ida_hexrays.mcases_t.resize(self, s: int) -> None -ida_hexrays.mcases_t.size (method) - size(self) -> size_t +ida_hexrays.mcases_t.size(self) -> "size_t" -ida_hexrays.mcases_t.swap (method) - swap(self, r) - - @param r: mcases_t & +ida_hexrays.mcases_t.swap(self, r: "mcases_t") -> None -ida_hexrays.mcases_t.targets (variable) +ida_hexrays.mcases_t.targets target block numbers -ida_hexrays.mcases_t.values (variable) +ida_hexrays.mcases_t.values expression values for each target -ida_hexrays.mcode_modifies_d (function) - mcode_modifies_d(mcode) -> bool - - @param mcode: enum mcode_t +ida_hexrays.mcode_modifies_d(mcode: "mcode_t") -> bool -ida_hexrays.microcode_filter_t (class) - Proxy of C++ microcode_filter_t class. +ida_hexrays.microcode_filter_t -ida_hexrays.microcode_filter_t.__disown__ (method) +ida_hexrays.microcode_filter_t.__disown__(self) -ida_hexrays.microcode_filter_t.__init__ (method) - __init__(self) -> microcode_filter_t - - @param self: PyObject * +ida_hexrays.microcode_filter_t.__init__(self) -ida_hexrays.microcode_filter_t.apply (method) - apply(self, cdg) -> merror_t - generate microcode for an instruction - - @param cdg: (C++: codegen_t &) - @return: MERR_... code: MERR_OK - user-defined microcode generated, go to the - next instruction MERR_INSN - not generated - the caller should try the - standard way else - error +ida_hexrays.microcode_filter_t.apply(self, cdg: "codegen_t") -> "merror_t" + generate microcode for an instruction + + @returns MERR_... code: MERR_OK - user-defined microcode generated, go to the next instruction MERR_INSN - not generated - the caller should try the standard way else - error -ida_hexrays.microcode_filter_t.match (method) - match(self, cdg) -> bool - check if the filter object is to be applied - - @param cdg: (C++: codegen_t &) - @return: success +ida_hexrays.microcode_filter_t.match(self, cdg: "codegen_t") -> bool + check if the filter object is to be applied + + @returns success -ida_hexrays.minsn_t (class) - Proxy of C++ minsn_t class. +ida_hexrays.min_vlr_svalue(size: int) -> "uvlr_t" -ida_hexrays.minsn_t.__dbg_get_meminfo (method) - __dbg_get_meminfo(self) -> qstring +ida_hexrays.minsn_t -ida_hexrays.minsn_t.__dbg_get_registered_kind (method) - __dbg_get_registered_kind(self) -> int +ida_hexrays.minsn_t.__dbg_get_meminfo(self) -> str -ida_hexrays.minsn_t.__init__ (method) - __init__(self, _ea) -> minsn_t - - @param _ea: ea_t - - __init__(self, m) -> minsn_t - - @param m: minsn_t const & +ida_hexrays.minsn_t.__dbg_get_registered_kind(self) -> int -ida_hexrays.minsn_t.__lt__ (method) - __lt__(self, ri) -> bool - - @param ri: minsn_t const & +ida_hexrays.minsn_t.__init__(self, *args) -ida_hexrays.minsn_t._acquire_ownership (method) +ida_hexrays.minsn_t.__lt__(self, ri: "minsn_t") -> bool -ida_hexrays.minsn_t._deregister (method) - _deregister(self) +ida_hexrays.minsn_t._acquire_ownership(self, v, acquire) -ida_hexrays.minsn_t._ensure_cond (method) +ida_hexrays.minsn_t._deregister(self) -> None -ida_hexrays.minsn_t._ensure_no_obj (method) +ida_hexrays.minsn_t._ensure_cond(self, ok, cond_str) -ida_hexrays.minsn_t._ensure_ownership_transferrable (method) +ida_hexrays.minsn_t._ensure_no_obj(self, o, attr, attr_is_acquired) -ida_hexrays.minsn_t._make_nop (method) - _make_nop(self) +ida_hexrays.minsn_t._ensure_ownership_transferrable(self, v) -ida_hexrays.minsn_t._maybe_disown_and_deregister (method) +ida_hexrays.minsn_t._make_nop(self) -> None + Convert instruction to nop. This function erases all info but the prev/next fields. In most cases it is better to use mblock_t::make_nop(), which also marks the block lists as dirty. + -ida_hexrays.minsn_t._meminfo (method) +ida_hexrays.minsn_t._maybe_disown_and_deregister(self) -ida_hexrays.minsn_t._obj_id (method) - _obj_id(self) -> PyObject * +ida_hexrays.minsn_t._meminfo(self) -ida_hexrays.minsn_t._own_and_register (method) +ida_hexrays.minsn_t._obj_id(self) -> "PyObject *" -ida_hexrays.minsn_t._print (method) - _print(self, shins_flags=0x04|0x02) - - Parameters - ---------- - shins_flags: int +ida_hexrays.minsn_t._own_and_register(self) -ida_hexrays.minsn_t._register (method) - _register(self) +ida_hexrays.minsn_t._print(self, *args) -> None -ida_hexrays.minsn_t.clr_assert (method) - clr_assert(self) +ida_hexrays.minsn_t._register(self) -> None -ida_hexrays.minsn_t.clr_combinable (method) - clr_combinable(self) +ida_hexrays.minsn_t.clr_assert(self) -> None -ida_hexrays.minsn_t.clr_combined (method) - clr_combined(self) +ida_hexrays.minsn_t.clr_combinable(self) -> None -ida_hexrays.minsn_t.clr_fpinsn (method) - clr_fpinsn(self) +ida_hexrays.minsn_t.clr_combined(self) -> None -ida_hexrays.minsn_t.clr_ignlowsrc (method) - clr_ignlowsrc(self) +ida_hexrays.minsn_t.clr_fpinsn(self) -> None -ida_hexrays.minsn_t.clr_multimov (method) - clr_multimov(self) +ida_hexrays.minsn_t.clr_ignlowsrc(self) -> None -ida_hexrays.minsn_t.clr_noret_icall (method) - clr_noret_icall(self) +ida_hexrays.minsn_t.clr_multimov(self) -> None -ida_hexrays.minsn_t.clr_propagatable (method) - clr_propagatable(self) +ida_hexrays.minsn_t.clr_noret_icall(self) -> None -ida_hexrays.minsn_t.clr_tailcall (method) - clr_tailcall(self) +ida_hexrays.minsn_t.clr_propagatable(self) -> None -ida_hexrays.minsn_t.contains_call (method) - contains_call(self, with_helpers=False) -> bool +ida_hexrays.minsn_t.clr_tailcall(self) -> None + +ida_hexrays.minsn_t.contains_call(self, with_helpers: bool = False) -> bool Does the instruction contain a call? - - @param with_helpers: (C++: bool) -ida_hexrays.minsn_t.contains_opcode (method) - contains_opcode(self, mcode) -> bool - Does the instruction have the specified opcode? This function searches - subinstructions as well. - - @param mcode: (C++: mcode_t) opcode to search for. +ida_hexrays.minsn_t.contains_opcode(self, mcode: "mcode_t") -> bool + Does the instruction have the specified opcode? This function searches subinstructions as well. + + @param mcode: opcode to search for. -ida_hexrays.minsn_t.d (variable) +ida_hexrays.minsn_t.d destination operand -ida_hexrays.minsn_t.deserialize (method) - deserialize(self, bytes, format_version) -> bool - Deserialize an instruction - - @param bytes: (C++: const uchar *) pointer to serialized data - @param format_version: (C++: int) serialization format version. this value is returned by - minsn_t::serialize() - @return: success +ida_hexrays.minsn_t.deserialize(self, bytes: "uchar const *", format_version: int) -> bool + Deserialize an instruction + + @param bytes: pointer to serialized data + @param format_version: serialization format version. this value is returned by minsn_t::serialize() + @returns success -ida_hexrays.minsn_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.minsn_t.dstr(self) -> str Get displayable text without tags in a static buffer. -ida_hexrays.minsn_t.ea (variable) +ida_hexrays.minsn_t.ea instruction address -ida_hexrays.minsn_t.equal_insns (method) - equal_insns(self, m, eqflags) -> bool - Compare instructions. This is the main comparison function for instructions. - - @param m: (C++: const minsn_t &) instruction to compare with - @param eqflags: (C++: int) combination of comparison bits bits +ida_hexrays.minsn_t.equal_insns(self, m: "minsn_t", eqflags: int) -> bool + Compare instructions. This is the main comparison function for instructions. + + @param m: instruction to compare with + @param eqflags: combination of comparison bits bits -ida_hexrays.minsn_t.find_call (method) - find_call(self, with_helpers=False) -> minsn_t - Find a call instruction. Check for the current instruction and its - subinstructions. - - @param with_helpers: (C++: bool) consider helper calls as well? +ida_hexrays.minsn_t.find_call(self, with_helpers: bool = False) -> "minsn_t *" + Find a call instruction. Check for the current instruction and its subinstructions. + + @param with_helpers: consider helper calls as well? -ida_hexrays.minsn_t.find_ins_op (method) - find_ins_op(self, op=m_nop) -> minsn_t - - @param op: enum mcode_t +ida_hexrays.minsn_t.find_ins_op(self, op: "mcode_t" = m_nop) -> "minsn_t *" + Find an operand that is a subinsruction with the specified opcode. This function checks only the 'l' and 'r' operands of the current insn. + + @param op: opcode to search for + @returns &l or &r or nullptr -ida_hexrays.minsn_t.find_num_op (method) - find_num_op(self) -> mop_t +ida_hexrays.minsn_t.find_num_op(self) -> "mop_t *" + Find a numeric operand of the current instruction. This function checks only the 'l' and 'r' operands of the current insn. + + @returns &l or &r or nullptr -ida_hexrays.minsn_t.find_opcode (method) - find_opcode(self, mcode) -> minsn_t - - @param mcode: enum mcode_t +ida_hexrays.minsn_t.find_opcode(self, mcode: "mcode_t") -> "minsn_t *" + Find a (sub)insruction with the specified opcode. + + @param mcode: opcode to search for. -ida_hexrays.minsn_t.for_all_insns (method) - for_all_insns(self, mv) -> int - Visit all instructions. This function visits the instruction itself and all its - subinstructions. - - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: non-zero value returned by mv.visit_mop() or zero +ida_hexrays.minsn_t.for_all_insns(self, mv: "minsn_visitor_t") -> int + Visit all instructions. This function visits the instruction itself and all its subinstructions. + + @param mv: instruction visitor + @returns non-zero value returned by mv.visit_mop() or zero -ida_hexrays.minsn_t.for_all_ops (method) - for_all_ops(self, mv) -> int - Visit all instruction operands. This function visits subinstruction operands as - well. - - @param mv: (C++: mop_visitor_t &) operand visitor - @return: non-zero value returned by mv.visit_mop() or zero +ida_hexrays.minsn_t.for_all_ops(self, mv: "mop_visitor_t") -> int + Visit all instruction operands. This function visits subinstruction operands as well. + + @param mv: operand visitor + @returns non-zero value returned by mv.visit_mop() or zero -ida_hexrays.minsn_t.get_role (method) - get_role(self) -> funcrole_t +ida_hexrays.minsn_t.get_role(self) -> "funcrole_t" Get the function role of a call. -ida_hexrays.minsn_t.get_split_size (method) - get_split_size(self) -> int +ida_hexrays.minsn_t.get_split_size(self) -> int -ida_hexrays.minsn_t.has_side_effects (method) - has_side_effects(self, include_ldx_and_divs=False) -> bool - Does the instruction have a side effect? - - @param include_ldx_and_divs: (C++: bool) consider ldx/div/mod as having side effects? stx is - always considered as having side effects. Apart - from ldx/std only call may have side effects. +ida_hexrays.minsn_t.has_side_effects(self, include_ldx_and_divs: bool = False) -> bool + Does the instruction have a side effect? + + @param include_ldx_and_divs: consider ldx/div/mod as having side effects? stx is always considered as having side effects. Apart from ldx/std only call may have side effects. -ida_hexrays.minsn_t.iprops (variable) +ida_hexrays.minsn_t.iprops combination of instruction property bits bits -ida_hexrays.minsn_t.is_after (method) - is_after(self, m) -> bool - Is the instruction after the specified one? - - @param m: (C++: const minsn_t *) the instruction to compare against in the list +ida_hexrays.minsn_t.is_after(self, m: "minsn_t") -> bool + Is the instruction after the specified one? + + @param m: the instruction to compare against in the list -ida_hexrays.minsn_t.is_alloca (method) - is_alloca(self) -> bool +ida_hexrays.minsn_t.is_alloca(self) -> bool -ida_hexrays.minsn_t.is_assert (method) - is_assert(self) -> bool +ida_hexrays.minsn_t.is_assert(self) -> bool -ida_hexrays.minsn_t.is_between (method) - is_between(self, m1, m2) -> bool - Is the instruction in the specified range of instructions? - - @param m1: (C++: const minsn_t *) beginning of the range in the doubly linked list - @param m2: (C++: const minsn_t *) end of the range in the doubly linked list (excluded, may be nullptr) - This function assumes that m1 and m2 belong to the same basic block - and they are top level instructions. +ida_hexrays.minsn_t.is_between(self, m1: "minsn_t", m2: "minsn_t") -> bool + Is the instruction in the specified range of instructions? + + @param m1: beginning of the range in the doubly linked list + @param m2: end of the range in the doubly linked list (excluded, may be nullptr) This function assumes that m1 and m2 belong to the same basic block and they are top level instructions. -ida_hexrays.minsn_t.is_bswap (method) - is_bswap(self) -> bool +ida_hexrays.minsn_t.is_bswap(self) -> bool -ida_hexrays.minsn_t.is_cleaning_pop (method) - is_cleaning_pop(self) -> bool +ida_hexrays.minsn_t.is_cleaning_pop(self) -> bool -ida_hexrays.minsn_t.is_combinable (method) - is_combinable(self) -> bool +ida_hexrays.minsn_t.is_combinable(self) -> bool -ida_hexrays.minsn_t.is_combined (method) - is_combined(self) -> bool +ida_hexrays.minsn_t.is_combined(self) -> bool -ida_hexrays.minsn_t.is_extstx (method) - is_extstx(self) -> bool +ida_hexrays.minsn_t.is_extstx(self) -> bool -ida_hexrays.minsn_t.is_farcall (method) - is_farcall(self) -> bool +ida_hexrays.minsn_t.is_farcall(self) -> bool -ida_hexrays.minsn_t.is_fpinsn (method) - is_fpinsn(self) -> bool +ida_hexrays.minsn_t.is_fpinsn(self) -> bool -ida_hexrays.minsn_t.is_helper (method) - is_helper(self, name) -> bool - Is a helper call with the specified name? Helper calls usually have well-known - function names (see Well known function names) but they may have any other name. - The decompiler does not assume any special meaning for non-well-known names. - - @param name: (C++: const char *) char const * +ida_hexrays.minsn_t.is_helper(self, name: str) -> bool + Is a helper call with the specified name? Helper calls usually have well-known function names (see Well known function names) but they may have any other name. The decompiler does not assume any special meaning for non-well-known names. + -ida_hexrays.minsn_t.is_ignlowsrc (method) - is_ignlowsrc(self) -> bool +ida_hexrays.minsn_t.is_ignlowsrc(self) -> bool -ida_hexrays.minsn_t.is_inverted_jx (method) - is_inverted_jx(self) -> bool +ida_hexrays.minsn_t.is_inverted_jx(self) -> bool -ida_hexrays.minsn_t.is_like_move (method) - is_like_move(self) -> bool +ida_hexrays.minsn_t.is_like_move(self) -> bool -ida_hexrays.minsn_t.is_mbarrier (method) - is_mbarrier(self) -> bool +ida_hexrays.minsn_t.is_mbarrier(self) -> bool -ida_hexrays.minsn_t.is_memcpy (method) - is_memcpy(self) -> bool +ida_hexrays.minsn_t.is_memcpy(self) -> bool -ida_hexrays.minsn_t.is_memset (method) - is_memset(self) -> bool +ida_hexrays.minsn_t.is_memset(self) -> bool -ida_hexrays.minsn_t.is_mov (method) - is_mov(self) -> bool +ida_hexrays.minsn_t.is_mov(self) -> bool -ida_hexrays.minsn_t.is_multimov (method) - is_multimov(self) -> bool +ida_hexrays.minsn_t.is_multimov(self) -> bool -ida_hexrays.minsn_t.is_noret_call (method) - is_noret_call(self, flags=0) -> bool - Is a non-returing call? - - @param flags: (C++: int) combination of NORET_... bits +ida_hexrays.minsn_t.is_noret_call(self, flags: int = 0) -> bool + Is a non-returing call? + + @param flags: combination of NORET_... bits -ida_hexrays.minsn_t.is_optional (method) - is_optional(self) -> bool +ida_hexrays.minsn_t.is_optional(self) -> bool -ida_hexrays.minsn_t.is_persistent (method) - is_persistent(self) -> bool +ida_hexrays.minsn_t.is_persistent(self) -> bool -ida_hexrays.minsn_t.is_propagatable (method) - is_propagatable(self) -> bool +ida_hexrays.minsn_t.is_propagatable(self) -> bool -ida_hexrays.minsn_t.is_readflags (method) - is_readflags(self) -> bool +ida_hexrays.minsn_t.is_readflags(self) -> bool -ida_hexrays.minsn_t.is_tailcall (method) - is_tailcall(self) -> bool +ida_hexrays.minsn_t.is_tailcall(self) -> bool -ida_hexrays.minsn_t.is_unknown_call (method) - is_unknown_call(self) -> bool - Is an unknown call? Unknown calls are calls without the argument list - (mcallinfo_t). Usually the argument lists are determined by - mba_t::analyze_calls(). Unknown calls exist until the MMAT_CALLS maturity level. - See also mblock_t::is_call_block +ida_hexrays.minsn_t.is_unknown_call(self) -> bool + Is an unknown call? Unknown calls are calls without the argument list (mcallinfo_t). Usually the argument lists are determined by mba_t::analyze_calls(). Unknown calls exist until the MMAT_CALLS maturity level. See also mblock_t::is_call_block + -ida_hexrays.minsn_t.is_wild_match (method) - is_wild_match(self) -> bool +ida_hexrays.minsn_t.is_wild_match(self) -> bool -ida_hexrays.minsn_t.l (variable) +ida_hexrays.minsn_t.l left operand -ida_hexrays.minsn_t.lexcompare (method) - lexcompare(self, ri) -> int - - @param ri: minsn_t const & +ida_hexrays.minsn_t.lexcompare(self, ri: "minsn_t") -> int -ida_hexrays.minsn_t.may_use_aliased_memory (method) - may_use_aliased_memory(self) -> bool +ida_hexrays.minsn_t.may_use_aliased_memory(self) -> bool Is it possible for the instruction to use aliased memory? -ida_hexrays.minsn_t.modifies_d (method) - modifies_d(self) -> bool - Does the instruction modify its 'd' operand? Some instructions (e.g. m_stx) do - not modify the 'd' operand. +ida_hexrays.minsn_t.modifies_d(self) -> bool + Does the instruction modify its 'd' operand? Some instructions (e.g. m_stx) do not modify the 'd' operand. + -ida_hexrays.minsn_t.modifies_pair_mop (method) - modifies_pair_mop(self) -> bool +ida_hexrays.minsn_t.modifies_pair_mop(self) -> bool -ida_hexrays.minsn_t.next (variable) +ida_hexrays.minsn_t.next next insn in doubly linked list. check also nexti() -ida_hexrays.minsn_t.opcode (variable) +ida_hexrays.minsn_t.opcode instruction opcode -ida_hexrays.minsn_t.optimize_solo (method) - optimize_solo(self, optflags=0) -> int - Optimize one instruction without context. This function does not have access to - the instruction context (the previous and next instructions in the list, the - block number, etc). It performs only basic optimizations that are available - without this info. - - @param optflags: (C++: int) combination of optimization flags bits - @return: number of changes, 0-unchanged See also mblock_t::optimize_insn() +ida_hexrays.minsn_t.optimize_solo(self, optflags: int = 0) -> int + Optimize one instruction without context. This function does not have access to the instruction context (the previous and next instructions in the list, the block number, etc). It performs only basic optimizations that are available without this info. + + @param optflags: combination of optimization flags bits + @returns number of changes, 0-unchanged See also mblock_t::optimize_insn() -ida_hexrays.minsn_t.optimize_subtree (method) - optimize_subtree(self, blk, top, parent, converted_call, optflags=0x0002) -> int - Optimize instruction in its context. Do not use this function, use - mblock_t::optimize() - - @param blk: (C++: mblock_t *) - @param top: (C++: minsn_t *) - @param parent: (C++: minsn_t *) - @param converted_call: (C++: ea_t *) - @param optflags: (C++: int) +ida_hexrays.minsn_t.optimize_subtree(self, blk: "mblock_t", top: "minsn_t", parent: "minsn_t", converted_call: "ea_t *", optflags: int = 2) -> int + Optimize instruction in its context. Do not use this function, use mblock_t::optimize() + -ida_hexrays.minsn_t.prev (variable) +ida_hexrays.minsn_t.prev prev insn in doubly linked list. check also previ() -ida_hexrays.minsn_t.r (variable) +ida_hexrays.minsn_t.r right operand -ida_hexrays.minsn_t.replace_by (method) +ida_hexrays.minsn_t.replace_by(self, o) -ida_hexrays.minsn_t.serialize (method) - serialize(self, b) -> int - Serialize an instruction +ida_hexrays.minsn_t.serialize(self, b: "bytevec_t *") -> int + Serialize an instruction + + @param b: the output buffer + @returns the serialization format that was used to store info + +ida_hexrays.minsn_t.set_assert(self) -> None + +ida_hexrays.minsn_t.set_cleaning_pop(self) -> None + +ida_hexrays.minsn_t.set_combinable(self) -> None + +ida_hexrays.minsn_t.set_extstx(self) -> None + +ida_hexrays.minsn_t.set_farcall(self) -> None + +ida_hexrays.minsn_t.set_fpinsn(self) -> None + +ida_hexrays.minsn_t.set_ignlowsrc(self) -> None + +ida_hexrays.minsn_t.set_inverted_jx(self) -> None + +ida_hexrays.minsn_t.set_mbarrier(self) -> None + +ida_hexrays.minsn_t.set_multimov(self) -> None + +ida_hexrays.minsn_t.set_noret_icall(self) -> None + +ida_hexrays.minsn_t.set_optional(self) -> None + +ida_hexrays.minsn_t.set_persistent(self) -> None + +ida_hexrays.minsn_t.set_split_size(self, s: int) -> None + +ida_hexrays.minsn_t.set_tailcall(self) -> None + +ida_hexrays.minsn_t.set_unmerged(self) -> None + +ida_hexrays.minsn_t.set_wild_match(self) -> None + +ida_hexrays.minsn_t.setaddr(self, new_ea: ida_idaapi.ea_t) -> None + Change the instruction address. This function modifies subinstructions as well. + + +ida_hexrays.minsn_t.swap(self, m: "minsn_t") -> None + Swap two instructions. The prev/next fields are not modified by this function because it would corrupt the doubly linked list. + + +ida_hexrays.minsn_t.was_noret_icall(self) -> bool + +ida_hexrays.minsn_t.was_split(self) -> bool + +ida_hexrays.minsn_t.was_unmerged(self) -> bool + +ida_hexrays.minsn_t.was_unpaired(self) -> bool + +ida_hexrays.minsn_visitor_t + +ida_hexrays.minsn_visitor_t.__disown__(self) + +ida_hexrays.minsn_visitor_t.__init__(self, _mba: "mba_t" = None, _blk: "mblock_t" = None, _topins: "minsn_t" = None) + +ida_hexrays.minsn_visitor_t.visit_minsn(self) -> int + +ida_hexrays.mlist_mop_visitor_t + +ida_hexrays.mlist_mop_visitor_t.__disown__(self) + +ida_hexrays.mlist_mop_visitor_t.__init__(self) + +ida_hexrays.mlist_mop_visitor_t.prune + Should skip sub-operands of the current operand? visit_mop() may set 'prune=true' for that. + + +ida_hexrays.mlist_mop_visitor_t.visit_mop(self, op: "mop_t") -> int + +ida_hexrays.mlist_t + +ida_hexrays.mlist_t.__eq__(self, r: "mlist_t") -> bool + +ida_hexrays.mlist_t.__ge__(self, r: "mlist_t") -> bool + +ida_hexrays.mlist_t.__gt__(self, r: "mlist_t") -> bool + +ida_hexrays.mlist_t.__init__(self, *args) + +ida_hexrays.mlist_t.__le__(self, r: "mlist_t") -> bool + +ida_hexrays.mlist_t.__lt__(self, r: "mlist_t") -> bool + +ida_hexrays.mlist_t.__ne__(self, r: "mlist_t") -> bool + +ida_hexrays.mlist_t._print(self) -> None + +ida_hexrays.mlist_t.add(self, *args) -> bool + This function has the following signatures: - @param b: (C++: bytevec_t *) the output buffer - @return: the serialization format that was used to store info - -ida_hexrays.minsn_t.set_assert (method) - set_assert(self) - -ida_hexrays.minsn_t.set_cleaning_pop (method) - set_cleaning_pop(self) - -ida_hexrays.minsn_t.set_combinable (method) - set_combinable(self) - -ida_hexrays.minsn_t.set_extstx (method) - set_extstx(self) - -ida_hexrays.minsn_t.set_farcall (method) - set_farcall(self) - -ida_hexrays.minsn_t.set_fpinsn (method) - set_fpinsn(self) - -ida_hexrays.minsn_t.set_ignlowsrc (method) - set_ignlowsrc(self) - -ida_hexrays.minsn_t.set_inverted_jx (method) - set_inverted_jx(self) - -ida_hexrays.minsn_t.set_mbarrier (method) - set_mbarrier(self) - -ida_hexrays.minsn_t.set_multimov (method) - set_multimov(self) - -ida_hexrays.minsn_t.set_noret_icall (method) - set_noret_icall(self) - -ida_hexrays.minsn_t.set_optional (method) - set_optional(self) - -ida_hexrays.minsn_t.set_persistent (method) - set_persistent(self) - -ida_hexrays.minsn_t.set_split_size (method) - set_split_size(self, s) + 0. add(r: mreg_t, size: int) -> bool + 1. add(r: const rlist_t &) -> bool + 2. add(ivl: const ivl_t &) -> bool + 3. add(lst: const mlist_t &) -> bool - @param s: int - -ida_hexrays.minsn_t.set_tailcall (method) - set_tailcall(self) - -ida_hexrays.minsn_t.set_unmerged (method) - set_unmerged(self) - -ida_hexrays.minsn_t.set_wild_match (method) - set_wild_match(self) - -ida_hexrays.minsn_t.setaddr (method) - setaddr(self, new_ea) - Change the instruction address. This function modifies subinstructions as well. + # 0: add(r: mreg_t, size: int) -> bool - @param new_ea: (C++: ea_t) - -ida_hexrays.minsn_t.swap (method) - swap(self, m) - Swap two instructions. The prev/next fields are not modified by this function - because it would corrupt the doubly linked list. - @param m: (C++: minsn_t &) - -ida_hexrays.minsn_t.was_noret_icall (method) - was_noret_icall(self) -> bool - -ida_hexrays.minsn_t.was_split (method) - was_split(self) -> bool - -ida_hexrays.minsn_t.was_unmerged (method) - was_unmerged(self) -> bool - -ida_hexrays.minsn_visitor_t (class) - Proxy of C++ minsn_visitor_t class. - -ida_hexrays.minsn_visitor_t.__disown__ (method) - -ida_hexrays.minsn_visitor_t.__init__ (method) - __init__(self, _mba=None, _blk=None, _topins=None) -> minsn_visitor_t + # 1: add(r: const rlist_t &) -> bool - @param _mba: mba_t * - @param _blk: mblock_t * - @param _topins: minsn_t * - -ida_hexrays.minsn_visitor_t.visit_minsn (method) - visit_minsn(self) -> int - -ida_hexrays.mlist_mop_visitor_t (class) - Proxy of C++ mlist_mop_visitor_t class. - -ida_hexrays.mlist_mop_visitor_t.__disown__ (method) - -ida_hexrays.mlist_mop_visitor_t.__init__ (method) - __init__(self) -> mlist_mop_visitor_t - @param self: PyObject * + # 2: add(ivl: const ivl_t &) -> bool + + + # 3: add(lst: const mlist_t &) -> bool -ida_hexrays.mlist_mop_visitor_t.visit_mop (method) - visit_mop(self, op) -> int - - @param op: mop_t * +ida_hexrays.mlist_t.addmem(self, ea: ida_idaapi.ea_t, size: "asize_t") -> bool -ida_hexrays.mlist_t (class) - Proxy of C++ mlist_t class. +ida_hexrays.mlist_t.clear(self) -> None -ida_hexrays.mlist_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: mlist_t const & +ida_hexrays.mlist_t.compare(self, r: "mlist_t") -> int -ida_hexrays.mlist_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: mlist_t const & +ida_hexrays.mlist_t.count(self) -> "asize_t" -ida_hexrays.mlist_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: mlist_t const & +ida_hexrays.mlist_t.dstr(self) -> str -ida_hexrays.mlist_t.__init__ (method) - __init__(self) -> mlist_t - __init__(self, ivl) -> mlist_t - - @param ivl: ivl_t const & - - __init__(self, r, size) -> mlist_t - - @param r: mreg_t - @param size: int +ida_hexrays.mlist_t.empty(self) -> bool -ida_hexrays.mlist_t.__le__ (method) - __le__(self, r) -> bool - - @param r: mlist_t const & +ida_hexrays.mlist_t.has(self, r: "mreg_t") -> bool -ida_hexrays.mlist_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: mlist_t const & +ida_hexrays.mlist_t.has_all(self, r: "mreg_t", size: int) -> bool -ida_hexrays.mlist_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: mlist_t const & +ida_hexrays.mlist_t.has_any(self, r: "mreg_t", size: int) -> bool -ida_hexrays.mlist_t._print (method) - _print(self) +ida_hexrays.mlist_t.has_common(self, lst: "mlist_t") -> bool -ida_hexrays.mlist_t.add (method) - add(self, r, size) -> bool - - @param r: mreg_t - @param size: int - - add(self, r) -> bool - - @param r: rlist_t const & - - add(self, ivl) -> bool - - @param ivl: ivl_t const & - - add(self, lst) -> bool - - @param lst: mlist_t const & +ida_hexrays.mlist_t.has_memory(self) -> bool -ida_hexrays.mlist_t.addmem (method) - addmem(self, ea, size) -> bool +ida_hexrays.mlist_t.includes(self, lst: "mlist_t") -> bool + +ida_hexrays.mlist_t.intersect(self, lst: "mlist_t") -> bool + +ida_hexrays.mlist_t.is_subset_of(self, lst: "mlist_t") -> bool + +ida_hexrays.mlist_t.sub(self, *args) -> bool + This function has the following signatures: - @param ea: ea_t - @param size: asize_t - -ida_hexrays.mlist_t.clear (method) - clear(self) - -ida_hexrays.mlist_t.compare (method) - compare(self, r) -> int + 0. sub(r: mreg_t, size: int) -> bool + 1. sub(ivl: const ivl_t &) -> bool + 2. sub(lst: const mlist_t &) -> bool - @param r: mlist_t const & - -ida_hexrays.mlist_t.count (method) - count(self) -> asize_t - -ida_hexrays.mlist_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.mlist_t.empty (method) - empty(self) -> bool - -ida_hexrays.mlist_t.has (method) - has(self, r) -> bool + # 0: sub(r: mreg_t, size: int) -> bool - @param r: mreg_t + + # 1: sub(ivl: const ivl_t &) -> bool + + + # 2: sub(lst: const mlist_t &) -> bool -ida_hexrays.mlist_t.has_all (method) - has_all(self, r, size) -> bool - - @param r: mreg_t - @param size: int +ida_hexrays.mlist_t.swap(self, r: "mlist_t") -> None -ida_hexrays.mlist_t.has_any (method) - has_any(self, r, size) -> bool - - @param r: mreg_t - @param size: int +ida_hexrays.mnumber_t -ida_hexrays.mlist_t.has_common (method) - has_common(self, lst) -> bool - - @param lst: mlist_t const & +ida_hexrays.mnumber_t.__eq__(self, r: "mnumber_t") -> bool -ida_hexrays.mlist_t.has_memory (method) - has_memory(self) -> bool +ida_hexrays.mnumber_t.__ge__(self, r: "mnumber_t") -> bool -ida_hexrays.mlist_t.includes (method) - includes(self, lst) -> bool - - @param lst: mlist_t const & +ida_hexrays.mnumber_t.__gt__(self, r: "mnumber_t") -> bool -ida_hexrays.mlist_t.intersect (method) - intersect(self, lst) -> bool - - @param lst: mlist_t const & +ida_hexrays.mnumber_t.__init__(self, *args) -ida_hexrays.mlist_t.is_subset_of (method) - is_subset_of(self, lst) -> bool - - @param lst: mlist_t const & +ida_hexrays.mnumber_t.__le__(self, r: "mnumber_t") -> bool -ida_hexrays.mlist_t.sub (method) - sub(self, r, size) -> bool - - @param r: mreg_t - @param size: int - - sub(self, ivl) -> bool - - @param ivl: ivl_t const & - - sub(self, lst) -> bool - - @param lst: mlist_t const & +ida_hexrays.mnumber_t.__lt__(self, r: "mnumber_t") -> bool -ida_hexrays.mlist_t.swap (method) - swap(self, r) - - @param r: mlist_t & +ida_hexrays.mnumber_t.__ne__(self, r: "mnumber_t") -> bool -ida_hexrays.mnumber_t (class) - Proxy of C++ mnumber_t class. +ida_hexrays.mnumber_t.compare(self, r: "mnumber_t") -> int -ida_hexrays.mnumber_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: mnumber_t const & +ida_hexrays.mnumber_t.update_value(self, val64: "uint64") -> None -ida_hexrays.mnumber_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: mnumber_t const & +ida_hexrays.modify_user_lvar_info(func_ea: ida_idaapi.ea_t, mli_flags: "uint", info: "lvar_saved_info_t") -> bool + Modify saved local variable settings of one variable. + + @param func_ea: function start address + @param mli_flags: bits that specify which attrs defined by INFO are to be set + @param info: local variable info attrs + @returns true if modified, false if invalid MLI_FLAGS passed -ida_hexrays.mnumber_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: mnumber_t const & +ida_hexrays.modify_user_lvars(entry_ea: ida_idaapi.ea_t, mlv: "user_lvar_modifier_t") -> bool + Modify saved local variable settings. + + @param entry_ea: function start address + @param mlv: local variable modifier + @returns true if modified variables -ida_hexrays.mnumber_t.__init__ (method) - __init__(self, v, _ea=BADADDR, n=0) -> mnumber_t - - @param v: uint64 - @param _ea: ea_t - @param n: int - -ida_hexrays.mnumber_t.__le__ (method) - __le__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.compare (method) - compare(self, r) -> int - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.update_value (method) - update_value(self, val64) - - @param val64: uint64 - -ida_hexrays.modify_user_lvar_info (function) - modify_user_lvar_info(func_ea, mli_flags, info) -> bool - Modify saved local variable settings of one variable. - - @param func_ea: (C++: ea_t) function start address - @param mli_flags: (C++: uint) bits that specify which attrs defined by INFO are to be set - @param info: (C++: const lvar_saved_info_t &) local variable info attrs - @return: true if modified, false if invalid MLI_FLAGS passed - -ida_hexrays.modify_user_lvars (function) - modify_user_lvars(entry_ea, mlv) -> bool - Modify saved local variable settings. - - @param entry_ea: (C++: ea_t) function start address - @param mlv: (C++: user_lvar_modifier_t &) local variable modifier - @return: true if modified variables - -ida_hexrays.mop_S (variable) +ida_hexrays.mop_S local stack variable (they exist until MMAT_LVARS) -ida_hexrays.mop_addr_t (class) - Proxy of C++ mop_addr_t class. +ida_hexrays.mop_a + mop_addr_t: address of operand (mop_l, mop_v, mop_S, mop_r) -ida_hexrays.mop_addr_t.__init__ (method) - __init__(self) -> mop_addr_t - __init__(self, ra) -> mop_addr_t - - @param ra: mop_addr_t const & - - __init__(self, ra, isz, osz) -> mop_addr_t - - @param ra: mop_t const & - @param isz: int - @param osz: int +ida_hexrays.mop_addr_t -ida_hexrays.mop_addr_t.lexcompare (method) - lexcompare(self, ra) -> int - - @param ra: mop_addr_t const & +ida_hexrays.mop_addr_t.__init__(self, *args) -ida_hexrays.mop_b (variable) +ida_hexrays.mop_addr_t.lexcompare(self, ra: "mop_addr_t") -> int + +ida_hexrays.mop_b micro basic block (mblock_t) -ida_hexrays.mop_c (variable) +ida_hexrays.mop_c mcases -ida_hexrays.mop_d (variable) +ida_hexrays.mop_d result of another instruction -ida_hexrays.mop_f (variable) +ida_hexrays.mop_f list of arguments -ida_hexrays.mop_fn (variable) +ida_hexrays.mop_fn floating point constant -ida_hexrays.mop_h (variable) +ida_hexrays.mop_h helper function -ida_hexrays.mop_l (variable) +ida_hexrays.mop_l local variable -ida_hexrays.mop_n (variable) +ida_hexrays.mop_n immediate number constant -ida_hexrays.mop_p (variable) +ida_hexrays.mop_p operand pair -ida_hexrays.mop_pair_t (class) - Proxy of C++ mop_pair_t class. +ida_hexrays.mop_pair_t -ida_hexrays.mop_pair_t.__init__ (method) - __init__(self) -> mop_pair_t +ida_hexrays.mop_pair_t.__init__(self) -ida_hexrays.mop_pair_t.hop (variable) +ida_hexrays.mop_pair_t.hop high operand -ida_hexrays.mop_pair_t.lop (variable) +ida_hexrays.mop_pair_t.lop low operand -ida_hexrays.mop_r (variable) +ida_hexrays.mop_r register (they exist until MMAT_LVARS) -ida_hexrays.mop_sc (variable) +ida_hexrays.mop_sc scattered -ida_hexrays.mop_str (variable) +ida_hexrays.mop_str immediate string constant (user representation) -ida_hexrays.mop_t (class) - Proxy of C++ mop_t class. +ida_hexrays.mop_t -ida_hexrays.mop_t.__dbg_get_meminfo (method) - __dbg_get_meminfo(self) -> qstring +ida_hexrays.mop_t.__dbg_get_meminfo(self) -> str -ida_hexrays.mop_t.__dbg_get_registered_kind (method) - __dbg_get_registered_kind(self) -> int +ida_hexrays.mop_t.__dbg_get_registered_kind(self) -> int -ida_hexrays.mop_t.__eq__ (method) - __eq__(self, rop) -> bool +ida_hexrays.mop_t.__eq__(self, rop: "mop_t") -> bool + +ida_hexrays.mop_t.__init__(self, *args) + +ida_hexrays.mop_t.__lt__(self, rop: "mop_t") -> bool + +ida_hexrays.mop_t.__ne__(self, rop: "mop_t") -> bool + +ida_hexrays.mop_t._acquire_ownership(self, v, acquire) + +ida_hexrays.mop_t._deregister(self) -> None + +ida_hexrays.mop_t._ensure_cond(self, ok, cond_str) + +ida_hexrays.mop_t._ensure_no_obj(self, o, attr, attr_is_acquired) + +ida_hexrays.mop_t._ensure_no_t(self) + +ida_hexrays.mop_t._ensure_ownership_transferrable(self, v) + +ida_hexrays.mop_t._get_a(self) -> "mop_addr_t *" + +ida_hexrays.mop_t._get_b(self) -> int + +ida_hexrays.mop_t._get_c(self) -> "mcases_t *" + +ida_hexrays.mop_t._get_cstr(self) -> str + +ida_hexrays.mop_t._get_d(self) -> "minsn_t *" + +ida_hexrays.mop_t._get_f(self) -> "mcallinfo_t *" + +ida_hexrays.mop_t._get_fpc(self) -> "fnumber_t *" + +ida_hexrays.mop_t._get_g(self) -> ida_idaapi.ea_t + +ida_hexrays.mop_t._get_helper(self) -> str + +ida_hexrays.mop_t._get_l(self) -> "lvar_ref_t *" + +ida_hexrays.mop_t._get_nnn(self) -> "mnumber_t *" + +ida_hexrays.mop_t._get_pair(self) -> "mop_pair_t *" + +ida_hexrays.mop_t._get_r(self) -> "mreg_t" + +ida_hexrays.mop_t._get_s(self) -> "stkvar_ref_t *" + +ida_hexrays.mop_t._get_scif(self) -> "scif_t *" + +ida_hexrays.mop_t._get_t(self) -> "mopt_t" + +ida_hexrays.mop_t._make_blkref(self, blknum: int) -> None + Create a block reference operand without erasing previous data. + + @param blknum: block number Note: this function does not erase the previous contents of the operand; call erase() if necessary + +ida_hexrays.mop_t._make_callinfo(self, fi: "mcallinfo_t") -> None + Create a call info operand without erasing previous data. + + @param fi: callinfo Note: this function does not erase the previous contents of the operand; call erase() if necessary + +ida_hexrays.mop_t._make_cases(self, _cases: "mcases_t") -> None + Create a 'switch cases' operand without erasing previous data. Note: this function does not erase the previous contents of the operand; call erase() if necessary + + +ida_hexrays.mop_t._make_gvar(self, ea: ida_idaapi.ea_t) -> None + Create a global variable operand without erasing previous data. + + @param ea: address of the variable Note: this function does not erase the previous contents of the operand; call erase() if necessary + +ida_hexrays.mop_t._make_insn(self, ins: "minsn_t") -> None + Create a nested instruction without erasing previous data. + + @param ins: pointer to the instruction to encapsulate into the operand Note: this function does not erase the previous contents of the operand; call erase() if necessary See also create_from_insn, which is higher level + +ida_hexrays.mop_t._make_lvar(self, mba: "mba_t", idx: int, off: int = 0) -> None + Create a local variable operand. + + @param mba: pointer to microcode + @param idx: index into mba->vars + @param off: offset from the beginning of the variable Note: this function does not erase the previous contents of the operand; call erase() if necessary + +ida_hexrays.mop_t._make_pair(self, _pair: "mop_pair_t") -> None + Create a pair operand without erasing previous data. Note: this function does not erase the previous contents of the operand; call erase() if necessary + + +ida_hexrays.mop_t._make_reg(self, *args) -> None + This function has the following signatures: - @param rop: mop_t const & - -ida_hexrays.mop_t.__init__ (method) - __init__(self) -> mop_t - __init__(self, rop) -> mop_t + 0. _make_reg(reg: mreg_t) -> None + 1. _make_reg(reg: mreg_t, _size: int) -> None - @param rop: mop_t const & + # 0: _make_reg(reg: mreg_t) -> None - __init__(self, _r, _s) -> mop_t + Create a register operand without erasing previous data. + - @param _r: mreg_t - @param _s: int + # 1: _make_reg(reg: mreg_t, _size: int) -> None -ida_hexrays.mop_t.__lt__ (method) - __lt__(self, rop) -> bool - - @param rop: mop_t const & +ida_hexrays.mop_t._make_stkvar(self, mba: "mba_t", off: int) -> None + Create a stack variable operand. + + @param mba: pointer to microcode + @param off: decompiler stkoff Note: this function does not erase the previous contents of the operand; call erase() if necessary -ida_hexrays.mop_t.__ne__ (method) - __ne__(self, rop) -> bool - - @param rop: mop_t const & +ida_hexrays.mop_t._make_strlit(self, str: str) -> None + Create a constant string operand. -ida_hexrays.mop_t._acquire_ownership (method) +ida_hexrays.mop_t._maybe_disown_and_deregister(self) -ida_hexrays.mop_t._deregister (method) - _deregister(self) +ida_hexrays.mop_t._meminfo(self) -ida_hexrays.mop_t._ensure_cond (method) +ida_hexrays.mop_t._obj_id(self) -> "PyObject *" -ida_hexrays.mop_t._ensure_no_obj (method) +ida_hexrays.mop_t._own_and_register(self) -ida_hexrays.mop_t._ensure_no_t (method) +ida_hexrays.mop_t._print(self, *args) -> None -ida_hexrays.mop_t._ensure_ownership_transferrable (method) +ida_hexrays.mop_t._register(self) -> None -ida_hexrays.mop_t._get_a (method) - _get_a(self) -> mop_addr_t +ida_hexrays.mop_t._set_a(self, _v: "mop_addr_t") -> None -ida_hexrays.mop_t._get_b (method) - _get_b(self) -> int - -ida_hexrays.mop_t._get_c (method) - _get_c(self) -> mcases_t - -ida_hexrays.mop_t._get_cstr (method) - _get_cstr(self) -> char const * - -ida_hexrays.mop_t._get_d (method) - _get_d(self) -> minsn_t - -ida_hexrays.mop_t._get_f (method) - _get_f(self) -> mcallinfo_t - -ida_hexrays.mop_t._get_fpc (method) - _get_fpc(self) -> fnumber_t - -ida_hexrays.mop_t._get_g (method) - _get_g(self) -> ea_t - -ida_hexrays.mop_t._get_helper (method) - _get_helper(self) -> char const * - -ida_hexrays.mop_t._get_l (method) - _get_l(self) -> lvar_ref_t - -ida_hexrays.mop_t._get_nnn (method) - _get_nnn(self) -> mnumber_t - -ida_hexrays.mop_t._get_pair (method) - _get_pair(self) -> mop_pair_t - -ida_hexrays.mop_t._get_r (method) - _get_r(self) -> mreg_t - -ida_hexrays.mop_t._get_s (method) - _get_s(self) -> stkvar_ref_t - -ida_hexrays.mop_t._get_scif (method) - _get_scif(self) -> scif_t - -ida_hexrays.mop_t._get_t (method) - _get_t(self) -> mopt_t - -ida_hexrays.mop_t._make_blkref (method) - _make_blkref(self, blknum) - - Parameters - ---------- - blknum: int - -ida_hexrays.mop_t._make_callinfo (method) - _make_callinfo(self, fi) - - Parameters - ---------- - fi: mcallinfo_t * - -ida_hexrays.mop_t._make_cases (method) - _make_cases(self, _cases) - - Parameters - ---------- - _cases: mcases_t * - -ida_hexrays.mop_t._make_gvar (method) - _make_gvar(self, ea) - - Parameters - ---------- - ea: ea_t - -ida_hexrays.mop_t._make_insn (method) - _make_insn(self, ins) - - Parameters - ---------- - ins: minsn_t * - -ida_hexrays.mop_t._make_lvar (method) - _make_lvar(self, mba, idx, off=0) - - Parameters - ---------- - mba: mba_t * - idx: int - off: sval_t - -ida_hexrays.mop_t._make_pair (method) - _make_pair(self, _pair) - - Parameters - ---------- - _pair: mop_pair_t * - -ida_hexrays.mop_t._make_reg (method) - _make_reg(self, reg) - - Parameters - ---------- - reg: mreg_t - - _make_reg(self, reg, _size) - - Parameters - ---------- - reg: mreg_t - _size: int - -ida_hexrays.mop_t._make_stkvar (method) - _make_stkvar(self, mba, off) - - Parameters - ---------- - mba: mba_t * - off: sval_t - -ida_hexrays.mop_t._make_strlit (method) - _make_strlit(self, str) - - Parameters - ---------- - str: char const * - -ida_hexrays.mop_t._maybe_disown_and_deregister (method) - -ida_hexrays.mop_t._meminfo (method) - -ida_hexrays.mop_t._obj_id (method) - _obj_id(self) -> PyObject * - -ida_hexrays.mop_t._own_and_register (method) - -ida_hexrays.mop_t._print (method) - _print(self, shins_flags=0x04|0x02) - - Parameters - ---------- - shins_flags: int - -ida_hexrays.mop_t._register (method) - _register(self) - -ida_hexrays.mop_t._set_a (method) - _set_a(self, _v) - - Parameters - ---------- - _v: mop_addr_t * - -ida_hexrays.mop_t._set_b (method) - _set_b(self, _v) - - Parameters - ---------- - _v: int - -ida_hexrays.mop_t._set_c (method) - _set_c(self, _v) - - Parameters - ---------- - _v: mcases_t * - -ida_hexrays.mop_t._set_cstr (method) - _set_cstr(self, _v) - - Parameters - ---------- - _v: char const * - -ida_hexrays.mop_t._set_d (method) - _set_d(self, _v) - - Parameters - ---------- - _v: minsn_t * - -ida_hexrays.mop_t._set_f (method) - _set_f(self, _v) - - Parameters - ---------- - _v: mcallinfo_t * - -ida_hexrays.mop_t._set_fpc (method) - _set_fpc(self, _v) - - Parameters - ---------- - _v: fnumber_t * - -ida_hexrays.mop_t._set_g (method) - _set_g(self, _v) - - Parameters - ---------- - _v: ea_t - -ida_hexrays.mop_t._set_helper (method) - _set_helper(self, _v) - - Parameters - ---------- - _v: char const * - -ida_hexrays.mop_t._set_l (method) - _set_l(self, _v) - - Parameters - ---------- - _v: lvar_ref_t * - -ida_hexrays.mop_t._set_nnn (method) - _set_nnn(self, _v) - - Parameters - ---------- - _v: mnumber_t * - -ida_hexrays.mop_t._set_pair (method) - _set_pair(self, _v) - - Parameters - ---------- - _v: mop_pair_t * - -ida_hexrays.mop_t._set_r (method) - _set_r(self, _v) - - Parameters - ---------- - _v: mreg_t - -ida_hexrays.mop_t._set_s (method) - _set_s(self, _v) - - Parameters - ---------- - _v: stkvar_ref_t * - -ida_hexrays.mop_t._set_scif (method) - _set_scif(self, _v) - - Parameters - ---------- - _v: scif_t * - -ida_hexrays.mop_t._set_t (method) - _set_t(self, v) - - Parameters - ---------- - v: mopt_t - -ida_hexrays.mop_t.apply_ld_mcode (method) - apply_ld_mcode(self, mcode, ea, newsize) - Apply a unary opcode to the operand. - - @param mcode: (C++: mcode_t) opcode to apply. it must accept 'l' and 'd' operands but not 'r'. - @param ea: (C++: ea_t) value of minsn_t::ea for the newly created insruction - @param newsize: (C++: int) new operand size Example: apply_ld_mcode(m_low) will convert op - => low(op) - -ida_hexrays.mop_t.apply_xds (method) - apply_xds(self, ea, newsize) - - @param ea: ea_t - @param newsize: int - -ida_hexrays.mop_t.apply_xdu (method) - apply_xdu(self, ea, newsize) - - @param ea: ea_t - @param newsize: int - -ida_hexrays.mop_t.assign (method) - assign(self, rop) -> mop_t - - @param rop: mop_t const & - -ida_hexrays.mop_t.change_size (method) - change_size(self, nsize, sideff=WITH_SIDEFF) -> bool - Change the operand size. Examples: change_size(AL.1, 2) -> AX.2 - change_size(qword_00000008.8, 4) -> dword_00000008.4 change_size(xdu.8(op.4), 4) - -> op.4 change_size(#0x12345678.4, 1) -> #0x78.1 - - @param nsize: (C++: int) new operand size - @param sideff: (C++: side_effect_t) may modify the database because of the size change? - @return: success - -ida_hexrays.mop_t.create_from_insn (method) - create_from_insn(self, m) - Create operand from an instruction. This function creates a nested instruction - that can be used as an operand. Example: if m="add x,y,z", our operand will be - (t=mop_d,d=m). The destination operand of 'add' (z) is lost. - - @param m: (C++: const minsn_t *) instruction to embed into operand. may not be nullptr. - -ida_hexrays.mop_t.create_from_ivlset (method) - create_from_ivlset(self, mba, ivs, fullsize) -> bool - Create operand from ivlset_t. Example: if IVS contains [glbvar..glbvar+4), our - operand will be (t=mop_v, g=&glbvar, size=4) - - @param mba: (C++: mba_t *) pointer to microcode - @param ivs: (C++: const ivlset_t &) set of memory intervals - @param fullsize: (C++: sval_t) mba->fullsize - @return: success - -ida_hexrays.mop_t.create_from_mlist (method) - create_from_mlist(self, mba, lst, fullsize) -> bool - Create operand from mlist_t. Example: if LST contains 4 bits for R0.4, our - operand will be (t=mop_r, r=R0, size=4) - - @param mba: (C++: mba_t *) pointer to microcode - @param lst: (C++: const mlist_t &) list of locations - @param fullsize: (C++: sval_t) mba->fullsize - @return: success - -ida_hexrays.mop_t.create_from_scattered_vdloc (method) - create_from_scattered_vdloc(self, mba, name, type, loc) - Create operand from scattered vdloc_t. Example: if LOC is (ALOC_DIST, {EAX.4, - EDX.4}) and TYPE is _LARGE_INTEGER, our operand will be (t=mop_sc, scif={EAX.4, - EDX.4}) - - @param mba: (C++: mba_t *) pointer to microcode - @param name: (C++: const char *) name of the operand, if available - @param type: (C++: tinfo_t) type of the operand, must be present - @param loc: (C++: const vdloc_t &) a scattered location - @return: success - -ida_hexrays.mop_t.create_from_vdloc (method) - create_from_vdloc(self, mba, loc, _size) - Create operand from vdloc_t. Example: if LOC contains (type=ALOC_REG1, r=R0), - our operand will be (t=mop_r, r=R0, size=_SIZE) - - @param mba: (C++: mba_t *) pointer to microcode - @param loc: (C++: const vdloc_t &) location - @param _size: (C++: int) operand size Note: this function cannot handle scattered - locations. - @return: success - -ida_hexrays.mop_t.double_size (method) - double_size(self, sideff=WITH_SIDEFF) -> bool - - @param sideff: enum side_effect_t - -ida_hexrays.mop_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.mop_t.empty (method) - empty(self) -> bool - -ida_hexrays.mop_t.equal_mops (method) - equal_mops(self, rop, eqflags) -> bool - Compare operands. This is the main comparison function for operands. - - @param rop: (C++: const mop_t &) operand to compare with - @param eqflags: (C++: int) combination of comparison bits bits - -ida_hexrays.mop_t.erase (method) - erase(self) - -ida_hexrays.mop_t.erase_but_keep_size (method) - erase_but_keep_size(self) - -ida_hexrays.mop_t.for_all_ops (method) - for_all_ops(self, mv, type=None, is_target=False) -> int - Visit the operand and all its sub-operands. This function visits the current - operand as well. - - @param mv: (C++: mop_visitor_t &) visitor object - @param type: (C++: const tinfo_t *) operand type - @param is_target: (C++: bool) is a destination operand? - -ida_hexrays.mop_t.for_all_scattered_submops (method) - for_all_scattered_submops(self, sv) -> int - Visit all sub-operands of a scattered operand. This function does not visit the - current operand, only its sub-operands. All sub-operands are synthetic and are - destroyed after the visitor. This function works only with scattered operands. - - @param sv: (C++: scif_visitor_t &) visitor object - -ida_hexrays.mop_t.get_insn (method) - get_insn(self, code) -> minsn_t - - @param code: enum mcode_t - -ida_hexrays.mop_t.get_stkoff (method) - get_stkoff(self, p_off) -> bool - Get the referenced stack offset. This function can also handle mop_sc if it is - entirely mapped into a continuous stack region. - - @param p_off: (C++: sval_t *) the output buffer - @return: success - -ida_hexrays.mop_t.get_stkvar (method) - get_stkvar(self, p_off) -> member_t * - Retrieve the referenced stack variable. - - @param p_off: (C++: uval_t *) if specified, will hold IDA stkoff after the call. - @return: pointer to the stack variable - -ida_hexrays.mop_t.has_side_effects (method) - has_side_effects(self, include_ldx_and_divs=False) -> bool - Has any side effects? - - @param include_ldx_and_divs: (C++: bool) consider ldx/div/mod as having side effects? - -ida_hexrays.mop_t.is01 (method) - is01(self) -> bool - Are the possible values of the operand only 0 and 1? This function returns true - for 0/1 constants, bit registers, the result of 'set' insns, etc. - -ida_hexrays.mop_t.is_arglist (method) - is_arglist(self) -> bool +ida_hexrays.mop_t._set_b(self, _v: int) -> None + +ida_hexrays.mop_t._set_c(self, _v: "mcases_t") -> None + +ida_hexrays.mop_t._set_cstr(self, _v: str) -> None + +ida_hexrays.mop_t._set_d(self, _v: "minsn_t") -> None + +ida_hexrays.mop_t._set_f(self, _v: "mcallinfo_t") -> None + +ida_hexrays.mop_t._set_fpc(self, _v: "fnumber_t") -> None + +ida_hexrays.mop_t._set_g(self, _v: ida_idaapi.ea_t) -> None + +ida_hexrays.mop_t._set_helper(self, _v: str) -> None + +ida_hexrays.mop_t._set_l(self, _v: "lvar_ref_t") -> None + +ida_hexrays.mop_t._set_nnn(self, _v: "mnumber_t") -> None + +ida_hexrays.mop_t._set_pair(self, _v: "mop_pair_t") -> None + +ida_hexrays.mop_t._set_r(self, _v: "mreg_t") -> None + +ida_hexrays.mop_t._set_s(self, _v: "stkvar_ref_t") -> None + +ida_hexrays.mop_t._set_scif(self, _v: "scif_t") -> None + +ida_hexrays.mop_t._set_t(self, v: "mopt_t") -> None + +ida_hexrays.mop_t.apply_ld_mcode(self, mcode: "mcode_t", ea: ida_idaapi.ea_t, newsize: int) -> None + Apply a unary opcode to the operand. + + @param mcode: opcode to apply. it must accept 'l' and 'd' operands but not 'r'. examples: m_low/m_high/m_xds/m_xdu + @param ea: value of minsn_t::ea for the newly created insruction + @param newsize: new operand size Example: apply_ld_mcode(m_low) will convert op => low(op) + +ida_hexrays.mop_t.apply_xds(self, ea: ida_idaapi.ea_t, newsize: int) -> None + +ida_hexrays.mop_t.apply_xdu(self, ea: ida_idaapi.ea_t, newsize: int) -> None + +ida_hexrays.mop_t.assign(self, rop: "mop_t") -> "mop_t &" + +ida_hexrays.mop_t.change_size(self, nsize: int, sideff: "side_effect_t" = WITH_SIDEFF) -> bool + Change the operand size. Examples: change_size(AL.1, 2) -> AX.2 change_size(qword_00000008.8, 4) -> dword_00000008.4 change_size(xdu.8(op.4), 4) -> op.4 change_size(#0x12345678.4, 1) -> #0x78.1 + + @param nsize: new operand size + @param sideff: may modify the database because of the size change? + @returns success + +ida_hexrays.mop_t.create_from_insn(self, m: "minsn_t") -> None + Create operand from an instruction. This function creates a nested instruction that can be used as an operand. Example: if m="add x,y,z", our operand will be (t=mop_d,d=m). The destination operand of 'add' (z) is lost. + + @param m: instruction to embed into operand. may not be nullptr. + +ida_hexrays.mop_t.create_from_ivlset(self, mba: "mba_t", ivs: "ivlset_t", fullsize: int) -> bool + Create operand from ivlset_t. Example: if IVS contains [glbvar..glbvar+4), our operand will be (t=mop_v, g=&glbvar, size=4) + + @param mba: pointer to microcode + @param ivs: set of memory intervals + @param fullsize: mba->fullsize + @returns success + +ida_hexrays.mop_t.create_from_mlist(self, mba: "mba_t", lst: "mlist_t", fullsize: int) -> bool + Create operand from mlist_t. Example: if LST contains 4 bits for R0.4, our operand will be (t=mop_r, r=R0, size=4) + + @param mba: pointer to microcode + @param lst: list of locations + @param fullsize: mba->fullsize + @returns success + +ida_hexrays.mop_t.create_from_scattered_vdloc(self, mba: "mba_t", name: str, type: "tinfo_t", loc: "vdloc_t") -> None + Create operand from scattered vdloc_t. Example: if LOC is (ALOC_DIST, {EAX.4, EDX.4}) and TYPE is _LARGE_INTEGER, our operand will be (t=mop_sc, scif={EAX.4, EDX.4}) + + @param mba: pointer to microcode + @param name: name of the operand, if available + @param type: type of the operand, must be present + @param loc: a scattered location + @returns success + +ida_hexrays.mop_t.create_from_vdloc(self, mba: "mba_t", loc: "vdloc_t", _size: int) -> None + Create operand from vdloc_t. Example: if LOC contains (type=ALOC_REG1, r=R0), our operand will be (t=mop_r, r=R0, size=_SIZE) + + @param mba: pointer to microcode + @param loc: location + @param _size: operand size Note: this function cannot handle scattered locations. + @returns success + +ida_hexrays.mop_t.double_size(self, sideff: "side_effect_t" = WITH_SIDEFF) -> bool + +ida_hexrays.mop_t.dstr(self) -> str + +ida_hexrays.mop_t.empty(self) -> bool + +ida_hexrays.mop_t.equal_mops(self, rop: "mop_t", eqflags: int) -> bool + Compare operands. This is the main comparison function for operands. + + @param rop: operand to compare with + @param eqflags: combination of comparison bits bits + +ida_hexrays.mop_t.erase(self) -> None + +ida_hexrays.mop_t.erase_but_keep_size(self) -> None + +ida_hexrays.mop_t.for_all_ops(self, mv: "mop_visitor_t", type: "tinfo_t" = None, is_target: bool = False) -> int + Visit the operand and all its sub-operands. This function visits the current operand as well. + + @param mv: visitor object + @param type: operand type + @param is_target: is a destination operand? + +ida_hexrays.mop_t.for_all_scattered_submops(self, sv: "scif_visitor_t") -> int + Visit all sub-operands of a scattered operand. This function does not visit the current operand, only its sub-operands. All sub-operands are synthetic and are destroyed after the visitor. This function works only with scattered operands. + + @param sv: visitor object + +ida_hexrays.mop_t.get_insn(self, code: "mcode_t") -> "minsn_t *" + Get subinstruction of the operand. If the operand has a subinstruction with the specified opcode, return it. + + @param code: desired opcode + @returns pointer to the instruction or nullptr + +ida_hexrays.mop_t.get_stkoff(self, p_vdoff: "sval_t *") -> bool + Get the referenced stack offset. This function can also handle mop_sc if it is entirely mapped into a continuous stack region. + + @param p_vdoff: the output buffer + @returns success + +ida_hexrays.mop_t.get_stkvar(self, udm: "udm_t" = None, p_idaoff: "uval_t *" = None) -> "ssize_t" + Retrieve the referenced stack variable. + + @param udm: stkvar, may be nullptr + @param p_idaoff: if specified, will hold IDA stkoff after the call. + @returns index of stkvar in the frame or -1 + +ida_hexrays.mop_t.has_side_effects(self, include_ldx_and_divs: bool = False) -> bool + Has any side effects? + + @param include_ldx_and_divs: consider ldx/div/mod as having side effects? + +ida_hexrays.mop_t.is01(self) -> bool + Are the possible values of the operand only 0 and 1? This function returns true for 0/1 constants, bit registers, the result of 'set' insns, etc. + + +ida_hexrays.mop_t.is_arglist(self) -> bool Is a list of arguments? -ida_hexrays.mop_t.is_bit_reg (method) - is_bit_reg(self, reg) -> bool - Is a bit register? This includes condition codes and eventually other bit - registers +ida_hexrays.mop_t.is_bit_reg(self, *args) -> bool + This function has the following signatures: - @param reg: (C++: mreg_t) + 0. is_bit_reg() -> bool + 1. is_bit_reg(reg: mreg_t) -> bool - is_bit_reg(self) -> bool + # 0: is_bit_reg() -> bool + + + # 1: is_bit_reg(reg: mreg_t) -> bool + + Is a bit register? This includes condition codes and eventually other bit registers + -ida_hexrays.mop_t.is_cc (method) - is_cc(self) -> bool +ida_hexrays.mop_t.is_cc(self) -> bool Is a condition code? -ida_hexrays.mop_t.is_ccflags (method) - is_ccflags(self) -> bool +ida_hexrays.mop_t.is_ccflags(self) -> bool -ida_hexrays.mop_t.is_constant (method) - is_constant(self, is_signed=True) -> bool - Retrieve value of a constant integer operand. - - @param is_signed: (C++: bool) should treat the value as signed - @return: true if the operand is mop_n +ida_hexrays.mop_t.is_constant(self, is_signed: bool = True) -> bool + Retrieve value of a constant integer operand. + + @param is_signed: should treat the value as signed + @returns true if the operand is mop_n -ida_hexrays.mop_t.is_equal_to (method) - is_equal_to(self, n, is_signed=True) -> bool - - @param n: uint64 - @param is_signed: bool +ida_hexrays.mop_t.is_equal_to(self, n: "uint64", is_signed: bool = True) -> bool -ida_hexrays.mop_t.is_extended_from (method) - is_extended_from(self, nbytes, is_signed) -> bool +ida_hexrays.mop_t.is_extended_from(self, nbytes: int, is_signed: bool) -> bool Does the high part of the operand consist of zero or sign bytes? - - @param nbytes: (C++: int) - @param is_signed: (C++: bool) -ida_hexrays.mop_t.is_glbaddr (method) - is_glbaddr(self) -> bool +ida_hexrays.mop_t.is_glbaddr(self, *args) -> bool + This function has the following signatures: + + 0. is_glbaddr() -> bool + 1. is_glbaddr(ea: ida_idaapi.ea_t) -> bool + + # 0: is_glbaddr() -> bool + + Is address of a global memory cell? + + + # 1: is_glbaddr(ea: ida_idaapi.ea_t) -> bool + Is address of the specified global memory cell? - is_glbaddr(self, ea) -> bool + +ida_hexrays.mop_t.is_glbaddr_from_fixup(self) -> bool + +ida_hexrays.mop_t.is_impptr_done(self) -> bool + +ida_hexrays.mop_t.is_insn(self, *args) -> bool + This function has the following signatures: + + 0. is_insn() -> bool + 1. is_insn(code: mcode_t) -> bool + + # 0: is_insn() -> bool + + Is a sub-instruction? + + + # 1: is_insn(code: mcode_t) -> bool - @param ea: ea_t - -ida_hexrays.mop_t.is_glbaddr_from_fixup (method) - is_glbaddr_from_fixup(self) -> bool - -ida_hexrays.mop_t.is_impptr_done (method) - is_impptr_done(self) -> bool - -ida_hexrays.mop_t.is_insn (method) - is_insn(self) -> bool Is a sub-instruction with the specified opcode? - is_insn(self, code) -> bool - - @param code: enum mcode_t -ida_hexrays.mop_t.is_kreg (method) - is_kreg(self) -> bool +ida_hexrays.mop_t.is_kreg(self) -> bool Is a kernel register? -ida_hexrays.mop_t.is_lowaddr (method) - is_lowaddr(self) -> bool +ida_hexrays.mop_t.is_lowaddr(self) -> bool -ida_hexrays.mop_t.is_mob (method) - is_mob(self, serial) -> bool +ida_hexrays.mop_t.is_mob(self, serial: int) -> bool Is a block reference to the specified block? + +ida_hexrays.mop_t.is_negative_constant(self) -> bool + +ida_hexrays.mop_t.is_one(self) -> bool + +ida_hexrays.mop_t.is_pcval(self) -> bool + +ida_hexrays.mop_t.is_positive_constant(self) -> bool + +ida_hexrays.mop_t.is_reg(self, *args) -> bool + This function has the following signatures: + + 0. is_reg() -> bool + 1. is_reg(_r: mreg_t) -> bool + 2. is_reg(_r: mreg_t, _size: int) -> bool + + # 0: is_reg() -> bool + + Is a register operand? See also get_mreg_name() + + + # 1: is_reg(_r: mreg_t) -> bool + + Is the specified register? + + + # 2: is_reg(_r: mreg_t, _size: int) -> bool - @param serial: (C++: int) - -ida_hexrays.mop_t.is_negative_constant (method) - is_negative_constant(self) -> bool - -ida_hexrays.mop_t.is_one (method) - is_one(self) -> bool - -ida_hexrays.mop_t.is_pcval (method) - is_pcval(self) -> bool - -ida_hexrays.mop_t.is_positive_constant (method) - is_positive_constant(self) -> bool - -ida_hexrays.mop_t.is_reg (method) - is_reg(self) -> bool Is the specified register of the specified size? - is_reg(self, _r) -> bool - - @param _r: mreg_t - - is_reg(self, _r, _size) -> bool - - @param _r: mreg_t - @param _size: int -ida_hexrays.mop_t.is_scattered (method) - is_scattered(self) -> bool +ida_hexrays.mop_t.is_scattered(self) -> bool Is a scattered operand? -ida_hexrays.mop_t.is_sign_extended_from (method) - is_sign_extended_from(self, nbytes) -> bool - Does the high part of the operand consist of the sign bytes? - - @param nbytes: (C++: int) number of bytes that were sign extended. the remaining size- - nbytes high bytes must be sign bytes Example: - is_sign_extended_from(xds.4(op.1), 1) -> true because the high 3 - bytes are certainly sign bits +ida_hexrays.mop_t.is_sign_extended_from(self, nbytes: int) -> bool + Does the high part of the operand consist of the sign bytes? + + @param nbytes: number of bytes that were sign extended. the remaining size-nbytes high bytes must be sign bytes Example: is_sign_extended_from(xds.4(op.1), 1) -> true because the high 3 bytes are certainly sign bits -ida_hexrays.mop_t.is_stkaddr (method) - is_stkaddr(self) -> bool +ida_hexrays.mop_t.is_stkaddr(self) -> bool Is address of a stack variable? -ida_hexrays.mop_t.is_udt (method) - is_udt(self) -> bool +ida_hexrays.mop_t.is_udt(self) -> bool -ida_hexrays.mop_t.is_undef_val (method) - is_undef_val(self) -> bool +ida_hexrays.mop_t.is_undef_val(self) -> bool -ida_hexrays.mop_t.is_zero (method) - is_zero(self) -> bool +ida_hexrays.mop_t.is_zero(self) -> bool -ida_hexrays.mop_t.is_zero_extended_from (method) - is_zero_extended_from(self, nbytes) -> bool - Does the high part of the operand consist of zero bytes? - - @param nbytes: (C++: int) number of bytes that were zero extended. the remaining size- - nbytes high bytes must be zero Example: - is_zero_extended_from(xdu.8(op.1), 2) -> true because the high 6 - bytes are certainly zero +ida_hexrays.mop_t.is_zero_extended_from(self, nbytes: int) -> bool + Does the high part of the operand consist of zero bytes? + + @param nbytes: number of bytes that were zero extended. the remaining size-nbytes high bytes must be zero Example: is_zero_extended_from(xdu.8(op.1), 2) -> true because the high 6 bytes are certainly zero -ida_hexrays.mop_t.lexcompare (method) - lexcompare(self, rop) -> int - - @param rop: mop_t const & +ida_hexrays.mop_t.lexcompare(self, rop: "mop_t") -> int -ida_hexrays.mop_t.make_blkref (method) - make_blkref(self, blknum) +ida_hexrays.mop_t.make_blkref(self, blknum: int) -> None Create a global variable operand. - - @param blknum: (C++: int) -ida_hexrays.mop_t.make_first_half (method) - make_first_half(self, width) -> bool - Make the first part of the operand. This function does not care about the memory - endianness - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success +ida_hexrays.mop_t.make_first_half(self, width: int) -> bool + Make the first part of the operand. This function does not care about the memory endianness + + @param width: the desired size of the operand part in bytes + @returns success -ida_hexrays.mop_t.make_fpnum (method) - make_fpnum(self, bytes) -> bool - Create a floating point constant operand. - - @param bytes: (C++: const void *) pointer to the floating point value as used by the current - processor (e.g. for x86 it must be in IEEE 754) - @return: success +ida_hexrays.mop_t.make_fpnum(self, bytes: "void const *") -> bool + Create a floating point constant operand. + + @param bytes: pointer to the floating point value as used by the current processor (e.g. for x86 it must be in IEEE 754) + @returns success -ida_hexrays.mop_t.make_gvar (method) - make_gvar(self, ea) +ida_hexrays.mop_t.make_gvar(self, ea: ida_idaapi.ea_t) -> None Create a global variable operand. - - @param ea: (C++: ea_t) -ida_hexrays.mop_t.make_helper (method) - make_helper(self, name) - Create a helper operand. A helper operand usually keeps a built-in function name - like "va_start" It is essentially just an arbitrary identifier without any - additional info. - - @param name: (C++: const char *) char const * +ida_hexrays.mop_t.make_helper(self, name: str) -> None + Create a helper operand. A helper operand usually keeps a built-in function name like "va_start" It is essentially just an arbitrary identifier without any additional info. + -ida_hexrays.mop_t.make_high_half (method) - make_high_half(self, width) -> bool - Make the high part of the operand. This function takes into account the memory - endianness (byte sex) - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success +ida_hexrays.mop_t.make_high_half(self, width: int) -> bool + Make the high part of the operand. This function takes into account the memory endianness (byte sex) + + @param width: the desired size of the operand part in bytes + @returns success -ida_hexrays.mop_t.make_insn (method) - make_insn(self, ins) +ida_hexrays.mop_t.make_insn(self, ins: "minsn_t") -> None Create a nested instruction. - - @param ins: (C++: minsn_t *) -ida_hexrays.mop_t.make_low_half (method) - make_low_half(self, width) -> bool - Make the low part of the operand. This function takes into account the memory - endianness (byte sex) - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success +ida_hexrays.mop_t.make_low_half(self, width: int) -> bool + Make the low part of the operand. This function takes into account the memory endianness (byte sex) + + @param width: the desired size of the operand part in bytes + @returns success -ida_hexrays.mop_t.make_number (method) - make_number(self, _value, _size, _ea=BADADDR, opnum=0) - Create an integer constant operand. - - @param _value: (C++: uint64) value to store in the operand - @param _size: (C++: int) size of the value in bytes (1,2,4,8) - @param _ea: (C++: ea_t) address of the processor instruction that made the value - @param opnum: (C++: int) operand number of the processor instruction +ida_hexrays.mop_t.make_number(self, *args) -> None + Create an integer constant operand. + + @param _value: value to store in the operand + @param _size: size of the value in bytes (1,2,4,8) + @param _ea: address of the processor instruction that made the value + @param opnum: operand number of the processor instruction -ida_hexrays.mop_t.make_reg (method) - make_reg(self, reg) +ida_hexrays.mop_t.make_reg(self, *args) -> None + This function has the following signatures: - @param reg: mreg_t + 0. make_reg(reg: mreg_t) -> None + 1. make_reg(reg: mreg_t, _size: int) -> None - make_reg(self, reg, _size) + # 0: make_reg(reg: mreg_t) -> None - @param reg: mreg_t - @param _size: int + Create a register operand. + + + # 1: make_reg(reg: mreg_t, _size: int) -> None -ida_hexrays.mop_t.make_reg_pair (method) - make_reg_pair(self, loreg, hireg, halfsize) - Create pair of registers. - - @param loreg: (C++: int) register holding the low part of the value - @param hireg: (C++: int) register holding the high part of the value - @param halfsize: (C++: int) the size of each of loreg/hireg +ida_hexrays.mop_t.make_reg_pair(self, loreg: int, hireg: int, halfsize: int) -> None + Create pair of registers. + + @param loreg: register holding the low part of the value + @param hireg: register holding the high part of the value + @param halfsize: the size of each of loreg/hireg -ida_hexrays.mop_t.make_second_half (method) - make_second_half(self, width) -> bool - Make the second part of the operand. This function does not care about the - memory endianness - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success +ida_hexrays.mop_t.make_second_half(self, width: int) -> bool + Make the second part of the operand. This function does not care about the memory endianness + + @param width: the desired size of the operand part in bytes + @returns success -ida_hexrays.mop_t.make_stkvar (method) - make_stkvar(self, mba, off) - - @param mba: mba_t * - @param off: sval_t +ida_hexrays.mop_t.make_stkvar(self, mba: "mba_t", off: int) -> None -ida_hexrays.mop_t.may_use_aliased_memory (method) - may_use_aliased_memory(self) -> bool +ida_hexrays.mop_t.may_use_aliased_memory(self) -> bool Is it possible for the operand to use aliased memory? -ida_hexrays.mop_t.oprops (variable) +ida_hexrays.mop_t.oprops Operand properties. -ida_hexrays.mop_t.preserve_side_effects (method) - preserve_side_effects(self, blk, top, moved_calls=None) -> bool - Move subinstructions with side effects out of the operand. If we decide to - delete an instruction operand, it is a good idea to call this function. - Alternatively we should skip such operands by calling mop_t::has_side_effects() - For example, if we transform: jnz x, x, @blk => goto @blk then we must call this - function before deleting the X operands. - - @param blk: (C++: mblock_t *) current block - @param top: (C++: minsn_t *) top level instruction that contains our operand - @param moved_calls: (C++: bool *) pointer to the boolean that will track if all side effects - get handled correctly. must be false initially. - @return: false failed to preserve a side effect, it is not safe to delete the - operand true no side effects or successfully preserved them +ida_hexrays.mop_t.preserve_side_effects(self, blk: "mblock_t", top: "minsn_t", moved_calls: "bool *" = None) -> bool + Move subinstructions with side effects out of the operand. If we decide to delete an instruction operand, it is a good idea to call this function. Alternatively we should skip such operands by calling mop_t::has_side_effects() For example, if we transform: jnz x, x, @blk => goto @blk then we must call this function before deleting the X operands. + + @param blk: current block + @param top: top level instruction that contains our operand + @param moved_calls: pointer to the boolean that will track if all side effects get handled correctly. must be false initially. + @returns false failed to preserve a side effect, it is not safe to delete the operand true no side effects or successfully preserved them -ida_hexrays.mop_t.probably_floating (method) - probably_floating(self) -> bool +ida_hexrays.mop_t.probably_floating(self) -> bool -ida_hexrays.mop_t.replace_by (method) +ida_hexrays.mop_t.replace_by(self, o) -ida_hexrays.mop_t.set_impptr_done (method) - set_impptr_done(self) +ida_hexrays.mop_t.set_impptr_done(self) -> None -ida_hexrays.mop_t.set_lowaddr (method) - set_lowaddr(self) +ida_hexrays.mop_t.set_lowaddr(self) -> None -ida_hexrays.mop_t.set_udt (method) - set_udt(self) +ida_hexrays.mop_t.set_udt(self) -> None -ida_hexrays.mop_t.set_undef_val (method) - set_undef_val(self) +ida_hexrays.mop_t.set_undef_val(self) -> None -ida_hexrays.mop_t.shift_mop (method) - shift_mop(self, offset) -> bool - Shift the operand. This function shifts only the beginning of the operand. The - operand size will be changed. Examples: shift_mop(AH.1, -1) -> AX.2 - shift_mop(qword_00000008.8, 4) -> dword_0000000C.4 shift_mop(xdu.8(op.4), 4) -> - #0.4 shift_mop(#0x12345678.4, 3) -> #12.1 - - @param offset: (C++: int) shift count (the number of bytes to shift) - @return: success +ida_hexrays.mop_t.shift_mop(self, offset: int) -> bool + Shift the operand. This function shifts only the beginning of the operand. The operand size will be changed. Examples: shift_mop(AH.1, -1) -> AX.2 shift_mop(qword_00000008.8, 4) -> dword_0000000C.4 shift_mop(xdu.8(op.4), 4) -> #0.4 shift_mop(#0x12345678.4, 3) -> #12.1 + + @param offset: shift count (the number of bytes to shift) + @returns success -ida_hexrays.mop_t.signed_value (method) - signed_value(self) -> int64 +ida_hexrays.mop_t.signed_value(self) -> "int64" -ida_hexrays.mop_t.size (variable) - Operand size. Usually it is 1,2,4,8 or NOSIZE but for UDTs other sizes are - permitted +ida_hexrays.mop_t.size + Operand size. Usually it is 1,2,4,8 or NOSIZE but for UDTs other sizes are permitted + -ida_hexrays.mop_t.swap (method) - swap(self, rop) - - @param rop: mop_t & +ida_hexrays.mop_t.swap(self, rop: "mop_t") -> None -ida_hexrays.mop_t.t (variable) +ida_hexrays.mop_t.t Operand type. -ida_hexrays.mop_t.unsigned_value (method) - unsigned_value(self) -> uint64 +ida_hexrays.mop_t.t + Operand type. -ida_hexrays.mop_t.update_numop_value (method) - update_numop_value(self, val) - - @param val: uint64 +ida_hexrays.mop_t.unsigned_value(self) -> "uint64" -ida_hexrays.mop_t.valnum (variable) - Value number. Zero means unknown. Operands with the same value number are equal. +ida_hexrays.mop_t.update_numop_value(self, val: "uint64") -> None -ida_hexrays.mop_t.value (method) - value(self, is_signed) -> uint64 - Retrieve value of a constant integer operand. These functions can be called only - for mop_n operands. See is_constant() that can be called on any operand. - - @param is_signed: (C++: bool) +ida_hexrays.mop_t.valnum + Value number. Zero means unknown. Operands with the same value number are equal. + -ida_hexrays.mop_t.zero (method) - zero(self) +ida_hexrays.mop_t.value(self, is_signed: bool) -> "uint64" + Retrieve value of a constant integer operand. These functions can be called only for mop_n operands. See is_constant() that can be called on any operand. + -ida_hexrays.mop_v (variable) +ida_hexrays.mop_t.zero(self) -> None + +ida_hexrays.mop_v global variable -ida_hexrays.mop_visitor_t (class) - Proxy of C++ mop_visitor_t class. +ida_hexrays.mop_visitor_t -ida_hexrays.mop_visitor_t.__disown__ (method) +ida_hexrays.mop_visitor_t.__disown__(self) -ida_hexrays.mop_visitor_t.__init__ (method) - __init__(self, _mba=None, _blk=None, _topins=None) -> mop_visitor_t - - @param _mba: mba_t * - @param _blk: mblock_t * - @param _topins: minsn_t * +ida_hexrays.mop_visitor_t.__init__(self, _mba: "mba_t" = None, _blk: "mblock_t" = None, _topins: "minsn_t" = None) -ida_hexrays.mop_visitor_t.prune (variable) - Should skip sub-operands of the current operand? visit_mop() may set - 'prune=true' for that. +ida_hexrays.mop_visitor_t.prune + Should skip sub-operands of the current operand? visit_mop() may set 'prune=true' for that. + -ida_hexrays.mop_visitor_t.visit_mop (method) - visit_mop(self, op, type, is_target) -> int - - @param op: mop_t * - @param type: tinfo_t const * - @param is_target: bool +ida_hexrays.mop_visitor_t.visit_mop(self, op: "mop_t", type: "tinfo_t", is_target: bool) -> int -ida_hexrays.mop_z (variable) +ida_hexrays.mop_z none -ida_hexrays.mopvec_t (class) - Proxy of C++ qvector< mop_t > class. +ida_hexrays.mopvec_t -ida_hexrays.mopvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< mop_t > const & +ida_hexrays.mopvec_t.__eq__(self, r: "mopvec_t") -> bool -ida_hexrays.mopvec_t.__getitem__ (method) - __getitem__(self, i) -> mop_t - - @param i: size_t +ida_hexrays.mopvec_t.__getitem__(self, i: "size_t") -> "mop_t const &" -ida_hexrays.mopvec_t.__init__ (method) - __init__(self) -> mopvec_t - __init__(self, x) -> mopvec_t - - @param x: qvector< mop_t > const & +ida_hexrays.mopvec_t.__init__(self, *args) -ida_hexrays.mopvec_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.mopvec_t.__len__(self) -> "size_t" -ida_hexrays.mopvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< mop_t > const & +ida_hexrays.mopvec_t.__ne__(self, r: "mopvec_t") -> bool -ida_hexrays.mopvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: mop_t const & +ida_hexrays.mopvec_t.__setitem__(self, i: "size_t", v: "mop_t") -> None -ida_hexrays.mopvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: mop_t const & +ida_hexrays.mopvec_t._del(self, x: "mop_t") -> bool -ida_hexrays.mopvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: mop_t const & +ida_hexrays.mopvec_t.add_unique(self, x: "mop_t") -> bool -ida_hexrays.mopvec_t.at (method) - at(self, _idx) -> mop_t - - @param _idx: size_t +ida_hexrays.mopvec_t.append(self, x: "mop_t") -> None -ida_hexrays.mopvec_t.begin (method) - begin(self) -> mop_t +ida_hexrays.mopvec_t.at(self, _idx: "size_t") -> "mop_t const &" -ida_hexrays.mopvec_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.mopvec_t.begin(self, *args) -> "qvector< mop_t >::const_iterator" -ida_hexrays.mopvec_t.clear (method) - clear(self) +ida_hexrays.mopvec_t.capacity(self) -> "size_t" -ida_hexrays.mopvec_t.empty (method) - empty(self) -> bool +ida_hexrays.mopvec_t.clear(self) -> None -ida_hexrays.mopvec_t.end (method) - end(self) -> mop_t +ida_hexrays.mopvec_t.empty(self) -> bool -ida_hexrays.mopvec_t.erase (method) - erase(self, it) -> mop_t - - @param it: qvector< mop_t >::iterator - - erase(self, first, last) -> mop_t - - @param first: qvector< mop_t >::iterator - @param last: qvector< mop_t >::iterator +ida_hexrays.mopvec_t.end(self, *args) -> "qvector< mop_t >::const_iterator" -ida_hexrays.mopvec_t.extract (method) - extract(self) -> mop_t +ida_hexrays.mopvec_t.erase(self, *args) -> "qvector< mop_t >::iterator" -ida_hexrays.mopvec_t.find (method) - find(self, x) -> mop_t - - @param x: mop_t const & +ida_hexrays.mopvec_t.extend(self, x: "mopvec_t") -> None -ida_hexrays.mopvec_t.grow (method) - grow(self, x=mop_t()) - - @param x: mop_t const & +ida_hexrays.mopvec_t.extract(self) -> "mop_t *" -ida_hexrays.mopvec_t.has (method) - has(self, x) -> bool - - @param x: mop_t const & +ida_hexrays.mopvec_t.find(self, *args) -> "qvector< mop_t >::const_iterator" -ida_hexrays.mopvec_t.inject (method) - inject(self, s, len) - - @param s: mop_t * - @param len: size_t +ida_hexrays.mopvec_t.grow(self, *args) -> None -ida_hexrays.mopvec_t.insert (method) - insert(self, it, x) -> mop_t - - @param it: qvector< mop_t >::iterator - @param x: mop_t const & +ida_hexrays.mopvec_t.has(self, x: "mop_t") -> bool -ida_hexrays.mopvec_t.pop_back (method) - pop_back(self) +ida_hexrays.mopvec_t.inject(self, s: "mop_t", len: "size_t") -> None -ida_hexrays.mopvec_t.push_back (method) - push_back(self, x) - - @param x: mop_t const & - - push_back(self) -> mop_t +ida_hexrays.mopvec_t.insert(self, it: "mop_t", x: "mop_t") -> "qvector< mop_t >::iterator" -ida_hexrays.mopvec_t.qclear (method) - qclear(self) +ida_hexrays.mopvec_t.pop_back(self) -> None -ida_hexrays.mopvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.mopvec_t.push_back(self, *args) -> "mop_t &" -ida_hexrays.mopvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: mop_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.mopvec_t.qclear(self) -> None -ida_hexrays.mopvec_t.size (method) - size(self) -> size_t +ida_hexrays.mopvec_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.mopvec_t.swap (method) - swap(self, r) - - @param r: qvector< mop_t > & +ida_hexrays.mopvec_t.resize(self, *args) -> None -ida_hexrays.mopvec_t.truncate (method) - truncate(self) +ida_hexrays.mopvec_t.size(self) -> "size_t" -ida_hexrays.mreg2reg (function) - mreg2reg(reg, width) -> int - Map a microregister to a processor register. - - @param reg: (C++: mreg_t) microregister number - @param width: (C++: int) size of microregister in bytes - @return: processor register id or -1 +ida_hexrays.mopvec_t.swap(self, r: "mopvec_t") -> None -ida_hexrays.must_mcode_close_block (function) - must_mcode_close_block(mcode, including_calls) -> bool - Must an instruction with the given opcode be the last one in a block? Such - opcodes are called closing opcodes. - - @param mcode: (C++: mcode_t) instruction opcode - @param including_calls: (C++: bool) should m_call/m_icall be considered as the closing - opcodes? If this function returns true, the opcode - cannot appear in the middle of a block. Calls are a - special case: unknown calls (is_unknown_call) are - considered as closing opcodes. +ida_hexrays.mopvec_t.truncate(self) -> None -ida_hexrays.negate_mcode_relation (function) - negate_mcode_relation(code) -> mcode_t - - @param code: enum mcode_t +ida_hexrays.mreg2reg(reg: "mreg_t", width: int) -> int + Map a microregister to a processor register. + + @param reg: microregister number + @param width: size of microregister in bytes + @returns processor register id or -1 -ida_hexrays.negated_relation (function) - negated_relation(op) -> ctype_t +ida_hexrays.must_mcode_close_block(mcode: "mcode_t", including_calls: bool) -> bool + Must an instruction with the given opcode be the last one in a block? Such opcodes are called closing opcodes. + + @param mcode: instruction opcode + @param including_calls: should m_call/m_icall be considered as the closing opcodes? If this function returns true, the opcode cannot appear in the middle of a block. Calls are a special case: unknown calls (is_unknown_call) are considered as closing opcodes. + +ida_hexrays.negate_mcode_relation(code: "mcode_t") -> "mcode_t" + +ida_hexrays.negated_relation(op: "ctype_t") -> "ctype_t" Negate a comparison operator. For example, cot_sge becomes cot_slt. - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.new_block (function) +ida_hexrays.new_block() Create a new block-statement. -ida_hexrays.number_format_t (class) - Proxy of C++ number_format_t class. +ida_hexrays.node_bitset_t -ida_hexrays.number_format_t.__init__ (method) - __init__(self, _opnum=0) -> number_format_t - - @param _opnum: int +ida_hexrays.node_bitset_t.__init__(self, *args) -ida_hexrays.number_format_t.flags (variable) - ida flags, which describe number radix, enum, etc +ida_hexrays.number_format_t -ida_hexrays.number_format_t.flags32 (variable) +ida_hexrays.number_format_t.__init__(self, _opnum: int = 0) + +ida_hexrays.number_format_t.flags + ida flags, which describe number radix, enum, etc + + +ida_hexrays.number_format_t.flags32 low 32bit of flags (for compatibility) -ida_hexrays.number_format_t.get_radix (method) - get_radix(self) -> int - Get number radix - - @return: 2,8,10, or 16 +ida_hexrays.number_format_t.get_radix(self) -> int + Get number radix + + @returns 2,8,10, or 16 -ida_hexrays.number_format_t.has_unmutable_type (method) - has_unmutable_type(self) -> bool +ida_hexrays.number_format_t.has_unmutable_type(self) -> bool -ida_hexrays.number_format_t.is_char (method) - is_char(self) -> bool +ida_hexrays.number_format_t.is_char(self) -> bool Is a character constant? -ida_hexrays.number_format_t.is_dec (method) - is_dec(self) -> bool +ida_hexrays.number_format_t.is_dec(self) -> bool Is a decimal number? -ida_hexrays.number_format_t.is_enum (method) - is_enum(self) -> bool +ida_hexrays.number_format_t.is_enum(self) -> bool Is a symbolic constant? -ida_hexrays.number_format_t.is_fixed (method) - is_fixed(self) -> bool - Is number representation fixed? Fixed representation cannot be modified by the - decompiler +ida_hexrays.number_format_t.is_fixed(self) -> bool + Is number representation fixed? Fixed representation cannot be modified by the decompiler + -ida_hexrays.number_format_t.is_hex (method) - is_hex(self) -> bool +ida_hexrays.number_format_t.is_hex(self) -> bool Is a hexadecimal number? -ida_hexrays.number_format_t.is_numop (method) - is_numop(self) -> bool +ida_hexrays.number_format_t.is_numop(self) -> bool Is a number? -ida_hexrays.number_format_t.is_oct (method) - is_oct(self) -> bool +ida_hexrays.number_format_t.is_oct(self) -> bool Is a octal number? -ida_hexrays.number_format_t.is_stroff (method) - is_stroff(self) -> bool +ida_hexrays.number_format_t.is_stroff(self) -> bool Is a structure field offset? -ida_hexrays.number_format_t.needs_to_be_inverted (method) - needs_to_be_inverted(self) -> bool - Does the number need to be negated or bitwise negated? Returns true if the user - requested a negation but it is not done yet +ida_hexrays.number_format_t.needs_to_be_inverted(self) -> bool + Does the number need to be negated or bitwise negated? Returns true if the user requested a negation but it is not done yet + -ida_hexrays.number_format_t.opnum (variable) +ida_hexrays.number_format_t.opnum operand number: 0..UA_MAXOP -ida_hexrays.number_format_t.org_nbytes (variable) +ida_hexrays.number_format_t.org_nbytes original number size in bytes -ida_hexrays.number_format_t.serial (variable) +ida_hexrays.number_format_t.props + properties: combination of NF_ bits (Number format property bits) + + +ida_hexrays.number_format_t.serial for enums: constant serial number -ida_hexrays.number_format_t.type_name (variable) +ida_hexrays.number_format_t.type_name for stroffs: structure for offsetof() - for enums: enum name + for enums: enum name + -ida_hexrays.op_parent_info_t (class) - Proxy of C++ op_parent_info_t class. +ida_hexrays.op_parent_info_t -ida_hexrays.op_parent_info_t.__init__ (method) - __init__(self, _mba=None, _blk=None, _topins=None) -> op_parent_info_t - - @param _mba: mba_t * - @param _blk: mblock_t * - @param _topins: minsn_t * +ida_hexrays.op_parent_info_t.__disown__(self) -ida_hexrays.op_uses_x (function) - op_uses_x(op) -> bool +ida_hexrays.op_parent_info_t.__init__(self, _mba: "mba_t" = None, _blk: "mblock_t" = None, _topins: "minsn_t" = None) + +ida_hexrays.op_uses_x(op: "ctype_t") -> bool Does operator use the 'x' field of cexpr_t? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.op_uses_y (function) - op_uses_y(op) -> bool +ida_hexrays.op_uses_y(op: "ctype_t") -> bool Does operator use the 'y' field of cexpr_t? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.op_uses_z (function) - op_uses_z(op) -> bool +ida_hexrays.op_uses_z(op: "ctype_t") -> bool Does operator use the 'z' field of cexpr_t? - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.open_pseudocode (function) - open_pseudocode(ea, flags) -> vdui_t - Open pseudocode window. The specified function is decompiled and the pseudocode - window is opened. - - @param ea: (C++: ea_t) function to decompile - @param flags: (C++: int) a combination of OPF_ flags - @return: false if failed +ida_hexrays.open_pseudocode(ea: ida_idaapi.ea_t, flags: int) -> "vdui_t *" + Open pseudocode window. The specified function is decompiled and the pseudocode window is opened. + + @param ea: function to decompile + @param flags: a combination of OPF_ flags + @returns false if failed -ida_hexrays.operand_locator_t (class) - Proxy of C++ operand_locator_t class. +ida_hexrays.operand_locator_t -ida_hexrays.operand_locator_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: operand_locator_t const & +ida_hexrays.operand_locator_t.__eq__(self, r: "operand_locator_t") -> bool -ida_hexrays.operand_locator_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: operand_locator_t const & +ida_hexrays.operand_locator_t.__ge__(self, r: "operand_locator_t") -> bool -ida_hexrays.operand_locator_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: operand_locator_t const & +ida_hexrays.operand_locator_t.__gt__(self, r: "operand_locator_t") -> bool -ida_hexrays.operand_locator_t.__init__ (method) - __init__(self, _ea, _opnum) -> operand_locator_t - - @param _ea: ea_t - @param _opnum: int +ida_hexrays.operand_locator_t.__init__(self, _ea: ida_idaapi.ea_t, _opnum: int) -ida_hexrays.operand_locator_t.__le__ (method) - __le__(self, r) -> bool - - @param r: operand_locator_t const & +ida_hexrays.operand_locator_t.__le__(self, r: "operand_locator_t") -> bool -ida_hexrays.operand_locator_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: operand_locator_t const & +ida_hexrays.operand_locator_t.__lt__(self, r: "operand_locator_t") -> bool -ida_hexrays.operand_locator_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: operand_locator_t const & +ida_hexrays.operand_locator_t.__ne__(self, r: "operand_locator_t") -> bool -ida_hexrays.operand_locator_t.compare (method) - compare(self, r) -> int - - @param r: operand_locator_t const & +ida_hexrays.operand_locator_t.compare(self, r: "operand_locator_t") -> int -ida_hexrays.operand_locator_t.ea (variable) +ida_hexrays.operand_locator_t.ea address of the original processor instruction -ida_hexrays.operand_locator_t.opnum (variable) +ida_hexrays.operand_locator_t.opnum operand number in the instruction -ida_hexrays.optblock_t (class) - Proxy of C++ optblock_t class. +ida_hexrays.optblock_t -ida_hexrays.optblock_t.__disown__ (method) +ida_hexrays.optblock_t.__disown__(self) -ida_hexrays.optblock_t.__init__ (method) - __init__(self) -> optblock_t - - @param self: PyObject * +ida_hexrays.optblock_t.__init__(self) -ida_hexrays.optblock_t.func (method) - func(self, blk) -> int - Optimize a block. This function usually performs the optimizations that require - analyzing the entire block and/or its neighbors. For example it can recognize - patterns and perform conversions like: b0: b0: ... ... jnz x, 0, @b2 => jnz x, - 0, @b2 b1: b1: add x, 0, y mov x, y ... ... - - @param blk: (C++: mblock_t *) Basic block to optimize as a whole. - @return: number of changes made to the block. See also mark_lists_dirty. +ida_hexrays.optblock_t.func(self, blk: "mblock_t") -> int + Optimize a block. This function usually performs the optimizations that require analyzing the entire block and/or its neighbors. For example it can recognize patterns and perform conversions like: b0: b0: ... ... jnz x, 0, @b2 => jnz x, 0, @b2 b1: b1: add x, 0, y mov x, y ... ... + + @param blk: Basic block to optimize as a whole. + @returns number of changes made to the block. See also mark_lists_dirty. -ida_hexrays.optblock_t.install (method) - install(self) +ida_hexrays.optblock_t.install(self) -> None -ida_hexrays.optblock_t.remove (method) - remove(self) -> bool +ida_hexrays.optblock_t.remove(self) -> bool -ida_hexrays.optinsn_t (class) - Proxy of C++ optinsn_t class. +ida_hexrays.optinsn_t -ida_hexrays.optinsn_t.__disown__ (method) +ida_hexrays.optinsn_t.__disown__(self) -ida_hexrays.optinsn_t.__init__ (method) - __init__(self) -> optinsn_t - - @param self: PyObject * +ida_hexrays.optinsn_t.__init__(self) -ida_hexrays.optinsn_t.func (method) - func(self, blk, ins, optflags) -> int - Optimize an instruction. - - @param blk: (C++: mblock_t *) current basic block. maybe nullptr, which means that the instruction - must be optimized without context - @param ins: (C++: minsn_t *) instruction to optimize; it is always a top-level instruction. the - callback may not delete the instruction but may convert it into nop - (see mblock_t::make_nop). to optimize sub-instructions, visit them - using minsn_visitor_t. sub-instructions may not be converted into - nop but can be converted to "mov x,x". for example: add x,0,x => mov - x,x this callback may change other instructions in the block, but - should do this with care, e.g. to no break the propagation algorithm - if called with OPTI_NO_LDXOPT. - @param optflags: (C++: int) combination of optimization flags bits - @return: number of changes made to the instruction. if after this call the - instruction's use/def lists have changed, you must mark the block level - lists as dirty (see mark_lists_dirty) +ida_hexrays.optinsn_t.func(self, blk: "mblock_t", ins: "minsn_t", optflags: int) -> int + Optimize an instruction. + + @param blk: current basic block. maybe nullptr, which means that the instruction must be optimized without context + @param ins: instruction to optimize; it is always a top-level instruction. the callback may not delete the instruction but may convert it into nop (see mblock_t::make_nop). to optimize sub-instructions, visit them using minsn_visitor_t. sub-instructions may not be converted into nop but can be converted to "mov x,x". for example: add x,0,x => mov x,x this callback may change other instructions in the block, but should do this with care, e.g. to no break the propagation algorithm if called with OPTI_NO_LDXOPT. + @param optflags: combination of optimization flags bits + @returns number of changes made to the instruction. if after this call the instruction's use/def lists have changed, you must mark the block level lists as dirty (see mark_lists_dirty) -ida_hexrays.optinsn_t.install (method) - install(self) +ida_hexrays.optinsn_t.install(self) -> None -ida_hexrays.optinsn_t.remove (method) - remove(self) -> bool +ida_hexrays.optinsn_t.remove(self) -> bool -ida_hexrays.parse_user_call (function) - parse_user_call(udc, decl, silent) -> bool - Convert function type declaration into internal structure - - @param udc: (C++: udcall_t *) - pointer to output structure - @param decl: (C++: const char *) - function type declaration - @param silent: (C++: bool) - if TRUE: do not show warning in case of incorrect type - @return: success +ida_hexrays.parse_user_call(udc: "udcall_t", decl: str, silent: bool) -> bool + Convert function type declaration into internal structure + + @param udc: - pointer to output structure + @param decl: - function type declaration + @param silent: - if TRUE: do not show warning in case of incorrect type + @returns success -ida_hexrays.partial_type_num (function) - partial_type_num(type) -> int - Calculate number of partial subtypes. - - @param type: (C++: const tinfo_t &) tinfo_t const & - @return: number of partial subtypes. The bigger is this number, the uglier is - the type. +ida_hexrays.partial_type_num(type: "tinfo_t") -> int + Calculate number of partial subtypes. + + @returns number of partial subtypes. The bigger is this number, the uglier is the type. -ida_hexrays.print_vdloc (function) - print_vdloc(loc, nbytes) -> str - Print vdloc. Since vdloc does not always carry the size info, we pass it as - NBYTES.. - - @param loc: (C++: const vdloc_t &) vdloc_t const & - @param nbytes: (C++: int) +ida_hexrays.print_vdloc(loc: "vdloc_t", nbytes: int) -> str + Print vdloc. Since vdloc does not always carry the size info, we pass it as NBYTES.. + -ida_hexrays.property_op_to_typename (function) +ida_hexrays.property_op_to_typename(self) -ida_hexrays.qstring_printer_t (class) - Proxy of C++ qstring_printer_t class. +ida_hexrays.qstring_printer_t -ida_hexrays.qstring_printer_t.__init__ (method) - __init__(self, f, tags) -> qstring_printer_t - - @param f: cfunc_t const * - @param tags: bool +ida_hexrays.qstring_printer_t.__init__(self, f: "cfunc_t", tags: bool) -ida_hexrays.qstring_printer_t._print (method) - _print(self, indent, format) -> int - - Parameters - ---------- - indent: int - format: char const * +ida_hexrays.qstring_printer_t._print(self, indent: int, format: str) -> int -ida_hexrays.qstring_printer_t.get_s (method) - get_s(self) -> qstring +ida_hexrays.qstring_printer_t.get_s(self) -> str -ida_hexrays.qstring_printer_t.s (variable) - Reference to the output string +ida_hexrays.qstring_printer_t.s + Reference to the output string + -ida_hexrays.qstring_printer_t.with_tags (variable) +ida_hexrays.qstring_printer_t.s + Reference to the output string + + +ida_hexrays.qstring_printer_t.with_tags Generate output with color tags. -ida_hexrays.qswap (function) - qswap(a, b) - - @param a: cinsn_t & - @param b: cinsn_t & - -ida_hexrays.qvector_carg_t (class) - Proxy of C++ qvector< carg_t > class. - -ida_hexrays.qvector_carg_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< carg_t > const & - -ida_hexrays.qvector_carg_t.__getitem__ (method) - __getitem__(self, i) -> carg_t - - @param i: size_t - -ida_hexrays.qvector_carg_t.__init__ (method) - __init__(self) -> qvector_carg_t - __init__(self, x) -> qvector_carg_t - - @param x: qvector< carg_t > const & - -ida_hexrays.qvector_carg_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_carg_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< carg_t > const & - -ida_hexrays.qvector_carg_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: carg_t const & - -ida_hexrays.qvector_carg_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: carg_t const & - -ida_hexrays.qvector_carg_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.at (method) - at(self, _idx) -> carg_t - - @param _idx: size_t - -ida_hexrays.qvector_carg_t.begin (method) - begin(self) -> carg_t - -ida_hexrays.qvector_carg_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_carg_t.clear (method) - clear(self) - -ida_hexrays.qvector_carg_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_carg_t.end (method) - end(self) -> carg_t - -ida_hexrays.qvector_carg_t.erase (method) - erase(self, it) -> carg_t - - @param it: qvector< carg_t >::iterator - - erase(self, first, last) -> carg_t - - @param first: qvector< carg_t >::iterator - @param last: qvector< carg_t >::iterator - -ida_hexrays.qvector_carg_t.extract (method) - extract(self) -> carg_t - -ida_hexrays.qvector_carg_t.find (method) - find(self, x) -> carg_t - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.grow (method) - grow(self, x=carg_t()) - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.has (method) - has(self, x) -> bool - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.inject (method) - inject(self, s, len) - - @param s: carg_t * - @param len: size_t - -ida_hexrays.qvector_carg_t.insert (method) - insert(self, it, x) -> carg_t - - @param it: qvector< carg_t >::iterator - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_carg_t.push_back (method) - push_back(self, x) - - @param x: carg_t const & - - push_back(self) -> carg_t - -ida_hexrays.qvector_carg_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_carg_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_carg_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: carg_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_carg_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_carg_t.swap (method) - swap(self, r) - - @param r: qvector< carg_t > & - -ida_hexrays.qvector_carg_t.truncate (method) - truncate(self) - -ida_hexrays.qvector_ccase_t (class) - Proxy of C++ qvector< ccase_t > class. - -ida_hexrays.qvector_ccase_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< ccase_t > const & - -ida_hexrays.qvector_ccase_t.__getitem__ (method) - __getitem__(self, i) -> ccase_t - - @param i: size_t - -ida_hexrays.qvector_ccase_t.__init__ (method) - __init__(self) -> qvector_ccase_t - __init__(self, x) -> qvector_ccase_t - - @param x: qvector< ccase_t > const & - -ida_hexrays.qvector_ccase_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_ccase_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< ccase_t > const & - -ida_hexrays.qvector_ccase_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ccase_t const & - -ida_hexrays.qvector_ccase_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: ccase_t const & - -ida_hexrays.qvector_ccase_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.at (method) - at(self, _idx) -> ccase_t - - @param _idx: size_t - -ida_hexrays.qvector_ccase_t.begin (method) - begin(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_ccase_t.clear (method) - clear(self) - -ida_hexrays.qvector_ccase_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_ccase_t.end (method) - end(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.erase (method) - erase(self, it) -> ccase_t - - @param it: qvector< ccase_t >::iterator - - erase(self, first, last) -> ccase_t - - @param first: qvector< ccase_t >::iterator - @param last: qvector< ccase_t >::iterator - -ida_hexrays.qvector_ccase_t.extract (method) - extract(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.find (method) - find(self, x) -> ccase_t - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.grow (method) - grow(self, x=ccase_t()) - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.has (method) - has(self, x) -> bool - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.inject (method) - inject(self, s, len) - - @param s: ccase_t * - @param len: size_t - -ida_hexrays.qvector_ccase_t.insert (method) - insert(self, it, x) -> ccase_t - - @param it: qvector< ccase_t >::iterator - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_ccase_t.push_back (method) - push_back(self, x) - - @param x: ccase_t const & - - push_back(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_ccase_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_ccase_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ccase_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_ccase_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_ccase_t.swap (method) - swap(self, r) - - @param r: qvector< ccase_t > & - -ida_hexrays.qvector_ccase_t.truncate (method) - truncate(self) - -ida_hexrays.qvector_history_t (class) - Proxy of C++ qvector< history_item_t > class. - -ida_hexrays.qvector_history_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< history_item_t > const & - -ida_hexrays.qvector_history_t.__getitem__ (method) - __getitem__(self, i) -> history_item_t - - @param i: size_t - -ida_hexrays.qvector_history_t.__init__ (method) - __init__(self) -> qvector_history_t - __init__(self, x) -> qvector_history_t - - @param x: qvector< history_item_t > const & - -ida_hexrays.qvector_history_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_history_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< history_item_t > const & - -ida_hexrays.qvector_history_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: history_item_t const & - -ida_hexrays.qvector_history_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: history_item_t const & - -ida_hexrays.qvector_history_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.at (method) - at(self, _idx) -> history_item_t - - @param _idx: size_t - -ida_hexrays.qvector_history_t.begin (method) - begin(self) -> history_item_t - -ida_hexrays.qvector_history_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_history_t.clear (method) - clear(self) - -ida_hexrays.qvector_history_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_history_t.end (method) - end(self) -> history_item_t - -ida_hexrays.qvector_history_t.erase (method) - erase(self, it) -> history_item_t - - @param it: qvector< history_item_t >::iterator - - erase(self, first, last) -> history_item_t - - @param first: qvector< history_item_t >::iterator - @param last: qvector< history_item_t >::iterator - -ida_hexrays.qvector_history_t.extract (method) - extract(self) -> history_item_t - -ida_hexrays.qvector_history_t.find (method) - find(self, x) -> history_item_t - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.grow (method) - grow(self, x=history_item_t()) - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.has (method) - has(self, x) -> bool - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.inject (method) - inject(self, s, len) - - @param s: history_item_t * - @param len: size_t - -ida_hexrays.qvector_history_t.insert (method) - insert(self, it, x) -> history_item_t - - @param it: qvector< history_item_t >::iterator - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_history_t.push_back (method) - push_back(self, x) - - @param x: history_item_t const & - - push_back(self) -> history_item_t - -ida_hexrays.qvector_history_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_history_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_history_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: history_item_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_history_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_history_t.swap (method) - swap(self, r) - - @param r: qvector< history_item_t > & - -ida_hexrays.qvector_history_t.truncate (method) - truncate(self) - -ida_hexrays.qvector_lvar_t (class) - Proxy of C++ qvector< lvar_t > class. - -ida_hexrays.qvector_lvar_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< lvar_t > const & - -ida_hexrays.qvector_lvar_t.__getitem__ (method) - __getitem__(self, i) -> lvar_t - - @param i: size_t - -ida_hexrays.qvector_lvar_t.__init__ (method) - __init__(self) -> qvector_lvar_t - __init__(self, x) -> qvector_lvar_t - - @param x: qvector< lvar_t > const & - -ida_hexrays.qvector_lvar_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_lvar_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< lvar_t > const & - -ida_hexrays.qvector_lvar_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: lvar_t const & - -ida_hexrays.qvector_lvar_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: lvar_t const & - -ida_hexrays.qvector_lvar_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.at (method) - at(self, _idx) -> lvar_t - - @param _idx: size_t - -ida_hexrays.qvector_lvar_t.begin (method) - begin(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_lvar_t.clear (method) - clear(self) - -ida_hexrays.qvector_lvar_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_lvar_t.end (method) - end(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.erase (method) - erase(self, it) -> lvar_t - - @param it: qvector< lvar_t >::iterator - - erase(self, first, last) -> lvar_t - - @param first: qvector< lvar_t >::iterator - @param last: qvector< lvar_t >::iterator - -ida_hexrays.qvector_lvar_t.extract (method) - extract(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.find (method) - find(self, x) -> lvar_t - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.grow (method) - grow(self, x=lvar_t()) - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.has (method) - has(self, x) -> bool - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.inject (method) - inject(self, s, len) - - @param s: lvar_t * - @param len: size_t - -ida_hexrays.qvector_lvar_t.insert (method) - insert(self, it, x) -> lvar_t - - @param it: qvector< lvar_t >::iterator - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_lvar_t.push_back (method) - push_back(self, x) - - @param x: lvar_t const & - - push_back(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_lvar_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_lvar_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: lvar_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_lvar_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_lvar_t.swap (method) - swap(self, r) - - @param r: qvector< lvar_t > & - -ida_hexrays.qvector_lvar_t.truncate (method) - truncate(self) - -ida_hexrays.reg2mreg (function) - reg2mreg(reg) -> mreg_t - Map a processor register to a microregister. - - @param reg: (C++: int) processor register number - @return: microregister register id or mr_none - -ida_hexrays.remitem (function) - remitem(e) - - @param e: citem_t const * - -ida_hexrays.remove_hexrays_callback (function) - Deprecated. Please use Hexrays_Hooks instead - Uninstall handler for decompiler events. - - @return: number of uninstalled handlers. - -ida_hexrays.rename_lvar (function) - rename_lvar(func_ea, oldname, newname) -> bool - Rename a local variable. - - @param func_ea: (C++: ea_t) function start address - @param oldname: (C++: const char *) old name of the variable - @param newname: (C++: const char *) new name of the variable - @return: success This is a convenience function. For bulk renaming consider - using modify_user_lvars. - -ida_hexrays.restore_user_cmts (function) - restore_user_cmts(func_ea) -> user_cmts_t - Restore user defined comments from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of user defined comments. The returned object must be - deleted by the caller using delete_user_cmts() - -ida_hexrays.restore_user_defined_calls (function) - restore_user_defined_calls(udcalls, func_ea) -> bool - Restore user defined function calls from the database. - - @param udcalls: (C++: udcall_map_t *) ptr to output buffer - @param func_ea: (C++: ea_t) entry address of the function - @return: success - -ida_hexrays.restore_user_iflags (function) - restore_user_iflags(func_ea) -> user_iflags_t - Restore user defined citem iflags from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of user defined iflags. The returned object must be deleted - by the caller using delete_user_iflags() - -ida_hexrays.restore_user_labels (function) - restore_user_labels(func_ea) -> user_labels_t - Restore user defined labels from the database. - - @param func_ea: (C++: ea_t) the entry address of the function, ignored if FUNC != nullptr - @return: collection of user defined labels. The returned object must be deleted - by the caller using delete_user_labels() - -ida_hexrays.restore_user_labels2 (function) - restore_user_labels2(func_ea, func=None) -> user_labels_t - - @param func_ea: ea_t - @param func: cfunc_t const * - -ida_hexrays.restore_user_lvar_settings (function) - restore_user_lvar_settings(lvinf, func_ea) -> bool - Restore user defined local variable settings in the database. - - @param lvinf: (C++: lvar_uservec_t *) ptr to output buffer - @param func_ea: (C++: ea_t) entry address of the function - @return: success - -ida_hexrays.restore_user_numforms (function) - restore_user_numforms(func_ea) -> user_numforms_t - Restore user defined number formats from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of user defined number formats. The returned object must be - deleted by the caller using delete_user_numforms() - -ida_hexrays.restore_user_unions (function) - restore_user_unions(func_ea) -> user_unions_t - Restore user defined union field selections from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of union field selections The returned object must be - deleted by the caller using delete_user_unions() - -ida_hexrays.rlist_t (class) - Proxy of C++ rlist_t class. - -ida_hexrays.rlist_t.__init__ (method) - __init__(self) -> rlist_t - __init__(self, m) -> rlist_t - - @param m: rlist_t const & - - __init__(self, reg, width) -> rlist_t - - @param reg: mreg_t - @param width: int - -ida_hexrays.rlist_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.save_user_cmts (function) - save_user_cmts(func_ea, user_cmts) - Save user defined comments into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param user_cmts: (C++: const user_cmts_t *) collection of user defined comments - -ida_hexrays.save_user_defined_calls (function) - save_user_defined_calls(func_ea, udcalls) - Save user defined local function calls into the database. - - @param func_ea: (C++: ea_t) entry address of the function - @param udcalls: (C++: const udcall_map_t &) user-specified info about user defined function calls - -ida_hexrays.save_user_iflags (function) - save_user_iflags(func_ea, iflags) - Save user defined citem iflags into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param iflags: (C++: const user_iflags_t *) collection of user defined citem iflags - -ida_hexrays.save_user_labels (function) - save_user_labels(func_ea, user_labels) - Save user defined labels into the database. - - @param func_ea: (C++: ea_t) the entry address of the function, ignored if FUNC != nullptr - @param user_labels: (C++: const user_labels_t *) collection of user defined labels - -ida_hexrays.save_user_labels2 (function) - save_user_labels2(func_ea, user_labels, func=None) - - @param func_ea: ea_t - @param user_labels: user_labels_t const * - @param func: cfunc_t const * - -ida_hexrays.save_user_lvar_settings (function) - save_user_lvar_settings(func_ea, lvinf) - Save user defined local variable settings into the database. - - @param func_ea: (C++: ea_t) entry address of the function - @param lvinf: (C++: const lvar_uservec_t &) user-specified info about local variables - -ida_hexrays.save_user_numforms (function) - save_user_numforms(func_ea, numforms) - Save user defined number formats into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param numforms: (C++: const user_numforms_t *) collection of user defined comments - -ida_hexrays.save_user_unions (function) - save_user_unions(func_ea, unions) - Save user defined union field selections into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param unions: (C++: const user_unions_t *) collection of union field selections - -ida_hexrays.scif_t (class) - Proxy of C++ scif_t class. - -ida_hexrays.scif_t.__init__ (method) - __init__(self, _mba, tif, n=None) -> scif_t - - @param _mba: mba_t * - @param tif: tinfo_t * - @param n: qstring * - -ida_hexrays.scif_t.mba (variable) - Pointer to the parent mba_t object. Some operations may convert a scattered - operand into something simpler, (a stack operand, for example). We will need to - create stkvar_ref_t at that moment, this is why we need this pointer. See notes - for lvar_ref_t::mba. - -ida_hexrays.scif_t.name (variable) - Usually scattered operands are created from a function prototype, which has the - name information. We preserve it and use it to name the corresponding local - variable. - -ida_hexrays.scif_t.type (variable) - Scattered operands always have type info assigned to them because without it we - won't be able to manipulte them. - -ida_hexrays.scif_visitor_t (class) - Proxy of C++ scif_visitor_t class. - -ida_hexrays.scif_visitor_t.__disown__ (method) - -ida_hexrays.scif_visitor_t.__init__ (method) - __init__(self) -> scif_visitor_t - - @param self: PyObject * - -ida_hexrays.scif_visitor_t.visit_scif_mop (method) - visit_scif_mop(self, r, off) -> int - - @param r: mop_t const & - @param off: int - -ida_hexrays.select_udt_by_offset (function) - select_udt_by_offset(udts, ops, applicator) -> int - Select UDT - - @param udts: (C++: const qvector< tinfo_t > *) list of UDT tinfo_t for the selection, if nullptr or empty then - UDTs from the "Local types" will be used - @param ops: (C++: const ui_stroff_ops_t &) operands - @param applicator: (C++: ui_stroff_applicator_t &) callback will be called to apply the selection for every - operand - -ida_hexrays.send_database (function) - send_database(err, silent) - Send the database to Hex-Rays. This function sends the current database to the - Hex-Rays server. The database is sent in the compressed form over an encrypted - (SSL) connection. - - @param err: (C++: const hexrays_failure_t &) failure description object. Empty hexrays_failure_t object can be - used if error information is not available. - @param silent: (C++: bool) if false, a dialog box will be displayed before sending the - database. - -ida_hexrays.set2jcnd (function) - set2jcnd(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.set_type (function) - set_type(id, tif, source, force=False) -> bool - Set a global type. - - @param id: (C++: uval_t) address or id of the object - @param tif: (C++: const tinfo_t &) new type info - @param source: (C++: type_source_t) where the type comes from - @param force: (C++: bool) true means to set the type as is, false means to merge the new - type with the possibly existing old type info. - @return: success - -ida_hexrays.simple_graph_t (class) - Proxy of C++ simple_graph_t class. - -ida_hexrays.simple_graph_t.__init__ (method) - -ida_hexrays.stkvar_ref_t (class) - Proxy of C++ stkvar_ref_t class. - -ida_hexrays.stkvar_ref_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__init__ (method) - __init__(self, m, o) -> stkvar_ref_t - - @param m: mba_t * - @param o: sval_t - -ida_hexrays.stkvar_ref_t.__le__ (method) - __le__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.compare (method) - compare(self, r) -> int - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.get_stkvar (method) - get_stkvar(self, p_off=None) -> member_t * - Retrieve the referenced stack variable. - - @param p_off: (C++: uval_t *) if specified, will hold IDA stkoff after the call. - @return: pointer to the stack variable - -ida_hexrays.stkvar_ref_t.mba (variable) - Pointer to the parent mba_t object. We need it in order to retrieve the - referenced stack variable. See notes for lvar_ref_t::mba. - -ida_hexrays.stkvar_ref_t.off (variable) - Offset to the stack variable from the bottom of the stack frame. It is called - 'decompiler stkoff' and it is different from IDA stkoff. See a note and a - picture about 'decompiler stkoff' below. - -ida_hexrays.stkvar_ref_t.swap (method) - swap(self, r) - - @param r: stkvar_ref_t & - -ida_hexrays.swap_mcode_relation (function) - swap_mcode_relation(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.swapped_relation (function) - swapped_relation(op) -> ctype_t +ida_hexrays.qswap(a: "cinsn_t", b: "cinsn_t") -> None + +ida_hexrays.qvector_carg_t + +ida_hexrays.qvector_carg_t.__eq__(self, r: "qvector_carg_t") -> bool + +ida_hexrays.qvector_carg_t.__getitem__(self, i: "size_t") -> "carg_t const &" + +ida_hexrays.qvector_carg_t.__init__(self, *args) + +ida_hexrays.qvector_carg_t.__len__(self) -> "size_t" + +ida_hexrays.qvector_carg_t.__ne__(self, r: "qvector_carg_t") -> bool + +ida_hexrays.qvector_carg_t.__setitem__(self, i: "size_t", v: "carg_t") -> None + +ida_hexrays.qvector_carg_t._del(self, x: "carg_t") -> bool + +ida_hexrays.qvector_carg_t.add_unique(self, x: "carg_t") -> bool + +ida_hexrays.qvector_carg_t.append(self, x: "carg_t") -> None + +ida_hexrays.qvector_carg_t.at(self, _idx: "size_t") -> "carg_t const &" + +ida_hexrays.qvector_carg_t.begin(self, *args) -> "qvector< carg_t >::const_iterator" + +ida_hexrays.qvector_carg_t.capacity(self) -> "size_t" + +ida_hexrays.qvector_carg_t.clear(self) -> None + +ida_hexrays.qvector_carg_t.empty(self) -> bool + +ida_hexrays.qvector_carg_t.end(self, *args) -> "qvector< carg_t >::const_iterator" + +ida_hexrays.qvector_carg_t.erase(self, *args) -> "qvector< carg_t >::iterator" + +ida_hexrays.qvector_carg_t.extend(self, x: "qvector_carg_t") -> None + +ida_hexrays.qvector_carg_t.extract(self) -> "carg_t *" + +ida_hexrays.qvector_carg_t.find(self, *args) -> "qvector< carg_t >::const_iterator" + +ida_hexrays.qvector_carg_t.grow(self, *args) -> None + +ida_hexrays.qvector_carg_t.has(self, x: "carg_t") -> bool + +ida_hexrays.qvector_carg_t.inject(self, s: "carg_t", len: "size_t") -> None + +ida_hexrays.qvector_carg_t.insert(self, it: "carg_t", x: "carg_t") -> "qvector< carg_t >::iterator" + +ida_hexrays.qvector_carg_t.pop_back(self) -> None + +ida_hexrays.qvector_carg_t.push_back(self, *args) -> "carg_t &" + +ida_hexrays.qvector_carg_t.qclear(self) -> None + +ida_hexrays.qvector_carg_t.reserve(self, cnt: "size_t") -> None + +ida_hexrays.qvector_carg_t.resize(self, *args) -> None + +ida_hexrays.qvector_carg_t.size(self) -> "size_t" + +ida_hexrays.qvector_carg_t.swap(self, r: "qvector_carg_t") -> None + +ida_hexrays.qvector_carg_t.truncate(self) -> None + +ida_hexrays.qvector_catchexprs_t + +ida_hexrays.qvector_catchexprs_t.__eq__(self, r: "qvector_catchexprs_t") -> bool + +ida_hexrays.qvector_catchexprs_t.__getitem__(self, i: "size_t") -> "catchexpr_t const &" + +ida_hexrays.qvector_catchexprs_t.__init__(self, *args) + +ida_hexrays.qvector_catchexprs_t.__len__(self) -> "size_t" + +ida_hexrays.qvector_catchexprs_t.__ne__(self, r: "qvector_catchexprs_t") -> bool + +ida_hexrays.qvector_catchexprs_t.__setitem__(self, i: "size_t", v: "catchexpr_t") -> None + +ida_hexrays.qvector_catchexprs_t._del(self, x: "catchexpr_t") -> bool + +ida_hexrays.qvector_catchexprs_t.add_unique(self, x: "catchexpr_t") -> bool + +ida_hexrays.qvector_catchexprs_t.append(self, x: "catchexpr_t") -> None + +ida_hexrays.qvector_catchexprs_t.at(self, _idx: "size_t") -> "catchexpr_t const &" + +ida_hexrays.qvector_catchexprs_t.begin(self, *args) -> "qvector< catchexpr_t >::const_iterator" + +ida_hexrays.qvector_catchexprs_t.capacity(self) -> "size_t" + +ida_hexrays.qvector_catchexprs_t.clear(self) -> None + +ida_hexrays.qvector_catchexprs_t.empty(self) -> bool + +ida_hexrays.qvector_catchexprs_t.end(self, *args) -> "qvector< catchexpr_t >::const_iterator" + +ida_hexrays.qvector_catchexprs_t.erase(self, *args) -> "qvector< catchexpr_t >::iterator" + +ida_hexrays.qvector_catchexprs_t.extend(self, x: "qvector_catchexprs_t") -> None + +ida_hexrays.qvector_catchexprs_t.extract(self) -> "catchexpr_t *" + +ida_hexrays.qvector_catchexprs_t.find(self, *args) -> "qvector< catchexpr_t >::const_iterator" + +ida_hexrays.qvector_catchexprs_t.grow(self, *args) -> None + +ida_hexrays.qvector_catchexprs_t.has(self, x: "catchexpr_t") -> bool + +ida_hexrays.qvector_catchexprs_t.inject(self, s: "catchexpr_t", len: "size_t") -> None + +ida_hexrays.qvector_catchexprs_t.insert(self, it: "catchexpr_t", x: "catchexpr_t") -> "qvector< catchexpr_t >::iterator" + +ida_hexrays.qvector_catchexprs_t.pop_back(self) -> None + +ida_hexrays.qvector_catchexprs_t.push_back(self, *args) -> "catchexpr_t &" + +ida_hexrays.qvector_catchexprs_t.qclear(self) -> None + +ida_hexrays.qvector_catchexprs_t.reserve(self, cnt: "size_t") -> None + +ida_hexrays.qvector_catchexprs_t.resize(self, *args) -> None + +ida_hexrays.qvector_catchexprs_t.size(self) -> "size_t" + +ida_hexrays.qvector_catchexprs_t.swap(self, r: "qvector_catchexprs_t") -> None + +ida_hexrays.qvector_catchexprs_t.truncate(self) -> None + +ida_hexrays.qvector_ccase_t + +ida_hexrays.qvector_ccase_t.__eq__(self, r: "qvector_ccase_t") -> bool + +ida_hexrays.qvector_ccase_t.__getitem__(self, i: "size_t") -> "ccase_t const &" + +ida_hexrays.qvector_ccase_t.__init__(self, *args) + +ida_hexrays.qvector_ccase_t.__len__(self) -> "size_t" + +ida_hexrays.qvector_ccase_t.__ne__(self, r: "qvector_ccase_t") -> bool + +ida_hexrays.qvector_ccase_t.__setitem__(self, i: "size_t", v: "ccase_t") -> None + +ida_hexrays.qvector_ccase_t._del(self, x: "ccase_t") -> bool + +ida_hexrays.qvector_ccase_t.add_unique(self, x: "ccase_t") -> bool + +ida_hexrays.qvector_ccase_t.append(self, x: "ccase_t") -> None + +ida_hexrays.qvector_ccase_t.at(self, _idx: "size_t") -> "ccase_t const &" + +ida_hexrays.qvector_ccase_t.begin(self, *args) -> "qvector< ccase_t >::const_iterator" + +ida_hexrays.qvector_ccase_t.capacity(self) -> "size_t" + +ida_hexrays.qvector_ccase_t.clear(self) -> None + +ida_hexrays.qvector_ccase_t.empty(self) -> bool + +ida_hexrays.qvector_ccase_t.end(self, *args) -> "qvector< ccase_t >::const_iterator" + +ida_hexrays.qvector_ccase_t.erase(self, *args) -> "qvector< ccase_t >::iterator" + +ida_hexrays.qvector_ccase_t.extend(self, x: "qvector_ccase_t") -> None + +ida_hexrays.qvector_ccase_t.extract(self) -> "ccase_t *" + +ida_hexrays.qvector_ccase_t.find(self, *args) -> "qvector< ccase_t >::const_iterator" + +ida_hexrays.qvector_ccase_t.grow(self, *args) -> None + +ida_hexrays.qvector_ccase_t.has(self, x: "ccase_t") -> bool + +ida_hexrays.qvector_ccase_t.inject(self, s: "ccase_t", len: "size_t") -> None + +ida_hexrays.qvector_ccase_t.insert(self, it: "ccase_t", x: "ccase_t") -> "qvector< ccase_t >::iterator" + +ida_hexrays.qvector_ccase_t.pop_back(self) -> None + +ida_hexrays.qvector_ccase_t.push_back(self, *args) -> "ccase_t &" + +ida_hexrays.qvector_ccase_t.qclear(self) -> None + +ida_hexrays.qvector_ccase_t.reserve(self, cnt: "size_t") -> None + +ida_hexrays.qvector_ccase_t.resize(self, *args) -> None + +ida_hexrays.qvector_ccase_t.size(self) -> "size_t" + +ida_hexrays.qvector_ccase_t.swap(self, r: "qvector_ccase_t") -> None + +ida_hexrays.qvector_ccase_t.truncate(self) -> None + +ida_hexrays.qvector_ccatchvec_t + +ida_hexrays.qvector_ccatchvec_t.__eq__(self, r: "qvector_ccatchvec_t") -> bool + +ida_hexrays.qvector_ccatchvec_t.__getitem__(self, i: "size_t") -> "ccatch_t const &" + +ida_hexrays.qvector_ccatchvec_t.__init__(self, *args) + +ida_hexrays.qvector_ccatchvec_t.__len__(self) -> "size_t" + +ida_hexrays.qvector_ccatchvec_t.__ne__(self, r: "qvector_ccatchvec_t") -> bool + +ida_hexrays.qvector_ccatchvec_t.__setitem__(self, i: "size_t", v: "ccatch_t") -> None + +ida_hexrays.qvector_ccatchvec_t._del(self, x: "ccatch_t") -> bool + +ida_hexrays.qvector_ccatchvec_t.add_unique(self, x: "ccatch_t") -> bool + +ida_hexrays.qvector_ccatchvec_t.append(self, x: "ccatch_t") -> None + +ida_hexrays.qvector_ccatchvec_t.at(self, _idx: "size_t") -> "ccatch_t const &" + +ida_hexrays.qvector_ccatchvec_t.begin(self, *args) -> "qvector< ccatch_t >::const_iterator" + +ida_hexrays.qvector_ccatchvec_t.capacity(self) -> "size_t" + +ida_hexrays.qvector_ccatchvec_t.clear(self) -> None + +ida_hexrays.qvector_ccatchvec_t.empty(self) -> bool + +ida_hexrays.qvector_ccatchvec_t.end(self, *args) -> "qvector< ccatch_t >::const_iterator" + +ida_hexrays.qvector_ccatchvec_t.erase(self, *args) -> "qvector< ccatch_t >::iterator" + +ida_hexrays.qvector_ccatchvec_t.extend(self, x: "qvector_ccatchvec_t") -> None + +ida_hexrays.qvector_ccatchvec_t.extract(self) -> "ccatch_t *" + +ida_hexrays.qvector_ccatchvec_t.find(self, *args) -> "qvector< ccatch_t >::const_iterator" + +ida_hexrays.qvector_ccatchvec_t.grow(self, *args) -> None + +ida_hexrays.qvector_ccatchvec_t.has(self, x: "ccatch_t") -> bool + +ida_hexrays.qvector_ccatchvec_t.inject(self, s: "ccatch_t", len: "size_t") -> None + +ida_hexrays.qvector_ccatchvec_t.insert(self, it: "ccatch_t", x: "ccatch_t") -> "qvector< ccatch_t >::iterator" + +ida_hexrays.qvector_ccatchvec_t.pop_back(self) -> None + +ida_hexrays.qvector_ccatchvec_t.push_back(self, *args) -> "ccatch_t &" + +ida_hexrays.qvector_ccatchvec_t.qclear(self) -> None + +ida_hexrays.qvector_ccatchvec_t.reserve(self, cnt: "size_t") -> None + +ida_hexrays.qvector_ccatchvec_t.resize(self, *args) -> None + +ida_hexrays.qvector_ccatchvec_t.size(self) -> "size_t" + +ida_hexrays.qvector_ccatchvec_t.swap(self, r: "qvector_ccatchvec_t") -> None + +ida_hexrays.qvector_ccatchvec_t.truncate(self) -> None + +ida_hexrays.qvector_history_t + +ida_hexrays.qvector_history_t.__eq__(self, r: "qvector_history_t") -> bool + +ida_hexrays.qvector_history_t.__getitem__(self, i: "size_t") -> "history_item_t const &" + +ida_hexrays.qvector_history_t.__init__(self, *args) + +ida_hexrays.qvector_history_t.__len__(self) -> "size_t" + +ida_hexrays.qvector_history_t.__ne__(self, r: "qvector_history_t") -> bool + +ida_hexrays.qvector_history_t.__setitem__(self, i: "size_t", v: "history_item_t") -> None + +ida_hexrays.qvector_history_t._del(self, x: "history_item_t") -> bool + +ida_hexrays.qvector_history_t.add_unique(self, x: "history_item_t") -> bool + +ida_hexrays.qvector_history_t.append(self, x: "history_item_t") -> None + +ida_hexrays.qvector_history_t.at(self, _idx: "size_t") -> "history_item_t const &" + +ida_hexrays.qvector_history_t.begin(self, *args) -> "qvector< history_item_t >::const_iterator" + +ida_hexrays.qvector_history_t.capacity(self) -> "size_t" + +ida_hexrays.qvector_history_t.clear(self) -> None + +ida_hexrays.qvector_history_t.empty(self) -> bool + +ida_hexrays.qvector_history_t.end(self, *args) -> "qvector< history_item_t >::const_iterator" + +ida_hexrays.qvector_history_t.erase(self, *args) -> "qvector< history_item_t >::iterator" + +ida_hexrays.qvector_history_t.extend(self, x: "qvector_history_t") -> None + +ida_hexrays.qvector_history_t.extract(self) -> "history_item_t *" + +ida_hexrays.qvector_history_t.find(self, *args) -> "qvector< history_item_t >::const_iterator" + +ida_hexrays.qvector_history_t.grow(self, *args) -> None + +ida_hexrays.qvector_history_t.has(self, x: "history_item_t") -> bool + +ida_hexrays.qvector_history_t.inject(self, s: "history_item_t", len: "size_t") -> None + +ida_hexrays.qvector_history_t.insert(self, it: "history_item_t", x: "history_item_t") -> "qvector< history_item_t >::iterator" + +ida_hexrays.qvector_history_t.pop_back(self) -> None + +ida_hexrays.qvector_history_t.push_back(self, *args) -> "history_item_t &" + +ida_hexrays.qvector_history_t.qclear(self) -> None + +ida_hexrays.qvector_history_t.reserve(self, cnt: "size_t") -> None + +ida_hexrays.qvector_history_t.resize(self, *args) -> None + +ida_hexrays.qvector_history_t.size(self) -> "size_t" + +ida_hexrays.qvector_history_t.swap(self, r: "qvector_history_t") -> None + +ida_hexrays.qvector_history_t.truncate(self) -> None + +ida_hexrays.qvector_lvar_t + +ida_hexrays.qvector_lvar_t.__eq__(self, r: "qvector_lvar_t") -> bool + +ida_hexrays.qvector_lvar_t.__getitem__(self, i: "size_t") -> "lvar_t const &" + +ida_hexrays.qvector_lvar_t.__init__(self, *args) + +ida_hexrays.qvector_lvar_t.__len__(self) -> "size_t" + +ida_hexrays.qvector_lvar_t.__ne__(self, r: "qvector_lvar_t") -> bool + +ida_hexrays.qvector_lvar_t.__setitem__(self, i: "size_t", v: "lvar_t") -> None + +ida_hexrays.qvector_lvar_t._del(self, x: "lvar_t") -> bool + +ida_hexrays.qvector_lvar_t.add_unique(self, x: "lvar_t") -> bool + +ida_hexrays.qvector_lvar_t.append(self, x: "lvar_t") -> None + +ida_hexrays.qvector_lvar_t.at(self, _idx: "size_t") -> "lvar_t const &" + +ida_hexrays.qvector_lvar_t.begin(self, *args) -> "qvector< lvar_t >::const_iterator" + +ida_hexrays.qvector_lvar_t.capacity(self) -> "size_t" + +ida_hexrays.qvector_lvar_t.clear(self) -> None + +ida_hexrays.qvector_lvar_t.empty(self) -> bool + +ida_hexrays.qvector_lvar_t.end(self, *args) -> "qvector< lvar_t >::const_iterator" + +ida_hexrays.qvector_lvar_t.erase(self, *args) -> "qvector< lvar_t >::iterator" + +ida_hexrays.qvector_lvar_t.extend(self, x: "qvector_lvar_t") -> None + +ida_hexrays.qvector_lvar_t.extract(self) -> "lvar_t *" + +ida_hexrays.qvector_lvar_t.find(self, *args) -> "qvector< lvar_t >::const_iterator" + +ida_hexrays.qvector_lvar_t.grow(self, *args) -> None + +ida_hexrays.qvector_lvar_t.has(self, x: "lvar_t") -> bool + +ida_hexrays.qvector_lvar_t.inject(self, s: "lvar_t", len: "size_t") -> None + +ida_hexrays.qvector_lvar_t.insert(self, it: "lvar_t", x: "lvar_t") -> "qvector< lvar_t >::iterator" + +ida_hexrays.qvector_lvar_t.pop_back(self) -> None + +ida_hexrays.qvector_lvar_t.push_back(self, *args) -> "lvar_t &" + +ida_hexrays.qvector_lvar_t.qclear(self) -> None + +ida_hexrays.qvector_lvar_t.reserve(self, cnt: "size_t") -> None + +ida_hexrays.qvector_lvar_t.resize(self, *args) -> None + +ida_hexrays.qvector_lvar_t.size(self) -> "size_t" + +ida_hexrays.qvector_lvar_t.swap(self, r: "qvector_lvar_t") -> None + +ida_hexrays.qvector_lvar_t.truncate(self) -> None + +ida_hexrays.reg2mreg(reg: int) -> "mreg_t" + Map a processor register to a microregister. + + @param reg: processor register number + @returns microregister register id or mr_none + +ida_hexrays.remitem(e: "citem_t") -> None + +ida_hexrays.remove_hexrays_callback(callback) + Uninstall handler for decompiler events. + + @param callback: handler to uninstall + @returns number of uninstalled handlers. + +ida_hexrays.rename_lvar(func_ea: ida_idaapi.ea_t, oldname: str, newname: str) -> bool + Rename a local variable. + + @param func_ea: function start address + @param oldname: old name of the variable + @param newname: new name of the variable + @returns success This is a convenience function. For bulk renaming consider using modify_user_lvars. + +ida_hexrays.restore_user_cmts(func_ea: ida_idaapi.ea_t) -> "user_cmts_t *" + Restore user defined comments from the database. + + @param func_ea: the entry address of the function + @returns collection of user defined comments. The returned object must be deleted by the caller using delete_user_cmts() + +ida_hexrays.restore_user_defined_calls(udcalls: "udcall_map_t *", func_ea: ida_idaapi.ea_t) -> bool + Restore user defined function calls from the database. + + @param udcalls: ptr to output buffer + @param func_ea: entry address of the function + @returns success + +ida_hexrays.restore_user_iflags(func_ea: ida_idaapi.ea_t) -> "user_iflags_t *" + Restore user defined citem iflags from the database. + + @param func_ea: the entry address of the function + @returns collection of user defined iflags. The returned object must be deleted by the caller using delete_user_iflags() + +ida_hexrays.restore_user_labels(func_ea: ida_idaapi.ea_t, func: "cfunc_t" = None) -> "user_labels_t *" + Restore user defined labels from the database. + + @param func_ea: the entry address of the function, ignored if FUNC != nullptr + @param func: pointer to current function + @returns collection of user defined labels. The returned object must be deleted by the caller using delete_user_labels() + +ida_hexrays.restore_user_lvar_settings(lvinf: "lvar_uservec_t", func_ea: ida_idaapi.ea_t) -> bool + Restore user defined local variable settings in the database. + + @param lvinf: ptr to output buffer + @param func_ea: entry address of the function + @returns success + +ida_hexrays.restore_user_numforms(func_ea: ida_idaapi.ea_t) -> "user_numforms_t *" + Restore user defined number formats from the database. + + @param func_ea: the entry address of the function + @returns collection of user defined number formats. The returned object must be deleted by the caller using delete_user_numforms() + +ida_hexrays.restore_user_unions(func_ea: ida_idaapi.ea_t) -> "user_unions_t *" + Restore user defined union field selections from the database. + + @param func_ea: the entry address of the function + @returns collection of union field selections The returned object must be deleted by the caller using delete_user_unions() + +ida_hexrays.rlist_t + +ida_hexrays.rlist_t.__init__(self, *args) + +ida_hexrays.rlist_t.dstr(self) -> str + +ida_hexrays.save_user_cmts(func_ea: ida_idaapi.ea_t, user_cmts: "user_cmts_t") -> None + Save user defined comments into the database. + + @param func_ea: the entry address of the function + @param user_cmts: collection of user defined comments + +ida_hexrays.save_user_defined_calls(func_ea: ida_idaapi.ea_t, udcalls: "udcall_map_t const &") -> None + Save user defined local function calls into the database. + + @param func_ea: entry address of the function + @param udcalls: user-specified info about user defined function calls + +ida_hexrays.save_user_iflags(func_ea: ida_idaapi.ea_t, iflags: "user_iflags_t") -> None + Save user defined citem iflags into the database. + + @param func_ea: the entry address of the function + @param iflags: collection of user defined citem iflags + +ida_hexrays.save_user_labels(func_ea: ida_idaapi.ea_t, user_labels: "user_labels_t", func: "cfunc_t" = None) -> None + Save user defined labels into the database. + + @param func_ea: the entry address of the function, ignored if FUNC != nullptr + @param user_labels: collection of user defined labels + @param func: pointer to current function, if FUNC != nullptr, then save labels using a more stable method that preserves them even when the decompiler output drastically changes + +ida_hexrays.save_user_lvar_settings(func_ea: ida_idaapi.ea_t, lvinf: "lvar_uservec_t") -> None + Save user defined local variable settings into the database. + + @param func_ea: entry address of the function + @param lvinf: user-specified info about local variables + +ida_hexrays.save_user_numforms(func_ea: ida_idaapi.ea_t, numforms: "user_numforms_t") -> None + Save user defined number formats into the database. + + @param func_ea: the entry address of the function + @param numforms: collection of user defined comments + +ida_hexrays.save_user_unions(func_ea: ida_idaapi.ea_t, unions: "user_unions_t") -> None + Save user defined union field selections into the database. + + @param func_ea: the entry address of the function + @param unions: collection of union field selections + +ida_hexrays.scif_t + +ida_hexrays.scif_t.__init__(self, _mba: "mba_t", tif: "tinfo_t", n: str = None) + +ida_hexrays.scif_t.mba + Pointer to the parent mba_t object. Some operations may convert a scattered operand into something simpler, (a stack operand, for example). We will need to create stkvar_ref_t at that moment, this is why we need this pointer. See notes for lvar_ref_t::mba. + + +ida_hexrays.scif_t.name + Usually scattered operands are created from a function prototype, which has the name information. We preserve it and use it to name the corresponding local variable. + + +ida_hexrays.scif_t.type + Scattered operands always have type info assigned to them because without it we won't be able to manipulte them. + + +ida_hexrays.scif_visitor_t + +ida_hexrays.scif_visitor_t.__disown__(self) + +ida_hexrays.scif_visitor_t.__init__(self) + +ida_hexrays.scif_visitor_t.visit_scif_mop(self, r: "mop_t", off: int) -> int + +ida_hexrays.select_udt_by_offset(udts: "qvector< tinfo_t > const *", ops: "ui_stroff_ops_t", applicator: "ui_stroff_applicator_t") -> int + Select UDT + + @param udts: list of UDT tinfo_t for the selection, if nullptr or empty then UDTs from the "Local types" will be used + @param ops: operands + @param applicator: callback will be called to apply the selection for every operand + +ida_hexrays.send_database(err: "hexrays_failure_t", silent: bool) -> None + Send the database to Hex-Rays. This function sends the current database to the Hex-Rays server. The database is sent in the compressed form over an encrypted (SSL) connection. + + @param err: failure description object. Empty hexrays_failure_t object can be used if error information is not available. + @param silent: if false, a dialog box will be displayed before sending the database. + +ida_hexrays.set2jcnd(code: "mcode_t") -> "mcode_t" + +ida_hexrays.set_type(id: int, tif: "tinfo_t", source: "type_source_t", force: bool = False) -> bool + Set a global type. + + @param id: address or id of the object + @param tif: new type info + @param source: where the type comes from + @param force: true means to set the type as is, false means to merge the new type with the possibly existing old type info. + @returns success + +ida_hexrays.simple_graph_t + +ida_hexrays.simple_graph_t.__init__(self, *args, **kwargs) + +ida_hexrays.simple_graph_t.begin(self) -> "simple_graph_t::iterator" + +ida_hexrays.simple_graph_t.compute_dominators(self, domin: "array_of_node_bitset_t", post: bool = False) -> None + +ida_hexrays.simple_graph_t.compute_immediate_dominators(self, domin: "array_of_node_bitset_t", idomin: "intvec_t", post: bool = False) -> None + +ida_hexrays.simple_graph_t.depth_first_postorder(self, post: "node_ordering_t") -> int + +ida_hexrays.simple_graph_t.depth_first_preorder(self, pre: "node_ordering_t") -> int + +ida_hexrays.simple_graph_t.end(self) -> "simple_graph_t::iterator" + +ida_hexrays.simple_graph_t.front(self) -> int + +ida_hexrays.simple_graph_t.goup(self, node: int) -> int + +ida_hexrays.simple_graph_t.inc(self, p: "simple_graph_t::iterator &", n: int = 1) -> None + +ida_hexrays.stkvar_ref_t + +ida_hexrays.stkvar_ref_t.__eq__(self, r: "stkvar_ref_t") -> bool + +ida_hexrays.stkvar_ref_t.__ge__(self, r: "stkvar_ref_t") -> bool + +ida_hexrays.stkvar_ref_t.__gt__(self, r: "stkvar_ref_t") -> bool + +ida_hexrays.stkvar_ref_t.__init__(self, m: "mba_t", o: int) + +ida_hexrays.stkvar_ref_t.__le__(self, r: "stkvar_ref_t") -> bool + +ida_hexrays.stkvar_ref_t.__lt__(self, r: "stkvar_ref_t") -> bool + +ida_hexrays.stkvar_ref_t.__ne__(self, r: "stkvar_ref_t") -> bool + +ida_hexrays.stkvar_ref_t.compare(self, r: "stkvar_ref_t") -> int + +ida_hexrays.stkvar_ref_t.get_stkvar(self, udm: "udm_t" = None, p_idaoff: "uval_t *" = None) -> "ssize_t" + Retrieve the referenced stack variable. + + @param udm: stkvar, may be nullptr + @param p_idaoff: if specified, will hold IDA stkoff after the call. + @returns index of stkvar in the frame or -1 + +ida_hexrays.stkvar_ref_t.mba + Pointer to the parent mba_t object. We need it in order to retrieve the referenced stack variable. See notes for lvar_ref_t::mba. + + +ida_hexrays.stkvar_ref_t.off + Offset to the stack variable from the bottom of the stack frame. It is called 'decompiler stkoff' and it is different from IDA stkoff. See a note and a picture about 'decompiler stkoff' below. + + +ida_hexrays.stkvar_ref_t.swap(self, r: "stkvar_ref_t") -> None + +ida_hexrays.swap_mcode_relation(code: "mcode_t") -> "mcode_t" + +ida_hexrays.swapped_relation(op: "ctype_t") -> "ctype_t" Swap a comparison operator. For example, cot_sge becomes cot_sle. - - @param op: (C++: ctype_t) enum ctype_t -ida_hexrays.term_hexrays_plugin (function) - term_hexrays_plugin() +ida_hexrays.term_hexrays_plugin() -> None Stop working with hex-rays decompiler. -ida_hexrays.treeloc_t (class) - Proxy of C++ treeloc_t class. +ida_hexrays.treeloc_t -ida_hexrays.treeloc_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: treeloc_t const & +ida_hexrays.treeloc_t.__eq__(self, r: "treeloc_t") -> bool -ida_hexrays.treeloc_t.__init__ (method) - __init__(self) -> treeloc_t +ida_hexrays.treeloc_t.__init__(self) -ida_hexrays.treeloc_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: treeloc_t const & +ida_hexrays.treeloc_t.__lt__(self, r: "treeloc_t") -> bool -ida_hexrays.udc_filter_t (class) - Proxy of C++ udc_filter_t class. +ida_hexrays.udc_filter_t -ida_hexrays.udc_filter_t.__disown__ (method) +ida_hexrays.udc_filter_t.__disown__(self) -ida_hexrays.udc_filter_t.__init__ (method) - __init__(self) -> udc_filter_t - - @param self: PyObject * +ida_hexrays.udc_filter_t.__init__(self) -ida_hexrays.udc_filter_t.apply (method) - apply(self, cdg) -> merror_t - generate microcode for an instruction - - @param cdg: (C++: codegen_t &) - @return: MERR_... code: MERR_OK - user-defined microcode generated, go to the - next instruction MERR_INSN - not generated - the caller should try the - standard way else - error +ida_hexrays.udc_filter_t.apply(self, cdg: "codegen_t") -> "merror_t" + generate microcode for an instruction + + @returns MERR_... code: MERR_OK - user-defined microcode generated, go to the next instruction MERR_INSN - not generated - the caller should try the standard way else - error -ida_hexrays.udc_filter_t.cleanup (method) - cleanup(self) - Cleanup the filter This function properly clears type information associated to - this filter. +ida_hexrays.udc_filter_t.cleanup(self) -> None + Cleanup the filter This function properly clears type information associated to this filter. + -ida_hexrays.udc_filter_t.empty (method) - empty(self) -> bool +ida_hexrays.udc_filter_t.empty(self) -> bool -ida_hexrays.udc_filter_t.init (method) - init(self, decl) -> bool - - @param decl: char const * +ida_hexrays.udc_filter_t.init(self, decl: str) -> bool -ida_hexrays.udc_filter_t.install (method) - install(self) +ida_hexrays.udc_filter_t.install(self) -> None -ida_hexrays.udc_filter_t.match (method) - match(self, cdg) -> bool +ida_hexrays.udc_filter_t.match(self, cdg: "codegen_t") -> bool return true if the filter object should be applied to given instruction - - @param cdg: (C++: codegen_t &) -ida_hexrays.udc_filter_t.remove (method) - remove(self) -> bool +ida_hexrays.udc_filter_t.remove(self) -> bool -ida_hexrays.udcall_map_begin (function) - udcall_map_begin(map) -> udcall_map_iterator_t +ida_hexrays.udcall_map_begin(map: "udcall_map_t const *") -> "udcall_map_iterator_t" Get iterator pointing to the beginning of udcall_map_t. - - @param map: (C++: const udcall_map_t *) udcall_map_t const * -ida_hexrays.udcall_map_clear (function) - udcall_map_clear(map) +ida_hexrays.udcall_map_clear(map: "udcall_map_t *") -> None Clear udcall_map_t. - - @param map: (C++: udcall_map_t *) -ida_hexrays.udcall_map_end (function) - udcall_map_end(map) -> udcall_map_iterator_t +ida_hexrays.udcall_map_end(map: "udcall_map_t const *") -> "udcall_map_iterator_t" Get iterator pointing to the end of udcall_map_t. - - @param map: (C++: const udcall_map_t *) udcall_map_t const * -ida_hexrays.udcall_map_erase (function) - udcall_map_erase(map, p) +ida_hexrays.udcall_map_erase(map: "udcall_map_t *", p: "udcall_map_iterator_t") -> None Erase current element from udcall_map_t. - - @param map: (C++: udcall_map_t *) - @param p: (C++: udcall_map_iterator_t) -ida_hexrays.udcall_map_find (function) - udcall_map_find(map, key) -> udcall_map_iterator_t +ida_hexrays.udcall_map_find(map: "udcall_map_t const *", key: "ea_t const &") -> "udcall_map_iterator_t" Find the specified key in udcall_map_t. - - @param map: (C++: const udcall_map_t *) udcall_map_t const * - @param key: (C++: const ea_t &) ea_t const & -ida_hexrays.udcall_map_first (function) - udcall_map_first(p) -> ea_t const & +ida_hexrays.udcall_map_first(p: "udcall_map_iterator_t") -> "ea_t const &" Get reference to the current map key. - - @param p: (C++: udcall_map_iterator_t) -ida_hexrays.udcall_map_free (function) - udcall_map_free(map) +ida_hexrays.udcall_map_free(map: "udcall_map_t *") -> None Delete udcall_map_t instance. - - @param map: (C++: udcall_map_t *) -ida_hexrays.udcall_map_insert (function) - udcall_map_insert(map, key, val) -> udcall_map_iterator_t +ida_hexrays.udcall_map_insert(map: "udcall_map_t *", key: "ea_t const &", val: "udcall_t") -> "udcall_map_iterator_t" Insert new (ea_t, udcall_t) pair into udcall_map_t. - - @param map: (C++: udcall_map_t *) - @param key: (C++: const ea_t &) ea_t const & - @param val: (C++: const udcall_t &) udcall_t const & -ida_hexrays.udcall_map_iterator_t (class) - Proxy of C++ udcall_map_iterator_t class. +ida_hexrays.udcall_map_iterator_t -ida_hexrays.udcall_map_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: udcall_map_iterator_t const & +ida_hexrays.udcall_map_iterator_t.__eq__(self, p: "udcall_map_iterator_t") -> bool -ida_hexrays.udcall_map_iterator_t.__init__ (method) - __init__(self) -> udcall_map_iterator_t +ida_hexrays.udcall_map_iterator_t.__init__(self) -ida_hexrays.udcall_map_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: udcall_map_iterator_t const & +ida_hexrays.udcall_map_iterator_t.__ne__(self, p: "udcall_map_iterator_t") -> bool -ida_hexrays.udcall_map_new (function) - udcall_map_new() -> udcall_map_t * +ida_hexrays.udcall_map_new() -> "udcall_map_t *" Create a new udcall_map_t instance. -ida_hexrays.udcall_map_next (function) - udcall_map_next(p) -> udcall_map_iterator_t +ida_hexrays.udcall_map_next(p: "udcall_map_iterator_t") -> "udcall_map_iterator_t" Move to the next element. - - @param p: (C++: udcall_map_iterator_t) -ida_hexrays.udcall_map_prev (function) - udcall_map_prev(p) -> udcall_map_iterator_t +ida_hexrays.udcall_map_prev(p: "udcall_map_iterator_t") -> "udcall_map_iterator_t" Move to the previous element. - - @param p: (C++: udcall_map_iterator_t) -ida_hexrays.udcall_map_second (function) - udcall_map_second(p) -> udcall_t +ida_hexrays.udcall_map_second(p: "udcall_map_iterator_t") -> "udcall_t &" Get reference to the current map value. - - @param p: (C++: udcall_map_iterator_t) -ida_hexrays.udcall_map_size (function) - udcall_map_size(map) -> size_t +ida_hexrays.udcall_map_size(map: "udcall_map_t *") -> "size_t" Get size of udcall_map_t. - - @param map: (C++: udcall_map_t *) -ida_hexrays.udcall_t (class) - Proxy of C++ udcall_t class. +ida_hexrays.udcall_t -ida_hexrays.udcall_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: udcall_t const & +ida_hexrays.udcall_t.__eq__(self, r: "udcall_t") -> bool -ida_hexrays.udcall_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: udcall_t const & +ida_hexrays.udcall_t.__ge__(self, r: "udcall_t") -> bool -ida_hexrays.udcall_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: udcall_t const & +ida_hexrays.udcall_t.__gt__(self, r: "udcall_t") -> bool -ida_hexrays.udcall_t.__init__ (method) - __init__(self) -> udcall_t +ida_hexrays.udcall_t.__init__(self) -ida_hexrays.udcall_t.__le__ (method) - __le__(self, r) -> bool - - @param r: udcall_t const & +ida_hexrays.udcall_t.__le__(self, r: "udcall_t") -> bool -ida_hexrays.udcall_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: udcall_t const & +ida_hexrays.udcall_t.__lt__(self, r: "udcall_t") -> bool -ida_hexrays.udcall_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: udcall_t const & +ida_hexrays.udcall_t.__ne__(self, r: "udcall_t") -> bool -ida_hexrays.udcall_t.compare (method) - compare(self, r) -> int - - @param r: udcall_t const & +ida_hexrays.udcall_t.compare(self, r: "udcall_t") -> int -ida_hexrays.udcall_t.empty (method) - empty(self) -> bool +ida_hexrays.udcall_t.empty(self) -> bool -ida_hexrays.ui_stroff_applicator_t (class) - Proxy of C++ ui_stroff_applicator_t class. +ida_hexrays.ui_stroff_applicator_t -ida_hexrays.ui_stroff_applicator_t.__disown__ (method) +ida_hexrays.ui_stroff_applicator_t.__disown__(self) -ida_hexrays.ui_stroff_applicator_t.__init__ (method) - __init__(self) -> ui_stroff_applicator_t - - @param self: PyObject * +ida_hexrays.ui_stroff_applicator_t.__init__(self) -ida_hexrays.ui_stroff_applicator_t.apply (method) - apply(self, opnum, path, top_tif, spath) -> bool - - @param opnum: (C++: size_t) operand ordinal number, see below - @param path: (C++: const intvec_t &) path describing the union selection, maybe empty - @param top_tif: (C++: const tinfo_t &) tinfo_t of the selected toplevel UDT - @param spath: (C++: const char *) selected path +ida_hexrays.ui_stroff_applicator_t.apply(self, opnum: "size_t", path: "intvec_t", top_tif: "tinfo_t", spath: str) -> bool + @param opnum: operand ordinal number, see below + @param path: path describing the union selection, maybe empty + @param top_tif: tinfo_t of the selected toplevel UDT + @param spath: selected path -ida_hexrays.ui_stroff_op_t (class) - Proxy of C++ ui_stroff_op_t class. +ida_hexrays.ui_stroff_op_t -ida_hexrays.ui_stroff_op_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ui_stroff_op_t const & +ida_hexrays.ui_stroff_op_t.__eq__(self, r: "ui_stroff_op_t") -> bool -ida_hexrays.ui_stroff_op_t.__init__ (method) - __init__(self) -> ui_stroff_op_t +ida_hexrays.ui_stroff_op_t.__init__(self) -ida_hexrays.ui_stroff_op_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ui_stroff_op_t const & +ida_hexrays.ui_stroff_op_t.__ne__(self, r: "ui_stroff_op_t") -> bool -ida_hexrays.ui_stroff_op_t.offset (variable) +ida_hexrays.ui_stroff_op_t.offset operand offset, will be used when calculating the UDT path -ida_hexrays.ui_stroff_op_t.text (variable) +ida_hexrays.ui_stroff_op_t.text any text for the column "Operand" of widget -ida_hexrays.ui_stroff_ops_t (class) - Proxy of C++ qvector< ui_stroff_op_t > class. +ida_hexrays.ui_stroff_ops_t -ida_hexrays.ui_stroff_ops_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< ui_stroff_op_t > const & +ida_hexrays.ui_stroff_ops_t.__eq__(self, r: "ui_stroff_ops_t") -> bool -ida_hexrays.ui_stroff_ops_t.__getitem__ (method) - __getitem__(self, i) -> ui_stroff_op_t - - @param i: size_t +ida_hexrays.ui_stroff_ops_t.__getitem__(self, i: "size_t") -> "ui_stroff_op_t const &" -ida_hexrays.ui_stroff_ops_t.__init__ (method) - __init__(self) -> ui_stroff_ops_t - __init__(self, x) -> ui_stroff_ops_t - - @param x: qvector< ui_stroff_op_t > const & +ida_hexrays.ui_stroff_ops_t.__init__(self, *args) -ida_hexrays.ui_stroff_ops_t.__len__ (method) - __len__(self) -> size_t +ida_hexrays.ui_stroff_ops_t.__len__(self) -> "size_t" -ida_hexrays.ui_stroff_ops_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< ui_stroff_op_t > const & +ida_hexrays.ui_stroff_ops_t.__ne__(self, r: "ui_stroff_ops_t") -> bool -ida_hexrays.ui_stroff_ops_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ui_stroff_op_t const & +ida_hexrays.ui_stroff_ops_t.__setitem__(self, i: "size_t", v: "ui_stroff_op_t") -> None -ida_hexrays.ui_stroff_ops_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: ui_stroff_op_t const & +ida_hexrays.ui_stroff_ops_t._del(self, x: "ui_stroff_op_t") -> bool -ida_hexrays.ui_stroff_ops_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: ui_stroff_op_t const & +ida_hexrays.ui_stroff_ops_t.add_unique(self, x: "ui_stroff_op_t") -> bool -ida_hexrays.ui_stroff_ops_t.at (method) - at(self, _idx) -> ui_stroff_op_t - - @param _idx: size_t +ida_hexrays.ui_stroff_ops_t.append(self, x: "ui_stroff_op_t") -> None -ida_hexrays.ui_stroff_ops_t.begin (method) - begin(self) -> ui_stroff_op_t +ida_hexrays.ui_stroff_ops_t.at(self, _idx: "size_t") -> "ui_stroff_op_t const &" -ida_hexrays.ui_stroff_ops_t.capacity (method) - capacity(self) -> size_t +ida_hexrays.ui_stroff_ops_t.begin(self, *args) -> "qvector< ui_stroff_op_t >::const_iterator" -ida_hexrays.ui_stroff_ops_t.clear (method) - clear(self) +ida_hexrays.ui_stroff_ops_t.capacity(self) -> "size_t" -ida_hexrays.ui_stroff_ops_t.empty (method) - empty(self) -> bool +ida_hexrays.ui_stroff_ops_t.clear(self) -> None -ida_hexrays.ui_stroff_ops_t.end (method) - end(self) -> ui_stroff_op_t +ida_hexrays.ui_stroff_ops_t.empty(self) -> bool -ida_hexrays.ui_stroff_ops_t.erase (method) - erase(self, it) -> ui_stroff_op_t - - @param it: qvector< ui_stroff_op_t >::iterator - - erase(self, first, last) -> ui_stroff_op_t - - @param first: qvector< ui_stroff_op_t >::iterator - @param last: qvector< ui_stroff_op_t >::iterator +ida_hexrays.ui_stroff_ops_t.end(self, *args) -> "qvector< ui_stroff_op_t >::const_iterator" -ida_hexrays.ui_stroff_ops_t.extract (method) - extract(self) -> ui_stroff_op_t +ida_hexrays.ui_stroff_ops_t.erase(self, *args) -> "qvector< ui_stroff_op_t >::iterator" -ida_hexrays.ui_stroff_ops_t.find (method) - find(self, x) -> ui_stroff_op_t - - @param x: ui_stroff_op_t const & +ida_hexrays.ui_stroff_ops_t.extend(self, x: "ui_stroff_ops_t") -> None -ida_hexrays.ui_stroff_ops_t.grow (method) - grow(self, x=ui_stroff_op_t()) - - @param x: ui_stroff_op_t const & +ida_hexrays.ui_stroff_ops_t.extract(self) -> "ui_stroff_op_t *" -ida_hexrays.ui_stroff_ops_t.has (method) - has(self, x) -> bool - - @param x: ui_stroff_op_t const & +ida_hexrays.ui_stroff_ops_t.find(self, *args) -> "qvector< ui_stroff_op_t >::const_iterator" -ida_hexrays.ui_stroff_ops_t.inject (method) - inject(self, s, len) - - @param s: ui_stroff_op_t * - @param len: size_t +ida_hexrays.ui_stroff_ops_t.grow(self, *args) -> None -ida_hexrays.ui_stroff_ops_t.insert (method) - insert(self, it, x) -> ui_stroff_op_t - - @param it: qvector< ui_stroff_op_t >::iterator - @param x: ui_stroff_op_t const & +ida_hexrays.ui_stroff_ops_t.has(self, x: "ui_stroff_op_t") -> bool -ida_hexrays.ui_stroff_ops_t.pop_back (method) - pop_back(self) +ida_hexrays.ui_stroff_ops_t.inject(self, s: "ui_stroff_op_t", len: "size_t") -> None -ida_hexrays.ui_stroff_ops_t.push_back (method) - push_back(self, x) - - @param x: ui_stroff_op_t const & - - push_back(self) -> ui_stroff_op_t +ida_hexrays.ui_stroff_ops_t.insert(self, it: "ui_stroff_op_t", x: "ui_stroff_op_t") -> "qvector< ui_stroff_op_t >::iterator" -ida_hexrays.ui_stroff_ops_t.qclear (method) - qclear(self) +ida_hexrays.ui_stroff_ops_t.pop_back(self) -> None -ida_hexrays.ui_stroff_ops_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_hexrays.ui_stroff_ops_t.push_back(self, *args) -> "ui_stroff_op_t &" -ida_hexrays.ui_stroff_ops_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ui_stroff_op_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_hexrays.ui_stroff_ops_t.qclear(self) -> None -ida_hexrays.ui_stroff_ops_t.size (method) - size(self) -> size_t +ida_hexrays.ui_stroff_ops_t.reserve(self, cnt: "size_t") -> None -ida_hexrays.ui_stroff_ops_t.swap (method) - swap(self, r) - - @param r: qvector< ui_stroff_op_t > & +ida_hexrays.ui_stroff_ops_t.resize(self, *args) -> None -ida_hexrays.ui_stroff_ops_t.truncate (method) - truncate(self) +ida_hexrays.ui_stroff_ops_t.size(self) -> "size_t" -ida_hexrays.user_cmts_begin (function) - user_cmts_begin(map) -> user_cmts_iterator_t +ida_hexrays.ui_stroff_ops_t.swap(self, r: "ui_stroff_ops_t") -> None + +ida_hexrays.ui_stroff_ops_t.truncate(self) -> None + +ida_hexrays.user_cmts_begin(map: "user_cmts_t") -> "user_cmts_iterator_t" Get iterator pointing to the beginning of user_cmts_t. - - @param map: (C++: const user_cmts_t *) user_cmts_t const * -ida_hexrays.user_cmts_clear (function) - user_cmts_clear(map) +ida_hexrays.user_cmts_clear(map: "user_cmts_t") -> None Clear user_cmts_t. - - @param map: (C++: user_cmts_t *) -ida_hexrays.user_cmts_end (function) - user_cmts_end(map) -> user_cmts_iterator_t +ida_hexrays.user_cmts_end(map: "user_cmts_t") -> "user_cmts_iterator_t" Get iterator pointing to the end of user_cmts_t. - - @param map: (C++: const user_cmts_t *) user_cmts_t const * -ida_hexrays.user_cmts_erase (function) - user_cmts_erase(map, p) +ida_hexrays.user_cmts_erase(map: "user_cmts_t", p: "user_cmts_iterator_t") -> None Erase current element from user_cmts_t. - - @param map: (C++: user_cmts_t *) - @param p: (C++: user_cmts_iterator_t) -ida_hexrays.user_cmts_find (function) - user_cmts_find(map, key) -> user_cmts_iterator_t +ida_hexrays.user_cmts_find(map: "user_cmts_t", key: "treeloc_t") -> "user_cmts_iterator_t" Find the specified key in user_cmts_t. - - @param map: (C++: const user_cmts_t *) user_cmts_t const * - @param key: (C++: const treeloc_t &) treeloc_t const & -ida_hexrays.user_cmts_first (function) - user_cmts_first(p) -> treeloc_t +ida_hexrays.user_cmts_first(p: "user_cmts_iterator_t") -> "treeloc_t const &" Get reference to the current map key. - - @param p: (C++: user_cmts_iterator_t) -ida_hexrays.user_cmts_free (function) - user_cmts_free(map) +ida_hexrays.user_cmts_free(map: "user_cmts_t") -> None Delete user_cmts_t instance. - - @param map: (C++: user_cmts_t *) -ida_hexrays.user_cmts_insert (function) - user_cmts_insert(map, key, val) -> user_cmts_iterator_t +ida_hexrays.user_cmts_insert(map: "user_cmts_t", key: "treeloc_t", val: "citem_cmt_t") -> "user_cmts_iterator_t" Insert new (treeloc_t, citem_cmt_t) pair into user_cmts_t. - - @param map: (C++: user_cmts_t *) - @param key: (C++: const treeloc_t &) treeloc_t const & - @param val: (C++: const citem_cmt_t &) citem_cmt_t const & -ida_hexrays.user_cmts_iterator_t (class) - Proxy of C++ user_cmts_iterator_t class. +ida_hexrays.user_cmts_iterator_t -ida_hexrays.user_cmts_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_cmts_iterator_t const & +ida_hexrays.user_cmts_iterator_t.__eq__(self, p: "user_cmts_iterator_t") -> bool -ida_hexrays.user_cmts_iterator_t.__init__ (method) - __init__(self) -> user_cmts_iterator_t +ida_hexrays.user_cmts_iterator_t.__init__(self) -ida_hexrays.user_cmts_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_cmts_iterator_t const & +ida_hexrays.user_cmts_iterator_t.__ne__(self, p: "user_cmts_iterator_t") -> bool -ida_hexrays.user_cmts_new (function) - user_cmts_new() -> user_cmts_t +ida_hexrays.user_cmts_new() -> "user_cmts_t *" Create a new user_cmts_t instance. -ida_hexrays.user_cmts_next (function) - user_cmts_next(p) -> user_cmts_iterator_t +ida_hexrays.user_cmts_next(p: "user_cmts_iterator_t") -> "user_cmts_iterator_t" Move to the next element. - - @param p: (C++: user_cmts_iterator_t) -ida_hexrays.user_cmts_prev (function) - user_cmts_prev(p) -> user_cmts_iterator_t +ida_hexrays.user_cmts_prev(p: "user_cmts_iterator_t") -> "user_cmts_iterator_t" Move to the previous element. - - @param p: (C++: user_cmts_iterator_t) -ida_hexrays.user_cmts_second (function) - user_cmts_second(p) -> citem_cmt_t +ida_hexrays.user_cmts_second(p: "user_cmts_iterator_t") -> "citem_cmt_t &" Get reference to the current map value. - - @param p: (C++: user_cmts_iterator_t) -ida_hexrays.user_cmts_size (function) - user_cmts_size(map) -> size_t +ida_hexrays.user_cmts_size(map: "user_cmts_t") -> "size_t" Get size of user_cmts_t. - - @param map: (C++: user_cmts_t *) -ida_hexrays.user_cmts_t (class) - Proxy of C++ std::map< treeloc_t,citem_cmt_t > class. +ida_hexrays.user_cmts_t -ida_hexrays.user_cmts_t.__init__ (method) - __init__(self) -> user_cmts_t +ida_hexrays.user_cmts_t.__init__(self) -ida_hexrays.user_cmts_t.at (method) - at(self, _Keyval) -> citem_cmt_t - - @param _Keyval: treeloc_t const & +ida_hexrays.user_cmts_t.at(self, _Keyval: "treeloc_t") -> "citem_cmt_t &" -ida_hexrays.user_cmts_t.size (method) - size(self) -> size_t +ida_hexrays.user_cmts_t.size(self) -> "size_t" -ida_hexrays.user_iflags_begin (function) - user_iflags_begin(map) -> user_iflags_iterator_t +ida_hexrays.user_iflags_begin(map: "user_iflags_t") -> "user_iflags_iterator_t" Get iterator pointing to the beginning of user_iflags_t. - - @param map: (C++: const user_iflags_t *) user_iflags_t const * -ida_hexrays.user_iflags_clear (function) - user_iflags_clear(map) +ida_hexrays.user_iflags_clear(map: "user_iflags_t") -> None Clear user_iflags_t. - - @param map: (C++: user_iflags_t *) -ida_hexrays.user_iflags_end (function) - user_iflags_end(map) -> user_iflags_iterator_t +ida_hexrays.user_iflags_end(map: "user_iflags_t") -> "user_iflags_iterator_t" Get iterator pointing to the end of user_iflags_t. - - @param map: (C++: const user_iflags_t *) user_iflags_t const * -ida_hexrays.user_iflags_erase (function) - user_iflags_erase(map, p) +ida_hexrays.user_iflags_erase(map: "user_iflags_t", p: "user_iflags_iterator_t") -> None Erase current element from user_iflags_t. - - @param map: (C++: user_iflags_t *) - @param p: (C++: user_iflags_iterator_t) -ida_hexrays.user_iflags_find (function) - user_iflags_find(map, key) -> user_iflags_iterator_t +ida_hexrays.user_iflags_find(map: "user_iflags_t", key: "citem_locator_t") -> "user_iflags_iterator_t" Find the specified key in user_iflags_t. - - @param map: (C++: const user_iflags_t *) user_iflags_t const * - @param key: (C++: const citem_locator_t &) citem_locator_t const & -ida_hexrays.user_iflags_first (function) - user_iflags_first(p) -> citem_locator_t +ida_hexrays.user_iflags_first(p: "user_iflags_iterator_t") -> "citem_locator_t const &" Get reference to the current map key. - - @param p: (C++: user_iflags_iterator_t) -ida_hexrays.user_iflags_free (function) - user_iflags_free(map) +ida_hexrays.user_iflags_free(map: "user_iflags_t") -> None Delete user_iflags_t instance. - - @param map: (C++: user_iflags_t *) -ida_hexrays.user_iflags_insert (function) - user_iflags_insert(map, key, val) -> user_iflags_iterator_t +ida_hexrays.user_iflags_insert(map: "user_iflags_t", key: "citem_locator_t", val: "int32 const &") -> "user_iflags_iterator_t" Insert new (citem_locator_t, int32) pair into user_iflags_t. - - @param map: (C++: user_iflags_t *) - @param key: (C++: const citem_locator_t &) citem_locator_t const & - @param val: (C++: const int32 &) int32 const & -ida_hexrays.user_iflags_iterator_t (class) - Proxy of C++ user_iflags_iterator_t class. +ida_hexrays.user_iflags_iterator_t -ida_hexrays.user_iflags_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_iflags_iterator_t const & +ida_hexrays.user_iflags_iterator_t.__eq__(self, p: "user_iflags_iterator_t") -> bool -ida_hexrays.user_iflags_iterator_t.__init__ (method) - __init__(self) -> user_iflags_iterator_t +ida_hexrays.user_iflags_iterator_t.__init__(self) -ida_hexrays.user_iflags_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_iflags_iterator_t const & +ida_hexrays.user_iflags_iterator_t.__ne__(self, p: "user_iflags_iterator_t") -> bool -ida_hexrays.user_iflags_new (function) - user_iflags_new() -> user_iflags_t +ida_hexrays.user_iflags_new() -> "user_iflags_t *" Create a new user_iflags_t instance. -ida_hexrays.user_iflags_next (function) - user_iflags_next(p) -> user_iflags_iterator_t +ida_hexrays.user_iflags_next(p: "user_iflags_iterator_t") -> "user_iflags_iterator_t" Move to the next element. - - @param p: (C++: user_iflags_iterator_t) -ida_hexrays.user_iflags_prev (function) - user_iflags_prev(p) -> user_iflags_iterator_t +ida_hexrays.user_iflags_prev(p: "user_iflags_iterator_t") -> "user_iflags_iterator_t" Move to the previous element. - - @param p: (C++: user_iflags_iterator_t) -ida_hexrays.user_iflags_second (function) - user_iflags_second(p) -> int32 const & +ida_hexrays.user_iflags_second(p: "user_iflags_iterator_t") -> "int32 const &" Get reference to the current map value. - - @param p: (C++: user_iflags_iterator_t) -ida_hexrays.user_iflags_size (function) - user_iflags_size(map) -> size_t +ida_hexrays.user_iflags_size(map: "user_iflags_t") -> "size_t" Get size of user_iflags_t. - - @param map: (C++: user_iflags_t *) -ida_hexrays.user_iflags_t (class) - Proxy of C++ std::map< citem_locator_t,int32 > class. +ida_hexrays.user_iflags_t -ida_hexrays.user_iflags_t.__init__ (method) - __init__(self) -> user_iflags_t +ida_hexrays.user_iflags_t.__init__(self) -ida_hexrays.user_iflags_t.at (method) - at(self, _Keyval) -> int & - - @param _Keyval: citem_locator_t const & +ida_hexrays.user_iflags_t.at(self, _Keyval: "citem_locator_t") -> "int &" -ida_hexrays.user_iflags_t.size (method) - size(self) -> size_t +ida_hexrays.user_iflags_t.size(self) -> "size_t" -ida_hexrays.user_labels_begin (function) - user_labels_begin(map) -> user_labels_iterator_t +ida_hexrays.user_labels_begin(map: "user_labels_t") -> "user_labels_iterator_t" Get iterator pointing to the beginning of user_labels_t. - - @param map: (C++: const user_labels_t *) user_labels_t const * -ida_hexrays.user_labels_clear (function) - user_labels_clear(map) +ida_hexrays.user_labels_clear(map: "user_labels_t") -> None Clear user_labels_t. - - @param map: (C++: user_labels_t *) -ida_hexrays.user_labels_end (function) - user_labels_end(map) -> user_labels_iterator_t +ida_hexrays.user_labels_end(map: "user_labels_t") -> "user_labels_iterator_t" Get iterator pointing to the end of user_labels_t. - - @param map: (C++: const user_labels_t *) user_labels_t const * -ida_hexrays.user_labels_erase (function) - user_labels_erase(map, p) +ida_hexrays.user_labels_erase(map: "user_labels_t", p: "user_labels_iterator_t") -> None Erase current element from user_labels_t. - - @param map: (C++: user_labels_t *) - @param p: (C++: user_labels_iterator_t) -ida_hexrays.user_labels_find (function) - user_labels_find(map, key) -> user_labels_iterator_t +ida_hexrays.user_labels_find(map: "user_labels_t", key: "int const &") -> "user_labels_iterator_t" Find the specified key in user_labels_t. - - @param map: (C++: const user_labels_t *) user_labels_t const * - @param key: (C++: const int &) int const & -ida_hexrays.user_labels_first (function) - user_labels_first(p) -> int const & +ida_hexrays.user_labels_first(p: "user_labels_iterator_t") -> "int const &" Get reference to the current map key. - - @param p: (C++: user_labels_iterator_t) -ida_hexrays.user_labels_free (function) - user_labels_free(map) +ida_hexrays.user_labels_free(map: "user_labels_t") -> None Delete user_labels_t instance. - - @param map: (C++: user_labels_t *) -ida_hexrays.user_labels_insert (function) - user_labels_insert(map, key, val) -> user_labels_iterator_t +ida_hexrays.user_labels_insert(map: "user_labels_t", key: "int const &", val: str) -> "user_labels_iterator_t" Insert new (int, qstring) pair into user_labels_t. - - @param map: (C++: user_labels_t *) - @param key: (C++: const int &) int const & - @param val: (C++: const qstring &) qstring const & -ida_hexrays.user_labels_iterator_t (class) - Proxy of C++ user_labels_iterator_t class. +ida_hexrays.user_labels_iterator_t -ida_hexrays.user_labels_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_labels_iterator_t const & +ida_hexrays.user_labels_iterator_t.__eq__(self, p: "user_labels_iterator_t") -> bool -ida_hexrays.user_labels_iterator_t.__init__ (method) - __init__(self) -> user_labels_iterator_t +ida_hexrays.user_labels_iterator_t.__init__(self) -ida_hexrays.user_labels_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_labels_iterator_t const & +ida_hexrays.user_labels_iterator_t.__ne__(self, p: "user_labels_iterator_t") -> bool -ida_hexrays.user_labels_new (function) - user_labels_new() -> user_labels_t +ida_hexrays.user_labels_new() -> "user_labels_t *" Create a new user_labels_t instance. -ida_hexrays.user_labels_next (function) - user_labels_next(p) -> user_labels_iterator_t +ida_hexrays.user_labels_next(p: "user_labels_iterator_t") -> "user_labels_iterator_t" Move to the next element. - - @param p: (C++: user_labels_iterator_t) -ida_hexrays.user_labels_prev (function) - user_labels_prev(p) -> user_labels_iterator_t +ida_hexrays.user_labels_prev(p: "user_labels_iterator_t") -> "user_labels_iterator_t" Move to the previous element. - - @param p: (C++: user_labels_iterator_t) -ida_hexrays.user_labels_second (function) - user_labels_second(p) -> qstring & +ida_hexrays.user_labels_second(p: "user_labels_iterator_t") -> str Get reference to the current map value. - - @param p: (C++: user_labels_iterator_t) -ida_hexrays.user_labels_size (function) - user_labels_size(map) -> size_t +ida_hexrays.user_labels_size(map: "user_labels_t") -> "size_t" Get size of user_labels_t. - - @param map: (C++: user_labels_t *) -ida_hexrays.user_labels_t (class) - Proxy of C++ std::map< int,qstring > class. +ida_hexrays.user_labels_t -ida_hexrays.user_labels_t.__init__ (method) - __init__(self) -> user_labels_t +ida_hexrays.user_labels_t.__init__(self) -ida_hexrays.user_labels_t.at (method) - at(self, _Keyval) -> _qstring< char > & - - @param _Keyval: int const & +ida_hexrays.user_labels_t.at(self, _Keyval: "int const &") -> "_qstring< char > &" -ida_hexrays.user_labels_t.size (method) - size(self) -> size_t +ida_hexrays.user_labels_t.size(self) -> "size_t" -ida_hexrays.user_lvar_modifier_t (class) - Proxy of C++ user_lvar_modifier_t class. +ida_hexrays.user_lvar_modifier_t -ida_hexrays.user_lvar_modifier_t.__disown__ (method) +ida_hexrays.user_lvar_modifier_t.__disown__(self) -ida_hexrays.user_lvar_modifier_t.__init__ (method) - __init__(self) -> user_lvar_modifier_t - - @param self: PyObject * +ida_hexrays.user_lvar_modifier_t.__init__(self) -ida_hexrays.user_lvar_modifier_t.modify_lvars (method) - modify_lvars(self, lvinf) -> bool - Modify lvar settings. Returns: true-modified - - @param lvinf: (C++: lvar_uservec_t *) +ida_hexrays.user_lvar_modifier_t.modify_lvars(self, lvinf: "lvar_uservec_t") -> bool + Modify lvar settings. Returns: true-modified + -ida_hexrays.user_numforms_begin (function) - user_numforms_begin(map) -> user_numforms_iterator_t +ida_hexrays.user_numforms_begin(map: "user_numforms_t") -> "user_numforms_iterator_t" Get iterator pointing to the beginning of user_numforms_t. - - @param map: (C++: const user_numforms_t *) user_numforms_t const * -ida_hexrays.user_numforms_clear (function) - user_numforms_clear(map) +ida_hexrays.user_numforms_clear(map: "user_numforms_t") -> None Clear user_numforms_t. - - @param map: (C++: user_numforms_t *) -ida_hexrays.user_numforms_end (function) - user_numforms_end(map) -> user_numforms_iterator_t +ida_hexrays.user_numforms_end(map: "user_numforms_t") -> "user_numforms_iterator_t" Get iterator pointing to the end of user_numforms_t. - - @param map: (C++: const user_numforms_t *) user_numforms_t const * -ida_hexrays.user_numforms_erase (function) - user_numforms_erase(map, p) +ida_hexrays.user_numforms_erase(map: "user_numforms_t", p: "user_numforms_iterator_t") -> None Erase current element from user_numforms_t. - - @param map: (C++: user_numforms_t *) - @param p: (C++: user_numforms_iterator_t) -ida_hexrays.user_numforms_find (function) - user_numforms_find(map, key) -> user_numforms_iterator_t +ida_hexrays.user_numforms_find(map: "user_numforms_t", key: "operand_locator_t") -> "user_numforms_iterator_t" Find the specified key in user_numforms_t. - - @param map: (C++: const user_numforms_t *) user_numforms_t const * - @param key: (C++: const operand_locator_t &) operand_locator_t const & -ida_hexrays.user_numforms_first (function) - user_numforms_first(p) -> operand_locator_t +ida_hexrays.user_numforms_first(p: "user_numforms_iterator_t") -> "operand_locator_t const &" Get reference to the current map key. - - @param p: (C++: user_numforms_iterator_t) -ida_hexrays.user_numforms_free (function) - user_numforms_free(map) +ida_hexrays.user_numforms_free(map: "user_numforms_t") -> None Delete user_numforms_t instance. - - @param map: (C++: user_numforms_t *) -ida_hexrays.user_numforms_insert (function) - user_numforms_insert(map, key, val) -> user_numforms_iterator_t +ida_hexrays.user_numforms_insert(map: "user_numforms_t", key: "operand_locator_t", val: "number_format_t") -> "user_numforms_iterator_t" Insert new (operand_locator_t, number_format_t) pair into user_numforms_t. - - @param map: (C++: user_numforms_t *) - @param key: (C++: const operand_locator_t &) operand_locator_t const & - @param val: (C++: const number_format_t &) number_format_t const & -ida_hexrays.user_numforms_iterator_t (class) - Proxy of C++ user_numforms_iterator_t class. +ida_hexrays.user_numforms_iterator_t -ida_hexrays.user_numforms_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_numforms_iterator_t const & +ida_hexrays.user_numforms_iterator_t.__eq__(self, p: "user_numforms_iterator_t") -> bool -ida_hexrays.user_numforms_iterator_t.__init__ (method) - __init__(self) -> user_numforms_iterator_t +ida_hexrays.user_numforms_iterator_t.__init__(self) -ida_hexrays.user_numforms_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_numforms_iterator_t const & +ida_hexrays.user_numforms_iterator_t.__ne__(self, p: "user_numforms_iterator_t") -> bool -ida_hexrays.user_numforms_new (function) - user_numforms_new() -> user_numforms_t +ida_hexrays.user_numforms_new() -> "user_numforms_t *" Create a new user_numforms_t instance. -ida_hexrays.user_numforms_next (function) - user_numforms_next(p) -> user_numforms_iterator_t +ida_hexrays.user_numforms_next(p: "user_numforms_iterator_t") -> "user_numforms_iterator_t" Move to the next element. - - @param p: (C++: user_numforms_iterator_t) -ida_hexrays.user_numforms_prev (function) - user_numforms_prev(p) -> user_numforms_iterator_t +ida_hexrays.user_numforms_prev(p: "user_numforms_iterator_t") -> "user_numforms_iterator_t" Move to the previous element. - - @param p: (C++: user_numforms_iterator_t) -ida_hexrays.user_numforms_second (function) - user_numforms_second(p) -> number_format_t +ida_hexrays.user_numforms_second(p: "user_numforms_iterator_t") -> "number_format_t &" Get reference to the current map value. - - @param p: (C++: user_numforms_iterator_t) -ida_hexrays.user_numforms_size (function) - user_numforms_size(map) -> size_t +ida_hexrays.user_numforms_size(map: "user_numforms_t") -> "size_t" Get size of user_numforms_t. - - @param map: (C++: user_numforms_t *) -ida_hexrays.user_numforms_t (class) - Proxy of C++ std::map< operand_locator_t,number_format_t > class. +ida_hexrays.user_numforms_t -ida_hexrays.user_numforms_t.__init__ (method) - __init__(self) -> user_numforms_t +ida_hexrays.user_numforms_t.__init__(self) -ida_hexrays.user_numforms_t.at (method) - at(self, _Keyval) -> number_format_t - - @param _Keyval: operand_locator_t const & +ida_hexrays.user_numforms_t.at(self, _Keyval: "operand_locator_t") -> "number_format_t &" -ida_hexrays.user_numforms_t.size (method) - size(self) -> size_t +ida_hexrays.user_numforms_t.size(self) -> "size_t" -ida_hexrays.user_unions_begin (function) - user_unions_begin(map) -> user_unions_iterator_t +ida_hexrays.user_unions_begin(map: "user_unions_t") -> "user_unions_iterator_t" Get iterator pointing to the beginning of user_unions_t. - - @param map: (C++: const user_unions_t *) user_unions_t const * -ida_hexrays.user_unions_clear (function) - user_unions_clear(map) +ida_hexrays.user_unions_clear(map: "user_unions_t") -> None Clear user_unions_t. - - @param map: (C++: user_unions_t *) -ida_hexrays.user_unions_end (function) - user_unions_end(map) -> user_unions_iterator_t +ida_hexrays.user_unions_end(map: "user_unions_t") -> "user_unions_iterator_t" Get iterator pointing to the end of user_unions_t. - - @param map: (C++: const user_unions_t *) user_unions_t const * -ida_hexrays.user_unions_erase (function) - user_unions_erase(map, p) +ida_hexrays.user_unions_erase(map: "user_unions_t", p: "user_unions_iterator_t") -> None Erase current element from user_unions_t. - - @param map: (C++: user_unions_t *) - @param p: (C++: user_unions_iterator_t) -ida_hexrays.user_unions_find (function) - user_unions_find(map, key) -> user_unions_iterator_t +ida_hexrays.user_unions_find(map: "user_unions_t", key: "ea_t const &") -> "user_unions_iterator_t" Find the specified key in user_unions_t. - - @param map: (C++: const user_unions_t *) user_unions_t const * - @param key: (C++: const ea_t &) ea_t const & -ida_hexrays.user_unions_first (function) - user_unions_first(p) -> ea_t const & +ida_hexrays.user_unions_first(p: "user_unions_iterator_t") -> "ea_t const &" Get reference to the current map key. - - @param p: (C++: user_unions_iterator_t) -ida_hexrays.user_unions_free (function) - user_unions_free(map) +ida_hexrays.user_unions_free(map: "user_unions_t") -> None Delete user_unions_t instance. - - @param map: (C++: user_unions_t *) -ida_hexrays.user_unions_insert (function) - user_unions_insert(map, key, val) -> user_unions_iterator_t +ida_hexrays.user_unions_insert(map: "user_unions_t", key: "ea_t const &", val: "intvec_t") -> "user_unions_iterator_t" Insert new (ea_t, intvec_t) pair into user_unions_t. - - @param map: (C++: user_unions_t *) - @param key: (C++: const ea_t &) ea_t const & - @param val: (C++: const intvec_t &) intvec_t const & -ida_hexrays.user_unions_iterator_t (class) - Proxy of C++ user_unions_iterator_t class. +ida_hexrays.user_unions_iterator_t -ida_hexrays.user_unions_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_unions_iterator_t const & +ida_hexrays.user_unions_iterator_t.__eq__(self, p: "user_unions_iterator_t") -> bool -ida_hexrays.user_unions_iterator_t.__init__ (method) - __init__(self) -> user_unions_iterator_t +ida_hexrays.user_unions_iterator_t.__init__(self) -ida_hexrays.user_unions_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_unions_iterator_t const & +ida_hexrays.user_unions_iterator_t.__ne__(self, p: "user_unions_iterator_t") -> bool -ida_hexrays.user_unions_new (function) - user_unions_new() -> user_unions_t +ida_hexrays.user_unions_new() -> "user_unions_t *" Create a new user_unions_t instance. -ida_hexrays.user_unions_next (function) - user_unions_next(p) -> user_unions_iterator_t +ida_hexrays.user_unions_next(p: "user_unions_iterator_t") -> "user_unions_iterator_t" Move to the next element. - - @param p: (C++: user_unions_iterator_t) -ida_hexrays.user_unions_prev (function) - user_unions_prev(p) -> user_unions_iterator_t +ida_hexrays.user_unions_prev(p: "user_unions_iterator_t") -> "user_unions_iterator_t" Move to the previous element. - - @param p: (C++: user_unions_iterator_t) -ida_hexrays.user_unions_second (function) - user_unions_second(p) -> intvec_t +ida_hexrays.user_unions_second(p: "user_unions_iterator_t") -> "intvec_t &" Get reference to the current map value. - - @param p: (C++: user_unions_iterator_t) -ida_hexrays.user_unions_size (function) - user_unions_size(map) -> size_t +ida_hexrays.user_unions_size(map: "user_unions_t") -> "size_t" Get size of user_unions_t. - - @param map: (C++: user_unions_t *) -ida_hexrays.user_unions_t (class) - Proxy of C++ std::map< ea_t,intvec_t > class. +ida_hexrays.user_unions_t -ida_hexrays.user_unions_t.__init__ (method) - __init__(self) -> user_unions_t +ida_hexrays.user_unions_t.__init__(self) -ida_hexrays.user_unions_t.at (method) - at(self, _Keyval) -> intvec_t - - @param _Keyval: unsigned-ea-like-numeric-type const & +ida_hexrays.user_unions_t.at(self, _Keyval: "unsigned long long const &") -> "qvector< int > &" -ida_hexrays.user_unions_t.size (method) - size(self) -> size_t +ida_hexrays.user_unions_t.size(self) -> "size_t" -ida_hexrays.uval_ivl_ivlset_t (class) - Proxy of C++ ivlset_tpl< ivl_t,uval_t > class. +ida_hexrays.uval_ivl_ivlset_t -ida_hexrays.uval_ivl_ivlset_t.__eq__ (method) - __eq__(self, v) -> bool - - @param v: ivl_t const & - -ida_hexrays.uval_ivl_ivlset_t.__init__ (method) - __init__(self) -> uval_ivl_ivlset_t - __init__(self, ivl) -> uval_ivl_ivlset_t - - @param ivl: ivl_t const & +ida_hexrays.uval_ivl_ivlset_t.__eq__(self, v: "ivl_t") -> bool -ida_hexrays.uval_ivl_ivlset_t.__ne__ (method) - __ne__(self, v) -> bool - - @param v: ivl_t const & - -ida_hexrays.uval_ivl_ivlset_t.all_values (method) - all_values(self) -> bool - -ida_hexrays.uval_ivl_ivlset_t.begin (method) - begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator - begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator - -ida_hexrays.uval_ivl_ivlset_t.clear (method) - clear(self) - -ida_hexrays.uval_ivl_ivlset_t.empty (method) - empty(self) -> bool - -ida_hexrays.uval_ivl_ivlset_t.end (method) - end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator - end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator +ida_hexrays.uval_ivl_ivlset_t.__init__(self, *args) -ida_hexrays.uval_ivl_ivlset_t.getivl (method) - getivl(self, idx) -> ivl_t - - @param idx: int +ida_hexrays.uval_ivl_ivlset_t.__ne__(self, v: "ivl_t") -> bool -ida_hexrays.uval_ivl_ivlset_t.lastivl (method) - lastivl(self) -> ivl_t - -ida_hexrays.uval_ivl_ivlset_t.nivls (method) - nivls(self) -> size_t - -ida_hexrays.uval_ivl_ivlset_t.qclear (method) - qclear(self) +ida_hexrays.uval_ivl_ivlset_t.all_values(self) -> bool -ida_hexrays.uval_ivl_ivlset_t.set_all_values (method) - set_all_values(self) +ida_hexrays.uval_ivl_ivlset_t.begin(self, *args) -> "ivlset_tpl< ivl_t,unsigned long long >::iterator" -ida_hexrays.uval_ivl_ivlset_t.single_value (method) - single_value(self) -> bool - single_value(self, v) -> bool - - @param v: unsigned-ea-like-numeric-type +ida_hexrays.uval_ivl_ivlset_t.clear(self) -> None -ida_hexrays.uval_ivl_ivlset_t.swap (method) - swap(self, r) - - @param r: ivlset_tpl< ivl_t,uval_t > & +ida_hexrays.uval_ivl_ivlset_t.empty(self) -> bool -ida_hexrays.uval_ivl_t (class) - Proxy of C++ ivl_tpl< uval_t > class. - -ida_hexrays.uval_ivl_t.__init__ (method) - __init__(self, _off, _size) -> uval_ivl_t - - @param _off: unsigned-ea-like-numeric-type - @param _size: unsigned-ea-like-numeric-type +ida_hexrays.uval_ivl_ivlset_t.end(self, *args) -> "ivlset_tpl< ivl_t,unsigned long long >::iterator" -ida_hexrays.uval_ivl_t.end (method) - end(self) -> unsigned-ea-like-numeric-type +ida_hexrays.uval_ivl_ivlset_t.getivl(self, idx: int) -> "ivl_t const &" -ida_hexrays.uval_ivl_t.last (method) - last(self) -> unsigned-ea-like-numeric-type - -ida_hexrays.uval_ivl_t.valid (method) - valid(self) -> bool +ida_hexrays.uval_ivl_ivlset_t.lastivl(self) -> "ivl_t const &" -ida_hexrays.valrng_t (class) - Proxy of C++ valrng_t class. - -ida_hexrays.valrng_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__init__ (method) - __init__(self, size_=MAX_VLR_SIZE) -> valrng_t - - @param size_: int - - __init__(self, r) -> valrng_t - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__le__ (method) - __le__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t._deregister (method) - _deregister(self) - -ida_hexrays.valrng_t._print (method) - _print(self) - -ida_hexrays.valrng_t._register (method) - _register(self) - -ida_hexrays.valrng_t.all_values (method) - all_values(self) -> bool - -ida_hexrays.valrng_t.compare (method) - compare(self, r) -> int - - @param r: valrng_t const & - -ida_hexrays.valrng_t.cvt_to_cmp (method) - cvt_to_cmp(self, strict) -> bool - - @param strict: bool - -ida_hexrays.valrng_t.cvt_to_single_value (method) - cvt_to_single_value(self) -> bool - -ida_hexrays.valrng_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.valrng_t.empty (method) - empty(self) -> bool - -ida_hexrays.valrng_t.get_size (method) - get_size(self) -> int - -ida_hexrays.valrng_t.has (method) - has(self, v) -> bool - - @param v: uvlr_t - -ida_hexrays.valrng_t.intersect_with (method) - intersect_with(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.inverse (method) - inverse(self) - -ida_hexrays.valrng_t.is_unknown (method) - is_unknown(self) -> bool - -ida_hexrays.valrng_t.max_svalue (method) - max_svalue(self, size_) -> uvlr_t - - @param size_: int - - max_svalue(self) -> uvlr_t - -ida_hexrays.valrng_t.max_value (method) - max_value(self, size_) -> uvlr_t - - @param size_: int - - max_value(self) -> uvlr_t - -ida_hexrays.valrng_t.min_svalue (method) - min_svalue(self, size_) -> uvlr_t - - @param size_: int - - min_svalue(self) -> uvlr_t - -ida_hexrays.valrng_t.reduce_size (method) - reduce_size(self, new_size) -> bool - - @param new_size: int - -ida_hexrays.valrng_t.set_all (method) - set_all(self) - -ida_hexrays.valrng_t.set_cmp (method) - set_cmp(self, cmp, _value) - - @param cmp: enum cmpop_t - @param _value: uvlr_t - -ida_hexrays.valrng_t.set_eq (method) - set_eq(self, v) - - @param v: uvlr_t - -ida_hexrays.valrng_t.set_none (method) - set_none(self) - -ida_hexrays.valrng_t.set_unk (method) - set_unk(self) - -ida_hexrays.valrng_t.swap (method) - swap(self, r) - - @param r: valrng_t & - -ida_hexrays.valrng_t.unite_with (method) - unite_with(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.var_ref_t (class) - Proxy of C++ var_ref_t class. - -ida_hexrays.var_ref_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__init__ (method) - __init__(self) -> var_ref_t - -ida_hexrays.var_ref_t.__le__ (method) - __le__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.compare (method) - compare(self, r) -> int - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.getv (method) - getv(self) -> lvar_t - -ida_hexrays.var_ref_t.idx (variable) +ida_hexrays.uval_ivl_ivlset_t.nivls(self) -> "size_t" + +ida_hexrays.uval_ivl_ivlset_t.qclear(self) -> None + +ida_hexrays.uval_ivl_ivlset_t.set_all_values(self) -> None + +ida_hexrays.uval_ivl_ivlset_t.single_value(self, *args) -> bool + +ida_hexrays.uval_ivl_ivlset_t.swap(self, r: "uval_ivl_ivlset_t") -> None + +ida_hexrays.uval_ivl_t + +ida_hexrays.uval_ivl_t.__init__(self, _off: "unsigned long long", _size: "unsigned long long") + +ida_hexrays.uval_ivl_t.end(self) -> "unsigned long long" + +ida_hexrays.uval_ivl_t.last(self) -> "unsigned long long" + +ida_hexrays.uval_ivl_t.valid(self) -> bool + +ida_hexrays.valrng_t + +ida_hexrays.valrng_t.__eq__(self, r: "valrng_t") -> bool + +ida_hexrays.valrng_t.__ge__(self, r: "valrng_t") -> bool + +ida_hexrays.valrng_t.__gt__(self, r: "valrng_t") -> bool + +ida_hexrays.valrng_t.__init__(self, *args) + +ida_hexrays.valrng_t.__le__(self, r: "valrng_t") -> bool + +ida_hexrays.valrng_t.__lt__(self, r: "valrng_t") -> bool + +ida_hexrays.valrng_t.__ne__(self, r: "valrng_t") -> bool + +ida_hexrays.valrng_t._deregister(self) -> None + +ida_hexrays.valrng_t._print(self) -> None + +ida_hexrays.valrng_t._register(self) -> None + +ida_hexrays.valrng_t.all_values(self) -> bool + +ida_hexrays.valrng_t.compare(self, r: "valrng_t") -> int + +ida_hexrays.valrng_t.cvt_to_cmp(self) -> bool + +ida_hexrays.valrng_t.cvt_to_single_value(self) -> bool + +ida_hexrays.valrng_t.dstr(self) -> str + +ida_hexrays.valrng_t.empty(self) -> bool + +ida_hexrays.valrng_t.get_size(self) -> int + +ida_hexrays.valrng_t.has(self, v: "uvlr_t") -> bool + +ida_hexrays.valrng_t.intersect_with(self, r: "valrng_t") -> bool + +ida_hexrays.valrng_t.inverse(self) -> None + +ida_hexrays.valrng_t.is_unknown(self) -> bool + +ida_hexrays.valrng_t.max_svalue(self) -> "uvlr_t" + +ida_hexrays.valrng_t.max_value(self) -> "uvlr_t" + +ida_hexrays.valrng_t.min_svalue(self) -> "uvlr_t" + +ida_hexrays.valrng_t.reduce_size(self, new_size: int) -> bool + +ida_hexrays.valrng_t.set_all(self) -> None + +ida_hexrays.valrng_t.set_cmp(self, cmp: "cmpop_t", _value: "uvlr_t") -> None + +ida_hexrays.valrng_t.set_eq(self, v: "uvlr_t") -> None + +ida_hexrays.valrng_t.set_none(self) -> None + +ida_hexrays.valrng_t.set_unk(self) -> None + +ida_hexrays.valrng_t.swap(self, r: "valrng_t") -> None + +ida_hexrays.valrng_t.unite_with(self, r: "valrng_t") -> bool + +ida_hexrays.var_ref_t + +ida_hexrays.var_ref_t.__eq__(self, r: "var_ref_t") -> bool + +ida_hexrays.var_ref_t.__ge__(self, r: "var_ref_t") -> bool + +ida_hexrays.var_ref_t.__gt__(self, r: "var_ref_t") -> bool + +ida_hexrays.var_ref_t.__init__(self) + +ida_hexrays.var_ref_t.__le__(self, r: "var_ref_t") -> bool + +ida_hexrays.var_ref_t.__lt__(self, r: "var_ref_t") -> bool + +ida_hexrays.var_ref_t.__ne__(self, r: "var_ref_t") -> bool + +ida_hexrays.var_ref_t.compare(self, r: "var_ref_t") -> int + +ida_hexrays.var_ref_t.getv(self) -> "lvar_t &" + +ida_hexrays.var_ref_t.idx index into lvars_t -ida_hexrays.var_ref_t.mba (variable) +ida_hexrays.var_ref_t.mba pointer to the underlying micro array -ida_hexrays.vc_printer_t (class) - Proxy of C++ vc_printer_t class. +ida_hexrays.vc_printer_t -ida_hexrays.vc_printer_t.__disown__ (method) +ida_hexrays.vc_printer_t.__disown__(self) -ida_hexrays.vc_printer_t.__init__ (method) - __init__(self, f) -> vc_printer_t - - @param f: cfunc_t const * +ida_hexrays.vc_printer_t.__init__(self, f: "cfunc_t") -ida_hexrays.vc_printer_t.func (variable) +ida_hexrays.vc_printer_t.func cfunc_t to generate text for -ida_hexrays.vc_printer_t.oneliner (method) - oneliner(self) -> bool - Are we generating one-line text representation? - - @return: true if the output will occupy one line without line breaks +ida_hexrays.vc_printer_t.lastchar + internal: last printed character + -ida_hexrays.vd_failure_t (class) - Proxy of C++ vd_failure_t class. +ida_hexrays.vc_printer_t.oneliner(self) -> bool + Are we generating one-line text representation? + + @returns `true` if the output will occupy one line without line breaks -ida_hexrays.vd_failure_t.__init__ (method) - __init__(self) -> vd_failure_t - __init__(self, code, ea, buf=None) -> vd_failure_t - - @param code: enum merror_t - @param ea: ea_t - @param buf: char const * - - __init__(self, code, ea, buf) -> vd_failure_t - - @param code: enum merror_t - @param ea: ea_t - @param buf: qstring const & - - __init__(self, _hf) -> vd_failure_t - - @param _hf: hexrays_failure_t const & +ida_hexrays.vd_failure_t -ida_hexrays.vd_failure_t.desc (method) - desc(self) -> qstring +ida_hexrays.vd_failure_t.__init__(self, *args) -ida_hexrays.vd_interr_t (class) - Proxy of C++ vd_interr_t class. +ida_hexrays.vd_failure_t.desc(self) -> str -ida_hexrays.vd_interr_t.__init__ (method) - __init__(self, ea, buf) -> vd_interr_t - - @param ea: ea_t - @param buf: char const * +ida_hexrays.vd_interr_t -ida_hexrays.vd_printer_t (class) - Proxy of C++ vd_printer_t class. +ida_hexrays.vd_interr_t.__init__(self, ea: ida_idaapi.ea_t, buf: str) -ida_hexrays.vd_printer_t.__disown__ (method) +ida_hexrays.vd_printer_t -ida_hexrays.vd_printer_t.__init__ (method) - __init__(self) -> vd_printer_t - - @param self: PyObject * +ida_hexrays.vd_printer_t.__disown__(self) -ida_hexrays.vd_printer_t._print (method) - _print(self, indent, format) -> int - - Parameters - ---------- - indent: int - format: char const * +ida_hexrays.vd_printer_t.__init__(self) -ida_hexrays.vd_printer_t.hdrlines (variable) - number of header lines (prototype+typedef+lvars) valid at the end of print - process +ida_hexrays.vd_printer_t._print(self, indent: int, format: str) -> int -ida_hexrays.vdloc_t (class) - Proxy of C++ vdloc_t class. +ida_hexrays.vd_printer_t.hdrlines + number of header lines (prototype+typedef+lvars) valid at the end of print process + -ida_hexrays.vdloc_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: vdloc_t const & +ida_hexrays.vdloc_t -ida_hexrays.vdloc_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: vdloc_t const & +ida_hexrays.vdloc_t.__eq__(self, r: "vdloc_t") -> bool -ida_hexrays.vdloc_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: vdloc_t const & +ida_hexrays.vdloc_t.__ge__(self, r: "vdloc_t") -> bool -ida_hexrays.vdloc_t.__init__ (method) - __init__(self) -> vdloc_t +ida_hexrays.vdloc_t.__gt__(self, r: "vdloc_t") -> bool -ida_hexrays.vdloc_t.__le__ (method) - __le__(self, r) -> bool - - @param r: vdloc_t const & +ida_hexrays.vdloc_t.__init__(self) -ida_hexrays.vdloc_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: vdloc_t const & +ida_hexrays.vdloc_t.__le__(self, r: "vdloc_t") -> bool -ida_hexrays.vdloc_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: vdloc_t const & +ida_hexrays.vdloc_t.__lt__(self, r: "vdloc_t") -> bool -ida_hexrays.vdloc_t._set_reg1 (method) - _set_reg1(self, r1) - - Parameters - ---------- - r1: int +ida_hexrays.vdloc_t.__ne__(self, r: "vdloc_t") -> bool -ida_hexrays.vdloc_t.compare (method) - compare(self, r) -> int - - @param r: vdloc_t const & +ida_hexrays.vdloc_t._set_reg1(self, r1: int) -> None -ida_hexrays.vdloc_t.is_aliasable (method) - is_aliasable(self, mb, size) -> bool - - @param mb: mba_t const * - @param size: int +ida_hexrays.vdloc_t.compare(self, r: "vdloc_t") -> int -ida_hexrays.vdloc_t.reg1 (method) - reg1(self) -> int +ida_hexrays.vdloc_t.is_aliasable(self, mb: "mba_t", size: int) -> bool -ida_hexrays.vdloc_t.set_reg1 (method) - set_reg1(self, r1) - - @param r1: int +ida_hexrays.vdloc_t.reg1(self) -> int -ida_hexrays.vdui_t (class) - Proxy of C++ vdui_t class. +ida_hexrays.vdloc_t.set_reg1(self, r1: int) -> None -ida_hexrays.vdui_t.__init__ (method) +ida_hexrays.vdui_t -ida_hexrays.vdui_t.calc_cmt_type (method) - calc_cmt_type(self, lnnum, cmttype) -> cmt_type_t - Check if the specified line can have a comment. Due to the coordinate system for - comments: (\link{https://www.hex-rays.com/blog/coordinate-system-for-hex-rays}) - some function lines cannot have comments. This function checks if a comment can - be attached to the specified line. - - @param lnnum: (C++: size_t) line number (0 based) - @param cmttype: (C++: cmt_type_t) comment types to check - @return: possible comment types +ida_hexrays.vdui_t.__init__(self, *args, **kwargs) -ida_hexrays.vdui_t.cfunc (variable) +ida_hexrays.vdui_t.calc_cmt_type(self, lnnum: "size_t", cmttype: "cmt_type_t") -> "cmt_type_t" + Check if the specified line can have a comment. Due to the coordinate system for comments: ([https://www.hex-rays.com/blog/coordinate-system-for-hex-rays](https://www.hex-rays.com/blog/coordinate-system-for-hex-rays)) some function lines cannot have comments. This function checks if a comment can be attached to the specified line. + + @param lnnum: line number (0 based) + @param cmttype: comment types to check + @returns possible comment types + +ida_hexrays.vdui_t.cfunc pointer to function object -ida_hexrays.vdui_t.clear (method) - clear(self) - Clear the pseudocode window. It deletes the current function and microcode. +ida_hexrays.vdui_t.clear(self) -> None + Clear the pseudocode window. It deletes the current function and microcode. + -ida_hexrays.vdui_t.collapse_item (method) - collapse_item(self, hide) -> bool - Collapse/uncollapse item. This function collapses the current item. - - @param hide: (C++: bool) - @return: false if failed. +ida_hexrays.vdui_t.collapse_item(self, hide: bool) -> bool + Collapse/uncollapse item. This function collapses the current item. + + @returns false if failed. -ida_hexrays.vdui_t.collapse_lvars (method) - collapse_lvars(self, hide) -> bool - Collapse/uncollapse local variable declarations. - - @param hide: (C++: bool) - @return: false if failed. +ida_hexrays.vdui_t.collapse_lvars(self, hide: bool) -> bool + Collapse/uncollapse local variable declarations. + + @returns false if failed. -ida_hexrays.vdui_t.cpos (variable) +ida_hexrays.vdui_t.cpos Current ctext position. -ida_hexrays.vdui_t.ct (variable) +ida_hexrays.vdui_t.ct pseudocode view -ida_hexrays.vdui_t.ctree_to_disasm (method) - ctree_to_disasm(self) -> bool - Jump to disassembly. This function jumps to the address in the disassembly - window which corresponds to the current item. The current item is determined - based on the current keyboard cursor position. - - @return: false if failed +ida_hexrays.vdui_t.ctree_to_disasm(self) -> bool + Jump to disassembly. This function jumps to the address in the disassembly window which corresponds to the current item. The current item is determined based on the current keyboard cursor position. + + @returns false if failed -ida_hexrays.vdui_t.del_orphan_cmts (method) - del_orphan_cmts(self) -> bool - Delete all orphan comments. Delete all orphan comments and refresh the screen. - - @return: true +ida_hexrays.vdui_t.del_orphan_cmts(self) -> bool + Delete all orphan comments. Delete all orphan comments and refresh the screen. + + @returns true -ida_hexrays.vdui_t.edit_cmt (method) - edit_cmt(self, loc) -> bool - Edit an indented comment. This function displays a dialog box and allows the - user to edit the comment for the specified ctree location. - - @param loc: (C++: const treeloc_t &) comment location - @return: false if failed or cancelled +ida_hexrays.vdui_t.edit_cmt(self, loc: "treeloc_t") -> bool + Edit an indented comment. This function displays a dialog box and allows the user to edit the comment for the specified ctree location. + + @param loc: comment location + @returns false if failed or cancelled -ida_hexrays.vdui_t.edit_func_cmt (method) - edit_func_cmt(self) -> bool - Edit a function comment. This function displays a dialog box and allows the user - to edit the function comment. - - @return: false if failed or cancelled +ida_hexrays.vdui_t.edit_func_cmt(self) -> bool + Edit a function comment. This function displays a dialog box and allows the user to edit the function comment. + + @returns false if failed or cancelled -ida_hexrays.vdui_t.flags (variable) - Properties of pseudocode window +ida_hexrays.vdui_t.flags + Properties of pseudocode window + -ida_hexrays.vdui_t.get_current_item (method) - get_current_item(self, idv) -> bool - Get current item. This function refreshes the cpos, item, tail fields. - - @param idv: (C++: input_device_t) keyboard or mouse - @see: cfunc_t::get_line_item() - @return: false if failed +ida_hexrays.vdui_t.get_current_item(self, idv: "input_device_t") -> bool + Get current item. This function refreshes the cpos, item, tail fields. + + @param idv: keyboard or mouse + @returns false if failed -ida_hexrays.vdui_t.get_current_label (method) - get_current_label(self) -> int - Get current label. If there is a label under the cursor, return its number. - - @return: -1 if there is no label under the cursor. prereq: get_current_item() - has been called +ida_hexrays.vdui_t.get_current_label(self) -> int + Get current label. If there is a label under the cursor, return its number. + + @returns -1 if there is no label under the cursor. prereq: get_current_item() has been called -ida_hexrays.vdui_t.get_number (method) - get_number(self) -> cnumber_t - Get current number. If the current item is a number, return pointer to it. - - @return: nullptr if the current item is not a number This function returns non- - null for the cases of a 'switch' statement Also, if the current item is - a casted number, then this function will succeed. +ida_hexrays.vdui_t.get_number(self) -> "cnumber_t *" + Get current number. If the current item is a number, return pointer to it. + + @returns nullptr if the current item is not a number This function returns non-null for the cases of a 'switch' statement Also, if the current item is a casted number, then this function will succeed. -ida_hexrays.vdui_t.head (variable) +ida_hexrays.vdui_t.head First ctree item on the current line (for block comments) -ida_hexrays.vdui_t.in_ctree (method) - in_ctree(self) -> bool +ida_hexrays.vdui_t.in_ctree(self) -> bool Is the current item a statement? - @return: false if the cursor is in the local variable/type declaration area - true if the cursor is in the statement area + @returns false if the cursor is in the local variable/type declaration area + true if the cursor is in the statement area -ida_hexrays.vdui_t.invert_bits (method) - invert_bits(self) -> bool - Bitwise negate a number. This function inverts all bits of the current number. - - @return: false if failed. +ida_hexrays.vdui_t.invert_bits(self) -> bool + Bitwise negate a number. This function inverts all bits of the current number. + + @returns false if failed. -ida_hexrays.vdui_t.invert_sign (method) - invert_sign(self) -> bool - Negate a number. This function negates the current number. - - @return: false if failed. +ida_hexrays.vdui_t.invert_sign(self) -> bool + Negate a number. This function negates the current number. + + @returns false if failed. -ida_hexrays.vdui_t.item (variable) +ida_hexrays.vdui_t.item Current ctree item. -ida_hexrays.vdui_t.jump_enter (method) - jump_enter(self, idv, omflags) -> bool - Process the Enter key. This function jumps to the definition of the item under - the cursor. If the current item is a function, it will be decompiled. If the - current item is a global data, its disassemly text will be displayed. - - @param idv: (C++: input_device_t) what cursor must be used, the keyboard or the mouse - @param omflags: (C++: int) OM_NEWWIN: new pseudocode window will open, 0: reuse the - existing window - @return: false if failed +ida_hexrays.vdui_t.jump_enter(self, idv: "input_device_t", omflags: int) -> bool + Process the Enter key. This function jumps to the definition of the item under the cursor. If the current item is a function, it will be decompiled. If the current item is a global data, its disassemly text will be displayed. + + @param idv: what cursor must be used, the keyboard or the mouse + @param omflags: OM_NEWWIN: new pseudocode window will open, 0: reuse the existing window + @returns false if failed -ida_hexrays.vdui_t.last_code (variable) +ida_hexrays.vdui_t.last_code result of the last user action. See Microcode error codes -ida_hexrays.vdui_t.locked (method) - locked(self) -> bool - Does the pseudocode window contain valid code? We lock windows before modifying - them, to avoid recursion due to the events generated by the IDA kernel. +ida_hexrays.vdui_t.locked(self) -> bool + Does the pseudocode window contain valid code? We lock windows before modifying them, to avoid recursion due to the events generated by the IDA kernel. + @retval true: The window is locked and may have stale info -ida_hexrays.vdui_t.map_lvar (method) - map_lvar(self, frm, to) -> bool - Map a local variable to another. This function permanently maps one lvar to - another. All occurrences of the mapped variable are replaced by the new variable - - @param from: (C++: lvar_t *) the variable being mapped - @param to: (C++: lvar_t *) the variable to map to. if nullptr, unmaps the variable - @return: false if failed +ida_hexrays.vdui_t.map_lvar(self, frm: "lvar_t", to: "lvar_t") -> bool + Map a local variable to another. This function permanently maps one lvar to another. All occurrences of the mapped variable are replaced by the new variable + + @param to: the variable to map to. if nullptr, unmaps the variable + @returns false if failed -ida_hexrays.vdui_t.mba (variable) +ida_hexrays.vdui_t.mba pointer to underlying microcode -ida_hexrays.vdui_t.refresh_cpos (method) - refresh_cpos(self, idv) -> bool - Refresh the current position. This function refreshes the cpos field. - - @param idv: (C++: input_device_t) keyboard or mouse - @return: false if failed +ida_hexrays.vdui_t.refresh_cpos(self, idv: "input_device_t") -> bool + Refresh the current position. This function refreshes the cpos field. + + @param idv: keyboard or mouse + @returns false if failed -ida_hexrays.vdui_t.refresh_ctext (method) - refresh_ctext(self, activate=True) - Refresh pseudocode window. This function refreshes the pseudocode window by - regenerating its text from cfunc_t. Instead of this function use - refresh_func_ctext(), which refreshes all pseudocode windows for the function. - @see: refresh_view(), refresh_func_ctext() - - @param activate: (C++: bool) +ida_hexrays.vdui_t.refresh_ctext(self, activate: bool = True) -> None + Refresh pseudocode window. This function refreshes the pseudocode window by regenerating its text from cfunc_t. Instead of this function use refresh_func_ctext(), which refreshes all pseudocode windows for the function. + -ida_hexrays.vdui_t.refresh_view (method) - refresh_view(self, redo_mba) - Refresh pseudocode window. This is the highest level refresh function. It causes - the most profound refresh possible and can lead to redecompilation of the - current function. Please consider using refresh_ctext() if you need a more - superficial refresh. - - @param redo_mba: (C++: bool) true means to redecompile the current function - false means to rebuild ctree without regenerating microcode - @see: refresh_ctext() +ida_hexrays.vdui_t.refresh_view(self, redo_mba: bool) -> None + Refresh pseudocode window. This is the highest level refresh function. It causes the most profound refresh possible and can lead to redecompilation of the current function. Please consider using refresh_ctext() if you need a more superficial refresh. + + @param redo_mba: true means to redecompile the current function + false means to rebuild ctree without regenerating microcode -ida_hexrays.vdui_t.rename_global (method) - rename_global(self, ea) -> bool - Rename global item. This function displays a dialog box and allows the user to - rename a global item (data or function). - - @param ea: (C++: ea_t) address of the global item - @return: false if failed or cancelled +ida_hexrays.vdui_t.rename_global(self, ea: ida_idaapi.ea_t) -> bool + Rename global item. This function displays a dialog box and allows the user to rename a global item (data or function). + + @param ea: address of the global item + @returns false if failed or cancelled -ida_hexrays.vdui_t.rename_label (method) - rename_label(self, label) -> bool - Rename a label. This function displays a dialog box and allows the user to - rename a statement label. - - @param label: (C++: int) label number - @return: false if failed or cancelled +ida_hexrays.vdui_t.rename_label(self, label: int) -> bool + Rename a label. This function displays a dialog box and allows the user to rename a statement label. + + @param label: label number + @returns false if failed or cancelled -ida_hexrays.vdui_t.rename_lvar (method) - rename_lvar(self, v, name, is_user_name) -> bool - Rename local variable. This function permanently renames a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @param name: (C++: const char *) new variable name - @param is_user_name: (C++: bool) use true to save the new name into the database. use false - to delete the saved name. - @see: ::rename_lvar() - @return: false if failed +ida_hexrays.vdui_t.rename_lvar(self, v: "lvar_t", name: str, is_user_name: bool) -> bool + Rename local variable. This function permanently renames a local variable. + + @param v: pointer to local variable + @param name: new variable name + @param is_user_name: use true to save the new name into the database. use false to delete the saved name. + @returns false if failed -ida_hexrays.vdui_t.rename_strmem (method) - rename_strmem(self, sptr, mptr) -> bool - Rename structure field. This function displays a dialog box and allows the user - to rename a structure field. - - @param sptr: (C++: struc_t *) pointer to structure - @param mptr: (C++: member_t *) pointer to structure member OBSOLETE FUNCTION, do not use! - @return: false if failed or cancelled +ida_hexrays.vdui_t.rename_udm(self, udt_type: "tinfo_t", udm_idx: int) -> bool + Rename structure field. This function displays a dialog box and allows the user to rename a structure field. + + @param udt_type: structure/union type + @param udm_idx: index of the structure/union member + @returns false if failed or cancelled -ida_hexrays.vdui_t.rename_udm (method) - rename_udm(self, udt_type, udm_idx) -> bool - Rename structure field. This function displays a dialog box and allows the user - to rename a structure field. - - @param udt_type: (C++: tinfo_t &) structure/union type - @param udm_idx: (C++: int) index of the structure/union member - @return: false if failed or cancelled +ida_hexrays.vdui_t.set_global_type(self, ea: ida_idaapi.ea_t) -> bool + Set global item type. This function displays a dialog box and allows the user to change the type of a global item (data or function). + + @param ea: address of the global item + @returns false if failed or cancelled -ida_hexrays.vdui_t.set_global_type (method) - set_global_type(self, ea) -> bool - Set global item type. This function displays a dialog box and allows the user to - change the type of a global item (data or function). - - @param ea: (C++: ea_t) address of the global item - @return: false if failed or cancelled +ida_hexrays.vdui_t.set_locked(self, v: bool) -> bool -ida_hexrays.vdui_t.set_locked (method) - set_locked(self, v) -> bool - - @param v: bool +ida_hexrays.vdui_t.set_lvar_cmt(self, v: "lvar_t", cmt: str) -> bool + Set local variable comment. This function permanently sets a variable comment. + + @param v: pointer to local variable + @param cmt: new comment + @returns false if failed -ida_hexrays.vdui_t.set_lvar_cmt (method) - set_lvar_cmt(self, v, cmt) -> bool - Set local variable comment. This function permanently sets a variable comment. - - @param v: (C++: lvar_t *) pointer to local variable - @param cmt: (C++: const char *) new comment - @return: false if failed +ida_hexrays.vdui_t.set_lvar_type(self, v: "lvar_t", type: "tinfo_t") -> bool + Set local variable type. This function permanently sets a local variable type and clears NOPTR flag if it was set before by function 'set_noptr_lvar' + + @param v: pointer to local variable + @param type: new variable type + @returns false if failed -ida_hexrays.vdui_t.set_lvar_type (method) - set_lvar_type(self, v, type) -> bool - Set local variable type. This function permanently sets a local variable type - and clears NOPTR flag if it was set before by function 'set_noptr_lvar' - - @param v: (C++: lvar_t *) pointer to local variable - @param type: (C++: const tinfo_t &) new variable type - @return: false if failed +ida_hexrays.vdui_t.set_noptr_lvar(self, v: "lvar_t") -> bool + Inform that local variable should have a non-pointer type This function permanently sets a corresponding variable flag (NOPTR) and removes type if it was set before by function 'set_lvar_type' + + @param v: pointer to local variable + @returns false if failed -ida_hexrays.vdui_t.set_noptr_lvar (method) - set_noptr_lvar(self, v) -> bool - Inform that local variable should have a non-pointer type This function - permanently sets a corresponding variable flag (NOPTR) and removes type if it - was set before by function 'set_lvar_type' - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed +ida_hexrays.vdui_t.set_num_enum(self) -> bool + Convert number to symbolic constant. This function displays a dialog box and allows the user to select a symbolic constant to represent the number. + + @returns false if failed or cancelled -ida_hexrays.vdui_t.set_num_enum (method) - set_num_enum(self) -> bool - Convert number to symbolic constant. This function displays a dialog box and - allows the user to select a symbolic constant to represent the number. - - @return: false if failed or cancelled +ida_hexrays.vdui_t.set_num_radix(self, base: int) -> bool + Change number base. This function changes the current number representation. + + @param base: number radix (10 or 16) + 0 means a character constant + @returns false if failed -ida_hexrays.vdui_t.set_num_radix (method) - set_num_radix(self, base) -> bool - Change number base. This function changes the current number representation. - - @param base: (C++: int) number radix (10 or 16) - 0 means a character constant - @return: false if failed +ida_hexrays.vdui_t.set_num_stroff(self) -> bool + Convert number to structure field offset. Currently not implemented. + + @returns false if failed or cancelled -ida_hexrays.vdui_t.set_num_stroff (method) - set_num_stroff(self) -> bool - Convert number to structure field offset. Currently not implemented. - - @return: false if failed or cancelled +ida_hexrays.vdui_t.set_udm_type(self, udt_type: "tinfo_t", udm_idx: int) -> bool + Set structure field type. This function displays a dialog box and allows the user to change the type of a structure field. + + @param udt_type: structure/union type + @param udm_idx: index of the structure/union member + @returns false if failed or cancelled -ida_hexrays.vdui_t.set_strmem_type (method) - set_strmem_type(self, sptr, mptr) -> bool - Set structure field type. This function displays a dialog box and allows the - user to change the type of a structure field. - - @param sptr: (C++: struc_t *) pointer to structure - @param mptr: (C++: member_t *) pointer to structure member OBSOLETE FUNCTION, do not use! - @return: false if failed or cancelled +ida_hexrays.vdui_t.set_valid(self, v: bool) -> None -ida_hexrays.vdui_t.set_udm_type (method) - set_udm_type(self, udt_type, udm_idx) -> bool - Set structure field type. This function displays a dialog box and allows the - user to change the type of a structure field. - - @param udt_type: (C++: tinfo_t &) structure/union type - @param udm_idx: (C++: int) index of the structure/union member - @return: false if failed or cancelled +ida_hexrays.vdui_t.set_visible(self, v: bool) -> None -ida_hexrays.vdui_t.set_valid (method) - set_valid(self, v) - - @param v: bool +ida_hexrays.vdui_t.split_item(self, split: bool) -> bool + Split/unsplit item. This function splits the current assignment expression. + + @returns false if failed. -ida_hexrays.vdui_t.set_visible (method) - set_visible(self, v) - - @param v: bool +ida_hexrays.vdui_t.switch_to(self, f: "cfuncptr_t", activate: bool) -> None + Display the specified pseudocode. This function replaces the pseudocode window contents with the specified cfunc_t. + + @param f: pointer to the function to display. + @param activate: should the pseudocode window get focus? -ida_hexrays.vdui_t.split_item (method) - split_item(self, split) -> bool - Split/unsplit item. This function splits the current assignment expression. - - @param split: (C++: bool) - @return: false if failed. - -ida_hexrays.vdui_t.switch_to (method) - switch_to(self, f, activate) - Display the specified pseudocode. This function replaces the pseudocode window - contents with the specified cfunc_t. - - @param f: (C++: cfuncptr_t) pointer to the function to display. - @param activate: (C++: bool) should the pseudocode window get focus? - -ida_hexrays.vdui_t.tail (variable) +ida_hexrays.vdui_t.tail Tail ctree item on the current line (for indented comments) -ida_hexrays.vdui_t.ui_edit_lvar_cmt (method) - ui_edit_lvar_cmt(self, v) -> bool - Set local variable comment. This function displays a dialog box and allows the - user to edit the comment of a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled +ida_hexrays.vdui_t.ui_edit_lvar_cmt(self, v: "lvar_t") -> bool + Set local variable comment. This function displays a dialog box and allows the user to edit the comment of a local variable. + + @param v: pointer to local variable + @returns false if failed or cancelled -ida_hexrays.vdui_t.ui_map_lvar (method) - ui_map_lvar(self, v) -> bool - Map a local variable to another. This function displays a variable list and - allows the user to select mapping. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled +ida_hexrays.vdui_t.ui_map_lvar(self, v: "lvar_t") -> bool + Map a local variable to another. This function displays a variable list and allows the user to select mapping. + + @param v: pointer to local variable + @returns false if failed or cancelled -ida_hexrays.vdui_t.ui_rename_lvar (method) - ui_rename_lvar(self, v) -> bool - Rename local variable. This function displays a dialog box and allows the user - to rename a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled +ida_hexrays.vdui_t.ui_rename_lvar(self, v: "lvar_t") -> bool + Rename local variable. This function displays a dialog box and allows the user to rename a local variable. + + @param v: pointer to local variable + @returns false if failed or cancelled -ida_hexrays.vdui_t.ui_set_call_type (method) - ui_set_call_type(self, e) -> bool - Set type of a function call This function displays a dialog box and allows the - user to change the type of a function call - - @param e: (C++: const cexpr_t *) pointer to call expression - @return: false if failed or cancelled +ida_hexrays.vdui_t.ui_set_call_type(self, e: "cexpr_t") -> bool + Set type of a function call This function displays a dialog box and allows the user to change the type of a function call + + @param e: pointer to call expression + @returns false if failed or cancelled -ida_hexrays.vdui_t.ui_set_lvar_type (method) - ui_set_lvar_type(self, v) -> bool - Set local variable type. This function displays a dialog box and allows the user - to change the type of a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled +ida_hexrays.vdui_t.ui_set_lvar_type(self, v: "lvar_t") -> bool + Set local variable type. This function displays a dialog box and allows the user to change the type of a local variable. + + @param v: pointer to local variable + @returns false if failed or cancelled -ida_hexrays.vdui_t.ui_unmap_lvar (method) - ui_unmap_lvar(self, v) -> bool - Unmap a local variable. This function displays list of variables mapped to the - specified variable and allows the user to select a variable to unmap. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled +ida_hexrays.vdui_t.ui_unmap_lvar(self, v: "lvar_t") -> bool + Unmap a local variable. This function displays list of variables mapped to the specified variable and allows the user to select a variable to unmap. + + @param v: pointer to local variable + @returns false if failed or cancelled -ida_hexrays.vdui_t.valid (method) - valid(self) -> bool - Does the pseudocode window contain valid code? It can become invalid if the - function type gets changed in IDA. +ida_hexrays.vdui_t.valid(self) -> bool + Does the pseudocode window contain valid code? It can become invalid if the function type gets changed in IDA. + -ida_hexrays.vdui_t.view_idx (variable) +ida_hexrays.vdui_t.view_idx pseudocode window index (0..) -ida_hexrays.vdui_t.visible (method) - visible(self) -> bool - Is the pseudocode window visible? if not, it might be invisible or destroyed +ida_hexrays.vdui_t.visible(self) -> bool + Is the pseudocode window visible? if not, it might be invisible or destroyed + -ida_hexrays.vivl_t (class) - Proxy of C++ vivl_t class. +ida_hexrays.vivl_t -ida_hexrays.vivl_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: vivl_t const & - - __eq__(self, mop) -> bool - - @param mop: mop_t const & +ida_hexrays.vivl_t.__eq__(self, *args) -> bool -ida_hexrays.vivl_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: vivl_t const & +ida_hexrays.vivl_t.__ge__(self, r: "vivl_t") -> bool -ida_hexrays.vivl_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: vivl_t const & +ida_hexrays.vivl_t.__gt__(self, r: "vivl_t") -> bool -ida_hexrays.vivl_t.__init__ (method) - __init__(self, _type=mop_z, _off=-1, _size=0) -> vivl_t - - @param _type: mopt_t - @param _off: sval_t - @param _size: int - - __init__(self, ch) -> vivl_t - - @param ch: chain_t const & - - __init__(self, op) -> vivl_t - - @param op: mop_t const & +ida_hexrays.vivl_t.__init__(self, *args) -ida_hexrays.vivl_t.__le__ (method) - __le__(self, r) -> bool - - @param r: vivl_t const & +ida_hexrays.vivl_t.__le__(self, r: "vivl_t") -> bool -ida_hexrays.vivl_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: vivl_t const & +ida_hexrays.vivl_t.__lt__(self, r: "vivl_t") -> bool -ida_hexrays.vivl_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: vivl_t const & +ida_hexrays.vivl_t.__ne__(self, r: "vivl_t") -> bool -ida_hexrays.vivl_t._print (method) - _print(self) +ida_hexrays.vivl_t._print(self) -> None -ida_hexrays.vivl_t.compare (method) - compare(self, r) -> int - - @param r: vivl_t const & +ida_hexrays.vivl_t.compare(self, r: "vivl_t") -> int -ida_hexrays.vivl_t.contains (method) - contains(self, voff2) -> bool +ida_hexrays.vivl_t.contains(self, voff2: "voff_t") -> bool Does our value interval contain the specified value offset? - - @param voff2: (C++: const voff_t &) voff_t const & -ida_hexrays.vivl_t.dstr (method) - dstr(self) -> char const * +ida_hexrays.vivl_t.dstr(self) -> str -ida_hexrays.vivl_t.extend_to_cover (method) - extend_to_cover(self, r) -> bool - Extend a value interval using another value interval of the same type - - @param r: (C++: const vivl_t &) vivl_t const & - @return: success +ida_hexrays.vivl_t.extend_to_cover(self, r: "vivl_t") -> bool + Extend a value interval using another value interval of the same type + + @returns success -ida_hexrays.vivl_t.includes (method) - includes(self, r) -> bool +ida_hexrays.vivl_t.includes(self, r: "vivl_t") -> bool Does our value interval include another? - - @param r: (C++: const vivl_t &) vivl_t const & -ida_hexrays.vivl_t.intersect (method) - intersect(self, r) -> uval_t - Intersect value intervals the same type - - @param r: (C++: const vivl_t &) vivl_t const & - @return: size of the resulting intersection +ida_hexrays.vivl_t.intersect(self, r: "vivl_t") -> int + Intersect value intervals the same type + + @returns size of the resulting intersection -ida_hexrays.vivl_t.overlap (method) - overlap(self, r) -> bool +ida_hexrays.vivl_t.overlap(self, r: "vivl_t") -> bool Do two value intervals overlap? - - @param r: (C++: const vivl_t &) vivl_t const & -ida_hexrays.vivl_t.set (method) - set(self, _type, _off, _size=0) +ida_hexrays.vivl_t.set(self, *args) -> None + This function has the following signatures: - @param _type: mopt_t - @param _off: sval_t - @param _size: int + 0. set(_type: mopt_t, _off: int, _size: int=0) -> None + 1. set(voff: const voff_t &, _size: int) -> None - set(self, voff, _size) + # 0: set(_type: mopt_t, _off: int, _size: int=0) -> None - @param voff: voff_t const & - @param _size: int + + # 1: set(voff: const voff_t &, _size: int) -> None -ida_hexrays.vivl_t.set_reg (method) - set_reg(self, mreg, sz=0) - - @param mreg: mreg_t - @param sz: int +ida_hexrays.vivl_t.set_reg(self, mreg: "mreg_t", sz: int = 0) -> None -ida_hexrays.vivl_t.set_stkoff (method) - set_stkoff(self, stkoff, sz=0) - - @param stkoff: sval_t - @param sz: int +ida_hexrays.vivl_t.set_stkoff(self, stkoff: int, sz: int = 0) -> None -ida_hexrays.vivl_t.size (variable) +ida_hexrays.vivl_t.size Interval size in bytes. -ida_hexrays.voff_t (class) - Proxy of C++ voff_t class. +ida_hexrays.voff_t -ida_hexrays.voff_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: voff_t const & +ida_hexrays.voff_t.__eq__(self, r: "voff_t") -> bool -ida_hexrays.voff_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: voff_t const & +ida_hexrays.voff_t.__ge__(self, r: "voff_t") -> bool -ida_hexrays.voff_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: voff_t const & +ida_hexrays.voff_t.__gt__(self, r: "voff_t") -> bool -ida_hexrays.voff_t.__init__ (method) - __init__(self) -> voff_t - __init__(self, _type, _off) -> voff_t - - @param _type: mopt_t - @param _off: sval_t - - __init__(self, op) -> voff_t - - @param op: mop_t const & +ida_hexrays.voff_t.__init__(self, *args) -ida_hexrays.voff_t.__le__ (method) - __le__(self, r) -> bool - - @param r: voff_t const & +ida_hexrays.voff_t.__le__(self, r: "voff_t") -> bool -ida_hexrays.voff_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: voff_t const & +ida_hexrays.voff_t.__lt__(self, r: "voff_t") -> bool -ida_hexrays.voff_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: voff_t const & +ida_hexrays.voff_t.__ne__(self, r: "voff_t") -> bool -ida_hexrays.voff_t.add (method) - add(self, width) -> voff_t - - @param width: int +ida_hexrays.voff_t.add(self, width: int) -> "voff_t" -ida_hexrays.voff_t.compare (method) - compare(self, r) -> int - - @param r: voff_t const & +ida_hexrays.voff_t.compare(self, r: "voff_t") -> int -ida_hexrays.voff_t.defined (method) - defined(self) -> bool +ida_hexrays.voff_t.defined(self) -> bool -ida_hexrays.voff_t.diff (method) - diff(self, r) -> sval_t - - @param r: voff_t const & +ida_hexrays.voff_t.diff(self, r: "voff_t") -> int -ida_hexrays.voff_t.get_reg (method) - get_reg(self) -> mreg_t +ida_hexrays.voff_t.get_reg(self) -> "mreg_t" -ida_hexrays.voff_t.get_stkoff (method) - get_stkoff(self) -> sval_t +ida_hexrays.voff_t.get_stkoff(self) -> int -ida_hexrays.voff_t.inc (method) - inc(self, delta) - - @param delta: sval_t +ida_hexrays.voff_t.inc(self, delta: int) -> None -ida_hexrays.voff_t.is_reg (method) - is_reg(self) -> bool +ida_hexrays.voff_t.is_reg(self) -> bool -ida_hexrays.voff_t.is_stkoff (method) - is_stkoff(self) -> bool +ida_hexrays.voff_t.is_stkoff(self) -> bool -ida_hexrays.voff_t.off (variable) +ida_hexrays.voff_t.off register number or stack offset -ida_hexrays.voff_t.set (method) - set(self, _type, _off) - - @param _type: mopt_t - @param _off: sval_t +ida_hexrays.voff_t.set(self, _type: "mopt_t", _off: int) -> None -ida_hexrays.voff_t.set_reg (method) - set_reg(self, mreg) - - @param mreg: mreg_t +ida_hexrays.voff_t.set_reg(self, mreg: "mreg_t") -> None -ida_hexrays.voff_t.set_stkoff (method) - set_stkoff(self, stkoff) - - @param stkoff: sval_t +ida_hexrays.voff_t.set_stkoff(self, stkoff: int) -> None -ida_hexrays.voff_t.type (variable) +ida_hexrays.voff_t.type mop_r - register, mop_S - stack, mop_z - undefined -ida_hexrays.voff_t.undef (method) - undef(self) +ida_hexrays.voff_t.undef(self) -> None -ida_allins (module) - +ida_allins -ida_auto (module) +ida_auto Functions that work with the autoanalyzer queue. - The autoanalyzer works when IDA is not busy processing the user keystrokes. It - has several queues, each queue having its own priority. The analyzer stops when - all queues are empty. - - A queue contains addresses or address ranges. The addresses are kept sorted by - their values. The analyzer will process all addresses from the first queue, then - switch to the second queue and so on. There are no limitations on the size of - the queues. - - This file also contains functions that deal with the IDA status indicator and - the autoanalysis indicator. You may use these functions to change the indicator - value. + The autoanalyzer works when IDA is not busy processing the user keystrokes. It has several queues, each queue having its own priority. The analyzer stops when all queues are empty. + A queue contains addresses or address ranges. The addresses are kept sorted by their values. The analyzer will process all addresses from the first queue, then switch to the second queue and so on. There are no limitations on the size of the queues. + This file also contains functions that deal with the IDA status indicator and the autoanalysis indicator. You may use these functions to change the indicator value. + -ida_auto.AU_CHLB (variable) +ida_auto.AU_CHLB 12: load signature file (file name is kept separately) -ida_auto.AU_CODE (variable) +ida_auto.AU_CODE 1: convert to instruction -ida_auto.AU_FCHUNK (variable) +ida_auto.AU_FCHUNK 5: find func chunks -ida_auto.AU_FINAL (variable) +ida_auto.AU_FINAL 13: final pass -ida_auto.AU_LBF2 (variable) +ida_auto.AU_LBF2 10: the same, second pass -ida_auto.AU_LBF3 (variable) +ida_auto.AU_LBF3 11: the same, third pass -ida_auto.AU_LIBF (variable) +ida_auto.AU_LIBF 9: apply signature to address -ida_auto.AU_NONE (variable) +ida_auto.AU_NONE placeholder, not used -ida_auto.AU_PROC (variable) +ida_auto.AU_PROC 3: convert to procedure start -ida_auto.AU_TAIL (variable) +ida_auto.AU_TAIL 4: add a procedure tail -ida_auto.AU_TYPE (variable) +ida_auto.AU_TYPE 8: apply type information -ida_auto.AU_UNK (variable) +ida_auto.AU_UNK 0: convert to unexplored -ida_auto.AU_USD2 (variable) +ida_auto.AU_USD2 7: reanalyze, second pass -ida_auto.AU_USED (variable) +ida_auto.AU_USED 6: reanalyze -ida_auto.AU_WEAK (variable) +ida_auto.AU_WEAK 2: convert to instruction (ida decision) -ida_auto.auto_apply_tail (function) - auto_apply_tail(tail_ea, parent_ea) - Plan to apply the tail_ea chunk to the parent - - @param tail_ea: (C++: ea_t) linear address of start of tail - @param parent_ea: (C++: ea_t) linear address within parent. If BADADDR, automatically try to - find parent via xrefs. +ida_auto.auto_apply_tail(tail_ea: ida_idaapi.ea_t, parent_ea: ida_idaapi.ea_t) -> None + Plan to apply the tail_ea chunk to the parent + + @param tail_ea: linear address of start of tail + @param parent_ea: linear address within parent. If BADADDR, automatically try to find parent via xrefs. -ida_auto.auto_apply_type (function) - auto_apply_type(caller, callee) +ida_auto.auto_apply_type(caller: ida_idaapi.ea_t, callee: ida_idaapi.ea_t) -> None Plan to apply the callee's type to the calling point. - - @param caller: (C++: ea_t) - @param callee: (C++: ea_t) -ida_auto.auto_cancel (function) - auto_cancel(ea1, ea2) - Remove an address range (ea1..ea2) from queues AU_CODE, AU_PROC, AU_USED. To - remove an address range from other queues use auto_unmark() function. 'ea1' may - be higher than 'ea2', the kernel will swap them in this case. 'ea2' doesn't - belong to the range. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) +ida_auto.auto_cancel(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> None + Remove an address range (ea1..ea2) from queues AU_CODE, AU_PROC, AU_USED. To remove an address range from other queues use auto_unmark() function. 'ea1' may be higher than 'ea2', the kernel will swap them in this case. 'ea2' doesn't belong to the range. + -ida_auto.auto_display_t (class) - Proxy of C++ auto_display_t class. +ida_auto.auto_display_t -ida_auto.auto_display_t.__init__ (method) - __init__(self) -> auto_display_t +ida_auto.auto_display_t.__init__(self) -ida_auto.auto_get (function) - auto_get(type, lowEA, highEA) -> ea_t - Retrieve an address from queues regarding their priority. Returns BADADDR if no - addresses not lower than 'lowEA' and less than 'highEA' are found in the queues. - Otherwise *type will have queue type. - - @param type: (C++: atype_t *) - @param lowEA: (C++: ea_t) - @param highEA: (C++: ea_t) +ida_auto.auto_get(type: "atype_t *", lowEA: ida_idaapi.ea_t, highEA: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Retrieve an address from queues regarding their priority. Returns BADADDR if no addresses not lower than 'lowEA' and less than 'highEA' are found in the queues. Otherwise *type will have queue type. + -ida_auto.auto_is_ok (function) - auto_is_ok() -> bool - Are all queues empty? (i.e. has autoanalysis finished?). +ida_auto.auto_is_ok() -> bool + Are all queues empty? (i.e. has autoanalysis finished?). + -ida_auto.auto_make_code (function) - auto_make_code(ea) +ida_auto.auto_make_code(ea: ida_idaapi.ea_t) -> None Plan to make code. - - @param ea: (C++: ea_t) -ida_auto.auto_make_proc (function) - auto_make_proc(ea) +ida_auto.auto_make_proc(ea: ida_idaapi.ea_t) -> None Plan to make code&function. - - @param ea: (C++: ea_t) -ida_auto.auto_make_step (function) - auto_make_step(ea1, ea2) -> bool - Analyze one address in the specified range and return true. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - @return: if processed anything. false means that there is nothing to process in - the specified range. +ida_auto.auto_make_step(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> bool + Analyze one address in the specified range and return true. + + @returns if processed anything. false means that there is nothing to process in the specified range. -ida_auto.auto_mark (function) - auto_mark(ea, type) +ida_auto.auto_mark(ea: ida_idaapi.ea_t, type: "atype_t") -> None Put single address into a queue. Queues keep addresses sorted. - - @param ea: (C++: ea_t) - @param type: (C++: atype_t) -ida_auto.auto_mark_range (function) - auto_mark_range(start, end, type) - Put range of addresses into a queue. 'start' may be higher than 'end', the - kernel will swap them in this case. 'end' doesn't belong to the range. - - @param start: (C++: ea_t) - @param end: (C++: ea_t) - @param type: (C++: atype_t) +ida_auto.auto_mark_range(start: ida_idaapi.ea_t, end: ida_idaapi.ea_t, type: "atype_t") -> None + Put range of addresses into a queue. 'start' may be higher than 'end', the kernel will swap them in this case. 'end' doesn't belong to the range. + -ida_auto.auto_postpone_analysis (function) - auto_postpone_analysis(ea) -> bool - Plan to reanalyze on the second pass The typical usage of this function in - emu.cpp is: if ( !auto_postpone_analysis(ea) ) op_offset(ea, 0, ...); (we make - an offset only on the second pass) - - @param ea: (C++: ea_t) +ida_auto.auto_postpone_analysis(ea: ida_idaapi.ea_t) -> bool + Plan to reanalyze on the second pass The typical usage of this function in emu.cpp is: if ( !auto_postpone_analysis(ea) ) op_offset(ea, 0, ...); (we make an offset only on the second pass) + -ida_auto.auto_recreate_insn (function) - auto_recreate_insn(ea) -> int - Try to create instruction - - @param ea: (C++: ea_t) linear address of callee - @return: the length of the instruction or 0 +ida_auto.auto_recreate_insn(ea: ida_idaapi.ea_t) -> int + Try to create instruction + + @param ea: linear address of callee + @returns the length of the instruction or 0 -ida_auto.auto_unmark (function) - auto_unmark(start, end, type) - Remove range of addresses from a queue. 'start' may be higher than 'end', the - kernel will swap them in this case. 'end' doesn't belong to the range. - - @param start: (C++: ea_t) - @param end: (C++: ea_t) - @param type: (C++: atype_t) +ida_auto.auto_unmark(start: ida_idaapi.ea_t, end: ida_idaapi.ea_t, type: "atype_t") -> None + Remove range of addresses from a queue. 'start' may be higher than 'end', the kernel will swap them in this case. 'end' doesn't belong to the range. + -ida_auto.auto_wait (function) - auto_wait() -> bool - Process everything in the queues and return true. - - @return: false if the user clicked cancel. (the wait box must be displayed by - the caller if desired) +ida_auto.auto_wait() -> bool + Process everything in the queues and return true. + + @returns false if the user clicked cancel. (the wait box must be displayed by the caller if desired) -ida_auto.auto_wait_range (function) - auto_wait_range(ea1, ea2) -> ssize_t - Process everything in the specified range and return true. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - @return: number of autoanalysis steps made. -1 if the user clicked cancel. (the - wait box must be displayed by the caller if desired) +ida_auto.auto_wait_range(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> "ssize_t" + Process everything in the specified range and return true. + + @returns number of autoanalysis steps made. -1 if the user clicked cancel. (the wait box must be displayed by the caller if desired) -ida_auto.enable_auto (function) - enable_auto(enable) -> bool - Temporarily enable/disable autoanalyzer. Not user-facing, but rather because IDA - sometimes need to turn AA on/off regardless of inf.s_genflags:INFFL_AUTO - - @param enable: (C++: bool) - @return: old state +ida_auto.enable_auto(enable: bool) -> bool + Temporarily enable/disable autoanalyzer. Not user-facing, but rather because IDA sometimes need to turn AA on/off regardless of inf.s_genflags:INFFL_AUTO + + @returns old state -ida_auto.get_auto_display (function) - get_auto_display(auto_display) -> bool +ida_auto.get_auto_display(auto_display: "auto_display_t") -> bool Get structure which holds the autoanalysis indicator contents. - - @param auto_display: (C++: auto_display_t *) -ida_auto.get_auto_state (function) - get_auto_state() -> atype_t - Get current state of autoanalyzer. If auto_state == AU_NONE, IDA is currently - not running the analysis (it could be temporarily interrupted to perform the - user's requests, for example). +ida_auto.get_auto_state() -> "atype_t" + Get current state of autoanalyzer. If auto_state == AU_NONE, IDA is currently not running the analysis (it could be temporarily interrupted to perform the user's requests, for example). + -ida_auto.is_auto_enabled (function) - is_auto_enabled() -> bool +ida_auto.is_auto_enabled() -> bool Get autoanalyzer state. -ida_auto.may_create_stkvars (function) - may_create_stkvars() -> bool - Is it allowed to create stack variables automatically?. This function should be - used by IDP modules before creating stack vars. +ida_auto.may_create_stkvars() -> bool + Is it allowed to create stack variables automatically?. This function should be used by IDP modules before creating stack vars. + -ida_auto.may_trace_sp (function) - may_trace_sp() -> bool - Is it allowed to trace stack pointer automatically?. This function should be - used by IDP modules before tracing sp. +ida_auto.may_trace_sp() -> bool + Is it allowed to trace stack pointer automatically?. This function should be used by IDP modules before tracing sp. + -ida_auto.peek_auto_queue (function) - peek_auto_queue(low_ea, type) -> ea_t - Peek into a queue 'type' for an address not lower than 'low_ea'. Do not remove - address from the queue. - - @param low_ea: (C++: ea_t) - @param type: (C++: atype_t) - @return: the address or BADADDR +ida_auto.peek_auto_queue(low_ea: ida_idaapi.ea_t, type: "atype_t") -> ida_idaapi.ea_t + Peek into a queue 'type' for an address not lower than 'low_ea'. Do not remove address from the queue. + + @returns the address or BADADDR -ida_auto.plan_and_wait (function) - plan_and_wait(ea1, ea2, final_pass=True) -> int - Analyze the specified range. Try to create instructions where possible. Make the - final pass over the specified range if specified. This function doesn't return - until the range is analyzed. +ida_auto.plan_and_wait(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, final_pass: bool = True) -> int + Analyze the specified range. Try to create instructions where possible. Make the final pass over the specified range if specified. This function doesn't return until the range is analyzed. + @retval 1: ok @retval 0: Ctrl-Break was pressed - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - @param final_pass: (C++: bool) -ida_auto.plan_ea (function) - plan_ea(ea) +ida_auto.plan_ea(ea: ida_idaapi.ea_t) -> None Plan to perform reanalysis. - - @param ea: (C++: ea_t) -ida_auto.plan_range (function) - plan_range(sEA, eEA) +ida_auto.plan_range(sEA: ida_idaapi.ea_t, eEA: ida_idaapi.ea_t) -> None Plan to perform reanalysis. - - @param sEA: (C++: ea_t) - @param eEA: (C++: ea_t) -ida_auto.reanalyze_callers (function) - reanalyze_callers(ea, noret) - Plan to reanalyze callers of the specified address. This function will add to - AU_USED queue all instructions that call (not jump to) the specified address. - - @param ea: (C++: ea_t) linear address of callee - @param noret: (C++: bool) !=0: the callee doesn't return, mark to undefine subsequent - instructions in the caller. 0: do nothing. +ida_auto.reanalyze_callers(ea: ida_idaapi.ea_t, noret: bool) -> None + Plan to reanalyze callers of the specified address. This function will add to AU_USED queue all instructions that call (not jump to) the specified address. + + @param ea: linear address of callee + @param noret: !=0: the callee doesn't return, mark to undefine subsequent instructions in the caller. 0: do nothing. -ida_auto.revert_ida_decisions (function) - revert_ida_decisions(ea1, ea2) +ida_auto.revert_ida_decisions(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> None Delete all analysis info that IDA generated for for the given range. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) -ida_auto.set_auto_state (function) - set_auto_state(new_state) -> atype_t - Set current state of autoanalyzer. - - @param new_state: (C++: atype_t) new state of autoanalyzer - @return: previous state +ida_auto.set_auto_state(new_state: "atype_t") -> "atype_t" + Set current state of autoanalyzer. + + @param new_state: new state of autoanalyzer + @returns previous state -ida_auto.set_ida_state (function) - set_ida_state(st) -> idastate_t - Change IDA status indicator value - - @param st: (C++: idastate_t) - new indicator status - @return: old indicator status +ida_auto.set_ida_state(st: "idastate_t") -> "idastate_t" + Change IDA status indicator value + + @param st: - new indicator status + @returns old indicator status -ida_auto.show_addr (function) - show_addr(ea) - Show an address on the autoanalysis indicator. The address is displayed in the - form " @:12345678". - - @param ea: (C++: ea_t) - linear address to display +ida_auto.show_addr(ea: ida_idaapi.ea_t) -> None + Show an address on the autoanalysis indicator. The address is displayed in the form " @:12345678". + + @param ea: - linear address to display -ida_auto.show_auto (function) - show_auto(ea, type=AU_NONE) - Change autoanalysis indicator value. - - @param ea: (C++: ea_t) linear address being analyzed - @param type: (C++: atype_t) autoanalysis type (see Autoanalysis queues) +ida_auto.show_auto(*args) -> None + Change autoanalysis indicator value. + + @param ea: linear address being analyzed + @param type: autoanalysis type (see Autoanalysis queues) -ida_bitrange (module) +ida_auto.st_Ready + READY: IDA is doing nothing. + +ida_auto.st_Think + THINKING: Autoanalysis on, the user may press keys. + +ida_auto.st_Waiting + WAITING: Waiting for the user input. + +ida_auto.st_Work + BUSY: IDA is busy. + +ida_bitrange Definition of the bitrange_t class. -ida_bitrange.bitrange_t (class) - Proxy of C++ bitrange_t class. +ida_bitrange.bitrange_t -ida_bitrange.bitrange_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bitrange_t const & +ida_bitrange.bitrange_t.__eq__(self, r: "bitrange_t") -> bool -ida_bitrange.bitrange_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bitrange_t const & +ida_bitrange.bitrange_t.__ge__(self, r: "bitrange_t") -> bool -ida_bitrange.bitrange_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bitrange_t const & +ida_bitrange.bitrange_t.__gt__(self, r: "bitrange_t") -> bool -ida_bitrange.bitrange_t.__init__ (method) - __init__(self, bit_ofs=0, size_in_bits=0) -> bitrange_t - - @param bit_ofs: uint16 - @param size_in_bits: uint16 +ida_bitrange.bitrange_t.__init__(self, bit_ofs: "uint16" = 0, size_in_bits: "uint16" = 0) -ida_bitrange.bitrange_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bitrange_t const & +ida_bitrange.bitrange_t.__le__(self, r: "bitrange_t") -> bool -ida_bitrange.bitrange_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bitrange_t const & +ida_bitrange.bitrange_t.__lt__(self, r: "bitrange_t") -> bool -ida_bitrange.bitrange_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bitrange_t const & +ida_bitrange.bitrange_t.__ne__(self, r: "bitrange_t") -> bool -ida_bitrange.bitrange_t.__str__ (method) - __str__(self) -> qstring +ida_bitrange.bitrange_t.__repr__(self) -ida_bitrange.bitrange_t.apply_mask (method) - apply_mask(self, subrange) -> bool - Apply mask to a bitrange - - @param subrange: (C++: const bitrange_t &) range *inside* the main bitrange to keep After this operation - the main bitrange will be truncated to have only the bits that - are specified by subrange. Example: [off=8,nbits=4], - subrange[off=1,nbits=2] => [off=9,nbits=2] - @return: success +ida_bitrange.bitrange_t.__str__(self) -> str -ida_bitrange.bitrange_t.bitoff (method) - bitoff(self) -> uint +ida_bitrange.bitrange_t.apply_mask(self, subrange: "bitrange_t") -> bool + Apply mask to a bitrange + + @param subrange: range *inside* the main bitrange to keep After this operation the main bitrange will be truncated to have only the bits that are specified by subrange. Example: [off=8,nbits=4], subrange[off=1,nbits=2] => [off=9,nbits=2] + @returns success + +ida_bitrange.bitrange_t.bitoff(self) -> "uint" Get offset of 1st bit. -ida_bitrange.bitrange_t.bitsize (method) - bitsize(self) -> uint +ida_bitrange.bitrange_t.bitsize(self) -> "uint" Get size of the value in bits. -ida_bitrange.bitrange_t.bytesize (method) - bytesize(self) -> uint +ida_bitrange.bitrange_t.bytesize(self) -> "uint" Size of the value in bytes. -ida_bitrange.bitrange_t.compare (method) - compare(self, r) -> int - - @param r: bitrange_t const & +ida_bitrange.bitrange_t.compare(self, r: "bitrange_t") -> int -ida_bitrange.bitrange_t.create_union (method) - create_union(self, r) +ida_bitrange.bitrange_t.create_union(self, r: "bitrange_t") -> None Create union of 2 ranges including the hole between them. - - @param r: (C++: const bitrange_t &) bitrange_t const & -ida_bitrange.bitrange_t.empty (method) - empty(self) -> bool +ida_bitrange.bitrange_t.empty(self) -> bool Is the bitrange empty? -ida_bitrange.bitrange_t.extract (method) - extract(self, src, is_mf) -> bool - - @param src: void const * - @param is_mf: bool +ida_bitrange.bitrange_t.extract(self, src: "void const *", is_mf: bool) -> bool -ida_bitrange.bitrange_t.has_common (method) - has_common(self, r) -> bool +ida_bitrange.bitrange_t.has_common(self, r: "bitrange_t") -> bool Does have common bits with another bitrange? - - @param r: (C++: const bitrange_t &) bitrange_t const & -ida_bitrange.bitrange_t.init (method) - init(self, bit_ofs, size_in_bits) +ida_bitrange.bitrange_t.init(self, bit_ofs: "uint16", size_in_bits: "uint16") -> None Initialize offset and size to given values. - - @param bit_ofs: (C++: uint16) - @param size_in_bits: (C++: uint16) -ida_bitrange.bitrange_t.inject (method) - inject(self, dst, src, is_mf) -> bool - - @param dst: void * - @param src: bytevec_t const & - @param is_mf: bool +ida_bitrange.bitrange_t.inject(self, dst: "void *", src: "bytevec_t const &", is_mf: bool) -> bool -ida_bitrange.bitrange_t.intersect (method) - intersect(self, r) +ida_bitrange.bitrange_t.intersect(self, r: "bitrange_t") -> None Intersect two ranges. - - @param r: (C++: const bitrange_t &) bitrange_t const & -ida_bitrange.bitrange_t.mask64 (method) - mask64(self) -> uint64 +ida_bitrange.bitrange_t.mask64(self) -> "uint64" Convert to mask of 64 bits. -ida_bitrange.bitrange_t.reset (method) - reset(self) +ida_bitrange.bitrange_t.reset(self) -> None Make the bitrange empty. -ida_bitrange.bitrange_t.shift_down (method) - shift_down(self, cnt) +ida_bitrange.bitrange_t.shift_down(self, cnt: "uint") -> None Shift range down (left) - - @param cnt: (C++: uint) -ida_bitrange.bitrange_t.shift_up (method) - shift_up(self, cnt) +ida_bitrange.bitrange_t.shift_up(self, cnt: "uint") -> None Shift range up (right) - - @param cnt: (C++: uint) -ida_bitrange.bitrange_t.sub (method) - sub(self, r) -> bool +ida_bitrange.bitrange_t.sub(self, r: "bitrange_t") -> bool Subtract a bitrange. - - @param r: (C++: const bitrange_t &) bitrange_t const & -ida_bytes (module) +ida_bytes Contains functions that deal with individual byte characteristics. - Each byte of the disassembled program is represented by a 32-bit value. We will - call this value 'flags'. The structure of the flags is here. - - You are not allowed to inspect individual bits of flags and modify them - directly. Use special functions to inspect and/or modify flags. - - Flags are kept in a virtual array file (*.id1). Addresses (ea) are all 32-bit - (or 64-bit) quantities. + Each byte of the disassembled program is represented by a 32-bit value. We will call this value 'flags'. The structure of the flags is here. + You are not allowed to inspect individual bits of flags and modify them directly. Use special functions to inspect and/or modify flags. + Flags are kept in a virtual array file (*.id1). Addresses (ea) are all 32-bit (or 64-bit) quantities. + -ida_bytes.ALOPT_APPEND (variable) - if an existing strlit is encountered, then append it to the string. +ida_bytes.ALOPT_APPEND + if an existing strlit is encountered, then append it to the string. + -ida_bytes.ALOPT_IGNCLT (variable) - if set, don't stop at codepoints that are not part of the current 'culture'; - accept all those that are graphical (this is typically used used by user- - initiated actions creating string literals.) +ida_bytes.ALOPT_IGNCLT + if set, don't stop at codepoints that are not part of the current 'culture'; accept all those that are graphical (this is typically used used by user-initiated actions creating string literals.) + -ida_bytes.ALOPT_IGNHEADS (variable) - don't stop if another data item is encountered. only the byte values will be - used to determine the string length. if not set, a defined data item or - instruction will truncate the string +ida_bytes.ALOPT_IGNHEADS + don't stop if another data item is encountered. only the byte values will be used to determine the string length. if not set, a defined data item or instruction will truncate the string + -ida_bytes.ALOPT_IGNPRINT (variable) - if set, don't stop at non-printable codepoints, but only at the terminating - character (or not unicode-mapped character (e.g., 0x8f in CP1252)) +ida_bytes.ALOPT_IGNPRINT + if set, don't stop at non-printable codepoints, but only at the terminating character (or not unicode-mapped character (e.g., 0x8f in CP1252)) + -ida_bytes.ALOPT_MAX4K (variable) - if string length is more than 4K, return the accumulated length +ida_bytes.ALOPT_MAX4K + if string length is more than 4K, return the accumulated length + -ida_bytes.ALOPT_ONLYTERM (variable) - only the termination characters can be at the string end. Without this option - illegal characters also terminate the string. +ida_bytes.ALOPT_ONLYTERM + only the termination characters can be at the string end. Without this option illegal characters also terminate the string. + -ida_bytes.BIN_SEARCH_BACKWARD (variable) +ida_bytes.BIN_SEARCH_BACKWARD search backward for bytes -ida_bytes.BIN_SEARCH_BITMASK (variable) +ida_bytes.BIN_SEARCH_BITMASK searching using strict bit mask -ida_bytes.BIN_SEARCH_CASE (variable) +ida_bytes.BIN_SEARCH_CASE case sensitive -ida_bytes.BIN_SEARCH_FORWARD (variable) +ida_bytes.BIN_SEARCH_FORWARD search forward for bytes -ida_bytes.BIN_SEARCH_INITED (variable) +ida_bytes.BIN_SEARCH_INITED find_byte, find_byter: any initilized value -ida_bytes.BIN_SEARCH_NOBREAK (variable) +ida_bytes.BIN_SEARCH_NOBREAK don't check for Ctrl-Break -ida_bytes.BIN_SEARCH_NOCASE (variable) +ida_bytes.BIN_SEARCH_NOCASE case insensitive -ida_bytes.BIN_SEARCH_NOSHOW (variable) +ida_bytes.BIN_SEARCH_NOSHOW don't show search progress or update screen -ida_bytes.DELIT_DELNAMES (variable) - delete any names at the specified address range (except for the starting - address). this bit is valid if nbytes > 1 +ida_bytes.DELIT_DELNAMES + delete any names at the specified address range (except for the starting address). this bit is valid if nbytes > 1 + -ida_bytes.DELIT_EXPAND (variable) - propagate undefined items; for example if removing an instruction removes all - references to the next instruction, then plan to convert to unexplored the next - instruction too. +ida_bytes.DELIT_EXPAND + propagate undefined items; for example if removing an instruction removes all references to the next instruction, then plan to convert to unexplored the next instruction too. + -ida_bytes.DELIT_KEEPFUNC (variable) - do not undefine the function start. Just delete xrefs, ops e.t.c. +ida_bytes.DELIT_KEEPFUNC + do not undefine the function start. Just delete xrefs, ops e.t.c. + -ida_bytes.DELIT_NOCMT (variable) - reject to delete if a comment is in address range (except for the starting - address). this bit is valid if nbytes > 1 +ida_bytes.DELIT_NOCMT + reject to delete if a comment is in address range (except for the starting address). this bit is valid if nbytes > 1 + -ida_bytes.DELIT_NOTRUNC (variable) - don't truncate the current function even if AF_TRFUNC is set +ida_bytes.DELIT_NOTRUNC + don't truncate the current function even if AF_TRFUNC is set + -ida_bytes.DELIT_NOUNAME (variable) - reject to delete if a user name is in address range (except for the starting - address). this bit is valid if nbytes > 1 +ida_bytes.DELIT_NOUNAME + reject to delete if a user name is in address range (except for the starting address). this bit is valid if nbytes > 1 + -ida_bytes.DELIT_SIMPLE (variable) +ida_bytes.DELIT_SIMPLE simply undefine the specified item(s) -ida_bytes.DTP_NODUP (variable) +ida_bytes.DTP_NODUP do not use dup construct -ida_bytes.DT_TYPE (variable) +ida_bytes.DTP_NODUP + do not use dup construct + +ida_bytes.DT_TYPE Mask for DATA typing. -ida_bytes.FF_ALIGN (variable) +ida_bytes.FF_ALIGN alignment directive -ida_bytes.FF_BNOT (variable) +ida_bytes.FF_ANYNAME + Has name or dummy name? + +ida_bytes.FF_BNOT Bitwise negation of operands. -ida_bytes.FF_BYTE (variable) +ida_bytes.FF_BYTE byte -ida_bytes.FF_CODE (variable) +ida_bytes.FF_CODE Code ? -ida_bytes.FF_COMM (variable) +ida_bytes.FF_COMM Has comment ? -ida_bytes.FF_CUSTOM (variable) +ida_bytes.FF_CUSTOM custom data type -ida_bytes.FF_DATA (variable) +ida_bytes.FF_DATA Data ? -ida_bytes.FF_DOUBLE (variable) +ida_bytes.FF_DOUBLE double -ida_bytes.FF_DWORD (variable) +ida_bytes.FF_DWORD double word -ida_bytes.FF_FLOAT (variable) +ida_bytes.FF_FLOAT float -ida_bytes.FF_FLOW (variable) +ida_bytes.FF_FLOW Exec flow from prev instruction. -ida_bytes.FF_FUNC (variable) +ida_bytes.FF_FUNC function start? -ida_bytes.FF_IMMD (variable) +ida_bytes.FF_IMMD Has Immediate value ? -ida_bytes.FF_IVL (variable) +ida_bytes.FF_IVL Byte has value ? -ida_bytes.FF_JUMP (variable) +ida_bytes.FF_JUMP Has jump table or switch_info? -ida_bytes.FF_LABL (variable) +ida_bytes.FF_LABL Has dummy name? -ida_bytes.FF_LINE (variable) +ida_bytes.FF_LINE Has next or prev lines ? -ida_bytes.FF_NAME (variable) +ida_bytes.FF_NAME Has name ? -ida_bytes.FF_N_CHAR (variable) +ida_bytes.FF_N_CHAR Char ('x')? -ida_bytes.FF_N_CUST (variable) +ida_bytes.FF_N_CUST Custom representation? -ida_bytes.FF_N_ENUM (variable) +ida_bytes.FF_N_ENUM Enumeration? -ida_bytes.FF_N_FLT (variable) +ida_bytes.FF_N_FLT Floating point number? -ida_bytes.FF_N_FOP (variable) +ida_bytes.FF_N_FOP Forced operand? -ida_bytes.FF_N_NUMB (variable) +ida_bytes.FF_N_NUMB Binary number? -ida_bytes.FF_N_NUMD (variable) +ida_bytes.FF_N_NUMD Decimal number? -ida_bytes.FF_N_NUMH (variable) +ida_bytes.FF_N_NUMH Hexadecimal number? -ida_bytes.FF_N_NUMO (variable) +ida_bytes.FF_N_NUMO Octal number? -ida_bytes.FF_N_OFF (variable) +ida_bytes.FF_N_OFF Offset? -ida_bytes.FF_N_SEG (variable) +ida_bytes.FF_N_SEG Segment? -ida_bytes.FF_N_STK (variable) +ida_bytes.FF_N_STK Stack variable? -ida_bytes.FF_N_STRO (variable) +ida_bytes.FF_N_STRO Struct offset? -ida_bytes.FF_N_VOID (variable) +ida_bytes.FF_N_VOID Void (unknown)? -ida_bytes.FF_OWORD (variable) +ida_bytes.FF_OWORD octaword/xmm word (16 bytes/128 bits) -ida_bytes.FF_PACKREAL (variable) +ida_bytes.FF_PACKREAL packed decimal real -ida_bytes.FF_QWORD (variable) +ida_bytes.FF_QWORD quadro word -ida_bytes.FF_REF (variable) +ida_bytes.FF_REF has references -ida_bytes.FF_SIGN (variable) +ida_bytes.FF_SIGN Inverted sign of operands. -ida_bytes.FF_STRLIT (variable) +ida_bytes.FF_STRLIT string literal -ida_bytes.FF_STRUCT (variable) +ida_bytes.FF_STRUCT struct variable -ida_bytes.FF_TAIL (variable) +ida_bytes.FF_TAIL Tail ? -ida_bytes.FF_TBYTE (variable) +ida_bytes.FF_TBYTE tbyte -ida_bytes.FF_UNK (variable) +ida_bytes.FF_UNK Unknown ? -ida_bytes.FF_UNUSED (variable) +ida_bytes.FF_UNUSED unused bit (was used for variable bytes) -ida_bytes.FF_WORD (variable) +ida_bytes.FF_WORD word -ida_bytes.FF_YWORD (variable) +ida_bytes.FF_YWORD ymm word (32 bytes/256 bits) -ida_bytes.FF_ZWORD (variable) +ida_bytes.FF_ZWORD zmm word (64 bytes/512 bits) -ida_bytes.GFE_IDB_VALUE (variable) - get flags with FF_IVL & MS_VAL. but never use the debugger memory. +ida_bytes.GFE_IDB_VALUE + get flags with FF_IVL & MS_VAL. but never use the debugger memory. + -ida_bytes.GFE_VALUE (variable) - get flags with FF_IVL & MS_VAL. It is much slower under remote debugging because - the kernel needs to read the process memory. +ida_bytes.GFE_VALUE + get flags with FF_IVL & MS_VAL. It is much slower under remote debugging because the kernel needs to read the process memory. + -ida_bytes.GMB_READALL (variable) - try to read all bytes; if this bit is not set, fail at first uninited byte +ida_bytes.GMB_READALL + try to read all bytes; if this bit is not set, fail at first uninited byte + -ida_bytes.GMB_WAITBOX (variable) +ida_bytes.GMB_WAITBOX show wait box (may return -1 in this case) -ida_bytes.ITEM_END_CANCEL (variable) - stop when operation cancelled, it is the responsibility of the caller to show - the wait dialog +ida_bytes.ITEM_END_CANCEL + stop when operation cancelled, it is the responsibility of the caller to show the wait dialog + -ida_bytes.ITEM_END_FIXUP (variable) +ida_bytes.ITEM_END_FIXUP stop at the first fixup -ida_bytes.ITEM_END_INITED (variable) +ida_bytes.ITEM_END_INITED stop when initialization changes i.e. * if is_loaded(ea): stop if uninitialized byte is encountered - * if !is_loaded(ea): stop if initialized byte is encountered + * if !is_loaded(ea): stop if initialized byte is encountered + + + -ida_bytes.ITEM_END_NAME (variable) +ida_bytes.ITEM_END_NAME stop at the first named location -ida_bytes.ITEM_END_XREF (variable) +ida_bytes.ITEM_END_XREF stop at the first referenced location -ida_bytes.MS_CLS (variable) +ida_bytes.MS_CLS Mask for typing. -ida_bytes.MS_CODE (variable) +ida_bytes.MS_CODE Mask for code bits. -ida_bytes.MS_COMM (variable) +ida_bytes.MS_COMM Mask of common bits. -ida_bytes.MS_N_TYPE (variable) +ida_bytes.MS_N_TYPE Mask for nth arg (a 64-bit constant) -ida_bytes.MS_VAL (variable) +ida_bytes.MS_VAL Mask for byte value. -ida_bytes.OPND_ALL (variable) +ida_bytes.OPND_ALL all operands -ida_bytes.OPND_MASK (variable) +ida_bytes.OPND_MASK mask for operand number -ida_bytes.OPND_OUTER (variable) - outer offset base (combined with operand number). used only in set, get, - del_offset() functions +ida_bytes.OPND_OUTER + outer offset base (combined with operand number). used only in set, get, del_offset() functions + -ida_bytes.PSTF_ATTRIB (variable) +ida_bytes.PBSENC_ALL + Use all IDB encodings. + +ida_bytes.PBSENC_DEF1BPU + Use the default 1 byte-per-unit IDB encoding. + +ida_bytes.PSTF_ATTRIB generate for type attribute usage -ida_bytes.PSTF_ENC (variable) +ida_bytes.PSTF_ENC if encoding is specified, append it -ida_bytes.PSTF_HOTKEY (variable) +ida_bytes.PSTF_HOTKEY have hotkey markers part of the name -ida_bytes.PSTF_ONLY_ENC (variable) +ida_bytes.PSTF_ONLY_ENC generate only the encoding name -ida_bytes.PSTF_TBRIEF (variable) +ida_bytes.PSTF_TBRIEF use brief name (e.g., in the 'Strings' window) -ida_bytes.PSTF_TINLIN (variable) +ida_bytes.PSTF_TINLIN use 'inline' name (e.g., in the structures comments) -ida_bytes.PSTF_TMASK (variable) +ida_bytes.PSTF_TMASK type mask -ida_bytes.PSTF_TNORM (variable) +ida_bytes.PSTF_TNORM use normal name -ida_bytes.STRCONV_ESCAPE (variable) +ida_bytes.STRCONV_ESCAPE convert non-printable characters to C escapes ( , \xNN, \uNNNN) -ida_bytes.STRCONV_INCLLEN (variable) - for Pascal-style strings, include the prefixing length byte(s) as C-escaped - sequence +ida_bytes.STRCONV_INCLLEN + for Pascal-style strings, include the prefixing length byte(s) as C-escaped sequence -ida_bytes.STRCONV_REPLCHAR (variable) +ida_bytes.STRCONV_REPLCHAR convert non-printable characters to the Unicode replacement character (U+FFFD) -ida_bytes.__walk_types_and_formats (function) +ida_bytes.__to_bytevec(_in: "bytevec_t const &") -> "bytevec_t" -ida_bytes.add_byte (function) - add_byte(ea, value) - Add a value to one byte of the program. This function works for wide byte - processors too. - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint32) byte value +ida_bytes.__walk_types_and_formats(formats, type_action, format_action, installing) -ida_bytes.add_dword (function) - add_dword(ea, value) - Add a value to one dword of the program. This function works for wide byte - processors too. This function takes into account order of bytes specified in - idainfo::is_be() - @note: this function works incorrectly if processor_t::nbits > 16 - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint64) byte value +ida_bytes.add_byte(ea: ida_idaapi.ea_t, value: int) -> None + Add a value to one byte of the program. This function works for wide byte processors too. + + @param ea: linear address + @param value: byte value -ida_bytes.add_hidden_range (function) - add_hidden_range(ea1, ea2, description, header, footer, color=bgcolor_t(-1)) -> bool - Mark a range of addresses as hidden. The range will be created in the invisible - state with the default color - - @param ea1: (C++: ea_t) linear address of start of the address range - @param ea2: (C++: ea_t) linear address of end of the address range - @param description: (C++: const char *) ,header,footer: range parameters - @param header: (C++: const char *) char const * - @param footer: (C++: const char *) char const * - @param color: (C++: bgcolor_t) the range color - @return: success +ida_bytes.add_dword(ea: ida_idaapi.ea_t, value: "uint64") -> None + Add a value to one dword of the program. This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be() + + @param ea: linear address + @param value: byte value -ida_bytes.add_mapping (function) - add_mapping(_from, to, size) -> bool - IDA supports memory mapping. References to the addresses from the mapped range - use data and meta-data from the mapping range. - @note: You should set flag PR2_MAPPING in ph.flag2 to use memory mapping Add - memory mapping range. - - @param from: (C++: ea_t) start of the mapped range (nonexistent address) - @param to: (C++: ea_t) start of the mapping range (existent address) - @param size: (C++: asize_t) size of the range - @return: success +ida_bytes.add_hidden_range(*args) -> bool + Mark a range of addresses as hidden. The range will be created in the invisible state with the default color + + @param ea1: linear address of start of the address range + @param ea2: linear address of end of the address range + @param description: range parameters + @param header: range parameters + @param footer: range parameters + @param color: the range color + @returns success -ida_bytes.add_qword (function) - add_qword(ea, value) - Add a value to one qword of the program. This function does not work for wide - byte processors. This function takes into account order of bytes specified in - idainfo::is_be() - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint64) byte value +ida_bytes.add_mapping(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, size: "asize_t") -> bool + IDA supports memory mapping. References to the addresses from the mapped range use data and meta-data from the mapping range. + + @param to: start of the mapping range (existent address) + @param size: size of the range + @returns success -ida_bytes.add_word (function) - add_word(ea, value) - Add a value to one word of the program. This function works for wide byte - processors too. This function takes into account order of bytes specified in - idainfo::is_be() - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint64) byte value +ida_bytes.add_qword(ea: ida_idaapi.ea_t, value: "uint64") -> None + Add a value to one qword of the program. This function does not work for wide byte processors. This function takes into account order of bytes specified in idainfo::is_be() + + @param ea: linear address + @param value: byte value -ida_bytes.align_flag (function) - align_flag() -> flags64_t +ida_bytes.add_word(ea: ida_idaapi.ea_t, value: "uint64") -> None + Add a value to one word of the program. This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be() + + @param ea: linear address + @param value: byte value + +ida_bytes.align_flag() -> "flags64_t" Get a flags64_t representing an alignment directive. -ida_bytes.append_cmt (function) - append_cmt(ea, str, rptble) -> bool - Append to an indented comment. Creates a new comment if none exists. Appends a - newline character and the specified string otherwise. - - @param ea: (C++: ea_t) linear address - @param str: (C++: const char *) comment string to append - @param rptble: (C++: bool) append to repeatable comment? - @return: success +ida_bytes.append_cmt(ea: ida_idaapi.ea_t, str: str, rptble: bool) -> bool + Append to an indented comment. Creates a new comment if none exists. Appends a newline character and the specified string otherwise. + + @param ea: linear address + @param str: comment string to append + @param rptble: append to repeatable comment? + @returns success -ida_bytes.attach_custom_data_format (function) - attach_custom_data_format(dtid, dfid) -> bool - Attach the data format to the data type. - - @param dtid: (C++: int) data type id that can use the data format. 0 means all standard - data types. Such data formats can be applied to any data item or - instruction operands. For instruction operands, the - data_format_t::value_size check is not performed by the kernel. - @param dfid: (C++: int) data format id +ida_bytes.attach_custom_data_format(dtid: int, dfid: int) -> bool + Attach the data format to the data type. + + @param dtid: data type id that can use the data format. 0 means all standard data types. Such data formats can be applied to any data item or instruction operands. For instruction operands, the data_format_t::value_size check is not performed by the kernel. + @param dfid: data format id @retval true: ok - @retval false: no such `dtid', or no such `dfid', or the data format has already - been attached to the data type + @retval false: no such `dtid`, or no such `dfid', or the data format has already been attached to the data type -ida_bytes.bin_flag (function) - bin_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() +ida_bytes.bin_flag() -> "flags64_t" + Get number flag of the base, regardless of current processor - better to use num_flag() -ida_bytes.bin_search (function) - bin_search(start_ea, end_ea, data, flags) -> ea_t +ida_bytes.bin_search(*args) Search for a set of bytes in the program + This function has the following signatures: + + 1. bin_search(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, data: compiled_binpat_vec_t, flags: int) -> Tuple[ida_idaapi.ea_t, int] + 2. bin_search(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, image: bytes, mask: bytes, len: int, flags: int) -> ida_idaapi.ea_t + + The return value type will differ depending on the form: + + 1. a tuple `(matched-address, index-in-compiled_binpat_vec_t)` (1st form) + 2. the address of a match, or ida_idaapi.BADADDR if not found (2nd form) + + This is a low-level function; more user-friendly alternatives + are available. Please see 'find_bytes' and 'find_string'. + @param start_ea: linear address, start of range to search @param end_ea: linear address, end of range to search (exclusive) - @param data: the prepared data to search for (see parse_binpat_str()) + @param data: (1st form) the prepared data to search for (see parse_binpat_str()) + @param bytes: (2nd form) a set of bytes to match + @param mask: (2nd form) a mask to apply to the set of bytes @param flags: combination of BIN_SEARCH_* flags - @return: the address of a match, or ida_idaapi.BADADDR if not found - bin_search(start_ea, end_ea, image, imask, step, flags) -> ea_t - - @param start_ea: ea_t - @param end_ea: ea_t - @param image: bytevec_t const & - @param imask: bytevec_t const & - @param step: int - @param flags: int + @return: either a tuple holding both the address of the match and the index of the compiled pattern that matched, or the address of a match (ida_idaapi.BADADDR if not found) -ida_bytes.bin_search3 (function) - bin_search3(start_ea, end_ea, data, flags) -> ea_t - Search for a patter in the program. - - @param start_ea: (C++: ea_t) linear address, start of range to search - @param end_ea: (C++: ea_t) linear address, end of range to search (exclusive) - @param data: (C++: const compiled_binpat_vec_t &) the prepared data to search for (see parse_binpat_str()) - @param flags: (C++: int) combination of Search flags - @return: BADADDR (if pressed Ctrl-Break or not found) or pattern address. - -ida_bytes.byte_flag (function) - byte_flag() -> flags64_t +ida_bytes.byte_flag() -> "flags64_t" Get a flags64_t representing a byte. -ida_bytes.bytesize (function) - bytesize(ea) -> int +ida_bytes.bytesize(ea: ida_idaapi.ea_t) -> int Get number of bytes required to store a byte at the given address. - - @param ea: (C++: ea_t) -ida_bytes.calc_def_align (function) - calc_def_align(ea, mina, maxa) -> int - Calculate the default alignment exponent. - - @param ea: (C++: ea_t) linear address - @param mina: (C++: int) minimal possible alignment exponent. - @param maxa: (C++: int) minimal possible alignment exponent. +ida_bytes.calc_def_align(ea: ida_idaapi.ea_t, mina: int, maxa: int) -> int + Calculate the default alignment exponent. + + @param ea: linear address + @param mina: minimal possible alignment exponent. + @param maxa: minimal possible alignment exponent. -ida_bytes.calc_dflags (function) - calc_dflags(f, force) -> flags64_t - - @param f: flags64_t - @param force: bool +ida_bytes.calc_dflags(f: "flags64_t", force: bool) -> "flags64_t" -ida_bytes.calc_max_align (function) - calc_max_align(endea) -> int - Calculate the maximal possible alignment exponent. - - @param endea: (C++: ea_t) end address of the alignment item. - @return: a value in the 0..32 range +ida_bytes.calc_max_align(endea: ida_idaapi.ea_t) -> int + Calculate the maximal possible alignment exponent. + + @param endea: end address of the alignment item. + @returns a value in the 0..32 range -ida_bytes.calc_max_item_end (function) - calc_max_item_end(ea, how=15) -> ea_t - Calculate maximal reasonable end address of a new item. This function will limit - the item with the current segment bounds. - - @param ea: (C++: ea_t) linear address - @param how: (C++: int) when to stop the search. A combination of Item end search flags - @return: end of new item. If it is not possible to create an item, it will - return 'ea'. If operation was cancelled by user, it will return 'ea' +ida_bytes.calc_max_item_end(ea: ida_idaapi.ea_t, how: int = 15) -> ida_idaapi.ea_t + Calculate maximal reasonable end address of a new item. This function will limit the item with the current segment bounds. + + @param ea: linear address + @param how: when to stop the search. A combination of Item end search flags + @returns end of new item. If it is not possible to create an item, it will return 'ea'. If operation was cancelled by user, it will return 'ea' -ida_bytes.calc_min_align (function) - calc_min_align(length) -> int - Calculate the minimal possible alignment exponent. - - @param length: (C++: asize_t) size of the item in bytes. - @return: a value in the 1..32 range +ida_bytes.calc_min_align(length: "asize_t") -> int + Calculate the minimal possible alignment exponent. + + @param length: size of the item in bytes. + @returns a value in the 1..32 range -ida_bytes.can_define_item (function) - can_define_item(ea, length, flags) -> bool - Can define item (instruction/data) of the specified 'length', starting at 'ea'? - @note: if there is an item starting at 'ea', this function ignores it - @note: this function converts to unexplored all encountered data items with - fixup information. Should be fixed in the future. +ida_bytes.can_define_item(ea: ida_idaapi.ea_t, length: "asize_t", flags: "flags64_t") -> bool + Can define item (instruction/data) of the specified 'length', starting at 'ea'? + * a new item would cross segment boundaries + * a new item would overlap with existing items (except items specified by 'flags') - @param ea: (C++: ea_t) start of the range for the new item - @param length: (C++: asize_t) length of the new item in bytes - @param flags: (C++: flags64_t) if not 0, then the kernel will ignore the data types specified by - the flags and destroy them. For example: - 1000 dw 5 + + + @param ea: start of the range for the new item + @param length: length of the new item in bytes + @param flags: if not 0, then the kernel will ignore the data types specified by the flags and destroy them. For example: + 1000 dw 5 1002 db 5 ; undef 1003 db 5 ; undef 1004 dw 5 1006 dd 5 - can_define_item(1000, 6, 0) - false because of dw at 1004 - can_define_item(1000, 6, word_flag()) - true, word at 1004 is destroyed - @return: 1-yes, 0-no - * a new item would cross segment boundaries - * a new item would overlap with existing items (except items specified by - 'flags') + can_define_item(1000, 6, 0) - false because of dw at 1004 + can_define_item(1000, 6, word_flag()) - true, word at 1004 is destroyed + @returns 1-yes, 0-no -ida_bytes.change_storage_type (function) - change_storage_type(start_ea, end_ea, stt) -> error_t - Change flag storage type for address range. - - @param start_ea: (C++: ea_t) should be lower than end_ea. - @param end_ea: (C++: ea_t) does not belong to the range. - @param stt: (C++: storage_type_t) - @return: error code +ida_bytes.change_storage_type(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, stt: "storage_type_t") -> "error_t" + Change flag storage type for address range. + + @param start_ea: should be lower than end_ea. + @param end_ea: does not belong to the range. + @param stt: storage_type_t + @returns error code -ida_bytes.char_flag (function) - char_flag() -> flags64_t +ida_bytes.char_flag() -> "flags64_t" see FF_opbits -ida_bytes.chunk_size (function) - chunk_size(ea) -> asize_t - Get size of the contiguous address block containing 'ea'. - - @param ea: (C++: ea_t) - @return: 0 if 'ea' doesn't belong to the program. +ida_bytes.chunk_size(ea: ida_idaapi.ea_t) -> "asize_t" + Get size of the contiguous address block containing 'ea'. + + @returns 0 if 'ea' doesn't belong to the program. -ida_bytes.chunk_start (function) - chunk_start(ea) -> ea_t - Get start of the contiguous address block containing 'ea'. - - @param ea: (C++: ea_t) - @return: BADADDR if 'ea' doesn't belong to the program. +ida_bytes.chunk_start(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get start of the contiguous address block containing 'ea'. + + @returns BADADDR if 'ea' doesn't belong to the program. -ida_bytes.clr_lzero (function) - clr_lzero(ea, n) -> bool - Clear toggle lzero bit. This function reset the display of leading zeroes for - the specified operand to the default. If the default is not to display leading - zeroes, leading zeroes will not be displayed, as vice versa. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success +ida_bytes.clr_lzero(ea: ida_idaapi.ea_t, n: int) -> bool + Clear toggle lzero bit. This function reset the display of leading zeroes for the specified operand to the default. If the default is not to display leading zeroes, leading zeroes will not be displayed, as vice versa. + + @param ea: the item (insn/data) address + @param n: the operand number (0-first operand, 1-other operands) + @returns success -ida_bytes.clr_op_type (function) - clr_op_type(ea, n) -> bool - Remove operand representation information. (set operand representation to be - 'undefined') - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @return: success +ida_bytes.clr_op_type(ea: ida_idaapi.ea_t, n: int) -> bool + Remove operand representation information. (set operand representation to be 'undefined') + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands + @returns success -ida_bytes.code_flag (function) - code_flag() -> flags64_t +ida_bytes.code_flag() -> "flags64_t" FF_CODE -ida_bytes.combine_flags (function) - combine_flags(F) -> flags64_t - - @param F: flags64_t +ida_bytes.combine_flags(F: "flags64_t") -> "flags64_t" -ida_bytes.compiled_binpat_t (class) - Proxy of C++ compiled_binpat_t class. +ida_bytes.compiled_binpat_t -ida_bytes.compiled_binpat_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: compiled_binpat_t const & +ida_bytes.compiled_binpat_t.__eq__(self, r: "compiled_binpat_t") -> bool -ida_bytes.compiled_binpat_t.__init__ (method) - __init__(self) -> compiled_binpat_t +ida_bytes.compiled_binpat_t.__init__(self) -ida_bytes.compiled_binpat_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: compiled_binpat_t const & +ida_bytes.compiled_binpat_t.__ne__(self, r: "compiled_binpat_t") -> bool -ida_bytes.compiled_binpat_t.all_bytes_defined (method) - all_bytes_defined(self) -> bool +ida_bytes.compiled_binpat_t.all_bytes_defined(self) -> bool -ida_bytes.compiled_binpat_t.qclear (method) - qclear(self) +ida_bytes.compiled_binpat_t.qclear(self) -> None -ida_bytes.compiled_binpat_vec_t (class) - Proxy of C++ qvector< compiled_binpat_t > class. +ida_bytes.compiled_binpat_vec_t -ida_bytes.compiled_binpat_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< compiled_binpat_t > const & +ida_bytes.compiled_binpat_vec_t.__eq__(self, r: "compiled_binpat_vec_t") -> bool -ida_bytes.compiled_binpat_vec_t.__getitem__ (method) - __getitem__(self, i) -> compiled_binpat_t - - @param i: size_t +ida_bytes.compiled_binpat_vec_t.__getitem__(self, i: "size_t") -> "compiled_binpat_t const &" -ida_bytes.compiled_binpat_vec_t.__init__ (method) - __init__(self) -> compiled_binpat_vec_t - __init__(self, x) -> compiled_binpat_vec_t - - @param x: qvector< compiled_binpat_t > const & +ida_bytes.compiled_binpat_vec_t.__init__(self, *args) -ida_bytes.compiled_binpat_vec_t.__len__ (method) - __len__(self) -> size_t +ida_bytes.compiled_binpat_vec_t.__len__(self) -> "size_t" -ida_bytes.compiled_binpat_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< compiled_binpat_t > const & +ida_bytes.compiled_binpat_vec_t.__ne__(self, r: "compiled_binpat_vec_t") -> bool -ida_bytes.compiled_binpat_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: compiled_binpat_t const & +ida_bytes.compiled_binpat_vec_t.__setitem__(self, i: "size_t", v: "compiled_binpat_t") -> None -ida_bytes.compiled_binpat_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: compiled_binpat_t const & +ida_bytes.compiled_binpat_vec_t._del(self, x: "compiled_binpat_t") -> bool -ida_bytes.compiled_binpat_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: compiled_binpat_t const & +ida_bytes.compiled_binpat_vec_t.add_unique(self, x: "compiled_binpat_t") -> bool -ida_bytes.compiled_binpat_vec_t.at (method) - at(self, _idx) -> compiled_binpat_t - - @param _idx: size_t +ida_bytes.compiled_binpat_vec_t.append(self, x: "compiled_binpat_t") -> None -ida_bytes.compiled_binpat_vec_t.begin (method) - begin(self) -> compiled_binpat_t +ida_bytes.compiled_binpat_vec_t.at(self, _idx: "size_t") -> "compiled_binpat_t const &" -ida_bytes.compiled_binpat_vec_t.capacity (method) - capacity(self) -> size_t +ida_bytes.compiled_binpat_vec_t.begin(self, *args) -> "qvector< compiled_binpat_t >::const_iterator" -ida_bytes.compiled_binpat_vec_t.clear (method) - clear(self) +ida_bytes.compiled_binpat_vec_t.capacity(self) -> "size_t" -ida_bytes.compiled_binpat_vec_t.empty (method) - empty(self) -> bool +ida_bytes.compiled_binpat_vec_t.clear(self) -> None -ida_bytes.compiled_binpat_vec_t.end (method) - end(self) -> compiled_binpat_t +ida_bytes.compiled_binpat_vec_t.empty(self) -> bool -ida_bytes.compiled_binpat_vec_t.erase (method) - erase(self, it) -> compiled_binpat_t - - @param it: qvector< compiled_binpat_t >::iterator - - erase(self, first, last) -> compiled_binpat_t - - @param first: qvector< compiled_binpat_t >::iterator - @param last: qvector< compiled_binpat_t >::iterator +ida_bytes.compiled_binpat_vec_t.end(self, *args) -> "qvector< compiled_binpat_t >::const_iterator" -ida_bytes.compiled_binpat_vec_t.extract (method) - extract(self) -> compiled_binpat_t +ida_bytes.compiled_binpat_vec_t.erase(self, *args) -> "qvector< compiled_binpat_t >::iterator" -ida_bytes.compiled_binpat_vec_t.find (method) - find(self, x) -> compiled_binpat_t - - @param x: compiled_binpat_t const & +ida_bytes.compiled_binpat_vec_t.extend(self, x: "compiled_binpat_vec_t") -> None -ida_bytes.compiled_binpat_vec_t.grow (method) - grow(self, x=compiled_binpat_t()) - - @param x: compiled_binpat_t const & +ida_bytes.compiled_binpat_vec_t.extract(self) -> "compiled_binpat_t *" -ida_bytes.compiled_binpat_vec_t.has (method) - has(self, x) -> bool - - @param x: compiled_binpat_t const & +ida_bytes.compiled_binpat_vec_t.find(self, *args) -> "qvector< compiled_binpat_t >::const_iterator" -ida_bytes.compiled_binpat_vec_t.inject (method) - inject(self, s, len) - - @param s: compiled_binpat_t * - @param len: size_t +ida_bytes.compiled_binpat_vec_t.grow(self, *args) -> None -ida_bytes.compiled_binpat_vec_t.insert (method) - insert(self, it, x) -> compiled_binpat_t - - @param it: qvector< compiled_binpat_t >::iterator - @param x: compiled_binpat_t const & +ida_bytes.compiled_binpat_vec_t.has(self, x: "compiled_binpat_t") -> bool -ida_bytes.compiled_binpat_vec_t.pop_back (method) - pop_back(self) +ida_bytes.compiled_binpat_vec_t.inject(self, s: "compiled_binpat_t", len: "size_t") -> None -ida_bytes.compiled_binpat_vec_t.push_back (method) - push_back(self, x) - - @param x: compiled_binpat_t const & - - push_back(self) -> compiled_binpat_t +ida_bytes.compiled_binpat_vec_t.insert(self, it: "compiled_binpat_t", x: "compiled_binpat_t") -> "qvector< compiled_binpat_t >::iterator" -ida_bytes.compiled_binpat_vec_t.qclear (method) - qclear(self) +ida_bytes.compiled_binpat_vec_t.pop_back(self) -> None -ida_bytes.compiled_binpat_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_bytes.compiled_binpat_vec_t.push_back(self, *args) -> "compiled_binpat_t &" -ida_bytes.compiled_binpat_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: compiled_binpat_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_bytes.compiled_binpat_vec_t.qclear(self) -> None -ida_bytes.compiled_binpat_vec_t.size (method) - size(self) -> size_t +ida_bytes.compiled_binpat_vec_t.reserve(self, cnt: "size_t") -> None -ida_bytes.compiled_binpat_vec_t.swap (method) - swap(self, r) - - @param r: qvector< compiled_binpat_t > & +ida_bytes.compiled_binpat_vec_t.resize(self, *args) -> None -ida_bytes.compiled_binpat_vec_t.truncate (method) - truncate(self) +ida_bytes.compiled_binpat_vec_t.size(self) -> "size_t" -ida_bytes.create_16bit_data (function) - create_16bit_data(ea, length) -> bool +ida_bytes.compiled_binpat_vec_t.swap(self, r: "compiled_binpat_vec_t") -> None + +ida_bytes.compiled_binpat_vec_t.truncate(self) -> None + +ida_bytes.create_16bit_data(ea: ida_idaapi.ea_t, length: "asize_t") -> bool Convert to 16-bit quantity (take the byte size into account) - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) -ida_bytes.create_32bit_data (function) - create_32bit_data(ea, length) -> bool +ida_bytes.create_32bit_data(ea: ida_idaapi.ea_t, length: "asize_t") -> bool Convert to 32-bit quantity (take the byte size into account) - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) -ida_bytes.create_align (function) - create_align(ea, length, alignment) -> bool - Create an alignment item. - - @param ea: (C++: ea_t) linear address - @param length: (C++: asize_t) size of the item in bytes. 0 means to infer from ALIGNMENT - @param alignment: (C++: int) alignment exponent. Example: 3 means align to 8 bytes. 0 means - to infer from LENGTH It is forbidden to specify both LENGTH - and ALIGNMENT as 0. - @return: success +ida_bytes.create_align(ea: ida_idaapi.ea_t, length: "asize_t", alignment: int) -> bool + Create an alignment item. + + @param ea: linear address + @param length: size of the item in bytes. 0 means to infer from ALIGNMENT + @param alignment: alignment exponent. Example: 3 means align to 8 bytes. 0 means to infer from LENGTH It is forbidden to specify both LENGTH and ALIGNMENT as 0. + @returns success -ida_bytes.create_byte (function) - create_byte(ea, length, force=False) -> bool +ida_bytes.create_byte(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to byte. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_custdata (function) - create_custdata(ea, length, dtid, fid, force=False) -> bool +ida_bytes.create_custdata(ea: ida_idaapi.ea_t, length: "asize_t", dtid: int, fid: int, force: bool = False) -> bool Convert to custom data type. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param dtid: (C++: int) - @param fid: (C++: int) - @param force: (C++: bool) -ida_bytes.create_data (function) - create_data(ea, dataflag, size, tid) -> bool - Convert to data (byte, word, dword, etc). This function may be used to create - arrays. - - @param ea: (C++: ea_t) linear address - @param dataflag: (C++: flags64_t) type of data. Value of function byte_flag(), word_flag(), etc. - @param size: (C++: asize_t) size of array in bytes. should be divisible by the size of one item - of the specified type. for variable sized items it can be specified - as 0, and the kernel will try to calculate the size. - @param tid: (C++: tid_t) type id. If the specified type is a structure, then tid is structure - id. Otherwise should be BADNODE. - @return: success +ida_bytes.create_data(ea: ida_idaapi.ea_t, dataflag: "flags64_t", size: "asize_t", tid: "tid_t") -> bool + Convert to data (byte, word, dword, etc). This function may be used to create arrays. + + @param ea: linear address + @param dataflag: type of data. Value of function byte_flag(), word_flag(), etc. + @param size: size of array in bytes. should be divisible by the size of one item of the specified type. for variable sized items it can be specified as 0, and the kernel will try to calculate the size. + @param tid: type id. If the specified type is a structure, then tid is structure id. Otherwise should be BADNODE. + @returns success -ida_bytes.create_double (function) - create_double(ea, length, force=False) -> bool +ida_bytes.create_double(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to double. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_dword (function) - create_dword(ea, length, force=False) -> bool +ida_bytes.create_dword(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to dword. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_float (function) - create_float(ea, length, force=False) -> bool +ida_bytes.create_float(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to float. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_oword (function) - create_oword(ea, length, force=False) -> bool +ida_bytes.create_oword(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to octaword/xmm word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_packed_real (function) - create_packed_real(ea, length, force=False) -> bool +ida_bytes.create_packed_real(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to packed decimal real. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_qword (function) - create_qword(ea, length, force=False) -> bool +ida_bytes.create_qword(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to quadword. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_strlit (function) - create_strlit(start, len, strtype) -> bool - Convert to string literal and give a meaningful name. 'start' may be higher than - 'end', the kernel will swap them in this case - - @param start: (C++: ea_t) starting address - @param len: (C++: size_t) length of the string in bytes. if 0, then get_max_strlit_length() - will be used to determine the length - @param strtype: (C++: int32) string type. one of String type codes - @return: success +ida_bytes.create_strlit(start: ida_idaapi.ea_t, len: "size_t", strtype: int) -> bool + Convert to string literal and give a meaningful name. 'start' may be higher than 'end', the kernel will swap them in this case + + @param start: starting address + @param len: length of the string in bytes. if 0, then get_max_strlit_length() will be used to determine the length + @param strtype: string type. one of String type codes + @returns success -ida_bytes.create_struct (function) - create_struct(ea, length, tid, force=False) -> bool +ida_bytes.create_struct(ea: ida_idaapi.ea_t, length: "asize_t", tid: "tid_t", force: bool = False) -> bool Convert to struct. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param tid: (C++: tid_t) - @param force: (C++: bool) -ida_bytes.create_tbyte (function) - create_tbyte(ea, length, force=False) -> bool +ida_bytes.create_tbyte(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to tbyte. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_word (function) - create_word(ea, length, force=False) -> bool +ida_bytes.create_word(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_yword (function) - create_yword(ea, length, force=False) -> bool +ida_bytes.create_yword(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to ymm word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.create_zword (function) - create_zword(ea, length, force=False) -> bool +ida_bytes.create_zword(ea: ida_idaapi.ea_t, length: "asize_t", force: bool = False) -> bool Convert to zmm word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) -ida_bytes.cust_flag (function) - cust_flag() -> flags64_t +ida_bytes.cust_flag() -> "flags64_t" Get a flags64_t representing custom type data. -ida_bytes.custfmt_flag (function) - custfmt_flag() -> flags64_t +ida_bytes.custfmt_flag() -> "flags64_t" see FF_opbits -ida_bytes.data_format_t (class) - Proxy of C++ data_format_t class. +ida_bytes.data_format_t + Information about a data format -ida_bytes.data_format_t.__get_id (method) - __get_id(self) -> int +ida_bytes.data_format_t.__get_id(self) -> int -ida_bytes.data_format_t.__init__ (method) - __init__(self, _self, name, value_size=0, menu_name=None, props=0, hotkey=None, text_width=0) -> data_format_t - - @param self: PyObject * - @param name: char const * - @param value_size: asize_t - @param menu_name: char const * - @param props: int - @param hotkey: char const * - @param text_width: int32 +ida_bytes.data_format_t.__init__(self, _self: "PyObject *", name: str, value_size: "asize_t" = 0, menu_name: str = None, props: int = 0, hotkey: str = None, text_width: int = 0) -ida_bytes.data_format_t.__init__ (method) +ida_bytes.data_format_t.__init__(self, *args) -ida_bytes.data_format_t.hotkey (variable) - Hotkey for the corresponding menu item if nullptr, no hotkey will be associated - with the menu item +ida_bytes.data_format_t.hotkey + Hotkey for the corresponding menu item if nullptr, no hotkey will be associated with the menu item + -ida_bytes.data_format_t.is_present_in_menus (method) - is_present_in_menus(self) -> bool - Should this format be shown in UI menus - - @return: success +ida_bytes.data_format_t.is_present_in_menus(self) -> bool + Should this format be shown in UI menus + + @returns success -ida_bytes.data_format_t.menu_name (variable) - Visible format name to use in menus if nullptr, no menu item will be created +ida_bytes.data_format_t.menu_name + Visible format name to use in menus if nullptr, no menu item will be created + -ida_bytes.data_format_t.name (variable) +ida_bytes.data_format_t.name Format name, must be unique. -ida_bytes.data_format_t.props (variable) +ida_bytes.data_format_t.props properties (currently 0) -ida_bytes.data_format_t.text_width (variable) - Usual width of the text representation This value is used to calculate the width - of the control to display values of this type +ida_bytes.data_format_t.text_width + Usual width of the text representation This value is used to calculate the width of the control to display values of this type + -ida_bytes.data_format_t.value_size (variable) - size of the value in bytes 0 means any size is ok data formats that are - registered for standard types (dtid 0) may be called with any value_size - (instruction operands only) +ida_bytes.data_format_t.value_size + size of the value in bytes 0 means any size is ok data formats that are registered for standard types (dtid 0) may be called with any value_size (instruction operands only) + -ida_bytes.data_type_t (class) - Proxy of C++ data_type_t class. +ida_bytes.data_type_t + Information about a data type -ida_bytes.data_type_t.__get_id (method) - __get_id(self) -> int +ida_bytes.data_type_t.__get_id(self) -> int -ida_bytes.data_type_t.__init__ (method) - __init__(self, _self, name, value_size=0, menu_name=None, hotkey=None, asm_keyword=None, props=0) -> data_type_t - - @param self: PyObject * - @param name: char const * - @param value_size: asize_t - @param menu_name: char const * - @param hotkey: char const * - @param asm_keyword: char const * - @param props: int +ida_bytes.data_type_t.__init__(self, _self: "PyObject *", name: str, value_size: "asize_t" = 0, menu_name: str = None, hotkey: str = None, asm_keyword: str = None, props: int = 0) -ida_bytes.data_type_t.__init__ (method) +ida_bytes.data_type_t.__init__(self, *args) -ida_bytes.data_type_t.asm_keyword (variable) - keyword to use for this type in the assembly if nullptr, the data type cannot be - used in the listing it can still be used in cpuregs window +ida_bytes.data_type_t.asm_keyword + keyword to use for this type in the assembly if nullptr, the data type cannot be used in the listing it can still be used in cpuregs window + -ida_bytes.data_type_t.hotkey (variable) - Hotkey for the corresponding menu item if nullptr, no hotkey will be associated - with the menu item +ida_bytes.data_type_t.hotkey + Hotkey for the corresponding menu item if nullptr, no hotkey will be associated with the menu item + -ida_bytes.data_type_t.is_present_in_menus (method) - is_present_in_menus(self) -> bool - Should this type be shown in UI menus - - @return: success +ida_bytes.data_type_t.is_present_in_menus(self) -> bool + Should this type be shown in UI menus + + @returns success -ida_bytes.data_type_t.menu_name (variable) - Visible data type name to use in menus if nullptr, no menu item will be created +ida_bytes.data_type_t.menu_name + Visible data type name to use in menus if nullptr, no menu item will be created + -ida_bytes.data_type_t.name (variable) +ida_bytes.data_type_t.name name of the data type. must be unique -ida_bytes.data_type_t.props (variable) +ida_bytes.data_type_t.props properties -ida_bytes.data_type_t.value_size (variable) +ida_bytes.data_type_t.value_size size of the value in bytes -ida_bytes.dec_flag (function) - dec_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() +ida_bytes.dec_flag() -> "flags64_t" + Get number flag of the base, regardless of current processor - better to use num_flag() -ida_bytes.del_hidden_range (function) - del_hidden_range(ea) -> bool - Delete hidden range. - - @param ea: (C++: ea_t) any address in the hidden range - @return: success +ida_bytes.del_hidden_range(ea: ida_idaapi.ea_t) -> bool + Delete hidden range. + + @param ea: any address in the hidden range + @returns success -ida_bytes.del_items (function) - del_items(ea, flags=0, nbytes=1, may_destroy=None) -> bool - Convert item (instruction/data) to unexplored bytes. The whole item (including - the head and tail bytes) will be destroyed. It is allowed to pass any address in - the item to this function - - @param ea: (C++: ea_t) any address within the first item to delete - @param flags: (C++: int) combination of Unexplored byte conversion flags - @param nbytes: (C++: asize_t) number of bytes in the range to be undefined - @param may_destroy: (C++: may_destroy_cb_t *) optional routine invoked before deleting a head item. If - callback returns false then item is not to be deleted and - operation fails - @return: true on sucessful operation, otherwise false +ida_bytes.del_items(ea: ida_idaapi.ea_t, flags: int = 0, nbytes: "asize_t" = 1, may_destroy: "may_destroy_cb_t *" = None) -> bool + Convert item (instruction/data) to unexplored bytes. The whole item (including the head and tail bytes) will be destroyed. It is allowed to pass any address in the item to this function + + @param ea: any address within the first item to delete + @param flags: combination of Unexplored byte conversion flags + @param nbytes: number of bytes in the range to be undefined + @param may_destroy: optional routine invoked before deleting a head item. If callback returns false then item is not to be deleted and operation fails + @returns true on sucessful operation, otherwise false -ida_bytes.del_mapping (function) - del_mapping(ea) - Delete memory mapping range. - - @param ea: (C++: ea_t) any address in the mapped range +ida_bytes.del_mapping(ea: ida_idaapi.ea_t) -> None + Delete memory mapping range. + + @param ea: any address in the mapped range -ida_bytes.del_value (function) - del_value(ea) - Delete byte value from flags. The corresponding byte becomes uninitialized. - - @param ea: (C++: ea_t) +ida_bytes.del_value(ea: ida_idaapi.ea_t) -> None + Delete byte value from flags. The corresponding byte becomes uninitialized. + -ida_bytes.detach_custom_data_format (function) - detach_custom_data_format(dtid, dfid) -> bool - Detach the data format from the data type. Unregistering a custom data type - detaches all attached data formats, no need to detach them explicitly. You still - need unregister them. Unregistering a custom data format detaches it from all - attached data types. - - @param dtid: (C++: int) data type id to detach data format from - @param dfid: (C++: int) data format id to detach +ida_bytes.detach_custom_data_format(dtid: int, dfid: int) -> bool + Detach the data format from the data type. Unregistering a custom data type detaches all attached data formats, no need to detach them explicitly. You still need unregister them. Unregistering a custom data format detaches it from all attached data types. + + @param dtid: data type id to detach data format from + @param dfid: data format id to detach @retval true: ok - @retval false: no such `dtid', or no such `dfid', or the data format was not - attached to the data type + @retval false: no such `dtid`, or no such `dfid', or the data format was not attached to the data type -ida_bytes.disable_flags (function) - disable_flags(start_ea, end_ea) -> error_t - Deallocate flags for address range. Exit with an error message if not enough - disk space (this may occur too). - - @param start_ea: (C++: ea_t) should be lower than end_ea. - @param end_ea: (C++: ea_t) does not belong to the range. - @return: 0 if ok, otherwise return error code +ida_bytes.disable_flags(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t) -> "error_t" + Deallocate flags for address range. Exit with an error message if not enough disk space (this may occur too). + + @param start_ea: should be lower than end_ea. + @param end_ea: does not belong to the range. + @returns 0 if ok, otherwise return error code -ida_bytes.double_flag (function) - double_flag() -> flags64_t +ida_bytes.double_flag() -> "flags64_t" Get a flags64_t representing a double. -ida_bytes.dword_flag (function) - dword_flag() -> flags64_t +ida_bytes.dword_flag() -> "flags64_t" Get a flags64_t representing a double word. -ida_bytes.enable_flags (function) - enable_flags(start_ea, end_ea, stt) -> error_t - Allocate flags for address range. This function does not change the storage type - of existing ranges. Exit with an error message if not enough disk space. - - @param start_ea: (C++: ea_t) should be lower than end_ea. - @param end_ea: (C++: ea_t) does not belong to the range. - @param stt: (C++: storage_type_t) - @return: 0 if ok, otherwise an error code +ida_bytes.enable_flags(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, stt: "storage_type_t") -> "error_t" + Allocate flags for address range. This function does not change the storage type of existing ranges. Exit with an error message if not enough disk space. + + @param start_ea: should be lower than end_ea. + @param end_ea: does not belong to the range. + @param stt: storage_type_t + @returns 0 if ok, otherwise an error code -ida_bytes.enum_flag (function) - enum_flag() -> flags64_t +ida_bytes.enum_flag() -> "flags64_t" see FF_opbits -ida_bytes.equal_bytes (function) - equal_bytes(ea, image, mask, len, bin_search_flags) -> bool - Compare 'len' bytes of the program starting from 'ea' with 'image'. - - @param ea: (C++: ea_t) linear address - @param image: (C++: const uchar *) bytes to compare with - @param mask: (C++: const uchar *) array of mask bytes, it's length is 'len'. if the flag - BIN_SEARCH_BITMASK is passsed, 'bitwise AND' is used to compare. if - not; 1 means to perform the comparison of the corresponding byte. 0 - means not to perform. if mask == nullptr, then all bytes of 'image' - will be compared. if mask == SKIP_FF_MASK then 0xFF bytes will be - skipped - @param len: (C++: size_t) length of block to compare in bytes. - @param bin_search_flags: (C++: int) combination of Search flags +ida_bytes.equal_bytes(ea: ida_idaapi.ea_t, image: "uchar const *", mask: "uchar const *", len: "size_t", bin_search_flags: int) -> bool + Compare 'len' bytes of the program starting from 'ea' with 'image'. + + @param ea: linear address + @param image: bytes to compare with + @param mask: array of mask bytes, it's length is 'len'. if the flag BIN_SEARCH_BITMASK is passsed, 'bitwise AND' is used to compare. if not; 1 means to perform the comparison of the corresponding byte. 0 means not to perform. if mask == nullptr, then all bytes of 'image' will be compared. if mask == SKIP_FF_MASK then 0xFF bytes will be skipped + @param len: length of block to compare in bytes. + @param bin_search_flags: combination of Search flags @retval 1: equal @retval 0: not equal -ida_bytes.f_has_cmt (function) - f_has_cmt(f, arg2) -> bool - - @param f: flags64_t - @param arg2: void * +ida_bytes.f_has_cmt(f: "flags64_t", arg2: "void *") -> bool -ida_bytes.f_has_dummy_name (function) - f_has_dummy_name(f, arg2) -> bool +ida_bytes.f_has_dummy_name(f: "flags64_t", arg2: "void *") -> bool Does the current byte have dummy (auto-generated, with special prefix) name? - - @param f: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_has_extra_cmts (function) - f_has_extra_cmts(f, arg2) -> bool - - @param f: flags64_t - @param arg2: void * +ida_bytes.f_has_extra_cmts(f: "flags64_t", arg2: "void *") -> bool -ida_bytes.f_has_name (function) - f_has_name(f, arg2) -> bool +ida_bytes.f_has_name(f: "flags64_t", arg2: "void *") -> bool Does the current byte have non-trivial (non-dummy) name? - - @param f: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_has_user_name (function) - f_has_user_name(F, arg2) -> bool +ida_bytes.f_has_user_name(F: "flags64_t", arg2: "void *") -> bool Does the current byte have user-specified name? - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_has_xref (function) - f_has_xref(f, arg2) -> bool +ida_bytes.f_has_xref(f: "flags64_t", arg2: "void *") -> bool Does the current byte have cross-references to it? - - @param f: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_align (function) - f_is_align(F, arg2) -> bool +ida_bytes.f_is_align(F: "flags64_t", arg2: "void *") -> bool See is_align() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_byte (function) - f_is_byte(F, arg2) -> bool +ida_bytes.f_is_byte(F: "flags64_t", arg2: "void *") -> bool See is_byte() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_code (function) - f_is_code(F, arg2) -> bool +ida_bytes.f_is_code(F: "flags64_t", arg2: "void *") -> bool Does flag denote start of an instruction? - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_custom (function) - f_is_custom(F, arg2) -> bool +ida_bytes.f_is_custom(F: "flags64_t", arg2: "void *") -> bool See is_custom() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_data (function) - f_is_data(F, arg2) -> bool +ida_bytes.f_is_data(F: "flags64_t", arg2: "void *") -> bool Does flag denote start of data? - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_double (function) - f_is_double(F, arg2) -> bool +ida_bytes.f_is_double(F: "flags64_t", arg2: "void *") -> bool See is_double() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_dword (function) - f_is_dword(F, arg2) -> bool +ida_bytes.f_is_dword(F: "flags64_t", arg2: "void *") -> bool See is_dword() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_float (function) - f_is_float(F, arg2) -> bool +ida_bytes.f_is_float(F: "flags64_t", arg2: "void *") -> bool See is_float() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_head (function) - f_is_head(F, arg2) -> bool +ida_bytes.f_is_head(F: "flags64_t", arg2: "void *") -> bool Does flag denote start of instruction OR data? - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_not_tail (function) - f_is_not_tail(F, arg2) -> bool +ida_bytes.f_is_not_tail(F: "flags64_t", arg2: "void *") -> bool Does flag denote tail byte? - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_oword (function) - f_is_oword(F, arg2) -> bool +ida_bytes.f_is_oword(F: "flags64_t", arg2: "void *") -> bool See is_oword() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_pack_real (function) - f_is_pack_real(F, arg2) -> bool +ida_bytes.f_is_pack_real(F: "flags64_t", arg2: "void *") -> bool See is_pack_real() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_qword (function) - f_is_qword(F, arg2) -> bool +ida_bytes.f_is_qword(F: "flags64_t", arg2: "void *") -> bool See is_qword() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_strlit (function) - f_is_strlit(F, arg2) -> bool +ida_bytes.f_is_strlit(F: "flags64_t", arg2: "void *") -> bool See is_strlit() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_struct (function) - f_is_struct(F, arg2) -> bool +ida_bytes.f_is_struct(F: "flags64_t", arg2: "void *") -> bool See is_struct() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_tail (function) - f_is_tail(F, arg2) -> bool +ida_bytes.f_is_tail(F: "flags64_t", arg2: "void *") -> bool Does flag denote tail byte? - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_tbyte (function) - f_is_tbyte(F, arg2) -> bool +ida_bytes.f_is_tbyte(F: "flags64_t", arg2: "void *") -> bool See is_tbyte() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_word (function) - f_is_word(F, arg2) -> bool +ida_bytes.f_is_word(F: "flags64_t", arg2: "void *") -> bool See is_word() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.f_is_yword (function) - f_is_yword(F, arg2) -> bool +ida_bytes.f_is_yword(F: "flags64_t", arg2: "void *") -> bool See is_yword() - - @param F: (C++: flags64_t) - @param arg2: void * -ida_bytes.find_byte (function) - find_byte(sEA, size, value, bin_search_flags) -> ea_t - Find forward a byte with the specified value (only 8-bit value from the - database). example: ea=4 size=3 will inspect addresses 4, 5, and 6 - - @param sEA: (C++: ea_t) linear address - @param size: (C++: asize_t) number of bytes to inspect - @param value: (C++: uchar) value to find - @param bin_search_flags: (C++: int) combination of Search flags - @return: address of byte or BADADDR +ida_bytes.find_byte(sEA: ida_idaapi.ea_t, size: "asize_t", value: "uchar", bin_search_flags: int) -> ida_idaapi.ea_t + Find forward a byte with the specified value (only 8-bit value from the database). example: ea=4 size=3 will inspect addresses 4, 5, and 6 + + @param sEA: linear address + @param size: number of bytes to inspect + @param value: value to find + @param bin_search_flags: combination of Search flags + @returns address of byte or BADADDR -ida_bytes.find_byter (function) - find_byter(sEA, size, value, bin_search_flags) -> ea_t - Find reverse a byte with the specified value (only 8-bit value from the - database). example: ea=4 size=3 will inspect addresses 6, 5, and 4 - - @param sEA: (C++: ea_t) the lower address of the search range - @param size: (C++: asize_t) number of bytes to inspect - @param value: (C++: uchar) value to find - @param bin_search_flags: (C++: int) combination of Search flags - @return: address of byte or BADADDR +ida_bytes.find_byter(sEA: ida_idaapi.ea_t, size: "asize_t", value: "uchar", bin_search_flags: int) -> ida_idaapi.ea_t + Find reverse a byte with the specified value (only 8-bit value from the database). example: ea=4 size=3 will inspect addresses 6, 5, and 4 + + @param sEA: the lower address of the search range + @param size: number of bytes to inspect + @param value: value to find + @param bin_search_flags: combination of Search flags + @returns address of byte or BADADDR -ida_bytes.find_custom_data_format (function) - find_custom_data_format(name) -> int - Get id of a custom data format. - - @param name: (C++: const char *) name of the custom data format - @return: id or -1 +ida_bytes.find_bytes(bs: typing.Union[bytes, bytearray, str], range_start: int, range_size: typing.Optional[int] = None, range_end: typing.Optional[int] = ida_idaapi.BADADDR, mask: typing.Optional[typing.Union[bytes, bytearray]] = None, flags: typing.Optional[int] = BIN_SEARCH_FORWARD|BIN_SEARCH_NOSHOW, radix: typing.Optional[int] = 16, strlit_encoding: typing.Optional[typing.Union[int, str]] = PBSENC_DEF1BPU) -> int -ida_bytes.find_custom_data_type (function) - find_custom_data_type(name) -> int - Get id of a custom data type. - - @param name: (C++: const char *) name of the custom data type - @return: id or -1 +ida_bytes.find_custom_data_format(name: str) -> int + Get id of a custom data format. + + @param name: name of the custom data format + @returns id or -1 -ida_bytes.find_free_chunk (function) - find_free_chunk(start, size, alignment) -> ea_t - Search for a hole in the addressing space of the program. - - @param start: (C++: ea_t) Address to start searching from - @param size: (C++: asize_t) Size of the desired empty range - @param alignment: (C++: asize_t) Alignment bitmask, must be a pow2-1. (for example, 0xF would - align the returned range to 16 bytes). - @return: Start of the found empty range or BADADDR +ida_bytes.find_custom_data_type(name: str) -> int + Get id of a custom data type. + + @param name: name of the custom data type + @returns id or -1 -ida_bytes.float_flag (function) - float_flag() -> flags64_t +ida_bytes.find_free_chunk(start: ida_idaapi.ea_t, size: "asize_t", alignment: "asize_t") -> ida_idaapi.ea_t + Search for a hole in the addressing space of the program. + + @param start: Address to start searching from + @param size: Size of the desired empty range + @param alignment: Alignment bitmask, must be a pow2-1. (for example, 0xF would align the returned range to 16 bytes). + @returns Start of the found empty range or BADADDR + +ida_bytes.find_string(_str: str, range_start: int, range_end: typing.Optional[int] = ida_idaapi.BADADDR, range_size: typing.Optional[int] = None, strlit_encoding: typing.Optional[typing.Union[int, str]] = PBSENC_DEF1BPU, flags: typing.Optional[int] = BIN_SEARCH_FORWARD|BIN_SEARCH_NOSHOW) -> int + +ida_bytes.float_flag() -> "flags64_t" Get a flags64_t representing a float. -ida_bytes.flt_flag (function) - flt_flag() -> flags64_t +ida_bytes.flt_flag() -> "flags64_t" see FF_opbits -ida_bytes.free_chunk (function) - free_chunk(bottom, size, step) -> ea_t - - @param bottom: ea_t - @param size: asize_t - @param step: int32 +ida_bytes.get_16bit(ea: ida_idaapi.ea_t) -> int + Get 16bits of the program at 'ea'. + + @returns 1 byte (getFullByte()) if the current processor has 16-bit byte, otherwise return get_word() -ida_bytes.get_16bit (function) - get_16bit(ea) -> uint32 - Get 16bits of the program at 'ea'. - - @param ea: (C++: ea_t) - @return: 1 byte (getFullByte()) if the current processor has 16-bit byte, - otherwise return get_word() - -ida_bytes.get_32bit (function) - get_32bit(ea) -> uint32 - Get not more than 32bits of the program at 'ea'. - - @param ea: (C++: ea_t) - @return: 32 bit value, depending on processor_t::nbits: +ida_bytes.get_32bit(ea: ida_idaapi.ea_t) -> int + Get not more than 32bits of the program at 'ea'. + + @returns 32 bit value, depending on processor_t::nbits: * if ( nbits <= 8 ) return get_dword(ea); * if ( nbits <= 16) return get_wide_word(ea); * return get_wide_byte(ea); -ida_bytes.get_64bit (function) - get_64bit(ea) -> uint64 - Get not more than 64bits of the program at 'ea'. - - @param ea: (C++: ea_t) - @return: 64 bit value, depending on processor_t::nbits: +ida_bytes.get_64bit(ea: ida_idaapi.ea_t) -> "uint64" + Get not more than 64bits of the program at 'ea'. + + @returns 64 bit value, depending on processor_t::nbits: * if ( nbits <= 8 ) return get_qword(ea); * if ( nbits <= 16) return get_wide_dword(ea); * return get_wide_byte(ea); -ida_bytes.get_8bit (function) - get_8bit(ea, v, nbit) -> PyObject * - - @param ea: ea_t - @param v: uint32 - @param nbit: int +ida_bytes.get_byte(ea: ida_idaapi.ea_t) -> "uchar" + Get one byte (8-bit) of the program at 'ea'. This function works only for 8bit byte processors. + -ida_bytes.get_byte (function) - get_byte(ea) -> uchar - Get one byte (8-bit) of the program at 'ea'. This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) - -ida_bytes.get_bytes (function) - get_bytes(ea, size, gmb_flags=0x01) -> bytes or None +ida_bytes.get_bytes(ea: ida_idaapi.ea_t, size: int, gmb_flags: int = GMB_READALL) Get the specified number of bytes of the program. @param ea: program address @param size: number of bytes to return - @param gmb_flags: int - @return: the bytes (as a str), or None in case of failure + @param gmb_flags: OR'ed combination of GMB_* values (defaults to GMB_READALL) + @return: the bytes (as bytes object), or None in case of failure -ida_bytes.get_bytes_and_mask (function) - get_bytes_and_mask(ea, size, gmb_flags=0x01) -> PyObject * +ida_bytes.get_bytes_and_mask(ea: ida_idaapi.ea_t, size: int, gmb_flags: int = GMB_READALL) Get the specified number of bytes of the program, and a bitmask specifying what bytes are defined and what bytes are not. @param ea: program address @param size: number of bytes to return - @param gmb_flags: int + @param gmb_flags: OR'ed combination of GMB_* values (defaults to GMB_READALL) @return: a tuple (bytes, mask), or None in case of failure. Both 'bytes' and 'mask' are 'str' instances. -ida_bytes.get_cmt (function) - get_cmt(ea, rptble) -> str - Get an indented comment. - - @param ea: (C++: ea_t) linear address. may point to tail byte, the function will find start - of the item - @param rptble: (C++: bool) get repeatable comment? - @return: size of comment or -1 +ida_bytes.get_cmt(ea: ida_idaapi.ea_t, rptble: bool) -> str + Get an indented comment. + + @param ea: linear address. may point to tail byte, the function will find start of the item + @param rptble: get repeatable comment? + @returns size of comment or -1 -ida_bytes.get_custom_data_format (function) - get_custom_data_format(dfid) -> data_format_t - Get definition of a registered custom data format. - - @param dfid: (C++: int) data format id - @return: data format definition or nullptr +ida_bytes.get_custom_data_format(dfid: int) -> "data_format_t const *" + Get definition of a registered custom data format. + + @param dfid: data format id + @returns data format definition or nullptr -ida_bytes.get_custom_data_formats (function) - get_custom_data_formats(out, dtid) -> int - Get list of attached custom data formats for the specified data type. - - @param out: (C++: intvec_t *) buffer for the output. may be nullptr - @param dtid: (C++: int) data type id - @return: number of returned custom data formats. if error, returns -1 +ida_bytes.get_custom_data_formats(out: "intvec_t *", dtid: int) -> int + Get list of attached custom data formats for the specified data type. + + @param out: buffer for the output. may be nullptr + @param dtid: data type id + @returns number of returned custom data formats. if error, returns -1 -ida_bytes.get_custom_data_type (function) - get_custom_data_type(dtid) -> data_type_t - Get definition of a registered custom data type. - - @param dtid: (C++: int) data type id - @return: data type definition or nullptr +ida_bytes.get_custom_data_type(dtid: int) -> "data_type_t const *" + Get definition of a registered custom data type. + + @param dtid: data type id + @returns data type definition or nullptr -ida_bytes.get_custom_data_types (function) - get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int - Get list of registered custom data type ids. - - @param out: (C++: intvec_t *) buffer for the output. may be nullptr - @param min_size: (C++: asize_t) minimum value size - @param max_size: (C++: asize_t) maximum value size - @return: number of custom data types with the specified size limits +ida_bytes.get_custom_data_types(*args) -> int + Get list of registered custom data type ids. + + @param out: buffer for the output. may be nullptr + @param min_size: minimum value size + @param max_size: maximum value size + @returns number of custom data types with the specified size limits -ida_bytes.get_data_elsize (function) - get_data_elsize(ea, F, ti=None) -> asize_t - Get size of data type specified in flags 'F'. - - @param ea: (C++: ea_t) linear address of the item - @param F: (C++: flags64_t) flags - @param ti: (C++: const opinfo_t *) additional information about the data type. For example, if the - current item is a structure instance, then ti->tid is structure id. - Otherwise is ignored (may be nullptr). If specified as nullptr, will - be automatically retrieved from the database - @return: * byte : 1 +ida_bytes.get_data_elsize(ea: ida_idaapi.ea_t, F: "flags64_t", ti: "opinfo_t" = None) -> "asize_t" + Get size of data type specified in flags 'F'. + + @param ea: linear address of the item + @param F: flags + @param ti: additional information about the data type. For example, if the current item is a structure instance, then ti->tid is structure id. Otherwise is ignored (may be nullptr). If specified as nullptr, will be automatically retrieved from the database + @returns * byte : 1 * word : 2 * etc... -ida_bytes.get_data_value (function) - get_data_value(v, ea, size) -> bool - Get the value at of the item at 'ea'. This function works with entities up to - sizeof(ea_t) (bytes, word, etc) - - @param v: (C++: uval_t *) pointer to the result. may be nullptr - @param ea: (C++: ea_t) linear address - @param size: (C++: asize_t) size of data to read. If 0, then the item type at 'ea' will be used - @return: success +ida_bytes.get_data_value(v: "uval_t *", ea: ida_idaapi.ea_t, size: "asize_t") -> bool + Get the value at of the item at 'ea'. This function works with entities up to sizeof(ea_t) (bytes, word, etc) + + @param v: pointer to the result. may be nullptr + @param ea: linear address + @param size: size of data to read. If 0, then the item type at 'ea' will be used + @returns success -ida_bytes.get_db_byte (function) - get_db_byte(ea) -> uchar - Get one byte (8-bit) of the program at 'ea' from the database. Works even if the - debugger is active. See also get_dbg_byte() to read the process memory directly. - This function works only for 8bit byte processors. - - @param ea: (C++: ea_t) +ida_bytes.get_db_byte(ea: ida_idaapi.ea_t) -> "uchar" + Get one byte (8-bit) of the program at 'ea' from the database. Works even if the debugger is active. See also get_dbg_byte() to read the process memory directly. This function works only for 8bit byte processors. + -ida_bytes.get_default_radix (function) - get_default_radix() -> int - Get default base of number for the current processor. - - @return: 2, 8, 10, 16 +ida_bytes.get_default_radix() -> int + Get default base of number for the current processor. + + @returns 2, 8, 10, 16 -ida_bytes.get_dword (function) - get_dword(ea) -> uint32 - Get one dword (32-bit) of the program at 'ea'. This function takes into account - order of bytes specified in idainfo::is_be() This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) +ida_bytes.get_dword(ea: ida_idaapi.ea_t) -> int + Get one dword (32-bit) of the program at 'ea'. This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors. + -ida_bytes.get_enum_id (function) - get_enum_id(ea, n) -> enum_t - Get enum id of 'enum' operand. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands - @return: id of enum or BADNODE +ida_bytes.get_enum_id(ea: ida_idaapi.ea_t, n: int) -> "uchar *" + Get enum id of 'enum' operand. + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands + @returns id of enum or BADNODE -ida_bytes.get_first_hidden_range (function) - get_first_hidden_range() -> hidden_range_t - Get pointer to the first hidden range. - - @return: ptr to hidden range or nullptr +ida_bytes.get_first_hidden_range() -> "hidden_range_t *" + Get pointer to the first hidden range. + + @returns ptr to hidden range or nullptr -ida_bytes.get_flags (function) - get_flags(ea) -> flags64_t - get flags with FF_IVL & MS_VAL. It is much slower under remote debugging because - the kernel needs to read the process memory. - - @param ea: (C++: ea_t) +ida_bytes.get_flags(ea: ida_idaapi.ea_t) -> "flags64_t" + get flags with FF_IVL & MS_VAL. It is much slower under remote debugging because the kernel needs to read the process memory. + -ida_bytes.get_flags_by_size (function) - get_flags_by_size(size) -> flags64_t - Get flags from size (in bytes). Supported sizes: 1, 2, 4, 8, 16, 32. For other - sizes returns 0 - - @param size: (C++: size_t) +ida_bytes.get_flags_by_size(size: "size_t") -> "flags64_t" + Get flags from size (in bytes). Supported sizes: 1, 2, 4, 8, 16, 32. For other sizes returns 0 + -ida_bytes.get_flags_ex (function) - get_flags_ex(ea, how) -> flags64_t +ida_bytes.get_flags_ex(ea: ida_idaapi.ea_t, how: int) -> "flags64_t" Get flags for the specified address, extended form. - - @param ea: (C++: ea_t) - @param how: (C++: int) -ida_bytes.get_forced_operand (function) - get_forced_operand(ea, n) -> str - Get forced operand. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number - @return: size of forced operand or -1 +ida_bytes.get_forced_operand(ea: ida_idaapi.ea_t, n: int) -> str + Get forced operand. + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number + @returns size of forced operand or -1 -ida_bytes.get_full_data_elsize (function) - get_full_data_elsize(ea, F, ti=None) -> asize_t - Get full size of data type specified in flags 'F'. takes into account processors - with wide bytes e.g. returns 2 for a byte element with 16-bit bytes - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param ti: (C++: const opinfo_t *) opinfo_t const * +ida_bytes.get_full_data_elsize(ea: ida_idaapi.ea_t, F: "flags64_t", ti: "opinfo_t" = None) -> "asize_t" + Get full size of data type specified in flags 'F'. takes into account processors with wide bytes e.g. returns 2 for a byte element with 16-bit bytes + -ida_bytes.get_full_flags (function) - get_full_flags(ea) -> flags64_t - Get flags value for address 'ea'. - - @param ea: (C++: ea_t) - @return: 0 if address is not present in the program +ida_bytes.get_full_flags(ea: ida_idaapi.ea_t) -> "flags64_t" + Get flags value for address 'ea'. + + @returns 0 if address is not present in the program -ida_bytes.get_hidden_range (function) - get_hidden_range(ea) -> hidden_range_t - Get pointer to hidden range structure, in: linear address. - - @param ea: (C++: ea_t) any address in the hidden range +ida_bytes.get_hidden_range(ea: ida_idaapi.ea_t) -> "hidden_range_t *" + Get pointer to hidden range structure, in: linear address. + + @param ea: any address in the hidden range -ida_bytes.get_hidden_range_num (function) - get_hidden_range_num(ea) -> int - Get number of a hidden range. - - @param ea: (C++: ea_t) any address in the hidden range - @return: number of hidden range (0..get_hidden_range_qty()-1) +ida_bytes.get_hidden_range_num(ea: ida_idaapi.ea_t) -> int + Get number of a hidden range. + + @param ea: any address in the hidden range + @returns number of hidden range (0..get_hidden_range_qty()-1) -ida_bytes.get_hidden_range_qty (function) - get_hidden_range_qty() -> int +ida_bytes.get_hidden_range_qty() -> int Get number of hidden ranges. -ida_bytes.get_item_end (function) - get_item_end(ea) -> ea_t - Get the end address of the item at 'ea'. The returned address doesn't belong to - the current item. Unexplored bytes are counted as 1 byte entities. - - @param ea: (C++: ea_t) +ida_bytes.get_item_end(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get the end address of the item at 'ea'. The returned address doesn't belong to the current item. Unexplored bytes are counted as 1 byte entities. + -ida_bytes.get_item_flag (function) - get_item_flag(_from, n, ea, appzero) -> flags64_t - Get flag of the item at 'ea' even if it is a tail byte of some array or - structure. This function is used to get flags of structure members or array - elements. - - @param from: (C++: ea_t) linear address of the instruction which refers to 'ea' - @param n: (C++: int) operand number which refers to 'ea' or OPND_ALL for one of the - operands - @param ea: (C++: ea_t) the referenced address - @param appzero: (C++: bool) append a struct field name if the field offset is zero? - meaningful only if the name refers to a structure. - @return: flags or 0 (if failed) +ida_bytes.get_item_flag(_from: ida_idaapi.ea_t, n: int, ea: ida_idaapi.ea_t, appzero: bool) -> "flags64_t" + Get flag of the item at 'ea' even if it is a tail byte of some array or structure. This function is used to get flags of structure members or array elements. + + @param n: operand number which refers to 'ea' or OPND_ALL for one of the operands + @param ea: the referenced address + @param appzero: append a struct field name if the field offset is zero? meaningful only if the name refers to a structure. + @returns flags or 0 (if failed) -ida_bytes.get_item_head (function) - get_item_head(ea) -> ea_t - Get the start address of the item at 'ea'. If there is no current item, then - 'ea' will be returned (see definition at the end of bytes.hpp source) - - @param ea: (C++: ea_t) +ida_bytes.get_item_head(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get the start address of the item at 'ea'. If there is no current item, then 'ea' will be returned (see definition at the end of bytes.hpp source) + -ida_bytes.get_item_refinfo (function) - get_item_refinfo(ri, ea, n) -> bool - Get refinfo of the item at 'ea'. This function works for a regular offset - operand as well as for a tail byte of a structure variable (in this case refinfo - to corresponding structure member will be returned) - - @param ri: (C++: refinfo_t *) refinfo holder - @param ea: (C++: ea_t) the item address - @param n: (C++: int) operand number which refers to 'ea' or OPND_ALL for one of the - operands - @return: success +ida_bytes.get_item_refinfo(ri: "refinfo_t", ea: ida_idaapi.ea_t, n: int) -> bool + Get refinfo of the item at 'ea'. This function works for a regular offset operand as well as for a tail byte of a structure variable (in this case refinfo to corresponding structure member will be returned) + + @param ri: refinfo holder + @param ea: the item address + @param n: operand number which refers to 'ea' or OPND_ALL for one of the operands + @returns success -ida_bytes.get_item_size (function) - get_item_size(ea) -> asize_t - Get size of item (instruction/data) in bytes. Unexplored bytes have length of 1 - byte. This function returns 0 only for BADADDR. - - @param ea: (C++: ea_t) +ida_bytes.get_item_size(ea: ida_idaapi.ea_t) -> "asize_t" + Get size of item (instruction/data) in bytes. Unexplored bytes have length of 1 byte. This function returns 0 only for BADADDR. + -ida_bytes.get_last_hidden_range (function) - get_last_hidden_range() -> hidden_range_t - Get pointer to the last hidden range. - - @return: ptr to hidden range or nullptr +ida_bytes.get_last_hidden_range() -> "hidden_range_t *" + Get pointer to the last hidden range. + + @returns ptr to hidden range or nullptr -ida_bytes.get_manual_insn (function) - get_manual_insn(ea) -> str - Retrieve the user-specified string for the manual instruction. - - @param ea: (C++: ea_t) linear address of the instruction or data item - @return: size of manual instruction or -1 +ida_bytes.get_manual_insn(ea: ida_idaapi.ea_t) -> str + Retrieve the user-specified string for the manual instruction. + + @param ea: linear address of the instruction or data item + @returns size of manual instruction or -1 -ida_bytes.get_mapping (function) - get_mapping(n) -> bool - Get memory mapping range by its number. - - @param n: (C++: size_t) number of mapping range (0..get_mappings_qty()-1) - @return: false if the specified range doesn't exist, otherwise returns `from', - `to', `size' +ida_bytes.get_mapping(n: "size_t") -> "ea_t *, ea_t *, asize_t *" + Get memory mapping range by its number. + + @param n: number of mapping range (0..get_mappings_qty()-1) + @returns false if the specified range doesn't exist, otherwise returns `from`, `to`, `size` -ida_bytes.get_mappings_qty (function) - get_mappings_qty() -> size_t +ida_bytes.get_mappings_qty() -> "size_t" Get number of mappings. -ida_bytes.get_max_strlit_length (function) - get_max_strlit_length(ea, strtype, options=0) -> size_t +ida_bytes.get_max_strlit_length(ea: ida_idaapi.ea_t, strtype: int, options: int = 0) -> "size_t" Determine maximum length of string literal. + If the string literal has a length prefix (e.g., STRTYPE_LEN2 has a two-byte length prefix), the length of that prefix (i.e., 2) will be part of the returned value. - If the string literal has a length prefix (e.g., STRTYPE_LEN2 has a two-byte - length prefix), the length of that prefix (i.e., 2) will be part of the returned - value. - - @param ea: (C++: ea_t) starting address - @param strtype: (C++: int32) string type. one of String type codes - @param options: (C++: int) combination of string literal length options - @return: length of the string in octets (octet==8bit) + @param ea: starting address + @param strtype: string type. one of String type codes + @param options: combination of string literal length options + @returns length of the string in octets (octet==8bit) -ida_bytes.get_next_hidden_range (function) - get_next_hidden_range(ea) -> hidden_range_t - Get pointer to next hidden range. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to hidden range or nullptr if next hidden range doesn't exist +ida_bytes.get_next_hidden_range(ea: ida_idaapi.ea_t) -> "hidden_range_t *" + Get pointer to next hidden range. + + @param ea: any address in the program + @returns ptr to hidden range or nullptr if next hidden range doesn't exist -ida_bytes.get_octet (function) - get_octet(ea, v, nbit) -> (int, int, int, int) - - @param ea: ea_t - @param v: uint64 - @param nbit: int +ida_bytes.get_octet(ogen: "octet_generator_t") -> "uchar *" -ida_bytes.get_octet2 (function) - get_octet2(ogen) -> bool - - @param ogen: octet_generator_t * - -ida_bytes.get_operand_flag (function) - get_operand_flag(typebits, n) -> flags64_t +ida_bytes.get_operand_flag(typebits: "uint8", n: int) -> "flags64_t" Place operand `n`'s type flag in the right nibble of a 64-bit flags set. - @param typebits: (C++: uint8) the type bits (one of `FF_N_`) - @param n: (C++: int) the operand number - @return: the shift to the nibble + @param typebits: the type bits (one of `FF_N_`) + @param n: the operand number + @returns the shift to the nibble -ida_bytes.get_operand_type_shift (function) - get_operand_type_shift(n) -> int +ida_bytes.get_operand_type_shift(n: int) -> int Get the shift in `flags64_t` for the nibble representing operand `n`'s type - Note: n must be < UA_MAXOP, and is not checked - @param n: (C++: uint32) the operand number - @return: the shift to the nibble + @param n: the operand number + @returns the shift to the nibble -ida_bytes.get_opinfo (function) - get_opinfo(buf, ea, n, flags) -> opinfo_t - Get additional information about an operand representation. - - @param buf: (C++: opinfo_t *) buffer to receive the result. may not be nullptr - @param ea: (C++: ea_t) linear address of item - @param n: (C++: int) number of operand, 0 or 1 - @param flags: (C++: flags64_t) flags of the item - @return: nullptr if no additional representation information +ida_bytes.get_opinfo(buf: "opinfo_t", ea: ida_idaapi.ea_t, n: int, flags: "flags64_t") -> "opinfo_t *" + Get additional information about an operand representation. + + @param buf: buffer to receive the result. may not be nullptr + @param ea: linear address of item + @param n: number of operand, 0 or 1 + @param flags: flags of the item + @returns nullptr if no additional representation information -ida_bytes.get_optype_flags0 (function) - get_optype_flags0(F) -> flags64_t +ida_bytes.get_optype_flags0(F: "flags64_t") -> "flags64_t" Get flags for first operand. - - @param F: (C++: flags64_t) -ida_bytes.get_optype_flags1 (function) - get_optype_flags1(F) -> flags64_t +ida_bytes.get_optype_flags1(F: "flags64_t") -> "flags64_t" Get flags for second operand. - - @param F: (C++: flags64_t) -ida_bytes.get_original_byte (function) - get_original_byte(ea) -> uint64 - Get original byte value (that was before patching). This function works for wide - byte processors too. - - @param ea: (C++: ea_t) +ida_bytes.get_original_byte(ea: ida_idaapi.ea_t) -> "uint64" + Get original byte value (that was before patching). This function works for wide byte processors too. + -ida_bytes.get_original_dword (function) - get_original_dword(ea) -> uint64 - Get original dword (that was before patching) This function works for wide byte - processors too. This function takes into account order of bytes specified in - idainfo::is_be() - - @param ea: (C++: ea_t) +ida_bytes.get_original_dword(ea: ida_idaapi.ea_t) -> "uint64" + Get original dword (that was before patching) This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be() + -ida_bytes.get_original_qword (function) - get_original_qword(ea) -> uint64 - Get original qword value (that was before patching) This function DOESN'T work - for wide byte processors too. This function takes into account order of bytes - specified in idainfo::is_be() - - @param ea: (C++: ea_t) +ida_bytes.get_original_qword(ea: ida_idaapi.ea_t) -> "uint64" + Get original qword value (that was before patching) This function DOESN'T work for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be() + -ida_bytes.get_original_word (function) - get_original_word(ea) -> uint64 - Get original word value (that was before patching). This function works for wide - byte processors too. This function takes into account order of bytes specified - in idainfo::is_be() - - @param ea: (C++: ea_t) +ida_bytes.get_original_word(ea: ida_idaapi.ea_t) -> "uint64" + Get original word value (that was before patching). This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be() + -ida_bytes.get_possible_item_varsize (function) - get_possible_item_varsize(ea, tif) -> asize_t - Return the possible size of the item at EA of type TIF if TIF is the variable - structure. - - @param ea: (C++: ea_t) the linear address of the item - @param tif: (C++: const tinfo_t &) the item type - @return: the possible size +ida_bytes.get_possible_item_varsize(ea: ida_idaapi.ea_t, tif: "tinfo_t") -> "asize_t" + Return the possible size of the item at EA of type TIF if TIF is the variable structure. + + @param ea: the linear address of the item + @param tif: the item type + @returns the possible size @retval asize_t(-1): TIF is not a variable structure -ida_bytes.get_predef_insn_cmt (function) - get_predef_insn_cmt(ins) -> str - Get predefined comment. - - @param ins: (C++: const insn_t &) current instruction information - @return: size of comment or -1 +ida_bytes.get_predef_insn_cmt(ins: "insn_t const &") -> str + Get predefined comment. + + @param ins: current instruction information + @returns size of comment or -1 -ida_bytes.get_prev_hidden_range (function) - get_prev_hidden_range(ea) -> hidden_range_t - Get pointer to previous hidden range. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to hidden range or nullptr if previous hidden range doesn't exist +ida_bytes.get_prev_hidden_range(ea: ida_idaapi.ea_t) -> "hidden_range_t *" + Get pointer to previous hidden range. + + @param ea: any address in the program + @returns ptr to hidden range or nullptr if previous hidden range doesn't exist -ida_bytes.get_qword (function) - get_qword(ea) -> uint64 - Get one qword (64-bit) of the program at 'ea'. This function takes into account - order of bytes specified in idainfo::is_be() This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) +ida_bytes.get_qword(ea: ida_idaapi.ea_t) -> "uint64" + Get one qword (64-bit) of the program at 'ea'. This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors. + -ida_bytes.get_radix (function) - get_radix(F, n) -> int - Get radix of the operand, in: flags. If the operand is not a number, returns - get_default_radix() - - @param F: (C++: flags64_t) flags - @param n: (C++: int) number of operand (0, 1, -1) - @return: 2, 8, 10, 16 +ida_bytes.get_radix(F: "flags64_t", n: int) -> int + Get radix of the operand, in: flags. If the operand is not a number, returns get_default_radix() + + @param F: flags + @param n: number of operand (0, 1, -1) + @returns 2, 8, 10, 16 -ida_bytes.get_strlit_contents (function) - get_strlit_contents(ea, py_len, type, flags=0) -> bytes or None +ida_bytes.get_strlit_contents(ea: ida_idaapi.ea_t, len: int, type: int, flags: int = 0) Get contents of string literal, as UTF-8-encoded codepoints. It works even if the string has not been created in the database yet. @@ -16971,1076 +11509,632 @@ ida_bytes.get_strlit_contents (function) strings), you should probably be using the idautils.Strings class. @param ea: linear address of the string - @param py_len: length of the string in bytes (including terminating 0) + @param len: length of the string in bytes (including terminating 0) @param type: type of the string. Represents both the character encoding, and the 'type' of string at the given location. @param flags: combination of STRCONV_..., to perform output conversion. @return: a bytes-filled str object. -ida_bytes.get_stroff_path (function) - get_stroff_path(path, delta, ea, n) -> int - Get struct path of operand. +ida_bytes.get_stroff_path(*args) + Get the structure offset path for operand `n`, at the + specified address. - @param path: (C++: tid_t *) buffer for structure path (strpath). see nalt.hpp for more info. - @param delta: (C++: adiff_t *) struct offset delta - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands - @return: length of strpath - -ida_bytes.get_wide_byte (function) - get_wide_byte(ea) -> uint64 - Get one wide byte of the program at 'ea'. Some processors may access more than - 8bit quantity at an address. These processors have 32-bit byte organization from - the IDA's point of view. + This function has the following signatures: - @param ea: (C++: ea_t) - -ida_bytes.get_wide_dword (function) - get_wide_dword(ea) -> uint64 - Get two wide words (4 'bytes') of the program at 'ea'. Some processors may - access more than 8bit quantity at an address. These processors have 32-bit byte - organization from the IDA's point of view. This function takes into account - order of bytes specified in idainfo::is_be() - @note: this function works incorrectly if processor_t::nbits > 16 + 1. get_stroff_path(ea: ida_idaapi.ea_t, n : int) -> Tuple[List[int], int] + 2. get_stroff_path(path: tid_array, delta: sval_pointer, ea: ida_idaapi.ea_t, n : int) (backward-compatibility only) - @param ea: (C++: ea_t) + @param ea address where the operand holds a path to a structure offset (1st form) + @param n operand number (1st form) + @return a tuple holding a (list_of_tid_t's, delta_within_the_last_type), or (None, None) -ida_bytes.get_wide_word (function) - get_wide_word(ea) -> uint64 - Get one wide word (2 'byte') of the program at 'ea'. Some processors may access - more than 8bit quantity at an address. These processors have 32-bit byte - organization from the IDA's point of view. This function takes into account - order of bytes specified in idainfo::is_be() - - @param ea: (C++: ea_t) +ida_bytes.get_wide_byte(ea: ida_idaapi.ea_t) -> "uint64" + Get one wide byte of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. + -ida_bytes.get_word (function) - get_word(ea) -> ushort - Get one word (16-bit) of the program at 'ea'. This function takes into account - order of bytes specified in idainfo::is_be() This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) +ida_bytes.get_wide_dword(ea: ida_idaapi.ea_t) -> "uint64" + Get two wide words (4 'bytes') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This function takes into account order of bytes specified in idainfo::is_be() + -ida_bytes.get_zero_ranges (function) - get_zero_ranges(zranges, range) -> bool - Return set of ranges with zero initialized bytes. The returned set includes only - big zero initialized ranges (at least >1KB). Some zero initialized byte ranges - may be not included. Only zero bytes that use the sparse storage method (STT_MM) - are reported. - - @param zranges: (C++: rangeset_t *) pointer to the return value. cannot be nullptr - @param range: (C++: const range_t *) the range of addresses to verify. can be nullptr - means all - ranges - @return: true if the result is a non-empty set +ida_bytes.get_wide_word(ea: ida_idaapi.ea_t) -> "uint64" + Get one wide word (2 'byte') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This function takes into account order of bytes specified in idainfo::is_be() + -ida_bytes.getn_hidden_range (function) - getn_hidden_range(n) -> hidden_range_t - Get pointer to hidden range structure, in: number of hidden range. - - @param n: (C++: int) number of hidden range, is in range 0..get_hidden_range_qty()-1 +ida_bytes.get_word(ea: ida_idaapi.ea_t) -> "ushort" + Get one word (16-bit) of the program at 'ea'. This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors. + -ida_bytes.has_any_name (function) - has_any_name(F) -> bool +ida_bytes.get_zero_ranges(zranges: "rangeset_t", range: "range_t") -> bool + Return set of ranges with zero initialized bytes. The returned set includes only big zero initialized ranges (at least >1KB). Some zero initialized byte ranges may be not included. Only zero bytes that use the sparse storage method (STT_MM) are reported. + + @param zranges: pointer to the return value. cannot be nullptr + @param range: the range of addresses to verify. can be nullptr - means all ranges + @returns true if the result is a non-empty set + +ida_bytes.getn_hidden_range(n: int) -> "hidden_range_t *" + Get pointer to hidden range structure, in: number of hidden range. + + @param n: number of hidden range, is in range 0..get_hidden_range_qty()-1 + +ida_bytes.has_any_name(F: "flags64_t") -> bool Does the current byte have any name? - - @param F: (C++: flags64_t) -ida_bytes.has_auto_name (function) - has_auto_name(F) -> bool +ida_bytes.has_auto_name(F: "flags64_t") -> bool Does the current byte have auto-generated (no special prefix) name? - - @param F: (C++: flags64_t) -ida_bytes.has_cmt (function) - has_cmt(F) -> bool +ida_bytes.has_cmt(F: "flags64_t") -> bool Does the current byte have an indented comment? - - @param F: (C++: flags64_t) -ida_bytes.has_dummy_name (function) - has_dummy_name(F) -> bool +ida_bytes.has_dummy_name(F: "flags64_t") -> bool Does the current byte have dummy (auto-generated, with special prefix) name? - - @param F: (C++: flags64_t) -ida_bytes.has_extra_cmts (function) - has_extra_cmts(F) -> bool +ida_bytes.has_extra_cmts(F: "flags64_t") -> bool Does the current byte have additional anterior or posterior lines? - - @param F: (C++: flags64_t) -ida_bytes.has_immd (function) - has_immd(F) -> bool +ida_bytes.has_immd(F: "flags64_t") -> bool Has immediate value? - - @param F: (C++: flags64_t) -ida_bytes.has_name (function) - has_name(F) -> bool +ida_bytes.has_name(F: "flags64_t") -> bool Does the current byte have non-trivial (non-dummy) name? - - @param F: (C++: flags64_t) -ida_bytes.has_user_name (function) - has_user_name(F) -> bool +ida_bytes.has_user_name(F: "flags64_t") -> bool Does the current byte have user-specified name? - - @param F: (C++: flags64_t) -ida_bytes.has_value (function) - has_value(F) -> bool +ida_bytes.has_value(F: "flags64_t") -> bool Do flags contain byte value? - - @param F: (C++: flags64_t) -ida_bytes.has_xref (function) - has_xref(F) -> bool +ida_bytes.has_xref(F: "flags64_t") -> bool Does the current byte have cross-references to it? - - @param F: (C++: flags64_t) -ida_bytes.hex_flag (function) - hex_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() +ida_bytes.hex_flag() -> "flags64_t" + Get number flag of the base, regardless of current processor - better to use num_flag() -ida_bytes.hidden_range_t (class) - Proxy of C++ hidden_range_t class. +ida_bytes.hidden_range_t -ida_bytes.hidden_range_t.__init__ (method) - __init__(self) -> hidden_range_t +ida_bytes.hidden_range_t.__init__(self) -ida_bytes.hidden_range_t.color (variable) +ida_bytes.hidden_range_t.color range color -ida_bytes.hidden_range_t.description (variable) +ida_bytes.hidden_range_t.description description to display if the range is collapsed -ida_bytes.hidden_range_t.footer (variable) +ida_bytes.hidden_range_t.footer footer lines to display if the range is expanded -ida_bytes.hidden_range_t.header (variable) +ida_bytes.hidden_range_t.header header lines to display if the range is expanded -ida_bytes.hidden_range_t.visible (variable) +ida_bytes.hidden_range_t.visible the range state -ida_bytes.is_align (function) - is_align(F) -> bool +ida_bytes.is_align(F: "flags64_t") -> bool FF_ALIGN - - @param F: (C++: flags64_t) -ida_bytes.is_attached_custom_data_format (function) - is_attached_custom_data_format(dtid, dfid) -> bool - Is the custom data format attached to the custom data type? - - @param dtid: (C++: int) data type id - @param dfid: (C++: int) data format id - @return: true or false +ida_bytes.is_attached_custom_data_format(dtid: int, dfid: int) -> bool + Is the custom data format attached to the custom data type? + + @param dtid: data type id + @param dfid: data format id + @returns true or false -ida_bytes.is_bnot (function) - is_bnot(ea, F, n) -> bool - Should we negate the operand?. asm_t::a_bnot should be defined in the idp module - in order to work with this function - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param n: (C++: int) +ida_bytes.is_bnot(ea: ida_idaapi.ea_t, F: "flags64_t", n: int) -> bool + Should we negate the operand?. asm_t::a_bnot should be defined in the idp module in order to work with this function + -ida_bytes.is_byte (function) - is_byte(F) -> bool +ida_bytes.is_byte(F: "flags64_t") -> bool FF_BYTE - - @param F: (C++: flags64_t) -ida_bytes.is_char (function) - is_char(F, n) -> bool +ida_bytes.is_char(F: "flags64_t", n: int) -> bool is character constant? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_char0 (function) - is_char0(F) -> bool +ida_bytes.is_char0(F: "flags64_t") -> bool Is the first operand character constant? (example: push 'a') - - @param F: (C++: flags64_t) -ida_bytes.is_char1 (function) - is_char1(F) -> bool +ida_bytes.is_char1(F: "flags64_t") -> bool Is the second operand character constant? (example: mov al, 'a') - - @param F: (C++: flags64_t) -ida_bytes.is_code (function) - is_code(F) -> bool +ida_bytes.is_code(F: "flags64_t") -> bool Does flag denote start of an instruction? - - @param F: (C++: flags64_t) -ida_bytes.is_custfmt (function) - is_custfmt(F, n) -> bool +ida_bytes.is_custfmt(F: "flags64_t", n: int) -> bool is custom data format? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_custfmt0 (function) - is_custfmt0(F) -> bool +ida_bytes.is_custfmt0(F: "flags64_t") -> bool Does the first operand use a custom data representation? - - @param F: (C++: flags64_t) -ida_bytes.is_custfmt1 (function) - is_custfmt1(F) -> bool +ida_bytes.is_custfmt1(F: "flags64_t") -> bool Does the second operand use a custom data representation? - - @param F: (C++: flags64_t) -ida_bytes.is_custom (function) - is_custom(F) -> bool +ida_bytes.is_custom(F: "flags64_t") -> bool FF_CUSTOM - - @param F: (C++: flags64_t) -ida_bytes.is_data (function) - is_data(F) -> bool +ida_bytes.is_data(F: "flags64_t") -> bool Does flag denote start of data? - - @param F: (C++: flags64_t) -ida_bytes.is_defarg (function) - is_defarg(F, n) -> bool +ida_bytes.is_defarg(F: "flags64_t", n: int) -> bool is defined? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_defarg0 (function) - is_defarg0(F) -> bool +ida_bytes.is_defarg0(F: "flags64_t") -> bool Is the first operand defined? Initially operand has no defined representation. - - @param F: (C++: flags64_t) -ida_bytes.is_defarg1 (function) - is_defarg1(F) -> bool +ida_bytes.is_defarg1(F: "flags64_t") -> bool Is the second operand defined? Initially operand has no defined representation. - - @param F: (C++: flags64_t) -ida_bytes.is_double (function) - is_double(F) -> bool +ida_bytes.is_double(F: "flags64_t") -> bool FF_DOUBLE - - @param F: (C++: flags64_t) -ida_bytes.is_dword (function) - is_dword(F) -> bool +ida_bytes.is_dword(F: "flags64_t") -> bool FF_DWORD - - @param F: (C++: flags64_t) -ida_bytes.is_enum (function) - is_enum(F, n) -> bool +ida_bytes.is_enum(F: "flags64_t", n: int) -> bool is enum? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_enum0 (function) - is_enum0(F) -> bool +ida_bytes.is_enum0(F: "flags64_t") -> bool Is the first operand a symbolic constant (enum member)? - - @param F: (C++: flags64_t) -ida_bytes.is_enum1 (function) - is_enum1(F) -> bool +ida_bytes.is_enum1(F: "flags64_t") -> bool Is the second operand a symbolic constant (enum member)? - - @param F: (C++: flags64_t) -ida_bytes.is_flag_for_operand (function) - is_flag_for_operand(F, typebits, n) -> bool +ida_bytes.is_flag_for_operand(F: "flags64_t", typebits: "uint8", n: int) -> bool Check that the 64-bit flags set has the expected type for operand `n`. - @param F: (C++: flags64_t) the flags - @param typebits: (C++: uint8) the type bits (one of `FF_N_`) - @param n: (C++: int) the operand number - @return: success + @param F: the flags + @param typebits: the type bits (one of `FF_N_`) + @param n: the operand number + @returns success -ida_bytes.is_float (function) - is_float(F) -> bool +ida_bytes.is_float(F: "flags64_t") -> bool FF_FLOAT - - @param F: (C++: flags64_t) -ida_bytes.is_float0 (function) - is_float0(F) -> bool +ida_bytes.is_float0(F: "flags64_t") -> bool Is the first operand a floating point number? - - @param F: (C++: flags64_t) -ida_bytes.is_float1 (function) - is_float1(F) -> bool +ida_bytes.is_float1(F: "flags64_t") -> bool Is the second operand a floating point number? - - @param F: (C++: flags64_t) -ida_bytes.is_flow (function) - is_flow(F) -> bool +ida_bytes.is_flow(F: "flags64_t") -> bool Does the previous instruction exist and pass execution flow to the current byte? - - @param F: (C++: flags64_t) -ida_bytes.is_fltnum (function) - is_fltnum(F, n) -> bool +ida_bytes.is_fltnum(F: "flags64_t", n: int) -> bool is floating point number? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_forced_operand (function) - is_forced_operand(ea, n) -> bool - Is operand manually defined?. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number +ida_bytes.is_forced_operand(ea: ida_idaapi.ea_t, n: int) -> bool + Is operand manually defined?. + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number -ida_bytes.is_func (function) - is_func(F) -> bool +ida_bytes.is_func(F: "flags64_t") -> bool Is function start? - - @param F: (C++: flags64_t) -ida_bytes.is_head (function) - is_head(F) -> bool +ida_bytes.is_head(F: "flags64_t") -> bool Does flag denote start of instruction OR data? - - @param F: (C++: flags64_t) -ida_bytes.is_invsign (function) - is_invsign(ea, F, n) -> bool - Should sign of n-th operand inverted during output?. allowed values of n: - 0-first operand, 1-other operands - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param n: (C++: int) +ida_bytes.is_invsign(ea: ida_idaapi.ea_t, F: "flags64_t", n: int) -> bool + Should sign of n-th operand inverted during output?. allowed values of n: 0-first operand, 1-other operands + -ida_bytes.is_loaded (function) - is_loaded(ea) -> bool +ida_bytes.is_loaded(ea: ida_idaapi.ea_t) -> bool Does the specified address have a byte value (is initialized?) - - @param ea: (C++: ea_t) -ida_bytes.is_lzero (function) - is_lzero(ea, n) -> bool - Display leading zeroes? Display leading zeroes in operands. The global switch - for the leading zeroes is in idainfo::s_genflags Note: the leading zeroes - doesn't work if for the target assembler octal numbers start with 0. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success +ida_bytes.is_lzero(ea: ida_idaapi.ea_t, n: int) -> bool + Display leading zeroes? Display leading zeroes in operands. The global switch for the leading zeroes is in idainfo::s_genflags Note: the leading zeroes doesn't work if for the target assembler octal numbers start with 0. + + @param ea: the item (insn/data) address + @param n: the operand number (0-first operand, 1-other operands) + @returns success -ida_bytes.is_manual (function) - is_manual(F, n) -> bool +ida_bytes.is_manual(F: "flags64_t", n: int) -> bool is forced operand? (use is_forced_operand()) - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_manual_insn (function) - is_manual_insn(ea) -> bool - Is the instruction overridden? - - @param ea: (C++: ea_t) linear address of the instruction or data item +ida_bytes.is_manual_insn(ea: ida_idaapi.ea_t) -> bool + Is the instruction overridden? + + @param ea: linear address of the instruction or data item -ida_bytes.is_mapped (function) - is_mapped(ea) -> bool +ida_bytes.is_mapped(ea: ida_idaapi.ea_t) -> bool Is the specified address 'ea' present in the program? - - @param ea: (C++: ea_t) -ida_bytes.is_not_tail (function) - is_not_tail(F) -> bool +ida_bytes.is_not_tail(F: "flags64_t") -> bool Does flag denote tail byte? - - @param F: (C++: flags64_t) -ida_bytes.is_numop (function) - is_numop(F, n) -> bool +ida_bytes.is_numop(F: "flags64_t", n: int) -> bool is number (bin, oct, dec, hex)? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_numop0 (function) - is_numop0(F) -> bool +ida_bytes.is_numop0(F: "flags64_t") -> bool Is the first operand a number (i.e. binary, octal, decimal or hex?) - - @param F: (C++: flags64_t) -ida_bytes.is_numop1 (function) - is_numop1(F) -> bool +ida_bytes.is_numop1(F: "flags64_t") -> bool Is the second operand a number (i.e. binary, octal, decimal or hex?) - - @param F: (C++: flags64_t) -ida_bytes.is_off (function) - is_off(F, n) -> bool +ida_bytes.is_off(F: "flags64_t", n: int) -> bool is offset? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_off0 (function) - is_off0(F) -> bool +ida_bytes.is_off0(F: "flags64_t") -> bool Is the first operand offset? (example: push offset xxx) - - @param F: (C++: flags64_t) -ida_bytes.is_off1 (function) - is_off1(F) -> bool +ida_bytes.is_off1(F: "flags64_t") -> bool Is the second operand offset? (example: mov ax, offset xxx) - - @param F: (C++: flags64_t) -ida_bytes.is_oword (function) - is_oword(F) -> bool +ida_bytes.is_oword(F: "flags64_t") -> bool FF_OWORD - - @param F: (C++: flags64_t) -ida_bytes.is_pack_real (function) - is_pack_real(F) -> bool +ida_bytes.is_pack_real(F: "flags64_t") -> bool FF_PACKREAL - - @param F: (C++: flags64_t) -ida_bytes.is_qword (function) - is_qword(F) -> bool +ida_bytes.is_qword(F: "flags64_t") -> bool FF_QWORD - - @param F: (C++: flags64_t) -ida_bytes.is_same_data_type (function) - is_same_data_type(F1, F2) -> bool +ida_bytes.is_same_data_type(F1: "flags64_t", F2: "flags64_t") -> bool Do the given flags specify the same data type? - - @param F1: (C++: flags64_t) - @param F2: (C++: flags64_t) -ida_bytes.is_seg (function) - is_seg(F, n) -> bool +ida_bytes.is_seg(F: "flags64_t", n: int) -> bool is segment? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_seg0 (function) - is_seg0(F) -> bool +ida_bytes.is_seg0(F: "flags64_t") -> bool Is the first operand segment selector? (example: push seg seg001) - - @param F: (C++: flags64_t) -ida_bytes.is_seg1 (function) - is_seg1(F) -> bool +ida_bytes.is_seg1(F: "flags64_t") -> bool Is the second operand segment selector? (example: mov dx, seg dseg) - - @param F: (C++: flags64_t) -ida_bytes.is_stkvar (function) - is_stkvar(F, n) -> bool +ida_bytes.is_stkvar(F: "flags64_t", n: int) -> bool is stack variable? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_stkvar0 (function) - is_stkvar0(F) -> bool +ida_bytes.is_stkvar0(F: "flags64_t") -> bool Is the first operand a stack variable? - - @param F: (C++: flags64_t) -ida_bytes.is_stkvar1 (function) - is_stkvar1(F) -> bool +ida_bytes.is_stkvar1(F: "flags64_t") -> bool Is the second operand a stack variable? - - @param F: (C++: flags64_t) -ida_bytes.is_strlit (function) - is_strlit(F) -> bool +ida_bytes.is_strlit(F: "flags64_t") -> bool FF_STRLIT - - @param F: (C++: flags64_t) -ida_bytes.is_stroff (function) - is_stroff(F, n) -> bool +ida_bytes.is_stroff(F: "flags64_t", n: int) -> bool is struct offset? - - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_stroff0 (function) - is_stroff0(F) -> bool +ida_bytes.is_stroff0(F: "flags64_t") -> bool Is the first operand an offset within a struct? - - @param F: (C++: flags64_t) -ida_bytes.is_stroff1 (function) - is_stroff1(F) -> bool +ida_bytes.is_stroff1(F: "flags64_t") -> bool Is the second operand an offset within a struct? - - @param F: (C++: flags64_t) -ida_bytes.is_struct (function) - is_struct(F) -> bool +ida_bytes.is_struct(F: "flags64_t") -> bool FF_STRUCT - - @param F: (C++: flags64_t) -ida_bytes.is_suspop (function) - is_suspop(ea, F, n) -> bool +ida_bytes.is_suspop(ea: ida_idaapi.ea_t, F: "flags64_t", n: int) -> bool is suspicious operand? - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param n: (C++: int) -ida_bytes.is_tail (function) - is_tail(F) -> bool +ida_bytes.is_tail(F: "flags64_t") -> bool Does flag denote tail byte? - - @param F: (C++: flags64_t) -ida_bytes.is_tbyte (function) - is_tbyte(F) -> bool +ida_bytes.is_tbyte(F: "flags64_t") -> bool FF_TBYTE - - @param F: (C++: flags64_t) -ida_bytes.is_unknown (function) - is_unknown(F) -> bool +ida_bytes.is_unknown(F: "flags64_t") -> bool Does flag denote unexplored byte? - - @param F: (C++: flags64_t) -ida_bytes.is_varsize_item (function) - is_varsize_item(ea, F, ti=None, itemsize=None) -> int - Is the item at 'ea' variable size?. - - @param ea: (C++: ea_t) linear address of the item - @param F: (C++: flags64_t) flags - @param ti: (C++: const opinfo_t *) additional information about the data type. For example, if the - current item is a structure instance, then ti->tid is structure id. - Otherwise is ignored (may be nullptr). If specified as nullptr, will - be automatically retrieved from the database - @param itemsize: (C++: asize_t *) if not nullptr and the item is varsize, itemsize will contain - the calculated item size (for struct types, the minimal size is - returned) +ida_bytes.is_varsize_item(ea: ida_idaapi.ea_t, F: "flags64_t", ti: "opinfo_t" = None, itemsize: "asize_t *" = None) -> int + Is the item at 'ea' variable size?. + + @param ea: linear address of the item + @param F: flags + @param ti: additional information about the data type. For example, if the current item is a structure instance, then ti->tid is structure id. Otherwise is ignored (may be nullptr). If specified as nullptr, will be automatically retrieved from the database + @param itemsize: if not nullptr and the item is varsize, itemsize will contain the calculated item size (for struct types, the minimal size is returned) @retval 1: varsize item @retval 0: fixed item @retval -1: error (bad data definition) -ida_bytes.is_word (function) - is_word(F) -> bool +ida_bytes.is_word(F: "flags64_t") -> bool FF_WORD - - @param F: (C++: flags64_t) -ida_bytes.is_yword (function) - is_yword(F) -> bool +ida_bytes.is_yword(F: "flags64_t") -> bool FF_YWORD - - @param F: (C++: flags64_t) -ida_bytes.is_zword (function) - is_zword(F) -> bool +ida_bytes.is_zword(F: "flags64_t") -> bool FF_ZWORD - - @param F: (C++: flags64_t) -ida_bytes.leading_zero_important (function) - leading_zero_important(ea, n) -> bool +ida_bytes.leading_zero_important(ea: ida_idaapi.ea_t, n: int) -> bool Check if leading zeroes are important. - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.nbits (function) - nbits(ea) -> int - Get number of bits in a byte at the given address. - - @param ea: (C++: ea_t) - @return: processor_t::dnbits() if the address doesn't belong to a segment, - otherwise the result depends on the segment type +ida_bytes.nbits(ea: ida_idaapi.ea_t) -> int + Get number of bits in a byte at the given address. + + @returns processor_t::dnbits() if the address doesn't belong to a segment, otherwise the result depends on the segment type -ida_bytes.next_addr (function) - next_addr(ea) -> ea_t - Get next address in the program (i.e. next address which has flags). - - @param ea: (C++: ea_t) - @return: BADADDR if no such address exist. +ida_bytes.next_addr(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get next address in the program (i.e. next address which has flags). + + @returns BADADDR if no such address exist. -ida_bytes.next_chunk (function) - next_chunk(ea) -> ea_t - Get the first address of next contiguous chunk in the program. - - @param ea: (C++: ea_t) - @return: BADADDR if next chunk doesn't exist. +ida_bytes.next_chunk(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get the first address of next contiguous chunk in the program. + + @returns BADADDR if next chunk doesn't exist. -ida_bytes.next_head (function) - next_head(ea, maxea) -> ea_t - Get start of next defined item. - - @param ea: (C++: ea_t) begin search at this address - @param maxea: (C++: ea_t) not included in the search range - @return: BADADDR if none exists. +ida_bytes.next_head(ea: ida_idaapi.ea_t, maxea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get start of next defined item. + + @param ea: begin search at this address + @param maxea: not included in the search range + @returns BADADDR if none exists. -ida_bytes.next_inited (function) - next_inited(ea, maxea) -> ea_t +ida_bytes.next_inited(ea: ida_idaapi.ea_t, maxea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Find the next initialized address. - - @param ea: (C++: ea_t) - @param maxea: (C++: ea_t) -ida_bytes.next_not_tail (function) - next_not_tail(ea) -> ea_t - Get address of next non-tail byte. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. +ida_bytes.next_not_tail(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get address of next non-tail byte. + + @returns BADADDR if none exists. -ida_bytes.next_that (function) - next_that(ea, maxea, testf) -> ea_t - Find next address with a flag satisfying the function 'testf'. - @note: do not pass is_unknown() to this function to find unexplored bytes. It - will fail under the debugger. To find unexplored bytes, use - next_unknown(). - - @param ea: (C++: ea_t) start searching at this address + 1 - @param maxea: (C++: ea_t) not included in the search range. - @param testf: (C++: testf_t *) test function to find next address - @return: the found address or BADADDR. +ida_bytes.next_that(ea: ida_idaapi.ea_t, maxea: ida_idaapi.ea_t, testf: "testf_t *") -> ida_idaapi.ea_t + Find next address with a flag satisfying the function 'testf'. + + @param ea: start searching at this address + 1 + @param maxea: not included in the search range. + @param testf: test function to find next address + @returns the found address or BADADDR. -ida_bytes.next_unknown (function) - next_unknown(ea, maxea) -> ea_t +ida_bytes.next_unknown(ea: ida_idaapi.ea_t, maxea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Similar to next_that(), but will find the next address that is unexplored. - - @param ea: (C++: ea_t) - @param maxea: (C++: ea_t) -ida_bytes.next_visea (function) - next_visea(ea) -> ea_t - Get next visible address. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. +ida_bytes.next_visea(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get next visible address. + + @returns BADADDR if none exists. -ida_bytes.num_flag (function) - num_flag() -> flags64_t - Get number of default base (bin, oct, dec, hex) +ida_bytes.num_flag() -> "flags64_t" + Get number of default base (bin, oct, dec, hex) + -ida_bytes.oct_flag (function) - oct_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() +ida_bytes.oct_flag() -> "flags64_t" + Get number flag of the base, regardless of current processor - better to use num_flag() -ida_bytes.octet_generator_t (class) - Proxy of C++ octet_generator_t class. +ida_bytes.octet_generator_t -ida_bytes.octet_generator_t.__init__ (method) - __init__(self, _ea) -> octet_generator_t - - @param _ea: ea_t +ida_bytes.octet_generator_t.__init__(self, _ea: ida_idaapi.ea_t) -ida_bytes.octet_generator_t.invert_byte_order (method) - invert_byte_order(self) +ida_bytes.octet_generator_t.invert_byte_order(self) -> None -ida_bytes.off_flag (function) - off_flag() -> flags64_t +ida_bytes.off_flag() -> "flags64_t" see FF_opbits -ida_bytes.op_adds_xrefs (function) - op_adds_xrefs(F, n) -> bool - Should processor module create xrefs from the operand?. Currently 'offset' and - 'structure offset' operands create xrefs - - @param F: (C++: flags64_t) - @param n: (C++: int) +ida_bytes.op_adds_xrefs(F: "flags64_t", n: int) -> bool + Should processor module create xrefs from the operand?. Currently 'offset' and 'structure offset' operands create xrefs + -ida_bytes.op_based_stroff (function) - op_based_stroff(insn, n, opval, base) -> bool - Set operand representation to be 'struct offset' if the operand likely points to - a structure member. For example, let's there is a structure at 1000 1000 - stru_1000 Elf32_Sym <...> the operand #8 will be represented as - '#Elf32_Sym.st_size' after the call of 'op_based_stroff(..., 8, 0x1000)' By the - way, after the call of 'op_plain_offset(..., 0x1000)' it will be represented as - '#(stru_1000.st_size - 0x1000)' - - @param insn: (C++: const insn_t &) the instruction - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @param opval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr) - @param base: (C++: ea_t) base reference - @return: success +ida_bytes.op_based_stroff(insn: "insn_t const &", n: int, opval: "adiff_t", base: ida_idaapi.ea_t) -> bool + Set operand representation to be 'struct offset' if the operand likely points to a structure member. For example, let's there is a structure at 1000 1000 stru_1000 Elf32_Sym <...> the operand #8 will be represented as '#Elf32_Sym.st_size' after the call of 'op_based_stroff(..., 8, 0x1000)' By the way, after the call of 'op_plain_offset(..., 0x1000)' it will be represented as '#(stru_1000.st_size - 0x1000)' + + @param insn: the instruction + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands + @param opval: operand value (usually op_t::value or op_t::addr) + @param base: base reference + @returns success -ida_bytes.op_bin (function) - op_bin(ea, n) -> bool +ida_bytes.op_bin(ea: ida_idaapi.ea_t, n: int) -> bool set op type to bin_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.op_chr (function) - op_chr(ea, n) -> bool +ida_bytes.op_chr(ea: ida_idaapi.ea_t, n: int) -> bool set op type to char_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.op_custfmt (function) - op_custfmt(ea, n, fid) -> bool +ida_bytes.op_custfmt(ea: ida_idaapi.ea_t, n: int, fid: int) -> bool Set custom data format for operand (fid-custom data format id) - - @param ea: (C++: ea_t) - @param n: (C++: int) - @param fid: (C++: int) -ida_bytes.op_dec (function) - op_dec(ea, n) -> bool +ida_bytes.op_dec(ea: ida_idaapi.ea_t, n: int) -> bool set op type to dec_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.op_enum (function) - op_enum(ea, n, id, serial=0) -> bool - Set operand representation to be 'enum_t'. If applied to unexplored bytes, - converts them to 16/32bit word data - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @param id: (C++: enum_t) id of enum - @param serial: (C++: uchar) the serial number of the constant in the enumeration, usually 0. - the serial numbers are used if the enumeration contains several - constants with the same value - @return: success +ida_bytes.op_enum(ea: ida_idaapi.ea_t, n: int, id: "tid_t", serial: "uchar" = 0) -> bool + Set operand representation to be enum type If applied to unexplored bytes, converts them to 16/32bit word data + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands + @param id: id of enum + @param serial: the serial number of the constant in the enumeration, usually 0. the serial numbers are used if the enumeration contains several constants with the same value + @returns success -ida_bytes.op_flt (function) - op_flt(ea, n) -> bool +ida_bytes.op_flt(ea: ida_idaapi.ea_t, n: int) -> bool set op type to flt_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.op_hex (function) - op_hex(ea, n) -> bool +ida_bytes.op_hex(ea: ida_idaapi.ea_t, n: int) -> bool set op type to hex_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.op_num (function) - op_num(ea, n) -> bool +ida_bytes.op_num(ea: ida_idaapi.ea_t, n: int) -> bool set op type to num_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.op_oct (function) - op_oct(ea, n) -> bool +ida_bytes.op_oct(ea: ida_idaapi.ea_t, n: int) -> bool set op type to oct_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.op_seg (function) - op_seg(ea, n) -> bool - Set operand representation to be 'segment'. If applied to unexplored bytes, - converts them to 16/32bit word data - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @return: success +ida_bytes.op_seg(ea: ida_idaapi.ea_t, n: int) -> bool + Set operand representation to be 'segment'. If applied to unexplored bytes, converts them to 16/32bit word data + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands + @returns success -ida_bytes.op_stkvar (function) - op_stkvar(ea, n) -> bool - Set operand representation to be 'stack variable'. Should be applied to an - instruction within a function. Should be applied after creating a stack var - using insn_t::create_stkvar(). - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @return: success +ida_bytes.op_stkvar(ea: ida_idaapi.ea_t, n: int) -> bool + Set operand representation to be 'stack variable'. Should be applied to an instruction within a function. Should be applied after creating a stack var using insn_t::create_stkvar(). + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands + @returns success -ida_bytes.op_stroff (function) - op_stroff(insn, n, path, path_len, delta) -> bool +ida_bytes.op_stroff(*args) -> bool Set operand representation to be 'struct offset'. - @param insn: (C++: const insn_t &) the instruction - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @param path: (C++: const tid_t *) structure path (strpath). see nalt.hpp for more info. - @param path_len: (C++: int) length of the structure path - @param delta: (C++: adiff_t) struct offset delta. usually 0. denotes the difference between the - structure base and the pointer into the structure. - @return: success - op_stroff(insn, n, path, delta) -> bool + This function has the following signatures: - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param n: int - @param path: qvector< tid_t > const & - @param delta: adiff_t + 1. op_stroff(ins: ida_ua.insn_t, n: int, path: List[int], delta: int) + 2. op_stroff(ins: ida_ua.insn_t, n: int, path: ida_pro.tid_array, path_len: int, delta: int) (backward-compatibility only) + + Here is an example using this function: + + ins = ida_ua.insn_t() + if ida_ua.decode_insn(ins, some_address): + operand = 0 + path = [ida_typeinf.get_named_type_tid("my_stucture_t")] # a one-element path + ida_bytes.op_stroff(ins, operand, path, 0) -ida_bytes.oword_flag (function) - oword_flag() -> flags64_t +ida_bytes.oword_flag() -> "flags64_t" Get a flags64_t representing a octaword. -ida_bytes.packreal_flag (function) - packreal_flag() -> flags64_t +ida_bytes.packreal_flag() -> "flags64_t" Get a flags64_t representing a packed decimal real. -ida_bytes.parse_binpat_str (function) - parse_binpat_str(out, ea, _in, radix, strlits_encoding=0) -> str - Convert user-specified binary string to internal representation. The 'in' - parameter contains space-separated tokens: - - numbers (numeric base is determined by 'radix') - - if value of number fits a byte, it is considered as a byte - - if value of number fits a word, it is considered as 2 bytes - - if value of number fits a dword,it is considered as 4 bytes - - "..." string constants - - 'x' single-character constants - - ? variable bytes +ida_bytes.parse_binpat_str(out: "compiled_binpat_vec_t", ea: ida_idaapi.ea_t, _in: str, radix: int, strlits_encoding: int = 0) -> bool + Convert user-specified binary string to internal representation. The 'in' parameter contains space-separated tokens: + numbers (numeric base is determined by 'radix') + - if value of number fits a byte, it is considered as a byte + - if value of number fits a word, it is considered as 2 bytes + - if value of number fits a dword,it is considered as 4 bytes + "..." string constants + 'x' single-character constants + ? variable bytes + Note that string constants are surrounded with double quotes. + Here are a few examples (assuming base 16): + 21 - bytes 0xCD, 0x21 + - bytes 0xCD, 0x21 (little endian ) or 0x21, 0xCD (big-endian) + 0 - the null terminated string "Hello" + - 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0 + ? ? ? ? 90 - byte 0xB8, 4 bytes with any value, byte 0x90 - Here are a few examples (assuming base 16): - CD 21 - bytes 0xCD, 0x21 - 21CD - bytes 0xCD, 0x21 (little endian ) or 0x21, 0xCD (big-endian) - "Hello", 0 - the null terminated string "Hello" - L"Hello" - 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0 - B8 ? ? ? ? 90 - byte 0xB8, 4 bytes with any value, byte 0x90 - @param out: (C++: compiled_binpat_vec_t *) a vector of compiled binary patterns, for use with bin_search2() - @param ea: (C++: ea_t) linear address to convert for (the conversion depends on the address, - because the number of bits in a byte depend on the segment type) - @param in: (C++: const char *) input text string - @param radix: (C++: int) numeric base of numbers (8,10,16) - @param strlits_encoding: (C++: int) the target encoding into which the string literals - present in 'in', should be encoded. Can be any from [1, - get_encoding_qty()), or the special values PBSENC_* - @return: false either in case of parsing error, or if at least one requested - target encoding couldn't encode the string literals present in "in". + + @param out: a vector of compiled binary patterns, for use with bin_search() + @param ea: linear address to convert for (the conversion depends on the address, because the number of bits in a byte depend on the segment type) + @param radix: numeric base of numbers (8,10,16) + @param strlits_encoding: the target encoding into which the string literals present in 'in', should be encoded. Can be any from [1, get_encoding_qty()), or the special values PBSENC_* + @returns false either in case of parsing error, or if at least one requested target encoding couldn't encode the string literals present in "in". -ida_bytes.patch_byte (function) - patch_byte(ea, x) -> bool - Patch a byte of the program. The original value of the byte is saved and can be - obtained by get_original_byte(). This function works for wide byte processors - too. +ida_bytes.patch_byte(ea: ida_idaapi.ea_t, x: "uint64") -> bool + Patch a byte of the program. The original value of the byte is saved and can be obtained by get_original_byte(). This function works for wide byte processors too. + @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) + @retval false: the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. -ida_bytes.patch_bytes (function) - patch_bytes(ea, buf) - Patch the specified number of bytes of the program. Original values of bytes are - saved and are available with get_original...() functions. See also put_bytes(). - - @param ea: (C++: ea_t) linear address - @param buf: (C++: const void *) buffer with new values of bytes +ida_bytes.patch_bytes(ea: ida_idaapi.ea_t, buf: "void const *") -> None + Patch the specified number of bytes of the program. Original values of bytes are saved and are available with get_original...() functions. See also put_bytes(). + + @param ea: linear address + @param buf: buffer with new values of bytes -ida_bytes.patch_dword (function) - patch_dword(ea, x) -> bool - Patch a dword of the program. The original value of the dword is saved and can - be obtained by get_original_dword(). This function DOESN'T work for wide byte - processors. This function takes into account order of bytes specified in - idainfo::is_be() +ida_bytes.patch_dword(ea: ida_idaapi.ea_t, x: "uint64") -> bool + Patch a dword of the program. The original value of the dword is saved and can be obtained by get_original_dword(). This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in idainfo::is_be() + @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) + @retval false: the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. -ida_bytes.patch_qword (function) - patch_qword(ea, x) -> bool - Patch a qword of the program. The original value of the qword is saved and can - be obtained by get_original_qword(). This function DOESN'T work for wide byte - processors. This function takes into account order of bytes specified in - idainfo::is_be() +ida_bytes.patch_qword(ea: ida_idaapi.ea_t, x: "uint64") -> bool + Patch a qword of the program. The original value of the qword is saved and can be obtained by get_original_qword(). This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in idainfo::is_be() + @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) + @retval false: the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. -ida_bytes.patch_word (function) - patch_word(ea, x) -> bool - Patch a word of the program. The original value of the word is saved and can be - obtained by get_original_word(). This function works for wide byte processors - too. This function takes into account order of bytes specified in - idainfo::is_be() +ida_bytes.patch_word(ea: ida_idaapi.ea_t, x: "uint64") -> bool + Patch a word of the program. The original value of the word is saved and can be obtained by get_original_word(). This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be() + @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) + @retval false: the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. -ida_bytes.prev_addr (function) - prev_addr(ea) -> ea_t - Get previous address in the program. - - @param ea: (C++: ea_t) - @return: BADADDR if no such address exist. +ida_bytes.prev_addr(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get previous address in the program. + + @returns BADADDR if no such address exist. -ida_bytes.prev_chunk (function) - prev_chunk(ea) -> ea_t - Get the last address of previous contiguous chunk in the program. - - @param ea: (C++: ea_t) - @return: BADADDR if previous chunk doesn't exist. +ida_bytes.prev_chunk(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get the last address of previous contiguous chunk in the program. + + @returns BADADDR if previous chunk doesn't exist. -ida_bytes.prev_head (function) - prev_head(ea, minea) -> ea_t - Get start of previous defined item. - - @param ea: (C++: ea_t) begin search at this address - @param minea: (C++: ea_t) included in the search range - @return: BADADDR if none exists. +ida_bytes.prev_head(ea: ida_idaapi.ea_t, minea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get start of previous defined item. + + @param ea: begin search at this address + @param minea: included in the search range + @returns BADADDR if none exists. -ida_bytes.prev_inited (function) - prev_inited(ea, minea) -> ea_t +ida_bytes.prev_inited(ea: ida_idaapi.ea_t, minea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Find the previous initialized address. - - @param ea: (C++: ea_t) - @param minea: (C++: ea_t) -ida_bytes.prev_not_tail (function) - prev_not_tail(ea) -> ea_t - Get address of previous non-tail byte. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. +ida_bytes.prev_not_tail(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get address of previous non-tail byte. + + @returns BADADDR if none exists. -ida_bytes.prev_that (function) - prev_that(ea, minea, testf) -> ea_t - Find previous address with a flag satisfying the function 'testf'. - @note: do not pass is_unknown() to this function to find unexplored bytes It - will fail under the debugger. To find unexplored bytes, use - prev_unknown(). - - @param ea: (C++: ea_t) start searching from this address - 1. - @param minea: (C++: ea_t) included in the search range. - @param testf: (C++: testf_t *) test function to find previous address - @return: the found address or BADADDR. +ida_bytes.prev_that(ea: ida_idaapi.ea_t, minea: ida_idaapi.ea_t, testf: "testf_t *") -> ida_idaapi.ea_t + Find previous address with a flag satisfying the function 'testf'. + + @param ea: start searching from this address - 1. + @param minea: included in the search range. + @param testf: test function to find previous address + @returns the found address or BADADDR. -ida_bytes.prev_unknown (function) - prev_unknown(ea, minea) -> ea_t +ida_bytes.prev_unknown(ea: ida_idaapi.ea_t, minea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Similar to prev_that(), but will find the previous address that is unexplored. - - @param ea: (C++: ea_t) - @param minea: (C++: ea_t) -ida_bytes.prev_visea (function) - prev_visea(ea) -> ea_t - Get previous visible address. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. +ida_bytes.prev_visea(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get previous visible address. + + @returns BADADDR if none exists. -ida_bytes.print_strlit_type (function) - print_strlit_type(strtype, flags=0) -> (str, str) - Get string type information: the string type name (possibly decorated with - hotkey markers), and the tooltip. +ida_bytes.print_strlit_type(strtype: int, flags: int = 0) -> "PyObject *" + Get string type information: the string type name (possibly decorated with hotkey markers), and the tooltip. - @param strtype: (C++: int32) the string type - @param flags: (C++: int) or'ed PSTF_* constants - @return: length of generated text + @param strtype: the string type + @param flags: or'ed PSTF_* constants + @returns length of generated text -ida_bytes.put_byte (function) - put_byte(ea, x) -> bool - Set value of one byte of the program. This function modifies the database. If - the debugger is active then the debugged process memory is patched too. - @note: The original value of the byte is completely lost and can't be recovered - by the get_original_byte() function. See also put_dbg_byte() to write to - the process memory directly when the debugger is active. This function - can handle wide byte processors. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint64) byte value - @return: true if the database has been modified +ida_bytes.put_byte(ea: ida_idaapi.ea_t, x: "uint64") -> bool + Set value of one byte of the program. This function modifies the database. If the debugger is active then the debugged process memory is patched too. + + @param ea: linear address + @param x: byte value + @returns true if the database has been modified -ida_bytes.put_bytes (function) - put_bytes(ea, buf) - Modify the specified number of bytes of the program. This function does not save - the original values of bytes. See also patch_bytes(). - - @param ea: (C++: ea_t) linear address - @param buf: (C++: const void *) buffer with new values of bytes +ida_bytes.put_bytes(ea: ida_idaapi.ea_t, buf: "void const *") -> None + Modify the specified number of bytes of the program. This function does not save the original values of bytes. See also patch_bytes(). + + @param ea: linear address + @param buf: buffer with new values of bytes -ida_bytes.put_dword (function) - put_dword(ea, x) - Set value of one dword of the program. This function takes into account order of - bytes specified in idainfo::is_be() This function works for wide byte processors - too. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint64) dword value - @note: the original value of the dword is completely lost and can't be recovered - by the get_original_dword() function. +ida_bytes.put_dword(ea: ida_idaapi.ea_t, x: "uint64") -> None + Set value of one dword of the program. This function takes into account order of bytes specified in idainfo::is_be() This function works for wide byte processors too. + + @param ea: linear address + @param x: dword value -ida_bytes.put_qword (function) - put_qword(ea, x) - Set value of one qword (8 bytes) of the program. This function takes into - account order of bytes specified in idainfo::is_be() This function DOESN'T works - for wide byte processors. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint64) qword value +ida_bytes.put_qword(ea: ida_idaapi.ea_t, x: "uint64") -> None + Set value of one qword (8 bytes) of the program. This function takes into account order of bytes specified in idainfo::is_be() This function DOESN'T works for wide byte processors. + + @param ea: linear address + @param x: qword value -ida_bytes.put_word (function) - put_word(ea, x) - Set value of one word of the program. This function takes into account order of - bytes specified in idainfo::is_be() This function works for wide byte processors - too. - @note: The original value of the word is completely lost and can't be recovered - by the get_original_word() function. ea - linear address x - word value - - @param ea: (C++: ea_t) - @param x: (C++: uint64) +ida_bytes.put_word(ea: ida_idaapi.ea_t, x: "uint64") -> None + Set value of one word of the program. This function takes into account order of bytes specified in idainfo::is_be() This function works for wide byte processors too. + -ida_bytes.qword_flag (function) - qword_flag() -> flags64_t +ida_bytes.qword_flag() -> "flags64_t" Get a flags64_t representing a quad word. -ida_bytes.register_custom_data_format (function) - register_custom_data_format(py_df) -> int +ida_bytes.register_custom_data_format(df) Registers a custom data format with a given data type. - @param py_df: an instance of data_format_t - @return: < 0 if failed to register + @param df: an instance of data_format_t + @return: + < 0 if failed to register > 0 data format id -ida_bytes.register_custom_data_type (function) - register_custom_data_type(py_dt) -> int +ida_bytes.register_custom_data_type(dt) Registers a custom data type. - @param py_dt: an instance of the data_type_t class - @return: < 0 if failed to register + @param dt: an instance of the data_type_t class + @return: + < 0 if failed to register > 0 data type id -ida_bytes.register_data_types_and_formats (function) +ida_bytes.register_data_types_and_formats(formats) Registers multiple data types and formats at once. To register one type/format at a time use register_custom_data_type/register_custom_data_format @@ -18062,182 +12156,141 @@ ida_bytes.register_data_types_and_formats (function) assert many_formats[2][0] != -1 assert many_formats[3][0] == -1 -ida_bytes.register_data_types_and_formats.__reg_format (function) +ida_bytes.register_data_types_and_formats.__reg_format(df, dtid) -ida_bytes.register_data_types_and_formats.__reg_type (function) +ida_bytes.register_data_types_and_formats.__reg_type(dt) -ida_bytes.revert_byte (function) - revert_byte(ea) -> bool - Revert patched byte +ida_bytes.revert_byte(ea: ida_idaapi.ea_t) -> bool + Revert patched byte + @retval true: byte was patched before and reverted now - - @param ea: (C++: ea_t) -ida_bytes.seg_flag (function) - seg_flag() -> flags64_t +ida_bytes.seg_flag() -> "flags64_t" see FF_opbits -ida_bytes.set_cmt (function) - set_cmt(ea, comm, rptble) -> bool - Set an indented comment. - - @param ea: (C++: ea_t) linear address - @param comm: (C++: const char *) comment string +ida_bytes.set_cmt(ea: ida_idaapi.ea_t, comm: str, rptble: bool) -> bool + Set an indented comment. + + @param ea: linear address + @param comm: comment string * nullptr: do nothing (return 0) * "" : delete comment - @param rptble: (C++: bool) is repeatable? - @return: success + @param rptble: is repeatable? + @returns success -ida_bytes.set_forced_operand (function) - set_forced_operand(ea, n, op) -> bool - Set forced operand. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number - @param op: (C++: const char *) text of operand +ida_bytes.set_forced_operand(ea: ida_idaapi.ea_t, n: int, op: str) -> bool + Set forced operand. + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number + @param op: text of operand * nullptr: do nothing (return 0) * "" : delete forced operand - @return: success + @returns success -ida_bytes.set_immd (function) - set_immd(ea) -> bool - Set 'has immediate operand' flag. Returns true if the FF_IMMD bit was not set - and now is set - - @param ea: (C++: ea_t) +ida_bytes.set_immd(ea: ida_idaapi.ea_t) -> bool + Set 'has immediate operand' flag. Returns true if the FF_IMMD bit was not set and now is set + -ida_bytes.set_lzero (function) - set_lzero(ea, n) -> bool - Set toggle lzero bit. This function changes the display of leading zeroes for - the specified operand. If the default is not to display leading zeroes, this - function will display them and vice versa. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success +ida_bytes.set_lzero(ea: ida_idaapi.ea_t, n: int) -> bool + Set toggle lzero bit. This function changes the display of leading zeroes for the specified operand. If the default is not to display leading zeroes, this function will display them and vice versa. + + @param ea: the item (insn/data) address + @param n: the operand number (0-first operand, 1-other operands) + @returns success -ida_bytes.set_manual_insn (function) - set_manual_insn(ea, manual_insn) - Set manual instruction string. - - @param ea: (C++: ea_t) linear address of the instruction or data item - @param manual_insn: (C++: const char *) "" - delete manual string. nullptr - do nothing +ida_bytes.set_manual_insn(ea: ida_idaapi.ea_t, manual_insn: str) -> None + Set manual instruction string. + + @param ea: linear address of the instruction or data item + @param manual_insn: "" - delete manual string. nullptr - do nothing -ida_bytes.set_op_type (function) - set_op_type(ea, type, n) -> bool - (internal function) change representation of operand(s). - - @param ea: (C++: ea_t) linear address - @param type: (C++: flags64_t) new flag value (should be obtained from char_flag(), num_flag() and - similar functions) - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands +ida_bytes.set_op_type(ea: ida_idaapi.ea_t, type: "flags64_t", n: int) -> bool + (internal function) change representation of operand(s). + + @param ea: linear address + @param type: new flag value (should be obtained from char_flag(), num_flag() and similar functions) + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands @retval 1: ok @retval 0: failed (applied to a tail byte) -ida_bytes.set_opinfo (function) - set_opinfo(ea, n, flag, ti, suppress_events=False) -> bool - Set additional information about an operand representation. This function is a - low level one. Only the kernel should use it. - - @param ea: (C++: ea_t) linear address of the item - @param n: (C++: int) number of operand, 0 or 1 (see the note below) - @param flag: (C++: flags64_t) flags of the item - @param ti: (C++: const opinfo_t *) additional representation information - @param suppress_events: (C++: bool) do not generate changing_op_type and op_type_changed - events - @return: success - @note: for custom formats (if is_custfmt(flag, n) is true) or for offsets (if - is_off(flag, n) is true) N can be in range 0..UA_MAXOP-1 or equal to - OPND_ALL. In the case of OPND_ALL the additional information about all - operands will be set. +ida_bytes.set_opinfo(ea: ida_idaapi.ea_t, n: int, flag: "flags64_t", ti: "opinfo_t", suppress_events: bool = False) -> bool + Set additional information about an operand representation. This function is a low level one. Only the kernel should use it. + + @param ea: linear address of the item + @param n: number of operand, 0 or 1 (see the note below) + @param flag: flags of the item + @param ti: additional representation information + @param suppress_events: do not generate changing_op_type and op_type_changed events + @returns success -ida_bytes.stkvar_flag (function) - stkvar_flag() -> flags64_t +ida_bytes.stkvar_flag() -> "flags64_t" see FF_opbits -ida_bytes.strlit_flag (function) - strlit_flag() -> flags64_t +ida_bytes.strlit_flag() -> "flags64_t" Get a flags64_t representing a string literal. -ida_bytes.stroff_flag (function) - stroff_flag() -> flags64_t +ida_bytes.stroff_flag() -> "flags64_t" see FF_opbits -ida_bytes.stru_flag (function) - stru_flag() -> flags64_t +ida_bytes.stru_flag() -> "flags64_t" Get a flags64_t representing a struct. -ida_bytes.tbyte_flag (function) - tbyte_flag() -> flags64_t +ida_bytes.tbyte_flag() -> "flags64_t" Get a flags64_t representing a tbyte. -ida_bytes.toggle_bnot (function) - toggle_bnot(ea, n) -> bool +ida_bytes.toggle_bnot(ea: ida_idaapi.ea_t, n: int) -> bool Toggle binary negation of operand. also see is_bnot() - - @param ea: (C++: ea_t) - @param n: (C++: int) -ida_bytes.toggle_lzero (function) - toggle_lzero(ea, n) -> bool - Toggle lzero bit. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success +ida_bytes.toggle_lzero(ea: ida_idaapi.ea_t, n: int) -> bool + Toggle lzero bit. + + @param ea: the item (insn/data) address + @param n: the operand number (0-first operand, 1-other operands) + @returns success -ida_bytes.toggle_sign (function) - toggle_sign(ea, n) -> bool - Toggle sign of n-th operand. allowed values of n: 0-first operand, 1-other - operands - - @param ea: (C++: ea_t) - @param n: (C++: int) +ida_bytes.toggle_sign(ea: ida_idaapi.ea_t, n: int) -> bool + Toggle sign of n-th operand. allowed values of n: 0-first operand, 1-other operands + -ida_bytes.unregister_custom_data_format (function) - unregister_custom_data_format(dfid) -> bool +ida_bytes.unregister_custom_data_format(dfid) Unregisters a custom data format @param dfid: data format id @return: Boolean -ida_bytes.unregister_custom_data_type (function) - unregister_custom_data_type(dtid) -> bool +ida_bytes.unregister_custom_data_type(dtid) Unregisters a custom data type. @param dtid: the data type id @return: Boolean -ida_bytes.unregister_data_types_and_formats (function) +ida_bytes.unregister_data_types_and_formats(formats) As opposed to register_data_types_and_formats(), this function unregisters multiple data types and formats at once. -ida_bytes.unregister_data_types_and_formats.__unreg_format (function) +ida_bytes.unregister_data_types_and_formats.__unreg_format(df, dtid) -ida_bytes.unregister_data_types_and_formats.__unreg_type (function) +ida_bytes.unregister_data_types_and_formats.__unreg_type(dt) -ida_bytes.update_hidden_range (function) - update_hidden_range(ha) -> bool - Update hidden range information in the database. You cannot use this function to - change the range boundaries - - @param ha: (C++: const hidden_range_t *) range to update - @return: success +ida_bytes.update_hidden_range(ha: "hidden_range_t") -> bool + Update hidden range information in the database. You cannot use this function to change the range boundaries + + @param ha: range to update + @returns success -ida_bytes.use_mapping (function) - use_mapping(ea) -> ea_t - Translate address according to current mappings. - - @param ea: (C++: ea_t) address to translate - @return: translated address +ida_bytes.use_mapping(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Translate address according to current mappings. + + @param ea: address to translate + @returns translated address -ida_bytes.visit_patched_bytes (function) - visit_patched_bytes(ea1, ea2, py_callable) -> int +ida_bytes.visit_patched_bytes(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, callable) Enumerates patched bytes in the given range and invokes a callable @param ea1: start address @param ea2: end address - @param py_callable: a Python callable with the following prototype: + @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 @@ -18245,1012 +12298,711 @@ ida_bytes.visit_patched_bytes (function) @return: Zero if the enumeration was successful or the return value of the callback if enumeration was interrupted. -ida_bytes.word_flag (function) - word_flag() -> flags64_t +ida_bytes.word_flag() -> "flags64_t" Get a flags64_t representing a word. -ida_bytes.yword_flag (function) - yword_flag() -> flags64_t +ida_bytes.yword_flag() -> "flags64_t" Get a flags64_t representing a ymm word. -ida_bytes.zword_flag (function) - zword_flag() -> flags64_t +ida_bytes.zword_flag() -> "flags64_t" Get a flags64_t representing a zmm word. -ida_dbg (module) +ida_dbg Contains functions to control the debugging of a process. See Debugger functions for a complete explanation of these functions. - - These functions are inlined for the kernel. They are not inlined for the user- - interfaces. + These functions are inlined for the kernel. They are not inlined for the user-interfaces. + -ida_dbg.BKPT_ACTIVE (variable) +ida_dbg.BKPT_ACTIVE active? -ida_dbg.BKPT_BADBPT (variable) +ida_dbg.BKPT_BADBPT failed to write the bpt to the process memory (at least one location) -ida_dbg.BKPT_CNDREADY (variable) +ida_dbg.BKPT_CNDREADY condition has been compiled -ida_dbg.BKPT_FAKEPEND (variable) - fake pending bpt: it is inactive but another bpt of the same type is active at - the same address(es) +ida_dbg.BKPT_FAKEPEND + fake pending bpt: it is inactive but another bpt of the same type is active at the same address(es) + -ida_dbg.BKPT_LISTBPT (variable) +ida_dbg.BKPT_LISTBPT include in bpt list (user-defined bpt) -ida_dbg.BKPT_PAGE (variable) - written to the process as a page bpt. Available only after writing the bpt to - the process. +ida_dbg.BKPT_PAGE + written to the process as a page bpt. Available only after writing the bpt to the process. + -ida_dbg.BKPT_PARTIAL (variable) +ida_dbg.BKPT_PARTIAL partially active? (some locations were not written yet) -ida_dbg.BKPT_TRACE (variable) +ida_dbg.BKPT_TRACE trace bpt; should not be deleted when the process gets suspended -ida_dbg.BPLT_ABS (variable) +ida_dbg.BPLT_ABS absolute address: ea -ida_dbg.BPLT_REL (variable) +ida_dbg.BPLT_REL relative address: module_path, offset -ida_dbg.BPLT_SRC (variable) +ida_dbg.BPLT_SRC source level: filename, lineno -ida_dbg.BPTCK_ACT (variable) +ida_dbg.BPLT_SYM + symbolic: symbol_name, offset + +ida_dbg.BPTCK_ACT breakpoint is active (written to the process) -ida_dbg.BPTCK_NO (variable) +ida_dbg.BPTCK_NO breakpoint is disabled -ida_dbg.BPTCK_NONE (variable) +ida_dbg.BPTCK_NONE breakpoint does not exist -ida_dbg.BPTCK_YES (variable) +ida_dbg.BPTCK_YES breakpoint is enabled -ida_dbg.BPTEV_ADDED (variable) +ida_dbg.BPTEV_ADDED Breakpoint has been added. -ida_dbg.BPTEV_CHANGED (variable) +ida_dbg.BPTEV_CHANGED Breakpoint has been modified. -ida_dbg.BPTEV_REMOVED (variable) +ida_dbg.BPTEV_REMOVED Breakpoint has been removed. -ida_dbg.BPT_BRK (variable) +ida_dbg.BPT_BRK suspend execution upon hit -ida_dbg.BPT_ELANG_SHIFT (variable) +ida_dbg.BPT_ELANG_SHIFT index of the extlang (scripting language) of the condition -ida_dbg.BPT_ENABLED (variable) +ida_dbg.BPT_ENABLED enabled? -ida_dbg.BPT_LOWCND (variable) +ida_dbg.BPT_LOWCND condition is calculated at low level (on the server side) -ida_dbg.BPT_TRACE (variable) +ida_dbg.BPT_TRACE add trace information upon hit -ida_dbg.BPT_TRACEON (variable) +ida_dbg.BPT_TRACEON enable tracing when the breakpoint is reached -ida_dbg.BPT_TRACE_BBLK (variable) +ida_dbg.BPT_TRACE_BBLK basic block tracing -ida_dbg.BPT_TRACE_FUNC (variable) +ida_dbg.BPT_TRACE_FUNC function tracing -ida_dbg.BPT_TRACE_INSN (variable) +ida_dbg.BPT_TRACE_INSN instruction tracing -ida_dbg.BPT_TRACE_TYPES (variable) - trace insns, functions, and basic blocks. if any of BPT_TRACE_TYPES bits are set - but BPT_TRACEON is clear, then turn off tracing for the specified trace types +ida_dbg.BPT_TRACE_TYPES + trace insns, functions, and basic blocks. if any of BPT_TRACE_TYPES bits are set but BPT_TRACEON is clear, then turn off tracing for the specified trace types + -ida_dbg.BPT_UPDMEM (variable) +ida_dbg.BPT_UPDMEM refresh the memory layout and contents before evaluating bpt condition -ida_dbg.BT_LOG_INSTS (variable) +ida_dbg.BT_LOG_INSTS specific options for basic block tracing (see set_bblk_trace_options()) - log all instructions in the current basic block + log all instructions in the current basic block + -ida_dbg.DBGINV_ALL (variable) +ida_dbg.DBGINV_ALL invalidate everything -ida_dbg.DBGINV_MEMCFG (variable) +ida_dbg.DBGINV_MEMCFG invalidate cached process segmentation -ida_dbg.DBGINV_MEMORY (variable) +ida_dbg.DBGINV_MEMORY invalidate cached memory contents -ida_dbg.DBGINV_NONE (variable) +ida_dbg.DBGINV_NONE invalidate nothing -ida_dbg.DBGINV_REDRAW (variable) +ida_dbg.DBGINV_REDRAW refresh the screen -ida_dbg.DBGINV_REGS (variable) +ida_dbg.DBGINV_REGS invalidate cached register values -ida_dbg.DBG_Hooks (class) - Proxy of C++ DBG_Hooks class. +ida_dbg.DBG_Hooks -ida_dbg.DBG_Hooks.__disown__ (method) +ida_dbg.DBG_Hooks.__disown__(self) -ida_dbg.DBG_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> DBG_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 +ida_dbg.DBG_Hooks.__init__(self, _flags: int = 0, _hkcb_flags: int = 1) -ida_dbg.DBG_Hooks.dbg_bpt (method) - dbg_bpt(self, tid, bptea) -> int - A user defined breakpoint was reached. - +ida_dbg.DBG_Hooks.dbg_bpt(self, tid: "thid_t", bptea: ida_idaapi.ea_t) -> int + A user defined breakpoint was reached. + @param tid: (thid_t) @param bptea: (::ea_t) -ida_dbg.DBG_Hooks.dbg_bpt_changed (method) - dbg_bpt_changed(self, bptev_code, bpt) - Breakpoint has been changed. - +ida_dbg.DBG_Hooks.dbg_bpt_changed(self, bptev_code: int, bpt: "bpt_t") -> None + Breakpoint has been changed. + @param bptev_code: (int) Breakpoint modification events @param bpt: (bpt_t *) -ida_dbg.DBG_Hooks.dbg_exception (method) - dbg_exception(self, pid, tid, ea, exc_code, exc_can_cont, exc_ea, exc_info) -> int - - @param event: (const debug_event_t *) - @param warn: (int *) filled with: - * -1: display an exception warning dialog if the process is suspended. - * 0: never display an exception warning dialog. - * 1: always display an exception warning dialog. - @param ea: ea_t - @param exc_code: int - @param exc_can_cont: bool - @param exc_ea: ea_t - @param exc_info: char const * +ida_dbg.DBG_Hooks.dbg_exception(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, exc_code: int, exc_can_cont: bool, exc_ea: ida_idaapi.ea_t, exc_info: str) -> int -ida_dbg.DBG_Hooks.dbg_finished_loading_bpts (method) - dbg_finished_loading_bpts(self) +ida_dbg.DBG_Hooks.dbg_finished_loading_bpts(self) -> None Finished loading breakpoint info from idb. -ida_dbg.DBG_Hooks.dbg_information (method) - dbg_information(self, pid, tid, ea, info) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param info: char const * +ida_dbg.DBG_Hooks.dbg_information(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, info: str) -> None -ida_dbg.DBG_Hooks.dbg_library_load (method) - dbg_library_load(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param modinfo_name: char const * - @param modinfo_base: ea_t - @param modinfo_size: asize_t +ida_dbg.DBG_Hooks.dbg_library_load(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, modinfo_name: str, modinfo_base: ida_idaapi.ea_t, modinfo_size: "asize_t") -> None -ida_dbg.DBG_Hooks.dbg_library_unload (method) - dbg_library_unload(self, pid, tid, ea, info) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param info: char const * +ida_dbg.DBG_Hooks.dbg_library_unload(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, info: str) -> None -ida_dbg.DBG_Hooks.dbg_process_attach (method) - dbg_process_attach(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t - @param modinfo_name: char const * - @param modinfo_base: ea_t - @param modinfo_size: asize_t +ida_dbg.DBG_Hooks.dbg_process_attach(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, modinfo_name: str, modinfo_base: ida_idaapi.ea_t, modinfo_size: "asize_t") -> None -ida_dbg.DBG_Hooks.dbg_process_detach (method) - dbg_process_detach(self, pid, tid, ea) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t +ida_dbg.DBG_Hooks.dbg_process_detach(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t) -> None -ida_dbg.DBG_Hooks.dbg_process_exit (method) - dbg_process_exit(self, pid, tid, ea, exit_code) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t - @param exit_code: int +ida_dbg.DBG_Hooks.dbg_process_exit(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, exit_code: int) -> None -ida_dbg.DBG_Hooks.dbg_process_start (method) - dbg_process_start(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t - @param modinfo_name: char const * - @param modinfo_base: ea_t - @param modinfo_size: asize_t +ida_dbg.DBG_Hooks.dbg_process_start(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, modinfo_name: str, modinfo_base: ida_idaapi.ea_t, modinfo_size: "asize_t") -> None -ida_dbg.DBG_Hooks.dbg_request_error (method) - dbg_request_error(self, failed_command, failed_dbg_notification) - An error occurred during the processing of a request. - +ida_dbg.DBG_Hooks.dbg_request_error(self, failed_command: int, failed_dbg_notification: int) -> None + An error occurred during the processing of a request. + @param failed_command: (ui_notification_t) @param failed_dbg_notification: (dbg_notification_t) -ida_dbg.DBG_Hooks.dbg_run_to (method) - dbg_run_to(self, pid, tid, ea) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t +ida_dbg.DBG_Hooks.dbg_run_to(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t) -> None -ida_dbg.DBG_Hooks.dbg_started_loading_bpts (method) - dbg_started_loading_bpts(self) +ida_dbg.DBG_Hooks.dbg_started_loading_bpts(self) -> None Started loading breakpoint info from idb. -ida_dbg.DBG_Hooks.dbg_step_into (method) - dbg_step_into(self) +ida_dbg.DBG_Hooks.dbg_step_into(self) -> None -ida_dbg.DBG_Hooks.dbg_step_over (method) - dbg_step_over(self) +ida_dbg.DBG_Hooks.dbg_step_over(self) -> None -ida_dbg.DBG_Hooks.dbg_step_until_ret (method) - dbg_step_until_ret(self) +ida_dbg.DBG_Hooks.dbg_step_until_ret(self) -> None -ida_dbg.DBG_Hooks.dbg_suspend_process (method) - dbg_suspend_process(self) - The process is now suspended. +ida_dbg.DBG_Hooks.dbg_suspend_process(self) -> None + The process is now suspended. + -ida_dbg.DBG_Hooks.dbg_thread_exit (method) - dbg_thread_exit(self, pid, tid, ea, exit_code) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param exit_code: int +ida_dbg.DBG_Hooks.dbg_thread_exit(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t, exit_code: int) -> None -ida_dbg.DBG_Hooks.dbg_thread_start (method) - dbg_thread_start(self, pid, tid, ea) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t +ida_dbg.DBG_Hooks.dbg_thread_start(self, pid: "pid_t", tid: "thid_t", ea: ida_idaapi.ea_t) -> None -ida_dbg.DBG_Hooks.dbg_trace (method) - dbg_trace(self, tid, ip) -> int - A step occurred (one instruction was executed). This event notification is only - generated if step tracing is enabled. - +ida_dbg.DBG_Hooks.dbg_trace(self, tid: "thid_t", ip: ida_idaapi.ea_t) -> int + A step occurred (one instruction was executed). This event notification is only generated if step tracing is enabled. + @param tid: (thid_t) thread ID - @param ip: (::ea_t) current instruction pointer. usually points after the - executed instruction + @param ip: (::ea_t) current instruction pointer. usually points after the executed instruction @retval 1: do not log this trace event @retval 0: log it -ida_dbg.DBG_Hooks.hook (method) - hook(self) -> bool +ida_dbg.DBG_Hooks.hook(self) -> bool -ida_dbg.DBG_Hooks.unhook (method) - unhook(self) -> bool +ida_dbg.DBG_Hooks.unhook(self) -> bool -ida_dbg.DEC_ERROR (variable) +ida_dbg.DEC_ERROR error -ida_dbg.DEC_NOTASK (variable) +ida_dbg.DEC_NOTASK process does not exist -ida_dbg.DEC_TIMEOUT (variable) +ida_dbg.DEC_TIMEOUT timeout -ida_dbg.DOPT_BPT_MSGS (variable) +ida_dbg.DOPT_BPT_MSGS log breakpoints -ida_dbg.DOPT_DISABLE_ASLR (variable) +ida_dbg.DOPT_DISABLE_ASLR disable ASLR -ida_dbg.DOPT_END_BPT (variable) +ida_dbg.DOPT_END_BPT evaluate event condition on process end -ida_dbg.DOPT_ENTRY_BPT (variable) +ida_dbg.DOPT_ENTRY_BPT break on program entry point -ida_dbg.DOPT_EXCDLG (variable) +ida_dbg.DOPT_EXCDLG exception dialogs: -ida_dbg.DOPT_FAST_STEP (variable) +ida_dbg.DOPT_FAST_STEP prevent debugger memory refreshes when single-stepping -ida_dbg.DOPT_INFO_BPT (variable) +ida_dbg.DOPT_INFO_BPT break on debugging information -ida_dbg.DOPT_INFO_MSGS (variable) +ida_dbg.DOPT_INFO_MSGS log debugging info events -ida_dbg.DOPT_LIB_BPT (variable) +ida_dbg.DOPT_LIB_BPT break on library load/unload -ida_dbg.DOPT_LIB_MSGS (variable) +ida_dbg.DOPT_LIB_MSGS log library loads/unloads -ida_dbg.DOPT_LOAD_DINFO (variable) +ida_dbg.DOPT_LOAD_DINFO automatically load debug files (pdb) -ida_dbg.DOPT_REAL_MEMORY (variable) +ida_dbg.DOPT_REAL_MEMORY do not hide breakpoint instructions -ida_dbg.DOPT_REDO_STACK (variable) +ida_dbg.DOPT_REDO_STACK reconstruct the stack -ida_dbg.DOPT_SEGM_MSGS (variable) +ida_dbg.DOPT_SEGM_MSGS log debugger segments modifications -ida_dbg.DOPT_START_BPT (variable) +ida_dbg.DOPT_START_BPT break on process start -ida_dbg.DOPT_TEMP_HWBPT (variable) +ida_dbg.DOPT_TEMP_HWBPT when possible use hardware bpts for temp bpts -ida_dbg.DOPT_THREAD_BPT (variable) +ida_dbg.DOPT_THREAD_BPT break on thread start/exit -ida_dbg.DOPT_THREAD_MSGS (variable) +ida_dbg.DOPT_THREAD_MSGS log thread starts/exits -ida_dbg.DSTATE_NOTASK (variable) +ida_dbg.DSTATE_NOTASK no process is currently debugged -ida_dbg.DSTATE_RUN (variable) +ida_dbg.DSTATE_RUN process is running -ida_dbg.DSTATE_SUSP (variable) +ida_dbg.DSTATE_SUSP process is suspended and will not continue -ida_dbg.EXCDLG_ALWAYS (variable) +ida_dbg.EXCDLG_ALWAYS always display -ida_dbg.EXCDLG_NEVER (variable) +ida_dbg.EXCDLG_NEVER never display exception dialogs -ida_dbg.EXCDLG_UNKNOWN (variable) +ida_dbg.EXCDLG_UNKNOWN display for unknown exceptions -ida_dbg.FT_LOG_RET (variable) +ida_dbg.FT_LOG_RET specific options for function tracing (see set_func_trace_options()) - function tracing will log returning instructions + function tracing will log returning instructions + -ida_dbg.IT_LOG_SAME_IP (variable) +ida_dbg.IT_LOG_SAME_IP specific options for instruction tracing (see set_insn_trace_options()) - instruction tracing will log new instructions even when IP doesn't change + instruction tracing will log new instructions even when IP doesn't change + -ida_dbg.SRCIT_EXPR (variable) +ida_dbg.MOVBPT_BAD_TYPE + BPLT_ABS is not supported. + +ida_dbg.MOVBPT_DEST_BUSY + destination location is busy (we already have such a bpt) + +ida_dbg.MOVBPT_NOT_FOUND + source bpt not found + +ida_dbg.MOVBPT_OK + moved ok + +ida_dbg.SRCIT_EXPR an expression (a+b*c) -ida_dbg.SRCIT_FUNC (variable) +ida_dbg.SRCIT_FUNC function -ida_dbg.SRCIT_LOCVAR (variable) +ida_dbg.SRCIT_LOCVAR a stack, register, or register-relative local variable or parameter -ida_dbg.SRCIT_MODULE (variable) +ida_dbg.SRCIT_MODULE module -ida_dbg.SRCIT_NONE (variable) +ida_dbg.SRCIT_NONE unknown -ida_dbg.SRCIT_STMT (variable) +ida_dbg.SRCIT_STMT a statement (if/while/for...) -ida_dbg.SRCIT_STTVAR (variable) +ida_dbg.SRCIT_STTVAR static variable/code -ida_dbg.ST_ALREADY_LOGGED (variable) +ida_dbg.ST_ALREADY_LOGGED step tracing will be disabled when IP is already logged -ida_dbg.ST_OPTIONS_MASK (variable) +ida_dbg.ST_DIFFERENTIAL + tracing: log only new instructions (not previously logged) + + +ida_dbg.ST_OPTIONS_MASK mask of available options, to ensure compatibility with newer IDA versions -ida_dbg.ST_OVER_DEBUG_SEG (variable) +ida_dbg.ST_OVER_DEBUG_SEG step tracing will be disabled when IP is in a debugger segment -ida_dbg.ST_OVER_LIB_FUNC (variable) +ida_dbg.ST_OVER_LIB_FUNC step tracing will be disabled when IP is in a library function -ida_dbg.ST_SKIP_LOOPS (variable) +ida_dbg.ST_SKIP_LOOPS step tracing will try to skip loops already recorded -ida_dbg.WFNE_ANY (variable) +ida_dbg.WFNE_ANY return the first event (even if it doesn't suspend the process) -ida_dbg.WFNE_CONT (variable) +ida_dbg.WFNE_CONT continue from the suspended state -ida_dbg.WFNE_NOWAIT (variable) - do not wait for any event, immediately return DEC_TIMEOUT (to be used with - WFNE_CONT) +ida_dbg.WFNE_NOWAIT + do not wait for any event, immediately return DEC_TIMEOUT (to be used with WFNE_CONT) + -ida_dbg.WFNE_SILENT (variable) +ida_dbg.WFNE_SILENT 1: be silent, 0:display modal boxes if necessary -ida_dbg.WFNE_SUSP (variable) +ida_dbg.WFNE_SUSP wait until the process gets suspended -ida_dbg.WFNE_USEC (variable) - timeout is specified in microseconds (minimum non-zero timeout is 40000us) +ida_dbg.WFNE_USEC + timeout is specified in microseconds (minimum non-zero timeout is 40000us) + -ida_dbg.add_bpt (function) - add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool - Add a new breakpoint in the debugged process. \sq{Type, Synchronous function - - available as request, Notification, none (synchronous function)} +ida_dbg.add_bpt(*args) -> bool + This function has the following signatures: - @param bpt: (C++: const bpt_t &) Breakpoint to add. It describes the break condition, type, flags, - location (module relative, source breakpoint or absolute) and other - attributes. - @param size: asize_t - @param type: bpttype_t + 0. add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool + 1. add_bpt(bpt: const bpt_t &) -> bool - add_bpt(bpt) -> bool + # 0: add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool - @param bpt: bpt_t const & + Add a new breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + + + # 1: add_bpt(bpt: const bpt_t &) -> bool + + Add a new breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + -ida_dbg.add_path_mapping (function) - add_path_mapping(src, dst) - - @param src: char const * - @param dst: char const * +ida_dbg.add_path_mapping(src: str, dst: str) -> None -ida_dbg.add_virt_module (function) - add_virt_module(mod) -> bool - - @param mod: modinfo_t const * +ida_dbg.add_virt_module(mod: "modinfo_t") -> bool -ida_dbg.attach_process (function) - attach_process(pid=pid_t(-1), event_id=-1) -> int - Attach the debugger to a running process. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_process_attach} - @note: This function shouldn't be called as a request if NO_PROCESS is used. - - @param pid: (C++: pid_t) PID of the process to attach to. If NO_PROCESS, a dialog box will - interactively ask the user for the process to attach to. +ida_dbg.attach_process(*args) -> int + Attach the debugger to a running process. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_attach} + + @param pid: PID of the process to attach to. If NO_PROCESS, a dialog box will interactively ask the user for the process to attach to. + @param event_id: event to trigger upon attaching @retval -4: debugger was not inited @retval -3: the attaching is not supported @retval -2: impossible to find a compatible process - @retval -1: impossible to attach to the given process (process died, privilege - needed, not supported by the debugger plugin, ...) + @retval -1: impossible to attach to the given process (process died, privilege needed, not supported by the debugger plugin, ...) @retval 0: the user cancelled the attaching to the process @retval 1: the debugger properly attached to the process -ida_dbg.bpt_location_t (class) - Proxy of C++ bpt_location_t class. +ida_dbg.bpt_location_t -ida_dbg.bpt_location_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bpt_location_t const & +ida_dbg.bpt_location_t.__eq__(self, r: "bpt_location_t") -> bool -ida_dbg.bpt_location_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bpt_location_t const & +ida_dbg.bpt_location_t.__ge__(self, r: "bpt_location_t") -> bool -ida_dbg.bpt_location_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bpt_location_t const & +ida_dbg.bpt_location_t.__gt__(self, r: "bpt_location_t") -> bool -ida_dbg.bpt_location_t.__init__ (method) - __init__(self) -> bpt_location_t +ida_dbg.bpt_location_t.__init__(self) -ida_dbg.bpt_location_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bpt_location_t const & +ida_dbg.bpt_location_t.__le__(self, r: "bpt_location_t") -> bool -ida_dbg.bpt_location_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bpt_location_t const & +ida_dbg.bpt_location_t.__lt__(self, r: "bpt_location_t") -> bool -ida_dbg.bpt_location_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bpt_location_t const & +ida_dbg.bpt_location_t.__ne__(self, r: "bpt_location_t") -> bool -ida_dbg.bpt_location_t.compare (method) - compare(self, r) -> int - Lexically compare two breakpoint locations. Bpt locations are first compared - based on type (i.e. BPLT_ABS < BPLT_REL). BPLT_ABS locations are compared based - on their ea values. For all other location types, locations are first compared - based on their string (path/filename/symbol), then their offset/lineno. - - @param r: (C++: const bpt_location_t &) bpt_location_t const & +ida_dbg.bpt_location_t.compare(self, r: "bpt_location_t") -> int + Lexically compare two breakpoint locations. Bpt locations are first compared based on type (i.e. BPLT_ABS < BPLT_REL). BPLT_ABS locations are compared based on their ea values. For all other location types, locations are first compared based on their string (path/filename/symbol), then their offset/lineno. + -ida_dbg.bpt_location_t.ea (method) - ea(self) -> ea_t +ida_dbg.bpt_location_t.ea(self) -> ida_idaapi.ea_t Get address (BPLT_ABS) -ida_dbg.bpt_location_t.is_empty_path (method) - is_empty_path(self) -> bool +ida_dbg.bpt_location_t.is_empty_path(self) -> bool No path/filename specified? (BPLT_REL, BPLT_SRC) -ida_dbg.bpt_location_t.lineno (method) - lineno(self) -> int +ida_dbg.bpt_location_t.lineno(self) -> int Get line number (BPLT_SRC) -ida_dbg.bpt_location_t.offset (method) - offset(self) -> uval_t +ida_dbg.bpt_location_t.offset(self) -> int Get offset (BPLT_REL, BPLT_SYM) -ida_dbg.bpt_location_t.path (method) - path(self) -> char const * +ida_dbg.bpt_location_t.path(self) -> str Get path/filename (BPLT_REL, BPLT_SRC) -ida_dbg.bpt_location_t.set_abs_bpt (method) - set_abs_bpt(self, a) +ida_dbg.bpt_location_t.set_abs_bpt(self, a: ida_idaapi.ea_t) -> None Specify an absolute address location. - - @param a: (C++: ea_t) -ida_dbg.bpt_location_t.set_rel_bpt (method) - set_rel_bpt(self, mod, _offset) +ida_dbg.bpt_location_t.set_rel_bpt(self, mod: str, _offset: int) -> None Specify a relative address location. - - @param mod: (C++: const char *) char const * - @param _offset: (C++: uval_t) -ida_dbg.bpt_location_t.set_src_bpt (method) - set_src_bpt(self, fn, _lineno) +ida_dbg.bpt_location_t.set_src_bpt(self, fn: str, _lineno: int) -> None Specify a source level location. - - @param fn: (C++: const char *) char const * - @param _lineno: (C++: int) -ida_dbg.bpt_location_t.set_sym_bpt (method) - set_sym_bpt(self, _symbol, _offset=0) +ida_dbg.bpt_location_t.set_sym_bpt(self, _symbol: str, _offset: int = 0) -> None Specify a symbolic location. - - @param _symbol: (C++: const char *) char const * - @param _offset: (C++: uval_t) -ida_dbg.bpt_location_t.symbol (method) - symbol(self) -> char const * +ida_dbg.bpt_location_t.symbol(self) -> str Get symbol name (BPLT_SYM) -ida_dbg.bpt_location_t.type (method) - type(self) -> bpt_loctype_t +ida_dbg.bpt_location_t.type(self) -> "bpt_loctype_t" Get bpt type. -ida_dbg.bpt_t (class) - Proxy of C++ bpt_t class. +ida_dbg.bpt_t -ida_dbg.bpt_t.__init__ (method) - __init__(self) -> bpt_t +ida_dbg.bpt_t.__init__(self) -ida_dbg.bpt_t.badbpt (method) - badbpt(self) -> bool +ida_dbg.bpt_t.badbpt(self) -> bool Failed to write bpt to process memory? -ida_dbg.bpt_t.bptid (variable) +ida_dbg.bpt_t.bptid Internal breakpoint id. -ida_dbg.bpt_t.cb (variable) +ida_dbg.bpt_t.cb size of this structure -ida_dbg.bpt_t.cndidx (variable) +ida_dbg.bpt_t.cndidx Internal number of the condition (<0-none) -ida_dbg.bpt_t.ea (variable) +ida_dbg.bpt_t.ea Address, if known. For BPLT_SRC, index into an internal data struct. -ida_dbg.bpt_t.enabled (method) - enabled(self) -> bool +ida_dbg.bpt_t.enabled(self) -> bool Is breakpoint enabled? -ida_dbg.bpt_t.flags (variable) - Breakpoint property bits +ida_dbg.bpt_t.flags + Breakpoint property bits + -ida_dbg.bpt_t.get_cnd_elang_idx (method) - get_cnd_elang_idx(self) -> size_t +ida_dbg.bpt_t.get_cnd_elang_idx(self) -> "size_t" -ida_dbg.bpt_t.get_size (method) - get_size(self) -> int +ida_dbg.bpt_t.get_size(self) -> int Get bpt size. -ida_dbg.bpt_t.is_absbpt (method) - is_absbpt(self) -> bool +ida_dbg.bpt_t.is_absbpt(self) -> bool Is absolute address breakpoint? -ida_dbg.bpt_t.is_active (method) - is_active(self) -> bool +ida_dbg.bpt_t.is_active(self) -> bool Written completely to process? -ida_dbg.bpt_t.is_compiled (method) - is_compiled(self) -> bool - Condition has been compiled? +ida_dbg.bpt_t.is_compiled(self) -> bool + Condition has been compiled? + -ida_dbg.bpt_t.is_hwbpt (method) - is_hwbpt(self) -> bool +ida_dbg.bpt_t.is_hwbpt(self) -> bool Is hardware breakpoint? -ida_dbg.bpt_t.is_inactive (method) - is_inactive(self) -> bool +ida_dbg.bpt_t.is_inactive(self) -> bool Not written to process at all? -ida_dbg.bpt_t.is_low_level (method) - is_low_level(self) -> bool +ida_dbg.bpt_t.is_low_level(self) -> bool Is bpt condition calculated at low level? -ida_dbg.bpt_t.is_page_bpt (method) - is_page_bpt(self) -> bool +ida_dbg.bpt_t.is_page_bpt(self) -> bool Page breakpoint? -ida_dbg.bpt_t.is_partially_active (method) - is_partially_active(self) -> bool +ida_dbg.bpt_t.is_partially_active(self) -> bool Written partially to process? -ida_dbg.bpt_t.is_relbpt (method) - is_relbpt(self) -> bool +ida_dbg.bpt_t.is_relbpt(self) -> bool Is relative address breakpoint? -ida_dbg.bpt_t.is_srcbpt (method) - is_srcbpt(self) -> bool +ida_dbg.bpt_t.is_srcbpt(self) -> bool Is source level breakpoint? -ida_dbg.bpt_t.is_symbpt (method) - is_symbpt(self) -> bool +ida_dbg.bpt_t.is_symbpt(self) -> bool Is symbolic breakpoint? -ida_dbg.bpt_t.is_tracemodebpt (method) - is_tracemodebpt(self) -> bool +ida_dbg.bpt_t.is_tracemodebpt(self) -> bool Does breakpoint trace anything? -ida_dbg.bpt_t.is_traceoffbpt (method) - is_traceoffbpt(self) -> bool +ida_dbg.bpt_t.is_traceoffbpt(self) -> bool Is this a tracing breakpoint, and is tracing disabled? -ida_dbg.bpt_t.is_traceonbpt (method) - is_traceonbpt(self) -> bool +ida_dbg.bpt_t.is_traceonbpt(self) -> bool Is this a tracing breakpoint, and is tracing enabled? -ida_dbg.bpt_t.listbpt (method) - listbpt(self) -> bool +ida_dbg.bpt_t.listbpt(self) -> bool Include in the bpt list? -ida_dbg.bpt_t.loc (variable) +ida_dbg.bpt_t.loc Location. -ida_dbg.bpt_t.pass_count (variable) - Number of times the breakpoint is hit before stopping (default is 0: stop - always) +ida_dbg.bpt_t.pass_count + Number of times the breakpoint is hit before stopping (default is 0: stop always) + -ida_dbg.bpt_t.pid (variable) +ida_dbg.bpt_t.pid breakpoint process id -ida_dbg.bpt_t.props (variable) - Internal breakpoint properties +ida_dbg.bpt_t.props + Internal breakpoint properties + -ida_dbg.bpt_t.set_abs_bpt (method) - set_abs_bpt(self, a) +ida_dbg.bpt_t.set_abs_bpt(self, a: ida_idaapi.ea_t) -> None Set bpt location to an absolute address. - - @param a: (C++: ea_t) -ida_dbg.bpt_t.set_rel_bpt (method) - set_rel_bpt(self, mod, o) +ida_dbg.bpt_t.set_rel_bpt(self, mod: str, o: int) -> None Set bpt location to a relative address. - - @param mod: (C++: const char *) char const * - @param o: (C++: uval_t) -ida_dbg.bpt_t.set_src_bpt (method) - set_src_bpt(self, fn, lineno) +ida_dbg.bpt_t.set_src_bpt(self, fn: str, lineno: int) -> None Set bpt location to a source line. - - @param fn: (C++: const char *) char const * - @param lineno: (C++: int) -ida_dbg.bpt_t.set_sym_bpt (method) - set_sym_bpt(self, sym, o) +ida_dbg.bpt_t.set_sym_bpt(self, sym: str, o: int) -> None Set bpt location to a symbol. - - @param sym: (C++: const char *) char const * - @param o: (C++: uval_t) -ida_dbg.bpt_t.set_trace_action (method) - set_trace_action(self, enable, trace_types) -> bool +ida_dbg.bpt_t.set_trace_action(self, enable: bool, trace_types: int) -> bool Configure tracing options. - - @param enable: (C++: bool) - @param trace_types: (C++: int) -ida_dbg.bpt_t.size (variable) +ida_dbg.bpt_t.size Size of the breakpoint (0 for software breakpoints) -ida_dbg.bpt_t.tid (variable) +ida_dbg.bpt_t.tid breakpoint thread id -ida_dbg.bpt_t.type (variable) +ida_dbg.bpt_t.type Breakpoint type. -ida_dbg.bpt_vec_t (class) - Proxy of C++ qvector< bpt_t > class. +ida_dbg.bpt_vec_t -ida_dbg.bpt_vec_t.__getitem__ (method) - __getitem__(self, i) -> bpt_t - - @param i: size_t +ida_dbg.bpt_vec_t.__getitem__(self, i: "size_t") -> "bpt_t const &" -ida_dbg.bpt_vec_t.__init__ (method) - __init__(self) -> bpt_vec_t - __init__(self, x) -> bpt_vec_t - - @param x: qvector< bpt_t > const & +ida_dbg.bpt_vec_t.__init__(self, *args) -ida_dbg.bpt_vec_t.__len__ (method) - __len__(self) -> size_t +ida_dbg.bpt_vec_t.__len__(self) -> "size_t" -ida_dbg.bpt_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: bpt_t const & +ida_dbg.bpt_vec_t.__setitem__(self, i: "size_t", v: "bpt_t") -> None -ida_dbg.bpt_vec_t.at (method) - at(self, _idx) -> bpt_t - - @param _idx: size_t +ida_dbg.bpt_vec_t.append(self, x: "bpt_t") -> None -ida_dbg.bpt_vec_t.begin (method) - begin(self) -> bpt_t +ida_dbg.bpt_vec_t.at(self, _idx: "size_t") -> "bpt_t const &" -ida_dbg.bpt_vec_t.capacity (method) - capacity(self) -> size_t +ida_dbg.bpt_vec_t.begin(self, *args) -> "qvector< bpt_t >::const_iterator" -ida_dbg.bpt_vec_t.clear (method) - clear(self) +ida_dbg.bpt_vec_t.capacity(self) -> "size_t" -ida_dbg.bpt_vec_t.empty (method) - empty(self) -> bool +ida_dbg.bpt_vec_t.clear(self) -> None -ida_dbg.bpt_vec_t.end (method) - end(self) -> bpt_t +ida_dbg.bpt_vec_t.empty(self) -> bool -ida_dbg.bpt_vec_t.erase (method) - erase(self, it) -> bpt_t - - @param it: qvector< bpt_t >::iterator - - erase(self, first, last) -> bpt_t - - @param first: qvector< bpt_t >::iterator - @param last: qvector< bpt_t >::iterator +ida_dbg.bpt_vec_t.end(self, *args) -> "qvector< bpt_t >::const_iterator" -ida_dbg.bpt_vec_t.extract (method) - extract(self) -> bpt_t +ida_dbg.bpt_vec_t.erase(self, *args) -> "qvector< bpt_t >::iterator" -ida_dbg.bpt_vec_t.grow (method) - grow(self, x=bpt_t()) - - @param x: bpt_t const & +ida_dbg.bpt_vec_t.extend(self, x: "bpt_vec_t") -> None -ida_dbg.bpt_vec_t.inject (method) - inject(self, s, len) - - @param s: bpt_t * - @param len: size_t +ida_dbg.bpt_vec_t.extract(self) -> "bpt_t *" -ida_dbg.bpt_vec_t.insert (method) - insert(self, it, x) -> bpt_t - - @param it: qvector< bpt_t >::iterator - @param x: bpt_t const & +ida_dbg.bpt_vec_t.grow(self, *args) -> None -ida_dbg.bpt_vec_t.pop_back (method) - pop_back(self) +ida_dbg.bpt_vec_t.inject(self, s: "bpt_t", len: "size_t") -> None -ida_dbg.bpt_vec_t.push_back (method) - push_back(self, x) - - @param x: bpt_t const & - - push_back(self) -> bpt_t +ida_dbg.bpt_vec_t.insert(self, it: "bpt_t", x: "bpt_t") -> "qvector< bpt_t >::iterator" -ida_dbg.bpt_vec_t.qclear (method) - qclear(self) +ida_dbg.bpt_vec_t.pop_back(self) -> None -ida_dbg.bpt_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_dbg.bpt_vec_t.push_back(self, *args) -> "bpt_t &" -ida_dbg.bpt_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: bpt_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_dbg.bpt_vec_t.qclear(self) -> None -ida_dbg.bpt_vec_t.size (method) - size(self) -> size_t +ida_dbg.bpt_vec_t.reserve(self, cnt: "size_t") -> None -ida_dbg.bpt_vec_t.swap (method) - swap(self, r) - - @param r: qvector< bpt_t > & +ida_dbg.bpt_vec_t.resize(self, *args) -> None -ida_dbg.bpt_vec_t.truncate (method) - truncate(self) +ida_dbg.bpt_vec_t.size(self) -> "size_t" -ida_dbg.bptaddrs_t (class) - Proxy of C++ bptaddrs_t class. +ida_dbg.bpt_vec_t.swap(self, r: "bpt_vec_t") -> None -ida_dbg.bptaddrs_t.__init__ (method) - __init__(self) -> bptaddrs_t +ida_dbg.bpt_vec_t.truncate(self) -> None -ida_dbg.bring_debugger_to_front (function) - bring_debugger_to_front() +ida_dbg.bptaddrs_t -ida_dbg.check_bpt (function) - check_bpt(ea) -> int - Check the breakpoint at the specified address. - - @param ea: (C++: ea_t) - @return: one of Breakpoint status codes +ida_dbg.bptaddrs_t.__init__(self) -ida_dbg.choose_trace_file (function) - choose_trace_file() -> str +ida_dbg.bring_debugger_to_front() -> None + +ida_dbg.check_bpt(ea: ida_idaapi.ea_t) -> int + Check the breakpoint at the specified address. + + @returns one of Breakpoint status codes + +ida_dbg.choose_trace_file() -> str Show the choose trace dialog. -ida_dbg.clear_requests_queue (function) - clear_requests_queue() - Clear the queue of waiting requests. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - @note: If a request is currently running, this one isn't stopped. +ida_dbg.clear_requests_queue() -> None + Clear the queue of waiting requests. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.clear_trace (function) - clear_trace() - Clear all events in the trace buffer. \sq{Type, Synchronous function - available - as request, Notification, none (synchronous function)} +ida_dbg.clear_trace() -> None + Clear all events in the trace buffer. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + -ida_dbg.collect_stack_trace (function) - collect_stack_trace(tid, trace) -> bool - - @param tid: thid_t - @param trace: call_stack_t * +ida_dbg.collect_stack_trace(tid: "thid_t", trace: "call_stack_t") -> bool -ida_dbg.continue_process (function) - continue_process() -> bool - Continue the execution of the process in the debugger. \sq{Type, Synchronous - function - available as Request, Notification, none (synchronous function)} - @note: The continue_process() function can be called from a notification handler - to force the continuation of the process. In this case the request queue - will not be examined, IDA will simply resume execution. Usually it makes - sense to call request_continue_process() followed by run_requests(), so - that IDA will first start a queued request (if any) and then resume the - application. +ida_dbg.continue_backwards() -> bool + Continue the execution of the process in the debugger backwards. Can only be used with debuggers that support time-travel debugging. \sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)} + -ida_dbg.create_source_viewer (function) - create_source_viewer(out_ccv, parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t * +ida_dbg.continue_process() -> bool + Continue the execution of the process in the debugger. \sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)} + + +ida_dbg.create_source_viewer(out_ccv: "TWidget **", parent: "TWidget *", custview: "TWidget *", sf: "source_file_ptr", lines: "strvec_t *", lnnum: int, colnum: int, flags: int) -> "source_view_t *" Create a source code view. - - @param out_ccv: (C++: TWidget **) - @param parent: (C++: TWidget *) - @param custview: (C++: TWidget *) - @param sf: (C++: source_file_ptr) - @param lines: (C++: strvec_t *) - @param lnnum: (C++: int) - @param colnum: (C++: int) - @param flags: (C++: int) -ida_dbg.dbg_add_bpt_tev (function) - dbg_add_bpt_tev(tid, ea, bp) -> bool - Add a new breakpoint trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param ea: (C++: ea_t) - @param bp: (C++: ea_t) - @return: false if the operation failed, true otherwise +ida_dbg.dbg_add_bpt_tev(tid: "thid_t", ea: ida_idaapi.ea_t, bp: ida_idaapi.ea_t) -> bool + Add a new breakpoint trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns false if the operation failed, true otherwise -ida_dbg.dbg_add_call_tev (function) - dbg_add_call_tev(tid, caller, callee) - Add a new call trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param caller: (C++: ea_t) - @param callee: (C++: ea_t) +ida_dbg.dbg_add_call_tev(tid: "thid_t", caller: ida_idaapi.ea_t, callee: ida_idaapi.ea_t) -> None + Add a new call trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.dbg_add_debug_event (function) - dbg_add_debug_event(event) - Add a new debug event to the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param event: (C++: debug_event_t *) +ida_dbg.dbg_add_debug_event(event: "debug_event_t") -> None + Add a new debug event to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.dbg_add_insn_tev (function) - dbg_add_insn_tev(tid, ea, save=SAVE_DIFF) -> bool - Add a new instruction trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param ea: (C++: ea_t) - @param save: (C++: save_reg_values_t) enum save_reg_values_t - @return: false if the operation failed, true otherwise +ida_dbg.dbg_add_insn_tev(tid: "thid_t", ea: ida_idaapi.ea_t, save: "save_reg_values_t" = SAVE_DIFF) -> bool + Add a new instruction trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns false if the operation failed, true otherwise -ida_dbg.dbg_add_many_tevs (function) - dbg_add_many_tevs(new_tevs) -> bool - Add many new trace elements to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param new_tevs: (C++: tevinforeg_vec_t *) - @return: false if the operation failed for any tev_info_t object +ida_dbg.dbg_add_many_tevs(new_tevs: "tevinforeg_vec_t") -> bool + Add many new trace elements to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns false if the operation failed for any tev_info_t object -ida_dbg.dbg_add_ret_tev (function) - dbg_add_ret_tev(tid, ret_insn, return_to) - Add a new return trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param ret_insn: (C++: ea_t) - @param return_to: (C++: ea_t) +ida_dbg.dbg_add_ret_tev(tid: "thid_t", ret_insn: ida_idaapi.ea_t, return_to: ida_idaapi.ea_t) -> None + Add a new return trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.dbg_add_tev (function) - dbg_add_tev(type, tid, address) - Add a new trace element to the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param type: (C++: tev_type_t) enum tev_type_t - @param tid: (C++: thid_t) - @param address: (C++: ea_t) +ida_dbg.dbg_add_tev(type: "tev_type_t", tid: "thid_t", address: ida_idaapi.ea_t) -> None + Add a new trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.dbg_add_thread (function) - dbg_add_thread(tid) - Add a thread to the current trace. \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @param tid: (C++: thid_t) +ida_dbg.dbg_add_thread(tid: "thid_t") -> None + Add a thread to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.dbg_bin_search (function) - dbg_bin_search(start_ea, end_ea, data, srch_flags) -> str - - @param start_ea: ea_t - @param end_ea: ea_t - @param data: compiled_binpat_vec_t const & - @param srch_flags: int +ida_dbg.dbg_bin_search(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, data: "compiled_binpat_vec_t const &", srch_flags: int) -> str -ida_dbg.dbg_bpt (variable) - A user defined breakpoint was reached. +ida_dbg.dbg_bpt + A user defined breakpoint was reached. + -ida_dbg.dbg_bpt_changed (variable) - Breakpoint has been changed. +ida_dbg.dbg_bpt_changed + Breakpoint has been changed. + -ida_dbg.dbg_can_query (function) - dbg_can_query() -> bool +ida_dbg.dbg_can_query() This function can be used to check if the debugger can be queried: - debugger is loaded - process is suspended @@ -19260,1132 +13012,726 @@ ida_dbg.dbg_can_query (function) @return: Boolean -ida_dbg.dbg_del_thread (function) - dbg_del_thread(tid) - Delete a thread from the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param tid: (C++: thid_t) +ida_dbg.dbg_del_thread(tid: "thid_t") -> None + Delete a thread from the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.dbg_finished_loading_bpts (variable) +ida_dbg.dbg_finished_loading_bpts Finished loading breakpoint info from idb. -ida_dbg.dbg_is_loaded (function) - dbg_is_loaded() -> bool +ida_dbg.dbg_is_loaded() Checks if a debugger is loaded @return: Boolean -ida_dbg.dbg_last (variable) +ida_dbg.dbg_last The last debugger notification code. -ida_dbg.dbg_process_attach (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! +ida_dbg.dbg_request_error + An error occurred during the processing of a request. + -ida_dbg.dbg_process_detach (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - -ida_dbg.dbg_process_exit (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - -ida_dbg.dbg_process_start (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - -ida_dbg.dbg_request_error (variable) - An error occurred during the processing of a request. - -ida_dbg.dbg_started_loading_bpts (variable) +ida_dbg.dbg_started_loading_bpts Started loading breakpoint info from idb. -ida_dbg.dbg_suspend_process (variable) - The process is now suspended. - - @note: This event notification is also an asynchronous function result - notification for suspend_process() ! +ida_dbg.dbg_suspend_process + The process is now suspended. + -ida_dbg.dbg_trace (variable) - A step occurred (one instruction was executed). This event notification is only - generated if step tracing is enabled. - - @retval 1: do not log this trace event - @retval 0: log it +ida_dbg.dbg_trace + A step occurred (one instruction was executed). This event notification is only generated if step tracing is enabled. + -ida_dbg.define_exception (function) - define_exception(code, name, desc, flags) -> char const * - Convenience function: define new exception code. - - @param code: (C++: uint) exception code (cannot be 0) - @param name: (C++: const char *) exception name (cannot be empty or nullptr) - @param desc: (C++: const char *) exception description (maybe nullptr) - @param flags: (C++: int) combination of Exception info flags - @return: failure message or nullptr. You must call store_exceptions() if this - function succeeds +ida_dbg.define_exception(code: "uint", name: str, desc: str, flags: int) -> str + Convenience function: define new exception code. + + @param code: exception code (cannot be 0) + @param name: exception name (cannot be empty or nullptr) + @param desc: exception description (maybe nullptr) + @param flags: combination of Exception info flags + @returns failure message or nullptr. You must call store_exceptions() if this function succeeds -ida_dbg.del_bpt (function) - del_bpt(ea) -> bool - Delete an existing breakpoint in the debugged process. \sq{Type, Synchronous - function - available as request, Notification, none (synchronous function)} +ida_dbg.del_bpt(*args) -> bool + This function has the following signatures: - @param bptloc: (C++: const bpt_location_t &) Breakpoint location - del_bpt(bptloc) -> bool + 0. del_bpt(ea: ida_idaapi.ea_t) -> bool + 1. del_bpt(bptloc: const bpt_location_t &) -> bool - @param bptloc: bpt_location_t const & - -ida_dbg.del_bptgrp (function) - del_bptgrp(name) -> bool - Delete a folder, bpt that were part of this folder are moved to the root folder - \sq{Type, Synchronous function, Notification, none (synchronous function)} + # 0: del_bpt(ea: ida_idaapi.ea_t) -> bool - @param name: (C++: const char *) full path to the folder to be deleted - @return: success - -ida_dbg.del_virt_module (function) - del_virt_module(base) -> bool + Delete an existing breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + - @param base: ea_t const + # 1: del_bpt(bptloc: const bpt_location_t &) -> bool + + Delete an existing breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + -ida_dbg.detach_process (function) - detach_process() -> bool - Detach the debugger from the debugged process. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_process_detach} +ida_dbg.del_bptgrp(name: str) -> bool + Delete a folder, bpt that were part of this folder are moved to the root folder \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param name: full path to the folder to be deleted + @returns success -ida_dbg.diff_trace_file (function) - diff_trace_file(NONNULL_filename) -> bool +ida_dbg.del_virt_module(base: "ea_t const") -> bool + +ida_dbg.detach_process() -> bool + Detach the debugger from the debugged process. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_detach} + + +ida_dbg.diff_trace_file(NONNULL_filename: str) -> bool Show difference between the current trace and the one from 'filename'. - - @param NONNULL_filename: (C++: const char *) char const * -ida_dbg.disable_bblk_trace (function) - disable_bblk_trace() -> bool +ida_dbg.disable_bblk_trace() -> bool -ida_dbg.disable_bpt (function) - disable_bpt(ea) -> bool - - @param ea: ea_t - - disable_bpt(bptloc) -> bool - - @param bptloc: bpt_location_t const & +ida_dbg.disable_bpt(*args) -> bool -ida_dbg.disable_func_trace (function) - disable_func_trace() -> bool +ida_dbg.disable_func_trace() -> bool -ida_dbg.disable_insn_trace (function) - disable_insn_trace() -> bool +ida_dbg.disable_insn_trace() -> bool -ida_dbg.disable_step_trace (function) - disable_step_trace() -> bool +ida_dbg.disable_step_trace() -> bool -ida_dbg.edit_manual_regions (function) - edit_manual_regions() +ida_dbg.edit_manual_regions() -> None -ida_dbg.enable_bblk_trace (function) - enable_bblk_trace(enable=True) -> bool - - @param enable: bool +ida_dbg.enable_bblk_trace(enable: bool = True) -> bool -ida_dbg.enable_bpt (function) - enable_bpt(ea, enable=True) -> bool - - @param ea: ea_t - @param enable: bool - - enable_bpt(bptloc, enable=True) -> bool - - @param bptloc: bpt_location_t const & - @param enable: bool +ida_dbg.enable_bpt(*args) -> bool -ida_dbg.enable_bptgrp (function) - enable_bptgrp(bptgrp_name, enable=True) -> int - Enable (or disable) all bpts in a folder \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param bptgrp_name: (C++: const char *) absolute path to the folder - @param enable: (C++: bool) by default true, enable bpts, false disable bpts - @return: -1 an error occured 0 no changes >0 nubmers of bpts udpated +ida_dbg.enable_bptgrp(bptgrp_name: str, enable: bool = True) -> int + Enable (or disable) all bpts in a folder \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param bptgrp_name: absolute path to the folder + @param enable: by default true, enable bpts, false disable bpts + @retval -1: an error occured + @retval 0: no changes + @retval >0: nubmers of bpts udpated -ida_dbg.enable_func_trace (function) - enable_func_trace(enable=True) -> bool - - @param enable: bool +ida_dbg.enable_func_trace(enable: bool = True) -> bool -ida_dbg.enable_insn_trace (function) - enable_insn_trace(enable=True) -> bool - - @param enable: bool +ida_dbg.enable_insn_trace(enable: bool = True) -> bool -ida_dbg.enable_manual_regions (function) - enable_manual_regions(enable) - - @param enable: bool +ida_dbg.enable_manual_regions(enable: bool) -> None -ida_dbg.enable_step_trace (function) - enable_step_trace(enable=1) -> bool - - @param enable: int +ida_dbg.enable_step_trace(enable: int = 1) -> bool -ida_dbg.eval_ctx_t (class) - Proxy of C++ eval_ctx_t class. +ida_dbg.eval_ctx_t -ida_dbg.eval_ctx_t.__init__ (method) - __init__(self, _ea) -> eval_ctx_t - - @param _ea: ea_t +ida_dbg.eval_ctx_t.__init__(self, _ea: ida_idaapi.ea_t) -ida_dbg.exist_bpt (function) - exist_bpt(ea) -> bool +ida_dbg.exist_bpt(ea: ida_idaapi.ea_t) -> bool Does a breakpoint exist at the given location? - - @param ea: (C++: ea_t) -ida_dbg.exit_process (function) - exit_process() -> bool - Terminate the debugging of the current process. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_process_exit} +ida_dbg.exit_process() -> bool + Terminate the debugging of the current process. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_exit} + -ida_dbg.find_bpt (function) - find_bpt(bptloc, bpt) -> bool - Find a breakpoint by location. \sq{Type, Synchronous function - available as - request, Notification, none (synchronous function)} - - @param bptloc: (C++: const bpt_location_t &) Breakpoint location - @param bpt: (C++: bpt_t *) bpt is filled if the breakpoint was found +ida_dbg.find_bpt(bptloc: "bpt_location_t", bpt: "bpt_t") -> bool + Find a breakpoint by location. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + + @param bptloc: Breakpoint location + @param bpt: bpt is filled if the breakpoint was found -ida_dbg.get_bblk_trace_options (function) - get_bblk_trace_options() -> int - Get current basic block tracing options. Also see BT_LOG_INSTS \sq{Type, - Synchronous function, Notification, none (synchronous function)} +ida_dbg.get_bblk_trace_options() -> int + Get current basic block tracing options. Also see BT_LOG_INSTS \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_bpt (function) - get_bpt(ea, bpt) -> bool - Get the characteristics of a breakpoint. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param ea: (C++: ea_t) any address in the breakpoint range - @param bpt: (C++: bpt_t *) if not nullptr, is filled with the characteristics. - @return: false if no breakpoint exists +ida_dbg.get_bpt(ea: ida_idaapi.ea_t, bpt: "bpt_t") -> bool + Get the characteristics of a breakpoint. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param ea: any address in the breakpoint range + @param bpt: if not nullptr, is filled with the characteristics. + @returns false if no breakpoint exists -ida_dbg.get_bpt_group (function) - get_bpt_group(bptloc) -> str - Retrieve the absolute path to the folder of the bpt based on the bpt_location - find_bpt is called to retrieve the bpt \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param bptloc: (C++: const bpt_location_t &) bptlocation of the bpt - @return: breakpoint correclty moved to the directory - success +ida_dbg.get_bpt_group(bptloc: "bpt_location_t") -> str + Retrieve the absolute path to the folder of the bpt based on the bpt_location find_bpt is called to retrieve the bpt \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param bptloc: bptlocation of the bpt + @returns success + @retval true: breakpoint correclty moved to the directory -ida_dbg.get_bpt_qty (function) - get_bpt_qty() -> int - Get number of breakpoints. \sq{Type, Synchronous function, Notification, none - (synchronous function)} +ida_dbg.get_bpt_qty() -> int + Get number of breakpoints. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_bpt_tev_ea (function) - get_bpt_tev_ea(n) -> ea_t - Get the address associated to a read, read/write or execution trace event. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @return: BADADDR if not a read, read/write or execution trace event. - @note: Usually, a breakpoint is associated with a read, read/write or execution - trace event. However, the returned address could be any address in the - range of this breakpoint. If the breakpoint was deleted after the trace - event, the address no longer corresponds to a valid breakpoint. +ida_dbg.get_bpt_tev_ea(n: int) -> ida_idaapi.ea_t + Get the address associated to a read, read/write or execution trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @returns BADADDR if not a read, read/write or execution trace event. -ida_dbg.get_bptloc_string (function) - get_bptloc_string(i) -> char const * - - @param i: int +ida_dbg.get_bptloc_string(i: int) -> str -ida_dbg.get_call_tev_callee (function) - get_call_tev_callee(n) -> ea_t - Get the called function from a function call trace event. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @return: BADADDR if not a function call event. +ida_dbg.get_call_tev_callee(n: int) -> ida_idaapi.ea_t + Get the called function from a function call trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @returns BADADDR if not a function call event. -ida_dbg.get_current_source_file (function) - get_current_source_file() -> str +ida_dbg.get_current_source_file() -> str -ida_dbg.get_current_source_line (function) - get_current_source_line() -> int +ida_dbg.get_current_source_line() -> int -ida_dbg.get_current_thread (function) - get_current_thread() -> thid_t - Get current thread ID. \sq{Type, Synchronous function, Notification, none - (synchronous function)} +ida_dbg.get_current_thread() -> "thid_t" + Get current thread ID. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_dbg_byte (function) - get_dbg_byte(ea) -> bool - Get one byte of the debugged process memory. - - @param ea: (C++: ea_t) linear address - @return: true success - false address inaccessible or debugger not running +ida_dbg.get_dbg_byte(ea: ida_idaapi.ea_t) -> "uint32 *" + Get one byte of the debugged process memory. + + @param ea: linear address + @returns success + @retval true: success + @retval false: address inaccessible or debugger not running -ida_dbg.get_dbg_memory_info (function) - get_dbg_memory_info(ranges) -> int - - @param ranges: meminfo_vec_t * +ida_dbg.get_dbg_memory_info(ranges: "meminfo_vec_t") -> int -ida_dbg.get_dbg_reg_info (function) - get_dbg_reg_info(regname, ri) -> bool - Get register information \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param regname: (C++: const char *) char const * - @param ri: (C++: register_info_t *) +ida_dbg.get_dbg_reg_info(regname: str, ri: "register_info_t") -> bool + Get register information \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_debug_event (function) - get_debug_event() -> debug_event_t +ida_dbg.get_debug_event() -> "debug_event_t const *" Get the current debugger event. -ida_dbg.get_debugger_event_cond (function) - get_debugger_event_cond() -> char const * +ida_dbg.get_debugger_event_cond() -> str -ida_dbg.get_first_module (function) - get_first_module(modinfo) -> bool - - @param modinfo: modinfo_t * +ida_dbg.get_first_module(modinfo: "modinfo_t") -> bool -ida_dbg.get_func_trace_options (function) - get_func_trace_options() -> int - Get current function tracing options. Also see FT_LOG_RET \sq{Type, Synchronous - function, Notification, none (synchronous function)} +ida_dbg.get_func_trace_options() -> int + Get current function tracing options. Also see FT_LOG_RET \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_global_var (function) - get_global_var(prov, ea, name, out) -> bool - - @param prov: srcinfo_provider_t * - @param ea: ea_t - @param name: char const * - @param out: source_item_ptr * +ida_dbg.get_global_var(prov: "srcinfo_provider_t *", ea: ida_idaapi.ea_t, name: str, out: "source_item_ptr *") -> bool -ida_dbg.get_grp_bpts (function) - get_grp_bpts(bpts, grp_name) -> ssize_t - Retrieve a copy the bpts stored in a folder \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param bpts: (C++: bpt_vec_t *) : pointer to a vector where the copy of bpts are stored - @param grp_name: (C++: const char *) absolute path to the folder - @return: number of bpts present in the vector +ida_dbg.get_grp_bpts(bpts: "bpt_vec_t", grp_name: str) -> "ssize_t" + Retrieve a copy the bpts stored in a folder \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param bpts: : pointer to a vector where the copy of bpts are stored + @param grp_name: absolute path to the folder + @returns number of bpts present in the vector -ida_dbg.get_insn_tev_reg_mem (function) - get_insn_tev_reg_mem(n, memmap) -> bool - Read the memory pointed by register values from an instruction trace event. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param memmap: (C++: memreg_infos_t *) result - @return: false if not an instruction event or no memory is available +ida_dbg.get_insn_tev_reg_mem(n: int, memmap: "memreg_infos_t") -> bool + Read the memory pointed by register values from an instruction trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @param memmap: result + @returns false if not an instruction event or no memory is available -ida_dbg.get_insn_tev_reg_result (function) - get_insn_tev_reg_result(n, regname, regval) -> bool - - @param n: int - @param regname: char const * - @param regval: regval_t * +ida_dbg.get_insn_tev_reg_result(n: int, regname: str, regval: "regval_t") -> bool + Read the resulting register value from an instruction trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @param regname: name of desired register + @param regval: result + @returns false if not an instruction trace event or register wasn't modified. -ida_dbg.get_insn_tev_reg_val (function) - get_insn_tev_reg_val(n, regname, regval) -> bool - - @param n: int - @param regname: char const * - @param regval: regval_t * +ida_dbg.get_insn_tev_reg_val(n: int, regname: str, regval: "regval_t") -> bool + Read a register value from an instruction trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @param regname: name of desired register + @param regval: result + @returns false if not an instruction event. -ida_dbg.get_insn_trace_options (function) - get_insn_trace_options() -> int - Get current instruction tracing options. Also see IT_LOG_SAME_IP \sq{Type, - Synchronous function, Notification, none (synchronous function)} +ida_dbg.get_insn_trace_options() -> int + Get current instruction tracing options. Also see IT_LOG_SAME_IP \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_ip_val (function) - get_ip_val() -> bool - Get value of the IP (program counter) register for the current thread. Requires - a suspended debugger. +ida_dbg.get_ip_val() -> "uint64 *" + Get value of the IP (program counter) register for the current thread. Requires a suspended debugger. + -ida_dbg.get_local_var (function) - get_local_var(prov, ea, name, out) -> bool - - @param prov: srcinfo_provider_t * - @param ea: ea_t - @param name: char const * - @param out: source_item_ptr * +ida_dbg.get_local_var(prov: "srcinfo_provider_t *", ea: ida_idaapi.ea_t, name: str, out: "source_item_ptr *") -> bool -ida_dbg.get_local_vars (function) - get_local_vars(prov, ea, out) -> bool - - @param prov: srcinfo_provider_t * - @param ea: ea_t - @param out: source_items_t * +ida_dbg.get_local_vars(prov: "srcinfo_provider_t *", ea: ida_idaapi.ea_t, out: "source_items_t *") -> bool -ida_dbg.get_manual_regions (function) - get_manual_regions(ranges) +ida_dbg.get_manual_regions(*args) Returns the manual memory regions - @param ranges: meminfo_vec_t * + This function has the following signatures: - @return: list(start_ea, end_ea, name, sclass, sbase, bitness, perm) - get_manual_regions() -> [(int, int, str, str, int, int, int), ...] or None + 1. get_manual_regions() -> List[Tuple(ida_idaapi.ea_t, ida_idaapi.ea_t, str, str, ida_idaapi.ea_t, int, int)] + Where each tuple holds (start_ea, end_ea, name, sclass, sbase, bitness, perm) + 2. get_manual_regions(storage: meminfo_vec_t) -> None -ida_dbg.get_module_info (function) - get_module_info(ea, modinfo) -> bool - - @param ea: ea_t - @param modinfo: modinfo_t * +ida_dbg.get_module_info(ea: ida_idaapi.ea_t, modinfo: "modinfo_t") -> bool -ida_dbg.get_next_module (function) - get_next_module(modinfo) -> bool - - @param modinfo: modinfo_t * +ida_dbg.get_next_module(modinfo: "modinfo_t") -> bool -ida_dbg.get_process_options (function) - get_process_options() - Get process options. Any of the arguments may be nullptr +ida_dbg.get_process_options() -> "qstring *, qstring *, qstring *, qstring *, qstring *, int *" + Get process options. Any of the arguments may be nullptr + -ida_dbg.get_process_state (function) - get_process_state() -> int - Return the state of the currently debugged process. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @return: one of Debugged process states +ida_dbg.get_process_options2() -> "qstring *, qstring *, launch_env_t *, qstring *, qstring *, qstring *, int *" -ida_dbg.get_processes (function) - get_processes(proclist) -> ssize_t - Take a snapshot of running processes and return their description. \sq{Type, - Synchronous function, Notification, none (synchronous function)} - - @param proclist: (C++: procinfo_vec_t *) array with information about each running process - @return: number of processes or -1 on error +ida_dbg.get_process_state() -> int + Return the state of the currently debugged process. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns one of Debugged process states -ida_dbg.get_reg_val (function) - get_reg_val(regname, regval) -> bool - Get register value as an unsigned 64-bit int. - - @param regname: (C++: const char *) char const * - @param regval: regval_t * - - get_reg_val(regname, ival) -> bool - - @param regname: char const * - @param ival: uint64 * - - get_reg_val(regname) -> bool, float, int - - @param regname: char const * +ida_dbg.get_processes(proclist: "procinfo_vec_t") -> "ssize_t" + Take a snapshot of running processes and return their description. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param proclist: array with information about each running process + @returns number of processes or -1 on error -ida_dbg.get_reg_vals (function) - get_reg_vals(tid, clsmask=-1) -> regvals_t +ida_dbg.get_reg_val(*args) + Get a register value. + + This function has the following signatures: + + 1. get_reg_val(name: str) -> Union[int, float, bytes] + 2. get_reg_val(name: str, regval: regval_t) -> bool + + The first (and most user-friendly) form will return + a value whose type is related to the register type. + I.e., either an integer, a float or, in the case of large + vector registers, a bytes sequence. + + @param name the register name + @return the register value (1st form) + +ida_dbg.get_reg_vals(tid: int, clsmask: int = -1) -> "ida_idd.regvals_t" Fetch live registers values for the thread - @param tid: The ID of the thread to read registers for - @param clsmask: An OR'ed mask of register classes to + @param tid The ID of the thread to read registers for + @param clsmask An OR'ed mask of register classes to read values for (can be used to speed up the retrieval process) - @return: a regvals_t instance (empty if an error occurs) + @return: a list of register values (empty if an error occurs) -ida_dbg.get_ret_tev_return (function) - get_ret_tev_return(n) -> ea_t - Get the return address from a function return trace event. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @return: BADADDR if not a function return event. +ida_dbg.get_ret_tev_return(n: int) -> ida_idaapi.ea_t + Get the return address from a function return trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @returns BADADDR if not a function return event. -ida_dbg.get_running_notification (function) - get_running_notification() -> dbg_notification_t - Get the notification associated (if any) with the current running request. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @return: dbg_null if no running request +ida_dbg.get_running_notification() -> "dbg_notification_t" + Get the notification associated (if any) with the current running request. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns dbg_null if no running request -ida_dbg.get_running_request (function) - get_running_request() -> ui_notification_t - Get the current running request. \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @return: ui_null if no running request +ida_dbg.get_running_request() -> "ui_notification_t" + Get the current running request. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns ui_null if no running request -ida_dbg.get_sp_val (function) - get_sp_val() -> bool - Get value of the SP register for the current thread. Requires a suspended - debugger. +ida_dbg.get_sp_val() -> "uint64 *" + Get value of the SP register for the current thread. Requires a suspended debugger. + -ida_dbg.get_srcinfo_provider (function) - get_srcinfo_provider(name) -> srcinfo_provider_t * - - @param name: char const * +ida_dbg.get_srcinfo_provider(name: str) -> "srcinfo_provider_t *" -ida_dbg.get_step_trace_options (function) - get_step_trace_options() -> int - Get current step tracing options. \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @return: Step trace options +ida_dbg.get_step_trace_options() -> int + Get current step tracing options. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns Step trace options -ida_dbg.get_tev_ea (function) - get_tev_ea(n) -> ea_t - - @param n: int +ida_dbg.get_tev_ea(n: int) -> ida_idaapi.ea_t -ida_dbg.get_tev_event (function) - get_tev_event(n, d) -> bool - Get the corresponding debug event, if any, for the specified tev object. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param d: (C++: debug_event_t *) result - @return: false if the tev_t object doesn't have any associated debug event, true - otherwise, with the debug event in "d". +ida_dbg.get_tev_event(n: int, d: "debug_event_t") -> bool + Get the corresponding debug event, if any, for the specified tev object. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @param d: result + @returns false if the tev_t object doesn't have any associated debug event, true otherwise, with the debug event in "d". -ida_dbg.get_tev_info (function) - get_tev_info(n, tev_info) -> bool - Get main information about a trace event. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param tev_info: (C++: tev_info_t *) result - @return: success +ida_dbg.get_tev_info(n: int, tev_info: "tev_info_t") -> bool + Get main information about a trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @param tev_info: result + @returns success -ida_dbg.get_tev_memory_info (function) - get_tev_memory_info(n, mi) -> bool - Get the memory layout, if any, for the specified tev object. \sq{Type, - Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param mi: (C++: meminfo_vec_t *) result - @return: false if the tev_t object is not of type tev_mem, true otherwise, with - the new memory layout in "mi". +ida_dbg.get_tev_memory_info(n: int, mi: "meminfo_vec_t") -> bool + Get the memory layout, if any, for the specified tev object. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. + @param mi: result + @returns false if the tev_t object is not of type tev_mem, true otherwise, with the new memory layout in "mi". -ida_dbg.get_tev_qty (function) - get_tev_qty() -> int - Get number of trace events available in trace buffer. \sq{Type, Synchronous - function, Notification, none (synchronous function)} +ida_dbg.get_tev_qty() -> int + Get number of trace events available in trace buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_tev_reg_mem (function) +ida_dbg.get_tev_reg_mem(tev, idx) -ida_dbg.get_tev_reg_mem_ea (function) +ida_dbg.get_tev_reg_mem_ea(tev, idx) -ida_dbg.get_tev_reg_mem_qty (function) +ida_dbg.get_tev_reg_mem_qty(tev) -ida_dbg.get_tev_reg_val (function) +ida_dbg.get_tev_reg_val(tev, reg) -ida_dbg.get_tev_tid (function) - get_tev_tid(n) -> int - - @param n: int +ida_dbg.get_tev_tid(n: int) -> int -ida_dbg.get_tev_type (function) - get_tev_type(n) -> int - - @param n: int +ida_dbg.get_tev_type(n: int) -> int -ida_dbg.get_thread_qty (function) - get_thread_qty() -> int - Get number of threads. \sq{Type, Synchronous function, Notification, none - (synchronous function)} +ida_dbg.get_thread_qty() -> int + Get number of threads. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.get_trace_base_address (function) - get_trace_base_address() -> ea_t - Get the base address of the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @return: the base address of the currently loaded trace +ida_dbg.get_trace_base_address() -> ida_idaapi.ea_t + Get the base address of the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns the base address of the currently loaded trace -ida_dbg.get_trace_dynamic_register_set (function) - get_trace_dynamic_register_set(idaregs) +ida_dbg.get_trace_dynamic_register_set(idaregs: "dynamic_register_set_t *") -> None Get dynamic register set of current trace. - - @param idaregs: (C++: dynamic_register_set_t *) -ida_dbg.get_trace_file_desc (function) - get_trace_file_desc(filename) -> str +ida_dbg.get_trace_file_desc(filename: str) -> str Get the file header of the specified trace file. - - @param filename: (C++: const char *) char const * -ida_dbg.get_trace_platform (function) - get_trace_platform() -> char const * +ida_dbg.get_trace_platform() -> str Get platform name of current trace. -ida_dbg.getn_bpt (function) - getn_bpt(n, bpt) -> bool - Get the characteristics of a breakpoint. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param n: (C++: int) number of breakpoint, is in range 0..get_bpt_qty()-1 - @param bpt: (C++: bpt_t *) filled with the characteristics. - @return: false if no breakpoint exists +ida_dbg.getn_bpt(n: int, bpt: "bpt_t") -> bool + Get the characteristics of a breakpoint. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of breakpoint, is in range 0..get_bpt_qty()-1 + @param bpt: filled with the characteristics. + @returns false if no breakpoint exists -ida_dbg.getn_thread (function) - getn_thread(n) -> thid_t - Get the ID of a thread. \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param n: (C++: int) number of thread, is in range 0..get_thread_qty()-1 - @return: NO_THREAD if the thread doesn't exist. +ida_dbg.getn_thread(n: int) -> "thid_t" + Get the ID of a thread. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of thread, is in range 0..get_thread_qty()-1 + @returns NO_THREAD if the thread doesn't exist. -ida_dbg.getn_thread_name (function) - getn_thread_name(n) -> char const * - Get the NAME of a thread \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param n: (C++: int) number of thread, is in range 0..get_thread_qty()-1 or -1 for the - current thread - @return: thread name or nullptr if the thread doesn't exist. +ida_dbg.getn_thread_name(n: int) -> str + Get the NAME of a thread \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param n: number of thread, is in range 0..get_thread_qty()-1 or -1 for the current thread + @returns thread name or nullptr if the thread doesn't exist. -ida_dbg.graph_trace (function) - graph_trace() -> bool +ida_dbg.graph_trace() -> bool Show the trace callgraph. -ida_dbg.handle_debug_event (function) - handle_debug_event(ev, rqflags) -> int - - @param ev: debug_event_t const * - @param rqflags: int +ida_dbg.handle_debug_event(ev: "debug_event_t", rqflags: int) -> int -ida_dbg.hide_all_bpts (function) - hide_all_bpts() -> int +ida_dbg.hide_all_bpts() -> int -ida_dbg.internal_get_sreg_base (function) - internal_get_sreg_base(tid, sreg_value) -> ea_t +ida_dbg.internal_get_sreg_base(tid: int, sreg_value: int) Get the sreg base, for the given thread. - @param tid: thid_t - @param sreg_value: int + @param tid: the thread ID + @param sreg_value: the sreg value @return: The sreg base, or BADADDR on failure. -ida_dbg.internal_ioctl (function) - internal_ioctl(fn, buf, poutbuf, poutsize) -> int - - @param fn: int - @param buf: void const * - @param poutbuf: void ** - @param poutsize: ssize_t * +ida_dbg.internal_ioctl(fn: int, buf: "void const *", poutbuf: "void **", poutsize: "ssize_t *") -> int -ida_dbg.invalidate_dbg_state (function) - invalidate_dbg_state(dbginv) -> int - Invalidate cached debugger information. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param dbginv: (C++: int) Debugged process invalidation options - @return: current debugger state (one of Debugged process states) +ida_dbg.invalidate_dbg_state(dbginv: int) -> int + Invalidate cached debugger information. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param dbginv: Debugged process invalidation options + @returns current debugger state (one of Debugged process states) -ida_dbg.invalidate_dbgmem_config (function) - invalidate_dbgmem_config() - Invalidate the debugged process memory configuration. Call this function if the - debugged process might have changed its memory layout (allocated more memory, - for example) +ida_dbg.invalidate_dbgmem_config() -> None + Invalidate the debugged process memory configuration. Call this function if the debugged process might have changed its memory layout (allocated more memory, for example) + -ida_dbg.invalidate_dbgmem_contents (function) - invalidate_dbgmem_contents(ea, size) - Invalidate the debugged process memory contents. Call this function each time - the process has been stopped or the process memory is modified. If ea == - BADADDR, then the whole memory contents will be invalidated - - @param ea: (C++: ea_t) - @param size: (C++: asize_t) +ida_dbg.invalidate_dbgmem_contents(ea: ida_idaapi.ea_t, size: "asize_t") -> None + Invalidate the debugged process memory contents. Call this function each time the process has been stopped or the process memory is modified. If ea == BADADDR, then the whole memory contents will be invalidated + -ida_dbg.is_bblk_trace_enabled (function) - is_bblk_trace_enabled() -> bool +ida_dbg.is_bblk_trace_enabled() -> bool -ida_dbg.is_debugger_busy (function) - is_debugger_busy() -> bool - Is the debugger busy?. Some debuggers do not accept any commands while the - debugged application is running. For such a debugger, it is unsafe to do - anything with the database (even simple queries like get_byte may lead to - undesired consequences). Returns: true if the debugged application is running - under such a debugger +ida_dbg.is_debugger_busy() -> bool + Is the debugger busy?. Some debuggers do not accept any commands while the debugged application is running. For such a debugger, it is unsafe to do anything with the database (even simple queries like get_byte may lead to undesired consequences). Returns: true if the debugged application is running under such a debugger + -ida_dbg.is_debugger_memory (function) - is_debugger_memory(ea) -> bool +ida_dbg.is_debugger_memory(ea: ida_idaapi.ea_t) -> bool Is the address mapped to debugger memory? - - @param ea: (C++: ea_t) -ida_dbg.is_debugger_on (function) - is_debugger_on() -> bool +ida_dbg.is_debugger_on() -> bool Is the debugger currently running? -ida_dbg.is_func_trace_enabled (function) - is_func_trace_enabled() -> bool - Get current state of functions tracing. \sq{Type, Synchronous function, - Notification, none (synchronous function)} +ida_dbg.is_func_trace_enabled() -> bool + Get current state of functions tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.is_insn_trace_enabled (function) - is_insn_trace_enabled() -> bool - Get current state of instruction tracing. \sq{Type, Synchronous function, - Notification, none (synchronous function)} +ida_dbg.is_insn_trace_enabled() -> bool + Get current state of instruction tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.is_reg_custom (function) - is_reg_custom(regname) -> bool - Does a register contain a value of a custom data type? \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param regname: (C++: const char *) char const * +ida_dbg.is_reg_custom(regname: str) -> bool + Does a register contain a value of a custom data type? \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.is_reg_float (function) - is_reg_float(regname) -> bool - Does a register contain a floating point value? \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param regname: (C++: const char *) char const * +ida_dbg.is_reg_float(regname: str) -> bool + Does a register contain a floating point value? \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.is_reg_integer (function) - is_reg_integer(regname) -> bool - Does a register contain an integer value? \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param regname: (C++: const char *) char const * +ida_dbg.is_reg_integer(regname: str) -> bool + Does a register contain an integer value? \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.is_request_running (function) - is_request_running() -> bool +ida_dbg.is_request_running() -> bool Is a request currently running? -ida_dbg.is_step_trace_enabled (function) - is_step_trace_enabled() -> bool - Get current state of step tracing. \sq{Type, Synchronous function, Notification, - none (synchronous function)} +ida_dbg.is_step_trace_enabled() -> bool + Get current state of step tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.is_valid_dstate (function) - is_valid_dstate(state) -> bool - - @param state: int +ida_dbg.is_valid_dstate(state: int) -> bool -ida_dbg.is_valid_trace_file (function) - is_valid_trace_file(filename) -> bool +ida_dbg.is_valid_trace_file(filename: str) -> bool Is the specified file a valid trace file for the current database? - - @param filename: (C++: const char *) char const * -ida_dbg.list_bptgrps (function) - list_bptgrps(bptgrps) -> size_t - Retrieve the list of absolute path of all folders of bpt dirtree \sq{Type, - Synchronous function, Notification, none (synchronous function)} - - @param bptgrps: (C++: qstrvec_t *) list of absolute path in the bpt dirtree - @return: number of folders returned - list_bptgrps() -> [str, ...] +ida_dbg.list_bptgrps() -> List[str] + Retrieve the list of absolute path of all folders of bpt dirtree. + Synchronous function, Notification, none (synchronous function) -ida_dbg.load_debugger (function) - load_debugger(dbgname, use_remote) -> bool - - @param dbgname: char const * - @param use_remote: bool +ida_dbg.load_debugger(dbgname: str, use_remote: bool) -> bool -ida_dbg.load_trace_file (function) - load_trace_file(filename) -> str - Load a recorded trace file in the 'Tracing' window. If the call succeeds and - 'buf' is not null, the description of the trace stored in the binary trace file - will be returned in 'buf' - - @param filename: (C++: const char *) char const * +ida_dbg.load_trace_file(filename: str) -> str + Load a recorded trace file in the 'Tracing' window. If the call succeeds and 'buf' is not null, the description of the trace stored in the binary trace file will be returned in 'buf' + -ida_dbg.memreg_info_t (class) - Proxy of C++ memreg_info_t class. +ida_dbg.memreg_info_t -ida_dbg.memreg_info_t.__init__ (method) - __init__(self) -> memreg_info_t +ida_dbg.memreg_info_t.__init__(self) -ida_dbg.memreg_info_t.get_bytes (method) - get_bytes(self) -> PyObject * +ida_dbg.memreg_info_t.get_bytes(self) -> "PyObject *" -ida_dbg.memreg_infos_t (class) - Proxy of C++ qvector< memreg_info_t > class. +ida_dbg.memreg_infos_t -ida_dbg.memreg_infos_t.__getitem__ (method) - __getitem__(self, i) -> memreg_info_t - - @param i: size_t +ida_dbg.memreg_infos_t.__getitem__(self, i: "size_t") -> "memreg_info_t const &" -ida_dbg.memreg_infos_t.__init__ (method) - __init__(self) -> memreg_infos_t - __init__(self, x) -> memreg_infos_t - - @param x: qvector< memreg_info_t > const & +ida_dbg.memreg_infos_t.__init__(self, *args) -ida_dbg.memreg_infos_t.__len__ (method) - __len__(self) -> size_t +ida_dbg.memreg_infos_t.__len__(self) -> "size_t" -ida_dbg.memreg_infos_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: memreg_info_t const & +ida_dbg.memreg_infos_t.__setitem__(self, i: "size_t", v: "memreg_info_t") -> None -ida_dbg.memreg_infos_t.at (method) - at(self, _idx) -> memreg_info_t - - @param _idx: size_t +ida_dbg.memreg_infos_t.append(self, x: "memreg_info_t") -> None -ida_dbg.memreg_infos_t.begin (method) - begin(self) -> memreg_info_t +ida_dbg.memreg_infos_t.at(self, _idx: "size_t") -> "memreg_info_t const &" -ida_dbg.memreg_infos_t.capacity (method) - capacity(self) -> size_t +ida_dbg.memreg_infos_t.begin(self, *args) -> "qvector< memreg_info_t >::const_iterator" -ida_dbg.memreg_infos_t.clear (method) - clear(self) +ida_dbg.memreg_infos_t.capacity(self) -> "size_t" -ida_dbg.memreg_infos_t.empty (method) - empty(self) -> bool +ida_dbg.memreg_infos_t.clear(self) -> None -ida_dbg.memreg_infos_t.end (method) - end(self) -> memreg_info_t +ida_dbg.memreg_infos_t.empty(self) -> bool -ida_dbg.memreg_infos_t.erase (method) - erase(self, it) -> memreg_info_t - - @param it: qvector< memreg_info_t >::iterator - - erase(self, first, last) -> memreg_info_t - - @param first: qvector< memreg_info_t >::iterator - @param last: qvector< memreg_info_t >::iterator +ida_dbg.memreg_infos_t.end(self, *args) -> "qvector< memreg_info_t >::const_iterator" -ida_dbg.memreg_infos_t.extract (method) - extract(self) -> memreg_info_t +ida_dbg.memreg_infos_t.erase(self, *args) -> "qvector< memreg_info_t >::iterator" -ida_dbg.memreg_infos_t.grow (method) - grow(self, x=memreg_info_t()) - - @param x: memreg_info_t const & +ida_dbg.memreg_infos_t.extend(self, x: "memreg_infos_t") -> None -ida_dbg.memreg_infos_t.inject (method) - inject(self, s, len) - - @param s: memreg_info_t * - @param len: size_t +ida_dbg.memreg_infos_t.extract(self) -> "memreg_info_t *" -ida_dbg.memreg_infos_t.insert (method) - insert(self, it, x) -> memreg_info_t - - @param it: qvector< memreg_info_t >::iterator - @param x: memreg_info_t const & +ida_dbg.memreg_infos_t.grow(self, *args) -> None -ida_dbg.memreg_infos_t.pop_back (method) - pop_back(self) +ida_dbg.memreg_infos_t.inject(self, s: "memreg_info_t", len: "size_t") -> None -ida_dbg.memreg_infos_t.push_back (method) - push_back(self, x) - - @param x: memreg_info_t const & - - push_back(self) -> memreg_info_t +ida_dbg.memreg_infos_t.insert(self, it: "memreg_info_t", x: "memreg_info_t") -> "qvector< memreg_info_t >::iterator" -ida_dbg.memreg_infos_t.qclear (method) - qclear(self) +ida_dbg.memreg_infos_t.pop_back(self) -> None -ida_dbg.memreg_infos_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_dbg.memreg_infos_t.push_back(self, *args) -> "memreg_info_t &" -ida_dbg.memreg_infos_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: memreg_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_dbg.memreg_infos_t.qclear(self) -> None -ida_dbg.memreg_infos_t.size (method) - size(self) -> size_t +ida_dbg.memreg_infos_t.reserve(self, cnt: "size_t") -> None -ida_dbg.memreg_infos_t.swap (method) - swap(self, r) - - @param r: qvector< memreg_info_t > & +ida_dbg.memreg_infos_t.resize(self, *args) -> None -ida_dbg.memreg_infos_t.truncate (method) - truncate(self) +ida_dbg.memreg_infos_t.size(self) -> "size_t" -ida_dbg.put_dbg_byte (function) - put_dbg_byte(ea, x) -> bool - Change one byte of the debugged process memory. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint32) byte value - @return: true if the process memory has been modified +ida_dbg.memreg_infos_t.swap(self, r: "memreg_infos_t") -> None -ida_dbg.read_dbg_memory (function) - read_dbg_memory(ea, buffer, size) -> ssize_t - - @param ea: ea_t - @param buffer: void * - @param size: size_t +ida_dbg.memreg_infos_t.truncate(self) -> None -ida_dbg.refresh_debugger_memory (function) - refresh_debugger_memory() -> PyObject * +ida_dbg.put_dbg_byte(ea: ida_idaapi.ea_t, x: int) -> bool + Change one byte of the debugged process memory. + + @param ea: linear address + @param x: byte value + @returns true if the process memory has been modified + +ida_dbg.read_dbg_memory(ea: ida_idaapi.ea_t, buffer: "void *", size: "size_t") -> "ssize_t" + +ida_dbg.refresh_debugger_memory() Refreshes the debugger memory @return: Nothing -ida_dbg.rename_bptgrp (function) - rename_bptgrp(old_name, new_name) -> bool - Rename a folder of bpt dirtree \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @param old_name: (C++: const char *) absolute path to the folder to be renamed - @param new_name: (C++: const char *) absolute path of the new folder name - @return: success +ida_dbg.rename_bptgrp(old_name: str, new_name: str) -> bool + Rename a folder of bpt dirtree \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param old_name: absolute path to the folder to be renamed + @param new_name: absolute path of the new folder name + @returns success -ida_dbg.request_add_bpt (function) - request_add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool +ida_dbg.request_add_bpt(*args) -> bool + This function has the following signatures: + + 0. request_add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool + 1. request_add_bpt(bpt: const bpt_t &) -> bool + + # 0: request_add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool + + Post an add_bpt(ea_t, asize_t, bpttype_t) request. + + + # 1: request_add_bpt(bpt: const bpt_t &) -> bool + Post an add_bpt(const bpt_t &) request. - - @param ea: ea_t - @param size: asize_t - @param type: bpttype_t - - request_add_bpt(bpt) -> bool - - @param bpt: bpt_t const & -ida_dbg.request_attach_process (function) - request_attach_process(pid, event_id) -> int +ida_dbg.request_attach_process(pid: "pid_t", event_id: int) -> int Post an attach_process() request. - - @param pid: (C++: pid_t) - @param event_id: (C++: int) -ida_dbg.request_clear_trace (function) - request_clear_trace() +ida_dbg.request_clear_trace() -> None Post a clear_trace() request. -ida_dbg.request_continue_process (function) - request_continue_process() -> bool - Post a continue_process() request. - @note: This requires an explicit call to run_requests() +ida_dbg.request_continue_backwards() -> bool + Post a continue_backwards() request. + -ida_dbg.request_del_bpt (function) - request_del_bpt(ea) -> bool +ida_dbg.request_continue_process() -> bool + Post a continue_process() request. + + +ida_dbg.request_del_bpt(*args) -> bool + This function has the following signatures: + + 0. request_del_bpt(ea: ida_idaapi.ea_t) -> bool + 1. request_del_bpt(bptloc: const bpt_location_t &) -> bool + + # 0: request_del_bpt(ea: ida_idaapi.ea_t) -> bool + + Post a del_bpt(ea_t) request. + + + # 1: request_del_bpt(bptloc: const bpt_location_t &) -> bool + Post a del_bpt(const bpt_location_t &) request. - - @param ea: ea_t - - request_del_bpt(bptloc) -> bool - - @param bptloc: bpt_location_t const & -ida_dbg.request_detach_process (function) - request_detach_process() -> bool +ida_dbg.request_detach_process() -> bool Post a detach_process() request. -ida_dbg.request_disable_bblk_trace (function) - request_disable_bblk_trace() -> bool +ida_dbg.request_disable_bblk_trace() -> bool -ida_dbg.request_disable_bpt (function) - request_disable_bpt(ea) -> bool - - @param ea: ea_t - - request_disable_bpt(bptloc) -> bool - - @param bptloc: bpt_location_t const & +ida_dbg.request_disable_bpt(*args) -> bool -ida_dbg.request_disable_func_trace (function) - request_disable_func_trace() -> bool +ida_dbg.request_disable_func_trace() -> bool -ida_dbg.request_disable_insn_trace (function) - request_disable_insn_trace() -> bool +ida_dbg.request_disable_insn_trace() -> bool -ida_dbg.request_disable_step_trace (function) - request_disable_step_trace() -> bool +ida_dbg.request_disable_step_trace() -> bool -ida_dbg.request_enable_bblk_trace (function) - request_enable_bblk_trace(enable=True) -> bool - - @param enable: bool +ida_dbg.request_enable_bblk_trace(enable: bool = True) -> bool -ida_dbg.request_enable_bpt (function) - request_enable_bpt(ea, enable=True) -> bool - - @param ea: ea_t - @param enable: bool - - request_enable_bpt(bptloc, enable=True) -> bool - - @param bptloc: bpt_location_t const & - @param enable: bool +ida_dbg.request_enable_bpt(*args) -> bool -ida_dbg.request_enable_func_trace (function) - request_enable_func_trace(enable=True) -> bool - - @param enable: bool +ida_dbg.request_enable_func_trace(enable: bool = True) -> bool -ida_dbg.request_enable_insn_trace (function) - request_enable_insn_trace(enable=True) -> bool - - @param enable: bool +ida_dbg.request_enable_insn_trace(enable: bool = True) -> bool -ida_dbg.request_enable_step_trace (function) - request_enable_step_trace(enable=1) -> bool - - @param enable: int +ida_dbg.request_enable_step_trace(enable: int = 1) -> bool -ida_dbg.request_exit_process (function) - request_exit_process() -> bool +ida_dbg.request_exit_process() -> bool Post an exit_process() request. -ida_dbg.request_resume_thread (function) - request_resume_thread(tid) -> int +ida_dbg.request_resume_thread(tid: "thid_t") -> int Post a resume_thread() request. - - @param tid: (C++: thid_t) -ida_dbg.request_run_to (function) - request_run_to(ea, pid=pid_t(-1), tid=0) -> bool +ida_dbg.request_run_to(*args) -> bool Post a run_to() request. - - @param ea: (C++: ea_t) - @param pid: (C++: pid_t) -ida_dbg.request_select_thread (function) - request_select_thread(tid) -> bool +ida_dbg.request_run_to_backwards(*args) -> bool + Post a run_to_backwards() request. + +ida_dbg.request_select_thread(tid: "thid_t") -> bool Post a select_thread() request. - - @param tid: (C++: thid_t) -ida_dbg.request_set_bblk_trace_options (function) - request_set_bblk_trace_options(options) +ida_dbg.request_set_bblk_trace_options(options: int) -> None Post a set_bblk_trace_options() request. - - @param options: (C++: int) -ida_dbg.request_set_func_trace_options (function) - request_set_func_trace_options(options) +ida_dbg.request_set_func_trace_options(options: int) -> None Post a set_func_trace_options() request. - - @param options: (C++: int) -ida_dbg.request_set_insn_trace_options (function) - request_set_insn_trace_options(options) +ida_dbg.request_set_insn_trace_options(options: int) -> None Post a set_insn_trace_options() request. - - @param options: (C++: int) -ida_dbg.request_set_reg_val (function) - request_set_reg_val(regname, o) -> PyObject * +ida_dbg.request_set_reg_val(regname: str, o: "PyObject *") -> "PyObject *" Post a set_reg_val() request. - - @param regname: (C++: const char *) char const * - @param o: PyObject * -ida_dbg.request_set_resume_mode (function) - request_set_resume_mode(tid, mode) -> bool +ida_dbg.request_set_resume_mode(tid: "thid_t", mode: "resume_mode_t") -> bool Post a set_resume_mode() request. - - @param tid: (C++: thid_t) - @param mode: (C++: resume_mode_t) enum resume_mode_t -ida_dbg.request_set_step_trace_options (function) - request_set_step_trace_options(options) +ida_dbg.request_set_step_trace_options(options: int) -> None Post a set_step_trace_options() request. - - @param options: (C++: int) -ida_dbg.request_start_process (function) - request_start_process(path=None, args=None, sdir=None) -> int +ida_dbg.request_start_process(path: str = None, args: str = None, sdir: str = None) -> int Post a start_process() request. - - @param path: (C++: const char *) char const * - @param args: (C++: const char *) char const * - @param sdir: (C++: const char *) char const * -ida_dbg.request_step_into (function) - request_step_into() -> bool +ida_dbg.request_step_into() -> bool Post a step_into() request. -ida_dbg.request_step_over (function) - request_step_over() -> bool +ida_dbg.request_step_into_backwards() -> bool + Post a step_into_backwards() request. + +ida_dbg.request_step_over() -> bool Post a step_over() request. -ida_dbg.request_step_until_ret (function) - request_step_until_ret() -> bool +ida_dbg.request_step_over_backwards() -> bool + Post a step_over_backwards() request. + +ida_dbg.request_step_until_ret() -> bool Post a step_until_ret() request. -ida_dbg.request_suspend_process (function) - request_suspend_process() -> bool +ida_dbg.request_suspend_process() -> bool Post a suspend_process() request. -ida_dbg.request_suspend_thread (function) - request_suspend_thread(tid) -> int +ida_dbg.request_suspend_thread(tid: "thid_t") -> int Post a suspend_thread() request. - - @param tid: (C++: thid_t) -ida_dbg.resume_thread (function) - resume_thread(tid) -> int - Resume thread. \sq{Type, Synchronous function - available as request, - Notification, none (synchronous function)} - - @param tid: (C++: thid_t) thread id +ida_dbg.resume_thread(tid: "thid_t") -> int + Resume thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + + @param tid: thread id @retval -1: network error @retval 0: failed @retval 1: ok -ida_dbg.retrieve_exceptions (function) - retrieve_exceptions() -> excvec_t - Retrieve the exception information. You may freely modify the returned vector - and add/edit/delete exceptions You must call store_exceptions() after any - modifications Note: exceptions with code zero, multiple exception codes or names - are prohibited +ida_dbg.retrieve_exceptions() -> "excvec_t *" + Retrieve the exception information. You may freely modify the returned vector and add/edit/delete exceptions You must call store_exceptions() after any modifications Note: exceptions with code zero, multiple exception codes or names are prohibited + -ida_dbg.run_requests (function) - run_requests() -> bool - Execute requests until all requests are processed or an asynchronous function is - called. \sq{Type, Synchronous function, Notification, none (synchronous - function)} - - @return: false if not all requests could be processed (indicates an asynchronous - function was started) - @note: If called from a notification handler, the execution of requests will be - postponed to the end of the execution of all notification handlers. +ida_dbg.run_requests() -> bool + Execute requests until all requests are processed or an asynchronous function is called. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @returns false if not all requests could be processed (indicates an asynchronous function was started) -ida_dbg.run_to (function) - run_to(ea, pid=pid_t(-1), tid=0) -> bool - Execute the process until the given address is reached. If no process is active, - a new process is started. Technically, the debugger sets up a temporary - breakpoint at the given address, and continues (or starts) the execution of the - whole process. So, all threads continue their execution! \sq{Type, Asynchronous - function - available as Request, Notification, dbg_run_to} - - @param ea: (C++: ea_t) target address - @param pid: (C++: pid_t) not used yet. please do not specify this parameter. +ida_dbg.run_to(*args) -> bool + Execute the process until the given address is reached. If no process is active, a new process is started. Technically, the debugger sets up a temporary breakpoint at the given address, and continues (or starts) the execution of the whole process. So, all threads continue their execution! \sq{Type, Asynchronous function - available as Request, Notification, dbg_run_to} + + @param ea: target address + @param pid: not used yet. please do not specify this parameter. + @param tid: not used yet. please do not specify this parameter. -ida_dbg.save_trace_file (function) - save_trace_file(filename, description) -> bool +ida_dbg.run_to_backwards(*args) -> bool + Execute the process backwards until the given address is reached. Technically, the debugger sets up a temporary breakpoint at the given address, and continues (or starts) the execution of the whole process. \sq{Type, Asynchronous function - available as Request, Notification, dbg_run_to} + + @param ea: target address + @param pid: not used yet. please do not specify this parameter. + @param tid: not used yet. please do not specify this parameter. + +ida_dbg.save_trace_file(filename: str, description: str) -> bool Save the current trace in the specified file. - - @param filename: (C++: const char *) char const * - @param description: (C++: const char *) char const * -ida_dbg.select_thread (function) - select_thread(tid) -> bool - Select the given thread as the current debugged thread. All thread related - execution functions will work on this thread. The process must be suspended to - select a new thread. \sq{Type, Synchronous function - available as request, - Notification, none (synchronous function)} - - @param tid: (C++: thid_t) ID of the thread to select - @return: false if the thread doesn't exist. +ida_dbg.select_thread(tid: "thid_t") -> bool + Select the given thread as the current debugged thread. All thread related execution functions will work on this thread. The process must be suspended to select a new thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + + @param tid: ID of the thread to select + @returns false if the thread doesn't exist. -ida_dbg.send_dbg_command (function) +ida_dbg.send_dbg_command(command) Send a direct command to the debugger backend, and retrieve the result as a string. @@ -20394,673 +13740,384 @@ ida_dbg.send_dbg_command (function) Returns: (True, ) on success, or (False, ) on failure -ida_dbg.set_bblk_trace_options (function) - set_bblk_trace_options(options) +ida_dbg.set_bblk_trace_options(options: int) -> None Modify basic block tracing options (see BT_LOG_INSTS) - - @param options: (C++: int) -ida_dbg.set_bpt_group (function) - set_bpt_group(bpt, grp_name) -> bool - Move a bpt into a folder in the breakpoint dirtree if the folder didn't exists, - it will be created \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param bpt: (C++: bpt_t &) bpt that will be moved - @param grp_name: (C++: const char *) absolute path to the breakpoint dirtree folder - @return: success +ida_dbg.set_bpt_group(bpt: "bpt_t", grp_name: str) -> bool + Move a bpt into a folder in the breakpoint dirtree if the folder didn't exists, it will be created \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param bpt: bpt that will be moved + @param grp_name: absolute path to the breakpoint dirtree folder + @returns success -ida_dbg.set_bptloc_group (function) - set_bptloc_group(bptloc, grp_name) -> bool - Move a bpt into a folder in the breakpoint dirtree based on the bpt_location - find_bpt is called to retrieve the bpt and then set_bpt_group if the folder - didn't exists, it will be created \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @param bptloc: (C++: const bpt_location_t &) bptlocation of the bpt that will be moved - @param grp_name: (C++: const char *) absolute path to the breakpoint dirtree folder - @return: success +ida_dbg.set_bptloc_group(bptloc: "bpt_location_t", grp_name: str) -> bool + Move a bpt into a folder in the breakpoint dirtree based on the bpt_location find_bpt is called to retrieve the bpt and then set_bpt_group if the folder didn't exists, it will be created \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param bptloc: bptlocation of the bpt that will be moved + @param grp_name: absolute path to the breakpoint dirtree folder + @returns success -ida_dbg.set_bptloc_string (function) - set_bptloc_string(s) -> int - - @param s: char const * +ida_dbg.set_bptloc_string(s: str) -> int -ida_dbg.set_debugger_event_cond (function) - set_debugger_event_cond(NONNULL_evcond) - - @param NONNULL_evcond: char const * +ida_dbg.set_debugger_event_cond(NONNULL_evcond: str) -> None -ida_dbg.set_debugger_options (function) - set_debugger_options(options) -> uint - Set debugger options. Replaces debugger options with the specification - combination Debugger options - - @param options: (C++: uint) - @return: the old debugger options +ida_dbg.set_debugger_options(options: "uint") -> "uint" + Set debugger options. Replaces debugger options with the specification combination Debugger options + + @returns the old debugger options -ida_dbg.set_func_trace_options (function) - set_func_trace_options(options) - Modify function tracing options. \sq{Type, Synchronous function - available as - request, Notification, none (synchronous function)} - - @param options: (C++: int) +ida_dbg.set_func_trace_options(options: int) -> None + Modify function tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + -ida_dbg.set_highlight_trace_options (function) - set_highlight_trace_options(hilight, color, diff) +ida_dbg.set_highlight_trace_options(hilight: bool, color: "bgcolor_t", diff: "bgcolor_t") -> None Set highlight trace parameters. - - @param hilight: (C++: bool) - @param color: (C++: bgcolor_t) - @param diff: (C++: bgcolor_t) -ida_dbg.set_insn_trace_options (function) - set_insn_trace_options(options) - Modify instruction tracing options. \sq{Type, Synchronous function - available - as request, Notification, none (synchronous function)} - - @param options: (C++: int) +ida_dbg.set_insn_trace_options(options: int) -> None + Modify instruction tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + -ida_dbg.set_manual_regions (function) - set_manual_regions(ranges) - - @param ranges: meminfo_vec_t const * +ida_dbg.set_manual_regions(ranges: "meminfo_vec_t") -> None -ida_dbg.set_process_options (function) - set_process_options(path, args, sdir, host, _pass, port) - Set process options. Any of the arguments may be nullptr, which means 'do not - modify' - - @param path: (C++: const char *) char const * - @param args: (C++: const char *) char const * - @param sdir: (C++: const char *) char const * - @param host: (C++: const char *) char const * - @param pass: (C++: const char *) char const * - @param port: (C++: int) +ida_dbg.set_process_options(*args) -> None + Set process options. Any of the arguments may be nullptr, which means 'do not modify' + -ida_dbg.set_process_state (function) - set_process_state(newstate, p_thid, dbginv) -> int - Set new state for the debugged process. Notifies the IDA kernel about the change - of the debugged process state. For example, a debugger module could call this - function when it knows that the process is suspended for a short period of time. - Some IDA API calls can be made only when the process is suspended. The process - state is usually restored before returning control to the caller. You must know - that it is ok to change the process state, doing it at arbitrary moments may - crash the application or IDA. \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param newstate: (C++: int) new process state (one of Debugged process states) if - DSTATE_NOTASK is passed then the state is not changed - @param p_thid: (C++: thid_t *) ptr to new thread id. may be nullptr or pointer to NO_THREAD. the - pointed variable will contain the old thread id upon return - @param dbginv: (C++: int) Debugged process invalidation options - @return: old debugger state (one of Debugged process states) +ida_dbg.set_process_state(newstate: int, p_thid: "thid_t *", dbginv: int) -> int + Set new state for the debugged process. Notifies the IDA kernel about the change of the debugged process state. For example, a debugger module could call this function when it knows that the process is suspended for a short period of time. Some IDA API calls can be made only when the process is suspended. The process state is usually restored before returning control to the caller. You must know that it is ok to change the process state, doing it at arbitrary moments may crash the application or IDA. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param newstate: new process state (one of Debugged process states) if DSTATE_NOTASK is passed then the state is not changed + @param p_thid: ptr to new thread id. may be nullptr or pointer to NO_THREAD. the pointed variable will contain the old thread id upon return + @param dbginv: Debugged process invalidation options + @returns old debugger state (one of Debugged process states) -ida_dbg.set_reg_val (function) - set_reg_val(regname, o) -> PyObject +ida_dbg.set_reg_val(*args) -> bool + Set a register value by name - @param regname: char const * - @param o: PyObject * + This function has the following signatures: + 1. set_reg_val(name: str, value: Union[int, float, bytes]) -> bool + 1. set_reg_val(tid: int, regidx: int, value: Union[int, float, bytes]) -> bool - set_reg_val(tid, regidx, o) -> bool, int + Depending on the register type, this will expect + either an integer, a float or, in the case of large + vector registers, a bytes sequence. - @param tid: thid_t - @param regidx: int - @param o: PyObject * + @param name (1st form) the register name + @param tid (2nd form) the thread ID + @param regidx (2nd form) the register index + @param value the register value + @return success -ida_dbg.set_remote_debugger (function) - set_remote_debugger(host, _pass, port=-1) - Set remote debugging options. Should be used before starting the debugger. - - @param host: (C++: const char *) If empty, IDA will use local debugger. If nullptr, the host will - not be set. - @param pass: (C++: const char *) If nullptr, the password will not be set - @param port: (C++: int) If -1, the default port number will be used +ida_dbg.set_remote_debugger(host: str, _pass: str, port: int = -1) -> None + Set remote debugging options. Should be used before starting the debugger. + + @param host: If empty, IDA will use local debugger. If nullptr, the host will not be set. + @param port: If -1, the default port number will be used -ida_dbg.set_resume_mode (function) - set_resume_mode(tid, mode) -> bool - How to resume the application. Set resume mode but do not resume process. - - @param tid: (C++: thid_t) - @param mode: (C++: resume_mode_t) enum resume_mode_t +ida_dbg.set_resume_mode(tid: "thid_t", mode: "resume_mode_t") -> bool + How to resume the application. Set resume mode but do not resume process. + -ida_dbg.set_step_trace_options (function) - set_step_trace_options(options) - Modify step tracing options. \sq{Type, Synchronous function - available as - request, Notification, none (synchronous function)} - - @param options: (C++: int) +ida_dbg.set_step_trace_options(options: int) -> None + Modify step tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + -ida_dbg.set_trace_base_address (function) - set_trace_base_address(ea) - Set the base address of the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param ea: (C++: ea_t) +ida_dbg.set_trace_base_address(ea: ida_idaapi.ea_t) -> None + Set the base address of the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} + -ida_dbg.set_trace_dynamic_register_set (function) - set_trace_dynamic_register_set(idaregs) +ida_dbg.set_trace_dynamic_register_set(idaregs: "dynamic_register_set_t &") -> None Set dynamic register set of current trace. - - @param idaregs: (C++: dynamic_register_set_t &) -ida_dbg.set_trace_file_desc (function) - set_trace_file_desc(filename, description) -> bool +ida_dbg.set_trace_file_desc(filename: str, description: str) -> bool Change the description of the specified trace file. - - @param filename: (C++: const char *) char const * - @param description: (C++: const char *) char const * -ida_dbg.set_trace_platform (function) - set_trace_platform(platform) +ida_dbg.set_trace_platform(platform: str) -> None Set platform name of current trace. - - @param platform: (C++: const char *) char const * -ida_dbg.set_trace_size (function) - set_trace_size(size) -> bool - Specify the new size of the circular buffer. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param size: (C++: int) if 0, buffer isn't circular and events are never removed. If the - new size is smaller than the existing number of trace events, a - corresponding number of trace events are removed. - @note: If you specify 0, all available memory can be quickly used !!! +ida_dbg.set_trace_size(size: int) -> bool + Specify the new size of the circular buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)} + + @param size: if 0, buffer isn't circular and events are never removed. If the new size is smaller than the existing number of trace events, a corresponding number of trace events are removed. -ida_dbg.srcdbg_request_step_into (function) - srcdbg_request_step_into() -> bool +ida_dbg.srcdbg_request_step_into() -> bool -ida_dbg.srcdbg_request_step_over (function) - srcdbg_request_step_over() -> bool +ida_dbg.srcdbg_request_step_over() -> bool -ida_dbg.srcdbg_request_step_until_ret (function) - srcdbg_request_step_until_ret() -> bool +ida_dbg.srcdbg_request_step_until_ret() -> bool -ida_dbg.srcdbg_step_into (function) - srcdbg_step_into() -> bool +ida_dbg.srcdbg_step_into() -> bool -ida_dbg.srcdbg_step_over (function) - srcdbg_step_over() -> bool +ida_dbg.srcdbg_step_over() -> bool -ida_dbg.srcdbg_step_until_ret (function) - srcdbg_step_until_ret() -> bool +ida_dbg.srcdbg_step_until_ret() -> bool -ida_dbg.start_process (function) - start_process(path=None, args=None, sdir=None) -> int - Start a process in the debugger. \sq{Type, Asynchronous function - available as - Request, Notification, dbg_process_start} - @note: You can also use the run_to() function to easily start the execution of a - process until a given address is reached. - @note: For all parameters, a nullptr value indicates the debugger will take the - value from the defined Process Options. - - @param path: (C++: const char *) path to the executable to start - @param args: (C++: const char *) arguments to pass to process - @param sdir: (C++: const char *) starting directory for the process +ida_dbg.start_process(path: str = None, args: str = None, sdir: str = None) -> int + Start a process in the debugger. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_start} + + @param path: path to the executable to start + @param args: arguments to pass to process + @param sdir: starting directory for the process @retval -1: impossible to create the process @retval 0: the starting of the process was cancelled by the user @retval 1: the process was properly started -ida_dbg.step_into (function) - step_into() -> bool - Execute one instruction in the current thread. Other threads are kept suspended. - \sq{Type, Asynchronous function - available as Request, Notification, - dbg_step_into} +ida_dbg.step_into() -> bool + Execute one instruction in the current thread. Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_into} + -ida_dbg.step_over (function) - step_over() -> bool - Execute one instruction in the current thread, but without entering into - functions. Others threads keep suspended. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_step_over} +ida_dbg.step_into_backwards() -> bool + Execute one instruction backwards in the current thread. Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_into} + -ida_dbg.step_until_ret (function) - step_until_ret() -> bool - Execute instructions in the current thread until a function return instruction - is executed (aka "step out"). Other threads are kept suspended. \sq{Type, - Asynchronous function - available as Request, Notification, dbg_step_until_ret} +ida_dbg.step_over() -> bool + Execute one instruction in the current thread, but without entering into functions. Others threads keep suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_over} + -ida_dbg.store_exceptions (function) - store_exceptions() -> bool - Update the exception information stored in the debugger module by invoking its - dbg->set_exception_info callback +ida_dbg.step_over_backwards() -> bool + Execute one instruction backwards in the current thread, but without entering into functions. Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_over} + -ida_dbg.suspend_process (function) - suspend_process() -> bool +ida_dbg.step_until_ret() -> bool + Execute instructions in the current thread until a function return instruction is executed (aka "step out"). Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_until_ret} + + +ida_dbg.store_exceptions() -> bool + Update the exception information stored in the debugger module by invoking its dbg->set_exception_info callback + + +ida_dbg.suspend_process() -> bool Suspend the process in the debugger. \sq{ Type, * Synchronous function (if in a notification handler) * Asynchronous function (everywhere else) * available as Request, Notification, * none (if in a notification handler) * dbg_suspend_process (everywhere else) } - @note: The suspend_process() function can be called from a notification handler - to force the stopping of the process. In this case, no notification will - be generated. When you suspend a process, the running command is always - aborted. -ida_dbg.suspend_thread (function) - suspend_thread(tid) -> int - Suspend thread. Suspending a thread may deadlock the whole application if the - suspended was owning some synchronization objects. \sq{Type, Synchronous - function - available as request, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) thread id +ida_dbg.suspend_thread(tid: "thid_t") -> int + Suspend thread. Suspending a thread may deadlock the whole application if the suspended was owning some synchronization objects. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} + + @param tid: thread id @retval -1: network error @retval 0: failed @retval 1: ok -ida_dbg.tev_bpt (variable) +ida_dbg.tev_bpt write, read/write, execution trace -ida_dbg.tev_call (variable) +ida_dbg.tev_call a function call trace -ida_dbg.tev_event (variable) +ida_dbg.tev_event debug event occurred -ida_dbg.tev_info_reg_t (class) - Proxy of C++ tev_info_reg_t class. +ida_dbg.tev_info_reg_t -ida_dbg.tev_info_reg_t.__init__ (method) - __init__(self) -> tev_info_reg_t +ida_dbg.tev_info_reg_t.__init__(self) -ida_dbg.tev_info_t (class) - Proxy of C++ tev_info_t class. +ida_dbg.tev_info_t -ida_dbg.tev_info_t.__init__ (method) - __init__(self) -> tev_info_t +ida_dbg.tev_info_t.__init__(self) -ida_dbg.tev_info_t.ea (variable) +ida_dbg.tev_info_t.ea address where the event occurred -ida_dbg.tev_info_t.tid (variable) +ida_dbg.tev_info_t.tid thread where the event was recorded -ida_dbg.tev_info_t.type (variable) +ida_dbg.tev_info_t.type trace event type -ida_dbg.tev_insn (variable) +ida_dbg.tev_insn an instruction trace -ida_dbg.tev_max (variable) +ida_dbg.tev_max first unused event type -ida_dbg.tev_mem (variable) +ida_dbg.tev_mem memory layout changed -ida_dbg.tev_none (variable) +ida_dbg.tev_none no event -ida_dbg.tev_reg_value_t (class) - Proxy of C++ tev_reg_value_t class. +ida_dbg.tev_reg_value_t -ida_dbg.tev_reg_value_t.__init__ (method) - __init__(self, _reg_idx=-1, _value=uint64(-1)) -> tev_reg_value_t - - @param _reg_idx: int - @param _value: uint64 +ida_dbg.tev_reg_value_t.__init__(self, *args) -ida_dbg.tev_reg_values_t (class) - Proxy of C++ qvector< tev_reg_value_t > class. +ida_dbg.tev_reg_values_t -ida_dbg.tev_reg_values_t.__getitem__ (method) - __getitem__(self, i) -> tev_reg_value_t - - @param i: size_t +ida_dbg.tev_reg_values_t.__getitem__(self, i: "size_t") -> "tev_reg_value_t const &" -ida_dbg.tev_reg_values_t.__init__ (method) - __init__(self) -> tev_reg_values_t - __init__(self, x) -> tev_reg_values_t - - @param x: qvector< tev_reg_value_t > const & +ida_dbg.tev_reg_values_t.__init__(self, *args) -ida_dbg.tev_reg_values_t.__len__ (method) - __len__(self) -> size_t +ida_dbg.tev_reg_values_t.__len__(self) -> "size_t" -ida_dbg.tev_reg_values_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: tev_reg_value_t const & +ida_dbg.tev_reg_values_t.__setitem__(self, i: "size_t", v: "tev_reg_value_t") -> None -ida_dbg.tev_reg_values_t.at (method) - at(self, _idx) -> tev_reg_value_t - - @param _idx: size_t +ida_dbg.tev_reg_values_t.append(self, x: "tev_reg_value_t") -> None -ida_dbg.tev_reg_values_t.begin (method) - begin(self) -> tev_reg_value_t +ida_dbg.tev_reg_values_t.at(self, _idx: "size_t") -> "tev_reg_value_t const &" -ida_dbg.tev_reg_values_t.capacity (method) - capacity(self) -> size_t +ida_dbg.tev_reg_values_t.begin(self, *args) -> "qvector< tev_reg_value_t >::const_iterator" -ida_dbg.tev_reg_values_t.clear (method) - clear(self) +ida_dbg.tev_reg_values_t.capacity(self) -> "size_t" -ida_dbg.tev_reg_values_t.empty (method) - empty(self) -> bool +ida_dbg.tev_reg_values_t.clear(self) -> None -ida_dbg.tev_reg_values_t.end (method) - end(self) -> tev_reg_value_t +ida_dbg.tev_reg_values_t.empty(self) -> bool -ida_dbg.tev_reg_values_t.erase (method) - erase(self, it) -> tev_reg_value_t - - @param it: qvector< tev_reg_value_t >::iterator - - erase(self, first, last) -> tev_reg_value_t - - @param first: qvector< tev_reg_value_t >::iterator - @param last: qvector< tev_reg_value_t >::iterator +ida_dbg.tev_reg_values_t.end(self, *args) -> "qvector< tev_reg_value_t >::const_iterator" -ida_dbg.tev_reg_values_t.extract (method) - extract(self) -> tev_reg_value_t +ida_dbg.tev_reg_values_t.erase(self, *args) -> "qvector< tev_reg_value_t >::iterator" -ida_dbg.tev_reg_values_t.grow (method) - grow(self, x=tev_reg_value_t()) - - @param x: tev_reg_value_t const & +ida_dbg.tev_reg_values_t.extend(self, x: "tev_reg_values_t") -> None -ida_dbg.tev_reg_values_t.inject (method) - inject(self, s, len) - - @param s: tev_reg_value_t * - @param len: size_t +ida_dbg.tev_reg_values_t.extract(self) -> "tev_reg_value_t *" -ida_dbg.tev_reg_values_t.insert (method) - insert(self, it, x) -> tev_reg_value_t - - @param it: qvector< tev_reg_value_t >::iterator - @param x: tev_reg_value_t const & +ida_dbg.tev_reg_values_t.grow(self, *args) -> None -ida_dbg.tev_reg_values_t.pop_back (method) - pop_back(self) +ida_dbg.tev_reg_values_t.inject(self, s: "tev_reg_value_t", len: "size_t") -> None -ida_dbg.tev_reg_values_t.push_back (method) - push_back(self, x) - - @param x: tev_reg_value_t const & - - push_back(self) -> tev_reg_value_t +ida_dbg.tev_reg_values_t.insert(self, it: "tev_reg_value_t", x: "tev_reg_value_t") -> "qvector< tev_reg_value_t >::iterator" -ida_dbg.tev_reg_values_t.qclear (method) - qclear(self) +ida_dbg.tev_reg_values_t.pop_back(self) -> None -ida_dbg.tev_reg_values_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_dbg.tev_reg_values_t.push_back(self, *args) -> "tev_reg_value_t &" -ida_dbg.tev_reg_values_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: tev_reg_value_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_dbg.tev_reg_values_t.qclear(self) -> None -ida_dbg.tev_reg_values_t.size (method) - size(self) -> size_t +ida_dbg.tev_reg_values_t.reserve(self, cnt: "size_t") -> None -ida_dbg.tev_reg_values_t.swap (method) - swap(self, r) - - @param r: qvector< tev_reg_value_t > & +ida_dbg.tev_reg_values_t.resize(self, *args) -> None -ida_dbg.tev_reg_values_t.truncate (method) - truncate(self) +ida_dbg.tev_reg_values_t.size(self) -> "size_t" -ida_dbg.tev_ret (variable) +ida_dbg.tev_reg_values_t.swap(self, r: "tev_reg_values_t") -> None + +ida_dbg.tev_reg_values_t.truncate(self) -> None + +ida_dbg.tev_ret a function return trace -ida_dbg.tevinforeg_vec_t (class) - Proxy of C++ qvector< tev_info_reg_t > class. +ida_dbg.tevinforeg_vec_t -ida_dbg.tevinforeg_vec_t.__getitem__ (method) - __getitem__(self, i) -> tev_info_reg_t - - @param i: size_t +ida_dbg.tevinforeg_vec_t.__getitem__(self, i: "size_t") -> "tev_info_reg_t const &" -ida_dbg.tevinforeg_vec_t.__init__ (method) - __init__(self) -> tevinforeg_vec_t - __init__(self, x) -> tevinforeg_vec_t - - @param x: qvector< tev_info_reg_t > const & +ida_dbg.tevinforeg_vec_t.__init__(self, *args) -ida_dbg.tevinforeg_vec_t.__len__ (method) - __len__(self) -> size_t +ida_dbg.tevinforeg_vec_t.__len__(self) -> "size_t" -ida_dbg.tevinforeg_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: tev_info_reg_t const & +ida_dbg.tevinforeg_vec_t.__setitem__(self, i: "size_t", v: "tev_info_reg_t") -> None -ida_dbg.tevinforeg_vec_t.at (method) - at(self, _idx) -> tev_info_reg_t - - @param _idx: size_t +ida_dbg.tevinforeg_vec_t.append(self, x: "tev_info_reg_t") -> None -ida_dbg.tevinforeg_vec_t.begin (method) - begin(self) -> tev_info_reg_t +ida_dbg.tevinforeg_vec_t.at(self, _idx: "size_t") -> "tev_info_reg_t const &" -ida_dbg.tevinforeg_vec_t.capacity (method) - capacity(self) -> size_t +ida_dbg.tevinforeg_vec_t.begin(self, *args) -> "qvector< tev_info_reg_t >::const_iterator" -ida_dbg.tevinforeg_vec_t.clear (method) - clear(self) +ida_dbg.tevinforeg_vec_t.capacity(self) -> "size_t" -ida_dbg.tevinforeg_vec_t.empty (method) - empty(self) -> bool +ida_dbg.tevinforeg_vec_t.clear(self) -> None -ida_dbg.tevinforeg_vec_t.end (method) - end(self) -> tev_info_reg_t +ida_dbg.tevinforeg_vec_t.empty(self) -> bool -ida_dbg.tevinforeg_vec_t.erase (method) - erase(self, it) -> tev_info_reg_t - - @param it: qvector< tev_info_reg_t >::iterator - - erase(self, first, last) -> tev_info_reg_t - - @param first: qvector< tev_info_reg_t >::iterator - @param last: qvector< tev_info_reg_t >::iterator +ida_dbg.tevinforeg_vec_t.end(self, *args) -> "qvector< tev_info_reg_t >::const_iterator" -ida_dbg.tevinforeg_vec_t.extract (method) - extract(self) -> tev_info_reg_t +ida_dbg.tevinforeg_vec_t.erase(self, *args) -> "qvector< tev_info_reg_t >::iterator" -ida_dbg.tevinforeg_vec_t.grow (method) - grow(self, x=tev_info_reg_t()) - - @param x: tev_info_reg_t const & +ida_dbg.tevinforeg_vec_t.extend(self, x: "tevinforeg_vec_t") -> None -ida_dbg.tevinforeg_vec_t.inject (method) - inject(self, s, len) - - @param s: tev_info_reg_t * - @param len: size_t +ida_dbg.tevinforeg_vec_t.extract(self) -> "tev_info_reg_t *" -ida_dbg.tevinforeg_vec_t.insert (method) - insert(self, it, x) -> tev_info_reg_t - - @param it: qvector< tev_info_reg_t >::iterator - @param x: tev_info_reg_t const & +ida_dbg.tevinforeg_vec_t.grow(self, *args) -> None -ida_dbg.tevinforeg_vec_t.pop_back (method) - pop_back(self) +ida_dbg.tevinforeg_vec_t.inject(self, s: "tev_info_reg_t", len: "size_t") -> None -ida_dbg.tevinforeg_vec_t.push_back (method) - push_back(self, x) - - @param x: tev_info_reg_t const & - - push_back(self) -> tev_info_reg_t +ida_dbg.tevinforeg_vec_t.insert(self, it: "tev_info_reg_t", x: "tev_info_reg_t") -> "qvector< tev_info_reg_t >::iterator" -ida_dbg.tevinforeg_vec_t.qclear (method) - qclear(self) +ida_dbg.tevinforeg_vec_t.pop_back(self) -> None -ida_dbg.tevinforeg_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_dbg.tevinforeg_vec_t.push_back(self, *args) -> "tev_info_reg_t &" -ida_dbg.tevinforeg_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: tev_info_reg_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_dbg.tevinforeg_vec_t.qclear(self) -> None -ida_dbg.tevinforeg_vec_t.size (method) - size(self) -> size_t +ida_dbg.tevinforeg_vec_t.reserve(self, cnt: "size_t") -> None -ida_dbg.tevinforeg_vec_t.swap (method) - swap(self, r) - - @param r: qvector< tev_info_reg_t > & +ida_dbg.tevinforeg_vec_t.resize(self, *args) -> None -ida_dbg.tevinforeg_vec_t.truncate (method) - truncate(self) +ida_dbg.tevinforeg_vec_t.size(self) -> "size_t" -ida_dbg.update_bpt (function) - update_bpt(bpt) -> bool - Update modifiable characteristics of an existing breakpoint. To update the - breakpoint location, use change_bptlocs() \sq{Type, Synchronous function, - Notification, none (synchronous function)} - @note: Only the following fields can be modified: - * bpt_t::cndbody - * bpt_t::pass_count - * bpt_t::flags - * bpt_t::size - * bpt_t::type - @note: Changing some properties will require removing and then re-adding the - breakpoint to the process memory (or the debugger backend), which can - lead to race conditions (i.e., breakpoint(s) can be missed) in case the - process is not suspended. Here are a list of scenarios that will require - the breakpoint to be removed & then re-added: - * bpt_t::size is modified - * bpt_t::type is modified - * bpt_t::flags's BPT_ENABLED is modified - * bpt_t::flags's BPT_LOWCND is changed - * bpt_t::flags's BPT_LOWCND remains set, but cndbody changed - - @param bpt: (C++: const bpt_t *) bpt_t const * +ida_dbg.tevinforeg_vec_t.swap(self, r: "tevinforeg_vec_t") -> None -ida_dbg.wait_for_next_event (function) - wait_for_next_event(wfne, timeout) -> dbg_event_code_t +ida_dbg.tevinforeg_vec_t.truncate(self) -> None + +ida_dbg.update_bpt(bpt: "bpt_t") -> bool + Update modifiable characteristics of an existing breakpoint. To update the breakpoint location, use change_bptlocs() \sq{Type, Synchronous function, Notification, none (synchronous function)} + + +ida_dbg.wait_for_next_event(wfne: int, timeout: int) -> "dbg_event_code_t" Wait for the next event. + This function (optionally) resumes the process execution, and waits for a debugger event until a possible timeout occurs. - This function (optionally) resumes the process execution, and waits for a - debugger event until a possible timeout occurs. - - @param wfne: (C++: int) combination of Wait for debugger event flags constants - @param timeout: (C++: int) number of seconds to wait, -1-infinity - @return: either an event_id_t (if > 0), or a dbg_event_code_t (if <= 0) + @param wfne: combination of Wait for debugger event flags constants + @param timeout: number of seconds to wait, -1-infinity + @returns either an event_id_t (if > 0), or a dbg_event_code_t (if <= 0) -ida_dbg.write_dbg_memory (function) - write_dbg_memory(ea, py_buf, size=size_t(-1)) -> ssize_t - - @param ea: ea_t - @param py_buf: PyObject * - @param size: size_t +ida_dbg.write_dbg_memory(*args) -> "ssize_t" -ida_diskio (module) +ida_diskio File I/O functions for IDA. - You should not use standard C file I/O functions in modules. Use functions from - this header, pro.h and fpro.h instead. - - This file also declares a call_system() function. + You should not use standard C file I/O functions in modules. Use functions from this header, pro.h and fpro.h instead. + This file also declares a call_system() function. + -ida_diskio.IDA_SUBDIR_IDADIR_FIRST (variable) +ida_diskio.IDA_SUBDIR_IDADIR_FIRST $IDADIR/subdir will be first, not last -ida_diskio.IDA_SUBDIR_IDP (variable) +ida_diskio.IDA_SUBDIR_IDP append the processor name as a subdirectory -ida_diskio.IDA_SUBDIR_ONLY_EXISTING (variable) +ida_diskio.IDA_SUBDIR_ONLY_EXISTING only existing directories will be present -ida_diskio.LINPUT_GENERIC (variable) - generic linput +ida_diskio.LOC_CLOSE + close the inner linput -ida_diskio.LINPUT_LOCAL (variable) - local file +ida_diskio.LOC_KEEP + do nothing -ida_diskio.LINPUT_NONE (variable) - invalid linput +ida_diskio.LOC_UNMAKE + unmake the inner linput -ida_diskio.LINPUT_PROCMEM (variable) - debugged process memory (read_dbg_memory()) +ida_diskio.VAULT_CACHE_FNAME + to store file caches -ida_diskio.LINPUT_RFILE (variable) - remote file ( debugger_t::open_file, debugger_t::read_file) +ida_diskio.VAULT_CACHE_SUBDIR + subdir name for cached deltas and old files -ida_diskio.choose_ioport_device2 (function) - choose_ioport_device2(_device, file, parse_params) -> bool - - @param _device: qstring * - @param file: char const * - @param parse_params: choose_ioport_parser_t * +ida_diskio.choose_ioport_device2(_device: str, file: str, parse_params: "choose_ioport_parser_t") -> bool -ida_diskio.choose_ioport_parser_t (class) - Proxy of C++ choose_ioport_parser_t class. +ida_diskio.choose_ioport_parser_t -ida_diskio.choose_ioport_parser_t.__disown__ (method) +ida_diskio.choose_ioport_parser_t.__disown__(self) -ida_diskio.choose_ioport_parser_t.__init__ (method) - __init__(self) -> choose_ioport_parser_t - - @param self: PyObject * +ida_diskio.choose_ioport_parser_t.__init__(self) -ida_diskio.choose_ioport_parser_t.parse (method) - parse(self, param, line) -> bool +ida_diskio.choose_ioport_parser_t.parse(self, param: str, line: str) -> bool @retval true: and fill PARAM with a displayed string @retval false: and empty PARAM to skip the current device @retval false: and fill PARAM with an error message - - @param param: (C++: qstring *) - @param line: (C++: const char *) char const * -ida_diskio.close_linput (function) - close_linput(li) - Close loader input. - - @param li: (C++: linput_t *) +ida_diskio.close_linput(li: "linput_t *") -> None -ida_diskio.create_bytearray_linput (function) - create_bytearray_linput(s) -> linput_t * - Trivial memory linput. - - @param s: qstring const & +ida_diskio.create_bytearray_linput(s: str) -> "linput_t *" -ida_diskio.create_generic_linput (function) - create_generic_linput(gl) -> linput_t * - Create a generic linput - - @param gl: (C++: generic_linput_t *) linput description. this object will be destroyed by close_linput() - using "delete gl;" +ida_diskio.create_generic_linput(gl: "generic_linput_t") -> "linput_t *" -ida_diskio.create_memory_linput (function) - create_memory_linput(start, size) -> linput_t * - Create a linput for process memory. This linput will use read_dbg_memory() to - read data. - - @param start: (C++: ea_t) starting address of the input - @param size: (C++: asize_t) size of the memory area to represent as linput if unknown, may be - passed as 0 +ida_diskio.create_memory_linput(start: ida_idaapi.ea_t, size: "asize_t") -> "linput_t *" -ida_diskio.eclose (function) - eclose(fp) - - @param fp: FILE * - -ida_diskio.enumerate_files (function) - enumerate_files(path, fname, callback) -> PyObject * +ida_diskio.enumerate_files(path, fname, callback) Enumerate files in the specified directory while the callback returns 0. @param path: directory to enumerate files in @@ -21068,2712 +14125,1489 @@ ida_diskio.enumerate_files (function) @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 + @return: + None in case of script errors tuple(code, fname) : If the callback returns non-zero -ida_diskio.enumerate_files2 (function) - enumerate_files2(answer, answer_size, path, fname, fv) -> int +ida_diskio.file_enumerator_t + +ida_diskio.file_enumerator_t.__disown__(self) + +ida_diskio.file_enumerator_t.__init__(self) + +ida_diskio.file_enumerator_t.visit_file(self, file: str) -> int + +ida_diskio.fopenA(file: str) -> "FILE *" + +ida_diskio.fopenM(file: str) -> "FILE *" + +ida_diskio.fopenRB(file: str) -> "FILE *" + +ida_diskio.fopenRT(file: str) -> "FILE *" + +ida_diskio.fopenWB(file: str) -> "FILE *" + +ida_diskio.fopenWT(file: str) -> "FILE *" + +ida_diskio.generic_linput_t + +ida_diskio.generic_linput_t.__init__(self, *args, **kwargs) + +ida_diskio.generic_linput_t.read(self, off: "qoff64_t", buffer: "void *", nbytes: "size_t") -> "ssize_t" + +ida_diskio.get_ida_subdirs(subdir: str, flags: int = 0) -> "qstrvec_t *" + Get list of directories in which to find a specific IDA resource (see IDA subdirectories). The order of the resulting list is as follows: + [$IDAUSR/subdir (0..N entries)] + $IDADIR/subdir - @param answer: char * - @param answer_size: size_t - @param path: char const * - @param fname: char const * - @param fv: file_enumerator_t & - -ida_diskio.file_enumerator_t (class) - Proxy of C++ file_enumerator_t class. - -ida_diskio.file_enumerator_t.__disown__ (method) - -ida_diskio.file_enumerator_t.__init__ (method) - __init__(self) -> file_enumerator_t - @param self: PyObject * + + @param subdir: name of the resource to list (can be nullptr) + @param flags: Subdirectory modification flags bits + @returns number of directories appended to 'dirs' -ida_diskio.file_enumerator_t.visit_file (method) - visit_file(self, file) -> int +ida_diskio.get_linput_type(li: "linput_t *") -> "linput_type_t" + +ida_diskio.get_special_folder(csidl: int) -> str + Get a folder location by CSIDL (see Common CSIDLs). Path should be of at least MAX_PATH size + + +ida_diskio.get_user_idadir() -> str + Get user ida related directory. + if $IDAUSR is defined: + - the first element in $IDAUSR + else + - default user directory ($HOME/.idapro or %APPDATA%Hex-Rays/IDA Pro) - @param file: char const * - -ida_diskio.fopenA (function) - fopenA(file) -> FILE * - Open a file for append in text mode, deny none. - @param file: (C++: const char *) char const * - @return: nullptr if failure + -ida_diskio.fopenM (function) - fopenM(file) -> FILE * - Open a file for read/write in binary mode, deny write. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenRB (function) - fopenRB(file) -> FILE * - Open a file for read in binary mode, deny none. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenRT (function) - fopenRT(file) -> FILE * - Open a file for read in text mode, deny none. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenWB (function) - fopenWB(file) -> FILE * - Open a new file for write in binary mode, deny read/write. If a file exists, it - will be removed. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenWT (function) - fopenWT(file) -> FILE * - Open a new file for write in text mode, deny write. If a file exists, it will be - removed. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.generic_linput_t (class) - Proxy of C++ generic_linput_t class. - -ida_diskio.generic_linput_t.__init__ (method) - -ida_diskio.generic_linput_t.blocksize (variable) - preferred block size to work with read/write sizes will be in multiples of this - number. for example, 4096 is a nice value blocksize 0 means that the filesize is - unknown. the internal cache will be disabled in this case. also, seeks from the - file end will fail. blocksize=-1 means error. - -ida_diskio.generic_linput_t.filesize (variable) - input file size - -ida_diskio.generic_linput_t.read (method) - read(self, off, buffer, nbytes) -> ssize_t - - @param off: qoff64_t - @param buffer: void * - @param nbytes: size_t - -ida_diskio.get_ida_subdirs (function) - get_ida_subdirs(subdir, flags=0) -> int - Get list of directories in which to find a specific IDA resource (see IDA - subdirectories). The order of the resulting list is as follows: - - [$IDAUSR/subdir (0..N entries)] - - $IDADIR/subdir - - @param subdir: (C++: const char *) name of the resource to list - @param flags: (C++: int) Subdirectory modification flags bits - @return: number of directories appended to 'dirs' - -ida_diskio.get_linput_type (function) - get_linput_type(li) -> linput_type_t - Get linput type. - - @param li: (C++: linput_t *) - -ida_diskio.get_special_folder (function) - get_special_folder(csidl) -> str - Get a folder location by CSIDL (see Common CSIDLs). Path should be of at least - MAX_PATH size - - @param csidl: (C++: int) - -ida_diskio.get_user_idadir (function) - get_user_idadir() -> char const * - Get user ida related directory. - - if $IDAUSR is defined: - - the first element in $IDAUSR - - else - - default user directory ($HOME/.idapro or %APPDATA%Hex-Rays/IDA Pro) - -ida_diskio.getsysfile (function) - getsysfile(filename, subdir) -> str +ida_diskio.getsysfile(filename: str, subdir: str) -> str Search for IDA system file. This function searches for a file in: - 1. each directory specified by IDAUSR% - 2. ida directory [+ subdir] and returns the first match. + 0. each directory specified by IDAUSR% + 1. ida directory [+ subdir] - @param filename: (C++: const char *) name of file to search - @param subdir: (C++: const char *) if specified, the file is looked for in the specified - subdirectory of the ida directory first (see IDA subdirectories) - @return: nullptr if not found, otherwise a pointer to full file name. - -ida_diskio.idadir (function) - idadir(subdir) -> char const * - Get IDA directory (if subdir==nullptr) or the specified subdirectory (see IDA - subdirectories) - @param subdir: (C++: const char *) char const * + and returns the first match. + + @param filename: name of file to search + @param subdir: if specified, the file is looked for in the specified subdirectory of the ida directory first (see IDA subdirectories) + @returns nullptr if not found, otherwise a pointer to full file name. -ida_diskio.ioports_fallback_t (class) - Proxy of C++ ioports_fallback_t class. +ida_diskio.idadir(subdir: str) -> str + Get IDA directory (if subdir==nullptr) or the specified subdirectory (see IDA subdirectories) + -ida_diskio.ioports_fallback_t.__disown__ (method) +ida_diskio.ioports_fallback_t -ida_diskio.ioports_fallback_t.__init__ (method) - __init__(self) -> ioports_fallback_t - - @param self: PyObject * +ida_diskio.ioports_fallback_t.__disown__(self) -ida_diskio.ioports_fallback_t.handle (method) - handle(self, ports, line) -> bool - - @param ports: ioports_t const & - @param line: char const * +ida_diskio.ioports_fallback_t.__init__(self) -ida_diskio.open_linput (function) - open_linput(file, remote) -> linput_t * - Open loader input. - - @param file: (C++: const char *) char const * - @param remote: (C++: bool) +ida_diskio.ioports_fallback_t.handle(self, ports: "ioports_t const &", line: str) -> bool + @param ports: i/o port definitions + @param line: input line to parse + @returns success or fills ERRBUF with an error message -ida_diskio.qlgetz (function) - qlgetz(li, fpos) -> str - Read a zero-terminated string from the input. If fpos == -1 then no seek will be - performed. - - @param li: (C++: linput_t *) - @param fpos: (C++: int64) +ida_diskio.open_linput(file: str, remote: bool) -> "linput_t *" -ida_diskio.read_ioports2 (function) - read_ioports2(ports, device, file, callback=None) -> ssize_t - - @param ports: ioports_t * - @param device: qstring * - @param file: char const * - @param callback: ioports_fallback_t * +ida_diskio.qlgetz(li: "linput_t *", fpos: "int64") -> str -ida_dirtree (module) +ida_diskio.read_ioports(ports: "ioports_t *", device: str, file: str, callback: "ioports_fallback_t" = None) -> "ssize_t" + +ida_dirtree Types involved in grouping of item into folders. - The dirtree_t class is used to organize a directory tree on top of any - collection that allows for accessing its elements by an id (inode). - - No requirements are imposed on the inodes apart from the forbidden value -1 (it - is used ot denote a bad inode). - - The dirspec_t class is used to specialize the dirtree. It can be used to - introduce a directory structure for: + The dirtree_t class is used to organize a directory tree on top of any collection that allows for accessing its elements by an id (inode). + No requirements are imposed on the inodes apart from the forbidden value -1 (used to denote a bad inode). + The dirspec_t class is used to specialize the dirtree. It can be used to introduce a directory structure for: * local types * structs * enums * functions * names * etc - - @note: you should be manipulating dirtree_t (and, if implementing a new tree - backend, dirspec_t) instances, not calling top-level functions in this - file directly. -ida_dirtree.DTN_DISPLAY_NAME (variable) - use short, displayable form of the entry name. for example, 'std::string' - instead of 'std::basic_string'. Note that more than one "full name" - can have the same displayable name. +ida_dirtree.DTE_ALREADY_EXISTS + item already exists -ida_dirtree.DTN_FULL_NAME (variable) - use long form of the entry name. That name is unique. +ida_dirtree.DTE_BAD_PATH + invalid path -ida_dirtree.direntry_t (class) - Proxy of C++ direntry_t class. +ida_dirtree.DTE_CANT_RENAME + failed to rename an item -ida_dirtree.direntry_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: direntry_t const & +ida_dirtree.DTE_MAX_DIR + maximum directory count achieved -ida_dirtree.direntry_t.__init__ (method) - __init__(self, i=BADIDX, d=False) -> direntry_t - - @param i: uval_t - @param d: bool +ida_dirtree.DTE_NOT_DIRECTORY + item is not a directory -ida_dirtree.direntry_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: direntry_t const & +ida_dirtree.DTE_NOT_EMPTY + directory is not empty -ida_dirtree.direntry_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: direntry_t const & +ida_dirtree.DTE_NOT_FOUND + item not found -ida_dirtree.direntry_t.idx (variable) +ida_dirtree.DTE_OK + ok + +ida_dirtree.DTE_OWN_CHILD + moving inside subdirectory of itself + +ida_dirtree.DTN_DISPLAY_NAME + use short, displayable form of the entry name. for example, 'std::string' instead of 'std::basic_string'. Note that more than one "full name" can have the same displayable name. + + +ida_dirtree.DTN_FULL_NAME + use long form of the entry name. That name is unique. + + +ida_dirtree.direntry_t + +ida_dirtree.direntry_t.__eq__(self, r: "direntry_t") -> bool + +ida_dirtree.direntry_t.__init__(self, *args) + +ida_dirtree.direntry_t.__lt__(self, r: "direntry_t") -> bool + +ida_dirtree.direntry_t.__ne__(self, r: "direntry_t") -> bool + +ida_dirtree.direntry_t.idx diridx_t or inode_t -ida_dirtree.direntry_t.isdir (variable) +ida_dirtree.direntry_t.isdir is 'idx' a diridx_t, or an inode_t -ida_dirtree.direntry_t.valid (method) - valid(self) -> bool +ida_dirtree.direntry_t.valid(self) -> bool -ida_dirtree.direntry_vec_t (class) - Proxy of C++ qvector< direntry_t > class. +ida_dirtree.direntry_vec_t -ida_dirtree.direntry_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< direntry_t > const & +ida_dirtree.direntry_vec_t.__eq__(self, r: "direntry_vec_t") -> bool -ida_dirtree.direntry_vec_t.__getitem__ (method) - __getitem__(self, i) -> direntry_t - - @param i: size_t +ida_dirtree.direntry_vec_t.__getitem__(self, i: "size_t") -> "direntry_t const &" -ida_dirtree.direntry_vec_t.__init__ (method) - __init__(self) -> direntry_vec_t - __init__(self, x) -> direntry_vec_t - - @param x: qvector< direntry_t > const & +ida_dirtree.direntry_vec_t.__init__(self, *args) -ida_dirtree.direntry_vec_t.__len__ (method) - __len__(self) -> size_t +ida_dirtree.direntry_vec_t.__len__(self) -> "size_t" -ida_dirtree.direntry_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< direntry_t > const & +ida_dirtree.direntry_vec_t.__ne__(self, r: "direntry_vec_t") -> bool -ida_dirtree.direntry_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: direntry_t const & +ida_dirtree.direntry_vec_t.__setitem__(self, i: "size_t", v: "direntry_t") -> None -ida_dirtree.direntry_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: direntry_t const & +ida_dirtree.direntry_vec_t._del(self, x: "direntry_t") -> bool -ida_dirtree.direntry_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: direntry_t const & +ida_dirtree.direntry_vec_t.add_unique(self, x: "direntry_t") -> bool -ida_dirtree.direntry_vec_t.at (method) - at(self, _idx) -> direntry_t - - @param _idx: size_t +ida_dirtree.direntry_vec_t.append(self, x: "direntry_t") -> None -ida_dirtree.direntry_vec_t.begin (method) - begin(self) -> direntry_t +ida_dirtree.direntry_vec_t.at(self, _idx: "size_t") -> "direntry_t const &" -ida_dirtree.direntry_vec_t.capacity (method) - capacity(self) -> size_t +ida_dirtree.direntry_vec_t.begin(self, *args) -> "qvector< direntry_t >::const_iterator" -ida_dirtree.direntry_vec_t.clear (method) - clear(self) +ida_dirtree.direntry_vec_t.capacity(self) -> "size_t" -ida_dirtree.direntry_vec_t.empty (method) - empty(self) -> bool +ida_dirtree.direntry_vec_t.clear(self) -> None -ida_dirtree.direntry_vec_t.end (method) - end(self) -> direntry_t +ida_dirtree.direntry_vec_t.empty(self) -> bool -ida_dirtree.direntry_vec_t.erase (method) - erase(self, it) -> direntry_t - - @param it: qvector< direntry_t >::iterator - - erase(self, first, last) -> direntry_t - - @param first: qvector< direntry_t >::iterator - @param last: qvector< direntry_t >::iterator +ida_dirtree.direntry_vec_t.end(self, *args) -> "qvector< direntry_t >::const_iterator" -ida_dirtree.direntry_vec_t.extract (method) - extract(self) -> direntry_t +ida_dirtree.direntry_vec_t.erase(self, *args) -> "qvector< direntry_t >::iterator" -ida_dirtree.direntry_vec_t.find (method) - find(self, x) -> direntry_t - - @param x: direntry_t const & +ida_dirtree.direntry_vec_t.extend(self, x: "direntry_vec_t") -> None -ida_dirtree.direntry_vec_t.grow (method) - grow(self, x=direntry_t()) - - @param x: direntry_t const & +ida_dirtree.direntry_vec_t.extract(self) -> "direntry_t *" -ida_dirtree.direntry_vec_t.has (method) - has(self, x) -> bool - - @param x: direntry_t const & +ida_dirtree.direntry_vec_t.find(self, *args) -> "qvector< direntry_t >::const_iterator" -ida_dirtree.direntry_vec_t.inject (method) - inject(self, s, len) - - @param s: direntry_t * - @param len: size_t +ida_dirtree.direntry_vec_t.grow(self, *args) -> None -ida_dirtree.direntry_vec_t.insert (method) - insert(self, it, x) -> direntry_t - - @param it: qvector< direntry_t >::iterator - @param x: direntry_t const & +ida_dirtree.direntry_vec_t.has(self, x: "direntry_t") -> bool -ida_dirtree.direntry_vec_t.pop_back (method) - pop_back(self) +ida_dirtree.direntry_vec_t.inject(self, s: "direntry_t", len: "size_t") -> None -ida_dirtree.direntry_vec_t.push_back (method) - push_back(self, x) - - @param x: direntry_t const & - - push_back(self) -> direntry_t +ida_dirtree.direntry_vec_t.insert(self, it: "direntry_t", x: "direntry_t") -> "qvector< direntry_t >::iterator" -ida_dirtree.direntry_vec_t.qclear (method) - qclear(self) +ida_dirtree.direntry_vec_t.pop_back(self) -> None -ida_dirtree.direntry_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_dirtree.direntry_vec_t.push_back(self, *args) -> "direntry_t &" -ida_dirtree.direntry_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: direntry_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_dirtree.direntry_vec_t.qclear(self) -> None -ida_dirtree.direntry_vec_t.size (method) - size(self) -> size_t +ida_dirtree.direntry_vec_t.reserve(self, cnt: "size_t") -> None -ida_dirtree.direntry_vec_t.swap (method) - swap(self, r) - - @param r: qvector< direntry_t > & +ida_dirtree.direntry_vec_t.resize(self, *args) -> None -ida_dirtree.direntry_vec_t.truncate (method) - truncate(self) +ida_dirtree.direntry_vec_t.size(self) -> "size_t" -ida_dirtree.dirspec_t (class) - Proxy of C++ dirspec_t class. +ida_dirtree.direntry_vec_t.swap(self, r: "direntry_vec_t") -> None -ida_dirtree.dirspec_t.__disown__ (method) +ida_dirtree.direntry_vec_t.truncate(self) -> None -ida_dirtree.dirspec_t.__init__ (method) - __init__(self, nm=None, f=0) -> dirspec_t - - @param nm: char const * - @param f: uint32 +ida_dirtree.dirspec_t -ida_dirtree.dirspec_t.get_attrs (method) - get_attrs(self, inode) -> qstring - - @param inode: inode_t +ida_dirtree.dirspec_t.__disown__(self) -ida_dirtree.dirspec_t.get_inode (method) - get_inode(self, dirpath, name) -> inode_t - get the entry inode in the specified directory - - @param dirpath: (C++: const char *) the absolute directory path with trailing slash - @param name: (C++: const char *) the entry name in the directory - @return: the entry inode +ida_dirtree.dirspec_t.__init__(self, nm: str = None, f: int = 0) -ida_dirtree.dirspec_t.get_name (method) - get_name(self, inode, name_flags=DTN_FULL_NAME) -> bool - get the entry name. for example, the structure name - - @param inode: (C++: inode_t) inode number of the entry - @param name_flags: (C++: uint32) how exactly the name should be retrieved. combination of bits - for get_...name() methods bits - @return: false if the entry does not exist. +ida_dirtree.dirspec_t.get_attrs(self, inode: "inode_t") -> str -ida_dirtree.dirspec_t.is_orderable (method) - is_orderable(self) -> bool +ida_dirtree.dirspec_t.get_inode(self, dirpath: str, name: str) -> "inode_t" + get the entry inode in the specified directory + + @param dirpath: the absolute directory path with trailing slash + @param name: the entry name in the directory + @returns the entry inode -ida_dirtree.dirspec_t.rename_inode (method) - rename_inode(self, inode, newname) -> bool - rename the entry - - @param inode: (C++: inode_t) - @param newname: (C++: const char *) - @return: success +ida_dirtree.dirspec_t.get_name(self, inode: "inode_t", name_flags: int = DTN_FULL_NAME) -> bool + get the entry name. for example, the structure name + + @param inode: inode number of the entry + @param name_flags: how exactly the name should be retrieved. combination of bits for get_...name() methods bits + @returns false if the entry does not exist. -ida_dirtree.dirspec_t.unlink_inode (method) - unlink_inode(self, inode) - - @param inode: (C++: inode_t) +ida_dirtree.dirspec_t.is_orderable(self) -> bool -ida_dirtree.dirtree_cursor_t (class) - Proxy of C++ dirtree_cursor_t class. +ida_dirtree.dirspec_t.rename_inode(self, inode: "inode_t", newname: str) -> bool + rename the entry + + @returns success -ida_dirtree.dirtree_cursor_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: dirtree_cursor_t const & +ida_dirtree.dirspec_t.unlink_inode(self, inode: "inode_t") -> None + event: unlinked an inode + -ida_dirtree.dirtree_cursor_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_t -ida_dirtree.dirtree_cursor_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_t.__eq__(self, r: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_t.__init__ (method) - __init__(self, _parent=BADIDX, _rank=size_t(-1)) -> dirtree_cursor_t - - @param _parent: diridx_t - @param _rank: size_t +ida_dirtree.dirtree_cursor_t.__ge__(self, r: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_t.__le__ (method) - __le__(self, r) -> bool - - @param r: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_t.__gt__(self, r: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_t.__init__(self, *args) -ida_dirtree.dirtree_cursor_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_t.__le__(self, r: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_t.compare (method) - compare(self, r) -> int - - @param r: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_t.__lt__(self, r: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_t.is_root_cursor (method) - is_root_cursor(self) -> bool +ida_dirtree.dirtree_cursor_t.__ne__(self, r: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_t.parent (variable) +ida_dirtree.dirtree_cursor_t.compare(self, r: "dirtree_cursor_t") -> int + +ida_dirtree.dirtree_cursor_t.is_root_cursor(self) -> bool + +ida_dirtree.dirtree_cursor_t.parent the parent directory -ida_dirtree.dirtree_cursor_t.rank (variable) +ida_dirtree.dirtree_cursor_t.rank the index into the parent directory -ida_dirtree.dirtree_cursor_t.root_cursor (method) - root_cursor() -> dirtree_cursor_t +ida_dirtree.dirtree_cursor_t.root_cursor() -> "dirtree_cursor_t" -ida_dirtree.dirtree_cursor_t.set_root_cursor (method) - set_root_cursor(self) +ida_dirtree.dirtree_cursor_t.set_root_cursor(self) -> None -ida_dirtree.dirtree_cursor_t.valid (method) - valid(self) -> bool +ida_dirtree.dirtree_cursor_t.valid(self) -> bool -ida_dirtree.dirtree_cursor_t_root_cursor (function) - dirtree_cursor_t_root_cursor() -> dirtree_cursor_t +ida_dirtree.dirtree_cursor_vec_t -ida_dirtree.dirtree_cursor_vec_t (class) - Proxy of C++ qvector< dirtree_cursor_t > class. +ida_dirtree.dirtree_cursor_vec_t.__eq__(self, r: "dirtree_cursor_vec_t") -> bool -ida_dirtree.dirtree_cursor_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< dirtree_cursor_t > const & +ida_dirtree.dirtree_cursor_vec_t.__getitem__(self, i: "size_t") -> "dirtree_cursor_t const &" -ida_dirtree.dirtree_cursor_vec_t.__getitem__ (method) - __getitem__(self, i) -> dirtree_cursor_t - - @param i: size_t +ida_dirtree.dirtree_cursor_vec_t.__init__(self, *args) -ida_dirtree.dirtree_cursor_vec_t.__init__ (method) - __init__(self) -> dirtree_cursor_vec_t - __init__(self, x) -> dirtree_cursor_vec_t - - @param x: qvector< dirtree_cursor_t > const & +ida_dirtree.dirtree_cursor_vec_t.__len__(self) -> "size_t" -ida_dirtree.dirtree_cursor_vec_t.__len__ (method) - __len__(self) -> size_t +ida_dirtree.dirtree_cursor_vec_t.__ne__(self, r: "dirtree_cursor_vec_t") -> bool -ida_dirtree.dirtree_cursor_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< dirtree_cursor_t > const & +ida_dirtree.dirtree_cursor_vec_t.__setitem__(self, i: "size_t", v: "dirtree_cursor_t") -> None -ida_dirtree.dirtree_cursor_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_vec_t._del(self, x: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_vec_t.add_unique(self, x: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_vec_t.append(self, x: "dirtree_cursor_t") -> None -ida_dirtree.dirtree_cursor_vec_t.at (method) - at(self, _idx) -> dirtree_cursor_t - - @param _idx: size_t +ida_dirtree.dirtree_cursor_vec_t.at(self, _idx: "size_t") -> "dirtree_cursor_t const &" -ida_dirtree.dirtree_cursor_vec_t.begin (method) - begin(self) -> dirtree_cursor_t +ida_dirtree.dirtree_cursor_vec_t.begin(self, *args) -> "qvector< dirtree_cursor_t >::const_iterator" -ida_dirtree.dirtree_cursor_vec_t.capacity (method) - capacity(self) -> size_t +ida_dirtree.dirtree_cursor_vec_t.capacity(self) -> "size_t" -ida_dirtree.dirtree_cursor_vec_t.clear (method) - clear(self) +ida_dirtree.dirtree_cursor_vec_t.clear(self) -> None -ida_dirtree.dirtree_cursor_vec_t.empty (method) - empty(self) -> bool +ida_dirtree.dirtree_cursor_vec_t.empty(self) -> bool -ida_dirtree.dirtree_cursor_vec_t.end (method) - end(self) -> dirtree_cursor_t +ida_dirtree.dirtree_cursor_vec_t.end(self, *args) -> "qvector< dirtree_cursor_t >::const_iterator" -ida_dirtree.dirtree_cursor_vec_t.erase (method) - erase(self, it) -> dirtree_cursor_t - - @param it: qvector< dirtree_cursor_t >::iterator - - erase(self, first, last) -> dirtree_cursor_t - - @param first: qvector< dirtree_cursor_t >::iterator - @param last: qvector< dirtree_cursor_t >::iterator +ida_dirtree.dirtree_cursor_vec_t.erase(self, *args) -> "qvector< dirtree_cursor_t >::iterator" -ida_dirtree.dirtree_cursor_vec_t.extract (method) - extract(self) -> dirtree_cursor_t +ida_dirtree.dirtree_cursor_vec_t.extend(self, x: "dirtree_cursor_vec_t") -> None -ida_dirtree.dirtree_cursor_vec_t.find (method) - find(self, x) -> dirtree_cursor_t - - @param x: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_vec_t.extract(self) -> "dirtree_cursor_t *" -ida_dirtree.dirtree_cursor_vec_t.grow (method) - grow(self, x=dirtree_cursor_t()) - - @param x: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_vec_t.find(self, *args) -> "qvector< dirtree_cursor_t >::const_iterator" -ida_dirtree.dirtree_cursor_vec_t.has (method) - has(self, x) -> bool - - @param x: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_vec_t.grow(self, *args) -> None -ida_dirtree.dirtree_cursor_vec_t.inject (method) - inject(self, s, len) - - @param s: dirtree_cursor_t * - @param len: size_t +ida_dirtree.dirtree_cursor_vec_t.has(self, x: "dirtree_cursor_t") -> bool -ida_dirtree.dirtree_cursor_vec_t.insert (method) - insert(self, it, x) -> dirtree_cursor_t - - @param it: qvector< dirtree_cursor_t >::iterator - @param x: dirtree_cursor_t const & +ida_dirtree.dirtree_cursor_vec_t.inject(self, s: "dirtree_cursor_t", len: "size_t") -> None -ida_dirtree.dirtree_cursor_vec_t.pop_back (method) - pop_back(self) +ida_dirtree.dirtree_cursor_vec_t.insert(self, it: "dirtree_cursor_t", x: "dirtree_cursor_t") -> "qvector< dirtree_cursor_t >::iterator" -ida_dirtree.dirtree_cursor_vec_t.push_back (method) - push_back(self, x) - - @param x: dirtree_cursor_t const & - - push_back(self) -> dirtree_cursor_t +ida_dirtree.dirtree_cursor_vec_t.pop_back(self) -> None -ida_dirtree.dirtree_cursor_vec_t.qclear (method) - qclear(self) +ida_dirtree.dirtree_cursor_vec_t.push_back(self, *args) -> "dirtree_cursor_t &" -ida_dirtree.dirtree_cursor_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_dirtree.dirtree_cursor_vec_t.qclear(self) -> None -ida_dirtree.dirtree_cursor_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: dirtree_cursor_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_dirtree.dirtree_cursor_vec_t.reserve(self, cnt: "size_t") -> None -ida_dirtree.dirtree_cursor_vec_t.size (method) - size(self) -> size_t +ida_dirtree.dirtree_cursor_vec_t.resize(self, *args) -> None -ida_dirtree.dirtree_cursor_vec_t.swap (method) - swap(self, r) - - @param r: qvector< dirtree_cursor_t > & +ida_dirtree.dirtree_cursor_vec_t.size(self) -> "size_t" -ida_dirtree.dirtree_cursor_vec_t.truncate (method) - truncate(self) +ida_dirtree.dirtree_cursor_vec_t.swap(self, r: "dirtree_cursor_vec_t") -> None -ida_dirtree.dirtree_iterator_t (class) - Proxy of C++ dirtree_iterator_t class. +ida_dirtree.dirtree_cursor_vec_t.truncate(self) -> None -ida_dirtree.dirtree_iterator_t.__init__ (method) - __init__(self) -> dirtree_iterator_t +ida_dirtree.dirtree_iterator_t -ida_dirtree.dirtree_selection_t (class) - Proxy of C++ dirtree_selection_t class. +ida_dirtree.dirtree_iterator_t.__init__(self) -ida_dirtree.dirtree_selection_t.__init__ (method) - __init__(self) -> dirtree_selection_t +ida_dirtree.dirtree_selection_t -ida_dirtree.dirtree_t (class) - Proxy of C++ dirtree_t class. +ida_dirtree.dirtree_selection_t.__init__(self) -ida_dirtree.dirtree_t.__init__ (method) - __init__(self, ds) -> dirtree_t - - @param ds: dirspec_t * +ida_dirtree.dirtree_t -ida_dirtree.dirtree_t.change_rank (method) - change_rank(self, path, rank_delta) -> dterr_t - Change ordering rank of an item. - - @param path: (C++: const char *) path to the item - @param rank_delta: (C++: ssize_t) the amount of the change. positive numbers mean to move down - in the list; negative numbers mean to move up. - @return: dterr_t error code - @note: this function may disable natural ordering of the parent folder - @see: set_natural_order() +ida_dirtree.dirtree_t.__init__(self, ds: "dirspec_t") -ida_dirtree.dirtree_t.chdir (method) - chdir(self, path) -> dterr_t - Change current directory - - @param path: (C++: const char *) new current directory - @return: dterr_t error code +ida_dirtree.dirtree_t.change_rank(self, path: str, rank_delta: "ssize_t") -> "dterr_t" + Change ordering rank of an item. + + @param path: path to the item + @param rank_delta: the amount of the change. positive numbers mean to move down in the list; negative numbers mean to move up. + @returns dterr_t error code -ida_dirtree.dirtree_t.errstr (method) - errstr(err) -> char const * +ida_dirtree.dirtree_t.chdir(self, path: str) -> "dterr_t" + Change current directory + + @param path: new current directory + @returns dterr_t error code + +ida_dirtree.dirtree_t.errstr(err: "dterr_t") -> str Get textual representation of the error code. - - @param err: (C++: dterr_t) enum dterr_t -ida_dirtree.dirtree_t.find_entry (method) - find_entry(self, de) -> dirtree_cursor_t - Find the cursor corresponding to an entry of a directory - - @param de: (C++: const direntry_t &) directory entry - @return: cursor corresponding to the directory entry +ida_dirtree.dirtree_t.find_entry(self, de: "direntry_t") -> "dirtree_cursor_t" + Find the cursor corresponding to an entry of a directory + + @param de: directory entry + @returns cursor corresponding to the directory entry -ida_dirtree.dirtree_t.findfirst (method) - findfirst(self, ff, pattern) -> bool - Start iterating over files in a directory - - @param ff: (C++: dirtree_iterator_t *) directory iterator. it will be initialized by the function - @param pattern: (C++: const char *) pattern to search for - @return: success +ida_dirtree.dirtree_t.findfirst(self, ff: "dirtree_iterator_t", pattern: str) -> bool + Start iterating over files in a directory + + @param ff: directory iterator. it will be initialized by the function + @param pattern: pattern to search for + @returns success -ida_dirtree.dirtree_t.findnext (method) - findnext(self, ff) -> bool - Continue iterating over files in a directory - - @param ff: (C++: dirtree_iterator_t *) directory iterator - @return: success +ida_dirtree.dirtree_t.findnext(self, ff: "dirtree_iterator_t") -> bool + Continue iterating over files in a directory + + @param ff: directory iterator + @returns success -ida_dirtree.dirtree_t.get_abspath (method) - get_abspath(self, cursor, name_flags=DTN_FULL_NAME) -> qstring - Construct an absolute path from the specified relative path. This function - verifies the directory part of the specified path. The last component of the - specified path is not verified. +ida_dirtree.dirtree_t.get_abspath(self, *args) -> str + This function has the following signatures: - @param cursor: dirtree_cursor_t const & - @param name_flags: uint32 + 0. get_abspath(cursor: const dirtree_cursor_t &, name_flags: int=DTN_FULL_NAME) -> str + 1. get_abspath(relpath: str) -> str - @return: path. empty path means wrong directory part of RELPATH - get_abspath(self, relpath) -> qstring + # 0: get_abspath(cursor: const dirtree_cursor_t &, name_flags: int=DTN_FULL_NAME) -> str - @param relpath: char const * + Get absolute path pointed by the cursor + + @returns path; empty string if error + + # 1: get_abspath(relpath: str) -> str + + Construct an absolute path from the specified relative path. This function verifies the directory part of the specified path. The last component of the specified path is not verified. + + @returns path. empty path means wrong directory part of RELPATH -ida_dirtree.dirtree_t.get_dir_size (method) - get_dir_size(self, diridx) -> ssize_t - Get dir size - - @param diridx: (C++: diridx_t) directory index - @return: number of entries under this directory; if error, return -1 +ida_dirtree.dirtree_t.get_dir_size(self, diridx: "diridx_t") -> "ssize_t" + Get dir size + + @param diridx: directory index + @returns number of entries under this directory; if error, return -1 -ida_dirtree.dirtree_t.get_entry_attrs (method) - get_entry_attrs(self, de) -> qstring - Get entry attributes - - @param de: (C++: const direntry_t &) directory entry - @return: name +ida_dirtree.dirtree_t.get_entry_attrs(self, de: "direntry_t") -> str + Get entry attributes + + @param de: directory entry + @returns name -ida_dirtree.dirtree_t.get_entry_name (method) - get_entry_name(self, de, name_flags=DTN_FULL_NAME) -> qstring - Get entry name - - @param de: (C++: const direntry_t &) directory entry - @param name_flags: (C++: uint32) how exactly the name should be retrieved. combination of bits - for get_...name() methods bits - @return: name +ida_dirtree.dirtree_t.get_entry_name(self, de: "direntry_t", name_flags: int = DTN_FULL_NAME) -> str + Get entry name + + @param de: directory entry + @param name_flags: how exactly the name should be retrieved. combination of bits for get_...name() methods bits + @returns name -ida_dirtree.dirtree_t.get_id (method) - get_id(self) -> char const * +ida_dirtree.dirtree_t.get_id(self) -> str netnode name -ida_dirtree.dirtree_t.get_parent_cursor (method) - get_parent_cursor(self, cursor) -> dirtree_cursor_t - Get parent cursor. - - @param cursor: (C++: const dirtree_cursor_t &) a valid ditree cursor - @return: cursor's parent +ida_dirtree.dirtree_t.get_parent_cursor(self, cursor: "dirtree_cursor_t") -> "dirtree_cursor_t" + Get parent cursor. + + @param cursor: a valid ditree cursor + @returns cursor's parent -ida_dirtree.dirtree_t.get_rank (method) - get_rank(self, diridx, de) -> ssize_t - Get ordering rank of an item. - - @param diridx: (C++: diridx_t) index of the parent directory - @param de: (C++: const direntry_t &) directory entry - @return: number in a range of [0..n) where n is the number of entries in the - parent directory. -1 if error +ida_dirtree.dirtree_t.get_rank(self, diridx: "diridx_t", de: "direntry_t") -> "ssize_t" + Get ordering rank of an item. + + @param diridx: index of the parent directory + @param de: directory entry + @returns number in a range of [0..n) where n is the number of entries in the parent directory. -1 if error -ida_dirtree.dirtree_t.getcwd (method) - getcwd(self) -> qstring - Get current directory - - @return: the current working directory +ida_dirtree.dirtree_t.getcwd(self) -> str + Get current directory + + @returns the current working directory -ida_dirtree.dirtree_t.is_dir_ordered (method) - is_dir_ordered(self, diridx) -> bool - Is dir ordered? - - @param diridx: (C++: diridx_t) - @return: true if the dirtree has natural ordering +ida_dirtree.dirtree_t.is_dir_ordered(self, diridx: "diridx_t") -> bool + Is dir ordered? + + @returns true if the dirtree has natural ordering -ida_dirtree.dirtree_t.is_orderable (method) - is_orderable(self) -> bool - Is dirtree orderable? - - @return: true if the dirtree is orderable +ida_dirtree.dirtree_t.is_orderable(self) -> bool + Is dirtree orderable? + + @returns true if the dirtree is orderable -ida_dirtree.dirtree_t.isdir (method) - isdir(self, de) -> bool +ida_dirtree.dirtree_t.isdir(self, *args) -> bool + This function has the following signatures: - @param de: direntry_t const & + 0. isdir(path: str) -> bool + 1. isdir(de: const direntry_t &) -> bool - isdir(self, path) -> bool + # 0: isdir(path: str) -> bool - @param path: char const * + Is a directory? + + @returns true if the specified path is a directory + + # 1: isdir(de: const direntry_t &) -> bool -ida_dirtree.dirtree_t.isfile (method) - isfile(self, de) -> bool +ida_dirtree.dirtree_t.isfile(self, *args) -> bool + This function has the following signatures: - @param de: direntry_t const & + 0. isfile(path: str) -> bool + 1. isfile(de: const direntry_t &) -> bool - isfile(self, path) -> bool + # 0: isfile(path: str) -> bool - @param path: char const * + Is a file? + + @returns true if the specified path is a file + + # 1: isfile(de: const direntry_t &) -> bool -ida_dirtree.dirtree_t.link (method) - link(self, path) -> dterr_t - Add an inode into the current directory +ida_dirtree.dirtree_t.link(self, *args) -> "dterr_t" + This function has the following signatures: - @param path: char const * + 0. link(path: str) -> dterr_t + 1. link(inode: inode_t) -> dterr_t - @return: dterr_t error code - link(self, inode) -> dterr_t + # 0: link(path: str) -> dterr_t - @param inode: inode_t + Add a file item into a directory. + + @returns dterr_t error code + + # 1: link(inode: inode_t) -> dterr_t + + Add an inode into the current directory + + @returns dterr_t error code -ida_dirtree.dirtree_t.load (method) - load(self) -> bool - Load the tree structure from the netnode. If dirspec_t::id is empty, the - operation will be considered a success. In addition, calling load() more than - once will not do anything, and will be considered a success. - - @return: success - @see: dirspec_t::id. +ida_dirtree.dirtree_t.load(self) -> bool + Load the tree structure from the netnode. If dirspec_t::id is empty, the operation will be considered a success. In addition, calling load() more than once will not do anything, and will be considered a success. + + @returns success -ida_dirtree.dirtree_t.mkdir (method) - mkdir(self, path) -> dterr_t - Create a directory. - - @param path: (C++: const char *) directory to create - @return: dterr_t error code +ida_dirtree.dirtree_t.mkdir(self, path: str) -> "dterr_t" + Create a directory. + + @param path: directory to create + @returns dterr_t error code -ida_dirtree.dirtree_t.notify_dirtree (method) - notify_dirtree(self, added, inode) - Notify dirtree about a change of an inode. - - @param added: (C++: bool) are we adding or deleting an inode? - @param inode: (C++: inode_t) inode in question +ida_dirtree.dirtree_t.notify_dirtree(self, added: bool, inode: "inode_t") -> None + Notify dirtree about a change of an inode. + + @param added: are we adding or deleting an inode? + @param inode: inode in question -ida_dirtree.dirtree_t.rename (method) - rename(self, _from, to) -> dterr_t - Rename a directory entry. - - @param from: (C++: const char *) source path - @param to: (C++: const char *) destination path - @return: dterr_t error code - @note: This function can also rename the item +ida_dirtree.dirtree_t.rename(self, _from: str, to: str) -> "dterr_t" + Rename a directory entry. + + @param to: destination path + @returns dterr_t error code -ida_dirtree.dirtree_t.resolve_cursor (method) - resolve_cursor(self, cursor) -> direntry_t - Resolve cursor - - @param cursor: (C++: const dirtree_cursor_t &) to analyze - @return: directory entry; if the cursor is bad, the resolved entry will be - invalid. - @note: see also get_abspath() +ida_dirtree.dirtree_t.resolve_cursor(self, cursor: "dirtree_cursor_t") -> "direntry_t" + Resolve cursor + + @param cursor: to analyze + @returns directory entry; if the cursor is bad, the resolved entry will be invalid. -ida_dirtree.dirtree_t.resolve_path (method) - resolve_path(self, path) -> direntry_t - Resolve path - - @param path: (C++: const char *) to analyze - @return: directory entry +ida_dirtree.dirtree_t.resolve_path(self, path: str) -> "direntry_t" + Resolve path + + @param path: to analyze + @returns directory entry -ida_dirtree.dirtree_t.rmdir (method) - rmdir(self, path) -> dterr_t - Remove a directory. - - @param path: (C++: const char *) directory to delete - @return: dterr_t error code +ida_dirtree.dirtree_t.rmdir(self, path: str) -> "dterr_t" + Remove a directory. + + @param path: directory to delete + @returns dterr_t error code -ida_dirtree.dirtree_t.save (method) - save(self) -> bool - Save the tree structure to the netnode. - - @return: success - @see: dirspec_t::id. +ida_dirtree.dirtree_t.save(self) -> bool + Save the tree structure to the netnode. + + @returns success -ida_dirtree.dirtree_t.set_id (method) - set_id(self, nm) - - @param nm: char const * +ida_dirtree.dirtree_t.set_id(self, nm: str) -> None -ida_dirtree.dirtree_t.set_natural_order (method) - set_natural_order(self, diridx, enable) -> bool - Enable/disable natural inode order in a directory. - - @param diridx: (C++: diridx_t) directory index - @param enable: (C++: bool) action to do TRUE - enable ordering: re-order existing entries so - that all subdirs are at the to beginning of the list, file - entries are sorted and placed after the subdirs FALSE - disable - ordering, no changes to existing entries - @return: SUCCESS +ida_dirtree.dirtree_t.set_natural_order(self, diridx: "diridx_t", enable: bool) -> bool + Enable/disable natural inode order in a directory. + + @param diridx: directory index + @param enable: action to do TRUE - enable ordering: re-order existing entries so that all subdirs are at the to beginning of the list, file entries are sorted and placed after the subdirs FALSE - disable ordering, no changes to existing entries + @returns SUCCESS -ida_dirtree.dirtree_t.traverse (method) - traverse(self, v) -> ssize_t - Traverse dirtree, and be notified at each entry If the the visitor returns - anything other than 0, iteration will stop, and that value returned. The tree is - traversed using a depth-first algorithm. It is forbidden to modify the dirtree_t - during traversal; doing so will result in undefined behavior. - - @param v: (C++: dirtree_visitor_t &) the callback - @return: 0, or whatever the visitor returned +ida_dirtree.dirtree_t.traverse(self, v: "dirtree_visitor_t") -> "ssize_t" + Traverse dirtree, and be notified at each entry If the the visitor returns anything other than 0, iteration will stop, and that value returned. The tree is traversed using a depth-first algorithm. It is forbidden to modify the dirtree_t during traversal; doing so will result in undefined behavior. + + @param v: the callback + @returns 0, or whatever the visitor returned -ida_dirtree.dirtree_t.unlink (method) - unlink(self, path) -> dterr_t - Remove an inode from the current directory +ida_dirtree.dirtree_t.unlink(self, *args) -> "dterr_t" + This function has the following signatures: - @param path: char const * + 0. unlink(path: str) -> dterr_t + 1. unlink(inode: inode_t) -> dterr_t - @return: dterr_t error code - unlink(self, inode) -> dterr_t + # 0: unlink(path: str) -> dterr_t - @param inode: inode_t - -ida_dirtree.dirtree_t_errstr (function) - dirtree_t_errstr(err) -> char const * + Remove a file item from a directory. + + @returns dterr_t error code - @param err: enum dterr_t - -ida_dirtree.dirtree_visitor_t (class) - Proxy of C++ dirtree_visitor_t class. - -ida_dirtree.dirtree_visitor_t.__disown__ (method) - -ida_dirtree.dirtree_visitor_t.__init__ (method) - __init__(self) -> dirtree_visitor_t + # 1: unlink(inode: inode_t) -> dterr_t - @param self: PyObject * + Remove an inode from the current directory + + @returns dterr_t error code -ida_dirtree.dirtree_visitor_t.visit (method) - visit(self, c, de) -> ssize_t - Will be called for each entry in the dirtree_t If something other than 0 is - returned, iteration will stop. - - @param c: (C++: const dirtree_cursor_t &) the current cursor - @param de: (C++: const direntry_t &) the current entry - @return: 0 to keep iterating, or anything else to stop +ida_dirtree.dirtree_visitor_t -ida_dirtree.get_std_dirtree (function) - get_std_dirtree(id) -> dirtree_t - - @param id: enum dirtree_id_t +ida_dirtree.dirtree_visitor_t.__disown__(self) -ida_entry (module) +ida_dirtree.dirtree_visitor_t.__init__(self) + +ida_dirtree.dirtree_visitor_t.visit(self, c: "dirtree_cursor_t", de: "direntry_t") -> "ssize_t" + Will be called for each entry in the dirtree_t If something other than 0 is returned, iteration will stop. + + @param c: the current cursor + @param de: the current entry + @returns 0 to keep iterating, or anything else to stop + +ida_dirtree.get_std_dirtree(id: "dirtree_id_t") -> "dirtree_t *" + +ida_entry Functions that deal with entry points. Exported functions are considered as entry points as well. - IDA maintains list of entry points to the program. Each entry point: * has an address * has a name - * may have an ordinal number + * may have an ordinal number + + + -ida_entry.AEF_IDBENC (variable) - the name is given in the IDB encoding; non-ASCII bytes will be decoded - accordingly. Specifying AEF_IDBENC also implies AEF_NODUMMY +ida_entry.AEF_IDBENC + the name is given in the IDB encoding; non-ASCII bytes will be decoded accordingly. Specifying AEF_IDBENC also implies AEF_NODUMMY + -ida_entry.AEF_NODUMMY (variable) - automatically prepend the name with '_' if it begins with a dummy suffix. See - also AEF_IDBENC +ida_entry.AEF_NODUMMY + automatically prepend the name with '_' if it begins with a dummy suffix. See also AEF_IDBENC + -ida_entry.AEF_UTF8 (variable) +ida_entry.AEF_UTF8 the name is given in UTF-8 (default) -ida_entry.add_entry (function) - add_entry(ord, ea, name, makecode, flags=0) -> bool - Add an entry point to the list of entry points. - - @param ord: (C++: uval_t) ordinal number if ordinal number is equal to 'ea' then ordinal is - not used - @param ea: (C++: ea_t) linear address - @param name: (C++: const char *) name of entry point. If the specified location already has a name, - the old name will be appended to the regular comment. If name == - nullptr, then the old name will be retained. - @param makecode: (C++: bool) should the kernel convert bytes at the entry point to - instruction(s) - @param flags: (C++: int) See AEF_* - @return: success (currently always true) +ida_entry.add_entry(ord: int, ea: ida_idaapi.ea_t, name: str, makecode: bool, flags: int = 0) -> bool + Add an entry point to the list of entry points. + + @param ord: ordinal number if ordinal number is equal to 'ea' then ordinal is not used + @param ea: linear address + @param name: name of entry point. If the specified location already has a name, the old name will be appended to the regular comment. If name == nullptr, then the old name will be retained. + @param makecode: should the kernel convert bytes at the entry point to instruction(s) + @param flags: See AEF_* + @returns success (currently always true) -ida_entry.get_entry (function) - get_entry(ord) -> ea_t - Get entry point address by its ordinal - - @param ord: (C++: uval_t) ordinal number of entry point - @return: address or BADADDR +ida_entry.get_entry(ord: int) -> ida_idaapi.ea_t + Get entry point address by its ordinal + + @param ord: ordinal number of entry point + @returns address or BADADDR -ida_entry.get_entry_forwarder (function) - get_entry_forwarder(ord) -> str - Get forwarder name for the entry point by its ordinal. - - @param ord: (C++: uval_t) ordinal number of entry point - @return: size of entry forwarder name or -1 +ida_entry.get_entry_forwarder(ord: int) -> str + Get forwarder name for the entry point by its ordinal. + + @param ord: ordinal number of entry point + @returns size of entry forwarder name or -1 -ida_entry.get_entry_name (function) - get_entry_name(ord) -> str - Get name of the entry point by its ordinal. - - @param ord: (C++: uval_t) ordinal number of entry point - @return: size of entry name or -1 +ida_entry.get_entry_name(ord: int) -> str + Get name of the entry point by its ordinal. + + @param ord: ordinal number of entry point + @returns size of entry name or -1 -ida_entry.get_entry_ordinal (function) - get_entry_ordinal(idx) -> uval_t - Get ordinal number of an entry point. - - @param idx: (C++: size_t) internal number of entry point. Should be in the range - 0..get_entry_qty()-1 - @return: ordinal number or 0. +ida_entry.get_entry_ordinal(idx: "size_t") -> int + Get ordinal number of an entry point. + + @param idx: internal number of entry point. Should be in the range 0..get_entry_qty()-1 + @returns ordinal number or 0. -ida_entry.get_entry_qty (function) - get_entry_qty() -> size_t +ida_entry.get_entry_qty() -> "size_t" Get number of entry points. -ida_entry.rename_entry (function) - rename_entry(ord, name, flags=0) -> bool - Rename entry point. - - @param ord: (C++: uval_t) ordinal number of the entry point - @param name: (C++: const char *) name of entry point. If the specified location already has a name, - the old name will be appended to a repeatable comment. - @param flags: (C++: int) See AEF_* - @return: success - -ida_entry.set_entry_forwarder (function) - set_entry_forwarder(ord, name, flags=0) -> bool - Set forwarder name for ordinal. - - @param ord: (C++: uval_t) ordinal number of the entry point - @param name: (C++: const char *) forwarder name for entry point. - @param flags: (C++: int) See AEF_* - @return: success - -ida_enum (module) - Assembly level enum management. - - Enums and bitfields are represented as enum_t. - -ida_enum.DEFMASK (variable) - default bitmask - -ida_enum.ENFL_REGEX (variable) - apply regular expressions to beautify the name - -ida_enum.ENUM_MEMBER_ERROR_ENUM (variable) - bad enum id - -ida_enum.ENUM_MEMBER_ERROR_ILLV (variable) - bad bmask and value combination (~bmask & value != 0) - -ida_enum.ENUM_MEMBER_ERROR_MASK (variable) - bad bmask - -ida_enum.ENUM_MEMBER_ERROR_NAME (variable) - already have member with this name (bad name) - -ida_enum.ENUM_MEMBER_ERROR_VALUE (variable) - already have 256 members with this value - -ida_enum.MAX_ENUM_SERIAL (variable) - Max number of identical constants allowed for one enum type. - -ida_enum.add_enum (function) - add_enum(idx, name, flag) -> enum_t - Add new enum type. - * if idx==BADADDR then add as the last idx - * if name==nullptr then generate a unique name "enum_%d" - - @param idx: (C++: size_t) - @param name: (C++: const char *) char const * - @param flag: (C++: flags64_t) - -ida_enum.add_enum_member (function) - add_enum_member(id, name, value, bmask=(bmask_t(-1))) -> int - Add member to enum type. - - @param id: (C++: enum_t) - @param name: (C++: const char *) char const * - @param value: (C++: uval_t) - @param bmask: (C++: bmask_t) - @return: 0 if ok, otherwise one of Add enum member result codes - -ida_enum.del_enum (function) - del_enum(id) - Delete an enum type. - - @param id: (C++: enum_t) - -ida_enum.del_enum_member (function) - del_enum_member(id, value, serial, bmask) -> bool - Delete member of enum type. - - @param id: (C++: enum_t) - @param value: (C++: uval_t) - @param serial: (C++: uchar) - @param bmask: (C++: bmask_t) - -ida_enum.enum_member_visitor_t (class) - Proxy of C++ enum_member_visitor_t class. - -ida_enum.enum_member_visitor_t.__disown__ (method) - -ida_enum.enum_member_visitor_t.__init__ (method) - __init__(self) -> enum_member_visitor_t - - @param self: PyObject * - -ida_enum.enum_member_visitor_t.visit_enum_member (method) - visit_enum_member(self, cid, value) -> int - Implements action to take when enum member is visited. - - @param cid: (C++: const_t) - @param value: (C++: uval_t) - @return: nonzero to stop the iteration - -ida_enum.for_all_enum_members (function) - for_all_enum_members(id, cv) -> int - Visit all members of a given enum. - - @param id: (C++: enum_t) - @param cv: (C++: enum_member_visitor_t &) - -ida_enum.get_bmask_cmt (function) - get_bmask_cmt(id, bmask, repeatable) -> str - - @param id: enum_t - @param bmask: bmask_t - @param repeatable: bool - -ida_enum.get_bmask_name (function) - get_bmask_name(id, bmask) -> str - - @param id: enum_t - @param bmask: bmask_t - -ida_enum.get_enum (function) - get_enum(name) -> enum_t - Get enum by name. - - @param name: (C++: const char *) char const * - -ida_enum.get_enum_cmt (function) - get_enum_cmt(id, repeatable) -> str - Get enum comment. - - @param id: (C++: enum_t) - @param repeatable: (C++: bool) - -ida_enum.get_enum_flag (function) - get_enum_flag(id) -> flags64_t - Get flags determining the representation of the enum. (currently they define the - numeric base: octal, decimal, hex, bin) and signness. - - @param id: (C++: enum_t) - -ida_enum.get_enum_idx (function) - get_enum_idx(id) -> uval_t - Get the index in the list of enums. - - @param id: (C++: enum_t) - -ida_enum.get_enum_member (function) - get_enum_member(id, value, serial, mask) -> const_t - Find an enum member by enum, value and bitmask - @note: if serial -1, return a member with any serial - - @param id: (C++: enum_t) - @param value: (C++: uval_t) - @param serial: (C++: int) - @param mask: (C++: bmask_t) - -ida_enum.get_enum_member_bmask (function) - get_enum_member_bmask(id) -> bmask_t - Get bitmask of an enum member. - - @param id: (C++: const_t) - -ida_enum.get_enum_member_by_name (function) - get_enum_member_by_name(name) -> const_t - Get a reference to an enum member by its name. - - @param name: (C++: const char *) char const * - -ida_enum.get_enum_member_cmt (function) - get_enum_member_cmt(id, repeatable) -> str - Get enum member's comment. - - @param id: (C++: const_t) - @param repeatable: (C++: bool) - -ida_enum.get_enum_member_enum (function) - get_enum_member_enum(id) -> enum_t - Get the parent enum of an enum member. - - @param id: (C++: const_t) - -ida_enum.get_enum_member_name (function) - get_enum_member_name(id) -> str - Get name of an enum member by const_t. - - @param id: (C++: const_t) - -ida_enum.get_enum_member_serial (function) - get_enum_member_serial(cid) -> uchar - Get serial number of an enum member. - - @param cid: (C++: const_t) - -ida_enum.get_enum_member_value (function) - get_enum_member_value(id) -> uval_t - Get value of an enum member. - - @param id: (C++: const_t) - -ida_enum.get_enum_name (function) - get_enum_name(id) -> str - - @param id: enum_t - -ida_enum.get_enum_name2 (function) - get_enum_name2(id, flags=0) -> str - Get name of enum - - @param id: (C++: enum_t) enum id - @param flags: (C++: int) Enum name flags - -ida_enum.get_enum_qty (function) - get_enum_qty() -> size_t - Get number of declared enum_t types. - -ida_enum.get_enum_size (function) - get_enum_size(id) -> size_t - Get the number of the members of the enum. - - @param id: (C++: enum_t) - -ida_enum.get_enum_type_ordinal (function) - get_enum_type_ordinal(id) -> int32 - Get corresponding type ordinal number. - - @param id: (C++: enum_t) - -ida_enum.get_enum_width (function) - get_enum_width(id) -> size_t - Get the width of a enum element allowed values: 0 (unspecified),1,2,4,8,16,32,64 - - @param id: (C++: enum_t) - -ida_enum.get_first_bmask (function) - get_first_bmask(enum_id) -> bmask_t - Get first bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum (bitfield) - @return: the smallest bitmask for enum, or DEFMASK - -ida_enum.get_first_enum_member (function) - get_first_enum_member(id, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param bmask: bmask_t - -ida_enum.get_first_serial_enum_member (function) - get_first_serial_enum_member(id, value, bmask) -> const_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_last_bmask (function) - get_last_bmask(enum_id) -> bmask_t - Get last bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum - @return: the biggest bitmask for enum, or DEFMASK - -ida_enum.get_last_enum_member (function) - get_last_enum_member(id, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param bmask: bmask_t - -ida_enum.get_last_serial_enum_member (function) - get_last_serial_enum_member(id, value, bmask) -> const_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_next_bmask (function) - get_next_bmask(enum_id, bmask) -> bmask_t - Get next bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum - @param bmask: (C++: bmask_t) the current bitmask - @return: value of a bitmask with value higher than the specified value, or - DEFMASK - -ida_enum.get_next_enum_member (function) - get_next_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_next_serial_enum_member (function) - get_next_serial_enum_member(in_out_serial, first_cid) -> const_t - - @param in_out_serial: uchar * - @param first_cid: const_t - -ida_enum.get_prev_bmask (function) - get_prev_bmask(enum_id, bmask) -> bmask_t - Get prev bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum - @param bmask: (C++: bmask_t) the current bitmask - @return: value of a bitmask with value lower than the specified value, or - DEFMASK - -ida_enum.get_prev_enum_member (function) - get_prev_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_prev_serial_enum_member (function) - get_prev_serial_enum_member(in_out_serial, first_cid) -> const_t - - @param in_out_serial: uchar * - @param first_cid: const_t - -ida_enum.getn_enum (function) - getn_enum(idx) -> enum_t - Get enum by its index in the list of enums (0..get_enum_qty()-1). - - @param idx: (C++: size_t) - -ida_enum.is_bf (function) - is_bf(id) -> bool - Is enum a bitfield? (otherwise - plain enum, no bitmasks except for DEFMASK are - allowed) - - @param id: (C++: enum_t) - -ida_enum.is_enum_fromtil (function) - is_enum_fromtil(id) -> bool - Does enum come from type library? - - @param id: (C++: enum_t) - -ida_enum.is_enum_hidden (function) - is_enum_hidden(id) -> bool - Is enum collapsed? - - @param id: (C++: enum_t) - -ida_enum.is_ghost_enum (function) - is_ghost_enum(id) -> bool - Is a ghost copy of a local type? - - @param id: (C++: enum_t) - -ida_enum.is_one_bit_mask (function) - is_one_bit_mask(mask) -> bool - Is bitmask one bit? - - @param mask: (C++: bmask_t) - -ida_enum.set_bmask_cmt (function) - set_bmask_cmt(id, bmask, cmt, repeatable) -> bool - - @param id: enum_t - @param bmask: bmask_t - @param cmt: char const * - @param repeatable: bool - -ida_enum.set_bmask_name (function) - set_bmask_name(id, bmask, name) -> bool - - @param id: enum_t - @param bmask: bmask_t - @param name: char const * - -ida_enum.set_enum_bf (function) - set_enum_bf(id, bf) -> bool - Set 'bitfield' bit of enum (i.e. convert it to a bitfield) - - @param id: (C++: enum_t) - @param bf: (C++: bool) - -ida_enum.set_enum_cmt (function) - set_enum_cmt(id, cmt, repeatable) -> bool - Set comment for enum type. - - @param id: (C++: enum_t) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_enum.set_enum_flag (function) - set_enum_flag(id, flag) -> bool - Set data representation flags. - - @param id: (C++: enum_t) - @param flag: (C++: flags64_t) - -ida_enum.set_enum_fromtil (function) - set_enum_fromtil(id, fromtil) -> bool - Specify that enum comes from a type library. - - @param id: (C++: enum_t) - @param fromtil: (C++: bool) - -ida_enum.set_enum_ghost (function) - set_enum_ghost(id, ghost) -> bool - Specify that enum is a ghost copy of a local type. - - @param id: (C++: enum_t) - @param ghost: (C++: bool) - -ida_enum.set_enum_hidden (function) - set_enum_hidden(id, hidden) -> bool - Collapse enum. - - @param id: (C++: enum_t) - @param hidden: (C++: bool) - -ida_enum.set_enum_idx (function) - set_enum_idx(id, idx) -> bool - Set serial number of enum. Also see get_enum_idx(). - - @param id: (C++: enum_t) - @param idx: (C++: size_t) - -ida_enum.set_enum_member_cmt (function) - set_enum_member_cmt(id, cmt, repeatable) -> bool - Set comment for enum member. - - @param id: (C++: const_t) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_enum.set_enum_member_name (function) - set_enum_member_name(id, name) -> bool - Set name of enum member. - - @param id: (C++: const_t) - @param name: (C++: const char *) char const * - -ida_enum.set_enum_name (function) - set_enum_name(id, name) -> bool - Set name of enum type. - - @param id: (C++: enum_t) - @param name: (C++: const char *) char const * - -ida_enum.set_enum_type_ordinal (function) - set_enum_type_ordinal(id, ord) - Set corresponding type ordinal number. - - @param id: (C++: enum_t) - @param ord: (C++: int32) - -ida_enum.set_enum_width (function) - set_enum_width(id, width) -> bool - See comment for get_enum_width() - - @param id: (C++: enum_t) - @param width: (C++: int) - -ida_expr (module) - Functions that deal with C-like expressions and built-in IDC language. - - Functions marked THREAD_SAFE may be called from any thread. No simultaneous - calls should be made for the same variable. We protect only global structures, - individual variables must be protected manually. - -ida_expr.CPL_DEL_MACROS (variable) +ida_entry.rename_entry(ord: int, name: str, flags: int = 0) -> bool + Rename entry point. + + @param ord: ordinal number of the entry point + @param name: name of entry point. If the specified location already has a name, the old name will be appended to a repeatable comment. + @param flags: See AEF_* + @returns success + +ida_entry.set_entry_forwarder(ord: int, name: str, flags: int = 0) -> bool + Set forwarder name for ordinal. + + @param ord: ordinal number of the entry point + @param name: forwarder name for entry point. + @param flags: See AEF_* + @returns success + +ida_expr + thread safe function. may be called + +ida_expr.CPL_DEL_MACROS delete macros at the end of compilation -ida_expr.CPL_ONLY_SAFE (variable) +ida_expr.CPL_ONLY_SAFE allow calls of only thread-safe functions -ida_expr.CPL_USE_LABELS (variable) +ida_expr.CPL_USE_LABELS allow program labels in the script -ida_expr.EXTFUN_BASE (variable) +ida_expr.EXTFUN_BASE requires open database. -ida_expr.EXTFUN_NORET (variable) - does not return. the interpreter may clean up its state before calling it. +ida_expr.EXTFUN_NORET + does not return. the interpreter may clean up its state before calling it. + -ida_expr.EXTFUN_SAFE (variable) - thread safe function. may be called from any thread. +ida_expr.EXTFUN_SAFE + thread safe function. may be called from any thread. + -ida_expr.IDC_LANG_EXT (variable) +ida_expr.IDC_LANG_EXT IDC script extension. -ida_expr.VARSLICE_SINGLE (variable) +ida_expr.VARSLICE_SINGLE return single index (i2 is ignored) -ida_expr.VREF_COPY (variable) +ida_expr.VREF_COPY copy the result to the input var (v) -ida_expr.VREF_LOOP (variable) +ida_expr.VREF_LOOP dereference until we get a non VT_REF -ida_expr.VREF_ONCE (variable) +ida_expr.VREF_ONCE dereference only once, do not loop -ida_expr.VT_FLOAT (variable) +ida_expr.VT_FLOAT Floating point (see idc_value_t::e) -ida_expr.VT_FUNC (variable) +ida_expr.VT_FUNC Function (see idc_value_t::funcidx) -ida_expr.VT_INT64 (variable) +ida_expr.VT_INT64 i64 -ida_expr.VT_LONG (variable) +ida_expr.VT_LONG Integer (see idc_value_t::num) -ida_expr.VT_OBJ (variable) +ida_expr.VT_OBJ Object (see idc_value_t::obj) -ida_expr.VT_PVOID (variable) +ida_expr.VT_PVOID void * -ida_expr.VT_REF (variable) +ida_expr.VT_REF Reference. -ida_expr.VT_STR (variable) +ida_expr.VT_STR String (see qstr() and similar functions) -ida_expr.VT_WILD (variable) - Function with arbitrary number of arguments. The actual number of arguments will - be passed in idc_value_t::num. This value should not be used for idc_value_t. +ida_expr.VT_WILD + Function with arbitrary number of arguments. The actual number of arguments will be passed in idc_value_t::num. This value should not be used for idc_value_t. + -ida_expr._IdcFunction (class) +ida_expr._IdcFunction Internal class that calls pyw_call_idc_func() with a context -ida_expr._IdcFunction.__call__ (method) +ida_expr._IdcFunction.__call__(self, args, res) -ida_expr._IdcFunction.__init__ (method) +ida_expr._IdcFunction.__init__(self, ctxptr) -ida_expr.add_idc_class (function) - add_idc_class(name, super=None) -> idc_class_t * - Create a new IDC class. +ida_expr.add_idc_class(name: str, super: "idc_class_t const *" = None) -> "idc_class_t *" + Create a new IDC class. + + @param name: name of the new class + @param super: the base class for the new class. if the new class is not based on any other class, pass nullptr + @returns pointer to the created class. If such a class already exists, a pointer to it will be returned. Pointers to other existing classes may be invalidated by this call. + +ida_expr.add_idc_func(name, fp, args, defvals = , flags = 0) + Add an IDC function. This function does not modify the predefined kernel functions. Example: + error_t idaapi myfunc5(idc_value_t *argv, idc_value_t *res) + + msg("myfunc is called with arg0=%a and arg1=%s\n", argv[0].num, argv[1].str); + res->num = 5; // let's return 5 + return eOk; + + const char myfunc5_args[] = { VT_LONG, VT_STR, 0 }; + const ext_idcfunc_t myfunc_desc = { "MyFunc5", myfunc5, myfunc5_args, nullptr, 0, EXTFUN_BASE }; + + after this: + + + there is a new IDC function which can be called like this: + "test"); - @param name: (C++: const char *) name of the new class - @param super: (C++: const idc_class_t *) the base class for the new class. if the new class is not based on - any other class, pass nullptr - @return: pointer to the created class. If such a class already exists, a pointer - to it will be returned. Pointers to other existing classes may be - invalidated by this call. - -ida_expr.add_idc_func (function) - Extends the IDC language by exposing a new IDC function that is backed up by a Python function - Add an IDC function. This function does not modify the predefined kernel - functions. Example: - static error_t idaapi myfunc5(idc_value_t *argv, idc_value_t *res) - { - msg("myfunc is called with arg0=%a and arg1=%s\n", argv[0].num, argv[1].str); - res->num = 5; // let's return 5 - return eOk; - } - static const char myfunc5_args[] = { VT_LONG, VT_STR, 0 }; - static const ext_idcfunc_t myfunc_desc = { "MyFunc5", myfunc5, myfunc5_args, - nullptr, 0, EXTFUN_BASE }; - // after this: - add_idc_func(myfunc_desc); - // there is a new IDC function which can be called like this: - MyFunc5(0x123, "test"); - - @note: If the function already exists, it will be replaced by the new function - @return: success + + @returns success -ida_expr.add_idc_gvar (function) - add_idc_gvar(name) -> idc_value_t - Add global IDC variable. - - @param name: (C++: const char *) name of the global variable - @return: pointer to the created variable or existing variable. NB: the returned - pointer is valid until a new global var is added. +ida_expr.add_idc_gvar(name: str) -> "idc_value_t *" + Add global IDC variable. + + @param name: name of the global variable + @returns pointer to the created variable or existing variable. NB: the returned pointer is valid until a new global var is added. -ida_expr.call_idc_func__ (function) +ida_expr.call_idc_func__(*args) -ida_expr.compile_idc_file (function) - compile_idc_file(nonnul_line) -> str - - @param nonnul_line: char const * +ida_expr.compile_idc_file(nonnul_line: str) -> str -ida_expr.compile_idc_snippet (function) - compile_idc_snippet(func, text, resolver=None, only_safe_funcs=False) -> str - Compile text with IDC statements. - - @param func: (C++: const char *) name of the function to create out of the snippet - @param text: (C++: const char *) text to compile - @param resolver: (C++: idc_resolver_t *) callback object to get values of undefined variables This - object will be called if IDC function contains references to - undefined variables. May be nullptr. - @param only_safe_funcs: (C++: bool) if true, any calls to functions without EXTFUN_SAFE flag - will lead to a compilation error. +ida_expr.compile_idc_snippet(func: str, text: str, resolver: "idc_resolver_t *" = None, only_safe_funcs: bool = False) -> str + Compile text with IDC statements. + + @param func: name of the function to create out of the snippet + @param text: text to compile + @param resolver: callback object to get values of undefined variables This object will be called if IDC function contains references to undefined variables. May be nullptr. + @param only_safe_funcs: if true, any calls to functions without EXTFUN_SAFE flag will lead to a compilation error. @retval true: ok @retval false: error, see errbuf -ida_expr.compile_idc_text (function) - compile_idc_text(nonnul_line) -> str - - @param nonnul_line: char const * +ida_expr.compile_idc_text(nonnul_line: str) -> str -ida_expr.copy_idcv (function) - copy_idcv(dst, src) -> error_t - Copy 'src' to 'dst'. For idc objects only a reference is copied. - - @param dst: (C++: idc_value_t *) - @param src: (C++: const idc_value_t &) idc_value_t const & +ida_expr.copy_idcv(dst: "idc_value_t", src: "idc_value_t") -> "error_t" + Copy 'src' to 'dst'. For idc objects only a reference is copied. + -ida_expr.create_idcv_ref (function) - create_idcv_ref(ref, v) -> bool - Create a variable reference. Currently only references to global variables can - be created. - - @param ref: (C++: idc_value_t *) ptr to the result - @param v: (C++: const idc_value_t *) variable to reference - @return: success +ida_expr.create_idcv_ref(ref: "idc_value_t", v: "idc_value_t") -> bool + Create a variable reference. Currently only references to global variables can be created. + + @param ref: ptr to the result + @param v: variable to reference + @returns success -ida_expr.deep_copy_idcv (function) - deep_copy_idcv(dst, src) -> error_t - Deep copy an IDC object. This function performs deep copy of idc objects. If - 'src' is not an object, copy_idcv() will be called - - @param dst: (C++: idc_value_t *) - @param src: (C++: const idc_value_t &) idc_value_t const & +ida_expr.deep_copy_idcv(dst: "idc_value_t", src: "idc_value_t") -> "error_t" + Deep copy an IDC object. This function performs deep copy of idc objects. If 'src' is not an object, copy_idcv() will be called + -ida_expr.del_idc_func (function) - Unregisters the specified IDC function - - Delete an IDC function +ida_expr.del_idc_func(name) + Delete an IDC function + -ida_expr.del_idcv_attr (function) - del_idcv_attr(obj, attr) -> error_t - Delete an object attribute. - - @param obj: (C++: idc_value_t *) variable that holds an object reference - @param attr: (C++: const char *) attribute name - @return: error code, eOk on success +ida_expr.del_idcv_attr(obj: "idc_value_t", attr: str) -> "error_t" + Delete an object attribute. + + @param obj: variable that holds an object reference + @param attr: attribute name + @returns error code, eOk on success -ida_expr.deref_idcv (function) - deref_idcv(v, vref_flags) -> idc_value_t - Dereference a VT_REF variable. - - @param v: (C++: idc_value_t *) variable to dereference - @param vref_flags: (C++: int) Dereference IDC variable flags - @return: pointer to the dereference result or nullptr. If returns nullptr, - qerrno is set to eExecBadRef "Illegal variable reference" +ida_expr.deref_idcv(v: "idc_value_t", vref_flags: int) -> "idc_value_t *" + Dereference a VT_REF variable. + + @param v: variable to dereference + @param vref_flags: Dereference IDC variable flags + @returns pointer to the dereference result or nullptr. If returns nullptr, qerrno is set to eExecBadRef "Illegal variable reference" -ida_expr.eExecThrow (variable) +ida_expr.eExecThrow See return value of idc_func_t. -ida_expr.eval_expr (function) - eval_expr(rv, where, line) -> str - Compile and calculate an expression. - - @param rv: (C++: idc_value_t *) pointer to the result - @param where: (C++: ea_t) the current linear address in the addressing space of the program - being disassembled. If will be used to resolve names of local - variables etc. if not applicable, then should be BADADDR. - @param line: (C++: const char *) the expression to evaluate +ida_expr.eval_expr(rv: "idc_value_t", where: ida_idaapi.ea_t, line: str) -> str + Compile and calculate an expression. + + @param rv: pointer to the result + @param where: the current linear address in the addressing space of the program being disassembled. If will be used to resolve names of local variables etc. if not applicable, then should be BADADDR. + @param line: the expression to evaluate @retval true: ok @retval false: error, see errbuf -ida_expr.eval_idc_expr (function) - eval_idc_expr(rv, where, line) -> str - Same as eval_expr(), but will always use the IDC interpreter regardless of the - currently installed extlang. - - @param rv: (C++: idc_value_t *) - @param where: (C++: ea_t) - @param line: char const * +ida_expr.eval_idc_expr(rv: "idc_value_t", where: ida_idaapi.ea_t, line: str) -> str + Same as eval_expr(), but will always use the IDC interpreter regardless of the currently installed extlang. + -ida_expr.exec_idc_script (function) - exec_idc_script(result, path, func, args, argsnum) -> str - Compile and execute IDC function(s) from file. - - @param result: (C++: idc_value_t *) ptr to idc_value_t to hold result of the function. If execution - fails, this variable will contain the exception information. You - may pass nullptr if you are not interested in the returned value. - @param path: (C++: const char *) text file containing text of IDC functions - @param func: (C++: const char *) function name to execute - @param args: (C++: const idc_value_t) array of parameters - @param argsnum: (C++: size_t) number of parameters to pass to 'fname' This number should be - equal to number of parameters the function expects. +ida_expr.exec_idc_script(result: "idc_value_t", path: str, func: str, args: "idc_value_t", argsnum: "size_t") -> str + Compile and execute IDC function(s) from file. + + @param result: ptr to idc_value_t to hold result of the function. If execution fails, this variable will contain the exception information. You may pass nullptr if you are not interested in the returned value. + @param path: text file containing text of IDC functions + @param func: function name to execute + @param args: array of parameters + @param argsnum: number of parameters to pass to 'fname' This number should be equal to number of parameters the function expects. @retval true: ok @retval false: error, see errbuf -ida_expr.exec_system_script (function) - exec_system_script(file, complain_if_no_file=True) -> bool - Compile and execute "main" function from system file. - - @param file: (C++: const char *) file name with IDC function(s). The file will be searched using - get_idc_filename(). - @param complain_if_no_file: (C++: bool) * 1: display warning if the file is not found +ida_expr.exec_system_script(file: str, complain_if_no_file: bool = True) -> bool + Compile and execute "main" function from system file. + + @param file: file name with IDC function(s). The file will be searched using get_idc_filename(). + @param complain_if_no_file: * 1: display warning if the file is not found * 0: don't complain if file doesn't exist @retval 1: ok, file is compiled and executed @retval 0: failure, compilation or execution error, warning is displayed -ida_expr.find_idc_class (function) - find_idc_class(name) -> idc_class_t * - Find an existing IDC class by its name. - - @param name: (C++: const char *) name of the class - @return: pointer to the class or nullptr. The returned pointer is valid until a - new call to add_idc_class() +ida_expr.find_idc_class(name: str) -> "idc_class_t *" + Find an existing IDC class by its name. + + @param name: name of the class + @returns pointer to the class or nullptr. The returned pointer is valid until a new call to add_idc_class() -ida_expr.find_idc_func (function) - find_idc_func(prefix, n=0) -> str - - @param prefix: char const * - @param n: int +ida_expr.find_idc_func(prefix: str, n: int = 0) -> str -ida_expr.find_idc_gvar (function) - find_idc_gvar(name) -> idc_value_t - Find an existing global IDC variable by its name. - - @param name: (C++: const char *) name of the global variable - @return: pointer to the variable or nullptr. NB: the returned pointer is valid - until a new global var is added. FIXME: it is difficult to use this - function in a thread safe manner +ida_expr.find_idc_gvar(name: str) -> "idc_value_t *" + Find an existing global IDC variable by its name. + + @param name: name of the global variable + @returns pointer to the variable or nullptr. NB: the returned pointer is valid until a new global var is added. FIXME: it is difficult to use this function in a thread safe manner -ida_expr.first_idcv_attr (function) - first_idcv_attr(obj) -> char const * - - @param obj: idc_value_t const * +ida_expr.first_idcv_attr(obj: "idc_value_t") -> str -ida_expr.free_idcv (function) - free_idcv(v) - Free storage used by VT_STR/VT_OBJ IDC variables. After this call the variable - has a numeric value 0 - - @param v: (C++: idc_value_t *) +ida_expr.free_idcv(v: "idc_value_t") -> None + Free storage used by VT_STR/VT_OBJ IDC variables. After this call the variable has a numeric value 0 + -ida_expr.get_idc_filename (function) - get_idc_filename(file) -> str - Get full name of IDC file name. Search for file in list of include directories, - IDCPATH directory and system directories. - - @param file: (C++: const char *) file name without full path - @return: nullptr is file not found. otherwise returns pointer to buf +ida_expr.get_idc_filename(file: str) -> str + Get full name of IDC file name. Search for file in list of include directories, IDCPATH directory and system directories. + + @param file: file name without full path + @returns nullptr is file not found. otherwise returns pointer to buf -ida_expr.get_idcv_attr (function) - get_idcv_attr(res, obj, attr, may_use_getattr=False) -> error_t - Get an object attribute. - - @param res: (C++: idc_value_t *) buffer for the attribute value - @param obj: (C++: const idc_value_t *) variable that holds an object reference. if obj is nullptr it - searches global variables, then user functions - @param attr: (C++: const char *) attribute name - @param may_use_getattr: (C++: bool) may call getattr functions to calculate the attribute if - it does not exist - @return: error code, eOk on success +ida_expr.get_idcv_attr(res: "idc_value_t", obj: "idc_value_t", attr: str, may_use_getattr: bool = False) -> "error_t" + Get an object attribute. + + @param res: buffer for the attribute value + @param obj: variable that holds an object reference. if obj is nullptr it searches global variables, then user functions + @param attr: attribute name + @param may_use_getattr: may call getattr functions to calculate the attribute if it does not exist + @returns error code, eOk on success -ida_expr.get_idcv_class_name (function) - get_idcv_class_name(obj) -> str - Retrieves the IDC object class name. - - @param obj: (C++: const idc_value_t *) class instance variable - @return: error code, eOk on success +ida_expr.get_idcv_class_name(obj: "idc_value_t") -> str + Retrieves the IDC object class name. + + @param obj: class instance variable + @returns error code, eOk on success -ida_expr.get_idcv_slice (function) - get_idcv_slice(res, v, i1, i2, flags=0) -> error_t - Get slice. - - @param res: (C++: idc_value_t *) output variable that will contain the slice - @param v: (C++: const idc_value_t *) input variable (string or object) - @param i1: (C++: uval_t) slice start index - @param i2: (C++: uval_t) slice end index (excluded) - @param flags: (C++: int) IDC variable slice flags or 0 - @return: eOk if success +ida_expr.get_idcv_slice(res: "idc_value_t", v: "idc_value_t", i1: int, i2: int, flags: int = 0) -> "error_t" + Get slice. + + @param res: output variable that will contain the slice + @param v: input variable (string or object) + @param i1: slice start index + @param i2: slice end index (excluded) + @param flags: IDC variable slice flags or 0 + @returns eOk if success -ida_expr.highlighter_cbs_t (class) - Proxy of C++ highlighter_cbs_t class. +ida_expr.highlighter_cbs_t -ida_expr.highlighter_cbs_t.__disown__ (method) +ida_expr.highlighter_cbs_t.__disown__(self) -ida_expr.highlighter_cbs_t.__init__ (method) - __init__(self) -> highlighter_cbs_t - - @param self: PyObject * +ida_expr.highlighter_cbs_t.__init__(self) -ida_expr.highlighter_cbs_t.cur_block_state (method) - cur_block_state(self) -> int32 +ida_expr.highlighter_cbs_t.cur_block_state(self) -> int -ida_expr.highlighter_cbs_t.prev_block_state (method) - prev_block_state(self) -> int32 +ida_expr.highlighter_cbs_t.prev_block_state(self) -> int -ida_expr.highlighter_cbs_t.set_block_state (method) - set_block_state(self, arg0) - - @param arg0: int32 +ida_expr.highlighter_cbs_t.set_block_state(self, arg0: int) -> None -ida_expr.highlighter_cbs_t.set_style (method) - set_style(self, arg0, arg1, arg2) - - @param arg0: int32 - @param arg1: int32 - @param arg2: enum syntax_highlight_style +ida_expr.highlighter_cbs_t.set_style(self, arg0: int, arg1: int, arg2: "syntax_highlight_style") -> None -ida_expr.idc_global_t (class) - Proxy of C++ idc_global_t class. +ida_expr.idc_global_t -ida_expr.idc_global_t.__init__ (method) - __init__(self) -> idc_global_t - __init__(self, n) -> idc_global_t - - @param n: char const * +ida_expr.idc_global_t.__init__(self, *args) -ida_expr.idc_value_t (class) - Proxy of C++ idc_value_t class. +ida_expr.idc_value_t -ida_expr.idc_value_t.__init__ (method) - __init__(self, n=0) -> idc_value_t - - @param n: sval_t - - __init__(self, r) -> idc_value_t - - @param r: idc_value_t const & - - __init__(self, _str) -> idc_value_t - - @param _str: char const * +ida_expr.idc_value_t.__init__(self, *args) -ida_expr.idc_value_t._create_empty_string (method) - _create_empty_string(self) +ida_expr.idc_value_t._create_empty_string(self) -> None -ida_expr.idc_value_t.c_str (method) - c_str(self) -> char const * +ida_expr.idc_value_t.c_str(self) -> str VT_STR -ida_expr.idc_value_t.clear (method) - clear(self) +ida_expr.idc_value_t.clear(self) -> None See free_idcv() -ida_expr.idc_value_t.create_empty_string (method) - create_empty_string(self) +ida_expr.idc_value_t.create_empty_string(self) -> None -ida_expr.idc_value_t.e (variable) +ida_expr.idc_value_t.e VT_FLOAT -ida_expr.idc_value_t.funcidx (variable) +ida_expr.idc_value_t.funcidx VT_FUNC -ida_expr.idc_value_t.i64 (variable) +ida_expr.idc_value_t.i64 VT_INT64 -ida_expr.idc_value_t.is_convertible (method) - is_convertible(self) -> bool +ida_expr.idc_value_t.is_convertible(self) -> bool Convertible types are VT_LONG, VT_FLOAT, VT_INT64, and VT_STR. -ida_expr.idc_value_t.is_integral (method) - is_integral(self) -> bool - Does value represent a whole number? +ida_expr.idc_value_t.is_integral(self) -> bool + Does value represent a whole number? + -ida_expr.idc_value_t.is_zero (method) - is_zero(self) -> bool +ida_expr.idc_value_t.is_zero(self) -> bool Does value represent the integer 0? -ida_expr.idc_value_t.num (variable) +ida_expr.idc_value_t.num VT_LONG -ida_expr.idc_value_t.pvoid (variable) +ida_expr.idc_value_t.pvoid VT_PVOID -ida_expr.idc_value_t.qstr (method) - qstr(self) -> qstring +ida_expr.idc_value_t.qstr(self) -> str VT_STR - qstr(self) -> qstring const & -ida_expr.idc_value_t.reserve (variable) - internal housekeeping: 64-bit qstring is bigger than 12 bytes +ida_expr.idc_value_t.reserve + VT_STR. -ida_expr.idc_value_t.set_float (method) - set_float(self, f) - - @param f: fpvalue_t const & +ida_expr.idc_value_t.set_float(self, f: "fpvalue_t const &") -> None -ida_expr.idc_value_t.set_int64 (method) - set_int64(self, v) - - @param v: int64 +ida_expr.idc_value_t.set_int64(self, v: "int64") -> None -ida_expr.idc_value_t.set_long (method) - set_long(self, v) - - @param v: sval_t +ida_expr.idc_value_t.set_long(self, v: int) -> None -ida_expr.idc_value_t.set_pvoid (method) - set_pvoid(self, p) - - @param p: void * +ida_expr.idc_value_t.set_pvoid(self, p: "void *") -> None -ida_expr.idc_value_t.set_string (method) - set_string(self, _str, len) - - @param _str: char const * - @param len: size_t - - set_string(self, _str) - - @param _str: char const * +ida_expr.idc_value_t.set_string(self, *args) -> None -ida_expr.idc_value_t.swap (method) - swap(self, v) +ida_expr.idc_value_t.swap(self, v: "idc_value_t") -> None Set this = r and v = this. - - @param v: (C++: idc_value_t &) -ida_expr.idc_value_t.u_str (method) - u_str(self) -> uchar const * +ida_expr.idc_value_t.u_str(self) -> "uchar const *" VT_STR -ida_expr.idc_value_t.vtype (variable) +ida_expr.idc_value_t.vtype IDC value types -ida_expr.idc_values_t (class) - Proxy of C++ qvector< idc_value_t > class. +ida_expr.idc_values_t -ida_expr.idc_values_t.__getitem__ (method) - __getitem__(self, i) -> idc_value_t - - @param i: size_t +ida_expr.idc_values_t.__getitem__(self, i: "size_t") -> "idc_value_t const &" -ida_expr.idc_values_t.__init__ (method) - __init__(self) -> idc_values_t - __init__(self, x) -> idc_values_t - - @param x: qvector< idc_value_t > const & +ida_expr.idc_values_t.__init__(self, *args) -ida_expr.idc_values_t.__len__ (method) - __len__(self) -> size_t +ida_expr.idc_values_t.__len__(self) -> "size_t" -ida_expr.idc_values_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: idc_value_t const & +ida_expr.idc_values_t.__setitem__(self, i: "size_t", v: "idc_value_t") -> None -ida_expr.idc_values_t.at (method) - at(self, _idx) -> idc_value_t - - @param _idx: size_t +ida_expr.idc_values_t.append(self, x: "idc_value_t") -> None -ida_expr.idc_values_t.begin (method) - begin(self) -> idc_value_t +ida_expr.idc_values_t.at(self, _idx: "size_t") -> "idc_value_t const &" -ida_expr.idc_values_t.capacity (method) - capacity(self) -> size_t +ida_expr.idc_values_t.begin(self, *args) -> "qvector< idc_value_t >::const_iterator" -ida_expr.idc_values_t.clear (method) - clear(self) +ida_expr.idc_values_t.capacity(self) -> "size_t" -ida_expr.idc_values_t.empty (method) - empty(self) -> bool +ida_expr.idc_values_t.clear(self) -> None -ida_expr.idc_values_t.end (method) - end(self) -> idc_value_t +ida_expr.idc_values_t.empty(self) -> bool -ida_expr.idc_values_t.erase (method) - erase(self, it) -> idc_value_t - - @param it: qvector< idc_value_t >::iterator - - erase(self, first, last) -> idc_value_t - - @param first: qvector< idc_value_t >::iterator - @param last: qvector< idc_value_t >::iterator +ida_expr.idc_values_t.end(self, *args) -> "qvector< idc_value_t >::const_iterator" -ida_expr.idc_values_t.extract (method) - extract(self) -> idc_value_t +ida_expr.idc_values_t.erase(self, *args) -> "qvector< idc_value_t >::iterator" -ida_expr.idc_values_t.grow (method) - grow(self, x=idc_value_t()) - - @param x: idc_value_t const & +ida_expr.idc_values_t.extend(self, x: "idc_values_t") -> None -ida_expr.idc_values_t.inject (method) - inject(self, s, len) - - @param s: idc_value_t * - @param len: size_t +ida_expr.idc_values_t.extract(self) -> "idc_value_t *" -ida_expr.idc_values_t.insert (method) - insert(self, it, x) -> idc_value_t - - @param it: qvector< idc_value_t >::iterator - @param x: idc_value_t const & +ida_expr.idc_values_t.grow(self, *args) -> None -ida_expr.idc_values_t.pop_back (method) - pop_back(self) +ida_expr.idc_values_t.inject(self, s: "idc_value_t", len: "size_t") -> None -ida_expr.idc_values_t.push_back (method) - push_back(self, x) - - @param x: idc_value_t const & - - push_back(self) -> idc_value_t +ida_expr.idc_values_t.insert(self, it: "idc_value_t", x: "idc_value_t") -> "qvector< idc_value_t >::iterator" -ida_expr.idc_values_t.qclear (method) - qclear(self) +ida_expr.idc_values_t.pop_back(self) -> None -ida_expr.idc_values_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_expr.idc_values_t.push_back(self, *args) -> "idc_value_t &" -ida_expr.idc_values_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: idc_value_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_expr.idc_values_t.qclear(self) -> None -ida_expr.idc_values_t.size (method) - size(self) -> size_t +ida_expr.idc_values_t.reserve(self, cnt: "size_t") -> None -ida_expr.idc_values_t.swap (method) - swap(self, r) - - @param r: qvector< idc_value_t > & +ida_expr.idc_values_t.resize(self, *args) -> None -ida_expr.idc_values_t.truncate (method) - truncate(self) +ida_expr.idc_values_t.size(self) -> "size_t" -ida_expr.idcv_float (function) - idcv_float(v) -> error_t +ida_expr.idc_values_t.swap(self, r: "idc_values_t") -> None + +ida_expr.idc_values_t.truncate(self) -> None + +ida_expr.idcv_float(v: "idc_value_t") -> "error_t" Convert IDC variable to a floating point. - - @param v: (C++: idc_value_t *) -ida_expr.idcv_int64 (function) - idcv_int64(v) -> error_t - Convert IDC variable to a 64bit number. - - @param v: (C++: idc_value_t *) - @return: v = 0 if impossible to convert to int64 +ida_expr.idcv_int64(v: "idc_value_t") -> "error_t" + Convert IDC variable to a 64bit number. + + @returns v = 0 if impossible to convert to int64 -ida_expr.idcv_long (function) - idcv_long(v) -> error_t - Convert IDC variable to a long (32/64bit) number. - - @param v: (C++: idc_value_t *) - @return: v = 0 if impossible to convert to long +ida_expr.idcv_long(v: "idc_value_t") -> "error_t" + Convert IDC variable to a long (32/64bit) number. + + @returns v = 0 if impossible to convert to long -ida_expr.idcv_num (function) - idcv_num(v) -> error_t - Convert IDC variable to a long number. - - @param v: (C++: idc_value_t *) - @return: * v = 0 if IDC variable = "false" string +ida_expr.idcv_num(v: "idc_value_t") -> "error_t" + Convert IDC variable to a long number. + + @returns * v = 0 if IDC variable = "false" string * v = 1 if IDC variable = "true" string * v = number if IDC variable is number or string containing a number * eTypeConflict if IDC variable = empty string -ida_expr.idcv_object (function) - idcv_object(v, icls=None) -> error_t - Create an IDC object. The original value of 'v' is discarded (freed). - - @param v: (C++: idc_value_t *) variable to hold the object. any previous value will be cleaned - @param icls: (C++: const idc_class_t *) ptr to the desired class. nullptr means "object" class this ptr - must be returned by add_idc_class() or find_idc_class() - @return: always eOk +ida_expr.idcv_object(v: "idc_value_t", icls: "idc_class_t const *" = None) -> "error_t" + Create an IDC object. The original value of 'v' is discarded (freed). + + @param v: variable to hold the object. any previous value will be cleaned + @param icls: ptr to the desired class. nullptr means "object" class this ptr must be returned by add_idc_class() or find_idc_class() + @returns always eOk -ida_expr.idcv_string (function) - idcv_string(v) -> error_t +ida_expr.idcv_string(v: "idc_value_t") -> "error_t" Convert IDC variable to a text string. - - @param v: (C++: idc_value_t *) -ida_expr.last_idcv_attr (function) - last_idcv_attr(obj) -> char const * - - @param obj: idc_value_t const * +ida_expr.last_idcv_attr(obj: "idc_value_t") -> str -ida_expr.move_idcv (function) - move_idcv(dst, src) -> error_t - Move 'src' to 'dst'. This function is more effective than copy_idcv since it - never copies big amounts of data. - - @param dst: (C++: idc_value_t *) - @param src: (C++: idc_value_t *) +ida_expr.move_idcv(dst: "idc_value_t", src: "idc_value_t") -> "error_t" + Move 'src' to 'dst'. This function is more effective than copy_idcv since it never copies big amounts of data. + -ida_expr.next_idcv_attr (function) - next_idcv_attr(obj, attr) -> char const * - - @param obj: idc_value_t const * - @param attr: char const * +ida_expr.next_idcv_attr(obj: "idc_value_t", attr: str) -> str -ida_expr.prev_idcv_attr (function) - prev_idcv_attr(obj, attr) -> char const * - - @param obj: idc_value_t const * - @param attr: char const * +ida_expr.prev_idcv_attr(obj: "idc_value_t", attr: str) -> str -ida_expr.print_idcv (function) - print_idcv(v, name=None, indent=0) -> str +ida_expr.print_idcv(v: "idc_value_t", name: str = None, indent: int = 0) -> str Get text representation of idc_value_t. - - @param v: (C++: const idc_value_t &) idc_value_t const & - @param name: (C++: const char *) char const * - @param indent: (C++: int) -ida_expr.py_add_idc_func (function) - py_add_idc_func(name, fp_ptr, args, defvals, flags) -> bool - - @param name: char const * - @param fp_ptr: size_t - @param args: char const * - @param defvals: idc_values_t const & - @param flags: int +ida_expr.py_add_idc_func(name: str, fp_ptr: "size_t", args: str, defvals: "idc_values_t", flags: int) -> bool -ida_expr.py_get_call_idc_func (function) - py_get_call_idc_func() -> size_t +ida_expr.py_get_call_idc_func() -> "size_t" -ida_expr.pyw_convert_defvals (function) - pyw_convert_defvals(out, py_seq) -> bool - - @param out: idc_values_t * - @param py_seq: PyObject * +ida_expr.pyw_convert_defvals(out: "idc_values_t", py_seq: "PyObject *") -> bool -ida_expr.pyw_register_idc_func (function) - pyw_register_idc_func(name, args, py_fp) -> size_t - - @param name: char const * - @param args: char const * - @param py_fp: PyObject * +ida_expr.pyw_register_idc_func(name: str, args: str, py_fp: "PyObject *") -> "size_t" -ida_expr.pyw_unregister_idc_func (function) - pyw_unregister_idc_func(ctxptr) -> bool - - @param ctxptr: size_t +ida_expr.pyw_unregister_idc_func(ctxptr: "size_t") -> bool -ida_expr.set_header_path (function) - set_header_path(path, add) -> bool - Set or append a header path. IDA looks for the include files in the appended - header paths, then in the ida executable directory. - - @param path: (C++: const char *) list of directories to add (separated by ';') may be nullptr, in - this case nothing is added - @param add: (C++: bool) true: append. false: remove old paths. +ida_expr.set_header_path(path: str, add: bool) -> bool + Set or append a header path. IDA looks for the include files in the appended header paths, then in the ida executable directory. + + @param path: list of directories to add (separated by ';') may be nullptr, in this case nothing is added + @param add: true: append. false: remove old paths. @retval true: success @retval false: no memory -ida_expr.set_idcv_attr (function) - set_idcv_attr(obj, attr, value, may_use_setattr=False) -> error_t - Set an object attribute. - - @param obj: (C++: idc_value_t *) variable that holds an object reference. if obj is nullptr then it - tries to modify a global variable with the attribute name - @param attr: (C++: const char *) attribute name - @param value: (C++: const idc_value_t &) new attribute value - @param may_use_setattr: (C++: bool) may call setattr functions for the class - @return: error code, eOk on success +ida_expr.set_idcv_attr(obj: "idc_value_t", attr: str, value: "idc_value_t", may_use_setattr: bool = False) -> "error_t" + Set an object attribute. + + @param obj: variable that holds an object reference. if obj is nullptr then it tries to modify a global variable with the attribute name + @param attr: attribute name + @param value: new attribute value + @param may_use_setattr: may call setattr functions for the class + @returns error code, eOk on success -ida_expr.set_idcv_slice (function) - set_idcv_slice(v, i1, i2, _in, flags=0) -> error_t - Set slice. - - @param v: (C++: idc_value_t *) variable to modify (string or object) - @param i1: (C++: uval_t) slice start index - @param i2: (C++: uval_t) slice end index (excluded) - @param in: (C++: const idc_value_t &) new value for the slice - @param flags: (C++: int) IDC variable slice flags or 0 - @return: eOk on success +ida_expr.set_idcv_slice(v: "idc_value_t", i1: int, i2: int, _in: "idc_value_t", flags: int = 0) -> "error_t" + Set slice. + + @param v: variable to modify (string or object) + @param i1: slice start index + @param i2: slice end index (excluded) + @param flags: IDC variable slice flags or 0 + @returns eOk on success -ida_expr.swap_idcvs (function) - swap_idcvs(v1, v2) +ida_expr.swap_idcvs(v1: "idc_value_t", v2: "idc_value_t") -> None Swap 2 variables. - - @param v1: (C++: idc_value_t *) - @param v2: (C++: idc_value_t *) -ida_expr.throw_idc_exception (function) - throw_idc_exception(r, desc) -> error_t - Create an idc execution exception object. This helper function can be used to - return an exception from C++ code to IDC. In other words this function can be - called from idc_func_t() callbacks. Sample usage: if ( !ok ) return - throw_idc_exception(r, "detailed error msg"); - - @param r: (C++: idc_value_t *) object to hold the exception object - @param desc: (C++: const char *) exception description - @return: eExecThrow +ida_expr.throw_idc_exception(r: "idc_value_t", desc: str) -> "error_t" + Create an idc execution exception object. This helper function can be used to return an exception from C++ code to IDC. In other words this function can be called from idc_func_t() callbacks. Sample usage: if ( !ok ) return throw_idc_exception(r, "detailed error msg"); + + @param r: object to hold the exception object + @param desc: exception description + @returns eExecThrow -ida_fixup (module) +ida_fixup Functions that deal with fixup information. - A loader should setup fixup information using set_fixup(). + A loader should setup fixup information using set_fixup(). + -ida_fixup.FIXUPF_CREATED (variable) +ida_fixup.FIXUPF_CREATED fixup was not present in the input file -ida_fixup.FIXUPF_EXTDEF (variable) - target is a location (otherwise - segment). Use this bit if the target is a - symbol rather than an offset from the beginning of a segment. +ida_fixup.FIXUPF_EXTDEF + target is a location (otherwise - segment). Use this bit if the target is a symbol rather than an offset from the beginning of a segment. + -ida_fixup.FIXUPF_LOADER_MASK (variable) - additional flags. The bits from this mask are not stored in the database and can - be used by the loader at its discretion. +ida_fixup.FIXUPF_LOADER_MASK + additional flags. The bits from this mask are not stored in the database and can be used by the loader at its discretion. + -ida_fixup.FIXUPF_REL (variable) - fixup is relative to the linear address `base'. Otherwise fixup is relative to - the start of the segment with `sel' selector. +ida_fixup.FIXUPF_REL + fixup is relative to the linear address `base`. Otherwise fixup is relative to the start of the segment with `sel` selector. + -ida_fixup.FIXUPF_UNUSED (variable) +ida_fixup.FIXUPF_UNUSED fixup is ignored by IDA * disallows the kernel to convert operands - * this fixup is not used during output + * this fixup is not used during output + + + -ida_fixup.FIXUP_CUSTOM (variable) +ida_fixup.FIXUP_CUSTOM start of the custom types range -ida_fixup.FIXUP_HI16 (variable) +ida_fixup.FIXUP_HI16 high 16 bits of 32bit offset -ida_fixup.FIXUP_HI8 (variable) +ida_fixup.FIXUP_HI8 high 8 bits of 16bit offset -ida_fixup.FIXUP_LOW16 (variable) +ida_fixup.FIXUP_LOW16 low 16 bits of 32bit offset -ida_fixup.FIXUP_LOW8 (variable) +ida_fixup.FIXUP_LOW8 low 8 bits of 16bit offset -ida_fixup.FIXUP_OFF16 (variable) +ida_fixup.FIXUP_OFF16 16-bit offset -ida_fixup.FIXUP_OFF16S (variable) +ida_fixup.FIXUP_OFF16S 16-bit signed offset -ida_fixup.FIXUP_OFF32 (variable) +ida_fixup.FIXUP_OFF32 32-bit offset -ida_fixup.FIXUP_OFF32S (variable) +ida_fixup.FIXUP_OFF32S 32-bit signed offset -ida_fixup.FIXUP_OFF64 (variable) +ida_fixup.FIXUP_OFF64 64-bit offset -ida_fixup.FIXUP_OFF8 (variable) +ida_fixup.FIXUP_OFF8 8-bit offset -ida_fixup.FIXUP_OFF8S (variable) +ida_fixup.FIXUP_OFF8S 8-bit signed offset -ida_fixup.FIXUP_PTR16 (variable) - 32-bit long pointer (16-bit base:16-bit offset) +ida_fixup.FIXUP_PTR16 + 32-bit long pointer (16-bit base:16-bit offset) + -ida_fixup.FIXUP_PTR32 (variable) +ida_fixup.FIXUP_PTR32 48-bit pointer (16-bit base:32-bit offset) -ida_fixup.FIXUP_SEG16 (variable) +ida_fixup.FIXUP_SEG16 16-bit base-logical segment base (selector) -ida_fixup.V695_FIXUP_VHIGH (variable) +ida_fixup.V695_FIXUP_VHIGH obsolete -ida_fixup.V695_FIXUP_VLOW (variable) +ida_fixup.V695_FIXUP_VLOW obsolete -ida_fixup.calc_fixup_size (function) - calc_fixup_size(type) -> int - Calculate size of fixup in bytes (the number of bytes the fixup patches) +ida_fixup.calc_fixup_size(type: "fixup_type_t") -> int + Calculate size of fixup in bytes (the number of bytes the fixup patches) + @retval -1: means error - - @param type: (C++: fixup_type_t) -ida_fixup.contains_fixups (function) - contains_fixups(ea, size) -> bool +ida_fixup.contains_fixups(ea: ida_idaapi.ea_t, size: "asize_t") -> bool Does the specified address range contain any fixup information? - - @param ea: (C++: ea_t) - @param size: (C++: asize_t) -ida_fixup.del_fixup (function) - del_fixup(source) +ida_fixup.del_fixup(source: ida_idaapi.ea_t) -> None Delete fixup information. - - @param source: (C++: ea_t) -ida_fixup.exists_fixup (function) - exists_fixup(source) -> bool +ida_fixup.exists_fixup(source: ida_idaapi.ea_t) -> bool Check that a fixup exists at the given address. - - @param source: (C++: ea_t) -ida_fixup.find_custom_fixup (function) - find_custom_fixup(name) -> fixup_type_t - Get id of a custom fixup handler. - - @param name: (C++: const char *) name of the custom fixup handler - @return: id with FIXUP_CUSTOM bit set or 0 +ida_fixup.find_custom_fixup(name: str) -> "fixup_type_t" -ida_fixup.fixup_data_t (class) - Proxy of C++ fixup_data_t class. +ida_fixup.fixup_data_t -ida_fixup.fixup_data_t.__init__ (method) - __init__(self) -> fixup_data_t - __init__(self, type_, flags_=0) -> fixup_data_t - - @param type_: fixup_type_t - @param flags_: uint32 +ida_fixup.fixup_data_t.__init__(self, *args) -ida_fixup.fixup_data_t.calc_size (method) - calc_size(self) -> int +ida_fixup.fixup_data_t.calc_size(self) -> int calc_fixup_size() -ida_fixup.fixup_data_t.clr_extdef (method) - clr_extdef(self) +ida_fixup.fixup_data_t.clr_extdef(self) -> None -ida_fixup.fixup_data_t.clr_unused (method) - clr_unused(self) +ida_fixup.fixup_data_t.clr_unused(self) -> None -ida_fixup.fixup_data_t.displacement (variable) +ida_fixup.fixup_data_t.displacement displacement (offset from the target) -ida_fixup.fixup_data_t.get (method) - get(self, source) -> bool +ida_fixup.fixup_data_t.get(self, source: ida_idaapi.ea_t) -> bool get_fixup() - - @param source: (C++: ea_t) -ida_fixup.fixup_data_t.get_base (method) - get_base(self) -> ea_t - Get base of fixup. - @note: The target is calculated as `get_base() + off`. - @see: FIXUPF_REL +ida_fixup.fixup_data_t.get_base(self) -> ida_idaapi.ea_t + Get base of fixup. + -ida_fixup.fixup_data_t.get_desc (method) - get_desc(self, source) -> char const * +ida_fixup.fixup_data_t.get_desc(self, source: ida_idaapi.ea_t) -> str get_fixup_desc() - - @param source: (C++: ea_t) -ida_fixup.fixup_data_t.get_flags (method) - get_flags(self) -> uint32 +ida_fixup.fixup_data_t.get_flags(self) -> int Fixup flags Fixup flags. -ida_fixup.fixup_data_t.get_handler (method) - get_handler(self) -> fixup_handler_t const * +ida_fixup.fixup_data_t.get_handler(self) -> "fixup_handler_t const *" get_fixup_handler() -ida_fixup.fixup_data_t.get_type (method) - get_type(self) -> fixup_type_t +ida_fixup.fixup_data_t.get_type(self) -> "fixup_type_t" Fixup type Types of fixups. -ida_fixup.fixup_data_t.get_value (method) - get_value(self, ea) -> uval_t +ida_fixup.fixup_data_t.get_value(self, ea: ida_idaapi.ea_t) -> int get_fixup_value() - - @param ea: (C++: ea_t) -ida_fixup.fixup_data_t.has_base (method) - has_base(self) -> bool +ida_fixup.fixup_data_t.has_base(self) -> bool Is fixup relative? -ida_fixup.fixup_data_t.is_custom (method) - is_custom(self) -> bool +ida_fixup.fixup_data_t.is_custom(self) -> bool is_fixup_custom() -ida_fixup.fixup_data_t.is_extdef (method) - is_extdef(self) -> bool +ida_fixup.fixup_data_t.is_extdef(self) -> bool -ida_fixup.fixup_data_t.is_unused (method) - is_unused(self) -> bool +ida_fixup.fixup_data_t.is_unused(self) -> bool -ida_fixup.fixup_data_t.off (variable) - target offset - @note: The target is calculated as `get_base() + off`. +ida_fixup.fixup_data_t.off + target offset + -ida_fixup.fixup_data_t.patch_value (method) - patch_value(self, ea) -> bool +ida_fixup.fixup_data_t.patch_value(self, ea: ida_idaapi.ea_t) -> bool patch_fixup_value() - - @param ea: (C++: ea_t) -ida_fixup.fixup_data_t.sel (variable) - selector of the target segment. BADSEL means an absolute (zero based) target. - @see: FIXUPF_REL +ida_fixup.fixup_data_t.sel + selector of the target segment. BADSEL means an absolute (zero based) target. + -ida_fixup.fixup_data_t.set (method) - set(self, source) +ida_fixup.fixup_data_t.set(self, source: ida_idaapi.ea_t) -> None set_fixup() - - @param source: (C++: ea_t) -ida_fixup.fixup_data_t.set_base (method) - set_base(self, new_base) - Set base of fixup. The target should be set before a call of this function. - - @param new_base: (C++: ea_t) +ida_fixup.fixup_data_t.set_base(self, new_base: ida_idaapi.ea_t) -> None + Set base of fixup. The target should be set before a call of this function. + -ida_fixup.fixup_data_t.set_extdef (method) - set_extdef(self) +ida_fixup.fixup_data_t.set_extdef(self) -> None -ida_fixup.fixup_data_t.set_sel (method) - set_sel(self, seg) - - @param seg: segment_t const * +ida_fixup.fixup_data_t.set_sel(self, seg: "segment_t const *") -> None -ida_fixup.fixup_data_t.set_target_sel (method) - set_target_sel(self) - Set selector of fixup to the target. The target should be set before a call of - this function. +ida_fixup.fixup_data_t.set_target_sel(self) -> None + Set selector of fixup to the target. The target should be set before a call of this function. + -ida_fixup.fixup_data_t.set_type (method) - set_type(self, type_) - - @param type_: fixup_type_t +ida_fixup.fixup_data_t.set_type(self, type_: "fixup_type_t") -> None -ida_fixup.fixup_data_t.set_type_and_flags (method) - set_type_and_flags(self, type_, flags_=0) - - @param type_: fixup_type_t - @param flags_: uint32 +ida_fixup.fixup_data_t.set_type_and_flags(self, type_: "fixup_type_t", flags_: int = 0) -> None -ida_fixup.fixup_data_t.set_unused (method) - set_unused(self) +ida_fixup.fixup_data_t.set_unused(self) -> None -ida_fixup.fixup_data_t.was_created (method) - was_created(self) -> bool +ida_fixup.fixup_data_t.was_created(self) -> bool Is fixup artificial? -ida_fixup.fixup_info_t (class) - Proxy of C++ fixup_info_t class. +ida_fixup.fixup_info_t -ida_fixup.fixup_info_t.__init__ (method) - __init__(self) -> fixup_info_t +ida_fixup.fixup_info_t.__init__(self) -ida_fixup.gen_fix_fixups (function) - gen_fix_fixups(_from, to, size) - Relocate the bytes with fixup information once more (generic function). This - function may be called from loader_t::move_segm() if it suits the goal. If - loader_t::move_segm is not defined then this function will be called - automatically when moving segments or rebasing the entire program. Special - parameter values (from = BADADDR, size = 0, to = delta) are used when the - function is called from rebase_program(delta). - - @param from: (C++: ea_t) - @param to: (C++: ea_t) - @param size: (C++: asize_t) +ida_fixup.gen_fix_fixups(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, size: "asize_t") -> None + Relocate the bytes with fixup information once more (generic function). This function may be called from loader_t::move_segm() if it suits the goal. If loader_t::move_segm is not defined then this function will be called automatically when moving segments or rebasing the entire program. Special parameter values (from = BADADDR, size = 0, to = delta) are used when the function is called from rebase_program(delta). + -ida_fixup.get_first_fixup_ea (function) - get_first_fixup_ea() -> ea_t +ida_fixup.get_first_fixup_ea() -> ida_idaapi.ea_t -ida_fixup.get_fixup (function) - get_fixup(fd, source) -> bool +ida_fixup.get_fixup(fd: "fixup_data_t", source: ida_idaapi.ea_t) -> bool Get fixup information. - - @param fd: (C++: fixup_data_t *) - @param source: (C++: ea_t) -ida_fixup.get_fixup_desc (function) - get_fixup_desc(source, fd) -> str +ida_fixup.get_fixup_desc(source: ida_idaapi.ea_t, fd: "fixup_data_t") -> str Get FIXUP description comment. - - @param source: (C++: ea_t) - @param fd: (C++: const fixup_data_t &) fixup_data_t const & -ida_fixup.get_fixup_handler (function) - get_fixup_handler(type) -> fixup_handler_t const * +ida_fixup.get_fixup_handler(type: "fixup_type_t") -> "fixup_handler_t const *" Get handler of standard or custom fixup. - - @param type: (C++: fixup_type_t) -ida_fixup.get_fixup_value (function) - get_fixup_value(ea, type) -> uval_t - Get the operand value. This function get fixup bytes from data or an instruction - at `ea' and convert them to the operand value (maybe partially). It is opposite - in meaning to the `patch_fixup_value()`. For example, FIXUP_HI8 read a byte at - `ea' and shifts it left by 8 bits, or AArch64's custom fixup BRANCH26 get low 26 - bits of the insn at `ea' and shifts it left by 2 bits. This function is mainly - used to get a relocation addend. - - @param ea: (C++: ea_t) address to get fixup bytes from, the size of the fixup bytes depends - on the fixup type. - @see: fixup_handler_t::size - @param type: (C++: fixup_type_t) fixup type +ida_fixup.get_fixup_value(ea: ida_idaapi.ea_t, type: "fixup_type_t") -> int + Get the operand value. This function get fixup bytes from data or an instruction at `ea` and convert them to the operand value (maybe partially). It is opposite in meaning to the `patch_fixup_value()`. For example, FIXUP_HI8 read a byte at `ea` and shifts it left by 8 bits, or AArch64's custom fixup BRANCH26 get low 26 bits of the insn at `ea` and shifts it left by 2 bits. This function is mainly used to get a relocation addend. + + @param ea: address to get fixup bytes from, the size of the fixup bytes depends on the fixup type. + @param type: fixup type @retval operand: value -ida_fixup.get_fixups (function) - get_fixups(out, ea, size) -> bool - - @param out: fixups_t * - @param ea: ea_t - @param size: asize_t +ida_fixup.get_fixups(out: "fixups_t *", ea: ida_idaapi.ea_t, size: "asize_t") -> bool -ida_fixup.get_next_fixup_ea (function) - get_next_fixup_ea(ea) -> ea_t - Find next address with fixup information - - @param ea: (C++: ea_t) current address - @return: the next address with fixup information, or BADADDR +ida_fixup.get_next_fixup_ea(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_fixup.get_prev_fixup_ea (function) - get_prev_fixup_ea(ea) -> ea_t - Find previous address with fixup information - - @param ea: (C++: ea_t) current address - @return: the previous address with fixup information, or BADADDR +ida_fixup.get_prev_fixup_ea(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_fixup.handle_fixups_in_macro (function) - handle_fixups_in_macro(ri, ea, other, macro_reft_and_flags) -> bool - Handle two fixups in a macro. We often combine two instruction that load parts - of a value into one macro instruction. For example: - ARM: ADRP X0, #var@PAGE - ADD X0, X0, #var@PAGEOFF --> ADRL X0, var - MIPS: lui $v0, %hi(var) - addiu $v0, $v0, %lo(var) --> la $v0, var - When applying the fixups that fall inside such a macro, we should convert them - to one refinfo. This function does exactly that. It should be called from the - apply() callback of a custom fixup. +ida_fixup.handle_fixups_in_macro(ri: "refinfo_t", ea: ida_idaapi.ea_t, other: "fixup_type_t", macro_reft_and_flags: int) -> bool + Handle two fixups in a macro. We often combine two instruction that load parts of a value into one macro instruction. For example: + ADRP X0, #var@PAGE + ADD X0, X0, #var@PAGEOFF --> ADRL X0, var + lui $v0, %hi(var) + addiu $v0, $v0, %lo(var) --> la $v0, var - @param ri: (C++: refinfo_t *) - @param ea: (C++: ea_t) - @param other: (C++: fixup_type_t) - @param macro_reft_and_flags: (C++: uint32) - @return: success ('false' means that RI was not changed) + + + @returns success ('false' means that RI was not changed) -ida_fixup.is_fixup_custom (function) - is_fixup_custom(type) -> bool +ida_fixup.is_fixup_custom(type: "fixup_type_t") -> bool Is fixup processed by processor module? - - @param type: (C++: fixup_type_t) -ida_fixup.patch_fixup_value (function) - patch_fixup_value(ea, fd) -> bool - Patch the fixup bytes. This function updates data or an instruction at `ea' to - the fixup bytes. For example, FIXUP_HI8 updates a byte at `ea' to the high byte - of `fd->off', or AArch64's custom fixup BRANCH26 updates low 26 bits of the insn - at `ea' to the value of `fd->off' shifted right by 2. - - @param ea: (C++: ea_t) address where data are changed, the size of the changed data depends - on the fixup type. - @see: fixup_handler_t::size - @param fd: (C++: const fixup_data_t &) fixup data - @retval false: the fixup bytes do not fit (e.g. `fd->off' is greater than - 0xFFFFFFC for BRANCH26). The database is changed even in this - case. +ida_fixup.patch_fixup_value(ea: ida_idaapi.ea_t, fd: "fixup_data_t") -> bool + Patch the fixup bytes. This function updates data or an instruction at `ea` to the fixup bytes. For example, FIXUP_HI8 updates a byte at `ea` to the high byte of `fd->off`, or AArch64's custom fixup BRANCH26 updates low 26 bits of the insn at `ea` to the value of `fd->off` shifted right by 2. + + @param ea: address where data are changed, the size of the changed data depends on the fixup type. + @param fd: fixup data + @retval false: the fixup bytes do not fit (e.g. `fd->off` is greater than 0xFFFFFFC for BRANCH26). The database is changed even in this case. -ida_fixup.set_fixup (function) - set_fixup(source, fd) - Set fixup information. You should fill fixup_data_t and call this function and - the kernel will remember information in the database. - - @param source: (C++: ea_t) the fixup source address, i.e. the address modified by the fixup - @param fd: (C++: const fixup_data_t &) fixup data +ida_fixup.set_fixup(source: ida_idaapi.ea_t, fd: "fixup_data_t") -> None + Set fixup information. You should fill fixup_data_t and call this function and the kernel will remember information in the database. + + @param source: the fixup source address, i.e. the address modified by the fixup + @param fd: fixup data -ida_fpro (module) +ida_fpro System independent counterparts of FILE* related functions from Clib. - You should not use C standard I/O functions in your modules. The reason: Each - module compiled with Borland (and statically linked to Borland's library) will - host a copy of the FILE * information. - - So, if you open a file in the plugin and pass the handle to the kernel, the - kernel will not be able to use it. - - If you really need to use the standard functions, define - USE_STANDARD_FILE_FUNCTIONS. In this case do not mix them with q... functions. + You should not use C standard I/O functions in your modules. The reason: Each module compiled with Borland (and statically linked to Borland's library) will host a copy of the FILE * information. + So, if you open a file in the plugin and pass the handle to the kernel, the kernel will not be able to use it. + If you really need to use the standard functions, define USE_STANDARD_FILE_FUNCTIONS. In this case do not mix them with q... functions. + -ida_fpro.qfile_t (class) +ida_fpro.qfclose(fp: "FILE *") -> int + +ida_fpro.qfile_t A helper class to work with FILE related functions. -ida_fpro.qfile_t.__init__ (method) - __init__(self, rhs) -> qfile_t - - @param rhs: qfile_t const & - - __init__(self, pycapsule=None) -> qfile_t - - @param pycapsule: PyObject * +ida_fpro.qfile_t.__init__(self, *args) -ida_fpro.qfile_t.close (method) - close(self) +ida_fpro.qfile_t.close(self) Closes the file -ida_fpro.qfile_t.filename (method) - filename(self) -> PyObject * +ida_fpro.qfile_t.filename(self) -> "PyObject *" -ida_fpro.qfile_t.flush (method) - flush(self) -> int +ida_fpro.qfile_t.flush(self) -ida_fpro.qfile_t.from_capsule (method) - from_capsule(pycapsule) -> qfile_t - - @param pycapsule: PyObject * +ida_fpro.qfile_t.from_capsule(pycapsule: "PyObject *") -> "qfile_t *" -ida_fpro.qfile_t.from_fp (method) - from_fp(fp) -> qfile_t - - @param fp: FILE * +ida_fpro.qfile_t.from_fp(fp: "FILE *") -> "qfile_t *" -ida_fpro.qfile_t.get_byte (method) - get_byte(self) -> PyObject * +ida_fpro.qfile_t.get_byte(self) Reads a single byte from the file. Returns None if EOF or the read byte -ida_fpro.qfile_t.get_fp (method) - get_fp(self) -> FILE * +ida_fpro.qfile_t.get_fp(self) -> "FILE *" -ida_fpro.qfile_t.gets (method) - gets(self, size) -> PyObject * +ida_fpro.qfile_t.gets(self, len) Reads a line from the input file. Returns the read line or None - @param size: int + @param len: the maximum line length -ida_fpro.qfile_t.open (method) - open(self, filename, mode) -> bool +ida_fpro.qfile_t.open(self, filename, mode) Opens a file @param filename: the file name @param mode: The mode string, ala fopen() style @return: Boolean -ida_fpro.qfile_t.opened (method) - opened(self) -> bool +ida_fpro.qfile_t.opened(self) Checks if the file is opened or not -ida_fpro.qfile_t.put_byte (method) - put_byte(self, chr) -> int +ida_fpro.qfile_t.put_byte(self) Writes a single byte to the file - @param chr: int + @param chr: the byte value -ida_fpro.qfile_t.puts (method) - puts(self, str) -> int - - @param str: char const * +ida_fpro.qfile_t.puts(self, str: str) -> int -ida_fpro.qfile_t.read (method) - read(self, size) -> PyObject * +ida_fpro.qfile_t.read(self, size) Reads from the file. Returns the buffer or None - @param size: int + @param size: the maximum number of bytes to read + @return: a str, or None -ida_fpro.qfile_t.readbytes (method) - readbytes(self, size, big_endian) -> PyObject * +ida_fpro.qfile_t.readbytes(self, size, big_endian) Similar to read() but it respect the endianness - @param size: int - @param big_endian: bool + @param size: the maximum number of bytes to read + @param big_endian: endianness + @return a str, or None -ida_fpro.qfile_t.seek (method) - seek(self, offset, whence=SEEK_SET) -> int +ida_fpro.qfile_t.seek(self, offset, whence = ida_idaapi.SEEK_SET) Set input source position - @param offset: int64 - @param whence: int + @param offset: the seek offset + @param whence: the position to seek from @return: the new position (not 0 as fseek!) -ida_fpro.qfile_t.size (method) - size(self) -> int64 +ida_fpro.qfile_t.size(self) -> "int64" -ida_fpro.qfile_t.tell (method) - tell(self) -> int64 +ida_fpro.qfile_t.tell(self) Returns the current position -ida_fpro.qfile_t.tmpfile (method) - tmpfile() -> qfile_t +ida_fpro.qfile_t.tmpfile() A static method to construct an instance using a temporary file -ida_fpro.qfile_t.write (method) - write(self, py_buf) -> int +ida_fpro.qfile_t.write(self, buf) Writes to the file. Returns 0 or the number of bytes written - @param py_buf: PyObject * + @param buf: the str to write + @return: result code -ida_fpro.qfile_t.writebytes (method) - writebytes(self, py_buf, big_endian) -> int +ida_fpro.qfile_t.writebytes(self, size, big_endian) Similar to write() but it respect the endianness - @param py_buf: PyObject * - @param big_endian: bool + @param buf: the str to write + @param big_endian: endianness + @return: result code -ida_fpro.qfile_t_from_capsule (function) - qfile_t_from_capsule(pycapsule) -> qfile_t +ida_frame + Routines to manipulate function stack frames, stack variables, register variables and local labels. - @param pycapsule: PyObject * - -ida_fpro.qfile_t_from_fp (function) - qfile_t_from_fp(fp) -> qfile_t - - @param fp: FILE * - -ida_fpro.qfile_t_tmpfile (function) - qfile_t_tmpfile() -> qfile_t - -ida_frame (module) - Routines to manipulate function stack frames, stack variables, register - variables and local labels. - - The frame is represented as a structure: - +------------------------------------------------+ + The frame is represented as a structure: + +------------------------------------------------+ | function arguments | +------------------------------------------------+ | return address (isn't stored in func_t) | @@ -23789,1560 +15623,1117 @@ ida_frame (module) | | +------------------------------------------------+ <- SP - To access the structure of a function frame, use: - * get_struc() (use func_t::frame as structure ID) - * get_frame(const func_t *pfn) - * get_frame(ea_t ea) + To access the structure of a function frame and stack variables, use: + * tinfo_t::get_func_frame(const func_t *pfn) (the preferred way) + * get_func_frame(tinfo_t *out, const func_t *pfn) + * tinfo_t::get_udt_details() gives info about stack variables: their type, names, offset, etc + + + -ida_frame.REGVAR_ERROR_ARG (variable) +ida_frame.REGVAR_ERROR_ARG function arguments are bad -ida_frame.REGVAR_ERROR_NAME (variable) +ida_frame.REGVAR_ERROR_NAME the provided name(s) can't be accepted -ida_frame.REGVAR_ERROR_OK (variable) +ida_frame.REGVAR_ERROR_OK all ok -ida_frame.REGVAR_ERROR_RANGE (variable) +ida_frame.REGVAR_ERROR_RANGE the definition range is bad -ida_frame.STKVAR_VALID_SIZE (variable) - x.dtyp contains correct variable type (for insns like 'lea' this bit must be - off). In general, dr_O references do not allow to determine the variable size +ida_frame.STKVAR_VALID_SIZE + x.dtyp contains correct variable type (for insns like 'lea' this bit must be off). In general, dr_O references do not allow to determine the variable size + -ida_frame.add_auto_stkpnt (function) - add_auto_stkpnt(pfn, ea, delta) -> bool - Add automatic SP register change point. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address where SP changes. usually this is the end of the - instruction which modifies the stack pointer ( insn_t::ea+ - insn_t::size) - @param delta: (C++: sval_t) difference between old and new values of SP - @return: success +ida_frame.add_auto_stkpnt(pfn: "func_t *", ea: ida_idaapi.ea_t, delta: int) -> bool + Add automatic SP register change point. + + @param pfn: pointer to the function. may be nullptr. + @param ea: linear address where SP changes. usually this is the end of the instruction which modifies the stack pointer ( insn_t::ea+ insn_t::size) + @param delta: difference between old and new values of SP + @returns success -ida_frame.add_frame (function) - add_frame(pfn, frsize, frregs, argsize) -> bool - Add function frame. - - @param pfn: (C++: func_t *) pointer to function structure - @param frsize: (C++: sval_t) size of function local variables - @param frregs: (C++: ushort) size of saved registers - @param argsize: (C++: asize_t) size of function arguments range which will be purged upon - return. this parameter is used for __stdcall and __pascal - calling conventions. for other calling conventions please pass - 0. +ida_frame.add_frame(pfn: "func_t *", frsize: int, frregs: "ushort", argsize: "asize_t") -> bool + Add function frame. + + @param pfn: pointer to function structure + @param frsize: size of function local variables + @param frregs: size of saved registers + @param argsize: size of function arguments range which will be purged upon return. this parameter is used for __stdcall and __pascal calling conventions. for other calling conventions please pass 0. @retval 1: ok @retval 0: failed (no function, frame already exists) -ida_frame.add_regvar (function) - add_regvar(pfn, ea1, ea2, canon, user, cmt) -> int - Define a register variable. - - @param pfn: (C++: func_t *) function in which the definition will be created - @param ea1: (C++: ea_t) ,ea2: range of addresses within the function where the definition will - be used - @param canon: (C++: const char *) name of a general register - @param canon: (C++: const char *) name of a general register - @param user: (C++: const char *) user-defined name for the register - @param cmt: (C++: const char *) comment for the definition - @return: Register variable error codes +ida_frame.add_frame_member(pfn: "func_t const *", name: str, offset: int, tif: "tinfo_t", repr: "value_repr_t" = None, etf_flags: "uint" = 0) -> bool + Add member to the frame type + + @param pfn: pointer to function + @param name: variable name, nullptr means autogenerate a name + @param offset: member offset in the frame structure, in bytes + @param tif: variable type + @param repr: variable representation + @returns success -ida_frame.add_user_stkpnt (function) - add_user_stkpnt(ea, delta) -> bool - Add user-defined SP register change point. - - @param ea: (C++: ea_t) linear address where SP changes - @param delta: (C++: sval_t) difference between old and new values of SP - @return: success +ida_frame.add_regvar(pfn: "func_t *", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, canon: str, user: str, cmt: str) -> int + Define a register variable. + + @param pfn: function in which the definition will be created + @param ea1: range of addresses within the function where the definition will be used + @param ea2: range of addresses within the function where the definition will be used + @param canon: name of a general register + @param user: user-defined name for the register + @param cmt: comment for the definition + @returns Register variable error codes -ida_frame.build_stkvar_name (function) - build_stkvar_name(pfn, v) -> str - Build automatic stack variable name. - - @param pfn: (C++: const func_t *) pointer to function (can't be nullptr!) - @param v: (C++: sval_t) value of variable offset - @return: length of stack variable name or -1 +ida_frame.add_user_stkpnt(ea: ida_idaapi.ea_t, delta: int) -> bool + Add user-defined SP register change point. + + @param ea: linear address where SP changes + @param delta: difference between old and new values of SP + @returns success -ida_frame.build_stkvar_xrefs (function) - build_stkvar_xrefs(out, pfn, mptr) - Fill 'out' with a list of all the xrefs made from function 'pfn', to the - argument or variable 'mptr' in 'pfn's stack frame. - - @param out: (C++: xreflist_t *) the list of xrefs to fill. - @param pfn: (C++: func_t *) the function to scan. - @param mptr: (C++: const member_t *) the argument/variable in pfn's stack frame. +ida_frame.build_stkvar_name(pfn: "func_t const *", v: int) -> str + Build automatic stack variable name. + + @param pfn: pointer to function (can't be nullptr!) + @param v: value of variable offset + @returns length of stack variable name or -1 -ida_frame.calc_stkvar_struc_offset (function) - calc_stkvar_struc_offset(pfn, insn, n) -> ea_t - Calculate offset of stack variable in the frame structure. - - @param pfn: (C++: func_t *) pointer to function (can't be nullptr!) - @param insn: (C++: const insn_t &) the instruction - @param n: (C++: int) 0..UA_MAXOP-1 operand number -1 if error, return BADADDR - @return: BADADDR if some error (issue a warning if stack frame is bad) +ida_frame.build_stkvar_xrefs(out: "xreflist_t", pfn: "func_t *", start_offset: int, end_offset: int) -> None + Fill 'out' with a list of all the xrefs made from function 'pfn' to specified range of the pfn's stack frame. + + @param out: the list of xrefs to fill. + @param pfn: the function to scan. + @param start_offset: start frame structure offset, in bytes + @param end_offset: end frame structure offset, in bytes -ida_frame.define_stkvar (function) - define_stkvar(pfn, name, off, flags, ti, nbytes) -> bool - Define/redefine a stack variable. - - @param pfn: (C++: func_t *) pointer to function - @param name: (C++: const char *) variable name, nullptr means autogenerate a name - @param off: (C++: sval_t) offset of the stack variable in the frame. negative values denote - local variables, positive - function arguments. - @param flags: (C++: flags64_t) variable type flags (byte_flag() for a byte variable, for example) - @param ti: (C++: const opinfo_t *) additional type information (like offsets, structs, etc) - @param nbytes: (C++: asize_t) number of bytes occupied by the variable - @return: success +ida_frame.calc_frame_offset(pfn: "func_t *", off: int, insn: "insn_t const *" = None, op: "op_t const *" = None) -> int + Calculate the offset of stack variable in the frame. + + @param pfn: pointer to function (cannot be nullptr) + @param off: the offset relative to stack pointer or frame pointer + @param insn: the instruction + @param op: the operand + @returns the offset in the frame -ida_frame.del_frame (function) - del_frame(pfn) -> bool - Delete a function frame. - - @param pfn: (C++: func_t *) pointer to function structure - @return: success +ida_frame.calc_stkvar_struc_offset(pfn: "func_t *", insn: "insn_t const &", n: int) -> ida_idaapi.ea_t + Calculate offset of stack variable in the frame structure. + + @param pfn: pointer to function (cannot be nullptr) + @param insn: the instruction + @param n: 0..UA_MAXOP-1 operand number -1 if error, return BADADDR + @returns BADADDR if some error (issue a warning if stack frame is bad) -ida_frame.del_regvar (function) - del_regvar(pfn, ea1, ea2, canon) -> int - Delete a register variable definition. - - @param pfn: (C++: func_t *) function in question - @param ea1: (C++: ea_t) ,ea2: range of addresses within the function where the definition - holds - @param canon: (C++: const char *) name of a general register - @param canon: (C++: const char *) name of a general register - @return: Register variable error codes +ida_frame.define_stkvar(pfn: "func_t *", name: str, off: int, tif: "tinfo_t", repr: "value_repr_t" = None) -> bool + Define/redefine a stack variable. + + @param pfn: pointer to function + @param name: variable name, nullptr means autogenerate a name + @param off: offset of the stack variable in the frame. negative values denote local variables, positive - function arguments. + @param tif: variable type + @param repr: variable representation + @returns success -ida_frame.del_stkpnt (function) - del_stkpnt(pfn, ea) -> bool - Delete SP register change point. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address - @return: success +ida_frame.del_frame(pfn: "func_t *") -> bool + Delete a function frame. + + @param pfn: pointer to function structure + @returns success -ida_frame.delete_unreferenced_stkvars (function) - delete_unreferenced_stkvars(pfn) -> int - - @param pfn: func_t * +ida_frame.del_regvar(pfn: "func_t *", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, canon: str) -> int + Delete a register variable definition. + + @param pfn: function in question + @param ea1: range of addresses within the function where the definition holds + @param ea2: range of addresses within the function where the definition holds + @param canon: name of a general register + @returns Register variable error codes -ida_frame.delete_wrong_stkvar_ops (function) - delete_wrong_stkvar_ops(pfn) -> int - - @param pfn: func_t * +ida_frame.del_stkpnt(pfn: "func_t *", ea: ida_idaapi.ea_t) -> bool + Delete SP register change point. + + @param pfn: pointer to the function. may be nullptr. + @param ea: linear address + @returns success -ida_frame.find_regvar (function) - find_regvar(pfn, ea1, ea2, canon, user) -> regvar_t - Find a register variable definition. - - @param pfn: (C++: func_t *) function in question - @param ea1: ea_t - @param canon: (C++: const char *) name of a general register - @param canon: (C++: const char *) name of a general register - @param user: char const * - - @return: nullptr-not found, otherwise ptr to regvar_t - find_regvar(pfn, ea, canon) -> regvar_t - - @param pfn: func_t * - @param ea: ea_t - @param canon: char const * +ida_frame.delete_frame_members(pfn: "func_t const *", start_offset: int, end_offset: int) -> bool + Delete frame members + + @param pfn: pointer to function + @param start_offset: member offset to start deletion from, in bytes + @param end_offset: member offset which not included in the deletion, in bytes + @returns success -ida_frame.frame_off_args (function) - frame_off_args(pfn) -> ea_t +ida_frame.find_regvar(*args) -> "regvar_t *" + This function has the following signatures: + + 0. find_regvar(pfn: func_t *, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, canon: str, user: str) -> regvar_t * + 1. find_regvar(pfn: func_t *, ea: ida_idaapi.ea_t, canon: str) -> regvar_t * + + # 0: find_regvar(pfn: func_t *, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, canon: str, user: str) -> regvar_t * + + Find a register variable definition (powerful version). One of 'canon' and 'user' should be nullptr. If both 'canon' and 'user' are nullptr it returns the first regvar definition in the range. + + @returns nullptr-not found, otherwise ptr to regvar_t + + # 1: find_regvar(pfn: func_t *, ea: ida_idaapi.ea_t, canon: str) -> regvar_t * + + Find a register variable definition. + + @returns nullptr-not found, otherwise ptr to regvar_t + +ida_frame.frame_off_args(pfn: "func_t const *") -> ida_idaapi.ea_t Get starting address of arguments section. - - @param pfn: (C++: const func_t *) func_t const * -ida_frame.frame_off_lvars (function) - frame_off_lvars(pfn) -> ea_t +ida_frame.frame_off_lvars(pfn: "func_t const *") -> ida_idaapi.ea_t Get start address of local variables section. - - @param pfn: (C++: const func_t *) func_t const * -ida_frame.frame_off_retaddr (function) - frame_off_retaddr(pfn) -> ea_t +ida_frame.frame_off_retaddr(pfn: "func_t const *") -> ida_idaapi.ea_t Get starting address of return address section. - - @param pfn: (C++: const func_t *) func_t const * -ida_frame.frame_off_savregs (function) - frame_off_savregs(pfn) -> ea_t +ida_frame.frame_off_savregs(pfn: "func_t const *") -> ida_idaapi.ea_t Get starting address of saved registers section. - - @param pfn: (C++: const func_t *) func_t const * -ida_frame.free_regvar (function) - free_regvar(v) - - @param v: regvar_t * +ida_frame.free_regvar(v: "regvar_t") -> None -ida_frame.get_effective_spd (function) - get_effective_spd(pfn, ea) -> sval_t - Get effective difference between the initial and current values of ESP. This - function returns the sp-diff used by the instruction. The difference between - get_spd() and get_effective_spd() is present only for instructions like "pop - [esp+N]": they modify sp and use the modified value. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address - @return: 0 or the difference, usually a negative number +ida_frame.get_effective_spd(pfn: "func_t *", ea: ida_idaapi.ea_t) -> int + Get effective difference between the initial and current values of ESP. This function returns the sp-diff used by the instruction. The difference between get_spd() and get_effective_spd() is present only for instructions like "pop [esp+N]": they modify sp and use the modified value. + + @param pfn: pointer to the function. may be nullptr. + @param ea: linear address + @returns 0 or the difference, usually a negative number -ida_frame.get_frame (function) - get_frame(pfn) -> struc_t * - Get pointer to function frame. - - @param pfn: func_t const * +ida_frame.get_frame_part(range: "range_t", pfn: "func_t const *", part: "frame_part_t") -> None + Get offsets of the frame part in the frame. + + @param range: pointer to the output buffer with the frame part start/end(exclusive) offsets, can't be nullptr + @param pfn: pointer to function structure, can't be nullptr + @param part: frame part -ida_frame.get_frame_member_by_id (function) - get_frame_member_by_id(out_mname, out_fptr, mid) -> member_t * - Check if the specified member id points to a frame member. - - @param out_mname: (C++: qstring *) - @param out_fptr: (C++: struc_t **) - @param mid: (C++: tid_t) +ida_frame.get_frame_retsize(pfn: "func_t const *") -> int + Get size of function return address. + + @param pfn: pointer to function structure, can't be nullptr -ida_frame.get_frame_part (function) - get_frame_part(range, pfn, part) - Get offsets of the frame part in the frame. - - @param range: (C++: range_t *) pointer to the output buffer with the frame part - start/end(exclusive) offsets, can't be nullptr - @param pfn: (C++: const func_t *) pointer to function structure, can't be nullptr - @param part: (C++: frame_part_t) frame part +ida_frame.get_frame_size(pfn: "func_t const *") -> "asize_t" + Get full size of a function frame. This function takes into account size of local variables + size of saved registers + size of return address + number of purged bytes. The purged bytes correspond to the arguments of the functions with __stdcall and __fastcall calling conventions. + + @param pfn: pointer to function structure, may be nullptr + @returns size of frame in bytes or zero -ida_frame.get_frame_retsize (function) - get_frame_retsize(pfn) -> int - Get size of function return address. - - @param pfn: (C++: const func_t *) pointer to function structure, can't be nullptr +ida_frame.get_func_frame(out: "tinfo_t", pfn: "func_t const *") -> bool + Get type of function frame + + @param out: type info + @param pfn: pointer to function structure + @returns success -ida_frame.get_frame_size (function) - get_frame_size(pfn) -> asize_t - Get full size of a function frame. This function takes into account size of - local variables + size of saved registers + size of return address + number of - purged bytes. The purged bytes correspond to the arguments of the functions with - __stdcall and __fastcall calling conventions. - - @param pfn: (C++: const func_t *) pointer to function structure, may be nullptr - @return: size of frame in bytes or zero +ida_frame.get_sp_delta(pfn: "func_t *", ea: ida_idaapi.ea_t) -> int + Get modification of SP made at the specified location + + @param pfn: pointer to the function. may be nullptr. + @param ea: linear address + @returns 0 if the specified location doesn't contain a SP change point. otherwise return delta of SP modification. -ida_frame.get_func_by_frame (function) - get_func_by_frame(frame_id) -> ea_t - Get function by its frame id. - @warning: this function works only with databases created by IDA > 5.6 - - @param frame_id: (C++: tid_t) id of the function frame - @return: start address of the function or BADADDR +ida_frame.get_spd(pfn: "func_t *", ea: ida_idaapi.ea_t) -> int + Get difference between the initial and current values of ESP. + + @param pfn: pointer to the function. may be nullptr. + @param ea: linear address of the instruction + @returns 0 or the difference, usually a negative number. returns the sp-diff before executing the instruction. -ida_frame.get_min_spd_ea (function) - get_min_spd_ea(pfn) -> ea_t - - @param pfn: func_t * +ida_frame.has_regvar(pfn: "func_t *", ea: ida_idaapi.ea_t) -> bool + Is there a register variable definition? + + @param pfn: function in question + @param ea: current address -ida_frame.get_sp_delta (function) - get_sp_delta(pfn, ea) -> sval_t - Get modification of SP made at the specified location - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address - @return: 0 if the specified location doesn't contain a SP change point. - otherwise return delta of SP modification. +ida_frame.is_anonymous_member_name(name: str) -> bool + Is member name prefixed with "anonymous"? -ida_frame.get_spd (function) - get_spd(pfn, ea) -> sval_t - Get difference between the initial and current values of ESP. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address of the instruction - @return: 0 or the difference, usually a negative number. returns the sp-diff - before executing the instruction. +ida_frame.is_dummy_member_name(name: str) -> bool + Is member name an auto-generated name? -ida_frame.get_stkvar (function) - get_stkvar(insn, op, v) -> (member_t, int) or None - Get pointer to stack variable - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @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 +ida_frame.is_funcarg_off(pfn: "func_t const *", frameoff: int) -> bool -ida_frame.has_regvar (function) - has_regvar(pfn, ea) -> bool - Is there a register variable definition? - - @param pfn: (C++: func_t *) function in question - @param ea: (C++: ea_t) current address +ida_frame.is_special_frame_member(tid: "tid_t") -> bool + Is stkvar with TID the return address slot or the saved registers slot ? + + @param tid: frame member type id return address or saved registers member? -ida_frame.is_funcarg_off (function) - is_funcarg_off(pfn, frameoff) -> bool - - @param pfn: func_t const * - @param frameoff: uval_t +ida_frame.lvar_off(pfn: "func_t const *", frameoff: int) -> int -ida_frame.lvar_off (function) - lvar_off(pfn, frameoff) -> sval_t - - @param pfn: func_t const * - @param frameoff: uval_t - -ida_frame.recalc_spd (function) - recalc_spd(cur_ea) -> bool - Recalculate SP delta for an instruction that stops execution. The next - instruction is not reached from the current instruction. We need to recalculate - SP for the next instruction. - - This function will create a new automatic SP register change point if necessary. - It should be called from the emulator (emu.cpp) when auto_state == AU_USED if - the current instruction doesn't pass the execution flow to the next instruction. - - @param cur_ea: (C++: ea_t) linear address of the current instruction +ida_frame.recalc_spd(cur_ea: ida_idaapi.ea_t) -> bool + Recalculate SP delta for an instruction that stops execution. The next instruction is not reached from the current instruction. We need to recalculate SP for the next instruction. + This function will create a new automatic SP register change point if necessary. It should be called from the emulator (emu.cpp) when auto_state == AU_USED if the current instruction doesn't pass the execution flow to the next instruction. + + @param cur_ea: linear address of the current instruction @retval 1: new stkpnt is added @retval 0: nothing is changed -ida_frame.recalc_spd_for_basic_block (function) - recalc_spd_for_basic_block(pfn, cur_ea) -> bool - Recalculate SP delta for the current instruction. The typical code snippet to - calculate SP delta in a proc module is: +ida_frame.recalc_spd_for_basic_block(pfn: "func_t *", cur_ea: ida_idaapi.ea_t) -> bool + Recalculate SP delta for the current instruction. The typical code snippet to calculate SP delta in a proc module is: if ( may_trace_sp() && pfn != nullptr ) if ( !recalc_spd_for_basic_block(pfn, insn.ea) ) trace_sp(pfn, insn); - where trace_sp() is a typical name for a function that emulates the SP change of - an instruction. + where trace_sp() is a typical name for a function that emulates the SP change of an instruction. - @param pfn: (C++: func_t *) pointer to the function - @param cur_ea: (C++: ea_t) linear address of the current instruction + @param pfn: pointer to the function + @param cur_ea: linear address of the current instruction @retval true: the cumulative SP delta is set - @retval false: the instruction at CUR_EA passes flow to the next instruction. SP - delta must be set as a result of emulating the current - instruction. + @retval false: the instruction at CUR_EA passes flow to the next instruction. SP delta must be set as a result of emulating the current instruction. -ida_frame.regvar_t (class) - Proxy of C++ regvar_t class. +ida_frame.regvar_t -ida_frame.regvar_t.__init__ (method) - __init__(self) -> regvar_t - __init__(self, r) -> regvar_t - - @param r: regvar_t const & +ida_frame.regvar_t.__init__(self, *args) -ida_frame.regvar_t.canon (variable) +ida_frame.regvar_t.canon canonical register name (case-insensitive) -ida_frame.regvar_t.cmt (variable) +ida_frame.regvar_t.cmt comment to appear near definition -ida_frame.regvar_t.swap (method) - swap(self, r) - - @param r: regvar_t & +ida_frame.regvar_t.swap(self, r: "regvar_t") -> None -ida_frame.regvar_t.user (variable) +ida_frame.regvar_t.user user-defined register name -ida_frame.rename_regvar (function) - rename_regvar(pfn, v, user) -> int - Rename a register variable. - - @param pfn: (C++: func_t *) function in question - @param v: (C++: regvar_t *) variable to rename - @param user: (C++: const char *) new user-defined name for the register - @return: Register variable error codes +ida_frame.rename_regvar(pfn: "func_t *", v: "regvar_t", user: str) -> int + Rename a register variable. + + @param pfn: function in question + @param v: variable to rename + @param user: new user-defined name for the register + @returns Register variable error codes -ida_frame.set_auto_spd (function) - set_auto_spd(pfn, ea, new_spd) -> bool - Add such an automatic SP register change point so that at EA the new cumulative - SP delta (that is, the difference between the initial and current values of SP) - would be equal to NEW_SPD. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address of the instruction - @param new_spd: (C++: sval_t) new value of the cumulative SP delta - @return: success +ida_frame.set_auto_spd(pfn: "func_t *", ea: ida_idaapi.ea_t, new_spd: int) -> bool + Add such an automatic SP register change point so that at EA the new cumulative SP delta (that is, the difference between the initial and current values of SP) would be equal to NEW_SPD. + + @param pfn: pointer to the function. may be nullptr. + @param ea: linear address of the instruction + @param new_spd: new value of the cumulative SP delta + @returns success -ida_frame.set_frame_size (function) - set_frame_size(pfn, frsize, frregs, argsize) -> bool - Set size of function frame. Note: The returned size may not include all stack - arguments. It does so only for __stdcall and __fastcall calling conventions. To - get the entire frame size for all cases use get_struc_size(get_frame(pfn)). - - @param pfn: (C++: func_t *) pointer to function structure - @param frsize: (C++: asize_t) size of function local variables - @param frregs: (C++: ushort) size of saved registers - @param argsize: (C++: asize_t) size of function arguments that will be purged from the stack - upon return - @return: success +ida_frame.set_frame_member_type(pfn: "func_t const *", offset: int, tif: "tinfo_t", repr: "value_repr_t" = None, etf_flags: "uint" = 0) -> bool + Change type of the frame member + + @param pfn: pointer to function + @param offset: member offset in the frame structure, in bytes + @param tif: variable type + @param repr: variable representation + @returns success -ida_frame.set_purged (function) - set_purged(ea, nbytes, override_old_value) -> bool - Set the number of purged bytes for a function or data item (funcptr). This - function will update the database and plan to reanalyze items referencing the - specified address. It works only for processors with PR_PURGING bit in 16 and 32 - bit modes. - - @param ea: (C++: ea_t) address of the function of item - @param nbytes: (C++: int) number of purged bytes - @param override_old_value: (C++: bool) may overwrite old information about purged bytes - @return: success +ida_frame.set_frame_size(pfn: "func_t *", frsize: "asize_t", frregs: "ushort", argsize: "asize_t") -> bool + Set size of function frame. Note: The returned size may not include all stack arguments. It does so only for __stdcall and __fastcall calling conventions. To get the entire frame size for all cases use frame.get_func_frame(pfn).get_size() + + @param pfn: pointer to function structure + @param frsize: size of function local variables + @param frregs: size of saved registers + @param argsize: size of function arguments that will be purged from the stack upon return + @returns success -ida_frame.set_regvar_cmt (function) - set_regvar_cmt(pfn, v, cmt) -> int - Set comment for a register variable. - - @param pfn: (C++: func_t *) function in question - @param v: (C++: regvar_t *) variable to rename - @param cmt: (C++: const char *) new comment - @return: Register variable error codes +ida_frame.set_purged(ea: ida_idaapi.ea_t, nbytes: int, override_old_value: bool) -> bool + Set the number of purged bytes for a function or data item (funcptr). This function will update the database and plan to reanalyze items referencing the specified address. It works only for processors with PR_PURGING bit in 16 and 32 bit modes. + + @param ea: address of the function of item + @param nbytes: number of purged bytes + @param override_old_value: may overwrite old information about purged bytes + @returns success -ida_frame.soff_to_fpoff (function) - soff_to_fpoff(pfn, soff) -> sval_t - Convert struct offsets into fp-relative offsets. This function converts the - offsets inside the struc_t object into the frame pointer offsets (for example, - EBP-relative). - - @param pfn: (C++: func_t *) - @param soff: (C++: uval_t) +ida_frame.set_regvar_cmt(pfn: "func_t *", v: "regvar_t", cmt: str) -> int + Set comment for a register variable. + + @param pfn: function in question + @param v: variable to rename + @param cmt: new comment + @returns Register variable error codes -ida_frame.stkpnt_t (class) - Proxy of C++ stkpnt_t class. +ida_frame.soff_to_fpoff(pfn: "func_t *", soff: int) -> int + Convert struct offsets into fp-relative offsets. This function converts the offsets inside the udt_type_data_t object into the frame pointer offsets (for example, EBP-relative). + -ida_frame.stkpnt_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: stkpnt_t const & +ida_frame.stkpnt_t -ida_frame.stkpnt_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: stkpnt_t const & +ida_frame.stkpnt_t.__eq__(self, r: "stkpnt_t") -> bool -ida_frame.stkpnt_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: stkpnt_t const & +ida_frame.stkpnt_t.__ge__(self, r: "stkpnt_t") -> bool -ida_frame.stkpnt_t.__init__ (method) - __init__(self) -> stkpnt_t +ida_frame.stkpnt_t.__gt__(self, r: "stkpnt_t") -> bool -ida_frame.stkpnt_t.__le__ (method) - __le__(self, r) -> bool - - @param r: stkpnt_t const & +ida_frame.stkpnt_t.__init__(self) -ida_frame.stkpnt_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: stkpnt_t const & +ida_frame.stkpnt_t.__le__(self, r: "stkpnt_t") -> bool -ida_frame.stkpnt_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: stkpnt_t const & +ida_frame.stkpnt_t.__lt__(self, r: "stkpnt_t") -> bool -ida_frame.stkpnt_t.compare (method) - compare(self, r) -> int - - @param r: stkpnt_t const & +ida_frame.stkpnt_t.__ne__(self, r: "stkpnt_t") -> bool -ida_frame.stkpnts_t (class) - Proxy of C++ stkpnts_t class. +ida_frame.stkpnt_t.compare(self, r: "stkpnt_t") -> int -ida_frame.stkpnts_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: stkpnts_t const & +ida_frame.stkpnts_t -ida_frame.stkpnts_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: stkpnts_t const & +ida_frame.stkpnts_t.__eq__(self, r: "stkpnts_t") -> bool -ida_frame.stkpnts_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: stkpnts_t const & +ida_frame.stkpnts_t.__ge__(self, r: "stkpnts_t") -> bool -ida_frame.stkpnts_t.__init__ (method) - __init__(self) -> stkpnts_t +ida_frame.stkpnts_t.__gt__(self, r: "stkpnts_t") -> bool -ida_frame.stkpnts_t.__le__ (method) - __le__(self, r) -> bool - - @param r: stkpnts_t const & +ida_frame.stkpnts_t.__init__(self) -ida_frame.stkpnts_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: stkpnts_t const & +ida_frame.stkpnts_t.__le__(self, r: "stkpnts_t") -> bool -ida_frame.stkpnts_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: stkpnts_t const & +ida_frame.stkpnts_t.__lt__(self, r: "stkpnts_t") -> bool -ida_frame.stkpnts_t.compare (method) - compare(self, r) -> int - - @param r: stkpnts_t const & +ida_frame.stkpnts_t.__ne__(self, r: "stkpnts_t") -> bool -ida_frame.update_fpd (function) - update_fpd(pfn, fpd) -> bool - Update frame pointer delta. - - @param pfn: (C++: func_t *) pointer to function structure - @param fpd: (C++: asize_t) new fpd value. cannot be bigger than the local variable range size. - @return: success +ida_frame.stkpnts_t.compare(self, r: "stkpnts_t") -> int -ida_frame.xreflist_entry_t (class) - Proxy of C++ xreflist_entry_t class. +ida_frame.update_fpd(pfn: "func_t *", fpd: "asize_t") -> bool + Update frame pointer delta. + + @param pfn: pointer to function structure + @param fpd: new fpd value. cannot be bigger than the local variable range size. + @returns success -ida_frame.xreflist_entry_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: xreflist_entry_t const & +ida_frame.xreflist_entry_t -ida_frame.xreflist_entry_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: xreflist_entry_t const & +ida_frame.xreflist_entry_t.__eq__(self, r: "xreflist_entry_t") -> bool -ida_frame.xreflist_entry_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: xreflist_entry_t const & +ida_frame.xreflist_entry_t.__ge__(self, r: "xreflist_entry_t") -> bool -ida_frame.xreflist_entry_t.__init__ (method) - __init__(self) -> xreflist_entry_t +ida_frame.xreflist_entry_t.__gt__(self, r: "xreflist_entry_t") -> bool -ida_frame.xreflist_entry_t.__le__ (method) - __le__(self, r) -> bool - - @param r: xreflist_entry_t const & +ida_frame.xreflist_entry_t.__init__(self) -ida_frame.xreflist_entry_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: xreflist_entry_t const & +ida_frame.xreflist_entry_t.__le__(self, r: "xreflist_entry_t") -> bool -ida_frame.xreflist_entry_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: xreflist_entry_t const & +ida_frame.xreflist_entry_t.__lt__(self, r: "xreflist_entry_t") -> bool -ida_frame.xreflist_entry_t.compare (method) - compare(self, r) -> int - - @param r: xreflist_entry_t const & +ida_frame.xreflist_entry_t.__ne__(self, r: "xreflist_entry_t") -> bool -ida_frame.xreflist_entry_t.ea (variable) +ida_frame.xreflist_entry_t.compare(self, r: "xreflist_entry_t") -> int + +ida_frame.xreflist_entry_t.ea Location of the insn referencing the stack frame member. -ida_frame.xreflist_entry_t.opnum (variable) +ida_frame.xreflist_entry_t.opnum Number of the operand of that instruction. -ida_frame.xreflist_entry_t.type (variable) +ida_frame.xreflist_entry_t.type The type of xref (cref_t & dref_t) -ida_frame.xreflist_t (class) - Proxy of C++ qvector< xreflist_entry_t > class. +ida_frame.xreflist_t -ida_frame.xreflist_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< xreflist_entry_t > const & +ida_frame.xreflist_t.__eq__(self, r: "xreflist_t") -> bool -ida_frame.xreflist_t.__getitem__ (method) - __getitem__(self, i) -> xreflist_entry_t - - @param i: size_t +ida_frame.xreflist_t.__getitem__(self, i: "size_t") -> "xreflist_entry_t const &" -ida_frame.xreflist_t.__init__ (method) - __init__(self) -> xreflist_t - __init__(self, x) -> xreflist_t - - @param x: qvector< xreflist_entry_t > const & +ida_frame.xreflist_t.__init__(self, *args) -ida_frame.xreflist_t.__len__ (method) - __len__(self) -> size_t +ida_frame.xreflist_t.__len__(self) -> "size_t" -ida_frame.xreflist_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< xreflist_entry_t > const & +ida_frame.xreflist_t.__ne__(self, r: "xreflist_t") -> bool -ida_frame.xreflist_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: xreflist_entry_t const & +ida_frame.xreflist_t.__setitem__(self, i: "size_t", v: "xreflist_entry_t") -> None -ida_frame.xreflist_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: xreflist_entry_t const & +ida_frame.xreflist_t._del(self, x: "xreflist_entry_t") -> bool -ida_frame.xreflist_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: xreflist_entry_t const & +ida_frame.xreflist_t.add_unique(self, x: "xreflist_entry_t") -> bool -ida_frame.xreflist_t.at (method) - at(self, _idx) -> xreflist_entry_t - - @param _idx: size_t +ida_frame.xreflist_t.append(self, x: "xreflist_entry_t") -> None -ida_frame.xreflist_t.begin (method) - begin(self) -> xreflist_entry_t +ida_frame.xreflist_t.at(self, _idx: "size_t") -> "xreflist_entry_t const &" -ida_frame.xreflist_t.capacity (method) - capacity(self) -> size_t +ida_frame.xreflist_t.begin(self, *args) -> "qvector< xreflist_entry_t >::const_iterator" -ida_frame.xreflist_t.clear (method) - clear(self) +ida_frame.xreflist_t.capacity(self) -> "size_t" -ida_frame.xreflist_t.empty (method) - empty(self) -> bool +ida_frame.xreflist_t.clear(self) -> None -ida_frame.xreflist_t.end (method) - end(self) -> xreflist_entry_t +ida_frame.xreflist_t.empty(self) -> bool -ida_frame.xreflist_t.erase (method) - erase(self, it) -> xreflist_entry_t - - @param it: qvector< xreflist_entry_t >::iterator - - erase(self, first, last) -> xreflist_entry_t - - @param first: qvector< xreflist_entry_t >::iterator - @param last: qvector< xreflist_entry_t >::iterator +ida_frame.xreflist_t.end(self, *args) -> "qvector< xreflist_entry_t >::const_iterator" -ida_frame.xreflist_t.extract (method) - extract(self) -> xreflist_entry_t +ida_frame.xreflist_t.erase(self, *args) -> "qvector< xreflist_entry_t >::iterator" -ida_frame.xreflist_t.find (method) - find(self, x) -> xreflist_entry_t - - @param x: xreflist_entry_t const & +ida_frame.xreflist_t.extend(self, x: "xreflist_t") -> None -ida_frame.xreflist_t.grow (method) - grow(self, x=xreflist_entry_t()) - - @param x: xreflist_entry_t const & +ida_frame.xreflist_t.extract(self) -> "xreflist_entry_t *" -ida_frame.xreflist_t.has (method) - has(self, x) -> bool - - @param x: xreflist_entry_t const & +ida_frame.xreflist_t.find(self, *args) -> "qvector< xreflist_entry_t >::const_iterator" -ida_frame.xreflist_t.inject (method) - inject(self, s, len) - - @param s: xreflist_entry_t * - @param len: size_t +ida_frame.xreflist_t.grow(self, *args) -> None -ida_frame.xreflist_t.insert (method) - insert(self, it, x) -> xreflist_entry_t - - @param it: qvector< xreflist_entry_t >::iterator - @param x: xreflist_entry_t const & +ida_frame.xreflist_t.has(self, x: "xreflist_entry_t") -> bool -ida_frame.xreflist_t.pop_back (method) - pop_back(self) +ida_frame.xreflist_t.inject(self, s: "xreflist_entry_t", len: "size_t") -> None -ida_frame.xreflist_t.push_back (method) - push_back(self, x) - - @param x: xreflist_entry_t const & - - push_back(self) -> xreflist_entry_t +ida_frame.xreflist_t.insert(self, it: "xreflist_entry_t", x: "xreflist_entry_t") -> "qvector< xreflist_entry_t >::iterator" -ida_frame.xreflist_t.qclear (method) - qclear(self) +ida_frame.xreflist_t.pop_back(self) -> None -ida_frame.xreflist_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_frame.xreflist_t.push_back(self, *args) -> "xreflist_entry_t &" -ida_frame.xreflist_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: xreflist_entry_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_frame.xreflist_t.qclear(self) -> None -ida_frame.xreflist_t.size (method) - size(self) -> size_t +ida_frame.xreflist_t.reserve(self, cnt: "size_t") -> None -ida_frame.xreflist_t.swap (method) - swap(self, r) - - @param r: qvector< xreflist_entry_t > & +ida_frame.xreflist_t.resize(self, *args) -> None -ida_frame.xreflist_t.truncate (method) - truncate(self) +ida_frame.xreflist_t.size(self) -> "size_t" -ida_funcs (module) +ida_frame.xreflist_t.swap(self, r: "xreflist_t") -> None + +ida_frame.xreflist_t.truncate(self) -> None + +ida_funcs Routines for working with functions within the disassembled program. - This file also contains routines for working with library signatures (e.g. - FLIRT). - - Each function consists of function chunks. At least one function chunk must be - present in the function definition - the function entry chunk. Other chunks are - called function tails. There may be several of them for a function. - - A function tail is a continuous range of addresses. It can be used in the - definition of one or more functions. One function using the tail is singled out - and called the tail owner. This function is considered as 'possessing' the tail. - get_func() on a tail address will return the function possessing the tail. You - can enumerate the functions using the tail by using func_parent_iterator_t. - - Each function chunk in the disassembly is represented as an "range" (a range of - addresses, see range.hpp for details) with characteristics. - - A function entry must start with an instruction (code) byte. + This file also contains routines for working with library signatures (e.g. FLIRT). + Each function consists of function chunks. At least one function chunk must be present in the function definition - the function entry chunk. Other chunks are called function tails. There may be several of them for a function. + A function tail is a continuous range of addresses. It can be used in the definition of one or more functions. One function using the tail is singled out and called the tail owner. This function is considered as 'possessing' the tail. get_func() on a tail address will return the function possessing the tail. You can enumerate the functions using the tail by using func_parent_iterator_t. + Each function chunk in the disassembly is represented as an "range" (a range of addresses, see range.hpp for details) with characteristics. + A function entry must start with an instruction (code) byte. + -ida_funcs.FIND_FUNC_DEFINE (variable) +ida_funcs.FIND_FUNC_DEFINE create instruction if undefined byte is encountered -ida_funcs.FIND_FUNC_EXIST (variable) - function exists already. its bounds are returned in 'nfn'. +ida_funcs.FIND_FUNC_EXIST + function exists already. its bounds are returned in 'nfn'. + -ida_funcs.FIND_FUNC_IGNOREFN (variable) - ignore existing function boundaries. by default the function returns function - boundaries if ea belongs to a function. +ida_funcs.FIND_FUNC_IGNOREFN + ignore existing function boundaries. by default the function returns function boundaries if ea belongs to a function. + -ida_funcs.FIND_FUNC_KEEPBD (variable) - do not modify incoming function boundaries, just create instructions inside the - boundaries. +ida_funcs.FIND_FUNC_KEEPBD + do not modify incoming function boundaries, just create instructions inside the boundaries. + -ida_funcs.FIND_FUNC_NORMAL (variable) +ida_funcs.FIND_FUNC_NORMAL stop processing if undefined byte is encountered -ida_funcs.FIND_FUNC_OK (variable) +ida_funcs.FIND_FUNC_OK ok, 'nfn' is ready for add_func() -ida_funcs.FIND_FUNC_UNDEF (variable) - function has instructions that pass execution flow to unexplored bytes. - nfn->end_ea will have the address of the unexplored byte. +ida_funcs.FIND_FUNC_UNDEF + function has instructions that pass execution flow to unexplored bytes. nfn->end_ea will have the address of the unexplored byte. + -ida_funcs.FUNC_BOTTOMBP (variable) +ida_funcs.FUNC_BOTTOMBP BP points to the bottom of the stack frame. -ida_funcs.FUNC_FAR (variable) +ida_funcs.FUNC_CATCH + function is an exception catch handler + +ida_funcs.FUNC_FAR Far function. -ida_funcs.FUNC_FRAME (variable) +ida_funcs.FUNC_FRAME Function uses frame pointer (BP) -ida_funcs.FUNC_FUZZY_SP (variable) - Function changes SP in untraceable way, for example: and esp, 0FFFFFFF0h +ida_funcs.FUNC_FUZZY_SP + Function changes SP in untraceable way, for example: and esp, 0FFFFFFF0h + -ida_funcs.FUNC_HIDDEN (variable) +ida_funcs.FUNC_HIDDEN A hidden function chunk. -ida_funcs.FUNC_LIB (variable) +ida_funcs.FUNC_LIB Library function. -ida_funcs.FUNC_LUMINA (variable) +ida_funcs.FUNC_LUMINA Function info is provided by Lumina. -ida_funcs.FUNC_NORET (variable) +ida_funcs.FUNC_NORET Function doesn't return. -ida_funcs.FUNC_NORET_PENDING (variable) - Function 'non-return' analysis must be performed. This flag is verified upon - func_does_return() +ida_funcs.FUNC_NORET_PENDING + Function 'non-return' analysis must be performed. This flag is verified upon func_does_return() + -ida_funcs.FUNC_OUTLINE (variable) +ida_funcs.FUNC_OUTLINE Outlined code, not a real function. -ida_funcs.FUNC_PROLOG_OK (variable) - Prolog analysis has been performed by last SP-analysis +ida_funcs.FUNC_PROLOG_OK + Prolog analysis has been performed by last SP-analysis + -ida_funcs.FUNC_PURGED_OK (variable) - 'argsize' field has been validated. If this bit is clear and 'argsize' is 0, - then we do not known the real number of bytes removed from the stack. This bit - is handled by the processor module. +ida_funcs.FUNC_PURGED_OK + 'argsize' field has been validated. If this bit is clear and 'argsize' is 0, then we do not known the real number of bytes removed from the stack. This bit is handled by the processor module. + -ida_funcs.FUNC_REANALYZE (variable) - Function frame changed, request to reanalyze the function after the last insn is - analyzed. +ida_funcs.FUNC_REANALYZE + Function frame changed, request to reanalyze the function after the last insn is analyzed. + -ida_funcs.FUNC_SP_READY (variable) - SP-analysis has been performed. If this flag is on, the stack change points - should not be not modified anymore. Currently this analysis is performed only - for PC +ida_funcs.FUNC_SP_READY + SP-analysis has been performed. If this flag is on, the stack change points should not be not modified anymore. Currently this analysis is performed only for PC + -ida_funcs.FUNC_STATICDEF (variable) +ida_funcs.FUNC_STATICDEF Static function. -ida_funcs.FUNC_TAIL (variable) - This is a function tail. Other bits must be clear (except FUNC_HIDDEN). +ida_funcs.FUNC_TAIL + This is a function tail. Other bits must be clear (except FUNC_HIDDEN). + -ida_funcs.FUNC_THUNK (variable) +ida_funcs.FUNC_THUNK Thunk (jump) function. -ida_funcs.FUNC_USERFAR (variable) - User has specified far-ness of the function +ida_funcs.FUNC_UNWIND + function is an exception unwind handler -ida_funcs.IDASGN_APPLIED (variable) +ida_funcs.FUNC_USERFAR + User has specified far-ness of the function + + +ida_funcs.IDASGN_APPLIED signature is already applied -ida_funcs.IDASGN_BADARG (variable) +ida_funcs.IDASGN_BADARG bad number of signature -ida_funcs.IDASGN_CURRENT (variable) +ida_funcs.IDASGN_CURRENT signature is currently being applied -ida_funcs.IDASGN_OK (variable) +ida_funcs.IDASGN_OK ok -ida_funcs.IDASGN_PLANNED (variable) +ida_funcs.IDASGN_PLANNED signature is planned to be applied -ida_funcs.LIBFUNC_DELAY (variable) +ida_funcs.LIBFUNC_DELAY no decision because of lack of information -ida_funcs.LIBFUNC_FOUND (variable) +ida_funcs.LIBFUNC_FOUND ok, library function is found -ida_funcs.LIBFUNC_NONE (variable) +ida_funcs.LIBFUNC_NONE no, this is not a library function -ida_funcs.MOVE_FUNC_BADSTART (variable) +ida_funcs.MOVE_FUNC_BADSTART bad new start address -ida_funcs.MOVE_FUNC_NOCODE (variable) +ida_funcs.MOVE_FUNC_NOCODE no instruction at 'newstart' -ida_funcs.MOVE_FUNC_NOFUNC (variable) +ida_funcs.MOVE_FUNC_NOFUNC no function at 'ea' -ida_funcs.MOVE_FUNC_OK (variable) +ida_funcs.MOVE_FUNC_OK ok -ida_funcs.MOVE_FUNC_REFUSED (variable) +ida_funcs.MOVE_FUNC_REFUSED a plugin refused the action -ida_funcs.add_func (function) - add_func(ea1, ea2=BADADDR) -> bool - Add a new function. If the function end address is BADADDR, then IDA will try to - determine the function bounds by calling find_func_bounds(..., - FIND_FUNC_DEFINE). - - @param ea1: (C++: ea_t) start address - @param ea2: (C++: ea_t) end address - @return: success +ida_funcs.add_func(*args) -> bool + Add a new function. If the function end address is BADADDR, then IDA will try to determine the function bounds by calling find_func_bounds(..., FIND_FUNC_DEFINE). + + @param ea1: start address + @param ea2: end address + @returns success -ida_funcs.add_func_ex (function) - add_func_ex(pfn) -> bool - Add a new function. If the fn->end_ea is BADADDR, then IDA will try to determine - the function bounds by calling find_func_bounds(..., FIND_FUNC_DEFINE). - - @param pfn: (C++: func_t *) ptr to filled function structure - @return: success +ida_funcs.add_func_ex(pfn: "func_t") -> bool + Add a new function. If the fn->end_ea is BADADDR, then IDA will try to determine the function bounds by calling find_func_bounds(..., FIND_FUNC_DEFINE). + + @param pfn: ptr to filled function structure + @returns success -ida_funcs.add_regarg (function) - add_regarg(pfn, reg, tif, name) - - @param pfn: func_t * - @param reg: int - @param tif: tinfo_t const & - @param name: char const * +ida_funcs.add_regarg(pfn: "func_t", reg: int, tif: "tinfo_t", name: str) -> None -ida_funcs.append_func_tail (function) - append_func_tail(pfn, ea1, ea2) -> bool - Append a new tail chunk to the function definition. If the tail already exists, - then it will simply be added to the function tail list Otherwise a new tail will - be created and its owner will be set to be our function If a new tail cannot be - created, then this function will fail. - - @param pfn: (C++: func_t *) pointer to the function - @param ea1: (C++: ea_t) start of the tail. If a tail already exists at the specified address - it must start at 'ea1' - @param ea2: (C++: ea_t) end of the tail. If a tail already exists at the specified address - it must end at 'ea2'. If specified as BADADDR, IDA will determine - the end address itself. +ida_funcs.append_func_tail(pfn: "func_t", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> bool + Append a new tail chunk to the function definition. If the tail already exists, then it will simply be added to the function tail list Otherwise a new tail will be created and its owner will be set to be our function If a new tail cannot be created, then this function will fail. + + @param pfn: pointer to the function + @param ea1: start of the tail. If a tail already exists at the specified address it must start at 'ea1' + @param ea2: end of the tail. If a tail already exists at the specified address it must end at 'ea2'. If specified as BADADDR, IDA will determine the end address itself. -ida_funcs.apply_idasgn_to (function) - apply_idasgn_to(signame, ea, is_startup) -> int - Apply a signature file to the specified address. - - @param signame: (C++: const char *) short name of signature file (the file name without path) - @param ea: (C++: ea_t) address to apply the signature - @param is_startup: (C++: bool) if set, then the signature is treated as a startup one for - startup signature ida doesn't rename the first function of - the applied module. - @return: Library function codes +ida_funcs.apply_idasgn_to(signame: str, ea: ida_idaapi.ea_t, is_startup: bool) -> int + Apply a signature file to the specified address. + + @param signame: short name of signature file (the file name without path) + @param ea: address to apply the signature + @param is_startup: if set, then the signature is treated as a startup one for startup signature ida doesn't rename the first function of the applied module. + @returns Library function codes -ida_funcs.apply_startup_sig (function) - apply_startup_sig(ea, startup) -> bool - Apply a startup signature file to the specified address. - - @param ea: (C++: ea_t) address to apply the signature to; usually idainfo::start_ea - @param startup: (C++: const char *) the name of the signature file without path and extension - @return: true if successfully applied the signature +ida_funcs.apply_startup_sig(ea: ida_idaapi.ea_t, startup: str) -> bool + Apply a startup signature file to the specified address. + + @param ea: address to apply the signature to; usually idainfo::start_ea + @param startup: the name of the signature file without path and extension + @returns true if successfully applied the signature -ida_funcs.calc_func_size (function) - calc_func_size(pfn) -> asize_t - Calculate function size. This function takes into account all fragments of the - function. - - @param pfn: (C++: func_t *) ptr to function structure +ida_funcs.calc_func_size(pfn: "func_t") -> "asize_t" + Calculate function size. This function takes into account all fragments of the function. + + @param pfn: ptr to function structure -ida_funcs.calc_idasgn_state (function) - calc_idasgn_state(n) -> int - Get state of a signature in the list of planned signatures - - @param n: (C++: int) number of signature in the list (0..get_idasgn_qty()-1) - @return: state of signature or IDASGN_BADARG +ida_funcs.calc_idasgn_state(n: int) -> int + Get state of a signature in the list of planned signatures + + @param n: number of signature in the list (0..get_idasgn_qty()-1) + @returns state of signature or IDASGN_BADARG -ida_funcs.calc_thunk_func_target (function) - calc_thunk_func_target(pfn) -> ea_t - Calculate target of a thunk function. - - @param pfn: (C++: func_t *) pointer to function (may not be nullptr) - @return: the target function or BADADDR +ida_funcs.calc_thunk_func_target(pfn: "func_t") -> "ea_t *" + Calculate target of a thunk function. + + @param pfn: pointer to function (may not be nullptr) + @returns the target function or BADADDR -ida_funcs.calc_thunk_func_target (function) +ida_funcs.calc_thunk_func_target(*args) + Calculate target of a thunk function. + + @param pfn: pointer to function (may not be nullptr) + @param fptr: out: will hold address of a function pointer (if indirect jump) + @returns the target function or BADADDR -ida_funcs.del_func (function) - del_func(ea) -> bool - Delete a function. - - @param ea: (C++: ea_t) any address in the function entry chunk - @return: success +ida_funcs.del_func(ea: ida_idaapi.ea_t) -> bool + Delete a function. + + @param ea: any address in the function entry chunk + @returns success -ida_funcs.del_idasgn (function) - del_idasgn(n) -> int - Remove signature from the list of planned signatures. - - @param n: (C++: int) number of signature in the list (0..get_idasgn_qty()-1) - @return: IDASGN_OK, IDASGN_BADARG, IDASGN_APPLIED +ida_funcs.del_idasgn(n: int) -> int + Remove signature from the list of planned signatures. + + @param n: number of signature in the list (0..get_idasgn_qty()-1) + @returns IDASGN_OK, IDASGN_BADARG, IDASGN_APPLIED -ida_funcs.dyn_ea_array (class) - Proxy of C++ dynamic_wrapped_array_t< ea_t > class. +ida_funcs.dyn_ea_array -ida_funcs.dyn_ea_array.__getitem__ (method) - __getitem__(self, i) -> unsigned-ea-like-numeric-type const & - - @param i: size_t +ida_funcs.dyn_ea_array.__getitem__(self, i: "size_t") -> "unsigned long long const &" -ida_funcs.dyn_ea_array.__init__ (method) - __init__(self, _data, _count) -> dyn_ea_array - - @param _data: unsigned-ea-like-numeric-type * - @param _count: size_t +ida_funcs.dyn_ea_array.__init__(self, _data: "unsigned long long *", _count: "size_t") -ida_funcs.dyn_ea_array.__len__ (method) - __len__(self) -> size_t +ida_funcs.dyn_ea_array.__len__(self) -> "size_t" -ida_funcs.dyn_ea_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned-ea-like-numeric-type const & +ida_funcs.dyn_ea_array.__setitem__(self, i: "size_t", v: "unsigned long long const &") -> None -ida_funcs.dyn_range_array (class) - Proxy of C++ dynamic_wrapped_array_t< range_t > class. +ida_funcs.dyn_range_array -ida_funcs.dyn_range_array.__getitem__ (method) - __getitem__(self, i) -> range_t - - @param i: size_t +ida_funcs.dyn_range_array.__getitem__(self, i: "size_t") -> "range_t const &" -ida_funcs.dyn_range_array.__init__ (method) - __init__(self, _data, _count) -> dyn_range_array - - @param _data: range_t * - @param _count: size_t +ida_funcs.dyn_range_array.__init__(self, _data: "range_t", _count: "size_t") -ida_funcs.dyn_range_array.__len__ (method) - __len__(self) -> size_t +ida_funcs.dyn_range_array.__len__(self) -> "size_t" -ida_funcs.dyn_range_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: range_t const & +ida_funcs.dyn_range_array.__setitem__(self, i: "size_t", v: "range_t") -> None -ida_funcs.dyn_regarg_array (class) - Proxy of C++ dynamic_wrapped_array_t< regarg_t > class. +ida_funcs.dyn_regarg_array -ida_funcs.dyn_regarg_array.__getitem__ (method) - __getitem__(self, i) -> regarg_t - - @param i: size_t +ida_funcs.dyn_regarg_array.__getitem__(self, i: "size_t") -> "regarg_t const &" -ida_funcs.dyn_regarg_array.__init__ (method) - __init__(self, _data, _count) -> dyn_regarg_array - - @param _data: regarg_t * - @param _count: size_t +ida_funcs.dyn_regarg_array.__init__(self, _data: "regarg_t", _count: "size_t") -ida_funcs.dyn_regarg_array.__len__ (method) - __len__(self) -> size_t +ida_funcs.dyn_regarg_array.__len__(self) -> "size_t" -ida_funcs.dyn_regarg_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regarg_t const & +ida_funcs.dyn_regarg_array.__setitem__(self, i: "size_t", v: "regarg_t") -> None -ida_funcs.dyn_regvar_array (class) - Proxy of C++ dynamic_wrapped_array_t< regvar_t > class. +ida_funcs.dyn_regvar_array -ida_funcs.dyn_regvar_array.__getitem__ (method) - __getitem__(self, i) -> regvar_t const & - - @param i: size_t +ida_funcs.dyn_regvar_array.__getitem__(self, i: "size_t") -> "regvar_t const &" -ida_funcs.dyn_regvar_array.__init__ (method) - __init__(self, _data, _count) -> dyn_regvar_array - - @param _data: regvar_t * - @param _count: size_t +ida_funcs.dyn_regvar_array.__init__(self, _data: "regvar_t *", _count: "size_t") -ida_funcs.dyn_regvar_array.__len__ (method) - __len__(self) -> size_t +ida_funcs.dyn_regvar_array.__len__(self) -> "size_t" -ida_funcs.dyn_regvar_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regvar_t const & +ida_funcs.dyn_regvar_array.__setitem__(self, i: "size_t", v: "regvar_t const &") -> None -ida_funcs.dyn_stkpnt_array (class) - Proxy of C++ dynamic_wrapped_array_t< stkpnt_t > class. +ida_funcs.dyn_stkpnt_array -ida_funcs.dyn_stkpnt_array.__getitem__ (method) - __getitem__(self, i) -> stkpnt_t const & - - @param i: size_t +ida_funcs.dyn_stkpnt_array.__getitem__(self, i: "size_t") -> "stkpnt_t const &" -ida_funcs.dyn_stkpnt_array.__init__ (method) - __init__(self, _data, _count) -> dyn_stkpnt_array - - @param _data: stkpnt_t * - @param _count: size_t +ida_funcs.dyn_stkpnt_array.__init__(self, _data: "stkpnt_t *", _count: "size_t") -ida_funcs.dyn_stkpnt_array.__len__ (method) - __len__(self) -> size_t +ida_funcs.dyn_stkpnt_array.__len__(self) -> "size_t" -ida_funcs.dyn_stkpnt_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: stkpnt_t const & +ida_funcs.dyn_stkpnt_array.__setitem__(self, i: "size_t", v: "stkpnt_t const &") -> None -ida_funcs.f_any (function) - f_any(arg1, arg2) -> bool +ida_funcs.f_any(arg1: "flags64_t", arg2: "void *") -> bool Helper function to accept any address. - - @param arg1: flags64_t - @param arg2: void * -ida_funcs.find_func_bounds (function) - find_func_bounds(nfn, flags) -> int - Determine the boundaries of a new function. This function tries to find the - start and end addresses of a new function. It calls the module with - processor_t::func_bounds in order to fine tune the function boundaries. - - @param nfn: (C++: func_t *) structure to fill with information \ nfn->start_ea points to the - start address of the new function. - @param flags: (C++: int) Find function bounds flags - @return: Find function bounds result codes +ida_funcs.find_func_bounds(nfn: "func_t", flags: int) -> int + Determine the boundaries of a new function. This function tries to find the start and end addresses of a new function. It calls the module with processor_t::func_bounds in order to fine tune the function boundaries. + + @param nfn: structure to fill with information \ nfn->start_ea points to the start address of the new function. + @param flags: Find function bounds flags + @returns Find function bounds result codes -ida_funcs.free_regarg (function) - free_regarg(v) - - @param v: regarg_t * +ida_funcs.free_regarg(v: "regarg_t") -> None -ida_funcs.func_contains (function) - func_contains(pfn, ea) -> bool +ida_funcs.func_contains(pfn: "func_t", ea: ida_idaapi.ea_t) -> bool Does the given function contain the given address? - - @param pfn: (C++: func_t *) - @param ea: (C++: ea_t) -ida_funcs.func_does_return (function) - func_does_return(callee) -> bool - Does the function return?. To calculate the answer, FUNC_NORET flag and - is_noret() are consulted The latter is required for imported functions in the - .idata section. Since in .idata we have only function pointers but not - functions, we have to introduce a special flag for them. - - @param callee: (C++: ea_t) +ida_funcs.func_does_return(callee: ida_idaapi.ea_t) -> bool + Does the function return?. To calculate the answer, FUNC_NORET flag and is_noret() are consulted The latter is required for imported functions in the .idata section. Since in .idata we have only function pointers but not functions, we have to introduce a special flag for them. + -ida_funcs.func_item_iterator_t (class) - Proxy of C++ func_item_iterator_t class. +ida_funcs.func_item_iterator_t -ida_funcs.func_item_iterator_t.__init__ (method) - __init__(self) -> func_item_iterator_t - __init__(self, pfn, _ea=BADADDR) -> func_item_iterator_t - - @param pfn: func_t * - @param _ea: ea_t +ida_funcs.func_item_iterator_t.__init__(self, *args) -ida_funcs.func_item_iterator_t.__iter__ (method) +ida_funcs.func_item_iterator_t.__iter__(self) Provide an iterator on code items -ida_funcs.func_item_iterator_t.__next__ (method) - __next__(self, func) -> bool - - @param func: testf_t * +ida_funcs.func_item_iterator_t.__next__(self, func: "testf_t *") -> bool -ida_funcs.func_item_iterator_t.addresses (method) +ida_funcs.func_item_iterator_t.addresses(self) Provide an iterator on addresses contained within the function -ida_funcs.func_item_iterator_t.chunk (method) - chunk(self) -> range_t +ida_funcs.func_item_iterator_t.chunk(self) -> "range_t const &" -ida_funcs.func_item_iterator_t.code_items (method) +ida_funcs.func_item_iterator_t.code_items(self) Provide an iterator on code items contained within the function -ida_funcs.func_item_iterator_t.current (method) - current(self) -> ea_t +ida_funcs.func_item_iterator_t.current(self) -> ida_idaapi.ea_t -ida_funcs.func_item_iterator_t.data_items (method) +ida_funcs.func_item_iterator_t.data_items(self) Provide an iterator on data items contained within the function -ida_funcs.func_item_iterator_t.decode_preceding_insn (method) - decode_preceding_insn(self, visited, p_farref, out) -> bool - - @param visited: eavec_t * - @param p_farref: bool * - @param out: insn_t * +ida_funcs.func_item_iterator_t.decode_preceding_insn(self, visited: "eavec_t *", p_farref: "bool *", out: "insn_t *") -> bool -ida_funcs.func_item_iterator_t.decode_prev_insn (method) - decode_prev_insn(self, out) -> bool - - @param out: insn_t * +ida_funcs.func_item_iterator_t.decode_prev_insn(self, out: "insn_t *") -> bool -ida_funcs.func_item_iterator_t.first (method) - first(self) -> bool +ida_funcs.func_item_iterator_t.first(self) -> bool -ida_funcs.func_item_iterator_t.head_items (method) +ida_funcs.func_item_iterator_t.head_items(self) Provide an iterator on item heads contained within the function -ida_funcs.func_item_iterator_t.last (method) - last(self) -> bool +ida_funcs.func_item_iterator_t.last(self) -> bool -ida_funcs.func_item_iterator_t.next_addr (method) - next_addr(self) -> bool +ida_funcs.func_item_iterator_t.next_addr(self) -> bool -ida_funcs.func_item_iterator_t.next_code (method) - next_code(self) -> bool +ida_funcs.func_item_iterator_t.next_code(self) -> bool -ida_funcs.func_item_iterator_t.next_data (method) - next_data(self) -> bool +ida_funcs.func_item_iterator_t.next_data(self) -> bool -ida_funcs.func_item_iterator_t.next_head (method) - next_head(self) -> bool +ida_funcs.func_item_iterator_t.next_head(self) -> bool -ida_funcs.func_item_iterator_t.next_not_tail (method) - next_not_tail(self) -> bool +ida_funcs.func_item_iterator_t.next_not_tail(self) -> bool -ida_funcs.func_item_iterator_t.not_tails (method) +ida_funcs.func_item_iterator_t.not_tails(self) Provide an iterator on non-tail addresses contained within the function -ida_funcs.func_item_iterator_t.prev (method) - prev(self, func) -> bool - - @param func: testf_t * +ida_funcs.func_item_iterator_t.prev(self, func: "testf_t *") -> bool -ida_funcs.func_item_iterator_t.prev_addr (method) - prev_addr(self) -> bool +ida_funcs.func_item_iterator_t.prev_addr(self) -> bool -ida_funcs.func_item_iterator_t.prev_code (method) - prev_code(self) -> bool +ida_funcs.func_item_iterator_t.prev_code(self) -> bool -ida_funcs.func_item_iterator_t.prev_data (method) - prev_data(self) -> bool +ida_funcs.func_item_iterator_t.prev_data(self) -> bool -ida_funcs.func_item_iterator_t.prev_head (method) - prev_head(self) -> bool +ida_funcs.func_item_iterator_t.prev_head(self) -> bool -ida_funcs.func_item_iterator_t.prev_not_tail (method) - prev_not_tail(self) -> bool +ida_funcs.func_item_iterator_t.prev_not_tail(self) -> bool -ida_funcs.func_item_iterator_t.set (method) - set(self, pfn, _ea=BADADDR) -> bool +ida_funcs.func_item_iterator_t.set(self, *args) -> bool Set a function range. if pfn == nullptr then a segment range will be set. - - @param pfn: (C++: func_t *) - @param _ea: (C++: ea_t) -ida_funcs.func_item_iterator_t.set_range (method) - set_range(self, ea1, ea2) -> bool +ida_funcs.func_item_iterator_t.set_ea(self, _ea: ida_idaapi.ea_t) -> bool + +ida_funcs.func_item_iterator_t.set_range(self, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> bool Set an arbitrary range. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) -ida_funcs.func_item_iterator_t.succ (method) - succ(self, func) -> bool - Similar to next(), but succ() iterates the chunks from low to high addresses, - while next() iterates through chunks starting at the function entry chunk - - @param func: (C++: testf_t *) +ida_funcs.func_item_iterator_t.succ(self, func: "testf_t *") -> bool + Similar to next(), but succ() iterates the chunks from low to high addresses, while next() iterates through chunks starting at the function entry chunk + -ida_funcs.func_item_iterator_t.succ_code (method) - succ_code(self) -> bool +ida_funcs.func_item_iterator_t.succ_code(self) -> bool -ida_funcs.func_parent_iterator_set (function) - func_parent_iterator_set(fpi, pfn) -> bool - - @param fpi: func_parent_iterator_t * - @param pfn: func_t * +ida_funcs.func_parent_iterator_set(fpi: "func_parent_iterator_t", pfn: "func_t") -> bool -ida_funcs.func_parent_iterator_t (class) - Proxy of C++ func_parent_iterator_t class. +ida_funcs.func_parent_iterator_t -ida_funcs.func_parent_iterator_t.__init__ (method) - __init__(self) -> func_parent_iterator_t - __init__(self, _fnt) -> func_parent_iterator_t - - @param _fnt: func_t * +ida_funcs.func_parent_iterator_t.__init__(self, *args) -ida_funcs.func_parent_iterator_t.__iter__ (method) +ida_funcs.func_parent_iterator_t.__iter__(self) Provide an iterator on function parents -ida_funcs.func_parent_iterator_t.__next__ (method) - __next__(self) -> bool +ida_funcs.func_parent_iterator_t.__next__(self) -> bool -ida_funcs.func_parent_iterator_t.first (method) - first(self) -> bool +ida_funcs.func_parent_iterator_t.first(self) -> bool -ida_funcs.func_parent_iterator_t.last (method) - last(self) -> bool +ida_funcs.func_parent_iterator_t.last(self) -> bool -ida_funcs.func_parent_iterator_t.parent (method) - parent(self) -> ea_t +ida_funcs.func_parent_iterator_t.parent(self) -> ida_idaapi.ea_t -ida_funcs.func_parent_iterator_t.prev (method) - prev(self) -> bool +ida_funcs.func_parent_iterator_t.prev(self) -> bool -ida_funcs.func_parent_iterator_t.reset_fnt (method) - reset_fnt(self, _fnt) - - @param _fnt: func_t * +ida_funcs.func_parent_iterator_t.reset_fnt(self, _fnt: "func_t") -> None -ida_funcs.func_parent_iterator_t.set (method) - set(self, _fnt) -> bool - - @param _fnt: func_t * +ida_funcs.func_parent_iterator_t.set(self, _fnt: "func_t") -> bool -ida_funcs.func_t (class) - Proxy of C++ func_t class. +ida_funcs.func_t -ida_funcs.func_t.__get_points__ (method) - __get_points__(self) -> dyn_stkpnt_array +ida_funcs.func_t.__get_points__(self) -> "dynamic_wrapped_array_t< stkpnt_t >" -ida_funcs.func_t.__get_referers__ (method) - __get_referers__(self) -> dyn_ea_array +ida_funcs.func_t.__get_referers__(self) -> "dynamic_wrapped_array_t< ea_t >" -ida_funcs.func_t.__get_regargs__ (method) - __get_regargs__(self) -> dyn_regarg_array +ida_funcs.func_t.__get_regargs__(self) -> "dynamic_wrapped_array_t< regarg_t >" -ida_funcs.func_t.__get_regvars__ (method) - __get_regvars__(self) -> dyn_regvar_array +ida_funcs.func_t.__get_regvars__(self) -> "dynamic_wrapped_array_t< regvar_t >" -ida_funcs.func_t.__get_tails__ (method) - __get_tails__(self) -> dyn_range_array +ida_funcs.func_t.__get_tails__(self) -> "dynamic_wrapped_array_t< range_t >" -ida_funcs.func_t.__init__ (method) - __init__(self, start=0, end=0, f=0) -> func_t - - @param start: ea_t - @param end: ea_t - @param f: flags64_t +ida_funcs.func_t.__init__(self, start: ida_idaapi.ea_t = 0, end: ida_idaapi.ea_t = 0, f: "flags64_t" = 0) -ida_funcs.func_t.__iter__ (method) +ida_funcs.func_t.__iter__(self) Alias for func_item_iterator_t(self).__iter__() -ida_funcs.func_t.addresses (method) +ida_funcs.func_t.addresses(self) Alias for func_item_iterator_t(self).addresses() -ida_funcs.func_t.analyzed_sp (method) - analyzed_sp(self) -> bool +ida_funcs.func_t.analyzed_sp(self) -> bool Has SP-analysis been performed? -ida_funcs.func_t.argsize (variable) - number of bytes purged from the stack upon returning +ida_funcs.func_t.argsize + number of bytes purged from the stack upon returning + -ida_funcs.func_t.code_items (method) +ida_funcs.func_t.code_items(self) Alias for func_item_iterator_t(self).code_items() -ida_funcs.func_t.color (variable) +ida_funcs.func_t.color user defined function color -ida_funcs.func_t.data_items (method) +ida_funcs.func_t.data_items(self) Alias for func_item_iterator_t(self).data_items() -ida_funcs.func_t.does_return (method) - does_return(self) -> bool +ida_funcs.func_t.does_return(self) -> bool Does function return? -ida_funcs.func_t.flags (variable) - Function flags +ida_funcs.func_t.flags + Function flags + -ida_funcs.func_t.fpd (variable) - frame pointer delta. (usually 0, i.e. realBP==typicalBP) use update_fpd() to - modify it. +ida_funcs.func_t.fpd + frame pointer delta. (usually 0, i.e. realBP==typicalBP) use update_fpd() to modify it. + -ida_funcs.func_t.frame (variable) +ida_funcs.func_t.frame netnode id of frame structure - see frame.hpp -ida_funcs.func_t.frregs (variable) - size of saved registers in frame. This range is immediately above the local - variables range. +ida_funcs.func_t.frregs + size of saved registers in frame. This range is immediately above the local variables range. + -ida_funcs.func_t.frsize (variable) - size of local variables part of frame in bytes. If FUNC_FRAME is set and fpd==0, - the frame pointer (EBP) is assumed to point to the top of the local variables - range. +ida_funcs.func_t.frsize + size of local variables part of frame in bytes. If FUNC_FRAME is set and fpd==0, the frame pointer (EBP) is assumed to point to the top of the local variables range. + -ida_funcs.func_t.head_items (method) +ida_funcs.func_t.get_frame_object(self) + Retrieve the function frame, in the form of a structure + where frame offsets that are accessed by the program, as well + as areas for "saved registers" and "return address", are + represented by structure members. + + If the function has no associated frame, return None + + @return a ida_typeinf.tinfo_t object representing the frame, or None + +ida_funcs.func_t.get_name(self) + Get the function name + + @return the function name + +ida_funcs.func_t.get_prototype(self) + Retrieve the function prototype. + + Once you have obtained the prototype, you can: + + * retrieve the return type through ida_typeinf.tinfo_t.get_rettype() + * iterate on the arguments using ida_typeinf.tinfo_t.iter_func() + + If the function has no associated prototype, return None + + @return a ida_typeinf.tinfo_t object representing the prototype, or None + +ida_funcs.func_t.head_items(self) Alias for func_item_iterator_t(self).head_items() -ida_funcs.func_t.is_far (method) - is_far(self) -> bool +ida_funcs.func_t.is_far(self) -> bool Is a far function? -ida_funcs.func_t.need_prolog_analysis (method) - need_prolog_analysis(self) -> bool +ida_funcs.func_t.need_prolog_analysis(self) -> bool Needs prolog analysis? -ida_funcs.func_t.not_tails (method) +ida_funcs.func_t.not_tails(self) Alias for func_item_iterator_t(self).not_tails() -ida_funcs.func_t.owner (variable) +ida_funcs.func_t.owner the address of the main function possessing this tail -ida_funcs.func_t.pntqty (variable) +ida_funcs.func_t.pntqty number of SP change points -ida_funcs.func_t.points (variable) - array of SP change points. use ...stkpnt...() functions to access this array. +ida_funcs.func_t.points + array of SP change points. use ...stkpnt...() functions to access this array. + -ida_funcs.func_t.referers (variable) - array of referers (function start addresses). use func_parent_iterator_t to - access the referers. +ida_funcs.func_t.points + array of SP change points. use ...stkpnt...() functions to access this array. + -ida_funcs.func_t.refqty (variable) +ida_funcs.func_t.referers + array of referers (function start addresses). use func_parent_iterator_t to access the referers. + + +ida_funcs.func_t.referers + array of referers (function start addresses). use func_parent_iterator_t to access the referers. + + +ida_funcs.func_t.refqty number of referers -ida_funcs.func_t.regargqty (variable) - number of register arguments. During analysis IDA tries to guess the register - arguments. It stores store the guessing outcome in this field. As soon as it - determines the final function prototype, regargqty is set to zero. +ida_funcs.func_t.regargqty + number of register arguments. During analysis IDA tries to guess the register arguments. It stores store the guessing outcome in this field. As soon as it determines the final function prototype, regargqty is set to zero. + -ida_funcs.func_t.regargs (variable) - unsorted array of register arguments. use ...regarg...() functions to access - this array. regargs are destroyed when the full function type is determined. +ida_funcs.func_t.regargs + unsorted array of register arguments. use ...regarg...() functions to access this array. regargs are destroyed when the full function type is determined. + -ida_funcs.func_t.regvarqty (variable) - number of register variables (-1-not read in yet) use find_regvar() to read - register variables +ida_funcs.func_t.regargs + unsorted array of register arguments. use ...regarg...() functions to access this array. regargs are destroyed when the full function type is determined. + -ida_funcs.func_t.regvars (variable) - array of register variables. this array is sorted by: start_ea. use - ...regvar...() functions to access this array. +ida_funcs.func_t.regvarqty + number of register variables (-1-not read in yet) use find_regvar() to read register variables + -ida_funcs.func_t.tailqty (variable) +ida_funcs.func_t.regvars + array of register variables. this array is sorted by: start_ea. use ...regvar...() functions to access this array. + + +ida_funcs.func_t.regvars + array of register variables. this array is sorted by: start_ea. use ...regvar...() functions to access this array. + + +ida_funcs.func_t.tailqty number of function tails -ida_funcs.func_t.tails (variable) - array of tails, sorted by ea. use func_tail_iterator_t to access function tails. +ida_funcs.func_t.tails + array of tails, sorted by ea. use func_tail_iterator_t to access function tails. + -ida_funcs.func_t__from_ptrval__ (function) - func_t__from_ptrval__(ptrval) -> func_t - - @param ptrval: size_t +ida_funcs.func_t.tails + array of tails, sorted by ea. use func_tail_iterator_t to access function tails. + -ida_funcs.func_tail_iterator_set (function) - func_tail_iterator_set(fti, pfn, ea) -> bool - - @param fti: func_tail_iterator_t * - @param pfn: func_t * - @param ea: ea_t +ida_funcs.func_t__from_ptrval__(ptrval: "size_t") -> "func_t *" -ida_funcs.func_tail_iterator_set_ea (function) - func_tail_iterator_set_ea(fti, ea) -> bool - - @param fti: func_tail_iterator_t * - @param ea: ea_t +ida_funcs.func_tail_iterator_set(fti: "func_tail_iterator_t", pfn: "func_t", ea: ida_idaapi.ea_t) -> bool -ida_funcs.func_tail_iterator_t (class) - Proxy of C++ func_tail_iterator_t class. +ida_funcs.func_tail_iterator_set_ea(fti: "func_tail_iterator_t", ea: ida_idaapi.ea_t) -> bool -ida_funcs.func_tail_iterator_t.__init__ (method) - __init__(self) -> func_tail_iterator_t - __init__(self, _pfn, ea=BADADDR) -> func_tail_iterator_t - - @param _pfn: func_t * - @param ea: ea_t +ida_funcs.func_tail_iterator_t -ida_funcs.func_tail_iterator_t.__iter__ (method) +ida_funcs.func_tail_iterator_t.__init__(self, *args) + +ida_funcs.func_tail_iterator_t.__iter__(self) Provide an iterator on function tails -ida_funcs.func_tail_iterator_t.__next__ (method) - __next__(self) -> bool +ida_funcs.func_tail_iterator_t.__next__(self) -> bool -ida_funcs.func_tail_iterator_t.chunk (method) - chunk(self) -> range_t +ida_funcs.func_tail_iterator_t.chunk(self) -> "range_t const &" -ida_funcs.func_tail_iterator_t.first (method) - first(self) -> bool +ida_funcs.func_tail_iterator_t.first(self) -> bool -ida_funcs.func_tail_iterator_t.last (method) - last(self) -> bool +ida_funcs.func_tail_iterator_t.last(self) -> bool -ida_funcs.func_tail_iterator_t.main (method) - main(self) -> bool +ida_funcs.func_tail_iterator_t.main(self) -> bool -ida_funcs.func_tail_iterator_t.prev (method) - prev(self) -> bool +ida_funcs.func_tail_iterator_t.prev(self) -> bool -ida_funcs.func_tail_iterator_t.set (method) - set(self, _pfn, ea=BADADDR) -> bool - - @param _pfn: func_t * - @param ea: ea_t +ida_funcs.func_tail_iterator_t.set(self, *args) -> bool -ida_funcs.func_tail_iterator_t.set_ea (method) - set_ea(self, ea) -> bool - - @param ea: ea_t +ida_funcs.func_tail_iterator_t.set_ea(self, ea: ida_idaapi.ea_t) -> bool -ida_funcs.func_tail_iterator_t.set_range (method) - set_range(self, ea1, ea2) -> bool - - @param ea1: ea_t - @param ea2: ea_t +ida_funcs.func_tail_iterator_t.set_range(self, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> bool -ida_funcs.get_current_idasgn (function) - get_current_idasgn() -> int - Get number of the the current signature. - - @return: 0..n-1 +ida_funcs.get_current_idasgn() -> int + Get number of the the current signature. + + @returns 0..n-1 -ida_funcs.get_fchunk (function) - get_fchunk(ea) -> func_t - Get pointer to function chunk structure by address. - - @param ea: (C++: ea_t) any address in a function chunk - @return: ptr to a function chunk or nullptr. This function may return a function - entry as well as a function tail. +ida_funcs.get_fchunk(ea: ida_idaapi.ea_t) -> "func_t *" + Get pointer to function chunk structure by address. + + @param ea: any address in a function chunk + @returns ptr to a function chunk or nullptr. This function may return a function entry as well as a function tail. -ida_funcs.get_fchunk_num (function) - get_fchunk_num(ea) -> int - Get ordinal number of a function chunk in the global list of function chunks. - - @param ea: (C++: ea_t) any address in the function chunk - @return: number of function chunk (0..get_fchunk_qty()-1). -1 means 'no function - chunk at the specified address'. +ida_funcs.get_fchunk_num(ea: ida_idaapi.ea_t) -> int + Get ordinal number of a function chunk in the global list of function chunks. + + @param ea: any address in the function chunk + @returns number of function chunk (0..get_fchunk_qty()-1). -1 means 'no function chunk at the specified address'. -ida_funcs.get_fchunk_qty (function) - get_fchunk_qty() -> size_t +ida_funcs.get_fchunk_qty() -> "size_t" Get total number of function chunks in the program. -ida_funcs.get_fchunk_referer (function) - get_fchunk_referer(ea, idx) -> ea_t - - @param ea: ea_t - @param idx: size_t +ida_funcs.get_fchunk_referer(ea: int, idx) -ida_funcs.get_func (function) - get_func(ea) -> func_t - Get pointer to function structure by address. - - @param ea: (C++: ea_t) any address in a function - @return: ptr to a function or nullptr. This function returns a function entry - chunk. +ida_funcs.get_func(ea: ida_idaapi.ea_t) -> "func_t *" + Get pointer to function structure by address. + + @param ea: any address in a function + @returns ptr to a function or nullptr. This function returns a function entry chunk. -ida_funcs.get_func_bitness (function) - get_func_bitness(pfn) -> int - Get function bitness (which is equal to the function segment bitness). - pfn==nullptr => returns 0 +ida_funcs.get_func_bitness(pfn: "func_t") -> int + Get function bitness (which is equal to the function segment bitness). pfn==nullptr => returns 0 + @retval 0: 16 @retval 1: 32 @retval 2: 64 - - @param pfn: (C++: const func_t *) func_t const * -ida_funcs.get_func_bits (function) - get_func_bits(pfn) -> int +ida_funcs.get_func_bits(pfn: "func_t") -> int Get number of bits in the function addressing. - - @param pfn: (C++: const func_t *) func_t const * -ida_funcs.get_func_bytes (function) - get_func_bytes(pfn) -> int +ida_funcs.get_func_bytes(pfn: "func_t") -> int Get number of bytes in the function addressing. - - @param pfn: (C++: const func_t *) func_t const * -ida_funcs.get_func_chunknum (function) - get_func_chunknum(pfn, ea) -> int - Get the containing tail chunk of 'ea'. +ida_funcs.get_func_chunknum(pfn: "func_t", ea: ida_idaapi.ea_t) -> int + Get the containing tail chunk of 'ea'. + @retval -1: means 'does not contain ea' @retval 0: means the 'pfn' itself contains ea @retval >0: the number of the containing function tail chunk - - @param pfn: (C++: func_t *) - @param ea: (C++: ea_t) -ida_funcs.get_func_cmt (function) - get_func_cmt(pfn, repeatable) -> str - Get function comment. - - @param pfn: (C++: const func_t *) ptr to function structure - @param repeatable: (C++: bool) get repeatable comment? - @return: size of comment or -1 In fact this function works with function chunks - too. +ida_funcs.get_func_cmt(pfn: "func_t", repeatable: bool) -> str + Get function comment. + + @param pfn: ptr to function structure + @param repeatable: get repeatable comment? + @returns size of comment or -1 In fact this function works with function chunks too. -ida_funcs.get_func_name (function) - get_func_name(ea) -> str - Get function name. - - @param ea: (C++: ea_t) any address in the function - @return: length of the function name +ida_funcs.get_func_name(ea: ida_idaapi.ea_t) -> str + Get function name. + + @param ea: any address in the function + @returns length of the function name -ida_funcs.get_func_num (function) - get_func_num(ea) -> int - Get ordinal number of a function. - - @param ea: (C++: ea_t) any address in the function - @return: number of function (0..get_func_qty()-1). -1 means 'no function at the - specified address'. +ida_funcs.get_func_num(ea: ida_idaapi.ea_t) -> int + Get ordinal number of a function. + + @param ea: any address in the function + @returns number of function (0..get_func_qty()-1). -1 means 'no function at the specified address'. -ida_funcs.get_func_qty (function) - get_func_qty() -> size_t +ida_funcs.get_func_qty() -> "size_t" Get total number of functions in the program. -ida_funcs.get_func_ranges (function) - get_func_ranges(ranges, pfn) -> ea_t - Get function ranges. - - @param ranges: (C++: rangeset_t *) buffer to receive the range info - @param pfn: (C++: func_t *) ptr to function structure - @return: end address of the last function range (BADADDR-error) +ida_funcs.get_func_ranges(ranges: "rangeset_t", pfn: "func_t") -> ida_idaapi.ea_t + Get function ranges. + + @param ranges: buffer to receive the range info + @param pfn: ptr to function structure + @returns end address of the last function range (BADADDR-error) -ida_funcs.get_idasgn_desc (function) - get_idasgn_desc(n) -> (str, str) +ida_funcs.get_idasgn_desc(n) Get information about a signature in the list. It returns: (name of signature, names of optional libraries) @@ -25351,773 +16742,547 @@ ida_funcs.get_idasgn_desc (function) @param n: number of signature in the list (0..get_idasgn_qty()-1) @return: None on failure or tuple(signame, optlibs) -ida_funcs.get_idasgn_desc_with_matches (function) - get_idasgn_desc_with_matches(n) -> (str, str, int) +ida_funcs.get_idasgn_desc_with_matches(n) Get information about a signature in the list. It returns: (name of signature, names of optional libraries, number of matches) @param n: number of signature in the list (0..get_idasgn_qty()-1) @return: None on failure or tuple(signame, optlibs, nmatches) -ida_funcs.get_idasgn_qty (function) - get_idasgn_qty() -> int - Get number of signatures in the list of planned and applied signatures. - - @return: 0..n +ida_funcs.get_idasgn_qty() -> int + Get number of signatures in the list of planned and applied signatures. + + @returns 0..n -ida_funcs.get_idasgn_title (function) - get_idasgn_title(name) -> str - Get full description of the signature by its short name. - - @param name: (C++: const char *) short name of a signature - @return: size of signature description or -1 +ida_funcs.get_idasgn_title(name: str) -> str + Get full description of the signature by its short name. + + @param name: short name of a signature + @returns size of signature description or -1 -ida_funcs.get_next_fchunk (function) - get_next_fchunk(ea) -> func_t - Get pointer to the next function chunk in the global list. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function chunk or nullptr if next function chunk doesn't exist +ida_funcs.get_next_fchunk(ea: ida_idaapi.ea_t) -> "func_t *" + Get pointer to the next function chunk in the global list. + + @param ea: any address in the program + @returns ptr to function chunk or nullptr if next function chunk doesn't exist -ida_funcs.get_next_func (function) - get_next_func(ea) -> func_t - Get pointer to the next function. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function or nullptr if next function doesn't exist +ida_funcs.get_next_func(ea: ida_idaapi.ea_t) -> "func_t *" + Get pointer to the next function. + + @param ea: any address in the program + @returns ptr to function or nullptr if next function doesn't exist -ida_funcs.get_next_func_addr (function) - get_next_func_addr(pfn, ea) -> ea_t - - @param pfn: func_t * - @param ea: ea_t +ida_funcs.get_next_func_addr(pfn: "func_t", ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_funcs.get_prev_fchunk (function) - get_prev_fchunk(ea) -> func_t - Get pointer to the previous function chunk in the global list. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function chunk or nullptr if previous function chunk doesn't - exist +ida_funcs.get_prev_fchunk(ea: ida_idaapi.ea_t) -> "func_t *" + Get pointer to the previous function chunk in the global list. + + @param ea: any address in the program + @returns ptr to function chunk or nullptr if previous function chunk doesn't exist -ida_funcs.get_prev_func (function) - get_prev_func(ea) -> func_t - Get pointer to the previous function. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function or nullptr if previous function doesn't exist +ida_funcs.get_prev_func(ea: ida_idaapi.ea_t) -> "func_t *" + Get pointer to the previous function. + + @param ea: any address in the program + @returns ptr to function or nullptr if previous function doesn't exist -ida_funcs.get_prev_func_addr (function) - get_prev_func_addr(pfn, ea) -> ea_t - - @param pfn: func_t * - @param ea: ea_t +ida_funcs.get_prev_func_addr(pfn: "func_t", ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_funcs.getn_fchunk (function) - getn_fchunk(n) -> func_t - Get pointer to function chunk structure by number. - - @param n: (C++: int) number of function chunk, is in range 0..get_fchunk_qty()-1 - @return: ptr to a function chunk or nullptr. This function may return a function - entry as well as a function tail. +ida_funcs.getn_fchunk(n: int) -> "func_t *" + Get pointer to function chunk structure by number. + + @param n: number of function chunk, is in range 0..get_fchunk_qty()-1 + @returns ptr to a function chunk or nullptr. This function may return a function entry as well as a function tail. -ida_funcs.getn_func (function) - getn_func(n) -> func_t - Get pointer to function structure by number. - - @param n: (C++: size_t) number of function, is in range 0..get_func_qty()-1 - @return: ptr to a function or nullptr. This function returns a function entry - chunk. +ida_funcs.getn_func(n: "size_t") -> "func_t *" + Get pointer to function structure by number. + + @param n: number of function, is in range 0..get_func_qty()-1 + @returns ptr to a function or nullptr. This function returns a function entry chunk. -ida_funcs.is_finally_visible_func (function) - is_finally_visible_func(pfn) -> bool +ida_funcs.is_finally_visible_func(pfn: "func_t") -> bool Is the function visible (event after considering SCF_SHHID_FUNC)? - - @param pfn: (C++: func_t *) -ida_funcs.is_func_entry (function) - is_func_entry(pfn) -> bool +ida_funcs.is_func_entry(pfn: "func_t") -> bool Does function describe a function entry chunk? - - @param pfn: (C++: const func_t *) func_t const * -ida_funcs.is_func_locked (function) - is_func_locked(pfn) -> bool +ida_funcs.is_func_locked(pfn: "func_t") -> bool Is the function pointer locked? - - @param pfn: (C++: const func_t *) func_t const * -ida_funcs.is_func_tail (function) - is_func_tail(pfn) -> bool +ida_funcs.is_func_tail(pfn: "func_t") -> bool Does function describe a function tail chunk? - - @param pfn: (C++: const func_t *) func_t const * -ida_funcs.is_same_func (function) - is_same_func(ea1, ea2) -> bool +ida_funcs.is_same_func(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> bool Do two addresses belong to the same function? - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) -ida_funcs.is_visible_func (function) - is_visible_func(pfn) -> bool +ida_funcs.is_visible_func(pfn: "func_t") -> bool Is the function visible (not hidden)? - - @param pfn: (C++: func_t *) -ida_funcs.lock_func (class) - Proxy of C++ lock_func class. +ida_funcs.lock_func -ida_funcs.lock_func.__init__ (method) - __init__(self, _pfn) -> lock_func - - @param _pfn: func_t const * +ida_funcs.lock_func.__init__(self, _pfn: "func_t") -ida_funcs.lock_func_range (function) - lock_func_range(pfn, lock) - Lock function pointer Locked pointers are guaranteed to remain valid until they - are unlocked. Ranges with locked pointers cannot be deleted or moved. - - @param pfn: (C++: const func_t *) func_t const * - @param lock: (C++: bool) +ida_funcs.lock_func_range(pfn: "func_t", lock: bool) -> None + Lock function pointer Locked pointers are guaranteed to remain valid until they are unlocked. Ranges with locked pointers cannot be deleted or moved. + -ida_funcs.lock_func_with_tails_t (class) - Proxy of C++ lock_func_with_tails_t class. +ida_funcs.lock_func_with_tails_t -ida_funcs.lock_func_with_tails_t.__init__ (method) - __init__(self, pfn) -> lock_func_with_tails_t - - @param pfn: func_t * +ida_funcs.lock_func_with_tails_t.__init__(self, pfn: "func_t") -ida_funcs.plan_to_apply_idasgn (function) - plan_to_apply_idasgn(fname) -> int - Add a signature file to the list of planned signature files. - - @param fname: (C++: const char *) file name. should not contain directory part. - @return: 0 if failed, otherwise number of planned (and applied) signatures +ida_funcs.plan_to_apply_idasgn(fname: str) -> int + Add a signature file to the list of planned signature files. + + @param fname: file name. should not contain directory part. + @returns 0 if failed, otherwise number of planned (and applied) signatures -ida_funcs.read_regargs (function) - read_regargs(pfn) - - @param pfn: func_t * +ida_funcs.read_regargs(pfn: "func_t") -> None -ida_funcs.reanalyze_function (function) - reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False) - Reanalyze a function. This function plans to analyzes all chunks of the given - function. Optional parameters (ea1, ea2) may be used to narrow the analyzed - range. - - @param pfn: (C++: func_t *) pointer to a function - @param ea1: (C++: ea_t) start of the range to analyze - @param ea2: (C++: ea_t) end of range to analyze - @param analyze_parents: (C++: bool) meaningful only if pfn points to a function tail. if - true, all tail parents will be reanalyzed. if false, - only the given tail will be reanalyzed. +ida_funcs.reanalyze_function(*args) -> None + Reanalyze a function. This function plans to analyzes all chunks of the given function. Optional parameters (ea1, ea2) may be used to narrow the analyzed range. + + @param pfn: pointer to a function + @param ea1: start of the range to analyze + @param ea2: end of range to analyze + @param analyze_parents: meaningful only if pfn points to a function tail. if true, all tail parents will be reanalyzed. if false, only the given tail will be reanalyzed. -ida_funcs.reanalyze_noret_flag (function) - reanalyze_noret_flag(ea) -> bool - Plan to reanalyze noret flag. This function does not remove FUNC_NORET if it is - already present. It just plans to reanalysis. - - @param ea: (C++: ea_t) +ida_funcs.reanalyze_noret_flag(ea: ida_idaapi.ea_t) -> bool + Plan to reanalyze noret flag. This function does not remove FUNC_NORET if it is already present. It just plans to reanalysis. + -ida_funcs.regarg_t (class) - Proxy of C++ regarg_t class. +ida_funcs.regarg_t -ida_funcs.regarg_t.__init__ (method) - __init__(self) -> regarg_t - __init__(self, r) -> regarg_t - - @param r: regarg_t const & +ida_funcs.regarg_t.__init__(self, *args) -ida_funcs.regarg_t.swap (method) - swap(self, r) - - @param r: regarg_t & +ida_funcs.regarg_t.swap(self, r: "regarg_t") -> None -ida_funcs.remove_func_tail (function) - remove_func_tail(pfn, tail_ea) -> bool - Remove a function tail. If the tail belongs only to one function, it will be - completely removed. Otherwise if the function was the tail owner, the first - function using this tail becomes the owner of the tail. - - @param pfn: (C++: func_t *) pointer to the function - @param tail_ea: (C++: ea_t) any address inside the tail to remove +ida_funcs.remove_func_tail(pfn: "func_t", tail_ea: ida_idaapi.ea_t) -> bool + Remove a function tail. If the tail belongs only to one function, it will be completely removed. Otherwise if the function was the tail owner, the first function using this tail becomes the owner of the tail. + + @param pfn: pointer to the function + @param tail_ea: any address inside the tail to remove -ida_funcs.set_func_cmt (function) - set_func_cmt(pfn, cmt, repeatable) -> bool - Set function comment. This function works with function chunks too. - - @param pfn: (C++: const func_t *) ptr to function structure - @param cmt: (C++: const char *) comment string, may be multiline (with ' +ida_funcs.set_func_cmt(pfn: "func_t", cmt: str, repeatable: bool) -> bool + Set function comment. This function works with function chunks too. + + @param pfn: ptr to function structure + @param cmt: comment string, may be multiline (with ' '). Use empty str ("") to delete comment - @param repeatable: (C++: bool) set repeatable comment? + @param repeatable: set repeatable comment? -ida_funcs.set_func_end (function) - set_func_end(ea, newend) -> bool - Move function chunk end address. - - @param ea: (C++: ea_t) any address in the function - @param newend: (C++: ea_t) new end address of the function - @return: success +ida_funcs.set_func_end(ea: ida_idaapi.ea_t, newend: ida_idaapi.ea_t) -> bool + Move function chunk end address. + + @param ea: any address in the function + @param newend: new end address of the function + @returns success -ida_funcs.set_func_name_if_jumpfunc (function) - set_func_name_if_jumpfunc(pfn, oldname) -> int - Give a meaningful name to function if it consists of only 'jump' instruction. - - @param pfn: (C++: func_t *) pointer to function (may be nullptr) - @param oldname: (C++: const char *) old name of function. if old name was in "j_..." form, then we - may discard it and set a new name. if oldname is not known, you - may pass nullptr. - @return: success +ida_funcs.set_func_name_if_jumpfunc(pfn: "func_t", oldname: str) -> int + Give a meaningful name to function if it consists of only 'jump' instruction. + + @param pfn: pointer to function (may be nullptr) + @param oldname: old name of function. if old name was in "j_..." form, then we may discard it and set a new name. if oldname is not known, you may pass nullptr. + @returns success -ida_funcs.set_func_start (function) - set_func_start(ea, newstart) -> int - Move function chunk start address. - - @param ea: (C++: ea_t) any address in the function - @param newstart: (C++: ea_t) new end address of the function - @return: Function move result codes +ida_funcs.set_func_start(ea: ida_idaapi.ea_t, newstart: ida_idaapi.ea_t) -> int + Move function chunk start address. + + @param ea: any address in the function + @param newstart: new end address of the function + @returns Function move result codes -ida_funcs.set_noret_insn (function) - set_noret_insn(insn_ea, noret) -> bool - Signal a non-returning instruction. This function can be used by the processor - module to tell the kernel about non-returning instructions (like call exit). The - kernel will perform the global function analysis and find out if the function - returns at all. This analysis will be done at the first call to - func_does_return() - - @param insn_ea: (C++: ea_t) - @param noret: (C++: bool) - @return: true if the instruction 'noret' flag has been changed +ida_funcs.set_noret_insn(insn_ea: ida_idaapi.ea_t, noret: bool) -> bool + Signal a non-returning instruction. This function can be used by the processor module to tell the kernel about non-returning instructions (like call exit). The kernel will perform the global function analysis and find out if the function returns at all. This analysis will be done at the first call to func_does_return() + + @returns true if the instruction 'noret' flag has been changed -ida_funcs.set_tail_owner (function) - set_tail_owner(fnt, new_owner) -> bool - Set a new owner of a function tail. The new owner function must be already - referring to the tail (after append_func_tail). - - @param fnt: (C++: func_t *) pointer to the function tail - @param new_owner: (C++: ea_t) the entry point of the new owner function +ida_funcs.set_tail_owner(fnt: "func_t", new_owner: ida_idaapi.ea_t) -> bool + Set a new owner of a function tail. The new owner function must be already referring to the tail (after append_func_tail). + + @param fnt: pointer to the function tail + @param new_owner: the entry point of the new owner function -ida_funcs.set_visible_func (function) - set_visible_func(pfn, visible) +ida_funcs.set_visible_func(pfn: "func_t", visible: bool) -> None Set visibility of function. - - @param pfn: (C++: func_t *) - @param visible: (C++: bool) -ida_funcs.try_to_add_libfunc (function) - try_to_add_libfunc(ea) -> int - Apply the currently loaded signature file to the specified address. If a library - function is found, then create a function and name it accordingly. - - @param ea: (C++: ea_t) any address in the program - @return: Library function codes +ida_funcs.try_to_add_libfunc(ea: ida_idaapi.ea_t) -> int + Apply the currently loaded signature file to the specified address. If a library function is found, then create a function and name it accordingly. + + @param ea: any address in the program + @returns Library function codes -ida_funcs.update_func (function) - update_func(pfn) -> bool - Update information about a function in the database (func_t). You must not - change the function start and end addresses using this function. Use - set_func_start() and set_func_end() for it. - - @param pfn: (C++: func_t *) ptr to function structure - @return: success +ida_funcs.update_func(pfn: "func_t") -> bool + Update information about a function in the database (func_t). You must not change the function start and end addresses using this function. Use set_func_start() and set_func_end() for it. + + @param pfn: ptr to function structure + @returns success -ida_gdl (module) +ida_gdl Low level graph drawing operations. -ida_gdl.BasicBlock (class) +ida_gdl.BasicBlock Basic block class. It is returned by the Flowchart class -ida_gdl.BasicBlock.__init__ (method) +ida_gdl.BasicBlock.__init__(self, id, bb, fc) Block type (check fc_block_type_t enum) -ida_gdl.BasicBlock.preds (method) +ida_gdl.BasicBlock.preds(self) Iterates the predecessors list -ida_gdl.BasicBlock.succs (method) +ida_gdl.BasicBlock.succs(self) Iterates the successors list -ida_gdl.CHART_FOLLOW_DIRECTION (variable) - analyze references to added blocks only in the direction of the reference who - discovered the current block +ida_gdl.CHART_FOLLOW_DIRECTION + analyze references to added blocks only in the direction of the reference who discovered the current block -ida_gdl.CHART_GEN_DOT (variable) +ida_gdl.CHART_GEN_DOT generate .dot file (file extension is forced to .dot) -ida_gdl.CHART_GEN_GDL (variable) +ida_gdl.CHART_GEN_GDL generate .gdl file (file extension is forced to .gdl) -ida_gdl.CHART_IGNORE_LIB_FROM (variable) +ida_gdl.CHART_IGNORE_LIB_FROM ignore references from library functions -ida_gdl.CHART_IGNORE_LIB_TO (variable) +ida_gdl.CHART_IGNORE_LIB_TO ignore references to library functions -ida_gdl.CHART_NOLIBFUNCS (variable) +ida_gdl.CHART_NOLIBFUNCS don't include library functions in the graph -ida_gdl.CHART_PRINT_DOTS (variable) +ida_gdl.CHART_PRINT_DOTS print dots if xrefs exist outside of the range recursion depth -ida_gdl.CHART_PRINT_NAMES (variable) +ida_gdl.CHART_PRINT_NAMES print labels for each block? -ida_gdl.CHART_RECURSIVE (variable) +ida_gdl.CHART_RECURSIVE analyze added blocks -ida_gdl.CHART_REFERENCED (variable) +ida_gdl.CHART_REFERENCED references from the addresses in the list -ida_gdl.CHART_REFERENCING (variable) +ida_gdl.CHART_REFERENCING references to the addresses in the list -ida_gdl.CHART_WINGRAPH (variable) +ida_gdl.CHART_WINGRAPH call grapher to display the graph -ida_gdl.FC_APPND (variable) +ida_gdl.FC_APPND multirange flowchart (set by append_to_flowchart) -ida_gdl.FC_CALL_ENDS (variable) +ida_gdl.FC_CALL_ENDS call instructions terminate basic blocks -ida_gdl.FC_CHKBREAK (variable) +ida_gdl.FC_CHKBREAK build_qflow_chart() may be aborted by user -ida_gdl.FC_NOEXT (variable) - do not compute external blocks. Use this to prevent jumps leaving the function - from appearing in the flow chart. Unless specified, the targets of those - outgoing jumps will be present in the flow chart under the form of one- - instruction blocks +ida_gdl.FC_NOEXT + do not compute external blocks. Use this to prevent jumps leaving the function from appearing in the flow chart. Unless specified, the targets of those outgoing jumps will be present in the flow chart under the form of one-instruction blocks + -ida_gdl.FC_NOPREDS (variable) +ida_gdl.FC_NOPREDS do not compute predecessor lists -ida_gdl.FC_OUTLINES (variable) +ida_gdl.FC_OUTLINES include outlined code (with FUNC_OUTLINE) -ida_gdl.FC_PRINT (variable) +ida_gdl.FC_PRINT print names (used only by display_flow_chart()) -ida_gdl.FlowChart (class) +ida_gdl.FC_RESERVED + former FC_PREDS + +ida_gdl.FlowChart Flowchart class used to determine basic blocks. Check ex_gdl_qflow_chart.py for sample usage. -ida_gdl.FlowChart.__getitem__ (method) +ida_gdl.FlowChart.__getitem__(self, index) Returns a basic block @return: BasicBlock -ida_gdl.FlowChart.__init__ (method) +ida_gdl.FlowChart.__init__(self, f = None, bounds = None, flags = 0) Constructor @param f: A func_t type, use get_func(ea) to get a reference @param bounds: A tuple of the form (start, end). Used if "f" is None @param flags: one of the FC_xxxx flags. -ida_gdl.FlowChart.__iter__ (method) +ida_gdl.FlowChart.__iter__(self) -ida_gdl.FlowChart._getitem (method) +ida_gdl.FlowChart._getitem(self, index) -ida_gdl.FlowChart.refresh (method) +ida_gdl.FlowChart.refresh(self) Refreshes the flow chart -ida_gdl.FlowChart.size (variable) +ida_gdl.FlowChart.size Number of blocks in the flow chart -ida_gdl.cancellable_graph_t (class) - Proxy of C++ cancellable_graph_t class. +ida_gdl.cancellable_graph_t -ida_gdl.cancellable_graph_t.__disown__ (method) +ida_gdl.cancellable_graph_t.__disown__(self) -ida_gdl.cancellable_graph_t.__init__ (method) - __init__(self) -> cancellable_graph_t - - @param self: PyObject * +ida_gdl.cancellable_graph_t.__init__(self) -ida_gdl.display_gdl (function) - display_gdl(fname) -> int - Display GDL file by calling wingraph32. The exact name of the grapher is taken - from the configuration file and set up by setup_graph_subsystem(). The path - should point to a temporary file: when wingraph32 succeeds showing the graph, - the input file will be deleted. - - @param fname: (C++: const char *) char const * - @return: error code from os, 0 if ok +ida_gdl.display_gdl(fname: str) -> int + Display GDL file by calling wingraph32. The exact name of the grapher is taken from the configuration file and set up by setup_graph_subsystem(). The path should point to a temporary file: when wingraph32 succeeds showing the graph, the input file will be deleted. + + @returns error code from os, 0 if ok -ida_gdl.fcb_cndret (variable) +ida_gdl.edge_t + +ida_gdl.edge_t.__eq__(self, y: "edge_t") -> bool + +ida_gdl.edge_t.__init__(self, x: int = 0, y: int = 0) + +ida_gdl.edge_t.__lt__(self, y: "edge_t") -> bool + +ida_gdl.edge_t.__ne__(self, y: "edge_t") -> bool + +ida_gdl.edge_t.dst + destination node number + +ida_gdl.edge_t.src + source node number + +ida_gdl.edgevec_t + +ida_gdl.edgevec_t.__init__(self) + +ida_gdl.fcb_cndret conditional return block -ida_gdl.fcb_enoret (variable) +ida_gdl.fcb_enoret external noreturn block (does not belong to the function) -ida_gdl.fcb_error (variable) +ida_gdl.fcb_error block passes execution past the function end -ida_gdl.fcb_extern (variable) +ida_gdl.fcb_extern external normal block -ida_gdl.fcb_indjump (variable) +ida_gdl.fcb_indjump block ends with indirect jump -ida_gdl.fcb_noret (variable) +ida_gdl.fcb_noret noreturn block -ida_gdl.fcb_normal (variable) +ida_gdl.fcb_normal normal block -ida_gdl.fcb_ret (variable) +ida_gdl.fcb_ret return block -ida_gdl.gdl_graph_t (class) - Proxy of C++ gdl_graph_t class. +ida_gdl.gdl_graph_t -ida_gdl.gdl_graph_t.__disown__ (method) +ida_gdl.gdl_graph_t.__disown__(self) -ida_gdl.gdl_graph_t.__init__ (method) - __init__(self) -> gdl_graph_t - - @param self: PyObject * +ida_gdl.gdl_graph_t.__init__(self) -ida_gdl.gdl_graph_t.begin (method) - begin(self) -> node_iterator +ida_gdl.gdl_graph_t.begin(self) -> "node_iterator" -ida_gdl.gdl_graph_t.edge (method) - edge(self, node, i, ispred) -> int - - @param node: int - @param i: int - @param ispred: bool +ida_gdl.gdl_graph_t.edge(self, node: int, i: int, ispred: bool) -> int -ida_gdl.gdl_graph_t.empty (method) - empty(self) -> bool +ida_gdl.gdl_graph_t.empty(self) -> bool -ida_gdl.gdl_graph_t.end (method) - end(self) -> node_iterator +ida_gdl.gdl_graph_t.end(self) -> "node_iterator" -ida_gdl.gdl_graph_t.entry (method) - entry(self) -> int +ida_gdl.gdl_graph_t.entry(self) -> int -ida_gdl.gdl_graph_t.exists (method) - exists(self, node) -> bool - - @param node: int +ida_gdl.gdl_graph_t.exists(self, node: int) -> bool -ida_gdl.gdl_graph_t.exit (method) - exit(self) -> int +ida_gdl.gdl_graph_t.exit(self) -> int -ida_gdl.gdl_graph_t.front (method) - front(self) -> int +ida_gdl.gdl_graph_t.front(self) -> int -ida_gdl.gdl_graph_t.get_edge_color (method) - get_edge_color(self, i, j) -> bgcolor_t - - @param i: int - @param j: int +ida_gdl.gdl_graph_t.get_edge_color(self, i: int, j: int) -> "bgcolor_t" -ida_gdl.gdl_graph_t.get_node_color (method) - get_node_color(self, n) -> bgcolor_t - - @param n: int +ida_gdl.gdl_graph_t.get_node_color(self, n: int) -> "bgcolor_t" -ida_gdl.gdl_graph_t.get_node_label (method) - get_node_label(self, n) -> char * - - @param n: int +ida_gdl.gdl_graph_t.get_node_label(self, n: int) -> "char *" -ida_gdl.gdl_graph_t.nedge (method) - nedge(self, node, ispred) -> size_t - - @param node: int - @param ispred: bool +ida_gdl.gdl_graph_t.nedge(self, node: int, ispred: bool) -> "size_t" -ida_gdl.gdl_graph_t.node_qty (method) - node_qty(self) -> int +ida_gdl.gdl_graph_t.node_qty(self) -> int -ida_gdl.gdl_graph_t.npred (method) - npred(self, node) -> int - - @param node: int +ida_gdl.gdl_graph_t.npred(self, node: int) -> int -ida_gdl.gdl_graph_t.nsucc (method) - nsucc(self, node) -> int - - @param node: int +ida_gdl.gdl_graph_t.nsucc(self, node: int) -> int -ida_gdl.gdl_graph_t.pred (method) - pred(self, node, i) -> int - - @param node: int - @param i: int +ida_gdl.gdl_graph_t.pred(self, node: int, i: int) -> int -ida_gdl.gdl_graph_t.print_edge (method) - print_edge(self, fp, i, j) -> bool - - @param fp: FILE * - @param i: int - @param j: int +ida_gdl.gdl_graph_t.print_edge(self, fp: "FILE *", i: int, j: int) -> bool -ida_gdl.gdl_graph_t.print_graph_attributes (method) - print_graph_attributes(self, fp) - - @param fp: FILE * +ida_gdl.gdl_graph_t.print_graph_attributes(self, fp: "FILE *") -> None -ida_gdl.gdl_graph_t.print_node (method) - print_node(self, fp, n) -> bool - - @param fp: FILE * - @param n: int +ida_gdl.gdl_graph_t.print_node(self, fp: "FILE *", n: int) -> bool -ida_gdl.gdl_graph_t.print_node_attributes (method) - print_node_attributes(self, fp, n) - - @param fp: FILE * - @param n: int +ida_gdl.gdl_graph_t.print_node_attributes(self, fp: "FILE *", n: int) -> None -ida_gdl.gdl_graph_t.size (method) - size(self) -> int +ida_gdl.gdl_graph_t.size(self) -> int -ida_gdl.gdl_graph_t.succ (method) - succ(self, node, i) -> int - - @param node: int - @param i: int +ida_gdl.gdl_graph_t.succ(self, node: int, i: int) -> int -ida_gdl.gen_complex_call_chart (function) - gen_complex_call_chart(filename, wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool - Build and display a complex xref graph. - - @param filename: (C++: const char *) output file name. the file extension is not used. maybe - nullptr. - @param wait: (C++: const char *) message to display during graph building - @param title: (C++: const char *) graph title - @param ea1: (C++: ea_t) ,ea2: address range - @param flags: (C++: int) combination of Call chart building flags and Flow graph building - flags. if none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is - specified, the function will return false. - @param flags: (C++: int) combination of Call chart building flags and Flow graph building - flags. if none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is - specified, the function will return false. - @param recursion_depth: (C++: int32) optional limit of recursion - @return: success. if fails, a warning message is displayed on the screen +ida_gdl.gen_complex_call_chart(filename: str, wait: str, title: str, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, flags: int, recursion_depth: int = -1) -> bool + Build and display a complex xref graph. + + @param filename: output file name. the file extension is not used. maybe nullptr. + @param wait: message to display during graph building + @param title: graph title + @param ea1: address range + @param ea2: address range + @param flags: combination of Call chart building flags and Flow graph building flags. if none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is specified, the function will return false. + @param recursion_depth: optional limit of recursion + @returns success. if fails, a warning message is displayed on the screen -ida_gdl.gen_flow_graph (function) - gen_flow_graph(filename, title, pfn, ea1, ea2, gflags) -> bool - Build and display a flow graph. - - @param filename: (C++: const char *) output file name. the file extension is not used. maybe - nullptr. - @param title: (C++: const char *) graph title - @param pfn: (C++: func_t *) function to graph - @param ea1: (C++: ea_t) ,ea2: if pfn == nullptr, then the address range - @param gflags: (C++: int) combination of Flow graph building flags. if none of - CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is specified, the - function will return false - @param gflags: (C++: int) combination of Flow graph building flags. if none of - CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is specified, the - function will return false - @return: success. if fails, a warning message is displayed on the screen +ida_gdl.gen_flow_graph(filename: str, title: str, pfn: "func_t *", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, gflags: int) -> bool + Build and display a flow graph. + + @param filename: output file name. the file extension is not used. maybe nullptr. + @param title: graph title + @param pfn: function to graph + @param ea1: if pfn == nullptr, then the address range + @param ea2: if pfn == nullptr, then the address range + @param gflags: combination of Flow graph building flags. if none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is specified, the function will return false + @returns success. if fails, a warning message is displayed on the screen -ida_gdl.gen_gdl (function) - gen_gdl(g, fname) +ida_gdl.gen_gdl(g: "gdl_graph_t", fname: str) -> None Create GDL file for graph. - - @param g: (C++: const gdl_graph_t *) gdl_graph_t const * - @param fname: (C++: const char *) char const * -ida_gdl.gen_simple_call_chart (function) - gen_simple_call_chart(filename, wait, title, gflags) -> bool - Build and display a simple function call graph. - - @param filename: (C++: const char *) output file name. the file extension is not used. maybe - nullptr. - @param wait: (C++: const char *) message to display during graph building - @param title: (C++: const char *) graph title - @param gflags: (C++: int) combination of CHART_NOLIBFUNCS and Flow graph building flags. if - none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is - specified, the function will return false. - @return: success. if fails, a warning message is displayed on the screen +ida_gdl.gen_simple_call_chart(filename: str, wait: str, title: str, gflags: int) -> bool + Build and display a simple function call graph. + + @param filename: output file name. the file extension is not used. maybe nullptr. + @param wait: message to display during graph building + @param title: graph title + @param gflags: combination of CHART_NOLIBFUNCS and Flow graph building flags. if none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is specified, the function will return false. + @returns success. if fails, a warning message is displayed on the screen -ida_gdl.is_noret_block (function) - is_noret_block(btype) -> bool +ida_gdl.is_noret_block(btype: "fc_block_type_t") -> bool Does this block never return? - - @param btype: (C++: fc_block_type_t) enum fc_block_type_t -ida_gdl.is_ret_block (function) - is_ret_block(btype) -> bool +ida_gdl.is_ret_block(btype: "fc_block_type_t") -> bool Does this block return? - - @param btype: (C++: fc_block_type_t) enum fc_block_type_t -ida_gdl.node_iterator (class) - Proxy of C++ node_iterator class. +ida_gdl.node_iterator -ida_gdl.node_iterator.__eq__ (method) - __eq__(self, n) -> bool - - @param n: node_iterator const & +ida_gdl.node_iterator.__eq__(self, n: "node_iterator") -> bool -ida_gdl.node_iterator.__init__ (method) - __init__(self, _g, n) -> node_iterator - - @param _g: gdl_graph_t const * - @param n: int +ida_gdl.node_iterator.__init__(self, _g: "gdl_graph_t", n: int) -ida_gdl.node_iterator.__ne__ (method) - __ne__(self, n) -> bool - - @param n: node_iterator const & +ida_gdl.node_iterator.__ne__(self, n: "node_iterator") -> bool -ida_gdl.node_iterator.__ref__ (method) - __ref__(self) -> int +ida_gdl.node_iterator.__ref__(self) -> int -ida_gdl.qbasic_block_t (class) - Proxy of C++ qbasic_block_t class. +ida_gdl.node_ordering_t -ida_gdl.qbasic_block_t.__init__ (method) - __init__(self) -> qbasic_block_t +ida_gdl.node_ordering_t.__init__(self) -ida_gdl.qflow_chart_t (class) - Proxy of C++ qflow_chart_t class. +ida_gdl.node_ordering_t.clear(self) -> None -ida_gdl.qflow_chart_t.__getitem__ (method) - __getitem__(self, n) -> qbasic_block_t - - @param n: int +ida_gdl.node_ordering_t.clr(self, _node: int) -> bool -ida_gdl.qflow_chart_t.__init__ (method) - __init__(self) -> qflow_chart_t - __init__(self, _title, _pfn, _ea1, _ea2, _flags) -> qflow_chart_t - - @param _title: char const * - @param _pfn: func_t * - @param _ea1: ea_t - @param _ea2: ea_t - @param _flags: int +ida_gdl.node_ordering_t.node(self, _order: "size_t") -> int -ida_gdl.qflow_chart_t.append_to_flowchart (method) - append_to_flowchart(self, ea1, ea2) - - @param ea1: ea_t - @param ea2: ea_t +ida_gdl.node_ordering_t.order(self, _node: int) -> int -ida_gdl.qflow_chart_t.bounds (variable) +ida_gdl.node_ordering_t.resize(self, n: int) -> None + +ida_gdl.node_ordering_t.set(self, _node: int, num: int) -> None + +ida_gdl.node_ordering_t.size(self) -> "size_t" + +ida_gdl.qbasic_block_t + +ida_gdl.qbasic_block_t.__init__(self) + +ida_gdl.qflow_chart_t + +ida_gdl.qflow_chart_t.__getitem__(self, n: int) -> "qbasic_block_t *" + +ida_gdl.qflow_chart_t.__init__(self, *args) + +ida_gdl.qflow_chart_t.append_to_flowchart(self, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> None + +ida_gdl.qflow_chart_t.bounds overall bounds of the qflow_chart_t instance -ida_gdl.qflow_chart_t.calc_block_type (method) - calc_block_type(self, blknum) -> fc_block_type_t - - @param blknum: size_t +ida_gdl.qflow_chart_t.calc_block_type(self, blknum: "size_t") -> "fc_block_type_t" -ida_gdl.qflow_chart_t.create (method) - create(self, _title, _pfn, _ea1, _ea2, _flags) +ida_gdl.qflow_chart_t.create(self, *args) -> None + This function has the following signatures: - @param _title: char const * - @param _pfn: func_t * - @param _ea1: ea_t - @param _ea2: ea_t - @param _flags: int + 0. create(_title: str, _pfn: func_t *, _ea1: ida_idaapi.ea_t, _ea2: ida_idaapi.ea_t, _flags: int) -> None + 1. create(_title: str, ranges: const rangevec_t &, _flags: int) -> None - create(self, _title, ranges, _flags) + # 0: create(_title: str, _pfn: func_t *, _ea1: ida_idaapi.ea_t, _ea2: ida_idaapi.ea_t, _flags: int) -> None - @param _title: char const * - @param ranges: rangevec_t const & - @param _flags: int + + # 1: create(_title: str, ranges: const rangevec_t &, _flags: int) -> None -ida_gdl.qflow_chart_t.flags (variable) +ida_gdl.qflow_chart_t.flags flags. See Flow chart flags -ida_gdl.qflow_chart_t.get_node_label (method) - get_node_label(self, n) -> char * - - @param n: int +ida_gdl.qflow_chart_t.get_node_label(self, *args) -> "char *" -ida_gdl.qflow_chart_t.is_noret_block (method) - is_noret_block(self, blknum) -> bool - - @param blknum: size_t +ida_gdl.qflow_chart_t.is_noret_block(self, blknum: "size_t") -> bool -ida_gdl.qflow_chart_t.is_ret_block (method) - is_ret_block(self, blknum) -> bool - - @param blknum: size_t +ida_gdl.qflow_chart_t.is_ret_block(self, blknum: "size_t") -> bool -ida_gdl.qflow_chart_t.npred (method) - npred(self, node) -> int - - @param node: int +ida_gdl.qflow_chart_t.npred(self, node: int) -> int -ida_gdl.qflow_chart_t.nproper (variable) +ida_gdl.qflow_chart_t.nproper number of basic blocks belonging to the specified range -ida_gdl.qflow_chart_t.nsucc (method) - nsucc(self, node) -> int - - @param node: int +ida_gdl.qflow_chart_t.nsucc(self, node: int) -> int -ida_gdl.qflow_chart_t.pfn (variable) +ida_gdl.qflow_chart_t.pfn the function this instance was built upon -ida_gdl.qflow_chart_t.pred (method) - pred(self, node, i) -> int - - @param node: int - @param i: int +ida_gdl.qflow_chart_t.pred(self, node: int, i: int) -> int -ida_gdl.qflow_chart_t.print_names (method) - print_names(self) -> bool +ida_gdl.qflow_chart_t.print_names(self) -> bool -ida_gdl.qflow_chart_t.print_node_attributes (method) - print_node_attributes(self, fp, n) - - @param fp: FILE * - @param n: int +ida_gdl.qflow_chart_t.print_node_attributes(self, fp: "FILE *", n: int) -> None -ida_gdl.qflow_chart_t.refresh (method) - refresh(self) +ida_gdl.qflow_chart_t.refresh(self) -> None -ida_gdl.qflow_chart_t.size (method) - size(self) -> int +ida_gdl.qflow_chart_t.size(self) -> int -ida_gdl.qflow_chart_t.succ (method) - succ(self, node, i) -> int - - @param node: int - @param i: int +ida_gdl.qflow_chart_t.succ(self, node: int, i: int) -> int -ida_graph (module) +ida_graph Graph view management. -ida_graph.GLICTL_CENTER (variable) +ida_graph.GLICTL_CENTER the gli should be set/get as center -ida_graph.GraphViewer (class) +ida_graph.GraphViewer This class wraps the user graphing facility provided by the graph.hpp file -ida_graph.GraphViewer.AddCommand (method) +ida_graph.GraphViewer.AddCommand(self, title, shortcut) -ida_graph.GraphViewer.AddEdge (method) +ida_graph.GraphViewer.AddEdge(self, src_node, dest_node) Creates an edge between two given node ids -ida_graph.GraphViewer.AddNode (method) +ida_graph.GraphViewer.AddNode(self, obj) Creates a node associated with the given object and returns the node id -ida_graph.GraphViewer.Clear (method) +ida_graph.GraphViewer.Clear(self) Clears all the nodes and edges -ida_graph.GraphViewer.Close (method) +ida_graph.GraphViewer.Close(self) Closes the graph. It is possible to call Show() again (which will recreate the graph) -ida_graph.GraphViewer.Count (method) +ida_graph.GraphViewer.Count(self) Returns the node count -ida_graph.GraphViewer.OnCommand (method) +ida_graph.GraphViewer.OnCommand(self, cmd_id) -ida_graph.GraphViewer.OnPopup (method) +ida_graph.GraphViewer.OnPopup(self, widget, popup_handle) -ida_graph.GraphViewer.OnRefresh (method) +ida_graph.GraphViewer.OnRefresh(self) Event called when the graph is refreshed or first created. From this event you are supposed to create nodes and edges. This callback is mandatory. @@ -26125,4758 +17290,3169 @@ ida_graph.GraphViewer.OnRefresh (method) @note: ***It is important to clear previous nodes before adding nodes.*** @return: Returning True tells the graph viewer to use the items. Otherwise old items will be used. -ida_graph.GraphViewer.Select (method) +ida_graph.GraphViewer.Select(self, node_id) Selects a node on the graph -ida_graph.GraphViewer.Show (method) +ida_graph.GraphViewer.Show(self) Shows an existing graph or creates a new one @return: Boolean -ida_graph.GraphViewer.UI_Hooks_Trampoline (class) +ida_graph.GraphViewer.UI_Hooks_Trampoline -ida_graph.GraphViewer.UI_Hooks_Trampoline.__init__ (method) +ida_graph.GraphViewer.UI_Hooks_Trampoline.__init__(self, v) -ida_graph.GraphViewer.UI_Hooks_Trampoline.populating_widget_popup (method) +ida_graph.GraphViewer.UI_Hooks_Trampoline.populating_widget_popup(self, w, popup_handle) -ida_graph.GraphViewer._OnBind (method) +ida_graph.GraphViewer._OnBind(self, hook) -ida_graph.GraphViewer.__getitem__ (method) +ida_graph.GraphViewer.__getitem__(self, idx) Returns a reference to the object associated with this node id -ida_graph.GraphViewer.__init__ (method) +ida_graph.GraphViewer.__init__(self, title, close_open = False) Constructs the GraphView object. Please do not remove or rename the private fields @param title: The title of the graph window @param close_open: Should it attempt to close an existing graph (with same title) before creating this graph? -ida_graph.GraphViewer.__init__._qccb (function) +ida_graph.GraphViewer.__init__._qccb(ctx, cmd_id) -ida_graph.GraphViewer.__iter__ (method) +ida_graph.GraphViewer.__iter__(self) -ida_graph.MTG_DOT_NODE (variable) +ida_graph.MTG_DOT_NODE is dot node? -ida_graph.MTG_GROUP_NODE (variable) +ida_graph.MTG_GROUP_NODE is group node? -ida_graph.MTG_NON_DISPLAYABLE_NODE (variable) - for disassembly graphs - non-displayable nodes have a visible area that is too - large to generate disassembly lines for without IDA slowing down significantly - (see MAX_VISIBLE_NODE_AREA) +ida_graph.MTG_NON_DISPLAYABLE_NODE + for disassembly graphs - non-displayable nodes have a visible area that is too large to generate disassembly lines for without IDA slowing down significantly (see MAX_VISIBLE_NODE_AREA) + -ida_graph.NIF_BG_COLOR (variable) +ida_graph.NIF_BG_COLOR node_info_t::bg_color -ida_graph.NIF_EA (variable) +ida_graph.NIF_EA node_info_t::ea -ida_graph.NIF_FLAGS (variable) +ida_graph.NIF_FLAGS node_info_t::flags -ida_graph.NIF_FRAME_COLOR (variable) +ida_graph.NIF_FRAME_COLOR node_info_t::frame_color -ida_graph.NIF_TEXT (variable) +ida_graph.NIF_TEXT node_info_t::text -ida_graph.TPointDouble (class) - Proxy of C++ TPointDouble class. +ida_graph.TPointDouble -ida_graph.TPointDouble.__eq__ (method) - __eq__(self, r) -> bool +ida_graph.TPointDouble.__eq__(self, r: "TPointDouble") -> bool + +ida_graph.TPointDouble.__init__(self, *args) + +ida_graph.TPointDouble.__ne__(self, r: "TPointDouble") -> bool + +ida_graph.TPointDouble.add(self, r: "TPointDouble") -> None + +ida_graph.TPointDouble.negate(self) -> None + +ida_graph.TPointDouble.sub(self, r: "TPointDouble") -> None + +ida_graph.calc_dist(p: "point_t", q: "point_t") -> "double" + Calculate distance between p and q. + +ida_graph.clr_node_info(gid: "graph_id_t", node: int, flags: int) -> None + Clear node info for the given node. + + @param gid: id of desired graph + @param node: node number + @param flags: combination of Node info flags, identifying which fields of node_info_t will be cleared + +ida_graph.create_disasm_graph(*args) -> "interactive_graph_t *" + This function has the following signatures: - @param r: TPointDouble const & - -ida_graph.TPointDouble.__init__ (method) - __init__(self) -> TPointDouble - __init__(self, a, b) -> TPointDouble + 0. create_disasm_graph(ea: ida_idaapi.ea_t) -> interactive_graph_t * + 1. create_disasm_graph(ranges: const rangevec_t &) -> interactive_graph_t * - @param a: double - @param b: double + # 0: create_disasm_graph(ea: ida_idaapi.ea_t) -> interactive_graph_t * - __init__(self, r) -> TPointDouble + Create a graph for the function that contains 'ea'. - @param r: point_t const & - -ida_graph.TPointDouble.__ne__ (method) - __ne__(self, r) -> bool - @param r: TPointDouble const & - -ida_graph.TPointDouble.add (method) - add(self, r) + # 1: create_disasm_graph(ranges: const rangevec_t &) -> interactive_graph_t * - @param r: TPointDouble const & + Create a graph using an arbitrary set of ranges. -ida_graph.TPointDouble.negate (method) - negate(self) +ida_graph.create_graph_viewer(title: str, id: int, callback: "hook_cb_t *", ud: "void *", title_height: int, parent: "TWidget *" = None) -> "graph_viewer_t *" + Create a custom graph viewer. + + @param title: the widget title + @param id: graph id + @param callback: callback to handle graph notifications (graph_notification_t) + @param ud: user data passed to callback + @param title_height: node title height + @param parent: the parent widget of the graph viewer + @returns new viewer -ida_graph.TPointDouble.sub (method) - sub(self, r) - - @param r: TPointDouble const & +ida_graph.create_interactive_graph(id: int) -> "interactive_graph_t *" + Create a new empty graph with given id. -ida_graph.abstract_graph_t (class) - Proxy of C++ abstract_graph_t class. +ida_graph.create_user_graph_place(node: int, lnnum: int) -> "user_graph_place_t *" + Get a copy of a user_graph_place_t (returns a pointer to static storage) -ida_graph.abstract_graph_t.__disown__ (method) +ida_graph.del_node_info(gid: "graph_id_t", node: int) -> None + Delete the node_info_t for the given node. -ida_graph.abstract_graph_t.__init__ (method) - __init__(self) -> abstract_graph_t - - @param self: PyObject * +ida_graph.delete_interactive_graph(g: "interactive_graph_t") -> None + Delete graph object. + -ida_graph.abstract_graph_t.callback_ud (variable) +ida_graph.drawable_graph_t + +ida_graph.drawable_graph_t.__disown__(self) + +ida_graph.drawable_graph_t.__init__(self) + +ida_graph.drawable_graph_t.callback_ud user data for callback -ida_graph.abstract_graph_t.circle_center (variable) +ida_graph.drawable_graph_t.circle_center for layout_circle -ida_graph.abstract_graph_t.circle_radius (variable) +ida_graph.drawable_graph_t.circle_radius for layout_circle -ida_graph.abstract_graph_t.create_circle_layout (method) - create_circle_layout(self, p, radius) -> bool - - @param p: point_t - @param radius: int +ida_graph.drawable_graph_t.create_circle_layout(self, p: "point_t", radius: int) -> bool -ida_graph.abstract_graph_t.create_tree_layout (method) - create_tree_layout(self) -> bool +ida_graph.drawable_graph_t.create_tree_layout(self) -> bool -ida_graph.abstract_graph_t.current_layout (variable) +ida_graph.drawable_graph_t.current_layout see Proximity view layouts -ida_graph.abstract_graph_t.get_edge (method) - get_edge(self, e) -> edge_info_t - - @param e: edge_t +ida_graph.drawable_graph_t.get_edge(self, e: "edge_t") -> "edge_info_t *" -ida_graph.abstract_graph_t.grcall (method) - grcall(self, code) -> ssize_t - - @param code: int +ida_graph.drawable_graph_t.grcall(self, code: int) -> "ssize_t" -ida_graph.abstract_graph_t.nrect (method) - nrect(self, n) -> rect_t - - @param n: int +ida_graph.drawable_graph_t.nrect(self, n: int) -> "rect_t" -ida_graph.abstract_graph_t.rect_edges_made (variable) +ida_graph.drawable_graph_t.rect_edges_made have create rectangular edges? -ida_graph.abstract_graph_t.set_callback (method) - set_callback(self, _callback, _ud) - - @param _callback: hook_cb_t * - @param _ud: void * +ida_graph.drawable_graph_t.set_callback(self, _callback: "hook_cb_t *", _ud: "void *") -> None -ida_graph.abstract_graph_t.title (variable) +ida_graph.drawable_graph_t.title graph title -ida_graph.calc_dist (function) - calc_dist(p, q) -> double - Calculate distance between p and q. - - @param p: (C++: point_t) - @param q: (C++: point_t) +ida_graph.edge_info_t -ida_graph.clr_node_info (function) - clr_node_info(gid, node, flags) - Clear node info for the given node. - - @param gid: (C++: graph_id_t) id of desired graph - @param node: (C++: int) node number - @param flags: (C++: uint32) combination of Node info flags, identifying which fields of - node_info_t will be cleared +ida_graph.edge_info_t.__init__(self) -ida_graph.create_disasm_graph (function) - create_disasm_graph(ea) -> mutable_graph_t - Create a graph using an arbitrary set of ranges. - - @param ea: ea_t - - create_disasm_graph(ranges) -> mutable_graph_t - - @param ranges: rangevec_t const & - -ida_graph.create_graph_viewer (function) - create_graph_viewer(title, id, callback, ud, title_height, parent=None) -> graph_viewer_t * - Create a custom graph viewer. - - @param title: (C++: const char *) the widget title - @param id: (C++: uval_t) graph id - @param callback: (C++: hook_cb_t *) callback to handle graph notifications (graph_notification_t) - @param ud: (C++: void *) user data passed to callback - @param title_height: (C++: int) node title height - @param parent: (C++: TWidget *) the parent widget of the graph viewer - @return: new viewer - -ida_graph.create_mutable_graph (function) - create_mutable_graph(id) -> mutable_graph_t - Create a new empty graph with given id. - - @param id: (C++: uval_t) - -ida_graph.create_user_graph_place (function) - create_user_graph_place(node, lnnum) -> user_graph_place_t - Get a copy of a user_graph_place_t (returns a pointer to static storage) - - @param node: (C++: int) - @param lnnum: (C++: int) - -ida_graph.del_node_info (function) - del_node_info(gid, node) - Delete the node_info_t for the given node. - - @param gid: (C++: graph_id_t) - @param node: (C++: int) - -ida_graph.delete_mutable_graph (function) - delete_mutable_graph(g) - Delete graph object. - @warning: use this only if you are dealing with mutable_graph_t instances that - have not been used together with a graph_viewer_t. If you have called - set_viewer_graph() with your graph, the graph's lifecycle will be - managed by the viewer, and you shouldn't interfere with it - - @param g: (C++: mutable_graph_t *) - -ida_graph.edge_info_t (class) - Proxy of C++ edge_info_t class. - -ida_graph.edge_info_t.__init__ (method) - __init__(self) -> edge_info_t - -ida_graph.edge_info_t.color (variable) +ida_graph.edge_info_t.color edge color -ida_graph.edge_info_t.layout (variable) +ida_graph.edge_info_t.dstoff + destination: edge port offset from the left + +ida_graph.edge_info_t.layout describes geometry of edge -ida_graph.edge_info_t.reverse_layout (method) - reverse_layout(self) +ida_graph.edge_info_t.reverse_layout(self) -> None -ida_graph.edge_info_t.width (variable) +ida_graph.edge_info_t.srcoff + source: edge port offset from the left + +ida_graph.edge_info_t.width edge width -ida_graph.edge_infos_wrapper_t (class) - Proxy of C++ edge_infos_wrapper_t class. +ida_graph.edge_infos_wrapper_t -ida_graph.edge_infos_wrapper_t.__init__ (method) +ida_graph.edge_infos_wrapper_t.__init__(self, *args, **kwargs) -ida_graph.edge_infos_wrapper_t.clear (method) - clear(self) +ida_graph.edge_infos_wrapper_t.clear(self) -> None -ida_graph.edge_layout_point_t (class) - Proxy of C++ edge_layout_point_t class. +ida_graph.edge_layout_point_t -ida_graph.edge_layout_point_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: edge_layout_point_t const & +ida_graph.edge_layout_point_t.__eq__(self, r: "edge_layout_point_t") -> bool -ida_graph.edge_layout_point_t.__init__ (method) - __init__(self) -> edge_layout_point_t - __init__(self, _e, _pidx) -> edge_layout_point_t - - @param _e: edge_t const & - @param _pidx: int +ida_graph.edge_layout_point_t.__init__(self, *args) -ida_graph.edge_layout_point_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: edge_layout_point_t const & +ida_graph.edge_layout_point_t.__ne__(self, r: "edge_layout_point_t") -> bool -ida_graph.edge_layout_point_t.compare (method) - compare(self, r) -> int - - @param r: edge_layout_point_t const & +ida_graph.edge_layout_point_t.compare(self, r: "edge_layout_point_t") -> int -ida_graph.edge_layout_point_t.e (variable) +ida_graph.edge_layout_point_t.e parent edge -ida_graph.edge_layout_point_t.pidx (variable) +ida_graph.edge_layout_point_t.pidx index into edge_info_t::layout -ida_graph.edge_segment_t (class) - Proxy of C++ edge_segment_t class. +ida_graph.edge_segment_t -ida_graph.edge_segment_t.__init__ (method) - __init__(self) -> edge_segment_t +ida_graph.edge_segment_t.__init__(self) -ida_graph.edge_segment_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: edge_segment_t const & +ida_graph.edge_segment_t.__lt__(self, r: "edge_segment_t") -> bool -ida_graph.edge_segment_t.length (method) - length(self) -> size_t +ida_graph.edge_segment_t.length(self) -> "size_t" -ida_graph.edge_segment_t.toright (method) - toright(self) -> bool +ida_graph.edge_segment_t.toright(self) -> bool -ida_graph.edge_t (class) - Proxy of C++ edge_t class. - -ida_graph.edge_t.__eq__ (method) - __eq__(self, y) -> bool - - @param y: edge_t const & - -ida_graph.edge_t.__init__ (method) - __init__(self) -> edge_t - __init__(self, x, y) -> edge_t - - @param x: int - @param y: int - -ida_graph.edge_t.__lt__ (method) - __lt__(self, y) -> bool - - @param y: edge_t const & - -ida_graph.edge_t.__ne__ (method) - __ne__(self, y) -> bool - - @param y: edge_t const & - -ida_graph.edge_t.dst (variable) - destination node number - -ida_graph.edge_t.src (variable) - source node number - -ida_graph.get_graph_viewer (function) - get_graph_viewer(parent) -> graph_viewer_t * +ida_graph.get_graph_viewer(parent: "TWidget *") -> "graph_viewer_t *" Get custom graph viewer for given form. - - @param parent: (C++: TWidget *) -ida_graph.get_node_info (function) - get_node_info(out, gid, node) -> bool - Get node info. - - @param out: (C++: node_info_t *) result - @param gid: (C++: graph_id_t) id of desired graph - @param node: (C++: int) node number - @return: success +ida_graph.get_node_info(out: "node_info_t", gid: "graph_id_t", node: int) -> bool + Get node info. + + @param out: result + @param gid: id of desired graph + @param node: node number + @returns success -ida_graph.get_viewer_graph (function) - get_viewer_graph(gv) -> mutable_graph_t +ida_graph.get_viewer_graph(gv: "graph_viewer_t *") -> "interactive_graph_t *" Get graph object for given custom graph viewer. - - @param gv: (C++: graph_viewer_t *) -ida_graph.git_edge (variable) +ida_graph.git_edge edge (graph_item_t::e, graph_item_t::n. n is farthest edge endpoint) -ida_graph.git_elp (variable) +ida_graph.git_elp edge layout point (graph_item_t::elp) -ida_graph.git_node (variable) +ida_graph.git_node node title (graph_item_t::n) -ida_graph.git_none (variable) +ida_graph.git_none nothing -ida_graph.git_text (variable) +ida_graph.git_text node text (graph_item_t::n, graph_item_t::p) -ida_graph.git_tool (variable) +ida_graph.git_tool node title button (graph_item_t::n, graph_item_t::b) -ida_graph.graph_item_t (class) - Proxy of C++ graph_item_t class. +ida_graph.graph_item_t -ida_graph.graph_item_t.__init__ (method) - __init__(self) -> graph_item_t +ida_graph.graph_item_t.__init__(self) -ida_graph.graph_item_t.b (variable) +ida_graph.graph_item_t.b button number -ida_graph.graph_item_t.e (variable) +ida_graph.graph_item_t.e edge source and destination -ida_graph.graph_item_t.elp (variable) +ida_graph.graph_item_t.elp edge layout point -ida_graph.graph_item_t.is_edge (method) - is_edge(self) -> bool +ida_graph.graph_item_t.is_edge(self) -> bool -ida_graph.graph_item_t.is_node (method) - is_node(self) -> bool +ida_graph.graph_item_t.is_node(self) -> bool -ida_graph.graph_item_t.n (variable) +ida_graph.graph_item_t.n node number -ida_graph.graph_item_t.p (variable) +ida_graph.graph_item_t.p text coordinates in the node -ida_graph.graph_item_t.type (variable) +ida_graph.graph_item_t.type type -ida_graph.graph_node_visitor_t (class) - Proxy of C++ graph_node_visitor_t class. +ida_graph.graph_node_visitor_t -ida_graph.graph_node_visitor_t.__disown__ (method) +ida_graph.graph_node_visitor_t.__disown__(self) -ida_graph.graph_node_visitor_t.__init__ (method) - __init__(self) -> graph_node_visitor_t - - @param self: PyObject * +ida_graph.graph_node_visitor_t.__init__(self) -ida_graph.graph_node_visitor_t.is_forbidden_edge (method) - is_forbidden_edge(self, arg0, arg1) -> bool +ida_graph.graph_node_visitor_t.is_forbidden_edge(self, arg0: int, arg1: int) -> bool Should the edge between 'n' and 'm' be ignored? - - @param arg0: int - @param arg1: int -ida_graph.graph_node_visitor_t.is_visited (method) - is_visited(self, n) -> bool +ida_graph.graph_node_visitor_t.is_visited(self, n: int) -> bool Have we already visited the given node? - - @param n: (C++: int) -ida_graph.graph_node_visitor_t.reinit (method) - reinit(self) +ida_graph.graph_node_visitor_t.reinit(self) -> None Reset visited nodes. -ida_graph.graph_node_visitor_t.set_visited (method) - set_visited(self, n) +ida_graph.graph_node_visitor_t.set_visited(self, n: int) -> None Mark node as visited. - - @param n: (C++: int) -ida_graph.graph_node_visitor_t.visit_node (method) - visit_node(self, arg0) -> int +ida_graph.graph_node_visitor_t.visit_node(self, arg0: int) -> int Implements action to take when a node is visited. - - @param arg0: int -ida_graph.graph_path_visitor_t (class) - Proxy of C++ graph_path_visitor_t class. +ida_graph.graph_path_visitor_t -ida_graph.graph_path_visitor_t.__disown__ (method) +ida_graph.graph_path_visitor_t.__disown__(self) -ida_graph.graph_path_visitor_t.__init__ (method) - __init__(self) -> graph_path_visitor_t - - @param self: PyObject * +ida_graph.graph_path_visitor_t.__init__(self) -ida_graph.graph_path_visitor_t.path (variable) +ida_graph.graph_path_visitor_t.path current path -ida_graph.graph_path_visitor_t.prune (variable) - walk_forward(): prune := true means to stop the current path +ida_graph.graph_path_visitor_t.prune + walk_forward(): prune := true means to stop the current path + -ida_graph.graph_path_visitor_t.walk_backward (method) - walk_backward(self, arg0) -> int - - @param arg0: int +ida_graph.graph_path_visitor_t.walk_backward(self, arg0: int) -> int -ida_graph.graph_path_visitor_t.walk_forward (method) - walk_forward(self, arg0) -> int - - @param arg0: int +ida_graph.graph_path_visitor_t.walk_forward(self, arg0: int) -> int -ida_graph.graph_visitor_t (class) - Proxy of C++ graph_visitor_t class. +ida_graph.graph_visitor_t -ida_graph.graph_visitor_t.__disown__ (method) +ida_graph.graph_visitor_t.__disown__(self) -ida_graph.graph_visitor_t.__init__ (method) - __init__(self) -> graph_visitor_t - - @param self: PyObject * +ida_graph.graph_visitor_t.__init__(self) -ida_graph.graph_visitor_t.visit_edge (method) - visit_edge(self, arg2, arg3) -> int - - @param arg2: edge_t - @param arg3: edge_info_t * +ida_graph.graph_visitor_t.visit_edge(self, arg2: "edge_t", arg3: "edge_info_t") -> int -ida_graph.graph_visitor_t.visit_node (method) - visit_node(self, arg2, arg3) -> int - - @param arg2: int - @param arg3: rect_t & +ida_graph.graph_visitor_t.visit_node(self, arg2: int, arg3: "rect_t") -> int -ida_graph.grcode_calculating_layout (variable) - calculating user-defined graph layout. - - @retval 0: not implemented - @retval 1: graph layout calculated by the plugin +ida_graph.grcode_calculating_layout + calculating user-defined graph layout. + -ida_graph.grcode_center_on (variable) +ida_graph.grcode_center_on use viewer_center_on() -ida_graph.grcode_change_group_visibility (variable) - use mutable_graph_t::change_group_visibility() +ida_graph.grcode_change_group_visibility + use interactive_graph_t::change_group_visibility() -ida_graph.grcode_changed_graph (variable) - new graph has been set. - - @retval 0: must return 0 +ida_graph.grcode_changed_graph + new graph has been set. + -ida_graph.grcode_clear (variable) - use mutable_graph_t::clear() +ida_graph.grcode_clear + use interactive_graph_t::clear() -ida_graph.grcode_clicked (variable) - graph is being clicked. this callback allows you to ignore some clicks. it - occurs too early, internal graph variables are not updated yet. current_item1, - current_item2 point to the same thing. item2 has more information. see also: - custom_viewer_click_t - - @retval 0: ok - @retval 1: ignore click +ida_graph.grcode_clicked + graph is being clicked. this callback allows you to ignore some clicks. it occurs too early, internal graph variables are not updated yet. current_item1, current_item2 point to the same thing. item2 has more information. see also: custom_viewer_click_t + -ida_graph.grcode_create_circle_layout (variable) - use abstract_graph_t::create_circle_layout() +ida_graph.grcode_create_circle_layout + use drawable_graph_t::create_circle_layout() -ida_graph.grcode_create_digraph_layout (variable) - use mutable_graph_t::create_digraph_layout() +ida_graph.grcode_create_digraph_layout + use interactive_graph_t::create_digraph_layout() -ida_graph.grcode_create_disasm_graph1 (variable) +ida_graph.grcode_create_disasm_graph1 use create_disasm_graph(ea_t ea) -ida_graph.grcode_create_disasm_graph2 (variable) +ida_graph.grcode_create_disasm_graph2 use create_disasm_graph(const rangevec_t &ranges) -ida_graph.grcode_create_graph_viewer (variable) +ida_graph.grcode_create_graph_viewer use create_graph_viewer() -ida_graph.grcode_create_group (variable) - use mutable_graph_t::create_group() +ida_graph.grcode_create_group + use interactive_graph_t::create_group() -ida_graph.grcode_create_mutable_graph (variable) - use create_mutable_graph() +ida_graph.grcode_create_interactive_graph + use create_interactive_graph() -ida_graph.grcode_create_tree_layout (variable) - use abstract_graph_t::create_tree_layout() +ida_graph.grcode_create_tree_layout + use drawable_graph_t::create_tree_layout() -ida_graph.grcode_create_user_graph_place (variable) +ida_graph.grcode_create_user_graph_place use create_user_graph_place() -ida_graph.grcode_creating_group (variable) - a group is being created. this provides an opportunity for the graph to forbid - creation of the group. Note that groups management is done by the - mutable_graph_t instance itself: there is no need to modify the graph in this - callback. - - @retval 0: ok - @retval 1: forbid group creation +ida_graph.grcode_creating_group + a group is being created. this provides an opportunity for the graph to forbid creation of the group. Note that groups management is done by the interactive_graph_t instance itself: there is no need to modify the graph in this callback. + -ida_graph.grcode_dblclicked (variable) - a graph node has been double clicked. - - @retval 0: ok - @retval 1: ignore click +ida_graph.grcode_dblclicked + a graph node has been double clicked. + -ida_graph.grcode_del_custom_layout (variable) - use mutable_graph_t::del_custom_layout() +ida_graph.grcode_del_custom_layout + use interactive_graph_t::del_custom_layout() -ida_graph.grcode_del_node_info (variable) +ida_graph.grcode_del_node_info use viewer_del_node_info() -ida_graph.grcode_delete_group (variable) - use mutable_graph_t::delete_group() +ida_graph.grcode_delete_group + use interactive_graph_t::delete_group() -ida_graph.grcode_delete_mutable_graph (variable) - use delete_mutable_graph() +ida_graph.grcode_delete_interactive_graph + use delete_interactive_graph() -ida_graph.grcode_deleting_group (variable) - a group is being deleted. this provides an opportunity for the graph to forbid - deletion of the group. Note that groups management is done by the - mutable_graph_t instance itself: there is no need to modify the graph in this - callback. - - @retval 0: ok - @retval 1: forbid group deletion +ida_graph.grcode_deleting_group + a group is being deleted. this provides an opportunity for the graph to forbid deletion of the group. Note that groups management is done by the interactive_graph_t instance itself: there is no need to modify the graph in this callback. + -ida_graph.grcode_destroyed (variable) - graph is being destroyed. Note that this doesn't mean the graph viewer is being - destroyed; this only means that the graph that is being displayed by it is being - destroyed, and that, e.g., any possibly cached data should be invalidated (this - event can happen when, for example, the user decides to group nodes together: - that operation will effectively create a new graph, that will replace the old - one.) To be notified when the graph viewer itself is being destroyed, please see - notification 'view_close', in kernwin.hpp - - @retval 0: must return 0 +ida_graph.grcode_destroyed + graph is being destroyed. Note that this doesn't mean the graph viewer is being destroyed; this only means that the graph that is being displayed by it is being destroyed, and that, e.g., any possibly cached data should be invalidated (this event can happen when, for example, the user decides to group nodes together: that operation will effectively create a new graph, that will replace the old one.) To be notified when the graph viewer itself is being destroyed, please see notification 'view_close', in kernwin.hpp + -ida_graph.grcode_edge_infos_wrapper_clear (variable) +ida_graph.grcode_edge_infos_wrapper_clear use edge_infos_wrapper_t::clear() -ida_graph.grcode_edge_infos_wrapper_copy (variable) +ida_graph.grcode_edge_infos_wrapper_copy use edge_infos_wrapper_t::operator=() -ida_graph.grcode_empty (variable) - use mutable_graph_t::empty() +ida_graph.grcode_empty + use interactive_graph_t::empty() -ida_graph.grcode_find_subgraph_node (variable) - use mutable_graph_t::_find_subgraph_node() +ida_graph.grcode_find_subgraph_node + use interactive_graph_t::_find_subgraph_node() -ida_graph.grcode_fit_window (variable) +ida_graph.grcode_fit_window use viewer_fit_window() -ida_graph.grcode_get_curnode (variable) +ida_graph.grcode_get_curnode use viewer_get_curnode() -ida_graph.grcode_get_custom_layout (variable) - use mutable_graph_t::get_custom_layout() +ida_graph.grcode_get_custom_layout + use interactive_graph_t::get_custom_layout() -ida_graph.grcode_get_gli (variable) +ida_graph.grcode_get_gli use viewer_get_gli() -ida_graph.grcode_get_graph_groups (variable) - use mutable_graph_t::get_graph_groups() +ida_graph.grcode_get_graph_groups + use interactive_graph_t::get_graph_groups() -ida_graph.grcode_get_graph_viewer (variable) +ida_graph.grcode_get_graph_viewer use get_graph_viewer() -ida_graph.grcode_get_node_info (variable) +ida_graph.grcode_get_node_info use viewer_get_node_info() -ida_graph.grcode_get_node_representative (variable) - use mutable_graph_t::get_node_representative() +ida_graph.grcode_get_node_representative + use interactive_graph_t::get_node_representative() -ida_graph.grcode_get_selection (variable) +ida_graph.grcode_get_selection use viewer_get_selection() -ida_graph.grcode_get_viewer_graph (variable) +ida_graph.grcode_get_viewer_graph use get_viewer_graph() -ida_graph.grcode_gotfocus (variable) - a graph viewer got focus. - - @retval 0: must return 0 +ida_graph.grcode_gotfocus + a graph viewer got focus. + -ida_graph.grcode_group_visibility (variable) - a group is being collapsed/uncollapsed this provides an opportunity for the - graph to forbid changing the visibility of the group. Note that groups - management is done by the mutable_graph_t instance itself: there is no need to - modify the graph in this callback. - - @retval 0: ok - @retval 1: forbid group modification +ida_graph.grcode_group_visibility + a group is being collapsed/uncollapsed this provides an opportunity for the graph to forbid changing the visibility of the group. Note that groups management is done by the interactive_graph_t instance itself: there is no need to modify the graph in this callback. + -ida_graph.grcode_is_visible_node (variable) - use mutable_graph_t::is_visible_node() +ida_graph.grcode_is_visible_node + use interactive_graph_t::is_visible_node() -ida_graph.grcode_layout_calculated (variable) - graph layout calculated. - - @retval 0: must return 0 +ida_graph.grcode_layout_calculated + graph layout calculated. + -ida_graph.grcode_lostfocus (variable) - a graph viewer lost focus. - - @retval 0: must return 0 +ida_graph.grcode_lostfocus + a graph viewer lost focus. + -ida_graph.grcode_node_qty (variable) - use mutable_graph_t::node_qty() +ida_graph.grcode_node_qty + use interactive_graph_t::node_qty() -ida_graph.grcode_nrect (variable) - use mutable_graph_t::nrect() +ida_graph.grcode_nrect + use interactive_graph_t::nrect() -ida_graph.grcode_refresh_viewer (variable) +ida_graph.grcode_refresh_viewer use refresh_viewer() -ida_graph.grcode_set_custom_layout (variable) - use mutable_graph_t::set_custom_layout() +ida_graph.grcode_set_custom_layout + use interactive_graph_t::set_custom_layout() -ida_graph.grcode_set_edge (variable) - use mutable_graph_t::set_edge() +ida_graph.grcode_set_edge + use interactive_graph_t::set_edge() -ida_graph.grcode_set_gli (variable) +ida_graph.grcode_set_gli use viewer_set_gli() -ida_graph.grcode_set_graph_groups (variable) - use mutable_graph_t::set_graph_groups() +ida_graph.grcode_set_graph_groups + use interactive_graph_t::set_graph_groups() -ida_graph.grcode_set_node_info (variable) +ida_graph.grcode_set_node_info use viewer_set_node_info() -ida_graph.grcode_set_titlebar_height (variable) +ida_graph.grcode_set_titlebar_height use viewer_set_titlebar_height() -ida_graph.grcode_set_viewer_graph (variable) +ida_graph.grcode_set_viewer_graph use set_viewer_graph() -ida_graph.grcode_user_draw (variable) - render node of a user-defined graph. NB: draw only on the specified DC and - nowhere else! - - @retval 0: not rendered - @retval 1: rendered +ida_graph.grcode_user_draw + render node of a user-defined graph. NB: draw only on the specified DC and nowhere else! + -ida_graph.grcode_user_hint (variable) - retrieve hint for the user-defined graph. - - @retval 0: use default hint - @retval 1: use proposed hint +ida_graph.grcode_user_hint + retrieve hint for the user-defined graph. + -ida_graph.grcode_user_refresh (variable) - refresh user-defined graph nodes and edges This is called when the UI considers - that it is necessary to recreate the graph layout, and thus has to ensure that - the 'mutable_graph_t' instance it is using, is up-to-date. For example: +ida_graph.grcode_user_refresh + refresh user-defined graph nodes and edges This is called when the UI considers that it is necessary to recreate the graph layout, and thus has to ensure that the 'interactive_graph_t' instance it is using, is up-to-date. For example: * at graph creation-time * if a refresh_viewer() call was made - - @return: success -ida_graph.grcode_user_size (variable) - calculate node size for user-defined graph. - - @retval 0: did not calculate. ida will use node text size - @retval 1: calculated. ida will add node title to the size +ida_graph.grcode_user_size + calculate node size for user-defined graph. + -ida_graph.grcode_user_text (variable) - retrieve text for user-defined graph node. NB: do not use anything calling GDI! - - @return: success, result must be filled +ida_graph.grcode_user_text + retrieve text for user-defined graph node. NB: do not use anything calling GDI! + -ida_graph.grcode_user_title (variable) - render node title of a user-defined graph. - - @retval 0: did not render, ida will fill it with title_bg_color - @retval 1: rendered node title +ida_graph.grcode_user_title + render node title of a user-defined graph. + -ida_graph.grcode_viewer_create_groups_vec (variable) +ida_graph.grcode_viewer_create_groups_vec use viewer_create_groups() -ida_graph.grcode_viewer_delete_groups_vec (variable) +ida_graph.grcode_viewer_delete_groups_vec use viewer_delete_groups() -ida_graph.grcode_viewer_groups_visibility_vec (variable) +ida_graph.grcode_viewer_groups_visibility_vec use viewer_set_groups_visibility() -ida_graph.group_crinfo_t (class) - Proxy of C++ group_crinfo_t class. +ida_graph.group_crinfo_t -ida_graph.group_crinfo_t.__init__ (method) - __init__(self) -> group_crinfo_t +ida_graph.group_crinfo_t.__init__(self) -ida_graph.interval_t (class) - Proxy of C++ interval_t class. +ida_graph.interactive_graph_t -ida_graph.interval_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: interval_t const & +ida_graph.interactive_graph_t.__init__(self, *args, **kwargs) -ida_graph.interval_t.__init__ (method) - __init__(self) -> interval_t - __init__(self, y0, y1) -> interval_t - - @param y0: int - @param y1: int - - __init__(self, s) -> interval_t - - @param s: edge_segment_t const & +ida_graph.interactive_graph_t.add_edge(self, i: int, j: int, ei: "edge_info_t") -> bool -ida_graph.interval_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: interval_t const & - -ida_graph.interval_t.contains (method) - contains(self, x) -> bool - - @param x: int - -ida_graph.interval_t.empty (method) - empty(self) -> bool - -ida_graph.interval_t.intersect (method) - intersect(self, r) - - @param r: interval_t const & - -ida_graph.interval_t.length (method) - length(self) -> int - -ida_graph.interval_t.make_union (method) - make_union(self, r) - - @param r: interval_t const & - -ida_graph.interval_t.move_by (method) - move_by(self, shift) - - @param shift: int - -ida_graph.mutable_graph_t (class) - Proxy of C++ mutable_graph_t class. - -ida_graph.mutable_graph_t.__init__ (method) - -ida_graph.mutable_graph_t.add_edge (method) - add_edge(self, i, j, ei) -> bool - - @param i: int - @param j: int - @param ei: edge_info_t const * - -ida_graph.mutable_graph_t.add_node (method) - add_node(self, r) -> int +ida_graph.interactive_graph_t.add_node(self, r: "rect_t") -> int Add a node, possibly with a specific geometry - @param r: (C++: const rect_t *) the node geometry (can be nullptr) - @return: the new node + @param r: the node geometry (can be nullptr) + @returns the new node -ida_graph.mutable_graph_t.belongs (variable) - the subgraph the node belongs to INT_MAX means that the node doesn't exist sign - bit means collapsed node +ida_graph.interactive_graph_t.belongs + the subgraph the node belongs to INT_MAX means that the node doesn't exist sign bit means collapsed node + -ida_graph.mutable_graph_t.calc_group_ea (method) - calc_group_ea(self, arg2) -> ea_t - - @param arg2: intvec_t const & +ida_graph.interactive_graph_t.calc_group_ea(self, arg2: "intvec_t const &") -> ida_idaapi.ea_t -ida_graph.mutable_graph_t.change_group_visibility (method) - change_group_visibility(self, group, expand) -> bool +ida_graph.interactive_graph_t.change_group_visibility(self, group: int, expand: bool) -> bool Expand/collapse a group node - @param group: (C++: int) the group node - @param expand: (C++: bool) whether to expand or collapse - @return: success + @param group: the group node + @param expand: whether to expand or collapse + @returns success -ida_graph.mutable_graph_t.create_digraph_layout (method) - create_digraph_layout(self) -> bool +ida_graph.interactive_graph_t.create_digraph_layout(self) -> bool -ida_graph.mutable_graph_t.create_group (method) - create_group(self, nodes) -> int +ida_graph.interactive_graph_t.create_group(self, nodes: "intvec_t const &") -> int Create a new group node, that will contain all the nodes in 'nodes'. - @param nodes: (C++: const intvec_t &) the nodes that will be part of the group - @return: the group node, or -1 in case of error + @param nodes: the nodes that will be part of the group + @returns the group node, or -1 in case of error -ida_graph.mutable_graph_t.del_custom_layout (method) - del_custom_layout(self) +ida_graph.interactive_graph_t.del_custom_layout(self) -> None -ida_graph.mutable_graph_t.del_edge (method) - del_edge(self, i, j) -> bool - - @param i: int - @param j: int +ida_graph.interactive_graph_t.del_edge(self, i: int, j: int) -> bool -ida_graph.mutable_graph_t.del_node (method) - del_node(self, n) -> ssize_t +ida_graph.interactive_graph_t.del_node(self, n: int) -> "ssize_t" Delete a node - @param n: (C++: int) the node to delete - @return: the number of deleted edges + @param n: the node to delete + @returns the number of deleted edges -ida_graph.mutable_graph_t.delete_group (method) - delete_group(self, group) -> bool +ida_graph.interactive_graph_t.delete_group(self, group: int) -> bool Delete a group node. + This deletes the group node only; it does not delete nodes that are part of the group. - This deletes the group node only; it does not delete nodes that are part of the - group. - - @param group: (C++: int) the group node - @return: success + @param group: the group node + @returns success -ida_graph.mutable_graph_t.empty (method) - empty(self) -> bool - Is the graph (visually) empty? - - @return: true if there are no visible nodes +ida_graph.interactive_graph_t.empty(self) -> bool + Is the graph (visually) empty? + + @returns true if there are no visible nodes -ida_graph.mutable_graph_t.exists (method) - exists(self, node) -> bool +ida_graph.interactive_graph_t.exists(self, node: int) -> bool Is the node visible? - @param node: (C++: int) the node number - @return: success + @param node: the node number + @returns success -ida_graph.mutable_graph_t.get_custom_layout (method) - get_custom_layout(self) -> bool +ida_graph.interactive_graph_t.get_custom_layout(self) -> bool -ida_graph.mutable_graph_t.get_first_subgraph_node (method) - get_first_subgraph_node(self, group) -> int - - @param group: int +ida_graph.interactive_graph_t.get_first_subgraph_node(self, group: int) -> int -ida_graph.mutable_graph_t.get_graph_groups (method) - get_graph_groups(self) -> bool +ida_graph.interactive_graph_t.get_graph_groups(self) -> bool -ida_graph.mutable_graph_t.get_next_subgraph_node (method) - get_next_subgraph_node(self, group, current) -> int - - @param group: int - @param current: int +ida_graph.interactive_graph_t.get_next_subgraph_node(self, group: int, current: int) -> int -ida_graph.mutable_graph_t.get_node_group (method) - get_node_group(self, node) -> int - - @param node: int +ida_graph.interactive_graph_t.get_node_group(self, node: int) -> int -ida_graph.mutable_graph_t.get_node_representative (method) - get_node_representative(self, node) -> int - Get the node that currently visually represents 'node'. This will find the - "closest" parent group node that's visible, by attempting to walk up the group - nodes that contain 'node', and will stop when it finds a node that is currently - visible. - - See also get_group_node() - - @param node: (C++: int) the node - @return: the node that represents 'node', or 'node' if it's not part of any - group +ida_graph.interactive_graph_t.get_node_representative(self, node: int) -> int + Get the node that currently visually represents 'node'. This will find the "closest" parent group node that's visible, by attempting to walk up the group nodes that contain 'node', and will stop when it finds a node that is currently visible. + See also get_group_node() + + @param node: the node + @returns the node that represents 'node', or 'node' if it's not part of any group -ida_graph.mutable_graph_t.gid (variable) - graph id - unique for the database for flowcharts it is equal to the function - start_ea +ida_graph.interactive_graph_t.gid + graph id - unique for the database for flowcharts it is equal to the function start_ea + -ida_graph.mutable_graph_t.is_collapsed_node (method) - is_collapsed_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_collapsed_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_deleted_node (method) - is_deleted_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_deleted_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_displayable_node (method) - is_displayable_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_displayable_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_dot_node (method) - is_dot_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_dot_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_group_node (method) - is_group_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_group_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_simple_node (method) - is_simple_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_simple_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_subgraph_node (method) - is_subgraph_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_subgraph_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_uncollapsed_node (method) - is_uncollapsed_node(self, node) -> bool - - @param node: int +ida_graph.interactive_graph_t.is_uncollapsed_node(self, node: int) -> bool -ida_graph.mutable_graph_t.is_user_graph (method) - is_user_graph(self) -> bool +ida_graph.interactive_graph_t.is_user_graph(self) -> bool -ida_graph.mutable_graph_t.is_visible_node (method) - is_visible_node(self, node) -> bool +ida_graph.interactive_graph_t.is_visible_node(self, node: int) -> bool Is the node currently visible? - An invisible node is a node that's part of a group that's currently collapsed. - @param node: (C++: int) the node - @return: success + @param node: the node + @returns success -ida_graph.mutable_graph_t.node_flags (variable) +ida_graph.interactive_graph_t.node_flags node flags -ida_graph.mutable_graph_t.node_qty (method) - node_qty(self) -> int - Get the number of visible nodes (the list can be retrieved using gdl.hpp's - node_iterator) - +ida_graph.interactive_graph_t.node_qty(self) -> int + Get the number of visible nodes (the list can be retrieved using gdl.hpp's node_iterator) See also size() - @return: the number of visible nodes + @returns the number of visible nodes -ida_graph.mutable_graph_t.npred (method) - npred(self, b) -> int - - @param b: int +ida_graph.interactive_graph_t.npred(self, b: int) -> int -ida_graph.mutable_graph_t.nsucc (method) - nsucc(self, b) -> int - - @param b: int +ida_graph.interactive_graph_t.nsucc(self, b: int) -> int -ida_graph.mutable_graph_t.pred (method) - pred(self, b, i) -> int - - @param b: int - @param i: int +ida_graph.interactive_graph_t.pred(self, b: int, i: int) -> int -ida_graph.mutable_graph_t.predset (method) - predset(self, b) -> intvec_t const & - - @param b: int +ida_graph.interactive_graph_t.predset(self, b: int) -> "intvec_t const &" -ida_graph.mutable_graph_t.redo_layout (method) - redo_layout(self) -> bool +ida_graph.interactive_graph_t.redo_layout(self) -> bool Recompute the layout, according to the value of 'current_layout'. - @return: success + @returns success -ida_graph.mutable_graph_t.refresh (method) - refresh(self) -> bool +ida_graph.interactive_graph_t.refresh(self) -> bool Refresh the graph - - A graph needs refreshing when it's "backing data". E.g., if the number (or - contents) of the objects in the above example, change. - - Let's say the user's plugin ends up finding a 5th piece of scattered data. It - should then add it to its internal list of known objects, and tell IDA that the - graph needs to be refreshed, using refresh_viewer(). This will cause IDA to: + A graph needs refreshing when it's "backing data". E.g., if the number (or contents) of the objects in the above example, change. + Let's say the user's plugin ends up finding a 5th piece of scattered data. It should then add it to its internal list of known objects, and tell IDA that the graph needs to be refreshed, using refresh_viewer(). This will cause IDA to: * discard all its internal rendering information, - * call mutable_graph_t::refresh() on the graph so that the user's plugin has a - chance to "sync" the number of nodes & edges that this graph contains, to the - information that the plugin has collected so far + * call interactive_graph_t::refresh() on the graph so that the user's plugin has a chance to "sync" the number of nodes & edges that this graph contains, to the information that the plugin has collected so far * re-create internal rendering information, and * repaint the view - @return: success - -ida_graph.mutable_graph_t.replace_edge (method) - replace_edge(self, i, j, x, y) -> bool - @param i: int - @param j: int - @param x: int - @param y: int + + @returns success -ida_graph.mutable_graph_t.reset (method) - reset(self) +ida_graph.interactive_graph_t.replace_edge(self, i: int, j: int, x: int, y: int) -> bool -ida_graph.mutable_graph_t.resize (method) - resize(self, n) +ida_graph.interactive_graph_t.reset(self) -> None + +ida_graph.interactive_graph_t.resize(self, n: int) -> None Resize the graph to 'n' nodes - @param n: (C++: int) the new size + @param n: the new size -ida_graph.mutable_graph_t.set_custom_layout (method) - set_custom_layout(self) +ida_graph.interactive_graph_t.set_custom_layout(self) -> None -ida_graph.mutable_graph_t.set_deleted_node (method) - set_deleted_node(self, node) - - @param node: int +ida_graph.interactive_graph_t.set_deleted_node(self, node: int) -> None -ida_graph.mutable_graph_t.set_edge (method) - set_edge(self, e, ei) -> bool - - @param e: edge_t - @param ei: edge_info_t const * +ida_graph.interactive_graph_t.set_edge(self, e: "edge_t", ei: "edge_info_t") -> bool -ida_graph.mutable_graph_t.set_graph_groups (method) - set_graph_groups(self) +ida_graph.interactive_graph_t.set_graph_groups(self) -> None -ida_graph.mutable_graph_t.set_node_group (method) - set_node_group(self, node, group) - - @param node: int - @param group: int +ida_graph.interactive_graph_t.set_node_group(self, node: int, group: int) -> None -ida_graph.mutable_graph_t.set_nrect (method) - set_nrect(self, n, r) -> bool - - @param n: int - @param r: rect_t const & +ida_graph.interactive_graph_t.set_nrect(self, n: int, r: "rect_t") -> bool -ida_graph.mutable_graph_t.size (method) - size(self) -> int - Get the total number of nodes (including group nodes, and including hidden - nodes.) - +ida_graph.interactive_graph_t.size(self) -> int + Get the total number of nodes (including group nodes, and including hidden nodes.) See also node_qty() - @return: the total number of nodes in the graph + @returns the total number of nodes in the graph -ida_graph.mutable_graph_t.succ (method) - succ(self, b, i) -> int - - @param b: int - @param i: int +ida_graph.interactive_graph_t.succ(self, b: int, i: int) -> int -ida_graph.mutable_graph_t.succset (method) - succset(self, b) -> intvec_t const & - - @param b: int +ida_graph.interactive_graph_t.succset(self, b: int) -> "intvec_t const &" -ida_graph.node_info_t (class) - Proxy of C++ node_info_t class. +ida_graph.interval_t -ida_graph.node_info_t.__init__ (method) - __init__(self) -> node_info_t +ida_graph.interval_t.__eq__(self, r: "interval_t") -> bool -ida_graph.node_info_t.bg_color (variable) +ida_graph.interval_t.__init__(self, *args) + +ida_graph.interval_t.__ne__(self, r: "interval_t") -> bool + +ida_graph.interval_t.contains(self, x: int) -> bool + +ida_graph.interval_t.empty(self) -> bool + +ida_graph.interval_t.intersect(self, r: "interval_t") -> None + +ida_graph.interval_t.length(self) -> int + +ida_graph.interval_t.make_union(self, r: "interval_t") -> None + +ida_graph.interval_t.move_by(self, shift: int) -> None + +ida_graph.node_info_t + +ida_graph.node_info_t.__init__(self) + +ida_graph.node_info_t.bg_color background color -ida_graph.node_info_t.ea (variable) +ida_graph.node_info_t.ea address -ida_graph.node_info_t.flags (variable) +ida_graph.node_info_t.flags flags -ida_graph.node_info_t.frame_color (variable) +ida_graph.node_info_t.frame_color color of enclosing frame -ida_graph.node_info_t.get_flags_for_valid (method) - get_flags_for_valid(self) -> uint32 +ida_graph.node_info_t.get_flags_for_valid(self) -> int Get combination of Node info flags describing which attributes are valid. -ida_graph.node_info_t.text (variable) +ida_graph.node_info_t.text node contents -ida_graph.node_info_t.valid_bg_color (method) - valid_bg_color(self) -> bool +ida_graph.node_info_t.valid_bg_color(self) -> bool Has valid bg_color? -ida_graph.node_info_t.valid_ea (method) - valid_ea(self) -> bool +ida_graph.node_info_t.valid_ea(self) -> bool Has valid ea? -ida_graph.node_info_t.valid_flags (method) - valid_flags(self) -> bool +ida_graph.node_info_t.valid_flags(self) -> bool Has valid flags? -ida_graph.node_info_t.valid_frame_color (method) - valid_frame_color(self) -> bool +ida_graph.node_info_t.valid_frame_color(self) -> bool Has valid frame_color? -ida_graph.node_info_t.valid_text (method) - valid_text(self) -> bool +ida_graph.node_info_t.valid_text(self) -> bool Has non-empty text? -ida_graph.node_layout_t (class) - Proxy of C++ qvector< rect_t > class. - -ida_graph.node_layout_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< rect_t > const & - -ida_graph.node_layout_t.__getitem__ (method) - __getitem__(self, i) -> rect_t - - @param i: size_t - -ida_graph.node_layout_t.__init__ (method) - __init__(self) -> node_layout_t - __init__(self, x) -> node_layout_t - - @param x: qvector< rect_t > const & - -ida_graph.node_layout_t.__len__ (method) - __len__(self) -> size_t - -ida_graph.node_layout_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< rect_t > const & - -ida_graph.node_layout_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: rect_t const & - -ida_graph.node_layout_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: rect_t const & - -ida_graph.node_layout_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: rect_t const & - -ida_graph.node_layout_t.at (method) - at(self, _idx) -> rect_t - - @param _idx: size_t - -ida_graph.node_layout_t.begin (method) - begin(self) -> rect_t - -ida_graph.node_layout_t.capacity (method) - capacity(self) -> size_t - -ida_graph.node_layout_t.clear (method) - clear(self) - -ida_graph.node_layout_t.empty (method) - empty(self) -> bool - -ida_graph.node_layout_t.end (method) - end(self) -> rect_t - -ida_graph.node_layout_t.erase (method) - erase(self, it) -> rect_t - - @param it: qvector< rect_t >::iterator - - erase(self, first, last) -> rect_t - - @param first: qvector< rect_t >::iterator - @param last: qvector< rect_t >::iterator - -ida_graph.node_layout_t.extract (method) - extract(self) -> rect_t - -ida_graph.node_layout_t.find (method) - find(self, x) -> rect_t - - @param x: rect_t const & - -ida_graph.node_layout_t.grow (method) - grow(self, x=rect_t()) - - @param x: rect_t const & - -ida_graph.node_layout_t.has (method) - has(self, x) -> bool - - @param x: rect_t const & - -ida_graph.node_layout_t.inject (method) - inject(self, s, len) - - @param s: rect_t * - @param len: size_t - -ida_graph.node_layout_t.insert (method) - insert(self, it, x) -> rect_t - - @param it: qvector< rect_t >::iterator - @param x: rect_t const & - -ida_graph.node_layout_t.pop_back (method) - pop_back(self) - -ida_graph.node_layout_t.push_back (method) - push_back(self, x) - - @param x: rect_t const & - - push_back(self) -> rect_t - -ida_graph.node_layout_t.qclear (method) - qclear(self) - -ida_graph.node_layout_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_graph.node_layout_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: rect_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_graph.node_layout_t.size (method) - size(self) -> size_t - -ida_graph.node_layout_t.swap (method) - swap(self, r) - - @param r: qvector< rect_t > & - -ida_graph.node_layout_t.truncate (method) - truncate(self) - -ida_graph.node_ordering_t (class) - Proxy of C++ node_ordering_t class. - -ida_graph.node_ordering_t.__init__ (method) - __init__(self) -> node_ordering_t - -ida_graph.node_ordering_t.clear (method) - clear(self) - -ida_graph.node_ordering_t.clr (method) - clr(self, _node) -> bool - - @param _node: int - -ida_graph.node_ordering_t.node (method) - node(self, _order) -> int - - @param _order: size_t - -ida_graph.node_ordering_t.order (method) - order(self, _node) -> int - - @param _node: int - -ida_graph.node_ordering_t.resize (method) - resize(self, n) - - @param n: int - -ida_graph.node_ordering_t.set (method) - set(self, _node, num) - - @param _node: int - @param num: int - -ida_graph.node_ordering_t.size (method) - size(self) -> size_t - -ida_graph.point_t (class) - Proxy of C++ point_t class. - -ida_graph.point_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: point_t const & - -ida_graph.point_t.__init__ (method) - __init__(self) -> point_t - __init__(self, _x, _y) -> point_t - - @param _x: int - @param _y: int - -ida_graph.point_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: point_t const & - -ida_graph.point_t.add (method) - add(self, r) -> point_t - - @param r: point_t const & - -ida_graph.point_t.negate (method) - negate(self) - -ida_graph.point_t.sub (method) - sub(self, r) -> point_t - - @param r: point_t const & - -ida_graph.pointseq_t (class) - Proxy of C++ pointseq_t class. - -ida_graph.pointseq_t.__init__ (method) - __init__(self) -> pointseq_t - -ida_graph.pointvec_t (class) - Proxy of C++ qvector< point_t > class. - -ida_graph.pointvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< point_t > const & - -ida_graph.pointvec_t.__getitem__ (method) - __getitem__(self, i) -> point_t - - @param i: size_t - -ida_graph.pointvec_t.__init__ (method) - __init__(self) -> pointvec_t - __init__(self, x) -> pointvec_t - - @param x: qvector< point_t > const & - -ida_graph.pointvec_t.__len__ (method) - __len__(self) -> size_t - -ida_graph.pointvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< point_t > const & - -ida_graph.pointvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: point_t const & - -ida_graph.pointvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: point_t const & - -ida_graph.pointvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: point_t const & - -ida_graph.pointvec_t.at (method) - at(self, _idx) -> point_t - - @param _idx: size_t - -ida_graph.pointvec_t.begin (method) - begin(self) -> point_t - -ida_graph.pointvec_t.capacity (method) - capacity(self) -> size_t - -ida_graph.pointvec_t.clear (method) - clear(self) - -ida_graph.pointvec_t.empty (method) - empty(self) -> bool - -ida_graph.pointvec_t.end (method) - end(self) -> point_t - -ida_graph.pointvec_t.erase (method) - erase(self, it) -> point_t - - @param it: qvector< point_t >::iterator - - erase(self, first, last) -> point_t - - @param first: qvector< point_t >::iterator - @param last: qvector< point_t >::iterator - -ida_graph.pointvec_t.extract (method) - extract(self) -> point_t - -ida_graph.pointvec_t.find (method) - find(self, x) -> point_t - - @param x: point_t const & - -ida_graph.pointvec_t.grow (method) - grow(self, x=point_t()) - - @param x: point_t const & - -ida_graph.pointvec_t.has (method) - has(self, x) -> bool - - @param x: point_t const & - -ida_graph.pointvec_t.inject (method) - inject(self, s, len) - - @param s: point_t * - @param len: size_t - -ida_graph.pointvec_t.insert (method) - insert(self, it, x) -> point_t - - @param it: qvector< point_t >::iterator - @param x: point_t const & - -ida_graph.pointvec_t.pop_back (method) - pop_back(self) - -ida_graph.pointvec_t.push_back (method) - push_back(self, x) - - @param x: point_t const & - - push_back(self) -> point_t - -ida_graph.pointvec_t.qclear (method) - qclear(self) - -ida_graph.pointvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_graph.pointvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: point_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_graph.pointvec_t.size (method) - size(self) -> size_t - -ida_graph.pointvec_t.swap (method) - swap(self, r) - - @param r: qvector< point_t > & - -ida_graph.pointvec_t.truncate (method) - truncate(self) - -ida_graph.pyg_close (function) - pyg_close(_self) - - @param self: PyObject * - -ida_graph.pyg_select_node (function) - pyg_select_node(_self, nid) - - @param self: PyObject * - @param nid: int - -ida_graph.pyg_show (function) - pyg_show(_self) -> bool - - @param self: PyObject * - -ida_graph.rect_t (class) - Proxy of C++ rect_t class. - -ida_graph.rect_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: rect_t const & - -ida_graph.rect_t.__init__ (method) - __init__(self) -> rect_t - __init__(self, l, t, r, b) -> rect_t - - @param l: int - @param t: int - @param r: int - @param b: int - - __init__(self, p0, p1) -> rect_t - - @param p0: point_t const & - @param p1: point_t const & - -ida_graph.rect_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: rect_t const & - -ida_graph.rect_t.area (method) - area(self) -> int - -ida_graph.rect_t.bottomright (method) - bottomright(self) -> point_t - -ida_graph.rect_t.center (method) - center(self) -> point_t - -ida_graph.rect_t.contains (method) - contains(self, p) -> bool - - @param p: point_t const & - -ida_graph.rect_t.empty (method) - empty(self) -> bool - -ida_graph.rect_t.grow (method) - grow(self, delta) - - @param delta: int - -ida_graph.rect_t.height (method) - height(self) -> int - -ida_graph.rect_t.intersect (method) - intersect(self, r) - - @param r: rect_t const & - -ida_graph.rect_t.is_intersection_empty (method) - is_intersection_empty(self, r) -> bool - - @param r: rect_t const & - -ida_graph.rect_t.make_union (method) - make_union(self, r) - - @param r: rect_t const & - -ida_graph.rect_t.move_by (method) - move_by(self, p) - - @param p: point_t const & - -ida_graph.rect_t.move_to (method) - move_to(self, p) - - @param p: point_t const & - -ida_graph.rect_t.topleft (method) - topleft(self) -> point_t - -ida_graph.rect_t.width (method) - width(self) -> int - -ida_graph.refresh_viewer (function) - refresh_viewer(gv) +ida_graph.node_layout_t + +ida_graph.node_layout_t.__eq__(self, r: "node_layout_t") -> bool + +ida_graph.node_layout_t.__getitem__(self, i: "size_t") -> "rect_t const &" + +ida_graph.node_layout_t.__init__(self, *args) + +ida_graph.node_layout_t.__len__(self) -> "size_t" + +ida_graph.node_layout_t.__ne__(self, r: "node_layout_t") -> bool + +ida_graph.node_layout_t.__setitem__(self, i: "size_t", v: "rect_t") -> None + +ida_graph.node_layout_t._del(self, x: "rect_t") -> bool + +ida_graph.node_layout_t.add_unique(self, x: "rect_t") -> bool + +ida_graph.node_layout_t.append(self, x: "rect_t") -> None + +ida_graph.node_layout_t.at(self, _idx: "size_t") -> "rect_t const &" + +ida_graph.node_layout_t.begin(self, *args) -> "qvector< rect_t >::const_iterator" + +ida_graph.node_layout_t.capacity(self) -> "size_t" + +ida_graph.node_layout_t.clear(self) -> None + +ida_graph.node_layout_t.empty(self) -> bool + +ida_graph.node_layout_t.end(self, *args) -> "qvector< rect_t >::const_iterator" + +ida_graph.node_layout_t.erase(self, *args) -> "qvector< rect_t >::iterator" + +ida_graph.node_layout_t.extend(self, x: "node_layout_t") -> None + +ida_graph.node_layout_t.extract(self) -> "rect_t *" + +ida_graph.node_layout_t.find(self, *args) -> "qvector< rect_t >::const_iterator" + +ida_graph.node_layout_t.grow(self, *args) -> None + +ida_graph.node_layout_t.has(self, x: "rect_t") -> bool + +ida_graph.node_layout_t.inject(self, s: "rect_t", len: "size_t") -> None + +ida_graph.node_layout_t.insert(self, it: "rect_t", x: "rect_t") -> "qvector< rect_t >::iterator" + +ida_graph.node_layout_t.pop_back(self) -> None + +ida_graph.node_layout_t.push_back(self, *args) -> "rect_t &" + +ida_graph.node_layout_t.qclear(self) -> None + +ida_graph.node_layout_t.reserve(self, cnt: "size_t") -> None + +ida_graph.node_layout_t.resize(self, *args) -> None + +ida_graph.node_layout_t.size(self) -> "size_t" + +ida_graph.node_layout_t.swap(self, r: "node_layout_t") -> None + +ida_graph.node_layout_t.truncate(self) -> None + +ida_graph.point_t + +ida_graph.point_t.__eq__(self, r: "point_t") -> bool + +ida_graph.point_t.__init__(self, *args) + +ida_graph.point_t.__ne__(self, r: "point_t") -> bool + +ida_graph.point_t.add(self, r: "point_t") -> "point_t &" + +ida_graph.point_t.negate(self) -> None + +ida_graph.point_t.sub(self, r: "point_t") -> "point_t &" + +ida_graph.pointseq_t + +ida_graph.pointseq_t.__init__(self) + +ida_graph.pointvec_t + +ida_graph.pointvec_t.__eq__(self, r: "pointvec_t") -> bool + +ida_graph.pointvec_t.__getitem__(self, i: "size_t") -> "point_t const &" + +ida_graph.pointvec_t.__init__(self, *args) + +ida_graph.pointvec_t.__len__(self) -> "size_t" + +ida_graph.pointvec_t.__ne__(self, r: "pointvec_t") -> bool + +ida_graph.pointvec_t.__setitem__(self, i: "size_t", v: "point_t") -> None + +ida_graph.pointvec_t._del(self, x: "point_t") -> bool + +ida_graph.pointvec_t.add_unique(self, x: "point_t") -> bool + +ida_graph.pointvec_t.append(self, x: "point_t") -> None + +ida_graph.pointvec_t.at(self, _idx: "size_t") -> "point_t const &" + +ida_graph.pointvec_t.begin(self, *args) -> "qvector< point_t >::const_iterator" + +ida_graph.pointvec_t.capacity(self) -> "size_t" + +ida_graph.pointvec_t.clear(self) -> None + +ida_graph.pointvec_t.empty(self) -> bool + +ida_graph.pointvec_t.end(self, *args) -> "qvector< point_t >::const_iterator" + +ida_graph.pointvec_t.erase(self, *args) -> "qvector< point_t >::iterator" + +ida_graph.pointvec_t.extend(self, x: "pointvec_t") -> None + +ida_graph.pointvec_t.extract(self) -> "point_t *" + +ida_graph.pointvec_t.find(self, *args) -> "qvector< point_t >::const_iterator" + +ida_graph.pointvec_t.grow(self, *args) -> None + +ida_graph.pointvec_t.has(self, x: "point_t") -> bool + +ida_graph.pointvec_t.inject(self, s: "point_t", len: "size_t") -> None + +ida_graph.pointvec_t.insert(self, it: "point_t", x: "point_t") -> "qvector< point_t >::iterator" + +ida_graph.pointvec_t.pop_back(self) -> None + +ida_graph.pointvec_t.push_back(self, *args) -> "point_t &" + +ida_graph.pointvec_t.qclear(self) -> None + +ida_graph.pointvec_t.reserve(self, cnt: "size_t") -> None + +ida_graph.pointvec_t.resize(self, *args) -> None + +ida_graph.pointvec_t.size(self) -> "size_t" + +ida_graph.pointvec_t.swap(self, r: "pointvec_t") -> None + +ida_graph.pointvec_t.truncate(self) -> None + +ida_graph.pyg_close(_self: "PyObject *") -> None + +ida_graph.pyg_select_node(_self: "PyObject *", nid: int) -> None + +ida_graph.pyg_show(_self: "PyObject *") -> bool + +ida_graph.rect_t + +ida_graph.rect_t.__eq__(self, r: "rect_t") -> bool + +ida_graph.rect_t.__init__(self, *args) + +ida_graph.rect_t.__ne__(self, r: "rect_t") -> bool + +ida_graph.rect_t.area(self) -> int + +ida_graph.rect_t.bottomright(self) -> "point_t" + +ida_graph.rect_t.center(self) -> "point_t" + +ida_graph.rect_t.contains(self, p: "point_t") -> bool + +ida_graph.rect_t.empty(self) -> bool + +ida_graph.rect_t.grow(self, delta: int) -> None + +ida_graph.rect_t.height(self) -> int + +ida_graph.rect_t.intersect(self, r: "rect_t") -> None + +ida_graph.rect_t.is_intersection_empty(self, r: "rect_t") -> bool + +ida_graph.rect_t.make_union(self, r: "rect_t") -> None + +ida_graph.rect_t.move_by(self, p: "point_t") -> None + +ida_graph.rect_t.move_to(self, p: "point_t") -> None + +ida_graph.rect_t.topleft(self) -> "point_t" + +ida_graph.rect_t.verify(self) -> None + +ida_graph.rect_t.width(self) -> int + +ida_graph.refresh_viewer(gv: "graph_viewer_t *") -> None Redraw the graph in the given view. - - @param gv: (C++: graph_viewer_t *) -ida_graph.row_info_t (class) - Proxy of C++ row_info_t class. +ida_graph.row_info_t -ida_graph.row_info_t.__init__ (method) - __init__(self) -> row_info_t +ida_graph.row_info_t.__init__(self) -ida_graph.row_info_t.bottom (variable) +ida_graph.row_info_t.bottom bottom y coord of the row -ida_graph.row_info_t.height (method) - height(self) -> int +ida_graph.row_info_t.height(self) -> int -ida_graph.row_info_t.nodes (variable) +ida_graph.row_info_t.nodes list of nodes at the row -ida_graph.row_info_t.top (variable) +ida_graph.row_info_t.top top y coord of the row -ida_graph.screen_graph_selection_base_t (class) - Proxy of C++ qvector< selection_item_t > class. +ida_graph.screen_graph_selection_base_t -ida_graph.screen_graph_selection_base_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< selection_item_t > const & +ida_graph.screen_graph_selection_base_t.__eq__(self, r: "screen_graph_selection_base_t") -> bool -ida_graph.screen_graph_selection_base_t.__getitem__ (method) - __getitem__(self, i) -> selection_item_t - - @param i: size_t +ida_graph.screen_graph_selection_base_t.__getitem__(self, i: "size_t") -> "selection_item_t const &" -ida_graph.screen_graph_selection_base_t.__init__ (method) - __init__(self) -> screen_graph_selection_base_t - __init__(self, x) -> screen_graph_selection_base_t - - @param x: qvector< selection_item_t > const & +ida_graph.screen_graph_selection_base_t.__init__(self, *args) -ida_graph.screen_graph_selection_base_t.__len__ (method) - __len__(self) -> size_t +ida_graph.screen_graph_selection_base_t.__len__(self) -> "size_t" -ida_graph.screen_graph_selection_base_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< selection_item_t > const & +ida_graph.screen_graph_selection_base_t.__ne__(self, r: "screen_graph_selection_base_t") -> bool -ida_graph.screen_graph_selection_base_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: selection_item_t const & +ida_graph.screen_graph_selection_base_t.__setitem__(self, i: "size_t", v: "selection_item_t") -> None -ida_graph.screen_graph_selection_base_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: selection_item_t const & +ida_graph.screen_graph_selection_base_t._del(self, x: "selection_item_t") -> bool -ida_graph.screen_graph_selection_base_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: selection_item_t const & +ida_graph.screen_graph_selection_base_t.add_unique(self, x: "selection_item_t") -> bool -ida_graph.screen_graph_selection_base_t.at (method) - at(self, _idx) -> selection_item_t - - @param _idx: size_t +ida_graph.screen_graph_selection_base_t.append(self, x: "selection_item_t") -> None -ida_graph.screen_graph_selection_base_t.begin (method) - begin(self) -> selection_item_t +ida_graph.screen_graph_selection_base_t.at(self, _idx: "size_t") -> "selection_item_t const &" -ida_graph.screen_graph_selection_base_t.capacity (method) - capacity(self) -> size_t +ida_graph.screen_graph_selection_base_t.begin(self, *args) -> "qvector< selection_item_t >::const_iterator" -ida_graph.screen_graph_selection_base_t.clear (method) - clear(self) +ida_graph.screen_graph_selection_base_t.capacity(self) -> "size_t" -ida_graph.screen_graph_selection_base_t.empty (method) - empty(self) -> bool +ida_graph.screen_graph_selection_base_t.clear(self) -> None -ida_graph.screen_graph_selection_base_t.end (method) - end(self) -> selection_item_t +ida_graph.screen_graph_selection_base_t.empty(self) -> bool -ida_graph.screen_graph_selection_base_t.erase (method) - erase(self, it) -> selection_item_t - - @param it: qvector< selection_item_t >::iterator - - erase(self, first, last) -> selection_item_t - - @param first: qvector< selection_item_t >::iterator - @param last: qvector< selection_item_t >::iterator +ida_graph.screen_graph_selection_base_t.end(self, *args) -> "qvector< selection_item_t >::const_iterator" -ida_graph.screen_graph_selection_base_t.extract (method) - extract(self) -> selection_item_t +ida_graph.screen_graph_selection_base_t.erase(self, *args) -> "qvector< selection_item_t >::iterator" -ida_graph.screen_graph_selection_base_t.find (method) - find(self, x) -> selection_item_t - - @param x: selection_item_t const & +ida_graph.screen_graph_selection_base_t.extend(self, x: "screen_graph_selection_base_t") -> None -ida_graph.screen_graph_selection_base_t.grow (method) - grow(self, x=selection_item_t()) - - @param x: selection_item_t const & +ida_graph.screen_graph_selection_base_t.extract(self) -> "selection_item_t *" -ida_graph.screen_graph_selection_base_t.has (method) - has(self, x) -> bool - - @param x: selection_item_t const & +ida_graph.screen_graph_selection_base_t.find(self, *args) -> "qvector< selection_item_t >::const_iterator" -ida_graph.screen_graph_selection_base_t.inject (method) - inject(self, s, len) - - @param s: selection_item_t * - @param len: size_t +ida_graph.screen_graph_selection_base_t.grow(self, *args) -> None -ida_graph.screen_graph_selection_base_t.insert (method) - insert(self, it, x) -> selection_item_t - - @param it: qvector< selection_item_t >::iterator - @param x: selection_item_t const & +ida_graph.screen_graph_selection_base_t.has(self, x: "selection_item_t") -> bool -ida_graph.screen_graph_selection_base_t.pop_back (method) - pop_back(self) +ida_graph.screen_graph_selection_base_t.inject(self, s: "selection_item_t", len: "size_t") -> None -ida_graph.screen_graph_selection_base_t.push_back (method) - push_back(self, x) - - @param x: selection_item_t const & - - push_back(self) -> selection_item_t +ida_graph.screen_graph_selection_base_t.insert(self, it: "selection_item_t", x: "selection_item_t") -> "qvector< selection_item_t >::iterator" -ida_graph.screen_graph_selection_base_t.qclear (method) - qclear(self) +ida_graph.screen_graph_selection_base_t.pop_back(self) -> None -ida_graph.screen_graph_selection_base_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_graph.screen_graph_selection_base_t.push_back(self, *args) -> "selection_item_t &" -ida_graph.screen_graph_selection_base_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: selection_item_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_graph.screen_graph_selection_base_t.qclear(self) -> None -ida_graph.screen_graph_selection_base_t.size (method) - size(self) -> size_t +ida_graph.screen_graph_selection_base_t.reserve(self, cnt: "size_t") -> None -ida_graph.screen_graph_selection_base_t.swap (method) - swap(self, r) - - @param r: qvector< selection_item_t > & +ida_graph.screen_graph_selection_base_t.resize(self, *args) -> None -ida_graph.screen_graph_selection_base_t.truncate (method) - truncate(self) +ida_graph.screen_graph_selection_base_t.size(self) -> "size_t" -ida_graph.screen_graph_selection_t (class) - Proxy of C++ screen_graph_selection_t class. +ida_graph.screen_graph_selection_base_t.swap(self, r: "screen_graph_selection_base_t") -> None -ida_graph.screen_graph_selection_t.__init__ (method) - __init__(self) -> screen_graph_selection_t +ida_graph.screen_graph_selection_base_t.truncate(self) -> None -ida_graph.screen_graph_selection_t.add (method) - add(self, s) - - @param s: screen_graph_selection_t const & +ida_graph.screen_graph_selection_t -ida_graph.screen_graph_selection_t.add_node (method) - add_node(self, node) - - @param node: int +ida_graph.screen_graph_selection_t.__init__(self) -ida_graph.screen_graph_selection_t.add_point (method) - add_point(self, e, idx) - - @param e: edge_t - @param idx: int +ida_graph.screen_graph_selection_t.add(self, s: "screen_graph_selection_t") -> None -ida_graph.screen_graph_selection_t.del_node (method) - del_node(self, node) - - @param node: int +ida_graph.screen_graph_selection_t.add_node(self, node: int) -> None -ida_graph.screen_graph_selection_t.del_point (method) - del_point(self, e, idx) - - @param e: edge_t - @param idx: int +ida_graph.screen_graph_selection_t.add_point(self, e: "edge_t", idx: int) -> None -ida_graph.screen_graph_selection_t.has (method) - has(self, item) -> bool - - @param item: selection_item_t const & +ida_graph.screen_graph_selection_t.del_node(self, node: int) -> None -ida_graph.screen_graph_selection_t.items_count (method) - items_count(self, look_for_nodes) -> size_t - - @param look_for_nodes: bool +ida_graph.screen_graph_selection_t.del_point(self, e: "edge_t", idx: int) -> None -ida_graph.screen_graph_selection_t.nodes_count (method) - nodes_count(self) -> size_t +ida_graph.screen_graph_selection_t.has(self, item: "selection_item_t") -> bool -ida_graph.screen_graph_selection_t.points_count (method) - points_count(self) -> size_t +ida_graph.screen_graph_selection_t.items_count(self, look_for_nodes: bool) -> "size_t" -ida_graph.screen_graph_selection_t.sub (method) - sub(self, s) - - @param s: screen_graph_selection_t const & +ida_graph.screen_graph_selection_t.nodes_count(self) -> "size_t" -ida_graph.selection_item_t (class) - Proxy of C++ selection_item_t class. +ida_graph.screen_graph_selection_t.points_count(self) -> "size_t" -ida_graph.selection_item_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: selection_item_t const & +ida_graph.screen_graph_selection_t.sub(self, s: "screen_graph_selection_t") -> None -ida_graph.selection_item_t.__init__ (method) - __init__(self) -> selection_item_t - __init__(self, n) -> selection_item_t - - @param n: int - - __init__(self, _elp) -> selection_item_t - - @param _elp: edge_layout_point_t & - - __init__(self, e, idx) -> selection_item_t - - @param e: edge_t - @param idx: int +ida_graph.selection_item_t -ida_graph.selection_item_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: selection_item_t const & +ida_graph.selection_item_t.__eq__(self, r: "selection_item_t") -> bool -ida_graph.selection_item_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: selection_item_t const & +ida_graph.selection_item_t.__init__(self, *args) -ida_graph.selection_item_t.compare (method) - compare(self, r) -> int - - @param r: selection_item_t const & +ida_graph.selection_item_t.__lt__(self, r: "selection_item_t") -> bool -ida_graph.selection_item_t.elp (variable) +ida_graph.selection_item_t.__ne__(self, r: "selection_item_t") -> bool + +ida_graph.selection_item_t.compare(self, r: "selection_item_t") -> int + +ida_graph.selection_item_t.elp edge layout point (is_node = false) -ida_graph.selection_item_t.is_node (variable) +ida_graph.selection_item_t.is_node represents a selected node? -ida_graph.selection_item_t.node (variable) +ida_graph.selection_item_t.node node number (is_node = true) -ida_graph.set_node_info (function) - set_node_info(gid, node, ni, flags) - Set node info. - - @param gid: (C++: graph_id_t) id of desired graph - @param node: (C++: int) node number - @param ni: (C++: const node_info_t &) node info to use - @param flags: (C++: uint32) combination of Node info flags, identifying which fields of 'ni' - will be used +ida_graph.set_node_info(gid: "graph_id_t", node: int, ni: "node_info_t", flags: int) -> None + Set node info. + + @param gid: id of desired graph + @param node: node number + @param ni: node info to use + @param flags: combination of Node info flags, identifying which fields of 'ni' will be used -ida_graph.set_viewer_graph (function) - set_viewer_graph(gv, g) +ida_graph.set_viewer_graph(gv: "graph_viewer_t *", g: "interactive_graph_t") -> None Set the underlying graph object for the given viewer. - - @param gv: (C++: graph_viewer_t *) - @param g: (C++: mutable_graph_t *) -ida_graph.user_graph_place_t (class) - Proxy of C++ user_graph_place_t class. +ida_graph.user_graph_place_t -ida_graph.user_graph_place_t.__init__ (method) +ida_graph.user_graph_place_t.__init__(self, *args, **kwargs) -ida_graph.viewer_attach_menu_item (function) - viewer_attach_menu_item(g, name) -> bool - Attach a previously-registered action to the view's context menu. See - kernwin.hpp for how to register actions. - - @param g: (C++: graph_viewer_t *) graph viewer - @param name: (C++: const char *) action name - @return: success +ida_graph.viewer_attach_menu_item(g: "graph_viewer_t *", name: str) -> bool + Attach a previously-registered action to the view's context menu. See kernwin.hpp for how to register actions. + + @param g: graph viewer + @param name: action name + @returns success -ida_graph.viewer_center_on (function) - viewer_center_on(gv, node) +ida_graph.viewer_center_on(gv: "graph_viewer_t *", node: int) -> None Center the graph view on the given node. - - @param gv: (C++: graph_viewer_t *) - @param node: (C++: int) -ida_graph.viewer_create_groups (function) - viewer_create_groups(gv, out_group_nodes, gi) -> bool - This will perform an operation similar to what happens when a user manually - selects a set of nodes, right-clicks and selects "Create group". This is a - wrapper around mutable_graph_t::create_group that will, in essence: +ida_graph.viewer_create_groups(gv: "graph_viewer_t *", out_group_nodes: "intvec_t *", gi: "groups_crinfos_t const &") -> bool + This will perform an operation similar to what happens when a user manually selects a set of nodes, right-clicks and selects "Create group". This is a wrapper around interactive_graph_t::create_group that will, in essence: * clone the current graph * for each group_crinfo_t, attempt creating group in that new graph * if all were successful, animate to that new graph. - @note: this accepts parameters that allow creating of multiple groups at once; - which means only one graph animation will be triggered. - - @param gv: (C++: graph_viewer_t *) - @param out_group_nodes: (C++: intvec_t *) - @param gi: (C++: const groups_crinfos_t &) groups_crinfos_t const & -ida_graph.viewer_del_node_info (function) - viewer_del_node_info(gv, n) +ida_graph.viewer_del_node_info(gv: "graph_viewer_t *", n: int) -> None Delete node info for node in given viewer (see del_node_info()) - - @param gv: (C++: graph_viewer_t *) - @param n: (C++: int) -ida_graph.viewer_delete_groups (function) - viewer_delete_groups(gv, groups, new_current=-1) -> bool - Wrapper around mutable_graph_t::delete_group. This function will: +ida_graph.viewer_delete_groups(gv: "graph_viewer_t *", groups: "intvec_t const &", new_current: int = -1) -> bool + Wrapper around interactive_graph_t::delete_group. This function will: * clone the current graph * attempt deleting the groups in that new graph - * if successful, animate to that new graph. + * if successful, animate to that new graph. - @param gv: (C++: graph_viewer_t *) - @param groups: (C++: const intvec_t &) intvec_t const & - @param new_current: (C++: int) + + -ida_graph.viewer_fit_window (function) - viewer_fit_window(gv) +ida_graph.viewer_fit_window(gv: "graph_viewer_t *") -> None Fit graph viewer to its parent form. - - @param gv: (C++: graph_viewer_t *) -ida_graph.viewer_get_curnode (function) - viewer_get_curnode(gv) -> int +ida_graph.viewer_get_curnode(gv: "graph_viewer_t *") -> int Get number of currently selected node (-1 if none) - - @param gv: (C++: graph_viewer_t *) -ida_graph.viewer_get_gli (function) - viewer_get_gli(out, gv, flags=0) -> bool - Get location info for given graph view If flags contains GLICTL_CENTER, then the - gli that will be retrieved, will be the one at the center of the view. Otherwise - it will be the top-left. - - @param out: (C++: graph_location_info_t *) - @param gv: (C++: graph_viewer_t *) - @param flags: (C++: uint32) +ida_graph.viewer_get_gli(out: "graph_location_info_t *", gv: "graph_viewer_t *", flags: int = 0) -> bool + Get location info for given graph view If flags contains GLICTL_CENTER, then the gli that will be retrieved, will be the one at the center of the view. Otherwise it will be the top-left. + -ida_graph.viewer_get_node_info (function) - viewer_get_node_info(gv, out, n) -> bool +ida_graph.viewer_get_node_info(gv: "graph_viewer_t *", out: "node_info_t", n: int) -> bool Get node info for node in given viewer (see get_node_info()) - - @param gv: (C++: graph_viewer_t *) - @param out: (C++: node_info_t *) - @param n: (C++: int) -ida_graph.viewer_get_selection (function) - viewer_get_selection(gv, sgs) -> bool +ida_graph.viewer_get_selection(gv: "graph_viewer_t *", sgs: "screen_graph_selection_t") -> bool Get currently selected items for graph viewer. - - @param gv: (C++: graph_viewer_t *) - @param sgs: (C++: screen_graph_selection_t *) -ida_graph.viewer_set_gli (function) - viewer_set_gli(gv, gli, flags=0) - Set location info for given graph view If flags contains GLICTL_CENTER, then the - gli will be set to be the center of the view. Otherwise it will be the top-left. - - @param gv: (C++: graph_viewer_t *) - @param gli: (C++: const graph_location_info_t *) graph_location_info_t const * - @param flags: (C++: uint32) +ida_graph.viewer_set_gli(gv: "graph_viewer_t *", gli: "graph_location_info_t const *", flags: int = 0) -> None + Set location info for given graph view If flags contains GLICTL_CENTER, then the gli will be set to be the center of the view. Otherwise it will be the top-left. + -ida_graph.viewer_set_groups_visibility (function) - viewer_set_groups_visibility(gv, groups, expand, new_current=-1) -> bool - Wrapper around mutable_graph_t::change_visibility. This function will: +ida_graph.viewer_set_groups_visibility(gv: "graph_viewer_t *", groups: "intvec_t const &", expand: bool, new_current: int = -1) -> bool + Wrapper around interactive_graph_t::change_visibility. This function will: * clone the current graph * attempt changing visibility of the groups in that new graph - * if successful, animate to that new graph. + * if successful, animate to that new graph. - @param gv: (C++: graph_viewer_t *) - @param groups: (C++: const intvec_t &) intvec_t const & - @param expand: (C++: bool) - @param new_current: (C++: int) + + -ida_graph.viewer_set_node_info (function) - viewer_set_node_info(gv, n, ni, flags) +ida_graph.viewer_set_node_info(gv: "graph_viewer_t *", n: int, ni: "node_info_t", flags: int) -> None Set node info for node in given viewer (see set_node_info()) - - @param gv: (C++: graph_viewer_t *) - @param n: (C++: int) - @param ni: (C++: const node_info_t &) node_info_t const & - @param flags: (C++: uint32) -ida_graph.viewer_set_titlebar_height (function) - viewer_set_titlebar_height(gv, height) -> int +ida_graph.viewer_set_titlebar_height(gv: "graph_viewer_t *", height: int) -> int Set height of node title bars (grcode_set_titlebar_height) - - @param gv: (C++: graph_viewer_t *) - @param height: (C++: int) -ida_ida (module) - Contains the inf structure definition and some functions common to the whole IDA - project. +ida_ida + Contains the ::inf structure definition and some functions common to the whole IDA project. - The inf structure is saved in the database and contains information specific to - the current program being disassembled. Initially it is filled with values from - ida.cfg. - - Although it is not a good idea to change values in inf structure (because you - will overwrite values taken from ida.cfg), you are allowed to do it if you feel - it necessary. + The ::inf structure is saved in the database and contains information specific to the current program being disassembled. Initially it is filled with values from ida.cfg. + Although it is not a good idea to change values in ::inf structure (because you will overwrite values taken from ida.cfg), you are allowed to do it if you feel it necessary. + -ida_ida.ABI_8ALIGN4 (variable) +ida_ida.ABI_8ALIGN4 4 byte alignment for 8byte scalars (__int64/double) inside structures? -ida_ida.ABI_BIGARG_ALIGN (variable) - use natural type alignment for argument if the alignment exceeds native word - size. (e.g. __int64 argument should be 8byte aligned on some 32bit platforms) +ida_ida.ABI_BIGARG_ALIGN + use natural type alignment for argument if the alignment exceeds native word size. (e.g. __int64 argument should be 8byte aligned on some 32bit platforms) + -ida_ida.ABI_GCC_LAYOUT (variable) +ida_ida.ABI_GCC_LAYOUT use gcc layout for udts (used for mingw) -ida_ida.ABI_HARD_FLOAT (variable) +ida_ida.ABI_HARD_FLOAT use the floating-point register set -ida_ida.ABI_HUGEARG_ALIGN (variable) - use natural type alignment for an argument even if its alignment exceeds double - native word size (the default is to use double word max). e.g. if this bit is - set, __int128 has 16-byte alignment. this bit is not used by ida yet +ida_ida.ABI_HUGEARG_ALIGN + use natural type alignment for an argument even if its alignment exceeds double native word size (the default is to use double word max). e.g. if this bit is set, __int128 has 16-byte alignment. this bit is not used by ida yet + -ida_ida.ABI_MAP_STKARGS (variable) +ida_ida.ABI_MAP_STKARGS register arguments are mapped to stack area (and consume stack slots) -ida_ida.ABI_PACK_STKARGS (variable) +ida_ida.ABI_PACK_STKARGS do not align stack arguments to stack slots -ida_ida.ABI_SET_BY_USER (variable) - compiler/abi were set by user flag and require SETCOMP_BY_USER flag to be - changed +ida_ida.ABI_SET_BY_USER + compiler/abi were set by user flag and require SETCOMP_BY_USER flag to be changed -ida_ida.ABI_STACK_LDBL (variable) +ida_ida.ABI_STACK_LDBL long double arguments are passed on stack -ida_ida.ABI_STACK_VARARGS (variable) +ida_ida.ABI_STACK_VARARGS varargs are always passed on stack (even when there are free registers) -ida_ida.AF2_DOEH (variable) +ida_ida.AF2_DOEH Handle EH information. -ida_ida.AF2_DORTTI (variable) +ida_ida.AF2_DORTTI Handle RTTI information. -ida_ida.AF2_MACRO (variable) - Try to combine several instructions into a macro instruction +ida_ida.AF2_MACRO + Try to combine several instructions into a macro instruction + -ida_ida.AF2_MERGESTR (variable) - Merge string literals created using data xrefs +ida_ida.AF2_MERGESTR + Merge string literals created using data xrefs + -ida_ida.AF_ANORET (variable) +ida_ida.AF_ANORET Perform 'no-return' analysis. -ida_ida.AF_CHKUNI (variable) +ida_ida.AF_CHKUNI Check for unicode strings. -ida_ida.AF_CODE (variable) +ida_ida.AF_CODE Trace execution flow. -ida_ida.AF_DATOFF (variable) +ida_ida.AF_DATOFF Automatically convert data to offsets. -ida_ida.AF_DOCODE (variable) +ida_ida.AF_DOCODE Coagulate code segs at the final pass. -ida_ida.AF_DODATA (variable) +ida_ida.AF_DODATA Coagulate data segs at the final pass. -ida_ida.AF_DREFOFF (variable) +ida_ida.AF_DREFOFF Create offset if data xref to seg32 exists. -ida_ida.AF_FINAL (variable) +ida_ida.AF_FINAL Final pass of analysis. -ida_ida.AF_FIXUP (variable) +ida_ida.AF_FIXUP Create offsets and segments using fixup info. -ida_ida.AF_FLIRT (variable) +ida_ida.AF_FLIRT Use flirt signatures. -ida_ida.AF_FTAIL (variable) +ida_ida.AF_FTAIL Create function tails. -ida_ida.AF_HFLIRT (variable) +ida_ida.AF_HFLIRT Automatically hide library functions. -ida_ida.AF_IMMOFF (variable) +ida_ida.AF_IMMOFF Convert 32bit instruction operand to offset. -ida_ida.AF_JFUNC (variable) +ida_ida.AF_JFUNC Rename jump functions as j_... -ida_ida.AF_JUMPTBL (variable) +ida_ida.AF_JUMPTBL Locate and create jump tables. -ida_ida.AF_LVAR (variable) +ida_ida.AF_LVAR Create stack variables. -ida_ida.AF_MARKCODE (variable) +ida_ida.AF_MARKCODE Mark typical code sequences as code. -ida_ida.AF_MEMFUNC (variable) +ida_ida.AF_MEMFUNC Try to guess member function types. -ida_ida.AF_NULLSUB (variable) +ida_ida.AF_NULLSUB Rename empty functions as nullsub_... -ida_ida.AF_PROC (variable) +ida_ida.AF_PROC Create functions if call is present. -ida_ida.AF_PROCPTR (variable) +ida_ida.AF_PROCPTR Create function if data xref data->code32 exists. -ida_ida.AF_PURDAT (variable) +ida_ida.AF_PURDAT Control flow to data segment is ignored. -ida_ida.AF_REGARG (variable) +ida_ida.AF_REGARG Propagate register argument information. -ida_ida.AF_SIGCMT (variable) +ida_ida.AF_SIGCMT Append a signature name comment for recognized anonymous library functions. -ida_ida.AF_SIGMLT (variable) +ida_ida.AF_SIGMLT Allow recognition of several copies of the same function. -ida_ida.AF_STKARG (variable) +ida_ida.AF_STKARG Propagate stack argument information. -ida_ida.AF_STRLIT (variable) +ida_ida.AF_STRLIT Create string literal if data xref exists. -ida_ida.AF_TRACE (variable) +ida_ida.AF_TRACE Trace stack pointer. -ida_ida.AF_TRFUNC (variable) +ida_ida.AF_TRFUNC Truncate functions upon code deletion. -ida_ida.AF_UNK (variable) +ida_ida.AF_UNK Delete instructions with no xrefs. -ida_ida.AF_USED (variable) +ida_ida.AF_USED Analyze and create all xrefs. -ida_ida.AF_VERSP (variable) +ida_ida.AF_VERSP Perform full SP-analysis. ( processor_t::verify_sp) -ida_ida.DEMNAM_CMNT (variable) +ida_ida.DEMNAM_CMNT display demangled names as comments -ida_ida.DEMNAM_FIRST (variable) +ida_ida.DEMNAM_FIRST override type info -ida_ida.DEMNAM_GCC3 (variable) +ida_ida.DEMNAM_GCC3 assume gcc3 names (valid for gnu compiler) -ida_ida.DEMNAM_MASK (variable) +ida_ida.DEMNAM_MASK mask for name form -ida_ida.DEMNAM_NAME (variable) +ida_ida.DEMNAM_NAME display demangled names as regular names -ida_ida.DEMNAM_NONE (variable) +ida_ida.DEMNAM_NONE don't display demangled names -ida_ida.IDAINFO_TAG_SIZE (variable) - The database parameters. This structure is kept in the ida database. It contains - the essential parameters for the current program +ida_ida.IDAINFO_TAG_SIZE + The database parameters. This structure is kept in the ida database. It contains the essential parameters for the current program + -ida_ida.IDB_COMPRESSED (variable) +ida_ida.IDB_COMPRESSED compress & pack database components -ida_ida.IDB_PACKED (variable) +ida_ida.IDB_PACKED pack database components into .idb -ida_ida.IDB_UNPACKED (variable) +ida_ida.IDB_UNPACKED leave database components unpacked -ida_ida.IDI_BITMAP (variable) +ida_ida.IDI_ALTVAL + netnode: altval + +ida_ida.IDI_BITMAP bitmap field: interpret bitmask as bit number -ida_ida.IDI_BYTEARRAY (variable) +ida_ida.IDI_BLOB + netnode: blob + +ida_ida.IDI_BYTEARRAY byte array: binary representation -ida_ida.IDI_CSTR (variable) +ida_ida.IDI_CSTR string -ida_ida.IDI_DEC (variable) +ida_ida.IDI_DEC show as decimal -ida_ida.IDI_EA_HEX (variable) +ida_ida.IDI_EA_HEX default representation: hex or "BADADDR" -ida_ida.IDI_HASH (variable) +ida_ida.IDI_HASH hashed node field, hash name in offset -ida_ida.IDI_HEX (variable) +ida_ida.IDI_HEX show as hexadecimal -ida_ida.IDI_HLPSTRUC (variable) +ida_ida.IDI_HLPSTRUC call helper for pointer to structure -ida_ida.IDI_INC (variable) +ida_ida.IDI_INC stored value is incremented (scalars only) -ida_ida.IDI_MAP_VAL (variable) +ida_ida.IDI_MAP_VAL apply ea2node() to value -ida_ida.IDI_NOMERGE (variable) +ida_ida.IDI_NOMERGE field should not be merged as part of INF -ida_ida.IDI_ONOFF (variable) +ida_ida.IDI_ONOFF show boolean as on/off (not true/false) -ida_ida.IDI_QSTRING (variable) +ida_ida.IDI_QSTRING qstring -ida_ida.IDI_READONLY (variable) +ida_ida.IDI_READONLY read-only field (cannot be modified) -ida_ida.IDI_SCALAR (variable) +ida_ida.IDI_SCALAR scalar value (default) -ida_ida.IDI_STRUCFLD (variable) +ida_ida.IDI_STRUCFLD structure field (opposite to IDI_NODEVAL) -ida_ida.INFFL_ALLASM (variable) - may use constructs not supported by the target assembler +ida_ida.IDI_SUPVAL + netnode: supval -ida_ida.INFFL_AUTO (variable) +ida_ida.IDI_VALOBJ + netnode: valobj + +ida_ida.INFFL_ALLASM + may use constructs not supported by the target assembler + + +ida_ida.INFFL_AUTO Autoanalysis is enabled? -ida_ida.INFFL_CHKOPS (variable) +ida_ida.INFFL_CHKOPS check manual operands? (unused) -ida_ida.INFFL_GRAPH_VIEW (variable) +ida_ida.INFFL_GRAPH_VIEW currently using graph options ( text_options_t::graph) -ida_ida.INFFL_LOADIDC (variable) +ida_ida.INFFL_LOADIDC loading an idc file that contains database info -ida_ida.INFFL_NMOPS (variable) +ida_ida.INFFL_NMOPS allow non-matched operands? (unused) -ida_ida.INFFL_NOUSER (variable) +ida_ida.INFFL_NOUSER do not store user info in the database -ida_ida.INFFL_READONLY (variable) +ida_ida.INFFL_READONLY (internal) temporary interdiction to modify the database -ida_ida.INF_ABINAME (variable) +ida_ida.INF_ABINAME ABI name (processor specific) -ida_ida.INF_ARCHIVE_PATH (variable) +ida_ida.INF_ARCHIVE_PATH archive file path -ida_ida.INF_CRC32 (variable) +ida_ida.INF_CRC32 input file crc32 -ida_ida.INF_CTIME (variable) +ida_ida.INF_CTIME database creation timestamp -ida_ida.INF_C_MACROS (variable) +ida_ida.INF_C_MACROS C predefined macros. -ida_ida.INF_DBG_BINPATHS (variable) +ida_ida.INF_DBG_BINPATHS unused (20 indexes) -ida_ida.INF_DUALOP_GRAPH (variable) +ida_ida.INF_DUALOP_GRAPH Graph text representation options. -ida_ida.INF_DUALOP_TEXT (variable) +ida_ida.INF_DUALOP_TEXT Text text representation options. -ida_ida.INF_ELAPSED (variable) +ida_ida.INF_ELAPSED seconds database stayed open -ida_ida.INF_FILE_FORMAT_NAME (variable) +ida_ida.INF_FILE_FORMAT_NAME file format name for loader modules -ida_ida.INF_FSIZE (variable) +ida_ida.INF_FSIZE input file size -ida_ida.INF_GROUPS (variable) +ida_ida.INF_GROUPS segment group information (see init_groups()) -ida_ida.INF_H_PATH (variable) +ida_ida.INF_H_PATH C header path. -ida_ida.INF_IDA_VERSION (variable) +ida_ida.INF_IDA_VERSION version of ida which created the database -ida_ida.INF_IDSNODE (variable) +ida_ida.INF_IDSNODE ids modnode id (for import_module) -ida_ida.INF_IMAGEBASE (variable) +ida_ida.INF_IMAGEBASE image base -ida_ida.INF_INCLUDE (variable) +ida_ida.INF_INCLUDE assembler include file name -ida_ida.INF_INITIAL_VERSION (variable) +ida_ida.INF_INITIAL_VERSION initial version of database -ida_ida.INF_MD5 (variable) +ida_ida.INF_MD5 MD5 of the input file. -ida_ida.INF_NOPENS (variable) +ida_ida.INF_NOPENS how many times the database is opened -ida_ida.INF_NOTEPAD (variable) +ida_ida.INF_NOTEPAD notepad blob, occupies 1000 indexes (1MB of text) -ida_ida.INF_OUTFILEENC (variable) +ida_ida.INF_OUTFILEENC output file encoding index -ida_ida.INF_PROBLEMS (variable) +ida_ida.INF_PROBLEMS problem lists -ida_ida.INF_SELECTORS (variable) +ida_ida.INF_SELECTORS 2..63 are for selector_t blob (see init_selectors()) -ida_ida.INF_SHA256 (variable) +ida_ida.INF_SHA256 SHA256 of the input file. -ida_ida.INF_SRCDBG_PATHS (variable) +ida_ida.INF_SRCDBG_PATHS source debug paths, occupies 20 indexes -ida_ida.INF_SRCDBG_UNDESIRED (variable) +ida_ida.INF_SRCDBG_UNDESIRED user-closed source files, occupies 20 indexes -ida_ida.INF_STR_ENCODINGS (variable) +ida_ida.INF_STR_ENCODINGS a list of encodings for the program strings -ida_ida.LFLG_64BIT (variable) +ida_ida.LFLG_64BIT 64-bit program? -ida_ida.LFLG_COMPRESS (variable) +ida_ida.LFLG_COMPRESS compress the database? -ida_ida.LFLG_DBG_NOPATH (variable) +ida_ida.LFLG_DBG_NOPATH do not store input full path in debugger process options -ida_ida.LFLG_FLAT_OFF32 (variable) +ida_ida.LFLG_FLAT_OFF32 treat REF_OFF32 as 32-bit offset for 16bit segments (otherwise try SEG16:OFF16) -ida_ida.LFLG_IS_DLL (variable) +ida_ida.LFLG_ILP32 + 64-bit instructions with 64-bit registers, but 32-bit pointers and address space. this bit is mutually exclusive with LFLG_64BIT + + +ida_ida.LFLG_IS_DLL Is dynamic library? -ida_ida.LFLG_KERNMODE (variable) +ida_ida.LFLG_KERNMODE is kernel mode binary? -ida_ida.LFLG_MSF (variable) +ida_ida.LFLG_MSF Byte order: is MSB first? -ida_ida.LFLG_PACK (variable) +ida_ida.LFLG_PACK pack the database? -ida_ida.LFLG_PC_FLAT (variable) +ida_ida.LFLG_PC_FLAT 32-bit program (or higher)? -ida_ida.LFLG_PC_FPP (variable) +ida_ida.LFLG_PC_FPP decode floating point processor instructions? -ida_ida.LFLG_SNAPSHOT (variable) +ida_ida.LFLG_SNAPSHOT memory snapshot was taken? -ida_ida.LFLG_WIDE_HBF (variable) - Bit order of wide bytes: high byte first? (wide bytes: processor_t::dnbits > 8) +ida_ida.LFLG_WIDE_HBF + Bit order of wide bytes: high byte first? (wide bytes: processor_t::dnbits > 8) + -ida_ida.LMT_EMPTY (variable) +ida_ida.LMT_EMPTY empty lines at the end of basic blocks -ida_ida.LMT_THICK (variable) +ida_ida.LMT_THICK thick borders -ida_ida.LMT_THIN (variable) +ida_ida.LMT_THIN thin borders -ida_ida.LN_AUTO (variable) +ida_ida.LN_AUTO include autogenerated names -ida_ida.LN_NORMAL (variable) +ida_ida.LN_NORMAL include normal names -ida_ida.LN_PUBLIC (variable) +ida_ida.LN_PUBLIC include public names -ida_ida.LN_WEAK (variable) +ida_ida.LN_WEAK include weak names -ida_ida.OFLG_GEN_ASSUME (variable) +ida_ida.OFLG_GEN_ASSUME Generate 'assume' directives? -ida_ida.OFLG_GEN_NULL (variable) +ida_ida.OFLG_GEN_NULL Generate empty lines? -ida_ida.OFLG_GEN_ORG (variable) +ida_ida.OFLG_GEN_ORG Generate 'org' directives? -ida_ida.OFLG_GEN_TRYBLKS (variable) +ida_ida.OFLG_GEN_TRYBLKS Generate try/catch directives? -ida_ida.OFLG_LZERO (variable) +ida_ida.OFLG_LZERO generate leading zeroes in numbers -ida_ida.OFLG_PREF_SEG (variable) +ida_ida.OFLG_PREF_SEG line prefixes with segment name? -ida_ida.OFLG_SHOW_AUTO (variable) +ida_ida.OFLG_SHOW_AUTO Display autoanalysis indicator? -ida_ida.OFLG_SHOW_PREF (variable) +ida_ida.OFLG_SHOW_PREF Show line prefixes? -ida_ida.OFLG_SHOW_VOID (variable) +ida_ida.OFLG_SHOW_VOID Display void marks? -ida_ida.PREF_FNCOFF (variable) +ida_ida.PREF_FNCOFF show function offsets? -ida_ida.PREF_PFXTRUNC (variable) +ida_ida.PREF_PFXTRUNC truncate instruction bytes if they would need more than 1 line -ida_ida.PREF_SEGADR (variable) +ida_ida.PREF_SEGADR show segment addresses? -ida_ida.PREF_STACK (variable) +ida_ida.PREF_STACK show stack pointer? -ida_ida.SCF_ALLCMT (variable) +ida_ida.SCF_ALLCMT comment all lines? -ida_ida.SCF_LINNUM (variable) +ida_ida.SCF_LINNUM show source line numbers -ida_ida.SCF_NOCMT (variable) +ida_ida.SCF_NOCMT no comments at all -ida_ida.SCF_RPTCMT (variable) +ida_ida.SCF_RPTCMT show repeatable comments? -ida_ida.SCF_SHHID_FUNC (variable) +ida_ida.SCF_SHHID_FUNC show hidden functions -ida_ida.SCF_SHHID_ITEM (variable) +ida_ida.SCF_SHHID_ITEM show hidden instructions -ida_ida.SCF_SHHID_SEGM (variable) +ida_ida.SCF_SHHID_SEGM show hidden segments -ida_ida.SCF_TESTMODE (variable) +ida_ida.SCF_TESTMODE testida.idc is running -ida_ida.STRF_AUTO (variable) +ida_ida.STRF_AUTO names have 'autogenerated' bit? -ida_ida.STRF_COMMENT (variable) +ida_ida.STRF_COMMENT generate auto comment for string references? -ida_ida.STRF_GEN (variable) +ida_ida.STRF_GEN generate names? -ida_ida.STRF_SAVECASE (variable) +ida_ida.STRF_SAVECASE preserve case of strings for identifiers -ida_ida.STRF_SERIAL (variable) +ida_ida.STRF_SERIAL generate serial names? -ida_ida.STRF_UNICODE (variable) +ida_ida.STRF_UNICODE unicode strings are present? -ida_ida.STT_CUR (variable) +ida_ida.STT_CUR use current storage type (may be used only as a function argument) -ida_ida.STT_DBG (variable) +ida_ida.STT_DBG memory map: temporary debugger storage. used internally -ida_ida.STT_MM (variable) +ida_ida.STT_MM memory map: sparse storage. useful for huge objects -ida_ida.STT_VA (variable) +ida_ida.STT_VA regular storage: virtual arrays, an explicit flag for each byte -ida_ida.SW_SEGXRF (variable) +ida_ida.SW_SEGXRF show segments in xrefs? -ida_ida.SW_XRFFNC (variable) +ida_ida.SW_XRFFNC show function offsets? -ida_ida.SW_XRFMRK (variable) +ida_ida.SW_XRFMRK show xref type marks? -ida_ida.SW_XRFVAL (variable) +ida_ida.SW_XRFVAL show xref values? (otherwise-"...") -ida_ida.UA_MAXOP (variable) +ida_ida.UA_MAXOP max number of operands allowed for an instruction -ida_ida.VLD_AUTO_REPAIR (variable) +ida_ida.VLD_AUTO_REPAIR automatically repair the database -ida_ida.VLD_DIALOG (variable) +ida_ida.VLD_DIALOG ask user to repair (this bit is mutually exclusive with VLD_AUTO_REPAIR) -ida_ida.VLD_SILENT (variable) +ida_ida.VLD_SILENT no messages to the output window -ida_ida.__make_idainfo_accessors (function) +ida_ida.__make_idainfo_accessors(attr, getter_name = None, setter_name = None) -ida_ida.__make_idainfo_bound (function) +ida_ida.__make_idainfo_bound(func, attr) -ida_ida.__make_idainfo_bound.__func (function) +ida_ida.__make_idainfo_bound.__func(self, *args) -ida_ida.__make_idainfo_getter (function) +ida_ida.__make_idainfo_getter(name) -ida_ida.__set_module_dynattrs (function) +ida_ida.__set_module_dynattrs(modname, pdict) -ida_ida.__wrap_hooks_callback (function) +ida_ida.__wrap_hooks_callback(klass, new_name, old_name, do_call) -ida_ida.__wrap_hooks_callback.__wrapper (function) +ida_ida.__wrap_hooks_callback.__wrapper(self, *args) -ida_ida.calc_default_idaplace_flags (function) - calc_default_idaplace_flags() -> int +ida_ida.calc_default_idaplace_flags() -> int Get default disassembly line options. -ida_ida.compiler_info_t (class) - Proxy of C++ compiler_info_t class. +ida_ida.compiler_info_t -ida_ida.compiler_info_t.__init__ (method) - __init__(self) -> compiler_info_t +ida_ida.compiler_info_t.__init__(self) -ida_ida.compiler_info_t.cm (variable) +ida_ida.compiler_info_t.cm memory model and calling convention (see CM) -ida_ida.compiler_info_t.defalign (variable) +ida_ida.compiler_info_t.defalign default alignment for structures -ida_ida.compiler_info_t.id (variable) +ida_ida.compiler_info_t.id compiler id (see Compiler IDs) -ida_ida.compiler_info_t.size_b (variable) +ida_ida.compiler_info_t.size_b sizeof(bool) -ida_ida.compiler_info_t.size_e (variable) +ida_ida.compiler_info_t.size_e sizeof(enum) -ida_ida.compiler_info_t.size_i (variable) +ida_ida.compiler_info_t.size_i sizeof(int) -ida_ida.compiler_info_t.size_l (variable) +ida_ida.compiler_info_t.size_l long -ida_ida.compiler_info_t.size_ldbl (variable) +ida_ida.compiler_info_t.size_ldbl longdouble (if different from processor_t::tbyte_size) -ida_ida.compiler_info_t.size_ll (variable) +ida_ida.compiler_info_t.size_ll longlong -ida_ida.compiler_info_t.size_s (variable) +ida_ida.compiler_info_t.size_s short -ida_ida.delinf (function) - delinf(tag) -> bool - Undefine a program specific information - - @param tag: (C++: inftag_t) one of inftag_t constants - @return: success +ida_ida.delinf(tag: "inftag_t") -> bool + Undefine a program specific information + + @param tag: one of inftag_t constants + @returns success -ida_ida.f_AIXAR (variable) +ida_ida.f_AIXAR AIX ar library. -ida_ida.f_AOUT (variable) +ida_ida.f_AOUT Linux a.out (AOUT) -ida_ida.f_AR (variable) +ida_ida.f_AR ar library -ida_ida.f_BIN (variable) +ida_ida.f_BIN Binary File. -ida_ida.f_COFF (variable) +ida_ida.f_COFF Common Object File Format (COFF) -ida_ida.f_COM (variable) +ida_ida.f_COM MS DOS COM File. -ida_ida.f_COM_old (variable) +ida_ida.f_COM_old MS DOS COM File. -ida_ida.f_DRV (variable) +ida_ida.f_DRV MS DOS Driver. -ida_ida.f_ELF (variable) +ida_ida.f_ELF Executable and Linkable Format (ELF) -ida_ida.f_EXE (variable) +ida_ida.f_EXE MS DOS EXE File. -ida_ida.f_EXE_old (variable) +ida_ida.f_EXE_old MS DOS EXE File. -ida_ida.f_HEX (variable) +ida_ida.f_HEX Intel Hex Object File. -ida_ida.f_LE (variable) +ida_ida.f_LE Linear Executable (LE) -ida_ida.f_LOADER (variable) +ida_ida.f_LOADER file is loaded using LOADER DLL -ida_ida.f_LX (variable) +ida_ida.f_LX Linear Executable (LX) -ida_ida.f_MACHO (variable) +ida_ida.f_MACHO Mac OS X Mach-O. -ida_ida.f_MEX (variable) +ida_ida.f_MD1IMG + Mediatek Firmware Image. + +ida_ida.f_MEX MOS Technology Hex Object File. -ida_ida.f_NLM (variable) +ida_ida.f_NLM Netware Loadable Module (NLM) -ida_ida.f_OMF (variable) +ida_ida.f_OMF Object Module Format. -ida_ida.f_OMFLIB (variable) +ida_ida.f_OMFLIB Library of OMF Modules. -ida_ida.f_PE (variable) +ida_ida.f_PE Portable Executable (PE) -ida_ida.f_PRC (variable) +ida_ida.f_PRC PalmPilot program file. -ida_ida.f_PSXOBJ (variable) +ida_ida.f_PSXOBJ Sony Playstation PSX object file. -ida_ida.f_SREC (variable) +ida_ida.f_SREC Motorola SREC (S-record) -ida_ida.f_W32RUN (variable) +ida_ida.f_W32RUN Watcom DOS32 Extender (W32RUN) -ida_ida.f_WIN (variable) +ida_ida.f_WIN New Executable (NE) -ida_ida.f_ZIP (variable) +ida_ida.f_ZIP ZIP file (this file is never loaded to IDA database) -ida_ida.get_dbctx_id (function) - get_dbctx_id() -> ssize_t - Get the current database context ID - - @return: the database context ID, or -1 if no current database +ida_ida.get_dbctx_id() -> "ssize_t" + Get the current database context ID + + @returns the database context ID, or -1 if no current database -ida_ida.get_dbctx_qty (function) - get_dbctx_qty() -> size_t - Get number of database contexts - - @return: number of database contexts +ida_ida.get_dbctx_qty() -> "size_t" + Get number of database contexts + + @returns number of database contexts -ida_ida.getinf_str (function) - getinf_str(tag) -> str - Get program specific information (a non-scalar value) - - @param tag: (C++: inftag_t) one of inftag_t constants - @return: number of bytes stored in the buffer (<0 - not defined) +ida_ida.getinf_str(tag: "inftag_t") -> str + Get program specific information (a non-scalar value) + + @param tag: one of inftag_t constants + @returns number of bytes stored in the buffer (<0 - not defined) -ida_ida.idainfo (class) - Proxy of C++ idainfo class. +ida_ida.idainfo -ida_ida.idainfo.__init__ (method) +ida_ida.idainfo.__init__(self, *args, **kwargs) -ida_ida.idainfo._get_lflags (method) - _get_lflags(self) -> uint32 +ida_ida.idainfo._get_lflags(self) -> int -ida_ida.idainfo._set_lflags (method) - _set_lflags(self, _f) - - Parameters - ---------- - _f: uint32 +ida_ida.idainfo._set_lflags(self, _f: int) -> None -ida_ida.idainfo.abibits (variable) - ABI features. Depends on info returned by get_abi_name() Processor modules may - modify them in set_compiler +ida_ida.idainfo.abibits + ABI features. Depends on info returned by get_abi_name() Processor modules may modify them in set_compiler + -ida_ida.idainfo.af (variable) - Analysis flags +ida_ida.idainfo.af + Analysis flags + -ida_ida.idainfo.af2 (variable) - Analysis flags 2 +ida_ida.idainfo.af2 + Analysis flags 2 + -ida_ida.idainfo.appcall_options (variable) +ida_ida.idainfo.appcall_options appcall options, see idd.hpp -ida_ida.idainfo.apptype (variable) - Application type bit definitions in libfuncs.hpp +ida_ida.idainfo.apptype + Application type bit definitions in libfuncs.hpp + -ida_ida.idainfo.asmtype (variable) +ida_ida.idainfo.asmtype target assembler number -ida_ida.idainfo.baseaddr (variable) +ida_ida.idainfo.baseaddr remaining 28 bits are reserved - base address of the program (paragraphs) + base address of the program (paragraphs) + -ida_ida.idainfo.bin_prefix_size (variable) +ida_ida.idainfo.bin_prefix_size Number of instruction bytes (opcodes) to show in line prefix. -ida_ida.idainfo.cc (variable) +ida_ida.idainfo.cc COMPILER. - Target compiler + Target compiler + -ida_ida.idainfo.cmt_indent (variable) +ida_ida.idainfo.cmt_indent Indentation for comments. -ida_ida.idainfo.database_change_count (variable) - incremented after each byte and regular segment modifications +ida_ida.idainfo.database_change_count + incremented after each byte and regular segment modifications + -ida_ida.idainfo.datatypes (variable) +ida_ida.idainfo.datatypes data types allowed in data carousel -ida_ida.idainfo.demnames (variable) - Demangled name flags +ida_ida.idainfo.demnames + Demangled name flags + -ida_ida.idainfo.filetype (variable) +ida_ida.idainfo.filetype The input file type. -ida_ida.idainfo.get_abiname (method) - get_abiname(self) -> qstring +ida_ida.idainfo.get_abiname(self) -> str -ida_ida.idainfo.highoff (variable) - High limit for offsets (used in calculation of 'void' operands) +ida_ida.idainfo.highoff + High limit for offsets (used in calculation of 'void' operands) + -ida_ida.idainfo.indent (variable) +ida_ida.idainfo.indent DISASSEMBLY LISTING DETAILS. - Indentation for instructions + Indentation for instructions + -ida_ida.idainfo.lenxref (variable) +ida_ida.idainfo.lenxref max length of line with xrefs -ida_ida.idainfo.lflags (variable) - Misc. database flags +ida_ida.idainfo.lflags + Misc. database flags + -ida_ida.idainfo.listnames (variable) - Name list options +ida_ida.idainfo.listnames + Name list options + -ida_ida.idainfo.long_demnames (variable) - long form of demangled names see demangle.h for definitions +ida_ida.idainfo.long_demnames + long form of demangled names see demangle.h for definitions + -ida_ida.idainfo.lowoff (variable) - Low limit for offsets (used in calculation of 'void' operands) +ida_ida.idainfo.lowoff + Low limit for offsets (used in calculation of 'void' operands) + -ida_ida.idainfo.main (variable) +ida_ida.idainfo.main address of main() -ida_ida.idainfo.margin (variable) +ida_ida.idainfo.margin max length of data lines -ida_ida.idainfo.max_autoname_len (variable) +ida_ida.idainfo.max_autoname_len NAMES. - max autogenerated name length (without zero byte) + max autogenerated name length (without zero byte) + -ida_ida.idainfo.max_ea (variable) +ida_ida.idainfo.max_ea maxEA is excluded -ida_ida.idainfo.maxref (variable) +ida_ida.idainfo.maxref Max tail for references. -ida_ida.idainfo.min_ea (variable) +ida_ida.idainfo.min_ea current limits of program -ida_ida.idainfo.nametype (variable) - Dummy names representation types +ida_ida.idainfo.nametype + Dummy names representation types + -ida_ida.idainfo.omax_ea (variable) +ida_ida.idainfo.omax_ea original maxEA (is set after loading the input file) -ida_ida.idainfo.omin_ea (variable) +ida_ida.idainfo.omin_ea original minEA (is set after loading the input file) -ida_ida.idainfo.ostype (variable) - OS type the program is for bit definitions in libfuncs.hpp +ida_ida.idainfo.ostype + OS type the program is for bit definitions in libfuncs.hpp + -ida_ida.idainfo.outflags (variable) - output flags +ida_ida.idainfo.outflags + output flags + -ida_ida.idainfo.procname (variable) +ida_ida.idainfo.procname Name of the current processor (with \0) -ida_ida.idainfo.refcmtnum (variable) - Number of comment lines to generate for refs to string literals or demangled - names 0 - such comments won't be generated at all +ida_ida.idainfo.refcmtnum + Number of comment lines to generate for refs to string literals or demangled names 0 - such comments won't be generated at all + -ida_ida.idainfo.s_cmtflg (variable) - Comment options +ida_ida.idainfo.s_cmtflg + Comment options + -ida_ida.idainfo.s_genflags (variable) - General idainfo flags +ida_ida.idainfo.s_genflags + General idainfo flags + -ida_ida.idainfo.s_limiter (variable) - Delimiter options +ida_ida.idainfo.s_limiter + Delimiter options + -ida_ida.idainfo.s_prefflag (variable) - Line prefix options +ida_ida.idainfo.s_prefflag + Line prefix options + -ida_ida.idainfo.s_xrefflag (variable) - Xref options +ida_ida.idainfo.s_xrefflag + Xref options + -ida_ida.idainfo.short_demnames (variable) +ida_ida.idainfo.short_demnames short form of demangled names -ida_ida.idainfo.specsegs (variable) - What format do special segments use? 0-unspecified, 4-entries are 4 bytes, 8- - entries are 8 bytes. +ida_ida.idainfo.specsegs + What format do special segments use? 0-unspecified, 4-entries are 4 bytes, 8- entries are 8 bytes. -ida_ida.idainfo.start_cs (variable) +ida_ida.idainfo.start_cs selector of the segment with the main entry point -ida_ida.idainfo.start_ea (variable) +ida_ida.idainfo.start_ea Linear address of program entry point. -ida_ida.idainfo.start_ip (variable) - IP register value at the start of program execution +ida_ida.idainfo.start_ip + IP register value at the start of program execution + -ida_ida.idainfo.start_sp (variable) - SP register value at the start of program execution +ida_ida.idainfo.start_sp + SP register value at the start of program execution + -ida_ida.idainfo.start_ss (variable) +ida_ida.idainfo.start_ss selector of the initial stack segment -ida_ida.idainfo.strlit_break (variable) +ida_ida.idainfo.strlit_break string literal line break symbol -ida_ida.idainfo.strlit_flags (variable) +ida_ida.idainfo.strlit_flags STRING LITERALS. - string literal flags + string literal flags + -ida_ida.idainfo.strlit_pref (variable) +ida_ida.idainfo.strlit_pref prefix for string literal names -ida_ida.idainfo.strlit_sernum (variable) +ida_ida.idainfo.strlit_sernum serial number -ida_ida.idainfo.strlit_zeroes (variable) +ida_ida.idainfo.strlit_zeroes leading zeroes -ida_ida.idainfo.strtype (variable) - current ascii string type see nalt.hpp for string types +ida_ida.idainfo.strtype + current ascii string type see nalt.hpp for string types + -ida_ida.idainfo.tag (variable) +ida_ida.idainfo.tag 'IDA' -ida_ida.idainfo.type_xrefnum (variable) - Number of references to generate in the struct & enum windows 0 - xrefs won't be - generated at all +ida_ida.idainfo.type_xrefnum + Number of references to generate in the struct & enum windows 0 - xrefs won't be generated at all + -ida_ida.idainfo.version (variable) +ida_ida.idainfo.version Version of database. -ida_ida.idainfo.xrefnum (variable) +ida_ida.idainfo.xrefnum CROSS REFERENCES. - Number of references to generate in the disassembly listing 0 - xrefs won't be - generated at all + Number of references to generate in the disassembly listing 0 - xrefs won't be generated at all + -ida_ida.idainfo_is_32bit (function) +ida_ida.idainfo_is_32bit() -ida_ida.idbattr_info_t (class) - Proxy of C++ idbattr_info_t class. +ida_ida.idbattr_info_t -ida_ida.idbattr_info_t.__init__ (method) - __init__(self, name, offset, width, bitmask=0, tag=0, idi_flags=0) -> idbattr_info_t - - @param name: char const * - @param offset: uintptr_t - @param width: size_t - @param bitmask: uint64 - @param tag: uchar - @param idi_flags: uint +ida_ida.idbattr_info_t.__init__(self, name: str, offset: "uintptr_t", width: "size_t", bitmask: "uint64" = 0, tag: "uchar" = 0, idi_flags: "uint" = 0) -ida_ida.idbattr_info_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: idbattr_info_t const & +ida_ida.idbattr_info_t.__lt__(self, r: "idbattr_info_t") -> bool -ida_ida.idbattr_info_t.bitmask (variable) +ida_ida.idbattr_info_t.bitmask mask for bitfields (0-not bitfield) -ida_ida.idbattr_info_t.has_individual_node (method) - has_individual_node(self) -> bool +ida_ida.idbattr_info_t.has_individual_node(self) -> bool -ida_ida.idbattr_info_t.hashname (method) - hashname(self) -> char const * +ida_ida.idbattr_info_t.hashname(self) -> str -ida_ida.idbattr_info_t.individual_node (variable) +ida_ida.idbattr_info_t.individual_node individual node name (nullptr - use default) -ida_ida.idbattr_info_t.is_bitfield (method) - is_bitfield(self) -> bool +ida_ida.idbattr_info_t.is_bitfield(self) -> bool -ida_ida.idbattr_info_t.is_bitmap (method) - is_bitmap(self) -> bool +ida_ida.idbattr_info_t.is_bitmap(self) -> bool -ida_ida.idbattr_info_t.is_boolean (method) - is_boolean(self) -> bool +ida_ida.idbattr_info_t.is_boolean(self) -> bool -ida_ida.idbattr_info_t.is_buf_var (method) - is_buf_var(self) -> bool +ida_ida.idbattr_info_t.is_buf_var(self) -> bool -ida_ida.idbattr_info_t.is_bytearray (method) - is_bytearray(self) -> bool +ida_ida.idbattr_info_t.is_bytearray(self) -> bool -ida_ida.idbattr_info_t.is_cstr (method) - is_cstr(self) -> bool +ida_ida.idbattr_info_t.is_cstr(self) -> bool -ida_ida.idbattr_info_t.is_decimal (method) - is_decimal(self) -> bool +ida_ida.idbattr_info_t.is_decimal(self) -> bool -ida_ida.idbattr_info_t.is_hash (method) - is_hash(self) -> bool +ida_ida.idbattr_info_t.is_hash(self) -> bool -ida_ida.idbattr_info_t.is_hexadecimal (method) - is_hexadecimal(self) -> bool +ida_ida.idbattr_info_t.is_hexadecimal(self) -> bool -ida_ida.idbattr_info_t.is_incremented (method) - is_incremented(self) -> bool +ida_ida.idbattr_info_t.is_incremented(self) -> bool -ida_ida.idbattr_info_t.is_node_altval (method) - is_node_altval(self) -> bool +ida_ida.idbattr_info_t.is_node_altval(self) -> bool -ida_ida.idbattr_info_t.is_node_blob (method) - is_node_blob(self) -> bool +ida_ida.idbattr_info_t.is_node_blob(self) -> bool -ida_ida.idbattr_info_t.is_node_supval (method) - is_node_supval(self) -> bool +ida_ida.idbattr_info_t.is_node_supval(self) -> bool -ida_ida.idbattr_info_t.is_node_valobj (method) - is_node_valobj(self) -> bool +ida_ida.idbattr_info_t.is_node_valobj(self) -> bool -ida_ida.idbattr_info_t.is_node_var (method) - is_node_var(self) -> bool +ida_ida.idbattr_info_t.is_node_var(self) -> bool -ida_ida.idbattr_info_t.is_onoff (method) - is_onoff(self) -> bool +ida_ida.idbattr_info_t.is_onoff(self) -> bool -ida_ida.idbattr_info_t.is_qstring (method) - is_qstring(self) -> bool +ida_ida.idbattr_info_t.is_qstring(self) -> bool -ida_ida.idbattr_info_t.is_readonly_var (method) - is_readonly_var(self) -> bool +ida_ida.idbattr_info_t.is_readonly_var(self) -> bool -ida_ida.idbattr_info_t.is_scalar_var (method) - is_scalar_var(self) -> bool +ida_ida.idbattr_info_t.is_scalar_var(self) -> bool -ida_ida.idbattr_info_t.is_struc_field (method) - is_struc_field(self) -> bool +ida_ida.idbattr_info_t.is_struc_field(self) -> bool -ida_ida.idbattr_info_t.is_val_mapped (method) - is_val_mapped(self) -> bool +ida_ida.idbattr_info_t.is_val_mapped(self) -> bool -ida_ida.idbattr_info_t.maxsize (variable) +ida_ida.idbattr_info_t.maxsize max bytes reserved for storage in netnode -ida_ida.idbattr_info_t.name (variable) +ida_ida.idbattr_info_t.name human-readable name -ida_ida.idbattr_info_t.offset (variable) - field position: offset within a structure (IDI_STRUCFLD) altval or supval index - (IDI_NODEVAL) hashval name (IDI_ALTVAL/IDI_SUPVAL+IDI_HASH) +ida_ida.idbattr_info_t.offset + field position: offset within a structure (IDI_STRUCFLD) altval or supval index (IDI_NODEVAL) hashval name (IDI_ALTVAL/IDI_SUPVAL+IDI_HASH) + -ida_ida.idbattr_info_t.ridx (method) - ridx(self) -> size_t +ida_ida.idbattr_info_t.ridx(self) -> "size_t" -ida_ida.idbattr_info_t.str_false (method) - str_false(self) -> char const * +ida_ida.idbattr_info_t.str_false(self) -> str -ida_ida.idbattr_info_t.str_true (method) - str_true(self) -> char const * +ida_ida.idbattr_info_t.str_true(self) -> str -ida_ida.idbattr_info_t.tag (variable) +ida_ida.idbattr_info_t.tag tag of node value (if IDI_NODEVAL is set) -ida_ida.idbattr_info_t.use_hlpstruc (method) - use_hlpstruc(self) -> bool +ida_ida.idbattr_info_t.use_hlpstruc(self) -> bool -ida_ida.idbattr_info_t.vmap (variable) +ida_ida.idbattr_info_t.vmap array value=>name (terminated by empty element) -ida_ida.idbattr_info_t.width (variable) +ida_ida.idbattr_info_t.width field width in bytes -ida_ida.idbattr_valmap_t (class) - Proxy of C++ idbattr_valmap_t class. +ida_ida.idbattr_valmap_t -ida_ida.idbattr_valmap_t.__init__ (method) - __init__(self) -> idbattr_valmap_t +ida_ida.idbattr_valmap_t.__init__(self) -ida_ida.inf_abi_set_by_user (function) - inf_abi_set_by_user() -> bool +ida_ida.inf_abi_set_by_user() -> bool -ida_ida.inf_allow_non_matched_ops (function) - inf_allow_non_matched_ops() -> bool +ida_ida.inf_allow_non_matched_ops() -> bool -ida_ida.inf_allow_sigmulti (function) - inf_allow_sigmulti() -> bool +ida_ida.inf_allow_sigmulti() -> bool -ida_ida.inf_append_sigcmt (function) - inf_append_sigcmt() -> bool +ida_ida.inf_append_sigcmt() -> bool -ida_ida.inf_big_arg_align (function) - inf_big_arg_align(cc) -> bool - - @param cc: cm_t - - inf_big_arg_align() -> bool +ida_ida.inf_big_arg_align(*args) -> bool -ida_ida.inf_check_manual_ops (function) - inf_check_manual_ops() -> bool +ida_ida.inf_check_manual_ops() -> bool -ida_ida.inf_check_unicode_strlits (function) - inf_check_unicode_strlits() -> bool +ida_ida.inf_check_unicode_strlits() -> bool -ida_ida.inf_coagulate_code (function) - inf_coagulate_code() -> bool +ida_ida.inf_coagulate_code() -> bool -ida_ida.inf_coagulate_data (function) - inf_coagulate_data() -> bool +ida_ida.inf_coagulate_data() -> bool -ida_ida.inf_compress_idb (function) - inf_compress_idb() -> bool +ida_ida.inf_compress_idb() -> bool -ida_ida.inf_create_all_xrefs (function) - inf_create_all_xrefs() -> bool +ida_ida.inf_create_all_xrefs() -> bool -ida_ida.inf_create_func_from_call (function) - inf_create_func_from_call() -> bool +ida_ida.inf_create_func_from_call() -> bool -ida_ida.inf_create_func_from_ptr (function) - inf_create_func_from_ptr() -> bool +ida_ida.inf_create_func_from_ptr() -> bool -ida_ida.inf_create_func_tails (function) - inf_create_func_tails() -> bool +ida_ida.inf_create_func_tails() -> bool -ida_ida.inf_create_jump_tables (function) - inf_create_jump_tables() -> bool +ida_ida.inf_create_jump_tables() -> bool -ida_ida.inf_create_off_on_dref (function) - inf_create_off_on_dref() -> bool +ida_ida.inf_create_off_on_dref() -> bool -ida_ida.inf_create_off_using_fixup (function) - inf_create_off_using_fixup() -> bool +ida_ida.inf_create_off_using_fixup() -> bool -ida_ida.inf_create_strlit_on_xref (function) - inf_create_strlit_on_xref() -> bool +ida_ida.inf_create_strlit_on_xref() -> bool -ida_ida.inf_data_offset (function) - inf_data_offset() -> bool +ida_ida.inf_data_offset() -> bool -ida_ida.inf_dbg_no_store_path (function) - inf_dbg_no_store_path() -> bool +ida_ida.inf_dbg_no_store_path() -> bool -ida_ida.inf_decode_fpp (function) - inf_decode_fpp() -> bool +ida_ida.inf_decode_fpp() -> bool -ida_ida.inf_del_no_xref_insns (function) - inf_del_no_xref_insns() -> bool +ida_ida.inf_del_no_xref_insns() -> bool -ida_ida.inf_final_pass (function) - inf_final_pass() -> bool +ida_ida.inf_final_pass() -> bool -ida_ida.inf_full_sp_ana (function) - inf_full_sp_ana() -> bool +ida_ida.inf_full_sp_ana() -> bool -ida_ida.inf_gen_assume (function) - inf_gen_assume() -> bool +ida_ida.inf_gen_assume() -> bool -ida_ida.inf_gen_lzero (function) - inf_gen_lzero() -> bool +ida_ida.inf_gen_lzero() -> bool -ida_ida.inf_gen_null (function) - inf_gen_null() -> bool +ida_ida.inf_gen_null() -> bool -ida_ida.inf_gen_org (function) - inf_gen_org() -> bool +ida_ida.inf_gen_org() -> bool -ida_ida.inf_gen_tryblks (function) - inf_gen_tryblks() -> bool +ida_ida.inf_gen_tryblks() -> bool -ida_ida.inf_get_abibits (function) - inf_get_abibits() -> uint32 +ida_ida.inf_get_abibits() -> int -ida_ida.inf_get_af (function) - inf_get_af() -> uint32 +ida_ida.inf_get_af() -> int -ida_ida.inf_get_af2 (function) - inf_get_af2() -> uint32 +ida_ida.inf_get_af2() -> int -ida_ida.inf_get_af2_low (function) - inf_get_af2_low() -> ushort +ida_ida.inf_get_af2_low() -> "ushort" Get/set low 16bit half of inf.af2. -ida_ida.inf_get_af_high (function) - inf_get_af_high() -> ushort +ida_ida.inf_get_af_high() -> "ushort" -ida_ida.inf_get_af_low (function) - inf_get_af_low() -> ushort +ida_ida.inf_get_af_low() -> "ushort" Get/set low/high 16bit halves of inf.af. -ida_ida.inf_get_app_bitness (function) - inf_get_app_bitness() -> uint +ida_ida.inf_get_app_bitness() -> "uint" -ida_ida.inf_get_appcall_options (function) - inf_get_appcall_options() -> uint32 +ida_ida.inf_get_appcall_options() -> int -ida_ida.inf_get_apptype (function) - inf_get_apptype() -> ushort +ida_ida.inf_get_apptype() -> "ushort" -ida_ida.inf_get_asmtype (function) - inf_get_asmtype() -> uchar +ida_ida.inf_get_asmtype() -> "uchar" -ida_ida.inf_get_baseaddr (function) - inf_get_baseaddr() -> uval_t +ida_ida.inf_get_baseaddr() -> int -ida_ida.inf_get_bin_prefix_size (function) - inf_get_bin_prefix_size() -> short +ida_ida.inf_get_bin_prefix_size() -> "short" -ida_ida.inf_get_cc (function) - inf_get_cc(out) -> bool - - @param out: compiler_info_t * +ida_ida.inf_get_cc(out: "compiler_info_t") -> bool -ida_ida.inf_get_cc_cm (function) - inf_get_cc_cm() -> cm_t +ida_ida.inf_get_cc_cm() -> "cm_t" -ida_ida.inf_get_cc_defalign (function) - inf_get_cc_defalign() -> uchar +ida_ida.inf_get_cc_defalign() -> "uchar" -ida_ida.inf_get_cc_id (function) - inf_get_cc_id() -> comp_t +ida_ida.inf_get_cc_id() -> "comp_t" -ida_ida.inf_get_cc_size_b (function) - inf_get_cc_size_b() -> uchar +ida_ida.inf_get_cc_size_b() -> "uchar" -ida_ida.inf_get_cc_size_e (function) - inf_get_cc_size_e() -> uchar +ida_ida.inf_get_cc_size_e() -> "uchar" -ida_ida.inf_get_cc_size_i (function) - inf_get_cc_size_i() -> uchar +ida_ida.inf_get_cc_size_i() -> "uchar" -ida_ida.inf_get_cc_size_l (function) - inf_get_cc_size_l() -> uchar +ida_ida.inf_get_cc_size_l() -> "uchar" -ida_ida.inf_get_cc_size_ldbl (function) - inf_get_cc_size_ldbl() -> uchar +ida_ida.inf_get_cc_size_ldbl() -> "uchar" -ida_ida.inf_get_cc_size_ll (function) - inf_get_cc_size_ll() -> uchar +ida_ida.inf_get_cc_size_ll() -> "uchar" -ida_ida.inf_get_cc_size_s (function) - inf_get_cc_size_s() -> uchar +ida_ida.inf_get_cc_size_s() -> "uchar" -ida_ida.inf_get_cmt_indent (function) - inf_get_cmt_indent() -> uchar +ida_ida.inf_get_cmt_indent() -> "uchar" -ida_ida.inf_get_cmtflg (function) - inf_get_cmtflg() -> uchar +ida_ida.inf_get_cmtflg() -> "uchar" -ida_ida.inf_get_database_change_count (function) - inf_get_database_change_count() -> uint32 +ida_ida.inf_get_database_change_count() -> int -ida_ida.inf_get_datatypes (function) - inf_get_datatypes() -> uval_t +ida_ida.inf_get_datatypes() -> int -ida_ida.inf_get_demname_form (function) - inf_get_demname_form() -> uchar +ida_ida.inf_get_demname_form() -> "uchar" Get DEMNAM_MASK bits of #demnames. -ida_ida.inf_get_demnames (function) - inf_get_demnames() -> uchar +ida_ida.inf_get_demnames() -> "uchar" -ida_ida.inf_get_filetype (function) - inf_get_filetype() -> filetype_t +ida_ida.inf_get_filetype() -> "filetype_t" -ida_ida.inf_get_genflags (function) - inf_get_genflags() -> ushort +ida_ida.inf_get_genflags() -> "ushort" -ida_ida.inf_get_highoff (function) - inf_get_highoff() -> ea_t +ida_ida.inf_get_highoff() -> ida_idaapi.ea_t -ida_ida.inf_get_indent (function) - inf_get_indent() -> uchar +ida_ida.inf_get_indent() -> "uchar" -ida_ida.inf_get_lenxref (function) - inf_get_lenxref() -> ushort +ida_ida.inf_get_lenxref() -> "ushort" -ida_ida.inf_get_lflags (function) - inf_get_lflags() -> uint32 +ida_ida.inf_get_lflags() -> int -ida_ida.inf_get_limiter (function) - inf_get_limiter() -> uchar +ida_ida.inf_get_limiter() -> "uchar" -ida_ida.inf_get_listnames (function) - inf_get_listnames() -> uchar +ida_ida.inf_get_listnames() -> "uchar" -ida_ida.inf_get_long_demnames (function) - inf_get_long_demnames() -> uint32 +ida_ida.inf_get_long_demnames() -> int -ida_ida.inf_get_lowoff (function) - inf_get_lowoff() -> ea_t +ida_ida.inf_get_lowoff() -> ida_idaapi.ea_t -ida_ida.inf_get_main (function) - inf_get_main() -> ea_t +ida_ida.inf_get_main() -> ida_idaapi.ea_t -ida_ida.inf_get_margin (function) - inf_get_margin() -> ushort +ida_ida.inf_get_margin() -> "ushort" -ida_ida.inf_get_max_autoname_len (function) - inf_get_max_autoname_len() -> ushort +ida_ida.inf_get_max_autoname_len() -> "ushort" -ida_ida.inf_get_max_ea (function) - inf_get_max_ea() -> ea_t +ida_ida.inf_get_max_ea() -> ida_idaapi.ea_t -ida_ida.inf_get_maxref (function) - inf_get_maxref() -> uval_t +ida_ida.inf_get_maxref() -> int -ida_ida.inf_get_min_ea (function) - inf_get_min_ea() -> ea_t +ida_ida.inf_get_min_ea() -> ida_idaapi.ea_t -ida_ida.inf_get_nametype (function) - inf_get_nametype() -> char +ida_ida.inf_get_nametype() -> "char" -ida_ida.inf_get_netdelta (function) - inf_get_netdelta() -> sval_t +ida_ida.inf_get_netdelta() -> int -ida_ida.inf_get_omax_ea (function) - inf_get_omax_ea() -> ea_t +ida_ida.inf_get_omax_ea() -> ida_idaapi.ea_t -ida_ida.inf_get_omin_ea (function) - inf_get_omin_ea() -> ea_t +ida_ida.inf_get_omin_ea() -> ida_idaapi.ea_t -ida_ida.inf_get_ostype (function) - inf_get_ostype() -> ushort +ida_ida.inf_get_ostype() -> "ushort" -ida_ida.inf_get_outflags (function) - inf_get_outflags() -> uint32 +ida_ida.inf_get_outflags() -> int -ida_ida.inf_get_pack_mode (function) - inf_get_pack_mode() -> int +ida_ida.inf_get_pack_mode() -> int -ida_ida.inf_get_prefflag (function) - inf_get_prefflag() -> uchar +ida_ida.inf_get_prefflag() -> "uchar" -ida_ida.inf_get_privrange (function) - inf_get_privrange(out) -> bool +ida_ida.inf_get_privrange(*args) -> "range_t" + This function has the following signatures: - @param out: range_t * + 0. inf_get_privrange(out: range_t *) -> bool + 1. inf_get_privrange() -> range_t - inf_get_privrange() -> range_t + # 0: inf_get_privrange(out: range_t *) -> bool + + + # 1: inf_get_privrange() -> range_t -ida_ida.inf_get_privrange_end_ea (function) - inf_get_privrange_end_ea() -> ea_t +ida_ida.inf_get_privrange_end_ea() -> ida_idaapi.ea_t -ida_ida.inf_get_privrange_start_ea (function) - inf_get_privrange_start_ea() -> ea_t +ida_ida.inf_get_privrange_start_ea() -> ida_idaapi.ea_t -ida_ida.inf_get_procname (function) - inf_get_procname() -> str +ida_ida.inf_get_procname() -> str -ida_ida.inf_get_refcmtnum (function) - inf_get_refcmtnum() -> uchar +ida_ida.inf_get_refcmtnum() -> "uchar" -ida_ida.inf_get_short_demnames (function) - inf_get_short_demnames() -> uint32 +ida_ida.inf_get_short_demnames() -> int -ida_ida.inf_get_specsegs (function) - inf_get_specsegs() -> uchar +ida_ida.inf_get_specsegs() -> "uchar" -ida_ida.inf_get_start_cs (function) - inf_get_start_cs() -> sel_t +ida_ida.inf_get_start_cs() -> "sel_t" -ida_ida.inf_get_start_ea (function) - inf_get_start_ea() -> ea_t +ida_ida.inf_get_start_ea() -> ida_idaapi.ea_t -ida_ida.inf_get_start_ip (function) - inf_get_start_ip() -> ea_t +ida_ida.inf_get_start_ip() -> ida_idaapi.ea_t -ida_ida.inf_get_start_sp (function) - inf_get_start_sp() -> ea_t +ida_ida.inf_get_start_sp() -> ida_idaapi.ea_t -ida_ida.inf_get_start_ss (function) - inf_get_start_ss() -> sel_t +ida_ida.inf_get_start_ss() -> "sel_t" -ida_ida.inf_get_strlit_break (function) - inf_get_strlit_break() -> uchar +ida_ida.inf_get_strlit_break() -> "uchar" -ida_ida.inf_get_strlit_flags (function) - inf_get_strlit_flags() -> uchar +ida_ida.inf_get_strlit_flags() -> "uchar" -ida_ida.inf_get_strlit_pref (function) - inf_get_strlit_pref() -> str +ida_ida.inf_get_strlit_pref() -> str -ida_ida.inf_get_strlit_sernum (function) - inf_get_strlit_sernum() -> uval_t +ida_ida.inf_get_strlit_sernum() -> int -ida_ida.inf_get_strlit_zeroes (function) - inf_get_strlit_zeroes() -> char +ida_ida.inf_get_strlit_zeroes() -> "char" -ida_ida.inf_get_strtype (function) - inf_get_strtype() -> int32 +ida_ida.inf_get_strtype() -> int -ida_ida.inf_get_type_xrefnum (function) - inf_get_type_xrefnum() -> uchar +ida_ida.inf_get_type_xrefnum() -> "uchar" -ida_ida.inf_get_version (function) - inf_get_version() -> ushort +ida_ida.inf_get_version() -> "ushort" -ida_ida.inf_get_xrefflag (function) - inf_get_xrefflag() -> uchar +ida_ida.inf_get_xrefflag() -> "uchar" -ida_ida.inf_get_xrefnum (function) - inf_get_xrefnum() -> uchar +ida_ida.inf_get_xrefnum() -> "uchar" -ida_ida.inf_guess_func_type (function) - inf_guess_func_type() -> bool +ida_ida.inf_guess_func_type() -> bool -ida_ida.inf_handle_eh (function) - inf_handle_eh() -> bool +ida_ida.inf_handle_eh() -> bool -ida_ida.inf_handle_rtti (function) - inf_handle_rtti() -> bool +ida_ida.inf_handle_rtti() -> bool -ida_ida.inf_hide_comments (function) - inf_hide_comments() -> bool +ida_ida.inf_hide_comments() -> bool -ida_ida.inf_hide_libfuncs (function) - inf_hide_libfuncs() -> bool +ida_ida.inf_hide_libfuncs() -> bool -ida_ida.inf_huge_arg_align (function) - inf_huge_arg_align(cc) -> bool - - @param cc: cm_t - - inf_huge_arg_align() -> bool +ida_ida.inf_huge_arg_align(*args) -> bool -ida_ida.inf_inc_database_change_count (function) - inf_inc_database_change_count(cnt=1) - - @param cnt: int +ida_ida.inf_inc_database_change_count(cnt: int = 1) -> None -ida_ida.inf_is_16bit (function) - inf_is_16bit() -> bool +ida_ida.inf_is_16bit() -> bool -ida_ida.inf_is_32bit_exactly (function) - inf_is_32bit_exactly() -> bool +ida_ida.inf_is_32bit_exactly() -> bool -ida_ida.inf_is_32bit_or_higher (function) - inf_is_32bit_or_higher() -> bool +ida_ida.inf_is_32bit_or_higher() -> bool -ida_ida.inf_is_64bit (function) - inf_is_64bit() -> bool +ida_ida.inf_is_64bit() -> bool -ida_ida.inf_is_auto_enabled (function) - inf_is_auto_enabled() -> bool +ida_ida.inf_is_auto_enabled() -> bool -ida_ida.inf_is_be (function) - inf_is_be() -> bool +ida_ida.inf_is_be() -> bool -ida_ida.inf_is_dll (function) - inf_is_dll() -> bool +ida_ida.inf_is_dll() -> bool -ida_ida.inf_is_flat_off32 (function) - inf_is_flat_off32() -> bool +ida_ida.inf_is_flat_off32() -> bool -ida_ida.inf_is_graph_view (function) - inf_is_graph_view() -> bool +ida_ida.inf_is_graph_view() -> bool -ida_ida.inf_is_hard_float (function) - inf_is_hard_float() -> bool +ida_ida.inf_is_hard_float() -> bool -ida_ida.inf_is_kernel_mode (function) - inf_is_kernel_mode() -> bool +ida_ida.inf_is_ilp32() -> bool -ida_ida.inf_is_limiter_empty (function) - inf_is_limiter_empty() -> bool +ida_ida.inf_is_kernel_mode() -> bool -ida_ida.inf_is_limiter_thick (function) - inf_is_limiter_thick() -> bool +ida_ida.inf_is_limiter_empty() -> bool -ida_ida.inf_is_limiter_thin (function) - inf_is_limiter_thin() -> bool +ida_ida.inf_is_limiter_thick() -> bool -ida_ida.inf_is_mem_aligned4 (function) - inf_is_mem_aligned4() -> bool +ida_ida.inf_is_limiter_thin() -> bool -ida_ida.inf_is_snapshot (function) - inf_is_snapshot() -> bool +ida_ida.inf_is_mem_aligned4() -> bool -ida_ida.inf_is_wide_high_byte_first (function) - inf_is_wide_high_byte_first() -> bool +ida_ida.inf_is_snapshot() -> bool -ida_ida.inf_like_binary (function) - inf_like_binary() -> bool +ida_ida.inf_is_wide_high_byte_first() -> bool -ida_ida.inf_line_pref_with_seg (function) - inf_line_pref_with_seg() -> bool +ida_ida.inf_like_binary() -> bool -ida_ida.inf_loading_idc (function) - inf_loading_idc() -> bool +ida_ida.inf_line_pref_with_seg() -> bool -ida_ida.inf_macros_enabled (function) - inf_macros_enabled() -> bool +ida_ida.inf_loading_idc() -> bool -ida_ida.inf_map_stkargs (function) - inf_map_stkargs() -> bool +ida_ida.inf_macros_enabled() -> bool -ida_ida.inf_mark_code (function) - inf_mark_code() -> bool +ida_ida.inf_map_stkargs() -> bool -ida_ida.inf_merge_strlits (function) - inf_merge_strlits() -> bool +ida_ida.inf_mark_code() -> bool -ida_ida.inf_no_store_user_info (function) - inf_no_store_user_info() -> bool +ida_ida.inf_merge_strlits() -> bool -ida_ida.inf_noflow_to_data (function) - inf_noflow_to_data() -> bool +ida_ida.inf_no_store_user_info() -> bool -ida_ida.inf_noret_ana (function) - inf_noret_ana() -> bool +ida_ida.inf_noflow_to_data() -> bool -ida_ida.inf_op_offset (function) - inf_op_offset() -> bool +ida_ida.inf_noret_ana() -> bool -ida_ida.inf_pack_idb (function) - inf_pack_idb() -> bool +ida_ida.inf_op_offset() -> bool -ida_ida.inf_pack_stkargs (function) - inf_pack_stkargs(cc) -> bool - - @param cc: cm_t - - inf_pack_stkargs() -> bool +ida_ida.inf_pack_idb() -> bool -ida_ida.inf_postinc_strlit_sernum (function) - inf_postinc_strlit_sernum(cnt=1) -> uval_t - - @param cnt: uval_t +ida_ida.inf_pack_stkargs(*args) -> bool -ida_ida.inf_prefix_show_funcoff (function) - inf_prefix_show_funcoff() -> bool +ida_ida.inf_postinc_strlit_sernum(cnt: int = 1) -> int -ida_ida.inf_prefix_show_segaddr (function) - inf_prefix_show_segaddr() -> bool +ida_ida.inf_prefix_show_funcoff() -> bool -ida_ida.inf_prefix_show_stack (function) - inf_prefix_show_stack() -> bool +ida_ida.inf_prefix_show_segaddr() -> bool -ida_ida.inf_prefix_truncate_opcode_bytes (function) - inf_prefix_truncate_opcode_bytes() -> bool +ida_ida.inf_prefix_show_stack() -> bool -ida_ida.inf_propagate_regargs (function) - inf_propagate_regargs() -> bool +ida_ida.inf_prefix_truncate_opcode_bytes() -> bool -ida_ida.inf_propagate_stkargs (function) - inf_propagate_stkargs() -> bool +ida_ida.inf_propagate_regargs() -> bool -ida_ida.inf_readonly_idb (function) - inf_readonly_idb() -> bool +ida_ida.inf_propagate_stkargs() -> bool -ida_ida.inf_rename_jumpfunc (function) - inf_rename_jumpfunc() -> bool +ida_ida.inf_readonly_idb() -> bool -ida_ida.inf_rename_nullsub (function) - inf_rename_nullsub() -> bool +ida_ida.inf_rename_jumpfunc() -> bool -ida_ida.inf_set_32bit (function) - inf_set_32bit(_v=True) -> bool - - @param _v: bool +ida_ida.inf_rename_nullsub() -> bool -ida_ida.inf_set_64bit (function) - inf_set_64bit(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_32bit(_v: bool = True) -> bool -ida_ida.inf_set_abi_set_by_user (function) - inf_set_abi_set_by_user(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_64bit(_v: bool = True) -> bool -ida_ida.inf_set_abibits (function) - inf_set_abibits(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_abi_set_by_user(_v: bool = True) -> bool -ida_ida.inf_set_af (function) - inf_set_af(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_abibits(_v: int) -> bool -ida_ida.inf_set_af2 (function) - inf_set_af2(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_af(_v: int) -> bool -ida_ida.inf_set_af2_low (function) - inf_set_af2_low(saf) - - @param saf: ushort +ida_ida.inf_set_af2(_v: int) -> bool -ida_ida.inf_set_af_high (function) - inf_set_af_high(saf2) - - @param saf2: ushort +ida_ida.inf_set_af2_low(saf: "ushort") -> None -ida_ida.inf_set_af_low (function) - inf_set_af_low(saf) - - @param saf: ushort +ida_ida.inf_set_af_high(saf2: "ushort") -> None -ida_ida.inf_set_allow_non_matched_ops (function) - inf_set_allow_non_matched_ops(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_af_low(saf: "ushort") -> None -ida_ida.inf_set_allow_sigmulti (function) - inf_set_allow_sigmulti(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_allow_non_matched_ops(_v: bool = True) -> bool -ida_ida.inf_set_app_bitness (function) - inf_set_app_bitness(bitness) - - @param bitness: uint +ida_ida.inf_set_allow_sigmulti(_v: bool = True) -> bool -ida_ida.inf_set_appcall_options (function) - inf_set_appcall_options(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_app_bitness(bitness: "uint") -> None -ida_ida.inf_set_append_sigcmt (function) - inf_set_append_sigcmt(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_appcall_options(_v: int) -> bool -ida_ida.inf_set_apptype (function) - inf_set_apptype(_v) -> bool - - @param _v: ushort +ida_ida.inf_set_append_sigcmt(_v: bool = True) -> bool -ida_ida.inf_set_asmtype (function) - inf_set_asmtype(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_apptype(_v: "ushort") -> bool -ida_ida.inf_set_auto_enabled (function) - inf_set_auto_enabled(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_asmtype(_v: "uchar") -> bool -ida_ida.inf_set_baseaddr (function) - inf_set_baseaddr(_v) -> bool - - @param _v: uval_t +ida_ida.inf_set_auto_enabled(_v: bool = True) -> bool -ida_ida.inf_set_be (function) - inf_set_be(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_baseaddr(_v: int) -> bool -ida_ida.inf_set_big_arg_align (function) - inf_set_big_arg_align(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_be(_v: bool = True) -> bool -ida_ida.inf_set_bin_prefix_size (function) - inf_set_bin_prefix_size(_v) -> bool - - @param _v: short +ida_ida.inf_set_big_arg_align(_v: bool = True) -> bool -ida_ida.inf_set_cc (function) - inf_set_cc(_v) -> bool - - @param _v: compiler_info_t const & +ida_ida.inf_set_bin_prefix_size(_v: "short") -> bool -ida_ida.inf_set_cc_cm (function) - inf_set_cc_cm(_v) -> bool - - @param _v: cm_t +ida_ida.inf_set_cc(_v: "compiler_info_t") -> bool -ida_ida.inf_set_cc_defalign (function) - inf_set_cc_defalign(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_cm(_v: "cm_t") -> bool -ida_ida.inf_set_cc_id (function) - inf_set_cc_id(_v) -> bool - - @param _v: comp_t +ida_ida.inf_set_cc_defalign(_v: "uchar") -> bool -ida_ida.inf_set_cc_size_b (function) - inf_set_cc_size_b(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_id(_v: "comp_t") -> bool -ida_ida.inf_set_cc_size_e (function) - inf_set_cc_size_e(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_size_b(_v: "uchar") -> bool -ida_ida.inf_set_cc_size_i (function) - inf_set_cc_size_i(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_size_e(_v: "uchar") -> bool -ida_ida.inf_set_cc_size_l (function) - inf_set_cc_size_l(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_size_i(_v: "uchar") -> bool -ida_ida.inf_set_cc_size_ldbl (function) - inf_set_cc_size_ldbl(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_size_l(_v: "uchar") -> bool -ida_ida.inf_set_cc_size_ll (function) - inf_set_cc_size_ll(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_size_ldbl(_v: "uchar") -> bool -ida_ida.inf_set_cc_size_s (function) - inf_set_cc_size_s(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cc_size_ll(_v: "uchar") -> bool -ida_ida.inf_set_check_manual_ops (function) - inf_set_check_manual_ops(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_cc_size_s(_v: "uchar") -> bool -ida_ida.inf_set_check_unicode_strlits (function) - inf_set_check_unicode_strlits(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_check_manual_ops(_v: bool = True) -> bool -ida_ida.inf_set_cmt_indent (function) - inf_set_cmt_indent(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_check_unicode_strlits(_v: bool = True) -> bool -ida_ida.inf_set_cmtflg (function) - inf_set_cmtflg(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_cmt_indent(_v: "uchar") -> bool -ida_ida.inf_set_coagulate_code (function) - inf_set_coagulate_code(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_cmtflg(_v: "uchar") -> bool -ida_ida.inf_set_coagulate_data (function) - inf_set_coagulate_data(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_coagulate_code(_v: bool = True) -> bool -ida_ida.inf_set_compress_idb (function) - inf_set_compress_idb(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_coagulate_data(_v: bool = True) -> bool -ida_ida.inf_set_create_all_xrefs (function) - inf_set_create_all_xrefs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_compress_idb(_v: bool = True) -> bool -ida_ida.inf_set_create_func_from_call (function) - inf_set_create_func_from_call(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_all_xrefs(_v: bool = True) -> bool -ida_ida.inf_set_create_func_from_ptr (function) - inf_set_create_func_from_ptr(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_func_from_call(_v: bool = True) -> bool -ida_ida.inf_set_create_func_tails (function) - inf_set_create_func_tails(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_func_from_ptr(_v: bool = True) -> bool -ida_ida.inf_set_create_jump_tables (function) - inf_set_create_jump_tables(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_func_tails(_v: bool = True) -> bool -ida_ida.inf_set_create_off_on_dref (function) - inf_set_create_off_on_dref(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_jump_tables(_v: bool = True) -> bool -ida_ida.inf_set_create_off_using_fixup (function) - inf_set_create_off_using_fixup(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_off_on_dref(_v: bool = True) -> bool -ida_ida.inf_set_create_strlit_on_xref (function) - inf_set_create_strlit_on_xref(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_off_using_fixup(_v: bool = True) -> bool -ida_ida.inf_set_data_offset (function) - inf_set_data_offset(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_create_strlit_on_xref(_v: bool = True) -> bool -ida_ida.inf_set_database_change_count (function) - inf_set_database_change_count(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_data_offset(_v: bool = True) -> bool -ida_ida.inf_set_datatypes (function) - inf_set_datatypes(_v) -> bool - - @param _v: uval_t +ida_ida.inf_set_database_change_count(_v: int) -> bool -ida_ida.inf_set_dbg_no_store_path (function) - inf_set_dbg_no_store_path(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_datatypes(_v: int) -> bool -ida_ida.inf_set_decode_fpp (function) - inf_set_decode_fpp(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_dbg_no_store_path(_v: bool = True) -> bool -ida_ida.inf_set_del_no_xref_insns (function) - inf_set_del_no_xref_insns(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_decode_fpp(_v: bool = True) -> bool -ida_ida.inf_set_demnames (function) - inf_set_demnames(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_del_no_xref_insns(_v: bool = True) -> bool -ida_ida.inf_set_dll (function) - inf_set_dll(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_demnames(_v: "uchar") -> bool -ida_ida.inf_set_filetype (function) - inf_set_filetype(_v) -> bool - - @param _v: enum filetype_t +ida_ida.inf_set_dll(_v: bool = True) -> bool -ida_ida.inf_set_final_pass (function) - inf_set_final_pass(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_filetype(_v: "filetype_t") -> bool -ida_ida.inf_set_flat_off32 (function) - inf_set_flat_off32(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_final_pass(_v: bool = True) -> bool -ida_ida.inf_set_full_sp_ana (function) - inf_set_full_sp_ana(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_flat_off32(_v: bool = True) -> bool -ida_ida.inf_set_gen_assume (function) - inf_set_gen_assume(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_full_sp_ana(_v: bool = True) -> bool -ida_ida.inf_set_gen_lzero (function) - inf_set_gen_lzero(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_gen_assume(_v: bool = True) -> bool -ida_ida.inf_set_gen_null (function) - inf_set_gen_null(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_gen_lzero(_v: bool = True) -> bool -ida_ida.inf_set_gen_org (function) - inf_set_gen_org(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_gen_null(_v: bool = True) -> bool -ida_ida.inf_set_gen_tryblks (function) - inf_set_gen_tryblks(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_gen_org(_v: bool = True) -> bool -ida_ida.inf_set_genflags (function) - inf_set_genflags(_v) -> bool - - @param _v: ushort +ida_ida.inf_set_gen_tryblks(_v: bool = True) -> bool -ida_ida.inf_set_graph_view (function) - inf_set_graph_view(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_genflags(_v: "ushort") -> bool -ida_ida.inf_set_guess_func_type (function) - inf_set_guess_func_type(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_graph_view(_v: bool = True) -> bool -ida_ida.inf_set_handle_eh (function) - inf_set_handle_eh(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_guess_func_type(_v: bool = True) -> bool -ida_ida.inf_set_handle_rtti (function) - inf_set_handle_rtti(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_handle_eh(_v: bool = True) -> bool -ida_ida.inf_set_hard_float (function) - inf_set_hard_float(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_handle_rtti(_v: bool = True) -> bool -ida_ida.inf_set_hide_comments (function) - inf_set_hide_comments(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_hard_float(_v: bool = True) -> bool -ida_ida.inf_set_hide_libfuncs (function) - inf_set_hide_libfuncs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_hide_comments(_v: bool = True) -> bool -ida_ida.inf_set_highoff (function) - inf_set_highoff(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_hide_libfuncs(_v: bool = True) -> bool -ida_ida.inf_set_huge_arg_align (function) - inf_set_huge_arg_align(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_highoff(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_indent (function) - inf_set_indent(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_huge_arg_align(_v: bool = True) -> bool -ida_ida.inf_set_kernel_mode (function) - inf_set_kernel_mode(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_ilp32(_v: bool = True) -> bool -ida_ida.inf_set_lenxref (function) - inf_set_lenxref(_v) -> bool - - @param _v: ushort +ida_ida.inf_set_indent(_v: "uchar") -> bool -ida_ida.inf_set_lflags (function) - inf_set_lflags(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_kernel_mode(_v: bool = True) -> bool -ida_ida.inf_set_limiter (function) - inf_set_limiter(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_lenxref(_v: "ushort") -> bool -ida_ida.inf_set_limiter_empty (function) - inf_set_limiter_empty(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_lflags(_v: int) -> bool -ida_ida.inf_set_limiter_thick (function) - inf_set_limiter_thick(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_limiter(_v: "uchar") -> bool -ida_ida.inf_set_limiter_thin (function) - inf_set_limiter_thin(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_limiter_empty(_v: bool = True) -> bool -ida_ida.inf_set_line_pref_with_seg (function) - inf_set_line_pref_with_seg(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_limiter_thick(_v: bool = True) -> bool -ida_ida.inf_set_listnames (function) - inf_set_listnames(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_limiter_thin(_v: bool = True) -> bool -ida_ida.inf_set_loading_idc (function) - inf_set_loading_idc(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_line_pref_with_seg(_v: bool = True) -> bool -ida_ida.inf_set_long_demnames (function) - inf_set_long_demnames(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_listnames(_v: "uchar") -> bool -ida_ida.inf_set_lowoff (function) - inf_set_lowoff(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_loading_idc(_v: bool = True) -> bool -ida_ida.inf_set_macros_enabled (function) - inf_set_macros_enabled(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_long_demnames(_v: int) -> bool -ida_ida.inf_set_main (function) - inf_set_main(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_lowoff(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_map_stkargs (function) - inf_set_map_stkargs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_macros_enabled(_v: bool = True) -> bool -ida_ida.inf_set_margin (function) - inf_set_margin(_v) -> bool - - @param _v: ushort +ida_ida.inf_set_main(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_mark_code (function) - inf_set_mark_code(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_map_stkargs(_v: bool = True) -> bool -ida_ida.inf_set_max_autoname_len (function) - inf_set_max_autoname_len(_v) -> bool - - @param _v: ushort +ida_ida.inf_set_margin(_v: "ushort") -> bool -ida_ida.inf_set_max_ea (function) - inf_set_max_ea(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_mark_code(_v: bool = True) -> bool -ida_ida.inf_set_maxref (function) - inf_set_maxref(_v) -> bool - - @param _v: uval_t +ida_ida.inf_set_max_autoname_len(_v: "ushort") -> bool -ida_ida.inf_set_mem_aligned4 (function) - inf_set_mem_aligned4(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_max_ea(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_merge_strlits (function) - inf_set_merge_strlits(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_maxref(_v: int) -> bool -ida_ida.inf_set_min_ea (function) - inf_set_min_ea(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_mem_aligned4(_v: bool = True) -> bool -ida_ida.inf_set_nametype (function) - inf_set_nametype(_v) -> bool - - @param _v: char +ida_ida.inf_set_merge_strlits(_v: bool = True) -> bool -ida_ida.inf_set_netdelta (function) - inf_set_netdelta(_v) -> bool - - @param _v: sval_t +ida_ida.inf_set_min_ea(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_no_store_user_info (function) - inf_set_no_store_user_info(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_nametype(_v: "char") -> bool -ida_ida.inf_set_noflow_to_data (function) - inf_set_noflow_to_data(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_netdelta(_v: int) -> bool -ida_ida.inf_set_noret_ana (function) - inf_set_noret_ana(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_no_store_user_info(_v: bool = True) -> bool -ida_ida.inf_set_omax_ea (function) - inf_set_omax_ea(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_noflow_to_data(_v: bool = True) -> bool -ida_ida.inf_set_omin_ea (function) - inf_set_omin_ea(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_noret_ana(_v: bool = True) -> bool -ida_ida.inf_set_op_offset (function) - inf_set_op_offset(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_omax_ea(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_ostype (function) - inf_set_ostype(_v) -> bool - - @param _v: ushort +ida_ida.inf_set_omin_ea(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_outflags (function) - inf_set_outflags(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_op_offset(_v: bool = True) -> bool -ida_ida.inf_set_pack_idb (function) - inf_set_pack_idb(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_ostype(_v: "ushort") -> bool -ida_ida.inf_set_pack_mode (function) - inf_set_pack_mode(pack_mode) -> int - - @param pack_mode: int +ida_ida.inf_set_outflags(_v: int) -> bool -ida_ida.inf_set_pack_stkargs (function) - inf_set_pack_stkargs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_pack_idb(_v: bool = True) -> bool -ida_ida.inf_set_prefflag (function) - inf_set_prefflag(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_pack_mode(pack_mode: int) -> int -ida_ida.inf_set_prefix_show_funcoff (function) - inf_set_prefix_show_funcoff(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_pack_stkargs(_v: bool = True) -> bool -ida_ida.inf_set_prefix_show_segaddr (function) - inf_set_prefix_show_segaddr(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_prefflag(_v: "uchar") -> bool -ida_ida.inf_set_prefix_show_stack (function) - inf_set_prefix_show_stack(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_prefix_show_funcoff(_v: bool = True) -> bool -ida_ida.inf_set_prefix_truncate_opcode_bytes (function) - inf_set_prefix_truncate_opcode_bytes(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_prefix_show_segaddr(_v: bool = True) -> bool -ida_ida.inf_set_privrange (function) - inf_set_privrange(_v) -> bool - - @param _v: range_t const & +ida_ida.inf_set_prefix_show_stack(_v: bool = True) -> bool -ida_ida.inf_set_privrange_end_ea (function) - inf_set_privrange_end_ea(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_prefix_truncate_opcode_bytes(_v: bool = True) -> bool -ida_ida.inf_set_privrange_start_ea (function) - inf_set_privrange_start_ea(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_privrange(_v: "range_t") -> bool -ida_ida.inf_set_procname (function) - inf_set_procname(_v, len=size_t(-1)) -> bool - - @param _v: char const * - @param len: size_t +ida_ida.inf_set_privrange_end_ea(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_propagate_regargs (function) - inf_set_propagate_regargs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_privrange_start_ea(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_propagate_stkargs (function) - inf_set_propagate_stkargs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_procname(*args) -> bool -ida_ida.inf_set_readonly_idb (function) - inf_set_readonly_idb(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_propagate_regargs(_v: bool = True) -> bool -ida_ida.inf_set_refcmtnum (function) - inf_set_refcmtnum(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_propagate_stkargs(_v: bool = True) -> bool -ida_ida.inf_set_rename_jumpfunc (function) - inf_set_rename_jumpfunc(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_readonly_idb(_v: bool = True) -> bool -ida_ida.inf_set_rename_nullsub (function) - inf_set_rename_nullsub(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_refcmtnum(_v: "uchar") -> bool -ida_ida.inf_set_short_demnames (function) - inf_set_short_demnames(_v) -> bool - - @param _v: uint32 +ida_ida.inf_set_rename_jumpfunc(_v: bool = True) -> bool -ida_ida.inf_set_should_create_stkvars (function) - inf_set_should_create_stkvars(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_rename_nullsub(_v: bool = True) -> bool -ida_ida.inf_set_should_trace_sp (function) - inf_set_should_trace_sp(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_short_demnames(_v: int) -> bool -ida_ida.inf_set_show_all_comments (function) - inf_set_show_all_comments(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_should_create_stkvars(_v: bool = True) -> bool -ida_ida.inf_set_show_auto (function) - inf_set_show_auto(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_should_trace_sp(_v: bool = True) -> bool -ida_ida.inf_set_show_hidden_funcs (function) - inf_set_show_hidden_funcs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_all_comments(_v: bool = True) -> bool -ida_ida.inf_set_show_hidden_insns (function) - inf_set_show_hidden_insns(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_auto(_v: bool = True) -> bool -ida_ida.inf_set_show_hidden_segms (function) - inf_set_show_hidden_segms(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_hidden_funcs(_v: bool = True) -> bool -ida_ida.inf_set_show_line_pref (function) - inf_set_show_line_pref(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_hidden_insns(_v: bool = True) -> bool -ida_ida.inf_set_show_repeatables (function) - inf_set_show_repeatables(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_hidden_segms(_v: bool = True) -> bool -ida_ida.inf_set_show_src_linnum (function) - inf_set_show_src_linnum(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_line_pref(_v: bool = True) -> bool -ida_ida.inf_set_show_void (function) - inf_set_show_void(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_repeatables(_v: bool = True) -> bool -ida_ida.inf_set_show_xref_fncoff (function) - inf_set_show_xref_fncoff(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_src_linnum(_v: bool = True) -> bool -ida_ida.inf_set_show_xref_seg (function) - inf_set_show_xref_seg(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_void(_v: bool = True) -> bool -ida_ida.inf_set_show_xref_tmarks (function) - inf_set_show_xref_tmarks(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_xref_fncoff(_v: bool = True) -> bool -ida_ida.inf_set_show_xref_val (function) - inf_set_show_xref_val(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_xref_seg(_v: bool = True) -> bool -ida_ida.inf_set_snapshot (function) - inf_set_snapshot(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_show_xref_tmarks(_v: bool = True) -> bool -ida_ida.inf_set_specsegs (function) - inf_set_specsegs(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_show_xref_val(_v: bool = True) -> bool -ida_ida.inf_set_stack_ldbl (function) - inf_set_stack_ldbl(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_snapshot(_v: bool = True) -> bool -ida_ida.inf_set_stack_varargs (function) - inf_set_stack_varargs(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_specsegs(_v: "uchar") -> bool -ida_ida.inf_set_start_cs (function) - inf_set_start_cs(_v) -> bool - - @param _v: sel_t +ida_ida.inf_set_stack_ldbl(_v: bool = True) -> bool -ida_ida.inf_set_start_ea (function) - inf_set_start_ea(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_stack_varargs(_v: bool = True) -> bool -ida_ida.inf_set_start_ip (function) - inf_set_start_ip(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_start_cs(_v: "sel_t") -> bool -ida_ida.inf_set_start_sp (function) - inf_set_start_sp(_v) -> bool - - @param _v: ea_t +ida_ida.inf_set_start_ea(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_start_ss (function) - inf_set_start_ss(_v) -> bool - - @param _v: sel_t +ida_ida.inf_set_start_ip(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_strlit_autocmt (function) - inf_set_strlit_autocmt(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_start_sp(_v: ida_idaapi.ea_t) -> bool -ida_ida.inf_set_strlit_break (function) - inf_set_strlit_break(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_start_ss(_v: "sel_t") -> bool -ida_ida.inf_set_strlit_flags (function) - inf_set_strlit_flags(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_strlit_autocmt(_v: bool = True) -> bool -ida_ida.inf_set_strlit_name_bit (function) - inf_set_strlit_name_bit(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_strlit_break(_v: "uchar") -> bool -ida_ida.inf_set_strlit_names (function) - inf_set_strlit_names(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_strlit_flags(_v: "uchar") -> bool -ida_ida.inf_set_strlit_pref (function) - inf_set_strlit_pref(_v, len=size_t(-1)) -> bool - - @param _v: char const * - @param len: size_t +ida_ida.inf_set_strlit_name_bit(_v: bool = True) -> bool -ida_ida.inf_set_strlit_savecase (function) - inf_set_strlit_savecase(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_strlit_names(_v: bool = True) -> bool -ida_ida.inf_set_strlit_serial_names (function) - inf_set_strlit_serial_names(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_strlit_pref(*args) -> bool -ida_ida.inf_set_strlit_sernum (function) - inf_set_strlit_sernum(_v) -> bool - - @param _v: uval_t +ida_ida.inf_set_strlit_savecase(_v: bool = True) -> bool -ida_ida.inf_set_strlit_zeroes (function) - inf_set_strlit_zeroes(_v) -> bool - - @param _v: char +ida_ida.inf_set_strlit_serial_names(_v: bool = True) -> bool -ida_ida.inf_set_strtype (function) - inf_set_strtype(_v) -> bool - - @param _v: int32 +ida_ida.inf_set_strlit_sernum(_v: int) -> bool -ida_ida.inf_set_trace_flow (function) - inf_set_trace_flow(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_strlit_zeroes(_v: "char") -> bool -ida_ida.inf_set_truncate_on_del (function) - inf_set_truncate_on_del(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_strtype(_v: int) -> bool -ida_ida.inf_set_type_xrefnum (function) - inf_set_type_xrefnum(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_trace_flow(_v: bool = True) -> bool -ida_ida.inf_set_unicode_strlits (function) - inf_set_unicode_strlits(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_truncate_on_del(_v: bool = True) -> bool -ida_ida.inf_set_use_allasm (function) - inf_set_use_allasm(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_type_xrefnum(_v: "uchar") -> bool -ida_ida.inf_set_use_flirt (function) - inf_set_use_flirt(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_unicode_strlits(_v: bool = True) -> bool -ida_ida.inf_set_use_gcc_layout (function) - inf_set_use_gcc_layout(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_use_allasm(_v: bool = True) -> bool -ida_ida.inf_set_version (function) - inf_set_version(_v) -> bool - - @param _v: ushort +ida_ida.inf_set_use_flirt(_v: bool = True) -> bool -ida_ida.inf_set_wide_high_byte_first (function) - inf_set_wide_high_byte_first(_v=True) -> bool - - @param _v: bool +ida_ida.inf_set_use_gcc_layout(_v: bool = True) -> bool -ida_ida.inf_set_xrefflag (function) - inf_set_xrefflag(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_version(_v: "ushort") -> bool -ida_ida.inf_set_xrefnum (function) - inf_set_xrefnum(_v) -> bool - - @param _v: uchar +ida_ida.inf_set_wide_high_byte_first(_v: bool = True) -> bool + +ida_ida.inf_set_xrefflag(_v: "uchar") -> bool + +ida_ida.inf_set_xrefnum(_v: "uchar") -> bool -ida_ida.inf_should_create_stkvars (function) - inf_should_create_stkvars() -> bool +ida_ida.inf_should_create_stkvars() -> bool -ida_ida.inf_should_trace_sp (function) - inf_should_trace_sp() -> bool +ida_ida.inf_should_trace_sp() -> bool -ida_ida.inf_show_all_comments (function) - inf_show_all_comments() -> bool +ida_ida.inf_show_all_comments() -> bool -ida_ida.inf_show_auto (function) - inf_show_auto() -> bool +ida_ida.inf_show_auto() -> bool -ida_ida.inf_show_hidden_funcs (function) - inf_show_hidden_funcs() -> bool +ida_ida.inf_show_hidden_funcs() -> bool -ida_ida.inf_show_hidden_insns (function) - inf_show_hidden_insns() -> bool +ida_ida.inf_show_hidden_insns() -> bool -ida_ida.inf_show_hidden_segms (function) - inf_show_hidden_segms() -> bool +ida_ida.inf_show_hidden_segms() -> bool -ida_ida.inf_show_line_pref (function) - inf_show_line_pref() -> bool +ida_ida.inf_show_line_pref() -> bool -ida_ida.inf_show_repeatables (function) - inf_show_repeatables() -> bool +ida_ida.inf_show_repeatables() -> bool -ida_ida.inf_show_src_linnum (function) - inf_show_src_linnum() -> bool +ida_ida.inf_show_src_linnum() -> bool -ida_ida.inf_show_void (function) - inf_show_void() -> bool +ida_ida.inf_show_void() -> bool -ida_ida.inf_show_xref_fncoff (function) - inf_show_xref_fncoff() -> bool +ida_ida.inf_show_xref_fncoff() -> bool -ida_ida.inf_show_xref_seg (function) - inf_show_xref_seg() -> bool +ida_ida.inf_show_xref_seg() -> bool -ida_ida.inf_show_xref_tmarks (function) - inf_show_xref_tmarks() -> bool +ida_ida.inf_show_xref_tmarks() -> bool -ida_ida.inf_show_xref_val (function) - inf_show_xref_val() -> bool +ida_ida.inf_show_xref_val() -> bool -ida_ida.inf_stack_ldbl (function) - inf_stack_ldbl() -> bool +ida_ida.inf_stack_ldbl() -> bool -ida_ida.inf_stack_varargs (function) - inf_stack_varargs() -> bool +ida_ida.inf_stack_varargs() -> bool -ida_ida.inf_strlit_autocmt (function) - inf_strlit_autocmt() -> bool +ida_ida.inf_strlit_autocmt() -> bool -ida_ida.inf_strlit_name_bit (function) - inf_strlit_name_bit() -> bool +ida_ida.inf_strlit_name_bit() -> bool -ida_ida.inf_strlit_names (function) - inf_strlit_names() -> bool +ida_ida.inf_strlit_names() -> bool -ida_ida.inf_strlit_savecase (function) - inf_strlit_savecase() -> bool +ida_ida.inf_strlit_savecase() -> bool -ida_ida.inf_strlit_serial_names (function) - inf_strlit_serial_names() -> bool +ida_ida.inf_strlit_serial_names() -> bool -ida_ida.inf_test_mode (function) - inf_test_mode() -> bool +ida_ida.inf_test_mode() -> bool -ida_ida.inf_trace_flow (function) - inf_trace_flow() -> bool +ida_ida.inf_trace_flow() -> bool -ida_ida.inf_truncate_on_del (function) - inf_truncate_on_del() -> bool +ida_ida.inf_truncate_on_del() -> bool -ida_ida.inf_unicode_strlits (function) - inf_unicode_strlits() -> bool +ida_ida.inf_unicode_strlits() -> bool -ida_ida.inf_use_allasm (function) - inf_use_allasm() -> bool +ida_ida.inf_use_allasm() -> bool -ida_ida.inf_use_flirt (function) - inf_use_flirt() -> bool +ida_ida.inf_use_flirt() -> bool -ida_ida.inf_use_gcc_layout (function) - inf_use_gcc_layout() -> bool +ida_ida.inf_use_gcc_layout() -> bool -ida_ida.is_database_busy (function) - is_database_busy() -> bool - Check if the database is busy (e.g. performing some critical operations and - cannot be safely accessed) +ida_ida.is_database_busy() -> bool + Check if the database is busy (e.g. performing some critical operations and cannot be safely accessed) + -ida_ida.is_filetype_like_binary (function) - is_filetype_like_binary(ft) -> bool +ida_ida.is_filetype_like_binary(ft: "filetype_t") -> bool Is unstructured input file? - - @param ft: (C++: filetype_t) enum filetype_t -ida_ida.move_privrange (function) - move_privrange(new_privrange_start) -> bool - Move privrange to the specified address - - @param new_privrange_start: (C++: ea_t) new start address of the privrange - @return: success +ida_ida.move_privrange(new_privrange_start: ida_idaapi.ea_t) -> bool + Move privrange to the specified address + + @param new_privrange_start: new start address of the privrange + @returns success -ida_ida.switch_dbctx (function) - switch_dbctx(idx) -> dbctx_t * - Switch to the database with the provided context ID - - @param idx: (C++: size_t) the index of the database to switch to - @return: the current dbctx_t instance or nullptr +ida_ida.switch_dbctx(idx: "size_t") -> "dbctx_t *" + Switch to the database with the provided context ID + + @param idx: the index of the database to switch to + @returns the current dbctx_t instance or nullptr -ida_ida.to_ea (function) - to_ea(reg_cs, reg_ip) -> ea_t +ida_ida.to_ea(reg_cs: "sel_t", reg_ip: int) -> ida_idaapi.ea_t Convert (sel,off) value to a linear address. - - @param reg_cs: (C++: sel_t) - @param reg_ip: (C++: uval_t) -ida_ida.validate_idb (function) - validate_idb(vld_flags=0) -> size_t - Validate the database - - @param vld_flags: (C++: uint32) combination of VLD_.. constants - @return: number of corrupted/fixed records +ida_ida.validate_idb(vld_flags: int = 0) -> "size_t" + Validate the database + + @param vld_flags: combination of VLD_.. constants + @returns number of corrupted/fixed records -ida_idaapi (module) +ida_idaapi -ida_idaapi.IDAPython_ExecScript (function) +ida_idaapi.IDAPython_ExecScript(path, g, print_error = True) Run the specified script. This function is used by the low-level plugin code. -ida_idaapi.IDAPython_ExecSystem (function) +ida_idaapi.IDAPython_ExecSystem(cmd) Executes a command with popen(). -ida_idaapi.IDAPython_FormatExc (function) +ida_idaapi.IDAPython_FormatExc(etype, value = None, tb = None, limit = None) This function is used to format an exception given the values returned by a PyErr_Fetch() -ida_idaapi.IDAPython_LoadProcMod (function) +ida_idaapi.IDAPython_GetDocstrings(obj) + +ida_idaapi.IDAPython_GetDocstrings._dedent(source: str) -> str + +ida_idaapi.IDAPython_GetDocstrings._nodes(tree) + Returns the list of all nodes in tree's body. + +ida_idaapi.IDAPython_GetDocstrings._nodes_iter(tree) + +ida_idaapi.IDAPython_GetDocstrings._pairwise_longest(iterable) + s -> (s0,s1), (s1,s2), (s2, s3), ..., (sN, None) + +ida_idaapi.IDAPython_GetDocstrings._walk_tree(tree) + +ida_idaapi.IDAPython_LoadProcMod(path, g, print_error = True) Load processor module. -ida_idaapi.IDAPython_UnLoadProcMod (function) +ida_idaapi.IDAPython_UnLoadProcMod(script, g, print_error = True) Unload processor module. -ida_idaapi.IDAPython_displayhook (class) +ida_idaapi.IDAPython_displayhook -ida_idaapi.IDAPython_displayhook.__init__ (method) +ida_idaapi.IDAPython_displayhook.__init__(self) -ida_idaapi.IDAPython_displayhook._print_hex (method) +ida_idaapi.IDAPython_displayhook._print_hex(self, x) -ida_idaapi.IDAPython_displayhook.displayhook (method) +ida_idaapi.IDAPython_displayhook.displayhook(self, item) -ida_idaapi.IDAPython_displayhook.format_item (method) +ida_idaapi.IDAPython_displayhook.displayhook_format(self, item) -ida_idaapi.IDAPython_displayhook.format_seq (method) +ida_idaapi.IDAPython_displayhook.format_item(self, num_printer, storage, item) -ida_idaapi.NW_CLOSEIDB (variable) +ida_idaapi.IDAPython_displayhook.format_seq(self, num_printer, storage, item, opn, cls) + +ida_idaapi.NW_CLOSEIDB Notify when the database is closed. Its callback is of the form: def notify_when_callback(nw_code) -ida_idaapi.NW_INITIDA (variable) +ida_idaapi.NW_INITIDA Notify when the IDA starts. Its callback is of the form: def notify_when_callback(nw_code) -ida_idaapi.NW_OPENIDB (variable) +ida_idaapi.NW_OPENIDB Notify when the database is opened. Its callback is of the form: def notify_when_callback(nw_code, is_old_database) -ida_idaapi.NW_REMOVE (variable) +ida_idaapi.NW_REMOVE Use this flag with other flags to uninstall a notifywhen callback -ida_idaapi.NW_TERMIDA (variable) +ida_idaapi.NW_TERMIDA Notify when the IDA terminates. Its callback is of the form: def notify_when_callback(nw_code) -ida_idaapi.PY_ICID_BYREF (variable) +ida_idaapi.PY_ICID_BYREF byref object -ida_idaapi.PY_ICID_INT64 (variable) +ida_idaapi.PY_ICID_INT64 int64 object -ida_idaapi.PY_ICID_OPAQUE (variable) +ida_idaapi.PY_ICID_OPAQUE opaque object -ida_idaapi.PyIdc_cvt_int64__ (class) +ida_idaapi.PyIdc_cvt_int64__ Helper class for explicitly representing VT_INT64 values -ida_idaapi.PyIdc_cvt_int64__.__add__ (method) +ida_idaapi.PyIdc_cvt_int64__.__add__(self, other) -ida_idaapi.PyIdc_cvt_int64__.__div__ (method) +ida_idaapi.PyIdc_cvt_int64__.__div__(self, other) -ida_idaapi.PyIdc_cvt_int64__.__init__ (method) +ida_idaapi.PyIdc_cvt_int64__.__init__(self, v) -ida_idaapi.PyIdc_cvt_int64__.__mul__ (method) +ida_idaapi.PyIdc_cvt_int64__.__mul__(self, other) -ida_idaapi.PyIdc_cvt_int64__.__op (method) +ida_idaapi.PyIdc_cvt_int64__.__op(self, op_n, other, rev = False) -ida_idaapi.PyIdc_cvt_int64__.__radd__ (method) +ida_idaapi.PyIdc_cvt_int64__.__radd__(self, other) -ida_idaapi.PyIdc_cvt_int64__.__rdiv__ (method) +ida_idaapi.PyIdc_cvt_int64__.__rdiv__(self, other) -ida_idaapi.PyIdc_cvt_int64__.__rmul__ (method) +ida_idaapi.PyIdc_cvt_int64__.__rmul__(self, other) -ida_idaapi.PyIdc_cvt_int64__.__rsub__ (method) +ida_idaapi.PyIdc_cvt_int64__.__rsub__(self, other) -ida_idaapi.PyIdc_cvt_int64__.__sub__ (method) +ida_idaapi.PyIdc_cvt_int64__.__sub__(self, other) -ida_idaapi.PyIdc_cvt_refclass__ (class) +ida_idaapi.PyIdc_cvt_refclass__ Helper class for representing references to immutable objects -ida_idaapi.PyIdc_cvt_refclass__.__init__ (method) +ida_idaapi.PyIdc_cvt_refclass__.__init__(self, v) -ida_idaapi.PyIdc_cvt_refclass__.cstr (method) +ida_idaapi.PyIdc_cvt_refclass__.cstr(self) Returns the string as a C string (up to the zero termination) -ida_idaapi.ST_OVER_DEBUG_SEG (variable) +ida_idaapi.ST_OVER_DEBUG_SEG step tracing will be disabled when IP is in a debugger segment -ida_idaapi.ST_OVER_LIB_FUNC (variable) +ida_idaapi.ST_OVER_LIB_FUNC step tracing will be disabled when IP is in a library function -ida_idaapi.TRUNC (function) +ida_idaapi.TRUNC(ea) Truncate EA for the current application bitness -ida_idaapi.__IDAPython_Completion_Util (class) +ida_idaapi.__IDAPython_Completion_Util Internal utility class for auto-completion support -ida_idaapi.__IDAPython_Completion_Util.__call__ (method) +ida_idaapi.__IDAPython_Completion_Util.__call__(self, line, x) -ida_idaapi.__IDAPython_Completion_Util.__init__ (method) +ida_idaapi.__IDAPython_Completion_Util.__init__(self) -ida_idaapi.__IDAPython_Completion_Util.debug (method) +ida_idaapi.__IDAPython_Completion_Util.__parse_arg(self, arg) -ida_idaapi.__IDAPython_Completion_Util.dir_namespace (method) +ida_idaapi.__IDAPython_Completion_Util.__proto_from_argspec(self, name, args, defaults, annotations) -ida_idaapi.__IDAPython_Completion_Util.get_candidates (method) +ida_idaapi.__IDAPython_Completion_Util.__proto_from_argspec.__repr_type(typ) -ida_idaapi.__IDAPython_Completion_Util.maybe_extend_syntactically (method) +ida_idaapi.__IDAPython_Completion_Util.__proto_from_docstring(self, name, doc, altname = None) -ida_idaapi.__install_excepthook (function) +ida_idaapi.__IDAPython_Completion_Util.__render_args(self, args, types, defaults) -ida_idaapi._bounded_getitem_iterator (function) +ida_idaapi.__IDAPython_Completion_Util.__render_constant(self, name, attr) + +ida_idaapi.__IDAPython_Completion_Util.__render_default(self, name) + +ida_idaapi.__IDAPython_Completion_Util.__render_docstr(self, doc, name, proto) + +ida_idaapi.__IDAPython_Completion_Util.__render_int_member(self, name, typ, val) + +ida_idaapi.__IDAPython_Completion_Util.__render_proto(self, name, args, types, defaults, rets, is_ctor = False) + +ida_idaapi.__IDAPython_Completion_Util.__render_rets(self, rets) + +ida_idaapi.__IDAPython_Completion_Util.__resolve_type(self, tname) + +ida_idaapi.__IDAPython_Completion_Util.build_hints(self, names, ns) + +ida_idaapi.__IDAPython_Completion_Util.debug(self, *args) + +ida_idaapi.__IDAPython_Completion_Util.dir_namespace(self, m, prefix) + +ida_idaapi.__IDAPython_Completion_Util.get_candidates(self, qname, line, match_syntax_char) + +ida_idaapi.__IDAPython_Completion_Util.maybe_extend_syntactically(self, ns, name, line, syntax_char) + +ida_idaapi.__install_excepthook() + +ida_idaapi._bounded_getitem_iterator(self) Helper function, to be set as __iter__ method for qvector-, or array-based classes. -ida_idaapi._listify_types (function) +ida_idaapi._listify_types(*classes) -ida_idaapi._make_missed_695bwcompat_property (function) +ida_idaapi._make_missed_695bwcompat_property(bad_attr, new_attr, has_setter) -ida_idaapi._make_missed_695bwcompat_property._getter (function) +ida_idaapi._make_missed_695bwcompat_property._getter(self) -ida_idaapi._make_missed_695bwcompat_property._setter (function) +ida_idaapi._make_missed_695bwcompat_property._setter(self, v) -ida_idaapi._make_one_time_warning_message (function) +ida_idaapi._make_one_time_warning_message(bad_attr, new_attr) -ida_idaapi._make_one_time_warning_message.f (function) +ida_idaapi._make_one_time_warning_message.f() -ida_idaapi._qvector_back (function) +ida_idaapi._qvector_back(self) -ida_idaapi._qvector_front (function) +ida_idaapi._qvector_front(self) -ida_idaapi._replace_module_function (function) +ida_idaapi._replace_module_function(replacement) -ida_idaapi.as_UTF16 (function) +ida_idaapi.as_UTF16(s) Convenience function to convert a string into appropriate unicode format -ida_idaapi.as_cstr (function) +ida_idaapi.as_cstr(val) Returns a C str from the passed value. The passed value can be of type refclass (returned by a call to buffer() or byref()) It scans for the first \x00 and returns the string value up to that point. -ida_idaapi.as_int32 (function) +ida_idaapi.as_int32(v) Returns a number as a signed int32 number -ida_idaapi.as_signed (function) +ida_idaapi.as_signed(v, nbits = 32) Returns a number as signed. The number of bits are specified by the user. The MSB holds the sign. -ida_idaapi.as_uint32 (function) +ida_idaapi.as_uint32(v) Returns a number as an unsigned int32 number -ida_idaapi.copy_bits (function) +ida_idaapi.copy_bits(v, s, e = -1) Copy bits from a value @param v: the value @param s: starting bit (0-based) @param e: ending bit -ida_idaapi.disable_script_timeout (function) - disable_script_timeout() +ida_idaapi.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 -ida_idaapi.enable_extlang_python (function) - enable_extlang_python(enable) +ida_idaapi.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 -ida_idaapi.enable_python_cli (function) - enable_python_cli(enable) - - @param enable: bool +ida_idaapi.enable_python_cli(enable: bool) -> None -ida_idaapi.format_basestring (function) - format_basestring(_in) -> str - - @param _in: PyObject * +ida_idaapi.format_basestring(_in: "PyObject *") -> str -ida_idaapi.get_inf_structure (function) - get_inf_structure() -> idainfo - Returns the global variable 'inf' (an instance of idainfo structure, see ida.hpp) - -ida_idaapi.loader_input_t (class) +ida_idaapi.loader_input_t A helper class to work with linput_t related functions. This class is also used by file loaders scripts. -ida_idaapi.loader_input_t.__init__ (method) - __init__(self, pycapsule=None) -> loader_input_t - - @param pycapsule: PyObject * +ida_idaapi.loader_input_t.__init__(self, pycapsule = None) -ida_idaapi.loader_input_t.close (method) - close(self) +ida_idaapi.loader_input_t.close(self) Closes the file -ida_idaapi.loader_input_t.file2base (method) - file2base(self, pos, ea1, ea2, patchable) -> int +ida_idaapi.loader_input_t.file2base(self, pos: int, ea1: ea_t, ea2: ea_t, patchable: bool) 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 ea1: ..ea2): range of destination linear addresses + @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 -ida_idaapi.loader_input_t.filename (method) - filename(self) -> PyObject * +ida_idaapi.loader_input_t.filename(self) -> "PyObject *" -ida_idaapi.loader_input_t.from_capsule (method) - from_capsule(pycapsule) -> loader_input_t - - @param pycapsule: PyObject * +ida_idaapi.loader_input_t.from_capsule(pycapsule: "PyObject *") -> "loader_input_t *" -ida_idaapi.loader_input_t.from_fp (method) - from_fp(fp) -> loader_input_t +ida_idaapi.loader_input_t.from_fp(fp) A static method to construct an instance from a FILE* - @param fp: FILE * + @param fp: a FILE pointer + @return: a new instance, or None -ida_idaapi.loader_input_t.from_linput (method) - from_linput(linput) -> loader_input_t - - @param linput: linput_t * +ida_idaapi.loader_input_t.from_linput(linput: "linput_t *") -> "loader_input_t *" -ida_idaapi.loader_input_t.get_byte (method) - get_byte(self) -> PyObject * +ida_idaapi.loader_input_t.get_byte(self) Reads a single byte from the file. Returns None if EOF or the read byte -ida_idaapi.loader_input_t.get_linput (method) - get_linput(self) -> linput_t * +ida_idaapi.loader_input_t.get_linput(self) -> "linput_t *" -ida_idaapi.loader_input_t.gets (method) - gets(self, len) -> str +ida_idaapi.loader_input_t.gets(self, len: int) Reads a line from the input file. Returns the read line or None - @param len: size_t + @param len: the maximum line length + @return: a str, or None -ida_idaapi.loader_input_t.getz (method) - getz(self, sz, fpos=-1) -> PyObject * +ida_idaapi.loader_input_t.getz(self, size: int, fpos: int = -1) Returns a zero terminated string at the given position - @param sz: maximum size of the string + @param size: maximum size of the string @param fpos: if != -1 then seek will be performed before reading @return: The string or None on failure. -ida_idaapi.loader_input_t.open (method) - open(self, filename, remote=False) -> bool +ida_idaapi.loader_input_t.open(self, filename, remote = False) Opens a file (or a remote file) - @param filename: char const * - @param remote: bool + @param filename: the file name + @param remote: whether the file is local, or remote @return: Boolean -ida_idaapi.loader_input_t.open_memory (method) - open_memory(self, start, size=0) -> bool +ida_idaapi.loader_input_t.open_memory(self, start: ea_t, size: int) Create a linput for process memory (By internally calling idaapi.create_memory_linput()) This linput will use dbg->read_memory() to read data @@ -30884,60 +20460,40 @@ ida_idaapi.loader_input_t.open_memory (method) @param size: size of the memory range to represent as linput if unknown, may be passed as 0 -ida_idaapi.loader_input_t.opened (method) - opened(self) -> bool +ida_idaapi.loader_input_t.opened(self) Checks if the file is opened or not -ida_idaapi.loader_input_t.read (method) - read(self, size) -> bytes or None - Reads from the file. Returns the buffer or None +ida_idaapi.loader_input_t.read(self, size: int = -1) + Read up to size bytes (all data if size is negative). Return an empty bytes object on EOF. - @param size: size_t + @param size: the maximum number of bytes to read + @return a bytes object -ida_idaapi.loader_input_t.readbytes (method) - readbytes(self, size, big_endian) -> PyObject * +ida_idaapi.loader_input_t.readbytes(self, size: int, big_endian: bool) Similar to read() but it respect the endianness - @param size: size_t - @param big_endian: bool + @param size: the maximum number of bytes to read + @param big_endian: endianness + @return a str, or None -ida_idaapi.loader_input_t.seek (method) - seek(self, pos, whence=SEEK_SET) -> int64 +ida_idaapi.loader_input_t.seek(self, offset: int, whence = SEEK_SET) Set input source position - @param pos: int64 - @param whence: int + @param offset: the seek offset + @param whence: the position to seek from @return: the new position (not 0 as fseek!) -ida_idaapi.loader_input_t.set_linput (method) - set_linput(self, linput) +ida_idaapi.loader_input_t.set_linput(self, linput) Links the current loader_input_t instance to a linput_t instance - @param linput: linput_t * + @param linput: the linput_t to link to -ida_idaapi.loader_input_t.size (method) - size(self) -> int64 +ida_idaapi.loader_input_t.size(self) -> "int64" -ida_idaapi.loader_input_t.tell (method) - tell(self) -> int64 +ida_idaapi.loader_input_t.tell(self) Returns the current position -ida_idaapi.loader_input_t_from_capsule (function) - loader_input_t_from_capsule(pycapsule) -> loader_input_t - - @param pycapsule: PyObject * - -ida_idaapi.loader_input_t_from_fp (function) - loader_input_t_from_fp(fp) -> loader_input_t - - @param fp: FILE * - -ida_idaapi.loader_input_t_from_linput (function) - loader_input_t_from_linput(linput) -> loader_input_t - - @param linput: linput_t * - -ida_idaapi.notify_when (function) +ida_idaapi.notify_when(when, callback) 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: @@ -30947,121 +20503,94 @@ ida_idaapi.notify_when (function) def notify_when_callback(nw_code, is_old_database) @return: Boolean -ida_idaapi.object_t (class) +ida_idaapi.object_t Helper class used to initialize empty objects -ida_idaapi.object_t.__getitem__ (method) +ida_idaapi.object_t.__getitem__(self, idx) Allow access to object attributes by index (like dictionaries) -ida_idaapi.object_t.__init__ (method) +ida_idaapi.object_t.__init__(self, **kwds) -ida_idaapi.parse_command_line3 (function) - parse_command_line3(cmdline) -> PyObject * - - @param cmdline: char const * +ida_idaapi.parse_command_line3(cmdline: str) -> "PyObject *" -ida_idaapi.plugin_t (class) +ida_idaapi.plugin_t Base class for all scripted plugins. -ida_idaapi.plugin_t.run (method) +ida_idaapi.plugin_t.run(self, arg) -ida_idaapi.plugin_t.term (method) +ida_idaapi.plugin_t.term(self) -ida_idaapi.plugmod_t (class) +ida_idaapi.plugmod_t Base class for all scripted multi-plugins. -ida_idaapi.py_clinked_object_t (class) +ida_idaapi.py_clinked_object_t This is a utility and base class for C linked objects -ida_idaapi.py_clinked_object_t.__del__ (method) +ida_idaapi.py_clinked_object_t.__del__(self) Delete the link upon object destruction (only if not static) -ida_idaapi.py_clinked_object_t.__init__ (method) +ida_idaapi.py_clinked_object_t.__init__(self, lnk = None) -ida_idaapi.py_clinked_object_t._create_clink (method) +ida_idaapi.py_clinked_object_t._create_clink(self) Overwrite me. Creates a new clink @return: PyCapsule representing the C link -ida_idaapi.py_clinked_object_t._del_clink (method) +ida_idaapi.py_clinked_object_t._del_clink(self, lnk) Overwrite me. This method deletes the link -ida_idaapi.py_clinked_object_t._free (method) +ida_idaapi.py_clinked_object_t._free(self) Explicitly delete the link (only if not static) -ida_idaapi.py_clinked_object_t._get_clink_ptr (method) +ida_idaapi.py_clinked_object_t._get_clink_ptr(self) Overwrite me. Returns the C link pointer as a 64bit number -ida_idaapi.py_clinked_object_t.assign (method) +ida_idaapi.py_clinked_object_t.assign(self, other) Overwrite me. This method allows you to assign an instance contents to anothers @return: Boolean -ida_idaapi.py_clinked_object_t.clink (variable) +ida_idaapi.py_clinked_object_t.clink Returns the C link as a PyObject -ida_idaapi.py_clinked_object_t.clink_ptr (variable) +ida_idaapi.py_clinked_object_t.clink_ptr Returns the C link pointer as a number -ida_idaapi.py_clinked_object_t.copy (method) +ida_idaapi.py_clinked_object_t.copy(self) Returns a new copy of this class -ida_idaapi.pycim_get_widget (function) - pycim_get_widget(_self) -> TWidget * - - @param self: PyObject * +ida_idaapi.pycim_get_widget(_self: "PyObject *") -> "TWidget *" -ida_idaapi.pycim_view_close (function) - pycim_view_close(_self) - - @param self: PyObject * +ida_idaapi.pycim_view_close(_self: "PyObject *") -> None -ida_idaapi.pygc_create_groups (function) - pygc_create_groups(_self, groups_infos) -> [int, ...] or None - - @param self: PyObject * - @param groups_infos: PyObject * +ida_idaapi.pygc_create_groups(_self: "PyObject *", groups_infos: "PyObject *") -> "PyObject *" -ida_idaapi.pygc_delete_groups (function) - pygc_delete_groups(_self, groups, new_current) -> bool - - @param self: PyObject * - @param groups: PyObject * - @param new_current: PyObject * +ida_idaapi.pygc_delete_groups(_self: "PyObject *", groups: "PyObject *", new_current: "PyObject *") -> "PyObject *" -ida_idaapi.pygc_refresh (function) - pygc_refresh(_self) - - @param self: PyObject * +ida_idaapi.pygc_refresh(_self: "PyObject *") -> None -ida_idaapi.pygc_set_groups_visibility (function) - pygc_set_groups_visibility(_self, groups, expand, new_current) -> bool - - @param self: PyObject * - @param groups: PyObject * - @param expand: PyObject * - @param new_current: PyObject * +ida_idaapi.pygc_set_groups_visibility(_self: "PyObject *", groups: "PyObject *", expand: "PyObject *", new_current: "PyObject *") -> "PyObject *" -ida_idaapi.pyidc_cvt_helper__ (class) +ida_idaapi.pyidc_cvt_helper__ This is a special helper object that helps detect which kind of object is this python object wrapping and how to convert it back and from IDC. This object is characterized by its special attribute and its value -ida_idaapi.pyidc_cvt_helper__.__get_value (method) +ida_idaapi.pyidc_cvt_helper__.__get_value(self) -ida_idaapi.pyidc_cvt_helper__.__init__ (method) +ida_idaapi.pyidc_cvt_helper__.__init__(self, cvt_id, value) -ida_idaapi.pyidc_cvt_helper__.__set_value (method) +ida_idaapi.pyidc_cvt_helper__.__set_value(self, v) -ida_idaapi.pyidc_opaque_object_t (class) +ida_idaapi.pyidc_opaque_object_t This is the base class for all Python<->IDC opaque objects -ida_idaapi.replfun (function) +ida_idaapi.replfun(func) -ida_idaapi.require (function) +ida_idaapi.require(modulename, package = None) Load, or reload a module. When under heavy development, a user's tool might consist of multiple @@ -31081,8 +20610,7 @@ ida_idaapi.require (function) For more information, see: . -ida_idaapi.set_script_timeout (function) - set_script_timeout(timeout) -> int +ida_idaapi.set_script_timeout(timeout) 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}. @@ -31090,159 +20618,150 @@ ida_idaapi.set_script_timeout (function) If this value is set to zero then the script will never timeout. @return: Returns the old timeout value -ida_idaapi.struct_unpack (function) +ida_idaapi.struct_unpack(buffer, signed = False, offs = 0) Unpack a buffer given its length and offset using struct.unpack_from(). This function will know how to unpack the given buffer by using the lookup table '__struct_unpack_table' If the buffer is of unknown length then None is returned. Otherwise the unpacked value is returned. -ida_idc (module) +ida_idc -ida_idc.get_mark_comment (function) - get_mark_comment(slot) -> PyObject * - - @param slot: int32 +ida_idc.get_mark_comment(slot: int) -> "PyObject *" -ida_idc.get_marked_pos (function) - get_marked_pos(slot) -> ea_t - - @param slot: int32 +ida_idc.get_marked_pos(slot: int) -> ida_idaapi.ea_t -ida_idc.mark_position (function) - mark_position(ea, lnnum, x, y, slot, comment) - - @param ea: ea_t - @param lnnum: int - @param x: short - @param y: short - @param slot: int32 - @param comment: char const * +ida_idc.mark_position(ea: ida_idaapi.ea_t, lnnum: int, x: "short", y: "short", slot: int, comment: str) -> None -ida_idd (module) +ida_idd Contains definition of the interface to IDD modules. - The interface consists of structures describing the target debugged processor - and a debugging API. + The interface consists of structures describing the target debugged processor and a debugging API. + -ida_idd.APPCALL_DEBEV (variable) +ida_idd.APPCALL_DEBEV Return debug event information. -ida_idd.APPCALL_MANUAL (variable) - Only set up the appcall, do not run. debugger_t::cleanup_appcall will not be - generated by ida! +ida_idd.APPCALL_MANUAL + Only set up the appcall, do not run. debugger_t::cleanup_appcall will not be generated by ida! + -ida_idd.APPCALL_TIMEOUT (variable) - Appcall with timeout. If timed out, errbuf will contain "timeout". See - SET_APPCALL_TIMEOUT and GET_APPCALL_TIMEOUT +ida_idd.APPCALL_TIMEOUT + Appcall with timeout. If timed out, errbuf will contain "timeout". See SET_APPCALL_TIMEOUT and GET_APPCALL_TIMEOUT + -ida_idd.Appcall__ (class) - -ida_idd.Appcall__.APPCALL_DEBEV (variable) - Return debug event information - If this bit is set, exceptions during appcall - will generate idc exceptions with full - information about the exception - -ida_idd.Appcall__.APPCALL_MANUAL (variable) - Only set up the appcall, do not run it. - you should call CleanupAppcall() when finished - -ida_idd.Appcall__.APPCALL_TIMEOUT (variable) +ida_idd.Appcall__ Appcall with timeout The timeout value in milliseconds is specified in the high 2 bytes of the 'options' argument: If timed out, errbuf will contain "timeout". -ida_idd.Appcall__.Consts (variable) +ida_idd.Appcall__.APPCALL_DEBEV + Return debug event information. + +ida_idd.Appcall__.APPCALL_MANUAL + Only set up the appcall, do not run. debugger_t::cleanup_appcall will not be generated by ida! + + +ida_idd.Appcall__.APPCALL_TIMEOUT + Appcall with timeout. If timed out, errbuf will contain "timeout". See SET_APPCALL_TIMEOUT and GET_APPCALL_TIMEOUT + + +ida_idd.Appcall__.Consts Use Appcall.Consts.CONST_NAME to access constants -ida_idd.Appcall__.UTF16 (method) +ida_idd.Appcall__.UTF16(s) -ida_idd.Appcall__.__get_consts (method) +ida_idd.Appcall__.__get_consts(self) -ida_idd.Appcall__.__getattr__ (method) +ida_idd.Appcall__.__getattr__(self, name_or_ea) Allows you to call functions as if they were member functions (by returning a callable object) -ida_idd.Appcall__.__getitem__ (method) +ida_idd.Appcall__.__getitem__(self, idx) Use self[func_name] syntax if the function name contains invalid characters for an attribute name See __getattr___ -ida_idd.Appcall__.__init__ (method) +ida_idd.Appcall__.__init__(self) -ida_idd.Appcall__.__name_or_ea (method) +ida_idd.Appcall__.__name_or_ea(name_or_ea) Function that accepts a name or an ea and checks if the address is enabled. If a name is passed then idaapi.get_name_ea() is applied to retrieve the name - @return: - Returns the resolved EA or + @return: + - Returns the resolved EA or - Raises an exception if the address is not enabled -ida_idd.Appcall__.__typedecl_or_tinfo (method) +ida_idd.Appcall__.__typedecl_or_tinfo(typedecl_or_tinfo, flags = None) Function that accepts a tinfo_t object or type declaration as a string If a type declaration is passed then ida_typeinf.parse_decl() is applied to prepare tinfo_t object - @return: - Returns the tinfo_t object + @return: + - Returns the tinfo_t object - Raises an exception if the declaration cannot be parsed -ida_idd.Appcall__.array (method) +ida_idd.Appcall__.array(type_name) Defines an array type. Later you need to pack() / unpack() -ida_idd.Appcall__.buffer (method) +ida_idd.Appcall__.buffer(str = None, size = 0, fill = "") Creates a string buffer. The returned value (r) will be a byref object. Use r.value to get the contents and r.size to get the buffer's size -ida_idd.Appcall__.byref (method) +ida_idd.Appcall__.byref(val) Method to create references to immutable objects Currently we support references to int/strings Objects need not be passed by reference (this will be done automatically) -ida_idd.Appcall__.cleanup_appcall (method) - Equivalent to IDC's CleanupAppcall() +ida_idd.Appcall__.cleanup_appcall(tid = 0) + Cleanup after manual appcall. + + @param tid: thread to use. NO_THREAD means to use the current thread The application state is restored as it was before calling the last appcall(). Nested appcalls are supported. + @returns eOk if successful, otherwise an error code -ida_idd.Appcall__.cstr (method) +ida_idd.Appcall__.cstr(val) -ida_idd.Appcall__.get_appcall_options (method) +ida_idd.Appcall__.get_appcall_options() Return the global Appcall options -ida_idd.Appcall__.int64 (method) +ida_idd.Appcall__.int64(v) Whenever a 64bit number is needed use this method to construct an object -ida_idd.Appcall__.obj (method) +ida_idd.Appcall__.obj(**kwds) Returns an empty object or objects with attributes as passed via its keywords arguments -ida_idd.Appcall__.proto (method) +ida_idd.Appcall__.proto(name_or_ea, proto_or_tinfo, flags = None) Allows you to instantiate an appcall (callable object) with the desired prototype @param name_or_ea: The name of the function (will be resolved with LocByName()) @param proto_or_tinfo: function prototype as a string or type of the function as tinfo_t object - @return: - On failure it raises an exception if the prototype could not be parsed + @return: + - On failure it raises an exception if the prototype could not be parsed or the address is not resolvable - Returns a callbable Appcall instance with the given prototypes and flags -ida_idd.Appcall__.set_appcall_options (method) +ida_idd.Appcall__.set_appcall_options(opt) Method to change the Appcall options globally (not per Appcall) -ida_idd.Appcall__.typedobj (method) +ida_idd.Appcall__.typedobj(typedecl_or_tinfo, ea = None) Returns an appcall object for a type (can be given as tinfo_t object or as a string declaration) One can then use retrieve() member method @param ea: Optional parameter that later can be used to retrieve the type @return: Appcall object or raises ValueError exception -ida_idd.Appcall__.valueof (method) +ida_idd.Appcall__.valueof(name, default = 0) Returns the numeric value of a given name string. If the name could not be resolved then the default value will be returned -ida_idd.Appcall_array__ (class) +ida_idd.Appcall_array__ This class is used with Appcall.array() method -ida_idd.Appcall_array__.__init__ (method) +ida_idd.Appcall_array__.__init__(self, tp) -ida_idd.Appcall_array__.pack (method) +ida_idd.Appcall_array__.pack(self, L) Packs a list or tuple into a byref buffer -ida_idd.Appcall_array__.try_to_convert_to_list (method) +ida_idd.Appcall_array__.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 -ida_idd.Appcall_array__.unpack (method) +ida_idd.Appcall_array__.unpack(self, buf, as_list = True) Unpacks an array back into a list or an object -ida_idd.Appcall_callable__ (class) +ida_idd.Appcall_callable__ Helper class to issue appcalls using a natural syntax: appcall.FunctionNameInTheDatabase(arguments, ....) or @@ -31255,3389 +20774,2465 @@ ida_idd.Appcall_callable__ (class) i = byref(5) appcall.funcname(arg1, i, "hello", o) -ida_idd.Appcall_callable__.__call__ (method) +ida_idd.Appcall_callable__.__call__(self, *args) Make object callable. We redirect execution to idaapi.appcall() -ida_idd.Appcall_callable__.__get_ea (method) +ida_idd.Appcall_callable__.__get_ea(self) -ida_idd.Appcall_callable__.__get_fields (method) +ida_idd.Appcall_callable__.__get_fields(self) -ida_idd.Appcall_callable__.__get_options (method) +ida_idd.Appcall_callable__.__get_options(self) -ida_idd.Appcall_callable__.__get_size (method) +ida_idd.Appcall_callable__.__get_size(self) -ida_idd.Appcall_callable__.__get_tif (method) +ida_idd.Appcall_callable__.__get_tif(self) -ida_idd.Appcall_callable__.__get_timeout (method) +ida_idd.Appcall_callable__.__get_timeout(self) -ida_idd.Appcall_callable__.__get_type (method) +ida_idd.Appcall_callable__.__get_type(self) -ida_idd.Appcall_callable__.__init__ (method) +ida_idd.Appcall_callable__.__init__(self, ea, tinfo_or_typestr = None, fields = None) Initializes an appcall with a given function ea -ida_idd.Appcall_callable__.__set_ea (method) +ida_idd.Appcall_callable__.__set_ea(self, val) -ida_idd.Appcall_callable__.__set_options (method) +ida_idd.Appcall_callable__.__set_options(self, v) -ida_idd.Appcall_callable__.__set_timeout (method) +ida_idd.Appcall_callable__.__set_timeout(self, v) -ida_idd.Appcall_callable__.ea (variable) +ida_idd.Appcall_callable__.ea Returns or sets the EA associated with this object -ida_idd.Appcall_callable__.fields (variable) +ida_idd.Appcall_callable__.fields Returns the field names -ida_idd.Appcall_callable__.options (variable) +ida_idd.Appcall_callable__.options Sets the Appcall options locally to this Appcall instance -ida_idd.Appcall_callable__.retrieve (method) +ida_idd.Appcall_callable__.retrieve(self, src = None, flags = 0) Unpacks a typed object from the database if an ea is given or from a string if a string was passed @param src: the address of the object or a string @return: Returns a tuple of boolean and object or error number (Bool, Error | Object). -ida_idd.Appcall_callable__.size (variable) +ida_idd.Appcall_callable__.size Returns the size of the type -ida_idd.Appcall_callable__.store (method) +ida_idd.Appcall_callable__.store(self, obj, dest_ea = None, base_ea = 0, flags = 0) Packs an object into a given ea if provided or into a string if no address was passed. @param obj: The object to pack @param dest_ea: If packing to idb this will be the store location @param base_ea: If packing to a buffer, this will be the base that will be used to relocate the pointers - @return: - If packing to a string then a Tuple(Boolean, packed_string or error code) + @return: + - If packing to a string then a Tuple(Boolean, packed_string or error code) - If packing to the database then a return code is returned (0 is success) -ida_idd.Appcall_callable__.tif (variable) +ida_idd.Appcall_callable__.tif Returns the tinfo_t object -ida_idd.Appcall_callable__.timeout (variable) +ida_idd.Appcall_callable__.timeout An Appcall instance can change its timeout value with this attribute -ida_idd.Appcall_callable__.type (variable) +ida_idd.Appcall_callable__.type Returns the typestring -ida_idd.Appcall_consts__ (class) +ida_idd.Appcall_consts__ Helper class used by Appcall.Consts attribute It is used to retrieve constants via attribute access -ida_idd.Appcall_consts__.__getattr__ (method) +ida_idd.Appcall_consts__.__getattr__(self, attr) -ida_idd.Appcall_consts__.__init__ (method) +ida_idd.Appcall_consts__.__init__(self, default = None) -ida_idd.BPT_BAD_ADDR (variable) +ida_idd.BBLK_TRACE + basic block tracing + +ida_idd.BITNESS_CHANGED + Debugger detected the process bitness changing. + +ida_idd.BPT_BAD_ADDR ea is invalid -ida_idd.BPT_BAD_ALIGN (variable) +ida_idd.BPT_BAD_ALIGN alignment is invalid -ida_idd.BPT_BAD_LEN (variable) +ida_idd.BPT_BAD_LEN bpt len is invalid -ida_idd.BPT_BAD_TYPE (variable) +ida_idd.BPT_BAD_TYPE bpt type is not supported -ida_idd.BPT_DEFAULT (variable) +ida_idd.BPT_DEFAULT Choose bpt type automatically. -ida_idd.BPT_EXEC (variable) +ida_idd.BPT_EXEC Execute instruction. -ida_idd.BPT_INTERNAL_ERR (variable) +ida_idd.BPT_INTERNAL_ERR interr occurred when verifying breakpoint -ida_idd.BPT_OK (variable) +ida_idd.BPT_OK breakpoint can be set -ida_idd.BPT_PAGE_OK (variable) +ida_idd.BPT_PAGE_OK update_bpts(): ok, added a page bpt -ida_idd.BPT_RDWR (variable) +ida_idd.BPT_RDWR Read/write access. -ida_idd.BPT_READ (variable) +ida_idd.BPT_READ Read access. -ida_idd.BPT_READ_ERROR (variable) +ida_idd.BPT_READ_ERROR failed to read memory at bpt ea -ida_idd.BPT_SKIP (variable) +ida_idd.BPT_SKIP update_bpts(): do not process bpt -ida_idd.BPT_SOFT (variable) +ida_idd.BPT_SOFT Software breakpoint. -ida_idd.BPT_TOO_MANY (variable) +ida_idd.BPT_TOO_MANY reached max number of supported breakpoints -ida_idd.BPT_WRITE (variable) +ida_idd.BPT_WRITE Write access. -ida_idd.BPT_WRITE_ERROR (variable) +ida_idd.BPT_WRITE_ERROR failed to write memory at bpt ea -ida_idd.BREAKPOINT (variable) - Breakpoint has been reached. IDA will complain about unknown breakpoints, they - should be reported as exceptions. +ida_idd.BREAKPOINT + Breakpoint has been reached. IDA will complain about unknown breakpoints, they should be reported as exceptions. + -ida_idd.DBG_FLAG_ADD_ENVS (variable) +ida_idd.DBG_FLAG_ADD_ENVS The debugger supports launching processes with environment variables. -ida_idd.DBG_FLAG_ANYSIZE_HWBPT (variable) +ida_idd.DBG_FLAG_ANYSIZE_HWBPT The debugger supports arbitrary size hardware breakpoints. -ida_idd.DBG_FLAG_CAN_CONT_BPT (variable) - Debugger knows to continue from a bpt. This flag also means that the debugger - module hides breakpoints from ida upon read_memory +ida_idd.DBG_FLAG_CAN_CONT_BPT + Debugger knows to continue from a bpt. This flag also means that the debugger module hides breakpoints from ida upon read_memory + -ida_idd.DBG_FLAG_CLEAN_EXIT (variable) - IDA must suspend the application and remove all breakpoints before terminating - the application. Usually this is not required because the application memory - disappears upon termination. +ida_idd.DBG_FLAG_CLEAN_EXIT + IDA must suspend the application and remove all breakpoints before terminating the application. Usually this is not required because the application memory disappears upon termination. + -ida_idd.DBG_FLAG_CONNSTRING (variable) +ida_idd.DBG_FLAG_CONNSTRING Display "Connection string" instead of "Hostname" and hide the "Port" field. -ida_idd.DBG_FLAG_DEBTHREAD (variable) - Supports creation of a separate thread in ida for the debugger (the debthread). - Most debugger functions will be called from debthread (exceptions are marked - below) The debugger module may directly call only THREAD_SAFE functions. To call - other functions please use execute_sync(). The debthread significantly increases - debugging speed, especially if debug events occur frequently. +ida_idd.DBG_FLAG_DEBTHREAD + Supports creation of a separate thread in ida for the debugger (the debthread). Most debugger functions will be called from debthread (exceptions are marked below) The debugger module may directly call only THREAD_SAFE functions. To call other functions please use execute_sync(). The debthread significantly increases debugging speed, especially if debug events occur frequently. + -ida_idd.DBG_FLAG_DEBUG_DLL (variable) - Can debug standalone DLLs. For example, Bochs debugger can debug any snippet of - code +ida_idd.DBG_FLAG_DEBUG_DLL + Can debug standalone DLLs. For example, Bochs debugger can debug any snippet of code + -ida_idd.DBG_FLAG_DONT_DISTURB (variable) - Debugger can handle only get_debug_event(), request_pause(), exit_process() when - the debugged process is running. The kernel may also call service functions - (file I/O, map_address, etc) +ida_idd.DBG_FLAG_DISABLE_ASLR + The debugger support ASLR disabling (Address space layout randomization) + -ida_idd.DBG_FLAG_EXITSHOTOK (variable) +ida_idd.DBG_FLAG_DONT_DISTURB + Debugger can handle only get_debug_event(), request_pause(), exit_process() when the debugged process is running. The kernel may also call service functions (file I/O, map_address, etc) + + +ida_idd.DBG_FLAG_EXITSHOTOK IDA may take a memory snapshot at PROCESS_EXITED event. -ida_idd.DBG_FLAG_FAKE_ATTACH (variable) - PROCESS_ATTACHED is a fake event and does not suspend the execution +ida_idd.DBG_FLAG_FAKE_ATTACH + PROCESS_ATTACHED is a fake event and does not suspend the execution + -ida_idd.DBG_FLAG_FAKE_MEMORY (variable) - get_memory_info()/read_memory()/write_memory() work with the idb. (there is no - real process to read from, as for the replayer module) the kernel will not call - these functions if this flag is set. however, third party plugins may call them, - they must be implemented. +ida_idd.DBG_FLAG_FAKE_MEMORY + get_memory_info()/read_memory()/write_memory() work with the idb. (there is no real process to read from, as for the replayer module) the kernel will not call these functions if this flag is set. however, third party plugins may call them, they must be implemented. + -ida_idd.DBG_FLAG_FAST_STEP (variable) +ida_idd.DBG_FLAG_FAST_STEP Do not refresh memory layout info after single stepping. -ida_idd.DBG_FLAG_HWDATBPT_ONE (variable) - Hardware data breakpoints are one byte size by default +ida_idd.DBG_FLAG_FULL_INSTR_BPT + Setting a breakpoint in the middle of an instruction will also break. -ida_idd.DBG_FLAG_LAZY_WATCHPTS (variable) - Watchpoints are triggered before the offending instruction is executed. The - debugger must temporarily disable the watchpoint and single-step before - resuming. +ida_idd.DBG_FLAG_HWDATBPT_ONE + Hardware data breakpoints are one byte size by default + -ida_idd.DBG_FLAG_LOWCNDS (variable) +ida_idd.DBG_FLAG_LAZY_WATCHPTS + Watchpoints are triggered before the offending instruction is executed. The debugger must temporarily disable the watchpoint and single-step before resuming. + + +ida_idd.DBG_FLAG_LOWCNDS Low level breakpoint conditions are supported. -ida_idd.DBG_FLAG_MANMEMINFO (variable) - If set, manual memory region manipulation commands will be available. Use this - bit for debugger modules that cannot return memory layout information +ida_idd.DBG_FLAG_MANMEMINFO + If set, manual memory region manipulation commands will be available. Use this bit for debugger modules that cannot return memory layout information + -ida_idd.DBG_FLAG_MERGE_ENVS (variable) - The debugger supports merge or replace setting for environment variables (only - makes sense if DBG_FLAG_ADD_ENVS is set) +ida_idd.DBG_FLAG_MERGE_ENVS + The debugger supports merge or replace setting for environment variables (only makes sense if DBG_FLAG_ADD_ENVS is set) + -ida_idd.DBG_FLAG_NEEDPORT (variable) +ida_idd.DBG_FLAG_NEEDPORT Remote debugger requires port number (to be used with DBG_FLAG_NOHOST) -ida_idd.DBG_FLAG_NOHOST (variable) - Remote debugger with does not require network params (host/port/pass). (a unique - device connected to the machine) +ida_idd.DBG_FLAG_NOHOST + Remote debugger with does not require network params (host/port/pass). (a unique device connected to the machine) + -ida_idd.DBG_FLAG_NOPARAMETERS (variable) +ida_idd.DBG_FLAG_NOPARAMETERS Debugger module doesn't use commandline parameters. -ida_idd.DBG_FLAG_NOPASSWORD (variable) +ida_idd.DBG_FLAG_NOPASSWORD Remote debugger doesn't use password. -ida_idd.DBG_FLAG_NOSTARTDIR (variable) +ida_idd.DBG_FLAG_NOSTARTDIR Debugger module doesn't use startup directory. -ida_idd.DBG_FLAG_PREFER_SWBPTS (variable) +ida_idd.DBG_FLAG_PREFER_SWBPTS Prefer to use software breakpoints. -ida_idd.DBG_FLAG_REMOTE (variable) +ida_idd.DBG_FLAG_REMOTE Remote debugger (requires remote host name unless DBG_FLAG_NOHOST) -ida_idd.DBG_FLAG_SAFE (variable) - The debugger is safe (probably because it just emulates the application without - really running it) +ida_idd.DBG_FLAG_SAFE + The debugger is safe (probably because it just emulates the application without really running it) + -ida_idd.DBG_FLAG_SMALLBLKS (variable) - If set, IDA uses 256-byte blocks for caching memory contents. Otherwise, - 1024-byte blocks are used +ida_idd.DBG_FLAG_SMALLBLKS + If set, IDA uses 256-byte blocks for caching memory contents. Otherwise, 1024-byte blocks are used + -ida_idd.DBG_FLAG_TRACER_MODULE (variable) +ida_idd.DBG_FLAG_TRACER_MODULE The module is a tracer, not a full featured debugger module. -ida_idd.DBG_FLAG_USE_SREGS (variable) +ida_idd.DBG_FLAG_TTD + The debugger is a time travel debugger and supports continuing backwards. + +ida_idd.DBG_FLAG_USE_SREGS Take segment register values into account (non flat memory) -ida_idd.DBG_FLAG_VIRTHREADS (variable) - Thread IDs may be shuffled after each debug event. (to be used for virtual - threads that represent cpus for windbg kmode) +ida_idd.DBG_FLAG_VIRTHREADS + Thread IDs may be shuffled after each debug event. (to be used for virtual threads that represent cpus for windbg kmode) + -ida_idd.DBG_HAS_APPCALL (variable) +ida_idd.DBG_HAS_APPCALL supports ev_appcall, ev_cleanup_appcall -ida_idd.DBG_HAS_ATTACH_PROCESS (variable) +ida_idd.DBG_HAS_ATTACH_PROCESS supports ev_attach_process -ida_idd.DBG_HAS_CHECK_BPT (variable) +ida_idd.DBG_HAS_CHECK_BPT supports ev_check_bpt -ida_idd.DBG_HAS_DETACH_PROCESS (variable) +ida_idd.DBG_HAS_DETACH_PROCESS supports ev_detach_process -ida_idd.DBG_HAS_GET_PROCESSES (variable) +ida_idd.DBG_HAS_GET_PROCESSES supports ev_get_processes -ida_idd.DBG_HAS_MAP_ADDRESS (variable) - supports ev_map_address. Avoid using this bit, especially together with - DBG_FLAG_DEBTHREAD because it may cause big slow downs +ida_idd.DBG_HAS_MAP_ADDRESS + supports ev_map_address. Avoid using this bit, especially together with DBG_FLAG_DEBTHREAD because it may cause big slow downs + -ida_idd.DBG_HAS_OPEN_FILE (variable) +ida_idd.DBG_HAS_OPEN_FILE supports ev_open_file, ev_close_file, ev_read_file, ev_write_file -ida_idd.DBG_HAS_REQUEST_PAUSE (variable) +ida_idd.DBG_HAS_REQUEST_PAUSE supports ev_request_pause -ida_idd.DBG_HAS_REXEC (variable) +ida_idd.DBG_HAS_REXEC supports ev_rexec -ida_idd.DBG_HAS_SET_EXCEPTION_INFO (variable) +ida_idd.DBG_HAS_SET_EXCEPTION_INFO supports ev_set_exception_info -ida_idd.DBG_HAS_SET_RESUME_MODE (variable) - supports ev_set_resume_mode. Cannot be set inside the - debugger_t::init_debugger() +ida_idd.DBG_HAS_SET_RESUME_MODE + supports ev_set_resume_mode. Cannot be set inside the debugger_t::init_debugger() + -ida_idd.DBG_HAS_THREAD_CONTINUE (variable) +ida_idd.DBG_HAS_THREAD_CONTINUE supports ev_thread_continue -ida_idd.DBG_HAS_THREAD_GET_SREG_BASE (variable) +ida_idd.DBG_HAS_THREAD_GET_SREG_BASE supports ev_thread_get_sreg_base -ida_idd.DBG_HAS_THREAD_SUSPEND (variable) +ida_idd.DBG_HAS_THREAD_SUSPEND supports ev_thread_suspend -ida_idd.DBG_HAS_UPDATE_CALL_STACK (variable) +ida_idd.DBG_HAS_UPDATE_CALL_STACK supports ev_update_call_stack -ida_idd.DBG_HIDE_WINDOW (variable) +ida_idd.DBG_HIDE_WINDOW application should be hidden on startup (windows) -ida_idd.DBG_NO_ASLR (variable) +ida_idd.DBG_NO_ASLR disable ASLR (linux) -ida_idd.DBG_NO_TRACE (variable) +ida_idd.DBG_NO_TRACE do not trace the application (mac/linux) -ida_idd.DBG_PROC_32BIT (variable) +ida_idd.DBG_PROC_32BIT application is 32-bit -ida_idd.DBG_PROC_64BIT (variable) +ida_idd.DBG_PROC_64BIT application is 64-bit -ida_idd.DBG_PROC_IS_DLL (variable) +ida_idd.DBG_PROC_IS_DLL database contains a dll (not exe) -ida_idd.DBG_PROC_IS_GUI (variable) +ida_idd.DBG_PROC_IS_GUI using gui version of ida -ida_idd.DBG_RESMOD_STEP_HANDLE (variable) +ida_idd.DBG_RESMOD_STEP_BACKINTO + RESMOD_BACKINTO is available + +ida_idd.DBG_RESMOD_STEP_HANDLE RESMOD_HANDLE is available -ida_idd.DBG_RESMOD_STEP_INTO (variable) +ida_idd.DBG_RESMOD_STEP_INTO RESMOD_INTO is available -ida_idd.DBG_RESMOD_STEP_OUT (variable) +ida_idd.DBG_RESMOD_STEP_OUT RESMOD_OUT is available -ida_idd.DBG_RESMOD_STEP_OVER (variable) +ida_idd.DBG_RESMOD_STEP_OVER RESMOD_OVER is available -ida_idd.DBG_RESMOD_STEP_SRCINTO (variable) +ida_idd.DBG_RESMOD_STEP_SRCINTO RESMOD_SRCINTO is available -ida_idd.DBG_RESMOD_STEP_SRCOUT (variable) +ida_idd.DBG_RESMOD_STEP_SRCOUT RESMOD_SRCOUT is available -ida_idd.DBG_RESMOD_STEP_SRCOVER (variable) +ida_idd.DBG_RESMOD_STEP_SRCOVER RESMOD_SRCOVER is available -ida_idd.DBG_RESMOD_STEP_USER (variable) +ida_idd.DBG_RESMOD_STEP_USER RESMOD_USER is available -ida_idd.DBG_SUSPENDED (variable) +ida_idd.DBG_SUSPENDED application should be suspended on startup (mac) -ida_idd.DEBUGGER_ID_6811_EMULATOR (variable) +ida_idd.DEBUGGER_ID_6811_EMULATOR MC6812 emulator (beta) -ida_idd.DEBUGGER_ID_ARM_IPHONE_USER (variable) +ida_idd.DEBUGGER_ID_ARM_IPHONE_USER iPhone 1.x -ida_idd.DEBUGGER_ID_ARM_LINUX_USER (variable) +ida_idd.DEBUGGER_ID_ARM_LINUX_USER Userland arm linux. -ida_idd.DEBUGGER_ID_ARM_MACOS_USER (variable) +ida_idd.DEBUGGER_ID_ARM_MACOS_USER Userland arm MAC OS. -ida_idd.DEBUGGER_ID_DALVIK_USER (variable) +ida_idd.DEBUGGER_ID_DALVIK_USER Dalvik. -ida_idd.DEBUGGER_ID_GDB_USER (variable) +ida_idd.DEBUGGER_ID_GDB_USER GDB remote. -ida_idd.DEBUGGER_ID_TRACE_REPLAYER (variable) +ida_idd.DEBUGGER_ID_TRACE_REPLAYER Fake debugger to replay recorded traces. -ida_idd.DEBUGGER_ID_WINDBG (variable) +ida_idd.DEBUGGER_ID_WINDBG WinDBG using Microsoft Debug engine. -ida_idd.DEBUGGER_ID_X86_DOSBOX_EMULATOR (variable) +ida_idd.DEBUGGER_ID_X86_DOSBOX_EMULATOR Dosbox MS-DOS emulator. -ida_idd.DEBUGGER_ID_X86_IA32_BOCHS (variable) +ida_idd.DEBUGGER_ID_X86_IA32_BOCHS BochsDbg.exe 32. -ida_idd.DEBUGGER_ID_X86_IA32_LINUX_USER (variable) +ida_idd.DEBUGGER_ID_X86_IA32_LINUX_USER Userland linux processes (ptrace()) -ida_idd.DEBUGGER_ID_X86_IA32_MACOSX_USER (variable) +ida_idd.DEBUGGER_ID_X86_IA32_MACOSX_USER Userland MAC OS X processes. -ida_idd.DEBUGGER_ID_X86_IA32_WIN32_USER (variable) +ida_idd.DEBUGGER_ID_X86_IA32_WIN32_USER Userland win32 processes (win32 debugging APIs) -ida_idd.DEBUGGER_ID_X86_PIN_TRACER (variable) +ida_idd.DEBUGGER_ID_X86_PIN_TRACER PIN Tracer module. -ida_idd.DEBUGGER_ID_XNU_USER (variable) +ida_idd.DEBUGGER_ID_XNU_USER XNU Kernel. -ida_idd.DRC_CRC (variable) +ida_idd.DRC_CRC success, but the input file crc does not match -ida_idd.DRC_ERROR (variable) +ida_idd.DRC_ERROR unclassified error, may be complemented by errbuf -ida_idd.DRC_EVENTS (variable) +ida_idd.DRC_EVENTS success, there are pending events -ida_idd.DRC_FAILED (variable) +ida_idd.DRC_FAILED failed or false -ida_idd.DRC_IDBSEG (variable) +ida_idd.DRC_IDBSEG use idb segmentation -ida_idd.DRC_NETERR (variable) +ida_idd.DRC_NETERR network error -ida_idd.DRC_NOCHG (variable) +ida_idd.DRC_NOCHG no changes -ida_idd.DRC_NOFILE (variable) +ida_idd.DRC_NOFILE file not found -ida_idd.DRC_NONE (variable) +ida_idd.DRC_NONE reaction to the event not implemented -ida_idd.DRC_NOPROC (variable) +ida_idd.DRC_NOPROC the process does not exist anymore -ida_idd.DRC_OK (variable) +ida_idd.DRC_OK success -ida_idd.EXCEPTION (variable) +ida_idd.EXCEPTION Exception. -ida_idd.EXC_BREAK (variable) +ida_idd.EXC_BREAK break on the exception -ida_idd.EXC_HANDLE (variable) +ida_idd.EXC_HANDLE should be handled by the debugger? -ida_idd.EXC_MSG (variable) +ida_idd.EXC_MSG instead of a warning, log the exception to the output window -ida_idd.EXC_SILENT (variable) +ida_idd.EXC_SILENT do not warn or log to the output window -ida_idd.IDD_INTERFACE_VERSION (variable) +ida_idd.FUNC_TRACE + function tracing + +ida_idd.IDD_INTERFACE_VERSION The IDD interface version number. -ida_idd.INFORMATION (variable) - User-defined information. This event can be used to return empty information - This will cause IDA to call get_debug_event() immediately once more. +ida_idd.INFORMATION + User-defined information. This event can be used to return empty information This will cause IDA to call get_debug_event() immediately once more. + -ida_idd.LIB_LOADED (variable) +ida_idd.INSN_TRACE + instruction tracing + +ida_idd.LIB_LOADED New library has been loaded. -ida_idd.LIB_UNLOADED (variable) +ida_idd.LIB_UNLOADED Library has been unloaded. -ida_idd.NO_EVENT (variable) - Not an interesting event. This event can be used if the debugger module needs to - return an event but there are no valid events. +ida_idd.NO_EVENT + Not an interesting event. This event can be used if the debugger module needs to return an event but there are no valid events. + -ida_idd.NO_PROCESS (variable) +ida_idd.NO_PROCESS No process. -ida_idd.NO_THREAD (variable) - No thread. in PROCESS_STARTED this value can be used to specify that the main - thread has not been created. It will be initialized later by a THREAD_STARTED - event. +ida_idd.NO_THREAD + No thread. in PROCESS_STARTED this value can be used to specify that the main thread has not been created. It will be initialized later by a THREAD_STARTED event. + -ida_idd.PROCESS_ATTACHED (variable) +ida_idd.NO_THREAD + No thread. in PROCESS_STARTED this value can be used to specify that the main thread has not been created. It will be initialized later by a THREAD_STARTED event. + + +ida_idd.PROCESS_ATTACHED Successfully attached to running process. -ida_idd.PROCESS_DETACHED (variable) +ida_idd.PROCESS_DETACHED Successfully detached from process. -ida_idd.PROCESS_EXITED (variable) +ida_idd.PROCESS_EXITED Process has been stopped. -ida_idd.PROCESS_STARTED (variable) +ida_idd.PROCESS_STARTED New process has been started. -ida_idd.PROCESS_SUSPENDED (variable) - Process has been suspended. This event can be used by the debugger module to - signal if the process spontaneously gets suspended (not because of an exception, - breakpoint, or single step). IDA will silently switch to the 'suspended process' - mode without displaying any messages. +ida_idd.PROCESS_SUSPENDED + Process has been suspended. This event can be used by the debugger module to signal if the process spontaneously gets suspended (not because of an exception, breakpoint, or single step). IDA will silently switch to the 'suspended process' mode without displaying any messages. + -ida_idd.REGISTER_ADDRESS (variable) +ida_idd.REGISTER_ADDRESS may contain an address -ida_idd.REGISTER_CS (variable) +ida_idd.REGISTER_CS code segment -ida_idd.REGISTER_CUSTFMT (variable) - register should be displayed using a custom data format. the format name is in - bit_strings[0]; the corresponding regval_t will use bytevec_t +ida_idd.REGISTER_CUSTFMT + register should be displayed using a custom data format. the format name is in bit_strings[0]; the corresponding regval_t will use bytevec_t + -ida_idd.REGISTER_FP (variable) +ida_idd.REGISTER_FP frame pointer -ida_idd.REGISTER_IP (variable) +ida_idd.REGISTER_IP instruction pointer -ida_idd.REGISTER_NOLF (variable) - displays this register without returning to the next line, allowing the next - register to be displayed to its right (on the same line) +ida_idd.REGISTER_NOLF + displays this register without returning to the next line, allowing the next register to be displayed to its right (on the same line) + -ida_idd.REGISTER_READONLY (variable) +ida_idd.REGISTER_READONLY the user can't modify the current value of this register -ida_idd.REGISTER_SP (variable) +ida_idd.REGISTER_SP stack pointer -ida_idd.REGISTER_SS (variable) +ida_idd.REGISTER_SS stack segment -ida_idd.RESMOD_HANDLE (variable) +ida_idd.RESMOD_BACKINTO + step backwards into call (in time-travel debugging) + +ida_idd.RESMOD_HANDLE step into the exception handler -ida_idd.RESMOD_INTO (variable) +ida_idd.RESMOD_INTO step into call (the most typical single stepping) -ida_idd.RESMOD_NONE (variable) +ida_idd.RESMOD_NONE no stepping, run freely -ida_idd.RESMOD_OUT (variable) +ida_idd.RESMOD_OUT step out of the current function (run until return) -ida_idd.RESMOD_OVER (variable) +ida_idd.RESMOD_OVER step over call -ida_idd.RESMOD_SRCINTO (variable) +ida_idd.RESMOD_SRCINTO until control reaches a different source line -ida_idd.RESMOD_SRCOUT (variable) +ida_idd.RESMOD_SRCOUT next source line in the previous stack frame -ida_idd.RESMOD_SRCOVER (variable) +ida_idd.RESMOD_SRCOVER next source line in the current stack frame -ida_idd.RESMOD_USER (variable) +ida_idd.RESMOD_USER step out to the user code -ida_idd.RVT_FLOAT (variable) +ida_idd.RQ_IDAIDLE + handle_debug_event: ida is idle + +ida_idd.RQ_IGNWERR + ignore breakpoint write failures + +ida_idd.RQ_MASKING + masking step handler: unless errors, tmpbpt handlers won't be generated should be used only with request_internal_step() + + +ida_idd.RQ_NOSUSP + running step handler: continues the app + +ida_idd.RQ_PROCEXIT + snapshots: the process is exiting + +ida_idd.RQ_RESMOD + resume_mode_t + +ida_idd.RQ_RESUME + handle_debug_event: resume application + +ida_idd.RQ_SILENT + all: no dialog boxes + +ida_idd.RQ_SUSPEND + suspending step handler: suspends the app handle_debug_event: suspends the app + + +ida_idd.RQ_SUSPRUN + handle_debug_event: suspend at PROCESS_STARTED + +ida_idd.RQ_SWSCREEN + handle_debug_event: switch screens + +ida_idd.RQ_VERBOSE + all: display dialog boxes + +ida_idd.RQ__NOTHRRF + handle_debug_event: do not refresh threads + +ida_idd.RVT_FLOAT floating point -ida_idd.RVT_INT (variable) +ida_idd.RVT_INT integer -ida_idd.RVT_UNAVAILABLE (variable) - unavailable; other values mean custom data type +ida_idd.RVT_UNAVAILABLE + unavailable; other values mean custom data type + -ida_idd.STEP (variable) - One instruction has been executed. Spurious events of this kind are silently - ignored by IDA. +ida_idd.STATUS_MASK + additional info about process state -ida_idd.THREAD_EXITED (variable) +ida_idd.STEP + One instruction has been executed. Spurious events of this kind are silently ignored by IDA. + + +ida_idd.STEP_TRACE + lowest level trace. trace buffers are not maintained + +ida_idd.THREAD_EXITED Thread has been stopped. -ida_idd.THREAD_STARTED (variable) +ida_idd.THREAD_STARTED New thread has been started. -ida_idd.TRACE_FULL (variable) - The trace buffer of the tracer module is full and IDA needs to read it before - continuing +ida_idd.TRACE_FULL + The trace buffer of the tracer module is full and IDA needs to read it before continuing + -ida_idd.appcall (function) - appcall(func_ea, tid, _type_or_none, _fields, arg_list) -> PyObject * - - @param func_ea: ea_t - @param tid: thid_t - @param _type_or_none: bytevec_t const & - @param _fields: bytevec_t const & - @param arg_list: PyObject * +ida_idd.appcall(func_ea: ida_idaapi.ea_t, tid: "thid_t", _type_or_none: "bytevec_t const &", _fields: "bytevec_t const &", arg_list: "PyObject *") -> "PyObject *" -ida_idd.bptaddr_t (class) - Proxy of C++ bptaddr_t class. +ida_idd.bptaddr_t -ida_idd.bptaddr_t.__init__ (method) - __init__(self) -> bptaddr_t +ida_idd.bptaddr_t.__init__(self) -ida_idd.bptaddr_t.hea (variable) +ida_idd.bptaddr_t.hea Possible address referenced by hardware breakpoints. -ida_idd.bptaddr_t.kea (variable) - Address of the triggered bpt from the kernel's point of view. (for some systems - with special memory mappings, the triggered ea might be different from event - ea). Use to BADADDR for flat memory model. +ida_idd.bptaddr_t.kea + Address of the triggered bpt from the kernel's point of view. (for some systems with special memory mappings, the triggered ea might be different from event ea). Use to BADADDR for flat memory model. + -ida_idd.call_stack_info_t (class) - Proxy of C++ call_stack_info_t class. +ida_idd.call_stack_info_t -ida_idd.call_stack_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: call_stack_info_t const & +ida_idd.call_stack_info_t.__eq__(self, r: "call_stack_info_t") -> bool -ida_idd.call_stack_info_t.__init__ (method) - __init__(self) -> call_stack_info_t +ida_idd.call_stack_info_t.__init__(self) -ida_idd.call_stack_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: call_stack_info_t const & +ida_idd.call_stack_info_t.__ne__(self, r: "call_stack_info_t") -> bool -ida_idd.call_stack_info_t.callea (variable) - the address of the call instruction. for the 0th frame this is usually just the - current value of EIP. +ida_idd.call_stack_info_t.callea + the address of the call instruction. for the 0th frame this is usually just the current value of EIP. + -ida_idd.call_stack_info_t.fp (variable) +ida_idd.call_stack_info_t.fp the value of the frame pointer of the called function -ida_idd.call_stack_info_t.funcea (variable) +ida_idd.call_stack_info_t.funcea the address of the called function -ida_idd.call_stack_info_t.funcok (variable) +ida_idd.call_stack_info_t.funcok is the function present? -ida_idd.call_stack_info_vec_t (class) - Proxy of C++ qvector< call_stack_info_t > class. +ida_idd.call_stack_info_vec_t -ida_idd.call_stack_info_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< call_stack_info_t > const & +ida_idd.call_stack_info_vec_t.__eq__(self, r: "call_stack_info_vec_t") -> bool -ida_idd.call_stack_info_vec_t.__getitem__ (method) - __getitem__(self, i) -> call_stack_info_t - - @param i: size_t +ida_idd.call_stack_info_vec_t.__getitem__(self, i: "size_t") -> "call_stack_info_t const &" -ida_idd.call_stack_info_vec_t.__init__ (method) - __init__(self) -> call_stack_info_vec_t - __init__(self, x) -> call_stack_info_vec_t - - @param x: qvector< call_stack_info_t > const & +ida_idd.call_stack_info_vec_t.__init__(self, *args) -ida_idd.call_stack_info_vec_t.__len__ (method) - __len__(self) -> size_t +ida_idd.call_stack_info_vec_t.__len__(self) -> "size_t" -ida_idd.call_stack_info_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< call_stack_info_t > const & +ida_idd.call_stack_info_vec_t.__ne__(self, r: "call_stack_info_vec_t") -> bool -ida_idd.call_stack_info_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: call_stack_info_t const & +ida_idd.call_stack_info_vec_t.__setitem__(self, i: "size_t", v: "call_stack_info_t") -> None -ida_idd.call_stack_info_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: call_stack_info_t const & +ida_idd.call_stack_info_vec_t._del(self, x: "call_stack_info_t") -> bool -ida_idd.call_stack_info_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: call_stack_info_t const & +ida_idd.call_stack_info_vec_t.add_unique(self, x: "call_stack_info_t") -> bool -ida_idd.call_stack_info_vec_t.at (method) - at(self, _idx) -> call_stack_info_t - - @param _idx: size_t +ida_idd.call_stack_info_vec_t.append(self, x: "call_stack_info_t") -> None -ida_idd.call_stack_info_vec_t.begin (method) - begin(self) -> call_stack_info_t +ida_idd.call_stack_info_vec_t.at(self, _idx: "size_t") -> "call_stack_info_t const &" -ida_idd.call_stack_info_vec_t.capacity (method) - capacity(self) -> size_t +ida_idd.call_stack_info_vec_t.begin(self, *args) -> "qvector< call_stack_info_t >::const_iterator" -ida_idd.call_stack_info_vec_t.clear (method) - clear(self) +ida_idd.call_stack_info_vec_t.capacity(self) -> "size_t" -ida_idd.call_stack_info_vec_t.empty (method) - empty(self) -> bool +ida_idd.call_stack_info_vec_t.clear(self) -> None -ida_idd.call_stack_info_vec_t.end (method) - end(self) -> call_stack_info_t +ida_idd.call_stack_info_vec_t.empty(self) -> bool -ida_idd.call_stack_info_vec_t.erase (method) - erase(self, it) -> call_stack_info_t - - @param it: qvector< call_stack_info_t >::iterator - - erase(self, first, last) -> call_stack_info_t - - @param first: qvector< call_stack_info_t >::iterator - @param last: qvector< call_stack_info_t >::iterator +ida_idd.call_stack_info_vec_t.end(self, *args) -> "qvector< call_stack_info_t >::const_iterator" -ida_idd.call_stack_info_vec_t.extract (method) - extract(self) -> call_stack_info_t +ida_idd.call_stack_info_vec_t.erase(self, *args) -> "qvector< call_stack_info_t >::iterator" -ida_idd.call_stack_info_vec_t.find (method) - find(self, x) -> call_stack_info_t - - @param x: call_stack_info_t const & +ida_idd.call_stack_info_vec_t.extend(self, x: "call_stack_info_vec_t") -> None -ida_idd.call_stack_info_vec_t.grow (method) - grow(self, x=call_stack_info_t()) - - @param x: call_stack_info_t const & +ida_idd.call_stack_info_vec_t.extract(self) -> "call_stack_info_t *" -ida_idd.call_stack_info_vec_t.has (method) - has(self, x) -> bool - - @param x: call_stack_info_t const & +ida_idd.call_stack_info_vec_t.find(self, *args) -> "qvector< call_stack_info_t >::const_iterator" -ida_idd.call_stack_info_vec_t.inject (method) - inject(self, s, len) - - @param s: call_stack_info_t * - @param len: size_t +ida_idd.call_stack_info_vec_t.grow(self, *args) -> None -ida_idd.call_stack_info_vec_t.insert (method) - insert(self, it, x) -> call_stack_info_t - - @param it: qvector< call_stack_info_t >::iterator - @param x: call_stack_info_t const & +ida_idd.call_stack_info_vec_t.has(self, x: "call_stack_info_t") -> bool -ida_idd.call_stack_info_vec_t.pop_back (method) - pop_back(self) +ida_idd.call_stack_info_vec_t.inject(self, s: "call_stack_info_t", len: "size_t") -> None -ida_idd.call_stack_info_vec_t.push_back (method) - push_back(self, x) - - @param x: call_stack_info_t const & - - push_back(self) -> call_stack_info_t +ida_idd.call_stack_info_vec_t.insert(self, it: "call_stack_info_t", x: "call_stack_info_t") -> "qvector< call_stack_info_t >::iterator" -ida_idd.call_stack_info_vec_t.qclear (method) - qclear(self) +ida_idd.call_stack_info_vec_t.pop_back(self) -> None -ida_idd.call_stack_info_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_idd.call_stack_info_vec_t.push_back(self, *args) -> "call_stack_info_t &" -ida_idd.call_stack_info_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: call_stack_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_idd.call_stack_info_vec_t.qclear(self) -> None -ida_idd.call_stack_info_vec_t.size (method) - size(self) -> size_t +ida_idd.call_stack_info_vec_t.reserve(self, cnt: "size_t") -> None -ida_idd.call_stack_info_vec_t.swap (method) - swap(self, r) - - @param r: qvector< call_stack_info_t > & +ida_idd.call_stack_info_vec_t.resize(self, *args) -> None -ida_idd.call_stack_info_vec_t.truncate (method) - truncate(self) +ida_idd.call_stack_info_vec_t.size(self) -> "size_t" -ida_idd.call_stack_t (class) - Proxy of C++ call_stack_t class. +ida_idd.call_stack_info_vec_t.swap(self, r: "call_stack_info_vec_t") -> None -ida_idd.call_stack_t.__init__ (method) - __init__(self) -> call_stack_t +ida_idd.call_stack_info_vec_t.truncate(self) -> None -ida_idd.can_exc_continue (function) - can_exc_continue(ev) -> bool - - @param ev: debug_event_t const * +ida_idd.call_stack_t -ida_idd.cleanup_appcall (function) - cleanup_appcall(tid) -> error_t - Cleanup after manual appcall. - - @param tid: (C++: thid_t) thread to use. NO_THREAD means to use the current thread The - application state is restored as it was before calling the last - appcall(). Nested appcalls are supported. - @return: eOk if successful, otherwise an error code +ida_idd.call_stack_t.__init__(self) -ida_idd.dbg_appcall (function) - dbg_appcall(retval, func_ea, tid, ptif, argv, argnum) -> error_t - Call a function from the debugged application. - - @param retval: (C++: idc_value_t *) function return value +ida_idd.can_exc_continue(ev: "debug_event_t") -> bool + +ida_idd.cleanup_appcall(tid: "thid_t") -> "error_t" + Cleanup after manual appcall. + + @param tid: thread to use. NO_THREAD means to use the current thread The application state is restored as it was before calling the last appcall(). Nested appcalls are supported. + @returns eOk if successful, otherwise an error code + +ida_idd.cpu2ieee(ieee_out: "fpvalue_t *", cpu_fpval: "void const *", size: int) -> int + Convert a floating point number in CPU native format to IDA's internal format. + + @param ieee_out: output buffer + @param cpu_fpval: floating point number in CPU native format + @param size: size of cpu_fpval in bytes (size of the input buffer) + @returns Floating point/IEEE Conversion codes + +ida_idd.dbg_appcall(retval: "idc_value_t *", func_ea: ida_idaapi.ea_t, tid: "thid_t", ptif: "tinfo_t", argv: "idc_value_t *", argnum: "size_t") -> "error_t" + Call a function from the debugged application. + + @param retval: function return value * for APPCALL_MANUAL, r will hold the new stack point value - * for APPCALL_DEBEV, r will hold the exception information upon failure and the - return code will be eExecThrow - @param func_ea: (C++: ea_t) address to call - @param tid: (C++: thid_t) thread to use. NO_THREAD means to use the current thread - @param ptif: (C++: const tinfo_t *) pointer to type of the function to call - @param argv: (C++: idc_value_t *) array of arguments - @param argnum: (C++: size_t) number of actual arguments - @return: eOk if successful, otherwise an error code + * for APPCALL_DEBEV, r will hold the exception information upon failure and the return code will be eExecThrow + @param func_ea: address to call + @param tid: thread to use. NO_THREAD means to use the current thread + @param ptif: pointer to type of the function to call + @param argv: array of arguments + @param argnum: number of actual arguments + @returns eOk if successful, otherwise an error code -ida_idd.dbg_get_memory_info (function) - dbg_get_memory_info() -> PyObject * +ida_idd.dbg_get_memory_info() This function returns the memory configuration of a debugged process. - @return: None if no debugger is active + @return: + None if no debugger is active tuple(start_ea, end_ea, name, sclass, sbase, bitness, perm) -ida_idd.dbg_get_name (function) - dbg_get_name() -> PyObject * +ida_idd.dbg_get_name() This function returns the current debugger's name. @return: Debugger name or None if no debugger is active -ida_idd.dbg_get_registers (function) - dbg_get_registers() -> PyObject * +ida_idd.dbg_get_registers() 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 + @return: + None if no debugger is loaded tuple(name, flags, class, dtype, bit_strings, default_bit_strings_mask) The bit_strings can be a tuple of strings or None (if the register does not have bit_strings) -ida_idd.dbg_get_thread_sreg_base (function) - dbg_get_thread_sreg_base(tid, sreg_value) -> PyObject * +ida_idd.dbg_get_thread_sreg_base(tid, sreg_value) Returns the segment register base value @param tid: thread id @param sreg_value: segment register (selector) value - @return: - The base as an 'ea' + @return: + - The base as an 'ea' - Or None on failure -ida_idd.dbg_read_memory (function) - dbg_read_memory(ea, sz) -> PyObject * +ida_idd.dbg_read_memory(ea, sz) Reads from the debugee's memory at the specified ea - @param ea: ea_t - @param sz: size_t - @return: - The read buffer (as a string) + @param ea: the debuggee's memory address + @param sz: the amount of data to read + @return: + - The read buffer (as bytes) - Or None on failure -ida_idd.dbg_write_memory (function) - dbg_write_memory(ea, buf) -> bool +ida_idd.dbg_write_memory(ea, buffer) Writes a buffer to the debugee's memory - @param ea: ea_t - @param buf: bytevec_t const & + @param ea: the debuggee's memory address + @param buf: a bytes object to write @return: Boolean -ida_idd.debapp_attrs_t (class) - Proxy of C++ debapp_attrs_t class. +ida_idd.debapp_attrs_t -ida_idd.debapp_attrs_t.__init__ (method) - __init__(self) -> debapp_attrs_t +ida_idd.debapp_attrs_t.__init__(self) -ida_idd.debapp_attrs_t.addrsize (variable) - address size of the process. Since 64-bit debuggers usually can debug 32-bit - applications, we cannot rely on sizeof(ea_t) to detect the current address size. - The following variable should be used instead. It is initialized with 8 for - 64-bit debuggers but they should adjust it as soon as they learn that a 32-bit - application is being debugged. For 32-bit debuggers it is initialized with 4. +ida_idd.debapp_attrs_t.addrsize + address size of the process. Since 64-bit debuggers usually can debug 32-bit applications, we cannot rely on sizeof(ea_t) to detect the current address size. The following variable should be used instead. It is initialized with 8 for 64-bit debuggers but they should adjust it as soon as they learn that a 32-bit application is being debugged. For 32-bit debuggers it is initialized with 4. + -ida_idd.debapp_attrs_t.cbsize (variable) +ida_idd.debapp_attrs_t.cbsize control field: size of this structure -ida_idd.debapp_attrs_t.platform (variable) - platform name process is running/debugging under. (is used as a key value in - exceptions.cfg) +ida_idd.debapp_attrs_t.platform + platform name process is running/debugging under. (is used as a key value in exceptions.cfg) + -ida_idd.debug_event_t (class) - Proxy of C++ debug_event_t class. +ida_idd.debug_event_t -ida_idd.debug_event_t.__init__ (method) - __init__(self) -> debug_event_t - __init__(self, r) -> debug_event_t - - @param r: debug_event_t const & +ida_idd.debug_event_t.__init__(self, *args) -ida_idd.debug_event_t.bpt (method) - bpt(self) -> bptaddr_t +ida_idd.debug_event_t.bpt(self) -> "bptaddr_t &" + EXCEPTION -ida_idd.debug_event_t.bpt_ea (method) - bpt_ea(self) -> ea_t - On some systems with special memory mappings the triggered ea might be different - from the actual ea. Calculate the address to use. +ida_idd.debug_event_t.bpt_ea(self) -> ida_idaapi.ea_t + On some systems with special memory mappings the triggered ea might be different from the actual ea. Calculate the address to use. + -ida_idd.debug_event_t.clear (method) - clear(self) +ida_idd.debug_event_t.clear(self) -> None clear the dependent information (see below), set event code to NO_EVENT -ida_idd.debug_event_t.clear_all (method) - clear_all(self) +ida_idd.debug_event_t.clear_all(self) -> None -ida_idd.debug_event_t.copy (method) - copy(self, r) -> debug_event_t - - @param r: debug_event_t const & +ida_idd.debug_event_t.copy(self, r: "debug_event_t") -> "debug_event_t &" -ida_idd.debug_event_t.ea (variable) +ida_idd.debug_event_t.ea Address where the event occurred. -ida_idd.debug_event_t.eid (method) - eid(self) -> event_id_t +ida_idd.debug_event_t.eid(self) -> "event_id_t" Event code. -ida_idd.debug_event_t.exc (method) - exc(self) -> excinfo_t +ida_idd.debug_event_t.exc(self) -> "excinfo_t &" -ida_idd.debug_event_t.exit_code (method) - exit_code(self) -> int const & +ida_idd.debug_event_t.exit_code(self) -> "int const &" + THREAD_STARTED (thread name) LIB_UNLOADED (unloaded library name) INFORMATION (will be displayed in the output window if not empty) + -ida_idd.debug_event_t.handled (variable) - Is event handled by the debugger?. (from the system's point of view) Meaningful - for EXCEPTION events +ida_idd.debug_event_t.handled + Is event handled by the debugger?. (from the system's point of view) Meaningful for EXCEPTION events + -ida_idd.debug_event_t.info (method) - info(self) -> qstring - info(self) -> qstring const & +ida_idd.debug_event_t.info(self) -> str + BREAKPOINT -ida_idd.debug_event_t.modinfo (method) - modinfo(self) -> modinfo_t +ida_idd.debug_event_t.is_bitness_changed(self) -> bool + process bitness -ida_idd.debug_event_t.pid (variable) +ida_idd.debug_event_t.modinfo(self) -> "modinfo_t &" + Information that depends on the event code: + + < PROCESS_STARTED, PROCESS_ATTACHED, LIB_LOADED PROCESS_EXITED, THREAD_EXITED + + +ida_idd.debug_event_t.pid Process where the event occurred. -ida_idd.debug_event_t.set_bpt (method) - set_bpt(self) -> bptaddr_t +ida_idd.debug_event_t.set_bitness_changed(self, on: bool = True) -> None -ida_idd.debug_event_t.set_eid (method) - set_eid(self, id) - Set event code. If the new event code is compatible with the old one then the - dependent information (see below) will be preserved. Otherwise the event will be - cleared and the new event code will be set. - - @param id: (C++: event_id_t) enum event_id_t +ida_idd.debug_event_t.set_bpt(self) -> "bptaddr_t &" -ida_idd.debug_event_t.set_exception (method) - set_exception(self) -> excinfo_t +ida_idd.debug_event_t.set_eid(self, id: "event_id_t") -> None + Set event code. If the new event code is compatible with the old one then the dependent information (see below) will be preserved. Otherwise the event will be cleared and the new event code will be set. + -ida_idd.debug_event_t.set_exit_code (method) - set_exit_code(self, id, code) - - @param id: enum event_id_t - @param code: int +ida_idd.debug_event_t.set_exception(self) -> "excinfo_t &" -ida_idd.debug_event_t.set_info (method) - set_info(self, id) -> qstring & - - @param id: enum event_id_t +ida_idd.debug_event_t.set_exit_code(self, id: "event_id_t", code: int) -> None -ida_idd.debug_event_t.set_modinfo (method) - set_modinfo(self, id) -> modinfo_t - - @param id: enum event_id_t +ida_idd.debug_event_t.set_info(self, id: "event_id_t") -> str -ida_idd.debug_event_t.tid (variable) +ida_idd.debug_event_t.set_modinfo(self, id: "event_id_t") -> "modinfo_t &" + +ida_idd.debug_event_t.tid Thread where the event occurred. -ida_idd.debugger_t (class) - Proxy of C++ debugger_t class. +ida_idd.debugger_t -ida_idd.debugger_t.__get_bpt_bytes (method) - __get_bpt_bytes(self) -> bytevec_t +ida_idd.debugger_t.__get_bpt_bytes(self) -> "bytevec_t" -ida_idd.debugger_t.__get_nregs (method) - __get_nregs(self) -> int +ida_idd.debugger_t.__get_nregisters(self) -> int -ida_idd.debugger_t.__get_regclasses (method) - __get_regclasses(self) -> PyObject * +ida_idd.debugger_t.__get_regclasses(self) -> "PyObject *" -ida_idd.debugger_t.__get_registers (method) - __get_registers(self) -> dyn_register_info_array +ida_idd.debugger_t.__get_registers(self) -> "dynamic_wrapped_array_t< register_info_t >" -ida_idd.debugger_t.__init__ (method) - __init__(self) -> debugger_t +ida_idd.debugger_t.__init__(self) -ida_idd.debugger_t.attach_process (method) - attach_process(self, pid, event_id, dbg_proc_flags) -> drc_t - - @param pid: pid_t - @param event_id: int - @param dbg_proc_flags: uint32 +ida_idd.debugger_t.attach_process(self, pid: "pid_t", event_id: int, dbg_proc_flags: int) -> "drc_t" -ida_idd.debugger_t.bin_search (method) - bin_search(self, start_ea, end_ea, data, srch_flags) -> drc_t - - @param start_ea: ea_t - @param end_ea: ea_t - @param data: compiled_binpat_vec_t const & - @param srch_flags: int +ida_idd.debugger_t.bin_search(self, start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, data: "compiled_binpat_vec_t const &", srch_flags: int) -> "drc_t" -ida_idd.debugger_t.bpt_bytes (variable) +ida_idd.debugger_t.bpt_bytes A software breakpoint instruction. -ida_idd.debugger_t.bpt_size (variable) +ida_idd.debugger_t.bpt_size Size of the software breakpoint instruction in bytes. -ida_idd.debugger_t.cache_block_size (method) - cache_block_size(self) -> size_t +ida_idd.debugger_t.cache_block_size(self) -> "size_t" -ida_idd.debugger_t.can_continue_from_bpt (method) - can_continue_from_bpt(self) -> bool +ida_idd.debugger_t.can_continue_from_bpt(self) -> bool -ida_idd.debugger_t.can_debug_standalone_dlls (method) - can_debug_standalone_dlls(self) -> bool +ida_idd.debugger_t.can_debug_standalone_dlls(self) -> bool -ida_idd.debugger_t.check_bpt (method) - check_bpt(self, bptvc, type, ea, len) -> drc_t - - @param bptvc: int * - @param type: bpttype_t - @param ea: ea_t - @param len: int +ida_idd.debugger_t.check_bpt(self, bptvc: "int *", type: "bpttype_t", ea: ida_idaapi.ea_t, len: int) -> "drc_t" -ida_idd.debugger_t.cleanup_appcall (method) - cleanup_appcall(self, tid) -> drc_t - - @param tid: thid_t +ida_idd.debugger_t.cleanup_appcall(self, tid: "thid_t") -> "drc_t" -ida_idd.debugger_t.close_file (method) - close_file(self, fn) - - @param fn: int +ida_idd.debugger_t.close_file(self, fn: int) -> None -ida_idd.debugger_t.dbg_enable_trace (method) - dbg_enable_trace(self, tid, enable, trace_flags) -> bool - - @param tid: thid_t - @param enable: bool - @param trace_flags: int +ida_idd.debugger_t.dbg_enable_trace(self, tid: "thid_t", enable: bool, trace_flags: int) -> bool -ida_idd.debugger_t.default_regclasses (variable) +ida_idd.debugger_t.default_regclasses Mask of default printed register classes. -ida_idd.debugger_t.detach_process (method) - detach_process(self) -> drc_t - -ida_idd.debugger_t.ev_appcall (variable) - Call application function. This event calls a function from the debugged - application. This event is generated in debthread Available if HAS_APPCALL is - set - - @retval DRC_NONE - @retval DRC_OK,see: BLOB_EA - -ida_idd.debugger_t.ev_attach_process (variable) - Attach to an existing running process. event_id should be equal to -1 if not - attaching to a crashed process. This event is generated in debthread. Available - if DBG_HAS_ATTACH_PROCESS is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_bin_search (variable) - Search for a binary pattern in the program. - - @return: DRC_OK EA contains the binary pattern address - @retval DRC_FAILED: not found - @retval DRC_NONE: not implemented - @retval DRC_NETERR,DRC_ERROR - -ida_idd.debugger_t.ev_check_bpt (variable) - Is it possible to set breakpoint? This event is generated in debthread or in the - main thread if debthread is not running yet. It is generated to verify hardware - breakpoints. Available if DBG_HAS_CHECK_BPT is set - - @return: DRC_OK, DRC_NONE - -ida_idd.debugger_t.ev_cleanup_appcall (variable) - Cleanup after appcall(). The debugger module must keep the stack blob in the - memory until this event is generated. It will be generated by the kernel for - each successful appcall(). There is an exception: if APPCALL_MANUAL, IDA may not - call cleanup_appcall. If the user selects to terminate a manual appcall, then - cleanup_appcall will be generated. Otherwise, the debugger module should - terminate the appcall when the generated event returns. This event is generated - in debthread. Available if HAS_APPCALL is set - - @retval DRC_EVENTS: success, there are pending events - @retval DRC_OK: success - @retval DRC_FAILED: failed - @retval DRC_NETERR: network error - -ida_idd.debugger_t.ev_close_file (variable) - @return: ignored - -ida_idd.debugger_t.ev_dbg_enable_trace (variable) - Enable/Disable tracing. The kernel will generated this event if the debugger - plugin set DBG_FLAG_TRACER_MODULE. TRACE_FLAGS can be a set of #STEP_TRACE, - #INSN_TRACE, #BBLK_TRACE or #FUNC_TRACE. This event is generated in the main - thread. - - @return: DRC_OK, DRC_FAILED, DRC_NONE - -ida_idd.debugger_t.ev_detach_process (variable) - Detach from the debugged process. May be generated while the process is running - or suspended. Must detach from the process in any case. The kernel will - repeatedly call get_debug_event() until PROCESS_DETACHED is received. In this - mode, all other events will be automatically handled and process will be - resumed. This event is generated from debthread. Available if - DBG_HAS_DETACH_PROCESS is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_eval_lowcnd (variable) - Evaluate a low level breakpoint condition at 'ea'. Other evaluation errors are - displayed in a dialog box. This call is used by IDA when the process has already - been temporarily suspended for some reason and IDA has to decide whether the - process should be resumed or definitely suspended because of a breakpoint with a - low level condition. This event is generated in debthread. - - @retval DRC_OK: condition is satisfied - @retval DRC_FAILED: not satisfied - @retval DRC_NETERR: network error - -ida_idd.debugger_t.ev_exit_process (variable) - Stop the process. May be generated while the process is running or suspended. - Must terminate the process in any case. The kernel will repeatedly call - get_debug_event() until PROCESS_EXITED is received. In this mode, all other - events will be automatically handled and process will be resumed. This event is - generated in debthread. Must be implemented. - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_get_debapp_attrs (variable) - Retrieve process- and debugger-specific runtime attributes. This event is - generated in the main thread. - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_get_debmod_extensions (variable) - Get pointer to debugger specific events. This event returns a pointer to a - structure that holds pointers to debugger module specific events. For - information on the structure layout, please check the corresponding debugger - module. Most debugger modules return nullptr because they do not have any - extensions. Available extensions may be generated from plugins. This event is - generated in the main thread. - - @return: DRC_NONE, DRC_OK see EXT - -ida_idd.debugger_t.ev_get_debug_event (variable) - Get a pending debug event and suspend the process. This event will be generated - regularly by IDA. This event is generated in debthread. IMPORTANT: the - BREAKPOINT/EXCEPTION/STEP events must be reported only after reporting other - pending events for a thread. Must be implemented. - - @retval ignored - -ida_idd.debugger_t.ev_get_memory_info (variable) - Get information on the memory ranges. The debugger module fills 'ranges'. The - returned vector must be sorted. This event is generated in debthread. Must be - implemented. - - @retval DRC_OK: new memory layout is returned - @retval DRC_FAILED,DRC_NETERR,DRC_NOPROC,DRC_NOCHG,DRC_IDBSEG - -ida_idd.debugger_t.ev_get_processes (variable) - Return information about the running processes. This event is generated in the - main thread. Available if DBG_HAS_GET_PROCESSES is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_get_srcinfo_path (variable) - Get the path to a file containing source debug info for the given module. This - allows srcinfo providers to call into the debugger when looking for debug info. - It is useful in certain cases like the iOS debugger, which is a remote debugger - but the remote debugserver does not provide dwarf info. So, we allow the - debugger client to decide where to look for debug info locally. - - @return: DRC_NONE, DRC_OK result stored in PATH - -ida_idd.debugger_t.ev_init_debugger (variable) - Initialize debugger. This event is generated in the main thread. - - @return: DRC_OK, DRC_FAILED - -ida_idd.debugger_t.ev_is_tracing_enabled (variable) - Is tracing enabled? The kernel will generated this event if the debugger plugin - set DBG_FLAG_TRACER_MODULE. TRACE_BIT can be one of the following: #STEP_TRACE, - #INSN_TRACE, #BBLK_TRACE or #FUNC_TRACE - - @retval DRC_OK: bit is set - @retval DRC_NONE: bit is not set or not implemented - -ida_idd.debugger_t.ev_map_address (variable) - Map process address. The debugger module may ignore this event. This event is - generated in debthread. IDA will generate this event only if DBG_HAS_MAP_ADDRESS - is set. - - @return: DRC_NONE, DRC_OK see MAPPED - -ida_idd.debugger_t.ev_open_file (variable) - @retval (int): handle - @retval -1: error - -ida_idd.debugger_t.ev_read_file (variable) - @retval number: of read bytes - -ida_idd.debugger_t.ev_read_memory (variable) - Read process memory. This event is generated in debthread. - - @return: DRC_OK, DRC_FAILED, DRC_NOPROC - -ida_idd.debugger_t.ev_read_registers (variable) - Read thread registers. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_rebase_if_required_to (variable) - Rebase database if the debugged program has been rebased by the system. This - event is generated in the main thread. - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_request_pause (variable) - Prepare to pause the process. Normally the next get_debug_event() will pause the - process If the process is sleeping, then the pause will not occur until the - process wakes up. If the debugger module does not react to this event, then it - will be impossible to pause the program. This event is generated in debthread. - Available if DBG_HAS_REQUEST_PAUSE is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_resume (variable) - Continue after handling the event. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_rexec (variable) - Execute a command on the remote computer. Available if DBG_HAS_REXEC is set - - @return: (int) exit code - -ida_idd.debugger_t.ev_send_ioctl (variable) - Perform a debugger-specific event. This event is generated in debthread - - @retval DRC_... - -ida_idd.debugger_t.ev_set_exception_info (variable) - Set exception handling. This event is generated in debthread or the main thread. - Available if DBG_HAS_SET_EXCEPTION_INFO is set - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_set_resume_mode (variable) - Specify resume action Available if DBG_HAS_SET_RESUME_MODE is set - -ida_idd.debugger_t.ev_start_process (variable) - Start an executable to debug. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_CRC, DRC_FAILED, DRC_NETERR, DRC_NOFILE - -ida_idd.debugger_t.ev_suspended (variable) - This event will be generated by the kernel each time it has suspended the - debuggee process and refreshed the database. The debugger module may add - information to the database if necessary. - - The reason for introducing this event is that when an event like LOAD_DLL - happens, the database does not reflect the memory state yet and therefore we - can't add information about the dll into the database in the get_debug_event() - function. Only when the kernel has adjusted the database we can do it. Example: - for loaded PE DLLs we can add the exported function names to the list of debug - names (see set_debug_names()). - - This event is generated in the main thread. - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_term_debugger (variable) - Terminate debugger. This event is generated in the main thread. - - @return: DRC_OK, DRC_FAILED - -ida_idd.debugger_t.ev_thread_continue (variable) - Resume a suspended thread Available if DBG_HAS_THREAD_CONTINUE is set - -ida_idd.debugger_t.ev_thread_get_sreg_base (variable) - Get information about the base of a segment register. Currently used by the IBM - PC module to resolve references like fs:0. This event is generated in debthread. - Available if DBG_HAS_THREAD_GET_SREG_BASE is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_thread_suspend (variable) - Suspend a running thread Available if DBG_HAS_THREAD_SUSPEND is set - -ida_idd.debugger_t.ev_update_bpts (variable) - Add/del breakpoints. bpts array contains nadd bpts to add, followed by ndel bpts - to del. This event is generated in debthread. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_update_call_stack (variable) - Calculate the call stack trace for the given thread. This event is generated - when the process is suspended and should fill the 'trace' object with the - information about the current call stack. If this event returns DRC_NONE, IDA - will try to invoke a processor-specific mechanism (see - processor_t::ev_update_call_stack). If the current processor module does not - implement stack tracing, then IDA will fall back to a generic algorithm (based - on the frame pointer chain) to calculate the trace. This event is ideal if the - debugging targets manage stack frames in a peculiar way, requiring special - analysis. This event is generated in the main thread. Available if - DBG_HAS_UPDATE_CALL_STACK is set - - @retval DRC_NONE: false or not implemented - @return: DRC_OK success - -ida_idd.debugger_t.ev_update_lowcnds (variable) - Update low-level (server side) breakpoint conditions. This event is generated in - debthread. - - @return: DRC_OK, DRC_NETERR - -ida_idd.debugger_t.ev_write_file (variable) - @retval number: of written bytes - -ida_idd.debugger_t.ev_write_memory (variable) - Write process memory. This event is generated in debthread. - - @retval DRC_OK,DRC_FAILED,DRC_NOPROC - -ida_idd.debugger_t.ev_write_register (variable) - Write one thread register. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.eval_lowcnd (method) - eval_lowcnd(self, tid, ea) -> drc_t - - @param tid: thid_t - @param ea: ea_t - -ida_idd.debugger_t.exit_process (method) - exit_process(self) -> drc_t - -ida_idd.debugger_t.fake_memory (method) - fake_memory(self) -> bool - -ida_idd.debugger_t.filetype (variable) - Input file type for the instant debugger. This value will be used after - attaching to a new process. - -ida_idd.debugger_t.flags2 (variable) - Debugger module features - -ida_idd.debugger_t.get_debapp_attrs (method) - get_debapp_attrs(self, out_pattrs) -> bool - - @param out_pattrs: debapp_attrs_t * - -ida_idd.debugger_t.get_debmod_extensions (method) - get_debmod_extensions(self) -> void const * - -ida_idd.debugger_t.get_debug_event (method) - get_debug_event(self, event, timeout_ms) -> gdecode_t - - @param event: debug_event_t * - @param timeout_ms: int - -ida_idd.debugger_t.get_memory_info (method) - get_memory_info(self, ranges) -> drc_t - - @param ranges: meminfo_vec_t & - -ida_idd.debugger_t.get_processes (method) - get_processes(self, procs) -> drc_t - - @param procs: procinfo_vec_t * - -ida_idd.debugger_t.get_srcinfo_path (method) - get_srcinfo_path(self, path, base) -> bool - - @param path: qstring * - @param base: ea_t - -ida_idd.debugger_t.has_appcall (method) - has_appcall(self) -> bool - -ida_idd.debugger_t.has_attach_process (method) - has_attach_process(self) -> bool - -ida_idd.debugger_t.has_check_bpt (method) - has_check_bpt(self) -> bool - -ida_idd.debugger_t.has_detach_process (method) - has_detach_process(self) -> bool - -ida_idd.debugger_t.has_get_processes (method) - has_get_processes(self) -> bool +ida_idd.debugger_t.detach_process(self) -> "drc_t" -ida_idd.debugger_t.has_map_address (method) - has_map_address(self) -> bool - -ida_idd.debugger_t.has_open_file (method) - has_open_file(self) -> bool +ida_idd.debugger_t.ev_appcall + Call application function. This event calls a function from the debugged application. This event is generated in debthread Available if HAS_APPCALL is set + -ida_idd.debugger_t.has_request_pause (method) - has_request_pause(self) -> bool +ida_idd.debugger_t.ev_attach_process + Attach to an existing running process. event_id should be equal to -1 if not attaching to a crashed process. This event is generated in debthread. Available if DBG_HAS_ATTACH_PROCESS is set + -ida_idd.debugger_t.has_rexec (method) - has_rexec(self) -> bool +ida_idd.debugger_t.ev_bin_search + Search for a binary pattern in the program. + -ida_idd.debugger_t.has_set_exception_info (method) - has_set_exception_info(self) -> bool +ida_idd.debugger_t.ev_check_bpt + Is it possible to set breakpoint? This event is generated in debthread or in the main thread if debthread is not running yet. It is generated to verify hardware breakpoints. Available if DBG_HAS_CHECK_BPT is set + -ida_idd.debugger_t.has_set_resume_mode (method) - has_set_resume_mode(self) -> bool +ida_idd.debugger_t.ev_cleanup_appcall + Cleanup after appcall(). The debugger module must keep the stack blob in the memory until this event is generated. It will be generated by the kernel for each successful appcall(). There is an exception: if APPCALL_MANUAL, IDA may not call cleanup_appcall. If the user selects to terminate a manual appcall, then cleanup_appcall will be generated. Otherwise, the debugger module should terminate the appcall when the generated event returns. This event is generated in debthread. Available if HAS_APPCALL is set + -ida_idd.debugger_t.has_soft_bpt (method) - has_soft_bpt(self) -> bool +ida_idd.debugger_t.ev_dbg_enable_trace + Enable/Disable tracing. The kernel will generated this event if the debugger plugin set DBG_FLAG_TRACER_MODULE. TRACE_FLAGS can be a set of STEP_TRACE, INSN_TRACE, BBLK_TRACE or FUNC_TRACE. This event is generated in the main thread. + -ida_idd.debugger_t.has_thread_continue (method) - has_thread_continue(self) -> bool +ida_idd.debugger_t.ev_detach_process + Detach from the debugged process. May be generated while the process is running or suspended. Must detach from the process in any case. The kernel will repeatedly call get_debug_event() until PROCESS_DETACHED is received. In this mode, all other events will be automatically handled and process will be resumed. This event is generated from debthread. Available if DBG_HAS_DETACH_PROCESS is set + -ida_idd.debugger_t.has_thread_get_sreg_base (method) - has_thread_get_sreg_base(self) -> bool +ida_idd.debugger_t.ev_eval_lowcnd + Evaluate a low level breakpoint condition at 'ea'. Other evaluation errors are displayed in a dialog box. This call is used by IDA when the process has already been temporarily suspended for some reason and IDA has to decide whether the process should be resumed or definitely suspended because of a breakpoint with a low level condition. This event is generated in debthread. + -ida_idd.debugger_t.has_thread_suspend (method) - has_thread_suspend(self) -> bool +ida_idd.debugger_t.ev_exit_process + Stop the process. May be generated while the process is running or suspended. Must terminate the process in any case. The kernel will repeatedly call get_debug_event() until PROCESS_EXITED is received. In this mode, all other events will be automatically handled and process will be resumed. This event is generated in debthread. Must be implemented. + -ida_idd.debugger_t.has_update_call_stack (method) - has_update_call_stack(self) -> bool +ida_idd.debugger_t.ev_get_debapp_attrs + Retrieve process- and debugger-specific runtime attributes. This event is generated in the main thread. + -ida_idd.debugger_t.id (variable) +ida_idd.debugger_t.ev_get_debmod_extensions + Get pointer to debugger specific events. This event returns a pointer to a structure that holds pointers to debugger module specific events. For information on the structure layout, please check the corresponding debugger module. Most debugger modules return nullptr because they do not have any extensions. Available extensions may be generated from plugins. This event is generated in the main thread. + + +ida_idd.debugger_t.ev_get_debug_event + Get a pending debug event and suspend the process. This event will be generated regularly by IDA. This event is generated in debthread. IMPORTANT: the BREAKPOINT/EXCEPTION/STEP events must be reported only after reporting other pending events for a thread. Must be implemented. + + +ida_idd.debugger_t.ev_get_dynamic_register_set + Ask debuger to send dynamic register set + + +ida_idd.debugger_t.ev_get_memory_info + Get information on the memory ranges. The debugger module fills 'ranges'. The returned vector must be sorted. This event is generated in debthread. Must be implemented. + + +ida_idd.debugger_t.ev_get_processes + Return information about the running processes. This event is generated in the main thread. Available if DBG_HAS_GET_PROCESSES is set + + +ida_idd.debugger_t.ev_get_srcinfo_path + Get the path to a file containing source debug info for the given module. This allows srcinfo providers to call into the debugger when looking for debug info. It is useful in certain cases like the iOS debugger, which is a remote debugger but the remote debugserver does not provide dwarf info. So, we allow the debugger client to decide where to look for debug info locally. + + +ida_idd.debugger_t.ev_init_debugger + Initialize debugger. This event is generated in the main thread. + + +ida_idd.debugger_t.ev_is_tracing_enabled + Is tracing enabled? The kernel will generated this event if the debugger plugin set DBG_FLAG_TRACER_MODULE. TRACE_BIT can be one of the following: STEP_TRACE, INSN_TRACE, BBLK_TRACE or FUNC_TRACE + + +ida_idd.debugger_t.ev_map_address + Map process address. The debugger module may ignore this event. This event is generated in debthread. IDA will generate this event only if DBG_HAS_MAP_ADDRESS is set. + + +ida_idd.debugger_t.ev_read_memory + Read process memory. This event is generated in debthread. + + +ida_idd.debugger_t.ev_read_registers + Read thread registers. This event is generated in debthread. Must be implemented. + + +ida_idd.debugger_t.ev_rebase_if_required_to + Rebase database if the debugged program has been rebased by the system. This event is generated in the main thread. + + +ida_idd.debugger_t.ev_request_pause + Prepare to pause the process. Normally the next get_debug_event() will pause the process If the process is sleeping, then the pause will not occur until the process wakes up. If the debugger module does not react to this event, then it will be impossible to pause the program. This event is generated in debthread. Available if DBG_HAS_REQUEST_PAUSE is set + + +ida_idd.debugger_t.ev_resume + Continue after handling the event. This event is generated in debthread. Must be implemented. + + +ida_idd.debugger_t.ev_rexec + Execute a command on the remote computer. Available if DBG_HAS_REXEC is set + + +ida_idd.debugger_t.ev_send_ioctl + Perform a debugger-specific event. This event is generated in debthread + + +ida_idd.debugger_t.ev_set_backwards + Set whether the debugger should continue backwards or forwards. This event is generated in debthread. Available if DBG_FLAG_TTD is set + + +ida_idd.debugger_t.ev_set_dbg_options + Set debugger options (parameters that are specific to the debugger module). + + +ida_idd.debugger_t.ev_set_exception_info + Set exception handling. This event is generated in debthread or the main thread. Available if DBG_HAS_SET_EXCEPTION_INFO is set + + +ida_idd.debugger_t.ev_set_resume_mode + Specify resume action Available if DBG_HAS_SET_RESUME_MODE is set + + +ida_idd.debugger_t.ev_start_process + Start an executable to debug. This event is generated in debthread. Must be implemented. + + +ida_idd.debugger_t.ev_suspended + This event will be generated by the kernel each time it has suspended the debuggee process and refreshed the database. The debugger module may add information to the database if necessary. + The reason for introducing this event is that when an event like LOAD_DLL happens, the database does not reflect the memory state yet and therefore we can't add information about the dll into the database in the get_debug_event() function. Only when the kernel has adjusted the database we can do it. Example: for loaded PE DLLs we can add the exported function names to the list of debug names (see set_debug_names()). + This event is generated in the main thread. + + +ida_idd.debugger_t.ev_term_debugger + Terminate debugger. This event is generated in the main thread. + + +ida_idd.debugger_t.ev_thread_continue + Resume a suspended thread Available if DBG_HAS_THREAD_CONTINUE is set + + +ida_idd.debugger_t.ev_thread_get_sreg_base + Get information about the base of a segment register. Currently used by the IBM PC module to resolve references like fs:0. This event is generated in debthread. Available if DBG_HAS_THREAD_GET_SREG_BASE is set + + +ida_idd.debugger_t.ev_thread_suspend + Suspend a running thread Available if DBG_HAS_THREAD_SUSPEND is set + + +ida_idd.debugger_t.ev_update_bpts + Add/del breakpoints. bpts array contains nadd bpts to add, followed by ndel bpts to del. This event is generated in debthread. + + +ida_idd.debugger_t.ev_update_call_stack + Calculate the call stack trace for the given thread. This event is generated when the process is suspended and should fill the 'trace' object with the information about the current call stack. If this event returns DRC_NONE, IDA will try to invoke a processor-specific mechanism (see processor_t::ev_update_call_stack). If the current processor module does not implement stack tracing, then IDA will fall back to a generic algorithm (based on the frame pointer chain) to calculate the trace. This event is ideal if the debugging targets manage stack frames in a peculiar way, requiring special analysis. This event is generated in the main thread. Available if DBG_HAS_UPDATE_CALL_STACK is set + + +ida_idd.debugger_t.ev_update_lowcnds + Update low-level (server side) breakpoint conditions. This event is generated in debthread. + + +ida_idd.debugger_t.ev_write_memory + Write process memory. This event is generated in debthread. + + +ida_idd.debugger_t.ev_write_register + Write one thread register. This event is generated in debthread. Must be implemented. + + +ida_idd.debugger_t.eval_lowcnd(self, tid: "thid_t", ea: ida_idaapi.ea_t) -> "drc_t" + +ida_idd.debugger_t.exit_process(self) -> "drc_t" + +ida_idd.debugger_t.fake_memory(self) -> bool + +ida_idd.debugger_t.filetype + Input file type for the instant debugger. This value will be used after attaching to a new process. + + +ida_idd.debugger_t.get_debapp_attrs(self, out_pattrs: "debapp_attrs_t") -> bool + +ida_idd.debugger_t.get_debmod_extensions(self) -> "void const *" + +ida_idd.debugger_t.get_debug_event(self, event: "debug_event_t", timeout_ms: int) -> "gdecode_t" + +ida_idd.debugger_t.get_dynamic_register_set(self, regset: "dynamic_register_set_t *") -> bool + +ida_idd.debugger_t.get_memory_info(self, ranges: "meminfo_vec_t") -> "drc_t" + +ida_idd.debugger_t.get_processes(self, procs: "procinfo_vec_t") -> "drc_t" + +ida_idd.debugger_t.get_srcinfo_path(self, path: str, base: ida_idaapi.ea_t) -> bool + +ida_idd.debugger_t.has_appcall(self) -> bool + +ida_idd.debugger_t.has_attach_process(self) -> bool + +ida_idd.debugger_t.has_check_bpt(self) -> bool + +ida_idd.debugger_t.has_detach_process(self) -> bool + +ida_idd.debugger_t.has_get_processes(self) -> bool + +ida_idd.debugger_t.has_map_address(self) -> bool + +ida_idd.debugger_t.has_open_file(self) -> bool + +ida_idd.debugger_t.has_request_pause(self) -> bool + +ida_idd.debugger_t.has_rexec(self) -> bool + +ida_idd.debugger_t.has_set_exception_info(self) -> bool + +ida_idd.debugger_t.has_set_resume_mode(self) -> bool + +ida_idd.debugger_t.has_soft_bpt(self) -> bool + +ida_idd.debugger_t.has_thread_continue(self) -> bool + +ida_idd.debugger_t.has_thread_get_sreg_base(self) -> bool + +ida_idd.debugger_t.has_thread_suspend(self) -> bool + +ida_idd.debugger_t.has_update_call_stack(self) -> bool + +ida_idd.debugger_t.have_set_options(self) -> bool + +ida_idd.debugger_t.id one of Debugger API module id -ida_idd.debugger_t.init_debugger (method) - init_debugger(self, hostname, portnum, password) -> bool - - @param hostname: char const * - @param portnum: int - @param password: char const * +ida_idd.debugger_t.init_debugger(self, hostname: str, portnum: int, password: str) -> bool -ida_idd.debugger_t.is_remote (method) - is_remote(self) -> bool +ida_idd.debugger_t.is_remote(self) -> bool -ida_idd.debugger_t.is_resmod_avail (method) - is_resmod_avail(self, resmod) -> bool - - @param resmod: int +ida_idd.debugger_t.is_resmod_avail(self, resmod: int) -> bool -ida_idd.debugger_t.is_safe (method) - is_safe(self) -> bool +ida_idd.debugger_t.is_safe(self) -> bool -ida_idd.debugger_t.is_tracing_enabled (method) - is_tracing_enabled(self, tid, tracebit) -> bool - - @param tid: thid_t - @param tracebit: int +ida_idd.debugger_t.is_tracing_enabled(self, tid: "thid_t", tracebit: int) -> bool -ida_idd.debugger_t.map_address (method) - map_address(self, off, regs, regnum) -> ea_t - - @param off: ea_t - @param regs: regval_t const * - @param regnum: int +ida_idd.debugger_t.is_ttd(self) -> bool -ida_idd.debugger_t.may_disturb (method) - may_disturb(self) -> bool +ida_idd.debugger_t.map_address(self, off: ida_idaapi.ea_t, regs: "regval_t", regnum: int) -> ida_idaapi.ea_t -ida_idd.debugger_t.may_take_exit_snapshot (method) - may_take_exit_snapshot(self) -> bool +ida_idd.debugger_t.may_disturb(self) -> bool -ida_idd.debugger_t.memory_page_size (variable) +ida_idd.debugger_t.may_take_exit_snapshot(self) -> bool + +ida_idd.debugger_t.memory_page_size Size of a memory page. Usually 4K. -ida_idd.debugger_t.must_have_hostname (method) - must_have_hostname(self) -> bool +ida_idd.debugger_t.must_have_hostname(self) -> bool -ida_idd.debugger_t.name (variable) +ida_idd.debugger_t.name Short debugger name like win32 or linux. -ida_idd.debugger_t.nregs (variable) +ida_idd.debugger_t.nregisters Number of registers. -ida_idd.debugger_t.open_file (method) - open_file(self, file, fsize, readonly) -> int - - @param file: char const * - @param fsize: uint64 * - @param readonly: bool +ida_idd.debugger_t.open_file(self, file: str, fsize: "uint64 *", readonly: bool) -> int -ida_idd.debugger_t.processor (variable) - Required processor name. Used for instant debugging to load the correct - processor module +ida_idd.debugger_t.processor + Required processor name. Used for instant debugging to load the correct processor module + -ida_idd.debugger_t.read_file (method) - read_file(self, fn, off, buf, size) -> ssize_t - - @param fn: int - @param off: qoff64_t - @param buf: void * - @param size: size_t +ida_idd.debugger_t.read_file(self, fn: int, off: "qoff64_t", buf: "void *", size: "size_t") -> "ssize_t" -ida_idd.debugger_t.read_memory (method) - read_memory(self, nbytes, ea, buffer, size) -> drc_t - - @param nbytes: size_t * - @param ea: ea_t - @param buffer: void * - @param size: size_t +ida_idd.debugger_t.read_memory(self, nbytes: "size_t *", ea: ida_idaapi.ea_t, buffer: "void *", size: "size_t") -> "drc_t" -ida_idd.debugger_t.read_registers (method) - read_registers(self, tid, clsmask, values) -> drc_t - - @param tid: thid_t - @param clsmask: int - @param values: regval_t * +ida_idd.debugger_t.read_registers(self, tid: "thid_t", clsmask: int, values: "regval_t") -> "drc_t" -ida_idd.debugger_t.rebase_if_required_to (method) - rebase_if_required_to(self, new_base) - - @param new_base: ea_t +ida_idd.debugger_t.rebase_if_required_to(self, new_base: ida_idaapi.ea_t) -> None -ida_idd.debugger_t.regclasses (variable) +ida_idd.debugger_t.regclasses Array of register class names. -ida_idd.debugger_t.registers (variable) +ida_idd.debugger_t.registers Array of registers. Use regs() to access it. -ida_idd.debugger_t.regs (method) - regs(self, idx) -> register_info_t - - @param idx: int +ida_idd.debugger_t.regs(self, idx: int) -> "register_info_t &" -ida_idd.debugger_t.request_pause (method) - request_pause(self) -> drc_t +ida_idd.debugger_t.request_pause(self) -> "drc_t" -ida_idd.debugger_t.resume (method) - resume(self, event) -> drc_t - - @param event: debug_event_t const * +ida_idd.debugger_t.resume(self, event: "debug_event_t") -> "drc_t" -ida_idd.debugger_t.resume_modes (variable) - Resume modes +ida_idd.debugger_t.resume_modes + Resume modes + -ida_idd.debugger_t.rexec (method) - rexec(self, cmdline) -> int - - @param cmdline: char const * +ida_idd.debugger_t.rexec(self, cmdline: str) -> int -ida_idd.debugger_t.send_ioctl (method) - send_ioctl(self, fn, buf, poutbuf, poutsize) -> drc_t - - @param fn: int - @param buf: void const * - @param poutbuf: void ** - @param poutsize: ssize_t * +ida_idd.debugger_t.send_ioctl(self, fn: int, buf: "void const *", poutbuf: "void **", poutsize: "ssize_t *") -> "drc_t" -ida_idd.debugger_t.set_exception_info (method) - set_exception_info(self, info, qty) - - @param info: exception_info_t const * - @param qty: int +ida_idd.debugger_t.set_backwards(self, backwards: bool) -> "drc_t" -ida_idd.debugger_t.set_resume_mode (method) - set_resume_mode(self, tid, resmod) -> drc_t - - @param tid: thid_t - @param resmod: enum resume_mode_t +ida_idd.debugger_t.set_exception_info(self, info: "exception_info_t", qty: int) -> None -ida_idd.debugger_t.start_process (method) - start_process(self, path, args, envs, startdir, dbg_proc_flags, input_path, input_file_crc32) -> drc_t - - @param path: char const * - @param args: char const * - @param envs: launch_env_t * - @param startdir: char const * - @param dbg_proc_flags: uint32 - @param input_path: char const * - @param input_file_crc32: uint32 +ida_idd.debugger_t.set_resume_mode(self, tid: "thid_t", resmod: "resume_mode_t") -> "drc_t" -ida_idd.debugger_t.supports_debthread (method) - supports_debthread(self) -> bool +ida_idd.debugger_t.start_process(self, path: str, args: str, envs: "launch_env_t", startdir: str, dbg_proc_flags: int, input_path: str, input_file_crc32: int) -> "drc_t" -ida_idd.debugger_t.supports_lowcnds (method) - supports_lowcnds(self) -> bool +ida_idd.debugger_t.supports_debthread(self) -> bool -ida_idd.debugger_t.suspended (method) - suspended(self, dlls_added, thr_names=None) - - @param dlls_added: bool - @param thr_names: thread_name_vec_t * +ida_idd.debugger_t.supports_lowcnds(self) -> bool -ida_idd.debugger_t.term_debugger (method) - term_debugger(self) -> bool +ida_idd.debugger_t.suspended(self, dlls_added: bool, thr_names: "thread_name_vec_t *" = None) -> None -ida_idd.debugger_t.thread_continue (method) - thread_continue(self, tid) -> drc_t - - @param tid: thid_t +ida_idd.debugger_t.term_debugger(self) -> bool -ida_idd.debugger_t.thread_get_sreg_base (method) - thread_get_sreg_base(self, answer, tid, sreg_value) -> drc_t - - @param answer: ea_t * - @param tid: thid_t - @param sreg_value: int +ida_idd.debugger_t.thread_continue(self, tid: "thid_t") -> "drc_t" -ida_idd.debugger_t.thread_suspend (method) - thread_suspend(self, tid) -> drc_t - - @param tid: thid_t +ida_idd.debugger_t.thread_get_sreg_base(self, answer: "ea_t *", tid: "thid_t", sreg_value: int) -> "drc_t" -ida_idd.debugger_t.update_bpts (method) - update_bpts(self, nbpts, bpts, nadd, ndel) -> drc_t - - @param nbpts: int * - @param bpts: update_bpt_info_t * - @param nadd: int - @param ndel: int +ida_idd.debugger_t.thread_suspend(self, tid: "thid_t") -> "drc_t" -ida_idd.debugger_t.update_call_stack (method) - update_call_stack(self, tid, trace) -> drc_t - - @param tid: thid_t - @param trace: call_stack_t * +ida_idd.debugger_t.update_bpts(self, nbpts: "int *", bpts: "update_bpt_info_t *", nadd: int, ndel: int) -> "drc_t" -ida_idd.debugger_t.update_lowcnds (method) - update_lowcnds(self, nupdated, lowcnds, nlowcnds) -> drc_t - - @param nupdated: int * - @param lowcnds: lowcnd_t const * - @param nlowcnds: int +ida_idd.debugger_t.update_call_stack(self, tid: "thid_t", trace: "call_stack_t") -> "drc_t" -ida_idd.debugger_t.use_memregs (method) - use_memregs(self) -> bool +ida_idd.debugger_t.update_lowcnds(self, nupdated: "int *", lowcnds: "lowcnd_t const *", nlowcnds: int) -> "drc_t" -ida_idd.debugger_t.use_sregs (method) - use_sregs(self) -> bool +ida_idd.debugger_t.use_memregs(self) -> bool -ida_idd.debugger_t.version (variable) - Expected kernel version, should be IDD_INTERFACE_VERSION +ida_idd.debugger_t.use_sregs(self) -> bool -ida_idd.debugger_t.virtual_threads (method) - virtual_threads(self) -> bool +ida_idd.debugger_t.version + Expected kernel version, should be IDD_INTERFACE_VERSION + -ida_idd.debugger_t.write_file (method) - write_file(self, fn, off, buf) -> ssize_t - - @param fn: int - @param off: qoff64_t - @param buf: void const * +ida_idd.debugger_t.virtual_threads(self) -> bool -ida_idd.debugger_t.write_memory (method) - write_memory(self, nbytes, ea, buffer, size) -> drc_t - - @param nbytes: size_t * - @param ea: ea_t - @param buffer: void const * - @param size: size_t +ida_idd.debugger_t.write_file(self, fn: int, off: "qoff64_t", buf: "void const *") -> "ssize_t" -ida_idd.debugger_t.write_register (method) - write_register(self, tid, regidx, value) -> drc_t - - @param tid: thid_t - @param regidx: int - @param value: regval_t const * +ida_idd.debugger_t.write_memory(self, nbytes: "size_t *", ea: ida_idaapi.ea_t, buffer: "void const *", size: "size_t") -> "drc_t" -ida_idd.dyn_register_info_array (class) - Proxy of C++ dynamic_wrapped_array_t< register_info_t > class. +ida_idd.debugger_t.write_register(self, tid: "thid_t", regidx: int, value: "regval_t") -> "drc_t" -ida_idd.dyn_register_info_array.__getitem__ (method) - __getitem__(self, i) -> register_info_t - - @param i: size_t +ida_idd.dyn_register_info_array -ida_idd.dyn_register_info_array.__init__ (method) - __init__(self, _data, _count) -> dyn_register_info_array - - @param _data: register_info_t * - @param _count: size_t +ida_idd.dyn_register_info_array.__getitem__(self, i: "size_t") -> "register_info_t const &" -ida_idd.dyn_register_info_array.__len__ (method) - __len__(self) -> size_t +ida_idd.dyn_register_info_array.__init__(self, _data: "register_info_t", _count: "size_t") -ida_idd.dyn_register_info_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: register_info_t const & +ida_idd.dyn_register_info_array.__len__(self) -> "size_t" -ida_idd.exception_info_t (class) - Proxy of C++ exception_info_t class. +ida_idd.dyn_register_info_array.__setitem__(self, i: "size_t", v: "register_info_t") -> None -ida_idd.exception_info_t.__init__ (method) - __init__(self) -> exception_info_t - __init__(self, _code, _flags, _name, _desc) -> exception_info_t - - @param _code: uint - @param _flags: uint32 - @param _name: char const * - @param _desc: char const * +ida_idd.exception_info_t -ida_idd.exception_info_t.break_on (method) - break_on(self) -> bool +ida_idd.exception_info_t.__init__(self, *args) + +ida_idd.exception_info_t.break_on(self) -> bool Should we break on the exception? -ida_idd.exception_info_t.code (variable) +ida_idd.exception_info_t.code exception code -ida_idd.exception_info_t.desc (variable) +ida_idd.exception_info_t.desc Long message used to display info about the exception. -ida_idd.exception_info_t.flags (variable) - Exception info flags +ida_idd.exception_info_t.flags + Exception info flags + -ida_idd.exception_info_t.handle (method) - handle(self) -> bool +ida_idd.exception_info_t.handle(self) -> bool Should we handle the exception? -ida_idd.exception_info_t.name (variable) +ida_idd.exception_info_t.name Exception standard name. -ida_idd.excinfo_t (class) - Proxy of C++ excinfo_t class. +ida_idd.excinfo_t -ida_idd.excinfo_t.__init__ (method) - __init__(self) -> excinfo_t +ida_idd.excinfo_t.__init__(self) -ida_idd.excinfo_t.can_cont (variable) +ida_idd.excinfo_t.can_cont Execution of the process can continue after this exception? -ida_idd.excinfo_t.code (variable) +ida_idd.excinfo_t.code Exception code. -ida_idd.excinfo_t.ea (variable) +ida_idd.excinfo_t.ea Possible address referenced by the exception. -ida_idd.excinfo_t.info (variable) +ida_idd.excinfo_t.info Exception message. -ida_idd.excvec_t (class) - Proxy of C++ qvector< exception_info_t > class. - -ida_idd.excvec_t.__getitem__ (method) - __getitem__(self, i) -> exception_info_t - - @param i: size_t - -ida_idd.excvec_t.__init__ (method) - __init__(self) -> excvec_t - __init__(self, x) -> excvec_t - - @param x: qvector< exception_info_t > const & - -ida_idd.excvec_t.__len__ (method) - __len__(self) -> size_t - -ida_idd.excvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: exception_info_t const & - -ida_idd.excvec_t.at (method) - at(self, _idx) -> exception_info_t - - @param _idx: size_t - -ida_idd.excvec_t.begin (method) - begin(self) -> exception_info_t - -ida_idd.excvec_t.capacity (method) - capacity(self) -> size_t - -ida_idd.excvec_t.clear (method) - clear(self) - -ida_idd.excvec_t.empty (method) - empty(self) -> bool - -ida_idd.excvec_t.end (method) - end(self) -> exception_info_t - -ida_idd.excvec_t.erase (method) - erase(self, it) -> exception_info_t - - @param it: qvector< exception_info_t >::iterator - - erase(self, first, last) -> exception_info_t - - @param first: qvector< exception_info_t >::iterator - @param last: qvector< exception_info_t >::iterator - -ida_idd.excvec_t.extract (method) - extract(self) -> exception_info_t - -ida_idd.excvec_t.grow (method) - grow(self, x=exception_info_t()) - - @param x: exception_info_t const & - -ida_idd.excvec_t.inject (method) - inject(self, s, len) - - @param s: exception_info_t * - @param len: size_t - -ida_idd.excvec_t.insert (method) - insert(self, it, x) -> exception_info_t - - @param it: qvector< exception_info_t >::iterator - @param x: exception_info_t const & - -ida_idd.excvec_t.pop_back (method) - pop_back(self) - -ida_idd.excvec_t.push_back (method) - push_back(self, x) - - @param x: exception_info_t const & - - push_back(self) -> exception_info_t - -ida_idd.excvec_t.qclear (method) - qclear(self) - -ida_idd.excvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idd.excvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: exception_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idd.excvec_t.size (method) - size(self) -> size_t - -ida_idd.excvec_t.swap (method) - swap(self, r) - - @param r: qvector< exception_info_t > & - -ida_idd.excvec_t.truncate (method) - truncate(self) - -ida_idd.get_dbg (function) - get_dbg() -> debugger_t - -ida_idd.get_event_bpt_hea (function) - get_event_bpt_hea(ev) -> ea_t - - @param ev: debug_event_t const * - -ida_idd.get_event_exc_code (function) - get_event_exc_code(ev) -> uint - - @param ev: debug_event_t const * - -ida_idd.get_event_exc_ea (function) - get_event_exc_ea(ev) -> ea_t - - @param ev: debug_event_t const * - -ida_idd.get_event_exc_info (function) - get_event_exc_info(ev) -> str - - @param ev: debug_event_t const * - -ida_idd.get_event_info (function) - get_event_info(ev) -> str - - @param ev: debug_event_t const * - -ida_idd.get_event_module_base (function) - get_event_module_base(ev) -> ea_t - - @param ev: debug_event_t const * - -ida_idd.get_event_module_name (function) - get_event_module_name(ev) -> str - - @param ev: debug_event_t const * - -ida_idd.get_event_module_size (function) - get_event_module_size(ev) -> asize_t - - @param ev: debug_event_t const * - -ida_idd.launch_env_t (class) - Proxy of C++ launch_env_t class. - -ida_idd.launch_env_t.__init__ (method) - __init__(self) -> launch_env_t - -ida_idd.meminfo_vec_t (class) - Proxy of C++ meminfo_vec_t class. - -ida_idd.meminfo_vec_t.__init__ (method) - __init__(self) -> meminfo_vec_t - -ida_idd.meminfo_vec_template_t (class) - Proxy of C++ qvector< memory_info_t > class. - -ida_idd.meminfo_vec_template_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< memory_info_t > const & - -ida_idd.meminfo_vec_template_t.__getitem__ (method) - __getitem__(self, i) -> memory_info_t - - @param i: size_t - -ida_idd.meminfo_vec_template_t.__init__ (method) - __init__(self) -> meminfo_vec_template_t - __init__(self, x) -> meminfo_vec_template_t - - @param x: qvector< memory_info_t > const & - -ida_idd.meminfo_vec_template_t.__len__ (method) - __len__(self) -> size_t - -ida_idd.meminfo_vec_template_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< memory_info_t > const & - -ida_idd.meminfo_vec_template_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: memory_info_t const & - -ida_idd.meminfo_vec_template_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.at (method) - at(self, _idx) -> memory_info_t - - @param _idx: size_t - -ida_idd.meminfo_vec_template_t.begin (method) - begin(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.capacity (method) - capacity(self) -> size_t - -ida_idd.meminfo_vec_template_t.clear (method) - clear(self) - -ida_idd.meminfo_vec_template_t.empty (method) - empty(self) -> bool - -ida_idd.meminfo_vec_template_t.end (method) - end(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.erase (method) - erase(self, it) -> memory_info_t - - @param it: qvector< memory_info_t >::iterator - - erase(self, first, last) -> memory_info_t - - @param first: qvector< memory_info_t >::iterator - @param last: qvector< memory_info_t >::iterator - -ida_idd.meminfo_vec_template_t.extract (method) - extract(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.find (method) - find(self, x) -> memory_info_t - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.grow (method) - grow(self, x=memory_info_t()) - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.has (method) - has(self, x) -> bool - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.inject (method) - inject(self, s, len) - - @param s: memory_info_t * - @param len: size_t - -ida_idd.meminfo_vec_template_t.insert (method) - insert(self, it, x) -> memory_info_t - - @param it: qvector< memory_info_t >::iterator - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.pop_back (method) - pop_back(self) - -ida_idd.meminfo_vec_template_t.push_back (method) - push_back(self, x) - - @param x: memory_info_t const & - - push_back(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.qclear (method) - qclear(self) - -ida_idd.meminfo_vec_template_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idd.meminfo_vec_template_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: memory_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idd.meminfo_vec_template_t.size (method) - size(self) -> size_t - -ida_idd.meminfo_vec_template_t.swap (method) - swap(self, r) - - @param r: qvector< memory_info_t > & - -ida_idd.meminfo_vec_template_t.truncate (method) - truncate(self) - -ida_idd.memory_info_t (class) - Proxy of C++ memory_info_t class. - -ida_idd.memory_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: memory_info_t const & - -ida_idd.memory_info_t.__init__ (method) - __init__(self) -> memory_info_t - -ida_idd.memory_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: memory_info_t const & - -ida_idd.memory_info_t.bitness (variable) +ida_idd.excvec_t + +ida_idd.excvec_t.__getitem__(self, i: "size_t") -> "exception_info_t const &" + +ida_idd.excvec_t.__init__(self, *args) + +ida_idd.excvec_t.__len__(self) -> "size_t" + +ida_idd.excvec_t.__setitem__(self, i: "size_t", v: "exception_info_t") -> None + +ida_idd.excvec_t.append(self, x: "exception_info_t") -> None + +ida_idd.excvec_t.at(self, _idx: "size_t") -> "exception_info_t const &" + +ida_idd.excvec_t.begin(self, *args) -> "qvector< exception_info_t >::const_iterator" + +ida_idd.excvec_t.capacity(self) -> "size_t" + +ida_idd.excvec_t.clear(self) -> None + +ida_idd.excvec_t.empty(self) -> bool + +ida_idd.excvec_t.end(self, *args) -> "qvector< exception_info_t >::const_iterator" + +ida_idd.excvec_t.erase(self, *args) -> "qvector< exception_info_t >::iterator" + +ida_idd.excvec_t.extend(self, x: "excvec_t") -> None + +ida_idd.excvec_t.extract(self) -> "exception_info_t *" + +ida_idd.excvec_t.grow(self, *args) -> None + +ida_idd.excvec_t.inject(self, s: "exception_info_t", len: "size_t") -> None + +ida_idd.excvec_t.insert(self, it: "exception_info_t", x: "exception_info_t") -> "qvector< exception_info_t >::iterator" + +ida_idd.excvec_t.pop_back(self) -> None + +ida_idd.excvec_t.push_back(self, *args) -> "exception_info_t &" + +ida_idd.excvec_t.qclear(self) -> None + +ida_idd.excvec_t.reserve(self, cnt: "size_t") -> None + +ida_idd.excvec_t.resize(self, *args) -> None + +ida_idd.excvec_t.size(self) -> "size_t" + +ida_idd.excvec_t.swap(self, r: "excvec_t") -> None + +ida_idd.excvec_t.truncate(self) -> None + +ida_idd.get_dbg() -> "debugger_t *" + +ida_idd.get_debug_event_name(dev: "debug_event_t") -> str + get debug event name + +ida_idd.get_event_bpt_hea(ev: "debug_event_t") -> ida_idaapi.ea_t + +ida_idd.get_event_exc_code(ev: "debug_event_t") -> "uint" + +ida_idd.get_event_exc_ea(ev: "debug_event_t") -> ida_idaapi.ea_t + +ida_idd.get_event_exc_info(ev: "debug_event_t") -> str + +ida_idd.get_event_info(ev: "debug_event_t") -> str + +ida_idd.get_event_module_base(ev: "debug_event_t") -> ida_idaapi.ea_t + +ida_idd.get_event_module_name(ev: "debug_event_t") -> str + +ida_idd.get_event_module_size(ev: "debug_event_t") -> "asize_t" + +ida_idd.ieee2cpu(cpu_fpval_out: "void *", ieee: "fpvalue_t const &", size: int) -> int + Convert a floating point number in IDA's internal format to CPU native format. + + @param cpu_fpval_out: output buffer + @param ieee: floating point number of IDA's internal format + @param size: size of cpu_fpval in bytes (size of the output buffer) + @returns Floating point/IEEE Conversion codes + +ida_idd.launch_env_t + +ida_idd.launch_env_t.__init__(self) + +ida_idd.launch_env_t.envs(self) -> "PyObject *" + +ida_idd.launch_env_t.set(self, envvar: str, value: str) -> None + +ida_idd.meminfo_vec_t + +ida_idd.meminfo_vec_t.__init__(self) + +ida_idd.meminfo_vec_template_t + +ida_idd.meminfo_vec_template_t.__eq__(self, r: "meminfo_vec_template_t") -> bool + +ida_idd.meminfo_vec_template_t.__getitem__(self, i: "size_t") -> "memory_info_t const &" + +ida_idd.meminfo_vec_template_t.__init__(self, *args) + +ida_idd.meminfo_vec_template_t.__len__(self) -> "size_t" + +ida_idd.meminfo_vec_template_t.__ne__(self, r: "meminfo_vec_template_t") -> bool + +ida_idd.meminfo_vec_template_t.__setitem__(self, i: "size_t", v: "memory_info_t") -> None + +ida_idd.meminfo_vec_template_t._del(self, x: "memory_info_t") -> bool + +ida_idd.meminfo_vec_template_t.add_unique(self, x: "memory_info_t") -> bool + +ida_idd.meminfo_vec_template_t.append(self, x: "memory_info_t") -> None + +ida_idd.meminfo_vec_template_t.at(self, _idx: "size_t") -> "memory_info_t const &" + +ida_idd.meminfo_vec_template_t.begin(self, *args) -> "qvector< memory_info_t >::const_iterator" + +ida_idd.meminfo_vec_template_t.capacity(self) -> "size_t" + +ida_idd.meminfo_vec_template_t.clear(self) -> None + +ida_idd.meminfo_vec_template_t.empty(self) -> bool + +ida_idd.meminfo_vec_template_t.end(self, *args) -> "qvector< memory_info_t >::const_iterator" + +ida_idd.meminfo_vec_template_t.erase(self, *args) -> "qvector< memory_info_t >::iterator" + +ida_idd.meminfo_vec_template_t.extend(self, x: "meminfo_vec_template_t") -> None + +ida_idd.meminfo_vec_template_t.extract(self) -> "memory_info_t *" + +ida_idd.meminfo_vec_template_t.find(self, *args) -> "qvector< memory_info_t >::const_iterator" + +ida_idd.meminfo_vec_template_t.grow(self, *args) -> None + +ida_idd.meminfo_vec_template_t.has(self, x: "memory_info_t") -> bool + +ida_idd.meminfo_vec_template_t.inject(self, s: "memory_info_t", len: "size_t") -> None + +ida_idd.meminfo_vec_template_t.insert(self, it: "memory_info_t", x: "memory_info_t") -> "qvector< memory_info_t >::iterator" + +ida_idd.meminfo_vec_template_t.pop_back(self) -> None + +ida_idd.meminfo_vec_template_t.push_back(self, *args) -> "memory_info_t &" + +ida_idd.meminfo_vec_template_t.qclear(self) -> None + +ida_idd.meminfo_vec_template_t.reserve(self, cnt: "size_t") -> None + +ida_idd.meminfo_vec_template_t.resize(self, *args) -> None + +ida_idd.meminfo_vec_template_t.size(self) -> "size_t" + +ida_idd.meminfo_vec_template_t.swap(self, r: "meminfo_vec_template_t") -> None + +ida_idd.meminfo_vec_template_t.truncate(self) -> None + +ida_idd.memory_info_t + +ida_idd.memory_info_t.__eq__(self, r: "memory_info_t") -> bool + +ida_idd.memory_info_t.__init__(self) + +ida_idd.memory_info_t.__ne__(self, r: "memory_info_t") -> bool + +ida_idd.memory_info_t.bitness Number of bits in segment addresses (0-16bit, 1-32bit, 2-64bit) -ida_idd.memory_info_t.name (variable) +ida_idd.memory_info_t.name Memory range name. -ida_idd.memory_info_t.perm (variable) +ida_idd.memory_info_t.perm Memory range permissions (0-no information): see segment.hpp. -ida_idd.memory_info_t.sbase (variable) - Segment base (meaningful only for segmented architectures, e.g. 16-bit x86) The - base is specified in paragraphs (i.e. shifted to the right by 4) +ida_idd.memory_info_t.sbase + Segment base (meaningful only for segmented architectures, e.g. 16-bit x86) The base is specified in paragraphs (i.e. shifted to the right by 4) + -ida_idd.memory_info_t.sclass (variable) +ida_idd.memory_info_t.sclass Memory range class name. -ida_idd.modinfo_t (class) - Proxy of C++ modinfo_t class. +ida_idd.modinfo_t -ida_idd.modinfo_t.__init__ (method) - __init__(self) -> modinfo_t +ida_idd.modinfo_t.__init__(self) -ida_idd.modinfo_t.base (variable) +ida_idd.modinfo_t.base module base address. if unknown pass BADADDR -ida_idd.modinfo_t.name (variable) +ida_idd.modinfo_t.name full name of the module -ida_idd.modinfo_t.rebase_to (variable) +ida_idd.modinfo_t.rebase_to if not BADADDR, then rebase the program to the specified address -ida_idd.modinfo_t.size (variable) +ida_idd.modinfo_t.size module size. if unknown pass 0 -ida_idd.process_info_t (class) - Proxy of C++ process_info_t class. +ida_idd.process_info_t -ida_idd.process_info_t.__init__ (method) - __init__(self) -> process_info_t +ida_idd.process_info_t.__init__(self) -ida_idd.process_info_t.name (variable) +ida_idd.process_info_t.name process name -ida_idd.process_info_t.pid (variable) +ida_idd.process_info_t.pid process id -ida_idd.procinfo_vec_t (class) - Proxy of C++ qvector< process_info_t > class. +ida_idd.procinfo_vec_t -ida_idd.procinfo_vec_t.__getitem__ (method) - __getitem__(self, i) -> process_info_t - - @param i: size_t +ida_idd.procinfo_vec_t.__getitem__(self, i: "size_t") -> "process_info_t const &" -ida_idd.procinfo_vec_t.__init__ (method) - __init__(self) -> procinfo_vec_t - __init__(self, x) -> procinfo_vec_t - - @param x: qvector< process_info_t > const & +ida_idd.procinfo_vec_t.__init__(self, *args) -ida_idd.procinfo_vec_t.__len__ (method) - __len__(self) -> size_t +ida_idd.procinfo_vec_t.__len__(self) -> "size_t" -ida_idd.procinfo_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: process_info_t const & +ida_idd.procinfo_vec_t.__setitem__(self, i: "size_t", v: "process_info_t") -> None -ida_idd.procinfo_vec_t.at (method) - at(self, _idx) -> process_info_t - - @param _idx: size_t +ida_idd.procinfo_vec_t.append(self, x: "process_info_t") -> None -ida_idd.procinfo_vec_t.begin (method) - begin(self) -> process_info_t +ida_idd.procinfo_vec_t.at(self, _idx: "size_t") -> "process_info_t const &" -ida_idd.procinfo_vec_t.capacity (method) - capacity(self) -> size_t +ida_idd.procinfo_vec_t.begin(self, *args) -> "qvector< process_info_t >::const_iterator" -ida_idd.procinfo_vec_t.clear (method) - clear(self) +ida_idd.procinfo_vec_t.capacity(self) -> "size_t" -ida_idd.procinfo_vec_t.empty (method) - empty(self) -> bool +ida_idd.procinfo_vec_t.clear(self) -> None -ida_idd.procinfo_vec_t.end (method) - end(self) -> process_info_t +ida_idd.procinfo_vec_t.empty(self) -> bool -ida_idd.procinfo_vec_t.erase (method) - erase(self, it) -> process_info_t - - @param it: qvector< process_info_t >::iterator - - erase(self, first, last) -> process_info_t - - @param first: qvector< process_info_t >::iterator - @param last: qvector< process_info_t >::iterator +ida_idd.procinfo_vec_t.end(self, *args) -> "qvector< process_info_t >::const_iterator" -ida_idd.procinfo_vec_t.extract (method) - extract(self) -> process_info_t +ida_idd.procinfo_vec_t.erase(self, *args) -> "qvector< process_info_t >::iterator" -ida_idd.procinfo_vec_t.grow (method) - grow(self, x=process_info_t()) - - @param x: process_info_t const & +ida_idd.procinfo_vec_t.extend(self, x: "procinfo_vec_t") -> None -ida_idd.procinfo_vec_t.inject (method) - inject(self, s, len) - - @param s: process_info_t * - @param len: size_t +ida_idd.procinfo_vec_t.extract(self) -> "process_info_t *" -ida_idd.procinfo_vec_t.insert (method) - insert(self, it, x) -> process_info_t - - @param it: qvector< process_info_t >::iterator - @param x: process_info_t const & +ida_idd.procinfo_vec_t.grow(self, *args) -> None -ida_idd.procinfo_vec_t.pop_back (method) - pop_back(self) +ida_idd.procinfo_vec_t.inject(self, s: "process_info_t", len: "size_t") -> None -ida_idd.procinfo_vec_t.push_back (method) - push_back(self, x) - - @param x: process_info_t const & - - push_back(self) -> process_info_t +ida_idd.procinfo_vec_t.insert(self, it: "process_info_t", x: "process_info_t") -> "qvector< process_info_t >::iterator" -ida_idd.procinfo_vec_t.qclear (method) - qclear(self) +ida_idd.procinfo_vec_t.pop_back(self) -> None -ida_idd.procinfo_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_idd.procinfo_vec_t.push_back(self, *args) -> "process_info_t &" -ida_idd.procinfo_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: process_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_idd.procinfo_vec_t.qclear(self) -> None -ida_idd.procinfo_vec_t.size (method) - size(self) -> size_t +ida_idd.procinfo_vec_t.reserve(self, cnt: "size_t") -> None -ida_idd.procinfo_vec_t.swap (method) - swap(self, r) - - @param r: qvector< process_info_t > & +ida_idd.procinfo_vec_t.resize(self, *args) -> None -ida_idd.procinfo_vec_t.truncate (method) - truncate(self) +ida_idd.procinfo_vec_t.size(self) -> "size_t" -ida_idd.register_info_t (class) - Proxy of C++ register_info_t class. +ida_idd.procinfo_vec_t.swap(self, r: "procinfo_vec_t") -> None -ida_idd.register_info_t.__get_bit_strings (method) - __get_bit_strings(self) -> PyObject * +ida_idd.procinfo_vec_t.truncate(self) -> None -ida_idd.register_info_t.__init__ (method) - __init__(self) -> register_info_t +ida_idd.register_info_t -ida_idd.register_info_t.bit_strings (variable) - strings corresponding to each bit of the register. (nullptr = no bit, same name - = multi-bits mask) +ida_idd.register_info_t.__get_bit_strings(self) -> "PyObject *" -ida_idd.register_info_t.default_bit_strings_mask (variable) +ida_idd.register_info_t.__init__(self) + +ida_idd.register_info_t.bit_strings + strings corresponding to each bit of the register. (nullptr = no bit, same name = multi-bits mask) + + +ida_idd.register_info_t.default_bit_strings_mask mask of default bits -ida_idd.register_info_t.dtype (variable) +ida_idd.register_info_t.dtype Register size (see Operand value types) -ida_idd.register_info_t.flags (variable) - Register info attribute flags +ida_idd.register_info_t.flags + Register info attribute flags + -ida_idd.register_info_t.name (variable) +ida_idd.register_info_t.name Register name. -ida_idd.register_info_t.register_class (variable) +ida_idd.register_info_t.register_class segment, mmx, etc. -ida_idd.regval_t (class) - Proxy of C++ regval_t class. +ida_idd.regval_t -ida_idd.regval_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: regval_t const & +ida_idd.regval_t.__eq__(self, r: "regval_t") -> bool -ida_idd.regval_t.__init__ (method) - __init__(self) -> regval_t - __init__(self, r) -> regval_t - - @param r: regval_t const & +ida_idd.regval_t.__init__(self, *args) -ida_idd.regval_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: regval_t const & +ida_idd.regval_t.__ne__(self, r: "regval_t") -> bool -ida_idd.regval_t.bytes (method) - bytes(self) -> bytevec_t - Get const custom value. - bytes(self) -> bytevec_t const & +ida_idd.regval_t.bytes(self, *args) -> "bytevec_t const &" -ida_idd.regval_t.clear (method) - clear(self) +ida_idd.regval_t.clear(self) -> None Clear register value. -ida_idd.regval_t.fval (variable) - 12: floating point value in the internal representation (see ieee.h) +ida_idd.regval_t.get_data(self, *args) -> "void const *" -ida_idd.regval_t.get_data (method) - get_data(self) - Get const pointer to value. - get_data(self) -> void const * +ida_idd.regval_t.get_data_size(self) -> "size_t" -ida_idd.regval_t.get_data_size (method) - get_data_size(self) -> size_t - Get size of value. +ida_idd.regval_t.ival + RVT_INT. -ida_idd.regval_t.ival (variable) - 8: integer value +ida_idd.regval_t.pyval(self, dtype: "op_dtype_t") -> "PyObject *" -ida_idd.regval_t.pyval (method) - pyval(self, dtype) -> PyObject * - - @param dtype: op_dtype_t - -ida_idd.regval_t.rvtype (variable) +ida_idd.regval_t.rvtype one of Register value types -ida_idd.regval_t.set_bytes (method) - set_bytes(self, data, size) - Initialize this regval to an empty custom value. - - @param data: uchar const * - @param size: size_t - - set_bytes(self, v) - - @param v: bytevec_t const & - - set_bytes(self) -> bytevec_t & +ida_idd.regval_t.set_bytes(self, *args) -> "bytevec_t &" -ida_idd.regval_t.set_float (method) - set_float(self, x) - Set float value (fval) - - @param x: (C++: const fpvalue_t &) fpvalue_t const & +ida_idd.regval_t.set_float(self, v: "bytevec_t const &") -> None -ida_idd.regval_t.set_int (method) - set_int(self, x) - - @param x: uint64 +ida_idd.regval_t.set_int(self, x: "uint64") -> None -ida_idd.regval_t.set_pyval (method) - set_pyval(self, o, dtype) -> bool - - @param o: PyObject * - @param dtype: op_dtype_t +ida_idd.regval_t.set_pyval(self, o: "PyObject *", dtype: "op_dtype_t") -> bool -ida_idd.regval_t.set_unavailable (method) - set_unavailable(self) - Mark as unavailable. +ida_idd.regval_t.set_unavailable(self) -> None -ida_idd.regval_t.swap (method) - swap(self, r) +ida_idd.regval_t.swap(self, r: "regval_t") -> None Set this = r and r = this. - - @param r: (C++: regval_t &) -ida_idd.regvals_t (class) - Proxy of C++ qvector< regval_t > class. +ida_idd.regval_t.use_bytevec(self) -> bool -ida_idd.regvals_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< regval_t > const & +ida_idd.regvals_t -ida_idd.regvals_t.__getitem__ (method) - __getitem__(self, i) -> regval_t - - @param i: size_t +ida_idd.regvals_t.__eq__(self, r: "regvals_t") -> bool -ida_idd.regvals_t.__init__ (method) - __init__(self) -> regvals_t - __init__(self, x) -> regvals_t - - @param x: qvector< regval_t > const & +ida_idd.regvals_t.__getitem__(self, i: "size_t") -> "regval_t const &" -ida_idd.regvals_t.__len__ (method) - __len__(self) -> size_t +ida_idd.regvals_t.__init__(self, *args) -ida_idd.regvals_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< regval_t > const & +ida_idd.regvals_t.__len__(self) -> "size_t" -ida_idd.regvals_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regval_t const & +ida_idd.regvals_t.__ne__(self, r: "regvals_t") -> bool -ida_idd.regvals_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: regval_t const & +ida_idd.regvals_t.__setitem__(self, i: "size_t", v: "regval_t") -> None -ida_idd.regvals_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: regval_t const & +ida_idd.regvals_t._del(self, x: "regval_t") -> bool -ida_idd.regvals_t.at (method) - at(self, _idx) -> regval_t - - @param _idx: size_t +ida_idd.regvals_t.add_unique(self, x: "regval_t") -> bool -ida_idd.regvals_t.begin (method) - begin(self) -> regval_t +ida_idd.regvals_t.append(self, x: "regval_t") -> None -ida_idd.regvals_t.capacity (method) - capacity(self) -> size_t +ida_idd.regvals_t.at(self, _idx: "size_t") -> "regval_t const &" -ida_idd.regvals_t.clear (method) - clear(self) +ida_idd.regvals_t.begin(self, *args) -> "qvector< regval_t >::const_iterator" -ida_idd.regvals_t.empty (method) - empty(self) -> bool +ida_idd.regvals_t.capacity(self) -> "size_t" -ida_idd.regvals_t.end (method) - end(self) -> regval_t +ida_idd.regvals_t.clear(self) -> None -ida_idd.regvals_t.erase (method) - erase(self, it) -> regval_t - - @param it: qvector< regval_t >::iterator - - erase(self, first, last) -> regval_t - - @param first: qvector< regval_t >::iterator - @param last: qvector< regval_t >::iterator +ida_idd.regvals_t.empty(self) -> bool -ida_idd.regvals_t.extract (method) - extract(self) -> regval_t +ida_idd.regvals_t.end(self, *args) -> "qvector< regval_t >::const_iterator" -ida_idd.regvals_t.find (method) - find(self, x) -> regval_t - - @param x: regval_t const & +ida_idd.regvals_t.erase(self, *args) -> "qvector< regval_t >::iterator" -ida_idd.regvals_t.grow (method) - grow(self, x=regval_t()) - - @param x: regval_t const & +ida_idd.regvals_t.extend(self, x: "regvals_t") -> None -ida_idd.regvals_t.has (method) - has(self, x) -> bool - - @param x: regval_t const & +ida_idd.regvals_t.extract(self) -> "regval_t *" -ida_idd.regvals_t.inject (method) - inject(self, s, len) - - @param s: regval_t * - @param len: size_t +ida_idd.regvals_t.find(self, *args) -> "qvector< regval_t >::const_iterator" -ida_idd.regvals_t.insert (method) - insert(self, it, x) -> regval_t - - @param it: qvector< regval_t >::iterator - @param x: regval_t const & +ida_idd.regvals_t.grow(self, *args) -> None -ida_idd.regvals_t.pop_back (method) - pop_back(self) +ida_idd.regvals_t.has(self, x: "regval_t") -> bool -ida_idd.regvals_t.push_back (method) - push_back(self, x) - - @param x: regval_t const & - - push_back(self) -> regval_t +ida_idd.regvals_t.inject(self, s: "regval_t", len: "size_t") -> None -ida_idd.regvals_t.qclear (method) - qclear(self) +ida_idd.regvals_t.insert(self, it: "regval_t", x: "regval_t") -> "qvector< regval_t >::iterator" -ida_idd.regvals_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_idd.regvals_t.pop_back(self) -> None -ida_idd.regvals_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: regval_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_idd.regvals_t.push_back(self, *args) -> "regval_t &" -ida_idd.regvals_t.size (method) - size(self) -> size_t +ida_idd.regvals_t.qclear(self) -> None -ida_idd.regvals_t.swap (method) - swap(self, r) - - @param r: qvector< regval_t > & +ida_idd.regvals_t.reserve(self, cnt: "size_t") -> None -ida_idd.regvals_t.truncate (method) - truncate(self) +ida_idd.regvals_t.resize(self, *args) -> None -ida_idd.scattered_segm_t (class) - Proxy of C++ scattered_segm_t class. +ida_idd.regvals_t.size(self) -> "size_t" -ida_idd.scattered_segm_t.__init__ (method) - __init__(self) -> scattered_segm_t +ida_idd.regvals_t.swap(self, r: "regvals_t") -> None -ida_idd.scattered_segm_t.name (variable) +ida_idd.regvals_t.truncate(self) -> None + +ida_idd.scattered_segm_t + +ida_idd.scattered_segm_t.__init__(self) + +ida_idd.scattered_segm_t.name name of the segment -ida_idd.set_debug_event_code (function) - set_debug_event_code(ev, id) - - @param ev: debug_event_t * - @param id: enum event_id_t +ida_idd.set_debug_event_code(ev: "debug_event_t", id: "event_id_t") -> None -ida_idd.thread_name_t (class) - Proxy of C++ thread_name_t class. +ida_idd.thread_name_t -ida_idd.thread_name_t.__init__ (method) - __init__(self) -> thread_name_t +ida_idd.thread_name_t.__init__(self) -ida_idd.thread_name_t.name (variable) +ida_idd.thread_name_t.name new thread name -ida_idd.thread_name_t.tid (variable) +ida_idd.thread_name_t.tid thread -ida_idp (module) +ida_idp Contains definition of the interface to IDP modules. The interface consists of two structures: * definition of target assembler: ::ash * definition of current processor: ::ph - These structures contain information about target processor and assembler - features. + These structures contain information about target processor and assembler features. It also defines two groups of kernel events: * processor_t::event_t processor related events * idb_event:event_code_t database related events - The processor related events are used to communicate with the processor module. - The database related events are used to inform any interested parties, like - plugins or processor modules, about the changes in the database. + + The processor related events are used to communicate with the processor module. The database related events are used to inform any interested parties, like plugins or processor modules, about the changes in the database. + -ida_idp.AS2_BRACE (variable) +ida_idp.AS2_BRACE Use braces for all expressions. -ida_idp.AS2_BYTE1CHAR (variable) - One symbol per processor byte. Meaningful only for wide byte processors +ida_idp.AS2_BYTE1CHAR + One symbol per processor byte. Meaningful only for wide byte processors + -ida_idp.AS2_COLONSUF (variable) - addresses may have ":xx" suffix; this suffix must be ignored when extracting the - address under the cursor +ida_idp.AS2_COLONSUF + addresses may have ":xx" suffix; this suffix must be ignored when extracting the address under the cursor + -ida_idp.AS2_IDEALDSCR (variable) - Description of struc/union is in the 'reverse' form (keyword before name), the - same as in borland tasm ideal +ida_idp.AS2_IDEALDSCR + Description of struc/union is in the 'reverse' form (keyword before name), the same as in borland tasm ideal + -ida_idp.AS2_STRINV (variable) - Invert meaning of idainfo::wide_high_byte_first for text strings (for processors - with bytes bigger than 8 bits) +ida_idp.AS2_STRINV + Invert meaning of idainfo::wide_high_byte_first for text strings (for processors with bytes bigger than 8 bits) + -ida_idp.AS2_TERSESTR (variable) - 'terse' structure initialization form; NAME is supported +ida_idp.AS2_TERSESTR + 'terse' structure initialization form; NAME is supported + -ida_idp.AS2_YWORD (variable) +ida_idp.AS2_YWORD a_yword field is present and valid -ida_idp.AS2_ZWORD (variable) +ida_idp.AS2_ZWORD a_zword field is present and valid -ida_idp.ASB_BINF0 (variable) +ida_idp.ASB_BINF0 010101b -ida_idp.ASB_BINF1 (variable) +ida_idp.ASB_BINF1 ^B010101 -ida_idp.ASB_BINF2 (variable) +ida_idp.ASB_BINF2 %010101 -ida_idp.ASB_BINF3 (variable) +ida_idp.ASB_BINF3 0b1010101 -ida_idp.ASB_BINF4 (variable) +ida_idp.ASB_BINF4 b'1010101 -ida_idp.ASB_BINF5 (variable) +ida_idp.ASB_BINF5 b'1010101' -ida_idp.ASD_DECF0 (variable) +ida_idp.ASD_DECF0 34 -ida_idp.ASD_DECF1 (variable) +ida_idp.ASD_DECF1 #34 -ida_idp.ASD_DECF2 (variable) +ida_idp.ASD_DECF2 34. -ida_idp.ASD_DECF3 (variable) +ida_idp.ASD_DECF3 .34 -ida_idp.ASH_HEXF0 (variable) +ida_idp.ASH_HEXF0 34h -ida_idp.ASH_HEXF1 (variable) +ida_idp.ASH_HEXF1 h'34 -ida_idp.ASH_HEXF2 (variable) +ida_idp.ASH_HEXF2 34 -ida_idp.ASH_HEXF3 (variable) +ida_idp.ASH_HEXF3 0x34 -ida_idp.ASH_HEXF4 (variable) +ida_idp.ASH_HEXF4 $34 -ida_idp.ASH_HEXF5 (variable) +ida_idp.ASH_HEXF5 <^R > (radix) -ida_idp.ASO_OCTF0 (variable) +ida_idp.ASO_OCTF0 123o -ida_idp.ASO_OCTF1 (variable) +ida_idp.ASO_OCTF1 0123 -ida_idp.ASO_OCTF2 (variable) +ida_idp.ASO_OCTF2 123 -ida_idp.ASO_OCTF3 (variable) +ida_idp.ASO_OCTF3 @123 -ida_idp.ASO_OCTF4 (variable) +ida_idp.ASO_OCTF4 o'123 -ida_idp.ASO_OCTF5 (variable) +ida_idp.ASO_OCTF5 123q -ida_idp.ASO_OCTF6 (variable) +ida_idp.ASO_OCTF6 ~123 -ida_idp.ASO_OCTF7 (variable) +ida_idp.ASO_OCTF7 q'123 -ida_idp.AS_1TEXT (variable) +ida_idp.AS_1TEXT 1 text per line, no bytes -ida_idp.AS_2CHRE (variable) +ida_idp.AS_2CHRE double char constants are: "xy -ida_idp.AS_ALIGN2 (variable) - .align directive expects an exponent rather than a power of 2 (.align 5 means to - align at 32byte boundary) +ida_idp.AS_ALIGN2 + .align directive expects an exponent rather than a power of 2 (.align 5 means to align at 32byte boundary) + -ida_idp.AS_ASCIIC (variable) - ascii directive accepts C-like escape sequences (\n,\x01 and similar) +ida_idp.AS_ASCIIC + ascii directive accepts C-like escape sequences (\n,\x01 and similar) + -ida_idp.AS_ASCIIZ (variable) +ida_idp.AS_ASCIIZ ascii directive inserts implicit zero byte at the end -ida_idp.AS_BINFM (variable) +ida_idp.AS_BINFM mask - binary number format -ida_idp.AS_COLON (variable) +ida_idp.AS_COLON create colons after data names ? -ida_idp.AS_DECFM (variable) +ida_idp.AS_DECFM mask - decimal number format -ida_idp.AS_HEXFM (variable) +ida_idp.AS_HEXFM mask - hex number format -ida_idp.AS_LALIGN (variable) +ida_idp.AS_LALIGN Labels at "align" keyword are supported. -ida_idp.AS_N2CHR (variable) +ida_idp.AS_N2CHR can't have 2 byte char consts -ida_idp.AS_NCHRE (variable) +ida_idp.AS_NCHRE char constants are: 'x -ida_idp.AS_NCMAS (variable) +ida_idp.AS_NCMAS no commas in ascii directives -ida_idp.AS_NHIAS (variable) +ida_idp.AS_NHIAS no characters with high bit -ida_idp.AS_NOCODECLN (variable) +ida_idp.AS_NOCODECLN don't create colons after code names -ida_idp.AS_NOSPACE (variable) +ida_idp.AS_NOSPACE No spaces in expressions. -ida_idp.AS_NOXRF (variable) +ida_idp.AS_NOXRF Disable xrefs during the output file generation. -ida_idp.AS_OCTFM (variable) +ida_idp.AS_OCTFM mask - octal number format -ida_idp.AS_OFFST (variable) +ida_idp.AS_OFFST offsets are 'offset xxx' ? -ida_idp.AS_ONEDUP (variable) +ida_idp.AS_ONEDUP One array definition per line. -ida_idp.AS_RELSUP (variable) +ida_idp.AS_RELSUP Checkarg: 'and','or','xor' operations with addresses are possible. -ida_idp.AS_UDATA (variable) +ida_idp.AS_UDATA can use '?' in data directives -ida_idp.AS_UNEQU (variable) +ida_idp.AS_UNEQU replace undefined data items with EQU (for ANTA's A80) -ida_idp.AS_XTRNTYPE (variable) +ida_idp.AS_XTRNTYPE Assembler understands type of extern symbols as ":type" suffix. -ida_idp.AssembleLine (function) - AssembleLine(ea, cs, ip, use32, nonnul_line) -> bytes +ida_idp.AssembleLine(ea, cs, ip, use32, line) 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 cs: cs of instruction + @param ip: ip of instruction @param use32: is 32bit segment - @param nonnul_line: char const * - @return: - None on failure + @param line: line to assemble + @return: + - None on failure - or a string containing the assembled instruction -ida_idp.CF_CALL (variable) +ida_idp.CF_CALL CALL instruction (should make a procedure here) -ida_idp.CF_CHG1 (variable) +ida_idp.CF_CHG1 The instruction modifies the first operand. -ida_idp.CF_CHG2 (variable) +ida_idp.CF_CHG2 The instruction modifies the second operand. -ida_idp.CF_CHG3 (variable) +ida_idp.CF_CHG3 The instruction modifies the third operand. -ida_idp.CF_CHG4 (variable) +ida_idp.CF_CHG4 The instruction modifies the fourth operand. -ida_idp.CF_CHG5 (variable) +ida_idp.CF_CHG5 The instruction modifies the fifth operand. -ida_idp.CF_CHG6 (variable) +ida_idp.CF_CHG6 The instruction modifies the sixth operand. -ida_idp.CF_CHG7 (variable) +ida_idp.CF_CHG7 The instruction modifies the seventh operand. -ida_idp.CF_CHG8 (variable) +ida_idp.CF_CHG8 The instruction modifies the eighth operand. -ida_idp.CF_HLL (variable) - Instruction may be present in a high level language function +ida_idp.CF_HLL + Instruction may be present in a high level language function + -ida_idp.CF_JUMP (variable) - The instruction passes execution using indirect jump or call (thus needs - additional analysis) +ida_idp.CF_JUMP + The instruction passes execution using indirect jump or call (thus needs additional analysis) + -ida_idp.CF_SHFT (variable) +ida_idp.CF_SHFT Bit-shift instruction (shl,shr...) -ida_idp.CF_STOP (variable) - Instruction doesn't pass execution to the next instruction +ida_idp.CF_STOP + Instruction doesn't pass execution to the next instruction + -ida_idp.CF_USE1 (variable) +ida_idp.CF_USE1 The instruction uses value of the first operand. -ida_idp.CF_USE2 (variable) +ida_idp.CF_USE2 The instruction uses value of the second operand. -ida_idp.CF_USE3 (variable) +ida_idp.CF_USE3 The instruction uses value of the third operand. -ida_idp.CF_USE4 (variable) +ida_idp.CF_USE4 The instruction uses value of the fourth operand. -ida_idp.CF_USE5 (variable) +ida_idp.CF_USE5 The instruction uses value of the fifth operand. -ida_idp.CF_USE6 (variable) +ida_idp.CF_USE6 The instruction uses value of the sixth operand. -ida_idp.CF_USE7 (variable) +ida_idp.CF_USE7 The instruction uses value of the seventh operand. -ida_idp.CF_USE8 (variable) +ida_idp.CF_USE8 The instruction uses value of the eighth operand. -ida_idp.CUSTOM_INSN_ITYPE (variable) - Custom instruction codes defined by processor extension plugins must be greater - than or equal to this +ida_idp.CUSTOM_INSN_ITYPE + Custom instruction codes defined by processor extension plugins must be greater than or equal to this + -ida_idp.HKCB_GLOBAL (variable) - is global event listener? if true, the listener will survive database closing - and opening. it will stay in the memory until explicitly unhooked. otherwise the - kernel will delete it as soon as the owner is unloaded. should be used only with - PLUGIN_FIX plugins. +ida_idp.HKCB_GLOBAL + is global event listener? if true, the listener will survive database closing and opening. it will stay in the memory until explicitly unhooked. otherwise the kernel will delete it as soon as the owner is unloaded. should be used only with PLUGIN_FIX plugins. + -ida_idp.IDB_Hooks (class) - Proxy of C++ IDB_Hooks class. +ida_idp.IDB_Hooks -ida_idp.IDB_Hooks.__disown__ (method) +ida_idp.IDB_Hooks.__disown__(self) -ida_idp.IDB_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> IDB_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 +ida_idp.IDB_Hooks.__init__(self, _flags: int = 0, _hkcb_flags: int = 1) -ida_idp.IDB_Hooks.adding_segm (method) - adding_segm(self, s) - A segment is being created. - +ida_idp.IDB_Hooks.adding_segm(self, s: "segment_t *") -> None + A segment is being created. + @param s: (segment_t *) -ida_idp.IDB_Hooks.allsegs_moved (method) - allsegs_moved(self, info) - Program rebasing is complete. This event is generated after series of segm_moved - events - +ida_idp.IDB_Hooks.allsegs_moved(self, info: "segm_move_infos_t *") -> None + Program rebasing is complete. This event is generated after series of segm_moved events + @param info: (segm_move_infos_t *) -ida_idp.IDB_Hooks.auto_empty (method) - auto_empty(self) +ida_idp.IDB_Hooks.auto_empty(self) -> None + Info: all analysis queues are empty. This callback is called once when the initial analysis is finished. If the queue is not empty upon the return from this callback, it will be called later again. + -ida_idp.IDB_Hooks.auto_empty_finally (method) - auto_empty_finally(self) +ida_idp.IDB_Hooks.auto_empty_finally(self) -> None + Info: all analysis queues are empty definitively. This callback is called only once. + -ida_idp.IDB_Hooks.bookmark_changed (method) - bookmark_changed(self, index, pos, desc, operation) - Boomarked position changed. - +ida_idp.IDB_Hooks.bookmark_changed(self, index: int, pos: "lochist_entry_t const *", desc: str, operation: int) -> None + Boomarked position changed. + @param index: (uint32) @param pos: (::const lochist_entry_t *) @param desc: (::const char *) - @param operation: (int) 0-added, 1-updated, 2-deleted if desc==nullptr, then the - bookmark was deleted. + @param operation: (int) 0-added, 1-updated, 2-deleted if desc==nullptr, then the bookmark was deleted. -ida_idp.IDB_Hooks.byte_patched (method) - byte_patched(self, ea, old_value) - A byte has been patched. - +ida_idp.IDB_Hooks.byte_patched(self, ea: ida_idaapi.ea_t, old_value: int) -> None + A byte has been patched. + @param ea: (::ea_t) @param old_value: (uint32) -ida_idp.IDB_Hooks.callee_addr_changed (method) - callee_addr_changed(self, ea, callee) - Callee address has been updated by the user. - +ida_idp.IDB_Hooks.callee_addr_changed(self, ea: ida_idaapi.ea_t, callee: ida_idaapi.ea_t) -> None + Callee address has been updated by the user. + @param ea: (::ea_t) @param callee: (::ea_t) -ida_idp.IDB_Hooks.changing_cmt (method) - changing_cmt(self, ea, repeatable_cmt, newcmt) - An item comment is to be changed. - +ida_idp.IDB_Hooks.changing_cmt(self, ea: ida_idaapi.ea_t, repeatable_cmt: bool, newcmt: str) -> None + An item comment is to be changed. + @param ea: (::ea_t) @param repeatable_cmt: (bool) @param newcmt: (const char *) -ida_idp.IDB_Hooks.changing_enum_bf (method) - changing_enum_bf(self, id, new_bf) - An enum type 'bitfield' attribute is to be changed. - - @param id: (enum_t) - @param new_bf: (bool) - -ida_idp.IDB_Hooks.changing_enum_cmt (method) - changing_enum_cmt(self, id, repeatable, newcmt) - An enum or member type comment is to be changed. - - @param id: (tid_t) - @param repeatable: (bool) - @param newcmt: (const char *) - -ida_idp.IDB_Hooks.changing_op_ti (method) - changing_op_ti(self, ea, n, new_type, new_fnames) - An operand typestring (c/c++ prototype) is to be changed. - +ida_idp.IDB_Hooks.changing_op_ti(self, ea: ida_idaapi.ea_t, n: int, new_type: "type_t const *", new_fnames: "p_list const *") -> None + An operand typestring (c/c++ prototype) is to be changed. + @param ea: (::ea_t) @param n: (int) @param new_type: (const type_t *) @param new_fnames: (const p_list *) -ida_idp.IDB_Hooks.changing_op_type (method) - changing_op_type(self, ea, n, opinfo) - An operand type (offset, hex, etc...) is to be changed. - +ida_idp.IDB_Hooks.changing_op_type(self, ea: ida_idaapi.ea_t, n: int, opinfo: "opinfo_t") -> None + An operand type (offset, hex, etc...) is to be changed. + @param ea: (::ea_t) @param n: (int) eventually or'ed with OPND_OUTER or OPND_ALL @param opinfo: (const opinfo_t *) additional operand info -ida_idp.IDB_Hooks.changing_range_cmt (method) - changing_range_cmt(self, kind, a, cmt, repeatable) - Range comment is to be changed. - +ida_idp.IDB_Hooks.changing_range_cmt(self, kind: "range_kind_t", a: "range_t", cmt: str, repeatable: bool) -> None + Range comment is to be changed. + @param kind: (range_kind_t) @param a: (const range_t *) @param cmt: (const char *) @param repeatable: (bool) -ida_idp.IDB_Hooks.changing_segm_class (method) - changing_segm_class(self, s) - Segment class is being changed. - +ida_idp.IDB_Hooks.changing_segm_class(self, s: "segment_t *") -> None + Segment class is being changed. + @param s: (segment_t *) -ida_idp.IDB_Hooks.changing_segm_end (method) - changing_segm_end(self, s, new_end, segmod_flags) - Segment end address is to be changed. - +ida_idp.IDB_Hooks.changing_segm_end(self, s: "segment_t *", new_end: ida_idaapi.ea_t, segmod_flags: int) -> None + Segment end address is to be changed. + @param s: (segment_t *) @param new_end: (::ea_t) @param segmod_flags: (int) -ida_idp.IDB_Hooks.changing_segm_name (method) - changing_segm_name(self, s, oldname) - Segment name is being changed. - +ida_idp.IDB_Hooks.changing_segm_name(self, s: "segment_t *", oldname: str) -> None + Segment name is being changed. + @param s: (segment_t *) @param oldname: (const char *) -ida_idp.IDB_Hooks.changing_segm_start (method) - changing_segm_start(self, s, new_start, segmod_flags) - Segment start address is to be changed. - +ida_idp.IDB_Hooks.changing_segm_start(self, s: "segment_t *", new_start: ida_idaapi.ea_t, segmod_flags: int) -> None + Segment start address is to be changed. + @param s: (segment_t *) @param new_start: (::ea_t) @param segmod_flags: (int) -ida_idp.IDB_Hooks.changing_struc_align (method) - changing_struc_align(self, sptr) - A structure type is being changed (the struct alignment). - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.changing_struc_cmt (method) - changing_struc_cmt(self, struc_id, repeatable, newcmt) - A structure type comment is to be changed. - - @param struc_id: (tid_t) - @param repeatable: (bool) - @param newcmt: (const char *) - -ida_idp.IDB_Hooks.changing_struc_member (method) - changing_struc_member(self, sptr, mptr, flag, ti, nbytes) - A structure member is to be changed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - @param flag: (flags64_t) - @param ti: (const opinfo_t *) - @param nbytes: (::asize_t) - -ida_idp.IDB_Hooks.changing_ti (method) - changing_ti(self, ea, new_type, new_fnames) - An item typestring (c/c++ prototype) is to be changed. - +ida_idp.IDB_Hooks.changing_ti(self, ea: ida_idaapi.ea_t, new_type: "type_t const *", new_fnames: "p_list const *") -> None + An item typestring (c/c++ prototype) is to be changed. + @param ea: (::ea_t) @param new_type: (const type_t *) @param new_fnames: (const p_list *) -ida_idp.IDB_Hooks.closebase (method) - closebase(self) +ida_idp.IDB_Hooks.closebase(self) -> None The database will be closed now. -ida_idp.IDB_Hooks.cmt_changed (method) - cmt_changed(self, ea, repeatable_cmt) - An item comment has been changed. - +ida_idp.IDB_Hooks.cmt_changed(self, ea: ida_idaapi.ea_t, repeatable_cmt: bool) -> None + An item comment has been changed. + @param ea: (::ea_t) @param repeatable_cmt: (bool) -ida_idp.IDB_Hooks.compiler_changed (method) - compiler_changed(self, adjust_inf_fields) - The kernel has changed the compiler information. ( idainfo::cc structure; - get_abi_name) - +ida_idp.IDB_Hooks.compiler_changed(self, adjust_inf_fields: bool) -> None + The kernel has changed the compiler information. ( idainfo::cc structure; get_abi_name) + @param adjust_inf_fields: (::bool) may change inf fields? -ida_idp.IDB_Hooks.deleting_enum (method) - deleting_enum(self, id) - An enum type is to be deleted. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.deleting_enum_member (method) - deleting_enum_member(self, id, cid) - An enum member is to be deleted. - - @param id: (enum_t) - @param cid: (const_t) - -ida_idp.IDB_Hooks.deleting_func (method) - deleting_func(self, pfn) - The kernel is about to delete a function. - +ida_idp.IDB_Hooks.deleting_func(self, pfn: "func_t *") -> None + The kernel is about to delete a function. + @param pfn: (func_t *) -ida_idp.IDB_Hooks.deleting_func_tail (method) - deleting_func_tail(self, pfn, tail) - A function tail chunk is to be removed. - +ida_idp.IDB_Hooks.deleting_func_tail(self, pfn: "func_t *", tail: "range_t") -> None + A function tail chunk is to be removed. + @param pfn: (func_t *) @param tail: (const range_t *) -ida_idp.IDB_Hooks.deleting_segm (method) - deleting_segm(self, start_ea) - A segment is to be deleted. - +ida_idp.IDB_Hooks.deleting_segm(self, start_ea: ida_idaapi.ea_t) -> None + A segment is to be deleted. + @param start_ea: (::ea_t) -ida_idp.IDB_Hooks.deleting_struc (method) - deleting_struc(self, sptr) - A structure type is to be deleted. - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.deleting_struc_member (method) - deleting_struc_member(self, sptr, mptr) - A structure member is to be deleted. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.deleting_tryblks (method) - deleting_tryblks(self, range) - About to delete tryblk information in given range - +ida_idp.IDB_Hooks.deleting_tryblks(self, range: "range_t") -> None + About to delete tryblk information in given range + @param range: (const range_t *) -ida_idp.IDB_Hooks.destroyed_items (method) - destroyed_items(self, ea1, ea2, will_disable_range) - Instructions/data have been destroyed in [ea1,ea2). - +ida_idp.IDB_Hooks.destroyed_items(self, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, will_disable_range: bool) -> None + Instructions/data have been destroyed in [ea1,ea2). + @param ea1: (::ea_t) @param ea2: (::ea_t) @param will_disable_range: (bool) -ida_idp.IDB_Hooks.determined_main (method) - determined_main(self, main) - The main() function has been determined. - +ida_idp.IDB_Hooks.determined_main(self, main: ida_idaapi.ea_t) -> None + The main() function has been determined. + @param main: (::ea_t) address of the main() function -ida_idp.IDB_Hooks.dirtree_link (method) - dirtree_link(self, dt, path, link) - +ida_idp.IDB_Hooks.dirtree_link(self, dt: "dirtree_t *", path: str, link: bool) -> None + Dirtree: an item has been linked/unlinked. + @param dt: (dirtree_t *) @param path: (::const char *) @param link: (::bool) -ida_idp.IDB_Hooks.dirtree_mkdir (method) - dirtree_mkdir(self, dt, path) - +ida_idp.IDB_Hooks.dirtree_mkdir(self, dt: "dirtree_t *", path: str) -> None + Dirtree: a directory has been created. + @param dt: (dirtree_t *) @param path: (::const char *) -ida_idp.IDB_Hooks.dirtree_move (method) - dirtree_move(self, dt, _from, to) - +ida_idp.IDB_Hooks.dirtree_move(self, dt: "dirtree_t *", _from: str, to: str) -> None + Dirtree: a directory or item has been moved. + @param dt: (dirtree_t *) - @param from: (::const char *) @param to: (::const char *) -ida_idp.IDB_Hooks.dirtree_rank (method) - dirtree_rank(self, dt, path, rank) - +ida_idp.IDB_Hooks.dirtree_rank(self, dt: "dirtree_t *", path: str, rank: "size_t") -> None + Dirtree: a directory or item rank has been changed. + @param dt: (dirtree_t *) @param path: (::const char *) @param rank: (::size_t) -ida_idp.IDB_Hooks.dirtree_rmdir (method) - dirtree_rmdir(self, dt, path) - +ida_idp.IDB_Hooks.dirtree_rmdir(self, dt: "dirtree_t *", path: str) -> None + Dirtree: a directory has been deleted. + @param dt: (dirtree_t *) @param path: (::const char *) -ida_idp.IDB_Hooks.dirtree_rminode (method) - dirtree_rminode(self, dt, inode) - +ida_idp.IDB_Hooks.dirtree_rminode(self, dt: "dirtree_t *", inode: "inode_t") -> None + Dirtree: an inode became unavailable. + @param dt: (dirtree_t *) @param inode: (inode_t) -ida_idp.IDB_Hooks.dirtree_segm_moved (method) - dirtree_segm_moved(self, dt) - +ida_idp.IDB_Hooks.dirtree_segm_moved(self, dt: "dirtree_t *") -> None + Dirtree: inodes were changed due to a segment movement or a program rebasing + @param dt: (dirtree_t *) -ida_idp.IDB_Hooks.enum_bf_changed (method) - enum_bf_changed(self, id) - An enum type 'bitfield' attribute has been changed. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.enum_cmt_changed (method) - enum_cmt_changed(self, id, repeatable) - An enum or member type comment has been changed. - - @param id: (tid_t) - @param repeatable: (bool) - -ida_idp.IDB_Hooks.enum_created (method) - enum_created(self, id) - An enum type has been created. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.enum_deleted (method) - enum_deleted(self, id) - An enum type has been deleted. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.enum_flag_changed (method) - enum_flag_changed(self, id, F) - Enum flags have been changed. - - @param id: (enum_t) - @param F: (flags64_t) - -ida_idp.IDB_Hooks.enum_member_created (method) - enum_member_created(self, id, cid) - An enum member has been created. - - @param id: (enum_t) - @param cid: (const_t) - -ida_idp.IDB_Hooks.enum_member_deleted (method) - enum_member_deleted(self, id, cid) - An enum member has been deleted. - - @param id: (enum_t) - @param cid: (const_t) - -ida_idp.IDB_Hooks.enum_ordinal_changed (method) - enum_ordinal_changed(self, id, ord) - Enum mapping to a local type has been changed. - - @param id: (enum_t) - @param ord: (int) - -ida_idp.IDB_Hooks.enum_renamed (method) - enum_renamed(self, id) - An enum or member has been renamed. - - @param id: (tid_t) - -ida_idp.IDB_Hooks.enum_width_changed (method) - enum_width_changed(self, id, width) - Enum width has been changed. - - @param id: (enum_t) - @param width: (int) - -ida_idp.IDB_Hooks.expanding_struc (method) - expanding_struc(self, sptr, offset, delta) - A structure type is to be expanded/shrunk. - - @param sptr: (struc_t *) - @param offset: (::ea_t) - @param delta: (::adiff_t) - -ida_idp.IDB_Hooks.extlang_changed (method) - extlang_changed(self, kind, el, idx) - The list of extlangs or the default extlang was changed. - - @param kind: (int) 0: extlang installed 1: extlang removed 2: default extlang - changed +ida_idp.IDB_Hooks.extlang_changed(self, kind: int, el: "extlang_t *", idx: int) -> None + The list of extlangs or the default extlang was changed. + + @param kind: (int) 0: extlang installed 1: extlang removed 2: default extlang changed @param el: (extlang_t *) pointer to the extlang affected @param idx: (int) extlang index -ida_idp.IDB_Hooks.extra_cmt_changed (method) - extra_cmt_changed(self, ea, line_idx, cmt) - An extra comment has been changed. - +ida_idp.IDB_Hooks.extra_cmt_changed(self, ea: ida_idaapi.ea_t, line_idx: int, cmt: str) -> None + An extra comment has been changed. + @param ea: (::ea_t) @param line_idx: (int) @param cmt: (const char *) -ida_idp.IDB_Hooks.flow_chart_created (method) - flow_chart_created(self, fc) - Gui has retrieved a function flow chart. Plugins may modify the flow chart in - this callback. - +ida_idp.IDB_Hooks.flow_chart_created(self, fc: "qflow_chart_t") -> None + Gui has retrieved a function flow chart. Plugins may modify the flow chart in this callback. + @param fc: (qflow_chart_t *) -ida_idp.IDB_Hooks.frame_deleted (method) - frame_deleted(self, pfn) - The kernel has deleted a function frame. - +ida_idp.IDB_Hooks.frame_created(self, func_ea: ida_idaapi.ea_t) -> None + A function frame has been created. + + @param func_ea: (::ea_t) idb_event::frame_deleted + +ida_idp.IDB_Hooks.frame_deleted(self, pfn: "func_t *") -> None + The kernel has deleted a function frame. + + @param pfn: (func_t *) idb_event::frame_created + +ida_idp.IDB_Hooks.frame_expanded(self, func_ea: ida_idaapi.ea_t, udm_tid: "tid_t", delta: "adiff_t") -> None + A frame type has been expanded/shrank. + + @param func_ea: (::ea_t) + @param udm_tid: (tid_t) the gap was added/removed before this member + @param delta: (::adiff_t) number of added/removed bytes + +ida_idp.IDB_Hooks.frame_udm_changed(self, func_ea: ida_idaapi.ea_t, udm_tid: "tid_t", udmold: "udm_t", udmnew: "udm_t") -> None + Frame member has been changed. + + @param func_ea: (::ea_t) + @param udm_tid: (tid_t) + @param udmold: (::const udm_t *) + @param udmnew: (::const udm_t *) + +ida_idp.IDB_Hooks.frame_udm_created(self, func_ea: ida_idaapi.ea_t, udm: "udm_t") -> None + Frame member has been added. + + @param func_ea: (::ea_t) + @param udm: (::const udm_t *) + +ida_idp.IDB_Hooks.frame_udm_deleted(self, func_ea: ida_idaapi.ea_t, udm_tid: "tid_t", udm: "udm_t") -> None + Frame member has been deleted. + + @param func_ea: (::ea_t) + @param udm_tid: (tid_t) + @param udm: (::const udm_t *) + +ida_idp.IDB_Hooks.frame_udm_renamed(self, func_ea: ida_idaapi.ea_t, udm: "udm_t", oldname: str) -> None + Frame member has been renamed. + + @param func_ea: (::ea_t) + @param udm: (::const udm_t *) + @param oldname: (::const char *) + +ida_idp.IDB_Hooks.func_added(self, pfn: "func_t *") -> None + The kernel has added a function. + @param pfn: (func_t *) -ida_idp.IDB_Hooks.func_added (method) - func_added(self, pfn) - The kernel has added a function. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.func_deleted (method) - func_deleted(self, func_ea) - A function has been deleted. - +ida_idp.IDB_Hooks.func_deleted(self, func_ea: ida_idaapi.ea_t) -> None + A function has been deleted. + @param func_ea: (::ea_t) -ida_idp.IDB_Hooks.func_noret_changed (method) - func_noret_changed(self, pfn) - FUNC_NORET bit has been changed. - +ida_idp.IDB_Hooks.func_noret_changed(self, pfn: "func_t *") -> None + FUNC_NORET bit has been changed. + @param pfn: (func_t *) -ida_idp.IDB_Hooks.func_tail_appended (method) - func_tail_appended(self, pfn, tail) - A function tail chunk has been appended. - +ida_idp.IDB_Hooks.func_tail_appended(self, pfn: "func_t *", tail: "func_t *") -> None + A function tail chunk has been appended. + @param pfn: (func_t *) @param tail: (func_t *) -ida_idp.IDB_Hooks.func_tail_deleted (method) - func_tail_deleted(self, pfn, tail_ea) - A function tail chunk has been removed. - +ida_idp.IDB_Hooks.func_tail_deleted(self, pfn: "func_t *", tail_ea: ida_idaapi.ea_t) -> None + A function tail chunk has been removed. + @param pfn: (func_t *) @param tail_ea: (::ea_t) -ida_idp.IDB_Hooks.func_updated (method) - func_updated(self, pfn) - The kernel has updated a function. - +ida_idp.IDB_Hooks.func_updated(self, pfn: "func_t *") -> None + The kernel has updated a function. + @param pfn: (func_t *) -ida_idp.IDB_Hooks.hook (method) - hook(self) -> bool +ida_idp.IDB_Hooks.hook(self) -> bool -ida_idp.IDB_Hooks.idasgn_loaded (method) - idasgn_loaded(self, short_sig_name) - FLIRT signature has been loaded for normal processing (not for recognition of - startup sequences). - +ida_idp.IDB_Hooks.idasgn_loaded(self, short_sig_name: str) -> None + FLIRT signature has been loaded for normal processing (not for recognition of startup sequences). + @param short_sig_name: (const char *) -ida_idp.IDB_Hooks.item_color_changed (method) - item_color_changed(self, ea, color) - An item color has been changed. - +ida_idp.IDB_Hooks.idasgn_matched_ea(self, ea: ida_idaapi.ea_t, name: str, lib_name: str) -> None + A FLIRT match has been found + + @param ea: (::ea_t) the matching address + @param name: (::const char *) the matched name + @param lib_name: (::const char *) library name extracted from signature file + +ida_idp.IDB_Hooks.item_color_changed(self, ea: ida_idaapi.ea_t, color: "bgcolor_t") -> None + An item color has been changed. + @param ea: (::ea_t) @param color: (bgcolor_t) if color==DEFCOLOR, the the color is deleted. -ida_idp.IDB_Hooks.kernel_config_loaded (method) - kernel_config_loaded(self, pass_number) - This event is issued when ida.cfg is parsed. - +ida_idp.IDB_Hooks.kernel_config_loaded(self, pass_number: int) -> None + This event is issued when ida.cfg is parsed. + @param pass_number: (int) -ida_idp.IDB_Hooks.loader_finished (method) - loader_finished(self, li, neflags, filetypename) - External file loader finished its work. Use this event to augment the existing - loader functionality. - +ida_idp.IDB_Hooks.loader_finished(self, li: "linput_t *", neflags: "uint16", filetypename: str) -> None + External file loader finished its work. Use this event to augment the existing loader functionality. + @param li: (linput_t *) @param neflags: (uint16) Load file flags @param filetypename: (const char *) -ida_idp.IDB_Hooks.local_types_changed (method) - local_types_changed(self, ltc, ordinal, name) - Local types have been changed - - @param ltc: (::local_type_change_t) +ida_idp.IDB_Hooks.local_types_changed(self, ltc: "local_type_change_t", ordinal: int, name: str) -> None + Local types have been changed + + @param ltc: (local_type_change_t) @param ordinal: (uint32) 0 means ordinal is unknown @param name: (const char *) nullptr means name is unknown -ida_idp.IDB_Hooks.make_code (method) - make_code(self, insn) - An instruction is being created. - +ida_idp.IDB_Hooks.lt_udm_changed(self, udtname: str, udm_tid: "tid_t", udmold: "udm_t", udmnew: "udm_t") -> None + local type udt member has been changed + + @param udtname: (::const char *) + @param udm_tid: (tid_t) + @param udmold: (::const udm_t *) + @param udmnew: (::const udm_t *) + +ida_idp.IDB_Hooks.lt_udm_created(self, udtname: str, udm: "udm_t") -> None + local type udt member has been added + + @param udtname: (::const char *) + @param udm: (::const udm_t *) + +ida_idp.IDB_Hooks.lt_udm_deleted(self, udtname: str, udm_tid: "tid_t", udm: "udm_t") -> None + local type udt member has been deleted + + @param udtname: (::const char *) + @param udm_tid: (tid_t) + @param udm: (::const udm_t *) + +ida_idp.IDB_Hooks.lt_udm_renamed(self, udtname: str, udm: "udm_t", oldname: str) -> None + local type udt member has been renamed + + @param udtname: (::const char *) + @param udm: (::const udm_t *) + @param oldname: (::const char *) + +ida_idp.IDB_Hooks.lt_udt_expanded(self, udtname: str, udm_tid: "tid_t", delta: "adiff_t") -> None + A structure type has been expanded/shrank. + + @param udtname: (::const char *) + @param udm_tid: (tid_t) the gap was added/removed before this member + @param delta: (::adiff_t) number of added/removed bytes + +ida_idp.IDB_Hooks.make_code(self, insn: "insn_t const *") -> None + An instruction is being created. + @param insn: (const insn_t*) -ida_idp.IDB_Hooks.make_data (method) - make_data(self, ea, flags, tid, len) - A data item is being created. - +ida_idp.IDB_Hooks.make_data(self, ea: ida_idaapi.ea_t, flags: "flags64_t", tid: "tid_t", len: "asize_t") -> None + A data item is being created. + @param ea: (::ea_t) @param flags: (flags64_t) @param tid: (tid_t) @param len: (::asize_t) -ida_idp.IDB_Hooks.op_ti_changed (method) - op_ti_changed(self, ea, n, type, fnames) - An operand typestring (c/c++ prototype) has been changed. - +ida_idp.IDB_Hooks.op_ti_changed(self, ea: ida_idaapi.ea_t, n: int, type: "type_t const *", fnames: "p_list const *") -> None + An operand typestring (c/c++ prototype) has been changed. + @param ea: (::ea_t) @param n: (int) @param type: (const type_t *) @param fnames: (const p_list *) -ida_idp.IDB_Hooks.op_type_changed (method) - op_type_changed(self, ea, n) - An operand type (offset, hex, etc...) has been set or deleted. - +ida_idp.IDB_Hooks.op_type_changed(self, ea: ida_idaapi.ea_t, n: int) -> None + An operand type (offset, hex, etc...) has been set or deleted. + @param ea: (::ea_t) @param n: (int) eventually or'ed with OPND_OUTER or OPND_ALL -ida_idp.IDB_Hooks.range_cmt_changed (method) - range_cmt_changed(self, kind, a, cmt, repeatable) - Range comment has been changed. - +ida_idp.IDB_Hooks.range_cmt_changed(self, kind: "range_kind_t", a: "range_t", cmt: str, repeatable: bool) -> None + Range comment has been changed. + @param kind: (range_kind_t) @param a: (const range_t *) @param cmt: (const char *) @param repeatable: (bool) -ida_idp.IDB_Hooks.renamed (method) - renamed(self, ea, new_name, local_name, old_name) - The kernel has renamed a byte. See also the rename event - +ida_idp.IDB_Hooks.renamed(self, ea: ida_idaapi.ea_t, new_name: str, local_name: bool, old_name: str) -> None + The kernel has renamed a byte. See also the rename event + @param ea: (::ea_t) @param new_name: (const char *) can be nullptr @param local_name: (bool) @param old_name: (const char *) can be nullptr -ida_idp.IDB_Hooks.renaming_enum (method) - renaming_enum(self, id, is_enum, newname) - An enum or enum member is to be renamed. - - @param id: (tid_t) - @param is_enum: (bool) - @param newname: (const char *) - -ida_idp.IDB_Hooks.renaming_struc (method) - renaming_struc(self, id, oldname, newname) - A structure type is to be renamed. - - @param id: (tid_t) - @param oldname: (const char *) - @param newname: (const char *) - -ida_idp.IDB_Hooks.renaming_struc_member (method) - renaming_struc_member(self, sptr, mptr, newname) - A structure member is to be renamed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - @param newname: (const char *) - -ida_idp.IDB_Hooks.savebase (method) - savebase(self) +ida_idp.IDB_Hooks.savebase(self) -> None The database is being saved. -ida_idp.IDB_Hooks.segm_added (method) - segm_added(self, s) - A new segment has been created. - +ida_idp.IDB_Hooks.segm_added(self, s: "segment_t *") -> None + A new segment has been created. + @param s: (segment_t *) See also adding_segm -ida_idp.IDB_Hooks.segm_attrs_updated (method) - segm_attrs_updated(self, s) - Segment attributes has been changed. - - @param s: (segment_t *) This event is generated for secondary segment attributes - (examples: color, permissions, etc) +ida_idp.IDB_Hooks.segm_attrs_updated(self, s: "segment_t *") -> None + Segment attributes has been changed. + + @param s: (segment_t *) This event is generated for secondary segment attributes (examples: color, permissions, etc) -ida_idp.IDB_Hooks.segm_class_changed (method) - segm_class_changed(self, s, sclass) - Segment class has been changed. - +ida_idp.IDB_Hooks.segm_class_changed(self, s: "segment_t *", sclass: str) -> None + Segment class has been changed. + @param s: (segment_t *) @param sclass: (const char *) -ida_idp.IDB_Hooks.segm_deleted (method) - segm_deleted(self, start_ea, end_ea, flags) - A segment has been deleted. - +ida_idp.IDB_Hooks.segm_deleted(self, start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, flags: int) -> None + A segment has been deleted. + @param start_ea: (::ea_t) @param end_ea: (::ea_t) @param flags: (int) -ida_idp.IDB_Hooks.segm_end_changed (method) - segm_end_changed(self, s, oldend) - Segment end address has been changed. - +ida_idp.IDB_Hooks.segm_end_changed(self, s: "segment_t *", oldend: ida_idaapi.ea_t) -> None + Segment end address has been changed. + @param s: (segment_t *) @param oldend: (::ea_t) -ida_idp.IDB_Hooks.segm_moved (method) - segm_moved(self, _from, to, size, changed_netmap) - Segment has been moved. - - @param from: (::ea_t) +ida_idp.IDB_Hooks.segm_moved(self, _from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, size: "asize_t", changed_netmap: bool) -> None + Segment has been moved. + @param to: (::ea_t) @param size: (::asize_t) @param changed_netmap: (bool) See also idb_event::allsegs_moved -ida_idp.IDB_Hooks.segm_name_changed (method) - segm_name_changed(self, s, name) - Segment name has been changed. - +ida_idp.IDB_Hooks.segm_name_changed(self, s: "segment_t *", name: str) -> None + Segment name has been changed. + @param s: (segment_t *) @param name: (const char *) -ida_idp.IDB_Hooks.segm_start_changed (method) - segm_start_changed(self, s, oldstart) - Segment start address has been changed. - +ida_idp.IDB_Hooks.segm_start_changed(self, s: "segment_t *", oldstart: ida_idaapi.ea_t) -> None + Segment start address has been changed. + @param s: (segment_t *) @param oldstart: (::ea_t) -ida_idp.IDB_Hooks.set_func_end (method) - set_func_end(self, pfn, new_end) - Function chunk end address will be changed. - +ida_idp.IDB_Hooks.set_func_end(self, pfn: "func_t *", new_end: ida_idaapi.ea_t) -> None + Function chunk end address will be changed. + @param pfn: (func_t *) @param new_end: (::ea_t) -ida_idp.IDB_Hooks.set_func_start (method) - set_func_start(self, pfn, new_start) - Function chunk start address will be changed. - +ida_idp.IDB_Hooks.set_func_start(self, pfn: "func_t *", new_start: ida_idaapi.ea_t) -> None + Function chunk start address will be changed. + @param pfn: (func_t *) @param new_start: (::ea_t) -ida_idp.IDB_Hooks.sgr_changed (method) - sgr_changed(self, start_ea, end_ea, regnum, value, old_value, tag) - The kernel has changed a segment register value. - +ida_idp.IDB_Hooks.sgr_changed(self, start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, regnum: int, value: "sel_t", old_value: "sel_t", tag: "uchar") -> None + The kernel has changed a segment register value. + @param start_ea: (::ea_t) @param end_ea: (::ea_t) @param regnum: (int) @@ -34645,193 +23240,96 @@ ida_idp.IDB_Hooks.sgr_changed (method) @param old_value: (::sel_t) @param tag: (uchar) Segment register range tags -ida_idp.IDB_Hooks.sgr_deleted (method) - sgr_deleted(self, start_ea, end_ea, regnum) - The kernel has deleted a segment register value. - +ida_idp.IDB_Hooks.sgr_deleted(self, start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, regnum: int) -> None + The kernel has deleted a segment register value. + @param start_ea: (::ea_t) @param end_ea: (::ea_t) @param regnum: (int) -ida_idp.IDB_Hooks.stkpnts_changed (method) - stkpnts_changed(self, pfn) - Stack change points have been modified. - +ida_idp.IDB_Hooks.stkpnts_changed(self, pfn: "func_t *") -> None + Stack change points have been modified. + @param pfn: (func_t *) -ida_idp.IDB_Hooks.struc_align_changed (method) - struc_align_changed(self, sptr) - A structure type has been changed (the struct alignment). - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.struc_cmt_changed (method) - struc_cmt_changed(self, struc_id, repeatable_cmt) - A structure type comment has been changed. - - @param struc_id: (tid_t) - @param repeatable_cmt: (bool) - -ida_idp.IDB_Hooks.struc_created (method) - struc_created(self, struc_id) - A new structure type has been created. - - @param struc_id: (tid_t) - -ida_idp.IDB_Hooks.struc_deleted (method) - struc_deleted(self, struc_id) - A structure type has been deleted. - - @param struc_id: (tid_t) - -ida_idp.IDB_Hooks.struc_expanded (method) - struc_expanded(self, sptr) - A structure type has been expanded/shrank. - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.struc_member_changed (method) - struc_member_changed(self, sptr, mptr) - A structure member has been changed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.struc_member_created (method) - struc_member_created(self, sptr, mptr) - A structure member has been created. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.struc_member_deleted (method) - struc_member_deleted(self, sptr, member_id, offset) - A structure member has been deleted. - - @param sptr: (struc_t *) - @param member_id: (tid_t) - @param offset: (::ea_t) - -ida_idp.IDB_Hooks.struc_member_renamed (method) - struc_member_renamed(self, sptr, mptr) - A structure member has been renamed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.struc_renamed (method) - struc_renamed(self, sptr, success) - A structure type has been renamed. - - @param sptr: (struc_t *) - @param success: (::bool) the structure was successfully renamed - -ida_idp.IDB_Hooks.tail_owner_changed (method) - tail_owner_changed(self, tail, owner_func, old_owner) - A tail chunk owner has been changed. - +ida_idp.IDB_Hooks.tail_owner_changed(self, tail: "func_t *", owner_func: ida_idaapi.ea_t, old_owner: ida_idaapi.ea_t) -> None + A tail chunk owner has been changed. + @param tail: (func_t *) @param owner_func: (::ea_t) @param old_owner: (::ea_t) -ida_idp.IDB_Hooks.thunk_func_created (method) - thunk_func_created(self, pfn) - A thunk bit has been set for a function. - +ida_idp.IDB_Hooks.thunk_func_created(self, pfn: "func_t *") -> None + A thunk bit has been set for a function. + @param pfn: (func_t *) -ida_idp.IDB_Hooks.ti_changed (method) - ti_changed(self, ea, type, fnames) - An item typestring (c/c++ prototype) has been changed. - +ida_idp.IDB_Hooks.ti_changed(self, ea: ida_idaapi.ea_t, type: "type_t const *", fnames: "p_list const *") -> None + An item typestring (c/c++ prototype) has been changed. + @param ea: (::ea_t) @param type: (const type_t *) @param fnames: (const p_list *) -ida_idp.IDB_Hooks.tryblks_updated (method) - tryblks_updated(self, tbv) - Updated tryblk information - +ida_idp.IDB_Hooks.tryblks_updated(self, tbv: "tryblks_t const *") -> None + Updated tryblk information + @param tbv: (const ::tryblks_t *) -ida_idp.IDB_Hooks.unhook (method) - unhook(self) -> bool +ida_idp.IDB_Hooks.unhook(self) -> bool -ida_idp.IDB_Hooks.updating_tryblks (method) - updating_tryblks(self, tbv) - About to update tryblk information - +ida_idp.IDB_Hooks.updating_tryblks(self, tbv: "tryblks_t const *") -> None + About to update tryblk information + @param tbv: (const ::tryblks_t *) -ida_idp.IDB_Hooks.upgraded (method) - upgraded(self, _from) - The database has been upgraded and the receiver can upgrade its info as well - - @param from: (int) - old IDB version +ida_idp.IDB_Hooks.upgraded(self, _from: int) -> None + The database has been upgraded and the receiver can upgrade its info as well + -ida_idp.IDP_Hooks (class) - Proxy of C++ IDP_Hooks class. +ida_idp.IDP_Hooks -ida_idp.IDP_Hooks.__disown__ (method) +ida_idp.IDP_Hooks.__disown__(self) -ida_idp.IDP_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> IDP_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 +ida_idp.IDP_Hooks.__init__(self, _flags: int = 0, _hkcb_flags: int = 1) -ida_idp.IDP_Hooks.ev_add_cref (method) - ev_add_cref(self, _from, to, type) -> int - A code reference is being created. - - @param from: (::ea_t) +ida_idp.IDP_Hooks.ev_add_cref(self, _from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, type: "cref_t") -> int + A code reference is being created. + @param to: (::ea_t) @param type: (cref_t) @retval <0: cancel cref creation @retval 0: not implemented or continue -ida_idp.IDP_Hooks.ev_add_dref (method) - ev_add_dref(self, _from, to, type) -> int - A data reference is being created. - - @param from: (::ea_t) +ida_idp.IDP_Hooks.ev_add_dref(self, _from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, type: "dref_t") -> int + A data reference is being created. + @param to: (::ea_t) @param type: (dref_t) @retval <0: cancel dref creation @retval 0: not implemented or continue -ida_idp.IDP_Hooks.ev_adjust_argloc (method) - ev_adjust_argloc(self, argloc, optional_type, size) -> int - Adjust argloc according to its type/size and platform endianess - +ida_idp.IDP_Hooks.ev_adjust_argloc(self, argloc: "argloc_t", optional_type: "tinfo_t", size: int) -> int + Adjust argloc according to its type/size and platform endianess + @param argloc: (argloc_t *), inout - @param type: (const tinfo_t *), may be nullptr nullptr means primitive type of - given size - @param size: (int) 'size' makes no sense if type != nullptr (type->get_size() - should be used instead) + @param size: (int) 'size' makes no sense if type != nullptr (type->get_size() should be used instead) @retval 0: not implemented @retval 1: ok @retval -1: error -ida_idp.IDP_Hooks.ev_adjust_libfunc_ea (method) - ev_adjust_libfunc_ea(self, sig, libfun, ea) -> int - Called when a signature module has been matched against bytes in the database. - This is used to compute the offset at which a particular module's libfunc should - be applied. - +ida_idp.IDP_Hooks.ev_adjust_libfunc_ea(self, sig: "idasgn_t const *", libfun: "libfunc_t const *", ea: "ea_t *") -> int + Called when a signature module has been matched against bytes in the database. This is used to compute the offset at which a particular module's libfunc should be applied. + @param sig: (const idasgn_t *) @param libfun: (const libfunc_t *) @param ea: (::ea_t *) - @note: 'ea' initially contains the ea_t of the start of the pattern match @retval 1: the ea_t pointed to by the third argument was modified. @retval <=0: not modified. use default algorithm. -ida_idp.IDP_Hooks.ev_adjust_refinfo (method) - ev_adjust_refinfo(self, ri, ea, n, fd) -> int - Called from apply_fixup before converting operand to reference. Can be used for - changing the reference info. (e.g. the PPC module adds REFINFO_NOBASE for some - references) - +ida_idp.IDP_Hooks.ev_adjust_refinfo(self, ri: "refinfo_t", ea: ida_idaapi.ea_t, n: int, fd: "fixup_data_t const *") -> int + Called from apply_fixup before converting operand to reference. Can be used for changing the reference info. (e.g. the PPC module adds REFINFO_NOBASE for some references) + @param ri: (refinfo_t *) @param ea: (::ea_t) instruction address @param n: (int) operand number @@ -34839,107 +23337,90 @@ ida_idp.IDP_Hooks.ev_adjust_refinfo (method) @retval <0: do not create an offset @retval 0: not implemented or refinfo adjusted -ida_idp.IDP_Hooks.ev_ana_insn (method) - ev_ana_insn(self, out) -> bool - Analyze one instruction and fill 'out' structure. This function shouldn't change - the database, flags or anything else. All these actions should be performed only - by emu_insn() function. insn_t::ea contains address of instruction to analyze. - +ida_idp.IDP_Hooks.ev_ana_insn(self, out: "insn_t *") -> bool + Analyze one instruction and fill 'out' structure. This function shouldn't change the database, flags or anything else. All these actions should be performed only by emu_insn() function. insn_t::ea contains address of instruction to analyze. + @param out: (insn_t *) - @return: length of the instruction in bytes, 0 if instruction can't be decoded. + @returns length of the instruction in bytes, 0 if instruction can't be decoded. @retval 0: if instruction can't be decoded. -ida_idp.IDP_Hooks.ev_analyze_prolog (method) - ev_analyze_prolog(self, ea) -> int - Analyzes function prolog, epilog, and updates purge, and function attributes - +ida_idp.IDP_Hooks.ev_analyze_prolog(self, ea: ida_idaapi.ea_t) -> int + Analyzes function prolog, epilog, and updates purge, and function attributes + @param ea: (::ea_t) start of function @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_arch_changed (method) - ev_arch_changed(self) -> int - The loader is done parsing arch-related information, which the processor module - might want to use to finish its initialization. +ida_idp.IDP_Hooks.ev_arch_changed(self) -> int + The loader is done parsing arch-related information, which the processor module might want to use to finish its initialization. + @retval 1: if success @retval 0: not implemented or failed -ida_idp.IDP_Hooks.ev_arg_addrs_ready (method) - ev_arg_addrs_ready(self, caller, n, tif, addrs) -> int - Argument address info is ready. - +ida_idp.IDP_Hooks.ev_arg_addrs_ready(self, caller: ida_idaapi.ea_t, n: int, tif: "tinfo_t", addrs: "ea_t *") -> int + Argument address info is ready. + @param caller: (::ea_t) @param n: (int) number of formal arguments @param tif: (tinfo_t *) call prototype @param addrs: (::ea_t *) argument intilization addresses @retval <0: do not save into idb; other values mean "ok to save" -ida_idp.IDP_Hooks.ev_asm_installed (method) - ev_asm_installed(self, asmnum) -> int - After setting a new assembler - +ida_idp.IDP_Hooks.ev_asm_installed(self, asmnum: int) -> int + After setting a new assembler + @param asmnum: (int) See also ev_newasm -ida_idp.IDP_Hooks.ev_assemble (method) - ev_assemble(self, ea, cs, ip, use32, line) -> PyObject * - Assemble an instruction. (display a warning if an error is found). - +ida_idp.IDP_Hooks.ev_assemble(self, ea: ida_idaapi.ea_t, cs: ida_idaapi.ea_t, ip: ida_idaapi.ea_t, use32: bool, line: str) -> "PyObject *" + Assemble an instruction. (display a warning if an error is found). + @param ea: (::ea_t) linear address of instruction @param cs: (::ea_t) cs of instruction @param ip: (::ea_t) ip of instruction @param use32: (bool) is 32bit segment? @param line: (const char *) line to assemble - @return: size of the instruction in bytes + @returns size of the instruction in bytes -ida_idp.IDP_Hooks.ev_auto_queue_empty (method) - ev_auto_queue_empty(self, type) -> int - One analysis queue is empty. - +ida_idp.IDP_Hooks.ev_auto_queue_empty(self, type: "atype_t") -> int + One analysis queue is empty. + @param type: (atype_t) @retval void: see also idb_event::auto_empty_finally -ida_idp.IDP_Hooks.ev_calc_arglocs (method) - ev_calc_arglocs(self, fti) -> int - Calculate function argument locations. This callback should fill retloc, all - arglocs, and stkargs. This callback is never called for CM_CC_SPECIAL functions. - +ida_idp.IDP_Hooks.ev_calc_arglocs(self, fti: "func_type_data_t") -> int + Calculate function argument locations. This callback should fill retloc, all arglocs, and stkargs. This callback is never called for CM_CC_SPECIAL functions. + @param fti: (func_type_data_t *) points to the func type info @retval 0: not implemented @retval 1: ok @retval -1: error -ida_idp.IDP_Hooks.ev_calc_cdecl_purged_bytes (method) - ev_calc_cdecl_purged_bytes(self, ea) -> int - Calculate number of purged bytes after call. - +ida_idp.IDP_Hooks.ev_calc_cdecl_purged_bytes(self, ea: ida_idaapi.ea_t) -> int + Calculate number of purged bytes after call. + @param ea: (::ea_t) address of the call instruction - @return: number of purged bytes (usually add sp, N) + @returns number of purged bytes (usually add sp, N) -ida_idp.IDP_Hooks.ev_calc_next_eas (method) - ev_calc_next_eas(self, res, insn, over) -> int - Calculate list of addresses the instruction in 'insn' may pass control to. This - callback is required for source level debugging. - +ida_idp.IDP_Hooks.ev_calc_next_eas(self, res: "eavec_t *", insn: "insn_t const *", over: bool) -> int + Calculate list of addresses the instruction in 'insn' may pass control to. This callback is required for source level debugging. + @param res: (eavec_t *), out: array for the results. @param insn: (const insn_t*) the instruction @param over: (bool) calculate for step over (ignore call targets) @retval <0: incalculable (indirect jumps, for example) - @retval >=0: number of addresses of called functions in the array. They must be - put at the beginning of the array (0 if over=true) + @retval >=0: number of addresses of called functions in the array. They must be put at the beginning of the array (0 if over=true) -ida_idp.IDP_Hooks.ev_calc_purged_bytes (method) - ev_calc_purged_bytes(self, p_purged_bytes, fti) -> int - Calculate number of purged bytes by the given function type. - +ida_idp.IDP_Hooks.ev_calc_purged_bytes(self, p_purged_bytes: "int *", fti: "func_type_data_t") -> int + Calculate number of purged bytes by the given function type. + @param p_purged_bytes: (int *) ptr to output @param fti: (const func_type_data_t *) func type details - @retval 1 + @retval 1: @retval 0: not implemented -ida_idp.IDP_Hooks.ev_calc_retloc (method) - ev_calc_retloc(self, retloc, rettype, cc) -> int - Calculate return value location. - +ida_idp.IDP_Hooks.ev_calc_retloc(self, retloc: "argloc_t", rettype: "tinfo_t", cc: "cm_t") -> int + Calculate return value location. + @param retloc: (argloc_t *) @param rettype: (const tinfo_t *) @param cc: (cm_t) @@ -34947,31 +23428,25 @@ ida_idp.IDP_Hooks.ev_calc_retloc (method) @retval 1: ok, @retval -1: error -ida_idp.IDP_Hooks.ev_calc_spdelta (method) - ev_calc_spdelta(self, spdelta, insn) -> int - Calculate amount of change to sp for the given insn. This event is required to - decompile code snippets. - +ida_idp.IDP_Hooks.ev_calc_spdelta(self, spdelta: "sval_t *", insn: "insn_t const *") -> int + Calculate amount of change to sp for the given insn. This event is required to decompile code snippets. + @param spdelta: (sval_t *) @param insn: (const insn_t *) @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_calc_step_over (method) - ev_calc_step_over(self, target, ip) -> int - Calculate the address of the instruction which will be executed after "step - over". The kernel will put a breakpoint there. If the step over is equal to step - into or we cannot calculate the address, return BADADDR. - +ida_idp.IDP_Hooks.ev_calc_step_over(self, target: "ea_t *", ip: ida_idaapi.ea_t) -> int + Calculate the address of the instruction which will be executed after "step over". The kernel will put a breakpoint there. If the step over is equal to step into or we cannot calculate the address, return BADADDR. + @param target: (::ea_t *) pointer to the answer @param ip: (::ea_t) instruction address @retval 0: unimplemented @retval 1: implemented -ida_idp.IDP_Hooks.ev_calc_switch_cases (method) - ev_calc_switch_cases(self, casevec, targets, insn_ea, si) -> int - Calculate case values and targets for a custom jump table. - +ida_idp.IDP_Hooks.ev_calc_switch_cases(self, casevec: "casevec_t *", targets: "eavec_t *", insn_ea: ida_idaapi.ea_t, si: "switch_info_t") -> int + Calculate case values and targets for a custom jump table. + @param casevec: (::casevec_t *) vector of case values (may be nullptr) @param targets: (eavec_t *) corresponding target addresses (my be nullptr) @param insn_ea: (::ea_t) address of the 'indirect jump' instruction @@ -34979,244 +23454,189 @@ ida_idp.IDP_Hooks.ev_calc_switch_cases (method) @retval 1: ok @retval <=0: failed -ida_idp.IDP_Hooks.ev_calc_varglocs (method) - ev_calc_varglocs(self, ftd, aux_regs, aux_stkargs, nfixed) -> int - Calculate locations of the arguments that correspond to '...'. - - @param ftd: (func_type_data_t *), inout: info about all arguments (including - varargs) - @param aux_regs: (regobjs_t *) buffer for hidden register arguments, may be - nullptr - @param aux_stkargs: (relobj_t *) buffer for hidden stack arguments, may be - nullptr +ida_idp.IDP_Hooks.ev_calc_varglocs(self, ftd: "func_type_data_t", aux_regs: "regobjs_t", aux_stkargs: "relobj_t", nfixed: int) -> int + Calculate locations of the arguments that correspond to '...'. + + @param ftd: (func_type_data_t *), inout: info about all arguments (including varargs) + @param aux_regs: (regobjs_t *) buffer for hidden register arguments, may be nullptr + @param aux_stkargs: (relobj_t *) buffer for hidden stack arguments, may be nullptr @param nfixed: (int) number of fixed arguments @retval 0: not implemented @retval 1: ok - @retval -1: error On some platforms variadic calls require passing additional - information: for example, number of floating variadic arguments must - be passed in rax on gcc-x64. The locations and values that - constitute this additional information are returned in the buffers - pointed by aux_regs and aux_stkargs + @retval -1: error On some platforms variadic calls require passing additional information: for example, number of floating variadic arguments must be passed in rax on gcc-x64. The locations and values that constitute this additional information are returned in the buffers pointed by aux_regs and aux_stkargs -ida_idp.IDP_Hooks.ev_calcrel (method) - ev_calcrel(self) -> int +ida_idp.IDP_Hooks.ev_calcrel(self) -> int Reserved. -ida_idp.IDP_Hooks.ev_can_have_type (method) - ev_can_have_type(self, op) -> int - Can the operand have a type as offset, segment, decimal, etc? (for example, a - register AX can't have a type, meaning that the user can't change its - representation. see bytes.hpp for information about types and flags) - +ida_idp.IDP_Hooks.ev_can_have_type(self, op: "op_t const *") -> int + Can the operand have a type as offset, segment, decimal, etc? (for example, a register AX can't have a type, meaning that the user can't change its representation. see bytes.hpp for information about types and flags) + @param op: (const op_t *) @retval 0: unknown @retval <0: no @retval 1: yes -ida_idp.IDP_Hooks.ev_clean_tbit (method) - ev_clean_tbit(self, ea, getreg, regvalues) -> int - Clear the TF bit after an insn like pushf stored it in memory. - +ida_idp.IDP_Hooks.ev_clean_tbit(self, ea: ida_idaapi.ea_t, getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> int + Clear the TF bit after an insn like pushf stored it in memory. + @param ea: (::ea_t) instruction address - @param getreg: (::processor_t::regval_getter_t *) function to get register - values + @param getreg: (::processor_t::regval_getter_t *) function to get register values @param regvalues: (const regval_t *) register values array @retval 1: ok @retval 0: failed -ida_idp.IDP_Hooks.ev_cmp_operands (method) - ev_cmp_operands(self, op1, op2) -> int - Compare instruction operands - +ida_idp.IDP_Hooks.ev_cmp_operands(self, op1: "op_t const *", op2: "op_t const *") -> int + Compare instruction operands + @param op1: (const op_t*) @param op2: (const op_t*) @retval 1: equal @retval -1: not equal @retval 0: not implemented -ida_idp.IDP_Hooks.ev_coagulate (method) - ev_coagulate(self, start_ea) -> int - Try to define some unexplored bytes. This notification will be called if the - kernel tried all possibilities and could not find anything more useful than to - convert to array of bytes. The module can help the kernel and convert the bytes - into something more useful. - +ida_idp.IDP_Hooks.ev_coagulate(self, start_ea: ida_idaapi.ea_t) -> int + Try to define some unexplored bytes. This notification will be called if the kernel tried all possibilities and could not find anything more useful than to convert to array of bytes. The module can help the kernel and convert the bytes into something more useful. + @param start_ea: (::ea_t) - @return: number of converted bytes + @returns number of converted bytes -ida_idp.IDP_Hooks.ev_coagulate_dref (method) - ev_coagulate_dref(self, _from, to, may_define, code_ea) -> int - Data reference is being analyzed. plugin may correct 'code_ea' (e.g. for thumb - mode refs, we clear the last bit) - - @param from: (::ea_t) +ida_idp.IDP_Hooks.ev_coagulate_dref(self, _from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, may_define: bool, code_ea: "ea_t *") -> int + Data reference is being analyzed. plugin may correct 'code_ea' (e.g. for thumb mode refs, we clear the last bit) + @param to: (::ea_t) @param may_define: (bool) @param code_ea: (::ea_t *) @retval <0: failed dref analysis, >0 done dref analysis @retval 0: not implemented or continue -ida_idp.IDP_Hooks.ev_create_flat_group (method) - ev_create_flat_group(self, image_base, bitness, dataseg_sel) -> int - Create special segment representing the flat group. - +ida_idp.IDP_Hooks.ev_create_flat_group(self, image_base: ida_idaapi.ea_t, bitness: int, dataseg_sel: "sel_t") -> int + Create special segment representing the flat group. + @param image_base: (::ea_t) @param bitness: (int) @param dataseg_sel: (::sel_t) return value is ignored -ida_idp.IDP_Hooks.ev_create_func_frame (method) - ev_create_func_frame(self, pfn) -> int - Create a function frame for a newly created function Set up frame size, its - attributes etc - +ida_idp.IDP_Hooks.ev_create_func_frame(self, pfn: "func_t *") -> int + Create a function frame for a newly created function Set up frame size, its attributes etc + @param pfn: (func_t *) @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_create_merge_handlers (method) - ev_create_merge_handlers(self, md) -> int - Create merge handlers, if needed - - @param md: (merge_data_t *) This event is generated immediately after opening - idbs. - @return: must be 0 +ida_idp.IDP_Hooks.ev_create_merge_handlers(self, md: "merge_data_t *") -> int + Create merge handlers, if needed + + @param md: (merge_data_t *) This event is generated immediately after opening idbs. + @returns must be 0 -ida_idp.IDP_Hooks.ev_create_switch_xrefs (method) - ev_create_switch_xrefs(self, jumpea, si) -> int - Create xrefs for a custom jump table. - +ida_idp.IDP_Hooks.ev_create_switch_xrefs(self, jumpea: ida_idaapi.ea_t, si: "switch_info_t") -> int + Create xrefs for a custom jump table. + @param jumpea: (::ea_t) address of the jump insn @param si: (const switch_info_t *) switch information - @return: must return 1 Must be implemented if module uses custom jump tables, - SWI_CUSTOM + @returns must return 1 Must be implemented if module uses custom jump tables, SWI_CUSTOM -ida_idp.IDP_Hooks.ev_creating_segm (method) - ev_creating_segm(self, seg) -> int - A new segment is about to be created. - +ida_idp.IDP_Hooks.ev_creating_segm(self, seg: "segment_t *") -> int + A new segment is about to be created. + @param seg: (segment_t *) @retval 1: ok @retval <0: segment should not be created -ida_idp.IDP_Hooks.ev_cvt64_hashval (method) - ev_cvt64_hashval(self, node, tag, name, data) -> int - perform 32-64 conversion for a hash value - +ida_idp.IDP_Hooks.ev_cvt64_hashval(self, node: "nodeidx_t", tag: "uchar", name: str, data: "uchar const *") -> int + perform 32-64 conversion for a hash value + @param node: (::nodeidx_t) @param tag: (uchar) @param name: (const ::char *) @param data: (const uchar *) - @return: 0 nothing was done - 1 converted successfully - -1 error (and message in errbuf) + @retval 0: nothing was done + @retval 1: converted successfully + @retval -1: error (and message in errbuf) -ida_idp.IDP_Hooks.ev_cvt64_supval (method) - ev_cvt64_supval(self, node, tag, idx, data) -> int - perform 32-64 conversion for a netnode array element - +ida_idp.IDP_Hooks.ev_cvt64_supval(self, node: "nodeidx_t", tag: "uchar", idx: "nodeidx_t", data: "uchar const *") -> int + perform 32-64 conversion for a netnode array element + @param node: (::nodeidx_t) @param tag: (uchar) @param idx: (::nodeidx_t) @param data: (const uchar *) - @return: 0 nothing was done - 1 converted successfully - -1 error (and message in errbuf) + @retval 0: nothing was done + @retval 1: converted successfully + @retval -1: error (and message in errbuf) -ida_idp.IDP_Hooks.ev_decorate_name (method) - ev_decorate_name(self, name, mangle, cc, optional_type) -> PyObject * - Decorate/undecorate a C symbol name. - +ida_idp.IDP_Hooks.ev_decorate_name(self, name: str, mangle: bool, cc: int, optional_type: "tinfo_t") -> "PyObject *" + Decorate/undecorate a C symbol name. + @param name: (const char *) name of symbol @param mangle: (bool) true-mangle, false-unmangle @param cc: (cm_t) calling convention - @param optional_type: tinfo_t const * @retval 1: if success @retval 0: not implemented or failed -ida_idp.IDP_Hooks.ev_del_cref (method) - ev_del_cref(self, _from, to, expand) -> int - A code reference is being deleted. - - @param from: (::ea_t) +ida_idp.IDP_Hooks.ev_del_cref(self, _from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, expand: bool) -> int + A code reference is being deleted. + @param to: (::ea_t) @param expand: (bool) @retval <0: cancel cref deletion @retval 0: not implemented or continue -ida_idp.IDP_Hooks.ev_del_dref (method) - ev_del_dref(self, _from, to) -> int - A data reference is being deleted. - - @param from: (::ea_t) +ida_idp.IDP_Hooks.ev_del_dref(self, _from: ida_idaapi.ea_t, to: ida_idaapi.ea_t) -> int + A data reference is being deleted. + @param to: (::ea_t) @retval <0: cancel dref deletion @retval 0: not implemented or continue -ida_idp.IDP_Hooks.ev_delay_slot_insn (method) - ev_delay_slot_insn(self, ea, bexec, fexec) -> PyObject * - Get delay slot instruction - - @param ea: (::ea_t *) in: instruction address in question, out: (if the answer - is positive) if the delay slot contains valid insn: the address of - the delay slot insn else: BADADDR (invalid insn, e.g. a branch) +ida_idp.IDP_Hooks.ev_delay_slot_insn(self, ea: ida_idaapi.ea_t, bexec: bool, fexec: bool) -> "PyObject *" + Get delay slot instruction + + @param ea: (::ea_t *) in: instruction address in question, out: (if the answer is positive) if the delay slot contains valid insn: the address of the delay slot insn else: BADADDR (invalid insn, e.g. a branch) @param bexec: (bool *) execute slot if jumping, initially set to 'true' @param fexec: (bool *) execute slot if not jumping, initally set to 'true' @retval 1: positive answer @retval <=0: ordinary insn - @note: Input EA may point to the instruction with a delay slot or to the delay - slot instruction itself. -ida_idp.IDP_Hooks.ev_demangle_name (method) - ev_demangle_name(self, name, disable_mask, demreq) -> PyObject * - Demangle a C++ (or another language) name into a user-readable string. This - event is called by demangle_name() - +ida_idp.IDP_Hooks.ev_demangle_name(self, name: str, disable_mask: int, demreq: int) -> "PyObject *" + Demangle a C++ (or another language) name into a user-readable string. This event is called by demangle_name() + @param name: (const char *) mangled name - @param disable_mask: (uint32) flags to inhibit parts of output or compiler - info/other (see MNG_) + @param disable_mask: (uint32) flags to inhibit parts of output or compiler info/other (see MNG_) @param demreq: (demreq_type_t) operation to perform @retval 1: if success @retval 0: not implemented - @note: if you call demangle_name() from the handler, protect against recursion! -ida_idp.IDP_Hooks.ev_emu_insn (method) - ev_emu_insn(self, insn) -> 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 'insn' structure. - +ida_idp.IDP_Hooks.ev_emu_insn(self, insn: "insn_t const *") -> 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 'insn' structure. + @param insn: (const insn_t *) @retval 1: ok @retval -1: the kernel will delete the instruction -ida_idp.IDP_Hooks.ev_endbinary (method) - ev_endbinary(self, ok) -> int - IDA has loaded a binary file. - +ida_idp.IDP_Hooks.ev_endbinary(self, ok: bool) -> int + IDA has loaded a binary file. + @param ok: (bool) file loaded successfully? -ida_idp.IDP_Hooks.ev_ending_undo (method) - ev_ending_undo(self, action_name, is_undo) -> int - Ended undoing/redoing an action - - @param action_name: (const char *) action that we finished undoing/redoing. is - not nullptr. +ida_idp.IDP_Hooks.ev_ending_undo(self, action_name: str, is_undo: bool) -> int + Ended undoing/redoing an action + + @param action_name: (const char *) action that we finished undoing/redoing. is not nullptr. @param is_undo: (bool) true if performing undo, false if performing redo -ida_idp.IDP_Hooks.ev_equal_reglocs (method) - ev_equal_reglocs(self, a1, a2) -> int - Are 2 register arglocs the same?. We need this callback for the pc module. - +ida_idp.IDP_Hooks.ev_equal_reglocs(self, a1: "argloc_t", a2: "argloc_t") -> int + Are 2 register arglocs the same?. We need this callback for the pc module. + @param a1: (argloc_t *) @param a2: (argloc_t *) @retval 1: yes @retval -1: no @retval 0: not implemented -ida_idp.IDP_Hooks.ev_extract_address (method) - ev_extract_address(self, out_ea, screen_ea, string, position) -> int - Extract address from a string. - +ida_idp.IDP_Hooks.ev_extract_address(self, out_ea: "ea_t *", screen_ea: ida_idaapi.ea_t, string: str, position: "size_t") -> int + Extract address from a string. + @param out_ea: (ea_t *), out @param screen_ea: (ea_t) @param string: (const char *) @@ -35225,192 +23645,165 @@ ida_idp.IDP_Hooks.ev_extract_address (method) @retval 0: kernel should use the standard algorithm @retval -1: error -ida_idp.IDP_Hooks.ev_find_op_value (method) - ev_find_op_value(self, pinsn, opn) -> PyObject * - Find operand value via a register tracker. The returned value in 'out' is valid - before executing the instruction. - +ida_idp.IDP_Hooks.ev_find_op_value(self, pinsn: "insn_t const *", opn: int) -> "PyObject *" + Find operand value via a register tracker. The returned value in 'out' is valid before executing the instruction. + @param pinsn: (const insn_t *) instruction @param opn: (int) operand index @retval 1: if implemented, and value was found @retval 0: not implemented, -1 decoding failed, or no value found -ida_idp.IDP_Hooks.ev_find_reg_value (method) - ev_find_reg_value(self, pinsn, reg) -> PyObject * - Find register value via a register tracker. The returned value in 'out' is valid - before executing the instruction. - +ida_idp.IDP_Hooks.ev_find_reg_value(self, pinsn: "insn_t const *", reg: int) -> "PyObject *" + Find register value via a register tracker. The returned value in 'out' is valid before executing the instruction. + @param pinsn: (const insn_t *) instruction @param reg: (int) register index @retval 1: if implemented, and value was found @retval 0: not implemented, -1 decoding failed, or no value found -ida_idp.IDP_Hooks.ev_func_bounds (method) - ev_func_bounds(self, possible_return_code, pfn, max_func_end_ea) -> int - find_func_bounds() finished its work. The module may fine tune the function - bounds - +ida_idp.IDP_Hooks.ev_func_bounds(self, possible_return_code: "int *", pfn: "func_t *", max_func_end_ea: ida_idaapi.ea_t) -> int + find_func_bounds() finished its work. The module may fine tune the function bounds + @param possible_return_code: (int *), in/out @param pfn: (func_t *) @param max_func_end_ea: (::ea_t) (from the kernel's point of view) - @retval void + @retval void: -ida_idp.IDP_Hooks.ev_gen_asm_or_lst (method) - ev_gen_asm_or_lst(self, starting, fp, is_asm, flags, outline) -> int - +ida_idp.IDP_Hooks.ev_gen_asm_or_lst(self, starting: bool, fp: "FILE *", is_asm: bool, flags: int, outline: "html_line_cb_t **") -> int + Callback: generating asm or lst file. The kernel calls this callback twice, at the beginning and at the end of listing generation. The processor module can intercept this event and adjust its output + @param starting: (bool) beginning listing generation @param fp: (FILE *) output file @param is_asm: (bool) true:assembler, false:listing @param flags: (int) flags passed to gen_file() - @param outline: (html_line_cb_t **) ptr to ptr to outline callback. if this - callback is defined for this code, it will be used by the kernel - to output the generated lines - @retval void + @param outline: (html_line_cb_t **) ptr to ptr to outline callback. if this callback is defined for this code, it will be used by the kernel to output the generated lines + @retval void: -ida_idp.IDP_Hooks.ev_gen_map_file (method) - ev_gen_map_file(self, nlines, fp) -> int - Generate map file. If not implemented the kernel itself will create the map - file. - +ida_idp.IDP_Hooks.ev_gen_map_file(self, nlines: "int *", fp: "FILE *") -> int + Generate map file. If not implemented the kernel itself will create the map file. + @param nlines: (int *) number of lines in map file (-1 means write error) @param fp: (FILE *) output file @retval 0: not implemented @retval 1: ok @retval -1: write error -ida_idp.IDP_Hooks.ev_gen_regvar_def (method) - ev_gen_regvar_def(self, outctx, v) -> int - Generate register variable definition line. - +ida_idp.IDP_Hooks.ev_gen_regvar_def(self, outctx: "outctx_t *", v: "regvar_t *") -> int + Generate register variable definition line. + @param outctx: (outctx_t *) @param v: (regvar_t *) @retval >0: ok, generated the definition text @retval 0: not implemented -ida_idp.IDP_Hooks.ev_gen_src_file_lnnum (method) - ev_gen_src_file_lnnum(self, outctx, file, lnnum) -> int +ida_idp.IDP_Hooks.ev_gen_src_file_lnnum(self, outctx: "outctx_t *", file: str, lnnum: "size_t") -> int + Callback: generate analog of: + #line 123 + + + @param outctx: (outctx_t *) output context @param file: (const char *) source file (may be nullptr) @param lnnum: (size_t) line number @retval 1: directive has been generated @retval 0: not implemented -ida_idp.IDP_Hooks.ev_gen_stkvar_def (method) - ev_gen_stkvar_def(self, outctx, mptr, v) -> int - Generate stack variable definition line Default line is varname = type ptr - value, where 'type' is one of byte,word,dword,qword,tbyte - +ida_idp.IDP_Hooks.ev_gen_stkvar_def(self, outctx: "outctx_t *", stkvar: "udm_t", v: int, tid: "tid_t") -> int + Generate stack variable definition line Default line is varname = type ptr value, where 'type' is one of byte,word,dword,qword,tbyte + @param outctx: (outctx_t *) - @param mptr: (const member_t *) + @param stkvar: (const udm_t *) @param v: (sval_t) + @param tid: (tid_t) stkvar TID @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_get_abi_info (method) - ev_get_abi_info(self, abi_names, abi_opts, comp) -> int - Get all possible ABI names and optional extensions for given compiler - abiname/option is a string entirely consisting of letters, digits and underscore - - @param abi_names: (qstrvec_t *) - all possible ABis each in form abiname- - opt1-opt2-... - @param abi_opts: (qstrvec_t *) - array of all possible options in form - "opt:description" or opt:hint-line#description +ida_idp.IDP_Hooks.ev_get_abi_info(self, comp: "comp_t") -> int + Get all possible ABI names and optional extensions for given compiler abiname/option is a string entirely consisting of letters, digits and underscore + @param comp: (comp_t) - compiler ID @retval 0: not implemented @retval 1: ok -ida_idp.IDP_Hooks.ev_get_autocmt (method) - ev_get_autocmt(self, insn) -> PyObject * - +ida_idp.IDP_Hooks.ev_get_autocmt(self, insn: "insn_t const *") -> "PyObject *" + Callback: get dynamic auto comment. Will be called if the autocomments are enabled and the comment retrieved from ida.int starts with '$!'. 'insn' contains valid info. + @param insn: (const insn_t*) the instruction @retval 1: new comment has been generated - @retval 0: callback has not been handled. the buffer must not be changed in this - case + @retval 0: callback has not been handled. the buffer must not be changed in this case -ida_idp.IDP_Hooks.ev_get_bg_color (method) - ev_get_bg_color(self, color, ea) -> int - Get item background color. Plugins can hook this callback to color disassembly - lines dynamically - +ida_idp.IDP_Hooks.ev_get_bg_color(self, color: "bgcolor_t *", ea: ida_idaapi.ea_t) -> int + Get item background color. Plugins can hook this callback to color disassembly lines dynamically + @param color: (bgcolor_t *), out @param ea: (::ea_t) @retval 0: not implemented @retval 1: color set -ida_idp.IDP_Hooks.ev_get_cc_regs (method) - ev_get_cc_regs(self, regs, cc) -> int - Get register allocation convention for given calling convention - +ida_idp.IDP_Hooks.ev_get_cc_regs(self, regs: "callregs_t", cc: "cm_t") -> int + Get register allocation convention for given calling convention + @param regs: (callregs_t *), out @param cc: (cm_t) - @retval 1 + @retval 1: @retval 0: not implemented -ida_idp.IDP_Hooks.ev_get_code16_mode (method) - ev_get_code16_mode(self, ea) -> int - Get ISA 16-bit mode - +ida_idp.IDP_Hooks.ev_get_code16_mode(self, ea: ida_idaapi.ea_t) -> int + Get ISA 16-bit mode + @param ea: (ea_t) address to get the ISA mode @retval 1: 16-bit mode @retval 0: not implemented or 32-bit mode -ida_idp.IDP_Hooks.ev_get_dbr_opnum (method) - ev_get_dbr_opnum(self, opnum, insn) -> int - Get the number of the operand to be displayed in the debugger reference view - (text mode). - +ida_idp.IDP_Hooks.ev_get_dbr_opnum(self, opnum: "int *", insn: "insn_t const *") -> int + Get the number of the operand to be displayed in the debugger reference view (text mode). + @param opnum: (int *) operand number (out, -1 means no such operand) @param insn: (const insn_t*) the instruction @retval 0: unimplemented @retval 1: implemented -ida_idp.IDP_Hooks.ev_get_default_enum_size (method) - ev_get_default_enum_size(self) -> int - Get default enum size. Not generated anymore. inf_get_cc_size_e() is used - instead +ida_idp.IDP_Hooks.ev_get_default_enum_size(self) -> int + Get default enum size. Not generated anymore. inf_get_cc_size_e() is used instead + -ida_idp.IDP_Hooks.ev_get_frame_retsize (method) - ev_get_frame_retsize(self, frsize, pfn) -> int - Get size of function return address in bytes If this event is not implemented, - the kernel will assume +ida_idp.IDP_Hooks.ev_get_frame_retsize(self, frsize: "int *", pfn: "func_t const *") -> int + Get size of function return address in bytes If this event is not implemented, the kernel will assume * 8 bytes for 64-bit function * 4 bytes for 32-bit function * 2 bytes otherwise + + @param frsize: (int *) frame size (out) @param pfn: (const func_t *), can't be nullptr @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_get_macro_insn_head (method) - ev_get_macro_insn_head(self, head, ip) -> int - Calculate the start of a macro instruction. This notification is called if IP - points to the middle of an instruction - +ida_idp.IDP_Hooks.ev_get_macro_insn_head(self, head: "ea_t *", ip: ida_idaapi.ea_t) -> int + Calculate the start of a macro instruction. This notification is called if IP points to the middle of an instruction + @param head: (::ea_t *), out: answer, BADADDR means normal instruction @param ip: (::ea_t) instruction address @retval 0: unimplemented @retval 1: implemented -ida_idp.IDP_Hooks.ev_get_operand_string (method) - ev_get_operand_string(self, insn, opnum) -> PyObject * - Request text string for operand (cli, java, ...). - +ida_idp.IDP_Hooks.ev_get_operand_string(self, insn: "insn_t const *", opnum: int) -> "PyObject *" + Request text string for operand (cli, java, ...). + @param insn: (const insn_t*) the instruction @param opnum: (int) operand number, -1 means any string operand @retval 0: no string (or empty string) @retval >0: original string length without terminating zero -ida_idp.IDP_Hooks.ev_get_procmod (method) - ev_get_procmod(self) -> int - Get pointer to the processor module object. All processor modules must implement - this. The pointer is returned as size_t. +ida_idp.IDP_Hooks.ev_get_procmod(self) -> int + Get pointer to the processor module object. All processor modules must implement this. The pointer is returned as size_t. + -ida_idp.IDP_Hooks.ev_get_reg_accesses (method) - ev_get_reg_accesses(self, accvec, insn, flags) -> int - Get info about the registers that are used/changed by an instruction. - +ida_idp.IDP_Hooks.ev_get_reg_accesses(self, accvec: "reg_accesses_t", insn: "insn_t const *", flags: int) -> int + Get info about the registers that are used/changed by an instruction. + @param accvec: (reg_accesses_t*) out: info about accessed registers @param insn: (const insn_t *) instruction in question @param flags: (int) reserved, must be 0 @@ -35418,39 +23811,33 @@ ida_idp.IDP_Hooks.ev_get_reg_accesses (method) @retval 1: found the requested access (and filled accvec) @retval 0: not implemented -ida_idp.IDP_Hooks.ev_get_reg_info (method) - ev_get_reg_info(self, main_regname, bitrange, regname) -> int +ida_idp.IDP_Hooks.ev_get_reg_info(self, main_regname: "char const **", bitrange: "bitrange_t", regname: str) -> int Get register information by its name. example: "ah" returns: * main_regname="eax" * bitrange_t = { offset==8, nbits==8 } - This callback may be unimplemented if the register names are all present in - processor_t::reg_names and they all have the same size + This callback may be unimplemented if the register names are all present in processor_t::reg_names and they all have the same size + @param main_regname: (const char **), out - @param bitrange: (bitrange_t *), out: position and size of the value within - 'main_regname' (empty bitrange == whole register) + @param bitrange: (bitrange_t *), out: position and size of the value within 'main_regname' (empty bitrange == whole register) @param regname: (const char *) @retval 1: ok @retval -1: failed (not found) @retval 0: unimplemented -ida_idp.IDP_Hooks.ev_get_reg_name (method) - ev_get_reg_name(self, reg, width, reghi) -> PyObject * - Generate text representation of a register. Most processor modules do not need - to implement this callback. It is useful only if processor_t::reg_names[reg] - does not provide the correct register name. - +ida_idp.IDP_Hooks.ev_get_reg_name(self, reg: int, width: "size_t", reghi: int) -> "PyObject *" + Generate text representation of a register. Most processor modules do not need to implement this callback. It is useful only if processor_t::reg_names[reg] does not provide the correct register name. + @param reg: (int) internal register number as defined in the processor module @param width: (size_t) register width in bytes @param reghi: (int) if not -1 then this function will return the register pair @retval -1: if error @retval strlen(buf): if success -ida_idp.IDP_Hooks.ev_get_simd_types (method) - ev_get_simd_types(self, out, simd_attrs, argloc, create_tifs) -> int - Get SIMD-related types according to given attributes ant/or argument location - +ida_idp.IDP_Hooks.ev_get_simd_types(self, out: "simd_info_vec_t *", simd_attrs: "simd_info_t", argloc: "argloc_t", create_tifs: bool) -> int + Get SIMD-related types according to given attributes ant/or argument location + @param out: (::simd_info_vec_t *) @param simd_attrs: (const simd_info_t *), may be nullptr @param argloc: (const argloc_t *), may be nullptr @@ -35458,105 +23845,86 @@ ida_idp.IDP_Hooks.ev_get_simd_types (method) @retval number: of found types @retval -1: error If name==nullptr, initialize all SIMD types -ida_idp.IDP_Hooks.ev_get_stkarg_area_info (method) - ev_get_stkarg_area_info(self, out, cc) -> int - Get some metrics of the stack argument area. - +ida_idp.IDP_Hooks.ev_get_stkarg_area_info(self, out: "stkarg_area_info_t", cc: "cm_t") -> int + Get some metrics of the stack argument area. + @param out: (stkarg_area_info_t *) ptr to stkarg_area_info_t @param cc: (cm_t) calling convention @retval 1: if success @retval 0: not implemented -ida_idp.IDP_Hooks.ev_get_stkvar_scale_factor (method) - ev_get_stkvar_scale_factor(self) -> int - Should stack variable references be multiplied by a coefficient before being - used in the stack frame?. Currently used by TMS320C55 because the references - into the stack should be multiplied by 2 - - @return: scaling factor +ida_idp.IDP_Hooks.ev_get_stkvar_scale_factor(self) -> int + Should stack variable references be multiplied by a coefficient before being used in the stack frame?. Currently used by TMS320C55 because the references into the stack should be multiplied by 2 + + @returns scaling factor @retval 0: not implemented - @note: PR_SCALE_STKVARS should be set to use this callback -ida_idp.IDP_Hooks.ev_getreg (method) - ev_getreg(self, regval, regnum) -> int - IBM PC only internal request, should never be used for other purpose Get - register value by internal index - +ida_idp.IDP_Hooks.ev_getreg(self, regval: "uval_t *", regnum: int) -> int + IBM PC only internal request, should never be used for other purpose Get register value by internal index + @param regval: (uval_t *), out @param regnum: (int) @retval 1: ok @retval 0: not implemented @retval -1: failed (undefined value or bad regnum) -ida_idp.IDP_Hooks.ev_init (method) - ev_init(self, idp_modname) -> int - The IDP module is just loaded. - +ida_idp.IDP_Hooks.ev_init(self, idp_modname: str) -> int + The IDP module is just loaded. + @param idp_modname: (const char *) processor module name @retval <0: on failure -ida_idp.IDP_Hooks.ev_insn_reads_tbit (method) - ev_insn_reads_tbit(self, insn, getreg, regvalues) -> int - Check if insn will read the TF bit. - +ida_idp.IDP_Hooks.ev_insn_reads_tbit(self, insn: "insn_t const *", getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> int + Check if insn will read the TF bit. + @param insn: (const insn_t*) the instruction - @param getreg: (::processor_t::regval_getter_t *) function to get register - values + @param getreg: (::processor_t::regval_getter_t *) function to get register values @param regvalues: (const regval_t *) register values array @retval 2: yes, will generate 'step' exception @retval 1: yes, will store the TF bit in memory @retval 0: no -ida_idp.IDP_Hooks.ev_is_align_insn (method) - ev_is_align_insn(self, ea) -> int - Is the instruction created only for alignment purposes?. Do not directly call - this function, use is_align_insn() - +ida_idp.IDP_Hooks.ev_is_align_insn(self, ea: ida_idaapi.ea_t) -> int + Is the instruction created only for alignment purposes?. Do not directly call this function, use is_align_insn() + @param ea: (ea_t) - instruction address @retval number: of bytes in the instruction -ida_idp.IDP_Hooks.ev_is_alloca_probe (method) - ev_is_alloca_probe(self, ea) -> int - Does the function at 'ea' behave as __alloca_probe? - +ida_idp.IDP_Hooks.ev_is_alloca_probe(self, ea: ida_idaapi.ea_t) -> int + Does the function at 'ea' behave as __alloca_probe? + @param ea: (::ea_t) @retval 1: yes @retval 0: no -ida_idp.IDP_Hooks.ev_is_basic_block_end (method) - ev_is_basic_block_end(self, insn, call_insn_stops_block) -> int - Is the current instruction end of a basic block?. This function should be - defined for processors with delayed jump slots. - +ida_idp.IDP_Hooks.ev_is_basic_block_end(self, insn: "insn_t const *", call_insn_stops_block: bool) -> int + Is the current instruction end of a basic block?. This function should be defined for processors with delayed jump slots. + @param insn: (const insn_t*) the instruction @param call_insn_stops_block: (bool) @retval 0: unknown @retval <0: no @retval 1: yes -ida_idp.IDP_Hooks.ev_is_call_insn (method) - ev_is_call_insn(self, insn) -> int - Is the instruction a "call"? - +ida_idp.IDP_Hooks.ev_is_call_insn(self, insn: "insn_t const *") -> int + Is the instruction a "call"? + @param insn: (const insn_t *) instruction @retval 0: unknown @retval <0: no @retval 1: yes -ida_idp.IDP_Hooks.ev_is_cond_insn (method) - ev_is_cond_insn(self, insn) -> int - Is conditional instruction? - +ida_idp.IDP_Hooks.ev_is_cond_insn(self, insn: "insn_t const *") -> int + Is conditional instruction? + @param insn: (const insn_t *) instruction address @retval 1: yes @retval -1: no @retval 0: not implemented or not instruction -ida_idp.IDP_Hooks.ev_is_control_flow_guard (method) - ev_is_control_flow_guard(self, p_reg, insn) -> int - Detect if an instruction is a "thunk call" to a flow guard function (equivalent - to call reg/return/nop) - +ida_idp.IDP_Hooks.ev_is_control_flow_guard(self, p_reg: "int *", insn: "insn_t const *") -> int + Detect if an instruction is a "thunk call" to a flow guard function (equivalent to call reg/return/nop) + @param p_reg: (int *) indirect register number, may be -1 @param insn: (const insn_t *) call/jump instruction @retval -1: no thunk detected @@ -35565,34 +23933,28 @@ ida_idp.IDP_Hooks.ev_is_control_flow_guard (method) @retval 3: return thunk @retval 0: not implemented -ida_idp.IDP_Hooks.ev_is_far_jump (method) - ev_is_far_jump(self, icode) -> int - is indirect far jump or call instruction? meaningful only if the processor has - 'near' and 'far' reference types - +ida_idp.IDP_Hooks.ev_is_far_jump(self, icode: int) -> int + is indirect far jump or call instruction? meaningful only if the processor has 'near' and 'far' reference types + @param icode: (int) @retval 0: not implemented @retval 1: yes @retval -1: no -ida_idp.IDP_Hooks.ev_is_indirect_jump (method) - ev_is_indirect_jump(self, insn) -> int - Determine if instruction is an indirect jump. If CF_JUMP bit cannot describe all - jump types jumps, please define this callback. - +ida_idp.IDP_Hooks.ev_is_indirect_jump(self, insn: "insn_t const *") -> int + Determine if instruction is an indirect jump. If CF_JUMP bit cannot describe all jump types jumps, please define this callback. + @param insn: (const insn_t*) the instruction @retval 0: use CF_JUMP @retval 1: no @retval 2: yes -ida_idp.IDP_Hooks.ev_is_insn_table_jump (method) - ev_is_insn_table_jump(self) -> int +ida_idp.IDP_Hooks.ev_is_insn_table_jump(self) -> int Reserved. -ida_idp.IDP_Hooks.ev_is_jump_func (method) - ev_is_jump_func(self, pfn, jump_target, func_pointer) -> int - Is the function a trivial "jump" function?. - +ida_idp.IDP_Hooks.ev_is_jump_func(self, pfn: "func_t *", jump_target: "ea_t *", func_pointer: "ea_t *") -> int + Is the function a trivial "jump" function?. + @param pfn: (func_t *) @param jump_target: (::ea_t *) @param func_pointer: (::ea_t *) @@ -35600,369 +23962,281 @@ ida_idp.IDP_Hooks.ev_is_jump_func (method) @retval 0: don't know @retval 1: yes, see 'jump_target' and 'func_pointer' -ida_idp.IDP_Hooks.ev_is_ret_insn (method) - ev_is_ret_insn(self, insn, strict) -> int - Is the instruction a "return"? - +ida_idp.IDP_Hooks.ev_is_ret_insn(self, insn: "insn_t const *", flags: "uchar") -> int + Is the instruction a "return"? + @param insn: (const insn_t *) instruction - @param strict: (bool) 1: report only ret instructions 0: include instructions - like "leave" which begins the function epilog + @param flags: (uchar), combination of IRI_... flags (see above) @retval 0: unknown @retval <0: no @retval 1: yes -ida_idp.IDP_Hooks.ev_is_sane_insn (method) - ev_is_sane_insn(self, insn, no_crefs) -> int - Is the instruction sane for the current file type?. - +ida_idp.IDP_Hooks.ev_is_sane_insn(self, insn: "insn_t const *", no_crefs: int) -> int + Is the instruction sane for the current file type?. + @param insn: (const insn_t*) the instruction - @param no_crefs: (int) 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. + @param no_crefs: (int) 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. @retval >=0: ok @retval <0: no, the instruction isn't likely to appear in the program -ida_idp.IDP_Hooks.ev_is_sp_based (method) - ev_is_sp_based(self, mode, insn, op) -> int - Check whether the operand is relative to stack pointer or frame pointer This - event is used to determine how to output a stack variable If not implemented, - then all operands are sp based by default. Implement this event only if some - stack references use frame pointer instead of stack pointer. - +ida_idp.IDP_Hooks.ev_is_sp_based(self, mode: "int *", insn: "insn_t const *", op: "op_t const *") -> int + Check whether the operand is relative to stack pointer or frame pointer This event is used to determine how to output a stack variable If not implemented, then all operands are sp based by default. Implement this event only if some stack references use frame pointer instead of stack pointer. + @param mode: (int *) out, combination of SP/FP operand flags @param insn: (const insn_t *) @param op: (const op_t *) @retval 0: not implemented @retval 1: ok -ida_idp.IDP_Hooks.ev_is_switch (method) - ev_is_switch(self, si, insn) -> int - Find 'switch' idiom or override processor module's decision. It will be called - for instructions marked with CF_JUMP. - +ida_idp.IDP_Hooks.ev_is_switch(self, si: "switch_info_t", insn: "insn_t const *") -> int + Find 'switch' idiom or override processor module's decision. It will be called for instructions marked with CF_JUMP. + @param si: (switch_info_t *), out @param insn: (const insn_t *) instruction possibly belonging to a switch - @retval 1: switch is found, 'si' is filled. IDA will create the switch using the - filled 'si' - @retval -1: no switch found. This value forbids switch creation by the processor - module + @retval 1: switch is found, 'si' is filled. IDA will create the switch using the filled 'si' + @retval -1: no switch found. This value forbids switch creation by the processor module @retval 0: not implemented -ida_idp.IDP_Hooks.ev_last_cb_before_loader (method) - ev_last_cb_before_loader(self) -> int +ida_idp.IDP_Hooks.ev_last_cb_before_loader(self) -> int -ida_idp.IDP_Hooks.ev_loader (method) - ev_loader(self) -> int - This code and higher ones are reserved for the loaders. The arguments and the - return values are defined by the loaders +ida_idp.IDP_Hooks.ev_loader(self) -> int + This code and higher ones are reserved for the loaders. The arguments and the return values are defined by the loaders + -ida_idp.IDP_Hooks.ev_lower_func_type (method) - ev_lower_func_type(self, argnums, fti) -> int - Get function arguments which should be converted to pointers when lowering - function prototype. The processor module can also modify 'fti' in order to make - non-standard conversion of some arguments. - - @param argnums: (intvec_t *), out - numbers of arguments to be converted to - pointers in acsending order - @param fti: (func_type_data_t *), inout func type details (special values -1/-2 - for return value - position of hidden 'retstr' argument: -1 - at the - beginning, -2 - at the end) +ida_idp.IDP_Hooks.ev_lower_func_type(self, argnums: "intvec_t *", fti: "func_type_data_t") -> int + Get function arguments which should be converted to pointers when lowering function prototype. The processor module can also modify 'fti' in order to make non-standard conversion of some arguments. + + @param argnums: (intvec_t *), out - numbers of arguments to be converted to pointers in acsending order + @param fti: (func_type_data_t *), inout func type details @retval 0: not implemented @retval 1: argnums was filled - @retval 2: argnums was filled and made substantial changes to fti + @retval 2: argnums was filled and made substantial changes to fti argnums[0] can contain a special negative value indicating that the return value should be passed as a hidden 'retstr' argument: -1 this argument is passed as the first one and the function returns a pointer to the argument, -2 this argument is passed as the last one and the function returns a pointer to the argument, -3 this argument is passed as the first one and the function returns 'void'. -ida_idp.IDP_Hooks.ev_max_ptr_size (method) - ev_max_ptr_size(self) -> int - Get maximal size of a pointer in bytes. - - @return: max possible size of a pointer +ida_idp.IDP_Hooks.ev_max_ptr_size(self) -> int + Get maximal size of a pointer in bytes. + + @returns max possible size of a pointer -ida_idp.IDP_Hooks.ev_may_be_func (method) - ev_may_be_func(self, insn, state) -> int - Can a function start here? - +ida_idp.IDP_Hooks.ev_may_be_func(self, insn: "insn_t const *", state: int) -> int + Can a function start here? + @param insn: (const insn_t*) the instruction @param state: (int) autoanalysis phase 0: creating functions 1: creating chunks - @return: probability 1..100 - @note: Actually IDA uses 3 intervals of a probability: 0..50 not a function, - 51..99 a function (IDA needs another proof), 100 a function (no other - proofs needed) + @returns probability 1..100 -ida_idp.IDP_Hooks.ev_may_show_sreg (method) - ev_may_show_sreg(self, current_ea) -> int - The kernel wants to display the segment registers in the messages window. - +ida_idp.IDP_Hooks.ev_may_show_sreg(self, current_ea: ida_idaapi.ea_t) -> int + The kernel wants to display the segment registers in the messages window. + @param current_ea: (::ea_t) - @retval <0: if the kernel should not show the segment registers. (assuming that - the module has done it) + @retval <0: if the kernel should not show the segment registers. (assuming that the module has done it) @retval 0: not implemented -ida_idp.IDP_Hooks.ev_moving_segm (method) - ev_moving_segm(self, seg, to, flags) -> int - May the kernel move the segment? - +ida_idp.IDP_Hooks.ev_moving_segm(self, seg: "segment_t *", to: ida_idaapi.ea_t, flags: int) -> int + May the kernel move the segment? + @param seg: (segment_t *) segment to move @param to: (::ea_t) new segment start address @param flags: (int) combination of Move segment flags @retval 0: yes @retval <0: the kernel should stop -ida_idp.IDP_Hooks.ev_newasm (method) - ev_newasm(self, asmnum) -> int - Before setting a new assembler. - +ida_idp.IDP_Hooks.ev_newasm(self, asmnum: int) -> int + Before setting a new assembler. + @param asmnum: (int) See also ev_asm_installed -ida_idp.IDP_Hooks.ev_newbinary (method) - ev_newbinary(self, filename, fileoff, basepara, binoff, nbytes) -> int - IDA is about to load a binary file. - +ida_idp.IDP_Hooks.ev_newbinary(self, filename: "char *", fileoff: "qoff64_t", basepara: ida_idaapi.ea_t, binoff: ida_idaapi.ea_t, nbytes: "uint64") -> int + IDA is about to load a binary file. + @param filename: (char *) binary file name @param fileoff: (qoff64_t) offset in the file @param basepara: (::ea_t) base loading paragraph @param binoff: (::ea_t) loader offset @param nbytes: (::uint64) number of bytes to load -ida_idp.IDP_Hooks.ev_newfile (method) - ev_newfile(self, fname) -> int - A new file has been loaded. - +ida_idp.IDP_Hooks.ev_newfile(self, fname: "char *") -> int + A new file has been loaded. + @param fname: (char *) input file name -ida_idp.IDP_Hooks.ev_newprc (method) - ev_newprc(self, pnum, keep_cfg) -> int - Before changing processor type. - +ida_idp.IDP_Hooks.ev_newprc(self, pnum: int, keep_cfg: bool) -> int + Before changing processor type. + @param pnum: (int) processor number in the array of processor names @param keep_cfg: (bool) true: do not modify kernel configuration @retval 1: ok @retval <0: prohibit -ida_idp.IDP_Hooks.ev_next_exec_insn (method) - ev_next_exec_insn(self, target, ea, tid, getreg, regvalues) -> int - Get next address to be executed This function must return the next address to be - executed. If the instruction following the current one is executed, then it must - return BADADDR Usually the instructions to consider are: jumps, branches, calls, - returns. This function is essential if the 'single step' is not supported in - hardware. - +ida_idp.IDP_Hooks.ev_next_exec_insn(self, target: "ea_t *", ea: ida_idaapi.ea_t, tid: int, getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> int + Get next address to be executed This function must return the next address to be executed. If the instruction following the current one is executed, then it must return BADADDR Usually the instructions to consider are: jumps, branches, calls, returns. This function is essential if the 'single step' is not supported in hardware. + @param target: (::ea_t *), out: pointer to the answer @param ea: (::ea_t) instruction address @param tid: (int) current therad id - @param getreg: (::processor_t::regval_getter_t *) function to get register - values + @param getreg: (::processor_t::regval_getter_t *) function to get register values @param regvalues: (const regval_t *) register values array @retval 0: unimplemented @retval 1: implemented -ida_idp.IDP_Hooks.ev_oldfile (method) - ev_oldfile(self, fname) -> int - An old file has been loaded. - +ida_idp.IDP_Hooks.ev_oldfile(self, fname: "char *") -> int + An old file has been loaded. + @param fname: (char *) input file name -ida_idp.IDP_Hooks.ev_out_assumes (method) - ev_out_assumes(self, outctx) -> int - Function to produce assume directives when segment register value changes. - +ida_idp.IDP_Hooks.ev_out_assumes(self, outctx: "outctx_t *") -> int + Function to produce assume directives when segment register value changes. + @param outctx: (outctx_t *) @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_out_data (method) - ev_out_data(self, outctx, analyze_only) -> int - Generate text representation of data items This function may change the database - and create cross-references if analyze_only is set - +ida_idp.IDP_Hooks.ev_out_data(self, outctx: "outctx_t *", analyze_only: bool) -> int + Generate text representation of data items This function may change the database and create cross-references if analyze_only is set + @param outctx: (outctx_t *) @param analyze_only: (bool) @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_out_footer (method) - ev_out_footer(self, outctx) -> int - Function to produce end of disassembled text - +ida_idp.IDP_Hooks.ev_out_footer(self, outctx: "outctx_t *") -> int + Function to produce end of disassembled text + @param outctx: (outctx_t *) - @retval void + @retval void: -ida_idp.IDP_Hooks.ev_out_header (method) - ev_out_header(self, outctx) -> int - Function to produce start of disassembled text - +ida_idp.IDP_Hooks.ev_out_header(self, outctx: "outctx_t *") -> int + Function to produce start of disassembled text + @param outctx: (outctx_t *) - @retval void + @retval void: -ida_idp.IDP_Hooks.ev_out_insn (method) - ev_out_insn(self, outctx) -> bool - Generate text representation of an instruction in 'ctx.insn' outctx_t provides - functions to output the generated text. This function shouldn't change the - database, flags or anything else. All these actions should be performed only by - emu_insn() function. - +ida_idp.IDP_Hooks.ev_out_insn(self, outctx: "outctx_t *") -> bool + Generate text representation of an instruction in 'ctx.insn' outctx_t provides functions to output the generated text. This function shouldn't change the database, flags or anything else. All these actions should be performed only by emu_insn() function. + @param outctx: (outctx_t *) - @retval void + @retval void: -ida_idp.IDP_Hooks.ev_out_label (method) - ev_out_label(self, outctx, colored_name) -> int - The kernel is going to generate an instruction label line or a function header. - +ida_idp.IDP_Hooks.ev_out_label(self, outctx: "outctx_t *", colored_name: str) -> int + The kernel is going to generate an instruction label line or a function header. + @param outctx: (outctx_t *) @param colored_name: (const char *) @retval <0: if the kernel should not generate the label @retval 0: not implemented or continue -ida_idp.IDP_Hooks.ev_out_mnem (method) - ev_out_mnem(self, outctx) -> int - Generate instruction mnemonics. This callback should append the colored - mnemonics to ctx.outbuf Optional notification, if absent, out_mnem will be - called. - +ida_idp.IDP_Hooks.ev_out_mnem(self, outctx: "outctx_t *") -> int + Generate instruction mnemonics. This callback should append the colored mnemonics to ctx.outbuf Optional notification, if absent, out_mnem will be called. + @param outctx: (outctx_t *) @retval 1: if appended the mnemonics @retval 0: not implemented -ida_idp.IDP_Hooks.ev_out_operand (method) - ev_out_operand(self, outctx, op) -> bool - Generate text representation of an instruction operand outctx_t provides - functions to output the generated text. All these actions should be performed - only by emu_insn() function. - +ida_idp.IDP_Hooks.ev_out_operand(self, outctx: "outctx_t *", op: "op_t const *") -> bool + Generate text representation of an instruction operand outctx_t provides functions to output the generated text. All these actions should be performed only by emu_insn() function. + @param outctx: (outctx_t *) @param op: (const op_t *) @retval 1: ok @retval -1: operand is hidden -ida_idp.IDP_Hooks.ev_out_segend (method) - ev_out_segend(self, outctx, seg) -> int - Function to produce end of segment - +ida_idp.IDP_Hooks.ev_out_segend(self, outctx: "outctx_t *", seg: "segment_t *") -> int + Function to produce end of segment + @param outctx: (outctx_t *) @param seg: (segment_t *) @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_out_segstart (method) - ev_out_segstart(self, outctx, seg) -> int - Function to produce start of segment - +ida_idp.IDP_Hooks.ev_out_segstart(self, outctx: "outctx_t *", seg: "segment_t *") -> int + Function to produce start of segment + @param outctx: (outctx_t *) @param seg: (segment_t *) @retval 1: ok @retval 0: not implemented -ida_idp.IDP_Hooks.ev_out_special_item (method) - ev_out_special_item(self, outctx, segtype) -> int - Generate text representation of an item in a special segment i.e. absolute - symbols, externs, communal definitions etc - +ida_idp.IDP_Hooks.ev_out_special_item(self, outctx: "outctx_t *", segtype: "uchar") -> int + Generate text representation of an item in a special segment i.e. absolute symbols, externs, communal definitions etc + @param outctx: (outctx_t *) @param segtype: (uchar) @retval 1: ok @retval 0: not implemented @retval -1: overflow -ida_idp.IDP_Hooks.ev_privrange_changed (method) - ev_privrange_changed(self, old_privrange, delta) -> int - Privrange interval has been moved to a new location. Most common actions to be - done by module in this case: fix indices of netnodes used by module - +ida_idp.IDP_Hooks.ev_privrange_changed(self, old_privrange: "range_t", delta: "adiff_t") -> int + Privrange interval has been moved to a new location. Most common actions to be done by module in this case: fix indices of netnodes used by module + @param old_privrange: (const range_t *) - old privrange interval @param delta: (::adiff_t) - @return: 0 Ok - -1 error (and message in errbuf) + @retval 0: Ok + @retval -1: error (and message in errbuf) -ida_idp.IDP_Hooks.ev_realcvt (method) - ev_realcvt(self, m, e, swt) -> int - Floating point -> IEEE conversion - +ida_idp.IDP_Hooks.ev_realcvt(self, m: "void *", e: "fpvalue_t *", swt: "uint16") -> int + Floating point -> IEEE conversion + @param m: (void *) ptr to processor-specific floating point value @param e: (fpvalue_t *) IDA representation of a floating point value @param swt: (uint16) operation (see realcvt() in ieee.h) @retval 0: not implemented - @retval 1: ok - @retval unknown -ida_idp.IDP_Hooks.ev_rename (method) - ev_rename(self, ea, new_name) -> int - The kernel is going to rename a byte. - +ida_idp.IDP_Hooks.ev_rename(self, ea: ida_idaapi.ea_t, new_name: str) -> int + The kernel is going to rename a byte. + @param ea: (::ea_t) @param new_name: (const char *) @retval <0: if the kernel should not rename it. - @retval 2: to inhibit the notification. I.e., the kernel should not rename, but - 'set_name()' should return 'true'. also see renamed the return value - is ignored when kernel is going to delete name + @retval 2: to inhibit the notification. I.e., the kernel should not rename, but 'set_name()' should return 'true'. also see renamed the return value is ignored when kernel is going to delete name -ida_idp.IDP_Hooks.ev_replaying_undo (method) - ev_replaying_undo(self, action_name, vec, is_undo) -> int - Replaying an undo/redo buffer - - @param action_name: (const char *) action that we perform undo/redo for. may be - nullptr for intermediary buffers. +ida_idp.IDP_Hooks.ev_replaying_undo(self, action_name: str, vec: "undo_records_t const *", is_undo: bool) -> int + Replaying an undo/redo buffer + + @param action_name: (const char *) action that we perform undo/redo for. may be nullptr for intermediary buffers. @param vec: (const undo_records_t *) - @param is_undo: (bool) true if performing undo, false if performing redo This - event may be generated multiple times per undo/redo + @param is_undo: (bool) true if performing undo, false if performing redo This event may be generated multiple times per undo/redo -ida_idp.IDP_Hooks.ev_set_code16_mode (method) - ev_set_code16_mode(self, ea, code16) -> int - Some processors have ISA 16-bit mode e.g. ARM Thumb mode, PPC VLE, MIPS16 Set - ISA 16-bit mode - +ida_idp.IDP_Hooks.ev_set_code16_mode(self, ea: ida_idaapi.ea_t, code16: bool) -> int + Some processors have ISA 16-bit mode e.g. ARM Thumb mode, PPC VLE, MIPS16 Set ISA 16-bit mode + @param ea: (ea_t) address to set new ISA mode @param code16: (bool) true for 16-bit mode, false for 32-bit mode -ida_idp.IDP_Hooks.ev_set_idp_options (method) - ev_set_idp_options(self, keyword, value_type, value, idb_loaded) -> int - Set IDP-specific configuration option Also see set_options_t in config.hpp - +ida_idp.IDP_Hooks.ev_set_idp_options(self, keyword: str, value_type: int, value: "void const *", idb_loaded: bool) -> int + Set IDP-specific configuration option Also see set_options_t in config.hpp + @param keyword: (const char *) @param value_type: (int) @param value: (const void *) - @param idb_loaded: (bool) true if the ev_oldfile/ev_newfile events have been - generated + @param idb_loaded: (bool) true if the ev_oldfile/ev_newfile events have been generated @retval 1: ok @retval 0: not implemented @retval -1: error (and message in errbuf) -ida_idp.IDP_Hooks.ev_set_proc_options (method) - ev_set_proc_options(self, options, confidence) -> int - Called if the user specified an option string in the command line: -p:. Can be used for setting a processor subtype. Also called if - option string is passed to set_processor_type() and IDC's SetProcessorType(). - +ida_idp.IDP_Hooks.ev_set_proc_options(self, options: str, confidence: int) -> int + Called if the user specified an option string in the command line: -p:. Can be used for setting a processor subtype. Also called if option string is passed to set_processor_type() and IDC's SetProcessorType(). + @param options: (const char *) @param confidence: (int) 0: loader's suggestion 1: user's decision @retval <0: if bad option string -ida_idp.IDP_Hooks.ev_setup_til (method) - ev_setup_til(self) -> int - Setup default type libraries. (called after loading a new file into the - database). The processor module may load tils, setup memory model and perform - other actions required to set up the type system. This is an optional callback. - @retval void +ida_idp.IDP_Hooks.ev_setup_til(self) -> int + Setup default type libraries. (called after loading a new file into the database). The processor module may load tils, setup memory model and perform other actions required to set up the type system. This is an optional callback. + + @retval void: -ida_idp.IDP_Hooks.ev_str2reg (method) - ev_str2reg(self, regname) -> int - Convert a register name to a register number. The register number is the - register index in the processor_t::reg_names array Most processor modules do not - need to implement this callback It is useful only if processor_t::reg_names[reg] - does not provide the correct register names - +ida_idp.IDP_Hooks.ev_str2reg(self, regname: str) -> int + Convert a register name to a register number. The register number is the register index in the processor_t::reg_names array Most processor modules do not need to implement this callback It is useful only if processor_t::reg_names[reg] does not provide the correct register names + @param regname: (const char *) @retval register: number + 1 @retval 0: not implemented or could not be decoded -ida_idp.IDP_Hooks.ev_term (method) - ev_term(self) -> int +ida_idp.IDP_Hooks.ev_term(self) -> int The IDP module is being unloaded. -ida_idp.IDP_Hooks.ev_treat_hindering_item (method) - ev_treat_hindering_item(self, hindering_item_ea, new_item_flags, new_item_ea, new_item_length) -> int - An item hinders creation of another item. - +ida_idp.IDP_Hooks.ev_treat_hindering_item(self, hindering_item_ea: ida_idaapi.ea_t, new_item_flags: "flags64_t", new_item_ea: ida_idaapi.ea_t, new_item_length: "asize_t") -> int + An item hinders creation of another item. + @param hindering_item_ea: (::ea_t) @param new_item_flags: (flags64_t) (0 for code) @param new_item_ea: (::ea_t) @@ -35970,2765 +24244,1022 @@ ida_idp.IDP_Hooks.ev_treat_hindering_item (method) @retval 0: no reaction @retval !=0: the kernel may delete the hindering item -ida_idp.IDP_Hooks.ev_undefine (method) - ev_undefine(self, ea) -> int - An item in the database (insn or data) is being deleted. - +ida_idp.IDP_Hooks.ev_undefine(self, ea: ida_idaapi.ea_t) -> int + An item in the database (insn or data) is being deleted. + @param ea: (ea_t) @retval 1: do not delete srranges at the item end @retval 0: srranges can be deleted -ida_idp.IDP_Hooks.ev_update_call_stack (method) - ev_update_call_stack(self, stack, tid, getreg, regvalues) -> int - Calculate the call stack trace for the given thread. This callback is invoked - when the process is suspended and should fill the 'trace' object with the - information about the current call stack. Note that this callback is NOT invoked - if the current debugger backend implements stack tracing via - debugger_t::event_t::ev_update_call_stack. The debugger-specific algorithm takes - priority. Implementing this callback in the processor module is useful when - multiple debugging platforms follow similar patterns, and thus the same - processor-specific algorithm can be used for different platforms. - +ida_idp.IDP_Hooks.ev_update_call_stack(self, stack: "call_stack_t", tid: int, getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> int + Calculate the call stack trace for the given thread. This callback is invoked when the process is suspended and should fill the 'trace' object with the information about the current call stack. Note that this callback is NOT invoked if the current debugger backend implements stack tracing via debugger_t::event_t::ev_update_call_stack. The debugger-specific algorithm takes priority. Implementing this callback in the processor module is useful when multiple debugging platforms follow similar patterns, and thus the same processor-specific algorithm can be used for different platforms. + @param stack: (call_stack_t *) result @param tid: (int) thread id - @param getreg: (::processor_t::regval_getter_t *) function to get register - values + @param getreg: (::processor_t::regval_getter_t *) function to get register values @param regvalues: (const regval_t *) register values array @retval 1: ok @retval -1: failed @retval 0: unimplemented -ida_idp.IDP_Hooks.ev_use_arg_types (method) - ev_use_arg_types(self, ea, fti, rargs) -> int - Use information about callee arguments. - +ida_idp.IDP_Hooks.ev_use_arg_types(self, ea: ida_idaapi.ea_t, fti: "func_type_data_t", rargs: "funcargvec_t *") -> int + Use information about callee arguments. + @param ea: (::ea_t) address of the call instruction @param fti: (func_type_data_t *) info about function type @param rargs: (funcargvec_t *) array of register arguments @retval 1: (and removes handled arguments from fti and rargs) @retval 0: not implemented -ida_idp.IDP_Hooks.ev_use_regarg_type (method) - ev_use_regarg_type(self, ea, rargs) -> PyObject * - Use information about register argument. - +ida_idp.IDP_Hooks.ev_use_regarg_type(self, ea: ida_idaapi.ea_t, rargs: "funcargvec_t const *") -> "PyObject *" + Use information about register argument. + @param ea: (::ea_t) address of the instruction - @param rargs: (const funcargvec_t *) vector of register arguments (including - regs extracted from scattered arguments) - @retval 1 + @param rargs: (const funcargvec_t *) vector of register arguments (including regs extracted from scattered arguments) + @retval 1: @retval 0: not implemented -ida_idp.IDP_Hooks.ev_use_stkarg_type (method) - ev_use_stkarg_type(self, ea, arg) -> int - Use information about a stack argument. - - @param ea: (::ea_t) address of the push instruction which pushes the function - argument into the stack +ida_idp.IDP_Hooks.ev_use_stkarg_type(self, ea: ida_idaapi.ea_t, arg: "funcarg_t") -> int + Use information about a stack argument. + + @param ea: (::ea_t) address of the push instruction which pushes the function argument into the stack @param arg: (const funcarg_t *) argument info @retval 1: ok - @retval <=0: failed, the kernel will create a comment with the argument name or - type for the instruction + @retval <=0: failed, the kernel will create a comment with the argument name or type for the instruction -ida_idp.IDP_Hooks.ev_validate_flirt_func (method) - ev_validate_flirt_func(self, start_ea, funcname) -> int - Flirt has recognized a library function. This callback can be used by a plugin - or proc module to intercept it and validate such a function. - +ida_idp.IDP_Hooks.ev_validate_flirt_func(self, start_ea: ida_idaapi.ea_t, funcname: str) -> int + Flirt has recognized a library function. This callback can be used by a plugin or proc module to intercept it and validate such a function. + @param start_ea: (::ea_t) @param funcname: (const char *) @retval -1: do not create a function, @retval 0: function is validated -ida_idp.IDP_Hooks.ev_verify_noreturn (method) - ev_verify_noreturn(self, pfn) -> int - The kernel wants to set 'noreturn' flags for a function. - +ida_idp.IDP_Hooks.ev_verify_noreturn(self, pfn: "func_t *") -> int + The kernel wants to set 'noreturn' flags for a function. + @param pfn: (func_t *) @retval 0: ok. any other value: do not set 'noreturn' flag -ida_idp.IDP_Hooks.ev_verify_sp (method) - ev_verify_sp(self, pfn) -> int - All function instructions have been analyzed. Now the processor module can - analyze the stack pointer for the whole function - +ida_idp.IDP_Hooks.ev_verify_sp(self, pfn: "func_t *") -> int + All function instructions have been analyzed. Now the processor module can analyze the stack pointer for the whole function + @param pfn: (func_t *) @retval 0: ok @retval <0: bad stack pointer -ida_idp.IDP_Hooks.hook (method) - hook(self) -> bool +ida_idp.IDP_Hooks.hook(self) -> bool -ida_idp.IDP_Hooks.unhook (method) - unhook(self) -> bool +ida_idp.IDP_Hooks.unhook(self) -> bool -ida_idp.IDP_INTERFACE_VERSION (variable) - The interface version number. - @note: see also IDA_SDK_VERSION from pro.h +ida_idp.IDP_INTERFACE_VERSION + The interface version number. + -ida_idp.OP_FP_BASED (variable) +ida_idp.IRI_EXTENDED + Is the instruction a "return"? + + include instructions like "leave" that begin the function epilog + + +ida_idp.IRI_RET_LITERALLY + report only 'ret' instructions + +ida_idp.IRI_SKIP_RETTARGET + exclude 'ret' instructions that have special targets (see set_ret_target in PC) + + +ida_idp.LTC_ADDED + added a local type + +ida_idp.LTC_ALIASED + added a type alias + +ida_idp.LTC_COMPILER + changed the compiler and calling convention + +ida_idp.LTC_DELETED + deleted a local type + +ida_idp.LTC_EDITED + edited a local type + +ida_idp.LTC_NONE + no event (internal use) + +ida_idp.LTC_TIL_COMPACTED + numbered types have been compacted compact_numbered_types() + +ida_idp.LTC_TIL_LOADED + loaded a til file + +ida_idp.LTC_TIL_UNLOADED + unloaded a til file + +ida_idp.OP_FP_BASED operand is FP based -ida_idp.OP_SP_ADD (variable) +ida_idp.OP_SP_ADD operand value is added to the pointer -ida_idp.OP_SP_BASED (variable) +ida_idp.OP_SP_BASED operand is SP based -ida_idp.OP_SP_SUB (variable) +ida_idp.OP_SP_SUB operand value is subtracted from the pointer -ida_idp.PLFM_386 (variable) +ida_idp.PLFM_386 Intel 80x86. -ida_idp.PLFM_6502 (variable) +ida_idp.PLFM_6502 6502 -ida_idp.PLFM_65C816 (variable) +ida_idp.PLFM_65C816 65802/65816 -ida_idp.PLFM_6800 (variable) +ida_idp.PLFM_6800 Motorola 68xx. -ida_idp.PLFM_68K (variable) +ida_idp.PLFM_68K Motorola 680x0. -ida_idp.PLFM_80196 (variable) +ida_idp.PLFM_80196 Intel 80196. -ida_idp.PLFM_8051 (variable) +ida_idp.PLFM_8051 8051 -ida_idp.PLFM_AD2106X (variable) +ida_idp.PLFM_AD2106X Analog Devices ADSP 2106X. -ida_idp.PLFM_AD218X (variable) +ida_idp.PLFM_AD218X Analog Devices ADSP 218X. -ida_idp.PLFM_ALPHA (variable) +ida_idp.PLFM_ALPHA DEC Alpha. -ida_idp.PLFM_ARC (variable) +ida_idp.PLFM_ARC Argonaut RISC Core. -ida_idp.PLFM_ARM (variable) +ida_idp.PLFM_ARM Advanced RISC Machines. -ida_idp.PLFM_AVR (variable) +ida_idp.PLFM_AVR Atmel 8-bit RISC processor(s) -ida_idp.PLFM_C166 (variable) +ida_idp.PLFM_C166 Siemens C166 family. -ida_idp.PLFM_C39 (variable) +ida_idp.PLFM_C39 Rockwell C39. -ida_idp.PLFM_CR16 (variable) +ida_idp.PLFM_CR16 NSC CR16. -ida_idp.PLFM_DALVIK (variable) +ida_idp.PLFM_DALVIK Android Dalvik Virtual Machine. -ida_idp.PLFM_DSP56K (variable) +ida_idp.PLFM_DSP56K Motorola DSP5600x. -ida_idp.PLFM_DSP96K (variable) +ida_idp.PLFM_DSP96K Motorola DSP96000. -ida_idp.PLFM_EBC (variable) +ida_idp.PLFM_EBC EFI Bytecode. -ida_idp.PLFM_F2MC (variable) +ida_idp.PLFM_F2MC Fujistu F2MC-16. -ida_idp.PLFM_FR (variable) +ida_idp.PLFM_FR Fujitsu FR Family. -ida_idp.PLFM_H8 (variable) +ida_idp.PLFM_H8 Hitachi H8/300, H8/2000. -ida_idp.PLFM_H8500 (variable) +ida_idp.PLFM_H8500 Hitachi H8/500. -ida_idp.PLFM_HPPA (variable) +ida_idp.PLFM_HPPA Hewlett-Packard PA-RISC. -ida_idp.PLFM_I860 (variable) +ida_idp.PLFM_I860 Intel 860. -ida_idp.PLFM_I960 (variable) +ida_idp.PLFM_I960 Intel 960. -ida_idp.PLFM_IA64 (variable) +ida_idp.PLFM_IA64 Intel Itanium IA64. -ida_idp.PLFM_JAVA (variable) +ida_idp.PLFM_JAVA Java. -ida_idp.PLFM_KR1878 (variable) +ida_idp.PLFM_KR1878 Angstrem KR1878. -ida_idp.PLFM_M16C (variable) +ida_idp.PLFM_M16C Renesas M16C. -ida_idp.PLFM_M32R (variable) +ida_idp.PLFM_M32R Mitsubishi 32bit RISC. -ida_idp.PLFM_M740 (variable) +ida_idp.PLFM_M740 Mitsubishi 8bit. -ida_idp.PLFM_M7700 (variable) +ida_idp.PLFM_M7700 Mitsubishi 16bit. -ida_idp.PLFM_M7900 (variable) +ida_idp.PLFM_M7900 Mitsubishi 7900. -ida_idp.PLFM_MC6812 (variable) +ida_idp.PLFM_MC6812 Motorola 68HC12. -ida_idp.PLFM_MC6816 (variable) +ida_idp.PLFM_MC6816 Motorola 68HC16. -ida_idp.PLFM_MIPS (variable) +ida_idp.PLFM_MIPS MIPS. -ida_idp.PLFM_MN102L00 (variable) +ida_idp.PLFM_MN102L00 Panasonic MN10200. -ida_idp.PLFM_MSP430 (variable) +ida_idp.PLFM_MSP430 Texas Instruments MSP430. -ida_idp.PLFM_NEC_78K0 (variable) +ida_idp.PLFM_NEC_78K0 NEC 78K0. -ida_idp.PLFM_NEC_78K0S (variable) +ida_idp.PLFM_NEC_78K0S NEC 78K0S. -ida_idp.PLFM_NEC_V850X (variable) +ida_idp.PLFM_NEC_V850X NEC V850 and V850ES/E1/E2. -ida_idp.PLFM_NET (variable) +ida_idp.PLFM_NET Microsoft Visual Studio.Net. -ida_idp.PLFM_OAKDSP (variable) +ida_idp.PLFM_OAKDSP Atmel OAK DSP. -ida_idp.PLFM_PDP (variable) +ida_idp.PLFM_PDP PDP11. -ida_idp.PLFM_PIC (variable) +ida_idp.PLFM_PIC Microchip's PIC. -ida_idp.PLFM_PIC16 (variable) +ida_idp.PLFM_PIC16 Microchip's 16-bit PIC. -ida_idp.PLFM_PPC (variable) +ida_idp.PLFM_PPC PowerPC. -ida_idp.PLFM_RISCV (variable) +ida_idp.PLFM_RISCV RISC-V. -ida_idp.PLFM_RL78 (variable) +ida_idp.PLFM_RL78 Renesas RL78. -ida_idp.PLFM_RX (variable) +ida_idp.PLFM_RX Renesas RX. -ida_idp.PLFM_S390 (variable) +ida_idp.PLFM_S390 IBM's S390. -ida_idp.PLFM_SCR_ADPT (variable) +ida_idp.PLFM_SCR_ADPT Processor module adapter for processor modules written in scripting languages. -ida_idp.PLFM_SH (variable) +ida_idp.PLFM_SH Renesas (formerly Hitachi) SuperH. -ida_idp.PLFM_SPARC (variable) +ida_idp.PLFM_SPARC SPARC. -ida_idp.PLFM_SPC700 (variable) +ida_idp.PLFM_SPC700 Sony SPC700. -ida_idp.PLFM_SPU (variable) +ida_idp.PLFM_SPU Cell Broadband Engine Synergistic Processor Unit. -ida_idp.PLFM_ST20 (variable) +ida_idp.PLFM_ST20 SGS-Thomson ST20. -ida_idp.PLFM_ST7 (variable) +ida_idp.PLFM_ST7 SGS-Thomson ST7. -ida_idp.PLFM_ST9 (variable) +ida_idp.PLFM_ST9 ST9+. -ida_idp.PLFM_TLCS900 (variable) +ida_idp.PLFM_TLCS900 Toshiba TLCS-900. -ida_idp.PLFM_TMS (variable) +ida_idp.PLFM_TMS Texas Instruments TMS320C5x. -ida_idp.PLFM_TMS320C1X (variable) +ida_idp.PLFM_TMS320C1X Texas Instruments TMS320C1x. -ida_idp.PLFM_TMS320C28 (variable) +ida_idp.PLFM_TMS320C28 Texas Instruments TMS320C28x. -ida_idp.PLFM_TMS320C3 (variable) +ida_idp.PLFM_TMS320C3 Texas Instruments TMS320C3. -ida_idp.PLFM_TMS320C54 (variable) +ida_idp.PLFM_TMS320C54 Texas Instruments TMS320C54xx. -ida_idp.PLFM_TMS320C55 (variable) +ida_idp.PLFM_TMS320C55 Texas Instruments TMS320C55xx. -ida_idp.PLFM_TMSC6 (variable) +ida_idp.PLFM_TMSC6 Texas Instruments TMS320C6x. -ida_idp.PLFM_TRICORE (variable) +ida_idp.PLFM_TRICORE Tasking Tricore. -ida_idp.PLFM_TRIMEDIA (variable) +ida_idp.PLFM_TRIMEDIA Trimedia. -ida_idp.PLFM_UNSP (variable) +ida_idp.PLFM_UNSP SunPlus unSP. -ida_idp.PLFM_XTENSA (variable) +ida_idp.PLFM_WASM + WASM. + +ida_idp.PLFM_XTENSA Tensilica Xtensa. -ida_idp.PLFM_Z8 (variable) +ida_idp.PLFM_Z8 Z8. -ida_idp.PLFM_Z80 (variable) +ida_idp.PLFM_Z80 8085, Z80 -ida_idp.PR2_CODE16_BIT (variable) - low bit of code addresses has special meaning e.g. ARM Thumb, MIPS16 +ida_idp.PR2_CODE16_BIT + low bit of code addresses has special meaning e.g. ARM Thumb, MIPS16 + -ida_idp.PR2_FORCE_16BIT (variable) +ida_idp.PR2_FORCE_16BIT use 16-bit basic types despite of 32-bit segments (used by c166) -ida_idp.PR2_IDP_OPTS (variable) +ida_idp.PR2_IDP_OPTS the module has processor-specific configuration options -ida_idp.PR2_MACRO (variable) +ida_idp.PR2_MACRO processor supports macro instructions -ida_idp.PR2_MAPPINGS (variable) +ida_idp.PR2_MAPPINGS the processor module uses memory mapping -ida_idp.PR2_REALCVT (variable) - the module has a custom 'ev_realcvt' implementation (otherwise IEEE-754 format - is assumed) - -ida_idp.PR2_REL_BITS (variable) +ida_idp.PR2_REL_BITS (Lumina) calcrel info has bits granularity, not bytes - construction flag only -ida_idp.PR2_USE_CALCREL (variable) +ida_idp.PR2_USE_CALCREL (Lumina) the module supports calcrel info -ida_idp.PRN_BIN (variable) +ida_idp.PRN_BIN binary -ida_idp.PRN_DEC (variable) +ida_idp.PRN_DEC decimal -ida_idp.PRN_HEX (variable) +ida_idp.PRN_HEX hex -ida_idp.PRN_OCT (variable) +ida_idp.PRN_OCT octal -ida_idp.PR_ADJSEGS (variable) +ida_idp.PR_ADJSEGS IDA may adjust segments' starting/ending addresses. -ida_idp.PR_ALIGN (variable) +ida_idp.PR_ALIGN All data items should be aligned properly. -ida_idp.PR_ALIGN_INSN (variable) - allow ida to create alignment instructions arbitrarily. Since these instructions - might lead to other wrong instructions and spoil the listing, IDA does not - create them by default anymore +ida_idp.PR_ALIGN_INSN + allow ida to create alignment instructions arbitrarily. Since these instructions might lead to other wrong instructions and spoil the listing, IDA does not create them by default anymore + -ida_idp.PR_ASSEMBLE (variable) +ida_idp.PR_ASSEMBLE Module has a built-in assembler and will react to ev_assemble. -ida_idp.PR_BINMEM (variable) - the processor module provides correct segmentation for binary files (i.e. it - creates additional segments). The kernel will not ask the user to specify the - RAM/ROM sizes +ida_idp.PR_BINMEM + the processor module provides correct segmentation for binary files (i.e. it creates additional segments). The kernel will not ask the user to specify the RAM/ROM sizes + -ida_idp.PR_CHK_XREF (variable) +ida_idp.PR_CHK_XREF don't allow near xrefs between segments with different bases -ida_idp.PR_CNDINSNS (variable) +ida_idp.PR_CNDINSNS has conditional instructions -ida_idp.PR_DEFNUM (variable) +ida_idp.PR_DEFNUM mask - default number representation -ida_idp.PR_DEFSEG32 (variable) +ida_idp.PR_DEFSEG32 segments are 32-bit by default -ida_idp.PR_DEFSEG64 (variable) +ida_idp.PR_DEFSEG64 segments are 64-bit by default -ida_idp.PR_DELAYED (variable) - has delayed jumps and calls. If this flag is set, - processor_t::is_basic_block_end, processor_t::delay_slot_insn should be - implemented +ida_idp.PR_DELAYED + has delayed jumps and calls. If this flag is set, processor_t::is_basic_block_end, processor_t::delay_slot_insn should be implemented + -ida_idp.PR_NOCHANGE (variable) - The user can't change segments and code/data attributes (display only) +ida_idp.PR_NOCHANGE + The user can't change segments and code/data attributes (display only) + -ida_idp.PR_NO_SEGMOVE (variable) - the processor module doesn't support move_segm() (i.e. the user can't move - segments) +ida_idp.PR_NO_SEGMOVE + the processor module doesn't support move_segm() (i.e. the user can't move segments) + -ida_idp.PR_OUTER (variable) +ida_idp.PR_OUTER has outer operands (currently only mc68k) -ida_idp.PR_PURGING (variable) +ida_idp.PR_PURGING there are calling conventions which may purge bytes from the stack -ida_idp.PR_RNAMESOK (variable) +ida_idp.PR_RNAMESOK allow user register names for location names -ida_idp.PR_SCALE_STKVARS (variable) +ida_idp.PR_SCALE_STKVARS use processor_t::get_stkvar_scale callback -ida_idp.PR_SEGS (variable) +ida_idp.PR_SEGS has segment registers? -ida_idp.PR_SEGTRANS (variable) - the processor module supports the segment translation feature (meaning it - calculates the code addresses using the map_code_ea() function) +ida_idp.PR_SEGTRANS + the processor module supports the segment translation feature (meaning it calculates the code addresses using the map_code_ea() function) + -ida_idp.PR_SGROTHER (variable) +ida_idp.PR_SGROTHER the segment registers don't contain the segment selectors. -ida_idp.PR_STACK_UP (variable) +ida_idp.PR_STACK_UP the stack grows up -ida_idp.PR_TYPEINFO (variable) - the processor module fully supports type information callbacks; without full - support, function argument locations and other things will probably be wrong. +ida_idp.PR_TYPEINFO + the processor module fully supports type information callbacks; without full support, function argument locations and other things will probably be wrong. + -ida_idp.PR_USE32 (variable) +ida_idp.PR_USE32 supports 32-bit addressing? -ida_idp.PR_USE64 (variable) +ida_idp.PR_USE64 supports 64-bit addressing? -ida_idp.PR_USE_ARG_TYPES (variable) +ida_idp.PR_USE_ARG_TYPES use processor_t::use_arg_types callback -ida_idp.PR_USE_TBYTE (variable) +ida_idp.PR_USE_TBYTE BTMT_SPECFLT means _TBYTE type -ida_idp.PR_WORD_INS (variable) +ida_idp.PR_WORD_INS instruction codes are grouped 2bytes in binary line prefix -ida_idp.REG_SPOIL (variable) - processor_t::use_regarg_type uses this bit in the return value to indicate that - the register value has been spoiled +ida_idp.REG_SPOIL + processor_t::use_regarg_type uses this bit in the return value to indicate that the register value has been spoiled + -ida_idp.SETPROC_IDB (variable) +ida_idp.SETPROC_IDB set processor type for old idb -ida_idp.SETPROC_LOADER (variable) - set processor type for new idb; if the user has specified a compatible - processor, return success without changing it. if failure, call loader_failure() +ida_idp.SETPROC_LOADER + set processor type for new idb; if the user has specified a compatible processor, return success without changing it. if failure, call loader_failure() + -ida_idp.SETPROC_LOADER_NON_FATAL (variable) +ida_idp.SETPROC_LOADER_NON_FATAL the same as SETPROC_LOADER but non-fatal failures. -ida_idp.SETPROC_USER (variable) - set user-specified processor used for -p and manual processor change at later - time +ida_idp.SETPROC_USER + set user-specified processor used for -p and manual processor change at later time + -ida_idp.__ph (class) +ida_idp.__ph -ida_idp._idp_cvar_t (class) +ida_idp._notify_when_dispatcher_t -ida_idp._notify_when_dispatcher_t (class) +ida_idp._notify_when_dispatcher_t._IDB_Hooks -ida_idp._notify_when_dispatcher_t._IDB_Hooks (class) - -ida_idp._notify_when_dispatcher_t._IDB_Hooks.__init__ (method) - -ida_idp._notify_when_dispatcher_t._IDB_Hooks.closebase (method) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks (class) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks.__init__ (method) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_newfile (method) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_oldfile (method) - -ida_idp._notify_when_dispatcher_t.__init__ (method) - -ida_idp._notify_when_dispatcher_t._callback_t (class) - -ida_idp._notify_when_dispatcher_t._callback_t.__init__ (method) - -ida_idp._notify_when_dispatcher_t._find (method) - -ida_idp._notify_when_dispatcher_t.dispatch (method) - -ida_idp._notify_when_dispatcher_t.notify_when (method) - -ida_idp._processor_t (class) - Proxy of C++ processor_t class. - -ida_idp._processor_t.__init__ (method) - __init__(self) -> _processor_t - -ida_idp._processor_t.add_cref (method) - add_cref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum cref_t - -ida_idp._processor_t.add_dref (method) - add_dref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum dref_t - -ida_idp._processor_t.adjust_argloc (method) - adjust_argloc(argloc, type, size) -> ssize_t - - Parameters - ---------- - argloc: argloc_t * - type: tinfo_t const * - size: int - -ida_idp._processor_t.adjust_libfunc_ea (method) - adjust_libfunc_ea(sig, libfun, ea) -> ssize_t - - Parameters - ---------- - sig: idasgn_t const & - libfun: libfunc_t const & - ea: ea_t * - -ida_idp._processor_t.adjust_refinfo (method) - adjust_refinfo(ri, ea, n, fd) -> ssize_t - - Parameters - ---------- - ri: refinfo_t * - ea: ea_t - n: int - fd: fixup_data_t const & - -ida_idp._processor_t.ana_insn (method) - ana_insn(out) -> ssize_t - - Parameters - ---------- - out: insn_t * - -ida_idp._processor_t.analyze_prolog (method) - analyze_prolog(fct_ea) -> ssize_t - - Parameters - ---------- - fct_ea: ea_t - -ida_idp._processor_t.arch_changed (method) - arch_changed() -> ssize_t - -ida_idp._processor_t.arg_addrs_ready (method) - arg_addrs_ready(caller, n, tif, addrs) -> ssize_t - - Parameters - ---------- - caller: ea_t - n: int - tif: tinfo_t const & - addrs: ea_t * - -ida_idp._processor_t.asm_installed (method) - asm_installed(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t.assemble (method) - assemble(_bin, ea, cs, ip, _use32, line) -> ssize_t - - Parameters - ---------- - _bin: uchar * - ea: ea_t - cs: ea_t - ip: ea_t - _use32: bool - line: char const * - -ida_idp._processor_t.auto_queue_empty (method) - auto_queue_empty(type) - - Parameters - ---------- - type: int - -ida_idp._processor_t.calc_arglocs (method) - calc_arglocs(fti) -> ssize_t - - Parameters - ---------- - fti: func_type_data_t * - -ida_idp._processor_t.calc_cdecl_purged_bytes (method) - calc_cdecl_purged_bytes(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.calc_next_eas (method) - calc_next_eas(res, insn, over) -> ssize_t - - Parameters - ---------- - res: eavec_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - over: bool - -ida_idp._processor_t.calc_purged_bytes (method) - calc_purged_bytes(p_purged_bytes, fti) -> ssize_t - - Parameters - ---------- - p_purged_bytes: int * - fti: func_type_data_t const & - -ida_idp._processor_t.calc_retloc (method) - calc_retloc(retloc, rettype, cc) -> ssize_t - - Parameters - ---------- - retloc: argloc_t * - rettype: tinfo_t const & - cc: cm_t - -ida_idp._processor_t.calc_spdelta (method) - calc_spdelta(spdelta, ins) -> ssize_t - - Parameters - ---------- - spdelta: sval_t * - ins: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.calc_step_over (method) - calc_step_over(target, ip) -> ssize_t - - Parameters - ---------- - target: ea_t * - ip: ea_t - -ida_idp._processor_t.calc_switch_cases (method) - calc_switch_cases(casevec, targets, insn_ea, si) -> ssize_t - - Parameters - ---------- - casevec: void * - targets: eavec_t * - insn_ea: ea_t - si: switch_info_t const & - -ida_idp._processor_t.calc_varglocs (method) - calc_varglocs(ftd, regs, stkargs, nfixed) -> ssize_t - - Parameters - ---------- - ftd: func_type_data_t * - regs: regobjs_t * - stkargs: relobj_t * - nfixed: int - -ida_idp._processor_t.calcrel (method) - calcrel(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.calcrel_in_bits (method) - calcrel_in_bits(self) -> bool - -ida_idp._processor_t.can_have_type (method) - can_have_type(op) -> ssize_t - - Parameters - ---------- - op: op_t const & - -ida_idp._processor_t.cbsize (method) - cbsize(self) -> int - -ida_idp._processor_t.clean_tbit (method) - clean_tbit(ea, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - ea: ea_t - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.cmp_operands (method) - cmp_operands(op1, op2) -> ssize_t - - Parameters - ---------- - op1: op_t const & - op2: op_t const & - -ida_idp._processor_t.coagulate (method) - coagulate(start_ea) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - -ida_idp._processor_t.coagulate_dref (method) - coagulate_dref(_from, to, may_define, code_ea) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - may_define: bool - code_ea: ea_t * - -ida_idp._processor_t.create_flat_group (method) - create_flat_group(image_base, bitness, dataseg_sel) -> ssize_t - - Parameters - ---------- - image_base: ea_t - bitness: int - dataseg_sel: sel_t - -ida_idp._processor_t.create_func_frame (method) - create_func_frame(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t.create_merge_handlers (method) - create_merge_handlers(md) -> ssize_t - - Parameters - ---------- - md: merge_data_t * - -ida_idp._processor_t.create_switch_xrefs (method) - create_switch_xrefs(jumpea, si) -> ssize_t - - Parameters - ---------- - jumpea: ea_t - si: switch_info_t const & - -ida_idp._processor_t.creating_segm (method) - creating_segm(seg) -> ssize_t - - Parameters - ---------- - seg: segment_t * - -ida_idp._processor_t.cvt64_hashval (method) - cvt64_hashval(self, node, tag, name, data) -> ssize_t - - Parameters - ---------- - node: nodeidx_t - tag: uchar - name: char const * - data: uchar const * - -ida_idp._processor_t.cvt64_supval (method) - cvt64_supval(self, node, tag, idx, data) -> ssize_t - - Parameters - ---------- - node: nodeidx_t - tag: uchar - idx: nodeidx_t - data: uchar const * - -ida_idp._processor_t.dbsize (method) - dbsize(self) -> int - -ida_idp._processor_t.decorate_name (method) - decorate_name(outbuf, name, mangle, cc, type) -> ssize_t - - Parameters - ---------- - outbuf: qstring * - name: char const * - mangle: bool - cc: cm_t - type: tinfo_t const & - -ida_idp._processor_t.del_cref (method) - del_cref(_from, to, expand) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - expand: bool - -ida_idp._processor_t.del_dref (method) - del_dref(_from, to) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - -ida_idp._processor_t.delay_slot_insn (method) - delay_slot_insn(self, ea, bexec, fexec) -> bool - - Parameters - ---------- - ea: ea_t * - bexec: bool * - fexec: bool * - -ida_idp._processor_t.demangle_name (method) - demangle_name(res, name, disable_mask, demreq) -> ssize_t - - Parameters - ---------- - res: int32 * - name: char const * - disable_mask: uint32 - demreq: int - -ida_idp._processor_t.emu_insn (method) - emu_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.endbinary (method) - endbinary(ok) -> ssize_t - - Parameters - ---------- - ok: bool - -ida_idp._processor_t.equal_reglocs (method) - equal_reglocs(a1, a2) -> ssize_t - - Parameters - ---------- - a1: argloc_t const & - a2: argloc_t const & - -ida_idp._processor_t.extract_address (method) - extract_address(out_ea, screen_ea, string, x) -> ssize_t - - Parameters - ---------- - out_ea: ea_t * - screen_ea: ea_t - string: char const * - x: size_t - -ida_idp._processor_t.find_op_value (method) - find_op_value(insn, op) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - op: int - -ida_idp._processor_t.find_reg_value (method) - find_reg_value(insn, reg) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - reg: int - -ida_idp._processor_t.func_bounds (method) - func_bounds(possible_return_code, pfn, max_func_end_ea) -> ssize_t - - Parameters - ---------- - possible_return_code: int * - pfn: func_t * - max_func_end_ea: ea_t - -ida_idp._processor_t.gen_asm_or_lst (method) - gen_asm_or_lst(starting, fp, is_asm, flags, outline) -> ssize_t - - Parameters - ---------- - starting: bool - fp: FILE * - is_asm: bool - flags: int - outline: void * - -ida_idp._processor_t.gen_map_file (method) - gen_map_file(nlines, fp) -> ssize_t - - Parameters - ---------- - nlines: int * - fp: FILE * - -ida_idp._processor_t.gen_regvar_def (method) - gen_regvar_def(ctx, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - v: regvar_t * - -ida_idp._processor_t.gen_src_file_lnnum (method) - gen_src_file_lnnum(ctx, file, lnnum) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - file: char const * - lnnum: size_t - -ida_idp._processor_t.gen_stkvar_def (method) - gen_stkvar_def(ctx, mptr, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - mptr: member_t const * - v: sval_t - -ida_idp._processor_t.get_abi_info (method) - get_abi_info(abi_names, abi_opts, comp) -> ssize_t - - Parameters - ---------- - abi_names: qstrvec_t * - abi_opts: qstrvec_t * - comp: comp_t - -ida_idp._processor_t.get_autocmt (method) - get_autocmt(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.get_bg_color (method) - get_bg_color(color, ea) -> ssize_t - - Parameters - ---------- - color: bgcolor_t * - ea: ea_t - -ida_idp._processor_t.get_canon_feature (method) - get_canon_feature(self, itype) -> uint32 - - Parameters - ---------- - itype: uint16 - -ida_idp._processor_t.get_canon_mnem (method) - get_canon_mnem(self, itype) -> char const * - - Parameters - ---------- - itype: uint16 - -ida_idp._processor_t.get_cc_regs (method) - get_cc_regs(regs, cc) -> ssize_t - - Parameters - ---------- - regs: callregs_t * - cc: cm_t - -ida_idp._processor_t.get_code16_mode (method) - get_code16_mode(ea) -> bool - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.get_dbr_opnum (method) - get_dbr_opnum(opnum, insn) -> ssize_t - - Parameters - ---------- - opnum: int * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.get_default_segm_bitness (method) - get_default_segm_bitness(self, is_64bit_app) -> int - - Parameters - ---------- - is_64bit_app: bool - -ida_idp._processor_t.get_frame_retsize (method) - get_frame_retsize(retsize, pfn) -> ssize_t - - Parameters - ---------- - retsize: int * - pfn: func_t const * - -ida_idp._processor_t.get_idd_opinfo (method) - get_idd_opinfo(opinf, ea, n, thread_id, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - opinf: idd_opinfo_t * - ea: ea_t - n: int - thread_id: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.get_macro_insn_head (method) - get_macro_insn_head(head, ip) -> ssize_t - - Parameters - ---------- - head: ea_t * - ip: ea_t - -ida_idp._processor_t.get_operand_string (method) - get_operand_string(insn, opnum) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - opnum: int - -ida_idp._processor_t.get_proc_index (method) - get_proc_index(self) -> int - -ida_idp._processor_t.get_reg_accesses (method) - get_reg_accesses(accvec, insn, flags) -> ssize_t - - Parameters - ---------- - accvec: reg_accesses_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - flags: int - -ida_idp._processor_t.get_reg_info (method) - get_reg_info(regname, bitrange) -> char const * - - Parameters - ---------- - regname: char const * - bitrange: bitrange_t * - -ida_idp._processor_t.get_reg_name (method) - get_reg_name(reg, width, reghi) -> ssize_t - - Parameters - ---------- - reg: int - width: size_t - reghi: int - -ida_idp._processor_t.get_simd_types (method) - get_simd_types(out, simd_attrs, argloc, create_tifs) -> ssize_t - - Parameters - ---------- - out: void * - simd_attrs: simd_info_t const * - argloc: argloc_t const * - create_tifs: bool - -ida_idp._processor_t.get_stkarg_area_info (method) - get_stkarg_area_info(out, cc) -> ssize_t - - Parameters - ---------- - out: stkarg_area_info_t * - cc: cm_t - -ida_idp._processor_t.get_stkvar_scale (method) - get_stkvar_scale(self) -> int - -ida_idp._processor_t.get_stkvar_scale_factor (method) - get_stkvar_scale_factor() -> ssize_t - -ida_idp._processor_t.getreg (method) - getreg(rv, regnum) -> ssize_t - - Parameters - ---------- - rv: uval_t * - regnum: int - -ida_idp._processor_t.has_code16_bit (method) - has_code16_bit(self) -> bool - -ida_idp._processor_t.has_idp_opts (method) - has_idp_opts(self) -> bool - -ida_idp._processor_t.has_realcvt (method) - has_realcvt(self) -> bool - -ida_idp._processor_t.has_segregs (method) - has_segregs(self) -> bool - -ida_idp._processor_t.init (method) - init(idp_modname) -> ssize_t - - Parameters - ---------- - idp_modname: char const * - -ida_idp._processor_t.insn_reads_tbit (method) - insn_reads_tbit(insn, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.is_align_insn (method) - is_align_insn(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.is_alloca_probe (method) - is_alloca_probe(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.is_basic_block_end (method) - is_basic_block_end(insn, call_insn_stops_block) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - call_insn_stops_block: bool - -ida_idp._processor_t.is_call_insn (method) - is_call_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.is_cond_insn (method) - is_cond_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.is_control_flow_guard (method) - is_control_flow_guard(p_reg, insn) -> ssize_t - - Parameters - ---------- - p_reg: int * - insn: insn_t const * - -ida_idp._processor_t.is_far_jump (method) - is_far_jump(icode) -> ssize_t - - Parameters - ---------- - icode: int - -ida_idp._processor_t.is_indirect_jump (method) - is_indirect_jump(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.is_jump_func (method) - is_jump_func(pfn, jump_target, func_pointer) -> ssize_t - - Parameters - ---------- - pfn: func_t * - jump_target: ea_t * - func_pointer: ea_t * - -ida_idp._processor_t.is_ret_insn (method) - is_ret_insn(insn, strict) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - strict: bool - -ida_idp._processor_t.is_sane_insn (method) - is_sane_insn(insn, no_crefs) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - no_crefs: int - -ida_idp._processor_t.is_sp_based (method) - is_sp_based(insn, x) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - x: op_t const & - -ida_idp._processor_t.is_switch (method) - is_switch(si, insn) -> ssize_t - - Parameters - ---------- - si: switch_info_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.loader_elf_machine (method) - loader_elf_machine(li, machine_type, p_procname, p_pd, ldr, reader) -> ssize_t - - Parameters - ---------- - li: linput_t * - machine_type: int - p_procname: char const ** - p_pd: proc_def_t ** - ldr: elf_loader_t * - reader: reader_t * - -ida_idp._processor_t.lower_func_type (method) - lower_func_type(argnums, fti) -> ssize_t - - Parameters - ---------- - argnums: intvec_t * - fti: func_type_data_t * - -ida_idp._processor_t.max_ptr_size (method) - max_ptr_size() -> ssize_t - -ida_idp._processor_t.may_be_func (method) - may_be_func(insn, state) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - state: int - -ida_idp._processor_t.may_show_sreg (method) - may_show_sreg(current_ea) -> ssize_t - - Parameters - ---------- - current_ea: ea_t - -ida_idp._processor_t.moving_segm (method) - moving_segm(seg, to, flags) -> ssize_t - - Parameters - ---------- - seg: segment_t * - to: ea_t - flags: int - -ida_idp._processor_t.newasm (method) - newasm(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t.newbinary (method) - newbinary(filename, fileoff, basepara, binoff, nbytes) -> ssize_t - - Parameters - ---------- - filename: char const * - fileoff: qoff64_t - basepara: ea_t - binoff: ea_t - nbytes: uint64 - -ida_idp._processor_t.newfile (method) - newfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t.newprc (method) - newprc(pnum, keep_cfg) -> ssize_t - - Parameters - ---------- - pnum: int - keep_cfg: bool - -ida_idp._processor_t.next_exec_insn (method) - next_exec_insn(target, ea, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - target: ea_t * - ea: ea_t - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.notify (method) - notify(event_code) -> ssize_t - - Parameters - ---------- - event_code: enum processor_t::event_t - -ida_idp._processor_t.oldfile (method) - oldfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t.out_assumes (method) - out_assumes(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_data (method) - out_data(ctx, analyze_only) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - analyze_only: bool - -ida_idp._processor_t.out_footer (method) - out_footer(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_header (method) - out_header(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_insn (method) - out_insn(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_label (method) - out_label(ctx, colored_name) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - colored_name: char const * - -ida_idp._processor_t.out_mnem (method) - out_mnem(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_operand (method) - out_operand(ctx, op) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - op: op_t const & - -ida_idp._processor_t.out_segend (method) - out_segend(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t.out_segstart (method) - out_segstart(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t.out_special_item (method) - out_special_item(ctx, segtype) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - segtype: uchar - -ida_idp._processor_t.privrange_changed (method) - privrange_changed(self, old_privrange, delta) -> ssize_t - - Parameters - ---------- - old_privrange: range_t const & - delta: adiff_t - -ida_idp._processor_t.realcvt (method) - realcvt(m, e, swt) -> fpvalue_error_t - - Parameters - ---------- - m: void * - e: fpvalue_t * - swt: uint16 - -ida_idp._processor_t.rename (method) - rename(ea, new_name, flags) -> ssize_t - - Parameters - ---------- - ea: ea_t - new_name: char const * - flags: int - -ida_idp._processor_t.set_code16_mode (method) - set_code16_mode(ea, code16=True) -> ssize_t - - Parameters - ---------- - ea: ea_t - code16: bool - -ida_idp._processor_t.set_idp_options (method) - set_idp_options(keyword, vtype, value, idb_loaded=True) -> char const * - - Parameters - ---------- - keyword: char const * - vtype: int - value: void const * - idb_loaded: bool - -ida_idp._processor_t.set_proc_options (method) - set_proc_options(options, confidence) -> ssize_t - - Parameters - ---------- - options: char const * - confidence: int - -ida_idp._processor_t.setup_til (method) - setup_til() -> ssize_t - -ida_idp._processor_t.sizeof_ldbl (method) - sizeof_ldbl(self) -> size_t - -ida_idp._processor_t.stkup (method) - stkup(self) -> bool - -ida_idp._processor_t.str2reg (method) - str2reg(regname) -> ssize_t - - Parameters - ---------- - regname: char const * - -ida_idp._processor_t.supports_calcrel (method) - supports_calcrel(self) -> bool - -ida_idp._processor_t.supports_macros (method) - supports_macros(self) -> bool - -ida_idp._processor_t.term (method) - term() -> ssize_t - -ida_idp._processor_t.ti (method) - ti(self) -> bool - -ida_idp._processor_t.treat_hindering_item (method) - treat_hindering_item(hindering_item_ea, new_item_flags, new_item_ea, new_item_length) -> ssize_t - - Parameters - ---------- - hindering_item_ea: ea_t - new_item_flags: flags64_t - new_item_ea: ea_t - new_item_length: asize_t - -ida_idp._processor_t.undefine (method) - undefine(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.update_call_stack (method) - update_call_stack(stack, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - stack: call_stack_t * - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.use32 (method) - use32(self) -> bool - -ida_idp._processor_t.use64 (method) - use64(self) -> bool - -ida_idp._processor_t.use_arg_types (method) - use_arg_types(ea, fti, rargs) -> ssize_t - - Parameters - ---------- - ea: ea_t - fti: func_type_data_t * - rargs: void * - -ida_idp._processor_t.use_mappings (method) - use_mappings(self) -> bool - -ida_idp._processor_t.use_regarg_type (method) - use_regarg_type(idx, ea, rargs) -> ssize_t - - Parameters - ---------- - idx: int * - ea: ea_t - rargs: void * - -ida_idp._processor_t.use_stkarg_type (method) - use_stkarg_type(ea, arg) -> ssize_t - - Parameters - ---------- - ea: ea_t - arg: funcarg_t const & - -ida_idp._processor_t.use_tbyte (method) - use_tbyte(self) -> bool - -ida_idp._processor_t.validate_flirt_func (method) - validate_flirt_func(start_ea, funcname) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - funcname: char const * - -ida_idp._processor_t.verify_noreturn (method) - verify_noreturn(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t.verify_sp (method) - verify_sp(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t_Trampoline_IDB_Hooks (class) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__dummy (method) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__init__ (method) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller (method) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller.call_parent (function) - -ida_idp._processor_t_add_cref (function) - _processor_t_add_cref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum cref_t - -ida_idp._processor_t_add_dref (function) - _processor_t_add_dref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum dref_t - -ida_idp._processor_t_adjust_argloc (function) - _processor_t_adjust_argloc(argloc, type, size) -> ssize_t - - Parameters - ---------- - argloc: argloc_t * - type: tinfo_t const * - size: int - -ida_idp._processor_t_adjust_libfunc_ea (function) - _processor_t_adjust_libfunc_ea(sig, libfun, ea) -> ssize_t - - Parameters - ---------- - sig: idasgn_t const & - libfun: libfunc_t const & - ea: ea_t * - -ida_idp._processor_t_adjust_refinfo (function) - _processor_t_adjust_refinfo(ri, ea, n, fd) -> ssize_t - - Parameters - ---------- - ri: refinfo_t * - ea: ea_t - n: int - fd: fixup_data_t const & - -ida_idp._processor_t_ana_insn (function) - _processor_t_ana_insn(out) -> ssize_t - - Parameters - ---------- - out: insn_t * - -ida_idp._processor_t_analyze_prolog (function) - _processor_t_analyze_prolog(fct_ea) -> ssize_t - - Parameters - ---------- - fct_ea: ea_t - -ida_idp._processor_t_arch_changed (function) - _processor_t_arch_changed() -> ssize_t - -ida_idp._processor_t_arg_addrs_ready (function) - _processor_t_arg_addrs_ready(caller, n, tif, addrs) -> ssize_t - - Parameters - ---------- - caller: ea_t - n: int - tif: tinfo_t const & - addrs: ea_t * - -ida_idp._processor_t_asm_installed (function) - _processor_t_asm_installed(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t_assemble (function) - _processor_t_assemble(_bin, ea, cs, ip, _use32, line) -> ssize_t - - Parameters - ---------- - _bin: uchar * - ea: ea_t - cs: ea_t - ip: ea_t - _use32: bool - line: char const * - -ida_idp._processor_t_auto_queue_empty (function) - _processor_t_auto_queue_empty(type) - - Parameters - ---------- - type: int - -ida_idp._processor_t_calc_arglocs (function) - _processor_t_calc_arglocs(fti) -> ssize_t - - Parameters - ---------- - fti: func_type_data_t * - -ida_idp._processor_t_calc_cdecl_purged_bytes (function) - _processor_t_calc_cdecl_purged_bytes(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_calc_next_eas (function) - _processor_t_calc_next_eas(res, insn, over) -> ssize_t - - Parameters - ---------- - res: eavec_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - over: bool - -ida_idp._processor_t_calc_purged_bytes (function) - _processor_t_calc_purged_bytes(p_purged_bytes, fti) -> ssize_t - - Parameters - ---------- - p_purged_bytes: int * - fti: func_type_data_t const & - -ida_idp._processor_t_calc_retloc (function) - _processor_t_calc_retloc(retloc, rettype, cc) -> ssize_t - - Parameters - ---------- - retloc: argloc_t * - rettype: tinfo_t const & - cc: cm_t - -ida_idp._processor_t_calc_spdelta (function) - _processor_t_calc_spdelta(spdelta, ins) -> ssize_t - - Parameters - ---------- - spdelta: sval_t * - ins: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_calc_step_over (function) - _processor_t_calc_step_over(target, ip) -> ssize_t - - Parameters - ---------- - target: ea_t * - ip: ea_t - -ida_idp._processor_t_calc_switch_cases (function) - _processor_t_calc_switch_cases(casevec, targets, insn_ea, si) -> ssize_t - - Parameters - ---------- - casevec: void * - targets: eavec_t * - insn_ea: ea_t - si: switch_info_t const & - -ida_idp._processor_t_calc_varglocs (function) - _processor_t_calc_varglocs(ftd, regs, stkargs, nfixed) -> ssize_t - - Parameters - ---------- - ftd: func_type_data_t * - regs: regobjs_t * - stkargs: relobj_t * - nfixed: int - -ida_idp._processor_t_calcrel (function) - _processor_t_calcrel(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_can_have_type (function) - _processor_t_can_have_type(op) -> ssize_t - - Parameters - ---------- - op: op_t const & - -ida_idp._processor_t_clean_tbit (function) - _processor_t_clean_tbit(ea, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - ea: ea_t - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_cmp_operands (function) - _processor_t_cmp_operands(op1, op2) -> ssize_t - - Parameters - ---------- - op1: op_t const & - op2: op_t const & - -ida_idp._processor_t_coagulate (function) - _processor_t_coagulate(start_ea) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - -ida_idp._processor_t_coagulate_dref (function) - _processor_t_coagulate_dref(_from, to, may_define, code_ea) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - may_define: bool - code_ea: ea_t * - -ida_idp._processor_t_create_flat_group (function) - _processor_t_create_flat_group(image_base, bitness, dataseg_sel) -> ssize_t - - Parameters - ---------- - image_base: ea_t - bitness: int - dataseg_sel: sel_t - -ida_idp._processor_t_create_func_frame (function) - _processor_t_create_func_frame(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t_create_merge_handlers (function) - _processor_t_create_merge_handlers(md) -> ssize_t - - Parameters - ---------- - md: merge_data_t * - -ida_idp._processor_t_create_switch_xrefs (function) - _processor_t_create_switch_xrefs(jumpea, si) -> ssize_t - - Parameters - ---------- - jumpea: ea_t - si: switch_info_t const & - -ida_idp._processor_t_creating_segm (function) - _processor_t_creating_segm(seg) -> ssize_t - - Parameters - ---------- - seg: segment_t * - -ida_idp._processor_t_decorate_name (function) - _processor_t_decorate_name(outbuf, name, mangle, cc, type) -> ssize_t - - Parameters - ---------- - outbuf: qstring * - name: char const * - mangle: bool - cc: cm_t - type: tinfo_t const & - -ida_idp._processor_t_del_cref (function) - _processor_t_del_cref(_from, to, expand) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - expand: bool - -ida_idp._processor_t_del_dref (function) - _processor_t_del_dref(_from, to) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - -ida_idp._processor_t_demangle_name (function) - _processor_t_demangle_name(res, name, disable_mask, demreq) -> ssize_t - - Parameters - ---------- - res: int32 * - name: char const * - disable_mask: uint32 - demreq: int - -ida_idp._processor_t_emu_insn (function) - _processor_t_emu_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_endbinary (function) - _processor_t_endbinary(ok) -> ssize_t - - Parameters - ---------- - ok: bool - -ida_idp._processor_t_equal_reglocs (function) - _processor_t_equal_reglocs(a1, a2) -> ssize_t - - Parameters - ---------- - a1: argloc_t const & - a2: argloc_t const & - -ida_idp._processor_t_extract_address (function) - _processor_t_extract_address(out_ea, screen_ea, string, x) -> ssize_t - - Parameters - ---------- - out_ea: ea_t * - screen_ea: ea_t - string: char const * - x: size_t - -ida_idp._processor_t_find_op_value (function) - _processor_t_find_op_value(insn, op) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - op: int - -ida_idp._processor_t_find_reg_value (function) - _processor_t_find_reg_value(insn, reg) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - reg: int - -ida_idp._processor_t_func_bounds (function) - _processor_t_func_bounds(possible_return_code, pfn, max_func_end_ea) -> ssize_t - - Parameters - ---------- - possible_return_code: int * - pfn: func_t * - max_func_end_ea: ea_t - -ida_idp._processor_t_gen_asm_or_lst (function) - _processor_t_gen_asm_or_lst(starting, fp, is_asm, flags, outline) -> ssize_t - - Parameters - ---------- - starting: bool - fp: FILE * - is_asm: bool - flags: int - outline: void * - -ida_idp._processor_t_gen_map_file (function) - _processor_t_gen_map_file(nlines, fp) -> ssize_t - - Parameters - ---------- - nlines: int * - fp: FILE * - -ida_idp._processor_t_gen_regvar_def (function) - _processor_t_gen_regvar_def(ctx, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - v: regvar_t * - -ida_idp._processor_t_gen_src_file_lnnum (function) - _processor_t_gen_src_file_lnnum(ctx, file, lnnum) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - file: char const * - lnnum: size_t - -ida_idp._processor_t_gen_stkvar_def (function) - _processor_t_gen_stkvar_def(ctx, mptr, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - mptr: member_t const * - v: sval_t - -ida_idp._processor_t_get_abi_info (function) - _processor_t_get_abi_info(abi_names, abi_opts, comp) -> ssize_t - - Parameters - ---------- - abi_names: qstrvec_t * - abi_opts: qstrvec_t * - comp: comp_t - -ida_idp._processor_t_get_autocmt (function) - _processor_t_get_autocmt(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_get_bg_color (function) - _processor_t_get_bg_color(color, ea) -> ssize_t - - Parameters - ---------- - color: bgcolor_t * - ea: ea_t - -ida_idp._processor_t_get_cc_regs (function) - _processor_t_get_cc_regs(regs, cc) -> ssize_t - - Parameters - ---------- - regs: callregs_t * - cc: cm_t - -ida_idp._processor_t_get_code16_mode (function) - _processor_t_get_code16_mode(ea) -> bool - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_get_dbr_opnum (function) - _processor_t_get_dbr_opnum(opnum, insn) -> ssize_t - - Parameters - ---------- - opnum: int * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_get_frame_retsize (function) - _processor_t_get_frame_retsize(retsize, pfn) -> ssize_t - - Parameters - ---------- - retsize: int * - pfn: func_t const * - -ida_idp._processor_t_get_idd_opinfo (function) - _processor_t_get_idd_opinfo(opinf, ea, n, thread_id, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - opinf: idd_opinfo_t * - ea: ea_t - n: int - thread_id: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_get_macro_insn_head (function) - _processor_t_get_macro_insn_head(head, ip) -> ssize_t - - Parameters - ---------- - head: ea_t * - ip: ea_t - -ida_idp._processor_t_get_operand_string (function) - _processor_t_get_operand_string(insn, opnum) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - opnum: int - -ida_idp._processor_t_get_reg_accesses (function) - _processor_t_get_reg_accesses(accvec, insn, flags) -> ssize_t - - Parameters - ---------- - accvec: reg_accesses_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - flags: int - -ida_idp._processor_t_get_reg_info (function) - _processor_t_get_reg_info(regname, bitrange) -> char const * - - Parameters - ---------- - regname: char const * - bitrange: bitrange_t * - -ida_idp._processor_t_get_reg_name (function) - _processor_t_get_reg_name(reg, width, reghi) -> ssize_t - - Parameters - ---------- - reg: int - width: size_t - reghi: int - -ida_idp._processor_t_get_simd_types (function) - _processor_t_get_simd_types(out, simd_attrs, argloc, create_tifs) -> ssize_t - - Parameters - ---------- - out: void * - simd_attrs: simd_info_t const * - argloc: argloc_t const * - create_tifs: bool - -ida_idp._processor_t_get_stkarg_area_info (function) - _processor_t_get_stkarg_area_info(out, cc) -> ssize_t - - Parameters - ---------- - out: stkarg_area_info_t * - cc: cm_t - -ida_idp._processor_t_get_stkvar_scale_factor (function) - _processor_t_get_stkvar_scale_factor() -> ssize_t - -ida_idp._processor_t_getreg (function) - _processor_t_getreg(rv, regnum) -> ssize_t - - Parameters - ---------- - rv: uval_t * - regnum: int - -ida_idp._processor_t_init (function) - _processor_t_init(idp_modname) -> ssize_t - - Parameters - ---------- - idp_modname: char const * - -ida_idp._processor_t_insn_reads_tbit (function) - _processor_t_insn_reads_tbit(insn, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_is_align_insn (function) - _processor_t_is_align_insn(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_is_alloca_probe (function) - _processor_t_is_alloca_probe(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_is_basic_block_end (function) - _processor_t_is_basic_block_end(insn, call_insn_stops_block) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - call_insn_stops_block: bool - -ida_idp._processor_t_is_call_insn (function) - _processor_t_is_call_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_is_cond_insn (function) - _processor_t_is_cond_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_is_control_flow_guard (function) - _processor_t_is_control_flow_guard(p_reg, insn) -> ssize_t - - Parameters - ---------- - p_reg: int * - insn: insn_t const * - -ida_idp._processor_t_is_far_jump (function) - _processor_t_is_far_jump(icode) -> ssize_t - - Parameters - ---------- - icode: int - -ida_idp._processor_t_is_indirect_jump (function) - _processor_t_is_indirect_jump(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_is_jump_func (function) - _processor_t_is_jump_func(pfn, jump_target, func_pointer) -> ssize_t - - Parameters - ---------- - pfn: func_t * - jump_target: ea_t * - func_pointer: ea_t * - -ida_idp._processor_t_is_ret_insn (function) - _processor_t_is_ret_insn(insn, strict) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - strict: bool - -ida_idp._processor_t_is_sane_insn (function) - _processor_t_is_sane_insn(insn, no_crefs) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - no_crefs: int - -ida_idp._processor_t_is_sp_based (function) - _processor_t_is_sp_based(insn, x) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - x: op_t const & - -ida_idp._processor_t_is_switch (function) - _processor_t_is_switch(si, insn) -> ssize_t - - Parameters - ---------- - si: switch_info_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_loader_elf_machine (function) - _processor_t_loader_elf_machine(li, machine_type, p_procname, p_pd, ldr, reader) -> ssize_t - - Parameters - ---------- - li: linput_t * - machine_type: int - p_procname: char const ** - p_pd: proc_def_t ** - ldr: elf_loader_t * - reader: reader_t * - -ida_idp._processor_t_lower_func_type (function) - _processor_t_lower_func_type(argnums, fti) -> ssize_t - - Parameters - ---------- - argnums: intvec_t * - fti: func_type_data_t * - -ida_idp._processor_t_max_ptr_size (function) - _processor_t_max_ptr_size() -> ssize_t - -ida_idp._processor_t_may_be_func (function) - _processor_t_may_be_func(insn, state) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - state: int - -ida_idp._processor_t_may_show_sreg (function) - _processor_t_may_show_sreg(current_ea) -> ssize_t - - Parameters - ---------- - current_ea: ea_t - -ida_idp._processor_t_moving_segm (function) - _processor_t_moving_segm(seg, to, flags) -> ssize_t - - Parameters - ---------- - seg: segment_t * - to: ea_t - flags: int - -ida_idp._processor_t_newasm (function) - _processor_t_newasm(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t_newbinary (function) - _processor_t_newbinary(filename, fileoff, basepara, binoff, nbytes) -> ssize_t - - Parameters - ---------- - filename: char const * - fileoff: qoff64_t - basepara: ea_t - binoff: ea_t - nbytes: uint64 - -ida_idp._processor_t_newfile (function) - _processor_t_newfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t_newprc (function) - _processor_t_newprc(pnum, keep_cfg) -> ssize_t - - Parameters - ---------- - pnum: int - keep_cfg: bool - -ida_idp._processor_t_next_exec_insn (function) - _processor_t_next_exec_insn(target, ea, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - target: ea_t * - ea: ea_t - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_notify (function) - _processor_t_notify(event_code) -> ssize_t - - Parameters - ---------- - event_code: enum processor_t::event_t - -ida_idp._processor_t_oldfile (function) - _processor_t_oldfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t_out_assumes (function) - _processor_t_out_assumes(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_data (function) - _processor_t_out_data(ctx, analyze_only) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - analyze_only: bool - -ida_idp._processor_t_out_footer (function) - _processor_t_out_footer(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_header (function) - _processor_t_out_header(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_insn (function) - _processor_t_out_insn(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_label (function) - _processor_t_out_label(ctx, colored_name) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - colored_name: char const * - -ida_idp._processor_t_out_mnem (function) - _processor_t_out_mnem(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_operand (function) - _processor_t_out_operand(ctx, op) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - op: op_t const & - -ida_idp._processor_t_out_segend (function) - _processor_t_out_segend(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t_out_segstart (function) - _processor_t_out_segstart(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t_out_special_item (function) - _processor_t_out_special_item(ctx, segtype) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - segtype: uchar - -ida_idp._processor_t_realcvt (function) - _processor_t_realcvt(m, e, swt) -> fpvalue_error_t - - Parameters - ---------- - m: void * - e: fpvalue_t * - swt: uint16 - -ida_idp._processor_t_rename (function) - _processor_t_rename(ea, new_name, flags) -> ssize_t - - Parameters - ---------- - ea: ea_t - new_name: char const * - flags: int - -ida_idp._processor_t_set_code16_mode (function) - _processor_t_set_code16_mode(ea, code16=True) -> ssize_t - - Parameters - ---------- - ea: ea_t - code16: bool - -ida_idp._processor_t_set_idp_options (function) - _processor_t_set_idp_options(keyword, vtype, value, idb_loaded=True) -> char const * - - Parameters - ---------- - keyword: char const * - vtype: int - value: void const * - idb_loaded: bool - -ida_idp._processor_t_set_proc_options (function) - _processor_t_set_proc_options(options, confidence) -> ssize_t - - Parameters - ---------- - options: char const * - confidence: int - -ida_idp._processor_t_setup_til (function) - _processor_t_setup_til() -> ssize_t - -ida_idp._processor_t_str2reg (function) - _processor_t_str2reg(regname) -> ssize_t - - Parameters - ---------- - regname: char const * - -ida_idp._processor_t_term (function) - _processor_t_term() -> ssize_t - -ida_idp._processor_t_treat_hindering_item (function) - _processor_t_treat_hindering_item(hindering_item_ea, new_item_flags, new_item_ea, new_item_length) -> ssize_t - - Parameters - ---------- - hindering_item_ea: ea_t - new_item_flags: flags64_t - new_item_ea: ea_t - new_item_length: asize_t - -ida_idp._processor_t_undefine (function) - _processor_t_undefine(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_update_call_stack (function) - _processor_t_update_call_stack(stack, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - stack: call_stack_t * - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_use_arg_types (function) - _processor_t_use_arg_types(ea, fti, rargs) -> ssize_t - - Parameters - ---------- - ea: ea_t - fti: func_type_data_t * - rargs: void * - -ida_idp._processor_t_use_regarg_type (function) - _processor_t_use_regarg_type(idx, ea, rargs) -> ssize_t - - Parameters - ---------- - idx: int * - ea: ea_t - rargs: void * - -ida_idp._processor_t_use_stkarg_type (function) - _processor_t_use_stkarg_type(ea, arg) -> ssize_t - - Parameters - ---------- - ea: ea_t - arg: funcarg_t const & - -ida_idp._processor_t_validate_flirt_func (function) - _processor_t_validate_flirt_func(start_ea, funcname) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - funcname: char const * - -ida_idp._processor_t_verify_noreturn (function) - _processor_t_verify_noreturn(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t_verify_sp (function) - _processor_t_verify_sp(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp.asm_t (class) - Proxy of C++ asm_t class. - -ida_idp.asm_t.__init__ (method) - __init__(self) -> asm_t - -ida_idp.asm_t.a_align (variable) +ida_idp._notify_when_dispatcher_t._IDB_Hooks.__init__(self, dispatcher) + +ida_idp._notify_when_dispatcher_t._IDB_Hooks.closebase(self) + +ida_idp._notify_when_dispatcher_t._IDP_Hooks + +ida_idp._notify_when_dispatcher_t._IDP_Hooks.__init__(self, dispatcher) + +ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_newfile(self, name) + +ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_oldfile(self, name) + +ida_idp._notify_when_dispatcher_t.__init__(self) + +ida_idp._notify_when_dispatcher_t._callback_t + +ida_idp._notify_when_dispatcher_t._callback_t.__init__(self, fun) + +ida_idp._notify_when_dispatcher_t._find(self, fun) + +ida_idp._notify_when_dispatcher_t.dispatch(self, slot, *args) + +ida_idp._notify_when_dispatcher_t.notify_when(self, when, fun) + +ida_idp._processor_t + +ida_idp._processor_t.__init__(self) + +ida_idp._processor_t.add_cref(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, type: "cref_t") -> "ssize_t" + +ida_idp._processor_t.add_dref(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, type: "dref_t") -> "ssize_t" + +ida_idp._processor_t.adjust_argloc(argloc: "argloc_t", type: "tinfo_t", size: int) -> "ssize_t" + +ida_idp._processor_t.adjust_libfunc_ea(sig: "idasgn_t const &", libfun: "libfunc_t const &", ea: "ea_t *") -> "ssize_t" + +ida_idp._processor_t.adjust_refinfo(ri: "refinfo_t", ea: ida_idaapi.ea_t, n: int, fd: "fixup_data_t const &") -> "ssize_t" + +ida_idp._processor_t.ana_insn(out: "insn_t *") -> "ssize_t" + +ida_idp._processor_t.analyze_prolog(fct_ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.arch_changed() -> "ssize_t" + +ida_idp._processor_t.arg_addrs_ready(caller: ida_idaapi.ea_t, n: int, tif: "tinfo_t", addrs: "ea_t *") -> "ssize_t" + +ida_idp._processor_t.asm_installed(asmnum: int) -> "ssize_t" + +ida_idp._processor_t.assemble(_bin: "uchar *", ea: ida_idaapi.ea_t, cs: ida_idaapi.ea_t, ip: ida_idaapi.ea_t, _use32: bool, line: str) -> "ssize_t" + +ida_idp._processor_t.auto_queue_empty(type: int) -> None + +ida_idp._processor_t.calc_arglocs(fti: "func_type_data_t") -> "ssize_t" + +ida_idp._processor_t.calc_cdecl_purged_bytes(ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.calc_next_eas(res: "eavec_t *", insn: "insn_t const &", over: bool) -> "ssize_t" + +ida_idp._processor_t.calc_purged_bytes(p_purged_bytes: "int *", fti: "func_type_data_t") -> "ssize_t" + +ida_idp._processor_t.calc_retloc(retloc: "argloc_t", rettype: "tinfo_t", cc: "cm_t") -> "ssize_t" + +ida_idp._processor_t.calc_spdelta(spdelta: "sval_t *", ins: "insn_t const &") -> "ssize_t" + +ida_idp._processor_t.calc_step_over(target: "ea_t *", ip: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.calc_switch_cases(casevec: "void *", targets: "eavec_t *", insn_ea: ida_idaapi.ea_t, si: "switch_info_t") -> "ssize_t" + +ida_idp._processor_t.calc_varglocs(ftd: "func_type_data_t", regs: "regobjs_t", stkargs: "relobj_t", nfixed: int) -> "ssize_t" + +ida_idp._processor_t.calcrel(ea: ida_idaapi.ea_t) -> "bytevec_t *, size_t *" + +ida_idp._processor_t.calcrel_in_bits(self) -> bool + +ida_idp._processor_t.can_have_type(op: "op_t const &") -> "ssize_t" + +ida_idp._processor_t.cbsize(self) -> int + +ida_idp._processor_t.clean_tbit(ea: ida_idaapi.ea_t, _getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> "ssize_t" + +ida_idp._processor_t.cmp_operands(op1: "op_t const &", op2: "op_t const &") -> "ssize_t" + +ida_idp._processor_t.coagulate(start_ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.coagulate_dref(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, may_define: bool, code_ea: "ea_t *") -> "ssize_t" + +ida_idp._processor_t.create_flat_group(image_base: ida_idaapi.ea_t, bitness: int, dataseg_sel: "sel_t") -> "ssize_t" + +ida_idp._processor_t.create_func_frame(pfn: "func_t *") -> "ssize_t" + +ida_idp._processor_t.create_merge_handlers(md: "merge_data_t *") -> "ssize_t" + +ida_idp._processor_t.create_switch_xrefs(jumpea: ida_idaapi.ea_t, si: "switch_info_t") -> "ssize_t" + +ida_idp._processor_t.creating_segm(seg: "segment_t *") -> "ssize_t" + +ida_idp._processor_t.cvt64_hashval(self, node: "nodeidx_t", tag: "uchar", name: str, data: "uchar const *") -> "ssize_t" + +ida_idp._processor_t.cvt64_supval(self, node: "nodeidx_t", tag: "uchar", idx: "nodeidx_t", data: "uchar const *") -> "ssize_t" + +ida_idp._processor_t.dbsize(self) -> int + +ida_idp._processor_t.decorate_name(outbuf: str, name: str, mangle: bool, cc: "cm_t", type: "tinfo_t") -> "ssize_t" + +ida_idp._processor_t.del_cref(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t, expand: bool) -> "ssize_t" + +ida_idp._processor_t.del_dref(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.delay_slot_insn(self, ea: "ea_t *", bexec: "bool *", fexec: "bool *") -> bool + +ida_idp._processor_t.demangle_name(res: "int32 *", name: str, disable_mask: int, demreq: int) -> int + +ida_idp._processor_t.emu_insn(insn: "insn_t const &") -> "ssize_t" + +ida_idp._processor_t.endbinary(ok: bool) -> "ssize_t" + +ida_idp._processor_t.equal_reglocs(a1: "argloc_t", a2: "argloc_t") -> "ssize_t" + +ida_idp._processor_t.extract_address(out_ea: "ea_t *", screen_ea: ida_idaapi.ea_t, string: str, x: "size_t") -> "ssize_t" + +ida_idp._processor_t.find_op_value(insn: "insn_t const &", op: int) -> "uint64 *" + +ida_idp._processor_t.find_reg_value(insn: "insn_t const &", reg: int) -> "uint64 *" + +ida_idp._processor_t.func_bounds(possible_return_code: "int *", pfn: "func_t *", max_func_end_ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.gen_asm_or_lst(starting: bool, fp: "FILE *", is_asm: bool, flags: int, outline: "void *") -> "ssize_t" + +ida_idp._processor_t.gen_map_file(nlines: "int *", fp: "FILE *") -> "ssize_t" + +ida_idp._processor_t.gen_regvar_def(ctx: "outctx_t &", v: "regvar_t *") -> "ssize_t" + +ida_idp._processor_t.gen_src_file_lnnum(ctx: "outctx_t &", file: str, lnnum: "size_t") -> "ssize_t" + +ida_idp._processor_t.gen_stkvar_def(ctx: "outctx_t &", mptr: "udm_t", v: int, tid: "tid_t") -> "ssize_t" + +ida_idp._processor_t.get_abi_info(comp: "comp_t") -> "qstrvec_t *, qstrvec_t *" + +ida_idp._processor_t.get_autocmt(insn: "insn_t const &") -> str + +ida_idp._processor_t.get_bg_color(color: "bgcolor_t *", ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.get_canon_feature(self, itype: "uint16") -> int + +ida_idp._processor_t.get_canon_mnem(self, itype: "uint16") -> str + +ida_idp._processor_t.get_cc_regs(regs: "callregs_t", cc: "cm_t") -> "ssize_t" + +ida_idp._processor_t.get_code16_mode(ea: ida_idaapi.ea_t) -> bool + +ida_idp._processor_t.get_dbr_opnum(opnum: "int *", insn: "insn_t const &") -> "ssize_t" + +ida_idp._processor_t.get_default_segm_bitness(self, is_64bit_app: bool) -> int + +ida_idp._processor_t.get_frame_retsize(retsize: "int *", pfn: "func_t const *") -> "ssize_t" + +ida_idp._processor_t.get_idd_opinfo(opinf: "idd_opinfo_t", ea: ida_idaapi.ea_t, n: int, thread_id: int, _getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> "ssize_t" + +ida_idp._processor_t.get_macro_insn_head(head: "ea_t *", ip: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.get_operand_string(insn: "insn_t const &", opnum: int) -> str + +ida_idp._processor_t.get_proc_index(self) -> int + +ida_idp._processor_t.get_reg_accesses(accvec: "reg_accesses_t", insn: "insn_t const &", flags: int) -> "ssize_t" + +ida_idp._processor_t.get_reg_info(regname: str, bitrange: "bitrange_t") -> str + +ida_idp._processor_t.get_reg_name(reg: int, width: "size_t", reghi: int) -> str + Get text representation of a register. For most processors this function will just return processor_t::reg_names[reg]. If the processor module has implemented processor_t::get_reg_name, it will be used instead + + @param reg: internal register number as defined in the processor module + @param width: register width in bytes + @param reghi: if specified, then this function will return the register pair + @returns length of register name in bytes or -1 if failure + +ida_idp._processor_t.get_simd_types(out: "void *", simd_attrs: "simd_info_t", argloc: "argloc_t", create_tifs: bool) -> "ssize_t" + +ida_idp._processor_t.get_stkarg_area_info(out: "stkarg_area_info_t", cc: "cm_t") -> "ssize_t" + +ida_idp._processor_t.get_stkvar_scale(self) -> int + +ida_idp._processor_t.get_stkvar_scale_factor() -> "ssize_t" + +ida_idp._processor_t.getreg(rv: "uval_t *", regnum: int) -> "ssize_t" + +ida_idp._processor_t.has_code16_bit(self) -> bool + +ida_idp._processor_t.has_idp_opts(self) -> bool + +ida_idp._processor_t.has_segregs(self) -> bool + +ida_idp._processor_t.init(idp_modname: str) -> "ssize_t" + +ida_idp._processor_t.insn_reads_tbit(insn: "insn_t const &", _getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> "ssize_t" + +ida_idp._processor_t.is_align_insn(ea: ida_idaapi.ea_t) -> "ssize_t" + If the instruction at 'ea' looks like an alignment instruction, return its length in bytes. Otherwise return 0. + + +ida_idp._processor_t.is_alloca_probe(ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.is_basic_block_end(insn: "insn_t const &", call_insn_stops_block: bool) -> "ssize_t" + Is the instruction the end of a basic block? + +ida_idp._processor_t.is_call_insn(insn: "insn_t const &") -> "ssize_t" + Is the instruction a "call"? + +ida_idp._processor_t.is_cond_insn(insn: "insn_t const &") -> "ssize_t" + +ida_idp._processor_t.is_control_flow_guard(p_reg: "int *", insn: "insn_t const *") -> "ssize_t" + +ida_idp._processor_t.is_far_jump(icode: int) -> "ssize_t" + +ida_idp._processor_t.is_indirect_jump(insn: "insn_t const &") -> "ssize_t" + +ida_idp._processor_t.is_jump_func(pfn: "func_t *", jump_target: "ea_t *", func_pointer: "ea_t *") -> "ssize_t" + +ida_idp._processor_t.is_ret_insn(insn: "insn_t const &", iri_flags: "uchar") -> "ssize_t" + +ida_idp._processor_t.is_sane_insn(insn: "insn_t const &", no_crefs: int) -> "ssize_t" + +ida_idp._processor_t.is_sp_based(insn: "insn_t const &", x: "op_t const &") -> "ssize_t" + +ida_idp._processor_t.is_switch(si: "switch_info_t", insn: "insn_t const &") -> "ssize_t" + +ida_idp._processor_t.loader_elf_machine(li: "linput_t *", machine_type: int, p_procname: "char const **", p_pd: "proc_def_t **", ldr: "elf_loader_t *", reader: "reader_t *") -> "ssize_t" + +ida_idp._processor_t.lower_func_type(argnums: "intvec_t *", fti: "func_type_data_t") -> "ssize_t" + +ida_idp._processor_t.max_ptr_size() -> "ssize_t" + +ida_idp._processor_t.may_be_func(insn: "insn_t const &", state: int) -> "ssize_t" + +ida_idp._processor_t.may_show_sreg(current_ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.moving_segm(seg: "segment_t *", to: ida_idaapi.ea_t, flags: int) -> "ssize_t" + +ida_idp._processor_t.newasm(asmnum: int) -> "ssize_t" + +ida_idp._processor_t.newbinary(filename: str, fileoff: "qoff64_t", basepara: ida_idaapi.ea_t, binoff: ida_idaapi.ea_t, nbytes: "uint64") -> "ssize_t" + +ida_idp._processor_t.newfile(fname: str) -> "ssize_t" + +ida_idp._processor_t.newprc(pnum: int, keep_cfg: bool) -> "ssize_t" + +ida_idp._processor_t.next_exec_insn(target: "ea_t *", ea: ida_idaapi.ea_t, tid: int, _getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> "ssize_t" + +ida_idp._processor_t.notify(*args) -> "ssize_t" + +ida_idp._processor_t.oldfile(fname: str) -> "ssize_t" + +ida_idp._processor_t.out_assumes(ctx: "outctx_t &") -> "ssize_t" + +ida_idp._processor_t.out_data(ctx: "outctx_t &", analyze_only: bool) -> "ssize_t" + +ida_idp._processor_t.out_footer(ctx: "outctx_t &") -> "ssize_t" + +ida_idp._processor_t.out_header(ctx: "outctx_t &") -> "ssize_t" + +ida_idp._processor_t.out_insn(ctx: "outctx_t &") -> "ssize_t" + +ida_idp._processor_t.out_label(ctx: "outctx_t &", colored_name: str) -> "ssize_t" + +ida_idp._processor_t.out_mnem(ctx: "outctx_t &") -> "ssize_t" + +ida_idp._processor_t.out_operand(ctx: "outctx_t &", op: "op_t const &") -> "ssize_t" + +ida_idp._processor_t.out_segend(ctx: "outctx_t &", seg: "segment_t *") -> "ssize_t" + +ida_idp._processor_t.out_segstart(ctx: "outctx_t &", seg: "segment_t *") -> "ssize_t" + +ida_idp._processor_t.out_special_item(ctx: "outctx_t &", segtype: "uchar") -> "ssize_t" + +ida_idp._processor_t.privrange_changed(self, old_privrange: "range_t", delta: "adiff_t") -> "ssize_t" + +ida_idp._processor_t.realcvt(m: "void *", e: "fpvalue_t *", swt: "uint16") -> "fpvalue_error_t" + +ida_idp._processor_t.rename(ea: ida_idaapi.ea_t, new_name: str, flags: int) -> "ssize_t" + +ida_idp._processor_t.set_code16_mode(ea: ida_idaapi.ea_t, code16: bool = True) -> "ssize_t" + +ida_idp._processor_t.set_idp_options(keyword: str, vtype: int, value: "void const *", idb_loaded: bool = True) -> str + +ida_idp._processor_t.set_proc_options(options: str, confidence: int) -> "ssize_t" + +ida_idp._processor_t.setup_til() -> "ssize_t" + +ida_idp._processor_t.sizeof_ldbl(self) -> "size_t" + +ida_idp._processor_t.stkup(self) -> bool + +ida_idp._processor_t.str2reg(regname: str) -> "ssize_t" + Get any register number (-1 on error) + +ida_idp._processor_t.supports_calcrel(self) -> bool + +ida_idp._processor_t.supports_macros(self) -> bool + +ida_idp._processor_t.term() -> "ssize_t" + +ida_idp._processor_t.ti(self) -> bool + +ida_idp._processor_t.treat_hindering_item(hindering_item_ea: ida_idaapi.ea_t, new_item_flags: "flags64_t", new_item_ea: ida_idaapi.ea_t, new_item_length: "asize_t") -> "ssize_t" + +ida_idp._processor_t.undefine(ea: ida_idaapi.ea_t) -> "ssize_t" + +ida_idp._processor_t.update_call_stack(stack: "call_stack_t", tid: int, _getreg: "processor_t::regval_getter_t *", regvalues: "regval_t") -> "ssize_t" + +ida_idp._processor_t.use32(self) -> bool + +ida_idp._processor_t.use64(self) -> bool + +ida_idp._processor_t.use_arg_types(ea: ida_idaapi.ea_t, fti: "func_type_data_t", rargs: "void *") -> "ssize_t" + +ida_idp._processor_t.use_mappings(self) -> bool + +ida_idp._processor_t.use_regarg_type(idx: "int *", ea: ida_idaapi.ea_t, rargs: "void *") -> "ssize_t" + +ida_idp._processor_t.use_stkarg_type(ea: ida_idaapi.ea_t, arg: "funcarg_t") -> "ssize_t" + +ida_idp._processor_t.use_tbyte(self) -> bool + +ida_idp._processor_t.validate_flirt_func(start_ea: ida_idaapi.ea_t, funcname: str) -> "ssize_t" + +ida_idp._processor_t.verify_noreturn(pfn: "func_t *") -> "ssize_t" + +ida_idp._processor_t.verify_sp(pfn: "func_t *") -> "ssize_t" + +ida_idp._processor_t_Trampoline_IDB_Hooks + +ida_idp._processor_t_Trampoline_IDB_Hooks.__dummy(self, *args) + +ida_idp._processor_t_Trampoline_IDB_Hooks.__init__(self, proc) + +ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller(self, key) + +ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller.call_parent(*args) + +ida_idp.asm_t + +ida_idp.asm_t.__init__(self) + +ida_idp.asm_t.a_align "align" keyword -ida_idp.asm_t.a_ascii (variable) +ida_idp.asm_t.a_ascii string literal directive -ida_idp.asm_t.a_band (variable) +ida_idp.asm_t.a_band & bit and assembler time operation -ida_idp.asm_t.a_bnot (variable) +ida_idp.asm_t.a_bnot ~ bit not assembler time operation -ida_idp.asm_t.a_bor (variable) +ida_idp.asm_t.a_bor | bit or assembler time operation -ida_idp.asm_t.a_bss (variable) - uninitialized data directive should include 's' for the size of data +ida_idp.asm_t.a_bss + uninitialized data directive should include 's' for the size of data + -ida_idp.asm_t.a_byte (variable) +ida_idp.asm_t.a_byte byte directive -ida_idp.asm_t.a_comdef (variable) +ida_idp.asm_t.a_comdef "comm" (communal variable) -ida_idp.asm_t.a_curip (variable) +ida_idp.asm_t.a_curip current IP (instruction pointer) symbol in assembler -ida_idp.asm_t.a_double (variable) +ida_idp.asm_t.a_double double; 8bytes; nullptr if not allowed -ida_idp.asm_t.a_dups (variable) +ida_idp.asm_t.a_dups array keyword. the following sequences may appear: * #h header * #d size * #v value - * #s(b,w,l,q,f,d,o) size specifiers for byte,word, dword,qword, - float,double,oword + * #s(b,w,l,q,f,d,o) size specifiers for byte,word, dword,qword, float,double,oword + + + -ida_idp.asm_t.a_dword (variable) +ida_idp.asm_t.a_dword nullptr if not allowed -ida_idp.asm_t.a_equ (variable) +ida_idp.asm_t.a_equ 'equ' Used if AS_UNEQU is set -ida_idp.asm_t.a_extrn (variable) +ida_idp.asm_t.a_extrn "extern" name keyword -ida_idp.asm_t.a_float (variable) +ida_idp.asm_t.a_float float; 4bytes; nullptr if not allowed -ida_idp.asm_t.a_include_fmt (variable) +ida_idp.asm_t.a_include_fmt the include directive (format string) -ida_idp.asm_t.a_mod (variable) +ida_idp.asm_t.a_mod % mod assembler time operation -ida_idp.asm_t.a_oword (variable) +ida_idp.asm_t.a_oword nullptr if not allowed -ida_idp.asm_t.a_packreal (variable) +ida_idp.asm_t.a_packreal packed decimal real nullptr if not allowed -ida_idp.asm_t.a_public (variable) +ida_idp.asm_t.a_public "public" name keyword. nullptr-use default, ""-do not generate -ida_idp.asm_t.a_qword (variable) +ida_idp.asm_t.a_qword nullptr if not allowed -ida_idp.asm_t.a_rva (variable) - 'rva' keyword for image based offsets (see REFINFO_RVAOFF) +ida_idp.asm_t.a_rva + 'rva' keyword for image based offsets (see REFINFO_RVAOFF) + -ida_idp.asm_t.a_seg (variable) +ida_idp.asm_t.a_seg 'seg ' prefix (example: push seg seg001) -ida_idp.asm_t.a_shl (variable) +ida_idp.asm_t.a_shl << shift left assembler time operation -ida_idp.asm_t.a_shr (variable) +ida_idp.asm_t.a_shr >> shift right assembler time operation -ida_idp.asm_t.a_sizeof_fmt (variable) +ida_idp.asm_t.a_sizeof_fmt size of type (format string) -ida_idp.asm_t.a_tbyte (variable) +ida_idp.asm_t.a_tbyte long double; nullptr if not allowed -ida_idp.asm_t.a_vstruc_fmt (variable) - if a named item is a structure and displayed in the verbose (multiline) form - then display the name as printf(a_strucname_fmt, typename) (for asms with type - checking, e.g. tasm ideal) +ida_idp.asm_t.a_vstruc_fmt + if a named item is a structure and displayed in the verbose (multiline) form then display the name as printf(a_strucname_fmt, typename) (for asms with type checking, e.g. tasm ideal) + -ida_idp.asm_t.a_weak (variable) +ida_idp.asm_t.a_weak "weak" name keyword. nullptr-use default, ""-do not generate -ida_idp.asm_t.a_word (variable) +ida_idp.asm_t.a_word word directive -ida_idp.asm_t.a_xor (variable) +ida_idp.asm_t.a_xor ^ bit xor assembler time operation -ida_idp.asm_t.a_yword (variable) - 32-byte (256-bit) data; nullptr if not allowed requires AS2_YWORD +ida_idp.asm_t.a_yword + 32-byte (256-bit) data; nullptr if not allowed requires AS2_YWORD + -ida_idp.asm_t.a_zword (variable) - 64-byte (512-bit) data; nullptr if not allowed requires AS2_ZWORD +ida_idp.asm_t.a_zword + 64-byte (512-bit) data; nullptr if not allowed requires AS2_ZWORD + -ida_idp.asm_t.accsep (variable) +ida_idp.asm_t.accsep char constant delimiter -ida_idp.asm_t.ascsep (variable) +ida_idp.asm_t.ascsep string literal delimiter -ida_idp.asm_t.cmnt (variable) +ida_idp.asm_t.cmnt comment string (see also cmnt2) -ida_idp.asm_t.cmnt2 (variable) - comment close string (usually nullptr) this is used to denote a string which - closes comments, for example, if the comments are represented with (* ... *) - then cmnt = "(*" and cmnt2 = "*)" +ida_idp.asm_t.cmnt2 + comment close string (usually nullptr) this is used to denote a string which closes comments, for example, if the comments are represented with (* ... *) then cmnt = "(*" and cmnt2 = "*)" + -ida_idp.asm_t.end (variable) +ida_idp.asm_t.end end directive -ida_idp.asm_t.esccodes (variable) - special chars that cannot appear as is in string and char literals +ida_idp.asm_t.esccodes + special chars that cannot appear as is in string and char literals + -ida_idp.asm_t.flag (variable) - Assembler feature bits +ida_idp.asm_t.flag + Assembler feature bits + -ida_idp.asm_t.flag2 (variable) - Secondary assembler feature bits +ida_idp.asm_t.flag2 + Secondary assembler feature bits + -ida_idp.asm_t.header (variable) - array of automatically generated header lines they appear at the start of - disassembled text +ida_idp.asm_t.header + array of automatically generated header lines they appear at the start of disassembled text + -ida_idp.asm_t.help (variable) +ida_idp.asm_t.help Help screen number, 0 - no help. -ida_idp.asm_t.high16 (variable) +ida_idp.asm_t.high16 high16 -ida_idp.asm_t.high8 (variable) +ida_idp.asm_t.high8 high8 -ida_idp.asm_t.lbrace (variable) +ida_idp.asm_t.lbrace left brace used in complex expressions -ida_idp.asm_t.low16 (variable) +ida_idp.asm_t.low16 low16 -ida_idp.asm_t.low8 (variable) +ida_idp.asm_t.low8 low8 operation, should contain s for the operand -ida_idp.asm_t.name (variable) +ida_idp.asm_t.name Assembler name (displayed in menus) -ida_idp.asm_t.origin (variable) +ida_idp.asm_t.origin org directive -ida_idp.asm_t.rbrace (variable) +ida_idp.asm_t.rbrace right brace used in complex expressions -ida_idp.asm_t.uflag (variable) - user defined flags (local only for IDP) you may define and use your own bits +ida_idp.asm_t.uflag + user defined flags (local only for IDP) you may define and use your own bits + -ida_idp.assemble (function) - assemble(ea, cs, ip, use32, line) -> bool +ida_idp.assemble(ea, cs, ip, use32, line) Assemble an instruction into the database (display a warning if an error is found) @param ea: linear address of instruction @@ -38739,222 +25270,118 @@ ida_idp.assemble (function) @return: Boolean. True on success. -ida_idp.cfg_get_cc_header_path (function) - cfg_get_cc_header_path(compid) -> char const * - - @param compid: comp_t +ida_idp.cfg_get_cc_header_path(compid: "comp_t") -> str -ida_idp.cfg_get_cc_parm (function) - cfg_get_cc_parm(compid, name) -> char const * - - @param compid: comp_t - @param name: char const * +ida_idp.cfg_get_cc_parm(compid: "comp_t", name: str) -> str -ida_idp.cfg_get_cc_predefined_macros (function) - cfg_get_cc_predefined_macros(compid) -> char const * - - @param compid: comp_t +ida_idp.cfg_get_cc_predefined_macros(compid: "comp_t") -> str -ida_idp.delay_slot_insn (function) - delay_slot_insn(ea, bexec, fexec) -> bool - - @param ea: ea_t * - @param bexec: bool * - @param fexec: bool * +ida_idp.delay_slot_insn(ea: "ea_t *", bexec: "bool *", fexec: "bool *") -> bool -ida_idp.gen_idb_event (function) - gen_idb_event(code) +ida_idp.gen_idb_event(*args) -> None the kernel will use this function to generate idb_events - - @param code: (C++: idb_event::event_code_t) enum idb_event::event_code_t -ida_idp.get_ash (function) - get_ash() -> asm_t +ida_idp.get_ash() -> "asm_t *" -ida_idp.get_config_value (function) - get_config_value(key) -> bool - - @param key: char const * +ida_idp.get_config_value(key: str) -> "jvalue_t *" -ida_idp.get_idb_notifier_addr (function) - get_idb_notifier_addr(arg1) -> PyObject * - - @param arg1: PyObject * +ida_idp.get_idb_notifier_addr(arg1: "PyObject *") -> "PyObject *" -ida_idp.get_idb_notifier_ud_addr (function) - get_idb_notifier_ud_addr(hooks) -> PyObject * - - @param hooks: IDB_Hooks * +ida_idp.get_idb_notifier_ud_addr(hooks: "IDB_Hooks") -> "PyObject *" -ida_idp.get_idp_name (function) - get_idp_name() -> str - Get name of the current processor module. The name is derived from the file - name. For example, for IBM PC the module is named "pc.w32" (windows version), - then the module name is "PC" (uppercase). If no processor module is loaded, this - function will return nullptr +ida_idp.get_idp_name() -> str + Get name of the current processor module. The name is derived from the file name. For example, for IBM PC the module is named "pc.w32" (windows version), then the module name is "PC" (uppercase). If no processor module is loaded, this function will return nullptr + -ida_idp.get_idp_notifier_addr (function) - get_idp_notifier_addr(arg1) -> PyObject * - - @param arg1: PyObject * +ida_idp.get_idp_notifier_addr(arg1: "PyObject *") -> "PyObject *" -ida_idp.get_idp_notifier_ud_addr (function) - get_idp_notifier_ud_addr(hooks) -> PyObject * - - @param hooks: IDP_Hooks * +ida_idp.get_idp_notifier_ud_addr(hooks: "IDP_Hooks") -> "PyObject *" -ida_idp.get_ph (function) - get_ph() -> _processor_t +ida_idp.get_ph() -> "processor_t *" -ida_idp.get_reg_info (function) - get_reg_info(regname, bitrange) -> char const * - - @param regname: char const * - @param bitrange: bitrange_t * +ida_idp.get_reg_info(regname: str, bitrange: "bitrange_t") -> str -ida_idp.get_reg_name (function) - get_reg_name(reg, width, reghi=-1) -> str - Get text representation of a register. For most processors this function will - just return processor_t::reg_names[reg]. If the processor module has implemented - processor_t::get_reg_name, it will be used instead - - @param reg: (C++: int) internal register number as defined in the processor module - @param width: (C++: size_t) register width in bytes - @param reghi: (C++: int) if specified, then this function will return the register pair - @return: length of register name in bytes or -1 if failure +ida_idp.get_reg_name(reg: int, width: "size_t", reghi: int = -1) -> str + Get text representation of a register. For most processors this function will just return processor_t::reg_names[reg]. If the processor module has implemented processor_t::get_reg_name, it will be used instead + + @param reg: internal register number as defined in the processor module + @param width: register width in bytes + @param reghi: if specified, then this function will return the register pair + @returns length of register name in bytes or -1 if failure -ida_idp.has_cf_chg (function) - has_cf_chg(feature, opnum) -> bool +ida_idp.has_cf_chg(feature: int, opnum: "uint") -> bool Does an instruction with the specified feature modify the i-th operand? - - @param feature: (C++: uint32) - @param opnum: (C++: uint) -ida_idp.has_cf_use (function) - has_cf_use(feature, opnum) -> bool +ida_idp.has_cf_use(feature: int, opnum: "uint") -> bool Does an instruction with the specified feature use a value of the i-th operand? - - @param feature: (C++: uint32) - @param opnum: (C++: uint) -ida_idp.has_insn_feature (function) - has_insn_feature(icode, bit) -> bool +ida_idp.has_insn_feature(icode: "uint16", bit: int) -> bool Does the specified instruction have the specified feature? - - @param icode: (C++: uint16) - @param bit: (C++: uint32) -ida_idp.is_align_insn (function) - is_align_insn(ea) -> int - If the instruction at 'ea' looks like an alignment instruction, return its - length in bytes. Otherwise return 0. - - @param ea: (C++: ea_t) +ida_idp.is_align_insn(ea: ida_idaapi.ea_t) -> int + If the instruction at 'ea' looks like an alignment instruction, return its length in bytes. Otherwise return 0. + -ida_idp.is_basic_block_end (function) - is_basic_block_end(insn, call_insn_stops_block) -> bool +ida_idp.is_basic_block_end(insn: "insn_t const &", call_insn_stops_block: bool) -> bool Is the instruction the end of a basic block? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param call_insn_stops_block: (C++: bool) -ida_idp.is_call_insn (function) - is_call_insn(insn) -> bool +ida_idp.is_call_insn(insn: "insn_t const &") -> bool Is the instruction a "call"? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) -ida_idp.is_indirect_jump_insn (function) - is_indirect_jump_insn(insn) -> bool +ida_idp.is_indirect_jump_insn(insn: "insn_t const &") -> bool Is the instruction an indirect jump? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) -ida_idp.is_ret_insn (function) - is_ret_insn(insn, strict=True) -> bool - Is the instruction a "return"? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param strict: (C++: bool) +ida_idp.is_ret_insn(*args) -> bool -ida_idp.num_range_t (class) - Proxy of C++ cfgopt_t::num_range_t class. +ida_idp.num_range_t -ida_idp.num_range_t.__init__ (method) - __init__(self, _min, _max) -> num_range_t - - @param _min: int64 - @param _max: int64 +ida_idp.num_range_t.__init__(self, _min: "int64", _max: "int64") -ida_idp.params_t (class) - Proxy of C++ cfgopt_t::params_t class. +ida_idp.params_t -ida_idp.params_t.__init__ (method) - __init__(self, _p1, _p2) -> params_t - - @param _p1: int64 - @param _p2: int64 +ida_idp.params_t.__init__(self, _p1: "int64", _p2: "int64") -ida_idp.parse_reg_name (function) - parse_reg_name(ri, regname) -> bool - Get register info by name. - - @param ri: (C++: reg_info_t *) result - @param regname: (C++: const char *) name of register - @return: success +ida_idp.parse_reg_name(ri: "reg_info_t", regname: str) -> bool + Get register info by name. + + @param ri: result + @param regname: name of register + @returns success -ida_idp.ph_calcrel (function) - ph_calcrel(ea) - - @param ea: ea_t +ida_idp.ph_calcrel(ea: ida_idaapi.ea_t) -> "bytevec_t *, size_t *" -ida_idp.ph_find_op_value (function) - ph_find_op_value(insn, op) -> ssize_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: int +ida_idp.ph_find_op_value(insn: "insn_t const &", op: int) -> "uint64 *" -ida_idp.ph_find_reg_value (function) - ph_find_reg_value(insn, reg) -> ssize_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param reg: int +ida_idp.ph_find_reg_value(insn: "insn_t const &", reg: int) -> "uint64 *" -ida_idp.ph_get_cnbits (function) - ph_get_cnbits() -> size_t +ida_idp.ph_get_abi_info(comp: "comp_t") -> "qstrvec_t *, qstrvec_t *" + +ida_idp.ph_get_cnbits() Returns the 'ph.cnbits' -ida_idp.ph_get_dnbits (function) - ph_get_dnbits() -> size_t +ida_idp.ph_get_dnbits() Returns the 'ph.dnbits' -ida_idp.ph_get_flag (function) - ph_get_flag() -> size_t +ida_idp.ph_get_flag() Returns the 'ph.flag' -ida_idp.ph_get_icode_return (function) - ph_get_icode_return() -> size_t +ida_idp.ph_get_icode_return() Returns the 'ph.icode_return' -ida_idp.ph_get_id (function) - ph_get_id() -> size_t +ida_idp.ph_get_id() Returns the 'ph.id' field -ida_idp.ph_get_instruc (function) - ph_get_instruc() -> [(str, int), ...] +ida_idp.ph_get_instruc() Returns a list of tuples (instruction_name, instruction_feature) containing the instructions list as defined in he processor module -ida_idp.ph_get_instruc_end (function) - ph_get_instruc_end() -> size_t +ida_idp.ph_get_instruc_end() Returns the 'ph.instruc_end' -ida_idp.ph_get_instruc_start (function) - ph_get_instruc_start() -> size_t +ida_idp.ph_get_instruc_start() Returns the 'ph.instruc_start' -ida_idp.ph_get_operand_info (function) - ph_get_operand_info(ea, n) -> (int, int, int, int, int) or None +ida_idp.ph_get_operand_info(ea: ida_idaapi.ea_t, n: int) -> Union[Tuple[int, ida_idaapi.ea_t, int, int, int], None] Returns the operand information given an ea and operand number. @param ea: address @@ -38963,52 +25390,37 @@ ida_idp.ph_get_operand_info (function) @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. -ida_idp.ph_get_reg_accesses (function) - ph_get_reg_accesses(accvec, insn, flags) -> ssize_t - - @param accvec: reg_accesses_t * - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param flags: int +ida_idp.ph_get_reg_accesses(accvec: "reg_accesses_t", insn: "insn_t const &", flags: int) -> "ssize_t" -ida_idp.ph_get_reg_code_sreg (function) - ph_get_reg_code_sreg() -> size_t +ida_idp.ph_get_reg_code_sreg() Returns the 'ph.reg_code_sreg' -ida_idp.ph_get_reg_data_sreg (function) - ph_get_reg_data_sreg() -> size_t +ida_idp.ph_get_reg_data_sreg() Returns the 'ph.reg_data_sreg' -ida_idp.ph_get_reg_first_sreg (function) - ph_get_reg_first_sreg() -> size_t +ida_idp.ph_get_reg_first_sreg() Returns the 'ph.reg_first_sreg' -ida_idp.ph_get_reg_last_sreg (function) - ph_get_reg_last_sreg() -> size_t +ida_idp.ph_get_reg_last_sreg() Returns the 'ph.reg_last_sreg' -ida_idp.ph_get_regnames (function) - ph_get_regnames() -> [str, ...] +ida_idp.ph_get_regnames() Returns the list of register names as defined in the processor module -ida_idp.ph_get_segreg_size (function) - ph_get_segreg_size() -> size_t +ida_idp.ph_get_segreg_size() Returns the 'ph.segreg_size' -ida_idp.ph_get_tbyte_size (function) - ph_get_tbyte_size() -> size_t +ida_idp.ph_get_tbyte_size() Returns the 'ph.tbyte_size' field as defined in he processor module -ida_idp.ph_get_version (function) - ph_get_version() -> size_t +ida_idp.ph_get_version() Returns the 'ph.version' -ida_idp.process_config_directive (function) - process_config_directive(directive, priority=2) - - @param directive: char const * - @param priority: int +ida_idp.process_config_directive(directive: str, priority: int = 2) -> None -ida_idp.processor_t (class) +ida_idp.processor_t + +ida_idp.processor_t.__idc_cvt_id__ Base class for all processor module scripts A processor_t instance is both an ida_idp.IDP_Hooks, and an @@ -39017,1477 +25429,1283 @@ ida_idp.processor_t (class) 'ida_idp.IDP_Hooks.ev_init' (replaced with processor_t.__init__), and 'ida_idp.IDP_Hooks.ev_term' (replaced with processor_t.__del__)). -ida_idp.processor_t.__init__ (method) +ida_idp.processor_t.__init__(self) -ida_idp.processor_t._get_idb_notifier_addr (method) +ida_idp.processor_t._get_idb_notifier_addr(self) -ida_idp.processor_t._get_idb_notifier_ud_addr (method) +ida_idp.processor_t._get_idb_notifier_ud_addr(self) -ida_idp.processor_t._get_idp_notifier_addr (method) +ida_idp.processor_t._get_idp_notifier_addr(self) -ida_idp.processor_t._get_idp_notifier_ud_addr (method) +ida_idp.processor_t._get_idp_notifier_ud_addr(self) -ida_idp.processor_t._get_notify (method) +ida_idp.processor_t._get_notify(self, what, unimp_val = 0, imp_forced_val = None, add_prefix = True, mandatory_impl = None) This helper is used to implement backward-compatibility of pre IDA 7.3 processor_t interfaces. -ida_idp.processor_t._make_forced_value_wrapper (method) +ida_idp.processor_t._make_forced_value_wrapper(self, val, meth = None) -ida_idp.processor_t._make_forced_value_wrapper.f (function) +ida_idp.processor_t._make_forced_value_wrapper.f(*args) -ida_idp.processor_t._make_int_returning_wrapper (method) +ida_idp.processor_t._make_int_returning_wrapper(self, meth, intval = 0) -ida_idp.processor_t._make_int_returning_wrapper.f (function) +ida_idp.processor_t._make_int_returning_wrapper.f(*args) -ida_idp.processor_t.auto_empty (method) +ida_idp.processor_t.auto_empty(self, *args) -ida_idp.processor_t.auto_empty_finally (method) +ida_idp.processor_t.auto_empty_finally(self, *args) -ida_idp.processor_t.closebase (method) +ida_idp.processor_t.closebase(self, *args) -ida_idp.processor_t.compiler_changed (method) +ida_idp.processor_t.compiler_changed(self, *args) -ida_idp.processor_t.deleting_func (method) +ida_idp.processor_t.deleting_func(self, pfn) -ida_idp.processor_t.determined_main (method) +ida_idp.processor_t.determined_main(self, *args) -ida_idp.processor_t.ev_ana_insn (method) +ida_idp.processor_t.ev_ana_insn(self, *args) -ida_idp.processor_t.ev_assemble (method) +ida_idp.processor_t.ev_assemble(self, *args) -ida_idp.processor_t.ev_auto_queue_empty (method) +ida_idp.processor_t.ev_auto_queue_empty(self, *args) -ida_idp.processor_t.ev_calc_step_over (method) +ida_idp.processor_t.ev_calc_step_over(self, target, ip) -ida_idp.processor_t.ev_can_have_type (method) +ida_idp.processor_t.ev_can_have_type(self, *args) -ida_idp.processor_t.ev_cmp_operands (method) +ida_idp.processor_t.ev_cmp_operands(self, *args) -ida_idp.processor_t.ev_coagulate (method) +ida_idp.processor_t.ev_coagulate(self, *args) -ida_idp.processor_t.ev_coagulate_dref (method) +ida_idp.processor_t.ev_coagulate_dref(self, from_ea, to_ea, may_define, _code_ea) -ida_idp.processor_t.ev_create_func_frame (method) +ida_idp.processor_t.ev_create_func_frame(self, pfn) -ida_idp.processor_t.ev_create_switch_xrefs (method) +ida_idp.processor_t.ev_create_switch_xrefs(self, *args) -ida_idp.processor_t.ev_creating_segm (method) +ida_idp.processor_t.ev_creating_segm(self, s) -ida_idp.processor_t.ev_emu_insn (method) +ida_idp.processor_t.ev_emu_insn(self, *args) -ida_idp.processor_t.ev_endbinary (method) +ida_idp.processor_t.ev_endbinary(self, *args) -ida_idp.processor_t.ev_func_bounds (method) +ida_idp.processor_t.ev_func_bounds(self, _possible_return_code, pfn, max_func_end_ea) -ida_idp.processor_t.ev_gen_map_file (method) +ida_idp.processor_t.ev_gen_map_file(self, nlines, fp) -ida_idp.processor_t.ev_gen_regvar_def (method) +ida_idp.processor_t.ev_gen_regvar_def(self, ctx, v) -ida_idp.processor_t.ev_gen_src_file_lnnum (method) +ida_idp.processor_t.ev_gen_src_file_lnnum(self, *args) -ida_idp.processor_t.ev_get_autocmt (method) +ida_idp.processor_t.ev_get_autocmt(self, *args) -ida_idp.processor_t.ev_get_frame_retsize (method) +ida_idp.processor_t.ev_get_frame_retsize(self, frsize, pfn) -ida_idp.processor_t.ev_get_operand_string (method) +ida_idp.processor_t.ev_get_operand_string(self, buf, insn, opnum) -ida_idp.processor_t.ev_is_align_insn (method) +ida_idp.processor_t.ev_is_align_insn(self, *args) -ida_idp.processor_t.ev_is_alloca_probe (method) +ida_idp.processor_t.ev_is_alloca_probe(self, *args) -ida_idp.processor_t.ev_is_basic_block_end (method) +ida_idp.processor_t.ev_is_basic_block_end(self, *args) -ida_idp.processor_t.ev_is_call_insn (method) +ida_idp.processor_t.ev_is_call_insn(self, *args) -ida_idp.processor_t.ev_is_far_jump (method) +ida_idp.processor_t.ev_is_far_jump(self, *args) -ida_idp.processor_t.ev_is_indirect_jump (method) +ida_idp.processor_t.ev_is_indirect_jump(self, *args) -ida_idp.processor_t.ev_is_insn_table_jump (method) +ida_idp.processor_t.ev_is_insn_table_jump(self, *args) -ida_idp.processor_t.ev_is_ret_insn (method) +ida_idp.processor_t.ev_is_ret_insn(self, *args) -ida_idp.processor_t.ev_is_sane_insn (method) +ida_idp.processor_t.ev_is_sane_insn(self, *args) -ida_idp.processor_t.ev_is_sp_based (method) +ida_idp.processor_t.ev_is_sp_based(self, mode, insn, op) -ida_idp.processor_t.ev_is_switch (method) +ida_idp.processor_t.ev_is_switch(self, *args) -ida_idp.processor_t.ev_may_be_func (method) +ida_idp.processor_t.ev_may_be_func(self, *args) -ida_idp.processor_t.ev_may_show_sreg (method) +ida_idp.processor_t.ev_may_show_sreg(self, *args) -ida_idp.processor_t.ev_moving_segm (method) +ida_idp.processor_t.ev_moving_segm(self, s, to_ea, flags) -ida_idp.processor_t.ev_newbinary (method) +ida_idp.processor_t.ev_newbinary(self, *args) -ida_idp.processor_t.ev_newfile (method) +ida_idp.processor_t.ev_newfile(self, *args) -ida_idp.processor_t.ev_newprc (method) +ida_idp.processor_t.ev_newprc(self, *args) -ida_idp.processor_t.ev_oldfile (method) +ida_idp.processor_t.ev_oldfile(self, *args) -ida_idp.processor_t.ev_out_assumes (method) +ida_idp.processor_t.ev_out_assumes(self, *args) -ida_idp.processor_t.ev_out_data (method) +ida_idp.processor_t.ev_out_data(self, *args) -ida_idp.processor_t.ev_out_footer (method) +ida_idp.processor_t.ev_out_footer(self, *args) -ida_idp.processor_t.ev_out_header (method) +ida_idp.processor_t.ev_out_header(self, *args) -ida_idp.processor_t.ev_out_insn (method) +ida_idp.processor_t.ev_out_insn(self, *args) -ida_idp.processor_t.ev_out_label (method) +ida_idp.processor_t.ev_out_label(self, *args) -ida_idp.processor_t.ev_out_mnem (method) +ida_idp.processor_t.ev_out_mnem(self, *args) -ida_idp.processor_t.ev_out_operand (method) +ida_idp.processor_t.ev_out_operand(self, *args) -ida_idp.processor_t.ev_out_segend (method) +ida_idp.processor_t.ev_out_segend(self, ctx, s) -ida_idp.processor_t.ev_out_segstart (method) +ida_idp.processor_t.ev_out_segstart(self, ctx, s) -ida_idp.processor_t.ev_out_special_item (method) +ida_idp.processor_t.ev_out_special_item(self, *args) -ida_idp.processor_t.ev_rename (method) +ida_idp.processor_t.ev_rename(self, *args) -ida_idp.processor_t.ev_set_idp_options (method) +ida_idp.processor_t.ev_set_idp_options(self, keyword, value_type, value, idb_loaded) -ida_idp.processor_t.ev_set_proc_options (method) +ida_idp.processor_t.ev_set_proc_options(self, *args) -ida_idp.processor_t.ev_str2reg (method) +ida_idp.processor_t.ev_str2reg(self, *args) -ida_idp.processor_t.ev_treat_hindering_item (method) +ida_idp.processor_t.ev_treat_hindering_item(self, *args) -ida_idp.processor_t.ev_undefine (method) +ida_idp.processor_t.ev_undefine(self, *args) -ida_idp.processor_t.ev_validate_flirt_func (method) +ida_idp.processor_t.ev_validate_flirt_func(self, *args) -ida_idp.processor_t.ev_verify_noreturn (method) +ida_idp.processor_t.ev_verify_noreturn(self, pfn) -ida_idp.processor_t.ev_verify_sp (method) +ida_idp.processor_t.ev_verify_sp(self, pfn) -ida_idp.processor_t.func_added (method) +ida_idp.processor_t.func_added(self, pfn) -ida_idp.processor_t.get_auxpref (method) +ida_idp.processor_t.get_auxpref(self, insn) This function returns insn.auxpref value -ida_idp.processor_t.get_idpdesc (method) +ida_idp.processor_t.get_idpdesc(self) This function must be present and should return the list of short processor names similar to the one in ph.psnames. This method can be overridden to return to the kernel a different IDP description. -ida_idp.processor_t.get_uFlag (method) - Use this utility function to retrieve the 'uFlag' global variable +ida_idp.processor_t.idasgn_loaded(self, *args) -ida_idp.processor_t.idasgn_loaded (method) +ida_idp.processor_t.kernel_config_loaded(self, *args) -ida_idp.processor_t.kernel_config_loaded (method) +ida_idp.processor_t.make_code(self, *args) -ida_idp.processor_t.make_code (method) +ida_idp.processor_t.make_data(self, *args) -ida_idp.processor_t.make_data (method) +ida_idp.processor_t.renamed(self, *args) -ida_idp.processor_t.renamed (method) +ida_idp.processor_t.savebase(self, *args) -ida_idp.processor_t.savebase (method) +ida_idp.processor_t.segm_moved(self, from_ea, to_ea, size, changed_netmap) -ida_idp.processor_t.segm_moved (method) +ida_idp.processor_t.set_func_end(self, *args) -ida_idp.processor_t.set_func_end (method) +ida_idp.processor_t.set_func_start(self, *args) -ida_idp.processor_t.set_func_start (method) +ida_idp.processor_t.sgr_changed(self, *args) -ida_idp.processor_t.sgr_changed (method) +ida_idp.reg_access_t -ida_idp.reg_access_t (class) - Proxy of C++ reg_access_t class. +ida_idp.reg_access_t.__eq__(self, r: "reg_access_t") -> bool -ida_idp.reg_access_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: reg_access_t const & +ida_idp.reg_access_t.__init__(self) -ida_idp.reg_access_t.__init__ (method) - __init__(self) -> reg_access_t +ida_idp.reg_access_t.__ne__(self, r: "reg_access_t") -> bool -ida_idp.reg_access_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: reg_access_t const & +ida_idp.reg_access_t.have_common_bits(self, r: "reg_access_t") -> bool -ida_idp.reg_access_t.have_common_bits (method) - have_common_bits(self, r) -> bool - - @param r: reg_access_t const & - -ida_idp.reg_access_t.opnum (variable) +ida_idp.reg_access_t.opnum operand number -ida_idp.reg_access_t.range (variable) +ida_idp.reg_access_t.range bitrange inside the register -ida_idp.reg_access_t.regnum (variable) +ida_idp.reg_access_t.regnum register number (only entire registers) -ida_idp.reg_access_vec_t (class) - Proxy of C++ qvector< reg_access_t > class. +ida_idp.reg_access_vec_t -ida_idp.reg_access_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< reg_access_t > const & +ida_idp.reg_access_vec_t.__eq__(self, r: "reg_access_vec_t") -> bool -ida_idp.reg_access_vec_t.__getitem__ (method) - __getitem__(self, i) -> reg_access_t - - @param i: size_t +ida_idp.reg_access_vec_t.__getitem__(self, i: "size_t") -> "reg_access_t const &" -ida_idp.reg_access_vec_t.__init__ (method) - __init__(self) -> reg_access_vec_t - __init__(self, x) -> reg_access_vec_t - - @param x: qvector< reg_access_t > const & +ida_idp.reg_access_vec_t.__init__(self, *args) -ida_idp.reg_access_vec_t.__len__ (method) - __len__(self) -> size_t +ida_idp.reg_access_vec_t.__len__(self) -> "size_t" -ida_idp.reg_access_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< reg_access_t > const & +ida_idp.reg_access_vec_t.__ne__(self, r: "reg_access_vec_t") -> bool -ida_idp.reg_access_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: reg_access_t const & +ida_idp.reg_access_vec_t.__setitem__(self, i: "size_t", v: "reg_access_t") -> None -ida_idp.reg_access_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: reg_access_t const & +ida_idp.reg_access_vec_t._del(self, x: "reg_access_t") -> bool -ida_idp.reg_access_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: reg_access_t const & +ida_idp.reg_access_vec_t.add_unique(self, x: "reg_access_t") -> bool -ida_idp.reg_access_vec_t.at (method) - at(self, _idx) -> reg_access_t - - @param _idx: size_t +ida_idp.reg_access_vec_t.append(self, x: "reg_access_t") -> None -ida_idp.reg_access_vec_t.begin (method) - begin(self) -> reg_access_t +ida_idp.reg_access_vec_t.at(self, _idx: "size_t") -> "reg_access_t const &" -ida_idp.reg_access_vec_t.capacity (method) - capacity(self) -> size_t +ida_idp.reg_access_vec_t.begin(self, *args) -> "qvector< reg_access_t >::const_iterator" -ida_idp.reg_access_vec_t.clear (method) - clear(self) +ida_idp.reg_access_vec_t.capacity(self) -> "size_t" -ida_idp.reg_access_vec_t.empty (method) - empty(self) -> bool +ida_idp.reg_access_vec_t.clear(self) -> None -ida_idp.reg_access_vec_t.end (method) - end(self) -> reg_access_t +ida_idp.reg_access_vec_t.empty(self) -> bool -ida_idp.reg_access_vec_t.erase (method) - erase(self, it) -> reg_access_t - - @param it: qvector< reg_access_t >::iterator - - erase(self, first, last) -> reg_access_t - - @param first: qvector< reg_access_t >::iterator - @param last: qvector< reg_access_t >::iterator +ida_idp.reg_access_vec_t.end(self, *args) -> "qvector< reg_access_t >::const_iterator" -ida_idp.reg_access_vec_t.extract (method) - extract(self) -> reg_access_t +ida_idp.reg_access_vec_t.erase(self, *args) -> "qvector< reg_access_t >::iterator" -ida_idp.reg_access_vec_t.find (method) - find(self, x) -> reg_access_t - - @param x: reg_access_t const & +ida_idp.reg_access_vec_t.extend(self, x: "reg_access_vec_t") -> None -ida_idp.reg_access_vec_t.grow (method) - grow(self, x=reg_access_t()) - - @param x: reg_access_t const & +ida_idp.reg_access_vec_t.extract(self) -> "reg_access_t *" -ida_idp.reg_access_vec_t.has (method) - has(self, x) -> bool - - @param x: reg_access_t const & +ida_idp.reg_access_vec_t.find(self, *args) -> "qvector< reg_access_t >::const_iterator" -ida_idp.reg_access_vec_t.inject (method) - inject(self, s, len) - - @param s: reg_access_t * - @param len: size_t +ida_idp.reg_access_vec_t.grow(self, *args) -> None -ida_idp.reg_access_vec_t.insert (method) - insert(self, it, x) -> reg_access_t - - @param it: qvector< reg_access_t >::iterator - @param x: reg_access_t const & +ida_idp.reg_access_vec_t.has(self, x: "reg_access_t") -> bool -ida_idp.reg_access_vec_t.pop_back (method) - pop_back(self) +ida_idp.reg_access_vec_t.inject(self, s: "reg_access_t", len: "size_t") -> None -ida_idp.reg_access_vec_t.push_back (method) - push_back(self, x) - - @param x: reg_access_t const & - - push_back(self) -> reg_access_t +ida_idp.reg_access_vec_t.insert(self, it: "reg_access_t", x: "reg_access_t") -> "qvector< reg_access_t >::iterator" -ida_idp.reg_access_vec_t.qclear (method) - qclear(self) +ida_idp.reg_access_vec_t.pop_back(self) -> None -ida_idp.reg_access_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_idp.reg_access_vec_t.push_back(self, *args) -> "reg_access_t &" -ida_idp.reg_access_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: reg_access_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_idp.reg_access_vec_t.qclear(self) -> None -ida_idp.reg_access_vec_t.size (method) - size(self) -> size_t +ida_idp.reg_access_vec_t.reserve(self, cnt: "size_t") -> None -ida_idp.reg_access_vec_t.swap (method) - swap(self, r) - - @param r: qvector< reg_access_t > & +ida_idp.reg_access_vec_t.resize(self, *args) -> None -ida_idp.reg_access_vec_t.truncate (method) - truncate(self) +ida_idp.reg_access_vec_t.size(self) -> "size_t" -ida_idp.reg_accesses_t (class) - Proxy of C++ reg_accesses_t class. +ida_idp.reg_access_vec_t.swap(self, r: "reg_access_vec_t") -> None -ida_idp.reg_accesses_t.__init__ (method) - __init__(self) -> reg_accesses_t +ida_idp.reg_access_vec_t.truncate(self) -> None -ida_idp.reg_info_t (class) - Proxy of C++ reg_info_t class. +ida_idp.reg_accesses_t -ida_idp.reg_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: reg_info_t const & +ida_idp.reg_accesses_t.__init__(self) -ida_idp.reg_info_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: reg_info_t const & +ida_idp.reg_info_t -ida_idp.reg_info_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: reg_info_t const & +ida_idp.reg_info_t.__eq__(self, r: "reg_info_t") -> bool -ida_idp.reg_info_t.__init__ (method) - __init__(self) -> reg_info_t +ida_idp.reg_info_t.__ge__(self, r: "reg_info_t") -> bool -ida_idp.reg_info_t.__le__ (method) - __le__(self, r) -> bool - - @param r: reg_info_t const & +ida_idp.reg_info_t.__gt__(self, r: "reg_info_t") -> bool -ida_idp.reg_info_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: reg_info_t const & +ida_idp.reg_info_t.__init__(self) -ida_idp.reg_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: reg_info_t const & +ida_idp.reg_info_t.__le__(self, r: "reg_info_t") -> bool -ida_idp.reg_info_t.compare (method) - compare(self, r) -> int - - @param r: reg_info_t const & +ida_idp.reg_info_t.__lt__(self, r: "reg_info_t") -> bool -ida_idp.reg_info_t.reg (variable) +ida_idp.reg_info_t.__ne__(self, r: "reg_info_t") -> bool + +ida_idp.reg_info_t.compare(self, r: "reg_info_t") -> int + +ida_idp.reg_info_t.reg register number -ida_idp.reg_info_t.size (variable) +ida_idp.reg_info_t.size register size -ida_idp.register_cfgopts (function) - register_cfgopts(opts, nopts, cb=None, obj=None) -> bool - - @param opts: cfgopt_t const [] - @param nopts: size_t - @param cb: config_changed_cb_t * - @param obj: void * +ida_idp.register_cfgopts(opts: "cfgopt_t const []", nopts: "size_t", cb: "config_changed_cb_t *" = None, obj: "void *" = None) -> bool -ida_idp.set_processor_type (function) - set_processor_type(procname, level) -> bool - Set target processor type. Once a processor module is loaded, it cannot be - replaced until we close the idb. - - @param procname: (C++: const char *) name of processor type (one of names present in - processor_t::psnames) - @param level: (C++: setproc_level_t) SETPROC_ - @return: success +ida_idp.set_processor_type(procname: str, level: "setproc_level_t") -> bool + Set target processor type. Once a processor module is loaded, it cannot be replaced until we close the idb. + + @param procname: name of processor type (one of names present in processor_t::psnames) + @param level: SETPROC_ + @returns success -ida_idp.set_target_assembler (function) - set_target_assembler(asmnum) -> bool - Set target assembler. - - @param asmnum: (C++: int) number of assembler in the current processor module - @return: success +ida_idp.set_target_assembler(asmnum: int) -> bool + Set target assembler. + + @param asmnum: number of assembler in the current processor module + @returns success -ida_idp.sizeof_ldbl (function) - sizeof_ldbl() -> size_t +ida_idp.sizeof_ldbl() -> "size_t" -ida_idp.str2reg (function) - str2reg(p) -> int - Get any reg number (-1 on error) - - @param p: (C++: const char *) char const * +ida_idp.str2reg(p: str) -> int + Get any register number (-1 on error) -ida_ieee (module) +ida_idp.str2sreg(name: str) + get segment register number from its name or -1 + +ida_ieee IEEE floating point functions. -ida_ieee.E_SPECIAL_EXP (variable) +ida_ieee.E_SPECIAL_EXP Exponent in fpvalue_t for NaN and Inf. -ida_ieee.FPV_BADARG (variable) +ida_ieee.FPVAL_NWORDS + number of words in fpvalue_t + +ida_ieee.FPV_BADARG wrong value of max_exp -ida_ieee.FPV_NAN (variable) +ida_ieee.FPV_NAN NaN. -ida_ieee.FPV_NINF (variable) +ida_ieee.FPV_NINF negative infinity -ida_ieee.FPV_NORM (variable) +ida_ieee.FPV_NORM regular value -ida_ieee.FPV_PINF (variable) +ida_ieee.FPV_PINF positive infinity -ida_ieee.IEEE_EXONE (variable) +ida_ieee.IEEE_E + Array offset to exponent. + +ida_ieee.IEEE_EXONE The exponent of 1.0. -ida_ieee.REAL_ERROR_FPOVER (variable) +ida_ieee.IEEE_M + Array offset to high guard word + + +ida_ieee.IEEE_NI + Number of 16 bit words in eNI. + +ida_ieee.REAL_ERROR_BADDATA + realcvt: illegal real data for load (IEEE data not filled) + +ida_ieee.REAL_ERROR_BADSTR + asctoreal: illegal input string + +ida_ieee.REAL_ERROR_FORMAT + realcvt: not supported format for current .idp + +ida_ieee.REAL_ERROR_FPOVER floating overflow or underflow -ida_ieee.REAL_ERROR_INTOVER (variable) +ida_ieee.REAL_ERROR_INTOVER eetol*: integer overflow -ida_ieee.REAL_ERROR_OK (variable) +ida_ieee.REAL_ERROR_OK no error -ida_ieee.ecleaz (function) - ecleaz(x) - - @param x: unsigned short [(6+3)] +ida_ieee.REAL_ERROR_RANGE + realcvt: number too big (small) for store (mem NOT modified) -ida_ieee.fpvalue_shorts_array_t (class) - Proxy of C++ wrapped_array_t< uint16,FPVAL_NWORDS > class. +ida_ieee.REAL_ERROR_ZERODIV + ediv: divide by 0 -ida_ieee.fpvalue_shorts_array_t.__getitem__ (method) - __getitem__(self, i) -> unsigned short const & - - @param i: size_t +ida_ieee.ecleaz(x: "eNI") -> None -ida_ieee.fpvalue_shorts_array_t.__init__ (method) - __init__(self, data) -> fpvalue_shorts_array_t - - @param data: unsigned short (&)[FPVAL_NWORDS] +ida_ieee.fpvalue_shorts_array_t -ida_ieee.fpvalue_shorts_array_t.__len__ (method) - __len__(self) -> size_t +ida_ieee.fpvalue_shorts_array_t.__getitem__(self, i: "size_t") -> "unsigned short const &" -ida_ieee.fpvalue_shorts_array_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned short const & +ida_ieee.fpvalue_shorts_array_t.__init__(self, data: "unsigned short (&)[FPVAL_NWORDS]") -ida_ieee.fpvalue_shorts_array_t._get_bytes (method) - _get_bytes(self) -> bytevec_t +ida_ieee.fpvalue_shorts_array_t.__len__(self) -> "size_t" -ida_ieee.fpvalue_shorts_array_t._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & +ida_ieee.fpvalue_shorts_array_t.__setitem__(self, i: "size_t", v: "unsigned short const &") -> None -ida_ieee.fpvalue_t (class) - Proxy of C++ fpvalue_t class. +ida_ieee.fpvalue_shorts_array_t._get_bytes(self) -> "bytevec_t" -ida_ieee.fpvalue_t.__add__ (method) - __add__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & +ida_ieee.fpvalue_shorts_array_t._set_bytes(self, bts: "bytevec_t const &") -> None -ida_ieee.fpvalue_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t -ida_ieee.fpvalue_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t.__add__(self, o: "fpvalue_t") -> "fpvalue_t" -ida_ieee.fpvalue_t.__getitem__ (method) +ida_ieee.fpvalue_t.__eq__(self, r: "fpvalue_t") -> bool -ida_ieee.fpvalue_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t.__ge__(self, r: "fpvalue_t") -> bool -ida_ieee.fpvalue_t.__init__ (method) - __init__(self) -> fpvalue_t - __init__(self, _in) -> fpvalue_t - - @param in: bytevec12_t const & +ida_ieee.fpvalue_t.__getitem__(self, i) -ida_ieee.fpvalue_t.__iter__ (method) +ida_ieee.fpvalue_t.__gt__(self, r: "fpvalue_t") -> bool -ida_ieee.fpvalue_t.__le__ (method) - __le__(self, r) -> bool - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t.__init__(self, *args) -ida_ieee.fpvalue_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t.__iter__(self) -ida_ieee.fpvalue_t.__mul__ (method) - __mul__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & +ida_ieee.fpvalue_t.__le__(self, r: "fpvalue_t") -> bool -ida_ieee.fpvalue_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t.__lt__(self, r: "fpvalue_t") -> bool -ida_ieee.fpvalue_t.__setitem__ (method) +ida_ieee.fpvalue_t.__mul__(self, o: "fpvalue_t") -> "fpvalue_t" -ida_ieee.fpvalue_t.__str__ (method) - __str__(self) -> qstring +ida_ieee.fpvalue_t.__ne__(self, r: "fpvalue_t") -> bool -ida_ieee.fpvalue_t.__sub__ (method) - __sub__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & +ida_ieee.fpvalue_t.__repr__(self) -ida_ieee.fpvalue_t.__truediv__ (method) - __truediv__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & +ida_ieee.fpvalue_t.__setitem__(self, i, v) -ida_ieee.fpvalue_t._get_10bytes (method) - _get_10bytes(self) +ida_ieee.fpvalue_t.__str__(self) -> str -ida_ieee.fpvalue_t._get_bytes (method) - _get_bytes(self) +ida_ieee.fpvalue_t.__sub__(self, o: "fpvalue_t") -> "fpvalue_t" -ida_ieee.fpvalue_t._get_float (method) - _get_float(self) -> double +ida_ieee.fpvalue_t.__truediv__(self, o: "fpvalue_t") -> "fpvalue_t" -ida_ieee.fpvalue_t._get_shorts (method) - _get_shorts(self) -> fpvalue_shorts_array_t +ida_ieee.fpvalue_t._get_bytes(self) -> None -ida_ieee.fpvalue_t._set_10bytes (method) - _set_10bytes(self, _in) - - Parameters - ---------- - in: bytevec10_t const & +ida_ieee.fpvalue_t._get_float(self) -> "double" -ida_ieee.fpvalue_t._set_bytes (method) - _set_bytes(self, _in) - - Parameters - ---------- - in: bytevec12_t const & +ida_ieee.fpvalue_t._get_shorts(self) -> "wrapped_array_t< uint16,FPVAL_NWORDS >" -ida_ieee.fpvalue_t._set_float (method) - _set_float(self, v) - - Parameters - ---------- - v: double +ida_ieee.fpvalue_t._set_bytes(self, _in: "bytevec16_t const &") -> None -ida_ieee.fpvalue_t.assign (method) - assign(self, r) - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t._set_float(self, v: "double") -> None -ida_ieee.fpvalue_t.clear (method) - clear(self) +ida_ieee.fpvalue_t.assign(self, r: "fpvalue_t") -> None -ida_ieee.fpvalue_t.compare (method) - compare(self, r) -> int - - @param r: fpvalue_t const & +ida_ieee.fpvalue_t.clear(self) -> None -ida_ieee.fpvalue_t.eabs (method) - eabs(self) +ida_ieee.fpvalue_t.compare(self, r: "fpvalue_t") -> int + +ida_ieee.fpvalue_t.copy(self) -> "fpvalue_t" + +ida_ieee.fpvalue_t.eabs(self) -> None Calculate absolute value. -ida_ieee.fpvalue_t.fadd (method) - fadd(self, y) -> fpvalue_error_t +ida_ieee.fpvalue_t.fadd(self, y: "fpvalue_t") -> "fpvalue_error_t" Arithmetic operations. - - @param y: (C++: const fpvalue_t &) fpvalue_t const & -ida_ieee.fpvalue_t.fdiv (method) - fdiv(self, y) -> fpvalue_error_t - - @param y: fpvalue_t const & +ida_ieee.fpvalue_t.fdiv(self, y: "fpvalue_t") -> "fpvalue_error_t" -ida_ieee.fpvalue_t.fmul (method) - fmul(self, y) -> fpvalue_error_t - - @param y: fpvalue_t const & +ida_ieee.fpvalue_t.fmul(self, y: "fpvalue_t") -> "fpvalue_error_t" -ida_ieee.fpvalue_t.from_10bytes (method) - from_10bytes(self, fpval) -> fpvalue_error_t +ida_ieee.fpvalue_t.from_10bytes(self, fpval: "void const *") -> "fpvalue_error_t" Conversions for 10-byte floating point values. - - @param fpval: (C++: const void *) void const * -ida_ieee.fpvalue_t.from_12bytes (method) - from_12bytes(self, fpval) -> fpvalue_error_t +ida_ieee.fpvalue_t.from_12bytes(self, fpval: "void const *") -> "fpvalue_error_t" Conversions for 12-byte floating point values. - - @param fpval: (C++: const void *) void const * -ida_ieee.fpvalue_t.from_int64 (method) - from_int64(self, x) - - @param x: int64 +ida_ieee.fpvalue_t.from_int64(self, x: "int64") -> None -ida_ieee.fpvalue_t.from_str (method) - from_str(self, p) -> fpvalue_error_t - Convert string to IEEE. - - @param p_str: (C++: const char **) pointer to pointer to string. it will advanced. +ida_ieee.fpvalue_t.from_str(self, p: str) -> "fpvalue_error_t" + Convert string to IEEE. + -ida_ieee.fpvalue_t.from_sval (method) - from_sval(self, x) +ida_ieee.fpvalue_t.from_sval(self, x: int) -> None Convert integer to IEEE. - - @param x: (C++: sval_t) -ida_ieee.fpvalue_t.from_uint64 (method) - from_uint64(self, x) - - @param x: uint64 +ida_ieee.fpvalue_t.from_uint64(self, x: "uint64") -> None -ida_ieee.fpvalue_t.fsub (method) - fsub(self, y) -> fpvalue_error_t - - @param y: fpvalue_t const & +ida_ieee.fpvalue_t.fsub(self, y: "fpvalue_t") -> "fpvalue_error_t" -ida_ieee.fpvalue_t.get_kind (method) - get_kind(self) -> fpvalue_kind_t +ida_ieee.fpvalue_t.get_kind(self) -> "fpvalue_kind_t" Get value kind. -ida_ieee.fpvalue_t.is_negative (method) - is_negative(self) -> bool +ida_ieee.fpvalue_t.is_negative(self) -> bool Is negative value? -ida_ieee.fpvalue_t.mul_pow2 (method) - mul_pow2(self, power_of_2) -> fpvalue_error_t +ida_ieee.fpvalue_t.mul_pow2(self, power_of_2: int) -> "fpvalue_error_t" Multiply by a power of 2. - - @param power_of_2: (C++: int32) -ida_ieee.fpvalue_t.negate (method) - negate(self) +ida_ieee.fpvalue_t.negate(self) -> None Negate. -ida_ieee.fpvalue_t.to_10bytes (method) - to_10bytes(self, fpval) -> fpvalue_error_t - - @param fpval: void * +ida_ieee.fpvalue_t.new_from_str(p: str) -> "fpvalue_t" -ida_ieee.fpvalue_t.to_12bytes (method) - to_12bytes(self, fpval) -> fpvalue_error_t - - @param fpval: void * +ida_ieee.fpvalue_t.to_10bytes(self, fpval: "void *") -> "fpvalue_error_t" -ida_ieee.fpvalue_t.to_int64 (method) - to_int64(self, round=False) -> fpvalue_error_t - - @param round: bool +ida_ieee.fpvalue_t.to_12bytes(self, fpval: "void *") -> "fpvalue_error_t" -ida_ieee.fpvalue_t.to_str (method) - to_str(self, mode) - Convert IEEE to string. - - @param mode: (C++: uint) broken down into: +ida_ieee.fpvalue_t.to_int64(self, round: bool = False) -> "fpvalue_error_t" + +ida_ieee.fpvalue_t.to_str(self, *args) -> None + Convert IEEE to string. + + @param buf: the output buffer + @param bufsize: the size of the output buffer + @param mode: broken down into: * low byte: number of digits after '.' * second byte: FPNUM_LENGTH * third byte: FPNUM_DIGITS -ida_ieee.fpvalue_t.to_sval (method) - to_sval(self, round=False) -> fpvalue_error_t +ida_ieee.fpvalue_t.to_sval(self, round: bool = False) -> "fpvalue_error_t" Convert IEEE to integer (+-0.5 if round) - - @param round: (C++: bool) -ida_ieee.fpvalue_t.to_uint64 (method) - to_uint64(self, round=False) -> fpvalue_error_t - - @param round: bool +ida_ieee.fpvalue_t.to_uint64(self, round: bool = False) -> "fpvalue_error_t" -ida_kernwin (module) +ida_kernwin Defines the interface between the kernel and the UI. It contains: * the UI dispatcher notification codes (ui_notification_t) * convenience functions for UI services - * structures which hold information about the lines (disassembly, structures, - enums) generated by the kernel + * structures which hold information about the lines (disassembly, structures, enums) generated by the kernel * functions to interact with the user (dialog boxes) - * some string and conversion functions. + * some string and conversion functions. + + + -ida_kernwin.AA_CHECKABLE (variable) +ida_kernwin.AA_CHECKABLE see update_action_checkable() -ida_kernwin.AA_CHECKED (variable) +ida_kernwin.AA_CHECKED see update_action_checked() -ida_kernwin.AA_ICON (variable) +ida_kernwin.AA_ICON see update_action_icon() -ida_kernwin.AA_LABEL (variable) +ida_kernwin.AA_LABEL see update_action_label() -ida_kernwin.AA_NONE (variable) +ida_kernwin.AA_NONE no effect -ida_kernwin.AA_SHORTCUT (variable) +ida_kernwin.AA_SHORTCUT see update_action_shortcut() -ida_kernwin.AA_STATE (variable) +ida_kernwin.AA_STATE see update_action_state() -ida_kernwin.AA_TOOLTIP (variable) +ida_kernwin.AA_TOOLTIP see update_action_tooltip() -ida_kernwin.AA_VISIBILITY (variable) +ida_kernwin.AA_VISIBILITY see update_action_visibility() -ida_kernwin.ACF_HAS_FIELD_DIRTREE_SELECTION (variable) - 'cur_enum_member' and 'dirtree_selection' fields are present +ida_kernwin.ACF_HAS_FIELD_DIRTREE_SELECTION + 'dirtree_selection' field is present -ida_kernwin.ACF_HAS_SELECTION (variable) +ida_kernwin.ACF_HAS_SELECTION there is currently a valid selection -ida_kernwin.ACF_HAS_SOURCE (variable) +ida_kernwin.ACF_HAS_SOURCE 'source' field is present -ida_kernwin.ACF_HAS_TYPE_REF (variable) +ida_kernwin.ACF_HAS_TYPE_REF 'type_ref' field is present -ida_kernwin.ACF_XTRN_EA (variable) +ida_kernwin.ACF_XTRN_EA cur_ea is in 'externs' segment -ida_kernwin.ADF_CHECKABLE (variable) +ida_kernwin.ADF_CHECKABLE action is checkable -ida_kernwin.ADF_CHECKED (variable) +ida_kernwin.ADF_CHECKED starts in a checked state (requires ADF_CHECKABLE) -ida_kernwin.ADF_GLOBAL (variable) - Register the action globally, so that it's available even if no IDB is present +ida_kernwin.ADF_GLOBAL + Register the action globally, so that it's available even if no IDB is present + -ida_kernwin.ADF_NO_HIGHLIGHT (variable) - After activating, do not update the highlight according to what's under the - cursor (listings only.) +ida_kernwin.ADF_NO_HIGHLIGHT + After activating, do not update the highlight according to what's under the cursor (listings only.) + -ida_kernwin.ADF_NO_UNDO (variable) - the action does not create an undo point. useful for actions that do not modify - the database. +ida_kernwin.ADF_NO_UNDO + the action does not create an undo point. useful for actions that do not modify the database. + -ida_kernwin.ADF_OT_MASK (variable) +ida_kernwin.ADF_OT_MASK Owner type mask. -ida_kernwin.ADF_OT_PLUGIN (variable) +ida_kernwin.ADF_OT_PLUGIN Owner is a plugin_t. -ida_kernwin.ADF_OT_PLUGMOD (variable) +ida_kernwin.ADF_OT_PLUGMOD Owner is a plugmod_t. -ida_kernwin.ADF_OT_PROCMOD (variable) +ida_kernwin.ADF_OT_PROCMOD Owner is a procmod_t. -ida_kernwin.ADF_OWN_HANDLER (variable) - handler is owned by the action; it'll be destroyed when the action is - unregistered. Use DYNACTION_DESC_LITERAL to set this bit. +ida_kernwin.ADF_OWN_HANDLER + handler is owned by the action; it'll be destroyed when the action is unregistered. Use DYNACTION_DESC_LITERAL to set this bit. + -ida_kernwin.AHF_VERSION (variable) +ida_kernwin.AHF_VERSION action handler version (used by action_handler_t::flags) -ida_kernwin.AHF_VERSION_MASK (variable) +ida_kernwin.AHF_VERSION_MASK mask for action_handler_t::flags -ida_kernwin.ASKBTN_BTN1 (variable) +ida_kernwin.ASKBTN_BTN1 First (Yes) button. -ida_kernwin.ASKBTN_BTN2 (variable) +ida_kernwin.ASKBTN_BTN2 Second (No) button. -ida_kernwin.ASKBTN_BTN3 (variable) +ida_kernwin.ASKBTN_BTN3 Third (Cancel) button. -ida_kernwin.ASKBTN_CANCEL (variable) +ida_kernwin.ASKBTN_CANCEL Cancel button. -ida_kernwin.ASKBTN_NO (variable) +ida_kernwin.ASKBTN_NO No button. -ida_kernwin.ASKBTN_YES (variable) +ida_kernwin.ASKBTN_YES Yes button. -ida_kernwin.AST_DISABLE (variable) +ida_kernwin.AST_DISABLE analog of AST_ENABLE -ida_kernwin.AST_DISABLE_ALWAYS (variable) +ida_kernwin.AST_DISABLE_ALWAYS disable action and do not call action_handler_t::action() anymore -ida_kernwin.AST_DISABLE_FOR_IDB (variable) +ida_kernwin.AST_DISABLE_FOR_IDB analog of AST_ENABLE_FOR_IDB -ida_kernwin.AST_DISABLE_FOR_WIDGET (variable) +ida_kernwin.AST_DISABLE_FOR_WIDGET analog of AST_ENABLE_FOR_WIDGET -ida_kernwin.AST_ENABLE (variable) +ida_kernwin.AST_ENABLE enable action - call action_handler_t::update() when anything changes -ida_kernwin.AST_ENABLE_ALWAYS (variable) +ida_kernwin.AST_ENABLE_ALWAYS enable action and do not call action_handler_t::update() anymore -ida_kernwin.AST_ENABLE_FOR_IDB (variable) - enable action for the current idb. call action_handler_t::update() when a - database is opened/closed +ida_kernwin.AST_ENABLE_FOR_IDB + enable action for the current idb. call action_handler_t::update() when a database is opened/closed + -ida_kernwin.AST_ENABLE_FOR_WIDGET (variable) - enable action for the current widget. call action_handler_t::update() when a - widget gets/loses focus +ida_kernwin.AST_ENABLE_FOR_WIDGET + enable action for the current widget. call action_handler_t::update() when a widget gets/loses focus + -ida_kernwin.BWN_ADDRWATCH (variable) +ida_kernwin.BWN_ADDRWATCH the 'Watch List' window -ida_kernwin.BWN_BOOKMARKS (variable) +ida_kernwin.BWN_BOOKMARKS a persistent 'Bookmarks' widget -ida_kernwin.BWN_BPTS (variable) +ida_kernwin.BWN_BPTS breakpoints -ida_kernwin.BWN_CALLS (variable) +ida_kernwin.BWN_CALLS function calls -ida_kernwin.BWN_CALLS_CALLEES (variable) +ida_kernwin.BWN_CALLS_CALLEES function calls, callees -ida_kernwin.BWN_CALLS_CALLERS (variable) +ida_kernwin.BWN_CALLS_CALLERS function calls, callers -ida_kernwin.BWN_CALL_STACK (variable) +ida_kernwin.BWN_CALL_STACK call stack -ida_kernwin.BWN_CHOOSER (variable) +ida_kernwin.BWN_CHOOSER a non-builtin chooser -ida_kernwin.BWN_CLI (variable) +ida_kernwin.BWN_CLI the command-line, in the output window -ida_kernwin.BWN_CMDPALCSR (variable) +ida_kernwin.BWN_CMDPALCSR the command palette chooser (Qt version only) -ida_kernwin.BWN_CMDPALWIN (variable) +ida_kernwin.BWN_CMDPALWIN the command palette window (Qt version only) -ida_kernwin.BWN_CPUREGS (variable) +ida_kernwin.BWN_CPUREGS one of the 'General registers', 'FPU register', ... debugger windows -ida_kernwin.BWN_CUSTVIEW (variable) +ida_kernwin.BWN_CUSTVIEW custom viewers -ida_kernwin.BWN_CV_LINE_INFOS (variable) +ida_kernwin.BWN_CV_LINE_INFOS custom viewers' lineinfo widget -ida_kernwin.BWN_DISASM (variable) +ida_kernwin.BWN_DISASM disassembly views -ida_kernwin.BWN_DISASMS (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_DISASM_ARROWS (variable) +ida_kernwin.BWN_DISASM_ARROWS disassembly arrows widget -ida_kernwin.BWN_DUMP (variable) - hex dumps - -ida_kernwin.BWN_DUMPS (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_ENUMS (variable) - enumerations - -ida_kernwin.BWN_EXPORTS (variable) +ida_kernwin.BWN_EXPORTS exports -ida_kernwin.BWN_FRAME (variable) +ida_kernwin.BWN_FRAME function frame -ida_kernwin.BWN_FUNCS (variable) +ida_kernwin.BWN_FUNCS functions -ida_kernwin.BWN_IMPORTS (variable) +ida_kernwin.BWN_HEXVIEW + hex view + +ida_kernwin.BWN_IMPORTS imports -ida_kernwin.BWN_LOCALS (variable) +ida_kernwin.BWN_LOCALS the 'locals' debugger window -ida_kernwin.BWN_LOCTYPS (variable) - local types - -ida_kernwin.BWN_MDVIEWCSR (variable) +ida_kernwin.BWN_MDVIEWCSR lumina metadata view chooser -ida_kernwin.BWN_MODULES (variable) +ida_kernwin.BWN_MODULES modules -ida_kernwin.BWN_NAMES (variable) +ida_kernwin.BWN_NAMES names -ida_kernwin.BWN_NAVBAND (variable) +ida_kernwin.BWN_NAVBAND navigation band -ida_kernwin.BWN_NOTEPAD (variable) +ida_kernwin.BWN_NOTEPAD notepad -ida_kernwin.BWN_OUTPUT (variable) +ida_kernwin.BWN_OUTPUT the text area, in the output window -ida_kernwin.BWN_PROBS (variable) +ida_kernwin.BWN_PROBS problems -ida_kernwin.BWN_PSEUDOCODE (variable) +ida_kernwin.BWN_PSEUDOCODE hexrays decompiler views -ida_kernwin.BWN_SCRIPTS_CSR (variable) +ida_kernwin.BWN_SCRIPTS_CSR the "Recent scripts" chooser -ida_kernwin.BWN_SEARCH (variable) +ida_kernwin.BWN_SEARCH search results -ida_kernwin.BWN_SEARCHS (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_SEGREGS (variable) +ida_kernwin.BWN_SEGREGS segment registers -ida_kernwin.BWN_SEGS (variable) +ida_kernwin.BWN_SEGS segments -ida_kernwin.BWN_SELS (variable) +ida_kernwin.BWN_SELS selectors -ida_kernwin.BWN_SHORTCUTCSR (variable) +ida_kernwin.BWN_SHORTCUTCSR the shortcuts chooser (Qt version only) -ida_kernwin.BWN_SHORTCUTWIN (variable) +ida_kernwin.BWN_SHORTCUTWIN the shortcuts window (Qt version only) -ida_kernwin.BWN_SIGNS (variable) +ida_kernwin.BWN_SIGNS signatures -ida_kernwin.BWN_SNIPPETS (variable) +ida_kernwin.BWN_SNIPPETS the 'Execute script' window -ida_kernwin.BWN_SNIPPETS_CSR (variable) +ida_kernwin.BWN_SNIPPETS_CSR the list of snippets in the 'Execute script' window -ida_kernwin.BWN_SO_OFFSETS (variable) +ida_kernwin.BWN_SO_OFFSETS the 'Structure offsets' dialog's offset panel -ida_kernwin.BWN_SO_STRUCTS (variable) +ida_kernwin.BWN_SO_STRUCTS the 'Structure offsets' dialog's 'Structures and Unions' panel -ida_kernwin.BWN_SRCPTHMAP_CSR (variable) +ida_kernwin.BWN_SRCPTHMAP_CSR "Source paths..."'s path mappings chooser -ida_kernwin.BWN_SRCPTHUND_CSR (variable) +ida_kernwin.BWN_SRCPTHUND_CSR "Source paths..."'s undesired paths chooser -ida_kernwin.BWN_STACK (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_STKVIEW (variable) +ida_kernwin.BWN_STKVIEW the 'Stack view' debugger window -ida_kernwin.BWN_STRINGS (variable) +ida_kernwin.BWN_STRINGS strings -ida_kernwin.BWN_STRUCTS (variable) - structures - -ida_kernwin.BWN_THREADS (variable) +ida_kernwin.BWN_THREADS threads -ida_kernwin.BWN_TILIST (variable) - a types listing widget +ida_kernwin.BWN_TICSR + type library widget's (e.g., "Local types") chooser -ida_kernwin.BWN_TILS (variable) +ida_kernwin.BWN_TILIST + a type listing widget + +ida_kernwin.BWN_TILS type libraries -ida_kernwin.BWN_TRACE (variable) +ida_kernwin.BWN_TIL_VIEW + a type library's toplevel widget + +ida_kernwin.BWN_TRACE tracing view -ida_kernwin.BWN_UNDOHIST (variable) +ida_kernwin.BWN_UNDOHIST Undo history. -ida_kernwin.BWN_UNKNOWN (variable) +ida_kernwin.BWN_UNKNOWN unknown window -ida_kernwin.BWN_WATCH (variable) +ida_kernwin.BWN_WATCH the 'watches' debugger window -ida_kernwin.BWN_XREFS (variable) +ida_kernwin.BWN_XREFS xrefs -ida_kernwin.CDVF_LINEICONS (variable) +ida_kernwin.CDVF_LINEICONS icons can be drawn over the line control -ida_kernwin.CDVF_NOLINES (variable) +ida_kernwin.CDVF_NOLINES don't show line numbers -ida_kernwin.CDVF_STATUSBAR (variable) +ida_kernwin.CDVF_STATUSBAR keep the status bar in the custom viewer -ida_kernwin.CDVH_LINES_ALIGNMENT (variable) +ida_kernwin.CDVH_LINES_ALIGNMENT see set_code_viewer_lines_alignment() -ida_kernwin.CDVH_LINES_CLICK (variable) +ida_kernwin.CDVH_LINES_CLICK see code_viewer_lines_click_t -ida_kernwin.CDVH_LINES_DBLCLICK (variable) +ida_kernwin.CDVH_LINES_DBLCLICK see code_viewer_lines_click_t -ida_kernwin.CDVH_LINES_DRAWICON (variable) +ida_kernwin.CDVH_LINES_DRAWICON see code_viewer_lines_icon_t -ida_kernwin.CDVH_LINES_ICONMARGIN (variable) +ida_kernwin.CDVH_LINES_ICONMARGIN see set_code_viewer_lines_icon_margin() -ida_kernwin.CDVH_LINES_LINENUM (variable) +ida_kernwin.CDVH_LINES_LINENUM see code_viewer_lines_linenum_t -ida_kernwin.CDVH_LINES_POPUP (variable) +ida_kernwin.CDVH_LINES_POPUP see code_viewer_lines_click_t -ida_kernwin.CDVH_LINES_RADIX (variable) +ida_kernwin.CDVH_LINES_RADIX see set_code_viewer_lines_radix() -ida_kernwin.CDVH_SRCVIEW (variable) +ida_kernwin.CDVH_SRCVIEW see set_code_viewer_is_source() -ida_kernwin.CDVH_USERDATA (variable) +ida_kernwin.CDVH_USERDATA see set_code_viewer_user_data() -ida_kernwin.CH2_LAZY_LOADED (variable) - The chooser is lazy-loaded; it receives the callback do_lazy_load_dir() (only - meaningful when CH_HAS_DIRTREE is set) +ida_kernwin.CH2_LAZY_LOADED + The chooser is lazy-loaded; it receives the callback do_lazy_load_dir() (only meaningful when CH_HAS_DIRTREE is set) + -ida_kernwin.CHCOL_DEC (variable) +ida_kernwin.CHCOL_DEC decimal number -ida_kernwin.CHCOL_DEFHIDDEN (variable) +ida_kernwin.CHCOL_DEFHIDDEN column should be hidden by default -ida_kernwin.CHCOL_DRAGHINT (variable) - the column number that will be used to build hints for the dragging undo label. - This should be provided for at most one column for any given chooser. +ida_kernwin.CHCOL_DRAGHINT + the column number that will be used to build hints for the dragging undo label. This should be provided for at most one column for any given chooser. + -ida_kernwin.CHCOL_EA (variable) +ida_kernwin.CHCOL_EA address -ida_kernwin.CHCOL_FNAME (variable) - function name. If a chooser column has this flag set and implements - chooser_base_t::get_ea(), rows background colors will be automatically set to - match the navigator's "Library function", "Lumina function" and "External - symbol" colors +ida_kernwin.CHCOL_FNAME + function name. If a chooser column has this flag set and implements chooser_base_t::get_ea(), rows background colors will be automatically set to match the navigator's "Library function", "Lumina function" and "External symbol" colors + -ida_kernwin.CHCOL_FORMAT (variable) +ida_kernwin.CHCOL_FORMAT column format mask -ida_kernwin.CHCOL_HEX (variable) +ida_kernwin.CHCOL_HEX hexadecimal number -ida_kernwin.CHCOL_INODENAME (variable) - if CH_HAS_DIRTREE has been specified, this instructs the chooser that this - column shows the inode name. This should be provided for at most one column for - any given chooser. +ida_kernwin.CHCOL_INODENAME + if CH_HAS_DIRTREE has been specified, this instructs the chooser that this column shows the inode name. This should be provided for at most one column for any given chooser. + -ida_kernwin.CHCOL_PATH (variable) - file path. TUI IDA will truncate excessive cell lengths starting at their - beginning, and prepending the resulting text with "..." order to leave the - filename visible +ida_kernwin.CHCOL_PATH + file path. TUI IDA will truncate excessive cell lengths starting at their beginning, and prepending the resulting text with "..." order to leave the filename visible + -ida_kernwin.CHCOL_PLAIN (variable) +ida_kernwin.CHCOL_PLAIN plain string -ida_kernwin.CHITEM_BOLD (variable) +ida_kernwin.CHITEM_BOLD display the item in bold -ida_kernwin.CHITEM_GRAY (variable) +ida_kernwin.CHITEM_GRAY gray out the item -ida_kernwin.CHITEM_ITALIC (variable) +ida_kernwin.CHITEM_ITALIC display the item in italic -ida_kernwin.CHITEM_STRIKE (variable) +ida_kernwin.CHITEM_STRIKE strikeout the item -ida_kernwin.CHITEM_UNDER (variable) +ida_kernwin.CHITEM_UNDER underline the item -ida_kernwin.CHOOSER_NOMAINMENU (variable) +ida_kernwin.CHOOSER_NOMAINMENU do not display main menu -ida_kernwin.CHOOSER_NOSTATUSBAR (variable) +ida_kernwin.CHOOSER_NOSTATUSBAR do not display status bar (obsolete. Use CH_NO_STATUS_BAR instead) -ida_kernwin.CH_ATTRS (variable) +ida_kernwin.CH_ATTRS generate ui_get_chooser_item_attrs (gui only) -ida_kernwin.CH_BUILTIN_MASK (variable) +ida_kernwin.CH_BUILTIN_MASK Mask for builtin chooser numbers. Plugins should not use them. -ida_kernwin.CH_CAN_DEL (variable) +ida_kernwin.CH_CAN_DEL allow to delete existing item(s) -ida_kernwin.CH_CAN_EDIT (variable) +ida_kernwin.CH_CAN_EDIT allow to edit existing item(s) -ida_kernwin.CH_CAN_INS (variable) +ida_kernwin.CH_CAN_INS allow to insert new items -ida_kernwin.CH_CAN_REFRESH (variable) +ida_kernwin.CH_CAN_REFRESH allow to refresh chooser -ida_kernwin.CH_FORCE_DEFAULT (variable) - if a non-modal chooser was already open, change selection to the default one +ida_kernwin.CH_FORCE_DEFAULT + if a non-modal chooser was already open, change selection to the default one + -ida_kernwin.CH_HAS_DIFF (variable) +ida_kernwin.CH_HAS_DIFF The chooser can be used in a diffing/merging workflow. -ida_kernwin.CH_HAS_DIRTREE (variable) - The chooser can provide a dirtree_t, meaning a tree-like structure can be - provided to the user (instead of a flat table) +ida_kernwin.CH_HAS_DIRTREE + The chooser can provide a dirtree_t, meaning a tree-like structure can be provided to the user (instead of a flat table) + -ida_kernwin.CH_KEEP (variable) - The chooser instance's lifecycle is not tied to the lifecycle of the widget - showing its contents. Closing the widget will not destroy the chooser structure. - This allows for, e.g., static global chooser instances that don't need to be - allocated on the heap. Also stack-allocated chooser instances must set this bit. +ida_kernwin.CH_KEEP + The chooser instance's lifecycle is not tied to the lifecycle of the widget showing its contents. Closing the widget will not destroy the chooser structure. This allows for, e.g., static global chooser instances that don't need to be allocated on the heap. Also stack-allocated chooser instances must set this bit. + -ida_kernwin.CH_MODAL (variable) +ida_kernwin.CH_MODAL Modal chooser. -ida_kernwin.CH_MULTI (variable) - The chooser will allow multi-selection (only for GUI choosers). This bit is set - when using the chooser_multi_t structure. +ida_kernwin.CH_MULTI + The chooser will allow multi-selection (only for GUI choosers). This bit is set when using the chooser_multi_t structure. + -ida_kernwin.CH_MULTI_EDIT (variable) +ida_kernwin.CH_MULTI_EDIT Obsolete. -ida_kernwin.CH_NOBTNS (variable) - do not display ok/cancel/help/search buttons. Meaningful only for gui modal - windows because non-modal windows do not have any buttons anyway. Text mode does - not have them neither. +ida_kernwin.CH_NOBTNS + do not display ok/cancel/help/search buttons. Meaningful only for gui modal windows because non-modal windows do not have any buttons anyway. Text mode does not have them neither. + -ida_kernwin.CH_NON_PERSISTED_TREE (variable) - the chooser tree is not persisted (it is not loaded on startup and is not saved - on exit) +ida_kernwin.CH_NON_PERSISTED_TREE + the chooser tree is not persisted (it is not loaded on startup and is not saved on exit) + -ida_kernwin.CH_NO_FILTER (variable) +ida_kernwin.CH_NO_FILTER The chooser will not have filtering abilities. -ida_kernwin.CH_NO_SORT (variable) +ida_kernwin.CH_NO_SORT The chooser will not have sorting abilities. -ida_kernwin.CH_NO_STATUS_BAR (variable) +ida_kernwin.CH_NO_STATUS_BAR don't show a status bar -ida_kernwin.CH_QFLT (variable) +ida_kernwin.CH_QFLT open with quick filter enabled and focused -ida_kernwin.CH_QFTYP_DEFAULT (variable) +ida_kernwin.CH_QFTYP_DEFAULT set quick filtering type to the possible existing default for this chooser -ida_kernwin.CH_QFTYP_FUZZY (variable) +ida_kernwin.CH_QFTYP_FUZZY fuzzy search quick filter type -ida_kernwin.CH_QFTYP_NORMAL (variable) +ida_kernwin.CH_QFTYP_NORMAL normal (i.e., lexicographical) quick filter type -ida_kernwin.CH_QFTYP_REGEX (variable) +ida_kernwin.CH_QFTYP_REGEX regex quick filter type -ida_kernwin.CH_QFTYP_WHOLE_WORDS (variable) +ida_kernwin.CH_QFTYP_WHOLE_WORDS whole words quick filter type -ida_kernwin.CH_RENAME_IS_EDIT (variable) - triggering a 'edit/rename' (i.e., F2 shortcut) on a cell, should call the edit() - callback for the corresponding row. +ida_kernwin.CH_RENAME_IS_EDIT + triggering a 'edit/rename' (i.e., F2 shortcut) on a cell, should call the edit() callback for the corresponding row. + -ida_kernwin.CH_RESTORE (variable) - restore floating position if present (equivalent of WOPN_RESTORE) (GUI version - only) - -ida_kernwin.CH_TM_FOLDERS_ONLY (variable) - chooser will show in folders-only mode - -ida_kernwin.CH_TM_FULL_TREE (variable) - chooser will show in no-tree mode - -ida_kernwin.CH_TM_NO_TREE (variable) - chooser will show up in no-tree mode - -ida_kernwin.CK_EXTRA1 (variable) - extra background overlay #1 - -ida_kernwin.CK_EXTRA10 (variable) - extra background overlay #10 - -ida_kernwin.CK_EXTRA11 (variable) - extra background overlay #11 - -ida_kernwin.CK_EXTRA12 (variable) - extra background overlay #12 - -ida_kernwin.CK_EXTRA13 (variable) - extra background overlay #13 - -ida_kernwin.CK_EXTRA14 (variable) - extra background overlay #14 - -ida_kernwin.CK_EXTRA15 (variable) - extra background overlay #15 - -ida_kernwin.CK_EXTRA16 (variable) - extra background overlay #16 - -ida_kernwin.CK_EXTRA2 (variable) - extra background overlay #2 - -ida_kernwin.CK_EXTRA3 (variable) - extra background overlay #3 - -ida_kernwin.CK_EXTRA4 (variable) - extra background overlay #4 - -ida_kernwin.CK_EXTRA5 (variable) - extra background overlay #5 - -ida_kernwin.CK_EXTRA6 (variable) - extra background overlay #6 - -ida_kernwin.CK_EXTRA7 (variable) - extra background overlay #7 - -ida_kernwin.CK_EXTRA8 (variable) - extra background overlay #8 - -ida_kernwin.CK_EXTRA9 (variable) - extra background overlay #9 - -ida_kernwin.CK_TRACE (variable) - traced address - -ida_kernwin.CK_TRACE_OVL (variable) - overlay trace address - -ida_kernwin.CLNL_FINDCMT (variable) - Search for the comment symbol everywhere in the line, not only at the beginning. - -ida_kernwin.CLNL_LTRIM (variable) - Remove leading space characters. - -ida_kernwin.CLNL_RTRIM (variable) - Remove trailing space characters. - -ida_kernwin.CREATETB_ADV (variable) - toolbar is for 'advanced mode' only - -ida_kernwin.CVH_CLICK (variable) - see custom_viewer_click_t - -ida_kernwin.CVH_CLOSE (variable) - see custom_viewer_close_t - -ida_kernwin.CVH_CURPOS (variable) - see custom_viewer_curpos_t - -ida_kernwin.CVH_DBLCLICK (variable) - see custom_viewer_dblclick_t - -ida_kernwin.CVH_HELP (variable) - see custom_viewer_help_t - -ida_kernwin.CVH_KEYDOWN (variable) - see custom_viewer_keydown_t - -ida_kernwin.CVH_MOUSEMOVE (variable) - see custom_viewer_mouse_moved_t - -ida_kernwin.CVH_POPUP (variable) - see custom_viewer_popup_t - -ida_kernwin.CVH_QT_AWARE (variable) - see set_custom_viewer_qt_aware() - -ida_kernwin.CVLF_USE_MOUSE (variable) - Fetch the location from the mouse, instead of caret in the listing. - -ida_kernwin.CVNF_ACT (variable) - activate (i.e., switch to) the viewer. Activation is performed before the new - lochist_entry_t instance is actually copied to the viewer's lochist_t - (otherwise, if the viewer was invisible its on_location_changed() handler - wouldn't be called.) - -ida_kernwin.CVNF_JUMP (variable) - push the current position in this viewer's lochist_t before going to the new - location - -ida_kernwin.CVNF_LAZY (variable) - try and move the cursor to a line displaying the place_t if possible. This might - disregard the Y position in case of success - -ida_kernwin.Choose (class) - The chooser can be used in a diffing/merging workflow - -ida_kernwin.Choose.ALREADY_EXISTS (variable) - the non-modal chooser with the same data is already open - -ida_kernwin.Choose.Activate (method) - Activates a visible chooser - -ida_kernwin.Choose.AddCommand (method) - -ida_kernwin.Choose.CH_CAN_DEL (variable) - allow to delete existing item(s) - -ida_kernwin.Choose.CH_CAN_EDIT (variable) - allow to edit existing item(s) - -ida_kernwin.Choose.CH_CAN_INS (variable) - allow to insert new items - -ida_kernwin.Choose.CH_CAN_REFRESH (variable) - allow to refresh chooser - -ida_kernwin.Choose.CH_FORCE_DEFAULT (variable) - If a non-modal chooser was already open, change selection to the given - default one - -ida_kernwin.Choose.CH_MODAL (variable) - Modal chooser - -ida_kernwin.Choose.CH_MULTI (variable) - Allow multi selection. - Refer the description of the OnInsertLine(), OnDeleteLine(), - OnEditLine(), OnSelectLine(), OnRefresh(), OnSelectionChange() to - see a difference between single and multi selection callbacks. - -ida_kernwin.Choose.CH_NOIDB (variable) - use the chooser even without an open database, same as x0=-2 - -ida_kernwin.Choose.CH_NO_STATUS_BAR (variable) - don't show a status bar - -ida_kernwin.Choose.CH_QFLT (variable) - open with quick filter enabled and focused - -ida_kernwin.Choose.CH_RENAME_IS_EDIT (variable) - triggering a 'edit/rename' (i.e., F2 shortcut) on a cell, - should call the edit() callback for the corresponding row. - -ida_kernwin.Choose.CH_RESTORE (variable) +ida_kernwin.CH_RESTORE restore floating position if present (equivalent of WOPN_RESTORE) (GUI version only) -ida_kernwin.Choose.Close (method) +ida_kernwin.CH_TM_FOLDERS_ONLY + chooser will show in folders-only mode + +ida_kernwin.CH_TM_FULL_TREE + chooser will show in full-tree mode + +ida_kernwin.CH_TM_NO_TREE + chooser will show in no-tree mode + +ida_kernwin.CK_EXTRA1 + extra background overlay #1 + +ida_kernwin.CK_EXTRA10 + extra background overlay #10 + +ida_kernwin.CK_EXTRA11 + extra background overlay #11 + +ida_kernwin.CK_EXTRA12 + extra background overlay #12 + +ida_kernwin.CK_EXTRA13 + extra background overlay #13 + +ida_kernwin.CK_EXTRA14 + extra background overlay #14 + +ida_kernwin.CK_EXTRA15 + extra background overlay #15 + +ida_kernwin.CK_EXTRA16 + extra background overlay #16 + +ida_kernwin.CK_EXTRA2 + extra background overlay #2 + +ida_kernwin.CK_EXTRA3 + extra background overlay #3 + +ida_kernwin.CK_EXTRA4 + extra background overlay #4 + +ida_kernwin.CK_EXTRA5 + extra background overlay #5 + +ida_kernwin.CK_EXTRA6 + extra background overlay #6 + +ida_kernwin.CK_EXTRA7 + extra background overlay #7 + +ida_kernwin.CK_EXTRA8 + extra background overlay #8 + +ida_kernwin.CK_EXTRA9 + extra background overlay #9 + +ida_kernwin.CK_TRACE + traced address + +ida_kernwin.CK_TRACE_OVL + overlay trace address + +ida_kernwin.CLNL_FINDCMT + Search for the comment symbol everywhere in the line, not only at the beginning. + +ida_kernwin.CLNL_LTRIM + Remove leading space characters. + +ida_kernwin.CLNL_RTRIM + Remove trailing space characters. + +ida_kernwin.CREATETB_ADV + toolbar is for 'advanced mode' only + +ida_kernwin.CVH_CLICK + see custom_viewer_click_t + +ida_kernwin.CVH_CLOSE + see custom_viewer_close_t + +ida_kernwin.CVH_CURPOS + see custom_viewer_curpos_t + +ida_kernwin.CVH_DBLCLICK + see custom_viewer_dblclick_t + +ida_kernwin.CVH_HELP + see custom_viewer_help_t + +ida_kernwin.CVH_KEYDOWN + see custom_viewer_keydown_t + +ida_kernwin.CVH_MOUSEMOVE + see custom_viewer_mouse_moved_t + +ida_kernwin.CVH_POPUP + see custom_viewer_popup_t + +ida_kernwin.CVH_QT_AWARE + see set_custom_viewer_qt_aware() + +ida_kernwin.CVLF_USE_MOUSE + Fetch the location from the mouse, instead of caret in the listing. + +ida_kernwin.CVNF_ACT + activate (i.e., switch to) the viewer. Activation is performed before the new lochist_entry_t instance is actually copied to the viewer's lochist_t (otherwise, if the viewer was invisible its on_location_changed() handler wouldn't be called.) + + +ida_kernwin.CVNF_JUMP + push the current position in this viewer's lochist_t before going to the new location + + +ida_kernwin.CVNF_LAZY + try and move the cursor to a line displaying the place_t if possible. This might disregard the Y position in case of success + + +ida_kernwin.Choose + The chooser can be used in a diffing/merging workflow + +ida_kernwin.Choose.ALREADY_EXISTS + the non-modal chooser with the same data is already open + +ida_kernwin.Choose.Activate(self) + Activates a visible chooser + +ida_kernwin.Choose.AddCommand(self, caption, flags = _ida_kernwin.CHOOSER_POPUP_MENU, menu_index = -1, icon = -1, emb = None, shortcut = None) + +ida_kernwin.Choose.CHCOL_DEC + decimal number + +ida_kernwin.Choose.CHCOL_DEFHIDDEN + column should be hidden by default + +ida_kernwin.Choose.CHCOL_DRAGHINT + the column number that will be used to build hints for the dragging undo label. This should be provided for at most one column for any given chooser. + + +ida_kernwin.Choose.CHCOL_EA + address + +ida_kernwin.Choose.CHCOL_FNAME + function name. If a chooser column has this flag set and implements chooser_base_t::get_ea(), rows background colors will be automatically set to match the navigator's "Library function", "Lumina function" and "External symbol" colors + + +ida_kernwin.Choose.CHCOL_FORMAT + column format mask + +ida_kernwin.Choose.CHCOL_HEX + hexadecimal number + +ida_kernwin.Choose.CHCOL_INODENAME + if CH_HAS_DIRTREE has been specified, this instructs the chooser that this column shows the inode name. This should be provided for at most one column for any given chooser. + + +ida_kernwin.Choose.CHCOL_PATH + file path. TUI IDA will truncate excessive cell lengths starting at their beginning, and prepending the resulting text with "..." order to leave the filename visible + + +ida_kernwin.Choose.CHCOL_PLAIN + plain string + +ida_kernwin.Choose.CH_ATTRS + generate ui_get_chooser_item_attrs (gui only) + +ida_kernwin.Choose.CH_BUILTIN_MASK + Mask for builtin chooser numbers. Plugins should not use them. + +ida_kernwin.Choose.CH_CAN_DEL + allow to delete existing item(s) + +ida_kernwin.Choose.CH_CAN_EDIT + allow to edit existing item(s) + +ida_kernwin.Choose.CH_CAN_INS + allow to insert new items + +ida_kernwin.Choose.CH_CAN_REFRESH + allow to refresh chooser + +ida_kernwin.Choose.CH_FORCE_DEFAULT + if a non-modal chooser was already open, change selection to the default one + + +ida_kernwin.Choose.CH_HAS_DIFF + The chooser can be used in a diffing/merging workflow. + +ida_kernwin.Choose.CH_HAS_DIRTREE + The chooser can provide a dirtree_t, meaning a tree-like structure can be provided to the user (instead of a flat table) + + +ida_kernwin.Choose.CH_MODAL + Modal chooser. + +ida_kernwin.Choose.CH_MULTI + The chooser will allow multi-selection (only for GUI choosers). This bit is set when using the chooser_multi_t structure. + + +ida_kernwin.Choose.CH_NOBTNS + do not display ok/cancel/help/search buttons. Meaningful only for gui modal windows because non-modal windows do not have any buttons anyway. Text mode does not have them neither. + + +ida_kernwin.Choose.CH_NOIDB + use the chooser even without an open database, same as x0=-2 + +ida_kernwin.Choose.CH_NO_STATUS_BAR + don't show a status bar + +ida_kernwin.Choose.CH_QFLT + open with quick filter enabled and focused + +ida_kernwin.Choose.CH_QFTYP_DEFAULT + set quick filtering type to the possible existing default for this chooser + +ida_kernwin.Choose.CH_QFTYP_FUZZY + fuzzy search quick filter type + +ida_kernwin.Choose.CH_QFTYP_NORMAL + normal (i.e., lexicographical) quick filter type + +ida_kernwin.Choose.CH_QFTYP_REGEX + regex quick filter type + +ida_kernwin.Choose.CH_QFTYP_WHOLE_WORDS + whole words quick filter type + +ida_kernwin.Choose.CH_RENAME_IS_EDIT + triggering a 'edit/rename' (i.e., F2 shortcut) on a cell, should call the edit() callback for the corresponding row. + + +ida_kernwin.Choose.CH_RESTORE + restore floating position if present (equivalent of WOPN_RESTORE) (GUI version only) + +ida_kernwin.Choose.Close(self) Closes the chooser -ida_kernwin.Choose.EMPTY_CHOOSER (variable) +ida_kernwin.Choose.EMPTY_CHOOSER the chooser is initialized -ida_kernwin.Choose.Embedded (method) +ida_kernwin.Choose.Embedded(self, create_chobj = False) Creates an embedded chooser (as opposed to Show()) @return: Returns 0 on success or NO_ATTR -ida_kernwin.Choose.GetEmbSelection (method) +ida_kernwin.Choose.GetEmbSelection(self) Deprecated. For embedded choosers, the selection is available through 'Form.EmbeddedChooserControl.selection' -ida_kernwin.Choose.GetWidget (method) +ida_kernwin.Choose.GetWidget(self) Return the TWidget underlying this view. @return: The TWidget underlying this view, or None. -ida_kernwin.Choose.NO_ATTR (variable) +ida_kernwin.Choose.NO_ATTR some mandatory attribute is missing -ida_kernwin.Choose.NO_SELECTION (variable) +ida_kernwin.Choose.NO_SELECTION there is no selected item -ida_kernwin.Choose.OnClose (method) +ida_kernwin.Choose.OnClose(self) The chooser window is closed. -ida_kernwin.Choose.OnDeleteLine (method) +ida_kernwin.Choose.OnDeleteLine(self, sel) User deleted an element - @param sel: the current selection - @return: a tuple (changed, selection) + @param sel the current selection + @return a tuple (changed, selection) -ida_kernwin.Choose.OnEditLine (method) +ida_kernwin.Choose.OnEditLine(self, sel) User asked to edit an element. - @param sel: the current selection - @return: a tuple (changed, selection) + @param sel the current selection + @return a tuple (changed, selection) -ida_kernwin.Choose.OnGetDirTree (method) +ida_kernwin.Choose.OnGetDirTree(self) Get the dirtree_t that will be used to present a tree-like structure to the user (see CH_HAS_DIRTREE) - @return: the dirtree_t, or None + @return the dirtree_t, or None -ida_kernwin.Choose.OnGetEA (method) +ida_kernwin.Choose.OnGetEA(self, n) Get the address of an element When this function returns valid addresses: @@ -40498,96 +26716,96 @@ ida_kernwin.Choose.OnGetEA (method) * When a selection is present and the user presses `` (`` if the chooser is modal), IDA will jump to that address (through jumpto()) - @param n: element number (0-based) - @return: the effective address, ida_idaapi.BADADDR if the element has no address + @param n element number (0-based) + @return the effective address, ida_idaapi.BADADDR if the element has no address -ida_kernwin.Choose.OnGetIcon (method) +ida_kernwin.Choose.OnGetIcon(self, n) Get an icon to associate with the first cell of an element - @param n: index of the element - @return: an icon ID + @param n index of the element + @return an icon ID -ida_kernwin.Choose.OnGetLine (method) +ida_kernwin.Choose.OnGetLine(self, n) Get data for an element This callback is mandatory - @param n: the index to fetch data for - @return: a list of strings + @param n the index to fetch data for + @return a list of strings -ida_kernwin.Choose.OnGetLineAttr (method) +ida_kernwin.Choose.OnGetLineAttr(self, n) Get attributes for an element - @param n: index of the element - @return: a tuple (color, flags) + @param n index of the element + @return a tuple (color, flags) -ida_kernwin.Choose.OnGetSize (method) +ida_kernwin.Choose.OnGetSize(self) Get the number of elements in the chooser. This callback is mandatory - @return: the number of elements + @return the number of elements -ida_kernwin.Choose.OnIndexToDiffpos (method) +ida_kernwin.Choose.OnIndexToDiffpos(self, n) Map an element index to a diffpos_t This callback is mandatory if CH_HAS_DIFF is specified - @param n: index of the element - @return: the diffpos + @param n index of the element + @return the diffpos -ida_kernwin.Choose.OnIndexToInode (method) +ida_kernwin.Choose.OnIndexToInode(self, n) Map an element index to a dirtree_t inode This callback is mandatory if CH_HAS_DIRTREE is specified - @param n: index of the element - @return: the inode number + @param n index of the element + @return the inode number -ida_kernwin.Choose.OnInit (method) +ida_kernwin.Choose.OnInit(self) Initialize the chooser and populate it. This callback is optional -ida_kernwin.Choose.OnInsertLine (method) +ida_kernwin.Choose.OnInsertLine(self, sel) User asked to insert an element - @param sel: the current selection - @return: a tuple (changed, selection) + @param sel the current selection + @return a tuple (changed, selection) -ida_kernwin.Choose.OnLazyLoadDir (method) +ida_kernwin.Choose.OnLazyLoadDir(self, path) Callback for lazy-loaded, dirtree-based choosers; the function will be called when a folder is expanded and it has not been loaded before. The implementation should use the given dirtree's link() or mkdir() methods to add the folder contents. - @param path: an absolute dirtree path to the directory that is being expanded - @return: success + @param path an absolute dirtree path to the directory that is being expanded + @return success -ida_kernwin.Choose.OnPopup (method) +ida_kernwin.Choose.OnPopup(self, widget, popup_handle) -ida_kernwin.Choose.OnRefresh (method) +ida_kernwin.Choose.OnRefresh(self, sel) The chooser needs to be refreshed. It returns the new positions of the selected items. - @param sel: the current selection - @return: a tuple (changed, selection) + @param sel the current selection + @return a tuple (changed, selection) -ida_kernwin.Choose.OnSelectLine (method) +ida_kernwin.Choose.OnSelectLine(self, sel) User pressed the enter key, or double-clicked a selection - @param sel: the current selection - @return: a tuple (changed, selection) + @param sel the current selection + @return a tuple (changed, selection) -ida_kernwin.Choose.OnSelectionChange (method) +ida_kernwin.Choose.OnSelectionChange(self, sel) Selection changed - @param sel: the new selection + @param sel the new selection -ida_kernwin.Choose.Refresh (method) +ida_kernwin.Choose.Refresh(self) Causes the refresh callback to trigger -ida_kernwin.Choose.Show (method) +ida_kernwin.Choose.Show(self, modal = False) Activates or creates a chooser window @param modal: Display as modal dialog @return: For all choosers it will return NO_ATTR if some mandatory @@ -40599,13 +26817,13 @@ ida_kernwin.Choose.Show (method) For non-modal choosers it will return 0 or ALREADY_EXISTS if the chooser was already open and is active now; -ida_kernwin.Choose.UI_Hooks_Trampoline (class) +ida_kernwin.Choose.UI_Hooks_Trampoline -ida_kernwin.Choose.UI_Hooks_Trampoline.__init__ (method) +ida_kernwin.Choose.UI_Hooks_Trampoline.__init__(self, v) -ida_kernwin.Choose.UI_Hooks_Trampoline.populating_widget_popup (method) +ida_kernwin.Choose.UI_Hooks_Trampoline.populating_widget_popup(self, widget, popup_handle) -ida_kernwin.Choose.__init__ (method) +ida_kernwin.Choose.__init__(self, title, cols, flags = 0, popup_names = None, icon = -1, x1 = -1, y1 = -1, x2 = -1, y2 = -1, deflt = None, embedded = False, width = None, height = None, forbidden_cb = 0, flags2 = 0) Constructs a chooser window. @param title: The chooser title @param cols: a list of colums; each list item is a list of two items @@ -40620,24 +26838,24 @@ ida_kernwin.Choose.__init__ (method) ["Insert", "Delete", "Edit", "Refresh"] @param icon: Icon index (the icon should exist in ida resources or an index to a custom loaded icon) - @param x1: , y1, x2, y2: The default location (for txt-version) + @param x1, y1, x2, y2: The default location (for txt-version) @param embedded: Create as embedded chooser @param width: Embedded chooser width @param height: Embedded chooser height @param forbidden_cb: Explicitly forbidden callbacks -ida_kernwin.Choose.__init__._qccb (function) +ida_kernwin.Choose.__init__._qccb(ctx, cmd_id) -ida_kernwin.Choose.adjust_last_item (method) +ida_kernwin.Choose.adjust_last_item(self, n) Helper for OnDeleteLine() and OnRefresh() callbacks. They can be finished by the following line: return [Choose.ALL_CHANGED] + self.adjust_last_item(n) - @param line: number of the remaining select item + @param: line number of the remaining select item @return: list of selected lines numbers (one element or empty) -ida_kernwin.CustomIDAMemo (class) +ida_kernwin.CustomIDAMemo -ida_kernwin.CustomIDAMemo.CreateGroups (method) +ida_kernwin.CustomIDAMemo.CreateGroups(self, groups_infos) Send a request to modify the graph by creating a (set of) group(s), and perform an animation. @@ -40650,12 +26868,12 @@ ida_kernwin.CustomIDAMemo.CreateGroups (method) @param groups_infos: A list of objects that describe those groups. @return: A [, , ...] list of group nodes, or None (failure). -ida_kernwin.CustomIDAMemo.DelNodesInfos (method) +ida_kernwin.CustomIDAMemo.DelNodesInfos(self, *nodes) Delete the properties for the given node(s). @param nodes: A list of node IDs -ida_kernwin.CustomIDAMemo.DeleteGroups (method) +ida_kernwin.CustomIDAMemo.DeleteGroups(self, groups, new_current = -1) Send a request to delete the specified groups in the graph, and perform an animation. @@ -40663,34 +26881,34 @@ ida_kernwin.CustomIDAMemo.DeleteGroups (method) @param new_current: A node to focus on after the groups have been deleted @return: True on success, False otherwise. -ida_kernwin.CustomIDAMemo.GetCurrentRendererType (method) +ida_kernwin.CustomIDAMemo.GetCurrentRendererType(self) -ida_kernwin.CustomIDAMemo.GetNodeInfo (method) +ida_kernwin.CustomIDAMemo.GetNodeInfo(self, *args) Get the properties for the given node. @param ni: A node_info_t instance @param node: The index of the node. @return: success -ida_kernwin.CustomIDAMemo.GetWidget (method) +ida_kernwin.CustomIDAMemo.GetWidget(self) Return the TWidget underlying this view. @return: The TWidget underlying this view, or None. -ida_kernwin.CustomIDAMemo.GetWidgetAsGraphViewer (method) +ida_kernwin.CustomIDAMemo.GetWidgetAsGraphViewer(self) Return the graph_viewer_t underlying this view. @return: The graph_viewer_t underlying this view, or None. -ida_kernwin.CustomIDAMemo.Refresh (method) +ida_kernwin.CustomIDAMemo.Refresh(self) Refreshes the view. This causes the OnRefresh() to be called -ida_kernwin.CustomIDAMemo.SetCurrentRendererType (method) +ida_kernwin.CustomIDAMemo.SetCurrentRendererType(self, rtype) Set the current view's renderer. @param rtype: The renderer type. Should be one of the idaapi.TCCRT_* values. -ida_kernwin.CustomIDAMemo.SetGroupsVisibility (method) +ida_kernwin.CustomIDAMemo.SetGroupsVisibility(self, groups, expand, new_current = -1) Send a request to expand/collapse the specified groups in the graph, and perform an animation. @@ -40699,7 +26917,7 @@ ida_kernwin.CustomIDAMemo.SetGroupsVisibility (method) @param new_current: A node to focus on after the groups have been expanded/collapsed. @return: True on success, False otherwise. -ida_kernwin.CustomIDAMemo.SetNodeInfo (method) +ida_kernwin.CustomIDAMemo.SetNodeInfo(self, node_index, node_info, flags) Set the properties for the given node. Example usage (set second nodes's bg color to red): @@ -40712,7 +26930,7 @@ ida_kernwin.CustomIDAMemo.SetNodeInfo (method) @param node_info: An idaapi.node_info_t instance. @param flags: An OR'ed value of NIF_* values. -ida_kernwin.CustomIDAMemo.SetNodesInfos (method) +ida_kernwin.CustomIDAMemo.SetNodesInfos(self, values) Set the properties for the given nodes. Example usage (set first three nodes's bg color to purple): @@ -40723,73 +26941,73 @@ ida_kernwin.CustomIDAMemo.SetNodesInfos (method) @param values: A dictionary of 'int -> node_info_t' objects. -ida_kernwin.CustomIDAMemo._OnBind (method) +ida_kernwin.CustomIDAMemo._OnBind(self, hook) -ida_kernwin.CustomIDAMemo.__init__ (method) +ida_kernwin.CustomIDAMemo.__init__(self) -ida_kernwin.CustomIDAMemo._dummy_cb (method) +ida_kernwin.CustomIDAMemo._dummy_cb(*args) -ida_kernwin.CustomIDAMemo._get_cb (method) +ida_kernwin.CustomIDAMemo._get_cb(self, view, cb_name) -ida_kernwin.CustomIDAMemo._get_cb_arity (method) +ida_kernwin.CustomIDAMemo._get_cb_arity(self, cb) -ida_kernwin.CustomIDAMemo._graph_item_tuple (method) +ida_kernwin.CustomIDAMemo._graph_item_tuple(self, ve) -ida_kernwin.CustomIDAMemo.view_activated (method) +ida_kernwin.CustomIDAMemo.view_activated(self, view) -ida_kernwin.CustomIDAMemo.view_click (method) +ida_kernwin.CustomIDAMemo.view_click(self, view, ve) -ida_kernwin.CustomIDAMemo.view_close (method) +ida_kernwin.CustomIDAMemo.view_close(self, view, *args) -ida_kernwin.CustomIDAMemo.view_curpos (method) +ida_kernwin.CustomIDAMemo.view_curpos(self, view, *args) -ida_kernwin.CustomIDAMemo.view_dblclick (method) +ida_kernwin.CustomIDAMemo.view_dblclick(self, view, ve) -ida_kernwin.CustomIDAMemo.view_deactivated (method) +ida_kernwin.CustomIDAMemo.view_deactivated(self, view) -ida_kernwin.CustomIDAMemo.view_keydown (method) +ida_kernwin.CustomIDAMemo.view_keydown(self, view, key, state) -ida_kernwin.CustomIDAMemo.view_loc_changed (method) +ida_kernwin.CustomIDAMemo.view_loc_changed(self, view, now, was) -ida_kernwin.CustomIDAMemo.view_mouse_moved (method) +ida_kernwin.CustomIDAMemo.view_mouse_moved(self, view, ve) -ida_kernwin.CustomIDAMemo.view_mouse_over (method) +ida_kernwin.CustomIDAMemo.view_mouse_over(self, view, ve) -ida_kernwin.CustomIDAMemo.view_switched (method) +ida_kernwin.CustomIDAMemo.view_switched(self, view, rt) -ida_kernwin.DP_BEFORE (variable) - Place src_form before dst_form in the tab bar instead of after; used with - DP_INSIDE or DP_TAB. +ida_kernwin.DP_BEFORE + Place src_form before dst_form in the tab bar instead of after; used with DP_INSIDE or DP_TAB. + -ida_kernwin.DP_BOTTOM (variable) +ida_kernwin.DP_BOTTOM Dock src_form below dest_form. -ida_kernwin.DP_FLOATING (variable) +ida_kernwin.DP_FLOATING Make src_form floating. -ida_kernwin.DP_INSIDE (variable) +ida_kernwin.DP_INSIDE Create a new tab bar with both src_form and dest_form. -ida_kernwin.DP_LEFT (variable) +ida_kernwin.DP_LEFT Dock src_form to the left of dest_form. -ida_kernwin.DP_RIGHT (variable) +ida_kernwin.DP_RIGHT Dock src_form to the right of dest_form. -ida_kernwin.DP_SZHINT (variable) - When floating or in a splitter (i.e., not tabbed), use the widget's size hint to - determine the best geometry (Qt only) +ida_kernwin.DP_SZHINT + When floating or in a splitter (i.e., not tabbed), use the widget's size hint to determine the best geometry (Qt only) + -ida_kernwin.DP_TAB (variable) - Place src_form into a tab next to dest_form, if dest_form is in a tab bar - (otherwise the same as DP_INSIDE) +ida_kernwin.DP_TAB + Place src_form into a tab next to dest_form, if dest_form is in a tab bar (otherwise the same as DP_INSIDE) + -ida_kernwin.DP_TOP (variable) +ida_kernwin.DP_TOP Dock src_form above dest_form. -ida_kernwin.Form (class) +ida_kernwin.Form -ida_kernwin.Form.Add (method) +ida_kernwin.Form.Add(self, name, ctrl, mkattr = True) Low level function. Prefer AddControls() to this function. This function adds one control to the form. @@ -40797,67 +27015,67 @@ ida_kernwin.Form.Add (method) @param ctrl: Control object @param mkattr: Create control name / control object as a form attribute -ida_kernwin.Form.AddControls (method) +ida_kernwin.Form.AddControls(self, controls, mkattr = True) Adds controls from a dictionary. The dictionary key is the control name and the value is a Form.Control object @param controls: The control dictionary -ida_kernwin.Form.ButtonInput (class) +ida_kernwin.Form.ButtonInput Button control. A handler along with a 'code' (numeric value) can be associated with the button. This way one handler can handle many buttons based on the button code (or in other terms id or tag) -ida_kernwin.Form.ButtonInput.__init__ (method) +ida_kernwin.Form.ButtonInput.__init__(self, handler, code = "", swidth = "", hlp = None) @param handler: Button handler. A callback taking one argument which is the code. @param code: A code associated with the button and that is later passed to the handler. -ida_kernwin.Form.ButtonInput.helper_cb (method) +ida_kernwin.Form.ButtonInput.helper_cb(self, button_code, p_fa) -ida_kernwin.Form.ButtonInput.is_input_field (method) +ida_kernwin.Form.ButtonInput.is_input_field(self) -ida_kernwin.Form.ChkGroupControl (class) +ida_kernwin.Form.ChkGroupControl Checkbox group control class. It holds a set of checkbox controls -ida_kernwin.Form.ChkGroupControl.ItemClass (variable) +ida_kernwin.Form.ChkGroupControl.ItemClass Group control item factory class instance We need this because later we won't be treating ChkGroupControl or RadGroupControl individually, instead we will be working with GroupControl in general. -ida_kernwin.Form.ChkGroupControl.__init__ (method) +ida_kernwin.Form.ChkGroupControl.__init__(self, children_names, value = 0, secondary = False) -ida_kernwin.Form.ChkGroupItemControl (class) +ida_kernwin.Form.ChkGroupItemControl Checkbox group item control -ida_kernwin.Form.ChkGroupItemControl.__get_value (method) +ida_kernwin.Form.ChkGroupItemControl.__get_value(self) -ida_kernwin.Form.ChkGroupItemControl.__init__ (method) +ida_kernwin.Form.ChkGroupItemControl.__init__(self, tag, parent) -ida_kernwin.Form.ChkGroupItemControl.__set_value (method) +ida_kernwin.Form.ChkGroupItemControl.__set_value(self, v) -ida_kernwin.Form.ChkGroupItemControl.checked (variable) +ida_kernwin.Form.ChkGroupItemControl.checked Get/Sets checkbox item check status -ida_kernwin.Form.Close (method) +ida_kernwin.Form.Close(self, close_normally) Close the form - @param close_normally + @param close_normally: 1: form is closed normally as if the user pressed Enter 0: form is closed abnormally as if the user pressed Esc @return: None -ida_kernwin.Form.ColorInput (class) +ida_kernwin.Form.ColorInput Color button input control -ida_kernwin.Form.ColorInput.__init__ (method) +ida_kernwin.Form.ColorInput.__init__(self, value = 0) @param value: Initial color value in RGB -ida_kernwin.Form.Compile (method) +ida_kernwin.Form.Compile(self) Compiles a form and returns the form object (self) and the argument list. The form object will contain object names corresponding to the form elements @return: It will raise an exception on failure. Otherwise the return value is ignored -ida_kernwin.Form.CompileEx (method) +ida_kernwin.Form.CompileEx(self, form) Low level function. Compiles (parses the form syntax and adds the control) the form string and returns the argument list to be passed the argument list to ask_form(). @@ -40871,172 +27089,172 @@ ida_kernwin.Form.CompileEx (method) @param form: Compiles the form and returns the arguments needed to be passed to ask_form() -ida_kernwin.Form.CompileEx.next_control (function) +ida_kernwin.Form.CompileEx.next_control(form, p, first_pass) -ida_kernwin.Form.Compiled (method) +ida_kernwin.Form.Compiled(self) Checks if the form has already been compiled @return: Boolean -ida_kernwin.Form.Control (class) +ida_kernwin.Form.Control -ida_kernwin.Form.Control.__init__ (method) +ida_kernwin.Form.Control.__init__(self) Reference to the parent form. It is filled by Form.Add() -ida_kernwin.Form.Control.free (method) +ida_kernwin.Form.Control.free(self) Free the control -ida_kernwin.Form.Control.get_arg (method) +ida_kernwin.Form.Control.get_arg(self) Control returns the parameter to be pushed on the stack (Of ask_form()) -ida_kernwin.Form.Control.get_tag (method) +ida_kernwin.Form.Control.get_tag(self) Control tag character. One of Form.FT_XXXX. The form class will expand the {} notation and replace them with the tags -ida_kernwin.Form.Control.is_input_field (method) +ida_kernwin.Form.Control.is_input_field(self) Return True if this field acts as an input -ida_kernwin.Form.ControlToFieldTypeIdAndSize (method) +ida_kernwin.Form.ControlToFieldTypeIdAndSize(ctrl) Converts a control object to a tuple containing the field id and the associated buffer size -ida_kernwin.Form.DirInput (class) +ida_kernwin.Form.DirInput Directory browsing control -ida_kernwin.Form.DirInput.__init__ (method) +ida_kernwin.Form.DirInput.__init__(self, width = 512, swidth = 80, hlp = None, value = None) -ida_kernwin.Form.DropdownListControl (class) +ida_kernwin.Form.DropdownListControl Dropdown control This control allows manipulating a dropdown control -ida_kernwin.Form.DropdownListControl.__get_selval (method) +ida_kernwin.Form.DropdownListControl.__get_selval(self) -ida_kernwin.Form.DropdownListControl.__init__ (method) +ida_kernwin.Form.DropdownListControl.__init__(self, items = [], readonly = True, selval = 0, width = 50, swidth = 50, hlp = None) @param items: A string list of items used to prepopulate the control @param readonly: Specifies whether the dropdown list is editable or not @param selval: The preselected item index (when readonly) or text value (when editable) @param width: the control width (n/a if the dropdown list is readonly) @param swidth: string width -ida_kernwin.Form.DropdownListControl.__set_selval (method) +ida_kernwin.Form.DropdownListControl.__set_selval(self, val) -ida_kernwin.Form.DropdownListControl.free (method) +ida_kernwin.Form.DropdownListControl.free(self) -ida_kernwin.Form.DropdownListControl.selval (variable) +ida_kernwin.Form.DropdownListControl.selval Read/write the selection value. The value is used as an item index in readonly mode or text value in editable mode This value can be used only after the form has been closed. -ida_kernwin.Form.DropdownListControl.set_items (method) +ida_kernwin.Form.DropdownListControl.set_items(self, items) Sets the dropdown list items -ida_kernwin.Form.EmbeddedChooserControl (class) +ida_kernwin.Form.EmbeddedChooserControl Embedded chooser control. This control links to a Chooser2 control created with the 'embedded=True' -ida_kernwin.Form.EmbeddedChooserControl.__get_selection__ (method) +ida_kernwin.Form.EmbeddedChooserControl.__get_selection__(self) -ida_kernwin.Form.EmbeddedChooserControl.__init__ (method) +ida_kernwin.Form.EmbeddedChooserControl.__init__(self, chooser = None, swidth = 40, hlp = None) Embedded chooser control @param chooser: A chooser2 instance (must be constructed with 'embedded=True') -ida_kernwin.Form.EmbeddedChooserControl.free (method) +ida_kernwin.Form.EmbeddedChooserControl.free(self) Frees the embedded chooser data -ida_kernwin.Form.EmbeddedChooserControl.selection (variable) +ida_kernwin.Form.EmbeddedChooserControl.selection Returns the selection -ida_kernwin.Form.EmbeddedChooserControl.value (variable) +ida_kernwin.Form.EmbeddedChooserControl.value Returns the embedded chooser instance -ida_kernwin.Form.EnableField (method) +ida_kernwin.Form.EnableField(self, ctrl, enable) Enable or disable an input field @return: False - no such control -ida_kernwin.Form.Execute (method) +ida_kernwin.Form.Execute(self) Displays a modal dialog containing the compiled form. @return: 1 - ok ; 0 - cancel -ida_kernwin.Form.FT_ADDR (variable) +ida_kernwin.Form.FT_ADDR Address - ea_t * -ida_kernwin.Form.FT_ASCII (variable) +ida_kernwin.Form.FT_ASCII Ascii string - char * -ida_kernwin.Form.FT_BIN (variable) +ida_kernwin.Form.FT_BIN Binary number, 0b prefix - sval_t * -ida_kernwin.Form.FT_BUTTON (variable) +ida_kernwin.Form.FT_BUTTON Button - def handler(code) -ida_kernwin.Form.FT_CHAR (variable) +ida_kernwin.Form.FT_CHAR Char value -- sval_t * -ida_kernwin.Form.FT_COLOR (variable) +ida_kernwin.Form.FT_COLOR Color button - bgcolor_t * -ida_kernwin.Form.FT_DEC (variable) +ida_kernwin.Form.FT_DEC Decimal number - sval_t * -ida_kernwin.Form.FT_DIR (variable) +ida_kernwin.Form.FT_DIR Path to directory - char * at least QMAXPATH -ida_kernwin.Form.FT_DROPDOWN_LIST (variable) +ida_kernwin.Form.FT_DROPDOWN_LIST Dropdown list control - Form.DropdownControl -ida_kernwin.Form.FT_ECHOOSER (variable) +ida_kernwin.Form.FT_ECHOOSER Embedded chooser - idaapi.Choose -ida_kernwin.Form.FT_FILE (variable) +ida_kernwin.Form.FT_FILE File browse - char * at least QMAXPATH -ida_kernwin.Form.FT_FORMCHG (variable) +ida_kernwin.Form.FT_FORMCHG Form change callback - formchgcb_t -ida_kernwin.Form.FT_HEX (variable) +ida_kernwin.Form.FT_HEX Hex number - uval_t * -ida_kernwin.Form.FT_HTML_LABEL (variable) +ida_kernwin.Form.FT_HTML_LABEL HTML label to display (only for GUI version, and for dynamic labels; no input) -ida_kernwin.Form.FT_IDENT (variable) +ida_kernwin.Form.FT_IDENT Identifier - char * at least MAXNAMELEN -ida_kernwin.Form.FT_INT64 (variable) +ida_kernwin.Form.FT_INT64 default base int64 - int64 -ida_kernwin.Form.FT_MULTI_LINE_TEXT (variable) +ida_kernwin.Form.FT_MULTI_LINE_TEXT Multi text control - textctrl_info_t -ida_kernwin.Form.FT_OCT (variable) +ida_kernwin.Form.FT_OCT Octal number, C notation - sval_t * -ida_kernwin.Form.FT_RAWHEX (variable) +ida_kernwin.Form.FT_RAWHEX Hex number, no 0x prefix - uval_t * -ida_kernwin.Form.FT_SEG (variable) +ida_kernwin.Form.FT_SEG Segment - sel_t * -ida_kernwin.Form.FT_SHEX (variable) +ida_kernwin.Form.FT_SHEX Signed hex number - sval_t * -ida_kernwin.Form.FT_TYPE (variable) +ida_kernwin.Form.FT_TYPE Type declaration - char * at least MAXSTR -ida_kernwin.Form.FT_UINT64 (variable) +ida_kernwin.Form.FT_UINT64 default base uint64 - uint64 -ida_kernwin.Form.FileInput (class) +ida_kernwin.Form.FileInput File Open/Save input control -ida_kernwin.Form.FileInput.__init__ (method) +ida_kernwin.Form.FileInput.__init__(self, width = 512, swidth = 80, save = False, open = False, hlp = None, value = None) -ida_kernwin.Form.FindControlById (method) +ida_kernwin.Form.FindControlById(self, id) Finds a control instance given its id -ida_kernwin.Form.FormChangeCb (class) +ida_kernwin.Form.FormChangeCb Form change handler. This can be thought of like a dialog procedure. Everytime a form action occurs, this handler will be called along with the control id. @@ -41049,185 +27267,186 @@ ida_kernwin.Form.FormChangeCb (class) Special control IDs: -1 (The form is initialized) and -2 (Ok has been clicked) -ida_kernwin.Form.FormChangeCb.__init__ (method) +ida_kernwin.Form.FormChangeCb.__init__(self, handler) Constructs the handler. @param handler: The handler (preferrably a member function of a class derived from the Form class). -ida_kernwin.Form.FormChangeCb.free (method) +ida_kernwin.Form.FormChangeCb.free(self) -ida_kernwin.Form.FormChangeCb.get_tag (method) +ida_kernwin.Form.FormChangeCb.get_tag(self) -ida_kernwin.Form.FormChangeCb.helper_cb (method) +ida_kernwin.Form.FormChangeCb.helper_cb(self, fid, p_fa) -ida_kernwin.Form.Free (method) +ida_kernwin.Form.Free(self) Frees all resources associated with a compiled form. Make sure you call this function when you finish using the form. -ida_kernwin.Form.GetControlValue (method) +ida_kernwin.Form.GetControlValue(self, ctrl) Returns the control's value depending on its type @param ctrl: Form control instance - @return: - color button, radio controls: integer + @return: + - color button, radio controls: integer - file/dir input, string input and string label: string - embedded chooser control (0-based indices of selected items): integer list - for multilinetext control: textctrl_info_t - dropdown list controls: string (when editable) or index (when readonly) - None: on failure -ida_kernwin.Form.GetFocusedField (method) +ida_kernwin.Form.GetFocusedField(self) Get currently focused input field. @return: None if no field is selected otherwise the control ID -ida_kernwin.Form.GroupControl (class) +ida_kernwin.Form.GroupControl Base class for group controls -ida_kernwin.Form.GroupControl.__init__ (method) +ida_kernwin.Form.GroupControl.__init__(self, children_names, tag, value = 0) -ida_kernwin.Form.GroupControl._reset (method) +ida_kernwin.Form.GroupControl._reset(self) -ida_kernwin.Form.GroupControl.get_tag (method) +ida_kernwin.Form.GroupControl.get_tag(self) -ida_kernwin.Form.GroupControl.next_child_pos (method) +ida_kernwin.Form.GroupControl.next_child_pos(self) -ida_kernwin.Form.GroupItemControl (class) +ida_kernwin.Form.GroupItemControl Base class for group control items -ida_kernwin.Form.GroupItemControl.__init__ (method) +ida_kernwin.Form.GroupItemControl.__init__(self, tag, parent) -ida_kernwin.Form.GroupItemControl.assign_pos (method) +ida_kernwin.Form.GroupItemControl.assign_pos(self) -ida_kernwin.Form.GroupItemControl.get_tag (method) +ida_kernwin.Form.GroupItemControl.get_tag(self) -ida_kernwin.Form.GroupItemControl.is_input_field (method) +ida_kernwin.Form.GroupItemControl.is_input_field(self) -ida_kernwin.Form.InputControl (class) +ida_kernwin.Form.InputControl Generic form input control. It could be numeric control, string control, directory/file browsing, etc... -ida_kernwin.Form.InputControl.__init__ (method) +ida_kernwin.Form.InputControl.__init__(self, tp, width, swidth, hlp = None, is_relative_offset = False) @param width: The maximum possible number of characters that can be entered into the input field @param swidth: The width of visible part of the input field -ida_kernwin.Form.InputControl.get_tag (method) +ida_kernwin.Form.InputControl.get_tag(self) -ida_kernwin.Form.InputControl.is_input_field (method) +ida_kernwin.Form.InputControl.is_input_field(self) -ida_kernwin.Form.LabelControl (class) +ida_kernwin.Form.LabelControl Base class for static label control -ida_kernwin.Form.LabelControl.__init__ (method) +ida_kernwin.Form.LabelControl.__init__(self, tp) -ida_kernwin.Form.LabelControl.get_tag (method) +ida_kernwin.Form.LabelControl.get_tag(self) -ida_kernwin.Form.MoveField (method) +ida_kernwin.Form.MoveField(self, ctrl, x, y, w, h) Move/resize an input field @return: False - no such fiel -ida_kernwin.Form.MultiLineTextControl (class) +ida_kernwin.Form.MultiLineTextControl Multi line text control. This class inherits from textctrl_info_t. Thus the attributes are also inherited This control allows manipulating a multilinetext control -ida_kernwin.Form.MultiLineTextControl.__init__ (method) +ida_kernwin.Form.MultiLineTextControl.__init__(self, text = "", flags = 0, tabsize = 0, width = 50, swidth = 50, hlp = None) @param text: Initial text value @param flags: One of textctrl_info_t.TXTF_.... values @param tabsize: Tab size @param width: Display width @param swidth: String width -ida_kernwin.Form.MultiLineTextControl.free (method) +ida_kernwin.Form.MultiLineTextControl.free(self) -ida_kernwin.Form.NumericArgument (class) +ida_kernwin.Form.NumericArgument Argument representing various integer arguments (ushort, uint32, uint64, etc...) @param tp: One of Form.FT_XXX -ida_kernwin.Form.NumericArgument.__init__ (method) +ida_kernwin.Form.NumericArgument.__init__(self, tp, value, i64 = None) -ida_kernwin.Form.NumericArgument.__set_value (method) +ida_kernwin.Form.NumericArgument.__set_value(self, v) -ida_kernwin.Form.NumericInput (class) +ida_kernwin.Form.NumericInput A composite class serving as a base numeric input control class -ida_kernwin.Form.NumericInput.__init__ (method) +ida_kernwin.Form.NumericInput.__init__(self, tp = None, value = 0, width = 50, swidth = 10, hlp = None, is_relative_offset = False, i64 = None) -ida_kernwin.Form.NumericLabel (class) +ida_kernwin.Form.NumericLabel Numeric label control -ida_kernwin.Form.NumericLabel.__init__ (method) +ida_kernwin.Form.NumericLabel.__init__(self, value, tp = None) -ida_kernwin.Form.Open (method) +ida_kernwin.Form.Open(self) Opens a widget containing the compiled form. -ida_kernwin.Form.RadGroupControl (class) +ida_kernwin.Form.RadGroupControl Radiobox group control class. It holds a set of radiobox controls -ida_kernwin.Form.RadGroupControl.__init__ (method) +ida_kernwin.Form.RadGroupControl.__init__(self, children_names, value = 0, secondary = False) Creates a radiogroup control. @param children_names: A tuple containing group item names @param value: Initial selected radio item @param secondory: Allows rendering one the same line as the previous group control. Use this if you have another group control on the same line. -ida_kernwin.Form.RadGroupItemControl (class) +ida_kernwin.Form.RadGroupItemControl Radiobox group item control -ida_kernwin.Form.RadGroupItemControl.__get_value (method) +ida_kernwin.Form.RadGroupItemControl.__get_value(self) -ida_kernwin.Form.RadGroupItemControl.__init__ (method) +ida_kernwin.Form.RadGroupItemControl.__init__(self, tag, parent) -ida_kernwin.Form.RadGroupItemControl.__set_value (method) +ida_kernwin.Form.RadGroupItemControl.__set_value(self, v) -ida_kernwin.Form.RadGroupItemControl.selected (variable) +ida_kernwin.Form.RadGroupItemControl.selected Get/Sets radiobox item selection status -ida_kernwin.Form.RefreshField (method) +ida_kernwin.Form.RefreshField(self, ctrl) Refresh a field @return: False - no such control -ida_kernwin.Form.SetControlValue (method) +ida_kernwin.Form.SetControlValue(self, ctrl, value) Set the control's value depending on its type @param ctrl: Form control instance - @param value + @param value: - embedded chooser: a 0-base indices list to select embedded chooser items - multilinetext: a textctrl_info_t - dropdown list: an integer designating the selection index if readonly a string designating the edit control value if not readonly @return: Boolean true on success -ida_kernwin.Form.SetFocusedField (method) +ida_kernwin.Form.SetFocusedField(self, ctrl) Set currently focused input field @return: False - no such control -ida_kernwin.Form.ShowField (method) +ida_kernwin.Form.ShowField(self, ctrl, show) Show or hide an input field @return: False - no such control -ida_kernwin.Form.StringArgument (class) +ida_kernwin.Form.StringArgument Argument representing a character buffer -ida_kernwin.Form.StringArgument.__get_value (method) +ida_kernwin.Form.StringArgument.__get_value(self) -ida_kernwin.Form.StringArgument.__init__ (method) +ida_kernwin.Form.StringArgument.__init__(self, size = None, value = None) -ida_kernwin.Form.StringArgument.__set_value (method) +ida_kernwin.Form.StringArgument.__set_value(self, v) -ida_kernwin.Form.StringInput (class) +ida_kernwin.Form.StringInput Base string input control class. This class also constructs a StringArgument -ida_kernwin.Form.StringInput.__init__ (method) +ida_kernwin.Form.StringInput.__init__(self, tp = None, width = ida_pro.MAXSTR, swidth = 40, hlp = None, value = None, size = None) @param width: String size. But in some cases it has special meaning. For example in FileInput control. If you want to define the string buffer size then pass the 'size' argument @param swidth: Control width @param value: Initial value @param size: String size -ida_kernwin.Form.StringLabel (class) +ida_kernwin.Form.StringLabel String label control -ida_kernwin.Form.StringLabel.__init__ (method) +ida_kernwin.Form.StringLabel.__init__(self, value, tp = None, size = ida_pro.MAXSTR) Type field can be one of: A - ascii string T - type declaration @@ -41236,118 +27455,117 @@ ida_kernwin.Form.StringLabel.__init__ (method) f - file X - command -ida_kernwin.Form._AddGroup (method) +ida_kernwin.Form._AddGroup(self, Group, mkattr = True) Internal function. This function expands the group item names and creates individual group item controls @param Group: The group class (checkbox or radio group class) -ida_kernwin.Form._ChkCompiled (method) +ida_kernwin.Form._ChkCompiled(self) -ida_kernwin.Form._FT_USHORT (variable) +ida_kernwin.Form._FT_USHORT Unsigned short -ida_kernwin.Form._ParseFormTitle (method) +ida_kernwin.Form._ParseFormTitle(form) Parses the form's title from the form text -ida_kernwin.Form.__getitem__ (method) +ida_kernwin.Form.__getitem__(self, name) Returns a control object by name -ida_kernwin.Form.__init__ (method) +ida_kernwin.Form.__init__(self, form, controls) If non-modal, these flags will be passed to open_form. This is an OR'ed combination of the PluginForm.FORM_* values. -ida_kernwin.Form._reset (method) +ida_kernwin.Form._reset(self) Resets the Form class state variables -ida_kernwin.Form.create_string_buffer (method) +ida_kernwin.Form.create_string_buffer(value, size = None) -ida_kernwin.Form.fieldtype_to_ctype (method) +ida_kernwin.Form.fieldtype_to_ctype(tp, i64 = False) Factory method returning a ctype class corresponding to the field type string -ida_kernwin.GCRF_ALL (variable) +ida_kernwin.GCRF_ALL Return all rows. -ida_kernwin.GCRF_CURRENT (variable) +ida_kernwin.GCRF_CURRENT Return the current row. -ida_kernwin.GCRF_HEADER (variable) +ida_kernwin.GCRF_HEADER Return header texts. -ida_kernwin.GCRF_SELECTION (variable) +ida_kernwin.GCRF_SELECTION Return selected rows. -ida_kernwin.HIF_IDENTIFIER (variable) - text is an identifier (i.e., when searching for the current highlight, - SEARCH_IDENT will be used) +ida_kernwin.HIF_IDENTIFIER + text is an identifier (i.e., when searching for the current highlight, SEARCH_IDENT will be used) -ida_kernwin.HIF_LOCKED (variable) +ida_kernwin.HIF_LOCKED locked; clicking/moving the cursor around doesn't change the highlight -ida_kernwin.HIF_NOCASE (variable) +ida_kernwin.HIF_NOCASE case insensitive -ida_kernwin.HIF_REGISTER (variable) +ida_kernwin.HIF_REGISTER text represents a register (aliases/subregisters will be highlit as well) -ida_kernwin.HIF_SLOT_0 (variable) +ida_kernwin.HIF_SLOT_0 operate on slot 0 -ida_kernwin.HIF_SLOT_1 (variable) +ida_kernwin.HIF_SLOT_1 operate on slot 1 -ida_kernwin.HIF_SLOT_2 (variable) +ida_kernwin.HIF_SLOT_2 operate on slot 2 -ida_kernwin.HIF_SLOT_3 (variable) +ida_kernwin.HIF_SLOT_3 operate on slot 3 -ida_kernwin.HIF_SLOT_4 (variable) +ida_kernwin.HIF_SLOT_4 operate on slot 4 -ida_kernwin.HIF_SLOT_5 (variable) +ida_kernwin.HIF_SLOT_5 operate on slot 5 -ida_kernwin.HIF_SLOT_6 (variable) +ida_kernwin.HIF_SLOT_6 operate on slot 6 -ida_kernwin.HIF_SLOT_7 (variable) +ida_kernwin.HIF_SLOT_7 operate on slot 7 -ida_kernwin.HIF_SLOT_SHIFT (variable) +ida_kernwin.HIF_SLOT_SHIFT position of the 3 top bits specifying which highlight to use -ida_kernwin.HIF_USE_SLOT (variable) +ida_kernwin.HIF_USE_SLOT use the given number, or just use the "floating" highlight -ida_kernwin.HIST_CMD (variable) +ida_kernwin.HIST_CMD commands -ida_kernwin.HIST_CMT (variable) +ida_kernwin.HIST_CMT comments -ida_kernwin.HIST_DIR (variable) +ida_kernwin.HIST_DIR directory names (text version only) -ida_kernwin.HIST_FILE (variable) +ida_kernwin.HIST_FILE file names -ida_kernwin.HIST_IDENT (variable) +ida_kernwin.HIST_IDENT identifiers. usually CPU register names are forbidden -ida_kernwin.HIST_IDENT2 (variable) +ida_kernwin.HIST_IDENT2 identifiers, including CPU register names -ida_kernwin.HIST_SEG (variable) +ida_kernwin.HIST_SEG segment names -ida_kernwin.HIST_SRCH (variable) +ida_kernwin.HIST_SRCH search substrings -ida_kernwin.HIST_TYPE (variable) +ida_kernwin.HIST_TYPE type declarations -ida_kernwin.IDAViewWrapper (class) +ida_kernwin.IDAViewWrapper Deprecated. Use View_Hooks instead. Because the lifecycle of an IDAView is not trivial to track (e.g., a user @@ -41355,1321 +27573,1114 @@ ida_kernwin.IDAViewWrapper (class) bring anything superior to the View_Hooks: quite the contrary, as the latter is much more generic (and better maps IDA's internal model.) -ida_kernwin.IDAViewWrapper.Bind (method) +ida_kernwin.IDAViewWrapper.Bind(self) -ida_kernwin.IDAViewWrapper.Unbind (method) +ida_kernwin.IDAViewWrapper.Unbind(self) -ida_kernwin.IDAViewWrapper.__init__ (method) +ida_kernwin.IDAViewWrapper.__init__(self, title) -ida_kernwin.IDA_DEBUG_ACCESSIBILITY (variable) +ida_kernwin.IDA_DEBUG_ACCESSIBILITY accessibility -ida_kernwin.IDA_DEBUG_ALREADY (variable) +ida_kernwin.IDA_DEBUG_ALREADY already data or code -ida_kernwin.IDA_DEBUG_ALWAYS (variable) +ida_kernwin.IDA_DEBUG_ALWAYS everything -ida_kernwin.IDA_DEBUG_APPCALL (variable) +ida_kernwin.IDA_DEBUG_APPCALL appcall -ida_kernwin.IDA_DEBUG_CHECKMEM (variable) +ida_kernwin.IDA_DEBUG_CHECKMEM check heap consistency -ida_kernwin.IDA_DEBUG_CONFIG (variable) +ida_kernwin.IDA_DEBUG_CONFIG config file -ida_kernwin.IDA_DEBUG_DBGINFO (variable) +ida_kernwin.IDA_DEBUG_DBGINFO handling of debug info (e.g. pdb, dwarf) -ida_kernwin.IDA_DEBUG_DEBUGGER (variable) +ida_kernwin.IDA_DEBUG_DEBUGGER debugger -ida_kernwin.IDA_DEBUG_DEMANGLE (variable) +ida_kernwin.IDA_DEBUG_DEMANGLE demangler -ida_kernwin.IDA_DEBUG_DREFS (variable) +ida_kernwin.IDA_DEBUG_DREFS drefs -ida_kernwin.IDA_DEBUG_FLIRT (variable) +ida_kernwin.IDA_DEBUG_FLIRT flirt -ida_kernwin.IDA_DEBUG_IDP (variable) +ida_kernwin.IDA_DEBUG_IDP idp module -ida_kernwin.IDA_DEBUG_IDS (variable) +ida_kernwin.IDA_DEBUG_IDS ids files -ida_kernwin.IDA_DEBUG_INTERNET (variable) +ida_kernwin.IDA_DEBUG_INTERNET internet connection (for API backward compatibility) -ida_kernwin.IDA_DEBUG_LDR (variable) +ida_kernwin.IDA_DEBUG_LDR ldr module -ida_kernwin.IDA_DEBUG_LICENSE (variable) +ida_kernwin.IDA_DEBUG_LICENSE licensing -ida_kernwin.IDA_DEBUG_LUMINA (variable) +ida_kernwin.IDA_DEBUG_LUMINA lumina related -ida_kernwin.IDA_DEBUG_NETWORK (variable) +ida_kernwin.IDA_DEBUG_NETWORK network -ida_kernwin.IDA_DEBUG_NOTIFY (variable) +ida_kernwin.IDA_DEBUG_NOTIFY show all notifications -ida_kernwin.IDA_DEBUG_OFFSET (variable) +ida_kernwin.IDA_DEBUG_OFFSET offsets -ida_kernwin.IDA_DEBUG_PLUGIN (variable) +ida_kernwin.IDA_DEBUG_PLUGIN plugin module -ida_kernwin.IDA_DEBUG_QUEUE (variable) +ida_kernwin.IDA_DEBUG_QUEUE queue -ida_kernwin.IDA_DEBUG_REGEX (variable) +ida_kernwin.IDA_DEBUG_RANGECB + range-based entities like segments, functions and so on + +ida_kernwin.IDA_DEBUG_REGEX regular expression -ida_kernwin.IDA_DEBUG_ROLLBACK (variable) +ida_kernwin.IDA_DEBUG_ROLLBACK rollback -ida_kernwin.IDA_DEBUG_SIMPLEX (variable) +ida_kernwin.IDA_DEBUG_SIMPLEX full stack analysis -ida_kernwin.IDA_DEBUG_SRCDBG (variable) +ida_kernwin.IDA_DEBUG_SRCDBG source debugging -ida_kernwin.IDA_DEBUG_SUBPROC (variable) +ida_kernwin.IDA_DEBUG_SUBPROC sub process -ida_kernwin.IDA_DEBUG_THEMES (variable) +ida_kernwin.IDA_DEBUG_THEMES themes -ida_kernwin.IDA_DEBUG_TIL (variable) +ida_kernwin.IDA_DEBUG_TIL type system -ida_kernwin.IDCHK_ARG (variable) +ida_kernwin.IDCHK_ARG bad argument(s) -ida_kernwin.IDCHK_KEY (variable) +ida_kernwin.IDCHK_KEY bad hotkey name -ida_kernwin.IDCHK_MAX (variable) +ida_kernwin.IDCHK_MAX too many IDC hotkeys -ida_kernwin.IDCHK_OK (variable) +ida_kernwin.IDCHK_OK ok -ida_kernwin.IWID_ADDRWATCH (variable) - address watches (47) +ida_kernwin.IWID_ADDRWATCH + address watches -ida_kernwin.IWID_ALL (variable) +ida_kernwin.IWID_ALL mask -ida_kernwin.IWID_BOOKMARKS (variable) - bookmarks list (59) +ida_kernwin.IWID_ANY_LISTING + anything that uses a listing widget -ida_kernwin.IWID_BPTS (variable) - breakpoints (13) +ida_kernwin.IWID_BOOKMARKS + bookmarks list -ida_kernwin.IWID_CALLS (variable) - function calls (11) +ida_kernwin.IWID_BPTS + breakpoints -ida_kernwin.IWID_CALLS_CALLEES (variable) - funcalls, callees (50) +ida_kernwin.IWID_CALLS + function calls -ida_kernwin.IWID_CALLS_CALLERS (variable) - funcalls, callers (49) +ida_kernwin.IWID_CALLS_CALLEES + funcalls, callees -ida_kernwin.IWID_CALL_STACK (variable) - call stack (17) +ida_kernwin.IWID_CALLS_CALLERS + funcalls, callers -ida_kernwin.IWID_CHOOSER (variable) - chooser (37) +ida_kernwin.IWID_CALL_STACK + call stack -ida_kernwin.IWID_CLI (variable) - input line (33) +ida_kernwin.IWID_CHOOSER + chooser -ida_kernwin.IWID_CMDPALCSR (variable) - command palette (43) +ida_kernwin.IWID_CLI + input line -ida_kernwin.IWID_CMDPALWIN (variable) - command palette (44) +ida_kernwin.IWID_CMDPALCSR + command palette -ida_kernwin.IWID_CPUREGS (variable) - registers (40) +ida_kernwin.IWID_CMDPALWIN + command palette -ida_kernwin.IWID_CUSTVIEW (variable) - custom viewers (46) +ida_kernwin.IWID_CPUREGS + registers -ida_kernwin.IWID_CV_LINE_INFOS (variable) - lineinfo widget (53) +ida_kernwin.IWID_CUSTVIEW + custom viewers -ida_kernwin.IWID_DISASM (variable) - disassembly views (29) +ida_kernwin.IWID_CV_LINE_INFOS + lineinfo widget -ida_kernwin.IWID_DISASM_ARROWS (variable) - arrows widget (52) +ida_kernwin.IWID_DISASM + disassembly views -ida_kernwin.IWID_DUMP (variable) - hex dumps (30) +ida_kernwin.IWID_DISASM_ARROWS + arrows widget -ida_kernwin.IWID_ENUMS (variable) - enumerations (27) +ida_kernwin.IWID_EA_LISTING + anything that can be used to represent data/code at an address -ida_kernwin.IWID_EXPORTS (variable) - exports (0) +ida_kernwin.IWID_EXPORTS + exports -ida_kernwin.IWID_FRAME (variable) - function frame (25) +ida_kernwin.IWID_FRAME + function frame -ida_kernwin.IWID_FUNCS (variable) - functions (3) +ida_kernwin.IWID_FUNCS + functions -ida_kernwin.IWID_IMPORTS (variable) - imports (1) +ida_kernwin.IWID_HEXVIEW + hex views -ida_kernwin.IWID_LOCALS (variable) - locals (35) +ida_kernwin.IWID_IMPORTS + imports -ida_kernwin.IWID_LOCTYPS (variable) - local types (10) +ida_kernwin.IWID_LOCALS + locals -ida_kernwin.IWID_MDVIEWCSR (variable) - lumina md view (51) +ida_kernwin.IWID_MDVIEWCSR + lumina md view -ida_kernwin.IWID_MODULES (variable) - modules (15) +ida_kernwin.IWID_MODULES + modules -ida_kernwin.IWID_NAMES (variable) - names (2) +ida_kernwin.IWID_NAMES + names -ida_kernwin.IWID_NAVBAND (variable) - navigation band (26) +ida_kernwin.IWID_NAVBAND + navigation band -ida_kernwin.IWID_NOTEPAD (variable) - notepad (31) +ida_kernwin.IWID_NOTEPAD + notepad -ida_kernwin.IWID_OUTPUT (variable) - output (32) +ida_kernwin.IWID_OUTPUT + output -ida_kernwin.IWID_PROBS (variable) - problems (12) +ida_kernwin.IWID_PROBS + problems -ida_kernwin.IWID_PSEUDOCODE (variable) - decompiler (48) +ida_kernwin.IWID_PSEUDOCODE + decompiler -ida_kernwin.IWID_SCRIPTS_CSR (variable) - recent scripts (58) +ida_kernwin.IWID_SCRIPTS_CSR + recent scripts -ida_kernwin.IWID_SEARCH (variable) - search results (19) +ida_kernwin.IWID_SEARCH + search results -ida_kernwin.IWID_SEGREGS (variable) - segment registers (6) +ida_kernwin.IWID_SEGREGS + segment registers -ida_kernwin.IWID_SEGS (variable) - segments (5) +ida_kernwin.IWID_SEGS + segments -ida_kernwin.IWID_SELS (variable) - selectors (7) +ida_kernwin.IWID_SELS + selectors -ida_kernwin.IWID_SHORTCUTCSR (variable) - shortcuts chooser (38) +ida_kernwin.IWID_SHORTCUTCSR + shortcuts chooser -ida_kernwin.IWID_SHORTCUTWIN (variable) - shortcuts window (39) +ida_kernwin.IWID_SHORTCUTWIN + shortcuts window -ida_kernwin.IWID_SIGNS (variable) - signatures (8) +ida_kernwin.IWID_SIGNS + signatures -ida_kernwin.IWID_SNIPPETS (variable) - snippets (45) +ida_kernwin.IWID_SNIPPETS + snippets -ida_kernwin.IWID_SNIPPETS_CSR (variable) - snippets chooser (57) +ida_kernwin.IWID_SNIPPETS_CSR + snippets chooser -ida_kernwin.IWID_SO_OFFSETS (variable) - stroff (42) +ida_kernwin.IWID_SO_OFFSETS + stroff -ida_kernwin.IWID_SO_STRUCTS (variable) - stroff (41) +ida_kernwin.IWID_SO_STRUCTS + stroff -ida_kernwin.IWID_SRCPTHMAP_CSR (variable) - mappings chooser (54) +ida_kernwin.IWID_SRCPTHMAP_CSR + mappings chooser -ida_kernwin.IWID_SRCPTHUND_CSR (variable) - undesired chooser (55) +ida_kernwin.IWID_SRCPTHUND_CSR + undesired chooser -ida_kernwin.IWID_STACK (variable) - Alias. Some IWID_* were confusing, and thus have been renamed. This is to ensure - bw-compat. +ida_kernwin.IWID_STKVIEW + stack view -ida_kernwin.IWID_STKVIEW (variable) - stack view (36) +ida_kernwin.IWID_STRINGS + strings -ida_kernwin.IWID_STRINGS (variable) - strings (4) +ida_kernwin.IWID_THREADS + threads -ida_kernwin.IWID_STRUCTS (variable) - structures (28) +ida_kernwin.IWID_TICSR + type library widget's (e.g., "Local types") chooser -ida_kernwin.IWID_THREADS (variable) - threads (14) +ida_kernwin.IWID_TILIST + type listing -ida_kernwin.IWID_TILIST (variable) - types listing (60) +ida_kernwin.IWID_TILS + type libraries -ida_kernwin.IWID_TILS (variable) - type libraries (9) +ida_kernwin.IWID_TIL_VIEW + type library's toplevel widget -ida_kernwin.IWID_TRACE (variable) - tracing view (16) +ida_kernwin.IWID_TRACE + tracing view -ida_kernwin.IWID_UNDOHIST (variable) - Undo history (56) +ida_kernwin.IWID_UNDOHIST + Undo history. -ida_kernwin.IWID_WATCH (variable) - watches (34) +ida_kernwin.IWID_WATCH + watches -ida_kernwin.IWID_XREFS (variable) - xrefs (18) +ida_kernwin.IWID_XREFS + xrefs -ida_kernwin.LROEF_CPS_RANGE (variable) +ida_kernwin.LROEF_CPS_RANGE background for range of chars -ida_kernwin.LROEF_FULL_LINE (variable) +ida_kernwin.LROEF_FULL_LINE full line background -ida_kernwin.MFF_FAST (variable) - execute code as soon as possible - this mode is ok call ui related functions - that do not query the database. +ida_kernwin.MFF_FAST + Execute code as soon as possible. this mode is ok for calling ui related functions that do not query the database. + -ida_kernwin.MFF_NOWAIT (variable) - Do not wait for the request to be executed. - he caller should ensure that the request is not - destroyed until the execution completes. - if not, the request will be ignored. - the return code of execute_sync() is meaningless - in this case. - This flag can be used to delay the code execution - until the next UI loop run even from the main thread +ida_kernwin.MFF_NOWAIT + Do not wait for the request to be executed. the caller should ensure that the request is not destroyed until the execution completes. if not, the request will be ignored. the request must be created using the 'new' operator to use it with this flag. it can be used in cancel_exec_request(). This flag can be used to delay the code execution until the next UI loop run even from the main thread. + -ida_kernwin.MFF_READ (variable) - execute code only when ida is idle and it is safe to query the database. - this mode is recommended only for code that does not modify the database. - (nb: ida may be in the middle of executing another user request, for example it may be waiting for him to enter values into a modal dialog box) +ida_kernwin.MFF_READ + Execute code only when ida is idle and it is safe to query the database. This mode is recommended only for code that does not modify the database. (nb: ida may be in the middle of executing another user request, for example it may be waiting for him to enter values into a modal dialog box) + -ida_kernwin.MFF_WRITE (variable) - execute code only when ida is idle and it is safe to modify the database. in particular, this flag will suspend execution if there is - a modal dialog box on the screen this mode can be used to call any ida api function. MFF_WRITE implies MFF_READ +ida_kernwin.MFF_WRITE + Execute code only when ida is idle and it is safe to modify the database. in particular, this flag will suspend execution if there is a modal dialog box on the screen. this mode can be used to call any ida api function. MFF_WRITE implies MFF_READ + -ida_kernwin.PCF_EA_CAPABLE (variable) +ida_kernwin.PCF_EA_CAPABLE toea() implementation returns meaningful data -ida_kernwin.PCF_MAKEPLACE_ALLOCATES (variable) - makeplace() returns a freshly allocated (i.e., non-static) instance. All new - code should pass that flag to register_place_class(), and the corresponding - makeplace() class implementation should return new instances. +ida_kernwin.PCF_MAKEPLACE_ALLOCATES + makeplace() returns a freshly allocated (i.e., non-static) instance. All new code should pass that flag to register_place_class(), and the corresponding makeplace() class implementation should return new instances. + -ida_kernwin.PluginForm (class) - PluginForm class. - - This form can be used to host additional controls. Please check the PyQt example. +ida_kernwin.PluginForm + This flag should be used when Close() is called from an event handler -ida_kernwin.PluginForm.Close (method) +ida_kernwin.PluginForm.Close(self, options) Closes the form. @param options: Close options (WCLS_SAVE, WCLS_NO_CONTEXT, ...) @return: None -ida_kernwin.PluginForm.GetWidget (method) +ida_kernwin.PluginForm.GetWidget(self) Return the TWidget underlying this view. @return: The TWidget underlying this view, or None. -ida_kernwin.PluginForm.OnClose (method) +ida_kernwin.PluginForm.OnClose(self, form) Called when the plugin form is closed @return: None -ida_kernwin.PluginForm.OnCreate (method) +ida_kernwin.PluginForm.OnCreate(self, form) This event is called when the plugin form is created. The programmer should populate the form when this event is triggered. @return: None -ida_kernwin.PluginForm.QtWidgetToTWidget (method) +ida_kernwin.PluginForm.QtWidgetToTWidget(w, ctx = sys.modules["__main__"]) Convert a QWidget to a TWidget* to be used by IDA @param ctx: Context. Reference to a module that already imported SIP and QtWidgets modules -ida_kernwin.PluginForm.Show (method) +ida_kernwin.PluginForm.Show(self, caption, options = 0) Creates the form if not was not created or brings to front if it was already created @param caption: The form caption @param options: One of PluginForm.WOPN_ constants -ida_kernwin.PluginForm.TWidgetToPyQtWidget (method) - Convert a TWidget* to a QWidget to be used by PyQt - - @param ctx: Context. Reference to a module that already imported SIP and QtWidgets modules +ida_kernwin.PluginForm.WCLS_DELETE_LATER + assign the deletion of the widget to the UI loop ///< -ida_kernwin.PluginForm.TWidgetToPySideWidget (method) - Use this method to convert a TWidget* to a QWidget to be used by PySide - - @param ctx: Context. Reference to a module that already imported QtWidgets module +ida_kernwin.PluginForm.WCLS_DONT_SAVE_SIZE + don't save size of the window -ida_kernwin.PluginForm.WCLS_DELETE_LATER (variable) - This flag should be used when Close() is called from an event handler +ida_kernwin.PluginForm.WCLS_NO_CONTEXT + don't change the current context (useful for toolbars) -ida_kernwin.PluginForm.WCLS_DONT_SAVE_SIZE (variable) - Don't save size of the window +ida_kernwin.PluginForm.WCLS_SAVE + save state in desktop config -ida_kernwin.PluginForm.WCLS_NO_CONTEXT (variable) - Don't change the current context (useful for toolbars) +ida_kernwin.PluginForm.WOPN_DP_BEFORE + Place widget before dst_form in the tab bar instead of after; used with WOPN_DP_INSIDE and WOPN_DP_TAB + -ida_kernwin.PluginForm.WCLS_SAVE (variable) - Save state in desktop config +ida_kernwin.PluginForm.WOPN_DP_BOTTOM + Dock widget below dest_ctrl. -ida_kernwin.PluginForm.WOPN_DP_BEFORE (variable) - place widget before dst_form in the tab bar instead of after - used with #WOPN_DP_INSIDE and #WOPN_DP_TAB +ida_kernwin.PluginForm.WOPN_DP_FLOATING + Make widget floating. -ida_kernwin.PluginForm.WOPN_DP_BOTTOM (variable) - Dock widget below dest_ctrl +ida_kernwin.PluginForm.WOPN_DP_INSIDE + Create a new tab bar with both widget and dest_ctrl. -ida_kernwin.PluginForm.WOPN_DP_FLOATING (variable) - When floating or in a splitter (i.e., not tabbed), - use the widget's size hint to determine the best - geometry (Qt only) +ida_kernwin.PluginForm.WOPN_DP_LEFT + Dock widget to the left of dest_ctrl. -ida_kernwin.PluginForm.WOPN_DP_INSIDE (variable) - Create a new tab bar with both widget and dest_ctrl +ida_kernwin.PluginForm.WOPN_DP_RIGHT + Dock widget to the right of dest_ctrl. -ida_kernwin.PluginForm.WOPN_DP_LEFT (variable) - Dock widget to the left of dest_ctrl +ida_kernwin.PluginForm.WOPN_DP_SZHINT + when floating or in a splitter (i.e., not tabbed), use the widget's size hint to determine the best geometry (Qt only) + -ida_kernwin.PluginForm.WOPN_DP_RIGHT (variable) - Dock widget to the right of dest_ctrl +ida_kernwin.PluginForm.WOPN_DP_TAB + Place widget into a tab next to dest_ctrl, if dest_ctrl is in a tab bar (otherwise the same as WOPN_DP_INSIDE) + -ida_kernwin.PluginForm.WOPN_DP_SZHINT (variable) - Make widget floating +ida_kernwin.PluginForm.WOPN_DP_TOP + Dock widget above dest_ctrl. -ida_kernwin.PluginForm.WOPN_DP_TAB (variable) - Place widget into a tab next to dest_ctrl, - if dest_ctrl is in a tab bar - (otherwise the same as #WOPN_DP_INSIDE) +ida_kernwin.PluginForm.WOPN_PERSIST + widget will remain available when starting or stopping debugger sessions -ida_kernwin.PluginForm.WOPN_DP_TOP (variable) - Dock widget above dest_ctrl +ida_kernwin.PluginForm.WOPN_RESTORE + if the widget was the only widget in a floating area the last time it was closed, it will be restored as floating, with the same position+size as before + -ida_kernwin.PluginForm.WOPN_PERSIST (variable) - form will persist until explicitly closed with Close() +ida_kernwin.PluginForm.__init__(self) + -ida_kernwin.PluginForm.WOPN_RESTORE (variable) - if the widget is the only widget in a floating area when - it is closed, remember that area's geometry. The next - time that widget is created as floating (i.e., WOPN_DP_FLOATING) - its geometry will be restored (e.g., "Execute script" +ida_kernwin.PluginForm._ensure_widget_deps(ctx) -ida_kernwin.PluginForm.__init__ (method) - -ida_kernwin.PluginForm._ensure_widget_deps (method) - -ida_kernwin.RENADDR_HR (variable) +ida_kernwin.RENADDR_HR dialog for "Pseudocode"; additional flags: * 0x01 Library function - * 0x02 Mark as decompiled + * 0x02 Mark as decompiled + + + -ida_kernwin.RENADDR_IDA (variable) +ida_kernwin.RENADDR_IDA dialog for "IDA View" -ida_kernwin.S2EAOPT_NOCALC (variable) +ida_kernwin.S2EAOPT_NOCALC don't try to interpret string as IDC (or current extlang) expression -ida_kernwin.SETMENU_APP (variable) +ida_kernwin.SETMENU_APP add menu item after the specified path -ida_kernwin.SETMENU_ENSURE_SEP (variable) +ida_kernwin.SETMENU_ENSURE_SEP make sure there is a separator before the action -ida_kernwin.SETMENU_FIRST (variable) +ida_kernwin.SETMENU_FIRST add item to the beginning of menu -ida_kernwin.SETMENU_INS (variable) +ida_kernwin.SETMENU_INS add menu item before the specified path (default) -ida_kernwin.SVF_COPY_LINES (variable) +ida_kernwin.SVF_COPY_LINES keep a local copy of '*lines' -ida_kernwin.SVF_LINES_BYPTR (variable) +ida_kernwin.SVF_LINES_BYPTR remember the 'lines' ptr. do not make a copy of '*lines' -ida_kernwin.TCCPT_ENUMPLACE (variable) - enumplace_t - -ida_kernwin.TCCPT_IDAPLACE (variable) +ida_kernwin.TCCPT_IDAPLACE idaplace_t -ida_kernwin.TCCPT_INVALID (variable) +ida_kernwin.TCCPT_INVALID invalid -ida_kernwin.TCCPT_PLACE (variable) +ida_kernwin.TCCPT_PLACE place_t -ida_kernwin.TCCPT_SIMPLELINE_PLACE (variable) +ida_kernwin.TCCPT_SIMPLELINE_PLACE simpleline_place_t -ida_kernwin.TCCPT_STRUCTPLACE (variable) - structplace_t - -ida_kernwin.TCCPT_TIPLACE (variable) +ida_kernwin.TCCPT_TIPLACE tiplace_t -ida_kernwin.TCCRT_FLAT (variable) +ida_kernwin.TCCRT_FLAT flat view -ida_kernwin.TCCRT_GRAPH (variable) +ida_kernwin.TCCRT_GRAPH graph view -ida_kernwin.TCCRT_INVALID (variable) +ida_kernwin.TCCRT_INVALID invalid -ida_kernwin.TCCRT_PROXIMITY (variable) +ida_kernwin.TCCRT_PROXIMITY proximity view -ida_kernwin.TWidget__from_ptrval__ (function) - TWidget__from_ptrval__(ptrval) -> TWidget * - - @param ptrval: size_t +ida_kernwin.TWidget__from_ptrval__(ptrval: "size_t") -> "TWidget *" -ida_kernwin.UIJMP_ACTIVATE (variable) +ida_kernwin.UIJMP_ACTIVATE activate the new window -ida_kernwin.UIJMP_ANYVIEW (variable) +ida_kernwin.UIJMP_ANYVIEW jump in any ea_t-capable view -ida_kernwin.UIJMP_DONTPUSH (variable) - do not remember the current address in the navigation history +ida_kernwin.UIJMP_DONTPUSH + do not remember the current address in the navigation history + -ida_kernwin.UIJMP_IDAVIEW (variable) +ida_kernwin.UIJMP_IDAVIEW jump in idaview -ida_kernwin.UIJMP_IDAVIEW_NEW (variable) +ida_kernwin.UIJMP_IDAVIEW_NEW jump in new idaview -ida_kernwin.UI_Hooks (class) - Proxy of C++ UI_Hooks class. +ida_kernwin.UI_Hooks -ida_kernwin.UI_Hooks.__disown__ (method) +ida_kernwin.UI_Hooks.__disown__(self) -ida_kernwin.UI_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> UI_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 +ida_kernwin.UI_Hooks.__init__(self, _flags: int = 0, _hkcb_flags: int = 1) -ida_kernwin.UI_Hooks.create_desktop_widget (method) - create_desktop_widget(self, title, cfg) -> PyObject * - create a widget, to be placed in the widget tree (at desktop-creation time.) - +ida_kernwin.UI_Hooks.create_desktop_widget(self, title: str, cfg: "jobj_wrapper_t") -> "PyObject *" + create a widget, to be placed in the widget tree (at desktop-creation time.) + @param title: (const char *) @param cfg: (const jobj_t *) - @return: TWidget * the created widget, or null + @returns TWidget * the created widget, or null -ida_kernwin.UI_Hooks.current_widget_changed (method) - current_widget_changed(self, widget, prev_widget) - The currently-active TWidget changed. - +ida_kernwin.UI_Hooks.current_widget_changed(self, widget: "TWidget *", prev_widget: "TWidget *") -> None + The currently-active TWidget changed. + @param widget: (TWidget *) @param prev_widget: (TWidget *) + @returns void -ida_kernwin.UI_Hooks.database_closed (method) - database_closed(self) - The database has been closed. See also processor_t::closebase, it occurs - earlier. See also ui_initing_database. This is not the same as IDA exiting. If - you need to perform cleanup at the exiting time, use qatexit(). +ida_kernwin.UI_Hooks.database_closed(self) -> None + The database has been closed. See also processor_t::closebase, it occurs earlier. See also ui_initing_database. This is not the same as IDA exiting. If you need to perform cleanup at the exiting time, use qatexit(). + + @returns void -ida_kernwin.UI_Hooks.database_inited (method) - database_inited(self, is_new_database, idc_script) - database initialization has completed. the kernel is about to run idc - scripts - +ida_kernwin.UI_Hooks.database_inited(self, is_new_database: int, idc_script: str) -> None + database initialization has completed. the kernel is about to run idc scripts + @param is_new_database: (int) @param idc_script: (const char *) - may be nullptr - @return: void See also ui_initing_database. This event is called for both new - and old databases. + @returns void See also ui_initing_database. This event is called for both new and old databases. -ida_kernwin.UI_Hooks.debugger_menu_change (method) - debugger_menu_change(self, enable) - debugger menu modification detected - - @param enable: (bool) true: debugger menu has been added, or a different - debugger has been selected false: debugger menu will be removed - (user switched to "No debugger") +ida_kernwin.UI_Hooks.debugger_menu_change(self, enable: bool) -> None + debugger menu modification detected + + @param enable: (bool) true: debugger menu has been added, or a different debugger has been selected false: debugger menu will be removed (user switched to "No debugger") + @returns void -ida_kernwin.UI_Hooks.desktop_applied (method) - desktop_applied(self, name, from_idb, type) - a desktop has been applied - +ida_kernwin.UI_Hooks.desktop_applied(self, name: str, from_idb: bool, type: int) -> None + a desktop has been applied + @param name: (const char *) the desktop name - @param from_idb: (bool) the desktop was stored in the IDB (false if it comes - from the registry) + @param from_idb: (bool) the desktop was stored in the IDB (false if it comes from the registry) @param type: (int) the desktop type (1-disassembly, 2-debugger, 3-merge) -ida_kernwin.UI_Hooks.destroying_plugmod (method) - destroying_plugmod(self, plugmod, entry) - The plugin object is about to be destroyed - +ida_kernwin.UI_Hooks.destroying_plugmod(self, plugmod: "plugmod_t", entry: "plugin_t const *") -> None + The plugin object is about to be destroyed + @param plugmod: (const plugmod_t *) @param entry: (const plugin_t *) -ida_kernwin.UI_Hooks.destroying_procmod (method) - destroying_procmod(self, procmod) - The processor module is about to be destroyed - +ida_kernwin.UI_Hooks.destroying_procmod(self, procmod: "procmod_t") -> None + The processor module is about to be destroyed + @param procmod: (const procmod_t *) -ida_kernwin.UI_Hooks.finish_populating_widget_popup (method) - finish_populating_widget_popup(self, widget, popup_handle, ctx=None) - IDA is about to be done populating the context menu for a widget. This is - your chance to attach_action_to_popup(). +ida_kernwin.UI_Hooks.finish_populating_widget_popup(self, widget: "TWidget *", popup_handle: "TPopupMenu *", ctx: "action_ctx_base_t" = None) -> None + IDA is about to be done populating the context menu for a widget. This is your chance to attach_action_to_popup(). @param widget: (TWidget *) @param popup_handle: (TPopupMenu *) @param ctx: (const action_activation_ctx_t *) + @returns void -ida_kernwin.UI_Hooks.get_chooser_item_attrs (method) - get_chooser_item_attrs(self, chooser, n, attrs) - get item-specific attributes for a chooser. This callback is generated only - after enable_chooser_attrs() - +ida_kernwin.UI_Hooks.get_chooser_item_attrs(self, chooser: "chooser_base_t", n: "size_t", attrs: "chooser_item_attrs_t") -> None + get item-specific attributes for a chooser. This callback is generated only after enable_chooser_attrs() + @param chooser: (const chooser_base_t *) @param n: (::size_t) @param attrs: (chooser_item_attrs_t *) + @returns void -ida_kernwin.UI_Hooks.get_custom_viewer_hint (method) - get_custom_viewer_hint(self, viewer, place) -> PyObject * - ui wants to display a hint for a viewer (idaview or custom). Every - subscriber is supposed to append the hint lines to HINT and increment - IMPORTANT_LINES accordingly. Completely overwriting the existing lines in HINT - is possible but not recommended. If the REG_HINTS_MARKER sequence is found in - the returned hints string, it will be replaced with the contents of the - "regular" hints. If the SRCDBG_HINTS_MARKER sequence is found in the returned - hints string, it will be replaced with the contents of the source-level - debugger-generated hints. The following keywords might appear at the beginning - of the returned hints: HIGHLIGHT text - where text will be highlighted CAPTION caption - caption for the hint widget - +ida_kernwin.UI_Hooks.get_custom_viewer_hint(self, viewer: "TWidget *", place: "place_t") -> "PyObject *" + ui wants to display a hint for a viewer (idaview or custom). Every subscriber is supposed to append the hint lines to HINT and increment IMPORTANT_LINES accordingly. Completely overwriting the existing lines in HINT is possible but not recommended. If the REG_HINTS_MARKER sequence is found in the returned hints string, it will be replaced with the contents of the "regular" hints. If the SRCDBG_HINTS_MARKER sequence is found in the returned hints string, it will be replaced with the contents of the source-level debugger-generated hints. The following keywords might appear at the beginning of the returned hints: HIGHLIGHT text + where text will be highlighted CAPTION caption + caption for the hint widget + @param viewer: (TWidget*) viewer @param place: (place_t *) current position in the viewer @retval 0: continue collecting hints with other subscribers @retval 1: stop collecting hints -ida_kernwin.UI_Hooks.get_ea_hint (method) - get_ea_hint(self, ea) -> PyObject * - ui wants to display a simple hint for an address. Use this event to generate - a custom hint See also more generic ui_get_item_hint - +ida_kernwin.UI_Hooks.get_ea_hint(self, ea: ida_idaapi.ea_t) -> "PyObject *" + ui wants to display a simple hint for an address. Use this event to generate a custom hint See also more generic ui_get_item_hint + @param ea: (::ea_t) - @return: true if generated a hint + @returns true if generated a hint -ida_kernwin.UI_Hooks.get_item_hint (method) - get_item_hint(self, ea, max_lines) -> PyObject * - ui wants to display multiline hint for an item. See also more generic - ui_get_custom_viewer_hint - +ida_kernwin.UI_Hooks.get_item_hint(self, ea: ida_idaapi.ea_t, max_lines: int) -> "PyObject *" + ui wants to display multiline hint for an item. See also more generic ui_get_custom_viewer_hint + @param ea: (ea_t) or item id like a structure or enum member @param max_lines: (int) maximal number of lines - @return: true if generated a hint + @returns true if generated a hint -ida_kernwin.UI_Hooks.get_lines_rendering_info (method) - get_lines_rendering_info(self, out, widget, info) - get lines rendering information - +ida_kernwin.UI_Hooks.get_lines_rendering_info(self, out: "lines_rendering_output_t", widget: "TWidget const *", info: "lines_rendering_input_t") -> None + get lines rendering information + @param out: (lines_rendering_output_t *) @param widget: (const TWidget *) @param info: (const lines_rendering_input_t *) + @returns void -ida_kernwin.UI_Hooks.get_widget_config (method) - get_widget_config(self, widget, cfg) -> PyObject * - retrieve the widget configuration (it will be passed back at - ui_create_desktop_widget-, and ui_set_widget_config-time) - +ida_kernwin.UI_Hooks.get_widget_config(self, widget: "TWidget const *", cfg: "jobj_t *") -> "PyObject *" + retrieve the widget configuration (it will be passed back at ui_create_desktop_widget-, and ui_set_widget_config-time) + @param widget: (const TWidget *) @param cfg: (jobj_t *) + @returns void -ida_kernwin.UI_Hooks.hook (method) - hook(self) -> bool +ida_kernwin.UI_Hooks.hook(self) -> bool -ida_kernwin.UI_Hooks.idcstart (method) - idcstart(self) - Start of IDC engine work. +ida_kernwin.UI_Hooks.idcstart(self) -> None + Start of IDC engine work. + + @returns void -ida_kernwin.UI_Hooks.idcstop (method) - idcstop(self) - Stop of IDC engine work. +ida_kernwin.UI_Hooks.idcstop(self) -> None + Stop of IDC engine work. + + @returns void -ida_kernwin.UI_Hooks.initing_database (method) - initing_database(self) - database initialization has started. - - @return: void See also ui_database_inited. This event is called for both new and - old databases. +ida_kernwin.UI_Hooks.initing_database(self) -> None + database initialization has started. + + @returns void See also ui_database_inited. This event is called for both new and old databases. -ida_kernwin.UI_Hooks.plugin_loaded (method) - plugin_loaded(self, plugin_info) - The plugin was loaded in memory. - +ida_kernwin.UI_Hooks.plugin_loaded(self, plugin_info: "plugin_info_t const *") -> None + The plugin was loaded in memory. + @param plugin_info: (const plugin_info_t *) -ida_kernwin.UI_Hooks.plugin_unloading (method) - plugin_unloading(self, plugin_info) - The plugin is about to be unloaded - +ida_kernwin.UI_Hooks.plugin_unloading(self, plugin_info: "plugin_info_t const *") -> None + The plugin is about to be unloaded + @param plugin_info: (const plugin_info_t *) -ida_kernwin.UI_Hooks.populating_widget_popup (method) - populating_widget_popup(self, widget, popup_handle, ctx=None) - IDA is populating the context menu for a widget. This is your chance to - attach_action_to_popup(). - - Have a look at ui_finish_populating_widget_popup, if you want to augment the - context menu with your own actions after the menu has had a chance to be - properly populated by the owning component or plugin (which typically does it on - ui_populating_widget_popup.) +ida_kernwin.UI_Hooks.populating_widget_popup(self, widget: "TWidget *", popup_handle: "TPopupMenu *", ctx: "action_ctx_base_t" = None) -> None + IDA is populating the context menu for a widget. This is your chance to attach_action_to_popup(). + Have a look at ui_finish_populating_widget_popup, if you want to augment the context menu with your own actions after the menu has had a chance to be properly populated by the owning component or plugin (which typically does it on ui_populating_widget_popup.) @param widget: (TWidget *) @param popup_handle: (TPopupMenu *) @param ctx: (const action_activation_ctx_t *) + @returns void -ida_kernwin.UI_Hooks.postprocess_action (method) - postprocess_action(self) +ida_kernwin.UI_Hooks.postprocess_action(self) -> None an ida ui action has been handled -ida_kernwin.UI_Hooks.preprocess_action (method) - preprocess_action(self, name) -> int - ida ui is about to handle a user action. - - @param name: (const char *) ui action name. these names can be looked up in - ida[tg]ui.cfg +ida_kernwin.UI_Hooks.preprocess_action(self, name: str) -> int + ida ui is about to handle a user action. + + @param name: (const char *) ui action name. these names can be looked up in ida[tg]ui.cfg @retval 0: ok @retval nonzero: a plugin has handled the command -ida_kernwin.UI_Hooks.range (method) - range(self) - The disassembly range has been changed ( idainfo::min_ea ... - idainfo::max_ea). UI should redraw the scrollbars. See also: - ui_lock_range_refresh +ida_kernwin.UI_Hooks.range(self) -> None + The disassembly range has been changed ( idainfo::min_ea ... idainfo::max_ea). UI should redraw the scrollbars. See also: ui_lock_range_refresh + + @returns void -ida_kernwin.UI_Hooks.ready_to_run (method) - ready_to_run(self) - all UI elements have been initialized. Automatic plugins may hook to this - event to perform their tasks. +ida_kernwin.UI_Hooks.ready_to_run(self) -> None + all UI elements have been initialized. Automatic plugins may hook to this event to perform their tasks. + + @returns void -ida_kernwin.UI_Hooks.resume (method) - resume(self) - Resume the suspended graphical interface. Only the text version. Interface - should respond to it +ida_kernwin.UI_Hooks.resume(self) -> None + Resume the suspended graphical interface. Only the text version. Interface should respond to it + + @returns void -ida_kernwin.UI_Hooks.saved (method) - saved(self, path) - The kernel has saved the database. This callback just informs the interface. - Note that at the time this notification is sent, the internal paths are not - updated yet, and calling get_path(PATH_TYPE_IDB) will return the previous path. - +ida_kernwin.UI_Hooks.saved(self, path: str) -> None + The kernel has saved the database. This callback just informs the interface. Note that at the time this notification is sent, the internal paths are not updated yet, and calling get_path(PATH_TYPE_IDB) will return the previous path. + @param path: (const char *) the database path + @returns void -ida_kernwin.UI_Hooks.saving (method) - saving(self) - The kernel is flushing its buffers to the disk. The user interface should - save its state. Parameters: none Returns: none +ida_kernwin.UI_Hooks.saving(self) -> None + The kernel is flushing its buffers to the disk. The user interface should save its state. Parameters: none Returns: none + -ida_kernwin.UI_Hooks.screen_ea_changed (method) - screen_ea_changed(self, ea, prev_ea) - The "current address" changed - +ida_kernwin.UI_Hooks.screen_ea_changed(self, ea: ida_idaapi.ea_t, prev_ea: ida_idaapi.ea_t) -> None + The "current address" changed + @param ea: (ea_t) @param prev_ea: (ea_t) + @returns void -ida_kernwin.UI_Hooks.set_widget_config (method) - set_widget_config(self, widget, cfg) - set the widget configuration - +ida_kernwin.UI_Hooks.set_widget_config(self, widget: "TWidget const *", cfg: "jobj_wrapper_t") -> None + set the widget configuration + @param widget: (const TWidget *) @param cfg: (const jobj_t *) + @returns void -ida_kernwin.UI_Hooks.suspend (method) - suspend(self) - Suspend graphical interface. Only the text version. Interface should respond - to it. +ida_kernwin.UI_Hooks.suspend(self) -> None + Suspend graphical interface. Only the text version. Interface should respond to it. + + @returns void -ida_kernwin.UI_Hooks.unhook (method) - unhook(self) -> bool +ida_kernwin.UI_Hooks.unhook(self) -> bool -ida_kernwin.UI_Hooks.updated_actions (method) - updated_actions(self) - IDA is done updating actions. +ida_kernwin.UI_Hooks.updated_actions(self) -> None + IDA is done updating actions. + + @returns void -ida_kernwin.UI_Hooks.updating_actions (method) - updating_actions(self, ctx) - IDA is about to update all actions. If your plugin needs to perform - expensive operations more than once (e.g., once per action it registers), you - should do them only once, right away. - +ida_kernwin.UI_Hooks.updating_actions(self, ctx: "action_ctx_base_t") -> None + IDA is about to update all actions. If your plugin needs to perform expensive operations more than once (e.g., once per action it registers), you should do them only once, right away. + @param ctx: (action_update_ctx_t *) + @returns void -ida_kernwin.UI_Hooks.widget_closing (method) - widget_closing(self, widget) - TWidget is about to close. This event precedes ui_widget_invisible. Use this to - perform some possible actions relevant to the lifecycle of this widget - +ida_kernwin.UI_Hooks.widget_closing(self, widget: "TWidget *") -> None + TWidget is about to close. This event precedes ui_widget_invisible. Use this to perform some possible actions relevant to the lifecycle of this widget + @param widget: (TWidget *) + @returns void -ida_kernwin.UI_Hooks.widget_invisible (method) - widget_invisible(self, widget) - TWidget is being closed. Use this event to destroy the window controls - +ida_kernwin.UI_Hooks.widget_invisible(self, widget: "TWidget *") -> None + TWidget is being closed. Use this event to destroy the window controls + @param widget: (TWidget *) + @returns void -ida_kernwin.UI_Hooks.widget_visible (method) - widget_visible(self, widget) - TWidget is displayed on the screen. Use this event to populate the window with - controls - +ida_kernwin.UI_Hooks.widget_visible(self, widget: "TWidget *") -> None + TWidget is displayed on the screen. Use this event to populate the window with controls + @param widget: (TWidget *) + @returns void -ida_kernwin.VES_SHIFT (variable) - state & 1 => Shift is pressed - state & 2 => Alt is pressed - state & 4 => Ctrl is pressed - state & 8 => Mouse left button is pressed - state & 16 => Mouse right button is pressed - state & 32 => Mouse middle button is pressed - state & 128 => Meta is pressed (OSX only) +ida_kernwin.VES_SHIFT + state & 1 => Shift is pressed + state & 2 => Alt is pressed + state & 4 => Ctrl is pressed + state & 8 => Mouse left button is pressed + state & 16 => Mouse right button is pressed + state & 32 => Mouse middle button is pressed + state & 128 => Meta is pressed (OSX only) + -ida_kernwin.VME_LEFT_BUTTON (variable) +ida_kernwin.VME_LEFT_BUTTON left mouse button -ida_kernwin.VME_MID_BUTTON (variable) +ida_kernwin.VME_MID_BUTTON middle mouse button -ida_kernwin.VME_RIGHT_BUTTON (variable) +ida_kernwin.VME_RIGHT_BUTTON right mouse button -ida_kernwin.VME_UNKNOWN (variable) +ida_kernwin.VME_UNKNOWN unknown mouse button -ida_kernwin.View_Hooks (class) - Proxy of C++ View_Hooks class. +ida_kernwin.View_Hooks -ida_kernwin.View_Hooks.__disown__ (method) +ida_kernwin.View_Hooks.__disown__(self) -ida_kernwin.View_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> View_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 +ida_kernwin.View_Hooks.__init__(self, _flags: int = 0, _hkcb_flags: int = 1) -ida_kernwin.View_Hooks.hook (method) - hook(self) -> bool +ida_kernwin.View_Hooks.hook(self) -> bool -ida_kernwin.View_Hooks.unhook (method) - unhook(self) -> bool +ida_kernwin.View_Hooks.unhook(self) -> bool -ida_kernwin.View_Hooks.view_activated (method) - view_activated(self, view) - A view is activated - +ida_kernwin.View_Hooks.view_activated(self, view: "TWidget *") -> None + A view is activated + @param view: (TWidget *) -ida_kernwin.View_Hooks.view_click (method) - view_click(self, view, event) - Click event - +ida_kernwin.View_Hooks.view_click(self, view: "TWidget *", event: "view_mouse_event_t") -> None + Click event + @param view: (TWidget *) @param event: (const view_mouse_event_t *) -ida_kernwin.View_Hooks.view_close (method) - view_close(self, view) - View closed - +ida_kernwin.View_Hooks.view_close(self, view: "TWidget *") -> None + View closed + @param view: (TWidget *) -ida_kernwin.View_Hooks.view_created (method) - view_created(self, view) - A view is being created. - +ida_kernwin.View_Hooks.view_created(self, view: "TWidget *") -> None + A view is being created. + @param view: (TWidget *) -ida_kernwin.View_Hooks.view_curpos (method) - view_curpos(self, view) - Cursor position changed - +ida_kernwin.View_Hooks.view_curpos(self, view: "TWidget *") -> None + Cursor position changed + @param view: (TWidget *) -ida_kernwin.View_Hooks.view_dblclick (method) - view_dblclick(self, view, event) - Double click event - +ida_kernwin.View_Hooks.view_dblclick(self, view: "TWidget *", event: "view_mouse_event_t") -> None + Double click event + @param view: (TWidget *) @param event: (const view_mouse_event_t *) -ida_kernwin.View_Hooks.view_deactivated (method) - view_deactivated(self, view) - A view is deactivated - +ida_kernwin.View_Hooks.view_deactivated(self, view: "TWidget *") -> None + A view is deactivated + @param view: (TWidget *) -ida_kernwin.View_Hooks.view_keydown (method) - view_keydown(self, view, key, state) - Key down event - +ida_kernwin.View_Hooks.view_keydown(self, view: "TWidget *", key: int, state: "view_event_state_t") -> None + Key down event + @param view: (TWidget *) @param key: (int) @param state: (::view_event_state_t) -ida_kernwin.View_Hooks.view_loc_changed (method) - view_loc_changed(self, view, now, was) - The location for the view has changed (can be either the place_t, the - renderer_info_t, or both.) - +ida_kernwin.View_Hooks.view_loc_changed(self, view: "TWidget *", now: "lochist_entry_t const *", was: "lochist_entry_t const *") -> None + The location for the view has changed (can be either the place_t, the renderer_info_t, or both.) + @param view: (TWidget *) @param now: (const lochist_entry_t *) @param was: (const lochist_entry_t *) -ida_kernwin.View_Hooks.view_mouse_moved (method) - view_mouse_moved(self, view, event) - The mouse moved on the view - +ida_kernwin.View_Hooks.view_mouse_moved(self, view: "TWidget *", event: "view_mouse_event_t") -> None + The mouse moved on the view + @param view: (TWidget *) @param event: (const view_mouse_event_t *) -ida_kernwin.View_Hooks.view_mouse_over (method) - view_mouse_over(self, view, event) - The user moved the mouse over (or out of) a node or an edge. This is only - relevant in a graph view. - +ida_kernwin.View_Hooks.view_mouse_over(self, view: "TWidget *", event: "view_mouse_event_t") -> None + The user moved the mouse over (or out of) a node or an edge. This is only relevant in a graph view. + @param view: (TWidget *) @param event: (const view_mouse_event_t *) -ida_kernwin.View_Hooks.view_switched (method) - view_switched(self, view, rt) - A view's renderer has changed. - +ida_kernwin.View_Hooks.view_switched(self, view: "TWidget *", rt: "tcc_renderer_type_t") -> None + A view's renderer has changed. + @param view: (TWidget *) @param rt: (tcc_renderer_type_t) -ida_kernwin.WCLS_DELETE_LATER (variable) +ida_kernwin.WCLS_DELETE_LATER assign the deletion of the widget to the UI loop ///< -ida_kernwin.WCLS_DONT_SAVE_SIZE (variable) +ida_kernwin.WCLS_DONT_SAVE_SIZE don't save size of the window -ida_kernwin.WCLS_NO_CONTEXT (variable) +ida_kernwin.WCLS_NO_CONTEXT don't change the current context (useful for toolbars) -ida_kernwin.WCLS_SAVE (variable) +ida_kernwin.WCLS_SAVE save state in desktop config -ida_kernwin.WOPN_CLOSED_BY_ESC (variable) +ida_kernwin.WOPN_CLOSED_BY_ESC override idagui.cfg:CLOSED_BY_ESC: esc will close -ida_kernwin.WOPN_DP_BEFORE (variable) - Place widget before dst_form in the tab bar instead of after; used with - WOPN_DP_INSIDE and WOPN_DP_TAB +ida_kernwin.WOPN_DP_BEFORE + Place widget before dst_form in the tab bar instead of after; used with WOPN_DP_INSIDE and WOPN_DP_TAB + -ida_kernwin.WOPN_DP_BOTTOM (variable) +ida_kernwin.WOPN_DP_BOTTOM Dock widget below dest_ctrl. -ida_kernwin.WOPN_DP_FLOATING (variable) +ida_kernwin.WOPN_DP_FLOATING Make widget floating. -ida_kernwin.WOPN_DP_INSIDE (variable) +ida_kernwin.WOPN_DP_INSIDE Create a new tab bar with both widget and dest_ctrl. -ida_kernwin.WOPN_DP_LEFT (variable) +ida_kernwin.WOPN_DP_LEFT Dock widget to the left of dest_ctrl. -ida_kernwin.WOPN_DP_RIGHT (variable) +ida_kernwin.WOPN_DP_RIGHT Dock widget to the right of dest_ctrl. -ida_kernwin.WOPN_DP_SZHINT (variable) - when floating or in a splitter (i.e., not tabbed), use the widget's size hint to - determine the best geometry (Qt only) +ida_kernwin.WOPN_DP_SZHINT + when floating or in a splitter (i.e., not tabbed), use the widget's size hint to determine the best geometry (Qt only) + -ida_kernwin.WOPN_DP_TAB (variable) - Place widget into a tab next to dest_ctrl, if dest_ctrl is in a tab bar - (otherwise the same as WOPN_DP_INSIDE) +ida_kernwin.WOPN_DP_TAB + Place widget into a tab next to dest_ctrl, if dest_ctrl is in a tab bar (otherwise the same as WOPN_DP_INSIDE) + -ida_kernwin.WOPN_DP_TOP (variable) +ida_kernwin.WOPN_DP_TOP Dock widget above dest_ctrl. -ida_kernwin.WOPN_NOT_CLOSED_BY_ESC (variable) +ida_kernwin.WOPN_NOT_CLOSED_BY_ESC override idagui.cfg:CLOSED_BY_ESC: esc will not close -ida_kernwin.WOPN_PERSIST (variable) +ida_kernwin.WOPN_PERSIST widget will remain available when starting or stopping debugger sessions -ida_kernwin.WOPN_RESTORE (variable) - if the widget was the only widget in a floating area the last time it was - closed, it will be restored as floating, with the same position+size as before +ida_kernwin.WOPN_RESTORE + if the widget was the only widget in a floating area the last time it was closed, it will be restored as floating, with the same position+size as before + -ida_kernwin.__qtimer_t (class) - Proxy of C++ __qtimer_t class. +ida_kernwin.__qtimer_t -ida_kernwin.__qtimer_t.__init__ (method) - __init__(self) -> __qtimer_t +ida_kernwin.__qtimer_t.__init__(self) -ida_kernwin._ask_addr (function) - _ask_addr(addr, format) -> bool - - Parameters - ---------- - addr: ea_t * - format: char const * +ida_kernwin._ask_addr(*args) -> "ea_t *" -ida_kernwin._ask_long (function) - _ask_long(value, format) -> bool - - Parameters - ---------- - value: sval_t * - format: char const * +ida_kernwin._ask_long(*args) -> "sval_t *" -ida_kernwin._ask_seg (function) - _ask_seg(sel, format) -> bool - - Parameters - ---------- - sel: sel_t * - format: char const * +ida_kernwin._ask_seg(*args) -> "sel_t *" -ida_kernwin._kludge_force_declare_dirspec_t (function) - _kludge_force_declare_dirspec_t(arg1) - - Parameters - ---------- - arg1: dirspec_t const * +ida_kernwin._kludge_force_declare_dirspec_t(arg1: "dirspec_t const *") -> None -ida_kernwin._kludge_force_declare_dirtree_t (function) - _kludge_force_declare_dirtree_t(arg1) - - Parameters - ---------- - arg1: dirtree_t const * +ida_kernwin._kludge_force_declare_dirtree_t(arg1: "dirtree_t const *") -> None -ida_kernwin.action_ctx_base_cur_sel_t (class) - Proxy of C++ action_ctx_base_cur_sel_t class. +ida_kernwin.action_ctx_base_cur_sel_t -ida_kernwin.action_ctx_base_cur_sel_t.__init__ (method) - __init__(self) -> action_ctx_base_cur_sel_t +ida_kernwin.action_ctx_base_cur_sel_t.__init__(self) -ida_kernwin.action_ctx_base_cur_sel_t.reset (method) - reset(self) +ida_kernwin.action_ctx_base_cur_sel_t.reset(self) -> None -ida_kernwin.action_ctx_base_cur_sel_t.to (variable) +ida_kernwin.action_ctx_base_cur_sel_t.to end of selection -ida_kernwin.action_ctx_base_source_t (class) - Proxy of C++ action_ctx_base_source_t class. +ida_kernwin.action_ctx_base_t -ida_kernwin.action_ctx_base_source_t.__init__ (method) - __init__(self) -> action_ctx_base_source_t +ida_kernwin.action_ctx_base_t.__init__(self) -ida_kernwin.action_ctx_base_source_t.reset (method) - reset(self) - -ida_kernwin.action_ctx_base_t (class) - Proxy of C++ action_ctx_base_t class. - -ida_kernwin.action_ctx_base_t.__init__ (method) - __init__(self) -> action_ctx_base_t - -ida_kernwin.action_ctx_base_t.action (variable) +ida_kernwin.action_ctx_base_t.action action name -ida_kernwin.action_ctx_base_t.chooser_selection (variable) - current chooser selection (0-based) - -ida_kernwin.action_ctx_base_t.cur_ea (variable) - the current EA of the position in the view - -ida_kernwin.action_ctx_base_t.cur_enum (variable) - the current enum - -ida_kernwin.action_ctx_base_t.cur_fchunk (variable) - the current function chunk - -ida_kernwin.action_ctx_base_t.cur_flags (variable) - Current address information. see Action context property bits. - -ida_kernwin.action_ctx_base_t.cur_func (variable) - the current function - -ida_kernwin.action_ctx_base_t.cur_seg (variable) - the current segment - -ida_kernwin.action_ctx_base_t.cur_sel (variable) - the currently selected range. also see ACF_HAS_SELECTION - -ida_kernwin.action_ctx_base_t.cur_strmem (variable) - the current structure member - -ida_kernwin.action_ctx_base_t.cur_struc (variable) - the current structure - -ida_kernwin.action_ctx_base_t.cur_value (variable) - the possible address, or value the cursor is positioned on - -ida_kernwin.action_ctx_base_t.dirtree_selection (variable) - the current dirtree_t selection (if applicable) - -ida_kernwin.action_ctx_base_t.focus (variable) - The focused widget in case it is not the 'form' itself (e.g., the 'quick filter' - input in choosers.) - -ida_kernwin.action_ctx_base_t.graph_selection (variable) - the current graph selection (if in a graph view) - -ida_kernwin.action_ctx_base_t.has_flag (method) - has_flag(self, flag) -> bool - Check if the given flag is set. - - @param flag: (C++: uint32) - -ida_kernwin.action_ctx_base_t.regname (variable) - register name (if widget_type == BWN_CPUREGS and context menu opened on - register) - -ida_kernwin.action_ctx_base_t.reset (method) - reset(self) - Invalidate all context info. - -ida_kernwin.action_ctx_base_t.source (variable) +ida_kernwin.action_ctx_base_t.chooser the underlying chooser_base_t (if 'widget' is a chooser widget) -ida_kernwin.action_ctx_base_t.type_ref (variable) - a reference to the current type (if 'widget' is a types listing widget; nullptr - otherwise) +ida_kernwin.action_ctx_base_t.chooser_selection + current chooser selection (0-based) -ida_kernwin.action_ctx_base_t.widget_title (variable) +ida_kernwin.action_ctx_base_t.cur_ea + the current EA of the position in the view + +ida_kernwin.action_ctx_base_t.cur_fchunk + the current function chunk + +ida_kernwin.action_ctx_base_t.cur_flags + Current address information. see Action context property bits. + +ida_kernwin.action_ctx_base_t.cur_func + the current function + +ida_kernwin.action_ctx_base_t.cur_seg + the current segment + +ida_kernwin.action_ctx_base_t.cur_sel + the currently selected range. also see ACF_HAS_SELECTION + +ida_kernwin.action_ctx_base_t.cur_value + the possible address, or value the cursor is positioned on + +ida_kernwin.action_ctx_base_t.dirtree_selection + the current dirtree_t selection (if applicable) + +ida_kernwin.action_ctx_base_t.focus + The focused widget in case it is not the 'form' itself (e.g., the 'quick filter' input in choosers.) + +ida_kernwin.action_ctx_base_t.graph + the current graph (if in a graph view) + +ida_kernwin.action_ctx_base_t.graph_selection + the current graph selection (if in a graph view) + +ida_kernwin.action_ctx_base_t.has_flag(self, flag: int) -> bool + Check if the given flag is set. + +ida_kernwin.action_ctx_base_t.hovered + the current item being hovered (if in a graph view) + +ida_kernwin.action_ctx_base_t.regname + register name (if widget_type == BWN_CPUREGS and context menu opened on register) + +ida_kernwin.action_ctx_base_t.reset(self) -> None + Invalidate all context info. + +ida_kernwin.action_ctx_base_t.type_ref + a reference to the current type (if 'widget' is a type listing widget; nullptr otherwise) + +ida_kernwin.action_ctx_base_t.widget_title title of current widget -ida_kernwin.action_ctx_base_t.widget_type (variable) +ida_kernwin.action_ctx_base_t.widget_type type of current widget -ida_kernwin.action_desc_t (class) - Proxy of C++ action_desc_t class. +ida_kernwin.action_desc_t -ida_kernwin.action_desc_t.__init__ (method) - __init__(self, name, label, handler, shortcut=None, tooltip=None, icon=-1, flags=0) -> action_desc_t - - @param name: char const * - @param label: char const * - @param handler: PyObject * - @param shortcut: char const * - @param tooltip: char const * - @param icon: int - @param flags: int +ida_kernwin.action_desc_t.__init__(self, name: str, label: str, handler: "PyObject *", shortcut: str = None, tooltip: str = None, icon: int = -1, flags: int = 0) -ida_kernwin.action_desc_t.cb (variable) +ida_kernwin.action_desc_t.cb size of this structure -ida_kernwin.action_desc_t.flags (variable) +ida_kernwin.action_desc_t.flags See Action flags. -ida_kernwin.action_desc_t.icon (variable) +ida_kernwin.action_desc_t.icon an optional icon ID to use -ida_kernwin.action_desc_t.label (variable) - the label of the action, possibly with an accelerator key definition (e.g., - "~J~ump to operand") +ida_kernwin.action_desc_t.label + the label of the action, possibly with an accelerator key definition (e.g., "~J~ump to operand") + -ida_kernwin.action_desc_t.name (variable) - the internal name of the action; must be unique. a way to reduce possible - conflicts is to prefix it with some specific prefix. E.g., "myplugin:doSthg". +ida_kernwin.action_desc_t.name + the internal name of the action; must be unique. a way to reduce possible conflicts is to prefix it with some specific prefix. E.g., "myplugin:doSthg". + -ida_kernwin.action_desc_t.owner (variable) - either the plugin_t, or plugmod_t responsible for registering the action. Can be - nullptr Please see ACTION_DESC_LITERAL_PLUGMOD +ida_kernwin.action_desc_t.owner + either the plugin_t, or plugmod_t responsible for registering the action. Can be nullptr Please see ACTION_DESC_LITERAL_PLUGMOD + -ida_kernwin.action_desc_t.shortcut (variable) +ida_kernwin.action_desc_t.shortcut an optional shortcut definition. E.g., "Ctrl+Enter" -ida_kernwin.action_desc_t.tooltip (variable) +ida_kernwin.action_desc_t.tooltip an optional tooltip for the action -ida_kernwin.action_handler_t (class) +ida_kernwin.action_handler_t -ida_kernwin.action_handler_t.__init__ (method) +ida_kernwin.action_handler_t.__init__(self) -ida_kernwin.action_handler_t.activate (method) - Activate an action. This function implements the core behavior of an action. It - is called when the action is triggered, from a menu, from a popup menu, from the - toolbar, or programmatically. - - @return: non-zero: all IDA windows will be refreshed +ida_kernwin.action_handler_t.activate(self, ctx) + Activate an action. This function implements the core behavior of an action. It is called when the action is triggered, from a menu, from a popup menu, from the toolbar, or programmatically. + + @returns non-zero: all IDA windows will be refreshed -ida_kernwin.action_handler_t.update (method) - Update an action. This is called when the context of the UI changed, and we need - to let the action update some of its properties if needed (label, icon, ...) - - In addition, this lets IDA know whether the action is enabled, and when it - should be queried for availability again. - - Note: This callback is not meant to change anything in the application's state, - except by calling one (or many) of the "update_action_*()" functions on this - very action. +ida_kernwin.action_handler_t.update(self, ctx) + Update an action. This is called when the context of the UI changed, and we need to let the action update some of its properties if needed (label, icon, ...) + In addition, this lets IDA know whether the action is enabled, and when it should be queried for availability again. + Note: This callback is not meant to change anything in the application's state, except by calling one (or many) of the "update_action_*()" functions on this very action. + -ida_kernwin.activate_widget (function) - activate_widget(widget, take_focus) - Activate widget (only gui version) (ui_activate_widget). - - @param widget: (C++: TWidget *) existing widget to display - @param take_focus: (C++: bool) give focus to given widget +ida_kernwin.activate_widget(widget: "TWidget *", take_focus: bool) -> None + Activate widget (only gui version) (ui_activate_widget). + + @param widget: existing widget to display + @param take_focus: give focus to given widget -ida_kernwin.add_hotkey (function) - add_hotkey(hotkey, pyfunc) -> PyCapsule +ida_kernwin.add_hotkey(hotkey, callable) Associates a function call with a hotkey. - Callable pyfunc will be called each time the hotkey is pressed + Callable 'callable' will be called each time the hotkey is pressed @param hotkey: The hotkey - @param pyfunc: Callable + @param callable: Callable @return: Context object on success or None on failure. -ida_kernwin.add_idc_hotkey (function) - add_idc_hotkey(hotkey, idcfunc) -> int - Add hotkey for IDC function (ui_add_idckey). - - @param hotkey: (C++: const char *) hotkey name - @param idcfunc: (C++: const char *) IDC function name - @return: IDC hotkey error codes +ida_kernwin.add_idc_hotkey(hotkey: str, idcfunc: str) -> int + Add hotkey for IDC function (ui_add_idckey). + + @param hotkey: hotkey name + @param idcfunc: IDC function name + @returns IDC hotkey error codes -ida_kernwin.add_spaces (function) - add_spaces(s, len) -> str - Add space characters to the colored string so that its length will be at least - 'len' characters. Don't trim the string if it is longer than 'len'. - - @param str: (C++: char *) pointer to colored string to modify (may not be nullptr) - @param len: (C++: ssize_t) the desired length of the string - @return: pointer to the end of input string +ida_kernwin.add_spaces(s: str, len: "size_t") -> str + Add space characters to the colored string so that its length will be at least 'len' characters. Don't trim the string if it is longer than 'len'. + + @param len: the desired length of the string + @returns pointer to the end of input string -ida_kernwin.addon_count (function) - addon_count() -> int +ida_kernwin.addon_count() -> int Get number of installed addons. -ida_kernwin.addon_info_t (class) - Proxy of C++ addon_info_t class. +ida_kernwin.addon_info_t -ida_kernwin.addon_info_t.__init__ (method) - __init__(self) -> addon_info_t +ida_kernwin.addon_info_t.__init__(self) -ida_kernwin.analyzer_options (function) - analyzer_options() - Allow the user to set analyzer options. (show a dialog box) - (ui_analyzer_options) +ida_kernwin.analyzer_options() -> None + Allow the user to set analyzer options. (show a dialog box) (ui_analyzer_options) -ida_kernwin.ask_addr (function) - Output a formatted string to the output window (msg) preprended with "**DATABASE - IS CORRUPTED: " Display a dialog box and wait for the user to input an address - (ui_ask_addr). - +ida_kernwin.ask_addr(defval, format) + Output a formatted string to the output window (msg) preprended with "**DATABASE IS CORRUPTED: " Display a dialog box and wait for the user to input an address (ui_ask_addr). + + @param format: printf() style format string with the question @retval 0: the user pressed Esc. @retval 1: ok, the user entered an address -ida_kernwin.ask_buttons (function) - ask_buttons(Yes, No, Cancel, deflt, format) -> int - Display a dialog box and get choice from maximum three possibilities - (ui_ask_buttons). - @note: for all buttons: - * use "" or nullptr to take the default name for the button. - * prepend "HIDECANCEL\n" in 'format' to hide the Cancel button - - @param Yes: (C++: const char *) text for the first button - @param No: (C++: const char *) text for the second button - @param Cancel: (C++: const char *) text for the third button - @param deflt: (C++: int) default choice: one of Button IDs - @param format: (C++: const char *) printf-style format string for question. It may have some - prefixes, see below. - @return: one of Button IDs specifying the selected button (Esc key returns - Cancel/3rd button value) +ida_kernwin.ask_buttons(*args) -> int + Display a dialog box and get choice from maximum three possibilities (ui_ask_buttons). + + @param Yes: text for the first button + @param No: text for the second button + @param Cancel: text for the third button + @param deflt: default choice: one of Button IDs + @param format: printf-style format string for question. It may have some prefixes, see below. + @returns one of Button IDs specifying the selected button (Esc key returns Cancel/3rd button value) -ida_kernwin.ask_file (function) - ask_file(for_saving, defval, format) -> char * - - @param for_saving: bool - @param defval: char const * - @param format: char const * +ida_kernwin.ask_file(*args) -> "char *" -ida_kernwin.ask_for_feedback (function) - ask_for_feedback(format) - Show a message box asking to send the input file to \link{mailto:support@hex- - rays.com,support@hex-rays.com}. - - @param format: (C++: const char *) the reason why the input file is bad +ida_kernwin.ask_for_feedback(*args) -> None + Show a message box asking to send the input file to [support@hex-rays.com](mailto:support@hex-rays.com). + + @param format: the reason why the input file is bad -ida_kernwin.ask_form (function) - Display a dialog box and wait for the user. If the form contains the "BUTTON NO - " keyword, then the return values are the same as in the ask_yn() - function (Button IDs) - - @retval 0: no memory to display or form syntax error (a warning is displayed in - this case). the user pressed the 'No' button (if the form has it) or - the user cancelled the dialog otherwise. all variables retain their - original values. +ida_kernwin.ask_form(*args) + Display a dialog box and wait for the user. If the form contains the "BUTTON NO <title>" keyword, then the return values are the same as in the ask_yn() function (Button IDs) + + @param form: dialog box as a string. see ask_form()/open_form() + @retval 0: no memory to display or form syntax error (a warning is displayed in this case). the user pressed the 'No' button (if the form has it) or the user cancelled the dialog otherwise. all variables retain their original values. @retval 1: ok, all input fields are filled and validated. @retval -1: the form has the 'No' button and the user cancelled the dialog -ida_kernwin.ask_ident (function) - Display a dialog box and wait for the user to input an identifier. If the user - enters a non-valid identifier, this function displays a warning and allows the - user to correct it. CPU register names are usually forbidden. - - @return: false if the user cancelled the dialog, otherwise returns true. +ida_kernwin.ask_ident(defval, format) + Display a dialog box and wait for the user to input an identifier. If the user enters a non-valid identifier, this function displays a warning and allows the user to correct it. CPU register names are usually forbidden. + + @param format: printf() style format string with the question + @returns false if the user cancelled the dialog, otherwise returns true. -ida_kernwin.ask_ident2 (function) - ask_ident2(str, format) -> bool - Display a dialog box and wait for the user to input an identifier. If the user - enters a non-valid identifier, this function displays a warning and allows the - user to correct it. CPU register names are permitted. - - @param str: (C++: qstring *) qstring to fill. Can contain the default value. Cannot be nullptr. - @param format: (C++: const char *) printf() style format string with the question - @return: false if the user cancelled the dialog, otherwise returns true. +ida_kernwin.ask_ident2(*args) -> bool + Display a dialog box and wait for the user to input an identifier. If the user enters a non-valid identifier, this function displays a warning and allows the user to correct it. CPU register names are permitted. + + @param str: qstring to fill. Can contain the default value. Cannot be nullptr. + @param format: printf() style format string with the question + @returns false if the user cancelled the dialog, otherwise returns true. -ida_kernwin.ask_long (function) - Display a dialog box and wait for the user to input an number (ui_ask_long). The - number is represented in C-style. This function allows to enter any IDC - expression and properly calculates it. - +ida_kernwin.ask_long(defval, format) + Display a dialog box and wait for the user to input an number (ui_ask_long). The number is represented in C-style. This function allows to enter any IDC expression and properly calculates it. + + @param format: printf() style format string with the question @retval 0: if the user pressed Esc. @retval 1: ok, the user entered a valid number. -ida_kernwin.ask_seg (function) - Display a dialog box and wait for the user to input an segment name - (ui_ask_seg). This function allows to enter segment register names, segment base - paragraphs, segment names to denote a segment. - +ida_kernwin.ask_seg(defval, format) + Display a dialog box and wait for the user to input an segment name (ui_ask_seg). This function allows to enter segment register names, segment base paragraphs, segment names to denote a segment. + + @param format: printf() style format string with the question @retval 0: if the user pressed Esc. @retval 1: ok, the user entered an segment name -ida_kernwin.ask_str (function) - ask_str(defval, hist, prompt) -> str or None +ida_kernwin.ask_str(defval, hist, prompt) Asks for a long text @param defval: The default value - @param hist: history id + @param hist: history id @param prompt: The prompt value @return: None or the entered string -ida_kernwin.ask_text (function) - ask_text(max_size, defval, prompt) -> str +ida_kernwin.ask_text(max_size: int, defval: str, prompt: str) -> Union[str, None] Asks for a long text @param max_size: Maximum text length, 0 for unlimited @@ -42677,32 +28688,26 @@ ida_kernwin.ask_text (function) @param prompt: The prompt value @return: None or the entered string -ida_kernwin.ask_yn (function) - ask_yn(deflt, format) -> int - Display a dialog box and get choice from "Yes", "No", "Cancel". - - @param deflt: (C++: int) default choice: one of Button IDs - @param format: (C++: const char *) The question in printf() style format - @return: the selected button (one of Button IDs). Esc key returns ASKBTN_CANCEL. +ida_kernwin.ask_yn(*args) -> int + Display a dialog box and get choice from "Yes", "No", "Cancel". + + @param deflt: default choice: one of Button IDs + @param format: The question in printf() style format + @returns the selected button (one of Button IDs). Esc key returns ASKBTN_CANCEL. -ida_kernwin.atoea (function) - atoea(str) -> bool - Convert a number in C notation to an address. decimal: 1234 - octal: 0123 - hexadecimal: 0xabcd - binary: 0b00101010 - - @param str: (C++: const char *) the string to parse +ida_kernwin.atoea(str: str) -> "uint64 *" + Convert a number in C notation to an address. decimal: 1234 + octal: 0123 + hexadecimal: 0xabcd + binary: 0b00101010 + + @param str: the string to parse -ida_kernwin.attach_action_to_menu (function) - attach_action_to_menu(menupath, name, flags=0) -> bool - Attach a previously-registered action to the menu (ui_attach_action_to_menu). - @note: You should not change top level menu, or the Edit,Plugins submenus If you - want to modify the debugger menu, do it at the ui_debugger_menu_change - event (ida might destroy your menu item if you do it elsewhere). +ida_kernwin.attach_action_to_menu(menupath: str, name: str, flags: int = 0) -> bool + Attach a previously-registered action to the menu (ui_attach_action_to_menu). + + @param menupath: path to the menu item after or before which the insertion will take place. - @param menupath: (C++: const char *) path to the menu item after or before which the insertion will - take place. * Example: Debug/StartProcess * Whitespace, punctuation are ignored. * It is allowed to specify only the prefix of the menu item. @@ -42710,682 +28715,476 @@ ida_kernwin.attach_action_to_menu (function) * menupath may start with the following prefixes: * [S] - modify the main menu of the structure window * [E] - modify the main menu of the enum window - @param name: (C++: const char *) the action name - @param flags: (C++: int) a combination of Set menu flags, to determine menu item position - @return: success + @param name: the action name + @param flags: a combination of Set menu flags, to determine menu item position + @returns success -ida_kernwin.attach_action_to_popup (function) - attach_action_to_popup(widget, popup_handle, name, popuppath=None, flags=0) -> bool - Insert a previously-registered action into the widget's popup menu - (ui_attach_action_to_popup). This function has two "modes": 'single-shot', and - 'permanent'. - - @param widget: (C++: TWidget *) target widget - @param popup_handle: (C++: TPopupMenu *) target popup menu - * if non-nullptr, the action is added to this popup menu invocation (i.e., - 'single-shot') - * if nullptr, the action is added to a list of actions that should always be - present in context menus for this widget (i.e., 'permanent'.) - @param name: (C++: const char *) action name - @param popuppath: (C++: const char *) can be nullptr - @param flags: (C++: int) a combination of SETMENU_ flags (see Set menu flags) - @return: success +ida_kernwin.attach_action_to_popup(widget: "TWidget *", popup_handle: "TPopupMenu *", name: str, popuppath: str = None, flags: int = 0) -> bool + Insert a previously-registered action into the widget's popup menu (ui_attach_action_to_popup). This function has two "modes": 'single-shot', and 'permanent'. + + @param widget: target widget + @param popup_handle: target popup menu + * if non-nullptr, the action is added to this popup menu invocation (i.e., 'single-shot') + * if nullptr, the action is added to a list of actions that should always be present in context menus for this widget (i.e., 'permanent'.) + @param name: action name + @param popuppath: can be nullptr + @param flags: a combination of SETMENU_ flags (see Set menu flags) + @returns success -ida_kernwin.attach_action_to_toolbar (function) - attach_action_to_toolbar(toolbar_name, name) -> bool - Attach an action to an existing toolbar (ui_attach_action_to_toolbar). - - @param toolbar_name: (C++: const char *) the name of the toolbar - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.attach_action_to_toolbar(toolbar_name: str, name: str) -> bool + Attach an action to an existing toolbar (ui_attach_action_to_toolbar). + + @param toolbar_name: the name of the toolbar + @param name: the action name + @returns success -ida_kernwin.attach_dynamic_action_to_popup (function) - attach_dynamic_action_to_popup(unused, popup_handle, desc, popuppath=None, flags=0) -> bool +ida_kernwin.attach_dynamic_action_to_popup(unused, popup_handle, desc, popuppath = None, flags = 0) Create & insert an action into the widget's popup menu (::ui_attach_dynamic_action_to_popup). Note: The action description in the 'desc' parameter is modified by this call so you should prepare a new description for each call. For example: - desc = idaapi.action_desc_t(None, 'Dynamic popup action', Handler()) - idaapi.attach_dynamic_action_to_popup(form, popup, desc) + desc = ida_kernwin.action_desc_t(None, 'Dynamic popup action', Handler()) + ida_kernwin.attach_dynamic_action_to_popup(form, popup, desc) - @param unused: deprecated; should be None + @param unused: deprecated; should be None @param popup_handle: target popup - @param desc: action description of type action_desc_t - @param popuppath: can be None - @param flags: a combination of SETMENU_ constants + @param desc: action description of type action_desc_t + @param popuppath: can be None + @param flags: a combination of SETMENU_ constants @return: success -ida_kernwin.banner (function) - banner(wait) -> bool - Show a banner dialog box (ui_banner). - - @param wait: (C++: int) time to wait before closing +ida_kernwin.banner(wait: int) -> bool + Show a banner dialog box (ui_banner). + + @param wait: time to wait before closing @retval 1: ok @retval 0: esc was pressed -ida_kernwin.beep (function) - beep(beep_type=beep_default) - Issue a beeping sound (ui_beep). - - @param beep_type: (C++: beep_t) +ida_kernwin.beep(beep_type: "beep_t" = beep_default) -> None + Issue a beeping sound (ui_beep). + + @param beep_type: beep_t -ida_kernwin.call_nav_colorizer (function) - call_nav_colorizer(dict, ea, nbytes) -> uint32 +ida_kernwin.call_nav_colorizer(colorizer, ea: ida_idaapi.ea_t, nbytes: int) To be used with the IDA-provided colorizer, that is returned as result of the first call to set_nav_colorizer(). - @param dict: PyObject * - @param ea: ea_t - @param nbytes: asize_t + @param colorizer: the Python colorizer to call + @param ea: the address to colorize + @param nbytes: the size of the range to colorize -ida_kernwin.cancel_exec_request (function) - cancel_exec_request(req_id) -> bool - Try to cancel an asynchronous exec request (ui_cancel_exec_request). - - @param req_id: (C++: int) request id +ida_kernwin.cancel_exec_request(req_id: int) -> bool + Try to cancel an asynchronous exec request (::ui_cancel_exec_request). + + @param req_id: request id @retval true: successfully canceled @retval false: request has already been processed. -ida_kernwin.cancel_thread_exec_requests (function) - cancel_thread_exec_requests(tid) -> int - Try to cancel asynchronous exec requests created by the specified thread. - - @param tid: (C++: qthread_t) thread id - @return: number of the canceled requests. +ida_kernwin.cancel_thread_exec_requests(tid: "__qthread_t") -> int + Try to cancel asynchronous exec requests created by the specified thread. + + @param tid: thread id + @returns number of the canceled requests. -ida_kernwin.choose_activate (function) - choose_activate(_self) - - @param self: PyObject * +ida_kernwin.choose_activate(_self: "PyObject *") -> None -ida_kernwin.choose_choose (function) - choose_choose(_self) -> PyObject * - - @param self: PyObject * +ida_kernwin.choose_choose(_self: "PyObject *") -> "PyObject *" -ida_kernwin.choose_close (function) - choose_close(_self) - - @param self: PyObject * +ida_kernwin.choose_close(_self: "PyObject *") -> None -ida_kernwin.choose_create_embedded_chobj (function) - choose_create_embedded_chobj(_self) -> PyObject * - - @param self: PyObject * +ida_kernwin.choose_create_embedded_chobj(_self: "PyObject *") -> "PyObject *" -ida_kernwin.choose_entry (function) - choose_entry(title) -> ea_t - Choose an entry point (ui_choose, chtype_entry). - - @param title: (C++: const char *) chooser title - @return: ea of selected entry point, BADADDR if none selected +ida_kernwin.choose_entry(title: str) -> ida_idaapi.ea_t + Choose an entry point (ui_choose, chtype_entry). + + @param title: chooser title + @returns ea of selected entry point, BADADDR if none selected -ida_kernwin.choose_enum (function) - choose_enum(out, title, default_ord) -> bool - - @param out: tinfo_t * - @param title: char const * - @param default_ord: uint32 - - choose_enum(title, default_id) -> enum_t - - @param title: char const * - @param default_id: enum_t +ida_kernwin.choose_enum(out: "tinfo_t", title: str, default_ord: int) -> bool + Choose an enum (ui_choose, chtype_enum). + + @param out: the selected enum type + @param title: chooser title + @param default_ord: ordinal of enum to select by default + @retval true: the selected type is in OUT + @retval false: nothing was selected -ida_kernwin.choose_enum_by_value (function) - choose_enum_by_value(out, title, default_ord, value, nbytes) -> bool - - @param out: tinfo_t * - @param title: char const * - @param default_ord: uint32 - @param value: uint64 - @param nbytes: int - - choose_enum_by_value(title, default_id, value, nbytes) -> enum_t - - @param title: char const * - @param default_id: enum_t - @param value: uint64 - @param nbytes: int +ida_kernwin.choose_enum_by_value(out: "tinfo_t", title: str, default_ord: int, value: "uint64", nbytes: int) -> "uchar *" + Choose an enum, restricted by value & size (ui_choose, chtype_enum_by_value_and_size). If the given value cannot be found initially, this function will ask if the user would like to import a standard enum. + + @param out: the selected enum type + @param title: chooser title + @param default_ord: ordinal of enum to select by default + @param value: value to search for + @param nbytes: size of value + @retval true: the selected type is in OUT + @retval false: nothing was selected -ida_kernwin.choose_find (function) - choose_find(title) -> MyChoose or None +ida_kernwin.choose_find(title: str) -> Union[object, None] + Retrieve the chooser object by title - @param title: char const * + @param title the chooser title + @return the chooser, or None -ida_kernwin.choose_func (function) - choose_func(title, default_ea) -> func_t * - Choose a function (ui_choose, chtype_func). - - @param title: (C++: const char *) chooser title - @param default_ea: (C++: ea_t) ea of function to select by default - @return: pointer to function that was selected, nullptr if none selected +ida_kernwin.choose_func(title: str, default_ea: ida_idaapi.ea_t) -> "func_t *" + Choose a function (ui_choose, chtype_func). + + @param title: chooser title + @param default_ea: ea of function to select by default + @returns pointer to function that was selected, nullptr if none selected -ida_kernwin.choose_get_widget (function) - choose_get_widget(_self) -> TWidget * - - @param self: PyObject * +ida_kernwin.choose_get_widget(_self: "PyObject *") -> "TWidget *" -ida_kernwin.choose_idasgn (function) - choose_idasgn() -> PyObject * +ida_kernwin.choose_idasgn() Opens the signature chooser @return: None or the selected signature name -ida_kernwin.choose_name (function) - choose_name(title) -> ea_t - Choose a name (ui_choose, chtype_name). - - @param title: (C++: const char *) chooser title - @return: ea of selected name, BADADDR if none selected +ida_kernwin.choose_name(title: str) -> ida_idaapi.ea_t + Choose a name (ui_choose, chtype_name). + + @param title: chooser title + @returns ea of selected name, BADADDR if none selected -ida_kernwin.choose_refresh (function) - choose_refresh(_self) - - @param self: PyObject * +ida_kernwin.choose_refresh(_self: "PyObject *") -> None -ida_kernwin.choose_segm (function) - choose_segm(title, default_ea) -> segment_t * - Choose a segment (ui_choose, chtype_segm). - - @param title: (C++: const char *) chooser title - @param default_ea: (C++: ea_t) ea of segment to select by default - @return: pointer to segment that was selected, nullptr if none selected +ida_kernwin.choose_segm(title: str, default_ea: ida_idaapi.ea_t) -> "segment_t *" + Choose a segment (ui_choose, chtype_segm). + + @param title: chooser title + @param default_ea: ea of segment to select by default + @returns pointer to segment that was selected, nullptr if none selected -ida_kernwin.choose_srcp (function) - choose_srcp(title) -> sreg_range_t * - Choose a segment register change point (ui_choose, chtype_srcp). - - @param title: (C++: const char *) chooser title - @return: pointer to segment register range of selected change point, nullptr if - none selected +ida_kernwin.choose_srcp(title: str) -> "sreg_range_t *" + Choose a segment register change point (ui_choose, chtype_srcp). + + @param title: chooser title + @returns pointer to segment register range of selected change point, nullptr if none selected -ida_kernwin.choose_stkvar_xref (function) - choose_stkvar_xref(pfn, mptr) -> ea_t - Choose an xref to a stack variable (ui_choose, chtype_name). - - @param pfn: (C++: func_t *) function - @param mptr: (C++: member_t *) variable - @return: ea of the selected xref, BADADDR if none selected +ida_kernwin.choose_stkvar_xref(pfn: "func_t *", srkvar_tid: "tid_t") -> ida_idaapi.ea_t + Choose an xref to a stack variable (ui_choose, chtype_name). + + @param pfn: function + @param srkvar_tid: frame variable TID + @returns ea of the selected xref, BADADDR if none selected -ida_kernwin.choose_struc (function) - choose_struc(title) -> struc_t * - - @param title: char const * - -ida_kernwin.choose_struct (function) - choose_struct(out, title) -> bool - Choose a structure (ui_choose, chtype_struct). - - @param out: (C++: tinfo_t *) the selected structure type - @param title: (C++: const char *) chooser title +ida_kernwin.choose_struct(out: "tinfo_t", title: str) -> bool + Choose a structure (ui_choose, chtype_struct). + + @param out: the selected structure type + @param title: chooser title @retval true: the selected type is in OUT @retval false: nothing was selected -ida_kernwin.choose_til (function) - choose_til() -> str - Choose a type library (ui_choose, chtype_idatil). - +ida_kernwin.choose_til() -> str + Choose a type library (ui_choose, chtype_idatil). + @retval true: 'buf' was filled with the name of the selected til @retval false: otherwise -ida_kernwin.choose_xref (function) - choose_xref(to) -> ea_t - Choose an xref to an address (ui_choose, chtype_xref). - - @param to: (C++: ea_t) referenced address - @return: ea of selected xref, BADADDR if none selected +ida_kernwin.choose_xref(to: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Choose an xref to an address (ui_choose, chtype_xref). + + @param to: referenced address + @returns ea of selected xref, BADADDR if none selected -ida_kernwin.chooser_base_t (class) - Proxy of C++ chooser_base_t class. +ida_kernwin.chooser_base_t -ida_kernwin.chooser_base_t.__init__ (method) +ida_kernwin.chooser_base_t.__init__(self, *args, **kwargs) -ida_kernwin.chooser_base_t.ask_item_attrs (method) - ask_item_attrs(self) -> bool +ida_kernwin.chooser_base_t.ask_item_attrs(self) -> bool should chooser generate ui_get_chooser_item_attrs events? -ida_kernwin.chooser_base_t.can_del (method) - can_del(self) -> bool +ida_kernwin.chooser_base_t.can_del(self) -> bool -ida_kernwin.chooser_base_t.can_edit (method) - can_edit(self) -> bool +ida_kernwin.chooser_base_t.can_edit(self) -> bool -ida_kernwin.chooser_base_t.can_filter (method) - can_filter(self) -> bool +ida_kernwin.chooser_base_t.can_filter(self) -> bool -ida_kernwin.chooser_base_t.can_ins (method) - can_ins(self) -> bool +ida_kernwin.chooser_base_t.can_ins(self) -> bool is an operation allowed? -ida_kernwin.chooser_base_t.can_refresh (method) - can_refresh(self) -> bool +ida_kernwin.chooser_base_t.can_refresh(self) -> bool -ida_kernwin.chooser_base_t.can_sort (method) - can_sort(self) -> bool +ida_kernwin.chooser_base_t.can_sort(self) -> bool -ida_kernwin.chooser_base_t.columns (variable) +ida_kernwin.chooser_base_t.columns number of columns -ida_kernwin.chooser_base_t.deflt_col (variable) +ida_kernwin.chooser_base_t.deflt_col Column that will have focus. -ida_kernwin.chooser_base_t.get_builtin_number (method) - get_builtin_number(self) -> uint +ida_kernwin.chooser_base_t.get_builtin_number(self) -> "uint" get number of the built-in chooser -ida_kernwin.chooser_base_t.get_count (method) - get_count(self) -> size_t +ida_kernwin.chooser_base_t.get_count(self) -> "size_t" get the number of elements in the chooser -ida_kernwin.chooser_base_t.get_ea (method) - get_ea(self, arg2) -> ea_t - get the address of an element. When this function returns valid addresses: * If - any column has the `CHCOL_FNAME` flag, rows will be colored according to the - attributes of the functions who own those addresses (extern, library function, - Lumina, ... - similar to what the "Functions" widget does) * When a selection is - present and the user presses `<Enter>` (`<Shift+Enter>` if the chooser is - modal), IDA will jump to that address (through jumpto()) +ida_kernwin.chooser_base_t.get_ea(self, arg2: "size_t") -> ida_idaapi.ea_t + get the address of an element. When this function returns valid addresses: * If any column has the `CHCOL_FNAME` flag, rows will be colored according to the attributes of the functions who own those addresses (extern, library function, Lumina, ... - similar to what the "Functions" widget does) * When a selection is present and the user presses `<Enter>` (`<Shift+Enter>` if the chooser is modal), IDA will jump to that address (through jumpto()) + + @returns the effective address, BADADDR if the element has no address + +ida_kernwin.chooser_base_t.get_quick_filter_initial_mode(self) -> int + +ida_kernwin.chooser_base_t.get_row(self, n: int) -> Tuple[List[str], int, chooser_item_attrs_t] + Get data & attributes for a row in a chooser. - @param arg2: size_t - @return: the effective address, BADADDR if the element has no address + @param n The row number + @return a tuple (list-of-strings, icon-id, row-attributes) -ida_kernwin.chooser_base_t.get_quick_filter_initial_mode (method) - get_quick_filter_initial_mode(self) -> int +ida_kernwin.chooser_base_t.has_diff_capability(self) -> bool -ida_kernwin.chooser_base_t.get_row (method) - get_row(self, n) -> ([str, ...], int, chooser_item_attrs_t) - get a description of an element. - - @param n: (C++: size_t) element number (0..get_count()-1) +ida_kernwin.chooser_base_t.has_dirtree(self) -> bool -ida_kernwin.chooser_base_t.has_diff_capability (method) - has_diff_capability(self) -> bool +ida_kernwin.chooser_base_t.has_inode_to_index(self) -> bool -ida_kernwin.chooser_base_t.has_dirtree (method) - has_dirtree(self) -> bool +ida_kernwin.chooser_base_t.has_widget_lifecycle(self) -> bool + should chooser object be deleted when the widget gets destroyed? -ida_kernwin.chooser_base_t.has_inode_to_index (method) - has_inode_to_index(self) -> bool +ida_kernwin.chooser_base_t.header + header line; contains the tooltips, and column name for each of 'columns' columns. When tooltips need to be provided, the syntax should be: "#tooltip#column-name". (Otherwise, the syntax is simply "column-name".) + -ida_kernwin.chooser_base_t.header (variable) - header line; contains the tooltips, and column name for each of 'columns' - columns. When tooltips need to be provided, the syntax should be: - "#tooltip#column-name". (Otherwise, the syntax is simply "column-name".) - -ida_kernwin.chooser_base_t.height (variable) +ida_kernwin.chooser_base_t.height (in chars) -ida_kernwin.chooser_base_t.icon (variable) +ida_kernwin.chooser_base_t.icon default icon -ida_kernwin.chooser_base_t.is_dirtree_persisted (method) - is_dirtree_persisted(self) -> bool +ida_kernwin.chooser_base_t.is_dirtree_persisted(self) -> bool -ida_kernwin.chooser_base_t.is_force_default (method) - is_force_default(self) -> bool +ida_kernwin.chooser_base_t.is_force_default(self) -> bool should selection of the already opened non-modal chooser be changed? -ida_kernwin.chooser_base_t.is_lazy_loaded (method) - is_lazy_loaded(self) -> bool +ida_kernwin.chooser_base_t.is_lazy_loaded(self) -> bool -ida_kernwin.chooser_base_t.is_modal (method) - is_modal(self) -> bool +ida_kernwin.chooser_base_t.is_modal(self) -> bool is choose modal? -ida_kernwin.chooser_base_t.is_multi (method) - is_multi(self) -> bool +ida_kernwin.chooser_base_t.is_multi(self) -> bool is multi-selection allowed? -ida_kernwin.chooser_base_t.is_quick_filter_visible_initially (method) - is_quick_filter_visible_initially(self) -> bool +ida_kernwin.chooser_base_t.is_quick_filter_visible_initially(self) -> bool -ida_kernwin.chooser_base_t.is_same (method) - is_same(self, other) -> bool +ida_kernwin.chooser_base_t.is_same(self, other: "chooser_base_t") -> bool do the current and the given objects hold the same data? - - @param other: (C++: const chooser_base_t *) chooser_base_t const * -ida_kernwin.chooser_base_t.is_status_bar_hidden (method) - is_status_bar_hidden(self) -> bool +ida_kernwin.chooser_base_t.is_status_bar_hidden(self) -> bool -ida_kernwin.chooser_base_t.popup_allowed (method) - popup_allowed(self, stdact_idx) -> bool +ida_kernwin.chooser_base_t.popup_allowed(self, stdact_idx: int) -> bool is a standard action allowed? - - @param stdact_idx: (C++: int) -ida_kernwin.chooser_base_t.popup_names (variable) - array of custom labels of the standard actions. Used to replace labels for these - actions. - An empty name means that the default name will be used. - @note: Availability of these actions is determined by the CH_CAN_... flags. The - label, icon and other action attributes can be overwritten in the action - description returned by get_stdact_descs() +ida_kernwin.chooser_base_t.popup_names + array of custom labels of the standard actions. Used to replace labels for these actions. + An empty name means that the default name will be used. + -ida_kernwin.chooser_base_t.should_rename_trigger_edit (method) - should_rename_trigger_edit(self) -> bool +ida_kernwin.chooser_base_t.should_rename_trigger_edit(self) -> bool -ida_kernwin.chooser_base_t.should_restore_geometry (method) - should_restore_geometry(self) -> bool +ida_kernwin.chooser_base_t.should_restore_geometry(self) -> bool -ida_kernwin.chooser_base_t.title (variable) +ida_kernwin.chooser_base_t.title menu title (includes ptr to help). May have chooser title prefixes (see "Chooser - title" above). + title" above). + -ida_kernwin.chooser_base_t.width (variable) +ida_kernwin.chooser_base_t.width (in chars) -ida_kernwin.chooser_base_t.widths (variable) +ida_kernwin.chooser_base_t.widths column widths * low 16 bits of each value hold the column width - * high 16 bits are flags (see Chooser column flags) + * high 16 bits are flags (see Chooser column flags) + + + -ida_kernwin.chooser_base_t.x0 (variable) +ida_kernwin.chooser_base_t.x0 screen position, Functions: generic list choosers -ida_kernwin.chooser_item_attrs_t (class) - Proxy of C++ chooser_item_attrs_t class. +ida_kernwin.chooser_item_attrs_t -ida_kernwin.chooser_item_attrs_t.__eq__ (method) - __eq__(self, other) -> bool - - @param other: chooser_item_attrs_t const & +ida_kernwin.chooser_item_attrs_t.__eq__(self, other: "chooser_item_attrs_t") -> bool -ida_kernwin.chooser_item_attrs_t.__init__ (method) - __init__(self) -> chooser_item_attrs_t +ida_kernwin.chooser_item_attrs_t.__init__(self) -ida_kernwin.chooser_item_attrs_t.color (variable) +ida_kernwin.chooser_item_attrs_t.color item color -ida_kernwin.chooser_item_attrs_t.flags (variable) +ida_kernwin.chooser_item_attrs_t.flags Chooser item property bits -ida_kernwin.chooser_item_attrs_t.reset (method) - reset(self) +ida_kernwin.chooser_item_attrs_t.reset(self) -> None -ida_kernwin.chooser_row_info_t (class) - Proxy of C++ chooser_row_info_t class. +ida_kernwin.chooser_row_info_t -ida_kernwin.chooser_row_info_t.__eq__ (method) - __eq__(self, other) -> bool - - @param other: chooser_row_info_t const & +ida_kernwin.chooser_row_info_t.__eq__(self, other: "chooser_row_info_t") -> bool -ida_kernwin.chooser_row_info_t.__init__ (method) - __init__(self) -> chooser_row_info_t +ida_kernwin.chooser_row_info_t.__init__(self) -ida_kernwin.chooser_row_info_t.__ne__ (method) - __ne__(self, other) -> bool - - @param other: chooser_row_info_t const & +ida_kernwin.chooser_row_info_t.__ne__(self, other: "chooser_row_info_t") -> bool -ida_kernwin.chooser_row_info_t.attrs (variable) +ida_kernwin.chooser_row_info_t.attrs styling attributes -ida_kernwin.chooser_row_info_t.icon (variable) +ida_kernwin.chooser_row_info_t.icon icon number -ida_kernwin.chooser_row_info_t.texts (variable) +ida_kernwin.chooser_row_info_t.texts texts, one per chooser column -ida_kernwin.chooser_row_info_vec_t (class) - Proxy of C++ qvector< chooser_row_info_t > class. +ida_kernwin.chooser_row_info_vec_t -ida_kernwin.chooser_row_info_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< chooser_row_info_t > const & +ida_kernwin.chooser_row_info_vec_t.__eq__(self, r: "chooser_row_info_vec_t") -> bool -ida_kernwin.chooser_row_info_vec_t.__getitem__ (method) - __getitem__(self, i) -> chooser_row_info_t - - @param i: size_t +ida_kernwin.chooser_row_info_vec_t.__getitem__(self, i: "size_t") -> "chooser_row_info_t const &" -ida_kernwin.chooser_row_info_vec_t.__init__ (method) - __init__(self) -> chooser_row_info_vec_t - __init__(self, x) -> chooser_row_info_vec_t - - @param x: qvector< chooser_row_info_t > const & +ida_kernwin.chooser_row_info_vec_t.__init__(self, *args) -ida_kernwin.chooser_row_info_vec_t.__len__ (method) - __len__(self) -> size_t +ida_kernwin.chooser_row_info_vec_t.__len__(self) -> "size_t" -ida_kernwin.chooser_row_info_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< chooser_row_info_t > const & +ida_kernwin.chooser_row_info_vec_t.__ne__(self, r: "chooser_row_info_vec_t") -> bool -ida_kernwin.chooser_row_info_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: chooser_row_info_t const & +ida_kernwin.chooser_row_info_vec_t.__setitem__(self, i: "size_t", v: "chooser_row_info_t") -> None -ida_kernwin.chooser_row_info_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: chooser_row_info_t const & +ida_kernwin.chooser_row_info_vec_t._del(self, x: "chooser_row_info_t") -> bool -ida_kernwin.chooser_row_info_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: chooser_row_info_t const & +ida_kernwin.chooser_row_info_vec_t.add_unique(self, x: "chooser_row_info_t") -> bool -ida_kernwin.chooser_row_info_vec_t.at (method) - at(self, _idx) -> chooser_row_info_t - - @param _idx: size_t +ida_kernwin.chooser_row_info_vec_t.append(self, x: "chooser_row_info_t") -> None -ida_kernwin.chooser_row_info_vec_t.begin (method) - begin(self) -> chooser_row_info_t +ida_kernwin.chooser_row_info_vec_t.at(self, _idx: "size_t") -> "chooser_row_info_t const &" -ida_kernwin.chooser_row_info_vec_t.capacity (method) - capacity(self) -> size_t +ida_kernwin.chooser_row_info_vec_t.begin(self, *args) -> "qvector< chooser_row_info_t >::const_iterator" -ida_kernwin.chooser_row_info_vec_t.clear (method) - clear(self) +ida_kernwin.chooser_row_info_vec_t.capacity(self) -> "size_t" -ida_kernwin.chooser_row_info_vec_t.empty (method) - empty(self) -> bool +ida_kernwin.chooser_row_info_vec_t.clear(self) -> None -ida_kernwin.chooser_row_info_vec_t.end (method) - end(self) -> chooser_row_info_t +ida_kernwin.chooser_row_info_vec_t.empty(self) -> bool -ida_kernwin.chooser_row_info_vec_t.erase (method) - erase(self, it) -> chooser_row_info_t - - @param it: qvector< chooser_row_info_t >::iterator - - erase(self, first, last) -> chooser_row_info_t - - @param first: qvector< chooser_row_info_t >::iterator - @param last: qvector< chooser_row_info_t >::iterator +ida_kernwin.chooser_row_info_vec_t.end(self, *args) -> "qvector< chooser_row_info_t >::const_iterator" -ida_kernwin.chooser_row_info_vec_t.extract (method) - extract(self) -> chooser_row_info_t +ida_kernwin.chooser_row_info_vec_t.erase(self, *args) -> "qvector< chooser_row_info_t >::iterator" -ida_kernwin.chooser_row_info_vec_t.find (method) - find(self, x) -> chooser_row_info_t - - @param x: chooser_row_info_t const & +ida_kernwin.chooser_row_info_vec_t.extend(self, x: "chooser_row_info_vec_t") -> None -ida_kernwin.chooser_row_info_vec_t.grow (method) - grow(self, x=chooser_row_info_t()) - - @param x: chooser_row_info_t const & +ida_kernwin.chooser_row_info_vec_t.extract(self) -> "chooser_row_info_t *" -ida_kernwin.chooser_row_info_vec_t.has (method) - has(self, x) -> bool - - @param x: chooser_row_info_t const & +ida_kernwin.chooser_row_info_vec_t.find(self, *args) -> "qvector< chooser_row_info_t >::const_iterator" -ida_kernwin.chooser_row_info_vec_t.inject (method) - inject(self, s, len) - - @param s: chooser_row_info_t * - @param len: size_t +ida_kernwin.chooser_row_info_vec_t.grow(self, *args) -> None -ida_kernwin.chooser_row_info_vec_t.insert (method) - insert(self, it, x) -> chooser_row_info_t - - @param it: qvector< chooser_row_info_t >::iterator - @param x: chooser_row_info_t const & +ida_kernwin.chooser_row_info_vec_t.has(self, x: "chooser_row_info_t") -> bool -ida_kernwin.chooser_row_info_vec_t.pop_back (method) - pop_back(self) +ida_kernwin.chooser_row_info_vec_t.inject(self, s: "chooser_row_info_t", len: "size_t") -> None -ida_kernwin.chooser_row_info_vec_t.push_back (method) - push_back(self, x) - - @param x: chooser_row_info_t const & - - push_back(self) -> chooser_row_info_t +ida_kernwin.chooser_row_info_vec_t.insert(self, it: "chooser_row_info_t", x: "chooser_row_info_t") -> "qvector< chooser_row_info_t >::iterator" -ida_kernwin.chooser_row_info_vec_t.qclear (method) - qclear(self) +ida_kernwin.chooser_row_info_vec_t.pop_back(self) -> None -ida_kernwin.chooser_row_info_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_kernwin.chooser_row_info_vec_t.push_back(self, *args) -> "chooser_row_info_t &" -ida_kernwin.chooser_row_info_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: chooser_row_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_kernwin.chooser_row_info_vec_t.qclear(self) -> None -ida_kernwin.chooser_row_info_vec_t.size (method) - size(self) -> size_t +ida_kernwin.chooser_row_info_vec_t.reserve(self, cnt: "size_t") -> None -ida_kernwin.chooser_row_info_vec_t.swap (method) - swap(self, r) - - @param r: qvector< chooser_row_info_t > & +ida_kernwin.chooser_row_info_vec_t.resize(self, *args) -> None -ida_kernwin.chooser_row_info_vec_t.truncate (method) - truncate(self) +ida_kernwin.chooser_row_info_vec_t.size(self) -> "size_t" -ida_kernwin.chooser_stdact_desc_t (class) - Proxy of C++ chooser_stdact_desc_t class. +ida_kernwin.chooser_row_info_vec_t.swap(self, r: "chooser_row_info_vec_t") -> None -ida_kernwin.chooser_stdact_desc_t.__disown__ (method) +ida_kernwin.chooser_row_info_vec_t.truncate(self) -> None -ida_kernwin.chooser_stdact_desc_t.__init__ (method) - __init__(self, _label=None, _tooltip=None, _icon=-1) -> chooser_stdact_desc_t - - @param _label: char const * - @param _tooltip: char const * - @param _icon: int +ida_kernwin.chooser_stdact_desc_t -ida_kernwin.chooser_stdact_desc_t.label (variable) +ida_kernwin.chooser_stdact_desc_t.__disown__(self) + +ida_kernwin.chooser_stdact_desc_t.__init__(self, _label: str = None, _tooltip: str = None, _icon: int = -1) + +ida_kernwin.chooser_stdact_desc_t.label see action_desc_t -ida_kernwin.chooser_stdact_desc_t.ucb (method) - ucb(self, arg0) -> action_state_t - the update callback, see action_handler_t::update() When the update callback is - called from the chooser UI engine, it can be sure that ctx.source.chooser is a - valid pointer to chooser_base_t and that there are selected items for the Delete - and Edit actions. - - @param arg0: action_update_ctx_t * +ida_kernwin.chooser_stdact_desc_t.ucb(self, arg0: "action_ctx_base_t") -> "action_state_t" + the update callback, see action_handler_t::update() When the update callback is called from the chooser UI engine, it can be sure that ctx.source.chooser is a valid pointer to chooser_base_t and that there are selected items for the Delete and Edit actions. + -ida_kernwin.chooser_stdact_desc_t.version (variable) +ida_kernwin.chooser_stdact_desc_t.version to support the backward compatibility -ida_kernwin.chtype_entry (variable) +ida_kernwin.chtype_entry see choose_entry() -ida_kernwin.chtype_enum (variable) +ida_kernwin.chtype_enum see choose_enum() -ida_kernwin.chtype_enum_by_value (variable) - Deprecated. See chtype_enum_by_value_and_size. - -ida_kernwin.chtype_enum_by_value_and_size (variable) +ida_kernwin.chtype_enum_by_value_and_size see choose_enum_by_value() -ida_kernwin.chtype_func (variable) +ida_kernwin.chtype_func see choose_func() -ida_kernwin.chtype_generic (variable) +ida_kernwin.chtype_generic the generic choose() function -ida_kernwin.chtype_idasgn (variable) +ida_kernwin.chtype_idasgn see choose_idasgn() -ida_kernwin.chtype_idatil (variable) +ida_kernwin.chtype_idatil see choose_til() -ida_kernwin.chtype_name (variable) +ida_kernwin.chtype_name see choose_name() -ida_kernwin.chtype_obsolete_enum (variable) - see choose_enum() - -ida_kernwin.chtype_obsolete_enum_by_value_and_size (variable) - see choose_enum_by_value() - -ida_kernwin.chtype_obsolete_struc (variable) - see choose_struc() - -ida_kernwin.chtype_segm (variable) +ida_kernwin.chtype_segm see choose_segm() -ida_kernwin.chtype_srcp (variable) +ida_kernwin.chtype_srcp see choose_srcp() -ida_kernwin.chtype_stkvar_xref (variable) +ida_kernwin.chtype_stkvar_xref see choose_stkvar_xref() -ida_kernwin.chtype_strpath (variable) +ida_kernwin.chtype_strpath see choose_struc_path() -ida_kernwin.chtype_struct (variable) +ida_kernwin.chtype_struct see choose_struct() -ida_kernwin.chtype_xref (variable) +ida_kernwin.chtype_xref see choose_xref() -ida_kernwin.clear_refresh_request (function) - clear_refresh_request(mask) - - @param mask: uint64 +ida_kernwin.clear_refresh_request(mask: "uint64") -> None -ida_kernwin.cli_t (class) +ida_kernwin.cli_t cli_t wrapper class. This class allows you to implement your own command line interface handlers. -ida_kernwin.cli_t.OnCompleteLine (method) - The user pressed Tab. Find a completion number N for prefix PREFIX - - This callback is optional. - - @param prefix: Line prefix at prefix_start (string) - @param n: completion number (int) - @param line: the current line (string) - @param prefix_start: the index where PREFIX starts in LINE (int) - - @return: None if no completion could be generated otherwise a String with the completion suggestion - -ida_kernwin.cli_t.OnExecuteLine (method) +ida_kernwin.cli_t.OnExecuteLine(self, line) The user pressed Enter. The CLI is free to execute the line immediately or ask for more lines. This callback is mandatory. @param line: typed line(s) - @return: Boolean: True-executed line, False-ask for more lines + @return Boolean: True-executed line, False-ask for more lines -ida_kernwin.cli_t.OnKeydown (method) +ida_kernwin.cli_t.OnFindCompletions(self, line, x) + The user pressed Tab. Return a list of completions + + This callback is optional. + + @param line: the current line (string) + @param x: the index where the cursor is (int) + + @return: None if no completion could be generated, otherwise a tuple: + (completions : Sequence[str], hints : Sequence[str], docs: Sequence[str], + match_start: int, match_end: int) + +ida_kernwin.cli_t.OnKeydown(self, line, x, sellen, vkey, shift) A keyboard key has been pressed This is a generic callback and the CLI is free to do whatever it wants. @@ -43397,369 +29196,240 @@ ida_kernwin.cli_t.OnKeydown (method) @param vkey: virtual key code. if the key has been handled, it should be returned as zero @param shift: shift state - @return: None - Nothing was changed + @return: + None - Nothing was changed tuple(line, x, sellen, vkey): if either of the input line or the x coordinate or the selection length has been modified. It is possible to return a tuple with None elements to preserve old values. Example: tuple(new_line, None, None, None) or tuple(new_line) -ida_kernwin.cli_t.__del__ (method) +ida_kernwin.cli_t.__del__(self) -ida_kernwin.cli_t.__init__ (method) +ida_kernwin.cli_t.__init__(self) -ida_kernwin.cli_t.register (method) +ida_kernwin.cli_t.register(self, flags = 0, sname = None, lname = None, hint = None) Registers the CLI. @param flags: Feature bits. No bits are defined yet, must be 0 @param sname: Short name (displayed on the button) @param lname: Long name (displayed in the menu) - @param hint: Hint for the input line + @param hint: Hint for the input line - @return: Boolean: True-Success, False-Failed + @return Boolean: True-Success, False-Failed -ida_kernwin.cli_t.unregister (method) +ida_kernwin.cli_t.unregister(self) Unregisters the CLI (if it was registered) -ida_kernwin.close_chooser (function) - close_chooser(title) -> bool - Close a non-modal chooser (ui_close_chooser). - - @param title: (C++: const char *) window title of chooser to close - @return: success +ida_kernwin.close_chooser(title: str) -> bool + Close a non-modal chooser (ui_close_chooser). + + @param title: window title of chooser to close + @returns success -ida_kernwin.close_widget (function) - close_widget(widget, options) - Close widget (ui_close_widget, only gui version). - - @param widget: (C++: TWidget *) pointer to the widget to close - @param options: (C++: int) Form close flags +ida_kernwin.close_widget(widget: "TWidget *", options: int) -> None + Close widget (ui_close_widget, only gui version). + + @param widget: pointer to the widget to close + @param options: Form close flags -ida_kernwin.clr_cancelled (function) - clr_cancelled() +ida_kernwin.clr_cancelled() -> None Clear "Cancelled" flag (ui_clr_cancelled) -ida_kernwin.create_code_viewer (function) - create_code_viewer(custview, flags=0, parent=None) -> TWidget * - Create a code viewer (ui_create_code_viewer). A code viewer contains on the left - side a widget representing the line numbers, and on the right side, the child - widget passed as parameter. It will inherit its title from the child widget. +ida_kernwin.create_code_viewer(custview: "TWidget *", flags: int = 0, parent: "TWidget *" = None) -> "TWidget *" + Create a code viewer (ui_create_code_viewer). A code viewer contains on the left side a widget representing the line numbers, and on the right side, the child widget passed as parameter. It will inherit its title from the child widget. - @param custview: (C++: TWidget *) the custom view to be added - @param flags: (C++: int) Code viewer flags - @param parent: (C++: TWidget *) widget to contain the new code viewer + @param custview: the custom view to be added + @param flags: Code viewer flags + @param parent: widget to contain the new code viewer -ida_kernwin.create_empty_widget (function) - create_empty_widget(title, icon=-1) -> TWidget * - Create an empty widget, serving as a container for custom user widgets +ida_kernwin.create_empty_widget(title: str, icon: int = -1) -> "TWidget *" + Create an empty widget, serving as a container for custom user widgets + + +ida_kernwin.create_menu(name: str, label: str, menupath: str = None) -> bool + Create a menu with the given name, label and optional position, either in the menubar, or as a submenu. If 'menupath' is non-nullptr, it provides information about where the menu should be positioned. First, IDA will try and resolve the corresponding menu by its name. If such an existing menu is found and is present in the menubar, then the new menu will be inserted in the menubar before it. Otherwise, IDA will try to resolve 'menupath' as it would for attach_action_to_menu() and, if found, add the new menu like so: + The new 'My menu' submenu will appear in the 'Comments' submenu + before the 'Enter comment..." command + "My menu", "Edit/Comments/Enter comment..."); - @param title: (C++: const char *) char const * - @param icon: (C++: int) - -ida_kernwin.create_menu (function) - create_menu(name, label, menupath=None) -> bool - Create a menu with the given name, label and optional position, either in the - menubar, or as a submenu. If 'menupath' is non-nullptr, it provides information - about where the menu should be positioned. First, IDA will try and resolve the - corresponding menu by its name. If such an existing menu is found and is present - in the menubar, then the new menu will be inserted in the menubar before it. - Otherwise, IDA will try to resolve 'menupath' as it would for - attach_action_to_menu() and, if found, add the new menu like so: - // The new 'My menu' submenu will appear in the 'Comments' submenu - // before the 'Enter comment..." command - create_menu("(...)", "My menu", "Edit/Comments/Enter comment..."); - or - // The new 'My menu' submenu will appear at the end of the - // 'Comments' submenu. - create_menu("(...)", "My menu", "Edit/Comments/"); - If the above fails, the new menu will be appended to the menubar. - @param name: (C++: const char *) name of menu (must be unique) - @param label: (C++: const char *) label of menu - @param menupath: (C++: const char *) where should the menu be inserted - @return: success - -ida_kernwin.create_toolbar (function) - create_toolbar(name, label, before=None, flags=0) -> bool - Create a toolbar with the given name, label and optional position + The new 'My menu' submenu will appear at the end of the + 'Comments' submenu. + "My menu", "Edit/Comments/"); - @param name: (C++: const char *) name of toolbar (must be unique) - @param label: (C++: const char *) label of toolbar - @param before: (C++: const char *) if non-nullptr, the toolbar before which the new toolbar will be - inserted - @param flags: (C++: int) a combination of create toolbar flags, to determine toolbar - position - @return: success - -ida_kernwin.custom_viewer_jump (function) - custom_viewer_jump(v, loc, flags=0) -> bool - Append 'loc' to the viewer's history, and cause the viewer to display it. - @param v: (C++: TWidget *) (TWidget *) - @param loc: (C++: const lochist_entry_t &) (const lochist_entry_t &) - @param flags: (C++: uint32) (uint32) or'ed combination of CVNF_* values - @return: success + + @param name: name of menu (must be unique) + @param label: label of menu + @param menupath: where should the menu be inserted + @returns success -ida_kernwin.del_hotkey (function) - del_hotkey(pyctx) -> bool +ida_kernwin.create_toolbar(name: str, label: str, before: str = None, flags: int = 0) -> bool + Create a toolbar with the given name, label and optional position + + @param name: name of toolbar (must be unique) + @param label: label of toolbar + @param before: if non-nullptr, the toolbar before which the new toolbar will be inserted + @param flags: a combination of create toolbar flags, to determine toolbar position + @returns success + +ida_kernwin.custom_viewer_jump(v: "TWidget *", loc: "lochist_entry_t const &", flags: int = 0) -> bool + Append 'loc' to the viewer's history, and cause the viewer to display it. + + @param v: (TWidget *) + @param loc: (const lochist_entry_t &) + @param flags: (uint32) or'ed combination of CVNF_* values + @returns success + +ida_kernwin.del_hotkey(ctx) Deletes a previously registered function hotkey @param ctx: Hotkey context previously returned by add_hotkey() @return: Boolean. -ida_kernwin.del_idc_hotkey (function) - del_idc_hotkey(hotkey) -> bool - - @param hotkey: char const * +ida_kernwin.del_idc_hotkey(hotkey: str) -> bool -ida_kernwin.delete_menu (function) - delete_menu(name) -> bool - Delete an existing menu - - @param name: (C++: const char *) name of menu - @return: success +ida_kernwin.delete_menu(name: str) -> bool + Delete an existing menu + + @param name: name of menu + @returns success -ida_kernwin.delete_toolbar (function) - delete_toolbar(name) -> bool - Delete an existing toolbar - - @param name: (C++: const char *) name of toolbar - @return: success +ida_kernwin.delete_toolbar(name: str) -> bool + Delete an existing toolbar + + @param name: name of toolbar + @returns success -ida_kernwin.detach_action_from_menu (function) - detach_action_from_menu(menupath, name) -> bool - Detach an action from the menu (ui_detach_action_from_menu). - - @param menupath: (C++: const char *) path to the menu item - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.detach_action_from_menu(menupath: str, name: str) -> bool + Detach an action from the menu (ui_detach_action_from_menu). + + @param menupath: path to the menu item + @param name: the action name + @returns success -ida_kernwin.detach_action_from_popup (function) - detach_action_from_popup(widget, name) -> bool - Remove a previously-registered action, from the list of 'permanent' context menu - actions for this widget (ui_detach_action_from_popup). This only makes sense if - the action has been added to 'widget's list of permanent popup actions by - calling attach_action_to_popup in 'permanent' mode. - - @param widget: (C++: TWidget *) target widget - @param name: (C++: const char *) action name +ida_kernwin.detach_action_from_popup(widget: "TWidget *", name: str) -> bool + Remove a previously-registered action, from the list of 'permanent' context menu actions for this widget (ui_detach_action_from_popup). This only makes sense if the action has been added to 'widget's list of permanent popup actions by calling attach_action_to_popup in 'permanent' mode. + + @param widget: target widget + @param name: action name -ida_kernwin.detach_action_from_toolbar (function) - detach_action_from_toolbar(toolbar_name, name) -> bool - Detach an action from the toolbar (ui_detach_action_from_toolbar). - - @param toolbar_name: (C++: const char *) the name of the toolbar - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.detach_action_from_toolbar(toolbar_name: str, name: str) -> bool + Detach an action from the toolbar (ui_detach_action_from_toolbar). + + @param toolbar_name: the name of the toolbar + @param name: the action name + @returns success -ida_kernwin.disabled_script_timeout_t (class) +ida_kernwin.disabled_script_timeout_t -ida_kernwin.disabled_script_timeout_t.__enter__ (method) +ida_kernwin.disabled_script_timeout_t.__enter__(self) -ida_kernwin.disabled_script_timeout_t.__exit__ (method) +ida_kernwin.disabled_script_timeout_t.__exit__(self, type, value, tb) -ida_kernwin.disasm_line_t (class) - Proxy of C++ disasm_line_t class. +ida_kernwin.disasm_line_t -ida_kernwin.disasm_line_t.__init__ (method) - __init__(self) -> disasm_line_t - __init__(self, other) -> disasm_line_t - - @param other: disasm_line_t const & +ida_kernwin.disasm_line_t.__init__(self, *args) -ida_kernwin.disasm_text_t (class) - Proxy of C++ qvector< disasm_line_t > class. +ida_kernwin.disasm_text_t -ida_kernwin.disasm_text_t.__getitem__ (method) - __getitem__(self, i) -> disasm_line_t - - @param i: size_t +ida_kernwin.disasm_text_t.__getitem__(self, i: "size_t") -> "disasm_line_t const &" -ida_kernwin.disasm_text_t.__init__ (method) - __init__(self) -> disasm_text_t - __init__(self, x) -> disasm_text_t - - @param x: qvector< disasm_line_t > const & +ida_kernwin.disasm_text_t.__init__(self, *args) -ida_kernwin.disasm_text_t.__len__ (method) - __len__(self) -> size_t +ida_kernwin.disasm_text_t.__len__(self) -> "size_t" -ida_kernwin.disasm_text_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: disasm_line_t const & +ida_kernwin.disasm_text_t.__setitem__(self, i: "size_t", v: "disasm_line_t") -> None -ida_kernwin.disasm_text_t.at (method) - at(self, _idx) -> disasm_line_t - - @param _idx: size_t +ida_kernwin.disasm_text_t.append(self, x: "disasm_line_t") -> None -ida_kernwin.disasm_text_t.begin (method) - begin(self) -> disasm_line_t +ida_kernwin.disasm_text_t.at(self, _idx: "size_t") -> "disasm_line_t const &" -ida_kernwin.disasm_text_t.capacity (method) - capacity(self) -> size_t +ida_kernwin.disasm_text_t.begin(self, *args) -> "qvector< disasm_line_t >::const_iterator" -ida_kernwin.disasm_text_t.clear (method) - clear(self) +ida_kernwin.disasm_text_t.capacity(self) -> "size_t" -ida_kernwin.disasm_text_t.empty (method) - empty(self) -> bool +ida_kernwin.disasm_text_t.clear(self) -> None -ida_kernwin.disasm_text_t.end (method) - end(self) -> disasm_line_t +ida_kernwin.disasm_text_t.empty(self) -> bool -ida_kernwin.disasm_text_t.erase (method) - erase(self, it) -> disasm_line_t - - @param it: qvector< disasm_line_t >::iterator - - erase(self, first, last) -> disasm_line_t - - @param first: qvector< disasm_line_t >::iterator - @param last: qvector< disasm_line_t >::iterator +ida_kernwin.disasm_text_t.end(self, *args) -> "qvector< disasm_line_t >::const_iterator" -ida_kernwin.disasm_text_t.extract (method) - extract(self) -> disasm_line_t +ida_kernwin.disasm_text_t.erase(self, *args) -> "qvector< disasm_line_t >::iterator" -ida_kernwin.disasm_text_t.grow (method) - grow(self, x=disasm_line_t()) - - @param x: disasm_line_t const & +ida_kernwin.disasm_text_t.extend(self, x: "disasm_text_t") -> None -ida_kernwin.disasm_text_t.inject (method) - inject(self, s, len) - - @param s: disasm_line_t * - @param len: size_t +ida_kernwin.disasm_text_t.extract(self) -> "disasm_line_t *" -ida_kernwin.disasm_text_t.insert (method) - insert(self, it, x) -> disasm_line_t - - @param it: qvector< disasm_line_t >::iterator - @param x: disasm_line_t const & +ida_kernwin.disasm_text_t.grow(self, *args) -> None -ida_kernwin.disasm_text_t.pop_back (method) - pop_back(self) +ida_kernwin.disasm_text_t.inject(self, s: "disasm_line_t", len: "size_t") -> None -ida_kernwin.disasm_text_t.push_back (method) - push_back(self, x) - - @param x: disasm_line_t const & - - push_back(self) -> disasm_line_t +ida_kernwin.disasm_text_t.insert(self, it: "disasm_line_t", x: "disasm_line_t") -> "qvector< disasm_line_t >::iterator" -ida_kernwin.disasm_text_t.qclear (method) - qclear(self) +ida_kernwin.disasm_text_t.pop_back(self) -> None -ida_kernwin.disasm_text_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_kernwin.disasm_text_t.push_back(self, *args) -> "disasm_line_t &" -ida_kernwin.disasm_text_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: disasm_line_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_kernwin.disasm_text_t.qclear(self) -> None -ida_kernwin.disasm_text_t.size (method) - size(self) -> size_t +ida_kernwin.disasm_text_t.reserve(self, cnt: "size_t") -> None -ida_kernwin.disasm_text_t.swap (method) - swap(self, r) - - @param r: qvector< disasm_line_t > & +ida_kernwin.disasm_text_t.resize(self, *args) -> None -ida_kernwin.disasm_text_t.truncate (method) - truncate(self) +ida_kernwin.disasm_text_t.size(self) -> "size_t" -ida_kernwin.display_copyright_warning (function) - display_copyright_warning() -> bool - Display copyright warning (ui_copywarn). - - @return: yes/no +ida_kernwin.disasm_text_t.swap(self, r: "disasm_text_t") -> None -ida_kernwin.display_widget (function) - display_widget(widget, options, dest_ctrl=None) - Display a widget, dock it if not done before - - @param widget: (C++: TWidget *) widget to display - @param options: (C++: uint32) Widget open flags - @param dest_ctrl: (C++: const char *) where to dock: if nullptr or invalid then use the active - docker if there is not create a new tab relative to current - active tab +ida_kernwin.disasm_text_t.truncate(self) -> None -ida_kernwin.ea2str (function) - ea2str(ea) -> str +ida_kernwin.display_copyright_warning() -> bool + Display copyright warning (ui_copywarn). + + @returns yes/no + +ida_kernwin.display_widget(widget: "TWidget *", options: int, dest_ctrl: str = None) -> None + Display a widget, dock it if not done before + + @param widget: widget to display + @param options: Widget open flags + @param dest_ctrl: where to dock: if nullptr or invalid then use the active docker if there is not create a new tab relative to current active tab + +ida_kernwin.ea2str(ea: ida_idaapi.ea_t) -> str Convert linear address to UTF-8 string. - - @param ea: (C++: ea_t) -ida_kernwin.ea_viewer_history_push_and_jump (function) - ea_viewer_history_push_and_jump(v, ea, x, y, lnnum) -> bool - Push current location in the history and jump to the given location - (ui_ea_viewer_history_push_and_jump). This will jump in the given ea viewer and - also in other synchronized views. - - @param v: (C++: TWidget *) ea viewer - @param ea: (C++: ea_t) jump destination - @param x: (C++: int) ,y: coords on screen - @param lnnum: (C++: int) desired line number of given address - @param lnnum: (C++: int) desired line number of given address +ida_kernwin.ea_viewer_history_push_and_jump(v: "TWidget *", ea: ida_idaapi.ea_t, x: int, y: int, lnnum: int) -> bool + Push current location in the history and jump to the given location (ui_ea_viewer_history_push_and_jump). This will jump in the given ea viewer and also in other synchronized views. + + @param v: ea viewer + @param ea: jump destination + @param x: coords on screen + @param y: coords on screen + @param lnnum: desired line number of given address -ida_kernwin.enable_chooser_item_attrs (function) - enable_chooser_item_attrs(chooser_caption, enable) -> bool - Enable item-specific attributes for chooser items - (ui_enable_chooser_item_attrs). For example: color list items differently - depending on a criterium. - If enabled, the chooser will generate ui_get_chooser_item_attrs - events that can be intercepted by a plugin to modify the item attributes. - This event is generated only in the GUI version of IDA. - Specifying CH_ATTRS bit at the chooser creation time has the same effect. - - @param chooser_caption: (C++: const char *) char const * - @param enable: (C++: bool) - @return: success +ida_kernwin.enable_chooser_item_attrs(chooser_caption: str, enable: bool) -> bool + Enable item-specific attributes for chooser items (ui_enable_chooser_item_attrs). For example: color list items differently depending on a criterium. + If enabled, the chooser will generate ui_get_chooser_item_attrs + events that can be intercepted by a plugin to modify the item attributes. + This event is generated only in the GUI version of IDA. + Specifying CH_ATTRS bit at the chooser creation time has the same effect. + + @returns success -ida_kernwin.enumplace_t (class) - Proxy of C++ enumplace_t class. - -ida_kernwin.enumplace_t.__init__ (method) - -ida_kernwin.enumplace_t.bmask (variable) - enum member bitmask - -ida_kernwin.enumplace_t.idx (variable) - enum serial number - -ida_kernwin.enumplace_t.serial (variable) - enum member serial number - -ida_kernwin.enumplace_t.value (variable) - enum member value - -ida_kernwin.error (function) - error(format) +ida_kernwin.error(message) Display a fatal message in a message box and quit IDA @param format: message to print -ida_kernwin.execute_sync (function) - execute_sync(py_callable, reqf) -> int +ida_kernwin.execute_sync(callable, reqf) 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. - @param py_callable: A python callable object, must return an integer value + @param callable: A python callable object, must return an integer value @param reqf: one of MFF_ flags @return: -1 or the return value of the callable -ida_kernwin.execute_ui_requests (function) - execute_ui_requests(py_list) -> bool +ida_kernwin.execute_ui_requests(callable_list) 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. @@ -43768,292 +29438,195 @@ ida_kernwin.execute_ui_requests (function) @note: A callable should return True if it wants to be called more than once. @return: Boolean. False if the list contains a non callable item -ida_kernwin.find_widget (function) - find_widget(caption) -> TWidget * - Find widget with the specified caption (only gui version) (ui_find_widget). NB: - this callback works only with the tabbed widgets! - - @param caption: (C++: const char *) title of tab, or window title if widget is not tabbed - @return: pointer to the TWidget, nullptr if none is found +ida_kernwin.find_widget(caption: str) -> "TWidget *" + Find widget with the specified caption (only gui version) (ui_find_widget). NB: this callback works only with the tabbed widgets! + + @param caption: title of tab, or window title if widget is not tabbed + @returns pointer to the TWidget, nullptr if none is found -ida_kernwin.formchgcbfa_close (function) - formchgcbfa_close(p_fa, close_normally) - - @param p_fa: size_t - @param close_normally: int +ida_kernwin.formchgcbfa_close(p_fa: "size_t", close_normally: int) -> None -ida_kernwin.formchgcbfa_enable_field (function) - formchgcbfa_enable_field(p_fa, fid, enable) -> bool - - @param p_fa: size_t - @param fid: int - @param enable: bool +ida_kernwin.formchgcbfa_enable_field(p_fa: "size_t", fid: int, enable: bool) -> bool -ida_kernwin.formchgcbfa_get_field_value (function) - formchgcbfa_get_field_value(p_fa, fid, ft, sz) -> PyObject * - - @param p_fa: size_t - @param fid: int - @param ft: int - @param sz: size_t +ida_kernwin.formchgcbfa_get_field_value(p_fa: "size_t", fid: int, ft: int, sz: "size_t") -> "PyObject *" -ida_kernwin.formchgcbfa_get_focused_field (function) - formchgcbfa_get_focused_field(p_fa) -> int - - @param p_fa: size_t +ida_kernwin.formchgcbfa_get_focused_field(p_fa: "size_t") -> int -ida_kernwin.formchgcbfa_move_field (function) - formchgcbfa_move_field(p_fa, fid, x, y, w, h) -> bool - - @param p_fa: size_t - @param fid: int - @param x: int - @param y: int - @param w: int - @param h: int +ida_kernwin.formchgcbfa_move_field(p_fa: "size_t", fid: int, x: int, y: int, w: int, h: int) -> bool -ida_kernwin.formchgcbfa_refresh_field (function) - formchgcbfa_refresh_field(p_fa, fid) - - @param p_fa: size_t - @param fid: int +ida_kernwin.formchgcbfa_refresh_field(p_fa: "size_t", fid: int) -> None -ida_kernwin.formchgcbfa_set_field_value (function) - formchgcbfa_set_field_value(p_fa, fid, ft, py_val) -> bool - - @param p_fa: size_t - @param fid: int - @param ft: int - @param py_val: PyObject * +ida_kernwin.formchgcbfa_set_field_value(p_fa: "size_t", fid: int, ft: int, py_val: "PyObject *") -> bool -ida_kernwin.formchgcbfa_set_focused_field (function) - formchgcbfa_set_focused_field(p_fa, fid) -> bool - - @param p_fa: size_t - @param fid: int +ida_kernwin.formchgcbfa_set_focused_field(p_fa: "size_t", fid: int) -> bool -ida_kernwin.formchgcbfa_show_field (function) - formchgcbfa_show_field(p_fa, fid, show) -> bool - - @param p_fa: size_t - @param fid: int - @param show: bool +ida_kernwin.formchgcbfa_show_field(p_fa: "size_t", fid: int, show: bool) -> bool -ida_kernwin.free_custom_icon (function) - free_custom_icon(icon_id) +ida_kernwin.free_custom_icon(icon_id) Frees an icon loaded with load_custom_icon() - @param icon_id: int + @param icon_id: The ID of the icon to free -ida_kernwin.gen_disasm_text (function) - gen_disasm_text(text, ea1, ea2, truncate_lines) - Generate disassembly text for a range. - - @param text: (C++: text_t &) result - @param ea1: (C++: ea_t) start address - @param ea2: (C++: ea_t) end address - @param truncate_lines: (C++: bool) (on idainfo::margin) +ida_kernwin.gen_disasm_text(text: "disasm_text_t", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, truncate_lines: bool) -> None + Generate disassembly text for a range. + + @param text: result + @param ea1: start address + @param ea2: end address + @param truncate_lines: (on idainfo::margin) -ida_kernwin.get_action_checkable (function) - get_action_checkable(name) -> bool - Get an action's checkability (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_checkable(name: str) -> "bool *" + Get an action's checkability (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_action_checked (function) - get_action_checked(name) -> bool - Get an action's checked state (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_checked(name: str) -> "bool *" + Get an action's checked state (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_action_icon (function) - get_action_icon(name) -> bool - Get an action's icon (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_icon(name: str) -> "int *" + Get an action's icon (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_action_label (function) - get_action_label(name) -> str - Get an action's label (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_label(name: str) -> str + Get an action's label (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_action_shortcut (function) - get_action_shortcut(name) -> str - Get an action's shortcut (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_shortcut(name: str) -> str + Get an action's shortcut (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_action_state (function) - get_action_state(name) -> bool - Get an action's state (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_state(name: str) -> "action_state_t *" + Get an action's state (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_action_tooltip (function) - get_action_tooltip(name) -> str - Get an action's tooltip (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_tooltip(name: str) -> str + Get an action's tooltip (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_action_visibility (function) - get_action_visibility(name) -> bool - Get an action's visibility (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success +ida_kernwin.get_action_visibility(name: str) -> "bool *" + Get an action's visibility (ui_get_action_attr). + + @param name: the action name + @returns success -ida_kernwin.get_active_modal_widget (function) - get_active_modal_widget() -> TWidget * - Get the current, active modal TWidget instance. Note that in this context, the - "wait dialog" is not considered: this function will return nullptr even if it is - currently shown. - - @return: TWidget * the active modal widget, or nullptr +ida_kernwin.get_active_modal_widget() -> "TWidget *" + Get the current, active modal TWidget instance. Note that in this context, the "wait dialog" is not considered: this function will return nullptr even if it is currently shown. + + @returns TWidget * the active modal widget, or nullptr -ida_kernwin.get_addon_info (function) - get_addon_info(id, info) -> bool - Get info about a registered addon with a given product code. info->cb must be - valid! NB: all pointers are invalidated by next call to register_addon or - get_addon_info - - @param id: (C++: const char *) char const * - @param info: (C++: addon_info_t *) - @return: false if not found +ida_kernwin.get_addon_info(id: str, info: "addon_info_t") -> bool + Get info about a registered addon with a given product code. info->cb must be valid! NB: all pointers are invalidated by next call to register_addon or get_addon_info + + @returns false if not found -ida_kernwin.get_addon_info_idx (function) - get_addon_info_idx(index, info) -> bool - Get info about a registered addon with specific index. info->cb must be valid! - NB: all pointers are invalidated by next call to register_addon or - get_addon_info - - @param index: (C++: int) - @param info: (C++: addon_info_t *) - @return: false if index is out of range +ida_kernwin.get_addon_info_idx(index: int, info: "addon_info_t") -> bool + Get info about a registered addon with specific index. info->cb must be valid! NB: all pointers are invalidated by next call to register_addon or get_addon_info + + @returns false if index is out of range -ida_kernwin.get_chooser_data (function) - get_chooser_data(chooser_caption, n) -> [str, ...] - Get the text corresponding to the index N in the chooser data. Use -1 to get the - header. +ida_kernwin.get_chooser_data(title: str, n: int) -> List[str] + Get the text corresponding to the index N in the chooser data. + Use -1 to get the header. - See also get_chooser_rows(). - - @param chooser_caption: (C++: const char *) char const * - @param n: (C++: int) + @param title The chooser title + @return a list of strings, or None -ida_kernwin.get_chooser_obj (function) - get_chooser_obj(chooser_caption) -> void * +ida_kernwin.get_chooser_obj(chooser_caption: str) -> "void *" Get the underlying object of the specified chooser (ui_get_chooser_obj). + This attemps to find the choser by its title and, if found, returns the result of calling its chooser_base_t::get_chooser_obj() method. - This attemps to find the choser by its title and, if found, returns the result - of calling its chooser_base_t::get_chooser_obj() method. - - @note: This is object is chooser-specific. - - @param chooser_caption: (C++: const char *) char const * - @return: the object that was used to create the chooser + @returns the object that was used to create the chooser -ida_kernwin.get_chooser_rows (function) - get_chooser_rows(out, chooser_caption, what) -> bool - Get the chooser contents corresponding to the rows indicated by "what". - - @param out: (C++: chooser_row_info_vec_t *) A vector of chooser_row_info_t, one entry per returned row. - @param chooser_caption: (C++: const char *) The caption that identifies the desired chooser. - @param what: (C++: size_t) Either one of the GCRF_ flags, or a row index. - @return: Success. +ida_kernwin.get_chooser_rows(out: "chooser_row_info_vec_t", chooser_caption: str, what: "size_t") -> bool + Get the chooser contents corresponding to the rows indicated by "what". + + @param out: A vector of chooser_row_info_t, one entry per returned row. + @param chooser_caption: The caption that identifies the desired chooser. + @param what: Either one of the GCRF_ flags, or a row index. + @returns Success. -ida_kernwin.get_curline (function) - get_curline() -> char const * - Get current line from the disassemble window (ui_get_curline). - - @return: cptr current line with the color codes (use tag_remove() to remove the - color codes) +ida_kernwin.get_curline() -> str + Get current line from the disassemble window (ui_get_curline). + + @returns cptr current line with the color codes (use tag_remove() to remove the color codes) -ida_kernwin.get_current_viewer (function) - get_current_viewer() -> TWidget * +ida_kernwin.get_current_viewer() -> "TWidget *" Get current ida viewer (idaview or custom viewer) (ui_get_current_viewer) -ida_kernwin.get_current_widget (function) - get_current_widget() -> TWidget * +ida_kernwin.get_current_widget() -> "TWidget *" Get a pointer to the current widget (ui_get_current_widget). -ida_kernwin.get_cursor (function) - get_cursor() -> bool - Get the cursor position on the screen (ui_get_cursor). - @note: coordinates are 0-based - +ida_kernwin.get_cursor() -> "int *, int *" + Get the cursor position on the screen (ui_get_cursor). + @retval true: pointers are filled @retval false: no disassembly window open -ida_kernwin.get_custom_viewer_curline (function) - get_custom_viewer_curline(custom_viewer, mouse) -> char const * - Get current line of custom viewer (ui_get_custom_viewer_curline). The returned - line contains color codes - +ida_kernwin.get_custom_viewer_curline(custom_viewer: "TWidget *", mouse: bool) -> str + Get current line of custom viewer (ui_get_custom_viewer_curline). The returned line contains color codes See also the more powerful get_custom_viewer_location() - @param custom_viewer: (C++: TWidget *) view - @param mouse: (C++: bool) mouse position (otherwise cursor position) - @return: pointer to contents of current line + @param custom_viewer: view + @param mouse: mouse position (otherwise cursor position) + @returns pointer to contents of current line -ida_kernwin.get_custom_viewer_location (function) - get_custom_viewer_location(out, custom_viewer, mouse=False) -> bool - Get the current location in a custom viewer (ui_get_custom_viewer_location_2). +ida_kernwin.get_custom_viewer_location(*args) -> bool + Get information about the current location in a listing - @param out: (C++: listing_location_t *) output structure to fill - @param custom_viewer: (C++: TWidget *) the listing widget - @param flags: (C++: uint32) or'ed combination of CVLF_* values - get_custom_viewer_location(out, custom_viewer, flags=0) -> bool + This function has the following signatures: - @param out: listing_location_t * - @param custom_viewer: TWidget * - @param flags: uint32 + 1. get_custom_viewer_location(out_entry: ida_moves.lochist_entry_t, widget: TWidget, mouse: bool=False) -> bool + 2. get_custom_viewer_location(out_entry: ida_kernwin.listing_location_t, widget: TWidget, flags: int=0) -> bool + + The 2nd form is a superset of the 1st, and retrieves + the text (and tags) of the text. -ida_kernwin.get_custom_viewer_place (function) - get_custom_viewer_place(custom_viewer, mouse) -> place_t +ida_kernwin.get_custom_viewer_place(custom_viewer: "TWidget *", mouse: bool) -> "int *, int *" Get current place in a custom viewer (ui_get_curplace). - See also the more complete get_custom_viewer_location() - @param custom_viewer: (C++: TWidget *) view - @param mouse: (C++: bool) mouse position (otherwise cursor position) + @param custom_viewer: view + @param mouse: mouse position (otherwise cursor position) -ida_kernwin.get_custom_viewer_place_xcoord (function) - get_custom_viewer_place_xcoord(custom_viewer, pline, pitem) -> int - Get the X position of the item, in the line - - @param custom_viewer: (C++: TWidget *) the widget - @param pline: (C++: const place_t *) a place corresponding to the line - @param pitem: (C++: const place_t *) a place corresponding to the item - @return: -1 if 'pitem' is not included in the line - -2 if 'pitem' points at the entire line - >= 0 for the X coordinate within the pline, where pitem points +ida_kernwin.get_custom_viewer_place_xcoord(custom_viewer: "TWidget *", pline: "place_t", pitem: "place_t") -> int + Get the X position of the item, in the line + + @param custom_viewer: the widget + @param pline: a place corresponding to the line + @param pitem: a place corresponding to the item + @retval -1: if 'pitem' is not included in the line + @retval -2: if 'pitem' points at the entire line + @retval >=: 0 for the X coordinate within the pline, where pitem points -ida_kernwin.get_ea_viewer_history_info (function) - get_ea_viewer_history_info(nback, nfwd, v) -> bool - Get information about what's in the history (ui_ea_viewer_history_info). - - @param nback: (C++: int *) number of available back steps - @param nfwd: (C++: int *) number of available forward steps - @param v: (C++: TWidget *) ea viewer +ida_kernwin.get_ea_viewer_history_info(nback: "int *", nfwd: "int *", v: "TWidget *") -> bool + Get information about what's in the history (ui_ea_viewer_history_info). + + @param nback: number of available back steps + @param nfwd: number of available forward steps + @param v: ea viewer @retval false: if the given ea viewer does not exist @retval true: otherwise -ida_kernwin.get_hexdump_ea (function) - get_hexdump_ea(hexdump_num) -> ea_t - Get the current address in a hex view. - - @param hexdump_num: (C++: int) number of hexview window +ida_kernwin.get_hexdump_ea(hexdump_num: int) -> ida_idaapi.ea_t + Get the current address in a hex view. + + @param hexdump_num: number of hexview window -ida_kernwin.get_highlight (function) - get_highlight(v, in_flags=0) -> (str, int) or None +ida_kernwin.get_highlight(v, flags = 0) Returns the currently highlighted identifier and flags @param v: The UI widget to operate on @@ -44061,1990 +29634,1225 @@ ida_kernwin.get_highlight (function) @return: a tuple (text, flags), or None if nothing is highlighted or in case of error. -ida_kernwin.get_icon_id_by_name (function) - get_icon_id_by_name(icon_name) -> int - Retrieve the id of the icon by name (ui_get_icon_id_by_name). - - @param icon_name: (C++: const char *) full name of the icon - @return: icon id +ida_kernwin.get_icon_id_by_name(icon_name: str) -> int + Retrieve the id of the icon by name (ui_get_icon_id_by_name). + + @param icon_name: full name of the icon + @returns icon id -ida_kernwin.get_kernel_version (function) - get_kernel_version() -> str +ida_kernwin.get_kernel_version() -> str Get IDA kernel version (in a string like "5.1"). -ida_kernwin.get_key_code (function) - get_key_code(keyname) -> ushort +ida_kernwin.get_key_code(keyname: str) -> "ushort" Get keyboard key code by its name (ui_get_key_code) - - @param keyname: (C++: const char *) char const * -ida_kernwin.get_navband_ea (function) - get_navband_ea(pixel) -> ea_t +ida_kernwin.get_last_widget(*args) -> "TWidget *" + Get last ida viewer (idaview or custom viewer) (ui_get_last_widget) + + @param mask: an OR'ed set of IWID_* to limit the search to + @returns the viewer, if found + +ida_kernwin.get_navband_ea(pixel: int) -> ida_idaapi.ea_t Translate the pixel position on the navigation band, into an address. - - @param pixel: (C++: int) -ida_kernwin.get_navband_pixel (function) - get_navband_pixel(ea) -> int +ida_kernwin.get_navband_pixel(ea) Maps an address, onto a pixel coordinate within the navigation band @param ea: The address to map @return: a list [pixel, is_vertical] -ida_kernwin.get_opnum (function) - get_opnum() -> int +ida_kernwin.get_opnum() -> int Get current operand number, -1 means no operand (ui_get_opnum) -ida_kernwin.get_output_curline (function) - get_output_curline(mouse) -> str - Get current line of output window (ui_get_output_curline). - - @param mouse: (C++: bool) current for mouse pointer? - @return: false if output contains no text +ida_kernwin.get_output_curline(mouse: bool) -> str + Get current line of output window (ui_get_output_curline). + + @param mouse: current for mouse pointer? + @returns false if output contains no text -ida_kernwin.get_output_cursor (function) - get_output_cursor() -> bool - Get coordinates of the output window's cursor (ui_get_output_cursor). - @note: coordinates are 0-based - @note: this function will succeed even if the output window is not visible - +ida_kernwin.get_output_cursor() -> "int *, int *" + Get coordinates of the output window's cursor (ui_get_output_cursor). + @retval false: the output window has been destroyed. @retval true: pointers are filled -ida_kernwin.get_output_selected_text (function) - get_output_selected_text() -> str - Returns selected text from output window (ui_get_output_selected_text). - - @return: true if there is a selection +ida_kernwin.get_output_selected_text() -> str + Returns selected text from output window (ui_get_output_selected_text). + + @returns true if there is a selection -ida_kernwin.get_place_class (function) - get_place_class(out_flags, out_sdk_version, id) -> place_t - Get information about a previously-registered place_t class. See also - register_place_class(). - - @param out_flags: (C++: int *) output flags (can be nullptr) - @param out_sdk_version: (C++: int *) sdk version the place was created with (can be nullptr) - @param id: (C++: int) place class ID - @return: the place_t template, or nullptr if not found +ida_kernwin.get_place_class(out_flags: "int *", out_sdk_version: "int *", id: int) -> "place_t const *" + Get information about a previously-registered place_t class. See also register_place_class(). + + @param out_flags: output flags (can be nullptr) + @param out_sdk_version: sdk version the place was created with (can be nullptr) + @param id: place class ID + @returns the place_t template, or nullptr if not found -ida_kernwin.get_place_class_id (function) - get_place_class_id(name) -> int - Get the place class ID for the place that has been registered as 'name'. - - @param name: (C++: const char *) the class name - @return: the place class ID, or -1 if not found +ida_kernwin.get_place_class_id(name: str) -> int + Get the place class ID for the place that has been registered as 'name'. + + @param name: the class name + @returns the place class ID, or -1 if not found -ida_kernwin.get_place_class_template (function) - get_place_class_template(id) -> place_t +ida_kernwin.get_place_class_template(id: int) -> "place_t const *" See get_place_class() + +ida_kernwin.get_registered_actions() -> List[str] + Get a list with the names of all currently-registered actions. - @param id: (C++: int) + @return the list of action names -ida_kernwin.get_registered_actions (function) - get_registered_actions() -> [str, ...] - Get a list of all currently-registered actions - -ida_kernwin.get_screen_ea (function) - get_screen_ea() -> ea_t +ida_kernwin.get_screen_ea() -> ida_idaapi.ea_t Get the address at the screen cursor (ui_screenea) -ida_kernwin.get_synced_group (function) - get_synced_group(w) -> synced_group_t - Get the group of widgets/registers this view is synchronized with - - @param w: (C++: const TWidget *) the widget - @return: the group of widgets/registers, or nullptr +ida_kernwin.get_synced_group(w: "TWidget const *") -> "synced_group_t const *" + Get the group of widgets/registers this view is synchronized with + + @param w: the widget + @returns the group of widgets/registers, or nullptr -ida_kernwin.get_tab_size (function) - get_tab_size(path) -> int - Get the size of a tab in spaces (ui_get_tab_size). - - @param path: (C++: const char *) the path of the source view for which the tab size is requested. +ida_kernwin.get_tab_size(path: str) -> int + Get the size of a tab in spaces (ui_get_tab_size). + + @param path: the path of the source view for which the tab size is requested. * if nullptr, the default size is returned. -ida_kernwin.get_user_input_event (function) - get_user_input_event(out) -> bool - Get the current user input event (mouse button press, key press, ...) It is - sometimes desirable to be able to tell when a certain situation happens (e.g., - 'view_curpos' gets triggered); this function exists to provide that context (GUI - version only) - - @param out: (C++: input_event_t *) the input event data - @return: false if we are not currently processing a user input event +ida_kernwin.get_user_input_event(out: "input_event_t") -> bool + Get the current user input event (mouse button press, key press, ...) It is sometimes desirable to be able to tell when a certain situation happens (e.g., 'view_curpos' gets triggered); this function exists to provide that context (GUI version only) + + @param out: the input event data + @returns false if we are not currently processing a user input event -ida_kernwin.get_user_strlist_options (function) - get_user_strlist_options(out) - - @param out: strwinsetup_t * +ida_kernwin.get_user_strlist_options(out: "strwinsetup_t *") -> None -ida_kernwin.get_view_renderer_type (function) - get_view_renderer_type(v) -> tcc_renderer_type_t - Get the type of renderer currently in use in the given view - (ui_get_renderer_type) - - @param v: (C++: TWidget *) +ida_kernwin.get_view_renderer_type(v: "TWidget *") -> "tcc_renderer_type_t" + Get the type of renderer currently in use in the given view (ui_get_renderer_type) -ida_kernwin.get_viewer_place_type (function) - get_viewer_place_type(viewer) -> tcc_place_type_t - Get the type of place_t instances a viewer uses & creates - (ui_get_viewer_place_type). - - @param viewer: (C++: TWidget *) +ida_kernwin.get_viewer_place_type(viewer: "TWidget *") -> "tcc_place_type_t" + Get the type of place_t instances a viewer uses & creates (ui_get_viewer_place_type). -ida_kernwin.get_viewer_user_data (function) - get_viewer_user_data(viewer) -> void * +ida_kernwin.get_viewer_user_data(viewer: "TWidget *") -> "void *" Get the user data from a custom viewer (ui_get_viewer_user_data) - - @param viewer: (C++: TWidget *) -ida_kernwin.get_widget_title (function) - get_widget_title(widget) -> str +ida_kernwin.get_widget_title(widget: "TWidget *") -> str Get the TWidget's title (ui_get_widget_title). - - @param widget: (C++: TWidget *) -ida_kernwin.get_widget_type (function) - get_widget_type(widget) -> twidget_type_t +ida_kernwin.get_widget_type(widget: "TWidget *") -> "twidget_type_t" Get the type of the TWidget * (ui_get_widget_type). - - @param widget: (C++: TWidget *) -ida_kernwin.get_window_id (function) - get_window_id(name=None) -> void * - Get the system-specific window ID (GUI version only) - - @param name: (C++: const char *) name of the window (nullptr means the main IDA window) - @return: the low-level window ID +ida_kernwin.get_window_id(name: str = None) -> "void *" + Get the system-specific window ID (GUI version only) + + @param name: name of the window (nullptr means the main IDA window) + @returns the low-level window ID -ida_kernwin.hide_wait_box (function) - hide_wait_box() +ida_kernwin.hide_wait_box() -> None Hide the "Please wait dialog box". -ida_kernwin.idaplace_t (class) - Proxy of C++ idaplace_t class. +ida_kernwin.idaplace_t -ida_kernwin.idaplace_t.__init__ (method) +ida_kernwin.idaplace_t.__init__(self, *args, **kwargs) -ida_kernwin.idaplace_t.ea (variable) +ida_kernwin.idaplace_t.ea address -ida_kernwin.info (function) - info(format) - - @param format: char const * +ida_kernwin.info(*args) -> "ssize_t" -ida_kernwin.input_event_keyboard_data_t (class) - Proxy of C++ input_event_t::input_event_keyboard_data_t class. +ida_kernwin.input_event_keyboard_data_t -ida_kernwin.input_event_keyboard_data_t.__init__ (method) - __init__(self) -> input_event_keyboard_data_t +ida_kernwin.input_event_keyboard_data_t.__init__(self) -ida_kernwin.input_event_mouse_data_t (class) - Proxy of C++ input_event_t::input_event_mouse_data_t class. +ida_kernwin.input_event_mouse_data_t -ida_kernwin.input_event_mouse_data_t.__init__ (method) - __init__(self) -> input_event_mouse_data_t +ida_kernwin.input_event_mouse_data_t.__init__(self) -ida_kernwin.input_event_shortcut_data_t (class) - Proxy of C++ input_event_t::input_event_shortcut_data_t class. +ida_kernwin.input_event_shortcut_data_t -ida_kernwin.input_event_shortcut_data_t.__init__ (method) - __init__(self) -> input_event_shortcut_data_t +ida_kernwin.input_event_shortcut_data_t.__init__(self) -ida_kernwin.input_event_t (class) - Proxy of C++ input_event_t class. +ida_kernwin.input_event_t -ida_kernwin.input_event_t.__init__ (method) - __init__(self) -> input_event_t +ida_kernwin.input_event_t.__init__(self) -ida_kernwin.input_event_t._source_as_size (method) - _source_as_size(self) -> size_t +ida_kernwin.input_event_t._source_as_size(self) -> "size_t" -ida_kernwin.input_event_t._target_as_size (method) - _target_as_size(self) -> size_t +ida_kernwin.input_event_t._target_as_size(self) -> "size_t" -ida_kernwin.input_event_t.cb (variable) +ida_kernwin.input_event_t.cb size marker -ida_kernwin.input_event_t.get_source_QEvent (method) +ida_kernwin.input_event_t.get_source_QEvent(self) -ida_kernwin.input_event_t.get_target_QWidget (method) +ida_kernwin.input_event_t.get_target_QWidget(self) -ida_kernwin.input_event_t.kind (variable) +ida_kernwin.input_event_t.kind the kind of event -ida_kernwin.input_event_t.modifiers (variable) +ida_kernwin.input_event_t.modifiers current keyboard (and mouse) modifiers -ida_kernwin.input_event_t.source (variable) - the source event, should it be required for detailed inform (e.g., a QEvent in - the GUI version of IDA) +ida_kernwin.input_event_t.source + the source event, should it be required for detailed inform (e.g., a QEvent in the GUI version of IDA) -ida_kernwin.input_event_t.target (variable) +ida_kernwin.input_event_t.target the target widget -ida_kernwin.install_command_interpreter (function) - install_command_interpreter(py_obj) -> int +ida_kernwin.install_command_interpreter(py_obj: "PyObject *") -> int Install command line interpreter (ui_install_cli) - - @param py_obj: PyObject * -ida_kernwin.internal_register_place_class (function) - internal_register_place_class(tmplate, flags, owner, sdk_version) -> int - - @param tmplate: place_t const * - @param flags: int - @param owner: plugin_t const * - @param sdk_version: int +ida_kernwin.internal_register_place_class(tmplate: "place_t", flags: int, owner: "plugin_t const *", sdk_version: int) -> int -ida_kernwin.is_action_enabled (function) - is_action_enabled(s) -> bool +ida_kernwin.is_action_enabled(s: "action_state_t") -> bool Check if the given action state is one of AST_ENABLE*. - - @param s: (C++: action_state_t) enum action_state_t -ida_kernwin.is_chooser_widget (function) - is_chooser_widget(t) -> bool +ida_kernwin.is_chooser_widget(t: "twidget_type_t") -> bool Does the given widget type specify a chooser widget? - - @param t: (C++: twidget_type_t) -ida_kernwin.is_idaq (function) - is_idaq() -> bool +ida_kernwin.is_ida_library(path: "char *", pathsize: "size_t", handle: "void **") -> bool + +ida_kernwin.is_idaq() Returns True or False depending if IDAPython is hosted by IDAQ -ida_kernwin.is_idaview (function) - is_idaview(v) -> bool +ida_kernwin.is_idaview(v: "TWidget *") -> bool Is the given custom view an idaview? (ui_is_idaview) - - @param v: (C++: TWidget *) -ida_kernwin.is_msg_inited (function) - is_msg_inited() -> bool +ida_kernwin.is_msg_inited() -> bool Can we use msg() functions? -ida_kernwin.is_place_class_ea_capable (function) - is_place_class_ea_capable(id) -> bool +ida_kernwin.is_place_class_ea_capable(id: int) -> bool See get_place_class() + +ida_kernwin.is_refresh_requested(mask: "uint64") -> bool + Get a refresh request state + + @param mask: Window refresh flags + @returns the state (set or cleared) + +ida_kernwin.is_tif_cursor_footer(c: "tif_cursor_t") -> bool + +ida_kernwin.is_tif_cursor_header(c: "tif_cursor_t") -> bool + +ida_kernwin.is_tif_cursor_index(c: "tif_cursor_t") -> bool + +ida_kernwin.jobj_wrapper_t + +ida_kernwin.jobj_wrapper_t.__init__(self, *args, **kwargs) + +ida_kernwin.jobj_wrapper_t.get_dict(self) -> dict + Retrieve the contents of this object, as a dict - @param id: (C++: int) + @return a dict containing all kvp's in this object -ida_kernwin.is_refresh_requested (function) - is_refresh_requested(mask) -> bool - Get a refresh request state +ida_kernwin.jumpto(*args) -> bool + This function has the following signatures: - @param mask: (C++: uint64) Window refresh flags - @return: the state (set or cleared) - -ida_kernwin.is_tif_cursor_footer (function) - is_tif_cursor_footer(c) -> bool + 0. jumpto(ea: ida_idaapi.ea_t, opnum: int=-1, uijmp_flags: int=UIJMP_ACTIVATE) -> bool + 1. jumpto(custom_viewer: TWidget *, place: place_t *, x: int, y: int) -> bool - @param c: tif_cursor_t - -ida_kernwin.is_tif_cursor_header (function) - is_tif_cursor_header(c) -> bool + # 0: jumpto(ea: ida_idaapi.ea_t, opnum: int=-1, uijmp_flags: int=UIJMP_ACTIVATE) -> bool - @param c: tif_cursor_t - -ida_kernwin.is_tif_cursor_index (function) - is_tif_cursor_index(c) -> bool + Jump to the specified address (ui_jumpto). + + @returns success - @param c: tif_cursor_t - -ida_kernwin.jobj_wrapper_t (class) - Proxy of C++ jobj_wrapper_t class. - -ida_kernwin.jobj_wrapper_t.__init__ (method) - -ida_kernwin.jobj_wrapper_t.get_dict (method) - get_dict(self) -> dict - -ida_kernwin.jumpto (function) - jumpto(ea, opnum=-1, uijmp_flags=0x0001) -> bool - Set cursor position in custom ida viewer. + # 1: jumpto(custom_viewer: TWidget *, place: place_t *, x: int, y: int) -> bool - @param custom_viewer: (C++: TWidget *) view - @param place: (C++: place_t *) target position - @param uijmp_flags: int - - @return: success - jumpto(custom_viewer, place, x, y) -> bool - - @param custom_viewer: TWidget * - @param place: place_t * - @param x: int + Set cursor position in custom ida viewer. + + @returns success -ida_kernwin.l_compare2 (function) - l_compare2(t1, t2, ud) -> int - - @param t1: place_t const * - @param t2: place_t const * - @param ud: void * +ida_kernwin.l_compare2(t1: "place_t", t2: "place_t", ud: "void *") -> int -ida_kernwin.line_rendering_output_entries_refs_t (class) - Proxy of C++ qvector< line_rendering_output_entry_t * > class. +ida_kernwin.line_rendering_output_entries_refs_t -ida_kernwin.line_rendering_output_entries_refs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< line_rendering_output_entry_t * > const & +ida_kernwin.line_rendering_output_entries_refs_t.__eq__(self, r: "line_rendering_output_entries_refs_t") -> bool -ida_kernwin.line_rendering_output_entries_refs_t.__getitem__ (method) - __getitem__(self, i) -> line_rendering_output_entry_t - - @param i: size_t +ida_kernwin.line_rendering_output_entries_refs_t.__getitem__(self, i: "size_t") -> "line_rendering_output_entry_t *const &" -ida_kernwin.line_rendering_output_entries_refs_t.__init__ (method) - __init__(self) -> line_rendering_output_entries_refs_t - __init__(self, x) -> line_rendering_output_entries_refs_t - - @param x: qvector< line_rendering_output_entry_t * > const & +ida_kernwin.line_rendering_output_entries_refs_t.__init__(self, *args) -ida_kernwin.line_rendering_output_entries_refs_t.__len__ (method) - __len__(self) -> size_t +ida_kernwin.line_rendering_output_entries_refs_t.__len__(self) -> "size_t" -ida_kernwin.line_rendering_output_entries_refs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< line_rendering_output_entry_t * > const & +ida_kernwin.line_rendering_output_entries_refs_t.__ne__(self, r: "line_rendering_output_entries_refs_t") -> bool -ida_kernwin.line_rendering_output_entries_refs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: line_rendering_output_entry_t *const & +ida_kernwin.line_rendering_output_entries_refs_t.__setitem__(self, i: "size_t", v: "line_rendering_output_entry_t") -> None -ida_kernwin.line_rendering_output_entries_refs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: line_rendering_output_entry_t *const & +ida_kernwin.line_rendering_output_entries_refs_t._del(self, x: "line_rendering_output_entry_t") -> bool -ida_kernwin.line_rendering_output_entries_refs_t._internal_push_back (method) - _internal_push_back(self, e) - - Parameters - ---------- - e: line_rendering_output_entry_t * +ida_kernwin.line_rendering_output_entries_refs_t._internal_push_back(self, e: "line_rendering_output_entry_t") -> None -ida_kernwin.line_rendering_output_entries_refs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: line_rendering_output_entry_t *const & +ida_kernwin.line_rendering_output_entries_refs_t.add_unique(self, x: "line_rendering_output_entry_t") -> bool -ida_kernwin.line_rendering_output_entries_refs_t.at (method) - at(self, _idx) -> line_rendering_output_entry_t - - @param _idx: size_t +ida_kernwin.line_rendering_output_entries_refs_t.append(self, x: "line_rendering_output_entry_t") -> None -ida_kernwin.line_rendering_output_entries_refs_t.begin (method) - begin(self) -> qvector< line_rendering_output_entry_t * >::iterator - begin(self) -> qvector< line_rendering_output_entry_t * >::const_iterator +ida_kernwin.line_rendering_output_entries_refs_t.at(self, _idx: "size_t") -> "line_rendering_output_entry_t *const &" -ida_kernwin.line_rendering_output_entries_refs_t.capacity (method) - capacity(self) -> size_t +ida_kernwin.line_rendering_output_entries_refs_t.begin(self, *args) -> "qvector< line_rendering_output_entry_t * >::const_iterator" -ida_kernwin.line_rendering_output_entries_refs_t.clear (method) - clear(self) +ida_kernwin.line_rendering_output_entries_refs_t.capacity(self) -> "size_t" -ida_kernwin.line_rendering_output_entries_refs_t.empty (method) - empty(self) -> bool +ida_kernwin.line_rendering_output_entries_refs_t.clear(self) -> None -ida_kernwin.line_rendering_output_entries_refs_t.end (method) - end(self) -> qvector< line_rendering_output_entry_t * >::iterator - end(self) -> qvector< line_rendering_output_entry_t * >::const_iterator +ida_kernwin.line_rendering_output_entries_refs_t.empty(self) -> bool -ida_kernwin.line_rendering_output_entries_refs_t.erase (method) - erase(self, it) -> qvector< line_rendering_output_entry_t * >::iterator - - @param it: qvector< line_rendering_output_entry_t * >::iterator - - erase(self, first, last) -> qvector< line_rendering_output_entry_t * >::iterator - - @param first: qvector< line_rendering_output_entry_t * >::iterator - @param last: qvector< line_rendering_output_entry_t * >::iterator +ida_kernwin.line_rendering_output_entries_refs_t.end(self, *args) -> "qvector< line_rendering_output_entry_t * >::const_iterator" -ida_kernwin.line_rendering_output_entries_refs_t.extract (method) - extract(self) -> line_rendering_output_entry_t ** +ida_kernwin.line_rendering_output_entries_refs_t.erase(self, *args) -> "qvector< line_rendering_output_entry_t * >::iterator" -ida_kernwin.line_rendering_output_entries_refs_t.find (method) - find(self, x) -> qvector< line_rendering_output_entry_t * >::iterator - - @param x: line_rendering_output_entry_t *const & - - find(self, x) -> qvector< line_rendering_output_entry_t * >::const_iterator - - @param x: line_rendering_output_entry_t *const & +ida_kernwin.line_rendering_output_entries_refs_t.extend(self, x: "line_rendering_output_entries_refs_t") -> None -ida_kernwin.line_rendering_output_entries_refs_t.has (method) - has(self, x) -> bool - - @param x: line_rendering_output_entry_t *const & +ida_kernwin.line_rendering_output_entries_refs_t.extract(self) -> "line_rendering_output_entry_t **" -ida_kernwin.line_rendering_output_entries_refs_t.inject (method) - inject(self, s, len) - - @param s: line_rendering_output_entry_t ** - @param len: size_t +ida_kernwin.line_rendering_output_entries_refs_t.find(self, *args) -> "qvector< line_rendering_output_entry_t * >::const_iterator" -ida_kernwin.line_rendering_output_entries_refs_t.insert (method) - insert(self, it, x) -> qvector< line_rendering_output_entry_t * >::iterator - - @param it: qvector< line_rendering_output_entry_t * >::iterator - @param x: line_rendering_output_entry_t *const & +ida_kernwin.line_rendering_output_entries_refs_t.has(self, x: "line_rendering_output_entry_t") -> bool -ida_kernwin.line_rendering_output_entries_refs_t.pop_back (method) - pop_back(self) +ida_kernwin.line_rendering_output_entries_refs_t.inject(self, s: "line_rendering_output_entry_t **", len: "size_t") -> None -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) - push_back(self, x) - - @param x: line_rendering_output_entry_t *const & - - push_back(self) -> line_rendering_output_entry_t *& +ida_kernwin.line_rendering_output_entries_refs_t.insert(self, it: "qvector< line_rendering_output_entry_t * >::iterator", x: "line_rendering_output_entry_t") -> "qvector< line_rendering_output_entry_t * >::iterator" -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) +ida_kernwin.line_rendering_output_entries_refs_t.pop_back(self) -> None -ida_kernwin.line_rendering_output_entries_refs_t.qclear (method) - qclear(self) +ida_kernwin.line_rendering_output_entries_refs_t.push_back(self, *args) -> "line_rendering_output_entry_t *&" -ida_kernwin.line_rendering_output_entries_refs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_kernwin.line_rendering_output_entries_refs_t.push_back(self, e) -ida_kernwin.line_rendering_output_entries_refs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: line_rendering_output_entry_t *const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_kernwin.line_rendering_output_entries_refs_t.qclear(self) -> None -ida_kernwin.line_rendering_output_entries_refs_t.size (method) - size(self) -> size_t +ida_kernwin.line_rendering_output_entries_refs_t.reserve(self, cnt: "size_t") -> None -ida_kernwin.line_rendering_output_entries_refs_t.swap (method) - swap(self, r) - - @param r: qvector< line_rendering_output_entry_t * > & +ida_kernwin.line_rendering_output_entries_refs_t.resize(self, *args) -> None -ida_kernwin.line_rendering_output_entries_refs_t.truncate (method) - truncate(self) +ida_kernwin.line_rendering_output_entries_refs_t.size(self) -> "size_t" -ida_kernwin.line_rendering_output_entry_t (class) - Proxy of C++ line_rendering_output_entry_t class. +ida_kernwin.line_rendering_output_entries_refs_t.swap(self, r: "line_rendering_output_entries_refs_t") -> None -ida_kernwin.line_rendering_output_entry_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: line_rendering_output_entry_t const & +ida_kernwin.line_rendering_output_entries_refs_t.truncate(self) -> None -ida_kernwin.line_rendering_output_entry_t.__init__ (method) - __init__(self, _line, _flags=0, _bg_color=0) -> line_rendering_output_entry_t - - @param _line: twinline_t const * - @param _flags: uint32 - @param _bg_color: bgcolor_t - - __init__(self, _line, _cpx, _nchars, _flags, _bg_color) -> line_rendering_output_entry_t - - @param _line: twinline_t const * - @param _cpx: int - @param _nchars: int - @param _flags: uint32 - @param _bg_color: bgcolor_t +ida_kernwin.line_rendering_output_entry_t -ida_kernwin.line_rendering_output_entry_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: line_rendering_output_entry_t const & +ida_kernwin.line_rendering_output_entry_t.__eq__(self, r: "line_rendering_output_entry_t") -> bool -ida_kernwin.line_rendering_output_entry_t.cpx (variable) +ida_kernwin.line_rendering_output_entry_t.__init__(self, *args) + +ida_kernwin.line_rendering_output_entry_t.__ne__(self, r: "line_rendering_output_entry_t") -> bool + +ida_kernwin.line_rendering_output_entry_t.cpx number of char to start from, valid if LROEF_CPS_RANGE -ida_kernwin.line_rendering_output_entry_t.flags (variable) +ida_kernwin.line_rendering_output_entry_t.flags line_rendering_output_entry_t flags -ida_kernwin.line_rendering_output_entry_t.is_bg_color_direct (method) - is_bg_color_direct(self) -> bool +ida_kernwin.line_rendering_output_entry_t.is_bg_color_direct(self) -> bool -ida_kernwin.line_rendering_output_entry_t.is_bg_color_empty (method) - is_bg_color_empty(self) -> bool +ida_kernwin.line_rendering_output_entry_t.is_bg_color_empty(self) -> bool -ida_kernwin.line_rendering_output_entry_t.is_bg_color_key (method) - is_bg_color_key(self) -> bool +ida_kernwin.line_rendering_output_entry_t.is_bg_color_key(self) -> bool -ida_kernwin.line_rendering_output_entry_t.nchars (variable) +ida_kernwin.line_rendering_output_entry_t.nchars chars count, valid if LROEF_CPS_RANGE -ida_kernwin.line_section_t (class) - Proxy of C++ line_section_t class. +ida_kernwin.line_section_t -ida_kernwin.line_section_t.__init__ (method) - __init__(self) -> line_section_t +ida_kernwin.line_section_t.__eq__(self, r: "line_section_t") -> bool -ida_kernwin.line_section_t.contains (method) - contains(self, x) -> bool - - @param x: cpidx_t +ida_kernwin.line_section_t.__init__(self) -ida_kernwin.line_section_t.is_closed (method) - is_closed(self) -> bool +ida_kernwin.line_section_t.__ne__(self, r: "line_section_t") -> bool -ida_kernwin.line_section_t.is_open (method) - is_open(self) -> bool +ida_kernwin.line_section_t.contains(self, x: "cpidx_t") -> bool -ida_kernwin.line_section_t.valid (method) - valid(self) -> bool +ida_kernwin.line_section_t.is_closed(self) -> bool -ida_kernwin.linearray_t (class) - Proxy of C++ linearray_t class. +ida_kernwin.line_section_t.is_open(self) -> bool -ida_kernwin.linearray_t.__init__ (method) - __init__(self, _ud) -> linearray_t - - @param _ud: void * +ida_kernwin.line_section_t.valid(self) -> bool -ida_kernwin.linearray_t.beginning (method) - beginning(self) -> bool +ida_kernwin.linearray_t + +ida_kernwin.linearray_t.__init__(self, _ud: "void *") + +ida_kernwin.linearray_t.beginning(self) -> bool Are we at the beginning? -ida_kernwin.linearray_t.down (method) - down(self) -> qstring const * - Get a line from down direction. place is ok BEFORE +ida_kernwin.linearray_t.down(self) -> str + Get a line from down direction. place is ok BEFORE + -ida_kernwin.linearray_t.ending (method) - ending(self) -> bool +ida_kernwin.linearray_t.ending(self) -> bool -ida_kernwin.linearray_t.get_bg_color (method) - get_bg_color(self) -> bgcolor_t - Get current background color. (the same behavior as with get_place(): good - before down() and after up()) +ida_kernwin.linearray_t.get_bg_color(self) -> "bgcolor_t" + Get current background color. (the same behavior as with get_place(): good before down() and after up()) + -ida_kernwin.linearray_t.get_dlnnum (method) - get_dlnnum(self) -> int - Get default line number. (the same behavior as with get_place(): good before - down() and after up()) +ida_kernwin.linearray_t.get_dlnnum(self) -> int + Get default line number. (the same behavior as with get_place(): good before down() and after up()) + -ida_kernwin.linearray_t.get_linecnt (method) - get_linecnt(self) -> int - Get number of lines for the current place. (the same behavior as with - get_place(): good before down() and after up()) +ida_kernwin.linearray_t.get_linecnt(self) -> int + Get number of lines for the current place. (the same behavior as with get_place(): good before down() and after up()) + -ida_kernwin.linearray_t.get_pfx_color (method) - get_pfx_color(self) -> bgcolor_t - Get current prefix color. (the same behavior as with get_place(): good before - down() and after up()) +ida_kernwin.linearray_t.get_pfx_color(self) -> "bgcolor_t" + Get current prefix color. (the same behavior as with get_place(): good before down() and after up()) + -ida_kernwin.linearray_t.get_place (method) - get_place(self) -> place_t - Get the current place. If called before down(), then returns place of line which - will be returned by down(). If called after up(), then returns place if line - returned by up(). +ida_kernwin.linearray_t.get_place(self) -> "place_t *" + Get the current place. If called before down(), then returns place of line which will be returned by down(). If called after up(), then returns place if line returned by up(). + -ida_kernwin.linearray_t.set_place (method) - set_place(self, new_at) -> int - Position the array. This function must be called before calling any other member - functions. +ida_kernwin.linearray_t.set_place(self, new_at: "place_t") -> int + Position the array. This function must be called before calling any other member functions. + linearray_t doesn't own place_t structures. The caller must take care of place_t objects. - linearray_t doesn't own place_t structures. The caller must take care of place_t - objects. - - @param new_at: (C++: const place_t *) new position of the array - @return: the delta of lines that the linearray_t had to adjust the place by. - For example, if the place_t has a lnnum of 5, but it turns out, upon generating - lines, - that the number of lines for that particular place is only 2, then 3 will be - returned. + @param new_at: new position of the array + @returns the delta of lines that the linearray_t had to adjust the place by. + For example, if the place_t has a lnnum of 5, but it turns out, upon generating lines, + that the number of lines for that particular place is only 2, then 3 will be returned. -ida_kernwin.linearray_t.set_userdata (method) - set_userdata(self, userd) +ida_kernwin.linearray_t.set_userdata(self, userd: "void *") -> None Change the user data. - - @param userd: (C++: void *) -ida_kernwin.linearray_t.up (method) - up(self) -> qstring const * - Get a line from up direction. place is ok AFTER +ida_kernwin.linearray_t.up(self) -> str + Get a line from up direction. place is ok AFTER + -ida_kernwin.linearray_t.userdata (method) - userdata(self) -> void * +ida_kernwin.linearray_t.userdata(self) -> "void *" Get pointer to user data. -ida_kernwin.lines_rendering_input_t (class) - Proxy of C++ lines_rendering_input_t class. +ida_kernwin.lines_rendering_input_t -ida_kernwin.lines_rendering_input_t.__init__ (method) - __init__(self) -> lines_rendering_input_t +ida_kernwin.lines_rendering_input_t.__init__(self) -ida_kernwin.lines_rendering_input_t.sections_lines (variable) +ida_kernwin.lines_rendering_input_t.sections_lines references to the lines that are used for rendering -ida_kernwin.lines_rendering_input_t.sync_group (variable) - the 'synced' group 'widget' (see ui_get_lines_rendering_info) belongs to, or - nullptr +ida_kernwin.lines_rendering_input_t.sync_group + the 'synced' group 'widget' (see ui_get_lines_rendering_info) belongs to, or nullptr -ida_kernwin.lines_rendering_output_t (class) - Proxy of C++ lines_rendering_output_t class. +ida_kernwin.lines_rendering_output_t -ida_kernwin.lines_rendering_output_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lines_rendering_output_t const & +ida_kernwin.lines_rendering_output_t.__eq__(self, r: "lines_rendering_output_t") -> bool -ida_kernwin.lines_rendering_output_t.__init__ (method) - __init__(self) -> lines_rendering_output_t +ida_kernwin.lines_rendering_output_t.__init__(self) -ida_kernwin.lines_rendering_output_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lines_rendering_output_t const & +ida_kernwin.lines_rendering_output_t.__ne__(self, r: "lines_rendering_output_t") -> bool -ida_kernwin.lines_rendering_output_t.clear (method) - clear(self) +ida_kernwin.lines_rendering_output_t.clear(self) -> None -ida_kernwin.lines_rendering_output_t.swap (method) - swap(self, r) - - @param r: lines_rendering_output_t & +ida_kernwin.lines_rendering_output_t.swap(self, r: "lines_rendering_output_t") -> None -ida_kernwin.listing_location_t (class) - Proxy of C++ listing_location_t class. +ida_kernwin.listing_location_t -ida_kernwin.listing_location_t.__init__ (method) - __init__(self) -> listing_location_t +ida_kernwin.listing_location_t.__init__(self) -ida_kernwin.load_custom_icon (function) - Loads a custom icon and returns an identifier that can be used with other APIs - - If file_name is passed then the other two arguments are ignored. - - Load an icon and return its id (ui_load_custom_icon). - - @return: icon id +ida_kernwin.load_custom_icon(file_name = None, data = None, format = None) + Load an icon from a file (ui_load_custom_icon_file). Also see load_custom_icon(const void *, unsigned int, const char *) + + @param file_name: path to file + @returns icon id -ida_kernwin.load_dbg_dbginfo (function) - load_dbg_dbginfo(path, li=None, base=BADADDR, verbose=False) -> bool - Load debugging information from a file. - - @param path: (C++: const char *) path to file - @param li: (C++: linput_t *) loader input. if nullptr, check DBG_NAME_KEY - @param base: (C++: ea_t) loading address - @param verbose: (C++: bool) dump status to message window +ida_kernwin.load_dbg_dbginfo(*args) -> bool + Load debugging information from a file. + + @param path: path to file + @param li: loader input. if nullptr, check DBG_NAME_KEY + @param base: loading address + @param verbose: dump status to message window -ida_kernwin.lookup_key_code (function) - lookup_key_code(key, shift, is_qt) -> ushort - Get shortcut code previously created by ui_get_key_code. - - @param key: (C++: int) key constant - @param shift: (C++: int) modifiers - @param is_qt: (C++: bool) are we using gui version? +ida_kernwin.lookup_key_code(key: int, shift: int, is_qt: bool) -> "ushort" + Get shortcut code previously created by ui_get_key_code. + + @param key: key constant + @param shift: modifiers + @param is_qt: are we using gui version? -ida_kernwin.mbox_internal (variable) +ida_kernwin.mbox_internal internal error -ida_kernwin.msg (function) - msg(o) -> int - Display an UTF-8 string in the message window +ida_kernwin.msg(message) + Display a message in the message window - The result of the stringification of the arguments - will be treated as an UTF-8 string. - - @param message: message to print (formatting is done in Python) - - This function can be used to debug IDAPython scripts + @param message: message to print -ida_kernwin.msg_activated (variable) - The message window is activated. +ida_kernwin.msg_activated + The message window is activated. + -ida_kernwin.msg_clear (function) - msg_clear() +ida_kernwin.msg_clear() -> None Clear the "Output" window. -ida_kernwin.msg_click (variable) - Click event. - - @retval 1: handled - @retval 0: not handled (invoke default handler) +ida_kernwin.msg_click + Click event. + -ida_kernwin.msg_closed (variable) - View closed. +ida_kernwin.msg_closed + View closed. + -ida_kernwin.msg_dblclick (variable) - Double click event. - - @retval 1: handled - @retval 0: not handled (invoke default handler) +ida_kernwin.msg_dblclick + Double click event. + -ida_kernwin.msg_deactivated (variable) - The message window is deactivated. +ida_kernwin.msg_deactivated + The message window is deactivated. + -ida_kernwin.msg_get_lines (function) - msg_get_lines(count=-1) -> [str, ...] - Retrieve the last 'count' lines from the output window, in reverse order (from - most recent, to least recent) - - @param count: (C++: int) The number of lines to retrieve. -1 means: all +ida_kernwin.msg_get_lines(count: int = -1) -> "PyObject *" + Retrieve the last 'count' lines from the output window, in reverse order (from most recent, to least recent) + + @param count: The number of lines to retrieve. -1 means: all -ida_kernwin.msg_keydown (variable) - Key down event. - - @retval 1: handled - @retval 0: not handled (invoke default handler) +ida_kernwin.msg_keydown + Key down event. + -ida_kernwin.msg_save (function) - msg_save(path) -> bool - Save the "Output" window contents into a file - - @param path: (C++: qstring &) The path of the file to save the contents into. An empty path means - that the user will be prompted for the destination and, if the file - already exists, the user will be asked to confirm before overriding - its contents. Upon return, 'path' will contain the path that the - user chose. - @return: success +ida_kernwin.msg_save(path: str) -> bool + Save the "Output" window contents into a file + + @param path: The path of the file to save the contents into. An empty path means that the user will be prompted for the destination and, if the file already exists, the user will be asked to confirm before overriding its contents. Upon return, 'path' will contain the path that the user chose. + @returns success -ida_kernwin.nomem (function) - nomem(format) - - @param format: char const * +ida_kernwin.nomem(*args) -> None -ida_kernwin.open_bookmarks_window (function) - open_bookmarks_window(w) -> TWidget * - Open the bookmarks window (ui_open_builtin). - - @param w: (C++: TWidget *) The widget for which the bookmarks will open. For example, this can be - an IDAView, or Enums view, etc. - @return: pointer to resulting window +ida_kernwin.open_bookmarks_window(w: "TWidget *") -> "TWidget *" + Open the bookmarks window (ui_open_builtin). + + @param w: The widget for which the bookmarks will open. For example, this can be an IDAView, or Enums view, etc. + @returns pointer to resulting window -ida_kernwin.open_bpts_window (function) - open_bpts_window(ea) -> TWidget * - Open the breakpoints window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.open_bpts_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the breakpoints window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_calls_window (function) - open_calls_window(ea) -> TWidget * - Open the function calls window (ui_open_builtin). - - @param ea: (C++: ea_t) - @return: pointer to resulting window +ida_kernwin.open_calls_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the function calls window (ui_open_builtin). + + @returns pointer to resulting window -ida_kernwin.open_disasm_window (function) - open_disasm_window(window_title, ranges=None) -> TWidget * - Open a disassembly view (ui_open_builtin). - - @param window_title: (C++: const char *) title of view to open - @param ranges: (C++: const rangevec_t *) if != nullptr, then display a flow chart with the specified - ranges - @return: pointer to resulting window +ida_kernwin.open_disasm_window(window_title: str, ranges: "rangevec_t" = None) -> "TWidget *" + Open a disassembly view (ui_open_builtin). + + @param window_title: title of view to open + @param ranges: if != nullptr, then display a flow chart with the specified ranges + @returns pointer to resulting window -ida_kernwin.open_enums_window (function) - open_enums_window(const_id=BADADDR) -> TWidget * - Open the enums window (ui_open_builtin). - - @param const_id: (C++: tid_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.open_exports_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the exports window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_exports_window (function) - open_exports_window(ea) -> TWidget * - Open the exports window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_form (function) - Display a dockable modeless dialog box and return a handle to it. The modeless - form can be closed in the following ways: +ida_kernwin.open_form(*args) + Display a dockable modeless dialog box and return a handle to it. The modeless form can be closed in the following ways: * by pressing the small 'x' in the window title * by calling form_actions_t::close() from the form callback (form_actions_t) - @note: pressing the 'Yes/No/Cancel' buttons does not close the modeless form, - except if the form callback explicitly calls close(). - @return: handle to the form or nullptr. the handle can be used with TWidget - -ida_kernwin.open_frame_window (function) - open_frame_window(pfn, offset) -> TWidget * - Open the frame window for the given function (ui_open_builtin). - @param pfn: (C++: func_t *) function to analyze - @param offset: (C++: uval_t) offset where the cursor is placed - @return: pointer to resulting window if 'pfn' is a valid function and the window - was displayed, - nullptr otherwise - -ida_kernwin.open_funcs_window (function) - open_funcs_window(ea) -> TWidget * - Open the 'Functions' window (ui_open_builtin). - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window + @param form: dialog box as a string. see ask_form()/open_form() + @param flags: Widget open flags + @returns handle to the form or nullptr. the handle can be used with TWidget functions: close_widget()/activate_widget()/etc -ida_kernwin.open_hexdump_window (function) - open_hexdump_window(window_title) -> TWidget * - Open a hexdump view (ui_open_builtin). - - @param window_title: (C++: const char *) title of view to open - @return: pointer to resulting window +ida_kernwin.open_frame_window(pfn: "func_t *", offset: int) -> "TWidget *" + Open the frame window for the given function (ui_open_builtin). + + @param pfn: function to analyze + @param offset: offset where the cursor is placed + @returns pointer to resulting window if 'pfn' is a valid function and the window was displayed, + nullptr otherwise -ida_kernwin.open_imports_window (function) - open_imports_window(ea) -> TWidget * - Open the exports window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.open_funcs_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the 'Functions' window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_loctypes_window (function) - open_loctypes_window(ordinal, cursor=None) -> TWidget * - Open the local types window (ui_open_builtin). - - @param ordinal: (C++: int) ordinal of type to select by default - @param cursor: (C++: const tif_cursor_t *) cursor to the type member - @return: pointer to resulting window +ida_kernwin.open_hexdump_window(window_title: str) -> "TWidget *" + Open a hexdump view (ui_open_builtin). + + @param window_title: title of view to open + @returns pointer to resulting window -ida_kernwin.open_modules_window (function) - open_modules_window() -> TWidget * - Open the modules window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_imports_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the exports window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_names_window (function) - open_names_window(ea) -> TWidget * - Open the names window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.open_loctypes_window(ordinal: int, cursor: "tif_cursor_t const *" = None) -> "TWidget *" + Open the local types window (ui_open_builtin2). + + @param ordinal: ordinal of type to select by default + @param cursor: cursor to the type member + @returns pointer to resulting window -ida_kernwin.open_navband_window (function) - open_navband_window(ea, zoom) -> TWidget * - Open the navigation band window (ui_open_builtin). - - @param ea: (C++: ea_t) sets the address of the navband arrow - @param zoom: (C++: int) sets the navband zoom level - @return: pointer to resulting window +ida_kernwin.open_modules_window() -> "TWidget *" + Open the modules window (ui_open_builtin). + + @returns pointer to resulting window -ida_kernwin.open_notepad_window (function) - open_notepad_window() -> TWidget * - Open the notepad window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_names_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the names window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_problems_window (function) - open_problems_window(ea) -> TWidget * - Open the problems window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.open_navband_window(ea: ida_idaapi.ea_t, zoom: int) -> "TWidget *" + Open the navigation band window (ui_open_builtin). + + @param ea: sets the address of the navband arrow + @param zoom: sets the navband zoom level + @returns pointer to resulting window -ida_kernwin.open_segments_window (function) - open_segments_window(ea) -> TWidget * - Open the segments window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.open_notepad_window() -> "TWidget *" + Open the notepad window (ui_open_builtin). + + @returns pointer to resulting window -ida_kernwin.open_segregs_window (function) - open_segregs_window(ea) -> TWidget * - Open the segment registers window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.open_problems_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the problems window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_selectors_window (function) - open_selectors_window() -> TWidget * - Open the selectors window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_segments_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the segments window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_signatures_window (function) - open_signatures_window() -> TWidget * - Open the signatures window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_segregs_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the segment registers window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window -ida_kernwin.open_stack_window (function) - open_stack_window() -> TWidget * - Open the call stack window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_selectors_window() -> "TWidget *" + Open the selectors window (ui_open_builtin). + + @returns pointer to resulting window -ida_kernwin.open_strings_window (function) - open_strings_window(ea, selstart=BADADDR, selend=BADADDR) -> TWidget * - Open the 'Strings' window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @param selstart: (C++: ea_t) ,selend: only display strings that occur within this range - @param selend: (C++: ea_t) - @return: pointer to resulting window +ida_kernwin.open_signatures_window() -> "TWidget *" + Open the signatures window (ui_open_builtin). + + @returns pointer to resulting window -ida_kernwin.open_structs_window (function) - open_structs_window(id=BADADDR, offset=0) -> TWidget * - Open the structs window (ui_open_builtin). - - @param id: (C++: tid_t) index of entry to select by default - @param offset: (C++: uval_t) offset where the cursor is placed - @return: pointer to resulting window +ida_kernwin.open_stack_window() -> "TWidget *" + Open the call stack window (ui_open_builtin). + + @returns pointer to resulting window -ida_kernwin.open_threads_window (function) - open_threads_window() -> TWidget * - Open the threads window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_strings_window(*args) -> "TWidget *" + Open the 'Strings' window (ui_open_builtin). + + @param ea: index of entry to select by default + @param selstart: only display strings that occur within this range + @param selend: only display strings that occur within this range + @returns pointer to resulting window -ida_kernwin.open_tils_window (function) - open_tils_window() -> TWidget * - Open the type libraries window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_threads_window() -> "TWidget *" + Open the threads window (ui_open_builtin). + + @returns pointer to resulting window -ida_kernwin.open_trace_window (function) - open_trace_window() -> TWidget * - Open the tracing window (ui_open_builtin). - - @return: pointer to resulting window +ida_kernwin.open_til_view_window(tif: "tinfo_t", cursor: "tif_cursor_t const *" = None) -> "TWidget *" + Open the sub-til window (ui_open_builtin2). + + @param tif: tif to open + @param cursor: cursor to the type member + @returns pointer to resulting window -ida_kernwin.open_url (function) - open_url(url) +ida_kernwin.open_tils_window() -> "TWidget *" + Open the type libraries window (ui_open_builtin). + + @returns pointer to resulting window + +ida_kernwin.open_trace_window() -> "TWidget *" + Open the tracing window (ui_open_builtin). + + @returns pointer to resulting window + +ida_kernwin.open_url(url: str) -> None Open the given url (ui_open_url) + +ida_kernwin.open_xrefs_window(ea: ida_idaapi.ea_t) -> "TWidget *" + Open the cross references window (ui_open_builtin). + + @param ea: index of entry to select by default + @returns pointer to resulting window + +ida_kernwin.parse_tagged_line_sections(out: "tagged_line_sections_t", line: str) -> bool + Collect tagged sections in a color-tagged line (produced by `place_t::generate`) - @param url: (C++: const char *) char const * + @param out: sections storage + @param line: input line + @returns success -ida_kernwin.open_xrefs_window (function) - open_xrefs_window(ea) -> TWidget * - Open the cross references window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window +ida_kernwin.place_t -ida_kernwin.place_t (class) - Proxy of C++ place_t class. +ida_kernwin.place_t.__init__(self, *args, **kwargs) -ida_kernwin.place_t.__init__ (method) +ida_kernwin.place_t._print(self, ud: "void *") -> None -ida_kernwin.place_t._print (method) - _print(self, ud) - - Parameters - ---------- - ud: void * +ida_kernwin.place_t.adjust(self, ud: "void *") -> None + Adjust the current location to point to a displayable object. This function validates the location and makes sure that it points to an existing object. For example, if the location points to the middle of an instruction, it will be adjusted to point to the beginning of the instruction. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t -ida_kernwin.place_t.adjust (method) - adjust(self, ud) - Adjust the current location to point to a displayable object. This function - validates the location and makes sure that it points to an existing object. For - example, if the location points to the middle of an instruction, it will be - adjusted to point to the beginning of the instruction. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t +ida_kernwin.place_t.as_idaplace_t(p: "place_t") -> "idaplace_t *" -ida_kernwin.place_t.as_enumplace_t (method) - as_enumplace_t(p) -> enumplace_t - - @param p: place_t * +ida_kernwin.place_t.as_simpleline_place_t(p: "place_t") -> "simpleline_place_t *" -ida_kernwin.place_t.as_idaplace_t (method) - as_idaplace_t(p) -> idaplace_t - - @param p: place_t * +ida_kernwin.place_t.as_tiplace_t(p: "place_t") -> "tiplace_t *" -ida_kernwin.place_t.as_simpleline_place_t (method) - as_simpleline_place_t(p) -> simpleline_place_t - - @param p: place_t * +ida_kernwin.place_t.beginning(self, ud: "void *") -> bool + Are we at the first displayable object?. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @returns true if the current location points to the first displayable object -ida_kernwin.place_t.as_structplace_t (method) - as_structplace_t(p) -> structplace_t - - @param p: place_t * +ida_kernwin.place_t.clone(self) -> "place_t *" + Clone the location. + + @returns a pointer to a copy of the current location in dynamic memory -ida_kernwin.place_t.as_tiplace_t (method) - as_tiplace_t(p) -> tiplace_t - - @param p: place_t * - -ida_kernwin.place_t.beginning (method) - beginning(self, ud) -> bool - Are we at the first displayable object?. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: true if the current location points to the first displayable object - -ida_kernwin.place_t.clone (method) - clone(self) -> place_t - Clone the location. - - @return: a pointer to a copy of the current location in dynamic memory - -ida_kernwin.place_t.compare (method) - compare(self, t2) -> int +ida_kernwin.place_t.compare(self, t2: "place_t") -> int Deprecated. Please consider compare2(const place_t *, void *) instead. - - @param t2: (C++: const place_t *) place_t const * -ida_kernwin.place_t.compare2 (method) - compare2(self, t2, arg3) -> int - Compare two locations except line numbers (lnnum). This function is used to - organize loops. For example, if the user has selected an range, its boundaries - are remembered as location objects. Any operation within the selection will have - the following look: for ( loc=starting_location; loc < ending_location; - loc.next() ) In this loop, the comparison function is used. - - @param t2: (C++: const place_t *) the place to compare this one to. - @param arg3: void * +ida_kernwin.place_t.compare2(self, t2: "place_t", arg3: "void *") -> int + Compare two locations except line numbers (lnnum). This function is used to organize loops. For example, if the user has selected an range, its boundaries are remembered as location objects. Any operation within the selection will have the following look: for ( loc=starting_location; loc < ending_location; loc.next() ) In this loop, the comparison function is used. + + @param t2: the place to compare this one to. + @retval -1: if the current location is less than 't2' + @retval 0: if the current location is equal to than 't2' + @retval 1: if the current location is greater than 't2' -ida_kernwin.place_t.copyfrom (method) - copyfrom(self, _from) +ida_kernwin.place_t.copyfrom(self, _from: "place_t") -> None Copy the specified location object to the current object. - - @param from: (C++: const place_t *) place_t const * -ida_kernwin.place_t.deserialize (method) - deserialize(self, _in) -> bool - De-serialize into this instance. 'pptr' should be incremented by as many bytes - as de-serialization consumed. - - @param pptr: (C++: const uchar **) pointer to a serialized representation of a place_t of this type. - @return: whether de-serialization was successful +ida_kernwin.place_t.deserialize(self, _in: "bytevec_t const &") -> bool + De-serialize into this instance. 'pptr' should be incremented by as many bytes as de-serialization consumed. + + @returns whether de-serialization was successful -ida_kernwin.place_t.ending (method) - ending(self, ud) -> bool - Are we at the last displayable object?. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: true if the current location points to the last displayable object +ida_kernwin.place_t.ending(self, ud: "void *") -> bool + Are we at the last displayable object?. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @returns true if the current location points to the last displayable object -ida_kernwin.place_t.enter (method) - enter(self, arg2) -> place_t - Visit this place, possibly 'unhiding' a section of text. If entering that place - required some expanding, a place_t should be returned that represents that - section, plus some flags for later use by 'leave()'. - - @param out_flags: flags to be used together with the place_t that is returned, - in order to restore the section to its original state when - leave() is called. - @return: a place_t corresponding to the beginning of the section of text that - had to be expanded. That place_t's leave() will be called with the - flags contained in 'out_flags' when the user navigates away from it. +ida_kernwin.place_t.enter(self, arg2: "uint32 *") -> "place_t *" + Visit this place, possibly 'unhiding' a section of text. If entering that place required some expanding, a place_t should be returned that represents that section, plus some flags for later use by 'leave()'. + + @returns a place_t corresponding to the beginning of the section of text that had to be expanded. That place_t's leave() will be called with the flags contained in 'out_flags' when the user navigates away from it. -ida_kernwin.place_t.generate (method) - generate(self, ud, maxsize) -> ([str, ...], int, int, int) +ida_kernwin.place_t.generate(self, ud, maxsize: int) -> Tuple[List[str], int, int, int] Generate text lines for the current location. - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @param maxsize: (C++: int) the maximum number of lines to generate - @return: number of generated lines + @param ud The user data object + @param maxsize The maximum number of lines to generate + @return a tuple (lines-of-text, default-line-number, prefix-color, background-color) -ida_kernwin.place_t.id (method) - id(self) -> int - Get the place's ID (i.e., the value returned by register_place_class()) - - @return: the id +ida_kernwin.place_t.id(self) -> int + Get the place's ID (i.e., the value returned by register_place_class()) + + @returns the id -ida_kernwin.place_t.leave (method) - leave(self, arg2) - Leave this place, possibly 'hiding' a section of text that was previously - expanded (at enter()-time.) - - @param arg2: uint32 +ida_kernwin.place_t.leave(self, arg2: int) -> None + Leave this place, possibly 'hiding' a section of text that was previously expanded (at enter()-time.) + -ida_kernwin.place_t.lnnum (variable) +ida_kernwin.place_t.lnnum Number of line within the current object. -ida_kernwin.place_t.makeplace (method) - makeplace(self, ud, x, lnnum) -> place_t - Map a number to a location. When the user clicks on the scrollbar and drags it, - we need to determine the location corresponding to the new scrollbar position. - This function is used to determine it. It builds a location object for the - specified 'x' and returns a pointer to it. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @param x: (C++: uval_t) number to map - @param lnnum: (C++: int) line number to initialize 'lnnum' - @return: a freshly allocated object. See also PCF_MAKEPLACE_ALLOCATES +ida_kernwin.place_t.makeplace(self, ud: "void *", x: int, lnnum: int) -> "place_t *" + Map a number to a location. When the user clicks on the scrollbar and drags it, we need to determine the location corresponding to the new scrollbar position. This function is used to determine it. It builds a location object for the specified 'x' and returns a pointer to it. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @param x: number to map + @param lnnum: line number to initialize 'lnnum' + @returns a freshly allocated object. See also PCF_MAKEPLACE_ALLOCATES -ida_kernwin.place_t.name (method) - name(self) -> char const * - Get this place type name. All instances of a given class must return the same - string. - - @return: the place type name. Please try and pick something that is not too - generic, as it might clash w/ other plugins. A good practice is to - prefix the class name with the name of your plugin. E.g., - "myplugin:srcplace_t". +ida_kernwin.place_t.name(self) -> str + Get this place type name. All instances of a given class must return the same string. + + @returns the place type name. Please try and pick something that is not too generic, as it might clash w/ other plugins. A good practice is to prefix the class name with the name of your plugin. E.g., "myplugin:srcplace_t". -ida_kernwin.place_t.next (method) - next(self, ud) -> bool - Move to the next displayable location. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: success +ida_kernwin.place_t.next(self, ud: "void *") -> bool + Move to the next displayable location. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @returns success -ida_kernwin.place_t.prev (method) - prev(self, ud) -> bool - Move to the previous displayable location. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: success +ida_kernwin.place_t.prev(self, ud: "void *") -> bool + Move to the previous displayable location. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @returns success -ida_kernwin.place_t.rebase (method) - rebase(self, arg2) -> bool - Rebase the place instance - - @param arg2: segm_move_infos_t const & - @return: true if place was rebased, false otherwise +ida_kernwin.place_t.rebase(self, arg2: "segm_move_infos_t const &") -> bool + Rebase the place instance + + @returns true if place was rebased, false otherwise -ida_kernwin.place_t.serialize (method) - serialize(self) - Serialize this instance. It is fundamental that all instances of a particular - subclass of of place_t occupy the same number of bytes when serialized. +ida_kernwin.place_t.serialize(self) -> None + Serialize this instance. It is fundamental that all instances of a particular subclass of of place_t occupy the same number of bytes when serialized. + -ida_kernwin.place_t.toea (method) - toea(self) -> ea_t - Map the location to an ea_t. - - @return: the corresponding ea_t, or BADADDR; +ida_kernwin.place_t.toea(self) -> ida_idaapi.ea_t + Map the location to an ea_t. + + @returns the corresponding ea_t, or BADADDR; -ida_kernwin.place_t.touval (method) - touval(self, ud) -> uval_t - Map the location to a number. This mapping is used to draw the vertical - scrollbar. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t +ida_kernwin.place_t.touval(self, ud: "void *") -> int + Map the location to a number. This mapping is used to draw the vertical scrollbar. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t -ida_kernwin.place_t_as_enumplace_t (function) - place_t_as_enumplace_t(p) -> enumplace_t - - @param p: place_t * +ida_kernwin.plgform_close(py_link: "PyObject *", options: int) -> None -ida_kernwin.place_t_as_idaplace_t (function) - place_t_as_idaplace_t(p) -> idaplace_t - - @param p: place_t * +ida_kernwin.plgform_get_widget(py_link: "PyObject *") -> "TWidget *" -ida_kernwin.place_t_as_simpleline_place_t (function) - place_t_as_simpleline_place_t(p) -> simpleline_place_t - - @param p: place_t * +ida_kernwin.plgform_new() -> "PyObject *" -ida_kernwin.place_t_as_structplace_t (function) - place_t_as_structplace_t(p) -> structplace_t - - @param p: place_t * +ida_kernwin.plgform_show(*args) -> bool -ida_kernwin.place_t_as_tiplace_t (function) - place_t_as_tiplace_t(p) -> tiplace_t - - @param p: place_t * - -ida_kernwin.plgform_close (function) - plgform_close(py_link, options) - - @param py_link: PyObject * - @param options: int - -ida_kernwin.plgform_get_widget (function) - plgform_get_widget(py_link) -> TWidget * - - @param py_link: PyObject * - -ida_kernwin.plgform_new (function) - plgform_new() -> PyObject * - -ida_kernwin.plgform_show (function) - plgform_show(py_link, py_obj, caption, options=(0x0040 << 16)|0x00000004u) -> bool - - @param py_link: PyObject * - @param py_obj: PyObject * - @param caption: char const * - @param options: int - -ida_kernwin.process_ui_action (function) - process_ui_action(name, flags=0) -> bool +ida_kernwin.process_ui_action(name: str, flags: int = 0) Invokes an IDA UI action by name - @param name: action name - @param flags: int + @param name: action name + @param flags: reserved @return: Boolean -ida_kernwin.py_chooser_base_t_get_row (function) - py_chooser_base_t_get_row(chobj, n) -> PyObject * - - @param chobj: chooser_base_t const * - @param n: size_t +ida_kernwin.prompt_function_prototype(out_tif: "tinfo_t", pfn: "func_t *", tif: "tinfo_t", name: str) -> str + Open function prototype editor to edit function type and create new type. Allows to change the function prototype either in the "old" one-liner mode or in the new multi-line editor, which supports shortcuts, etc. Note: changes will not apply! It is the caller's job to apply the resulting out_tif. Parameters: + + @param out_tif: - (tinfo_t *) tif for created type + @param pfn: - (func_t *) editing function + @param tif: - (tinfo_t *) current function type + @param name: - (const char *) function name + @returns true if new type created successfully -ida_kernwin.py_get_ask_form (function) - py_get_ask_form() -> size_t +ida_kernwin.py_chooser_base_t_get_row(chobj: "chooser_base_t", n: "size_t") -> "PyObject *" -ida_kernwin.py_get_open_form (function) - py_get_open_form() -> size_t +ida_kernwin.py_get_ask_form() -> "size_t" -ida_kernwin.py_load_custom_icon_data (function) - py_load_custom_icon_data(data, format) -> int - - @param data: PyObject * - @param format: char const * +ida_kernwin.py_get_open_form() -> "size_t" -ida_kernwin.py_load_custom_icon_fn (function) - py_load_custom_icon_fn(filename) -> int - - @param filename: char const * +ida_kernwin.py_load_custom_icon_data(data: "PyObject *", format: str) -> int -ida_kernwin.py_register_compiled_form (function) - py_register_compiled_form(py_form) - - @param py_form: PyObject * +ida_kernwin.py_load_custom_icon_fn(filename: str) -> int -ida_kernwin.py_unregister_compiled_form (function) - py_unregister_compiled_form(py_form) - - @param py_form: PyObject * +ida_kernwin.py_register_compiled_form(py_form: "PyObject *") -> None -ida_kernwin.pyidag_bind (function) - pyidag_bind(_self) -> bool - - @param self: PyObject * +ida_kernwin.py_unregister_compiled_form(py_form: "PyObject *") -> None -ida_kernwin.pyidag_unbind (function) - pyidag_unbind(_self) -> bool - - @param self: PyObject * +ida_kernwin.pyidag_bind(_self: "PyObject *") -> bool -ida_kernwin.pyscv_add_line (function) - pyscv_add_line(py_this, py_sl) -> bool - - @param py_this: PyObject * - @param py_sl: PyObject * +ida_kernwin.pyidag_unbind(_self: "PyObject *") -> bool -ida_kernwin.pyscv_clear_lines (function) - pyscv_clear_lines(py_this) -> PyObject * - - @param py_this: PyObject * +ida_kernwin.pyscv_add_line(py_this: "PyObject *", py_sl: "PyObject *") -> bool -ida_kernwin.pyscv_close (function) - pyscv_close(py_this) - - @param py_this: PyObject * +ida_kernwin.pyscv_clear_lines(py_this: "PyObject *") -> "PyObject *" -ida_kernwin.pyscv_count (function) - pyscv_count(py_this) -> size_t - - @param py_this: PyObject * +ida_kernwin.pyscv_close(py_this: "PyObject *") -> None -ida_kernwin.pyscv_del_line (function) - pyscv_del_line(py_this, nline) -> bool - - @param py_this: PyObject * - @param nline: size_t +ida_kernwin.pyscv_count(py_this: "PyObject *") -> "size_t" -ida_kernwin.pyscv_edit_line (function) - pyscv_edit_line(py_this, nline, py_sl) -> bool - - @param py_this: PyObject * - @param nline: size_t - @param py_sl: PyObject * +ida_kernwin.pyscv_del_line(py_this: "PyObject *", nline: "size_t") -> bool -ida_kernwin.pyscv_get_current_line (function) - pyscv_get_current_line(py_this, mouse, notags) -> PyObject * - - @param py_this: PyObject * - @param mouse: bool - @param notags: bool +ida_kernwin.pyscv_edit_line(py_this: "PyObject *", nline: "size_t", py_sl: "PyObject *") -> bool -ida_kernwin.pyscv_get_current_word (function) - pyscv_get_current_word(py_this, mouse) -> PyObject * - - @param py_this: PyObject * - @param mouse: bool +ida_kernwin.pyscv_get_current_line(py_this: "PyObject *", mouse: bool, notags: bool) -> "PyObject *" -ida_kernwin.pyscv_get_line (function) - pyscv_get_line(py_this, nline) -> PyObject * - - @param py_this: PyObject * - @param nline: size_t +ida_kernwin.pyscv_get_current_word(py_this: "PyObject *", mouse: bool) -> "PyObject *" -ida_kernwin.pyscv_get_pos (function) - pyscv_get_pos(py_this, mouse) -> PyObject * - - @param py_this: PyObject * - @param mouse: bool +ida_kernwin.pyscv_get_line(py_this: "PyObject *", nline: "size_t") -> "PyObject *" -ida_kernwin.pyscv_get_selection (function) - pyscv_get_selection(py_this) -> PyObject * - - @param py_this: PyObject * +ida_kernwin.pyscv_get_pos(py_this: "PyObject *", mouse: bool) -> "PyObject *" -ida_kernwin.pyscv_get_widget (function) - pyscv_get_widget(py_this) -> TWidget * - - @param py_this: PyObject * +ida_kernwin.pyscv_get_selection(py_this: "PyObject *") -> "PyObject *" -ida_kernwin.pyscv_init (function) - pyscv_init(py_link, title) -> PyObject * - - @param py_link: PyObject * - @param title: char const * +ida_kernwin.pyscv_get_widget(py_this: "PyObject *") -> "TWidget *" -ida_kernwin.pyscv_insert_line (function) - pyscv_insert_line(py_this, nline, py_sl) -> bool - - @param py_this: PyObject * - @param nline: size_t - @param py_sl: PyObject * +ida_kernwin.pyscv_init(py_link: "PyObject *", title: str) -> "PyObject *" -ida_kernwin.pyscv_is_focused (function) - pyscv_is_focused(py_this) -> bool - - @param py_this: PyObject * +ida_kernwin.pyscv_insert_line(py_this: "PyObject *", nline: "size_t", py_sl: "PyObject *") -> bool -ida_kernwin.pyscv_jumpto (function) - pyscv_jumpto(py_this, ln, x, y) -> bool - - @param py_this: PyObject * - @param ln: size_t - @param x: int - @param y: int +ida_kernwin.pyscv_is_focused(py_this: "PyObject *") -> bool -ida_kernwin.pyscv_patch_line (function) - pyscv_patch_line(py_this, nline, offs, value) -> bool - - @param py_this: PyObject * - @param nline: size_t - @param offs: size_t - @param value: int +ida_kernwin.pyscv_jumpto(py_this: "PyObject *", ln: "size_t", x: int, y: int) -> bool -ida_kernwin.pyscv_refresh (function) - pyscv_refresh(py_this) -> bool - - @param py_this: PyObject * +ida_kernwin.pyscv_patch_line(py_this: "PyObject *", nline: "size_t", offs: "size_t", value: int) -> bool -ida_kernwin.pyscv_show (function) - pyscv_show(py_this) -> bool - - @param py_this: PyObject * +ida_kernwin.pyscv_refresh(py_this: "PyObject *") -> bool -ida_kernwin.qcleanline (function) - qcleanline(cmt_char='\0', flags=((1 << 0)|(1 << 1))|(1 << 2)) -> str - Performs some cleanup operations to a line. - - @param cmt_char: (C++: char) character that denotes the start of a comment: - * the entire text is removed if the line begins with this character (ignoring - leading spaces) - * all text after (and including) this character is removed if flag CLNL_FINDCMT - is set - @param flags: (C++: uint32) a combination of line cleanup flags. defaults to CLNL_TRIM - @return: length of line +ida_kernwin.pyscv_show(py_this: "PyObject *") -> bool -ida_kernwin.quick_widget_commands_t (class) +ida_kernwin.qcleanline(*args) -> str + Performs some cleanup operations to a line. + + @param buf: string to modify + @param cmt_char: character that denotes the start of a comment: + * the entire text is removed if the line begins with this character (ignoring leading spaces) + * all text after (and including) this character is removed if flag CLNL_FINDCMT is set + @param flags: a combination of line cleanup flags. defaults to CLNL_TRIM + @returns length of line -ida_kernwin.quick_widget_commands_t.__init__ (method) +ida_kernwin.quick_widget_commands_t -ida_kernwin.quick_widget_commands_t._ah_t (class) +ida_kernwin.quick_widget_commands_t.__init__(self, callback) -ida_kernwin.quick_widget_commands_t._ah_t.__init__ (method) +ida_kernwin.quick_widget_commands_t._ah_t -ida_kernwin.quick_widget_commands_t._ah_t.activate (method) +ida_kernwin.quick_widget_commands_t._ah_t.__init__(self, parent, cmd_id) -ida_kernwin.quick_widget_commands_t._ah_t.update (method) +ida_kernwin.quick_widget_commands_t._ah_t.activate(self, ctx) -ida_kernwin.quick_widget_commands_t._cmd_t (class) +ida_kernwin.quick_widget_commands_t._ah_t.update(self, ctx) -ida_kernwin.quick_widget_commands_t._cmd_t.__init__ (method) +ida_kernwin.quick_widget_commands_t._cmd_t -ida_kernwin.quick_widget_commands_t.add (method) +ida_kernwin.quick_widget_commands_t._cmd_t.__init__(self, caption, flags, menu_index, icon, emb, shortcut) -ida_kernwin.quick_widget_commands_t.populate_popup (method) +ida_kernwin.quick_widget_commands_t.add(self, caption, flags, menu_index, icon, emb, shortcut) -ida_kernwin.read_range_selection (function) - read_range_selection(v) -> bool - Get the address range for the selected range boundaries, this is the convenient - function for read_selection() - - @param v: (C++: TWidget *) view, nullptr means the last active window containing addresses +ida_kernwin.quick_widget_commands_t.populate_popup(self, widget, popup) + +ida_kernwin.read_range_selection(v: "TWidget *") -> "ea_t *, ea_t *" + Get the address range for the selected range boundaries, this is the convenient function for read_selection() + + @param v: view, nullptr means the last active window containing addresses @retval 0: no range is selected @retval 1: ok, start ea and end ea are filled -ida_kernwin.read_selection (function) - read_selection(v, p1, p2) -> bool - Read the user selection, and store its information in p0 (from) and p1 (to). +ida_kernwin.read_selection(v, p1, p2) + Read the user selection, and store its information in p1 (from) and p2 (to). This can be used as follows: - >>> p0 = idaapi.twinpos_t() - p1 = idaapi.twinpos_t() - view = idaapi.get_current_viewer() - idaapi.read_selection(view, p0, p1) + >>> p1 = ida_kernwin.twinpos_t() + p2 = ida_kernwin.twinpos_t() + view = ida_kernwin.get_current_viewer() + ida_kernwin.read_selection(view, p1, p2) - At that point, p0 and p1 hold information for the selection. - But, the 'at' property of p0 and p1 is not properly typed. + At that point, p1 and p2 hold information for the selection. + But, the 'at' property of p1 and p2 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) + >>> place0 = p1.place(view) + place1 = p2.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 p1: Storage for the "to" part of the selection. - @param p1: Storage for the "to" part of the selection. + @param v: The view to retrieve the selection for. + @param p1: Storage for the "from" part of the selection. + @param p2: Storage for the "to" part of the selection. @return: a bool value indicating success. -ida_kernwin.refresh_chooser (function) - refresh_chooser(title) -> bool - Mark a non-modal custom chooser for a refresh (ui_refresh_chooser). - - @param title: (C++: const char *) title of chooser - @return: success +ida_kernwin.refresh_chooser(title: str) -> bool + Mark a non-modal custom chooser for a refresh (ui_refresh_chooser). + + @param title: title of chooser + @returns success -ida_kernwin.refresh_choosers (function) - refresh_choosers() +ida_kernwin.refresh_choosers() -> None -ida_kernwin.refresh_custom_viewer (function) - refresh_custom_viewer(custom_viewer) +ida_kernwin.refresh_custom_viewer(custom_viewer: "TWidget *") -> None Refresh custom ida viewer (ui_refresh_custom_viewer) - - @param custom_viewer: (C++: TWidget *) -ida_kernwin.refresh_idaview (function) - refresh_idaview() +ida_kernwin.refresh_idaview() -> None Refresh marked windows (ui_refreshmarked) -ida_kernwin.refresh_idaview_anyway (function) - refresh_idaview_anyway() - Refresh all disassembly views (ui_refresh), forces an immediate refresh. Please - consider request_refresh() instead +ida_kernwin.refresh_idaview_anyway() -> None + Refresh all disassembly views (ui_refresh), forces an immediate refresh. Please consider request_refresh() instead + -ida_kernwin.refresh_navband (function) - refresh_navband(force) - Refresh navigation band if changed (ui_refresh_navband). - - @param force: (C++: bool) refresh regardless +ida_kernwin.refresh_navband(force: bool) -> None + Refresh navigation band if changed (ui_refresh_navband). + + @param force: refresh regardless -ida_kernwin.register_action (function) - register_action(desc) -> bool - Create a new action (ui_register_action). After an action has been created, it - is possible to attach it to menu items (attach_action_to_menu()), or to popup - menus (attach_action_to_popup()). - - Because the actions will need to call the handler's activate() and update() - methods at any time, you shouldn't build your action handler on the stack. - - Please see the SDK's "ht_view" plugin for an example how to register actions. - - @param desc: (C++: const action_desc_t &) action to register - @return: success +ida_kernwin.register_action(desc: "action_desc_t") -> bool + Create a new action (ui_register_action). After an action has been created, it is possible to attach it to menu items (attach_action_to_menu()), or to popup menus (attach_action_to_popup()). + Because the actions will need to call the handler's activate() and update() methods at any time, you shouldn't build your action handler on the stack. + Please see the SDK's "ht_view" plugin for an example how to register actions. + + @param desc: action to register + @returns success -ida_kernwin.register_addon (function) - register_addon(info) -> int - Register an add-on. Show its info in the About box. For plugins, should be - called from init() function (repeated calls with the same product code overwrite - previous entries) returns: index of the add-on in the list, or -1 on error - - @param info: (C++: const addon_info_t *) addon_info_t const * +ida_kernwin.register_addon(info: "addon_info_t") -> int + Register an add-on. Show its info in the About box. For plugins, should be called from init() function (repeated calls with the same product code overwrite previous entries) returns: index of the add-on in the list, or -1 on error + -ida_kernwin.register_and_attach_to_menu (function) - register_and_attach_to_menu(menupath, name, label, shortcut, flags, handler, owner, action_desc_t_flags) -> bool +ida_kernwin.register_and_attach_to_menu(menupath: str, name: str, label: str, shortcut: str, flags: int, handler: "action_handler_t *", owner: "void *", action_desc_t_flags: int) -> bool Helper. - - You are not encouraged to use this, as it mixes flags for both - register_action(), and attach_action_to_menu(). - - The only reason for its existence is to make it simpler to port existing plugins - to the new actions API. - - @param menupath: (C++: const char *) char const * - @param name: (C++: const char *) char const * - @param label: (C++: const char *) char const * - @param shortcut: (C++: const char *) char const * - @param flags: (C++: int) - @param handler: (C++: action_handler_t *) - @param owner: (C++: void *) - @param action_desc_t_flags: (C++: int) + You are not encouraged to use this, as it mixes flags for both register_action(), and attach_action_to_menu(). + The only reason for its existence is to make it simpler to port existing plugins to the new actions API. + -ida_kernwin.register_timer (function) - register_timer(interval, py_callback) -> PyCapsule +ida_kernwin.register_timer(interval, callback) Register a timer @param interval: Interval in milliseconds - @param py_callback: A Python callable that takes no parameters and returns an integer. + @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 -ida_kernwin.remove_command_interpreter (function) - remove_command_interpreter(cli_idx) +ida_kernwin.remove_command_interpreter(cli_idx: int) -> None Remove command line interpreter (ui_install_cli) - - @param cli_idx: int -ida_kernwin.renderer_pos_info_t (class) - Proxy of C++ renderer_pos_info_t class. +ida_kernwin.renderer_pos_info_t -ida_kernwin.renderer_pos_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: renderer_pos_info_t const & +ida_kernwin.renderer_pos_info_t.__eq__(self, r: "renderer_pos_info_t") -> bool -ida_kernwin.renderer_pos_info_t.__init__ (method) - __init__(self) -> renderer_pos_info_t +ida_kernwin.renderer_pos_info_t.__init__(self) -ida_kernwin.renderer_pos_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: renderer_pos_info_t const & +ida_kernwin.renderer_pos_info_t.__ne__(self, r: "renderer_pos_info_t") -> bool -ida_kernwin.renderer_pos_info_t.cx (variable) - the X coords of the character in the current line. When in graph mode: X coords - of the character in 'node'. - When in flat mode: X coords of the character in the line, w/o - taking scrolling into consideration. +ida_kernwin.renderer_pos_info_t.cx + the X coords of the character in the current line. When in graph mode: X coords of the character in 'node'. + When in flat mode: X coords of the character in the line, w/o + taking scrolling into consideration. + -ida_kernwin.renderer_pos_info_t.cy (variable) - the Y coords of the character. When in graph mode: Y coords of the character in - 'node'. - When in flat mode: Line number, starting from the top. +ida_kernwin.renderer_pos_info_t.cy + the Y coords of the character. When in graph mode: Y coords of the character in 'node'. + When in flat mode: Line number, starting from the top. + -ida_kernwin.renderer_pos_info_t.node (variable) - the node, or -1 if the current renderer is not a graph renderer. +ida_kernwin.renderer_pos_info_t.node + the node, or -1 if the current renderer is not a graph renderer. + -ida_kernwin.renderer_pos_info_t.sx (variable) +ida_kernwin.renderer_pos_info_t.sx the number of chars that are scrolled (flat mode only) -ida_kernwin.repaint_custom_viewer (function) - repaint_custom_viewer(custom_viewer) +ida_kernwin.repaint_custom_viewer(custom_viewer: "TWidget *") -> None Repaint the given widget immediately (ui_repaint_qwidget) - - @param custom_viewer: (C++: TWidget *) -ida_kernwin.replace_wait_box (function) - replace_wait_box(format) +ida_kernwin.replace_wait_box(*args) -> None Replace the label of "Please wait dialog box". + +ida_kernwin.request_refresh(mask: "uint64", cnd: bool = True) -> None + Request a refresh of a builtin window. + + @param mask: Window refresh flags + @param cnd: set if true or clear flag otherwise + +ida_kernwin.restore_database_snapshot(snapshot, callback, userdata) -> bool + Restore a database snapshot. - @param format: (C++: const char *) char const * - -ida_kernwin.request_refresh (function) - request_refresh(mask, cnd=True) - Request a refresh of a builtin window. + Note: This call is asynchronous. When it is completed, the callback will be triggered. - @param mask: (C++: uint64) Window refresh flags - @param cnd: (C++: bool) set if true or clear flag otherwise + @param snapshot the snapshot object + @param callback a callback function + @param userdata payload to pass to the callback + @return success -ida_kernwin.restore_database_snapshot (function) - restore_database_snapshot(ss, pyfunc_or_none, pytuple_or_none) -> bool - Restore a database snapshot. Note: This call is asynchronous. When it is - completed, the callback will be triggered. - - @param ss: (C++: const snapshot_t *) snapshot instance (see build_snapshot_tree()) - @param pyfunc_or_none: PyObject * - @param pytuple_or_none: PyObject * - @return: false if restoration could not be started (snapshot file was not - found). - If the returned value is True then check if the operation succeeded from the - callback. +ida_kernwin.section_lines_refs_t -ida_kernwin.section_lines_refs_t (class) - Proxy of C++ qvector< twinline_t const * > class. +ida_kernwin.section_lines_refs_t.__eq__(self, r: "section_lines_refs_t") -> bool -ida_kernwin.section_lines_refs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< twinline_t const * > const & +ida_kernwin.section_lines_refs_t.__getitem__(self, i: "size_t") -> "twinline_t const *const &" -ida_kernwin.section_lines_refs_t.__getitem__ (method) - __getitem__(self, i) -> twinline_t - - @param i: size_t +ida_kernwin.section_lines_refs_t.__init__(self, *args) -ida_kernwin.section_lines_refs_t.__init__ (method) - __init__(self) -> section_lines_refs_t - __init__(self, x) -> section_lines_refs_t - - @param x: qvector< twinline_t const * > const & +ida_kernwin.section_lines_refs_t.__len__(self) -> "size_t" -ida_kernwin.section_lines_refs_t.__len__ (method) - __len__(self) -> size_t +ida_kernwin.section_lines_refs_t.__ne__(self, r: "section_lines_refs_t") -> bool -ida_kernwin.section_lines_refs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< twinline_t const * > const & +ida_kernwin.section_lines_refs_t.__setitem__(self, i: "size_t", v: "twinline_t") -> None -ida_kernwin.section_lines_refs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: twinline_t const *const & +ida_kernwin.section_lines_refs_t._del(self, x: "twinline_t") -> bool -ida_kernwin.section_lines_refs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: twinline_t const *const & +ida_kernwin.section_lines_refs_t.add_unique(self, x: "twinline_t") -> bool -ida_kernwin.section_lines_refs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: twinline_t const *const & +ida_kernwin.section_lines_refs_t.append(self, x: "twinline_t") -> None -ida_kernwin.section_lines_refs_t.at (method) - at(self, _idx) -> twinline_t - - @param _idx: size_t +ida_kernwin.section_lines_refs_t.at(self, _idx: "size_t") -> "twinline_t const *const &" -ida_kernwin.section_lines_refs_t.begin (method) - begin(self) -> qvector< twinline_t const * >::iterator - begin(self) -> qvector< twinline_t const * >::const_iterator +ida_kernwin.section_lines_refs_t.begin(self, *args) -> "qvector< twinline_t const * >::const_iterator" -ida_kernwin.section_lines_refs_t.capacity (method) - capacity(self) -> size_t +ida_kernwin.section_lines_refs_t.capacity(self) -> "size_t" -ida_kernwin.section_lines_refs_t.clear (method) - clear(self) +ida_kernwin.section_lines_refs_t.clear(self) -> None -ida_kernwin.section_lines_refs_t.empty (method) - empty(self) -> bool +ida_kernwin.section_lines_refs_t.empty(self) -> bool -ida_kernwin.section_lines_refs_t.end (method) - end(self) -> qvector< twinline_t const * >::iterator - end(self) -> qvector< twinline_t const * >::const_iterator +ida_kernwin.section_lines_refs_t.end(self, *args) -> "qvector< twinline_t const * >::const_iterator" -ida_kernwin.section_lines_refs_t.erase (method) - erase(self, it) -> qvector< twinline_t const * >::iterator - - @param it: qvector< twinline_t const * >::iterator - - erase(self, first, last) -> qvector< twinline_t const * >::iterator - - @param first: qvector< twinline_t const * >::iterator - @param last: qvector< twinline_t const * >::iterator +ida_kernwin.section_lines_refs_t.erase(self, *args) -> "qvector< twinline_t const * >::iterator" -ida_kernwin.section_lines_refs_t.extract (method) - extract(self) -> twinline_t const ** +ida_kernwin.section_lines_refs_t.extend(self, x: "section_lines_refs_t") -> None -ida_kernwin.section_lines_refs_t.find (method) - find(self, x) -> qvector< twinline_t const * >::iterator - - @param x: twinline_t const *const & - - find(self, x) -> qvector< twinline_t const * >::const_iterator - - @param x: twinline_t const *const & +ida_kernwin.section_lines_refs_t.extract(self) -> "twinline_t const **" -ida_kernwin.section_lines_refs_t.has (method) - has(self, x) -> bool - - @param x: twinline_t const *const & +ida_kernwin.section_lines_refs_t.find(self, *args) -> "qvector< twinline_t const * >::const_iterator" -ida_kernwin.section_lines_refs_t.inject (method) - inject(self, s, len) - - @param s: twinline_t const ** - @param len: size_t +ida_kernwin.section_lines_refs_t.has(self, x: "twinline_t") -> bool -ida_kernwin.section_lines_refs_t.insert (method) - insert(self, it, x) -> qvector< twinline_t const * >::iterator - - @param it: qvector< twinline_t const * >::iterator - @param x: twinline_t const *const & +ida_kernwin.section_lines_refs_t.inject(self, s: "twinline_t const **", len: "size_t") -> None -ida_kernwin.section_lines_refs_t.pop_back (method) - pop_back(self) +ida_kernwin.section_lines_refs_t.insert(self, it: "qvector< twinline_t const * >::iterator", x: "twinline_t") -> "qvector< twinline_t const * >::iterator" -ida_kernwin.section_lines_refs_t.push_back (method) - push_back(self, x) - - @param x: twinline_t const *const & - - push_back(self) -> twinline_t const *& +ida_kernwin.section_lines_refs_t.pop_back(self) -> None -ida_kernwin.section_lines_refs_t.qclear (method) - qclear(self) +ida_kernwin.section_lines_refs_t.push_back(self, *args) -> "twinline_t const *&" -ida_kernwin.section_lines_refs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_kernwin.section_lines_refs_t.qclear(self) -> None -ida_kernwin.section_lines_refs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: twinline_t const *const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_kernwin.section_lines_refs_t.reserve(self, cnt: "size_t") -> None -ida_kernwin.section_lines_refs_t.size (method) - size(self) -> size_t +ida_kernwin.section_lines_refs_t.resize(self, *args) -> None -ida_kernwin.section_lines_refs_t.swap (method) - swap(self, r) - - @param r: qvector< twinline_t const * > & +ida_kernwin.section_lines_refs_t.size(self) -> "size_t" -ida_kernwin.section_lines_refs_t.truncate (method) - truncate(self) +ida_kernwin.section_lines_refs_t.swap(self, r: "section_lines_refs_t") -> None -ida_kernwin.sections_lines_refs_t (class) - Proxy of C++ qvector< section_lines_refs_t > class. +ida_kernwin.section_lines_refs_t.truncate(self) -> None -ida_kernwin.sections_lines_refs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< section_lines_refs_t > const & +ida_kernwin.sections_lines_refs_t -ida_kernwin.sections_lines_refs_t.__getitem__ (method) - __getitem__(self, i) -> section_lines_refs_t - - @param i: size_t +ida_kernwin.sections_lines_refs_t.__eq__(self, r: "sections_lines_refs_t") -> bool -ida_kernwin.sections_lines_refs_t.__init__ (method) - __init__(self) -> sections_lines_refs_t - __init__(self, x) -> sections_lines_refs_t - - @param x: qvector< section_lines_refs_t > const & +ida_kernwin.sections_lines_refs_t.__getitem__(self, i: "size_t") -> "section_lines_refs_t const &" -ida_kernwin.sections_lines_refs_t.__len__ (method) - __len__(self) -> size_t +ida_kernwin.sections_lines_refs_t.__init__(self, *args) -ida_kernwin.sections_lines_refs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< section_lines_refs_t > const & +ida_kernwin.sections_lines_refs_t.__len__(self) -> "size_t" -ida_kernwin.sections_lines_refs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: section_lines_refs_t const & +ida_kernwin.sections_lines_refs_t.__ne__(self, r: "sections_lines_refs_t") -> bool -ida_kernwin.sections_lines_refs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: section_lines_refs_t const & +ida_kernwin.sections_lines_refs_t.__setitem__(self, i: "size_t", v: "section_lines_refs_t") -> None -ida_kernwin.sections_lines_refs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: section_lines_refs_t const & +ida_kernwin.sections_lines_refs_t._del(self, x: "section_lines_refs_t") -> bool -ida_kernwin.sections_lines_refs_t.at (method) - at(self, _idx) -> section_lines_refs_t - - @param _idx: size_t +ida_kernwin.sections_lines_refs_t.add_unique(self, x: "section_lines_refs_t") -> bool -ida_kernwin.sections_lines_refs_t.begin (method) - begin(self) -> qvector< section_lines_refs_t >::iterator - begin(self) -> qvector< section_lines_refs_t >::const_iterator +ida_kernwin.sections_lines_refs_t.append(self, x: "section_lines_refs_t") -> None -ida_kernwin.sections_lines_refs_t.capacity (method) - capacity(self) -> size_t +ida_kernwin.sections_lines_refs_t.at(self, _idx: "size_t") -> "section_lines_refs_t const &" -ida_kernwin.sections_lines_refs_t.clear (method) - clear(self) +ida_kernwin.sections_lines_refs_t.begin(self, *args) -> "qvector< section_lines_refs_t >::const_iterator" -ida_kernwin.sections_lines_refs_t.empty (method) - empty(self) -> bool +ida_kernwin.sections_lines_refs_t.capacity(self) -> "size_t" -ida_kernwin.sections_lines_refs_t.end (method) - end(self) -> qvector< section_lines_refs_t >::iterator - end(self) -> qvector< section_lines_refs_t >::const_iterator +ida_kernwin.sections_lines_refs_t.clear(self) -> None -ida_kernwin.sections_lines_refs_t.erase (method) - erase(self, it) -> qvector< section_lines_refs_t >::iterator - - @param it: qvector< section_lines_refs_t >::iterator - - erase(self, first, last) -> qvector< section_lines_refs_t >::iterator - - @param first: qvector< section_lines_refs_t >::iterator - @param last: qvector< section_lines_refs_t >::iterator +ida_kernwin.sections_lines_refs_t.empty(self) -> bool -ida_kernwin.sections_lines_refs_t.extract (method) - extract(self) -> section_lines_refs_t +ida_kernwin.sections_lines_refs_t.end(self, *args) -> "qvector< section_lines_refs_t >::const_iterator" -ida_kernwin.sections_lines_refs_t.find (method) - find(self, x) -> qvector< section_lines_refs_t >::iterator - - @param x: section_lines_refs_t const & - - find(self, x) -> qvector< section_lines_refs_t >::const_iterator - - @param x: section_lines_refs_t const & +ida_kernwin.sections_lines_refs_t.erase(self, *args) -> "qvector< section_lines_refs_t >::iterator" -ida_kernwin.sections_lines_refs_t.grow (method) - grow(self, x=section_lines_refs_t()) - - @param x: section_lines_refs_t const & +ida_kernwin.sections_lines_refs_t.extend(self, x: "sections_lines_refs_t") -> None -ida_kernwin.sections_lines_refs_t.has (method) - has(self, x) -> bool - - @param x: section_lines_refs_t const & +ida_kernwin.sections_lines_refs_t.extract(self) -> "section_lines_refs_t *" -ida_kernwin.sections_lines_refs_t.inject (method) - inject(self, s, len) - - @param s: section_lines_refs_t * - @param len: size_t +ida_kernwin.sections_lines_refs_t.find(self, *args) -> "qvector< section_lines_refs_t >::const_iterator" -ida_kernwin.sections_lines_refs_t.insert (method) - insert(self, it, x) -> qvector< section_lines_refs_t >::iterator - - @param it: qvector< section_lines_refs_t >::iterator - @param x: section_lines_refs_t const & +ida_kernwin.sections_lines_refs_t.grow(self, *args) -> None -ida_kernwin.sections_lines_refs_t.pop_back (method) - pop_back(self) +ida_kernwin.sections_lines_refs_t.has(self, x: "section_lines_refs_t") -> bool -ida_kernwin.sections_lines_refs_t.push_back (method) - push_back(self, x) - - @param x: section_lines_refs_t const & - - push_back(self) -> section_lines_refs_t +ida_kernwin.sections_lines_refs_t.inject(self, s: "section_lines_refs_t", len: "size_t") -> None -ida_kernwin.sections_lines_refs_t.qclear (method) - qclear(self) +ida_kernwin.sections_lines_refs_t.insert(self, it: "qvector< section_lines_refs_t >::iterator", x: "section_lines_refs_t") -> "qvector< section_lines_refs_t >::iterator" -ida_kernwin.sections_lines_refs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_kernwin.sections_lines_refs_t.pop_back(self) -> None -ida_kernwin.sections_lines_refs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: section_lines_refs_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_kernwin.sections_lines_refs_t.push_back(self, *args) -> "section_lines_refs_t &" -ida_kernwin.sections_lines_refs_t.size (method) - size(self) -> size_t +ida_kernwin.sections_lines_refs_t.qclear(self) -> None -ida_kernwin.sections_lines_refs_t.swap (method) - swap(self, r) - - @param r: qvector< section_lines_refs_t > & +ida_kernwin.sections_lines_refs_t.reserve(self, cnt: "size_t") -> None -ida_kernwin.sections_lines_refs_t.truncate (method) - truncate(self) +ida_kernwin.sections_lines_refs_t.resize(self, *args) -> None -ida_kernwin.set_cancelled (function) - set_cancelled() +ida_kernwin.sections_lines_refs_t.size(self) -> "size_t" + +ida_kernwin.sections_lines_refs_t.swap(self, r: "sections_lines_refs_t") -> None + +ida_kernwin.sections_lines_refs_t.truncate(self) -> None + +ida_kernwin.set_cancelled() -> None Set "Cancelled" flag (ui_set_cancelled) -ida_kernwin.set_code_viewer_handler (function) - set_code_viewer_handler(code_viewer, handler_id, handler_or_data) -> void * - Set a handler for a code viewer event (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) the code viewer - @param handler_id: (C++: custom_viewer_handler_id_t) one of CDVH_ in custom_viewer_handler_id_t - @param handler_or_data: (C++: void *) can be a handler or data. see examples in Functions: - custom viewer handlers - @return: old value of the handler or data +ida_kernwin.set_code_viewer_handler(code_viewer: "TWidget *", handler_id: "custom_viewer_handler_id_t", handler_or_data: "void *") -> "void *" + Set a handler for a code viewer event (ui_set_custom_viewer_handler). + + @param code_viewer: the code viewer + @param handler_id: one of CDVH_ in custom_viewer_handler_id_t + @param handler_or_data: can be a handler or data. see examples in Functions: custom viewer handlers + @returns old value of the handler or data -ida_kernwin.set_code_viewer_is_source (function) - set_code_viewer_is_source(code_viewer) -> bool - Specify that the given code viewer is used to display source code - (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) +ida_kernwin.set_code_viewer_is_source(code_viewer: "TWidget *") -> bool + Specify that the given code viewer is used to display source code (ui_set_custom_viewer_handler). -ida_kernwin.set_code_viewer_line_handlers (function) - set_code_viewer_line_handlers(code_viewer, click_handler, popup_handler, dblclick_handler, drawicon_handler, linenum_handler) - Set handlers for code viewer line events. Any of these handlers may be nullptr - - @param code_viewer: (C++: TWidget *) - @param click_handler: (C++: code_viewer_lines_click_t *) - @param popup_handler: (C++: code_viewer_lines_click_t *) - @param dblclick_handler: (C++: code_viewer_lines_click_t *) - @param drawicon_handler: (C++: code_viewer_lines_icon_t *) - @param linenum_handler: (C++: code_viewer_lines_linenum_t *) +ida_kernwin.set_code_viewer_line_handlers(code_viewer: "TWidget *", click_handler: "code_viewer_lines_click_t *", popup_handler: "code_viewer_lines_click_t *", dblclick_handler: "code_viewer_lines_click_t *", drawicon_handler: "code_viewer_lines_icon_t *", linenum_handler: "code_viewer_lines_linenum_t *") -> None + Set handlers for code viewer line events. Any of these handlers may be nullptr + -ida_kernwin.set_code_viewer_lines_alignment (function) - set_code_viewer_lines_alignment(code_viewer, align) -> bool +ida_kernwin.set_code_viewer_lines_alignment(code_viewer: "TWidget *", align: int) -> bool Set alignment for lines in a code viewer (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param align: (C++: int) -ida_kernwin.set_code_viewer_lines_icon_margin (function) - set_code_viewer_lines_icon_margin(code_viewer, margin) -> bool - Set space allowed for icons in the margin of a code viewer - (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param margin: (C++: int) +ida_kernwin.set_code_viewer_lines_icon_margin(code_viewer: "TWidget *", margin: int) -> bool + Set space allowed for icons in the margin of a code viewer (ui_set_custom_viewer_handler). -ida_kernwin.set_code_viewer_lines_radix (function) - set_code_viewer_lines_radix(code_viewer, radix) -> bool +ida_kernwin.set_code_viewer_lines_radix(code_viewer: "TWidget *", radix: int) -> bool Set radix for values displayed in a code viewer (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param radix: (C++: int) -ida_kernwin.set_code_viewer_user_data (function) - set_code_viewer_user_data(code_viewer, ud) -> bool +ida_kernwin.set_code_viewer_user_data(code_viewer: "TWidget *", ud: "void *") -> bool Set the user data on a code viewer (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param ud: (C++: void *) -ida_kernwin.set_custom_viewer_qt_aware (function) - set_custom_viewer_qt_aware(custom_viewer) -> bool +ida_kernwin.set_custom_viewer_qt_aware(custom_viewer: "TWidget *") -> bool Allow the given viewer to interpret Qt events (ui_set_custom_viewer_handler) - - @param custom_viewer: (C++: TWidget *) -ida_kernwin.set_dock_pos (function) - set_dock_pos(src_ctrl, dest_ctrl, orient, left=0, top=0, right=0, bottom=0) -> bool +ida_kernwin.set_dock_pos(src_ctrl, dest_ctrl, orient, left = 0, top = 0, right = 0, bottom = 0) Sets the dock orientation of a window relatively to another window. Use the left, top, right, bottom parameters if DP_FLOATING is used, or if you want to specify the width of docked windows. - @param src_ctrl: char const * - @param dest_ctrl: char const * + @param src_ctrl: Source docking control + @param dest_ctrl: Destination docking control @param orient: One of DP_XXXX constants - @param left: int - @param top: int - @param right: int - @param bottom: int @return: Boolean Example: set_dock_pos('Structures', 'Enums', DP_RIGHT) <- docks the Structures window to the right of Enums window -ida_kernwin.set_highlight (function) - set_highlight(viewer, str, flags) -> bool - Set the highlighted identifier in the viewer (ui_set_highlight). +ida_kernwin.set_execute_sync_availability(tid: "__qthread_t", availability: "execute_sync_availability_t") -> "execute_sync_availability_t" + Set the availability of the execute_sync functionality for the given thread + Setting it to `esa_unavailable` will cause the existing requests for this thread to be cancelled. Setting it to `esa_release` will clear the status for this thread, and should be issued right before a call to `qthread_free` is issued. - @param viewer: (C++: TWidget *) the viewer - @param str: (C++: const char *) the text to match, or nullptr to remove current - @param flags: (C++: int) combination of HIF_... bits (see set_highlight flags) - @return: false if an error occurred + @param tid: thread id + @param availability: the availability + @returns the previous availability -ida_kernwin.set_nav_colorizer (function) - set_nav_colorizer(new_py_colorizer) -> dict or None +ida_kernwin.set_highlight(viewer: "TWidget *", str: str, flags: int) -> bool + Set the highlighted identifier in the viewer (ui_set_highlight). + + @param viewer: the viewer + @param str: the text to match, or nullptr to remove current + @param flags: combination of HIF_... bits (see set_highlight flags) + @returns false if an error occurred + +ida_kernwin.set_nav_colorizer(callback) Set a new colorizer for the navigation band. The 'callback' is a function of 2 arguments: @@ -46066,1614 +30874,1281 @@ ida_kernwin.set_nav_colorizer (function) Example: colorizer inverting the color provided by the IDA colorizer: def my_colorizer(ea, nbytes): global ida_colorizer - orig = idaapi.call_nav_colorizer(ida_colorizer, ea, nbytes) + orig = ida_kernwin.call_nav_colorizer(ida_colorizer, ea, nbytes) return long(~orig) - ida_colorizer = idaapi.set_nav_colorizer(my_colorizer) + ida_colorizer = ida_kernwin.set_nav_colorizer(my_colorizer) - @param new_py_colorizer: PyObject * + @param callback: the new colorizer -ida_kernwin.set_view_renderer_type (function) - set_view_renderer_type(v, rt) +ida_kernwin.set_view_renderer_type(v: "TWidget *", rt: "tcc_renderer_type_t") -> None Set the type of renderer to use in a view (ui_set_renderer_type) - - @param v: (C++: TWidget *) - @param rt: (C++: tcc_renderer_type_t) enum tcc_renderer_type_t -ida_kernwin.show_wait_box (function) - show_wait_box(message) - Display a dialog box with "Please wait...". The behavior of the dialog box can - be configured with well-known - tokens, that should be placed at the start of the format string: - "NODELAY\n": the dialog will show immediately, instead of - appearing after usual grace threshold - "HIDECANCEL\n": the cancel button won't be added to the dialog box - and user_cancelled() will always return false (but - can be called to refresh UI) - Using "HIDECANCEL" implies "NODELAY" - Plugins must call hide_wait_box() to close the dialog box, otherwise - the user interface will remain disabled. - Note that, if the wait dialog is already visible, show_wait_box() will - 1) push the currently-displayed text on a stack - 2) display the new text - Then, when hide_wait_box() is called, if that stack isn't empty its top - label will be popped and restored in the wait dialog. - This implies that a plugin should call hide_wait_box() exactly as many - times as it called show_wait_box(), or the wait dialog might remain - visible and block the UI. - Also, in case the plugin knows the wait dialog is currently displayed, +ida_kernwin.show_wait_box(message: str) -> None + Display a dialog box with "Please wait...". The behavior of the dialog box can be configured with well-known + tokens, that should be placed at the start of the format string: + "NODELAY\n": the dialog will show immediately, instead of + appearing after usual grace threshold + "HIDECANCEL\n": the cancel button won't be added to the dialog box + and user_cancelled() will always return false (but + can be called to refresh UI) + Using "HIDECANCEL" implies "NODELAY" + Plugins must call hide_wait_box() to close the dialog box, otherwise + the user interface will remain disabled. + Note that, if the wait dialog is already visible, show_wait_box() will + 1) push the currently-displayed text on a stack + 2) display the new text + Then, when hide_wait_box() is called, if that stack isn't empty its top + label will be popped and restored in the wait dialog. + This implies that a plugin should call hide_wait_box() exactly as many + times as it called show_wait_box(), or the wait dialog might remain + visible and block the UI. + Also, in case the plugin knows the wait dialog is currently displayed, alternatively it can call replace_wait_box(), to replace the text of the - dialog without pushing the currently-displayed text on the stack. - - @param message: char const * + dialog without pushing the currently-displayed text on the stack. + -ida_kernwin.simplecustviewer_t (class) +ida_kernwin.simplecustviewer_t The base class for implementing simple custom viewers -ida_kernwin.simplecustviewer_t.AddLine (method) +ida_kernwin.simplecustviewer_t.AddLine(self, line, fgcolor = None, bgcolor = None) Adds a colored line to the view @return: Boolean -ida_kernwin.simplecustviewer_t.ClearLines (method) +ida_kernwin.simplecustviewer_t.ClearLines(self) Clears all the lines -ida_kernwin.simplecustviewer_t.Close (method) +ida_kernwin.simplecustviewer_t.Close(self) Destroys the view. One has to call Create() afterwards. Show() can be called and it will call Create() internally. @return: Boolean -ida_kernwin.simplecustviewer_t.Count (method) +ida_kernwin.simplecustviewer_t.Count(self) Returns the number of lines in the view -ida_kernwin.simplecustviewer_t.Create (method) +ida_kernwin.simplecustviewer_t.Create(self, title) Creates the custom view. This should be the first method called after instantiation @param title: The title of the view @return: Boolean whether it succeeds or fails. It may fail if a window with the same title is already open. In this case better close existing windows -ida_kernwin.simplecustviewer_t.DelLine (method) +ida_kernwin.simplecustviewer_t.DelLine(self, lineno) Deletes an existing line @return: Boolean -ida_kernwin.simplecustviewer_t.EditLine (method) +ida_kernwin.simplecustviewer_t.EditLine(self, lineno, line, fgcolor = None, bgcolor = None) Edits an existing line. @return: Boolean -ida_kernwin.simplecustviewer_t.GetCurrentLine (method) +ida_kernwin.simplecustviewer_t.GetCurrentLine(self, mouse = 0, notags = 0) Returns the current line. @param mouse: Current line at mouse pos @param notags: If True then tag_remove() will be called before returning the line @return: Returns the current line (colored or uncolored) or None on failure -ida_kernwin.simplecustviewer_t.GetCurrentWord (method) +ida_kernwin.simplecustviewer_t.GetCurrentWord(self, mouse = 0) Returns the current word @param mouse: Use mouse position or cursor position @return: None if failed or a String containing the current word at mouse or cursor -ida_kernwin.simplecustviewer_t.GetLine (method) +ida_kernwin.simplecustviewer_t.GetLine(self, lineno) Returns a line @param lineno: The line number - @return: Returns a tuple (colored_line, fgcolor, bgcolor) or None + @return: + Returns a tuple (colored_line, fgcolor, bgcolor) or None -ida_kernwin.simplecustviewer_t.GetLineNo (method) +ida_kernwin.simplecustviewer_t.GetLineNo(self, mouse = 0) Calls GetPos() and returns the current line number or -1 on failure -ida_kernwin.simplecustviewer_t.GetPos (method) +ida_kernwin.simplecustviewer_t.GetPos(self, mouse = 0) Returns the current cursor or mouse position. @param mouse: return mouse position @return: Returns a tuple (lineno, x, y) -ida_kernwin.simplecustviewer_t.GetSelection (method) +ida_kernwin.simplecustviewer_t.GetSelection(self) Returns the selected range or None - @return: - tuple(x1, y1, x2, y2) + @return: + - tuple(x1, y1, x2, y2) - None if no selection -ida_kernwin.simplecustviewer_t.GetWidget (method) +ida_kernwin.simplecustviewer_t.GetWidget(self) Return the TWidget underlying this view. @return: The TWidget underlying this view, or None. -ida_kernwin.simplecustviewer_t.InsertLine (method) +ida_kernwin.simplecustviewer_t.InsertLine(self, lineno, line, fgcolor = None, bgcolor = None) Inserts a line in the given position @return: Boolean -ida_kernwin.simplecustviewer_t.IsFocused (method) +ida_kernwin.simplecustviewer_t.IsFocused(self) Returns True if the current view is the focused view -ida_kernwin.simplecustviewer_t.Jump (method) +ida_kernwin.simplecustviewer_t.Jump(self, lineno, x = 0, y = 0) -ida_kernwin.simplecustviewer_t.OnPopup (method) +ida_kernwin.simplecustviewer_t.OnPopup(self, form, popup_handle) Context menu popup is about to be shown. Create items dynamically if you wish @return: Boolean. True if you handled the event -ida_kernwin.simplecustviewer_t.PatchLine (method) +ida_kernwin.simplecustviewer_t.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 -ida_kernwin.simplecustviewer_t.Refresh (method) +ida_kernwin.simplecustviewer_t.Refresh(self) -ida_kernwin.simplecustviewer_t.RefreshCurrent (method) +ida_kernwin.simplecustviewer_t.RefreshCurrent(self) Refreshes the current line only -ida_kernwin.simplecustviewer_t.Show (method) +ida_kernwin.simplecustviewer_t.Show(self) Shows an already created view. It the view was closed, then it will call Create() for you @return: Boolean -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline (class) +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.__init__ (method) +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.__init__(self, v) -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.populating_widget_popup (method) +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.populating_widget_popup(self, form, popup_handle) -ida_kernwin.simplecustviewer_t.__init__ (method) +ida_kernwin.simplecustviewer_t.__init__(self) -ida_kernwin.simplecustviewer_t.__make_sl_arg (method) +ida_kernwin.simplecustviewer_t.__make_sl_arg(line, fgcolor = None, bgcolor = None) -ida_kernwin.simpleline_place_t (class) - Proxy of C++ simpleline_place_t class. +ida_kernwin.simpleline_place_t -ida_kernwin.simpleline_place_t.__init__ (method) +ida_kernwin.simpleline_place_t.__init__(self, *args, **kwargs) -ida_kernwin.simpleline_place_t.n (variable) +ida_kernwin.simpleline_place_t.n line number -ida_kernwin.simpleline_t (class) - Proxy of C++ simpleline_t class. +ida_kernwin.simpleline_t -ida_kernwin.simpleline_t.__init__ (method) - __init__(self) -> simpleline_t - __init__(self, c, str) -> simpleline_t - - @param c: color_t - @param str: char const * - - __init__(self, str) -> simpleline_t - - @param str: char const * +ida_kernwin.simpleline_t.__init__(self, *args) -ida_kernwin.simpleline_t.bgcolor (variable) +ida_kernwin.simpleline_t.bgcolor line background color -ida_kernwin.simpleline_t.color (variable) +ida_kernwin.simpleline_t.color line prefix color -ida_kernwin.simpleline_t.line (variable) +ida_kernwin.simpleline_t.line line text -ida_kernwin.str2ea (function) - str2ea(str, screen_ea=BADADDR) -> bool - Convert string to linear address. Tries to interpret the string as: - 1) "current IP" keyword if supported by assembler (e.g. "$" in x86) - 2) segment:offset expression, where "segment" may be a name or a fixed segment - register (e.g. cs, ds) - 3) just segment name/register (translated to segment's start address) - 4) a name in the database (or debug name during debugging) - 5) hexadecimal value without prefix or suffix - 6) +delta or -delta, where numerical 'delta' is added to or subtracted from - 'screen_ea' - 7) register name (only during debugging) +ida_kernwin.str2ea(*args) -> "uint64 *" + Convert string to linear address. Tries to interpret the string as: + 1) "current IP" keyword if supported by assembler (e.g. "$" in x86) + 2) segment:offset expression, where "segment" may be a name or a fixed segment register (e.g. cs, ds) + 3) just segment name/register (translated to segment's start address) + 4) a name in the database (or debug name during debugging) + 5) hexadecimal value without prefix or suffix + 6) +delta or -delta, where numerical 'delta' is added to or subtracted from 'screen_ea' + 7) register name (only during debugging) 8) if all else fails, try to evaluate 'str' as an IDC expression - @param str: (C++: const char *) string to parse - @param screen_ea: (C++: ea_t) the current address in the disassembly/pseudocode view - @return: success + @param str: string to parse + @param screen_ea: the current address in the disassembly/pseudocode view + @returns success -ida_kernwin.str2ea_ex (function) - str2ea_ex(str, screen_ea=BADADDR, flags=0) -> bool - Same as str2ea() but possibly with some steps skipped. +ida_kernwin.str2ea_ex(*args) -> "uint64 *" + Same as str2ea() but possibly with some steps skipped. + + @param out: the buffer to put the result + @param str: string to parse + @param screen_ea: the current address in the disassembly/pseudocode view + @param flags: see String to address conversion flags + @returns success + +ida_kernwin.strarray(array: "strarray_t", array_size: "size_t", code: int) -> str + Find a line with the specified code in the strarray_t array. If the last element of the array has code==0 then it is considered as the default entry. + If no default entry exists and the code is not found, strarray() returns "". + + +ida_kernwin.strarray_t + +ida_kernwin.strarray_t.__init__(self) + +ida_kernwin.sync_source_t + +ida_kernwin.sync_source_t.__eq__(self, _o: "sync_source_t") -> bool + +ida_kernwin.sync_source_t.__init__(self, *args) + +ida_kernwin.sync_source_t.__ne__(self, _o: "sync_source_t") -> bool + +ida_kernwin.sync_source_t.get_register(self) -> str + +ida_kernwin.sync_source_t.get_widget(self) -> "TWidget const *" + +ida_kernwin.sync_source_t.is_register(self) -> bool + +ida_kernwin.sync_source_t.is_widget(self) -> bool + +ida_kernwin.sync_source_vec_t + +ida_kernwin.sync_source_vec_t.__eq__(self, r: "sync_source_vec_t") -> bool + +ida_kernwin.sync_source_vec_t.__getitem__(self, i: "size_t") -> "sync_source_t const &" + +ida_kernwin.sync_source_vec_t.__init__(self, *args) + +ida_kernwin.sync_source_vec_t.__len__(self) -> "size_t" + +ida_kernwin.sync_source_vec_t.__ne__(self, r: "sync_source_vec_t") -> bool + +ida_kernwin.sync_source_vec_t.__setitem__(self, i: "size_t", v: "sync_source_t") -> None + +ida_kernwin.sync_source_vec_t._del(self, x: "sync_source_t") -> bool + +ida_kernwin.sync_source_vec_t.add_unique(self, x: "sync_source_t") -> bool + +ida_kernwin.sync_source_vec_t.append(self, x: "sync_source_t") -> None + +ida_kernwin.sync_source_vec_t.at(self, _idx: "size_t") -> "sync_source_t const &" + +ida_kernwin.sync_source_vec_t.begin(self, *args) -> "qvector< sync_source_t >::const_iterator" + +ida_kernwin.sync_source_vec_t.capacity(self) -> "size_t" + +ida_kernwin.sync_source_vec_t.clear(self) -> None + +ida_kernwin.sync_source_vec_t.empty(self) -> bool + +ida_kernwin.sync_source_vec_t.end(self, *args) -> "qvector< sync_source_t >::const_iterator" + +ida_kernwin.sync_source_vec_t.erase(self, *args) -> "qvector< sync_source_t >::iterator" + +ida_kernwin.sync_source_vec_t.extend(self, x: "sync_source_vec_t") -> None + +ida_kernwin.sync_source_vec_t.extract(self) -> "sync_source_t *" + +ida_kernwin.sync_source_vec_t.find(self, *args) -> "qvector< sync_source_t >::const_iterator" + +ida_kernwin.sync_source_vec_t.has(self, x: "sync_source_t") -> bool + +ida_kernwin.sync_source_vec_t.inject(self, s: "sync_source_t", len: "size_t") -> None + +ida_kernwin.sync_source_vec_t.insert(self, it: "sync_source_t", x: "sync_source_t") -> "qvector< sync_source_t >::iterator" + +ida_kernwin.sync_source_vec_t.pop_back(self) -> None + +ida_kernwin.sync_source_vec_t.push_back(self, x: "sync_source_t") -> None + +ida_kernwin.sync_source_vec_t.qclear(self) -> None + +ida_kernwin.sync_source_vec_t.reserve(self, cnt: "size_t") -> None + +ida_kernwin.sync_source_vec_t.size(self) -> "size_t" + +ida_kernwin.sync_source_vec_t.swap(self, r: "sync_source_vec_t") -> None + +ida_kernwin.sync_source_vec_t.truncate(self) -> None + +ida_kernwin.sync_sources(what: "sync_source_t", _with: "sync_source_t", sync: bool) -> bool + [Un]synchronize sources + + @returns success + +ida_kernwin.synced_group_t + +ida_kernwin.synced_group_t.__init__(self) + +ida_kernwin.synced_group_t.has(self, ss: "sync_source_t") -> bool + +ida_kernwin.synced_group_t.has_register(self, r: str) -> bool + +ida_kernwin.synced_group_t.has_widget(self, v: "TWidget const *") -> bool + +ida_kernwin.tagged_line_section_t + +ida_kernwin.tagged_line_section_t.__eq__(self, r: "tagged_line_section_t") -> bool + +ida_kernwin.tagged_line_section_t.__init__(self) + +ida_kernwin.tagged_line_section_t.__ne__(self, r: "tagged_line_section_t") -> bool + +ida_kernwin.tagged_line_section_t.__str__(self) -> str + +ida_kernwin.tagged_line_section_t.substr(self, _in: str, end: "tagged_line_section_t" = None) -> bool + +ida_kernwin.tagged_line_section_t.valid(self) -> bool + +ida_kernwin.tagged_line_section_t.valid_in(self, _in: str) -> bool + +ida_kernwin.tagged_line_section_vec_t + +ida_kernwin.tagged_line_section_vec_t.__eq__(self, r: "tagged_line_section_vec_t") -> bool + +ida_kernwin.tagged_line_section_vec_t.__getitem__(self, i: "size_t") -> "tagged_line_section_t const &" + +ida_kernwin.tagged_line_section_vec_t.__init__(self, *args) + +ida_kernwin.tagged_line_section_vec_t.__len__(self) -> "size_t" + +ida_kernwin.tagged_line_section_vec_t.__ne__(self, r: "tagged_line_section_vec_t") -> bool + +ida_kernwin.tagged_line_section_vec_t.__setitem__(self, i: "size_t", v: "tagged_line_section_t") -> None + +ida_kernwin.tagged_line_section_vec_t._del(self, x: "tagged_line_section_t") -> bool + +ida_kernwin.tagged_line_section_vec_t.add_unique(self, x: "tagged_line_section_t") -> bool + +ida_kernwin.tagged_line_section_vec_t.append(self, x: "tagged_line_section_t") -> None + +ida_kernwin.tagged_line_section_vec_t.at(self, _idx: "size_t") -> "tagged_line_section_t const &" + +ida_kernwin.tagged_line_section_vec_t.begin(self, *args) -> "qvector< tagged_line_section_t >::const_iterator" + +ida_kernwin.tagged_line_section_vec_t.capacity(self) -> "size_t" + +ida_kernwin.tagged_line_section_vec_t.clear(self) -> None + +ida_kernwin.tagged_line_section_vec_t.empty(self) -> bool + +ida_kernwin.tagged_line_section_vec_t.end(self, *args) -> "qvector< tagged_line_section_t >::const_iterator" + +ida_kernwin.tagged_line_section_vec_t.erase(self, *args) -> "qvector< tagged_line_section_t >::iterator" + +ida_kernwin.tagged_line_section_vec_t.extend(self, x: "tagged_line_section_vec_t") -> None + +ida_kernwin.tagged_line_section_vec_t.extract(self) -> "tagged_line_section_t *" + +ida_kernwin.tagged_line_section_vec_t.find(self, *args) -> "qvector< tagged_line_section_t >::const_iterator" + +ida_kernwin.tagged_line_section_vec_t.grow(self, *args) -> None + +ida_kernwin.tagged_line_section_vec_t.has(self, x: "tagged_line_section_t") -> bool + +ida_kernwin.tagged_line_section_vec_t.inject(self, s: "tagged_line_section_t", len: "size_t") -> None + +ida_kernwin.tagged_line_section_vec_t.insert(self, it: "tagged_line_section_t", x: "tagged_line_section_t") -> "qvector< tagged_line_section_t >::iterator" + +ida_kernwin.tagged_line_section_vec_t.pop_back(self) -> None + +ida_kernwin.tagged_line_section_vec_t.push_back(self, *args) -> "tagged_line_section_t &" + +ida_kernwin.tagged_line_section_vec_t.qclear(self) -> None + +ida_kernwin.tagged_line_section_vec_t.reserve(self, cnt: "size_t") -> None + +ida_kernwin.tagged_line_section_vec_t.resize(self, *args) -> None + +ida_kernwin.tagged_line_section_vec_t.size(self) -> "size_t" + +ida_kernwin.tagged_line_section_vec_t.swap(self, r: "tagged_line_section_vec_t") -> None + +ida_kernwin.tagged_line_section_vec_t.truncate(self) -> None + +ida_kernwin.tagged_line_sections_t + +ida_kernwin.tagged_line_sections_t.__init__(self) + +ida_kernwin.tagged_line_sections_t.first(self, tag: "color_t") -> "tagged_line_section_t const *" + +ida_kernwin.tagged_line_sections_t.nearest_after(self, range: "tagged_line_section_t", start: "cpidx_t", tag: "color_t" = 0) -> "tagged_line_section_t const *" + +ida_kernwin.tagged_line_sections_t.nearest_at(self, x: "cpidx_t", tag: "color_t" = 0) -> "tagged_line_section_t const *" + +ida_kernwin.tagged_line_sections_t.nearest_before(self, range: "tagged_line_section_t", start: "cpidx_t", tag: "color_t" = 0) -> "tagged_line_section_t const *" + +ida_kernwin.tagged_line_sections_t.sections_at(self, out: "tagged_line_sections_t", x: "cpidx_t", tag: "color_t" = 0) -> None + +ida_kernwin.take_database_snapshot(snapshot) -> Tuple[bool, str] + Take a database snapshot. - @param str: (C++: const char *) string to parse - @param screen_ea: (C++: ea_t) the current address in the disassembly/pseudocode view - @param flags: (C++: int) see String to address conversion flags - @return: success + @param snapshot the snapshot object + @return a tuple (success, error-message) -ida_kernwin.strarray (function) - strarray(array, array_size, code) -> char const * - Find a line with the specified code in the strarray_t array. If the last element - of the array has code==0 then it is considered as the default entry. - If no default entry exists and the code is not found, strarray() returns "". - - @param array: (C++: const strarray_t *) strarray_t const * - @param array_size: (C++: size_t) - @param code: (C++: int) +ida_kernwin.text_t -ida_kernwin.strarray_t (class) - Proxy of C++ strarray_t class. +ida_kernwin.text_t.__getitem__(self, i: "size_t") -> "twinline_t const &" -ida_kernwin.strarray_t.__init__ (method) - __init__(self) -> strarray_t +ida_kernwin.text_t.__init__(self, *args) -ida_kernwin.structplace_t (class) - Proxy of C++ structplace_t class. +ida_kernwin.text_t.__len__(self) -> "size_t" -ida_kernwin.structplace_t.__init__ (method) +ida_kernwin.text_t.__setitem__(self, i: "size_t", v: "twinline_t") -> None -ida_kernwin.structplace_t.idx (variable) - struct serial number +ida_kernwin.text_t.append(self, x: "twinline_t") -> None -ida_kernwin.structplace_t.offset (variable) - offset within struct +ida_kernwin.text_t.at(self, _idx: "size_t") -> "twinline_t const &" -ida_kernwin.sync_source_t (class) - Proxy of C++ sync_source_t class. +ida_kernwin.text_t.begin(self, *args) -> "qvector< twinline_t >::const_iterator" -ida_kernwin.sync_source_t.__eq__ (method) - __eq__(self, _o) -> bool - - @param _o: sync_source_t const & +ida_kernwin.text_t.capacity(self) -> "size_t" -ida_kernwin.sync_source_t.__init__ (method) - __init__(self, _view) -> sync_source_t - - @param _view: TWidget const * - - __init__(self, _regname) -> sync_source_t - - @param _regname: char const * +ida_kernwin.text_t.clear(self) -> None -ida_kernwin.sync_source_t.__ne__ (method) - __ne__(self, _o) -> bool - - @param _o: sync_source_t const & +ida_kernwin.text_t.empty(self) -> bool -ida_kernwin.sync_source_t.get_register (method) - get_register(self) -> char const * +ida_kernwin.text_t.end(self, *args) -> "qvector< twinline_t >::const_iterator" -ida_kernwin.sync_source_t.get_widget (method) - get_widget(self) -> TWidget const * +ida_kernwin.text_t.erase(self, *args) -> "qvector< twinline_t >::iterator" -ida_kernwin.sync_source_t.is_register (method) - is_register(self) -> bool +ida_kernwin.text_t.extend(self, x: "text_t") -> None -ida_kernwin.sync_source_t.is_widget (method) - is_widget(self) -> bool +ida_kernwin.text_t.extract(self) -> "twinline_t *" -ida_kernwin.sync_source_vec_t (class) - Proxy of C++ qvector< sync_source_t > class. +ida_kernwin.text_t.grow(self, *args) -> None -ida_kernwin.sync_source_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< sync_source_t > const & +ida_kernwin.text_t.inject(self, s: "twinline_t", len: "size_t") -> None -ida_kernwin.sync_source_vec_t.__getitem__ (method) - __getitem__(self, i) -> sync_source_t - - @param i: size_t +ida_kernwin.text_t.insert(self, it: "twinline_t", x: "twinline_t") -> "qvector< twinline_t >::iterator" -ida_kernwin.sync_source_vec_t.__init__ (method) - __init__(self) -> sync_source_vec_t - __init__(self, x) -> sync_source_vec_t - - @param x: qvector< sync_source_t > const & +ida_kernwin.text_t.pop_back(self) -> None -ida_kernwin.sync_source_vec_t.__len__ (method) - __len__(self) -> size_t +ida_kernwin.text_t.push_back(self, *args) -> "twinline_t &" -ida_kernwin.sync_source_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< sync_source_t > const & +ida_kernwin.text_t.qclear(self) -> None -ida_kernwin.sync_source_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: sync_source_t const & +ida_kernwin.text_t.reserve(self, cnt: "size_t") -> None -ida_kernwin.sync_source_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: sync_source_t const & +ida_kernwin.text_t.resize(self, *args) -> None -ida_kernwin.sync_source_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: sync_source_t const & +ida_kernwin.text_t.size(self) -> "size_t" -ida_kernwin.sync_source_vec_t.at (method) - at(self, _idx) -> sync_source_t - - @param _idx: size_t +ida_kernwin.text_t.swap(self, r: "text_t") -> None -ida_kernwin.sync_source_vec_t.begin (method) - begin(self) -> sync_source_t +ida_kernwin.text_t.truncate(self) -> None -ida_kernwin.sync_source_vec_t.capacity (method) - capacity(self) -> size_t +ida_kernwin.textctrl_info_t + Flags value -ida_kernwin.sync_source_vec_t.clear (method) - clear(self) - -ida_kernwin.sync_source_vec_t.empty (method) - empty(self) -> bool - -ida_kernwin.sync_source_vec_t.end (method) - end(self) -> sync_source_t - -ida_kernwin.sync_source_vec_t.erase (method) - erase(self, it) -> sync_source_t - - @param it: qvector< sync_source_t >::iterator - - erase(self, first, last) -> sync_source_t - - @param first: qvector< sync_source_t >::iterator - @param last: qvector< sync_source_t >::iterator - -ida_kernwin.sync_source_vec_t.extract (method) - extract(self) -> sync_source_t - -ida_kernwin.sync_source_vec_t.find (method) - find(self, x) -> sync_source_t - - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.has (method) - has(self, x) -> bool - - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.inject (method) - inject(self, s, len) - - @param s: sync_source_t * - @param len: size_t - -ida_kernwin.sync_source_vec_t.insert (method) - insert(self, it, x) -> sync_source_t - - @param it: qvector< sync_source_t >::iterator - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.pop_back (method) - pop_back(self) - -ida_kernwin.sync_source_vec_t.push_back (method) - push_back(self, x) - - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.qclear (method) - qclear(self) - -ida_kernwin.sync_source_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.sync_source_vec_t.size (method) - size(self) -> size_t - -ida_kernwin.sync_source_vec_t.swap (method) - swap(self, r) - - @param r: qvector< sync_source_t > & - -ida_kernwin.sync_source_vec_t.truncate (method) - truncate(self) - -ida_kernwin.sync_sources (function) - sync_sources(what, _with, sync) -> bool - [Un]synchronize sources - - @param what: (C++: const sync_source_t &) - @param with: (C++: const sync_source_t &) - @param sync: (C++: bool) - @return: success - -ida_kernwin.synced_group_t (class) - Proxy of C++ synced_group_t class. - -ida_kernwin.synced_group_t.__init__ (method) - __init__(self) -> synced_group_t - -ida_kernwin.synced_group_t.has (method) - has(self, ss) -> bool - - @param ss: sync_source_t const & - -ida_kernwin.synced_group_t.has_register (method) - has_register(self, r) -> bool - - @param r: char const * - -ida_kernwin.synced_group_t.has_widget (method) - has_widget(self, v) -> bool - - @param v: TWidget const * - -ida_kernwin.tagged_line_section_t (class) - Proxy of C++ tagged_line_section_t class. - -ida_kernwin.tagged_line_section_t.__init__ (method) - __init__(self) -> tagged_line_section_t - -ida_kernwin.tagged_line_section_t.substr (method) - substr(self, _in) -> bool - - @param in: qstring const & - -ida_kernwin.tagged_line_section_t.valid (method) - valid(self) -> bool - -ida_kernwin.tagged_line_section_t.valid_in (method) - valid_in(self, _in) -> bool - - @param in: qstring const & - -ida_kernwin.tagged_line_sections_t (class) - Proxy of C++ tagged_line_sections_t class. - -ida_kernwin.tagged_line_sections_t.__init__ (method) - __init__(self) -> tagged_line_sections_t - -ida_kernwin.tagged_line_sections_t.find_in (method) - find_in(self, range, tag=0) -> tagged_line_section_t - - @param range: tagged_line_section_t const & - @param tag: color_t - -ida_kernwin.tagged_line_sections_t.nearest_at (method) - nearest_at(self, x, tag=0) -> tagged_line_section_t - - @param x: cpidx_t - @param tag: color_t - -ida_kernwin.tagged_line_sections_t.sections_at (method) - sections_at(self, out, x, tag=0) - - @param out: tagged_line_sections_t * - @param x: cpidx_t - @param tag: color_t - -ida_kernwin.take_database_snapshot (function) - take_database_snapshot(ss) -> (bool, NoneType) - Take a database snapshot (ui_take_database_snapshot). - - @param ss: (C++: snapshot_t *) in/out parameter. - * in: description, flags - * out: filename, id - @return: success - -ida_kernwin.text_t (class) - Proxy of C++ qvector< twinline_t > class. - -ida_kernwin.text_t.__getitem__ (method) - __getitem__(self, i) -> twinline_t - - @param i: size_t - -ida_kernwin.text_t.__init__ (method) - __init__(self) -> text_t - __init__(self, x) -> text_t - - @param x: qvector< twinline_t > const & - -ida_kernwin.text_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.text_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: twinline_t const & - -ida_kernwin.text_t.at (method) - at(self, _idx) -> twinline_t - - @param _idx: size_t - -ida_kernwin.text_t.begin (method) - begin(self) -> twinline_t - -ida_kernwin.text_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.text_t.clear (method) - clear(self) - -ida_kernwin.text_t.empty (method) - empty(self) -> bool - -ida_kernwin.text_t.end (method) - end(self) -> twinline_t - -ida_kernwin.text_t.erase (method) - erase(self, it) -> twinline_t - - @param it: qvector< twinline_t >::iterator - - erase(self, first, last) -> twinline_t - - @param first: qvector< twinline_t >::iterator - @param last: qvector< twinline_t >::iterator - -ida_kernwin.text_t.extract (method) - extract(self) -> twinline_t - -ida_kernwin.text_t.grow (method) - grow(self, x=twinline_t()) - - @param x: twinline_t const & - -ida_kernwin.text_t.inject (method) - inject(self, s, len) - - @param s: twinline_t * - @param len: size_t - -ida_kernwin.text_t.insert (method) - insert(self, it, x) -> twinline_t - - @param it: qvector< twinline_t >::iterator - @param x: twinline_t const & - -ida_kernwin.text_t.pop_back (method) - pop_back(self) - -ida_kernwin.text_t.push_back (method) - push_back(self, x) - - @param x: twinline_t const & - - push_back(self) -> twinline_t - -ida_kernwin.text_t.qclear (method) - qclear(self) - -ida_kernwin.text_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.text_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: twinline_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_kernwin.text_t.size (method) - size(self) -> size_t - -ida_kernwin.text_t.swap (method) - swap(self, r) - - @param r: qvector< twinline_t > & - -ida_kernwin.text_t.truncate (method) - truncate(self) - -ida_kernwin.textctrl_info_t (class) - Class representing textctrl_info_t - -ida_kernwin.textctrl_info_t.TXTF_ACCEPTTABS (variable) +ida_kernwin.textctrl_info_t.TXTF_ACCEPTTABS Tab key inserts 'tabsize' spaces -ida_kernwin.textctrl_info_t.TXTF_AUTOINDENT (variable) +ida_kernwin.textctrl_info_t.TXTF_AUTOINDENT Auto-indent on new line -ida_kernwin.textctrl_info_t.TXTF_FIXEDFONT (variable) +ida_kernwin.textctrl_info_t.TXTF_FIXEDFONT The control uses IDA's fixed font -ida_kernwin.textctrl_info_t.TXTF_MODIFIED (variable) +ida_kernwin.textctrl_info_t.TXTF_MODIFIED Gets/sets the modified status -ida_kernwin.textctrl_info_t.TXTF_READONLY (variable) +ida_kernwin.textctrl_info_t.TXTF_READONLY Text cannot be edited (but can be selected and copied) -ida_kernwin.textctrl_info_t.TXTF_SELECTED (variable) +ida_kernwin.textctrl_info_t.TXTF_SELECTED Shows the field with its text selected -ida_kernwin.textctrl_info_t.__get_flags__ (method) +ida_kernwin.textctrl_info_t.__get_flags__(self) Returns the flags value -ida_kernwin.textctrl_info_t.__get_tabsize__ (method) +ida_kernwin.textctrl_info_t.__get_tabsize__(self) Returns the tabsize value -ida_kernwin.textctrl_info_t.__get_text (method) +ida_kernwin.textctrl_info_t.__get_text(self) Sets the text value -ida_kernwin.textctrl_info_t.__init__ (method) +ida_kernwin.textctrl_info_t.__init__(self, text = "", flags = 0, tabsize = 0) -ida_kernwin.textctrl_info_t.__set_flags__ (method) +ida_kernwin.textctrl_info_t.__set_flags__(self, flags) Sets the flags value -ida_kernwin.textctrl_info_t.__set_tabsize__ (method) +ida_kernwin.textctrl_info_t.__set_tabsize__(self, tabsize) Sets the tabsize value -ida_kernwin.textctrl_info_t.__set_text (method) +ida_kernwin.textctrl_info_t.__set_text(self, s) Sets the text value -ida_kernwin.textctrl_info_t._create_clink (method) +ida_kernwin.textctrl_info_t._create_clink(self) -ida_kernwin.textctrl_info_t._del_clink (method) +ida_kernwin.textctrl_info_t._del_clink(self, lnk) -ida_kernwin.textctrl_info_t._get_clink_ptr (method) +ida_kernwin.textctrl_info_t._get_clink_ptr(self) -ida_kernwin.textctrl_info_t.assign (method) +ida_kernwin.textctrl_info_t.assign(self, other) Copies the contents of 'other' to 'self' -ida_kernwin.textctrl_info_t.flags (variable) - Text control property bits +ida_kernwin.textctrl_info_t.flags + Text control property bits + -ida_kernwin.textctrl_info_t.tabsize (variable) +ida_kernwin.textctrl_info_t.tabsize how many spaces a single tab will indent -ida_kernwin.textctrl_info_t.text (variable) +ida_kernwin.textctrl_info_t.text in, out: text control value -ida_kernwin.textctrl_info_t.value (variable) +ida_kernwin.textctrl_info_t.value Alias for the text property -ida_kernwin.textctrl_info_t_assign (function) - textctrl_info_t_assign(_self, other) -> bool - - @param self: PyObject * - @param other: PyObject * +ida_kernwin.textctrl_info_t_assign(_self: "PyObject *", other: "PyObject *") -> bool -ida_kernwin.textctrl_info_t_create (function) - textctrl_info_t_create() -> PyObject * +ida_kernwin.textctrl_info_t_create() -> "PyObject *" -ida_kernwin.textctrl_info_t_destroy (function) - textctrl_info_t_destroy(py_obj) -> bool - - @param py_obj: PyObject * +ida_kernwin.textctrl_info_t_destroy(py_obj: "PyObject *") -> bool -ida_kernwin.textctrl_info_t_get_clink (function) - textctrl_info_t_get_clink(_self) -> textctrl_info_t * - - @param self: PyObject * +ida_kernwin.textctrl_info_t_get_clink(_self: "PyObject *") -> "textctrl_info_t *" -ida_kernwin.textctrl_info_t_get_clink_ptr (function) - textctrl_info_t_get_clink_ptr(_self) -> PyObject * - - @param self: PyObject * +ida_kernwin.textctrl_info_t_get_clink_ptr(_self: "PyObject *") -> "PyObject *" -ida_kernwin.textctrl_info_t_get_flags (function) - textctrl_info_t_get_flags(_self) -> unsigned int - - @param self: PyObject * +ida_kernwin.textctrl_info_t_get_flags(_self: "PyObject *") -> "unsigned int" -ida_kernwin.textctrl_info_t_get_tabsize (function) - textctrl_info_t_get_tabsize(_self) -> unsigned int - - @param self: PyObject * +ida_kernwin.textctrl_info_t_get_tabsize(_self: "PyObject *") -> "unsigned int" -ida_kernwin.textctrl_info_t_get_text (function) - textctrl_info_t_get_text(_self) -> char const * - - @param self: PyObject * +ida_kernwin.textctrl_info_t_get_text(_self: "PyObject *") -> str -ida_kernwin.textctrl_info_t_set_flags (function) - textctrl_info_t_set_flags(_self, flags) -> bool - - @param self: PyObject * - @param flags: unsigned int +ida_kernwin.textctrl_info_t_set_flags(_self: "PyObject *", flags: "unsigned int") -> bool -ida_kernwin.textctrl_info_t_set_tabsize (function) - textctrl_info_t_set_tabsize(_self, tabsize) -> bool - - @param self: PyObject * - @param tabsize: unsigned int +ida_kernwin.textctrl_info_t_set_tabsize(_self: "PyObject *", tabsize: "unsigned int") -> bool -ida_kernwin.textctrl_info_t_set_text (function) - textctrl_info_t_set_text(_self, s) -> bool - - @param self: PyObject * - @param s: char const * +ida_kernwin.textctrl_info_t_set_text(_self: "PyObject *", s: str) -> bool -ida_kernwin.tiplace_t (class) - Proxy of C++ tiplace_t class. +ida_kernwin.tiplace_t -ida_kernwin.tiplace_t.__init__ (method) +ida_kernwin.tiplace_t.__init__(self, *args, **kwargs) -ida_kernwin.tiplace_t.calc_udm_offset (method) - calc_udm_offset(self, ud, p_udmidx=None, p_bitoff=None) -> uint64 - for structs: calculate the offset that corresponds to the tiplace. - - @param ud: (C++: const void *) pointer to user-defined context data. Is supplied by linearray_t - @param p_udmidx: (C++: ssize_t *) place to return the index of the current udt member, if any. if - there is no member at the current offset, return -1 - @param p_bitoff: (C++: int *) place to return the bit offset of the item from the beginning - of the bit bucket if there no bitfields, return -1 - @return: the current offset or uint64(-1) +ida_kernwin.tiplace_t.calc_udm_offset(self, ud: "void const *", p_udmidx: "ssize_t *" = None, p_bitoff: "int *" = None) -> "uint64" + for structs: calculate the offset that corresponds to the tiplace. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @param p_udmidx: place to return the index of the current udt member, if any. if there is no member at the current offset, return -1 + @param p_bitoff: place to return the bit offset of the item from the beginning of the bit bucket if there no bitfields, return -1 + @returns the current offset or uint64(-1) -ida_kernwin.tiplace_t.fill_type_ref (method) - fill_type_ref(self, out, ud) -> bool - fill the type information for use in actions - - @param out: (C++: til_type_ref_t *) pointer to storage - @param ud: (C++: const void *) pointer to user-defined context data. Is supplied by linearray_t - @return: success +ida_kernwin.tiplace_t.fill_type_ref(self, out: "til_type_ref_t", ud: "void const *") -> bool + fill the type information for use in actions + + @param out: pointer to storage + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @returns success -ida_kernwin.tiplace_t.get_kind (method) - get_kind(self, ud) -> type_t - get the kind of type this place represents - - @param ud: (C++: const void *) pointer to user-defined context data. Is supplied by linearray_t - @return: one of BTF_TYPEDEF, BTF_STRUCT, BTF_UNION, BTF_ENUM or BT_UNK +ida_kernwin.tiplace_t.get_kind(self, ud: "void const *") -> "type_t" + get the kind of type this place represents + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @returns one of BTF_TYPEDEF, BTF_STRUCT, BTF_UNION, BTF_ENUM or BT_UNK -ida_kernwin.tiplace_t.is_footer (method) - is_footer(self) -> bool +ida_kernwin.tiplace_t.is_footer(self) -> bool -ida_kernwin.tiplace_t.is_header (method) - is_header(self) -> bool +ida_kernwin.tiplace_t.is_header(self) -> bool -ida_kernwin.tiplace_t.is_index (method) - is_index(self) -> bool +ida_kernwin.tiplace_t.is_index(self) -> bool -ida_kernwin.tiplace_t.reset (method) - reset(self) +ida_kernwin.tiplace_t.reset(self) -> None -ida_kernwin.tiplace_t.set_footer (method) - set_footer(self) +ida_kernwin.tiplace_t.set_footer(self) -> None -ida_kernwin.tiplace_t.set_header (method) - set_header(self) +ida_kernwin.tiplace_t.set_header(self) -> None -ida_kernwin.tiplace_t.set_index_by_offset (method) - set_index_by_offset(self, ud, offset) - for structs: calculate the index that corresponds to the offset and set it. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @param offset: (C++: uint64) offset of udt member +ida_kernwin.tiplace_t.set_index_by_offset(self, ud: "void *", offset: "uint64") -> None + for structs: calculate the index that corresponds to the offset and set it. + + @param ud: pointer to user-defined context data. Is supplied by linearray_t + @param offset: offset of udt member -ida_kernwin.tiplace_t.valid_ord (method) - valid_ord(self) -> bool +ida_kernwin.tiplace_t.valid_ord(self) -> bool -ida_kernwin.twinline_t (class) - Proxy of C++ twinline_t class. +ida_kernwin.twinline_t -ida_kernwin.twinline_t.__init__ (method) - __init__(self) -> twinline_t - __init__(self, t, pc, bc) -> twinline_t - - @param t: place_t * - @param pc: color_t - @param bc: bgcolor_t +ida_kernwin.twinline_t.__init__(self, *args) -ida_kernwin.twinline_t.at (variable) +ida_kernwin.twinline_t.at location in view -ida_kernwin.twinline_t.bg_color (variable) +ida_kernwin.twinline_t.bg_color line background color -ida_kernwin.twinline_t.is_default (variable) +ida_kernwin.twinline_t.is_default is this the default line of the current location? -ida_kernwin.twinline_t.line (variable) +ida_kernwin.twinline_t.line line contents -ida_kernwin.twinline_t.prefix_color (variable) +ida_kernwin.twinline_t.prefix_color line prefix color -ida_kernwin.twinpos_t (class) - Proxy of C++ twinpos_t class. +ida_kernwin.twinpos_t -ida_kernwin.twinpos_t.__init__ (method) - __init__(self) -> twinpos_t - __init__(self, t) -> twinpos_t - - @param t: place_t * - - __init__(self, t, x0) -> twinpos_t - - @param t: place_t * - @param x0: int +ida_kernwin.twinpos_t.__init__(self, *args) -ida_kernwin.twinpos_t.at (variable) +ida_kernwin.twinpos_t.at location in view -ida_kernwin.twinpos_t.place (method) +ida_kernwin.twinpos_t.place(self, view) -ida_kernwin.twinpos_t.place_as_enumplace_t (method) +ida_kernwin.twinpos_t.place_as_idaplace_t(self) -ida_kernwin.twinpos_t.place_as_idaplace_t (method) +ida_kernwin.twinpos_t.place_as_simpleline_place_t(self) -ida_kernwin.twinpos_t.place_as_simpleline_place_t (method) +ida_kernwin.twinpos_t.place_as_tiplace_t(self) -ida_kernwin.twinpos_t.place_as_structplace_t (method) - -ida_kernwin.twinpos_t.place_as_tiplace_t (method) - -ida_kernwin.twinpos_t.x (variable) +ida_kernwin.twinpos_t.x cursor x -ida_kernwin.ui_load_new_file (function) - ui_load_new_file(temp_file, filename, pli, neflags, ploaders) -> bool - Display a load file dialog and load file (ui_load_file). - - @param temp_file: (C++: qstring *) name of the file with the extracted archive member. - @param filename: (C++: qstring *) the name of input file as is, library or archive name - @param pli: (C++: linput_t **) loader input source, may be changed to point to temp_file - @param neflags: (C++: ushort) combination of NEF_... bits (see Load file flags) - @param ploaders: (C++: load_info_t **) list of loaders which accept file, may be changed for loaders - of temp_file +ida_kernwin.ui_load_new_file(temp_file: str, filename: str, pli: "linput_t **", neflags: "ushort", ploaders: "load_info_t **") -> bool + Display a load file dialog and load file (ui_load_file). + + @param temp_file: name of the file with the extracted archive member. + @param filename: the name of input file as is, library or archive name + @param pli: loader input source, may be changed to point to temp_file + @param neflags: combination of NEF_... bits (see Load file flags) + @param ploaders: list of loaders which accept file, may be changed for loaders of temp_file @retval true: file was successfully loaded @retval false: otherwise -ida_kernwin.ui_requests_t (class) - Proxy of C++ ui_requests_t class. +ida_kernwin.ui_requests_t -ida_kernwin.ui_requests_t.__init__ (method) - __init__(self) -> ui_requests_t +ida_kernwin.ui_requests_t.__init__(self) -ida_kernwin.ui_run_debugger (function) - ui_run_debugger(dbgopts, exename, argc, argv) -> bool - Load a debugger plugin and run the specified program (ui_run_dbg). - - @param dbgopts: (C++: const char *) value of the -r command line switch - @param exename: (C++: const char *) name of the file to run - @param argc: (C++: int) number of arguments for the executable - @param argv: (C++: const char *const *) argument vector - @return: success +ida_kernwin.ui_run_debugger(dbgopts: str, exename: str, argc: int, argv: "char const *const *") -> bool + Load a debugger plugin and run the specified program (ui_run_dbg). + + @param dbgopts: value of the -r command line switch + @param exename: name of the file to run + @param argc: number of arguments for the executable + @param argv: argument vector + @returns success -ida_kernwin.unmark_selection (function) - unmark_selection() +ida_kernwin.unmark_selection() -> None Unmark selection (ui_unmarksel) -ida_kernwin.unregister_action (function) - unregister_action(name) -> bool - Delete a previously-registered action (ui_unregister_action). - - @param name: (C++: const char *) name of action - @return: success +ida_kernwin.unregister_action(name: str) -> bool + Delete a previously-registered action (ui_unregister_action). + + @param name: name of action + @returns success -ida_kernwin.unregister_timer (function) - unregister_timer(py_timerctx) -> bool +ida_kernwin.unregister_timer(timer_obj) 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. -ida_kernwin.update_action_checkable (function) - update_action_checkable(name, checkable) -> bool - Update an action's checkability (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param checkable: (C++: bool) new checkability - @return: success +ida_kernwin.update_action_checkable(name: str, checkable: bool) -> bool + Update an action's checkability (ui_update_action_attr). + + @param name: action name + @param checkable: new checkability + @returns success -ida_kernwin.update_action_checked (function) - update_action_checked(name, checked) -> bool - Update an action's checked state (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param checked: (C++: bool) new checked state - @return: success +ida_kernwin.update_action_checked(name: str, checked: bool) -> bool + Update an action's checked state (ui_update_action_attr). + + @param name: action name + @param checked: new checked state + @returns success -ida_kernwin.update_action_icon (function) - update_action_icon(name, icon) -> bool - Update an action's icon (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param icon: (C++: int) new icon id - @return: success +ida_kernwin.update_action_icon(name: str, icon: int) -> bool + Update an action's icon (ui_update_action_attr). + + @param name: action name + @param icon: new icon id + @returns success -ida_kernwin.update_action_label (function) - update_action_label(name, label) -> bool - Update an action's label (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param label: (C++: const char *) new label - @return: success +ida_kernwin.update_action_label(name: str, label: str) -> bool + Update an action's label (ui_update_action_attr). + + @param name: action name + @param label: new label + @returns success -ida_kernwin.update_action_shortcut (function) - update_action_shortcut(name, shortcut) -> bool - Update an action's shortcut (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param shortcut: (C++: const char *) new shortcut - @return: success +ida_kernwin.update_action_shortcut(name: str, shortcut: str) -> bool + Update an action's shortcut (ui_update_action_attr). + + @param name: action name + @param shortcut: new shortcut + @returns success -ida_kernwin.update_action_state (function) - update_action_state(name, state) -> bool - Update an action's state (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param state: (C++: action_state_t) new state - @return: success +ida_kernwin.update_action_state(name: str, state: "action_state_t") -> bool + Update an action's state (ui_update_action_attr). + + @param name: action name + @param state: new state + @returns success -ida_kernwin.update_action_tooltip (function) - update_action_tooltip(name, tooltip) -> bool - Update an action's tooltip (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param tooltip: (C++: const char *) new tooltip - @return: success +ida_kernwin.update_action_tooltip(name: str, tooltip: str) -> bool + Update an action's tooltip (ui_update_action_attr). + + @param name: action name + @param tooltip: new tooltip + @returns success -ida_kernwin.update_action_visibility (function) - update_action_visibility(name, visible) -> bool - Update an action's visibility (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param visible: (C++: bool) new visibility - @return: success +ida_kernwin.update_action_visibility(name: str, visible: bool) -> bool + Update an action's visibility (ui_update_action_attr). + + @param name: action name + @param visible: new visibility + @returns success -ida_kernwin.user_cancelled (function) - user_cancelled() -> bool - Test the ctrl-break flag (ui_test_cancelled). +ida_kernwin.user_cancelled() -> bool + Test the ctrl-break flag (ui_test_cancelled). + @retval 1: Ctrl-Break is detected, a message is displayed @retval 2: Ctrl-Break is detected again, a message is not displayed @retval 0: Ctrl-Break is not detected -ida_kernwin.view_activated (variable) - A view is activated +ida_kernwin.view_activated + A view is activated + -ida_kernwin.view_click (variable) - Click event +ida_kernwin.view_click + Click event + -ida_kernwin.view_close (variable) - View closed +ida_kernwin.view_close + View closed + -ida_kernwin.view_created (variable) - A view is being created. +ida_kernwin.view_created + A view is being created. + -ida_kernwin.view_curpos (variable) - Cursor position changed +ida_kernwin.view_curpos + Cursor position changed + -ida_kernwin.view_dblclick (variable) - Double click event +ida_kernwin.view_dblclick + Double click event + -ida_kernwin.view_deactivated (variable) - A view is deactivated +ida_kernwin.view_deactivated + A view is deactivated + -ida_kernwin.view_keydown (variable) - Key down event +ida_kernwin.view_keydown + Key down event + -ida_kernwin.view_loc_changed (variable) - The location for the view has changed (can be either the place_t, the - renderer_info_t, or both.) +ida_kernwin.view_loc_changed + The location for the view has changed (can be either the place_t, the renderer_info_t, or both.) + -ida_kernwin.view_mouse_event_location_t (class) - Proxy of C++ view_mouse_event_location_t class. +ida_kernwin.view_mouse_event_location_t -ida_kernwin.view_mouse_event_location_t.__init__ (method) - __init__(self) -> view_mouse_event_location_t +ida_kernwin.view_mouse_event_location_t.__init__(self) -ida_kernwin.view_mouse_event_location_t.ea (variable) +ida_kernwin.view_mouse_event_location_t.ea flat view (rtype == TCCRT_FLAT) -ida_kernwin.view_mouse_event_location_t.item (variable) - graph views (rtype != TCCRT_FLAT). nullptr if mouse is not currently over an - item. +ida_kernwin.view_mouse_event_location_t.item + graph views (rtype != TCCRT_FLAT). nullptr if mouse is not currently over an item. + -ida_kernwin.view_mouse_event_t (class) - Proxy of C++ view_mouse_event_t class. +ida_kernwin.view_mouse_event_t -ida_kernwin.view_mouse_event_t.__init__ (method) - __init__(self) -> view_mouse_event_t +ida_kernwin.view_mouse_event_t.__init__(self) -ida_kernwin.view_mouse_event_t.button (variable) - represents which mouse button was responsible for generating the event. This - field does not care about the current state of the mouse. +ida_kernwin.view_mouse_event_t.button + represents which mouse button was responsible for generating the event. This field does not care about the current state of the mouse. + -ida_kernwin.view_mouse_event_t.location (variable) +ida_kernwin.view_mouse_event_t.location location where event was generated -ida_kernwin.view_mouse_event_t.renderer_pos (variable) +ida_kernwin.view_mouse_event_t.renderer_pos position where event was generated, relative to the renderer -ida_kernwin.view_mouse_event_t.rtype (variable) +ida_kernwin.view_mouse_event_t.rtype type of renderer that received the event -ida_kernwin.view_mouse_event_t.state (variable) - contains information about what buttons are CURRENTLY pressed on the keyboard - and mouse. view_mouse_event_t instances created in functions like - mouseReleaseEvent() won't contain any information about the mouse, because it - has been released. +ida_kernwin.view_mouse_event_t.state + contains information about what buttons are CURRENTLY pressed on the keyboard and mouse. view_mouse_event_t instances created in functions like mouseReleaseEvent() won't contain any information about the mouse, because it has been released. + -ida_kernwin.view_mouse_event_t.x (variable) +ida_kernwin.view_mouse_event_t.x screen x coordinate -ida_kernwin.view_mouse_event_t.y (variable) +ida_kernwin.view_mouse_event_t.y screen y coordinate -ida_kernwin.view_mouse_moved (variable) - The mouse moved on the view +ida_kernwin.view_mouse_moved + The mouse moved on the view + -ida_kernwin.view_mouse_over (variable) - The user moved the mouse over (or out of) a node or an edge. This is only - relevant in a graph view. +ida_kernwin.view_mouse_over + The user moved the mouse over (or out of) a node or an edge. This is only relevant in a graph view. + -ida_kernwin.view_switched (variable) - A view's renderer has changed. +ida_kernwin.view_switched + A view's renderer has changed. + -ida_kernwin.warning (function) - warning(format) - Display a message in a message box +ida_kernwin.warning(message) + Display a message in a warning message box - @param message: message to print (formatting is done in Python) - - This function can be used to debug IDAPython scripts - The user will be able to hide messages if they appear twice in a row on - the screen + @param message: message to print -ida_lines (module) - High level functions that deal with the generation of the disassembled text - lines. +ida_libfuncs + +ida_libfuncs.get_idasgn_header_by_short_name(out_header: "idasgn_header_t", name: str) -> str + Get idasgn header by a short signature name. + + @param out_header: buffer for the signature file header + @param name: short name of a signature + @returns true in case of success + +ida_libfuncs.get_idasgn_path_by_short_name(name: str) -> str + Get idasgn full path by a short signature name. + + @param name: short name of a signature + @returns true in case of success + +ida_libfuncs.idasgn_header_t + +ida_libfuncs.idasgn_header_t.__init__(self) + +ida_lines + High level functions that deal with the generation of the disassembled text lines. This file also contains definitions for the syntax highlighting. - - Finally there are functions that deal with anterior/posterior user-defined - lines. + Finally there are functions that deal with anterior/posterior user-defined lines. + -ida_lines.COLOR_ADDR (variable) - hidden address marks. the address is represented as 8digit hex number: 01234567. - it doesn't have COLOR_OFF pair. NB: for 64-bit IDA, the address is 16digit. +ida_lines.COLOR_ADDR + hidden address marks. the address is represented as 8digit hex number: 01234567. it doesn't have COLOR_OFF pair. NB: for 64-bit IDA, the address is 16digit. + -ida_lines.COLOR_ADDR_SIZE (variable) +ida_lines.COLOR_ADDR_SIZE Size of a tagged address (see COLOR_ADDR) -ida_lines.COLOR_ALTOP (variable) +ida_lines.COLOR_ALTOP Alternative operand. -ida_lines.COLOR_ASMDIR (variable) +ida_lines.COLOR_ASMDIR Assembler directive. -ida_lines.COLOR_AUTOCMT (variable) +ida_lines.COLOR_AUTOCMT Automatic comment. -ida_lines.COLOR_BG_MAX (variable) +ida_lines.COLOR_BG_MAX Max color number. -ida_lines.COLOR_BINPREF (variable) +ida_lines.COLOR_BINPREF Binary line prefix bytes. -ida_lines.COLOR_CHAR (variable) +ida_lines.COLOR_CHAR Char constant in instruction. -ida_lines.COLOR_CNAME (variable) +ida_lines.COLOR_CNAME Regular code name. -ida_lines.COLOR_CODE (variable) +ida_lines.COLOR_CODE Single instruction. -ida_lines.COLOR_CODNAME (variable) +ida_lines.COLOR_CODNAME Dummy code name. -ida_lines.COLOR_COLLAPSED (variable) +ida_lines.COLOR_COLLAPSED Collapsed line. -ida_lines.COLOR_CREF (variable) +ida_lines.COLOR_CREF Code reference. -ida_lines.COLOR_CREFTAIL (variable) +ida_lines.COLOR_CREFTAIL Code reference to tail byte. -ida_lines.COLOR_CURITEM (variable) +ida_lines.COLOR_CURITEM Current item. -ida_lines.COLOR_CURLINE (variable) +ida_lines.COLOR_CURLINE Current line. -ida_lines.COLOR_DATA (variable) +ida_lines.COLOR_DATA Data bytes. -ida_lines.COLOR_DATNAME (variable) +ida_lines.COLOR_DATNAME Dummy Data Name. -ida_lines.COLOR_DCHAR (variable) +ida_lines.COLOR_DCHAR Char constant in data directive. -ida_lines.COLOR_DEFAULT (variable) +ida_lines.COLOR_DEFAULT Default. -ida_lines.COLOR_DEMNAME (variable) +ida_lines.COLOR_DEMNAME Demangled Name. -ida_lines.COLOR_DNAME (variable) +ida_lines.COLOR_DNAME Regular Data Name. -ida_lines.COLOR_DNUM (variable) +ida_lines.COLOR_DNUM Numeric constant in data directive. -ida_lines.COLOR_DREF (variable) +ida_lines.COLOR_DREF Data reference. -ida_lines.COLOR_DREFTAIL (variable) +ida_lines.COLOR_DREFTAIL Data reference to tail byte. -ida_lines.COLOR_DSTR (variable) +ida_lines.COLOR_DSTR String constant in data directive. -ida_lines.COLOR_ERROR (variable) +ida_lines.COLOR_ERROR Error or problem. -ida_lines.COLOR_ESC (variable) - Escape character (Quote next character). This is needed to output '\1' and '\2' - characters. +ida_lines.COLOR_ESC + Escape character (Quote next character). This is needed to output '\1' and '\2' characters. + -ida_lines.COLOR_EXTERN (variable) +ida_lines.COLOR_EXTERN External name definition segment. -ida_lines.COLOR_EXTRA (variable) +ida_lines.COLOR_EXTRA Extra line. -ida_lines.COLOR_FG_MAX (variable) +ida_lines.COLOR_FG_MAX Max color number. -ida_lines.COLOR_HIDLINE (variable) +ida_lines.COLOR_HIDLINE Hidden line. -ida_lines.COLOR_HIDNAME (variable) +ida_lines.COLOR_HIDNAME Hidden name. -ida_lines.COLOR_IMPNAME (variable) +ida_lines.COLOR_IMPNAME Imported name. -ida_lines.COLOR_INSN (variable) +ida_lines.COLOR_INSN Instruction. -ida_lines.COLOR_INV (variable) - Escape character (Inverse foreground and background colors). This escape - character has no corresponding COLOR_OFF. Its action continues until the next - COLOR_INV or end of line. +ida_lines.COLOR_INV + Escape character (Inverse foreground and background colors). This escape character has no corresponding COLOR_OFF. Its action continues until the next COLOR_INV or end of line. + -ida_lines.COLOR_KEYWORD (variable) +ida_lines.COLOR_KEYWORD Keywords. -ida_lines.COLOR_LIBFUNC (variable) +ida_lines.COLOR_LIBFUNC Library function. -ida_lines.COLOR_LIBNAME (variable) +ida_lines.COLOR_LIBNAME Library function name. -ida_lines.COLOR_LOCNAME (variable) +ida_lines.COLOR_LOCNAME Local variable name. -ida_lines.COLOR_LUMFUNC (variable) +ida_lines.COLOR_LUMFUNC Lumina function. -ida_lines.COLOR_LUMINA (variable) +ida_lines.COLOR_LUMINA Lumina-related, only for the navigation band. -ida_lines.COLOR_MACRO (variable) +ida_lines.COLOR_MACRO Macro. -ida_lines.COLOR_NUMBER (variable) +ida_lines.COLOR_NUMBER Numeric constant in instruction. -ida_lines.COLOR_OFF (variable) - Escape character (OFF). Followed by a color code (color_t). +ida_lines.COLOR_OFF + Escape character (OFF). Followed by a color code (color_t). + -ida_lines.COLOR_ON (variable) - Escape character (ON). Followed by a color code (color_t). +ida_lines.COLOR_ON + Escape character (ON). Followed by a color code (color_t). + -ida_lines.COLOR_OPND1 (variable) +ida_lines.COLOR_OPND1 Instruction operand 1. -ida_lines.COLOR_OPND2 (variable) +ida_lines.COLOR_OPND2 Instruction operand 2. -ida_lines.COLOR_OPND3 (variable) +ida_lines.COLOR_OPND3 Instruction operand 3. -ida_lines.COLOR_OPND4 (variable) +ida_lines.COLOR_OPND4 Instruction operand 4. -ida_lines.COLOR_OPND5 (variable) +ida_lines.COLOR_OPND5 Instruction operand 5. -ida_lines.COLOR_OPND6 (variable) +ida_lines.COLOR_OPND6 Instruction operand 6. -ida_lines.COLOR_OPND7 (variable) +ida_lines.COLOR_OPND7 Instruction operand 7. -ida_lines.COLOR_OPND8 (variable) +ida_lines.COLOR_OPND8 Instruction operand 8. -ida_lines.COLOR_PREFIX (variable) +ida_lines.COLOR_PREFIX Line prefix. -ida_lines.COLOR_REG (variable) +ida_lines.COLOR_REG Register name. -ida_lines.COLOR_REGCMT (variable) +ida_lines.COLOR_REGCMT Regular comment. -ida_lines.COLOR_REGFUNC (variable) +ida_lines.COLOR_REGFUNC Regular function. -ida_lines.COLOR_RESERVED1 (variable) +ida_lines.COLOR_RESERVED1 This tag is reserved for internal IDA use. -ida_lines.COLOR_RPTCMT (variable) +ida_lines.COLOR_RPTCMT Repeatable comment (comment defined somewhere else) -ida_lines.COLOR_SEGNAME (variable) +ida_lines.COLOR_SEGNAME Segment name. -ida_lines.COLOR_SELECTED (variable) +ida_lines.COLOR_SELECTED Selected. -ida_lines.COLOR_STRING (variable) +ida_lines.COLOR_STRING String constant in instruction. -ida_lines.COLOR_SYMBOL (variable) +ida_lines.COLOR_SYMBOL Punctuation. -ida_lines.COLOR_UNAME (variable) +ida_lines.COLOR_UNAME Regular unknown name. -ida_lines.COLOR_UNKNAME (variable) +ida_lines.COLOR_UNKNAME Dummy unknown name. -ida_lines.COLOR_UNKNOWN (variable) +ida_lines.COLOR_UNKNOWN Unexplored byte. -ida_lines.COLOR_VOIDOP (variable) +ida_lines.COLOR_VOIDOP Void operand. -ida_lines.COLSTR (function) +ida_lines.COLSTR(str, tag) Utility function to create a colored line @param str: The string @param tag: Color tag constant. One of SCOLOR_XXXX -ida_lines.SCOLOR_ADDR (variable) +ida_lines.SCOLOR_ADDR Hidden address mark. -ida_lines.SCOLOR_ALTOP (variable) +ida_lines.SCOLOR_ALTOP Alternative operand. -ida_lines.SCOLOR_ASMDIR (variable) +ida_lines.SCOLOR_ASMDIR Assembler directive. -ida_lines.SCOLOR_AUTOCMT (variable) +ida_lines.SCOLOR_AUTOCMT Automatic comment. -ida_lines.SCOLOR_BINPREF (variable) +ida_lines.SCOLOR_BINPREF Binary line prefix bytes. -ida_lines.SCOLOR_CHAR (variable) +ida_lines.SCOLOR_CHAR Char constant in instruction. -ida_lines.SCOLOR_CNAME (variable) +ida_lines.SCOLOR_CNAME Regular code name. -ida_lines.SCOLOR_CODNAME (variable) +ida_lines.SCOLOR_CODNAME Dummy code name. -ida_lines.SCOLOR_COLLAPSED (variable) +ida_lines.SCOLOR_COLLAPSED Collapsed line. -ida_lines.SCOLOR_CREF (variable) +ida_lines.SCOLOR_CREF Code reference. -ida_lines.SCOLOR_CREFTAIL (variable) +ida_lines.SCOLOR_CREFTAIL Code reference to tail byte. -ida_lines.SCOLOR_DATNAME (variable) +ida_lines.SCOLOR_DATNAME Dummy Data Name. -ida_lines.SCOLOR_DCHAR (variable) +ida_lines.SCOLOR_DCHAR Char constant in data directive. -ida_lines.SCOLOR_DEFAULT (variable) +ida_lines.SCOLOR_DEFAULT Default. -ida_lines.SCOLOR_DEMNAME (variable) +ida_lines.SCOLOR_DEMNAME Demangled Name. -ida_lines.SCOLOR_DNAME (variable) +ida_lines.SCOLOR_DNAME Regular Data Name. -ida_lines.SCOLOR_DNUM (variable) +ida_lines.SCOLOR_DNUM Numeric constant in data directive. -ida_lines.SCOLOR_DREF (variable) +ida_lines.SCOLOR_DREF Data reference. -ida_lines.SCOLOR_DREFTAIL (variable) +ida_lines.SCOLOR_DREFTAIL Data reference to tail byte. -ida_lines.SCOLOR_DSTR (variable) +ida_lines.SCOLOR_DSTR String constant in data directive. -ida_lines.SCOLOR_ERROR (variable) +ida_lines.SCOLOR_ERROR Error or problem. -ida_lines.SCOLOR_ESC (variable) +ida_lines.SCOLOR_ESC Escape character (Quote next character) -ida_lines.SCOLOR_EXTRA (variable) +ida_lines.SCOLOR_EXTRA Extra line. -ida_lines.SCOLOR_HIDNAME (variable) +ida_lines.SCOLOR_HIDNAME Hidden name. -ida_lines.SCOLOR_IMPNAME (variable) +ida_lines.SCOLOR_IMPNAME Imported name. -ida_lines.SCOLOR_INSN (variable) +ida_lines.SCOLOR_INSN Instruction. -ida_lines.SCOLOR_INV (variable) +ida_lines.SCOLOR_INV Escape character (Inverse colors) -ida_lines.SCOLOR_KEYWORD (variable) +ida_lines.SCOLOR_KEYWORD Keywords. -ida_lines.SCOLOR_LIBNAME (variable) +ida_lines.SCOLOR_LIBNAME Library function name. -ida_lines.SCOLOR_LOCNAME (variable) +ida_lines.SCOLOR_LOCNAME Local variable name. -ida_lines.SCOLOR_MACRO (variable) +ida_lines.SCOLOR_MACRO Macro. -ida_lines.SCOLOR_NUMBER (variable) +ida_lines.SCOLOR_NUMBER Numeric constant in instruction. -ida_lines.SCOLOR_OFF (variable) +ida_lines.SCOLOR_OFF Escape character (OFF) -ida_lines.SCOLOR_ON (variable) +ida_lines.SCOLOR_ON Escape character (ON) -ida_lines.SCOLOR_PREFIX (variable) +ida_lines.SCOLOR_PREFIX Line prefix. -ida_lines.SCOLOR_REG (variable) +ida_lines.SCOLOR_REG Register name. -ida_lines.SCOLOR_REGCMT (variable) +ida_lines.SCOLOR_REGCMT Regular comment. -ida_lines.SCOLOR_RPTCMT (variable) +ida_lines.SCOLOR_RPTCMT Repeatable comment (defined not here) -ida_lines.SCOLOR_SEGNAME (variable) +ida_lines.SCOLOR_SEGNAME Segment name. -ida_lines.SCOLOR_STRING (variable) +ida_lines.SCOLOR_STRING String constant in instruction. -ida_lines.SCOLOR_SYMBOL (variable) +ida_lines.SCOLOR_SYMBOL Punctuation. -ida_lines.SCOLOR_UNAME (variable) +ida_lines.SCOLOR_UNAME Regular unknown name. -ida_lines.SCOLOR_UNKNAME (variable) +ida_lines.SCOLOR_UNKNAME Dummy unknown name. -ida_lines.SCOLOR_VOIDOP (variable) +ida_lines.SCOLOR_VOIDOP Void operand. -ida_lines.add_extra_cmt (function) - add_extra_cmt(ea, isprev, format) -> bool - Add anterior/posterior comment line(s). - - @param ea: (C++: ea_t) linear address - @param isprev: (C++: bool) do we add anterior lines? (0-no, posterior) - @param format: (C++: const char *) printf() style format string. may contain \n to denote new lines. - The resulting string should not contain comment characters (;), - the kernel will add them automatically. - @return: true if success +ida_lines.VEL_CMT + append comment line -ida_lines.add_extra_line (function) - add_extra_line(ea, isprev, format) -> bool - Add anterior/posterior non-comment line(s). - - @param ea: (C++: ea_t) linear address - @param isprev: (C++: bool) do we add anterior lines? (0-no, posterior) - @param format: (C++: const char *) printf() style format string. may contain \n to denote new lines. - @return: true if success +ida_lines.VEL_POST + append posterior line -ida_lines.add_pgm_cmt (function) - add_pgm_cmt(format) -> bool - Add anterior comment line(s) at the start of program. - - @param format: (C++: const char *) printf() style format string. may contain \n to denote new lines. - The resulting string should not contain comment characters (;), - the kernel will add them automatically. - @return: true if success +ida_lines.add_extra_cmt(*args) -> bool -ida_lines.add_sourcefile (function) - add_sourcefile(ea1, ea2, filename) -> bool - Mark a range of address as belonging to a source file. An address range may - belong only to one source file. A source file may be represented by several - address ranges. - - @param ea1: (C++: ea_t) linear address of start of the address range - @param ea2: (C++: ea_t) linear address of end of the address range (excluded) - @param filename: (C++: const char *) name of source file. - @return: success +ida_lines.add_extra_line(*args) -> bool -ida_lines.calc_bg_color (function) - calc_bg_color(ea) -> bgcolor_t - Get background color for line at 'ea' - - @param ea: (C++: ea_t) - @return: RGB color +ida_lines.add_pgm_cmt(*args) -> bool -ida_lines.calc_prefix_color (function) - calc_prefix_color(ea) -> color_t - Get prefix color for line at 'ea' - - @param ea: (C++: ea_t) - @return: Line prefix colors +ida_lines.add_sourcefile(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, filename: str) -> bool -ida_lines.create_encoding_helper (function) - create_encoding_helper(encidx=-1, nr=nr_once) -> encoder_t * - - @param encidx: int - @param nr: enum encoder_t::notify_recerr_t +ida_lines.calc_bg_color(ea: ida_idaapi.ea_t) -> "bgcolor_t" + Get background color for line at 'ea' + + @returns RGB color -ida_lines.del_extra_cmt (function) - del_extra_cmt(ea, what) - - @param ea: ea_t - @param what: int +ida_lines.calc_prefix_color(ea: ida_idaapi.ea_t) -> "color_t" + Get prefix color for line at 'ea' + + @returns Line prefix colors -ida_lines.del_sourcefile (function) - del_sourcefile(ea) -> bool - Delete information about the source file. - - @param ea: (C++: ea_t) linear address - @return: success +ida_lines.create_encoding_helper(*args) -> "encoder_t *" -ida_lines.delete_extra_cmts (function) - delete_extra_cmts(ea, what) - - @param ea: ea_t - @param what: int +ida_lines.del_extra_cmt(ea: ida_idaapi.ea_t, what: int) -> bool -ida_lines.generate_disasm_line (function) - generate_disasm_line(ea, flags=0) -> str - - @param ea: ea_t - @param flags: int +ida_lines.del_sourcefile(ea: ida_idaapi.ea_t) -> bool -ida_lines.generate_disassembly (function) - generate_disassembly(ea, max_lines, as_stack, notags) -> (int, [str, ...]) +ida_lines.delete_extra_cmts(ea: ida_idaapi.ea_t, what: int) -> None + +ida_lines.generate_disasm_line(ea: ida_idaapi.ea_t, flags: int = 0) -> str + +ida_lines.generate_disassembly(ea, max_lines, as_stack, notags) 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 - @param notags: bool - @return: - None on failure + @return: + - None on failure - tuple(most_important_line_number, list(lines)) : Returns a tuple containing the most important line number and a list of generated lines -ida_lines.get_extra_cmt (function) - get_extra_cmt(ea, what) -> ssize_t - - @param ea: ea_t - @param what: int +ida_lines.get_extra_cmt(ea: ida_idaapi.ea_t, what: int) -> int -ida_lines.get_first_free_extra_cmtidx (function) - get_first_free_extra_cmtidx(ea, start) -> int - - @param ea: ea_t - @param start: int +ida_lines.get_first_free_extra_cmtidx(ea: ida_idaapi.ea_t, start: int) -> int -ida_lines.get_sourcefile (function) - get_sourcefile(ea, bounds=None) -> char const * - Get name of source file occupying the given address. - - @param ea: (C++: ea_t) linear address - @param bounds: (C++: range_t *) pointer to the output buffer with the address range for the - current file. May be nullptr. - @return: nullptr if source file information is not found, otherwise returns - pointer to file name +ida_lines.get_sourcefile(ea: ida_idaapi.ea_t, bounds: "range_t" = None) -> str -ida_lines.install_user_defined_prefix (function) - install_user_defined_prefix(prefix_len, udp, owner) -> bool - User-defined line-prefixes are displayed just after the autogenerated line - prefixes in the disassembly listing. There is no need to call this function - explicitly. Use the user_defined_prefix_t class. - - @param prefix_len: (C++: size_t) prefixed length. if 0, then uninstall UDP - @param udp: (C++: struct user_defined_prefix_t *) object to generate user-defined prefix - @param owner: (C++: const void *) pointer to the plugin_t that owns UDP if non-nullptr, then the - object will be uninstalled and destroyed when the plugin gets - unloaded +ida_lines.install_user_defined_prefix(*args) -> bool -ida_lines.requires_color_esc (function) - Checks if the given character requires escaping +ida_lines.requires_color_esc(c) Is the given char a color escape character? -ida_lines.set_user_defined_prefix (function) - set_user_defined_prefix(width, pycb) -> bool - Deprecated. Please use install_user_defined_prefix() instead - - @param width: size_t - @param pycb: PyObject * +ida_lines.tag_addr(ea: ida_idaapi.ea_t) -> str + Insert an address mark into a string. + + @param ea: address to include -ida_lines.tag_addr (function) - tag_addr(ea) -> PyObject * - Insert an address mark into a string. - - @param ea: (C++: ea_t) address to include +ida_lines.tag_advance(line: str, cnt: int) -> int + Move pointer to a 'line' to 'cnt' positions right. Take into account escape sequences. + + @param line: pointer to string + @param cnt: number of positions to move right + @returns moved pointer -ida_lines.tag_advance (function) - tag_advance(line, cnt) -> int - Move pointer to a 'line' to 'cnt' positions right. Take into account escape - sequences. - - @param line: (C++: const char *) pointer to string - @param cnt: (C++: int) number of positions to move right - @return: moved pointer +ida_lines.tag_remove(nonnul_instr: str) -> str + Remove color escape sequences from a string. + + @returns length of resulting string, -1 if error -ida_lines.tag_remove (function) - tag_remove(nonnul_instr) -> str - - @param nonnul_instr: char const * +ida_lines.tag_skipcode(line: str) -> int + Skip one color code. This function should be used if you are interested in color codes and want to analyze all of them. Otherwise tag_skipcodes() function is better since it will skip all colors at once. This function will skip the current color code if there is one. If the current symbol is not a color code, it will return the input. + + @returns moved pointer -ida_lines.tag_skipcode (function) - tag_skipcode(line) -> int - Skip one color code. This function should be used if you are interested in color - codes and want to analyze all of them. Otherwise tag_skipcodes() function is - better since it will skip all colors at once. This function will skip the - current color code if there is one. If the current symbol is not a color code, - it will return the input. - - @param line: (C++: const char *) char const * - @return: moved pointer +ida_lines.tag_skipcodes(line: str) -> int + Move the pointer past all color codes. + + @param line: can't be nullptr + @returns moved pointer, can't be nullptr -ida_lines.tag_skipcodes (function) - tag_skipcodes(line) -> int - Move the pointer past all color codes. - - @param line: (C++: const char *) can't be nullptr - @return: moved pointer, can't be nullptr +ida_lines.tag_strlen(line: str) -> "ssize_t" + Calculate length of a colored string This function computes the length in unicode codepoints of a line + + @returns the number of codepoints in the line, or -1 on error -ida_lines.tag_strlen (function) - tag_strlen(line) -> ssize_t - Calculate length of a colored string This function computes the length in - unicode codepoints of a line - - @param line: (C++: const char *) char const * - @return: the number of codepoints in the line, or -1 on error +ida_lines.update_extra_cmt(ea: ida_idaapi.ea_t, what: int, str: str) -> bool -ida_lines.update_extra_cmt (function) - update_extra_cmt(ea, what, str) - - @param ea: ea_t - @param what: int - @param str: char const * +ida_lines.user_defined_prefix_t -ida_lines.user_defined_prefix_t (class) - Proxy of C++ user_defined_prefix_t class. +ida_lines.user_defined_prefix_t.__disown__(self) -ida_lines.user_defined_prefix_t.__disown__ (method) +ida_lines.user_defined_prefix_t.__init__(self, *args) -ida_lines.user_defined_prefix_t.__init__ (method) - __init__(self, prefix_len, owner) -> user_defined_prefix_t - - @param prefix_len: size_t - @param owner: void const * +ida_lines.user_defined_prefix_t.get_user_defined_prefix(self, ea: ida_idaapi.ea_t, insn: "insn_t const &", lnnum: int, indent: int, line: str) -> None + This callback must be overridden by the derived class. + + @param ea: the current address + @param insn: the current instruction. if the current item is not an instruction, then insn.itype is zero. + @param lnnum: number of the current line (each address may have several listing lines for it). 0 means the very first line for the current address. + @param indent: see explanations for gen_printf() + @param line: the line to be generated. the line usually contains color tags. this argument can be examined to decide whether to generate the prefix. -ida_lines.user_defined_prefix_t.get_user_defined_prefix (method) - get_user_defined_prefix(self, ea, insn, lnnum, indent, line) - This callback must be overridden by the derived class. - - @param ea: (C++: ea_t) the current address - @param insn: (C++: const class insn_t &) the current instruction. if the current item is not an instruction, - then insn.itype is zero. - @param lnnum: (C++: int) number of the current line (each address may have several listing - lines for it). 0 means the very first line for the current - address. - @param indent: (C++: int) see explanations for gen_printf() - @param line: (C++: const char *) the line to be generated. the line usually contains color tags. - this argument can be examined to decide whether to generate the - prefix. - -ida_loader (module) +ida_loader Definitions of IDP, LDR, PLUGIN module interfaces. This file also contains: @@ -47681,740 +32156,1486 @@ ida_loader (module) * functions to generate output files * high level functions to work with the database (open, save, close) - The LDR interface consists of one structure: loader_t - The IDP interface consists of one structure: processor_t + + The LDR interface consists of one structure: loader_t + The IDP interface consists of one structure: processor_t The PLUGIN interface consists of one structure: plugin_t - - Modules can't use standard FILE* functions. They must use functions from - <fpro.h> - - Modules can't use standard memory allocation functions. They must use functions - from <pro.h> - - The exported entry #1 in the module should point to the the appropriate - structure. (loader_t for LDR module, for example) + Modules can't use standard FILE* functions. They must use functions from <fpro.h> + Modules can't use standard memory allocation functions. They must use functions from <pro.h> + The exported entry #1 in the module should point to the the appropriate structure. (loader_t for LDR module, for example) + -ida_loader.ACCEPT_ARCHIVE (variable) - Specify that a file format is served by archive loader See loader_t::accept_file +ida_loader.ACCEPT_ARCHIVE + Specify that a file format is served by archive loader See loader_t::accept_file + -ida_loader.ACCEPT_CONTINUE (variable) - Specify that the function must be called another time See loader_t::accept_file +ida_loader.ACCEPT_CONTINUE + Specify that the function must be called another time See loader_t::accept_file + -ida_loader.ACCEPT_FIRST (variable) - Specify that a file format should be place first in "load file" dialog box. See - loader_t::accept_file +ida_loader.ACCEPT_FIRST + Specify that a file format should be place first in "load file" dialog box. See loader_t::accept_file + -ida_loader.DBFL_BAK (variable) +ida_loader.DBFL_BAK create backup file (if !DBFL_KILL) -ida_loader.DBFL_COMP (variable) +ida_loader.DBFL_COMP collect garbage -ida_loader.DBFL_KILL (variable) +ida_loader.DBFL_KILL delete unpacked database -ida_loader.DBFL_TEMP (variable) +ida_loader.DBFL_TEMP temporary database -ida_loader.FILEREG_NOTPATCHABLE (variable) - the data is kept in some encoded form in the file. +ida_loader.FILEREG_NOTPATCHABLE + the data is kept in some encoded form in the file. + -ida_loader.FILEREG_PATCHABLE (variable) - means that the input file may be patched (i.e. no compression, no iterated data, - etc) +ida_loader.FILEREG_PATCHABLE + means that the input file may be patched (i.e. no compression, no iterated data, etc) + -ida_loader.GENFLG_ASMINC (variable) +ida_loader.GENFLG_ASMINC OFILE_ASM,OFILE_LST: gen information only about types -ida_loader.GENFLG_ASMTYPE (variable) +ida_loader.GENFLG_ASMTYPE OFILE_ASM,OFILE_LST: gen information about types too -ida_loader.GENFLG_GENHTML (variable) +ida_loader.GENFLG_GENHTML OFILE_ASM,OFILE_LST: generate html (ui_genfile_callback will be used) -ida_loader.LDRF_RELOAD (variable) +ida_loader.GENFLG_IDCTYPE + OFILE_IDC: gen only information about types + +ida_loader.GENFLG_MAPDMNG + OFILE_MAP: demangle names + +ida_loader.GENFLG_MAPLOC + OFILE_MAP: include local names + +ida_loader.GENFLG_MAPNAME + OFILE_MAP: include dummy names + +ida_loader.GENFLG_MAPSEG + OFILE_MAP: generate map of segments + +ida_loader.LDRF_RELOAD loader recognizes NEF_RELOAD flag -ida_loader.LDRF_REQ_PROC (variable) - Requires a processor to be set. if this bit is not set, load_file() must call - set_processor_type(..., SETPROC_LOADER) +ida_loader.LDRF_REQ_PROC + Requires a processor to be set. if this bit is not set, load_file() must call set_processor_type(..., SETPROC_LOADER) + -ida_loader.MAX_DATABASE_DESCRIPTION (variable) +ida_loader.MAX_DATABASE_DESCRIPTION Maximum database snapshot description length. -ida_loader.NEF_CODE (variable) - for load_binary_file(): load as a code segment +ida_loader.NEF_CODE + for load_binary_file(): load as a code segment + -ida_loader.NEF_FILL (variable) +ida_loader.NEF_FILL Fill segment gaps. -ida_loader.NEF_FIRST (variable) - This is the first file loaded into the database. +ida_loader.NEF_FIRST + This is the first file loaded into the database. + -ida_loader.NEF_FLAT (variable) +ida_loader.NEF_FLAT Autocreate FLAT group (PE) -ida_loader.NEF_IMPS (variable) +ida_loader.NEF_IMPS Create import segment. -ida_loader.NEF_LALL (variable) +ida_loader.NEF_LALL Load all segments without questions. -ida_loader.NEF_LOPT (variable) +ida_loader.NEF_LOPT Display additional loader options dialog. -ida_loader.NEF_MAN (variable) +ida_loader.NEF_MAN Manual load. -ida_loader.NEF_MINI (variable) - Create mini database (do not copy segment bytes from the input file; use only - the file header metadata) +ida_loader.NEF_MINI + Create mini database (do not copy segment bytes from the input file; use only the file header metadata) + -ida_loader.NEF_NAME (variable) +ida_loader.NEF_NAME Rename entries. -ida_loader.NEF_RELOAD (variable) +ida_loader.NEF_RELOAD reload the file at the same place: * don't create segments * don't create fixup info * don't import segments * etc. - Load only the bytes into the base. A loader should have the LDRF_RELOAD bit set. + + Load only the bytes into the base. A loader should have the LDRF_RELOAD bit set. + -ida_loader.NEF_RSCS (variable) +ida_loader.NEF_RSCS Load resources. -ida_loader.NEF_SEGS (variable) +ida_loader.NEF_SEGS Create segments. -ida_loader.OFILE_ASM (variable) +ida_loader.OFILE_ASM Assembly. -ida_loader.OFILE_DIF (variable) +ida_loader.OFILE_DIF Difference. -ida_loader.OFILE_EXE (variable) +ida_loader.OFILE_EXE Executable file. -ida_loader.OFILE_IDC (variable) +ida_loader.OFILE_IDC IDC file. -ida_loader.OFILE_LST (variable) +ida_loader.OFILE_LST Disassembly listing. -ida_loader.OFILE_MAP (variable) +ida_loader.OFILE_MAP MAP file. -ida_loader.PATH_TYPE_CMD (variable) +ida_loader.PATH_TYPE_CMD full path to the file specified in the command line -ida_loader.PATH_TYPE_ID0 (variable) +ida_loader.PATH_TYPE_ID0 full path of ID0 file -ida_loader.PATH_TYPE_IDB (variable) +ida_loader.PATH_TYPE_IDB full path of IDB file -ida_loader.PLUGIN_DLL (variable) +ida_loader.PLUGIN_DLL Pattern to find plugin files. -ida_loader.SSF_AUTOMATIC (variable) +ida_loader.SSF_AUTOMATIC automatic snapshot -ida_loader.SSUF_DESC (variable) +ida_loader.SSUF_DESC Update the description. -ida_loader.SSUF_FLAGS (variable) +ida_loader.SSUF_FLAGS Update the flags. -ida_loader.SSUF_PATH (variable) +ida_loader.SSUF_PATH Update the path. -ida_loader.base2file (function) - base2file(fp, pos, ea1, ea2) -> int - Unload database to a binary file. This function works for wide byte processors - too. - - @param fp: (C++: FILE *) pointer to file - @param pos: (C++: qoff64_t) position in the file - @param ea1: (C++: ea_t) ,ea2: range of source linear addresses - @param ea2: (C++: ea_t) - @return: 1-ok(always), write error leads to immediate exit +ida_loader.base2file(fp: "FILE *", pos: "qoff64_t", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> int + Unload database to a binary file. This function works for wide byte processors too. + + @param fp: pointer to file + @param pos: position in the file + @param ea1: range of source linear addresses + @param ea2: range of source linear addresses + @returns 1-ok(always), write error leads to immediate exit -ida_loader.build_snapshot_tree (function) - build_snapshot_tree(root) -> bool - Build the snapshot tree. - - @param root: (C++: snapshot_t *) snapshot root that will contain the snapshot tree elements. - @return: success +ida_loader.build_snapshot_tree(root: "snapshot_t") -> bool + Build the snapshot tree. + + @param root: snapshot root that will contain the snapshot tree elements. + @returns success -ida_loader.clr_database_flag (function) - clr_database_flag(dbfl) - - @param dbfl: uint32 +ida_loader.clr_database_flag(dbfl: int) -> None -ida_loader.extract_module_from_archive (function) - extract_module_from_archive(fname, is_remote=False) -> (NoneType, NoneType), (str, str) - Extract a module for an archive file. Parse an archive file, show the list of - modules to the user, allow him to select a module, extract the selected module - to a file (if the extract module is an archive, repeat the process). This - function can handle ZIP, AR, AIXAR, OMFLIB files. The temporary file will be - automatically deleted by IDA at the end. - - @param filename: (C++: char *) in: input file. out: name of the selected module. - @param is_remote: (C++: bool) is the input file remote? +ida_loader.extract_module_from_archive(fname: str, is_remote: bool = False) -> "PyObject *" + Extract a module for an archive file. Parse an archive file, show the list of modules to the user, allow him to select a module, extract the selected module to a file (if the extract module is an archive, repeat the process). This function can handle ZIP, AR, AIXAR, OMFLIB files. The temporary file will be automatically deleted by IDA at the end. + + @param is_remote: is the input file remote? @retval true: ok - @retval false: something bad happened (error message has been displayed to the - user) + @retval false: something bad happened (error message has been displayed to the user) -ida_loader.file2base (function) - file2base(li, 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: (C++: linput_t *) pointer of input source - @param pos: (C++: qoff64_t) position in the file - @param ea1: (C++: ea_t) ,ea2: range of destination linear addresses - @param patchable: (C++: int) should the kernel remember correspondence of file offsets to - linear addresses. +ida_loader.file2base(li: "linput_t *", pos: "qoff64_t", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, patchable: int) -> 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 of input source + @param pos: position in the file + @param ea1: range of destination linear addresses + @param ea2: range of destination linear addresses + @param patchable: should the kernel remember correspondence of file offsets to linear addresses. @retval 1: ok @retval 0: read error, a warning is displayed - @note: The storage type of the specified range will be changed to STT_VA. - @param patchable: (C++: int) should the kernel remember correspondence of file offsets to - linear addresses. - @retval 1: ok - @retval 0: read error, a warning is displayed - @note: The storage type of the specified range will be changed to STT_VA. -ida_loader.find_plugin (function) - find_plugin(name, load_if_needed=False) -> plugin_t * - Find a user-defined plugin and optionally load it. - - @param name: (C++: const char *) short plugin name without path and extension, or absolute path to - the file name - @param load_if_needed: (C++: bool) if the plugin is not present in the memory, try to load - it - @return: pointer to plugin description block +ida_loader.find_plugin(name: str, load_if_needed: bool = False) -> "plugin_t *" + Find a user-defined plugin and optionally load it. + + @param name: short plugin name without path and extension, or absolute path to the file name + @param load_if_needed: if the plugin is not present in the memory, try to load it + @returns pointer to plugin description block -ida_loader.flush_buffers (function) - flush_buffers() -> int +ida_loader.flush_buffers() -> int Flush buffers to the disk. -ida_loader.gen_exe_file (function) - gen_exe_file(fp) -> int - Generate an exe file (unload the database in binary form). - - @param fp: (C++: FILE *) - @return: fp the output file handle. if fp == nullptr then return: +ida_loader.gen_exe_file(fp: "FILE *") -> int + Generate an exe file (unload the database in binary form). + + @returns fp the output file handle. if fp == nullptr then return: * 1: can generate an executable file * 0: can't generate an executable file @retval 1: ok @retval 0: failed -ida_loader.gen_file (function) - gen_file(otype, fp, ea1, ea2, flags) -> int - Generate an output file. - - @param otype: (C++: ofile_type_t) type of output file. - @param fp: (C++: FILE *) the output file handle - @param ea1: (C++: ea_t) start address. For some file types this argument is ignored - @param ea2: (C++: ea_t) end address. For some file types this argument is ignored as usual - in ida, the end address of the range is not included - @param flags: (C++: int) Generate file flagsOFILE_EXE: +ida_loader.gen_file(otype: "ofile_type_t", fp: "FILE *", ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, flags: int) -> int + Generate an output file. OFILE_EXE: + + @param otype: type of output file. + @param fp: the output file handle + @param ea1: start address. For some file types this argument is ignored + @param ea2: end address. For some file types this argument is ignored as usual in ida, the end address of the range is not included + @param flags: Generate file flags + @returns number of the generated lines. -1 if an error occurred @retval 0: can't generate exe file @retval 1: ok - @return: number of the generated lines. -1 if an error occurred -ida_loader.get_basic_file_type (function) - get_basic_file_type(li) -> filetype_t - Get the input file type. This function can recognize libraries and zip files. - - @param li: (C++: linput_t *) +ida_loader.get_basic_file_type(li: "linput_t *") -> "filetype_t" + Get the input file type. This function can recognize libraries and zip files. + -ida_loader.get_elf_debug_file_directory (function) - get_elf_debug_file_directory() -> char const * - Get the value of the ELF_DEBUG_FILE_DIRECTORY configuration directive. +ida_loader.get_elf_debug_file_directory() -> str + Get the value of the ELF_DEBUG_FILE_DIRECTORY configuration directive. + -ida_loader.get_file_type_name (function) - get_file_type_name() -> str - Get name of the current file type. The current file type is kept in - idainfo::filetype. - - @return: size of answer, this function always succeeds +ida_loader.get_file_type_name() -> str + Get name of the current file type. The current file type is kept in idainfo::filetype. + + @returns size of answer, this function always succeeds -ida_loader.get_fileregion_ea (function) - get_fileregion_ea(offset) -> ea_t - Get linear address which corresponds to the specified input file offset. If - can't be found, return BADADDR - - @param offset: (C++: qoff64_t) +ida_loader.get_fileregion_ea(offset: "qoff64_t") -> ida_idaapi.ea_t + Get linear address which corresponds to the specified input file offset. If can't be found, return BADADDR + -ida_loader.get_fileregion_offset (function) - get_fileregion_offset(ea) -> qoff64_t - Get offset in the input file which corresponds to the given ea. If the specified - ea can't be mapped into the input file offset, return -1. - - @param ea: (C++: ea_t) +ida_loader.get_fileregion_offset(ea: ida_idaapi.ea_t) -> "qoff64_t" + Get offset in the input file which corresponds to the given ea. If the specified ea can't be mapped into the input file offset, return -1. + -ida_loader.get_path (function) - get_path(pt) -> char const * - Get the file path - - @param pt: (C++: path_type_t) file path type Types of the file pathes - @return: file path, never returns nullptr +ida_loader.get_path(pt: "path_type_t") -> str + Get the file path + + @param pt: file path type Types of the file pathes + @returns file path, never returns nullptr -ida_loader.get_plugin_options (function) - get_plugin_options(plugin) -> char const * - Get plugin options from the command line. If the user has specified the options - in the -Oplugin_name:options format, them this function will return the - 'options' part of it The 'plugin' parameter should denote the plugin name - Returns nullptr if there we no options specified - - @param plugin: (C++: const char *) char const * +ida_loader.get_plugin_options(plugin: str) -> str + Get plugin options from the command line. If the user has specified the options in the -Oplugin_name:options format, them this function will return the 'options' part of it The 'plugin' parameter should denote the plugin name Returns nullptr if there we no options specified + -ida_loader.idp_desc_t (class) - Proxy of C++ idp_desc_t class. +ida_loader.idp_desc_t -ida_loader.idp_desc_t.__init__ (method) - __init__(self) -> idp_desc_t +ida_loader.idp_desc_t.__init__(self) -ida_loader.idp_desc_t.checked (variable) +ida_loader.idp_desc_t.checked internal, for cache management -ida_loader.idp_desc_t.family (variable) +ida_loader.idp_desc_t.family processor's family -ida_loader.idp_desc_t.is_script (variable) +ida_loader.idp_desc_t.is_script the processor module is a script -ida_loader.idp_desc_t.mtime (variable) +ida_loader.idp_desc_t.mtime time of last modification -ida_loader.idp_desc_t.names (variable) +ida_loader.idp_desc_t.names processor names -ida_loader.idp_desc_t.path (variable) +ida_loader.idp_desc_t.path module file name -ida_loader.idp_name_t (class) - Proxy of C++ idp_name_t class. +ida_loader.idp_name_t -ida_loader.idp_name_t.__init__ (method) - __init__(self) -> idp_name_t +ida_loader.idp_name_t.__init__(self) -ida_loader.idp_name_t.hidden (variable) +ida_loader.idp_name_t.hidden is hidden -ida_loader.idp_name_t.lname (variable) +ida_loader.idp_name_t.lname long processor name -ida_loader.idp_name_t.sname (variable) +ida_loader.idp_name_t.sname short processor name -ida_loader.is_database_flag (function) - is_database_flag(dbfl) -> bool - Get the current database flag - - @param dbfl: (C++: uint32) flag Database flags - @return: the state of the flag (set or cleared) +ida_loader.is_database_flag(dbfl: int) -> bool + Get the current database flag + + @param dbfl: flag Database flags + @returns the state of the flag (set or cleared) -ida_loader.is_trusted_idb (function) - is_trusted_idb() -> bool +ida_loader.is_trusted_idb() -> bool Is the database considered as trusted? -ida_loader.load_and_run_plugin (function) - load_and_run_plugin(name, arg) -> bool +ida_loader.load_and_run_plugin(name: str, arg: "size_t") -> bool Load & run a plugin. - - @param name: (C++: const char *) char const * - @param arg: (C++: size_t) -ida_loader.load_binary_file (function) - load_binary_file(filename, li, _neflags, fileoff, basepara, binoff, nbytes) -> bool - Load a binary file into the database. This function usually is called from ui. - - @param filename: (C++: const char *) the name of input file as is (if the input file is from - library, then this is the name from the library) - @param li: (C++: linput_t *) loader input source - @param _neflags: (C++: ushort) Load file flags. For the first file, the flag NEF_FIRST must be - set. - @param fileoff: (C++: qoff64_t) Offset in the input file - @param basepara: (C++: ea_t) Load address in paragraphs - @param binoff: (C++: ea_t) Load offset (load_address=(basepara<<4)+binoff) - @param nbytes: (C++: uint64) Number of bytes to load from the file. +ida_loader.load_binary_file(filename: str, li: "linput_t *", _neflags: "ushort", fileoff: "qoff64_t", basepara: ida_idaapi.ea_t, binoff: ida_idaapi.ea_t, nbytes: "uint64") -> bool + Load a binary file into the database. This function usually is called from ui. + + @param filename: the name of input file as is (if the input file is from library, then this is the name from the library) + @param li: loader input source + @param _neflags: Load file flags. For the first file, the flag NEF_FIRST must be set. + @param fileoff: Offset in the input file + @param basepara: Load address in paragraphs + @param binoff: Load offset (load_address=(basepara<<4)+binoff) + @param nbytes: Number of bytes to load from the file. * 0: up to the end of the file @retval true: ok @retval false: failed (couldn't open the file) -ida_loader.load_ids_module (function) - load_ids_module(fname) -> int - Load and apply IDS file. This function loads the specified IDS file and applies - it to the database. If the program imports functions from a module with the same - name as the name of the ids file being loaded, then only functions from this - module will be affected. Otherwise (i.e. when the program does not import a - module with this name) any function in the program may be affected. - - @param fname: (C++: char *) name of file to apply +ida_loader.load_ids_module(fname: "char *") -> int + Load and apply IDS file. This function loads the specified IDS file and applies it to the database. If the program imports functions from a module with the same name as the name of the ids file being loaded, then only functions from this module will be affected. Otherwise (i.e. when the program does not import a module with this name) any function in the program may be affected. + + @param fname: name of file to apply @retval 1: ok - @retval 0: some error (a message is displayed). if the ids file does not exist, - no message is displayed + @retval 0: some error (a message is displayed). if the ids file does not exist, no message is displayed -ida_loader.load_plugin (function) - load_plugin(name) -> PyCapsule or None +ida_loader.load_plugin(name) Loads a plugin - @param name: char const * - @return: - None if plugin could not be loaded + @param name: short plugin name without path and extension, + or absolute path to the file name + @return: + - None if plugin could not be loaded - An opaque object representing the loaded plugin -ida_loader.loader_t (class) - Proxy of C++ loader_t class. +ida_loader.loader_t -ida_loader.loader_t.__init__ (method) - __init__(self) -> loader_t +ida_loader.loader_t.__init__(self) -ida_loader.loader_t.flags (variable) - Loader flags +ida_loader.loader_t.flags + Loader flags + -ida_loader.loader_t.version (variable) +ida_loader.loader_t.version api version, should be IDP_INTERFACE_VERSION -ida_loader.mem2base (function) - mem2base(py_mem, ea, fpos=-1) -> int +ida_loader.mem2base(mem, ea, fpos) Load database from the memory. - @param py_mem: the buffer + @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 + @return: + - Returns zero if the passed buffer was not a string - Otherwise 1 is returned -ida_loader.plugin_info_t (class) - Proxy of C++ plugin_info_t class. +ida_loader.plugin_info_t -ida_loader.plugin_info_t.__init__ (method) - __init__(self) -> plugin_info_t +ida_loader.plugin_info_t.__init__(self) -ida_loader.plugin_info_t.arg (variable) +ida_loader.plugin_info_t.arg argument used to call the plugin -ida_loader.plugin_info_t.comment (variable) +ida_loader.plugin_info_t.comment a copy of plugin_t::comment -ida_loader.plugin_info_t.entry (variable) +ida_loader.plugin_info_t.entry pointer to the plugin if it is already loaded -ida_loader.plugin_info_t.flags (variable) +ida_loader.plugin_info_t.flags a copy of plugin_t::flags -ida_loader.plugin_info_t.hotkey (variable) +ida_loader.plugin_info_t.hotkey current hotkey to run the plugin -ida_loader.plugin_info_t.name (variable) - short name of the plugin it will appear in the menu +ida_loader.plugin_info_t.idaplg_name + "name" provided by ida-plugin.json or basename of path (without extension) -ida_loader.plugin_info_t.next (variable) +ida_loader.plugin_info_t.name + short name of the plugin it will appear in the menu + + +ida_loader.plugin_info_t.next next plugin information -ida_loader.plugin_info_t.org_hotkey (variable) +ida_loader.plugin_info_t.org_hotkey original hotkey to run the plugin -ida_loader.plugin_info_t.org_name (variable) +ida_loader.plugin_info_t.org_name original short name of the plugin -ida_loader.plugin_info_t.path (variable) +ida_loader.plugin_info_t.path full path to the plugin -ida_loader.process_archive (function) - process_archive(temp_file, li, module_name, neflags, defmember, loader) -> str - Calls loader_t::process_archive() For parameters and return value description - look at loader_t::process_archive(). Additional parameter 'loader' is a pointer - to load_info_t structure. - - @param temp_file: (C++: qstring *) - @param li: (C++: linput_t *) - @param module_name: (C++: qstring *) - @param neflags: (C++: ushort *) - @param defmember: (C++: const char *) char const * - @param loader: (C++: const load_info_t *) load_info_t const * +ida_loader.process_archive(temp_file: str, li: "linput_t *", module_name: str, neflags: "ushort *", defmember: str, loader: "load_info_t const *") -> str + Calls loader_t::process_archive() For parameters and return value description look at loader_t::process_archive(). Additional parameter 'loader' is a pointer to load_info_t structure. + -ida_loader.qvector_snapshotvec_t (class) - Proxy of C++ qvector< snapshot_t * > class. +ida_loader.qvector_snapshotvec_t -ida_loader.qvector_snapshotvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< snapshot_t * > const & +ida_loader.qvector_snapshotvec_t.__eq__(self, r: "qvector_snapshotvec_t") -> bool -ida_loader.qvector_snapshotvec_t.__getitem__ (method) - __getitem__(self, i) -> snapshot_t - - @param i: size_t +ida_loader.qvector_snapshotvec_t.__getitem__(self, i: "size_t") -> "snapshot_t *const &" -ida_loader.qvector_snapshotvec_t.__init__ (method) - __init__(self) -> qvector_snapshotvec_t - __init__(self, x) -> qvector_snapshotvec_t - - @param x: qvector< snapshot_t * > const & +ida_loader.qvector_snapshotvec_t.__init__(self, *args) -ida_loader.qvector_snapshotvec_t.__len__ (method) - __len__(self) -> size_t +ida_loader.qvector_snapshotvec_t.__len__(self) -> "size_t" -ida_loader.qvector_snapshotvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< snapshot_t * > const & +ida_loader.qvector_snapshotvec_t.__ne__(self, r: "qvector_snapshotvec_t") -> bool -ida_loader.qvector_snapshotvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: snapshot_t *const & +ida_loader.qvector_snapshotvec_t.__setitem__(self, i: "size_t", v: "snapshot_t") -> None -ida_loader.qvector_snapshotvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: snapshot_t *const & +ida_loader.qvector_snapshotvec_t._del(self, x: "snapshot_t") -> bool -ida_loader.qvector_snapshotvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: snapshot_t *const & +ida_loader.qvector_snapshotvec_t.add_unique(self, x: "snapshot_t") -> bool -ida_loader.qvector_snapshotvec_t.at (method) - at(self, _idx) -> snapshot_t - - @param _idx: size_t +ida_loader.qvector_snapshotvec_t.append(self, x: "snapshot_t") -> None -ida_loader.qvector_snapshotvec_t.begin (method) - begin(self) -> qvector< snapshot_t * >::iterator - begin(self) -> qvector< snapshot_t * >::const_iterator +ida_loader.qvector_snapshotvec_t.at(self, _idx: "size_t") -> "snapshot_t *const &" -ida_loader.qvector_snapshotvec_t.capacity (method) - capacity(self) -> size_t +ida_loader.qvector_snapshotvec_t.begin(self, *args) -> "qvector< snapshot_t * >::const_iterator" -ida_loader.qvector_snapshotvec_t.clear (method) - clear(self) +ida_loader.qvector_snapshotvec_t.capacity(self) -> "size_t" -ida_loader.qvector_snapshotvec_t.empty (method) - empty(self) -> bool +ida_loader.qvector_snapshotvec_t.clear(self) -> None -ida_loader.qvector_snapshotvec_t.end (method) - end(self) -> qvector< snapshot_t * >::iterator - end(self) -> qvector< snapshot_t * >::const_iterator +ida_loader.qvector_snapshotvec_t.empty(self) -> bool -ida_loader.qvector_snapshotvec_t.erase (method) - erase(self, it) -> qvector< snapshot_t * >::iterator - - @param it: qvector< snapshot_t * >::iterator - - erase(self, first, last) -> qvector< snapshot_t * >::iterator - - @param first: qvector< snapshot_t * >::iterator - @param last: qvector< snapshot_t * >::iterator +ida_loader.qvector_snapshotvec_t.end(self, *args) -> "qvector< snapshot_t * >::const_iterator" -ida_loader.qvector_snapshotvec_t.extract (method) - extract(self) -> snapshot_t ** +ida_loader.qvector_snapshotvec_t.erase(self, *args) -> "qvector< snapshot_t * >::iterator" -ida_loader.qvector_snapshotvec_t.find (method) - find(self, x) -> qvector< snapshot_t * >::iterator - - @param x: snapshot_t *const & - - find(self, x) -> qvector< snapshot_t * >::const_iterator - - @param x: snapshot_t *const & +ida_loader.qvector_snapshotvec_t.extend(self, x: "qvector_snapshotvec_t") -> None -ida_loader.qvector_snapshotvec_t.has (method) - has(self, x) -> bool - - @param x: snapshot_t *const & +ida_loader.qvector_snapshotvec_t.extract(self) -> "snapshot_t **" -ida_loader.qvector_snapshotvec_t.inject (method) - inject(self, s, len) - - @param s: snapshot_t ** - @param len: size_t +ida_loader.qvector_snapshotvec_t.find(self, *args) -> "qvector< snapshot_t * >::const_iterator" -ida_loader.qvector_snapshotvec_t.insert (method) - insert(self, it, x) -> qvector< snapshot_t * >::iterator - - @param it: qvector< snapshot_t * >::iterator - @param x: snapshot_t *const & +ida_loader.qvector_snapshotvec_t.has(self, x: "snapshot_t") -> bool -ida_loader.qvector_snapshotvec_t.pop_back (method) - pop_back(self) +ida_loader.qvector_snapshotvec_t.inject(self, s: "snapshot_t **", len: "size_t") -> None -ida_loader.qvector_snapshotvec_t.push_back (method) - push_back(self, x) - - @param x: snapshot_t *const & - - push_back(self) -> snapshot_t *& +ida_loader.qvector_snapshotvec_t.insert(self, it: "qvector< snapshot_t * >::iterator", x: "snapshot_t") -> "qvector< snapshot_t * >::iterator" -ida_loader.qvector_snapshotvec_t.qclear (method) - qclear(self) +ida_loader.qvector_snapshotvec_t.pop_back(self) -> None -ida_loader.qvector_snapshotvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_loader.qvector_snapshotvec_t.push_back(self, *args) -> "snapshot_t *&" -ida_loader.qvector_snapshotvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: snapshot_t *const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_loader.qvector_snapshotvec_t.qclear(self) -> None -ida_loader.qvector_snapshotvec_t.size (method) - size(self) -> size_t +ida_loader.qvector_snapshotvec_t.reserve(self, cnt: "size_t") -> None -ida_loader.qvector_snapshotvec_t.swap (method) - swap(self, r) - - @param r: qvector< snapshot_t * > & +ida_loader.qvector_snapshotvec_t.resize(self, *args) -> None -ida_loader.qvector_snapshotvec_t.truncate (method) - truncate(self) +ida_loader.qvector_snapshotvec_t.size(self) -> "size_t" -ida_loader.reload_file (function) - reload_file(file, is_remote) -> bool - Reload the input file. This function reloads the byte values from the input - file. It doesn't modify the segmentation, names, comments, etc. - - @param file: (C++: const char *) name of the input file. if file == nullptr then returns: +ida_loader.qvector_snapshotvec_t.swap(self, r: "qvector_snapshotvec_t") -> None + +ida_loader.qvector_snapshotvec_t.truncate(self) -> None + +ida_loader.reload_file(file: str, is_remote: bool) -> bool + Reload the input file. This function reloads the byte values from the input file. It doesn't modify the segmentation, names, comments, etc. + + @param file: name of the input file. if file == nullptr then returns: * 1: can reload the input file * 0: can't reload the input file - @param is_remote: (C++: bool) is the file located on a remote computer with the debugger - server? - @return: success + @param is_remote: is the file located on a remote computer with the debugger server? + @returns success -ida_loader.run_plugin (function) - run_plugin(plg, arg) -> bool +ida_loader.run_plugin(plg, arg) Runs a plugin @param plg: A plugin object (returned by load_plugin()) - @param arg: size_t + @param arg: the code to pass to the plugin's "run()" function @return: Boolean -ida_loader.save_database (function) - save_database(outfile, flags, root=None, attr=None) -> bool - Save current database using a new file name. - - @param outfile: (C++: const char *) output database file name - @param flags: (C++: uint32) Database flags - @param root: (C++: const snapshot_t *) optional: snapshot tree root. - @param attr: (C++: const snapshot_t *) optional: snapshot attributes - @note: when both root and attr are not nullptr then the snapshot attributes will - be updated, otherwise the snapshot attributes will be inherited from the - current database. - @return: success +ida_loader.save_database(outfile: str = None, flags: int = -1, root: "snapshot_t" = None, attr: "snapshot_t" = None) -> bool + Save current database using a new file name. + + @param outfile: output database file name; nullptr means the current path + @param flags: Database flags; -1 means the current flags + @param root: optional: snapshot tree root. + @param attr: optional: snapshot attributes + @returns success -ida_loader.set_database_flag (function) - set_database_flag(dbfl, cnd=True) - Set or clear database flag - - @param dbfl: (C++: uint32) flag Database flags - @param cnd: (C++: bool) set if true or clear flag otherwise +ida_loader.set_database_flag(dbfl: int, cnd: bool = True) -> None + Set or clear database flag + + @param dbfl: flag Database flags + @param cnd: set if true or clear flag otherwise -ida_loader.set_import_name (function) - set_import_name(modnode, ea, name) - Set information about the named import entry. This function performs - 'modnode.supset_ea(ea, name);' - - @param modnode: (C++: uval_t) node with information about imported entries - @param ea: (C++: ea_t) linear address of the entry - @param name: (C++: const char *) name of the entry +ida_loader.set_import_name(modnode: int, ea: ida_idaapi.ea_t, name: str) -> None + Set information about the named import entry. This function performs 'modnode.supset_ea(ea, name);' + + @param modnode: node with information about imported entries + @param ea: linear address of the entry + @param name: name of the entry -ida_loader.set_import_ordinal (function) - set_import_ordinal(modnode, ea, ord) - Set information about the ordinal import entry. This function performs - 'modnode.altset(ord, ea2node(ea));' - - @param modnode: (C++: uval_t) node with information about imported entries - @param ea: (C++: ea_t) linear address of the entry - @param ord: (C++: uval_t) ordinal number of the entry +ida_loader.set_import_ordinal(modnode: int, ea: ida_idaapi.ea_t, ord: int) -> None + Set information about the ordinal import entry. This function performs 'modnode.altset(ord, ea2node(ea));' + + @param modnode: node with information about imported entries + @param ea: linear address of the entry + @param ord: ordinal number of the entry -ida_loader.set_path (function) - set_path(pt, path) - Set the file path - - @param pt: (C++: path_type_t) file path type Types of the file pathes - @param path: (C++: const char *) new file path, use nullptr or empty string to clear the file path +ida_loader.set_path(pt: "path_type_t", path: str) -> None + Set the file path + + @param pt: file path type Types of the file pathes + @param path: new file path, use nullptr or empty string to clear the file path -ida_loader.snapshot_t (class) - Proxy of C++ snapshot_t class. +ida_loader.snapshot_t -ida_loader.snapshot_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: snapshot_t const & +ida_loader.snapshot_t.__eq__(self, r: "snapshot_t") -> bool -ida_loader.snapshot_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: snapshot_t const & +ida_loader.snapshot_t.__ge__(self, r: "snapshot_t") -> bool -ida_loader.snapshot_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: snapshot_t const & +ida_loader.snapshot_t.__gt__(self, r: "snapshot_t") -> bool -ida_loader.snapshot_t.__init__ (method) - __init__(self) -> snapshot_t +ida_loader.snapshot_t.__init__(self) -ida_loader.snapshot_t.__le__ (method) - __le__(self, r) -> bool - - @param r: snapshot_t const & +ida_loader.snapshot_t.__le__(self, r: "snapshot_t") -> bool -ida_loader.snapshot_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: snapshot_t const & +ida_loader.snapshot_t.__lt__(self, r: "snapshot_t") -> bool -ida_loader.snapshot_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: snapshot_t const & +ida_loader.snapshot_t.__ne__(self, r: "snapshot_t") -> bool -ida_loader.snapshot_t.children (variable) +ida_loader.snapshot_t.children snapshot children -ida_loader.snapshot_t.clear (method) - clear(self) +ida_loader.snapshot_t.clear(self) -> None -ida_loader.snapshot_t.desc (variable) +ida_loader.snapshot_t.desc snapshot description -ida_loader.snapshot_t.filename (variable) +ida_loader.snapshot_t.filename snapshot file name -ida_loader.snapshot_t.flags (variable) - Snapshot flags +ida_loader.snapshot_t.flags + Snapshot flags + -ida_loader.snapshot_t.id (variable) +ida_loader.snapshot_t.id snapshot ID. This value is computed using qgettimeofday() -ida_moves (module) +ida_lumina + +ida_lumina.AMDF_FORCE + apply kvps regardless of what's currently in the IDB, possibly removing some attributes currently present (e.g., name, or prototype could be lost) + + +ida_lumina.AMDF_UPGRADE + apply kvps that seem to be of higher "quality" than what's currently in the IDB + + +ida_lumina.apply_metadata(ea: ida_idaapi.ea_t, fi: "func_info_t", flags: int = 0) -> None + +ida_lumina.backup_metadata(ea: ida_idaapi.ea_t) -> bool + +ida_lumina.calc_func_metadata(out_fi: "func_info_t", pfn: "func_t const *", append_metadata: "metadata_appender_t *" = None) -> "md5_t *" + +ida_lumina.diff_metadata(handler: "func_md_diff_handler_t", left: "func_info_t", right: "func_info_t", flags: int = 0) -> bool + +ida_lumina.extra_cmt_t + +ida_lumina.extra_cmt_t.__init__(self) + +ida_lumina.extra_cmts_t + +ida_lumina.extra_cmts_t.__getitem__(self, i: "size_t") -> "extra_cmt_t const &" + +ida_lumina.extra_cmts_t.__init__(self, *args) + +ida_lumina.extra_cmts_t.__len__(self) -> "size_t" + +ida_lumina.extra_cmts_t.__setitem__(self, i: "size_t", v: "extra_cmt_t") -> None + +ida_lumina.extra_cmts_t.append(self, x: "extra_cmt_t") -> None + +ida_lumina.extra_cmts_t.at(self, _idx: "size_t") -> "extra_cmt_t const &" + +ida_lumina.extra_cmts_t.begin(self, *args) -> "qvector< extra_cmt_t >::const_iterator" + +ida_lumina.extra_cmts_t.capacity(self) -> "size_t" + +ida_lumina.extra_cmts_t.clear(self) -> None + +ida_lumina.extra_cmts_t.empty(self) -> bool + +ida_lumina.extra_cmts_t.end(self, *args) -> "qvector< extra_cmt_t >::const_iterator" + +ida_lumina.extra_cmts_t.erase(self, *args) -> "qvector< extra_cmt_t >::iterator" + +ida_lumina.extra_cmts_t.extend(self, x: "extra_cmts_t") -> None + +ida_lumina.extra_cmts_t.extract(self) -> "extra_cmt_t *" + +ida_lumina.extra_cmts_t.grow(self, *args) -> None + +ida_lumina.extra_cmts_t.inject(self, s: "extra_cmt_t", len: "size_t") -> None + +ida_lumina.extra_cmts_t.insert(self, it: "extra_cmt_t", x: "extra_cmt_t") -> "qvector< extra_cmt_t >::iterator" + +ida_lumina.extra_cmts_t.pop_back(self) -> None + +ida_lumina.extra_cmts_t.push_back(self, *args) -> "extra_cmt_t &" + +ida_lumina.extra_cmts_t.qclear(self) -> None + +ida_lumina.extra_cmts_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.extra_cmts_t.resize(self, *args) -> None + +ida_lumina.extra_cmts_t.size(self) -> "size_t" + +ida_lumina.extra_cmts_t.swap(self, r: "extra_cmts_t") -> None + +ida_lumina.extra_cmts_t.truncate(self) -> None + +ida_lumina.extract_extra_cmts_from_metadata(out: "extra_cmts_t", ptr: "uchar const *") -> None + +ida_lumina.extract_frame_desc_from_metadata(out: "frame_desc_t", ptr: "uchar const *") -> None + +ida_lumina.extract_insn_cmts_from_metadata(out: "insn_cmts_t", ptr: "uchar const *") -> None + +ida_lumina.extract_insn_opreprs_from_metadata(out: "insn_ops_reprs_t", ptr: "uchar const *") -> None + +ida_lumina.extract_insn_opreprs_from_metadata_ex(out: "insn_ops_reprs_t", ptr: "uchar const *") -> None + +ida_lumina.extract_type_from_metadata(out: "tinfo_t", _in: "bytevec_t const &") -> bool + +ida_lumina.extract_user_stkpnts_from_metadata(out: "user_stkpnts_t", ptr: "uchar const *") -> None + +ida_lumina.frame_desc_t + +ida_lumina.frame_desc_t.__init__(self, *args) + +ida_lumina.frame_mem_t + +ida_lumina.frame_mem_t.__init__(self, *args) + +ida_lumina.frame_mems_t + +ida_lumina.frame_mems_t.__getitem__(self, i: "size_t") -> "frame_mem_t const &" + +ida_lumina.frame_mems_t.__init__(self, *args) + +ida_lumina.frame_mems_t.__len__(self) -> "size_t" + +ida_lumina.frame_mems_t.__setitem__(self, i: "size_t", v: "frame_mem_t") -> None + +ida_lumina.frame_mems_t.append(self, x: "frame_mem_t") -> None + +ida_lumina.frame_mems_t.at(self, _idx: "size_t") -> "frame_mem_t const &" + +ida_lumina.frame_mems_t.begin(self, *args) -> "qvector< frame_mem_t >::const_iterator" + +ida_lumina.frame_mems_t.capacity(self) -> "size_t" + +ida_lumina.frame_mems_t.clear(self) -> None + +ida_lumina.frame_mems_t.empty(self) -> bool + +ida_lumina.frame_mems_t.end(self, *args) -> "qvector< frame_mem_t >::const_iterator" + +ida_lumina.frame_mems_t.erase(self, *args) -> "qvector< frame_mem_t >::iterator" + +ida_lumina.frame_mems_t.extend(self, x: "frame_mems_t") -> None + +ida_lumina.frame_mems_t.extract(self) -> "frame_mem_t *" + +ida_lumina.frame_mems_t.grow(self, *args) -> None + +ida_lumina.frame_mems_t.inject(self, s: "frame_mem_t", len: "size_t") -> None + +ida_lumina.frame_mems_t.insert(self, it: "frame_mem_t", x: "frame_mem_t") -> "qvector< frame_mem_t >::iterator" + +ida_lumina.frame_mems_t.pop_back(self) -> None + +ida_lumina.frame_mems_t.push_back(self, *args) -> "frame_mem_t &" + +ida_lumina.frame_mems_t.qclear(self) -> None + +ida_lumina.frame_mems_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.frame_mems_t.resize(self, *args) -> None + +ida_lumina.frame_mems_t.size(self) -> "size_t" + +ida_lumina.frame_mems_t.swap(self, r: "frame_mems_t") -> None + +ida_lumina.frame_mems_t.truncate(self) -> None + +ida_lumina.func_info_and_frequency_t + +ida_lumina.func_info_and_frequency_t.__init__(self, __frequency: int = 0) + +ida_lumina.func_info_and_frequency_vec_t + +ida_lumina.func_info_and_frequency_vec_t.__getitem__(self, i: "size_t") -> "func_info_and_frequency_t const &" + +ida_lumina.func_info_and_frequency_vec_t.__init__(self, *args) + +ida_lumina.func_info_and_frequency_vec_t.__len__(self) -> "size_t" + +ida_lumina.func_info_and_frequency_vec_t.__setitem__(self, i: "size_t", v: "func_info_and_frequency_t") -> None + +ida_lumina.func_info_and_frequency_vec_t.append(self, x: "func_info_and_frequency_t") -> None + +ida_lumina.func_info_and_frequency_vec_t.at(self, _idx: "size_t") -> "func_info_and_frequency_t const &" + +ida_lumina.func_info_and_frequency_vec_t.begin(self, *args) -> "qvector< func_info_and_frequency_t >::const_iterator" + +ida_lumina.func_info_and_frequency_vec_t.capacity(self) -> "size_t" + +ida_lumina.func_info_and_frequency_vec_t.clear(self) -> None + +ida_lumina.func_info_and_frequency_vec_t.empty(self) -> bool + +ida_lumina.func_info_and_frequency_vec_t.end(self, *args) -> "qvector< func_info_and_frequency_t >::const_iterator" + +ida_lumina.func_info_and_frequency_vec_t.erase(self, *args) -> "qvector< func_info_and_frequency_t >::iterator" + +ida_lumina.func_info_and_frequency_vec_t.extend(self, x: "func_info_and_frequency_vec_t") -> None + +ida_lumina.func_info_and_frequency_vec_t.extract(self) -> "func_info_and_frequency_t *" + +ida_lumina.func_info_and_frequency_vec_t.grow(self, *args) -> None + +ida_lumina.func_info_and_frequency_vec_t.inject(self, s: "func_info_and_frequency_t", len: "size_t") -> None + +ida_lumina.func_info_and_frequency_vec_t.insert(self, it: "func_info_and_frequency_t", x: "func_info_and_frequency_t") -> "qvector< func_info_and_frequency_t >::iterator" + +ida_lumina.func_info_and_frequency_vec_t.pop_back(self) -> None + +ida_lumina.func_info_and_frequency_vec_t.push_back(self, *args) -> "func_info_and_frequency_t &" + +ida_lumina.func_info_and_frequency_vec_t.qclear(self) -> None + +ida_lumina.func_info_and_frequency_vec_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.func_info_and_frequency_vec_t.resize(self, *args) -> None + +ida_lumina.func_info_and_frequency_vec_t.size(self) -> "size_t" + +ida_lumina.func_info_and_frequency_vec_t.swap(self, r: "func_info_and_frequency_vec_t") -> None + +ida_lumina.func_info_and_frequency_vec_t.truncate(self) -> None + +ida_lumina.func_info_and_pattern_t + +ida_lumina.func_info_and_pattern_t.__init__(self, *args) + +ida_lumina.func_info_and_pattern_vec_t + +ida_lumina.func_info_and_pattern_vec_t.__getitem__(self, i: "size_t") -> "func_info_and_pattern_t const &" + +ida_lumina.func_info_and_pattern_vec_t.__init__(self, *args) + +ida_lumina.func_info_and_pattern_vec_t.__len__(self) -> "size_t" + +ida_lumina.func_info_and_pattern_vec_t.__setitem__(self, i: "size_t", v: "func_info_and_pattern_t") -> None + +ida_lumina.func_info_and_pattern_vec_t.append(self, x: "func_info_and_pattern_t") -> None + +ida_lumina.func_info_and_pattern_vec_t.at(self, _idx: "size_t") -> "func_info_and_pattern_t const &" + +ida_lumina.func_info_and_pattern_vec_t.begin(self, *args) -> "qvector< func_info_and_pattern_t >::const_iterator" + +ida_lumina.func_info_and_pattern_vec_t.capacity(self) -> "size_t" + +ida_lumina.func_info_and_pattern_vec_t.clear(self) -> None + +ida_lumina.func_info_and_pattern_vec_t.empty(self) -> bool + +ida_lumina.func_info_and_pattern_vec_t.end(self, *args) -> "qvector< func_info_and_pattern_t >::const_iterator" + +ida_lumina.func_info_and_pattern_vec_t.erase(self, *args) -> "qvector< func_info_and_pattern_t >::iterator" + +ida_lumina.func_info_and_pattern_vec_t.extend(self, x: "func_info_and_pattern_vec_t") -> None + +ida_lumina.func_info_and_pattern_vec_t.extract(self) -> "func_info_and_pattern_t *" + +ida_lumina.func_info_and_pattern_vec_t.grow(self, *args) -> None + +ida_lumina.func_info_and_pattern_vec_t.inject(self, s: "func_info_and_pattern_t", len: "size_t") -> None + +ida_lumina.func_info_and_pattern_vec_t.insert(self, it: "func_info_and_pattern_t", x: "func_info_and_pattern_t") -> "qvector< func_info_and_pattern_t >::iterator" + +ida_lumina.func_info_and_pattern_vec_t.pop_back(self) -> None + +ida_lumina.func_info_and_pattern_vec_t.push_back(self, *args) -> "func_info_and_pattern_t &" + +ida_lumina.func_info_and_pattern_vec_t.qclear(self) -> None + +ida_lumina.func_info_and_pattern_vec_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.func_info_and_pattern_vec_t.resize(self, *args) -> None + +ida_lumina.func_info_and_pattern_vec_t.size(self) -> "size_t" + +ida_lumina.func_info_and_pattern_vec_t.swap(self, r: "func_info_and_pattern_vec_t") -> None + +ida_lumina.func_info_and_pattern_vec_t.truncate(self) -> None + +ida_lumina.func_info_base_t + +ida_lumina.func_info_base_t.__init__(self, *args) + +ida_lumina.func_info_pattern_and_frequency_t + +ida_lumina.func_info_pattern_and_frequency_t.__init__(self, __frequency: int = 0) + +ida_lumina.func_info_pattern_and_frequency_vec_t + +ida_lumina.func_info_pattern_and_frequency_vec_t.__getitem__(self, i: "size_t") -> "func_info_pattern_and_frequency_t const &" + +ida_lumina.func_info_pattern_and_frequency_vec_t.__init__(self, *args) + +ida_lumina.func_info_pattern_and_frequency_vec_t.__len__(self) -> "size_t" + +ida_lumina.func_info_pattern_and_frequency_vec_t.__setitem__(self, i: "size_t", v: "func_info_pattern_and_frequency_t") -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.append(self, x: "func_info_pattern_and_frequency_t") -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.at(self, _idx: "size_t") -> "func_info_pattern_and_frequency_t const &" + +ida_lumina.func_info_pattern_and_frequency_vec_t.begin(self, *args) -> "qvector< func_info_pattern_and_frequency_t >::const_iterator" + +ida_lumina.func_info_pattern_and_frequency_vec_t.capacity(self) -> "size_t" + +ida_lumina.func_info_pattern_and_frequency_vec_t.clear(self) -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.empty(self) -> bool + +ida_lumina.func_info_pattern_and_frequency_vec_t.end(self, *args) -> "qvector< func_info_pattern_and_frequency_t >::const_iterator" + +ida_lumina.func_info_pattern_and_frequency_vec_t.erase(self, *args) -> "qvector< func_info_pattern_and_frequency_t >::iterator" + +ida_lumina.func_info_pattern_and_frequency_vec_t.extend(self, x: "func_info_pattern_and_frequency_vec_t") -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.extract(self) -> "func_info_pattern_and_frequency_t *" + +ida_lumina.func_info_pattern_and_frequency_vec_t.grow(self, *args) -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.inject(self, s: "func_info_pattern_and_frequency_t", len: "size_t") -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.insert(self, it: "func_info_pattern_and_frequency_t", x: "func_info_pattern_and_frequency_t") -> "qvector< func_info_pattern_and_frequency_t >::iterator" + +ida_lumina.func_info_pattern_and_frequency_vec_t.pop_back(self) -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.push_back(self, *args) -> "func_info_pattern_and_frequency_t &" + +ida_lumina.func_info_pattern_and_frequency_vec_t.qclear(self) -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.resize(self, *args) -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.size(self) -> "size_t" + +ida_lumina.func_info_pattern_and_frequency_vec_t.swap(self, r: "func_info_pattern_and_frequency_vec_t") -> None + +ida_lumina.func_info_pattern_and_frequency_vec_t.truncate(self) -> None + +ida_lumina.func_info_t + +ida_lumina.func_info_t.__init__(self, *args) + +ida_lumina.func_info_vec_t + +ida_lumina.func_info_vec_t.__getitem__(self, i: "size_t") -> "func_info_t const &" + +ida_lumina.func_info_vec_t.__init__(self, *args) + +ida_lumina.func_info_vec_t.__len__(self) -> "size_t" + +ida_lumina.func_info_vec_t.__setitem__(self, i: "size_t", v: "func_info_t") -> None + +ida_lumina.func_info_vec_t.append(self, x: "func_info_t") -> None + +ida_lumina.func_info_vec_t.at(self, _idx: "size_t") -> "func_info_t const &" + +ida_lumina.func_info_vec_t.begin(self, *args) -> "qvector< func_info_t >::const_iterator" + +ida_lumina.func_info_vec_t.capacity(self) -> "size_t" + +ida_lumina.func_info_vec_t.clear(self) -> None + +ida_lumina.func_info_vec_t.empty(self) -> bool + +ida_lumina.func_info_vec_t.end(self, *args) -> "qvector< func_info_t >::const_iterator" + +ida_lumina.func_info_vec_t.erase(self, *args) -> "qvector< func_info_t >::iterator" + +ida_lumina.func_info_vec_t.extend(self, x: "func_info_vec_t") -> None + +ida_lumina.func_info_vec_t.extract(self) -> "func_info_t *" + +ida_lumina.func_info_vec_t.grow(self, *args) -> None + +ida_lumina.func_info_vec_t.inject(self, s: "func_info_t", len: "size_t") -> None + +ida_lumina.func_info_vec_t.insert(self, it: "func_info_t", x: "func_info_t") -> "qvector< func_info_t >::iterator" + +ida_lumina.func_info_vec_t.pop_back(self) -> None + +ida_lumina.func_info_vec_t.push_back(self, *args) -> "func_info_t &" + +ida_lumina.func_info_vec_t.qclear(self) -> None + +ida_lumina.func_info_vec_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.func_info_vec_t.resize(self, *args) -> None + +ida_lumina.func_info_vec_t.size(self) -> "size_t" + +ida_lumina.func_info_vec_t.swap(self, r: "func_info_vec_t") -> None + +ida_lumina.func_info_vec_t.truncate(self) -> None + +ida_lumina.func_md_diff_handler_t + +ida_lumina.func_md_diff_handler_t.__disown__(self) + +ida_lumina.func_md_diff_handler_t.__init__(self) + +ida_lumina.func_md_diff_handler_t.on_comment_changed(self, fchunk_nr: int, fchunk_off: int, l: str, r: str, rep: bool) -> None + +ida_lumina.func_md_diff_handler_t.on_extra_comment_changed(self, fchunk_nr: int, fchunk_off: int, l: str, r: str, is_prev: bool) -> None + +ida_lumina.func_md_diff_handler_t.on_frame_member_changed(self, offset: int, l: "frame_mem_t", r: "frame_mem_t") -> None + +ida_lumina.func_md_diff_handler_t.on_function_comment_changed(self, l: str, r: str, rep: bool) -> None + +ida_lumina.func_md_diff_handler_t.on_insn_ops_repr_changed(self, fchunk_nr: int, fchunk_off: int, l: "insn_ops_repr_t", r: "insn_ops_repr_t") -> None + +ida_lumina.func_md_diff_handler_t.on_name_changed(self, l: str, r: str) -> None + +ida_lumina.func_md_diff_handler_t.on_proto_changed(self, l: "md_type_parts_t", r: "md_type_parts_t") -> None + +ida_lumina.func_md_diff_handler_t.on_score_changed(self, l: int, r: int) -> None + +ida_lumina.func_md_diff_handler_t.on_user_stkpnt_changed(self, fchunk_nr: int, fchunk_off: int, l: "int64 const *", r: "int64 const *") -> None + +ida_lumina.get_lumina_rpc_packet_t_index_from_base(code: "lumina_rpc_packet_t") -> "uchar" + +ida_lumina.get_server_connection() -> "lumina_client_t *" + +ida_lumina.get_server_connection2(flags: int) -> "lumina_client_t *" + +ida_lumina.has_backup_metadata(ea: ida_idaapi.ea_t) -> bool + +ida_lumina.input_file_t + +ida_lumina.input_file_t.__init__(self, *args) + +ida_lumina.insn_cmt_t + +ida_lumina.insn_cmt_t.__init__(self) + +ida_lumina.insn_cmts_t + +ida_lumina.insn_cmts_t.__getitem__(self, i: "size_t") -> "insn_cmt_t const &" + +ida_lumina.insn_cmts_t.__init__(self, *args) + +ida_lumina.insn_cmts_t.__len__(self) -> "size_t" + +ida_lumina.insn_cmts_t.__setitem__(self, i: "size_t", v: "insn_cmt_t") -> None + +ida_lumina.insn_cmts_t.append(self, x: "insn_cmt_t") -> None + +ida_lumina.insn_cmts_t.at(self, _idx: "size_t") -> "insn_cmt_t const &" + +ida_lumina.insn_cmts_t.begin(self, *args) -> "qvector< insn_cmt_t >::const_iterator" + +ida_lumina.insn_cmts_t.capacity(self) -> "size_t" + +ida_lumina.insn_cmts_t.clear(self) -> None + +ida_lumina.insn_cmts_t.empty(self) -> bool + +ida_lumina.insn_cmts_t.end(self, *args) -> "qvector< insn_cmt_t >::const_iterator" + +ida_lumina.insn_cmts_t.erase(self, *args) -> "qvector< insn_cmt_t >::iterator" + +ida_lumina.insn_cmts_t.extend(self, x: "insn_cmts_t") -> None + +ida_lumina.insn_cmts_t.extract(self) -> "insn_cmt_t *" + +ida_lumina.insn_cmts_t.grow(self, *args) -> None + +ida_lumina.insn_cmts_t.inject(self, s: "insn_cmt_t", len: "size_t") -> None + +ida_lumina.insn_cmts_t.insert(self, it: "insn_cmt_t", x: "insn_cmt_t") -> "qvector< insn_cmt_t >::iterator" + +ida_lumina.insn_cmts_t.pop_back(self) -> None + +ida_lumina.insn_cmts_t.push_back(self, *args) -> "insn_cmt_t &" + +ida_lumina.insn_cmts_t.qclear(self) -> None + +ida_lumina.insn_cmts_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.insn_cmts_t.resize(self, *args) -> None + +ida_lumina.insn_cmts_t.size(self) -> "size_t" + +ida_lumina.insn_cmts_t.swap(self, r: "insn_cmts_t") -> None + +ida_lumina.insn_cmts_t.truncate(self) -> None + +ida_lumina.insn_ops_repr_t + +ida_lumina.insn_ops_repr_t.__init__(self) + +ida_lumina.insn_ops_reprs_t + +ida_lumina.insn_ops_reprs_t.__getitem__(self, i: "size_t") -> "insn_ops_repr_t const &" + +ida_lumina.insn_ops_reprs_t.__init__(self, *args) + +ida_lumina.insn_ops_reprs_t.__len__(self) -> "size_t" + +ida_lumina.insn_ops_reprs_t.__setitem__(self, i: "size_t", v: "insn_ops_repr_t") -> None + +ida_lumina.insn_ops_reprs_t.append(self, x: "insn_ops_repr_t") -> None + +ida_lumina.insn_ops_reprs_t.at(self, _idx: "size_t") -> "insn_ops_repr_t const &" + +ida_lumina.insn_ops_reprs_t.begin(self, *args) -> "qvector< insn_ops_repr_t >::const_iterator" + +ida_lumina.insn_ops_reprs_t.capacity(self) -> "size_t" + +ida_lumina.insn_ops_reprs_t.clear(self) -> None + +ida_lumina.insn_ops_reprs_t.empty(self) -> bool + +ida_lumina.insn_ops_reprs_t.end(self, *args) -> "qvector< insn_ops_repr_t >::const_iterator" + +ida_lumina.insn_ops_reprs_t.erase(self, *args) -> "qvector< insn_ops_repr_t >::iterator" + +ida_lumina.insn_ops_reprs_t.extend(self, x: "insn_ops_reprs_t") -> None + +ida_lumina.insn_ops_reprs_t.extract(self) -> "insn_ops_repr_t *" + +ida_lumina.insn_ops_reprs_t.grow(self, *args) -> None + +ida_lumina.insn_ops_reprs_t.inject(self, s: "insn_ops_repr_t", len: "size_t") -> None + +ida_lumina.insn_ops_reprs_t.insert(self, it: "insn_ops_repr_t", x: "insn_ops_repr_t") -> "qvector< insn_ops_repr_t >::iterator" + +ida_lumina.insn_ops_reprs_t.pop_back(self) -> None + +ida_lumina.insn_ops_reprs_t.push_back(self, *args) -> "insn_ops_repr_t &" + +ida_lumina.insn_ops_reprs_t.qclear(self) -> None + +ida_lumina.insn_ops_reprs_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.insn_ops_reprs_t.resize(self, *args) -> None + +ida_lumina.insn_ops_reprs_t.size(self) -> "size_t" + +ida_lumina.insn_ops_reprs_t.swap(self, r: "insn_ops_reprs_t") -> None + +ida_lumina.insn_ops_reprs_t.truncate(self) -> None + +ida_lumina.insn_site_t + +ida_lumina.insn_site_t.__init__(self) + +ida_lumina.insn_site_t.toea(self, pfn: "func_t const *") -> ida_idaapi.ea_t + +ida_lumina.lumina_client_t + +ida_lumina.lumina_client_t.__init__(self, *args, **kwargs) + +ida_lumina.lumina_client_t.del_history(self, funcs: "eavec_t const &") -> bool + +ida_lumina.lumina_client_t.get_pop(self, nresults: int = 10) -> "pkt_get_pop_result_t *" + +ida_lumina.lumina_client_t.is_pattern_id(self, pid: "pattern_id_t", md5: "md5_t const &") -> bool + +ida_lumina.lumina_client_t.pull_md(self, *args) -> "pkt_pull_md_result_t *" + This function has the following signatures: + 0. pull_md(pattern_ids: pattern_ids_t &, errbuf: str, pull_md_flags: int=0) -> pkt_pull_md_result_t * + 1. pull_md(funcs: eavec_t *, errbuf: str, pull_md_flags: int=0) -> pkt_pull_md_result_t * + + # 0: pull_md(pattern_ids: pattern_ids_t &, errbuf: str, pull_md_flags: int=0) -> pkt_pull_md_result_t * + + + # 1: pull_md(funcs: eavec_t *, errbuf: str, pull_md_flags: int=0) -> pkt_pull_md_result_t * -ida_moves.bookmarks_t (class) - Proxy of C++ bookmarks_t class. +ida_lumina.lumina_client_t.push_md(self, result: "push_md_result_t", opts: "push_md_opts_t", append_metadata: "metadata_appender_t *" = None, flags: int = 0) -> bool -ida_moves.bookmarks_t.__getitem__ (method) +ida_lumina.lumina_client_t.set_pattern_id_md5(self, out: "pattern_id_t", md5: "md5_t const &") -> None + +ida_lumina.lumina_info_t + +ida_lumina.lumina_info_t.__init__(self, *args) + +ida_lumina.lumina_op_res_vec_t + +ida_lumina.lumina_op_res_vec_t.__eq__(self, r: "lumina_op_res_vec_t") -> bool + +ida_lumina.lumina_op_res_vec_t.__getitem__(self, i: "size_t") -> "lumina_op_res_t const &" + +ida_lumina.lumina_op_res_vec_t.__init__(self, *args) + +ida_lumina.lumina_op_res_vec_t.__len__(self) -> "size_t" + +ida_lumina.lumina_op_res_vec_t.__ne__(self, r: "lumina_op_res_vec_t") -> bool + +ida_lumina.lumina_op_res_vec_t.__setitem__(self, i: "size_t", v: "lumina_op_res_t const &") -> None + +ida_lumina.lumina_op_res_vec_t._del(self, x: "lumina_op_res_t const &") -> bool + +ida_lumina.lumina_op_res_vec_t.add_unique(self, x: "lumina_op_res_t const &") -> bool + +ida_lumina.lumina_op_res_vec_t.append(self, x: "lumina_op_res_t const &") -> None + +ida_lumina.lumina_op_res_vec_t.at(self, _idx: "size_t") -> "lumina_op_res_t const &" + +ida_lumina.lumina_op_res_vec_t.begin(self, *args) -> "qvector< lumina_op_res_t >::const_iterator" + +ida_lumina.lumina_op_res_vec_t.capacity(self) -> "size_t" + +ida_lumina.lumina_op_res_vec_t.clear(self) -> None + +ida_lumina.lumina_op_res_vec_t.empty(self) -> bool + +ida_lumina.lumina_op_res_vec_t.end(self, *args) -> "qvector< lumina_op_res_t >::const_iterator" + +ida_lumina.lumina_op_res_vec_t.erase(self, *args) -> "qvector< lumina_op_res_t >::iterator" + +ida_lumina.lumina_op_res_vec_t.extend(self, x: "lumina_op_res_vec_t") -> None + +ida_lumina.lumina_op_res_vec_t.extract(self) -> "lumina_op_res_t *" + +ida_lumina.lumina_op_res_vec_t.find(self, *args) -> "qvector< lumina_op_res_t >::const_iterator" + +ida_lumina.lumina_op_res_vec_t.grow(self, *args) -> None + +ida_lumina.lumina_op_res_vec_t.has(self, x: "lumina_op_res_t const &") -> bool + +ida_lumina.lumina_op_res_vec_t.inject(self, s: "lumina_op_res_t *", len: "size_t") -> None + +ida_lumina.lumina_op_res_vec_t.insert(self, it: "qvector< lumina_op_res_t >::iterator", x: "lumina_op_res_t const &") -> "qvector< lumina_op_res_t >::iterator" + +ida_lumina.lumina_op_res_vec_t.pop_back(self) -> None + +ida_lumina.lumina_op_res_vec_t.push_back(self, *args) -> "lumina_op_res_t &" + +ida_lumina.lumina_op_res_vec_t.qclear(self) -> None + +ida_lumina.lumina_op_res_vec_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.lumina_op_res_vec_t.resize(self, *args) -> None + +ida_lumina.lumina_op_res_vec_t.size(self) -> "size_t" + +ida_lumina.lumina_op_res_vec_t.swap(self, r: "lumina_op_res_vec_t") -> None + +ida_lumina.lumina_op_res_vec_t.truncate(self) -> None + +ida_lumina.lumina_server_info_t + +ida_lumina.lumina_server_info_t.__init__(self, __macaddr: str = None, __verstr: str = None, __start_time: "utc_timestamp_t" = 0, __current_time: "utc_timestamp_t" = 0) + +ida_lumina.lumina_user_t + +ida_lumina.lumina_user_t.__init__(self, *args) + +ida_lumina.lumina_user_t.can_del_history(self) -> bool + +ida_lumina.lumina_user_t.is_admin(self) -> bool + +ida_lumina.lumina_user_t.set_can_del_history(self, v: bool = True) -> None + +ida_lumina.lumina_user_t.set_is_admin(self, v: bool = True) -> None + +ida_lumina.md_type_parts_t + +ida_lumina.md_type_parts_t.__eq__(self, r: "md_type_parts_t") -> bool + +ida_lumina.md_type_parts_t.__init__(self) + +ida_lumina.md_type_parts_t.__ne__(self, r: "md_type_parts_t") -> bool + +ida_lumina.metadata_iterator_t + +ida_lumina.metadata_iterator_t.__init__(self, _md: "metadata_t const &") + +ida_lumina.metadata_iterator_t.data_end(self) -> "uchar const *" + +ida_lumina.metadata_iterator_t.next(self) -> bool + +ida_lumina.new_packet(code: "uchar", ptr: "uchar const *" = None, len: "size_t" = 0, version: int = -1) -> "rpc_packet_data_t *" + +ida_lumina.oprepr_t + +ida_lumina.oprepr_t.__init__(self) + +ida_lumina.pattern_id_t + +ida_lumina.pattern_id_t.__init__(self, *args) + +ida_lumina.peer_conn_t + +ida_lumina.peer_conn_t.__init__(self, *args) + +ida_lumina.pkt_get_lumina_info_result_t + +ida_lumina.pkt_get_lumina_info_result_t.__init__(self) + +ida_lumina.pkt_get_lumina_info_t + +ida_lumina.pkt_get_lumina_info_t.__init__(self) + +ida_lumina.pkt_get_pop_result_t + +ida_lumina.pkt_get_pop_result_t.__init__(self) + +ida_lumina.pkt_get_pop_t + +ida_lumina.pkt_get_pop_t.__init__(self) + +ida_lumina.pkt_helo_result_t + +ida_lumina.pkt_helo_result_t.__init__(self) + +ida_lumina.pkt_helo_t + +ida_lumina.pkt_helo_t.__init__(self) + +ida_lumina.pkt_pull_md_result_t + +ida_lumina.pkt_pull_md_result_t.__init__(self) + +ida_lumina.pkt_pull_md_t + +ida_lumina.pkt_pull_md_t.__init__(self) + +ida_lumina.pkt_push_md_result_t + +ida_lumina.pkt_push_md_result_t.__init__(self) + +ida_lumina.pkt_push_md_t + +ida_lumina.pkt_push_md_t.__init__(self) + +ida_lumina.pkt_rpc_fail_t + +ida_lumina.pkt_rpc_fail_t.__init__(self) + +ida_lumina.pkt_rpc_notify_t + +ida_lumina.pkt_rpc_notify_t.__init__(self) + +ida_lumina.pkt_rpc_ok_t + +ida_lumina.pkt_rpc_ok_t.__init__(self) + +ida_lumina.pop_fun_t + +ida_lumina.pop_fun_t.__init__(self, *args) + +ida_lumina.push_md_opts_t + +ida_lumina.push_md_opts_t.__init__(self, *args) + +ida_lumina.push_md_result_t + +ida_lumina.push_md_result_t.__init__(self) + +ida_lumina.revert_metadata(ea: ida_idaapi.ea_t) -> bool + +ida_lumina.score_metadata(fi: "func_info_t") -> int + +ida_lumina.serialized_tinfo + +ida_lumina.serialized_tinfo.__init__(self, __type: "type_t const *" = None, __fields: "type_t const *" = None) + +ida_lumina.simple_idb_diff_handler_t + +ida_lumina.simple_idb_diff_handler_t.__init__(self, pfn) + +ida_lumina.simple_idb_diff_handler_t.ensure_header_generated(self) + +ida_lumina.simple_idb_diff_handler_t.format_extra_cmt(self, cmt) + +ida_lumina.simple_idb_diff_handler_t.format_frame_member(self, m) + +ida_lumina.simple_idb_diff_handler_t.format_insn_ops(self, ro) + +ida_lumina.simple_idb_diff_handler_t.format_stkpnt(self, stkpnt) + +ida_lumina.simple_idb_diff_handler_t.format_type(self, type_parts) + +ida_lumina.simple_idb_diff_handler_t.indenter_t + +ida_lumina.simple_idb_diff_handler_t.indenter_t.__del__(self) + +ida_lumina.simple_idb_diff_handler_t.indenter_t.__init__(self, handler) + +ida_lumina.simple_idb_diff_handler_t.on_comment_changed(self, fchunk_nr, fchunk_off, l, r, rep) + +ida_lumina.simple_idb_diff_handler_t.on_extra_comment_changed(self, fchunk_nr, fchunk_off, l, r, is_prev) + +ida_lumina.simple_idb_diff_handler_t.on_frame_member_changed(self, offset, l, r) + +ida_lumina.simple_idb_diff_handler_t.on_function_comment_changed(self, l, r, rep) + +ida_lumina.simple_idb_diff_handler_t.on_insn_ops_repr_changed(self, fchunk_nr, fchunk_off, l, r) + +ida_lumina.simple_idb_diff_handler_t.on_name_changed(self, l, r) + +ida_lumina.simple_idb_diff_handler_t.on_proto_changed(self, l, r) + +ida_lumina.simple_idb_diff_handler_t.on_score_changed(self, l, r) + +ida_lumina.simple_idb_diff_handler_t.on_user_stkpnt_changed(self, fchunk_nr, fchunk_off, l, r) + +ida_lumina.simple_idb_diff_handler_t.put(self, msg) + +ida_lumina.simple_idb_diff_handler_t.put2(self, l, r, topic) + +ida_lumina.simple_idb_diff_handler_t.where(self, fchunk_nr, fchunk_off) + +ida_lumina.skipped_func_t + +ida_lumina.skipped_func_t.__init__(self, *args) + +ida_lumina.skipped_funcs_t + +ida_lumina.skipped_funcs_t.__getitem__(self, i: "size_t") -> "skipped_func_t const &" + +ida_lumina.skipped_funcs_t.__init__(self, *args) + +ida_lumina.skipped_funcs_t.__len__(self) -> "size_t" + +ida_lumina.skipped_funcs_t.__setitem__(self, i: "size_t", v: "skipped_func_t") -> None + +ida_lumina.skipped_funcs_t.append(self, x: "skipped_func_t") -> None + +ida_lumina.skipped_funcs_t.at(self, _idx: "size_t") -> "skipped_func_t const &" + +ida_lumina.skipped_funcs_t.begin(self, *args) -> "qvector< skipped_func_t >::const_iterator" + +ida_lumina.skipped_funcs_t.capacity(self) -> "size_t" + +ida_lumina.skipped_funcs_t.clear(self) -> None + +ida_lumina.skipped_funcs_t.empty(self) -> bool + +ida_lumina.skipped_funcs_t.end(self, *args) -> "qvector< skipped_func_t >::const_iterator" + +ida_lumina.skipped_funcs_t.erase(self, *args) -> "qvector< skipped_func_t >::iterator" + +ida_lumina.skipped_funcs_t.extend(self, x: "skipped_funcs_t") -> None + +ida_lumina.skipped_funcs_t.extract(self) -> "skipped_func_t *" + +ida_lumina.skipped_funcs_t.grow(self, *args) -> None + +ida_lumina.skipped_funcs_t.inject(self, s: "skipped_func_t", len: "size_t") -> None + +ida_lumina.skipped_funcs_t.insert(self, it: "skipped_func_t", x: "skipped_func_t") -> "qvector< skipped_func_t >::iterator" + +ida_lumina.skipped_funcs_t.pop_back(self) -> None + +ida_lumina.skipped_funcs_t.push_back(self, *args) -> "skipped_func_t &" + +ida_lumina.skipped_funcs_t.qclear(self) -> None + +ida_lumina.skipped_funcs_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.skipped_funcs_t.resize(self, *args) -> None + +ida_lumina.skipped_funcs_t.size(self) -> "size_t" + +ida_lumina.skipped_funcs_t.swap(self, r: "skipped_funcs_t") -> None + +ida_lumina.skipped_funcs_t.truncate(self) -> None + +ida_lumina.split_metadata(metadata: bytes) -> dict + Split the metadata blob into a set of KVP's + + @param metadata a metadata blob + @return a set of KVP's + +ida_lumina.user_license_info_t + +ida_lumina.user_license_info_t.__init__(self, __id: str = None, __name: str = None, __email: str = None) + +ida_lumina.user_stkpnt_t + +ida_lumina.user_stkpnt_t.__init__(self) + +ida_lumina.user_stkpnts_t + +ida_lumina.user_stkpnts_t.__getitem__(self, i: "size_t") -> "user_stkpnt_t const &" + +ida_lumina.user_stkpnts_t.__init__(self, *args) + +ida_lumina.user_stkpnts_t.__len__(self) -> "size_t" + +ida_lumina.user_stkpnts_t.__setitem__(self, i: "size_t", v: "user_stkpnt_t") -> None + +ida_lumina.user_stkpnts_t.append(self, x: "user_stkpnt_t") -> None + +ida_lumina.user_stkpnts_t.at(self, _idx: "size_t") -> "user_stkpnt_t const &" + +ida_lumina.user_stkpnts_t.begin(self, *args) -> "qvector< user_stkpnt_t >::const_iterator" + +ida_lumina.user_stkpnts_t.capacity(self) -> "size_t" + +ida_lumina.user_stkpnts_t.clear(self) -> None + +ida_lumina.user_stkpnts_t.empty(self) -> bool + +ida_lumina.user_stkpnts_t.end(self, *args) -> "qvector< user_stkpnt_t >::const_iterator" + +ida_lumina.user_stkpnts_t.erase(self, *args) -> "qvector< user_stkpnt_t >::iterator" + +ida_lumina.user_stkpnts_t.extend(self, x: "user_stkpnts_t") -> None + +ida_lumina.user_stkpnts_t.extract(self) -> "user_stkpnt_t *" + +ida_lumina.user_stkpnts_t.grow(self, *args) -> None + +ida_lumina.user_stkpnts_t.inject(self, s: "user_stkpnt_t", len: "size_t") -> None + +ida_lumina.user_stkpnts_t.insert(self, it: "user_stkpnt_t", x: "user_stkpnt_t") -> "qvector< user_stkpnt_t >::iterator" + +ida_lumina.user_stkpnts_t.pop_back(self) -> None + +ida_lumina.user_stkpnts_t.push_back(self, *args) -> "user_stkpnt_t &" + +ida_lumina.user_stkpnts_t.qclear(self) -> None + +ida_lumina.user_stkpnts_t.reserve(self, cnt: "size_t") -> None + +ida_lumina.user_stkpnts_t.resize(self, *args) -> None + +ida_lumina.user_stkpnts_t.size(self) -> "size_t" + +ida_lumina.user_stkpnts_t.swap(self, r: "user_stkpnts_t") -> None + +ida_lumina.user_stkpnts_t.truncate(self) -> None + +ida_moves + +ida_moves.UNHID_FUNC + unhid a function at 'target' + +ida_moves.UNHID_RANGE + unhid an range at 'target' + +ida_moves.UNHID_SEGM + unhid a segment at 'target' + +ida_moves.bookmarks_t + +ida_moves.bookmarks_t.__getitem__(self, idx) Get the n-th bookmark for the widget. -ida_moves.bookmarks_t.__init__ (method) +ida_moves.bookmarks_t.__init__(self, *args, **kwargs) -ida_moves.bookmarks_t.__init__ (method) +ida_moves.bookmarks_t.__init__(self, w) Build an object suitable for iterating bookmarks associated with the specified widget. @@ -48422,2924 +33643,1858 @@ ida_moves.bookmarks_t.__init__ (method) "Pseudocode-*", "Hex View-*", ...) share a common storage, so bookmarks can be re-used interchangeably between them -ida_moves.bookmarks_t.__iter__ (method) +ida_moves.bookmarks_t.__iter__(self) Iterate on bookmarks present for the widget. -ida_moves.bookmarks_t.__len__ (method) +ida_moves.bookmarks_t.__len__(self) Get the number of bookmarks for the widget. -ida_moves.bookmarks_t.erase (method) - erase(e, index, ud) -> bool - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t.find_index (method) - find_index(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t.get (method) - get(out, _index, ud) -> PyObject * - - @param out: lochist_entry_t * - @param _index: uint32 - @param ud: void * - -ida_moves.bookmarks_t.get_desc (method) - get_desc(e, index, ud) -> bool - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t.get_dirtree_id (method) - get_dirtree_id(e, ud) -> dirtree_id_t - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t.mark (method) - mark(e, index, title, desc, ud) -> uint32 - - @param e: lochist_entry_t const & - @param index: uint32 - @param title: char const * - @param desc: char const * - @param ud: void * - -ida_moves.bookmarks_t.size (method) - size(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t_erase (function) - bookmarks_t_erase(e, index, ud) -> bool - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t_find_index (function) - bookmarks_t_find_index(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t_get (function) - bookmarks_t_get(out, _index, ud) -> PyObject * - - @param out: lochist_entry_t * - @param _index: uint32 - @param ud: void * - -ida_moves.bookmarks_t_get_desc (function) - bookmarks_t_get_desc(e, index, ud) -> str - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t_get_dirtree_id (function) - bookmarks_t_get_dirtree_id(e, ud) -> dirtree_id_t - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t_mark (function) - bookmarks_t_mark(e, index, title, desc, ud) -> uint32 - - @param e: lochist_entry_t const & - @param index: uint32 - @param title: char const * - @param desc: char const * - @param ud: void * - -ida_moves.bookmarks_t_size (function) - bookmarks_t_size(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.graph_location_info_t (class) - Proxy of C++ graph_location_info_t class. - -ida_moves.graph_location_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: graph_location_info_t const & - -ida_moves.graph_location_info_t.__init__ (method) - __init__(self) -> graph_location_info_t - -ida_moves.graph_location_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: graph_location_info_t const & - -ida_moves.lochist_entry_t (class) - Proxy of C++ lochist_entry_t class. - -ida_moves.lochist_entry_t.__init__ (method) - __init__(self) -> lochist_entry_t - __init__(self, p, r) -> lochist_entry_t - - @param p: place_t const * - @param r: renderer_info_t const & - - __init__(self, other) -> lochist_entry_t - - @param other: lochist_entry_t const & - -ida_moves.lochist_entry_t.acquire_place (method) - acquire_place(self, in_p) - - @param in_p: place_t * - -ida_moves.lochist_entry_t.is_valid (method) - is_valid(self) -> bool - -ida_moves.lochist_entry_t.place (method) - place(self) -> place_t - -ida_moves.lochist_entry_t.renderer_info (method) - renderer_info(self) -> renderer_info_t - -ida_moves.lochist_entry_t.set_place (method) - set_place(self, p) - - @param p: place_t const * - -ida_moves.lochist_t (class) - Proxy of C++ lochist_t class. - -ida_moves.lochist_t.__init__ (method) - __init__(self) -> lochist_t - -ida_moves.lochist_t.back (method) - back(self, cnt, try_to_unhide) -> bool - - @param cnt: uint32 - @param try_to_unhide: bool - -ida_moves.lochist_t.clear (method) - clear(self) - -ida_moves.lochist_t.current_index (method) - current_index(self) -> uint32 - -ida_moves.lochist_t.fwd (method) - fwd(self, cnt, try_to_unhide) -> bool - - @param cnt: uint32 - @param try_to_unhide: bool - -ida_moves.lochist_t.get (method) - get(self, out, index) -> bool - - @param out: lochist_entry_t * - @param index: uint32 - -ida_moves.lochist_t.get_current (method) - get_current(self) -> lochist_entry_t - -ida_moves.lochist_t.get_place_id (method) - get_place_id(self) -> int - -ida_moves.lochist_t.get_template_place (method) - get_template_place(self) -> place_t - -ida_moves.lochist_t.init (method) - init(self, stream_name, _defpos, _ud, _flags) -> bool - - @param stream_name: char const * - @param _defpos: place_t const * - @param _ud: void * - @param _flags: uint32 - -ida_moves.lochist_t.is_history_enabled (method) - is_history_enabled(self) -> bool - -ida_moves.lochist_t.jump (method) - jump(self, try_to_unhide, e) - - @param try_to_unhide: bool - @param e: lochist_entry_t const & - -ida_moves.lochist_t.netcode (method) - netcode(self) -> nodeidx_t - -ida_moves.lochist_t.save (method) - save(self) - -ida_moves.lochist_t.seek (method) - seek(self, index, try_to_unhide) -> bool - - @param index: uint32 - @param try_to_unhide: bool - -ida_moves.lochist_t.set (method) - set(self, index, e) - - @param index: uint32 - @param e: lochist_entry_t const & - -ida_moves.lochist_t.set_current (method) - set_current(self, e) - - @param e: lochist_entry_t const & - -ida_moves.lochist_t.size (method) - size(self) -> uint32 - -ida_moves.renderer_info_pos_t (class) - Proxy of C++ renderer_info_pos_t class. - -ida_moves.renderer_info_pos_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: renderer_info_pos_t const & - -ida_moves.renderer_info_pos_t.__init__ (method) - __init__(self) -> renderer_info_pos_t - -ida_moves.renderer_info_pos_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: renderer_info_pos_t const & - -ida_moves.renderer_info_t (class) - Proxy of C++ renderer_info_t class. - -ida_moves.renderer_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: renderer_info_t const & - -ida_moves.renderer_info_t.__init__ (method) - __init__(self) -> renderer_info_t - __init__(self, _rtype, cx, cy) -> renderer_info_t - - @param _rtype: enum tcc_renderer_type_t - @param cx: short - @param cy: short - -ida_moves.renderer_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: renderer_info_t const & - -ida_moves.segm_move_info_t (class) - Proxy of C++ segm_move_info_t class. - -ida_moves.segm_move_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: segm_move_info_t const & - -ida_moves.segm_move_info_t.__init__ (method) - __init__(self, _from=0, _to=0, _sz=0) -> segm_move_info_t - - @param _from: ea_t - @param _to: ea_t - @param _sz: size_t - -ida_moves.segm_move_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t (class) - Proxy of C++ qvector< segm_move_info_t > class. - -ida_moves.segm_move_info_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< segm_move_info_t > const & - -ida_moves.segm_move_info_vec_t.__getitem__ (method) - __getitem__(self, i) -> segm_move_info_t - - @param i: size_t - -ida_moves.segm_move_info_vec_t.__init__ (method) - __init__(self) -> segm_move_info_vec_t - __init__(self, x) -> segm_move_info_vec_t - - @param x: qvector< segm_move_info_t > const & - -ida_moves.segm_move_info_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_moves.segm_move_info_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< segm_move_info_t > const & - -ida_moves.segm_move_info_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.at (method) - at(self, _idx) -> segm_move_info_t - - @param _idx: size_t - -ida_moves.segm_move_info_vec_t.begin (method) - begin(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.capacity (method) - capacity(self) -> size_t - -ida_moves.segm_move_info_vec_t.clear (method) - clear(self) - -ida_moves.segm_move_info_vec_t.empty (method) - empty(self) -> bool - -ida_moves.segm_move_info_vec_t.end (method) - end(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.erase (method) - erase(self, it) -> segm_move_info_t - - @param it: qvector< segm_move_info_t >::iterator - - erase(self, first, last) -> segm_move_info_t - - @param first: qvector< segm_move_info_t >::iterator - @param last: qvector< segm_move_info_t >::iterator - -ida_moves.segm_move_info_vec_t.extract (method) - extract(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.find (method) - find(self, x) -> segm_move_info_t - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.grow (method) - grow(self, x=segm_move_info_t()) - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.has (method) - has(self, x) -> bool - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.inject (method) - inject(self, s, len) - - @param s: segm_move_info_t * - @param len: size_t - -ida_moves.segm_move_info_vec_t.insert (method) - insert(self, it, x) -> segm_move_info_t - - @param it: qvector< segm_move_info_t >::iterator - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.pop_back (method) - pop_back(self) - -ida_moves.segm_move_info_vec_t.push_back (method) - push_back(self, x) - - @param x: segm_move_info_t const & - - push_back(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.qclear (method) - qclear(self) - -ida_moves.segm_move_info_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_moves.segm_move_info_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: segm_move_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_moves.segm_move_info_vec_t.size (method) - size(self) -> size_t - -ida_moves.segm_move_info_vec_t.swap (method) - swap(self, r) - - @param r: qvector< segm_move_info_t > & - -ida_moves.segm_move_info_vec_t.truncate (method) - truncate(self) - -ida_moves.segm_move_infos_t (class) - Proxy of C++ segm_move_infos_t class. - -ida_moves.segm_move_infos_t.__init__ (method) - __init__(self) -> segm_move_infos_t - -ida_moves.segm_move_infos_t.find (method) - find(self, ea) -> segm_move_info_t - - @param ea: ea_t - -ida_nalt (module) +ida_moves.bookmarks_t.erase(e: "lochist_entry_t", index: int, ud: "void *") -> bool + +ida_moves.bookmarks_t.find_index(e: "lochist_entry_t", ud: "void *") -> int + +ida_moves.bookmarks_t.get(out: "lochist_entry_t", _index: int, ud: "void *") -> "PyObject *" + +ida_moves.bookmarks_t.get_desc(e: "lochist_entry_t", index: int, ud: "void *") -> str + +ida_moves.bookmarks_t.get_dirtree_id(e: "lochist_entry_t", ud: "void *") -> "dirtree_id_t" + +ida_moves.bookmarks_t.mark(e: "lochist_entry_t", index: int, title: str, desc: str, ud: "void *") -> int + +ida_moves.bookmarks_t.size(e: "lochist_entry_t", ud: "void *") -> int + +ida_moves.graph_location_info_t + +ida_moves.graph_location_info_t.__eq__(self, r: "graph_location_info_t") -> bool + +ida_moves.graph_location_info_t.__init__(self) + +ida_moves.graph_location_info_t.__ne__(self, r: "graph_location_info_t") -> bool + +ida_moves.lochist_entry_t + +ida_moves.lochist_entry_t.__init__(self, *args) + +ida_moves.lochist_entry_t.acquire_place(self, in_p: "place_t") -> None + +ida_moves.lochist_entry_t.is_valid(self) -> bool + +ida_moves.lochist_entry_t.place(self) -> "place_t *" + +ida_moves.lochist_entry_t.renderer_info(self) -> "renderer_info_t &" + +ida_moves.lochist_entry_t.set_place(self, p: "place_t") -> None + +ida_moves.lochist_t + +ida_moves.lochist_t.__init__(self) + +ida_moves.lochist_t.back(self, cnt: int, try_to_unhide: bool) -> bool + +ida_moves.lochist_t.clear(self) -> None + +ida_moves.lochist_t.current_index(self) -> int + +ida_moves.lochist_t.fwd(self, cnt: int, try_to_unhide: bool) -> bool + +ida_moves.lochist_t.get(self, out: "lochist_entry_t", index: int) -> bool + +ida_moves.lochist_t.get_current(self) -> "lochist_entry_t const &" + +ida_moves.lochist_t.get_place_id(self) -> int + +ida_moves.lochist_t.get_template_place(self) -> "place_t const *" + +ida_moves.lochist_t.init(self, stream_name: str, _defpos: "place_t", _ud: "void *", _flags: int) -> bool + +ida_moves.lochist_t.is_history_enabled(self) -> bool + +ida_moves.lochist_t.jump(self, try_to_unhide: bool, e: "lochist_entry_t") -> None + +ida_moves.lochist_t.netcode(self) -> "nodeidx_t" + +ida_moves.lochist_t.save(self) -> None + +ida_moves.lochist_t.seek(self, index: int, try_to_unhide: bool) -> bool + +ida_moves.lochist_t.set(self, index: int, e: "lochist_entry_t") -> None + +ida_moves.lochist_t.set_current(self, e: "lochist_entry_t") -> None + +ida_moves.lochist_t.size(self) -> int + +ida_moves.renderer_info_pos_t + +ida_moves.renderer_info_pos_t.__eq__(self, r: "renderer_info_pos_t") -> bool + +ida_moves.renderer_info_pos_t.__init__(self) + +ida_moves.renderer_info_pos_t.__ne__(self, r: "renderer_info_pos_t") -> bool + +ida_moves.renderer_info_t + +ida_moves.renderer_info_t.__eq__(self, r: "renderer_info_t") -> bool + +ida_moves.renderer_info_t.__init__(self, *args) + +ida_moves.renderer_info_t.__ne__(self, r: "renderer_info_t") -> bool + +ida_moves.segm_move_info_t + +ida_moves.segm_move_info_t.__eq__(self, r: "segm_move_info_t") -> bool + +ida_moves.segm_move_info_t.__init__(self, _from: ida_idaapi.ea_t = 0, _to: ida_idaapi.ea_t = 0, _sz: "size_t" = 0) + +ida_moves.segm_move_info_t.__ne__(self, r: "segm_move_info_t") -> bool + +ida_moves.segm_move_info_vec_t + +ida_moves.segm_move_info_vec_t.__eq__(self, r: "segm_move_info_vec_t") -> bool + +ida_moves.segm_move_info_vec_t.__getitem__(self, i: "size_t") -> "segm_move_info_t const &" + +ida_moves.segm_move_info_vec_t.__init__(self, *args) + +ida_moves.segm_move_info_vec_t.__len__(self) -> "size_t" + +ida_moves.segm_move_info_vec_t.__ne__(self, r: "segm_move_info_vec_t") -> bool + +ida_moves.segm_move_info_vec_t.__setitem__(self, i: "size_t", v: "segm_move_info_t") -> None + +ida_moves.segm_move_info_vec_t._del(self, x: "segm_move_info_t") -> bool + +ida_moves.segm_move_info_vec_t.add_unique(self, x: "segm_move_info_t") -> bool + +ida_moves.segm_move_info_vec_t.append(self, x: "segm_move_info_t") -> None + +ida_moves.segm_move_info_vec_t.at(self, _idx: "size_t") -> "segm_move_info_t const &" + +ida_moves.segm_move_info_vec_t.begin(self, *args) -> "qvector< segm_move_info_t >::const_iterator" + +ida_moves.segm_move_info_vec_t.capacity(self) -> "size_t" + +ida_moves.segm_move_info_vec_t.clear(self) -> None + +ida_moves.segm_move_info_vec_t.empty(self) -> bool + +ida_moves.segm_move_info_vec_t.end(self, *args) -> "qvector< segm_move_info_t >::const_iterator" + +ida_moves.segm_move_info_vec_t.erase(self, *args) -> "qvector< segm_move_info_t >::iterator" + +ida_moves.segm_move_info_vec_t.extend(self, x: "segm_move_info_vec_t") -> None + +ida_moves.segm_move_info_vec_t.extract(self) -> "segm_move_info_t *" + +ida_moves.segm_move_info_vec_t.find(self, *args) -> "qvector< segm_move_info_t >::const_iterator" + +ida_moves.segm_move_info_vec_t.grow(self, *args) -> None + +ida_moves.segm_move_info_vec_t.has(self, x: "segm_move_info_t") -> bool + +ida_moves.segm_move_info_vec_t.inject(self, s: "segm_move_info_t", len: "size_t") -> None + +ida_moves.segm_move_info_vec_t.insert(self, it: "segm_move_info_t", x: "segm_move_info_t") -> "qvector< segm_move_info_t >::iterator" + +ida_moves.segm_move_info_vec_t.pop_back(self) -> None + +ida_moves.segm_move_info_vec_t.push_back(self, *args) -> "segm_move_info_t &" + +ida_moves.segm_move_info_vec_t.qclear(self) -> None + +ida_moves.segm_move_info_vec_t.reserve(self, cnt: "size_t") -> None + +ida_moves.segm_move_info_vec_t.resize(self, *args) -> None + +ida_moves.segm_move_info_vec_t.size(self) -> "size_t" + +ida_moves.segm_move_info_vec_t.swap(self, r: "segm_move_info_vec_t") -> None + +ida_moves.segm_move_info_vec_t.truncate(self) -> None + +ida_moves.segm_move_infos_t + +ida_moves.segm_move_infos_t.__init__(self) + +ida_moves.segm_move_infos_t.find(self, ea: ida_idaapi.ea_t) -> "segm_move_info_t const *" + +ida_nalt Definitions of various information kept in netnodes. Each address in the program has a corresponding netnode: netnode(ea). - - If we have no information about an address, the corresponding netnode is not - created. Otherwise we will create a netnode and save information in it. All - variable length information (names, comments, offset information, etc) is stored - in the netnode. - + If we have no information about an address, the corresponding netnode is not created. Otherwise we will create a netnode and save information in it. All variable length information (names, comments, offset information, etc) is stored in the netnode. Don't forget that some information is already stored in the flags (bytes.hpp) - - @warning: Many of the functions in this file are very low level (they are marked - as low level functions). Use them only if you can't find higher level - function to set/get/del information.netnode. + netnode. + -ida_nalt.AFL_ALIGNFLOW (variable) +ida_nalt.AFL_ALIGNFLOW the previous insn was created for alignment purposes only -ida_nalt.AFL_BNOT0 (variable) +ida_nalt.AFL_BNOT0 the 1st operand is bitwise negated -ida_nalt.AFL_BNOT1 (variable) +ida_nalt.AFL_BNOT1 the 2nd operand is bitwise negated -ida_nalt.AFL_COLORED (variable) +ida_nalt.AFL_COLORED has user defined instruction color? -ida_nalt.AFL_FIXEDSPD (variable) - sp delta value is fixed by analysis. should not be modified by modules +ida_nalt.AFL_FIXEDSPD + sp delta value is fixed by analysis. should not be modified by modules + -ida_nalt.AFL_HIDDEN (variable) +ida_nalt.AFL_HIDDEN the item is hidden completely -ida_nalt.AFL_HR_DETERMINED (variable) +ida_nalt.AFL_HR_DETERMINED the type is definitely guessed by the decompiler -ida_nalt.AFL_HR_GUESSED_DATA (variable) +ida_nalt.AFL_HR_GUESSED_DATA the data type is guessed by the decompiler -ida_nalt.AFL_HR_GUESSED_FUNC (variable) +ida_nalt.AFL_HR_GUESSED_FUNC the function type is guessed by the decompiler -ida_nalt.AFL_IDA_GUESSED (variable) +ida_nalt.AFL_IDA_GUESSED the type is guessed by IDA -ida_nalt.AFL_LIB (variable) - item from the standard library. low level flag, is used to set FUNC_LIB of - func_t +ida_nalt.AFL_LIB + item from the standard library. low level flag, is used to set FUNC_LIB of func_t + -ida_nalt.AFL_LINNUM (variable) +ida_nalt.AFL_LINNUM has line number info -ida_nalt.AFL_LNAME (variable) +ida_nalt.AFL_LNAME has local name too (FF_NAME should be set) -ida_nalt.AFL_LZERO0 (variable) +ida_nalt.AFL_LZERO0 toggle leading zeroes for the 1st operand -ida_nalt.AFL_LZERO1 (variable) +ida_nalt.AFL_LZERO1 toggle leading zeroes for the 2nd operand -ida_nalt.AFL_MANUAL (variable) +ida_nalt.AFL_MANUAL the instruction/data is specified by the user -ida_nalt.AFL_NOBRD (variable) +ida_nalt.AFL_NOBRD the code/data border is hidden -ida_nalt.AFL_NORET (variable) - for imported function pointers: doesn't return. this flag can also be used for - any instruction which halts or finishes the program execution +ida_nalt.AFL_NORET + for imported function pointers: doesn't return. this flag can also be used for any instruction which halts or finishes the program execution + -ida_nalt.AFL_NOTCODE (variable) +ida_nalt.AFL_NOTCODE autoanalysis should not create code here -ida_nalt.AFL_NOTPROC (variable) +ida_nalt.AFL_NOTPROC autoanalysis should not create proc here -ida_nalt.AFL_PUBNAM (variable) +ida_nalt.AFL_PUBNAM name is public (inter-file linkage) -ida_nalt.AFL_RETFP (variable) +ida_nalt.AFL_RETFP function returns a floating point value -ida_nalt.AFL_TERSESTR (variable) +ida_nalt.AFL_SIGN0 + code: toggle sign of the 1st operand + +ida_nalt.AFL_SIGN1 + code: toggle sign of the 2nd operand + +ida_nalt.AFL_TERSESTR terse structure variable display? -ida_nalt.AFL_TI (variable) +ida_nalt.AFL_TI has typeinfo? (NSUP_TYPEINFO); used only for addresses, not for member_t -ida_nalt.AFL_TI0 (variable) +ida_nalt.AFL_TI0 has typeinfo for operand 0? (NSUP_OPTYPES) -ida_nalt.AFL_TI1 (variable) +ida_nalt.AFL_TI1 has typeinfo for operand 1? (NSUP_OPTYPES+1) -ida_nalt.AFL_TILCMT (variable) +ida_nalt.AFL_TILCMT has type comment? (such a comment may be changed by IDA) -ida_nalt.AFL_TYPE_GUESSED (variable) +ida_nalt.AFL_TYPE_GUESSED who guessed the type information? -ida_nalt.AFL_USEMODSP (variable) - insn modifes SP and uses the modified value; example: pop [rsp+N] +ida_nalt.AFL_USEMODSP + insn modifes SP and uses the modified value; example: pop [rsp+N] + -ida_nalt.AFL_USERSP (variable) +ida_nalt.AFL_USERSP user-defined SP value -ida_nalt.AFL_USERTI (variable) - the type information is definitive. (comes from the user or type library) if not - set see AFL_TYPE_GUESSED +ida_nalt.AFL_USERTI + the type information is definitive. (comes from the user or type library) if not set see AFL_TYPE_GUESSED + -ida_nalt.AFL_WEAKNAM (variable) +ida_nalt.AFL_WEAKNAM name is weak -ida_nalt.AFL_ZSTROFF (variable) - display struct field name at 0 offset when displaying an offset. example: - offset somestruct.field_0 if this flag is clear, then - offset somestruct +ida_nalt.AFL_ZSTROFF + display struct field name at 0 offset when displaying an offset. example: `offset somestruct.field_0 ` if this flag is clear, then `offset somestruct ` + -ida_nalt.AP_ALLOWDUPS (variable) +ida_nalt.AP_ALLOWDUPS use 'dup' construct -ida_nalt.AP_ARRAY (variable) +ida_nalt.AP_ARRAY create as array (this flag is not stored in database) -ida_nalt.AP_IDXBASEMASK (variable) +ida_nalt.AP_IDXBASEMASK mask for number base of the indexes -ida_nalt.AP_IDXBIN (variable) +ida_nalt.AP_IDXBIN display indexes in binary -ida_nalt.AP_IDXDEC (variable) +ida_nalt.AP_IDXDEC display indexes in decimal -ida_nalt.AP_IDXHEX (variable) +ida_nalt.AP_IDXHEX display indexes in hex -ida_nalt.AP_IDXOCT (variable) +ida_nalt.AP_IDXOCT display indexes in octal -ida_nalt.AP_INDEX (variable) +ida_nalt.AP_INDEX display array element indexes as comments -ida_nalt.AP_SIGNED (variable) +ida_nalt.AP_SIGNED treats numbers as signed -ida_nalt.IDB_DESKTOPS_NODE_NAME (variable) +ida_nalt.GOTEA_NODE_NAME + node containing address of .got section + +ida_nalt.IDB_DESKTOPS_NODE_NAME hash indexed by desktop name with dekstop netnode -ida_nalt.IDB_DESKTOPS_TAG (variable) +ida_nalt.IDB_DESKTOPS_TAG tag to store desktop blob & timestamp -ida_nalt.MAXSTRUCPATH (variable) +ida_nalt.MAXSTRUCPATH maximal inclusion depth of unions -ida_nalt.NALT_ABSBASE (variable) +ida_nalt.NALT_ABSBASE absolute segment location -ida_nalt.NALT_AFLAGS (variable) +ida_nalt.NALT_AFLAGS additional flags for an item -ida_nalt.NALT_ALIGN (variable) - alignment value if the item is FF_ALIGN (should by equal to power of 2) +ida_nalt.NALT_ALIGN + alignment value if the item is FF_ALIGN (should by equal to power of 2) + -ida_nalt.NALT_COLOR (variable) +ida_nalt.NALT_COLOR instruction/data background color -ida_nalt.NALT_CREF_FROM (variable) +ida_nalt.NALT_CREF_FROM code xref from, idx: source address -ida_nalt.NALT_CREF_TO (variable) +ida_nalt.NALT_CREF_TO code xref to, idx: target address -ida_nalt.NALT_DREF_FROM (variable) +ida_nalt.NALT_DREF_FROM data xref from, idx: source address -ida_nalt.NALT_DREF_TO (variable) +ida_nalt.NALT_DREF_TO data xref to, idx: target address -ida_nalt.NALT_ENUM0 (variable) +ida_nalt.NALT_ENUM0 enum id for the first operand -ida_nalt.NALT_ENUM1 (variable) +ida_nalt.NALT_ENUM1 enum id for the second operand -ida_nalt.NALT_GR_LAYX (variable) +ida_nalt.NALT_GR_LAYX group layout ptrs, hash: md5 of 'belongs' -ida_nalt.NALT_LINNUM (variable) +ida_nalt.NALT_LINNUM source line number -ida_nalt.NALT_PURGE (variable) +ida_nalt.NALT_PURGE number of bytes purged from the stack when a function is called indirectly -ida_nalt.NALT_STRTYPE (variable) +ida_nalt.NALT_STRTYPE type of string item -ida_nalt.NALT_STRUCT (variable) +ida_nalt.NALT_STRUCT struct id -ida_nalt.NALT_SWITCH (variable) +ida_nalt.NALT_SWITCH switch idiom address (used at jump targets) -ida_nalt.NSUP_ARGEAS (variable) +ida_nalt.NSUP_ARGEAS instructions that initialize call arguments -ida_nalt.NSUP_ARRAY (variable) +ida_nalt.NSUP_ARRAY array parameters -ida_nalt.NSUP_CMT (variable) +ida_nalt.NSUP_CMT regular comment -ida_nalt.NSUP_CUSTDT (variable) +ida_nalt.NSUP_CUSTDT custom data type id -ida_nalt.NSUP_EX_FLAGS (variable) +ida_nalt.NSUP_EX_FLAGS Extended flags. -ida_nalt.NSUP_FOP1 (variable) +ida_nalt.NSUP_FOP1 forced operand 1 -ida_nalt.NSUP_FOP2 (variable) +ida_nalt.NSUP_FOP2 forced operand 2 -ida_nalt.NSUP_FOP3 (variable) +ida_nalt.NSUP_FOP3 forced operand 3 -ida_nalt.NSUP_FOP4 (variable) +ida_nalt.NSUP_FOP4 forced operand 4 -ida_nalt.NSUP_FOP5 (variable) +ida_nalt.NSUP_FOP5 forced operand 5 -ida_nalt.NSUP_FOP6 (variable) +ida_nalt.NSUP_FOP6 forced operand 6 -ida_nalt.NSUP_FOP7 (variable) +ida_nalt.NSUP_FOP7 forced operand 7 -ida_nalt.NSUP_FOP8 (variable) +ida_nalt.NSUP_FOP8 forced operand 8 -ida_nalt.NSUP_FTAILS (variable) - function tails or tail referers values NSUP_FTAILS..NSUP_FTAILS+0x1000 are - reserved +ida_nalt.NSUP_FRAME + function frame type values NSUP_FRAME..NSUP_FRAME+0x10000 are reserved + -ida_nalt.NSUP_GROUP (variable) - graph group information values NSUP_GROUP..NSUP_GROUP+0x1000 are reserved +ida_nalt.NSUP_FTAILS + function tails or tail referers values NSUP_FTAILS..NSUP_FTAILS+0x1000 are reserved + -ida_nalt.NSUP_GR_INFO (variable) +ida_nalt.NSUP_GROUP + graph group information values NSUP_GROUP..NSUP_GROUP+0x1000 are reserved + + +ida_nalt.NSUP_GROUPS + SEG_GRP: pack_dd encoded list of selectors. + +ida_nalt.NSUP_GR_INFO group node info: color, ea, text -ida_nalt.NSUP_GR_LAYT (variable) +ida_nalt.NSUP_GR_LAYT group layouts, idx: layout pointer -ida_nalt.NSUP_JINFO (variable) +ida_nalt.NSUP_JINFO jump table info -ida_nalt.NSUP_LLABEL (variable) - local labels. values NSUP_LLABEL..NSUP_LLABEL+0x1000 are reserved +ida_nalt.NSUP_LLABEL + local labels. values NSUP_LLABEL..NSUP_LLABEL+0x1000 are reserved + -ida_nalt.NSUP_MANUAL (variable) - manual instruction. values NSUP_MANUAL..NSUP_MANUAL+0x1000 are reserved +ida_nalt.NSUP_MANUAL + manual instruction. values NSUP_MANUAL..NSUP_MANUAL+0x1000 are reserved + -ida_nalt.NSUP_OPTYPES (variable) - operand type information. values NSUP_OPTYPES..NSUP_OPTYPES+0x100000 are - reserved +ida_nalt.NSUP_OMFGRP + OMF: group of segments (not used anymore) -ida_nalt.NSUP_OREF0 (variable) +ida_nalt.NSUP_OPTYPES + operand type information. values NSUP_OPTYPES..NSUP_OPTYPES+0x100000 are reserved + + +ida_nalt.NSUP_OREF0 outer complex reference information for operand 1 -ida_nalt.NSUP_OREF1 (variable) +ida_nalt.NSUP_OREF1 outer complex reference information for operand 2 -ida_nalt.NSUP_OREF2 (variable) +ida_nalt.NSUP_OREF2 outer complex reference information for operand 3 -ida_nalt.NSUP_OREF3 (variable) +ida_nalt.NSUP_OREF3 outer complex reference information for operand 4 -ida_nalt.NSUP_OREF4 (variable) +ida_nalt.NSUP_OREF4 outer complex reference information for operand 5 -ida_nalt.NSUP_OREF5 (variable) +ida_nalt.NSUP_OREF5 outer complex reference information for operand 6 -ida_nalt.NSUP_OREF6 (variable) +ida_nalt.NSUP_OREF6 outer complex reference information for operand 7 -ida_nalt.NSUP_OREF7 (variable) +ida_nalt.NSUP_OREF7 outer complex reference information for operand 8 -ida_nalt.NSUP_ORIGFMD (variable) - function metadata before lumina information was applied values - NSUP_ORIGFMD..NSUP_ORIGFMD+0x1000 are reserved +ida_nalt.NSUP_ORIGFMD + function metadata before lumina information was applied values NSUP_ORIGFMD..NSUP_ORIGFMD+0x1000 are reserved + -ida_nalt.NSUP_POINTS (variable) - SP change points blob (see funcs.cpp). values NSUP_POINTS..NSUP_POINTS+0x1000 - are reserved +ida_nalt.NSUP_POINTS + SP change points blob (see funcs.cpp). values NSUP_POINTS..NSUP_POINTS+0x1000 are reserved + -ida_nalt.NSUP_REF0 (variable) +ida_nalt.NSUP_REF0 complex reference information for operand 1 -ida_nalt.NSUP_REF1 (variable) +ida_nalt.NSUP_REF1 complex reference information for operand 2 -ida_nalt.NSUP_REF2 (variable) +ida_nalt.NSUP_REF2 complex reference information for operand 3 -ida_nalt.NSUP_REF3 (variable) +ida_nalt.NSUP_REF3 complex reference information for operand 4 -ida_nalt.NSUP_REF4 (variable) +ida_nalt.NSUP_REF4 complex reference information for operand 5 -ida_nalt.NSUP_REF5 (variable) +ida_nalt.NSUP_REF5 complex reference information for operand 6 -ida_nalt.NSUP_REF6 (variable) +ida_nalt.NSUP_REF6 complex reference information for operand 7 -ida_nalt.NSUP_REF7 (variable) +ida_nalt.NSUP_REF7 complex reference information for operand 8 -ida_nalt.NSUP_REGARG (variable) - register argument type/name descriptions values NSUP_REGARG..NSUP_REGARG+0x1000 - are reserved +ida_nalt.NSUP_REGARG + register argument type/name descriptions values NSUP_REGARG..NSUP_REGARG+0x1000 are reserved + -ida_nalt.NSUP_REGVAR (variable) - register variables. values NSUP_REGVAR..NSUP_REGVAR+0x1000 are reserved +ida_nalt.NSUP_REGVAR + register variables. values NSUP_REGVAR..NSUP_REGVAR+0x1000 are reserved + -ida_nalt.NSUP_REPCMT (variable) +ida_nalt.NSUP_REPCMT repeatable comment -ida_nalt.NSUP_SEGTRANS (variable) +ida_nalt.NSUP_SEGTRANS segment translations -ida_nalt.NSUP_SWITCH (variable) +ida_nalt.NSUP_STROFF0 + stroff: struct path for the first operand + +ida_nalt.NSUP_STROFF1 + stroff: struct path for the second operand + +ida_nalt.NSUP_SWITCH switch information -ida_nalt.NSUP_TYPEINFO (variable) - type information. values NSUP_TYPEINFO..NSUP_TYPEINFO+0x1000 are reserved +ida_nalt.NSUP_TYPEINFO + type information. values NSUP_TYPEINFO..NSUP_TYPEINFO+0x1000 are reserved + -ida_nalt.NSUP_XREFPOS (variable) +ida_nalt.NSUP_XREFPOS saved xref address and type in the xrefs window -ida_nalt.PATCH_TAG (variable) +ida_nalt.PATCH_TAG Patch netnode tag. -ida_nalt.REFINFO_CUSTOM (variable) - a custom reference. see custom_refinfo_handler_t. the id of the custom refinfo - is stored under the REFINFO_TYPE mask. +ida_nalt.REFINFO_CUSTOM + a custom reference. see custom_refinfo_handler_t. the id of the custom refinfo is stored under the REFINFO_TYPE mask. + -ida_nalt.REFINFO_NOBASE (variable) - don't create the base xref; implies that the base can be any value. nb: base - xrefs are created only if the offset base points to the middle of a segment +ida_nalt.REFINFO_NOBASE + don't create the base xref; implies that the base can be any value. nb: base xrefs are created only if the offset base points to the middle of a segment + -ida_nalt.REFINFO_NO_ONES (variable) +ida_nalt.REFINFO_NO_ONES an opval of ~0 will be considered invalid -ida_nalt.REFINFO_NO_ZEROS (variable) +ida_nalt.REFINFO_NO_ZEROS an opval of 0 will be considered invalid -ida_nalt.REFINFO_PASTEND (variable) - reference past an item; it may point to an nonexistent address; do not destroy - alignment dirs +ida_nalt.REFINFO_PASTEND + reference past an item; it may point to an nonexistent address; do not destroy alignment dirs + -ida_nalt.REFINFO_RVAOFF (variable) - based reference (rva); refinfo_t::base will be forced to get_imagebase(); such a - reference is displayed with the asm_t::a_rva keyword +ida_nalt.REFINFO_RVAOFF + based reference (rva); refinfo_t::base will be forced to get_imagebase(); such a reference is displayed with the asm_t::a_rva keyword + -ida_nalt.REFINFO_SELFREF (variable) - the self-based reference; refinfo_t::base will be forced to the reference - address +ida_nalt.REFINFO_SELFREF + the self-based reference; refinfo_t::base will be forced to the reference address + -ida_nalt.REFINFO_SIGNEDOP (variable) +ida_nalt.REFINFO_SIGNEDOP the operand value is sign-extended (only supported for REF_OFF8/16/32/64) -ida_nalt.REFINFO_SUBTRACT (variable) - the reference value is subtracted from the base value instead of (as usual) - being added to it +ida_nalt.REFINFO_SUBTRACT + the reference value is subtracted from the base value instead of (as usual) being added to it -ida_nalt.REFINFO_TYPE (variable) - reference type (reftype_t), or custom reference ID if REFINFO_CUSTOM set +ida_nalt.REFINFO_TYPE + reference type (reftype_t), or custom reference ID if REFINFO_CUSTOM set + -ida_nalt.REF_HIGH16 (variable) +ida_nalt.REF_HIGH16 high 16bits of 32bit offset -ida_nalt.REF_HIGH8 (variable) +ida_nalt.REF_HIGH8 high 8bits of 16bit offset -ida_nalt.REF_LOW16 (variable) +ida_nalt.REF_LOW16 low 16bits of 32bit offset -ida_nalt.REF_LOW8 (variable) +ida_nalt.REF_LOW8 low 8bits of 16bit offset -ida_nalt.REF_OFF16 (variable) +ida_nalt.REF_OFF16 16bit full offset -ida_nalt.REF_OFF32 (variable) +ida_nalt.REF_OFF32 32bit full offset -ida_nalt.REF_OFF64 (variable) +ida_nalt.REF_OFF64 64bit full offset -ida_nalt.REF_OFF8 (variable) +ida_nalt.REF_OFF8 8bit full offset -ida_nalt.RIDX_ABINAME (variable) +ida_nalt.RIDX_ABINAME ABI name (processor specific) -ida_nalt.RIDX_ARCHIVE_PATH (variable) +ida_nalt.RIDX_ARCHIVE_PATH archive file path -ida_nalt.RIDX_C_MACROS (variable) +ida_nalt.RIDX_C_MACROS C predefined macros. -ida_nalt.RIDX_DBG_BINPATHS (variable) +ida_nalt.RIDX_DBG_BINPATHS unused (20 indexes) -ida_nalt.RIDX_DUALOP_GRAPH (variable) +ida_nalt.RIDX_DUALOP_GRAPH Graph text representation options. -ida_nalt.RIDX_DUALOP_TEXT (variable) +ida_nalt.RIDX_DUALOP_TEXT Text text representation options. -ida_nalt.RIDX_FILE_FORMAT_NAME (variable) +ida_nalt.RIDX_FILE_FORMAT_NAME file format name for loader modules -ida_nalt.RIDX_GROUPS (variable) +ida_nalt.RIDX_GROUPS segment group information (see init_groups()) -ida_nalt.RIDX_H_PATH (variable) +ida_nalt.RIDX_H_PATH C header path. -ida_nalt.RIDX_IDA_VERSION (variable) +ida_nalt.RIDX_IDA_VERSION version of ida which created the database -ida_nalt.RIDX_INCLUDE (variable) +ida_nalt.RIDX_INCLUDE assembler include file name -ida_nalt.RIDX_MD5 (variable) +ida_nalt.RIDX_MD5 MD5 of the input file. -ida_nalt.RIDX_NOTEPAD (variable) +ida_nalt.RIDX_NOTEPAD notepad blob, occupies 1000 indexes (1MB of text) -ida_nalt.RIDX_PROBLEMS (variable) +ida_nalt.RIDX_PROBLEMS problem lists -ida_nalt.RIDX_SELECTORS (variable) +ida_nalt.RIDX_SELECTORS 2..63 are for selector_t blob (see init_selectors()) -ida_nalt.RIDX_SHA256 (variable) +ida_nalt.RIDX_SHA256 SHA256 of the input file. -ida_nalt.RIDX_SMALL_IDC (variable) +ida_nalt.RIDX_SMALL_IDC Instant IDC statements, blob. -ida_nalt.RIDX_SMALL_IDC_OLD (variable) +ida_nalt.RIDX_SMALL_IDC_OLD Instant IDC statements (obsolete) -ida_nalt.RIDX_SRCDBG_PATHS (variable) +ida_nalt.RIDX_SRCDBG_PATHS source debug paths, occupies 20 indexes -ida_nalt.RIDX_SRCDBG_UNDESIRED (variable) +ida_nalt.RIDX_SRCDBG_UNDESIRED user-closed source files, occupies 20 indexes -ida_nalt.RIDX_STR_ENCODINGS (variable) +ida_nalt.RIDX_STR_ENCODINGS a list of encodings for the program strings -ida_nalt.STRENC_DEFAULT (variable) +ida_nalt.STRENC_DEFAULT use default encoding for this type (see get_default_encoding_idx()) -ida_nalt.STRENC_NONE (variable) +ida_nalt.STRENC_NONE force no-conversion encoding -ida_nalt.STRTYPE_C (variable) +ida_nalt.STRTYPE_C Zero-terminated 16bit chars. -ida_nalt.STRTYPE_C_16 (variable) +ida_nalt.STRTYPE_C_16 Zero-terminated 32bit chars. -ida_nalt.STRTYPE_C_32 (variable) +ida_nalt.STRTYPE_C_32 Pascal-style, one-byte length prefix. -ida_nalt.STRTYPE_LEN2 (variable) +ida_nalt.STRTYPE_LEN2 Pascal-style, 16bit chars, two-byte length prefix. -ida_nalt.STRTYPE_LEN2_16 (variable) +ida_nalt.STRTYPE_LEN2_16 Pascal-style, 32bit chars, two-byte length prefix. -ida_nalt.STRTYPE_LEN2_32 (variable) +ida_nalt.STRTYPE_LEN2_32 Pascal-style, four-byte length prefix. -ida_nalt.STRTYPE_LEN4 (variable) +ida_nalt.STRTYPE_LEN4 Pascal-style, 16bit chars, four-byte length prefix. -ida_nalt.STRTYPE_LEN4_16 (variable) +ida_nalt.STRTYPE_LEN4_16 Pascal-style, 32bit chars, four-byte length prefix. -ida_nalt.STRTYPE_PASCAL (variable) +ida_nalt.STRTYPE_PASCAL Pascal-style, 16bit chars, one-byte length prefix. -ida_nalt.STRTYPE_PASCAL_16 (variable) +ida_nalt.STRTYPE_PASCAL_16 Pascal-style, 32bit chars, one-byte length prefix. -ida_nalt.STRTYPE_PASCAL_32 (variable) +ida_nalt.STRTYPE_PASCAL_32 Pascal-style, two-byte length prefix. -ida_nalt.STRTYPE_TERMCHR (variable) +ida_nalt.STRTYPE_TERMCHR C-style string. -ida_nalt.SWI_CUSTOM (variable) - custom jump table. processor_t::create_switch_xrefs will be called to create - code xrefs for the table. Custom jump table must be created by the module (see - also SWI_STDTBL) +ida_nalt.SWI_CUSTOM + custom jump table. processor_t::create_switch_xrefs will be called to create code xrefs for the table. Custom jump table must be created by the module (see also SWI_STDTBL) + -ida_nalt.SWI_DEFRET (variable) +ida_nalt.SWI_DEFRET return in the default case (defjump==BADADDR) -ida_nalt.SWI_DEF_IN_TBL (variable) +ida_nalt.SWI_DEF_IN_TBL default case is an entry in the jump table. This flag is applicable in 2 cases: - * The sparse indirect switch (i.e. a switch with a values table) {jump table - size} == {value table size} + 1. The default case entry is the last one in the - table (or the first one in the case of an inversed jump table). - * The switch with insns in the jump table. The default case entry is before the - first entry of the table. - See also the find_defjump_from_table() helper function. + * The sparse indirect switch (i.e. a switch with a values table) {jump table size} == {value table size} + 1. The default case entry is the last one in the table (or the first one in the case of an inversed jump table). + * The switch with insns in the jump table. The default case entry is before the first entry of the table. + See also the find_defjump_from_table() helper function. + + + -ida_nalt.SWI_ELBASE (variable) - elbase is present (otherwise the base of the switch segment will be used) +ida_nalt.SWI_ELBASE + elbase is present (otherwise the base of the switch segment will be used) + -ida_nalt.SWI_HXNOLOWCASE (variable) +ida_nalt.SWI_HXNOLOWCASE lowcase value should not be used by the decompiler (internal flag) -ida_nalt.SWI_INDIRECT (variable) - value table elements are used as indexes into the jump table (for sparse - switches) +ida_nalt.SWI_INDIRECT + value table elements are used as indexes into the jump table (for sparse switches) + -ida_nalt.SWI_J32 (variable) +ida_nalt.SWI_J32 32-bit jump offsets -ida_nalt.SWI_JMPINSN (variable) - jump table entries are insns. For such entries SHIFT has a different meaning. It - denotes the number of insns in the entry. For example, 0 - the entry contains - the jump to the case, 1 - the entry contains one insn like a 'mov' and jump to - the end of case, and so on. +ida_nalt.SWI_JMPINSN + jump table entries are insns. For such entries SHIFT has a different meaning. It denotes the number of insns in the entry. For example, 0 - the entry contains the jump to the case, 1 - the entry contains one insn like a 'mov' and jump to the end of case, and so on. + -ida_nalt.SWI_JMP_INV (variable) - jumptable is inversed. (last entry is for first entry in values table) +ida_nalt.SWI_JMP_INV + jumptable is inversed. (last entry is for first entry in values table) + -ida_nalt.SWI_JSIZE (variable) +ida_nalt.SWI_JSIZE jump offset expansion bit -ida_nalt.SWI_SELFREL (variable) +ida_nalt.SWI_SELFREL jump address is relative to the element not to ELBASE -ida_nalt.SWI_SEPARATE (variable) +ida_nalt.SWI_SEPARATE create an array of individual elements (otherwise separate items) -ida_nalt.SWI_SHIFT_MASK (variable) +ida_nalt.SWI_SHIFT_MASK use formula (element<<shift) + elbase to find jump targets -ida_nalt.SWI_SIGNED (variable) +ida_nalt.SWI_SIGNED jump table entries are signed -ida_nalt.SWI_SPARSE (variable) - sparse switch (value table present), otherwise lowcase present +ida_nalt.SWI_SPARSE + sparse switch (value table present), otherwise lowcase present + -ida_nalt.SWI_STDTBL (variable) - custom jump table with standard table formatting. ATM IDA doesn't use SWI_CUSTOM - for switches with standard table formatting. So this flag can be considered as - obsolete. +ida_nalt.SWI_STDTBL + custom jump table with standard table formatting. ATM IDA doesn't use SWI_CUSTOM for switches with standard table formatting. So this flag can be considered as obsolete. + -ida_nalt.SWI_SUBTRACT (variable) +ida_nalt.SWI_SUBTRACT table values are subtracted from the elbase instead of being added -ida_nalt.SWI_USER (variable) +ida_nalt.SWI_USER user specified switch (starting from version 2) -ida_nalt.SWI_V32 (variable) +ida_nalt.SWI_V32 32-bit values in table -ida_nalt.SWI_VERSION (variable) +ida_nalt.SWI_VERSION the structure contains the VERSION member -ida_nalt.SWI_VSIZE (variable) +ida_nalt.SWI_VSIZE value table element size expansion bit -ida_nalt.SWI_VSPLIT (variable) +ida_nalt.SWI_VSPLIT value table is split (only for 32-bit values) -ida_nalt.V695_REF_OFF8 (variable) +ida_nalt.V695_REF_OFF8 reserved -ida_nalt.V695_REF_VHIGH (variable) +ida_nalt.V695_REF_VHIGH obsolete -ida_nalt.V695_REF_VLOW (variable) +ida_nalt.V695_REF_VLOW obsolete -ida_nalt.add_encoding (function) - add_encoding(encname) -> int - Add a new encoding (e.g. "UTF-8"). If it's already in the list, return its - index. - - @param encname: (C++: const char *) the encoding name - @return: its index (1-based); -1 means error +ida_nalt.add_encoding(encname: str) -> int -ida_nalt.array_parameters_t (class) - Proxy of C++ array_parameters_t class. +ida_nalt.array_parameters_t -ida_nalt.array_parameters_t.__init__ (method) - __init__(self, _f=0x00000001, _l=0, _a=-1) -> array_parameters_t - - @param _f: int32 - @param _l: int32 - @param _a: int32 +ida_nalt.array_parameters_t.__init__(self, _f: int = 1, _l: int = 0, _a: int = -1) -ida_nalt.array_parameters_t.alignment (variable) - -1 - don't align. 0 - align automatically. else item width +ida_nalt.array_parameters_t.alignment + -1 - don't align. 0 - align automatically. else item width + -ida_nalt.array_parameters_t.is_default (method) - is_default(self) -> bool +ida_nalt.array_parameters_t.is_default(self) -> bool -ida_nalt.array_parameters_t.lineitems (variable) +ida_nalt.array_parameters_t.lineitems number of items on a line -ida_nalt.clr__bnot0 (function) - clr__bnot0(ea) - - @param ea: ea_t +ida_nalt.clr__bnot0(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr__bnot1 (function) - clr__bnot1(ea) - - @param ea: ea_t +ida_nalt.clr__bnot1(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr__invsign0 (function) - clr__invsign0(ea) - - @param ea: ea_t +ida_nalt.clr__invsign0(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr__invsign1 (function) - clr__invsign1(ea) - - @param ea: ea_t +ida_nalt.clr__invsign1(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_abits (function) - clr_abits(ea, bits) - - @param ea: ea_t - @param bits: aflags_t +ida_nalt.clr_abits(ea: ida_idaapi.ea_t, bits: "aflags_t") -> None -ida_nalt.clr_align_flow (function) - clr_align_flow(ea) - - @param ea: ea_t +ida_nalt.clr_align_flow(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_colored_item (function) - clr_colored_item(ea) - - @param ea: ea_t +ida_nalt.clr_colored_item(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_fixed_spd (function) - clr_fixed_spd(ea) - - @param ea: ea_t +ida_nalt.clr_fixed_spd(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_has_lname (function) - clr_has_lname(ea) - - @param ea: ea_t +ida_nalt.clr_has_lname(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_has_ti (function) - clr_has_ti(ea) - - @param ea: ea_t +ida_nalt.clr_has_ti(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_has_ti0 (function) - clr_has_ti0(ea) - - @param ea: ea_t +ida_nalt.clr_has_ti0(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_has_ti1 (function) - clr_has_ti1(ea) - - @param ea: ea_t +ida_nalt.clr_has_ti1(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_libitem (function) - clr_libitem(ea) - - @param ea: ea_t +ida_nalt.clr_libitem(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_lzero0 (function) - clr_lzero0(ea) - - @param ea: ea_t +ida_nalt.clr_lzero0(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_lzero1 (function) - clr_lzero1(ea) - - @param ea: ea_t +ida_nalt.clr_lzero1(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_noret (function) - clr_noret(ea) - - @param ea: ea_t +ida_nalt.clr_noret(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_notcode (function) - clr_notcode(ea) +ida_nalt.clr_notcode(ea: ida_idaapi.ea_t) -> None Clear not-code mark. - - @param ea: (C++: ea_t) -ida_nalt.clr_notproc (function) - clr_notproc(ea) - - @param ea: ea_t +ida_nalt.clr_notproc(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_retfp (function) - clr_retfp(ea) - - @param ea: ea_t +ida_nalt.clr_retfp(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_terse_struc (function) - clr_terse_struc(ea) - - @param ea: ea_t +ida_nalt.clr_terse_struc(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_tilcmt (function) - clr_tilcmt(ea) - - @param ea: ea_t +ida_nalt.clr_tilcmt(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_usemodsp (function) - clr_usemodsp(ea) - - @param ea: ea_t +ida_nalt.clr_usemodsp(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_usersp (function) - clr_usersp(ea) - - @param ea: ea_t +ida_nalt.clr_usersp(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_userti (function) - clr_userti(ea) - - @param ea: ea_t +ida_nalt.clr_userti(ea: ida_idaapi.ea_t) -> None -ida_nalt.clr_zstroff (function) - clr_zstroff(ea) - - @param ea: ea_t +ida_nalt.clr_zstroff(ea: ida_idaapi.ea_t) -> None -ida_nalt.custom_data_type_ids_fids_array (class) - Proxy of C++ wrapped_array_t< int16,8 > class. +ida_nalt.custom_data_type_ids_fids_array -ida_nalt.custom_data_type_ids_fids_array.__getitem__ (method) - __getitem__(self, i) -> short const & - - @param i: size_t +ida_nalt.custom_data_type_ids_fids_array.__getitem__(self, i: "size_t") -> "short const &" -ida_nalt.custom_data_type_ids_fids_array.__init__ (method) - __init__(self, data) -> custom_data_type_ids_fids_array - - @param data: short (&)[8] +ida_nalt.custom_data_type_ids_fids_array.__init__(self, data: "short (&)[8]") -ida_nalt.custom_data_type_ids_fids_array.__len__ (method) - __len__(self) -> size_t +ida_nalt.custom_data_type_ids_fids_array.__len__(self) -> "size_t" -ida_nalt.custom_data_type_ids_fids_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: short const & +ida_nalt.custom_data_type_ids_fids_array.__setitem__(self, i: "size_t", v: "short const &") -> None -ida_nalt.custom_data_type_ids_fids_array._get_bytes (method) - _get_bytes(self) -> bytevec_t +ida_nalt.custom_data_type_ids_fids_array._get_bytes(self) -> "bytevec_t" -ida_nalt.custom_data_type_ids_fids_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & +ida_nalt.custom_data_type_ids_fids_array._set_bytes(self, bts: "bytevec_t const &") -> None -ida_nalt.custom_data_type_ids_t (class) - Proxy of C++ custom_data_type_ids_t class. +ida_nalt.custom_data_type_ids_t -ida_nalt.custom_data_type_ids_t.__getFids (method) - __getFids(self) -> custom_data_type_ids_fids_array +ida_nalt.custom_data_type_ids_t.__getFids(self) -> "wrapped_array_t< int16,8 >" -ida_nalt.custom_data_type_ids_t.__init__ (method) - __init__(self) -> custom_data_type_ids_t +ida_nalt.custom_data_type_ids_t.__init__(self) -ida_nalt.custom_data_type_ids_t.dtid (variable) +ida_nalt.custom_data_type_ids_t.dtid data type id -ida_nalt.custom_data_type_ids_t.fids (variable) +ida_nalt.custom_data_type_ids_t.fids data format ids -ida_nalt.custom_data_type_ids_t.get_dtid (method) - get_dtid(self) -> tid_t +ida_nalt.custom_data_type_ids_t.fids + data format ids -ida_nalt.custom_data_type_ids_t.set (method) - set(self, tid) - - @param tid: tid_t +ida_nalt.custom_data_type_ids_t.get_dtid(self) -> "tid_t" -ida_nalt.dbg_get_input_path (function) - dbg_get_input_path() -> str +ida_nalt.custom_data_type_ids_t.set(self, tid: "tid_t") -> None + +ida_nalt.dbg_get_input_path() -> str Get debugger input file name/path (see LFLG_DBG_NOPATH) -ida_nalt.del_absbase (function) - del_absbase(ea) - - @param ea: ea_t +ida_nalt.del_absbase(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_aflags (function) - del_aflags(ea) - - @param ea: ea_t +ida_nalt.del_aflags(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_alignment (function) - del_alignment(ea) - - @param ea: ea_t +ida_nalt.del_alignment(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_array_parameters (function) - del_array_parameters(ea) - - @param ea: ea_t +ida_nalt.del_array_parameters(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_custom_data_type_ids (function) - del_custom_data_type_ids(ea) - - @param ea: ea_t +ida_nalt.del_custom_data_type_ids(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_encoding (function) - del_encoding(idx) -> bool - Delete an encoding The encoding is not actually removed because its index may be - used in strtype. So the deletion just clears the encoding name. The default - encoding cannot be deleted. - - @param idx: (C++: int) the encoding index (1-based) +ida_nalt.del_encoding(idx: int) -> bool -ida_nalt.del_ind_purged (function) - del_ind_purged(ea) - - @param ea: ea_t +ida_nalt.del_ind_purged(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_item_color (function) - del_item_color(ea) -> bool - - @param ea: ea_t +ida_nalt.del_item_color(ea: ida_idaapi.ea_t) -> bool -ida_nalt.del_op_tinfo (function) - del_op_tinfo(ea, n) - - @param ea: ea_t - @param n: int +ida_nalt.del_op_tinfo(ea: ida_idaapi.ea_t, n: int) -> None -ida_nalt.del_refinfo (function) - del_refinfo(ea, n) -> bool - - @param ea: ea_t - @param n: int +ida_nalt.del_refinfo(ea: ida_idaapi.ea_t, n: int) -> bool -ida_nalt.del_source_linnum (function) - del_source_linnum(ea) - - @param ea: ea_t +ida_nalt.del_source_linnum(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_str_type (function) - del_str_type(ea) - - @param ea: ea_t +ida_nalt.del_str_type(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_switch_info (function) - del_switch_info(ea) - - @param ea: ea_t +ida_nalt.del_switch_info(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_switch_parent (function) - del_switch_parent(ea) - - @param ea: ea_t +ida_nalt.del_switch_parent(ea: ida_idaapi.ea_t) -> None -ida_nalt.del_tinfo (function) - del_tinfo(ea) - - @param ea: ea_t +ida_nalt.del_tinfo(ea: ida_idaapi.ea_t) -> None -ida_nalt.delete_imports (function) - delete_imports() - Delete all imported modules information. +ida_nalt.delete_imports() -> None -ida_nalt.ea2node (function) - ea2node(ea) -> nodeidx_t +ida_nalt.ea2node(ea: ida_idaapi.ea_t) -> "nodeidx_t" Get netnode for the specified address. - - @param ea: (C++: ea_t) -ida_nalt.encoding_from_strtype (function) - encoding_from_strtype(strtype) -> char const * - Get encoding name for this strtype - @retval nullptr: if STRTYPE has an incorrent encoding index - @retval empty: string if the encoding was deleted - - @param strtype: (C++: int32) +ida_nalt.encoding_from_strtype(strtype: int) -> str -ida_nalt.end_ea2node (function) - end_ea2node(ea) -> nodeidx_t - - @param ea: ea_t +ida_nalt.end_ea2node(ea: ida_idaapi.ea_t) -> "nodeidx_t" -ida_nalt.enum_const_t (class) - Proxy of C++ enum_const_t class. +ida_nalt.enum_const_t -ida_nalt.enum_const_t.__init__ (method) - __init__(self) -> enum_const_t +ida_nalt.enum_const_t.__init__(self) -ida_nalt.enum_import_names (function) - enum_import_names(mod_index, py_cb) -> int +ida_nalt.enum_import_names(mod_index, callback) Enumerate imports from a specific module. - Please refer to ex_imports.py example. + Please refer to list_imports.py example. @param mod_index: The module index @param callback: A callable object that will be invoked with an ea, name (could be None) and ordinal. @return: 1-finished ok, -1 on error, otherwise callback return value (<=0) -ida_nalt.find_custom_refinfo (function) - find_custom_refinfo(name) -> int +ida_nalt.find_custom_refinfo(name: str) -> int Get id of a custom refinfo type. - - @param name: (C++: const char *) char const * -ida_nalt.get_abi_name (function) +ida_nalt.get_abi_name() -ida_nalt.get_absbase (function) - get_absbase(ea) -> ea_t - - @param ea: ea_t +ida_nalt.get_absbase(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_nalt.get_aflags (function) - get_aflags(ea) -> aflags_t - - @param ea: ea_t +ida_nalt.get_aflags(ea: ida_idaapi.ea_t) -> "aflags_t" -ida_nalt.get_alignment (function) - get_alignment(ea) -> uint32 - - @param ea: ea_t +ida_nalt.get_alignment(ea: ida_idaapi.ea_t) -> int -ida_nalt.get_archive_path (function) - get_archive_path() -> str +ida_nalt.get_archive_path() -> str Get archive file path from which input file was extracted. -ida_nalt.get_array_parameters (function) - get_array_parameters(out, ea) -> ssize_t - - @param out: array_parameters_t * - @param ea: ea_t +ida_nalt.get_array_parameters(out: "array_parameters_t", ea: ida_idaapi.ea_t) -> "ssize_t" -ida_nalt.get_asm_inc_file (function) - get_asm_inc_file() -> str +ida_nalt.get_asm_inc_file() -> str Get name of the include file. -ida_nalt.get_custom_data_type_ids (function) - get_custom_data_type_ids(cdis, ea) -> int - - @param cdis: custom_data_type_ids_t * - @param ea: ea_t +ida_nalt.get_custom_data_type_ids(cdis: "custom_data_type_ids_t", ea: ida_idaapi.ea_t) -> int -ida_nalt.get_custom_refinfo (function) - get_custom_refinfo(crid) -> custom_refinfo_handler_t const * +ida_nalt.get_custom_refinfo(crid: int) -> "custom_refinfo_handler_t const *" Get definition of a registered custom refinfo type. - - @param crid: (C++: int) -ida_nalt.get_default_encoding_idx (function) - get_default_encoding_idx(bpu) -> int - Get default encoding index for a specific string type. - - @param bpu: (C++: int) the amount of bytes per unit (e.g., 1 for ASCII, CP1252, UTF-8..., 2 - for UTF-16, 4 for UTF-32) - @retval 0: bad BPU argument +ida_nalt.get_default_encoding_idx(bpu: int) -> int -ida_nalt.get_elapsed_secs (function) - get_elapsed_secs() -> size_t +ida_nalt.get_elapsed_secs() -> "size_t" Get seconds database stayed open. -ida_nalt.get_encoding_bpu (function) - get_encoding_bpu(idx) -> int - Get the amount of bytes per unit (e.g., 2 for UTF-16, 4 for UTF-32) for the - encoding with the given index. - - @param idx: (C++: int) the encoding index (1-based) - @return: the number of bytes per units (1/2/4); -1 means error +ida_nalt.get_encoding_bpu(idx: int) -> int -ida_nalt.get_encoding_bpu_by_name (function) - get_encoding_bpu_by_name(encname) -> int - Get the amount of bytes per unit for the given encoding - - @param encname: (C++: const char *) the encoding name - @return: the number of bytes per units (1/2/4); -1 means error +ida_nalt.get_encoding_bpu_by_name(encname: str) -> int -ida_nalt.get_encoding_name (function) - get_encoding_name(idx) -> char const * - Get encoding name for specific index (1-based). - - @param idx: (C++: int) the encoding index (1-based) - @retval nullptr: if IDX is out of bounds - @retval empty: string if the encoding was deleted +ida_nalt.get_encoding_name(idx: int) -> str -ida_nalt.get_encoding_qty (function) - get_encoding_qty() -> int - Get total number of encodings (counted from 0) +ida_nalt.get_encoding_qty() -> int -ida_nalt.get_gotea (function) - get_gotea() -> ea_t +ida_nalt.get_gotea() -> ida_idaapi.ea_t -ida_nalt.get_ida_notepad_text (function) - get_ida_notepad_text() -> str +ida_nalt.get_ida_notepad_text() -> str Get notepad text. -ida_nalt.get_idb_ctime (function) - get_idb_ctime() -> time_t +ida_nalt.get_idb_ctime() -> "time_t" Get database creation timestamp. -ida_nalt.get_idb_nopens (function) - get_idb_nopens() -> size_t +ida_nalt.get_idb_nopens() -> "size_t" Get number of times the database is opened. -ida_nalt.get_ids_modnode (function) - get_ids_modnode() -> netnode +ida_nalt.get_ids_modnode() -> "netnode" Get ids modnode. -ida_nalt.get_imagebase (function) - get_imagebase() -> ea_t +ida_nalt.get_imagebase() -> ida_idaapi.ea_t Get image base address. -ida_nalt.get_import_module_name (function) - get_import_module_name(mod_index) -> str +ida_nalt.get_import_module_name(mod_index) Returns the name of an imported module given its index - @param mod_index: int + @param mod_index: the module index @return: None or the module name -ida_nalt.get_import_module_qty (function) - get_import_module_qty() -> uint - Get number of import modules. +ida_nalt.get_import_module_qty() -> "uint" -ida_nalt.get_ind_purged (function) - get_ind_purged(ea) -> ea_t - - @param ea: ea_t +ida_nalt.get_ind_purged(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_nalt.get_initial_ida_version (function) - get_initial_ida_version() -> str +ida_nalt.get_initial_ida_version() -> str Get version of ida which created the database (string format like "7.5") -ida_nalt.get_initial_idb_version (function) - get_initial_idb_version() -> ushort +ida_nalt.get_initial_idb_version() -> "ushort" Get initial version of the database (numeric format like 700) -ida_nalt.get_input_file_path (function) - get_input_file_path() -> str +ida_nalt.get_input_file_path() -> str Get full path of the input file. -ida_nalt.get_item_color (function) - get_item_color(ea) -> bgcolor_t - - @param ea: ea_t +ida_nalt.get_item_color(ea: ida_idaapi.ea_t) -> "bgcolor_t" -ida_nalt.get_loader_format_name (function) - get_loader_format_name() -> str +ida_nalt.get_loader_format_name() -> str Get file format name for loader modules. -ida_nalt.get_op_tinfo (function) - get_op_tinfo(tif, ea, n) -> bool - - @param tif: tinfo_t * - @param ea: ea_t - @param n: int +ida_nalt.get_op_tinfo(tif: "tinfo_t", ea: ida_idaapi.ea_t, n: int) -> bool -ida_nalt.get_outfile_encoding_idx (function) - get_outfile_encoding_idx() -> int - Get the index of the encoding used when producing files - @retval 0: the IDB's default 1 byte-per-unit encoding is used +ida_nalt.get_outfile_encoding_idx() -> int -ida_nalt.get_refinfo (function) - get_refinfo(ri, ea, n) -> bool - - @param ri: refinfo_t * - @param ea: ea_t - @param n: int +ida_nalt.get_refinfo(ri: "refinfo_t", ea: ida_idaapi.ea_t, n: int) -> bool -ida_nalt.get_reftype_by_size (function) - get_reftype_by_size(size) -> reftype_t - Get REF_... constant from size Supported sizes: 1,2,4,8,16 For other sizes - returns reftype_t(-1) - - @param size: (C++: size_t) +ida_nalt.get_reftype_by_size(size: "size_t") -> "reftype_t" + Get REF_... constant from size Supported sizes: 1,2,4,8,16 For other sizes returns reftype_t(-1) + -ida_nalt.get_root_filename (function) - get_root_filename() -> str +ida_nalt.get_root_filename() -> str Get file name only of the input file. -ida_nalt.get_source_linnum (function) - get_source_linnum(ea) -> uval_t - - @param ea: ea_t +ida_nalt.get_source_linnum(ea: ida_idaapi.ea_t) -> int -ida_nalt.get_srcdbg_paths (function) - get_srcdbg_paths() -> str +ida_nalt.get_srcdbg_paths() -> str Get source debug paths. -ida_nalt.get_srcdbg_undesired_paths (function) - get_srcdbg_undesired_paths() -> str +ida_nalt.get_srcdbg_undesired_paths() -> str Get user-closed source files. -ida_nalt.get_str_encoding_idx (function) - get_str_encoding_idx(strtype) -> uchar - Get index of the string encoding for this string. - - @param strtype: (C++: int32) +ida_nalt.get_str_encoding_idx(strtype: int) -> "uchar" -ida_nalt.get_str_term1 (function) - get_str_term1(strtype) -> char - - @param strtype: int32 +ida_nalt.get_str_term1(strtype: int) -> "char" -ida_nalt.get_str_term2 (function) - get_str_term2(strtype) -> char - - @param strtype: int32 +ida_nalt.get_str_term2(strtype: int) -> "char" -ida_nalt.get_str_type (function) - get_str_type(ea) -> uint32 - - @param ea: ea_t +ida_nalt.get_str_type(ea: ida_idaapi.ea_t) -> int -ida_nalt.get_str_type_code (function) - get_str_type_code(strtype) -> uchar - - @param strtype: int32 +ida_nalt.get_str_type_code(strtype: int) -> "uchar" -ida_nalt.get_str_type_prefix_length (function) - get_str_type_prefix_length(strtype) -> size_t - - @param strtype: int32 +ida_nalt.get_str_type_prefix_length(strtype: int) -> "size_t" -ida_nalt.get_strid (function) - get_strid(ea) -> tid_t - - @param ea: ea_t +ida_nalt.get_strid(ea: ida_idaapi.ea_t) -> "tid_t" -ida_nalt.get_strtype_bpu (function) - get_strtype_bpu(strtype) -> int - - @param strtype: int32 +ida_nalt.get_strtype_bpu(strtype: int) -> int -ida_nalt.get_switch_info (function) - get_switch_info(out, ea) -> ssize_t - - @param out: switch_info_t * - @param ea: ea_t +ida_nalt.get_switch_info(out: "switch_info_t", ea: ida_idaapi.ea_t) -> "ssize_t" -ida_nalt.get_switch_info (function) +ida_nalt.get_switch_info(*args) -ida_nalt.get_switch_parent (function) - get_switch_parent(ea) -> ea_t - - @param ea: ea_t +ida_nalt.get_switch_parent(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_nalt.get_tinfo (function) - get_tinfo(tif, ea) -> bool - - @param tif: tinfo_t * - @param ea: ea_t +ida_nalt.get_tinfo(tif: "tinfo_t", ea: ida_idaapi.ea_t) -> bool -ida_nalt.getnode (function) - getnode(ea) -> netnode - - @param ea: ea_t +ida_nalt.getnode(ea: ida_idaapi.ea_t) -> "netnode" -ida_nalt.has_aflag_linnum (function) - has_aflag_linnum(flags) -> bool - - @param flags: aflags_t +ida_nalt.has_aflag_linnum(flags: "aflags_t") -> bool -ida_nalt.has_aflag_lname (function) - has_aflag_lname(flags) -> bool - - @param flags: aflags_t +ida_nalt.has_aflag_lname(flags: "aflags_t") -> bool -ida_nalt.has_aflag_ti (function) - has_aflag_ti(flags) -> bool - - @param flags: aflags_t +ida_nalt.has_aflag_ti(flags: "aflags_t") -> bool -ida_nalt.has_aflag_ti0 (function) - has_aflag_ti0(flags) -> bool - - @param flags: aflags_t +ida_nalt.has_aflag_ti0(flags: "aflags_t") -> bool -ida_nalt.has_aflag_ti1 (function) - has_aflag_ti1(flags) -> bool - - @param flags: aflags_t +ida_nalt.has_aflag_ti1(flags: "aflags_t") -> bool -ida_nalt.has_lname (function) - has_lname(ea) -> bool - - @param ea: ea_t +ida_nalt.has_lname(ea: ida_idaapi.ea_t) -> bool -ida_nalt.has_ti (function) - has_ti(ea) -> bool - - @param ea: ea_t +ida_nalt.has_ti(ea: ida_idaapi.ea_t) -> bool -ida_nalt.has_ti0 (function) - has_ti0(ea) -> bool - - @param ea: ea_t +ida_nalt.has_ti0(ea: ida_idaapi.ea_t) -> bool -ida_nalt.has_ti1 (function) - has_ti1(ea) -> bool - - @param ea: ea_t +ida_nalt.has_ti1(ea: ida_idaapi.ea_t) -> bool -ida_nalt.hide_border (function) - hide_border(ea) - - @param ea: ea_t +ida_nalt.hide_border(ea: ida_idaapi.ea_t) -> None -ida_nalt.hide_item (function) - hide_item(ea) - - @param ea: ea_t +ida_nalt.hide_item(ea: ida_idaapi.ea_t) -> None -ida_nalt.is__bnot0 (function) - is__bnot0(ea) -> bool - - @param ea: ea_t +ida_nalt.is__bnot0(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is__bnot1 (function) - is__bnot1(ea) -> bool - - @param ea: ea_t +ida_nalt.is__bnot1(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is__invsign0 (function) - is__invsign0(ea) -> bool - - @param ea: ea_t +ida_nalt.is__invsign0(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is__invsign1 (function) - is__invsign1(ea) -> bool - - @param ea: ea_t +ida_nalt.is__invsign1(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_aflag__bnot0 (function) - is_aflag__bnot0(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag__bnot0(flags: "aflags_t") -> bool -ida_nalt.is_aflag__bnot1 (function) - is_aflag__bnot1(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag__bnot1(flags: "aflags_t") -> bool -ida_nalt.is_aflag__invsign0 (function) - is_aflag__invsign0(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag__invsign0(flags: "aflags_t") -> bool -ida_nalt.is_aflag__invsign1 (function) - is_aflag__invsign1(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag__invsign1(flags: "aflags_t") -> bool -ida_nalt.is_aflag_align_flow (function) - is_aflag_align_flow(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_align_flow(flags: "aflags_t") -> bool -ida_nalt.is_aflag_colored_item (function) - is_aflag_colored_item(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_colored_item(flags: "aflags_t") -> bool -ida_nalt.is_aflag_data_guessed_by_hexrays (function) - is_aflag_data_guessed_by_hexrays(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_data_guessed_by_hexrays(flags: "aflags_t") -> bool -ida_nalt.is_aflag_fixed_spd (function) - is_aflag_fixed_spd(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_fixed_spd(flags: "aflags_t") -> bool -ida_nalt.is_aflag_func_guessed_by_hexrays (function) - is_aflag_func_guessed_by_hexrays(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_func_guessed_by_hexrays(flags: "aflags_t") -> bool -ida_nalt.is_aflag_hidden_border (function) - is_aflag_hidden_border(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_hidden_border(flags: "aflags_t") -> bool -ida_nalt.is_aflag_hidden_item (function) - is_aflag_hidden_item(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_hidden_item(flags: "aflags_t") -> bool -ida_nalt.is_aflag_libitem (function) - is_aflag_libitem(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_libitem(flags: "aflags_t") -> bool -ida_nalt.is_aflag_lzero0 (function) - is_aflag_lzero0(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_lzero0(flags: "aflags_t") -> bool -ida_nalt.is_aflag_lzero1 (function) - is_aflag_lzero1(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_lzero1(flags: "aflags_t") -> bool -ida_nalt.is_aflag_manual_insn (function) - is_aflag_manual_insn(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_manual_insn(flags: "aflags_t") -> bool -ida_nalt.is_aflag_noret (function) - is_aflag_noret(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_noret(flags: "aflags_t") -> bool -ida_nalt.is_aflag_notcode (function) - is_aflag_notcode(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_notcode(flags: "aflags_t") -> bool -ida_nalt.is_aflag_notproc (function) - is_aflag_notproc(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_notproc(flags: "aflags_t") -> bool -ida_nalt.is_aflag_public_name (function) - is_aflag_public_name(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_public_name(flags: "aflags_t") -> bool -ida_nalt.is_aflag_retfp (function) - is_aflag_retfp(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_retfp(flags: "aflags_t") -> bool -ida_nalt.is_aflag_terse_struc (function) - is_aflag_terse_struc(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_terse_struc(flags: "aflags_t") -> bool -ida_nalt.is_aflag_tilcmt (function) - is_aflag_tilcmt(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_tilcmt(flags: "aflags_t") -> bool -ida_nalt.is_aflag_type_determined_by_hexrays (function) - is_aflag_type_determined_by_hexrays(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_type_determined_by_hexrays(flags: "aflags_t") -> bool -ida_nalt.is_aflag_type_guessed_by_hexrays (function) - is_aflag_type_guessed_by_hexrays(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_type_guessed_by_hexrays(flags: "aflags_t") -> bool -ida_nalt.is_aflag_type_guessed_by_ida (function) - is_aflag_type_guessed_by_ida(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_type_guessed_by_ida(flags: "aflags_t") -> bool -ida_nalt.is_aflag_usersp (function) - is_aflag_usersp(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_usersp(flags: "aflags_t") -> bool -ida_nalt.is_aflag_userti (function) - is_aflag_userti(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_userti(flags: "aflags_t") -> bool -ida_nalt.is_aflag_weak_name (function) - is_aflag_weak_name(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_weak_name(flags: "aflags_t") -> bool -ida_nalt.is_aflag_zstroff (function) - is_aflag_zstroff(flags) -> bool - - @param flags: aflags_t +ida_nalt.is_aflag_zstroff(flags: "aflags_t") -> bool -ida_nalt.is_align_flow (function) - is_align_flow(ea) -> bool - - @param ea: ea_t +ida_nalt.is_align_flow(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_colored_item (function) - is_colored_item(ea) -> bool - - @param ea: ea_t +ida_nalt.is_colored_item(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_data_guessed_by_hexrays (function) - is_data_guessed_by_hexrays(ea) -> bool - - @param ea: ea_t +ida_nalt.is_data_guessed_by_hexrays(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_finally_visible_item (function) - is_finally_visible_item(ea) -> bool +ida_nalt.is_finally_visible_item(ea: ida_idaapi.ea_t) -> bool Is instruction visible? - - @param ea: (C++: ea_t) -ida_nalt.is_fixed_spd (function) - is_fixed_spd(ea) -> bool - - @param ea: ea_t +ida_nalt.is_fixed_spd(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_func_guessed_by_hexrays (function) - is_func_guessed_by_hexrays(ea) -> bool - - @param ea: ea_t +ida_nalt.is_func_guessed_by_hexrays(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_hidden_border (function) - is_hidden_border(ea) -> bool - - @param ea: ea_t +ida_nalt.is_hidden_border(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_hidden_item (function) - is_hidden_item(ea) -> bool - - @param ea: ea_t +ida_nalt.is_hidden_item(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_libitem (function) - is_libitem(ea) -> bool - - @param ea: ea_t +ida_nalt.is_libitem(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_lzero0 (function) - is_lzero0(ea) -> bool - - @param ea: ea_t +ida_nalt.is_lzero0(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_lzero1 (function) - is_lzero1(ea) -> bool - - @param ea: ea_t +ida_nalt.is_lzero1(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_noret (function) - is_noret(ea) -> bool - - @param ea: ea_t +ida_nalt.is_noret(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_notcode (function) - is_notcode(ea) -> bool +ida_nalt.is_notcode(ea: ida_idaapi.ea_t) -> bool Is the address marked as not-code? - - @param ea: (C++: ea_t) -ida_nalt.is_notproc (function) - is_notproc(ea) -> bool - - @param ea: ea_t +ida_nalt.is_notproc(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_pascal (function) - is_pascal(strtype) -> bool - - @param strtype: int32 +ida_nalt.is_pascal(strtype: int) -> bool -ida_nalt.is_reftype_target_optional (function) - is_reftype_target_optional(type) -> bool +ida_nalt.is_reftype_target_optional(type: "reftype_t") -> bool Can the target be calculated using operand value? - - @param type: (C++: reftype_t) -ida_nalt.is_retfp (function) - is_retfp(ea) -> bool - - @param ea: ea_t +ida_nalt.is_retfp(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_terse_struc (function) - is_terse_struc(ea) -> bool - - @param ea: ea_t +ida_nalt.is_terse_struc(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_tilcmt (function) - is_tilcmt(ea) -> bool - - @param ea: ea_t +ida_nalt.is_tilcmt(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_type_determined_by_hexrays (function) - is_type_determined_by_hexrays(ea) -> bool - - @param ea: ea_t +ida_nalt.is_type_determined_by_hexrays(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_type_guessed_by_hexrays (function) - is_type_guessed_by_hexrays(ea) -> bool - - @param ea: ea_t +ida_nalt.is_type_guessed_by_hexrays(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_type_guessed_by_ida (function) - is_type_guessed_by_ida(ea) -> bool - - @param ea: ea_t +ida_nalt.is_type_guessed_by_ida(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_usersp (function) - is_usersp(ea) -> bool - - @param ea: ea_t +ida_nalt.is_usersp(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_userti (function) - is_userti(ea) -> bool - - @param ea: ea_t +ida_nalt.is_userti(ea: ida_idaapi.ea_t) -> bool -ida_nalt.is_visible_item (function) - is_visible_item(ea) -> bool +ida_nalt.is_visible_item(ea: ida_idaapi.ea_t) -> bool Test visibility of item at given ea. - - @param ea: (C++: ea_t) -ida_nalt.is_zstroff (function) - is_zstroff(ea) -> bool - - @param ea: ea_t +ida_nalt.is_zstroff(ea: ida_idaapi.ea_t) -> bool -ida_nalt.make_str_type (function) - make_str_type(type_code, encoding_idx, term1=0, term2=0) -> int32 - Get string type for a string in the given encoding. - - @param type_code: (C++: uchar) - @param encoding_idx: (C++: int) - @param term1: (C++: uchar) - @param term2: (C++: uchar) +ida_nalt.make_str_type(type_code: "uchar", encoding_idx: int, term1: "uchar" = 0, term2: "uchar" = 0) -> int -ida_nalt.node2ea (function) - node2ea(ndx) -> ea_t - - @param ndx: nodeidx_t +ida_nalt.node2ea(ndx: "nodeidx_t") -> ida_idaapi.ea_t -ida_nalt.opinfo_t (class) - Proxy of C++ opinfo_t class. +ida_nalt.opinfo_t -ida_nalt.opinfo_t.__init__ (method) - __init__(self) -> opinfo_t +ida_nalt.opinfo_t.__init__(self) -ida_nalt.opinfo_t.cd (variable) +ida_nalt.opinfo_t.cd for custom data -ida_nalt.opinfo_t.ec (variable) +ida_nalt.opinfo_t.ec for enums -ida_nalt.opinfo_t.path (variable) +ida_nalt.opinfo_t.path for stroff -ida_nalt.opinfo_t.ri (variable) +ida_nalt.opinfo_t.ri for offset members -ida_nalt.opinfo_t.strtype (variable) +ida_nalt.opinfo_t.strtype for strings (String type codes) -ida_nalt.opinfo_t.tid (variable) +ida_nalt.opinfo_t.tid for struct, etc. members -ida_nalt.printop_t (class) - Proxy of C++ printop_t class. +ida_nalt.printop_t -ida_nalt.printop_t.__init__ (method) - __init__(self) -> printop_t +ida_nalt.printop_t.__init__(self) -ida_nalt.printop_t.get_ti (method) - get_ti(self) -> opinfo_t +ida_nalt.printop_t.get_ti(self) -> "opinfo_t const *" -ida_nalt.printop_t.is_aflags_initialized (method) - is_aflags_initialized(self) -> bool +ida_nalt.printop_t.is_aflags_initialized(self) -> bool -ida_nalt.printop_t.is_f64 (method) - is_f64(self) -> bool +ida_nalt.printop_t.is_f64(self) -> bool -ida_nalt.printop_t.is_ti_initialized (method) - is_ti_initialized(self) -> bool +ida_nalt.printop_t.is_ti_initialized(self) -> bool -ida_nalt.printop_t.set_aflags_initialized (method) - set_aflags_initialized(self, v=True) - - @param v: bool +ida_nalt.printop_t.set_aflags_initialized(self, v: bool = True) -> None -ida_nalt.printop_t.set_ti_initialized (method) - set_ti_initialized(self, v=True) - - @param v: bool +ida_nalt.printop_t.set_ti_initialized(self, v: bool = True) -> None -ida_nalt.refinfo_t (class) - Proxy of C++ refinfo_t class. +ida_nalt.refinfo_t -ida_nalt.refinfo_t.__init__ (method) - __init__(self) -> refinfo_t +ida_nalt.refinfo_t.__init__(self) -ida_nalt.refinfo_t.base (variable) +ida_nalt.refinfo_t.base base of reference (may be BADADDR) -ida_nalt.refinfo_t.flags (variable) - Reference info flags +ida_nalt.refinfo_t.flags + Reference info flags + -ida_nalt.refinfo_t.init (method) - init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0) - - @param reft_and_flags: uint32 - @param _base: ea_t - @param _target: ea_t - @param _tdelta: adiff_t +ida_nalt.refinfo_t.init(self, *args) -> None -ida_nalt.refinfo_t.is_custom (method) - is_custom(self) -> bool +ida_nalt.refinfo_t.is_custom(self) -> bool -ida_nalt.refinfo_t.is_no_ones (method) - is_no_ones(self) -> bool +ida_nalt.refinfo_t.is_no_ones(self) -> bool -ida_nalt.refinfo_t.is_no_zeros (method) - is_no_zeros(self) -> bool +ida_nalt.refinfo_t.is_no_zeros(self) -> bool -ida_nalt.refinfo_t.is_pastend (method) - is_pastend(self) -> bool +ida_nalt.refinfo_t.is_pastend(self) -> bool -ida_nalt.refinfo_t.is_rvaoff (method) - is_rvaoff(self) -> bool +ida_nalt.refinfo_t.is_rvaoff(self) -> bool -ida_nalt.refinfo_t.is_selfref (method) - is_selfref(self) -> bool +ida_nalt.refinfo_t.is_selfref(self) -> bool -ida_nalt.refinfo_t.is_signed (method) - is_signed(self) -> bool +ida_nalt.refinfo_t.is_signed(self) -> bool -ida_nalt.refinfo_t.is_subtract (method) - is_subtract(self) -> bool +ida_nalt.refinfo_t.is_subtract(self) -> bool -ida_nalt.refinfo_t.is_target_optional (method) - is_target_optional(self) -> bool +ida_nalt.refinfo_t.is_target_optional(self) -> bool < is_reftype_target_optional() -ida_nalt.refinfo_t.no_base_xref (method) - no_base_xref(self) -> bool +ida_nalt.refinfo_t.no_base_xref(self) -> bool -ida_nalt.refinfo_t.set_type (method) - set_type(self, rt) - - @param rt: reftype_t +ida_nalt.refinfo_t.set_type(self, rt: "reftype_t") -> None -ida_nalt.refinfo_t.target (variable) +ida_nalt.refinfo_t.target reference target (BADADDR-none) -ida_nalt.refinfo_t.tdelta (variable) +ida_nalt.refinfo_t.tdelta offset from the target -ida_nalt.refinfo_t.type (method) - type(self) -> reftype_t +ida_nalt.refinfo_t.type(self) -> "reftype_t" -ida_nalt.rename_encoding (function) - rename_encoding(idx, encname) -> bool - Change name for an encoding The number of bytes per unit (BPU) of the new - encoding must match this number of the existing default encoding. Specifying the - empty name simply deletes this encoding. - - @param idx: (C++: int) the encoding index (1-based) - @param encname: (C++: const char *) the new encoding name +ida_nalt.rename_encoding(idx: int, encname: str) -> bool -ida_nalt.retrieve_input_file_crc32 (function) - retrieve_input_file_crc32() -> uint32 - Get input file crc32 stored in the database. it can be used to check that the - input file has not been changed. +ida_nalt.retrieve_input_file_crc32() -> int + Get input file crc32 stored in the database. it can be used to check that the input file has not been changed. + -ida_nalt.retrieve_input_file_md5 (function) - retrieve_input_file_md5() -> bytes +ida_nalt.retrieve_input_file_md5() -> bytes Get input file md5. -ida_nalt.retrieve_input_file_sha256 (function) - retrieve_input_file_sha256() -> bytes +ida_nalt.retrieve_input_file_sha256() -> bytes Get input file sha256. -ida_nalt.retrieve_input_file_size (function) - retrieve_input_file_size() -> size_t +ida_nalt.retrieve_input_file_size() -> "size_t" Get size of input file in bytes. -ida_nalt.set__bnot0 (function) - set__bnot0(ea) - - @param ea: ea_t +ida_nalt.set__bnot0(ea: ida_idaapi.ea_t) -> None -ida_nalt.set__bnot1 (function) - set__bnot1(ea) - - @param ea: ea_t +ida_nalt.set__bnot1(ea: ida_idaapi.ea_t) -> None -ida_nalt.set__invsign0 (function) - set__invsign0(ea) - - @param ea: ea_t +ida_nalt.set__invsign0(ea: ida_idaapi.ea_t) -> None -ida_nalt.set__invsign1 (function) - set__invsign1(ea) - - @param ea: ea_t +ida_nalt.set__invsign1(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_abits (function) - set_abits(ea, bits) - - @param ea: ea_t - @param bits: aflags_t +ida_nalt.set_abits(ea: ida_idaapi.ea_t, bits: "aflags_t") -> None -ida_nalt.set_absbase (function) - set_absbase(ea, x) - - @param ea: ea_t - @param x: ea_t +ida_nalt.set_absbase(ea: ida_idaapi.ea_t, x: ida_idaapi.ea_t) -> None -ida_nalt.set_aflags (function) - set_aflags(ea, flags) - - @param ea: ea_t - @param flags: aflags_t +ida_nalt.set_aflags(ea: ida_idaapi.ea_t, flags: "aflags_t") -> None -ida_nalt.set_align_flow (function) - set_align_flow(ea) - - @param ea: ea_t +ida_nalt.set_align_flow(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_alignment (function) - set_alignment(ea, x) - - @param ea: ea_t - @param x: uint32 +ida_nalt.set_alignment(ea: ida_idaapi.ea_t, x: int) -> None -ida_nalt.set_archive_path (function) - set_archive_path(file) -> bool +ida_nalt.set_archive_path(file: str) -> bool Set archive file path from which input file was extracted. - - @param file: (C++: const char *) char const * -ida_nalt.set_array_parameters (function) - set_array_parameters(ea, _in) - - @param ea: ea_t - @param in: array_parameters_t const * +ida_nalt.set_array_parameters(ea: ida_idaapi.ea_t, _in: "array_parameters_t") -> None -ida_nalt.set_asm_inc_file (function) - set_asm_inc_file(file) -> bool +ida_nalt.set_asm_inc_file(file: str) -> bool Set name of the include file. - - @param file: (C++: const char *) char const * -ida_nalt.set_colored_item (function) - set_colored_item(ea) - - @param ea: ea_t +ida_nalt.set_colored_item(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_custom_data_type_ids (function) - set_custom_data_type_ids(ea, cdis) - - @param ea: ea_t - @param cdis: custom_data_type_ids_t const * +ida_nalt.set_custom_data_type_ids(ea: ida_idaapi.ea_t, cdis: "custom_data_type_ids_t") -> None -ida_nalt.set_data_guessed_by_hexrays (function) - set_data_guessed_by_hexrays(ea) - - @param ea: ea_t +ida_nalt.set_data_guessed_by_hexrays(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_default_encoding_idx (function) - set_default_encoding_idx(bpu, idx) -> bool - Set default encoding for a string type - - @param bpu: (C++: int) the amount of bytes per unit - @param idx: (C++: int) the encoding index. It cannot be 0 +ida_nalt.set_default_encoding_idx(bpu: int, idx: int) -> bool -ida_nalt.set_fixed_spd (function) - set_fixed_spd(ea) - - @param ea: ea_t +ida_nalt.set_fixed_spd(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_func_guessed_by_hexrays (function) - set_func_guessed_by_hexrays(ea) - - @param ea: ea_t +ida_nalt.set_func_guessed_by_hexrays(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_gotea (function) - set_gotea(gotea) - - @param gotea: ea_t +ida_nalt.set_gotea(gotea: ida_idaapi.ea_t) -> None -ida_nalt.set_has_lname (function) - set_has_lname(ea) - - @param ea: ea_t +ida_nalt.set_has_lname(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_has_ti (function) - set_has_ti(ea) - - @param ea: ea_t +ida_nalt.set_has_ti(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_has_ti0 (function) - set_has_ti0(ea) - - @param ea: ea_t +ida_nalt.set_has_ti0(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_has_ti1 (function) - set_has_ti1(ea) - - @param ea: ea_t +ida_nalt.set_has_ti1(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_ida_notepad_text (function) - set_ida_notepad_text(text, size=0) +ida_nalt.set_ida_notepad_text(text: str, size: "size_t" = 0) -> None Set notepad text. - - @param text: (C++: const char *) char const * - @param size: (C++: size_t) -ida_nalt.set_ids_modnode (function) - set_ids_modnode(id) +ida_nalt.set_ids_modnode(id: "netnode") -> None Set ids modnode. - - @param id: (C++: netnode) -ida_nalt.set_imagebase (function) - set_imagebase(base) +ida_nalt.set_imagebase(base: ida_idaapi.ea_t) -> None Set image base address. - - @param base: (C++: ea_t) -ida_nalt.set_item_color (function) - set_item_color(ea, color) - - @param ea: ea_t - @param color: bgcolor_t +ida_nalt.set_item_color(ea: ida_idaapi.ea_t, color: "bgcolor_t") -> None -ida_nalt.set_libitem (function) - set_libitem(ea) - - @param ea: ea_t +ida_nalt.set_libitem(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_loader_format_name (function) - set_loader_format_name(name) +ida_nalt.set_loader_format_name(name: str) -> None Set file format name for loader modules. - - @param name: (C++: const char *) char const * -ida_nalt.set_lzero0 (function) - set_lzero0(ea) - - @param ea: ea_t +ida_nalt.set_lzero0(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_lzero1 (function) - set_lzero1(ea) - - @param ea: ea_t +ida_nalt.set_lzero1(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_noret (function) - set_noret(ea) - - @param ea: ea_t +ida_nalt.set_noret(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_notcode (function) - set_notcode(ea) +ida_nalt.set_notcode(ea: ida_idaapi.ea_t) -> None Mark address so that it cannot be converted to instruction. - - @param ea: (C++: ea_t) -ida_nalt.set_notproc (function) - set_notproc(ea) - - @param ea: ea_t +ida_nalt.set_notproc(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_op_tinfo (function) - set_op_tinfo(ea, n, tif) -> bool - - @param ea: ea_t - @param n: int - @param tif: tinfo_t const * +ida_nalt.set_op_tinfo(ea: ida_idaapi.ea_t, n: int, tif: "tinfo_t") -> bool -ida_nalt.set_outfile_encoding_idx (function) - set_outfile_encoding_idx(idx) -> bool - set encoding to be used when producing files - - @param idx: (C++: int) the encoding index IDX can be 0 to use the IDB's default 1-byte-per- - unit encoding +ida_nalt.set_outfile_encoding_idx(idx: int) -> bool -ida_nalt.set_refinfo (function) - set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> bool - - @param ea: ea_t - @param n: int - @param type: reftype_t - @param target: ea_t - @param base: ea_t - @param tdelta: adiff_t +ida_nalt.set_refinfo(*args) -> bool -ida_nalt.set_refinfo_ex (function) - set_refinfo_ex(ea, n, ri) -> bool - - @param ea: ea_t - @param n: int - @param ri: refinfo_t const * +ida_nalt.set_refinfo_ex(ea: ida_idaapi.ea_t, n: int, ri: "refinfo_t") -> bool -ida_nalt.set_retfp (function) - set_retfp(ea) - - @param ea: ea_t +ida_nalt.set_retfp(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_root_filename (function) - set_root_filename(file) +ida_nalt.set_root_filename(file: str) -> None Set full path of the input file. - - @param file: (C++: const char *) char const * -ida_nalt.set_source_linnum (function) - set_source_linnum(ea, lnnum) - - @param ea: ea_t - @param lnnum: uval_t +ida_nalt.set_source_linnum(ea: ida_idaapi.ea_t, lnnum: int) -> None -ida_nalt.set_srcdbg_paths (function) - set_srcdbg_paths(paths) +ida_nalt.set_srcdbg_paths(paths: str) -> None Set source debug paths. - - @param paths: (C++: const char *) char const * -ida_nalt.set_srcdbg_undesired_paths (function) - set_srcdbg_undesired_paths(paths) +ida_nalt.set_srcdbg_undesired_paths(paths: str) -> None Set user-closed source files. - - @param paths: (C++: const char *) char const * -ida_nalt.set_str_encoding_idx (function) - set_str_encoding_idx(strtype, encoding_idx) -> int32 - Set index of the string encoding in the string type. - - @param strtype: (C++: int32) - @param encoding_idx: (C++: int) +ida_nalt.set_str_encoding_idx(strtype: int, encoding_idx: int) -> int -ida_nalt.set_str_type (function) - set_str_type(ea, x) - - @param ea: ea_t - @param x: uint32 +ida_nalt.set_str_type(ea: ida_idaapi.ea_t, x: int) -> None -ida_nalt.set_switch_info (function) - set_switch_info(ea, _in) - - @param ea: ea_t - @param in: switch_info_t const & +ida_nalt.set_switch_info(ea: ida_idaapi.ea_t, _in: "switch_info_t") -> None -ida_nalt.set_switch_parent (function) - set_switch_parent(ea, x) - - @param ea: ea_t - @param x: ea_t +ida_nalt.set_switch_parent(ea: ida_idaapi.ea_t, x: ida_idaapi.ea_t) -> None -ida_nalt.set_terse_struc (function) - set_terse_struc(ea) - - @param ea: ea_t +ida_nalt.set_terse_struc(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_tilcmt (function) - set_tilcmt(ea) - - @param ea: ea_t +ida_nalt.set_tilcmt(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_tinfo (function) - set_tinfo(ea, tif) -> bool - - @param ea: ea_t - @param tif: tinfo_t const * +ida_nalt.set_tinfo(ea: ida_idaapi.ea_t, tif: "tinfo_t") -> bool -ida_nalt.set_type_determined_by_hexrays (function) - set_type_determined_by_hexrays(ea) - - @param ea: ea_t +ida_nalt.set_type_determined_by_hexrays(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_type_guessed_by_ida (function) - set_type_guessed_by_ida(ea) - - @param ea: ea_t +ida_nalt.set_type_guessed_by_ida(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_usemodsp (function) - set_usemodsp(ea) - - @param ea: ea_t +ida_nalt.set_usemodsp(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_usersp (function) - set_usersp(ea) - - @param ea: ea_t +ida_nalt.set_usersp(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_userti (function) - set_userti(ea) - - @param ea: ea_t +ida_nalt.set_userti(ea: ida_idaapi.ea_t) -> None -ida_nalt.set_visible_item (function) - set_visible_item(ea, visible) +ida_nalt.set_visible_item(ea: ida_idaapi.ea_t, visible: bool) -> None Change visibility of item at given ea. - - @param ea: (C++: ea_t) - @param visible: (C++: bool) -ida_nalt.set_zstroff (function) - set_zstroff(ea) - - @param ea: ea_t +ida_nalt.set_zstroff(ea: ida_idaapi.ea_t) -> None -ida_nalt.strpath_ids_array (class) - Proxy of C++ wrapped_array_t< tid_t,32 > class. +ida_nalt.strpath_ids_array -ida_nalt.strpath_ids_array.__getitem__ (method) - __getitem__(self, i) -> unsigned-ea-like-numeric-type const & - - @param i: size_t +ida_nalt.strpath_ids_array.__getitem__(self, i: "size_t") -> "unsigned long long const &" -ida_nalt.strpath_ids_array.__init__ (method) - __init__(self, data) -> strpath_ids_array - - @param data: unsigned-ea-like-numeric-type (&)[32] +ida_nalt.strpath_ids_array.__init__(self, data: "unsigned long long (&)[32]") -ida_nalt.strpath_ids_array.__len__ (method) - __len__(self) -> size_t +ida_nalt.strpath_ids_array.__len__(self) -> "size_t" -ida_nalt.strpath_ids_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned-ea-like-numeric-type const & +ida_nalt.strpath_ids_array.__setitem__(self, i: "size_t", v: "unsigned long long const &") -> None -ida_nalt.strpath_ids_array._get_bytes (method) - _get_bytes(self) -> bytevec_t +ida_nalt.strpath_ids_array._get_bytes(self) -> "bytevec_t" -ida_nalt.strpath_ids_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & +ida_nalt.strpath_ids_array._set_bytes(self, bts: "bytevec_t const &") -> None -ida_nalt.strpath_t (class) - Proxy of C++ strpath_t class. +ida_nalt.strpath_t -ida_nalt.strpath_t.__getIds (method) - __getIds(self) -> strpath_ids_array +ida_nalt.strpath_t.__getIds(self) -> "wrapped_array_t< tid_t,32 >" -ida_nalt.strpath_t.__init__ (method) - __init__(self) -> strpath_t +ida_nalt.strpath_t.__init__(self) -ida_nalt.switch_info_t (class) - Proxy of C++ switch_info_t class. +ida_nalt.switch_info_t -ida_nalt.switch_info_t.__init__ (method) - __init__(self) -> switch_info_t +ida_nalt.switch_info_t.__init__(self) -ida_nalt.switch_info_t._get_values_lowcase (method) - _get_values_lowcase(self) -> ea_t +ida_nalt.switch_info_t._get_values_lowcase(self) -> ida_idaapi.ea_t -ida_nalt.switch_info_t._set_values_lowcase (method) - _set_values_lowcase(self, values) - - Parameters - ---------- - values: ea_t +ida_nalt.switch_info_t._set_values_lowcase(self, values: ida_idaapi.ea_t) -> None -ida_nalt.switch_info_t.assign (method) - assign(self, other) - - @param other: switch_info_t const & +ida_nalt.switch_info_t.assign(self, other: "switch_info_t") -> None -ida_nalt.switch_info_t.clear (method) - clear(self) +ida_nalt.switch_info_t.clear(self) -> None -ida_nalt.switch_info_t.custom (variable) +ida_nalt.switch_info_t.custom information for custom tables (filled and used by modules) -ida_nalt.switch_info_t.defjump (variable) +ida_nalt.switch_info_t.defjump default jump address (BADADDR if no default case) -ida_nalt.switch_info_t.elbase (variable) +ida_nalt.switch_info_t.elbase element base -ida_nalt.switch_info_t.expr_ea (variable) - the address before that the switch expression is in REGNUM. If BADADDR, then the - first insn marked as IM_SWITCH after STARTEA is used. +ida_nalt.switch_info_t.expr_ea + the address before that the switch expression is in REGNUM. If BADADDR, then the first insn marked as IM_SWITCH after STARTEA is used. + -ida_nalt.switch_info_t.flags (variable) - Switch info flags +ida_nalt.switch_info_t.flags + Switch info flags + -ida_nalt.switch_info_t.get_jrange_vrange (method) - get_jrange_vrange(self, jrange=None, vrange=None) -> bool +ida_nalt.switch_info_t.get_jrange_vrange(self, jrange: "range_t" = None, vrange: "range_t" = None) -> bool get separate parts of the switch - - @param jrange: (C++: range_t *) - @param vrange: (C++: range_t *) -ida_nalt.switch_info_t.get_jtable_element_size (method) - get_jtable_element_size(self) -> int +ida_nalt.switch_info_t.get_jtable_element_size(self) -> int -ida_nalt.switch_info_t.get_jtable_size (method) - get_jtable_size(self) -> int +ida_nalt.switch_info_t.get_jtable_size(self) -> int -ida_nalt.switch_info_t.get_lowcase (method) - get_lowcase(self) -> sval_t +ida_nalt.switch_info_t.get_lowcase(self) -> int -ida_nalt.switch_info_t.get_shift (method) - get_shift(self) -> int - See SWI_SHIFT_MASK. possible answers: 0..3. +ida_nalt.switch_info_t.get_shift(self) -> int + See SWI_SHIFT_MASK. possible answers: 0..3. + -ida_nalt.switch_info_t.get_version (method) - get_version(self) -> int +ida_nalt.switch_info_t.get_version(self) -> int -ida_nalt.switch_info_t.get_vtable_element_size (method) - get_vtable_element_size(self) -> int +ida_nalt.switch_info_t.get_vtable_element_size(self) -> int -ida_nalt.switch_info_t.has_default (method) - has_default(self) -> bool +ida_nalt.switch_info_t.has_default(self) -> bool -ida_nalt.switch_info_t.has_elbase (method) - has_elbase(self) -> bool +ida_nalt.switch_info_t.has_elbase(self) -> bool -ida_nalt.switch_info_t.is_custom (method) - is_custom(self) -> bool +ida_nalt.switch_info_t.is_custom(self) -> bool -ida_nalt.switch_info_t.is_indirect (method) - is_indirect(self) -> bool +ida_nalt.switch_info_t.is_indirect(self) -> bool -ida_nalt.switch_info_t.is_nolowcase (method) - is_nolowcase(self) -> bool +ida_nalt.switch_info_t.is_nolowcase(self) -> bool -ida_nalt.switch_info_t.is_sparse (method) - is_sparse(self) -> bool +ida_nalt.switch_info_t.is_sparse(self) -> bool -ida_nalt.switch_info_t.is_subtract (method) - is_subtract(self) -> bool +ida_nalt.switch_info_t.is_subtract(self) -> bool -ida_nalt.switch_info_t.is_user_defined (method) - is_user_defined(self) -> bool +ida_nalt.switch_info_t.is_user_defined(self) -> bool -ida_nalt.switch_info_t.jcases (variable) +ida_nalt.switch_info_t.jcases number of entries in the jump table (SWI_INDIRECT) -ida_nalt.switch_info_t.jumps (variable) +ida_nalt.switch_info_t.jumps jump table start address -ida_nalt.switch_info_t.lowcase (variable) +ida_nalt.switch_info_t.lowcase the lowest value in cases -ida_nalt.switch_info_t.marks (variable) +ida_nalt.switch_info_t.lowcase + the lowest value in cases + +ida_nalt.switch_info_t.marks the insns marked as IM_SWITCH. They are used to delete the switch. -ida_nalt.switch_info_t.ncases (variable) +ida_nalt.switch_info_t.ncases number of cases (excluding default) -ida_nalt.switch_info_t.regdtype (variable) +ida_nalt.switch_info_t.regdtype size of the switch expression register as dtype -ida_nalt.switch_info_t.regnum (variable) - the switch expression as a value of the REGNUM register before the instruction - at EXPR_EA. -1 means 'unknown' +ida_nalt.switch_info_t.regnum + the switch expression as a value of the REGNUM register before the instruction at EXPR_EA. -1 means 'unknown' + -ida_nalt.switch_info_t.set_elbase (method) - set_elbase(self, base) - - @param base: ea_t +ida_nalt.switch_info_t.set_elbase(self, base: ida_idaapi.ea_t) -> None -ida_nalt.switch_info_t.set_expr (method) - set_expr(self, r, dt) - - @param r: int - @param dt: op_dtype_t +ida_nalt.switch_info_t.set_expr(self, r: int, dt: "op_dtype_t") -> None -ida_nalt.switch_info_t.set_jtable_element_size (method) - set_jtable_element_size(self, size) - - @param size: int +ida_nalt.switch_info_t.set_jtable_element_size(self, size: int) -> None -ida_nalt.switch_info_t.set_jtable_size (method) - set_jtable_size(self, size) - - @param size: int +ida_nalt.switch_info_t.set_jtable_size(self, size: int) -> None -ida_nalt.switch_info_t.set_shift (method) - set_shift(self, shift) +ida_nalt.switch_info_t.set_shift(self, shift: int) -> None See SWI_SHIFT_MASK. - - @param shift: (C++: int) -ida_nalt.switch_info_t.set_vtable_element_size (method) - set_vtable_element_size(self, size) - - @param size: int +ida_nalt.switch_info_t.set_vtable_element_size(self, size: int) -> None -ida_nalt.switch_info_t.startea (variable) +ida_nalt.switch_info_t.startea start of the switch idiom -ida_nalt.switch_info_t.use_std_table (method) - use_std_table(self) -> bool +ida_nalt.switch_info_t.use_std_table(self) -> bool -ida_nalt.switch_info_t.values (variable) +ida_nalt.switch_info_t.values values table address (if SWI_SPARSE is set) -ida_nalt.switch_info_t__from_ptrval__ (function) - switch_info_t__from_ptrval__(ptrval) -> switch_info_t - - @param ptrval: size_t +ida_nalt.switch_info_t.values + values table address (if SWI_SPARSE is set) -ida_nalt.unhide_border (function) - unhide_border(ea) - - @param ea: ea_t +ida_nalt.switch_info_t__from_ptrval__(ptrval: "size_t") -> "switch_info_t *" -ida_nalt.unhide_item (function) - unhide_item(ea) - - @param ea: ea_t +ida_nalt.unhide_border(ea: ida_idaapi.ea_t) -> None -ida_nalt.upd_abits (function) - upd_abits(ea, clr_bits, set_bits) - - @param ea: ea_t - @param clr_bits: aflags_t - @param set_bits: aflags_t +ida_nalt.unhide_item(ea: ida_idaapi.ea_t) -> None -ida_nalt.uses_aflag_modsp (function) - uses_aflag_modsp(flags) -> bool - - @param flags: aflags_t +ida_nalt.upd_abits(ea: ida_idaapi.ea_t, clr_bits: "aflags_t", set_bits: "aflags_t") -> None -ida_nalt.uses_modsp (function) - uses_modsp(ea) -> bool - - @param ea: ea_t +ida_nalt.uses_aflag_modsp(flags: "aflags_t") -> bool -ida_nalt.validate_idb_names (function) - validate_idb_names(do_repair) -> int - - @param do_repair: bool +ida_nalt.uses_modsp(ea: ida_idaapi.ea_t) -> bool -ida_name (module) +ida_name Functions that deal with names. - A non-tail address of the program may have a name. Tail addresses (i.e. the - addresses in the middle of an instruction or data item) cannot have names. + A non-tail address of the program may have a name. Tail addresses (i.e. the addresses in the middle of an instruction or data item) cannot have names. + -ida_name.DEBNAME_EXACT (variable) +ida_name.CN_KEEP_TRAILING_DIGITS + do not remove "_\d+" at the end of name + +ida_name.CN_KEEP_UNDERSCORES + do not remove leading underscores. but it is ok to remove __imp_. + + +ida_name.DEBNAME_EXACT find a name at exactly the specified address -ida_name.DEBNAME_LOWER (variable) +ida_name.DEBNAME_LOWER find a name with the address >= the specified address -ida_name.DEBNAME_NICE (variable) +ida_name.DEBNAME_NICE find a name with the address <= the specified address -ida_name.DEBNAME_UPPER (variable) +ida_name.DEBNAME_UPPER find a name with the address > the specified address -ida_name.FUNC_IMPORT_PREFIX (variable) +ida_name.DQT_COMPILER + only detect compiler that generated the name + +ida_name.DQT_FULL + really demangle + +ida_name.DQT_NAME_TYPE + only detect the name type (data/code) + +ida_name.DQT_NPURGED_2 + only calculate number of purged bytes (sizeof(arg)==2) + +ida_name.DQT_NPURGED_4 + only calculate number of purged bytes (sizeof(arg)==4) + +ida_name.DQT_NPURGED_8 + only calculate number of purged bytes (sizeof(arg)==8) + +ida_name.FUNC_IMPORT_PREFIX Name prefix used by IDA for the imported functions. -ida_name.GETN_APPZERO (variable) - meaningful only if the name refers to a structure. append a struct field name if - the field offset is zero? +ida_name.GETN_APPZERO + meaningful only if the name refers to a structure. append a struct field name if the field offset is zero? + -ida_name.GETN_NODUMMY (variable) +ida_name.GETN_NODUMMY do not create a new dummy name but pretend it exists -ida_name.GETN_NOFIXUP (variable) +ida_name.GETN_NOFIXUP ignore the fixup information when producing the name -ida_name.GNCN_NOCOLOR (variable) +ida_name.GNCN_NOCOLOR generate an uncolored name -ida_name.GNCN_NODBGNM (variable) +ida_name.GNCN_NODBGNM don't use debug names -ida_name.GNCN_NOFUNC (variable) +ida_name.GNCN_NOFUNC don't generate funcname+... expressions -ida_name.GNCN_NOLABEL (variable) +ida_name.GNCN_NOLABEL don't generate labels -ida_name.GNCN_NOSEG (variable) +ida_name.GNCN_NOSEG ignore the segment prefix when producing the name -ida_name.GNCN_PREFDBG (variable) +ida_name.GNCN_PREFDBG if using debug names, prefer debug names over function names -ida_name.GNCN_REQFUNC (variable) +ida_name.GNCN_REQFUNC return 0 if the address does not belong to a function -ida_name.GNCN_REQNAME (variable) +ida_name.GNCN_REQNAME return 0 if the address can only be represented as a hex number -ida_name.GNCN_SEGNUM (variable) +ida_name.GNCN_SEGNUM segment part is displayed as a hex number -ida_name.GNCN_SEG_FUNC (variable) - generate both segment and function names (default is to omit segment name if a - function name is present) +ida_name.GNCN_SEG_FUNC + generate both segment and function names (default is to omit segment name if a function name is present) -ida_name.GN_COLORED (variable) +ida_name.GN_COLORED return colored name -ida_name.GN_DEMANGLED (variable) +ida_name.GN_DEMANGLED return demangled name -ida_name.GN_ISRET (variable) +ida_name.GN_ISRET for dummy names: use retloc -ida_name.GN_LOCAL (variable) +ida_name.GN_LOCAL try to get local name first; if failed, get global -ida_name.GN_LONG (variable) +ida_name.GN_LONG use long form of demangled name -ida_name.GN_NOT_DUMMY (variable) +ida_name.GN_NOT_DUMMY do not return a dummy name -ida_name.GN_NOT_ISRET (variable) +ida_name.GN_NOT_ISRET for dummy names: do not use retloc -ida_name.GN_SHORT (variable) +ida_name.GN_SHORT use short form of demangled name -ida_name.GN_STRICT (variable) +ida_name.GN_STRICT fail if cannot demangle -ida_name.GN_VISIBLE (variable) +ida_name.GN_VISIBLE replace forbidden characters by SUBSTCHAR -ida_name.MAXNAMELEN (variable) +ida_name.MAXNAMELEN Maximum length of a name in IDA (with the trailing zero) -ida_name.NT_ABS (variable) +ida_name.NT_ABS name is absolute symbol (SEG_ABSSYM) -ida_name.NT_BMASK (variable) +ida_name.NT_BMASK name is a bit group mask name -ida_name.NT_BYTE (variable) +ida_name.NT_BYTE name is byte name (regular name) -ida_name.NT_ENUM (variable) +ida_name.NT_ENUM name is symbolic constant -ida_name.NT_LOCAL (variable) +ida_name.NT_LOCAL name is local label -ida_name.NT_NONE (variable) +ida_name.NT_NONE name doesn't exist or has no value -ida_name.NT_REGVAR (variable) +ida_name.NT_REGVAR name is a renamed register (*value is idx into pfn->regvars) -ida_name.NT_SEG (variable) +ida_name.NT_SEG name is segment or segment register name -ida_name.NT_STKVAR (variable) +ida_name.NT_STKVAR name is stack variable name -ida_name.NT_STROFF (variable) +ida_name.NT_STROFF name is structure member -ida_name.NearestName (class) +ida_name.NearestName Utility class to help find the nearest name in a given ea/name dictionary -ida_name.NearestName.__getitem__ (method) +ida_name.NearestName.__getitem__(self, index) Returns the tupple (ea, name, index) -ida_name.NearestName.__init__ (method) +ida_name.NearestName.__init__(self, ea_names) -ida_name.NearestName.__iter__ (method) +ida_name.NearestName.__iter__(self) -ida_name.NearestName._get_item (method) +ida_name.NearestName._get_item(self, index) -ida_name.NearestName.find (method) +ida_name.NearestName.find(self, ea) Returns a tupple (ea, name, pos) that is the nearest to the passed ea If no name is matched then None is returned -ida_name.NearestName.update (method) +ida_name.NearestName.update(self, ea_names) Updates the ea/names map -ida_name.SN_AUTO (variable) +ida_name.SN_AUTO if set, make name autogenerated -ida_name.SN_CHECK (variable) +ida_name.SN_CHECK Fail if the name contains invalid characters. -ida_name.SN_DELTAIL (variable) - if name cannot be set because of a tail byte, delete the hindering item +ida_name.SN_DELTAIL + if name cannot be set because of a tail byte, delete the hindering item + -ida_name.SN_FORCE (variable) - if the specified name is already present in the database, try variations with a - numerical suffix like "_123" +ida_name.SN_FORCE + if the specified name is already present in the database, try variations with a numerical suffix like "_123" + -ida_name.SN_IDBENC (variable) - the name is given in the IDB encoding; non-ASCII bytes will be decoded - accordingly. Specifying SN_IDBENC also implies SN_NODUMMY +ida_name.SN_IDBENC + the name is given in the IDB encoding; non-ASCII bytes will be decoded accordingly. Specifying SN_IDBENC also implies SN_NODUMMY + -ida_name.SN_LOCAL (variable) - create local name. a function should exist. local names can't be public or weak. - also they are not included into the list of names they can't have dummy - prefixes. +ida_name.SN_LOCAL + create local name. a function should exist. local names can't be public or weak. also they are not included into the list of names they can't have dummy prefixes. + -ida_name.SN_NOCHECK (variable) - Replace invalid characters silently. If this bit is set, all invalid chars (not - in NameChars or MangleChars) will be replaced by '_' List of valid characters is - defined in ida.cfg +ida_name.SN_NOCHECK + Replace invalid characters silently. If this bit is set, all invalid chars (not in NameChars or MangleChars) will be replaced by '_' List of valid characters is defined in ida.cfg + -ida_name.SN_NODUMMY (variable) - automatically prepend the name with '_' if it begins with a dummy suffix such as - 'sub_'. See also SN_IDBENC +ida_name.SN_NODUMMY + automatically prepend the name with '_' if it begins with a dummy suffix such as 'sub_'. See also SN_IDBENC + -ida_name.SN_NOLIST (variable) - if set, exclude name from the list. if not set, then include the name into the - list (however, if other bits are set, the name might be immediately excluded - from the list). +ida_name.SN_NOLIST + if set, exclude name from the list. if not set, then include the name into the list (however, if other bits are set, the name might be immediately excluded from the list). + -ida_name.SN_NON_AUTO (variable) +ida_name.SN_NON_AUTO if set, make name non-autogenerated -ida_name.SN_NON_PUBLIC (variable) +ida_name.SN_NON_PUBLIC if set, make name non-public -ida_name.SN_NON_WEAK (variable) +ida_name.SN_NON_WEAK if set, make name non-weak -ida_name.SN_NOWARN (variable) +ida_name.SN_NOWARN don't display a warning if failed -ida_name.SN_PUBLIC (variable) +ida_name.SN_PUBLIC if set, make name public -ida_name.SN_WEAK (variable) +ida_name.SN_WEAK if set, make name weak -ida_name.append_struct_fields (function) - append_struct_fields(disp, n, path, flags, delta, appzero) -> str - Append names of struct fields to a name if the name is a struct name. - - @param disp: (C++: adiff_t *) displacement from the name - @param n: (C++: int) operand number in which the name appears - @param path: (C++: const tid_t *) path in the struct. path is an array of id's. maximal length of - array is MAXSTRUCPATH. the first element of the array is the - structure id. consecutive elements are id's of used union members - (if any). - @param flags: (C++: flags64_t) the input flags. they will be returned if the struct cannot be - found. - @param delta: (C++: adiff_t) delta to add to displacement - @param appzero: (C++: bool) should append a struct field name if the displacement is zero? - @return: flags of the innermost struct member or the input flags +ida_name.UCDR_MANGLED + mangled names -ida_name.calc_gtn_flags (function) +ida_name.UCDR_NAME + regular (unmangled) names + +ida_name.UCDR_STRLIT + string literals + +ida_name.UCDR_TYPE + type names + +ida_name.VNT_IDENT + identifier (e.g., function name) + +ida_name.VNT_STRLIT + string literal + +ida_name.VNT_TYPE + type name (can contain '<', '>', ...) + +ida_name.VNT_UDTMEM + UDT (structure, union, enum) member. + +ida_name.VNT_VISIBLE + visible cp (obsolete; will be deleted) + +ida_name.append_struct_fields(disp: "adiff_t *", n: int, path: "tid_t const *", flags: "flags64_t", delta: "adiff_t", appzero: bool) -> str + Append names of struct fields to a name if the name is a struct name. + + @param disp: displacement from the name + @param n: operand number in which the name appears + @param path: path in the struct. path is an array of id's. maximal length of array is MAXSTRUCPATH. the first element of the array is the structure id. consecutive elements are id's of used union members (if any). + @param flags: the input flags. they will be returned if the struct cannot be found. + @param delta: delta to add to displacement + @param appzero: should append a struct field name if the displacement is zero? + @returns flags of the innermost struct member or the input flags + +ida_name.calc_gtn_flags(fromaddr, ea) Calculate flags for get_ea_name() function @param fromaddr: the referring address. May be BADADDR. @@ -51347,329 +35502,155 @@ ida_name.calc_gtn_flags (function) @return: flags -ida_name.cleanup_name (function) - cleanup_name(ea, name, flags=0) -> str - - @param ea: ea_t - @param name: char const * - @param flags: uint32 +ida_name.cleanup_name(ea: ida_idaapi.ea_t, name: str, flags: int = 0) -> str -ida_name.del_debug_names (function) - del_debug_names(ea1, ea2) - - @param ea1: ea_t - @param ea2: ea_t +ida_name.del_debug_names(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t) -> None -ida_name.del_global_name (function) - del_global_name(ea) -> bool - - @param ea: ea_t +ida_name.del_global_name(ea: ida_idaapi.ea_t) -> bool -ida_name.del_local_name (function) - del_local_name(ea) -> bool - - @param ea: ea_t +ida_name.del_local_name(ea: ida_idaapi.ea_t) -> bool -ida_name.demangle_name (function) - demangle_name(name, disable_mask, demreq=DQT_FULL) -> str - Demangle a name. - - @param name: (C++: const char *) char const * - @param disable_mask: (C++: uint32) - @param demreq: (C++: demreq_type_t) enum demreq_type_t +ida_name.demangle_name(name: str, disable_mask: int, demreq: "demreq_type_t" = DQT_FULL) -> str + Demangle a name. + + @param name: name to demangle + @param disable_mask: bits to inhibit parts of demangled name (see MNG_). by the M_COMPILER bits a specific compiler can be selected (see MT_). + @param demreq: the request type demreq_type_t + @returns ME_... or MT__ bitmasks from demangle.hpp -ida_name.ea_name_t (class) - Proxy of C++ ea_name_t class. +ida_name.ea_name_t -ida_name.ea_name_t.__init__ (method) - __init__(self) -> ea_name_t - __init__(self, _ea, _name) -> ea_name_t - - @param _ea: ea_t - @param _name: qstring const & +ida_name.ea_name_t.__init__(self, *args) -ida_name.ea_name_vec_t (class) - Proxy of C++ qvector< ea_name_t > class. +ida_name.ea_name_vec_t -ida_name.ea_name_vec_t.__getitem__ (method) - __getitem__(self, i) -> ea_name_t - - @param i: size_t +ida_name.ea_name_vec_t.__getitem__(self, i: "size_t") -> "ea_name_t const &" -ida_name.ea_name_vec_t.__init__ (method) - __init__(self) -> ea_name_vec_t - __init__(self, x) -> ea_name_vec_t - - @param x: qvector< ea_name_t > const & +ida_name.ea_name_vec_t.__init__(self, *args) -ida_name.ea_name_vec_t.__len__ (method) - __len__(self) -> size_t +ida_name.ea_name_vec_t.__len__(self) -> "size_t" -ida_name.ea_name_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ea_name_t const & +ida_name.ea_name_vec_t.__setitem__(self, i: "size_t", v: "ea_name_t") -> None -ida_name.ea_name_vec_t.at (method) - at(self, _idx) -> ea_name_t - - @param _idx: size_t +ida_name.ea_name_vec_t.append(self, x: "ea_name_t") -> None -ida_name.ea_name_vec_t.begin (method) - begin(self) -> ea_name_t +ida_name.ea_name_vec_t.at(self, _idx: "size_t") -> "ea_name_t const &" -ida_name.ea_name_vec_t.capacity (method) - capacity(self) -> size_t +ida_name.ea_name_vec_t.begin(self, *args) -> "qvector< ea_name_t >::const_iterator" -ida_name.ea_name_vec_t.clear (method) - clear(self) +ida_name.ea_name_vec_t.capacity(self) -> "size_t" -ida_name.ea_name_vec_t.empty (method) - empty(self) -> bool +ida_name.ea_name_vec_t.clear(self) -> None -ida_name.ea_name_vec_t.end (method) - end(self) -> ea_name_t +ida_name.ea_name_vec_t.empty(self) -> bool -ida_name.ea_name_vec_t.erase (method) - erase(self, it) -> ea_name_t - - @param it: qvector< ea_name_t >::iterator - - erase(self, first, last) -> ea_name_t - - @param first: qvector< ea_name_t >::iterator - @param last: qvector< ea_name_t >::iterator +ida_name.ea_name_vec_t.end(self, *args) -> "qvector< ea_name_t >::const_iterator" -ida_name.ea_name_vec_t.extract (method) - extract(self) -> ea_name_t +ida_name.ea_name_vec_t.erase(self, *args) -> "qvector< ea_name_t >::iterator" -ida_name.ea_name_vec_t.grow (method) - grow(self, x=ea_name_t()) - - @param x: ea_name_t const & +ida_name.ea_name_vec_t.extend(self, x: "ea_name_vec_t") -> None -ida_name.ea_name_vec_t.inject (method) - inject(self, s, len) - - @param s: ea_name_t * - @param len: size_t +ida_name.ea_name_vec_t.extract(self) -> "ea_name_t *" -ida_name.ea_name_vec_t.insert (method) - insert(self, it, x) -> ea_name_t - - @param it: qvector< ea_name_t >::iterator - @param x: ea_name_t const & +ida_name.ea_name_vec_t.grow(self, *args) -> None -ida_name.ea_name_vec_t.pop_back (method) - pop_back(self) +ida_name.ea_name_vec_t.inject(self, s: "ea_name_t", len: "size_t") -> None -ida_name.ea_name_vec_t.push_back (method) - push_back(self, x) - - @param x: ea_name_t const & - - push_back(self) -> ea_name_t +ida_name.ea_name_vec_t.insert(self, it: "ea_name_t", x: "ea_name_t") -> "qvector< ea_name_t >::iterator" -ida_name.ea_name_vec_t.qclear (method) - qclear(self) +ida_name.ea_name_vec_t.pop_back(self) -> None -ida_name.ea_name_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_name.ea_name_vec_t.push_back(self, *args) -> "ea_name_t &" -ida_name.ea_name_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ea_name_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_name.ea_name_vec_t.qclear(self) -> None -ida_name.ea_name_vec_t.size (method) - size(self) -> size_t +ida_name.ea_name_vec_t.reserve(self, cnt: "size_t") -> None -ida_name.ea_name_vec_t.swap (method) - swap(self, r) - - @param r: qvector< ea_name_t > & +ida_name.ea_name_vec_t.resize(self, *args) -> None -ida_name.ea_name_vec_t.truncate (method) - truncate(self) +ida_name.ea_name_vec_t.size(self) -> "size_t" -ida_name.extract_name (function) - extract_name(line, x) -> str - Extract a name or address from the specified string. - - @param line: (C++: const char *) input string - @param x: (C++: int) x coordinate of cursor - @return: -1 if cannot extract. otherwise length of the name +ida_name.ea_name_vec_t.swap(self, r: "ea_name_vec_t") -> None -ida_name.force_name (function) - force_name(ea, name, flags=0) -> bool - - @param ea: ea_t - @param name: char const * - @param flags: int +ida_name.ea_name_vec_t.truncate(self) -> None -ida_name.get_colored_demangled_name (function) - get_colored_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring - - @param ea: ea_t - @param inhibitor: int32 - @param demform: int - @param gtn_flags: int +ida_name.extract_name(line: str, x: int) -> str + Extract a name or address from the specified string. + + @param line: input string + @param x: x coordinate of cursor + @returns -1 if cannot extract. otherwise length of the name -ida_name.get_colored_long_name (function) - get_colored_long_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int +ida_name.force_name(ea: ida_idaapi.ea_t, name: str, flags: int = 0) -> bool -ida_name.get_colored_name (function) - get_colored_name(ea) -> qstring - - @param ea: ea_t +ida_name.get_colored_demangled_name(ea: ida_idaapi.ea_t, inhibitor: int, demform: int, gtn_flags: int = 0) -> str -ida_name.get_colored_short_name (function) - get_colored_short_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int +ida_name.get_colored_long_name(ea: ida_idaapi.ea_t, gtn_flags: int = 0) -> str -ida_name.get_cp_validity (function) - get_cp_validity(kind, cp, endcp=wchar32_t(-1)) -> bool - Is the given codepoint (or range) acceptable in the given context? If 'endcp' is - not BADCP, it is considered to be the end of the range: [cp, endcp), and is not - included in the range - - @param kind: (C++: ucdr_kind_t) enum ucdr_kind_t - @param cp: (C++: wchar32_t) - @param endcp: (C++: wchar32_t) +ida_name.get_colored_name(ea: ida_idaapi.ea_t) -> str -ida_name.get_debug_name (function) - get_debug_name(ea_ptr, how) -> str - - @param ea_ptr: ea_t * - @param how: enum debug_name_how_t +ida_name.get_colored_short_name(ea: ida_idaapi.ea_t, gtn_flags: int = 0) -> str -ida_name.get_debug_name_ea (function) - get_debug_name_ea(name) -> ea_t - - @param name: char const * +ida_name.get_cp_validity(*args) -> bool + Is the given codepoint (or range) acceptable in the given context? If 'endcp' is not BADCP, it is considered to be the end of the range: [cp, endcp), and is not included in the range + -ida_name.get_debug_names (function) - get_debug_names(names, ea1, ea2) - - @param names: ea_name_vec_t * - @param ea1: ea_t - @param ea2: ea_t - - get_debug_names(ea1, ea2, return_list=False) -> dict or None - - @param ea1: ea_t - @param ea2: ea_t - @param return_list: bool +ida_name.get_debug_name(ea_ptr: "ea_t *", how: "debug_name_how_t") -> str -ida_name.get_demangled_name (function) - get_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring - - @param ea: ea_t - @param inhibitor: int32 - @param demform: int - @param gtn_flags: int +ida_name.get_debug_name_ea(name: str) -> ida_idaapi.ea_t -ida_name.get_ea_name (function) - get_ea_name(ea, gtn_flags=0) -> qstring - Get name at the specified address. - - @param ea: (C++: ea_t) linear address - @param gtn_flags: (C++: int) how exactly the name should be retrieved. combination of bits - for get_ea_name() function. There is a convenience bits - @return: success +ida_name.get_debug_names(*args) -> "PyObject *" -ida_name.get_long_name (function) - get_long_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int +ida_name.get_demangled_name(ea: ida_idaapi.ea_t, inhibitor: int, demform: int, gtn_flags: int = 0) -> str -ida_name.get_mangled_name_type (function) - get_mangled_name_type(name) -> mangled_name_type_t - - @param name: char const * +ida_name.get_ea_name(ea: ida_idaapi.ea_t, gtn_flags: int = 0) -> str + Get name at the specified address. + + @param ea: linear address + @param gtn_flags: how exactly the name should be retrieved. combination of bits for get_ea_name() function. There is a convenience bits + @returns success -ida_name.get_name (function) - get_name(ea) -> qstring - - @param ea: ea_t +ida_name.get_long_name(ea: ida_idaapi.ea_t, gtn_flags: int = 0) -> str -ida_name.get_name_base_ea (function) - get_name_base_ea(_from, to) -> ea_t - Get address of the name used in the expression for the address - - @param from: (C++: ea_t) address of the operand which references to the address - @param to: (C++: ea_t) the referenced address - @return: address of the name used to represent the operand +ida_name.get_mangled_name_type(name: str) -> "mangled_name_type_t" -ida_name.get_name_color (function) - get_name_color(_from, ea) -> color_t +ida_name.get_name(ea: ida_idaapi.ea_t) -> str + +ida_name.get_name_base_ea(_from: ida_idaapi.ea_t, to: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get address of the name used in the expression for the address + + @param to: the referenced address + @returns address of the name used to represent the operand + +ida_name.get_name_color(_from: ida_idaapi.ea_t, ea: ida_idaapi.ea_t) -> "color_t" Calculate flags for get_ea_name() function. - Get name color. - - @param from: (C++: ea_t) linear address where the name is used. if not applicable, then - should be BADADDR. The kernel returns a local name color if the - reference is within a function, i.e. 'from' and 'ea' belong to the - same function. - @param ea: (C++: ea_t) linear address + Get name color. + + @param ea: linear address -ida_name.get_name_ea (function) - get_name_ea(_from, name) -> ea_t - Get the address of a name. This function resolves a name into an address. It can - handle regular global and local names, as well as debugger names. - - @param from: (C++: ea_t) linear address where the name is used. If specified, the local - labels of the function at the specified address will will be - checked. BADADDR means that local names won't be consulted. - @param name: (C++: const char *) any name in the program or nullptr - @return: address of the name or BADADDR +ida_name.get_name_ea(_from: ida_idaapi.ea_t, name: str) -> ida_idaapi.ea_t + Get the address of a name. This function resolves a name into an address. It can handle regular global and local names, as well as debugger names. + + @param name: any name in the program or nullptr + @returns address of the name or BADADDR -ida_name.get_name_expr (function) - get_name_expr(_from, n, ea, off, flags=0x0001) -> str - Convert address to name expression (name with a displacement). This function - takes into account fixup information and returns a colored name expression (in - the form <name> +/- <offset>). It also knows about structure members and arrays. - If the specified address doesn't have a name, a dummy name is generated. - - @param from: (C++: ea_t) linear address of instruction operand or data referring to the - name. This address will be used to get fixup information, so it - should point to exact position of the operand in the instruction. - @param n: (C++: int) number of referencing operand. for data items specify 0 - @param ea: (C++: ea_t) address to convert to name expression - @param off: (C++: uval_t) the value of name expression. this parameter is used only to check - that the name expression will have the wanted value. 'off' may be - equal to BADADDR but this is discouraged because it prohibits - checks. - @param flags: (C++: int) Name expression flags - @return: < 0 if address is not valid, no segment or other failure. otherwise the - length of the name expression in characters. +ida_name.get_name_expr(_from: ida_idaapi.ea_t, n: int, ea: ida_idaapi.ea_t, off: int, flags: int = 1) -> str + Convert address to name expression (name with a displacement). This function takes into account fixup information and returns a colored name expression (in the form <name> +/- <offset>). It also knows about structure members and arrays. If the specified address doesn't have a name, a dummy name is generated. + + @param n: number of referencing operand. for data items specify 0 + @param ea: address to convert to name expression + @param off: the value of name expression. this parameter is used only to check that the name expression will have the wanted value. 'off' may be equal to BADADDR but this is discouraged because it prohibits checks. + @param flags: Name expression flags + @returns < 0 if address is not valid, no segment or other failure. otherwise the length of the name expression in characters. -ida_name.get_name_value (function) - get_name_value(_from, name) -> int - Get value of the name. This function knows about: regular names, enums, special - segments, etc. - - @param from: (C++: ea_t) linear address where the name is used if not applicable, then - should be BADADDR - @param name: (C++: const char *) any name in the program or nullptr - @return: Name value result codes +ida_name.get_name_value(_from: ida_idaapi.ea_t, name: str) -> "uval_t *" + Get value of the name. This function knows about: regular names, enums, special segments, etc. + + @param name: any name in the program or nullptr + @returns Name value result codes -ida_name.get_nice_colored_name (function) - get_nice_colored_name(ea, flags=0) -> str +ida_name.get_nice_colored_name(ea: ida_idaapi.ea_t, flags: int = 0) -> str Get a nice colored name at the specified address. Ex: * segment:sub+offset * segment:sub:local_label @@ -51677,1445 +35658,630 @@ ida_name.get_nice_colored_name (function) * segment:address * segment:address+offset - @param ea: (C++: ea_t) linear address - @param flags: (C++: int) Nice colored name flags - @return: the length of the generated name in bytes. - -ida_name.get_nlist_ea (function) - get_nlist_ea(idx) -> ea_t - Get address from the list at 'idx'. - @param idx: (C++: size_t) - -ida_name.get_nlist_idx (function) - get_nlist_idx(ea) -> size_t - Get index of the name in the list - @warning: returns the closest match. may return idx >= size. - @param ea: (C++: ea_t) + @param ea: linear address + @param flags: Nice colored name flags + @returns the length of the generated name in bytes. -ida_name.get_nlist_name (function) - get_nlist_name(idx) -> char const * - Get name using idx. - - @param idx: (C++: size_t) +ida_name.get_nlist_ea(idx: "size_t") -> ida_idaapi.ea_t -ida_name.get_nlist_size (function) - get_nlist_size() -> size_t - Get number of names in the list. +ida_name.get_nlist_idx(ea: ida_idaapi.ea_t) -> "size_t" -ida_name.get_short_name (function) - get_short_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int +ida_name.get_nlist_name(idx: "size_t") -> str -ida_name.get_visible_name (function) - get_visible_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int +ida_name.get_nlist_size() -> "size_t" -ida_name.hide_name (function) - hide_name(ea) - Remove name from the list of names - - @param ea: (C++: ea_t) address of the name +ida_name.get_short_name(ea: ida_idaapi.ea_t, gtn_flags: int = 0) -> str -ida_name.is_ident (function) - is_ident(name) -> bool +ida_name.get_visible_name(ea: ida_idaapi.ea_t, gtn_flags: int = 0) -> str + +ida_name.hide_name(ea: ida_idaapi.ea_t) -> None + Remove name from the list of names + + @param ea: address of the name + +ida_name.is_ident(name: str) -> bool Is a valid name? (including ::MangleChars) - - @param name: (C++: const char *) char const * -ida_name.is_ident_cp (function) - is_ident_cp(cp) -> bool +ida_name.is_ident_cp(cp: "wchar32_t") -> bool Can a character appear in a name? (present in ::NameChars or ::MangleChars) - - @param cp: (C++: wchar32_t) -ida_name.is_in_nlist (function) - is_in_nlist(ea) -> bool - Is the name included into the name list? - - @param ea: (C++: ea_t) +ida_name.is_in_nlist(ea: ida_idaapi.ea_t) -> bool -ida_name.is_name_defined_locally (function) - is_name_defined_locally(pfn, name, ignore_name_def, ea1=BADADDR, ea2=BADADDR) -> bool - Is the name defined locally in the specified function? - - @param pfn: (C++: func_t *) pointer to function - @param name: (C++: const char *) name to check - @param ignore_name_def: (C++: ignore_name_def_t) which names to ignore when checking - @param ea1: (C++: ea_t) the starting address of the range inside the function (optional) - @param ea2: (C++: ea_t) the ending address of the range inside the function (optional) - @return: true if the name has been defined +ida_name.is_name_defined_locally(*args) -> bool + Is the name defined locally in the specified function? + + @param pfn: pointer to function + @param name: name to check + @param ignore_name_def: which names to ignore when checking + @param ea1: the starting address of the range inside the function (optional) + @param ea2: the ending address of the range inside the function (optional) + @returns true if the name has been defined -ida_name.is_public_name (function) - is_public_name(ea) -> bool - - @param ea: ea_t +ida_name.is_public_name(ea: ida_idaapi.ea_t) -> bool -ida_name.is_strlit_cp (function) - is_strlit_cp(cp, specific_ranges=None) -> bool - Can a character appear in a string literal (present in ::StrlitChars) If - 'specific_ranges' are specified, those will be used instead of the ones - corresponding to the current culture (only if ::StrlitChars is configured to use - the current culture) - - @param cp: (C++: wchar32_t) - @param specific_ranges: (C++: const rangeset_crefvec_t *) rangeset_crefvec_t const * +ida_name.is_strlit_cp(cp: "wchar32_t", specific_ranges: "rangeset_crefvec_t const *" = None) -> bool + Can a character appear in a string literal (present in ::StrlitChars) If 'specific_ranges' are specified, those will be used instead of the ones corresponding to the current culture (only if ::StrlitChars is configured to use the current culture) + -ida_name.is_uname (function) - is_uname(name) -> bool - Is valid user-specified name? (valid name & !dummy prefix). - - @param name: (C++: const char *) name to test. may be nullptr. +ida_name.is_uname(name: str) -> bool + Is valid user-specified name? (valid name & !dummy prefix). + + @param name: name to test. may be nullptr. @retval 1: yes @retval 0: no -ida_name.is_valid_cp (function) - is_valid_cp(cp, kind, data=None) -> bool +ida_name.is_valid_cp(cp: "wchar32_t", kind: "nametype_t", data: "void *" = None) -> bool Is the given codepoint acceptable in the given context? - - @param cp: (C++: wchar32_t) - @param kind: (C++: nametype_t) enum nametype_t - @param data: (C++: void *) -ida_name.is_valid_name (function) - is_valid_name(name, cpuregs_permitted) -> bool - - @param name: char const * - @param cpuregs_permitted: bool - -ida_name.is_valid_typename (function) - is_valid_typename(name) -> bool - Is valid type name? - - @param name: (C++: const char *) name to test. may be nullptr. +ida_name.is_valid_typename(name: str) -> bool + Is valid type name? + + @param name: name to test. may be nullptr. @retval 1: yes @retval 0: no -ida_name.is_visible_cp (function) - is_visible_cp(cp) -> bool +ida_name.is_visible_cp(cp: "wchar32_t") -> bool Can a character be displayed in a name? (present in ::NameChars) - - @param cp: (C++: wchar32_t) -ida_name.is_weak_name (function) - is_weak_name(ea) -> bool - - @param ea: ea_t +ida_name.is_weak_name(ea: ida_idaapi.ea_t) -> bool -ida_name.make_name_auto (function) - make_name_auto(ea) -> bool - - @param ea: ea_t +ida_name.make_name_auto(ea: ida_idaapi.ea_t) -> bool -ida_name.make_name_non_public (function) - make_name_non_public(ea) - - @param ea: ea_t +ida_name.make_name_non_public(ea: ida_idaapi.ea_t) -> None -ida_name.make_name_non_weak (function) - make_name_non_weak(ea) - - @param ea: ea_t +ida_name.make_name_non_weak(ea: ida_idaapi.ea_t) -> None -ida_name.make_name_public (function) - make_name_public(ea) - - @param ea: ea_t +ida_name.make_name_public(ea: ida_idaapi.ea_t) -> None -ida_name.make_name_user (function) - make_name_user(ea) -> bool - - @param ea: ea_t +ida_name.make_name_user(ea: ida_idaapi.ea_t) -> bool -ida_name.make_name_weak (function) - make_name_weak(ea) - - @param ea: ea_t +ida_name.make_name_weak(ea: ida_idaapi.ea_t) -> None -ida_name.rebuild_nlist (function) - rebuild_nlist() - Rebuild the name list. +ida_name.rebuild_nlist() -> None -ida_name.reorder_dummy_names (function) - reorder_dummy_names() +ida_name.reorder_dummy_names() -> None Renumber dummy names. -ida_name.set_cp_validity (function) - set_cp_validity(kind, cp, endcp=wchar32_t(-1), valid=True) - Mark the given codepoint (or range) as acceptable or unacceptable in the given - context If 'endcp' is not BADCP, it is considered to be the end of the range: - [cp, endcp), and is not included in the range - - @param kind: (C++: ucdr_kind_t) enum ucdr_kind_t - @param cp: (C++: wchar32_t) - @param endcp: (C++: wchar32_t) +ida_name.set_cp_validity(*args) -> None + Mark the given codepoint (or range) as acceptable or unacceptable in the given context If 'endcp' is not BADCP, it is considered to be the end of the range: [cp, endcp), and is not included in the range + -ida_name.set_debug_name (function) - set_debug_name(ea, name) -> bool - - @param ea: ea_t - @param name: char const * +ida_name.set_debug_name(ea: ida_idaapi.ea_t, name: str) -> bool -ida_name.set_dummy_name (function) - set_dummy_name(_from, ea) -> bool - Give an autogenerated (dummy) name. Autogenerated names have special prefixes - (loc_...). - - @param from: (C++: ea_t) linear address of the operand which references to the address - @param ea: (C++: ea_t) linear address +ida_name.set_dummy_name(_from: ida_idaapi.ea_t, ea: ida_idaapi.ea_t) -> bool + Give an autogenerated (dummy) name. Autogenerated names have special prefixes (loc_...). + + @param ea: linear address @retval 1: ok, dummy name is generated or the byte already had a name @retval 0: failure, invalid address or tail byte -ida_name.set_name (function) - set_name(ea, name, flags=0) -> bool - Set or delete name of an item at the specified address. An item can be anything: - instruction, function, data byte, word, string, structure, etc... Include name - into the list of names. - - @param ea: (C++: ea_t) linear address. do nothing if ea is not valid (return 0). tail bytes - can't have names. - @param name: (C++: const char *) new name. +ida_name.set_name(ea: ida_idaapi.ea_t, name: str, flags: int = 0) -> bool + Set or delete name of an item at the specified address. An item can be anything: instruction, function, data byte, word, string, structure, etc... Include name into the list of names. + + @param ea: linear address. do nothing if ea is not valid (return 0). tail bytes can't have names. + @param name: new name. * nullptr: do nothing (return 0). * "" : delete name. * otherwise this is a new name. - @param flags: (C++: int) Set name flags. If a bit is not specified, then the corresponding - action is not performed and the name will retain the same bits as - before calling this function. For new names, default is: non- - public, non-weak, non-auto. + @param flags: Set name flags. If a bit is not specified, then the corresponding action is not performed and the name will retain the same bits as before calling this function. For new names, default is: non-public, non-weak, non-auto. @retval 1: ok, name is changed @retval 0: failure, a warning is displayed -ida_name.show_name (function) - show_name(ea) +ida_name.show_name(ea: ida_idaapi.ea_t) -> None Insert name to the list of names. - - @param ea: (C++: ea_t) -ida_name.validate_name (function) - validate_name(name, type, flags=0) -> PyObject * - Validate a name. If SN_NOCHECK is specified, this function replaces all invalid - characters in the name with SUBSTCHAR. However, it will return false if name is - valid but not allowed to be an identifier (is a register name). +ida_name.validate_name(name: str, type: "nametype_t", flags: int = 1) -> "PyObject *" + Validate a name. If SN_NOCHECK is specified, this function replaces all invalid characters in the name with SUBSTCHAR. However, it will return false if name is valid but not allowed to be an identifier (is a register name). - @param name: (C++: qstring *) ptr to name. the name will be modified - @param type: (C++: nametype_t) the type of name we want to validate - @param flags: (C++: int) see SN_* - @return: success + @param name: ptr to name. the name will be modified + @param type: the type of name we want to validate + @param flags: see SN_* + @returns success -ida_netnode (module) - Functions that provide the lowest level public interface to the database. - Namely, we use Btree. To learn more about BTree: - - \link{https://en.wikipedia.org/wiki/B-tree} - - We do not use Btree directly. Instead, we have another layer built on the top of - Btree. Here is a brief explanation of this layer. - - An object called "netnode" is modeled on the top of Btree. Each netnode has a - unique id: a 32-bit value (64-bit for ida64). Initially there is a trivial - mapping of the linear addresses used in the program to netnodes (later this - mapping may be modified using ea2node and node2ea functions; this is used for - fast database rebasings). If we have additional information about an address - (for example, a comment is attached to it), this information is stored in the - corresponding netnode. See nalt.hpp to see how the kernel uses netnodes. Also, - some netnodes have no corresponding linear address (however, they still have an - id). They are used to store information not related to a particular address. +ida_netnode + Functions that provide the lowest level public interface to the database. Namely, we use Btree. To learn more about BTree: + [https://en.wikipedia.org/wiki/B-tree](https://en.wikipedia.org/wiki/B-tree) + We do not use Btree directly. Instead, we have another layer built on the top of Btree. Here is a brief explanation of this layer. + An object called "netnode" is modeled on the top of Btree. Each netnode has a unique id: a 32-bit value (64-bit for ida64). Initially there is a trivial mapping of the linear addresses used in the program to netnodes (later this mapping may be modified using ea2node and node2ea functions; this is used for fast database rebasings). If we have additional information about an address (for example, a comment is attached to it), this information is stored in the corresponding netnode. See nalt.hpp to see how the kernel uses netnodes. Also, some netnodes have no corresponding linear address (however, they still have an id). They are used to store information not related to a particular address. Each netnode _may_ have the following attributes: * a name: an arbitrary non-empty string, up to 255KB-1 bytes * a value: arbitrary sized object, max size is MAXSPECSIZE - * altvals: a sparse array of 32-bit values. indexes in this array may be 8-bit - or 32-bit values - * supvals: an array of arbitrary sized objects. (size of each object is limited - by MAXSPECSIZE) indexes in this array may be 8-bit or 32-bit values - * charvals: a sparse array of 8-bit values. indexes in this array may be 8-bit - or 32-bit values - * hashvals: a hash (an associative array). indexes in this array are strings - values are arbitrary sized (max size is MAXSPECSIZE) + * altvals: a sparse array of 32-bit values. indexes in this array may be 8-bit or 32-bit values + * supvals: an array of arbitrary sized objects. (size of each object is limited by MAXSPECSIZE) indexes in this array may be 8-bit or 32-bit values + * charvals: a sparse array of 8-bit values. indexes in this array may be 8-bit or 32-bit values + * hashvals: a hash (an associative array). indexes in this array are strings values are arbitrary sized (max size is MAXSPECSIZE) - Initially a new netnode contains no information at all so no disk space is used - for it. As you add new information, the netnode grows. - All arrays that are attached to the netnode behave in the same manner. - Initially: + Initially a new netnode contains no information at all so no disk space is used for it. As you add new information, the netnode grows. + All arrays that are attached to the netnode behave in the same manner. Initially: * all members of altvals/charvals array are zeroes * all members of supvals/hashvals array are undefined - If you need to store objects bigger that MAXSPECSIZE, please note that there are - high-level functions to store arbitrary sized objects in supvals. See - setblob/getblob and other blob-related functions. - You may use netnodes to store additional information about the program. - Limitations on the use of netnodes are the following: + If you need to store objects bigger that MAXSPECSIZE, please note that there are high-level functions to store arbitrary sized objects in supvals. See setblob/getblob and other blob-related functions. + You may use netnodes to store additional information about the program. Limitations on the use of netnodes are the following: - * use netnodes only if you could not find a kernel service to store your type of - information - * do not create netnodes with valid identifier names. Use the "$ " prefix (or - any other prefix with characters not allowed in the identifiers for the names of - your netnodes. Although you will probably not destroy anything by accident, - using already defined names for the names of your netnodes is still discouraged. - * you may create as many netnodes as you want (creation of an unnamed netnode - does not increase the size of the database). however, since each netnode has a - number, creating too many netnodes could lead to the exhaustion of the netnode - numbers (the numbering starts at 0xFF000000) + * use netnodes only if you could not find a kernel service to store your type of information + * do not create netnodes with valid identifier names. Use the "$ " prefix (or any other prefix with characters not allowed in the identifiers for the names of your netnodes. Although you will probably not destroy anything by accident, using already defined names for the names of your netnodes is still discouraged. + * you may create as many netnodes as you want (creation of an unnamed netnode does not increase the size of the database). however, since each netnode has a number, creating too many netnodes could lead to the exhaustion of the netnode numbers (the numbering starts at 0xFF000000) * remember that netnodes are automatically saved to the disk by the kernel. - Advanced info: - In fact a netnode may contain up to 256 arrays of arbitrary sized objects (not - only the 4 listed above). Each array has an 8-bit tag. Usually tags are - represented by character constants. For example, altvals and supvals are simply - 2 of 256 arrays, with the tags 'A' and 'S' respectively. + Advanced info: + In fact a netnode may contain up to 256 arrays of arbitrary sized objects (not only the 4 listed above). Each array has an 8-bit tag. Usually tags are represented by character constants. For example, altvals and supvals are simply 2 of 256 arrays, with the tags 'A' and 'S' respectively. + -ida_netnode.BADNODE (variable) +ida_netnode.BADNODE A number to represent a bad netnode reference. -ida_netnode.MAXNAMESIZE (variable) +ida_netnode.MAXNAMESIZE Maximum length of a netnode name. WILL BE REMOVED IN THE FUTURE. -ida_netnode.MAXSPECSIZE (variable) +ida_netnode.MAXSPECSIZE Maximum length of strings or objects stored in a supval array element. -ida_netnode.MAX_NODENAME_SIZE (variable) +ida_netnode.MAX_NODENAME_SIZE Maximum length of a name. We permit names up to 32KB-1 bytes. -ida_netnode.atag (variable) +ida_netnode.atag Array of altvals. -ida_netnode.exist (function) - exist(n) -> bool - - @param n: netnode const & +ida_netnode.exist(n: "netnode") -> bool -ida_netnode.htag (variable) +ida_netnode.htag Array of hashvals. -ida_netnode.ltag (variable) +ida_netnode.ltag Links between netnodes. -ida_netnode.netnode (class) - Proxy of C++ netnode class. +ida_netnode.netnode -ida_netnode.netnode.__eq__ (method) - __eq__(self, n) -> bool - - @param n: netnode & - - __eq__(self, x) -> bool - - @param x: nodeidx_t +ida_netnode.netnode.__eq__(self, *args) -> bool -ida_netnode.netnode.__init__ (method) - __init__(self, num=nodeidx_t(-1)) -> netnode - - @param num: nodeidx_t - - __init__(self, _name, namlen=0, do_create=False) -> netnode - - @param _name: char const * - @param namlen: size_t - @param do_create: bool +ida_netnode.netnode.__init__(self, *args) -ida_netnode.netnode.__ne__ (method) - __ne__(self, n) -> bool - - @param n: netnode & - - __ne__(self, x) -> bool - - @param x: nodeidx_t +ida_netnode.netnode.__ne__(self, *args) -> bool -ida_netnode.netnode.altdel (method) - altdel(self, alt, tag=atag) -> bool - Delete all elements of altval array. This function may be applied to 32-bit and - 8-bit altval arrays. This function deletes the whole altval array. - - @param alt: nodeidx_t - @param tag: uchar - - @return: success - altdel(self) -> bool +ida_netnode.netnode.altdel(self, *args) -> bool -ida_netnode.netnode.altdel_all (method) - altdel_all(self, tag=atag) -> bool - Delete all elements of the specified altval array. This function may be applied - to 32-bit and 8-bit altval arrays. This function deletes the whole altval array. - - @param tag: (C++: uchar) tag of array - @return: success +ida_netnode.netnode.altdel_all(self, *args) -> bool -ida_netnode.netnode.altdel_ea (method) - altdel_ea(self, ea, tag=atag) -> bool - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.altdel_ea(self, *args) -> bool -ida_netnode.netnode.altdel_idx8 (method) - altdel_idx8(self, alt, tag) -> bool - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.altdel_idx8(self, alt: "uchar", tag: "uchar") -> bool -ida_netnode.netnode.altfirst (method) - altfirst(self, tag=atag) -> nodeidx_t - Get first existing element of altval array. - - @param tag: (C++: uchar) tag of array - @return: index of first existing element of altval array, BADNODE if altval - array is empty +ida_netnode.netnode.altfirst(self, *args) -> "nodeidx_t" -ida_netnode.netnode.altfirst_idx8 (method) - altfirst_idx8(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.altfirst_idx8(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.altlast (method) - altlast(self, tag=atag) -> nodeidx_t - Get last element of altval array. - - @param tag: (C++: uchar) tag of array - @return: index of last existing element of altval array, BADNODE if altval array - is empty +ida_netnode.netnode.altlast(self, *args) -> "nodeidx_t" -ida_netnode.netnode.altlast_idx8 (method) - altlast_idx8(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.altlast_idx8(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.altnext (method) - altnext(self, cur, tag=atag) -> nodeidx_t - Get next existing element of altval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the next existing element of altval array, BADNODE if no more - altval array elements exist +ida_netnode.netnode.altnext(self, *args) -> "nodeidx_t" -ida_netnode.netnode.altnext_idx8 (method) - altnext_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar +ida_netnode.netnode.altnext_idx8(self, cur: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.altprev (method) - altprev(self, cur, tag=atag) -> nodeidx_t - Get previous existing element of altval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the previous existing element of altval array, BADNODE if no - more altval array elements exist +ida_netnode.netnode.altprev(self, *args) -> "nodeidx_t" -ida_netnode.netnode.altprev_idx8 (method) - altprev_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar +ida_netnode.netnode.altprev_idx8(self, cur: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.altset (method) - altset(self, alt, value, tag=atag) -> bool - Set value of altval array. - - @param alt: (C++: nodeidx_t) index into array of altvals - @param value: (C++: nodeidx_t) new value of altval element - @param tag: (C++: uchar) tag of array - @retval 1: ok - @retval 0: failed, normally should not occur +ida_netnode.netnode.altset(self, *args) -> bool -ida_netnode.netnode.altset_ea (method) - altset_ea(self, ea, value, tag=atag) -> bool - - @param ea: ea_t - @param value: nodeidx_t - @param tag: uchar +ida_netnode.netnode.altset_ea(self, *args) -> bool -ida_netnode.netnode.altset_idx8 (method) - altset_idx8(self, alt, val, tag) -> bool - - @param alt: uchar - @param val: nodeidx_t - @param tag: uchar +ida_netnode.netnode.altset_idx8(self, alt: "uchar", val: "nodeidx_t", tag: "uchar") -> bool -ida_netnode.netnode.altshift (method) - altshift(self, _from, to, size, tag=atag) -> size_t - Shift the altval array elements. Moves the array elements at (from..from+size) - to (to..to+size) - - @param from: (C++: nodeidx_t) - @param to: (C++: nodeidx_t) - @param size: (C++: nodeidx_t) - @param tag: (C++: uchar) - @return: number of shifted elements +ida_netnode.netnode.altshift(self, *args) -> "size_t" -ida_netnode.netnode.altval (method) - altval(self, alt, tag=atag) -> nodeidx_t - Get altval element of the specified array. - - @param alt: (C++: nodeidx_t) index into array of altvals - @param tag: (C++: uchar) tag of array. may be omitted - @return: value of altval element. nonexistent altval members are returned as - zeroes +ida_netnode.netnode.altval(self, *args) -> "nodeidx_t" -ida_netnode.netnode.altval_ea (method) - altval_ea(self, ea, tag=atag) -> nodeidx_t - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.altval_ea(self, *args) -> "nodeidx_t" -ida_netnode.netnode.altval_idx8 (method) - altval_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.altval_idx8(self, alt: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.blobshift (method) - blobshift(self, _from, to, size, tag) -> size_t - Shift the blob array elements. Moves the array elements at (from..from+size) to - (to..to+size) - - @param from: (C++: nodeidx_t) - @param to: (C++: nodeidx_t) - @param size: (C++: nodeidx_t) - @param tag: (C++: uchar) - @return: number of shifted elements +ida_netnode.netnode.blobshift(self, _from: "nodeidx_t", to: "nodeidx_t", size: "nodeidx_t", tag: "uchar") -> "size_t" -ida_netnode.netnode.blobsize (method) - blobsize(self, _start, tag) -> size_t - Get size of blob. - - @param _start: (C++: nodeidx_t) index of the first supval element used to store blob - @param tag: (C++: uchar) tag of supval array - @return: number of bytes required to store a blob +ida_netnode.netnode.blobsize(self, _start: "nodeidx_t", tag: "uchar") -> "size_t" -ida_netnode.netnode.blobsize_ea (method) - blobsize_ea(self, ea, tag) -> size_t - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.blobsize_ea(self, ea: ida_idaapi.ea_t, tag: "uchar") -> "size_t" -ida_netnode.netnode.chardel (method) - chardel(self, alt, tag) -> bool - - @param alt: nodeidx_t - @param tag: uchar +ida_netnode.netnode.chardel(self, alt: "nodeidx_t", tag: "uchar") -> bool -ida_netnode.netnode.chardel_ea (method) - chardel_ea(self, ea, tag) -> bool - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.chardel_ea(self, ea: ida_idaapi.ea_t, tag: "uchar") -> bool -ida_netnode.netnode.chardel_idx8 (method) - chardel_idx8(self, alt, tag) -> bool - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.chardel_idx8(self, alt: "uchar", tag: "uchar") -> bool -ida_netnode.netnode.charfirst (method) - charfirst(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.charfirst(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charfirst_idx8 (method) - charfirst_idx8(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.charfirst_idx8(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charlast (method) - charlast(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.charlast(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charlast_idx8 (method) - charlast_idx8(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.charlast_idx8(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charnext (method) - charnext(self, cur, tag) -> nodeidx_t - - @param cur: nodeidx_t - @param tag: uchar +ida_netnode.netnode.charnext(self, cur: "nodeidx_t", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charnext_idx8 (method) - charnext_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar +ida_netnode.netnode.charnext_idx8(self, cur: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charprev (method) - charprev(self, cur, tag) -> nodeidx_t - - @param cur: nodeidx_t - @param tag: uchar +ida_netnode.netnode.charprev(self, cur: "nodeidx_t", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charprev_idx8 (method) - charprev_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar +ida_netnode.netnode.charprev_idx8(self, cur: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.charset (method) - charset(self, alt, val, tag) -> bool - - @param alt: nodeidx_t - @param val: uchar - @param tag: uchar +ida_netnode.netnode.charset(self, alt: "nodeidx_t", val: "uchar", tag: "uchar") -> bool -ida_netnode.netnode.charset_ea (method) - charset_ea(self, ea, val, tag) -> bool - - @param ea: ea_t - @param val: uchar - @param tag: uchar +ida_netnode.netnode.charset_ea(self, ea: ida_idaapi.ea_t, val: "uchar", tag: "uchar") -> bool -ida_netnode.netnode.charset_idx8 (method) - charset_idx8(self, alt, val, tag) -> bool - - @param alt: uchar - @param val: uchar - @param tag: uchar +ida_netnode.netnode.charset_idx8(self, alt: "uchar", val: "uchar", tag: "uchar") -> bool -ida_netnode.netnode.charshift (method) - charshift(self, _from, to, size, tag) -> size_t - - @param from: nodeidx_t - @param to: nodeidx_t - @param size: nodeidx_t - @param tag: uchar +ida_netnode.netnode.charshift(self, _from: "nodeidx_t", to: "nodeidx_t", size: "nodeidx_t", tag: "uchar") -> "size_t" -ida_netnode.netnode.charval (method) - charval(self, alt, tag) -> uchar - - @param alt: nodeidx_t - @param tag: uchar +ida_netnode.netnode.charval(self, alt: "nodeidx_t", tag: "uchar") -> "uchar" -ida_netnode.netnode.charval_ea (method) - charval_ea(self, ea, tag) -> uchar - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.charval_ea(self, ea: ida_idaapi.ea_t, tag: "uchar") -> "uchar" -ida_netnode.netnode.charval_idx8 (method) - charval_idx8(self, alt, tag) -> uchar - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.charval_idx8(self, alt: "uchar", tag: "uchar") -> "uchar" -ida_netnode.netnode.copyto (method) - copyto(self, destnode, count=1) -> size_t - - @param destnode: netnode - @param count: nodeidx_t +ida_netnode.netnode.copyto(self, destnode: "netnode", count: "nodeidx_t" = 1) -> "size_t" -ida_netnode.netnode.create (method) - create(self, _name, namlen=0) -> bool - Create unnamed netnode. - @retval 1: ok - @retval 0: should not happen, indicates internal error - - @param _name: char const * - @param namlen: size_t - - create(self) -> bool +ida_netnode.netnode.create(self, *args) -> bool -ida_netnode.netnode.delblob (method) - delblob(self, _start, tag) -> int - Delete a blob. - - @param _start: (C++: nodeidx_t) index of the first supval element used to store blob - @param tag: (C++: uchar) tag of supval array - @return: number of deleted supvals +ida_netnode.netnode.delblob(self, _start: "nodeidx_t", tag: "uchar") -> int -ida_netnode.netnode.delblob_ea (method) - delblob_ea(self, ea, tag) -> int - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.delblob_ea(self, ea: ida_idaapi.ea_t, tag: "uchar") -> int -ida_netnode.netnode.delvalue (method) - delvalue(self) -> bool - Delete value of netnode. - @retval 1: ok - @retval 0: failed, netnode is bad or other error +ida_netnode.netnode.delvalue(self) -> bool -ida_netnode.netnode.eadel (method) - eadel(self, ea, tag) -> bool - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.eadel(self, ea: ida_idaapi.ea_t, tag: "uchar") -> bool -ida_netnode.netnode.eadel_idx8 (method) - eadel_idx8(self, idx, tag) -> bool - - @param idx: uchar - @param tag: uchar +ida_netnode.netnode.eadel_idx8(self, idx: "uchar", tag: "uchar") -> bool -ida_netnode.netnode.eaget (method) - eaget(self, ea, tag) -> ea_t - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.eaget(self, ea: ida_idaapi.ea_t, tag: "uchar") -> ida_idaapi.ea_t -ida_netnode.netnode.eaget_idx (method) - eaget_idx(self, idx, tag) -> ea_t - - @param idx: nodeidx_t - @param tag: uchar +ida_netnode.netnode.eaget_idx(self, idx: "nodeidx_t", tag: "uchar") -> ida_idaapi.ea_t -ida_netnode.netnode.eaget_idx8 (method) - eaget_idx8(self, idx, tag) -> ea_t - - @param idx: uchar - @param tag: uchar +ida_netnode.netnode.eaget_idx8(self, idx: "uchar", tag: "uchar") -> ida_idaapi.ea_t -ida_netnode.netnode.easet (method) - easet(self, ea, addr, tag) -> bool - Store/retrieve/delete an address value in the netnode that corresponds to an - address. - - @param ea: (C++: ea_t) - @param addr: (C++: ea_t) - @param tag: (C++: uchar) +ida_netnode.netnode.easet(self, ea: ida_idaapi.ea_t, addr: ida_idaapi.ea_t, tag: "uchar") -> bool -ida_netnode.netnode.easet_idx (method) - easet_idx(self, idx, addr, tag) -> bool - - @param idx: nodeidx_t - @param addr: ea_t - @param tag: uchar +ida_netnode.netnode.easet_idx(self, idx: "nodeidx_t", addr: ida_idaapi.ea_t, tag: "uchar") -> bool -ida_netnode.netnode.easet_idx8 (method) - easet_idx8(self, idx, addr, tag) -> bool - - @param idx: uchar - @param addr: ea_t - @param tag: uchar +ida_netnode.netnode.easet_idx8(self, idx: "uchar", addr: ida_idaapi.ea_t, tag: "uchar") -> bool -ida_netnode.netnode.end (method) - end(self) -> bool - Get last netnode in the graph. Sets netnodenumber to the highest existing - number. - @retval true: ok - @retval false: graph is empty +ida_netnode.netnode.end(self) -> bool -ida_netnode.netnode.exist (method) - exist(_name) -> bool +ida_netnode.netnode.exist(_name: str) -> bool Does the netnode with the specified name exist? + +ida_netnode.netnode.get_name(self) -> "ssize_t" + +ida_netnode.netnode.getblob(self, start, tag) -> Union[bytes, None] + Get a blob from a netnode. - @param _name: (C++: const char *) char const * + @param start the index where the blob starts (it may span on multiple indexes) + @param tag the netnode tag + @return a blob, or None -ida_netnode.netnode.get_name (method) - get_name(self) -> ssize_t - Get the netnode name. +ida_netnode.netnode.getblob_ea(self, ea: ida_idaapi.ea_t, tag: "char") -> "PyObject *" + +ida_netnode.netnode.getclob(self, start, tag) -> Union[str, None] + Get a large amount of text from a netnode. - @return: -1 if netnode is unnamed (buf is untouched in this case), otherwise the - name length + @param start the index where the clob starts (it may span on multiple indexes) + @param tag the netnode tag + @return a clob, or None -ida_netnode.netnode.getblob (method) - getblob(self, start, tag) -> bytes or None - Get blob from a netnode into a qstring* and make sure the string is null- - terminated. - - @param start: nodeidx_t - @param tag: (C++: uchar) tag of supval array - @return: -1 if blob doesn't exist size of string (including terminating null) - otherwise +ida_netnode.netnode.hashdel(self, *args) -> bool -ida_netnode.netnode.getblob_ea (method) - getblob_ea(self, ea, tag) -> PyObject * - - @param ea: ea_t - @param tag: char +ida_netnode.netnode.hashdel_all(self, *args) -> bool -ida_netnode.netnode.getclob (method) - getclob(self, start, tag) -> str - - @param start: nodeidx_t - @param tag: char +ida_netnode.netnode.hashfirst(self, *args) -> "ssize_t" -ida_netnode.netnode.hashdel (method) - hashdel(self, idx, tag=htag) -> bool - Delete hash element. - - @param idx: (C++: const char *) index into hash - @param tag: (C++: uchar) tag of hash. Default: htag - @retval true: deleted - @retval false: element does not exist +ida_netnode.netnode.hashlast(self, *args) -> "ssize_t" -ida_netnode.netnode.hashdel_all (method) - hashdel_all(self, tag=htag) -> bool - Delete all elements of hash. This function deletes the whole hash. - - @param tag: (C++: uchar) tag of hash. Default: htag - @return: success +ida_netnode.netnode.hashnext(self, *args) -> "ssize_t" -ida_netnode.netnode.hashfirst (method) - hashfirst(self, tag=htag) -> ssize_t - @see: hashfirst(qstring *buf, uchar tag=htag) const - - @param tag: (C++: uchar) +ida_netnode.netnode.hashprev(self, *args) -> "ssize_t" -ida_netnode.netnode.hashlast (method) - hashlast(self, tag=htag) -> ssize_t - @see: hashlast(qstring *buf, uchar tag=htag) const - - @param tag: (C++: uchar) +ida_netnode.netnode.hashset(self, *args) -> bool -ida_netnode.netnode.hashnext (method) - hashnext(self, idx, tag=htag) -> ssize_t - @see: hashnext(qstring *buf, const char *idx, uchar tag=htag) const - - @param idx: (C++: const char *) char const * - @param tag: (C++: uchar) +ida_netnode.netnode.hashset_buf(self, *args) -> bool -ida_netnode.netnode.hashprev (method) - hashprev(self, idx, tag=htag) -> ssize_t - @see: hashprev(qstring *buf, const char *idx, uchar tag=htag) const - - @param idx: (C++: const char *) char const * - @param tag: (C++: uchar) +ida_netnode.netnode.hashset_idx(self, *args) -> bool -ida_netnode.netnode.hashset (method) - hashset(self, idx, value, tag=htag) -> bool - Set value of hash element to long value. - - @param idx: (C++: const char *) index into hash - @param value: (C++: nodeidx_t) new value of hash element - @param tag: (C++: uchar) tag of hash. Default: htag - @retval 1: ok - @retval 0: should not occur - indicates internal error +ida_netnode.netnode.hashstr(self, *args) -> "ssize_t" -ida_netnode.netnode.hashset_buf (method) - hashset_buf(self, idx, py_str, tag=htag) -> bool - - @param idx: char const * - @param py_str: PyObject * - @param tag: char +ida_netnode.netnode.hashstr_buf(self, *args) -> "PyObject *" -ida_netnode.netnode.hashset_idx (method) - hashset_idx(self, idx, value, tag=htag) -> bool - - @param idx: char const * - @param value: nodeidx_t - @param tag: uchar +ida_netnode.netnode.hashval(self, *args) -> "ssize_t" -ida_netnode.netnode.hashstr (method) - hashstr(self, idx, tag=htag) -> ssize_t - @see: hashstr(qstring *buf, const char *idx, uchar tag=htag) const - - @param idx: (C++: const char *) char const * - @param tag: (C++: uchar) +ida_netnode.netnode.hashval_long(self, *args) -> "nodeidx_t" -ida_netnode.netnode.hashstr_buf (method) - hashstr_buf(self, idx, tag=htag) -> PyObject * - - @param idx: char const * - @param tag: char +ida_netnode.netnode.index(self) -> "nodeidx_t" -ida_netnode.netnode.hashval (method) - hashval(self, idx, tag=htag) -> ssize_t - Get value of the specified hash element. - - @param idx: (C++: const char *) index into hash - @param tag: (C++: uchar) tag of hash. Default: htag - @return: -1 if element doesn't exist or idx is nullptr. otherwise returns the - value size in bytes +ida_netnode.netnode.kill(self) -> None -ida_netnode.netnode.hashval_long (method) - hashval_long(self, idx, tag=htag) -> nodeidx_t - Get value of the specified hash element. - - @param idx: (C++: const char *) index into hash - @param tag: (C++: uchar) tag of hash. Default: htag - @return: value of hash element (it should be set using hashset(nodeidx_t)), 0 if - the element does not exist +ida_netnode.netnode.long_value(self) -> "nodeidx_t" -ida_netnode.netnode.index (method) - index(self) -> nodeidx_t +ida_netnode.netnode.lower_bound(self, *args) -> "nodeidx_t" -ida_netnode.netnode.kill (method) - kill(self) - Delete a netnode with all information attached to it. +ida_netnode.netnode.lower_bound_ea(self, *args) -> "nodeidx_t" -ida_netnode.netnode.long_value (method) - long_value(self) -> nodeidx_t +ida_netnode.netnode.lower_bound_idx8(self, alt: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.lower_bound (method) - lower_bound(self, cur, tag=stag) -> nodeidx_t - Get lower bound of existing elements of supval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of first existing element of supval array >= cur BADNODE if - supval array is empty +ida_netnode.netnode.moveto(self, destnode: "netnode", count: "nodeidx_t" = 1) -> "size_t" -ida_netnode.netnode.lower_bound_ea (method) - lower_bound_ea(self, ea, tag=stag) -> nodeidx_t - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.next(self) -> bool -ida_netnode.netnode.lower_bound_idx8 (method) - lower_bound_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.prev(self) -> bool -ida_netnode.netnode.moveto (method) - moveto(self, destnode, count=1) -> size_t - - @param destnode: netnode - @param count: nodeidx_t +ida_netnode.netnode.rename(self, newname: str, namlen: "size_t" = 0) -> bool -ida_netnode.netnode.next (method) - next(self) -> bool - Get next netnode in the graph. Sets netnodenumber to the next existing number - @retval true: ok - @retval false: no more netnodes +ida_netnode.netnode.set(self, value: "void const *") -> bool -ida_netnode.netnode.prev (method) - prev(self) -> bool - Get prev netnode in the graph. Sets netnodenumber to the previous existing - number - @retval true: ok - @retval false: no more netnodes +ida_netnode.netnode.set_long(self, x: "nodeidx_t") -> bool -ida_netnode.netnode.rename (method) - rename(self, newname, namlen=0) -> bool - Rename a netnode. - - @param newname: (C++: const char *) new name of netnode. nullptr or "" means to delete name. names - of user-defined netnodes must have the "$ " prefix in order to - avoid clashes with program byte names. - @param namlen: (C++: size_t) length of new name. if not specified, it will be calculated using - strlen() - @retval 1: ok - @retval 0: failed, newname is already used +ida_netnode.netnode.setblob(self, buf: "void const *", _start: "nodeidx_t", tag: "uchar") -> bool -ida_netnode.netnode.set (method) - set(self, value) -> bool - Set value of netnode. - - @param value: (C++: const void *) pointer to value - @return: 1 - ok +ida_netnode.netnode.setblob_ea(self, buf: "void const *", ea: ida_idaapi.ea_t, tag: "uchar") -> bool -ida_netnode.netnode.set_long (method) - set_long(self, x) -> bool - Value of netnode as a long number: - - @param x: (C++: nodeidx_t) +ida_netnode.netnode.start(self) -> bool -ida_netnode.netnode.setblob (method) - setblob(self, buf, _start, tag) -> bool - Store a blob in a netnode. - - @param buf: (C++: const void *) pointer to blob to save - @param _start: (C++: nodeidx_t) - @param tag: (C++: uchar) tag of supval array - @return: success +ida_netnode.netnode.supdel(self, *args) -> bool -ida_netnode.netnode.setblob_ea (method) - setblob_ea(self, buf, ea, tag) -> bool - - @param buf: void const * - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.supdel_all(self, tag: "uchar") -> bool -ida_netnode.netnode.start (method) - start(self) -> bool - Get first netnode in the graph. Sets netnodenumber to the lowest existing - number. - @retval true: ok - @retval false: graph is empty +ida_netnode.netnode.supdel_ea(self, *args) -> bool -ida_netnode.netnode.supdel (method) - supdel(self, alt, tag=stag) -> bool - Delete all elements of supval array. This function may be applied to 32-bit and - 8-bit supval arrays. This function deletes the whole supval array. - - @param alt: nodeidx_t - @param tag: uchar - - @return: success - supdel(self) -> bool +ida_netnode.netnode.supdel_idx8(self, alt: "uchar", tag: "uchar") -> bool -ida_netnode.netnode.supdel_all (method) - supdel_all(self, tag) -> bool - Delete all elements of the specified supval array. This function may be applied - to 32-bit and 8-bit supval arrays. This function deletes the whole supval array. - - @param tag: (C++: uchar) - @return: success +ida_netnode.netnode.supdel_range(self, idx1: "nodeidx_t", idx2: "nodeidx_t", tag: "uchar") -> int -ida_netnode.netnode.supdel_ea (method) - supdel_ea(self, ea, tag=stag) -> bool - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.supdel_range_idx8(self, idx1: "uchar", idx2: "uchar", tag: "uchar") -> int -ida_netnode.netnode.supdel_idx8 (method) - supdel_idx8(self, alt, tag) -> bool - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.supfirst(self, *args) -> "nodeidx_t" -ida_netnode.netnode.supdel_range (method) - supdel_range(self, idx1, idx2, tag) -> int - Delete range of elements in the specified supval array. Elements in range [idx1, - idx2) will be deleted. - @note: This function can also be used to delete a range of altval elements - - @param idx1: (C++: nodeidx_t) first element to delete - @param idx2: (C++: nodeidx_t) last element to delete + 1 - @param tag: (C++: uchar) tag of array - @return: number of deleted elements +ida_netnode.netnode.supfirst_idx8(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.supdel_range_idx8 (method) - supdel_range_idx8(self, idx1, idx2, tag) -> int - Same as above, but accepts 8-bit indexes. - - @param idx1: (C++: uchar) - @param idx2: (C++: uchar) - @param tag: (C++: uchar) +ida_netnode.netnode.suplast(self, *args) -> "nodeidx_t" -ida_netnode.netnode.supfirst (method) - supfirst(self, tag=stag) -> nodeidx_t - Get first existing element of supval array. - - @param tag: (C++: uchar) tag of array - @return: index of first existing element of supval array, BADNODE if supval - array is empty +ida_netnode.netnode.suplast_idx8(self, tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.supfirst_idx8 (method) - supfirst_idx8(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.supnext(self, *args) -> "nodeidx_t" -ida_netnode.netnode.suplast (method) - suplast(self, tag=stag) -> nodeidx_t - Get last existing element of supval array. - - @param tag: (C++: uchar) tag of array - @return: index of last existing element of supval array, BADNODE if supval array - is empty +ida_netnode.netnode.supnext_idx8(self, alt: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.suplast_idx8 (method) - suplast_idx8(self, tag) -> nodeidx_t - - @param tag: uchar +ida_netnode.netnode.supprev(self, *args) -> "nodeidx_t" -ida_netnode.netnode.supnext (method) - supnext(self, cur, tag=stag) -> nodeidx_t - Get next existing element of supval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the next existing element of supval array, BADNODE if no more - supval array elements exist +ida_netnode.netnode.supprev_idx8(self, alt: "uchar", tag: "uchar") -> "nodeidx_t" -ida_netnode.netnode.supnext_idx8 (method) - supnext_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.supset(self, *args) -> bool -ida_netnode.netnode.supprev (method) - supprev(self, cur, tag=stag) -> nodeidx_t - Get previous existing element of supval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the previous existing element of supval array BADNODE if no - more supval array elements exist +ida_netnode.netnode.supset_ea(self, *args) -> bool -ida_netnode.netnode.supprev_idx8 (method) - supprev_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.supset_idx8(self, alt: "uchar", value: "void const *", tag: "uchar") -> bool -ida_netnode.netnode.supset (method) - supset(self, alt, value, tag=stag) -> bool - Set value of supval array element. - - @param alt: (C++: nodeidx_t) index into array of supvals - @param value: (C++: const void *) pointer to supval value - @param tag: (C++: uchar) tag of array - @retval 1: ok - @retval 0: should not occur - indicates internal error +ida_netnode.netnode.supshift(self, *args) -> "size_t" -ida_netnode.netnode.supset_ea (method) - supset_ea(self, ea, value, tag=stag) -> bool - - @param ea: ea_t - @param value: void const * - @param tag: uchar +ida_netnode.netnode.supstr(self, *args) -> "ssize_t" -ida_netnode.netnode.supset_idx8 (method) - supset_idx8(self, alt, value, tag) -> bool - - @param alt: uchar - @param value: void const * - @param tag: uchar +ida_netnode.netnode.supstr_ea(self, *args) -> "ssize_t" -ida_netnode.netnode.supshift (method) - supshift(self, _from, to, size, tag=stag) -> size_t - Shift the supval array elements. Moves the array elements at (from..from+size) - to (to..to+size) - - @param from: (C++: nodeidx_t) - @param to: (C++: nodeidx_t) - @param size: (C++: nodeidx_t) - @param tag: (C++: uchar) - @return: number of shifted elements +ida_netnode.netnode.supstr_idx8(self, alt: "uchar", tag: "uchar") -> "ssize_t" -ida_netnode.netnode.supstr (method) - supstr(self, alt, tag=stag) -> ssize_t - @see: supstr(qstring *buf, nodeidx_t alt, uchar tag=stag) const - - @param alt: (C++: nodeidx_t) - @param tag: (C++: uchar) +ida_netnode.netnode.supval(self, *args) -> "ssize_t" -ida_netnode.netnode.supstr_ea (method) - supstr_ea(self, ea, tag=stag) -> ssize_t - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.supval_ea(self, *args) -> "ssize_t" -ida_netnode.netnode.supstr_idx8 (method) - supstr_idx8(self, alt, tag) -> ssize_t - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.supval_idx8(self, *args) -> "ssize_t" -ida_netnode.netnode.supval (method) - supval(self, alt, tag=stag) -> ssize_t - Get value of the specified supval array element. NB: do not use this function to - retrieve strings, see supstr()! - - @param alt: (C++: nodeidx_t) index into array of supvals - @param tag: (C++: uchar) tag of array. Default: stag - @return: size of value, -1 if element doesn't exist +ida_netnode.netnode.valobj(self, *args) -> "ssize_t" -ida_netnode.netnode.supval_ea (method) - supval_ea(self, ea, tag=stag) -> ssize_t - - @param ea: ea_t - @param tag: uchar +ida_netnode.netnode.valstr(self) -> "ssize_t" -ida_netnode.netnode.supval_idx8 (method) - supval_idx8(self, alt, tag) -> ssize_t - - @param alt: uchar - @param tag: uchar +ida_netnode.netnode.value_exists(self) -> bool -ida_netnode.netnode.valobj (method) - valobj(self) -> ssize_t - Get value of netnode. Netnode values are arbitrary sized objects with max size - is MAXSPECSIZE. NB: do not use this function for strings - see valstr(). - - @return: length of value, -1 if no value present - -ida_netnode.netnode.valstr (method) - valstr(self) -> ssize_t - @see: valstr(qstring *buf) const - -ida_netnode.netnode.value_exists (method) - value_exists(self) -> bool - -ida_netnode.netnode_exist (function) - netnode_exist(_name) -> bool - - @param _name: char const * - -ida_netnode.ntag (variable) +ida_netnode.ntag Name of netnode. -ida_netnode.stag (variable) +ida_netnode.stag Array of supvals. -ida_netnode.vtag (variable) +ida_netnode.vtag Value of netnode. -ida_offset (module) +ida_offset Functions that deal with offsets. - "Being an offset" is a characteristic of an operand. This means that operand or - its part represent offset from some address in the program. This linear address - is called "offset base". Some operands may have 2 offsets simultaneously. - Generally, IDA doesn't handle this except for Motorola outer offsets. Thus there - may be two offset values in an operand: simple offset and outer offset. - - Outer offsets are handled by specifying special operand number: it should be - ORed with OPND_OUTER value. - - See bytes.hpp for further explanation of operand numbers. + "Being an offset" is a characteristic of an operand. This means that operand or its part represent offset from some address in the program. This linear address is called "offset base". Some operands may have 2 offsets simultaneously. Generally, IDA doesn't handle this except for Motorola outer offsets. Thus there may be two offset values in an operand: simple offset and outer offset. + Outer offsets are handled by specifying special operand number: it should be ORed with OPND_OUTER value. + See bytes.hpp for further explanation of operand numbers. + -ida_offset.add_refinfo_dref (function) - add_refinfo_dref(insn, _from, ri, opval, type, opoff) -> ea_t - Add xrefs for a reference from the given instruction ( insn_t::ea). This - function creates a cross references to the target and the base. - insn_t::add_off_drefs() calls this function to create xrefs for 'offset' - operand. - - @param insn: (C++: const insn_t &) the referencing instruction - @param from: (C++: ea_t) the referencing instruction/data address - @param ri: (C++: const refinfo_t &) reference info block from the database - @param opval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr) - @param type: (C++: dref_t) type of xref - @param opoff: (C++: int) offset of the operand from the start of instruction - @return: the target address of the reference +ida_offset.add_refinfo_dref(insn: "insn_t const &", _from: ida_idaapi.ea_t, ri: "refinfo_t", opval: "adiff_t", type: "dref_t", opoff: int) -> ida_idaapi.ea_t + Add xrefs for a reference from the given instruction ( insn_t::ea). This function creates a cross references to the target and the base. insn_t::add_off_drefs() calls this function to create xrefs for 'offset' operand. + + @param insn: the referencing instruction + @param ri: reference info block from the database + @param opval: operand value (usually op_t::value or op_t::addr) + @param type: type of xref + @param opoff: offset of the operand from the start of instruction + @returns the target address of the reference -ida_offset.calc_basevalue (function) - calc_basevalue(target, base) -> ea_t +ida_offset.calc_basevalue(target: ida_idaapi.ea_t, base: ida_idaapi.ea_t) -> ida_idaapi.ea_t Calculate the value of the reference base. - - @param target: (C++: ea_t) - @param base: (C++: ea_t) -ida_offset.calc_offset_base (function) - calc_offset_base(ea, n) -> ea_t - Try to calculate the offset base This function takes into account the fixup - information, current ds and cs values. - - @param ea: (C++: ea_t) the referencing instruction/data address - @param n: (C++: int) operand number +ida_offset.calc_offset_base(ea: ida_idaapi.ea_t, n: int) -> ida_idaapi.ea_t + Try to calculate the offset base This function takes into account the fixup information, current ds and cs values. + + @param ea: the referencing instruction/data address + @param n: operand number * 0: first operand * 1: second operand * ... * 7: eighth operand - @return: output base address or BADADDR + @returns output base address or BADADDR -ida_offset.calc_probable_base_by_value (function) - calc_probable_base_by_value(ea, off) -> ea_t - Try to calculate the offset base. 2 bases are checked: current ds and cs. If - fails, return BADADDR +ida_offset.calc_probable_base_by_value(ea: ida_idaapi.ea_t, off: int) -> ida_idaapi.ea_t + Try to calculate the offset base. 2 bases are checked: current ds and cs. If fails, return BADADDR + + +ida_offset.calc_reference_data(target: "ea_t *", base: "ea_t *", _from: ida_idaapi.ea_t, ri: "refinfo_t", opval: "adiff_t") -> bool + Calculate the target and base addresses of an offset expression. The calculated target and base addresses are returned in the locations pointed by 'base' and 'target'. In case 'ri.base' is BADADDR, the function calculates the offset base address from the referencing instruction/data address. The target address is copied from ri.target. If ri.target is BADADDR then the target is calculated using the base address and 'opval'. This function also checks if 'opval' matches the full value of the reference and takes in account the memory-mapping. + + @param target: output target address + @param base: output base address + @param ri: reference info block from the database + @param opval: operand value (usually op_t::value or op_t::addr) + @returns success + +ida_offset.calc_target(*args) -> ida_idaapi.ea_t + This function has the following signatures: - @param ea: (C++: ea_t) - @param off: (C++: uval_t) - -ida_offset.calc_reference_data (function) - calc_reference_data(target, base, _from, ri, opval) -> bool - Calculate the target and base addresses of an offset expression. The calculated - target and base addresses are returned in the locations pointed by 'base' and - 'target'. In case 'ri.base' is BADADDR, the function calculates the offset base - address from the referencing instruction/data address. The target address is - copied from ri.target. If ri.target is BADADDR then the target is calculated - using the base address and 'opval'. This function also checks if 'opval' matches - the full value of the reference and takes in account the memory-mapping. + 0. calc_target(from: ida_idaapi.ea_t, opval: adiff_t, ri: const refinfo_t &) -> ida_idaapi.ea_t + 1. calc_target(from: ida_idaapi.ea_t, ea: ida_idaapi.ea_t, n: int, opval: adiff_t) -> ida_idaapi.ea_t + + # 0: calc_target(from: ida_idaapi.ea_t, opval: adiff_t, ri: const refinfo_t &) -> ida_idaapi.ea_t + + Calculate the target using the provided refinfo_t. + + + # 1: calc_target(from: ida_idaapi.ea_t, ea: ida_idaapi.ea_t, n: int, opval: adiff_t) -> ida_idaapi.ea_t - @param target: (C++: ea_t *) output target address - @param base: (C++: ea_t *) output base address - @param from: (C++: ea_t) the referencing instruction/data address - @param ri: (C++: const refinfo_t &) reference info block from the database - @param opval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr) - @return: success - -ida_offset.calc_target (function) - calc_target(_from, opval, ri) -> ea_t Retrieve refinfo_t structure and calculate the target. - - @param from: (C++: ea_t) - @param opval: (C++: adiff_t) - @param ri: refinfo_t const & - - calc_target(_from, ea, n, opval) -> ea_t - - @param from: ea_t - @param ea: ea_t - @param n: int - @param opval: adiff_t -ida_offset.can_be_off32 (function) - can_be_off32(ea) -> ea_t - Does the specified address contain a valid OFF32 value?. For symbols in special - segments the displacement is not taken into account. If yes, then the target - address of OFF32 will be returned. If not, then BADADDR is returned. - - @param ea: (C++: ea_t) +ida_offset.can_be_off32(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Does the specified address contain a valid OFF32 value?. For symbols in special segments the displacement is not taken into account. If yes, then the target address of OFF32 will be returned. If not, then BADADDR is returned. + -ida_offset.get_default_reftype (function) - get_default_reftype(ea) -> reftype_t - Get default reference type depending on the segment. - - @param ea: (C++: ea_t) - @return: one of REF_OFF8, REF_OFF16, REF_OFF32, REF_OFF64 +ida_offset.get_default_reftype(ea: ida_idaapi.ea_t) -> "reftype_t" + Get default reference type depending on the segment. + + @returns one of REF_OFF8, REF_OFF16, REF_OFF32, REF_OFF64 -ida_offset.get_offbase (function) - get_offbase(ea, n) -> ea_t - Get offset base value - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number - @return: offset base or BADADDR +ida_offset.get_offbase(ea: ida_idaapi.ea_t, n: int) -> ida_idaapi.ea_t + Get offset base value + + @param ea: linear address + @param n: 0..UA_MAXOP-1 operand number + @returns offset base or BADADDR -ida_offset.get_offset_expr (function) - get_offset_expr(ea, n, ri, _from, offset, getn_flags=0) -> str +ida_offset.get_offset_expr(ea: ida_idaapi.ea_t, n: int, ri: "refinfo_t", _from: ida_idaapi.ea_t, offset: "adiff_t", getn_flags: int = 0) -> str See get_offset_expression() - - @param ea: (C++: ea_t) - @param n: (C++: int) - @param ri: (C++: const refinfo_t &) refinfo_t const & - @param from: (C++: ea_t) - @param offset: (C++: adiff_t) - @param getn_flags: (C++: int) -ida_offset.get_offset_expression (function) - get_offset_expression(ea, n, _from, offset, getn_flags=0) -> str - Get offset expression (in the form "offset name+displ"). This function uses - offset translation function ( processor_t::translate) if your IDP module has - such a function. Translation function is used to map linear addresses in the - program (only for offsets). - - Example: suppose we have instruction at linear address 0x00011000: - mov ax, [bx+7422h] and at ds:7422h: - array dw ... We want to represent the second operand with an offset - expression, so then we call: - get_offset_expresion(0x001100, 1, 0x001102, 0x7422, buf); +ida_offset.get_offset_expression(ea: ida_idaapi.ea_t, n: int, _from: ida_idaapi.ea_t, offset: "adiff_t", getn_flags: int = 0) -> str + Get offset expression (in the form "offset name+displ"). This function uses offset translation function ( processor_t::translate) if your IDP module has such a function. Translation function is used to map linear addresses in the program (only for offsets). + Example: suppose we have instruction at linear address 0x00011000: `mov ax, [bx+7422h] ` and at ds:7422h: `array dw ... ` We want to represent the second operand with an offset expression, so then we call: `get_offset_expresion(0x001100, 1, 0x001102, 0x7422, buf); | | | | | | | | | +output buffer | | | +value of offset expression | | +address offset value in the instruction | +the second operand - +address of instruction and the function will return a - colored string: - offset array - - @param ea: (C++: ea_t) start of instruction or data with the offset expression - @param n: (C++: int) operand number (may be ORed with OPND_OUTER) + +address of instruction` and the function will return a colored string: `offset array ` + + @param ea: start of instruction or data with the offset expression + @param n: operand number (may be ORed with OPND_OUTER) * 0: first operand * 1: second operand * ... * 7: eighth operand - @param from: (C++: ea_t) linear address of instruction operand or data referring to the - name. This address will be used to get fixup information, so it - should point to exact position of operand in the instruction. - @param offset: (C++: adiff_t) value of operand or its part. The function will return text - representation of this value as offset expression. - @param getn_flags: (C++: int) combination of: - * GETN_APPZERO: meaningful only if the name refers to a structure. appends the - struct field name if the field offset is zero - * GETN_NODUMMY: do not generate dummy names for the expression but pretend they - already exist (useful to verify that the offset expression can be represented) + @param offset: value of operand or its part. The function will return text representation of this value as offset expression. + @param getn_flags: combination of: + * GETN_APPZERO: meaningful only if the name refers to a structure. appends the struct field name if the field offset is zero + * GETN_NODUMMY: do not generate dummy names for the expression but pretend they already exist (useful to verify that the offset expression can be represented) @retval 0: can't convert to offset expression @retval 1: ok, a simple offset expression @retval 2: ok, a complex offset expression -ida_offset.op_offset (function) - op_offset(ea, n, type_and_flags, target=BADADDR, base=0, tdelta=0) -> bool +ida_offset.op_offset(*args) -> bool See op_offset_ex() - - @param ea: (C++: ea_t) - @param n: (C++: int) - @param type_and_flags: (C++: uint32) - @param target: (C++: ea_t) - @param base: (C++: ea_t) - @param tdelta: (C++: adiff_t) -ida_offset.op_offset_ex (function) - op_offset_ex(ea, n, ri) -> bool - Convert operand to a reference. To delete an offset, use clr_op_type() function. - - @param ea: (C++: ea_t) linear address. if 'ea' has unexplored bytes, try to convert them to +ida_offset.op_offset_ex(ea: ida_idaapi.ea_t, n: int, ri: "refinfo_t") -> bool + Convert operand to a reference. To delete an offset, use clr_op_type() function. + + @param ea: linear address. if 'ea' has unexplored bytes, try to convert them to * no segment: fail * 16bit segment: to 16bit word data * 32bit segment: to dword - @param n: (C++: int) operand number (may be ORed with OPND_OUTER) + @param n: operand number (may be ORed with OPND_OUTER) * 0: first * 1: second * ... * 7: eighth operand - * OPND_MASK: all operands - @param ri: (C++: const refinfo_t *) reference information - @return: success - -ida_offset.op_plain_offset (function) - op_plain_offset(ea, n, base) -> bool - Convert operand to a reference with the default reference type. - @param ea: (C++: ea_t) - @param n: (C++: int) - @param base: (C++: ea_t) + + * OPND_MASK: all operands + @param ri: reference information + @returns success -ida_pro (module) +ida_offset.op_plain_offset(ea: ida_idaapi.ea_t, n: int, base: ida_idaapi.ea_t) -> bool + Convert operand to a reference with the default reference type. + +ida_pro This is the first header included in the IDA project. - It defines the most common types, functions and data. Also, it tries to make - system dependent definitions. - - The following preprocessor macros are used in the project (the list may be - incomplete) - + It defines the most common types, functions and data. Also, it tries to make system dependent definitions. + The following preprocessor macros are used in the project (the list may be incomplete) Platform must be specified as one of: - - __NT__ - MS Windows (all platforms) - __LINUX__ - Linux - __MAC__ - MAC OS X - - __EA64__ - 64-bit address size (sizeof(ea_t)==8) - __X86__ - 32-bit debug servers (sizeof(void*)==4) - __X64__ - x64 processor (sizeof(void*)==8) default - __PPC__ - PowerPC - __ARM__ - ARM + __NT__ - MS Windows (all platforms) + __LINUX__ - Linux + __MAC__ - MAC OS X + __EA64__ - 64-bit address size (sizeof(ea_t)==8) + __X86__ - 32-bit debug servers (sizeof(void*)==4) + __X64__ - x64 processor (sizeof(void*)==8) default + __PPC__ - PowerPC + __ARM__ - ARM + -ida_pro.CP_UTF16 (variable) +ida_pro.CP_UTF16 UTF-16 codepage. -ida_pro.IDA_SDK_VERSION (variable) - IDA SDK v8.4. +ida_pro.IDA_SDK_VERSION + IDA SDK v9.1. -ida_pro.IDBDEC_ESCAPE (variable) +ida_pro.IDBDEC_ESCAPE convert non-printable characters to C escapes ( , \xNN, \uNNNN) -ida_pro.IOREDIR_APPEND (variable) +ida_pro.IOREDIR_APPEND append, do not overwrite the output file -ida_pro.IOREDIR_INPUT (variable) +ida_pro.IOREDIR_INPUT input redirection -ida_pro.IOREDIR_OUTPUT (variable) +ida_pro.IOREDIR_OUTPUT output redirection -ida_pro.IOREDIR_QUOTED (variable) +ida_pro.IOREDIR_QUOTED the file name was quoted -ida_pro.MAXSTR (variable) +ida_pro.MAXSTR maximum string size -ida_pro.SUBSTCHAR (variable) +ida_pro.SUBSTCHAR default char, used if a char cannot be represented in a codepage -ida_pro.__MF__ (variable) - byte sex of our platform (Most significant byte First). 0: little endian (Intel - 80x86). 1: big endian (PowerPC). +ida_pro.__MF__ + byte sex of our platform (Most significant byte First). 0: little endian (Intel 80x86). 1: big endian (PowerPC). + -ida_pro.__qmutex_t (class) - Proxy of C++ __qmutex_t class. +ida_pro.__qmutex_t -ida_pro.__qmutex_t.__init__ (method) - __init__(self) -> __qmutex_t +ida_pro.__qmutex_t.__init__(self) -ida_pro.__qsemaphore_t (class) - Proxy of C++ __qsemaphore_t class. +ida_pro.__qsemaphore_t -ida_pro.__qsemaphore_t.__init__ (method) - __init__(self) -> __qsemaphore_t +ida_pro.__qsemaphore_t.__init__(self) -ida_pro.__qthread_t (class) - Proxy of C++ __qthread_t class. +ida_pro.__qthread_t -ida_pro.__qthread_t.__init__ (method) - __init__(self) -> __qthread_t +ida_pro.__qthread_t.__init__(self) -ida_pro._qstrvec_t (class) +ida_pro._qstrvec_t WARNING: It is very unlikely an IDAPython user should ever, ever have to use this type. It should only be used for IDAPython internals. @@ -53127,3524 +36293,2409 @@ ida_pro._qstrvec_t (class) This is, afaict, the only situation where a Python _qstrvec_t is required. -ida_pro._qstrvec_t.__get_size (method) +ida_pro._qstrvec_t.__get_size(self) -ida_pro._qstrvec_t.__getitem__ (method) +ida_pro._qstrvec_t.__getitem__(self, idx) Gets the string at the given index -ida_pro._qstrvec_t.__init__ (method) +ida_pro._qstrvec_t.__init__(self, items = None) -ida_pro._qstrvec_t.__setitem__ (method) +ida_pro._qstrvec_t.__setitem__(self, idx, s) Sets string at the given index -ida_pro._qstrvec_t._create_clink (method) +ida_pro._qstrvec_t._create_clink(self) -ida_pro._qstrvec_t._del_clink (method) +ida_pro._qstrvec_t._del_clink(self, lnk) -ida_pro._qstrvec_t._get_clink_ptr (method) +ida_pro._qstrvec_t._get_clink_ptr(self) -ida_pro._qstrvec_t.add (method) +ida_pro._qstrvec_t.add(self, s) Add a string to the vector -ida_pro._qstrvec_t.addressof (method) +ida_pro._qstrvec_t.addressof(self, idx) Returns the address (as number) of the qstring at the given index -ida_pro._qstrvec_t.assign (method) +ida_pro._qstrvec_t.assign(self, other) Copies the contents of 'other' to 'self' -ida_pro._qstrvec_t.clear (method) +ida_pro._qstrvec_t.clear(self, qclear = False) Clears all strings from the vector. @param qclear: Just reset the size but do not actually free the memory -ida_pro._qstrvec_t.from_list (method) +ida_pro._qstrvec_t.from_list(self, lst) Populates the vector from a Python string list -ida_pro._qstrvec_t.insert (method) +ida_pro._qstrvec_t.insert(self, idx, s) Insert a string into the vector -ida_pro._qstrvec_t.remove (method) +ida_pro._qstrvec_t.remove(self, idx) Removes a string from the vector -ida_pro._qstrvec_t.size (variable) +ida_pro._qstrvec_t.size Returns the count of elements -ida_pro.boolvec_t (class) - Proxy of C++ qvector< bool > class. +ida_pro.adiff_pointer -ida_pro.boolvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< bool > const & +ida_pro.adiff_pointer.__init__(self) -ida_pro.boolvec_t.__getitem__ (method) - __getitem__(self, i) -> bool const & - - @param i: size_t +ida_pro.adiff_pointer.assign(self, value: "adiff_t") -> None -ida_pro.boolvec_t.__init__ (method) - __init__(self) -> boolvec_t - __init__(self, x) -> boolvec_t - - @param x: qvector< bool > const & +ida_pro.adiff_pointer.cast(self) -> "adiff_t *" -ida_pro.boolvec_t.__len__ (method) - __len__(self) -> size_t +ida_pro.adiff_pointer.frompointer(t: "adiff_t *") -> "adiff_pointer *" -ida_pro.boolvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< bool > const & +ida_pro.adiff_pointer.value(self) -> "adiff_t" -ida_pro.boolvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: bool const & +ida_pro.asize_pointer -ida_pro.boolvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: bool const & +ida_pro.asize_pointer.__init__(self) -ida_pro.boolvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: bool const & +ida_pro.asize_pointer.assign(self, value: "asize_t") -> None -ida_pro.boolvec_t.at (method) - at(self, _idx) -> bool const & - - @param _idx: size_t +ida_pro.asize_pointer.cast(self) -> "asize_t *" -ida_pro.boolvec_t.begin (method) - begin(self) -> qvector< bool >::iterator - begin(self) -> qvector< bool >::const_iterator +ida_pro.asize_pointer.frompointer(t: "asize_t *") -> "asize_pointer *" -ida_pro.boolvec_t.capacity (method) - capacity(self) -> size_t +ida_pro.asize_pointer.value(self) -> "asize_t" -ida_pro.boolvec_t.clear (method) - clear(self) +ida_pro.bool_pointer -ida_pro.boolvec_t.empty (method) - empty(self) -> bool +ida_pro.bool_pointer.__init__(self) -ida_pro.boolvec_t.end (method) - end(self) -> qvector< bool >::iterator - end(self) -> qvector< bool >::const_iterator +ida_pro.bool_pointer.assign(self, value: bool) -> None -ida_pro.boolvec_t.erase (method) - erase(self, it) -> qvector< bool >::iterator - - @param it: qvector< bool >::iterator - - erase(self, first, last) -> qvector< bool >::iterator - - @param first: qvector< bool >::iterator - @param last: qvector< bool >::iterator +ida_pro.bool_pointer.cast(self) -> "bool *" -ida_pro.boolvec_t.extract (method) - extract(self) -> bool * +ida_pro.bool_pointer.frompointer(t: "bool *") -> "bool_pointer *" -ida_pro.boolvec_t.find (method) - find(self, x) -> qvector< bool >::iterator - - @param x: bool const & - - find(self, x) -> qvector< bool >::const_iterator - - @param x: bool const & +ida_pro.bool_pointer.value(self) -> bool -ida_pro.boolvec_t.grow (method) - grow(self, x=bool()) - - @param x: bool const & +ida_pro.boolvec_t -ida_pro.boolvec_t.has (method) - has(self, x) -> bool - - @param x: bool const & +ida_pro.boolvec_t.__eq__(self, r: "boolvec_t") -> bool -ida_pro.boolvec_t.inject (method) - inject(self, s, len) - - @param s: bool * - @param len: size_t +ida_pro.boolvec_t.__getitem__(self, i: "size_t") -> "bool const &" -ida_pro.boolvec_t.insert (method) - insert(self, it, x) -> qvector< bool >::iterator - - @param it: qvector< bool >::iterator - @param x: bool const & +ida_pro.boolvec_t.__init__(self, *args) -ida_pro.boolvec_t.pop_back (method) - pop_back(self) +ida_pro.boolvec_t.__len__(self) -> "size_t" -ida_pro.boolvec_t.push_back (method) - push_back(self, x) - - @param x: bool const & - - push_back(self) -> bool & +ida_pro.boolvec_t.__ne__(self, r: "boolvec_t") -> bool -ida_pro.boolvec_t.qclear (method) - qclear(self) +ida_pro.boolvec_t.__setitem__(self, i: "size_t", v: "bool const &") -> None -ida_pro.boolvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_pro.boolvec_t._del(self, x: "bool const &") -> bool -ida_pro.boolvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: bool const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_pro.boolvec_t.add_unique(self, x: "bool const &") -> bool -ida_pro.boolvec_t.size (method) - size(self) -> size_t +ida_pro.boolvec_t.append(self, x: "bool const &") -> None -ida_pro.boolvec_t.swap (method) - swap(self, r) - - @param r: qvector< bool > & +ida_pro.boolvec_t.at(self, _idx: "size_t") -> "bool const &" -ida_pro.boolvec_t.truncate (method) - truncate(self) +ida_pro.boolvec_t.begin(self, *args) -> "qvector< bool >::const_iterator" -ida_pro.channel_redir_t (class) - Proxy of C++ channel_redir_t class. +ida_pro.boolvec_t.capacity(self) -> "size_t" -ida_pro.channel_redir_t.__init__ (method) - __init__(self) -> channel_redir_t +ida_pro.boolvec_t.clear(self) -> None -ida_pro.channel_redir_t.fd (variable) +ida_pro.boolvec_t.empty(self) -> bool + +ida_pro.boolvec_t.end(self, *args) -> "qvector< bool >::const_iterator" + +ida_pro.boolvec_t.erase(self, *args) -> "qvector< bool >::iterator" + +ida_pro.boolvec_t.extend(self, x: "boolvec_t") -> None + +ida_pro.boolvec_t.extract(self) -> "bool *" + +ida_pro.boolvec_t.find(self, *args) -> "qvector< bool >::const_iterator" + +ida_pro.boolvec_t.grow(self, *args) -> None + +ida_pro.boolvec_t.has(self, x: "bool const &") -> bool + +ida_pro.boolvec_t.inject(self, s: "bool *", len: "size_t") -> None + +ida_pro.boolvec_t.insert(self, it: "qvector< bool >::iterator", x: "bool const &") -> "qvector< bool >::iterator" + +ida_pro.boolvec_t.pop_back(self) -> None + +ida_pro.boolvec_t.push_back(self, *args) -> "bool &" + +ida_pro.boolvec_t.qclear(self) -> None + +ida_pro.boolvec_t.reserve(self, cnt: "size_t") -> None + +ida_pro.boolvec_t.resize(self, *args) -> None + +ida_pro.boolvec_t.size(self) -> "size_t" + +ida_pro.boolvec_t.swap(self, r: "boolvec_t") -> None + +ida_pro.boolvec_t.truncate(self) -> None + +ida_pro.channel_redir_t + +ida_pro.channel_redir_t.__init__(self) + +ida_pro.channel_redir_t.fd channel number -ida_pro.channel_redir_t.file (variable) - file name to redirect to/from. if empty, the channel must be closed. +ida_pro.channel_redir_t.file + file name to redirect to/from. if empty, the channel must be closed. + -ida_pro.channel_redir_t.flags (variable) - i/o redirection flags +ida_pro.channel_redir_t.flags + i/o redirection flags + -ida_pro.channel_redir_t.is_append (method) - is_append(self) -> bool +ida_pro.channel_redir_t.is_append(self) -> bool -ida_pro.channel_redir_t.is_input (method) - is_input(self) -> bool +ida_pro.channel_redir_t.is_input(self) -> bool -ida_pro.channel_redir_t.is_output (method) - is_output(self) -> bool +ida_pro.channel_redir_t.is_output(self) -> bool -ida_pro.channel_redir_t.is_quoted (method) - is_quoted(self) -> bool +ida_pro.channel_redir_t.is_quoted(self) -> bool -ida_pro.channel_redir_t.length (variable) +ida_pro.channel_redir_t.length length of the redirection string in the command line -ida_pro.channel_redir_t.start (variable) +ida_pro.channel_redir_t.start begin of the redirection string in the command line -ida_pro.check_process_exit (function) - check_process_exit(handle, exit_code, msecs=-1) -> int - Check whether process has terminated or not. - - @param handle: (C++: void *) process handle to wait for - @param exit_code: (C++: int *) pointer to the buffer for the exit code - @param msecs: how long to wait. special values: - * 0: do not wait - * 1 or -1: wait infinitely - * other values: timeout in milliseconds - @retval 0: process has exited, and the exit code is available. if *exit_code < - 0: the process was killed with a signal -*exit_code +ida_pro.char_pointer + +ida_pro.char_pointer.__init__(self) + +ida_pro.char_pointer.assign(self, value: "char") -> None + +ida_pro.char_pointer.cast(self) -> "char *" + +ida_pro.char_pointer.frompointer(t: "char *") -> "char_pointer *" + +ida_pro.char_pointer.value(self) -> "char" + +ida_pro.check_process_exit(handle: "void *", exit_code: "int *", msecs: int = -1) -> int + Check whether process has terminated or not. + + @param handle: process handle to wait for + @param exit_code: pointer to the buffer for the exit code + @retval 0: process has exited, and the exit code is available. if *exit_code < 0: the process was killed with a signal -*exit_code @retval 1: process has not exited yet @retval -1: error happened, see error code for winerr() in *exit_code -ida_pro.ea_array (class) - Proxy of C++ ea_array class. +ida_pro.ea32_pointer -ida_pro.ea_array.__getitem__ (method) - __getitem__(self, index) -> ea_t - - @param index: size_t +ida_pro.ea32_pointer.__init__(self) -ida_pro.ea_array.__init__ (method) - __init__(self, nelements) -> ea_array - - @param nelements: size_t +ida_pro.ea32_pointer.assign(self, value: "ea32_t") -> None -ida_pro.ea_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: ea_t +ida_pro.ea32_pointer.cast(self) -> "ea32_t *" -ida_pro.ea_array.cast (method) - cast(self) -> ea_t * +ida_pro.ea32_pointer.frompointer(t: "ea32_t *") -> "ea32_pointer *" -ida_pro.ea_array.frompointer (method) - frompointer(t) -> ea_array - - @param t: ea_t * +ida_pro.ea32_pointer.value(self) -> "ea32_t" -ida_pro.ea_array_frompointer (function) - ea_array_frompointer(t) -> ea_array - - @param t: ea_t * +ida_pro.ea64_pointer -ida_pro.ea_pointer (class) - Proxy of C++ ea_pointer class. +ida_pro.ea64_pointer.__init__(self) -ida_pro.ea_pointer.__init__ (method) - __init__(self) -> ea_pointer +ida_pro.ea64_pointer.assign(self, value: "ea64_t") -> None -ida_pro.ea_pointer.assign (method) - assign(self, value) - - @param value: ea_t +ida_pro.ea64_pointer.cast(self) -> "ea64_t *" -ida_pro.ea_pointer.cast (method) - cast(self) -> ea_t * +ida_pro.ea64_pointer.frompointer(t: "ea64_t *") -> "ea64_pointer *" -ida_pro.ea_pointer.frompointer (method) - frompointer(t) -> ea_pointer - - @param t: ea_t * +ida_pro.ea64_pointer.value(self) -> "ea64_t" -ida_pro.ea_pointer.value (method) - value(self) -> ea_t +ida_pro.ea_array -ida_pro.ea_pointer_frompointer (function) - ea_pointer_frompointer(t) -> ea_pointer - - @param t: ea_t * +ida_pro.ea_array.__getitem__(self, index: "size_t") -> ida_idaapi.ea_t -ida_pro.extend_sign (function) - extend_sign(v, nbytes, sign_extend) -> uint64 - Sign-, or zero-extend the value 'v' to occupy 64 bits. The value 'v' is - considered to be of size 'nbytes'. - - @param v: (C++: uint64) - @param nbytes: (C++: int) - @param sign_extend: (C++: bool) +ida_pro.ea_array.__init__(self, nelements: "size_t") -ida_pro.instant_dbgopts_t (class) - Proxy of C++ instant_dbgopts_t class. +ida_pro.ea_array.__setitem__(self, index: "size_t", value: ida_idaapi.ea_t) -> None -ida_pro.instant_dbgopts_t.__init__ (method) - __init__(self) -> instant_dbgopts_t +ida_pro.ea_array.cast(self) -> "ea_t *" -ida_pro.instant_dbgopts_t.attach (variable) +ida_pro.ea_array.frompointer(t: "ea_t *") -> "ea_array *" + +ida_pro.ea_pointer + +ida_pro.ea_pointer.__init__(self) + +ida_pro.ea_pointer.assign(self, value: ida_idaapi.ea_t) -> None + +ida_pro.ea_pointer.cast(self) -> "ea_t *" + +ida_pro.ea_pointer.frompointer(t: "ea_t *") -> "ea_pointer *" + +ida_pro.ea_pointer.value(self) -> ida_idaapi.ea_t + +ida_pro.extend_sign(v: "uint64", nbytes: int, sign_extend: bool) -> "uint64" + Sign-, or zero-extend the value 'v' to occupy 64 bits. The value 'v' is considered to be of size 'nbytes'. + + +ida_pro.flags64_pointer + +ida_pro.flags64_pointer.__init__(self) + +ida_pro.flags64_pointer.assign(self, value: "flags64_t") -> None + +ida_pro.flags64_pointer.cast(self) -> "flags64_t *" + +ida_pro.flags64_pointer.frompointer(t: "flags64_t *") -> "flags64_pointer *" + +ida_pro.flags64_pointer.value(self) -> "flags64_t" + +ida_pro.flags_pointer + +ida_pro.flags_pointer.__init__(self) + +ida_pro.flags_pointer.assign(self, value: "flags_t") -> None + +ida_pro.flags_pointer.cast(self) -> "flags_t *" + +ida_pro.flags_pointer.frompointer(t: "flags_t *") -> "flags_pointer *" + +ida_pro.flags_pointer.value(self) -> "flags_t" + +ida_pro.get_available_core_count() -> int + Get the number of logical CPU cores available to the current process if supported by the OS. + + @returns the logical core count available for the process, or -1 on error + +ida_pro.get_logical_core_count() -> int + Get the total CPU logical core count + + @returns the logical core count, or -1 on error + +ida_pro.get_login_name() -> str + Get the user name for the current desktop session + + @returns success + +ida_pro.get_physical_core_count() -> int + Get the total CPU physical core count + + @returns the physical core count, or -1 on error + +ida_pro.instant_dbgopts_t + +ida_pro.instant_dbgopts_t.__init__(self) + +ida_pro.instant_dbgopts_t.attach should attach to a process? -ida_pro.instant_dbgopts_t.debmod (variable) +ida_pro.instant_dbgopts_t.debmod name of debugger module -ida_pro.instant_dbgopts_t.env (variable) +ida_pro.instant_dbgopts_t.env config variables for debmod. example: DEFAULT_CPU=13;MAXPACKETSIZE=-1 -ida_pro.instant_dbgopts_t.event_id (variable) +ida_pro.instant_dbgopts_t.event_id event to trigger upon attaching -ida_pro.instant_dbgopts_t.host (variable) +ida_pro.instant_dbgopts_t.host remote hostname (if remote debugging) -ida_pro.instant_dbgopts_t.pid (variable) +ida_pro.instant_dbgopts_t.pid process to attach to (-1: ask the user) -ida_pro.instant_dbgopts_t.port (variable) +ida_pro.instant_dbgopts_t.port port number for the remote debugger server -ida_pro.int64vec_t (class) - Proxy of C++ qvector< long long > class. - -ida_pro.int64vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< long long > const & - -ida_pro.int64vec_t.__getitem__ (method) - __getitem__(self, i) -> long long const & - - @param i: size_t - -ida_pro.int64vec_t.__init__ (method) - __init__(self) -> int64vec_t - __init__(self, x) -> int64vec_t - - @param x: qvector< long long > const & - -ida_pro.int64vec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.int64vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< long long > const & - -ida_pro.int64vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: long long const & - -ida_pro.int64vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: long long const & - -ida_pro.int64vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: long long const & - -ida_pro.int64vec_t.at (method) - at(self, _idx) -> long long const & - - @param _idx: size_t - -ida_pro.int64vec_t.begin (method) - begin(self) -> qvector< long long >::iterator - begin(self) -> qvector< long long >::const_iterator - -ida_pro.int64vec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.int64vec_t.clear (method) - clear(self) - -ida_pro.int64vec_t.empty (method) - empty(self) -> bool - -ida_pro.int64vec_t.end (method) - end(self) -> qvector< long long >::iterator - end(self) -> qvector< long long >::const_iterator - -ida_pro.int64vec_t.erase (method) - erase(self, it) -> qvector< long long >::iterator - - @param it: qvector< long long >::iterator - - erase(self, first, last) -> qvector< long long >::iterator - - @param first: qvector< long long >::iterator - @param last: qvector< long long >::iterator - -ida_pro.int64vec_t.extract (method) - extract(self) -> long long * - -ida_pro.int64vec_t.find (method) - find(self, x) -> qvector< long long >::iterator - - @param x: long long const & - - find(self, x) -> qvector< long long >::const_iterator - - @param x: long long const & - -ida_pro.int64vec_t.has (method) - has(self, x) -> bool - - @param x: long long const & - -ida_pro.int64vec_t.inject (method) - inject(self, s, len) - - @param s: long long * - @param len: size_t - -ida_pro.int64vec_t.insert (method) - insert(self, it, x) -> qvector< long long >::iterator - - @param it: qvector< long long >::iterator - @param x: long long const & - -ida_pro.int64vec_t.pop_back (method) - pop_back(self) - -ida_pro.int64vec_t.push_back (method) - push_back(self, x) - - @param x: long long const & - - push_back(self) -> long long & - -ida_pro.int64vec_t.qclear (method) - qclear(self) - -ida_pro.int64vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.int64vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: long long const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.int64vec_t.size (method) - size(self) -> size_t - -ida_pro.int64vec_t.swap (method) - swap(self, r) - - @param r: qvector< long long > & - -ida_pro.int64vec_t.truncate (method) - truncate(self) - -ida_pro.int_pointer (class) - Proxy of C++ int_pointer class. - -ida_pro.int_pointer.__init__ (method) - __init__(self) -> int_pointer - -ida_pro.int_pointer.assign (method) - assign(self, value) - - @param value: int - -ida_pro.int_pointer.cast (method) - cast(self) -> int * - -ida_pro.int_pointer.frompointer (method) - frompointer(t) -> int_pointer - - @param t: int * - -ida_pro.int_pointer.value (method) - value(self) -> int - -ida_pro.int_pointer_frompointer (function) - int_pointer_frompointer(t) -> int_pointer - - @param t: int * - -ida_pro.intvec_t (class) - Proxy of C++ qvector< int > class. - -ida_pro.intvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< int > const & - -ida_pro.intvec_t.__getitem__ (method) - __getitem__(self, i) -> int const & - - @param i: size_t - -ida_pro.intvec_t.__init__ (method) - __init__(self) -> intvec_t - __init__(self, x) -> intvec_t - - @param x: qvector< int > const & - -ida_pro.intvec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.intvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< int > const & - -ida_pro.intvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: int const & - -ida_pro.intvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: int const & - -ida_pro.intvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: int const & - -ida_pro.intvec_t.at (method) - at(self, _idx) -> int const & - - @param _idx: size_t - -ida_pro.intvec_t.begin (method) - begin(self) -> qvector< int >::iterator - begin(self) -> qvector< int >::const_iterator - -ida_pro.intvec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.intvec_t.clear (method) - clear(self) - -ida_pro.intvec_t.empty (method) - empty(self) -> bool - -ida_pro.intvec_t.end (method) - end(self) -> qvector< int >::iterator - end(self) -> qvector< int >::const_iterator - -ida_pro.intvec_t.erase (method) - erase(self, it) -> qvector< int >::iterator - - @param it: qvector< int >::iterator - - erase(self, first, last) -> qvector< int >::iterator - - @param first: qvector< int >::iterator - @param last: qvector< int >::iterator - -ida_pro.intvec_t.extract (method) - extract(self) -> int * - -ida_pro.intvec_t.find (method) - find(self, x) -> qvector< int >::iterator - - @param x: int const & - - find(self, x) -> qvector< int >::const_iterator - - @param x: int const & - -ida_pro.intvec_t.has (method) - has(self, x) -> bool - - @param x: int const & - -ida_pro.intvec_t.inject (method) - inject(self, s, len) - - @param s: int * - @param len: size_t - -ida_pro.intvec_t.insert (method) - insert(self, it, x) -> qvector< int >::iterator - - @param it: qvector< int >::iterator - @param x: int const & - -ida_pro.intvec_t.pop_back (method) - pop_back(self) - -ida_pro.intvec_t.push_back (method) - push_back(self, x) - - @param x: int const & - - push_back(self) -> int & - -ida_pro.intvec_t.qclear (method) - qclear(self) - -ida_pro.intvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.intvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: int const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.intvec_t.size (method) - size(self) -> size_t - -ida_pro.intvec_t.swap (method) - swap(self, r) - - @param r: qvector< int > & - -ida_pro.intvec_t.truncate (method) - truncate(self) - -ida_pro.is_control_tty (function) - is_control_tty(fd) -> enum tty_control_t - Check if the current process is the owner of the TTY specified by 'fd' - (typically an opened descriptor to /dev/tty). - - @param fd: (C++: int) - -ida_pro.is_cvt64 (function) - is_cvt64() -> bool +ida_pro.int16_pointer + +ida_pro.int16_pointer.__init__(self) + +ida_pro.int16_pointer.assign(self, value: "int16") -> None + +ida_pro.int16_pointer.cast(self) -> "int16 *" + +ida_pro.int16_pointer.frompointer(t: "int16 *") -> "int16_pointer *" + +ida_pro.int16_pointer.value(self) -> "int16" + +ida_pro.int32_pointer + +ida_pro.int32_pointer.__init__(self) + +ida_pro.int32_pointer.assign(self, value: int) -> None + +ida_pro.int32_pointer.cast(self) -> "int32 *" + +ida_pro.int32_pointer.frompointer(t: "int32 *") -> "int32_pointer *" + +ida_pro.int32_pointer.value(self) -> int + +ida_pro.int64_pointer + +ida_pro.int64_pointer.__init__(self) + +ida_pro.int64_pointer.assign(self, value: "int64") -> None + +ida_pro.int64_pointer.cast(self) -> "int64 *" + +ida_pro.int64_pointer.frompointer(t: "int64 *") -> "int64_pointer *" + +ida_pro.int64_pointer.value(self) -> "int64" + +ida_pro.int64vec_t + +ida_pro.int64vec_t.__eq__(self, r: "int64vec_t") -> bool + +ida_pro.int64vec_t.__getitem__(self, i: "size_t") -> "long long const &" + +ida_pro.int64vec_t.__init__(self, *args) + +ida_pro.int64vec_t.__len__(self) -> "size_t" + +ida_pro.int64vec_t.__ne__(self, r: "int64vec_t") -> bool + +ida_pro.int64vec_t.__setitem__(self, i: "size_t", v: "long long const &") -> None + +ida_pro.int64vec_t._del(self, x: "long long const &") -> bool + +ida_pro.int64vec_t.add_unique(self, x: "long long const &") -> bool + +ida_pro.int64vec_t.append(self, x: "long long const &") -> None + +ida_pro.int64vec_t.at(self, _idx: "size_t") -> "long long const &" + +ida_pro.int64vec_t.begin(self, *args) -> "qvector< long long >::const_iterator" + +ida_pro.int64vec_t.capacity(self) -> "size_t" + +ida_pro.int64vec_t.clear(self) -> None + +ida_pro.int64vec_t.empty(self) -> bool + +ida_pro.int64vec_t.end(self, *args) -> "qvector< long long >::const_iterator" + +ida_pro.int64vec_t.erase(self, *args) -> "qvector< long long >::iterator" + +ida_pro.int64vec_t.extend(self, x: "int64vec_t") -> None + +ida_pro.int64vec_t.extract(self) -> "long long *" + +ida_pro.int64vec_t.find(self, *args) -> "qvector< long long >::const_iterator" + +ida_pro.int64vec_t.has(self, x: "long long const &") -> bool + +ida_pro.int64vec_t.inject(self, s: "long long *", len: "size_t") -> None + +ida_pro.int64vec_t.insert(self, it: "qvector< long long >::iterator", x: "long long const &") -> "qvector< long long >::iterator" + +ida_pro.int64vec_t.pop_back(self) -> None + +ida_pro.int64vec_t.push_back(self, *args) -> "long long &" + +ida_pro.int64vec_t.qclear(self) -> None + +ida_pro.int64vec_t.reserve(self, cnt: "size_t") -> None + +ida_pro.int64vec_t.resize(self, *args) -> None + +ida_pro.int64vec_t.size(self) -> "size_t" + +ida_pro.int64vec_t.swap(self, r: "int64vec_t") -> None + +ida_pro.int64vec_t.truncate(self) -> None + +ida_pro.int8_pointer + +ida_pro.int8_pointer.__init__(self) + +ida_pro.int8_pointer.assign(self, value: "int8") -> None + +ida_pro.int8_pointer.cast(self) -> "int8 *" + +ida_pro.int8_pointer.frompointer(t: "int8 *") -> "int8_pointer *" + +ida_pro.int8_pointer.value(self) -> "int8" + +ida_pro.int_pointer + +ida_pro.int_pointer.__init__(self) + +ida_pro.int_pointer.assign(self, value: int) -> None + +ida_pro.int_pointer.cast(self) -> "int *" + +ida_pro.int_pointer.frompointer(t: "int *") -> "int_pointer *" + +ida_pro.int_pointer.value(self) -> int + +ida_pro.intvec_t + +ida_pro.intvec_t.__eq__(self, r: "intvec_t") -> bool + +ida_pro.intvec_t.__getitem__(self, i: "size_t") -> "int const &" + +ida_pro.intvec_t.__init__(self, *args) + +ida_pro.intvec_t.__len__(self) -> "size_t" + +ida_pro.intvec_t.__ne__(self, r: "intvec_t") -> bool + +ida_pro.intvec_t.__setitem__(self, i: "size_t", v: "int const &") -> None + +ida_pro.intvec_t._del(self, x: "int const &") -> bool + +ida_pro.intvec_t.add_unique(self, x: "int const &") -> bool + +ida_pro.intvec_t.append(self, x: "int const &") -> None + +ida_pro.intvec_t.at(self, _idx: "size_t") -> "int const &" + +ida_pro.intvec_t.begin(self, *args) -> "qvector< int >::const_iterator" + +ida_pro.intvec_t.capacity(self) -> "size_t" + +ida_pro.intvec_t.clear(self) -> None + +ida_pro.intvec_t.empty(self) -> bool + +ida_pro.intvec_t.end(self, *args) -> "qvector< int >::const_iterator" + +ida_pro.intvec_t.erase(self, *args) -> "qvector< int >::iterator" + +ida_pro.intvec_t.extend(self, x: "intvec_t") -> None + +ida_pro.intvec_t.extract(self) -> "int *" + +ida_pro.intvec_t.find(self, *args) -> "qvector< int >::const_iterator" + +ida_pro.intvec_t.has(self, x: "int const &") -> bool + +ida_pro.intvec_t.inject(self, s: "int *", len: "size_t") -> None + +ida_pro.intvec_t.insert(self, it: "qvector< int >::iterator", x: "int const &") -> "qvector< int >::iterator" + +ida_pro.intvec_t.pop_back(self) -> None + +ida_pro.intvec_t.push_back(self, *args) -> "int &" + +ida_pro.intvec_t.qclear(self) -> None + +ida_pro.intvec_t.reserve(self, cnt: "size_t") -> None + +ida_pro.intvec_t.resize(self, *args) -> None + +ida_pro.intvec_t.size(self) -> "size_t" + +ida_pro.intvec_t.swap(self, r: "intvec_t") -> None + +ida_pro.intvec_t.truncate(self) -> None + +ida_pro.is_control_tty(fd: int) -> "enum tty_control_t" + Check if the current process is the owner of the TTY specified by 'fd' (typically an opened descriptor to /dev/tty). + + +ida_pro.is_cvt64() -> bool is IDA converting IDB into I64? -ida_pro.is_main_thread (function) - is_main_thread() -> bool +ida_pro.is_main_thread() -> bool Are we running in the main thread? -ida_pro.log2ceil (function) - log2ceil(d64) -> int - calculate ceil(log2(d64)) or floor(log2(d64)), it returns 0 if d64 == 0 - - @param d64: (C++: uint64) +ida_pro.log2ceil(d64: "uint64") -> int + calculate ceil(log2(d64)) or floor(log2(d64)), it returns 0 if d64 == 0 + -ida_pro.log2floor (function) - log2floor(d64) -> int - - @param d64: uint64 +ida_pro.log2floor(d64: "uint64") -> int -ida_pro.parse_dbgopts (function) - parse_dbgopts(ido, r_switch) -> bool - Parse the -r command line switch (for instant debugging). r_switch points to the - value of the -r switch. Example: win32@localhost+ - - @param ido: (C++: struct instant_dbgopts_t *) instant_dbgopts_t * - @param r_switch: (C++: const char *) char const * - @return: true-ok, false-parse error +ida_pro.parse_dbgopts(ido: "instant_dbgopts_t", r_switch: str) -> bool + Parse the -r command line switch (for instant debugging). r_switch points to the value of the -r switch. Example: win32@localhost+ + + @returns true-ok, false-parse error -ida_pro.qatoll (function) - qatoll(nptr) -> int64 - - @param nptr: char const * +ida_pro.plugin_options_t -ida_pro.qcontrol_tty (function) - qcontrol_tty() - Make the current terminal the controlling terminal of the calling process. - @note: The current terminal is supposed to be /dev/tty +ida_pro.plugin_options_t.__init__(self) -ida_pro.qdetach_tty (function) - qdetach_tty() - If the current terminal is the controlling terminal of the calling process, give - up this controlling terminal. - @note: The current terminal is supposed to be /dev/tty +ida_pro.plugin_options_t.erase(self, name: str) -> bool -ida_pro.qexit (function) - qexit(code) - Call qatexit functions, shut down UI and kernel, and exit. - - @param code: (C++: int) exit code +ida_pro.plugin_options_t.find(self, name: str) -> "plugin_option_t const *" -ida_pro.qmutex_locker_t (class) - Proxy of C++ qmutex_locker_t class. +ida_pro.qatoll(nptr: str) -> "int64" -ida_pro.qmutex_locker_t.__init__ (method) - __init__(self, _lock) -> qmutex_locker_t - - @param _lock: qmutex_t +ida_pro.qcontrol_tty() -> None + Make the current terminal the controlling terminal of the calling process. + -ida_pro.qrefcnt_obj_t (class) - Proxy of C++ qrefcnt_obj_t class. +ida_pro.qdetach_tty() -> None + If the current terminal is the controlling terminal of the calling process, give up this controlling terminal. + -ida_pro.qrefcnt_obj_t.__init__ (method) +ida_pro.qexit(code: int) -> None + Call qatexit functions, shut down UI and kernel, and exit. + + @param code: exit code -ida_pro.qrefcnt_obj_t.refcnt (variable) - counter +ida_pro.qmutex_locker_t -ida_pro.qrefcnt_obj_t.release (method) - release(self) - Call destructor. We use release() instead of operator delete() to maintain - binary compatibility with all compilers (vc and gcc use different vtable layouts - for operator delete) +ida_pro.qmutex_locker_t.__init__(self, _lock: "__qmutex_t") -ida_pro.qstrvec_t_add (function) - qstrvec_t_add(_self, s) -> bool - - @param self: PyObject * - @param s: char const * +ida_pro.qrefcnt_obj_t -ida_pro.qstrvec_t_addressof (function) - qstrvec_t_addressof(_self, idx) -> PyObject * - - @param self: PyObject * - @param idx: size_t +ida_pro.qrefcnt_obj_t.__init__(self, *args, **kwargs) -ida_pro.qstrvec_t_assign (function) - qstrvec_t_assign(_self, other) -> bool - - @param self: PyObject * - @param other: PyObject * +ida_pro.qrefcnt_obj_t.refcnt + counter + -ida_pro.qstrvec_t_clear (function) - qstrvec_t_clear(_self, qclear) -> bool - - @param self: PyObject * - @param qclear: bool +ida_pro.qrefcnt_obj_t.release(self) -> None + Call destructor. We use release() instead of operator delete() to maintain binary compatibility with all compilers (vc and gcc use different vtable layouts for operator delete) + -ida_pro.qstrvec_t_create (function) - qstrvec_t_create() -> PyObject * +ida_pro.qstrvec_t_add(_self: "PyObject *", s: str) -> bool -ida_pro.qstrvec_t_destroy (function) - qstrvec_t_destroy(py_obj) -> bool - - @param py_obj: PyObject * +ida_pro.qstrvec_t_addressof(_self: "PyObject *", idx: "size_t") -> "PyObject *" -ida_pro.qstrvec_t_from_list (function) - qstrvec_t_from_list(_self, py_list) -> bool - - @param self: PyObject * - @param py_list: PyObject * +ida_pro.qstrvec_t_assign(_self: "PyObject *", other: "PyObject *") -> bool -ida_pro.qstrvec_t_get (function) - qstrvec_t_get(_self, idx) -> PyObject * - - @param self: PyObject * - @param idx: size_t +ida_pro.qstrvec_t_clear(_self: "PyObject *", qclear: bool) -> bool -ida_pro.qstrvec_t_get_clink (function) - qstrvec_t_get_clink(_self) -> qstrvec_t * - - @param self: PyObject * +ida_pro.qstrvec_t_create() -> "PyObject *" -ida_pro.qstrvec_t_get_clink_ptr (function) - qstrvec_t_get_clink_ptr(_self) -> PyObject * - - @param self: PyObject * +ida_pro.qstrvec_t_destroy(py_obj: "PyObject *") -> bool -ida_pro.qstrvec_t_insert (function) - qstrvec_t_insert(_self, idx, s) -> bool - - @param self: PyObject * - @param idx: size_t - @param s: char const * +ida_pro.qstrvec_t_from_list(_self: "PyObject *", py_list: "PyObject *") -> bool -ida_pro.qstrvec_t_remove (function) - qstrvec_t_remove(_self, idx) -> bool - - @param self: PyObject * - @param idx: size_t +ida_pro.qstrvec_t_get(_self: "PyObject *", idx: "size_t") -> "PyObject *" -ida_pro.qstrvec_t_set (function) - qstrvec_t_set(_self, idx, s) -> bool - - @param self: PyObject * - @param idx: size_t - @param s: char const * +ida_pro.qstrvec_t_get_clink(_self: "PyObject *") -> "qstrvec_t *" -ida_pro.qstrvec_t_size (function) - qstrvec_t_size(_self) -> size_t - - @param self: PyObject * +ida_pro.qstrvec_t_get_clink_ptr(_self: "PyObject *") -> "PyObject *" -ida_pro.qthread_equal (function) - qthread_equal(q1, q2) -> bool +ida_pro.qstrvec_t_insert(_self: "PyObject *", idx: "size_t", s: str) -> bool + +ida_pro.qstrvec_t_remove(_self: "PyObject *", idx: "size_t") -> bool + +ida_pro.qstrvec_t_set(_self: "PyObject *", idx: "size_t", s: str) -> bool + +ida_pro.qstrvec_t_size(_self: "PyObject *") -> "size_t" + +ida_pro.qthread_equal(q1: "__qthread_t", q2: "__qthread_t") -> bool Are two threads equal? - - @param q1: (C++: qthread_t) - @param q2: (C++: qthread_t) -ida_pro.quote_cmdline_arg (function) - quote_cmdline_arg(arg) -> bool - Quote a command line argument if it contains escape characters. For example, *.c - will be converted into "*.c" because * may be inadvertently expanded by the - shell - - @param arg: (C++: qstring *) - @return: true: modified 'arg' +ida_pro.quote_cmdline_arg(arg: str) -> bool + Quote a command line argument if it contains escape characters. For example, *.c will be converted into "*.c" because * may be inadvertently expanded by the shell + + @returns true: modified 'arg' -ida_pro.qvector_reserve (function) - qvector_reserve(vec, old, cnt, elsize) -> void * - Change capacity of given qvector. - - @param vec: (C++: void *) a pointer to a qvector - @param old: (C++: void *) a pointer to the qvector's array - @param cnt: (C++: size_t) number of elements to reserve - @param elsize: (C++: size_t) size of each element - @return: a pointer to the newly allocated array +ida_pro.qvector_reserve(vec: "void *", old: "void *", cnt: "size_t", elsize: "size_t") -> "void *" + Change capacity of given qvector. + + @param vec: a pointer to a qvector + @param old: a pointer to the qvector's array + @param cnt: number of elements to reserve + @param elsize: size of each element + @returns a pointer to the newly allocated array -ida_pro.readbytes (function) - readbytes(h, res, size, mf) -> int - Read at most 4 bytes from file. - - @param h: (C++: int) file handle - @param res: (C++: uint32 *) value read from file - @param size: (C++: int) size of value in bytes (1,2,4) - @param mf: (C++: bool) is MSB first? - @return: 0 on success, nonzero otherwise +ida_pro.readbytes(h: int, res: "uint32 *", size: int, mf: bool) -> int + Read at most 4 bytes from file. + + @param h: file handle + @param res: value read from file + @param size: size of value in bytes (1,2,4) + @param mf: is MSB first? + @returns 0 on success, nonzero otherwise -ida_pro.reloc_value (function) - reloc_value(value, size, delta, mf) - - @param value: void * - @param size: int - @param delta: adiff_t - @param mf: bool +ida_pro.reloc_value(value: "void *", size: int, delta: "adiff_t", mf: bool) -> None -ida_pro.relocate_relobj (function) - relocate_relobj(_relobj, ea, mf) -> bool - - @param _relobj: relobj_t * - @param ea: ea_t - @param mf: bool +ida_pro.relocate_relobj(_relobj: "relobj_t *", ea: ida_idaapi.ea_t, mf: bool) -> bool -ida_pro.sel_array (class) - Proxy of C++ sel_array class. +ida_pro.sel_array -ida_pro.sel_array.__getitem__ (method) - __getitem__(self, index) -> sel_t - - @param index: size_t +ida_pro.sel_array.__getitem__(self, index: "size_t") -> "sel_t" -ida_pro.sel_array.__init__ (method) - __init__(self, nelements) -> sel_array - - @param nelements: size_t +ida_pro.sel_array.__init__(self, nelements: "size_t") -ida_pro.sel_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: sel_t +ida_pro.sel_array.__setitem__(self, index: "size_t", value: "sel_t") -> None -ida_pro.sel_array.cast (method) - cast(self) -> sel_t * +ida_pro.sel_array.cast(self) -> "sel_t *" -ida_pro.sel_array.frompointer (method) - frompointer(t) -> sel_array - - @param t: sel_t * +ida_pro.sel_array.frompointer(t: "sel_t *") -> "sel_array *" -ida_pro.sel_array_frompointer (function) - sel_array_frompointer(t) -> sel_array - - @param t: sel_t * +ida_pro.sel_pointer -ida_pro.sel_pointer (class) - Proxy of C++ sel_pointer class. +ida_pro.sel_pointer.__init__(self) -ida_pro.sel_pointer.__init__ (method) - __init__(self) -> sel_pointer +ida_pro.sel_pointer.assign(self, value: "sel_t") -> None -ida_pro.sel_pointer.assign (method) - assign(self, value) - - @param value: sel_t +ida_pro.sel_pointer.cast(self) -> "sel_t *" -ida_pro.sel_pointer.cast (method) - cast(self) -> sel_t * +ida_pro.sel_pointer.frompointer(t: "sel_t *") -> "sel_pointer *" -ida_pro.sel_pointer.frompointer (method) - frompointer(t) -> sel_pointer - - @param t: sel_t * +ida_pro.sel_pointer.value(self) -> "sel_t" -ida_pro.sel_pointer.value (method) - value(self) -> sel_t +ida_pro.short_pointer -ida_pro.sel_pointer_frompointer (function) - sel_pointer_frompointer(t) -> sel_pointer - - @param t: sel_t * +ida_pro.short_pointer.__init__(self) -ida_pro.sizevec_t (class) - Proxy of C++ qvector< size_t > class. +ida_pro.short_pointer.assign(self, value: "short") -> None -ida_pro.sizevec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< size_t > const & +ida_pro.short_pointer.cast(self) -> "short *" -ida_pro.sizevec_t.__getitem__ (method) - __getitem__(self, i) -> size_t const & - - @param i: size_t +ida_pro.short_pointer.frompointer(t: "short *") -> "short_pointer *" -ida_pro.sizevec_t.__init__ (method) - __init__(self) -> sizevec_t - __init__(self, x) -> sizevec_t - - @param x: qvector< size_t > const & +ida_pro.short_pointer.value(self) -> "short" -ida_pro.sizevec_t.__len__ (method) - __len__(self) -> size_t +ida_pro.sint8_pointer -ida_pro.sizevec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< size_t > const & +ida_pro.sint8_pointer.__init__(self) -ida_pro.sizevec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: size_t const & +ida_pro.sint8_pointer.assign(self, value: "sint8") -> None -ida_pro.sizevec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: size_t const & +ida_pro.sint8_pointer.cast(self) -> "sint8 *" -ida_pro.sizevec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: size_t const & +ida_pro.sint8_pointer.frompointer(t: "sint8 *") -> "sint8_pointer *" -ida_pro.sizevec_t.at (method) - at(self, _idx) -> size_t const & - - @param _idx: size_t +ida_pro.sint8_pointer.value(self) -> "sint8" -ida_pro.sizevec_t.begin (method) - begin(self) -> qvector< size_t >::iterator - begin(self) -> qvector< size_t >::const_iterator +ida_pro.sizevec_t -ida_pro.sizevec_t.capacity (method) - capacity(self) -> size_t +ida_pro.sizevec_t.__eq__(self, r: "sizevec_t") -> bool -ida_pro.sizevec_t.clear (method) - clear(self) +ida_pro.sizevec_t.__getitem__(self, i: "size_t") -> "size_t const &" -ida_pro.sizevec_t.empty (method) - empty(self) -> bool +ida_pro.sizevec_t.__init__(self, *args) -ida_pro.sizevec_t.end (method) - end(self) -> qvector< size_t >::iterator - end(self) -> qvector< size_t >::const_iterator +ida_pro.sizevec_t.__len__(self) -> "size_t" -ida_pro.sizevec_t.erase (method) - erase(self, it) -> qvector< size_t >::iterator - - @param it: qvector< size_t >::iterator - - erase(self, first, last) -> qvector< size_t >::iterator - - @param first: qvector< size_t >::iterator - @param last: qvector< size_t >::iterator +ida_pro.sizevec_t.__ne__(self, r: "sizevec_t") -> bool -ida_pro.sizevec_t.extract (method) - extract(self) -> size_t * +ida_pro.sizevec_t.__setitem__(self, i: "size_t", v: "size_t const &") -> None -ida_pro.sizevec_t.find (method) - find(self, x) -> qvector< size_t >::iterator - - @param x: size_t const & - - find(self, x) -> qvector< size_t >::const_iterator - - @param x: size_t const & +ida_pro.sizevec_t._del(self, x: "size_t const &") -> bool -ida_pro.sizevec_t.grow (method) - grow(self, x=size_t()) - - @param x: size_t const & +ida_pro.sizevec_t.add_unique(self, x: "size_t const &") -> bool -ida_pro.sizevec_t.has (method) - has(self, x) -> bool - - @param x: size_t const & +ida_pro.sizevec_t.append(self, x: "size_t const &") -> None -ida_pro.sizevec_t.inject (method) - inject(self, s, len) - - @param s: size_t * - @param len: size_t +ida_pro.sizevec_t.at(self, _idx: "size_t") -> "size_t const &" -ida_pro.sizevec_t.insert (method) - insert(self, it, x) -> qvector< size_t >::iterator - - @param it: qvector< size_t >::iterator - @param x: size_t const & +ida_pro.sizevec_t.begin(self, *args) -> "qvector< size_t >::const_iterator" -ida_pro.sizevec_t.pop_back (method) - pop_back(self) +ida_pro.sizevec_t.capacity(self) -> "size_t" -ida_pro.sizevec_t.push_back (method) - push_back(self, x) - - @param x: size_t const & - - push_back(self) -> size_t & +ida_pro.sizevec_t.clear(self) -> None -ida_pro.sizevec_t.qclear (method) - qclear(self) +ida_pro.sizevec_t.empty(self) -> bool -ida_pro.sizevec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_pro.sizevec_t.end(self, *args) -> "qvector< size_t >::const_iterator" -ida_pro.sizevec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: size_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_pro.sizevec_t.erase(self, *args) -> "qvector< size_t >::iterator" -ida_pro.sizevec_t.size (method) - size(self) -> size_t +ida_pro.sizevec_t.extend(self, x: "sizevec_t") -> None -ida_pro.sizevec_t.swap (method) - swap(self, r) - - @param r: qvector< size_t > & +ida_pro.sizevec_t.extract(self) -> "size_t *" -ida_pro.sizevec_t.truncate (method) - truncate(self) +ida_pro.sizevec_t.find(self, *args) -> "qvector< size_t >::const_iterator" -ida_pro.str2user (function) - str2user(str) -> str or None +ida_pro.sizevec_t.grow(self, *args) -> None + +ida_pro.sizevec_t.has(self, x: "size_t const &") -> bool + +ida_pro.sizevec_t.inject(self, s: "size_t *", len: "size_t") -> None + +ida_pro.sizevec_t.insert(self, it: "qvector< size_t >::iterator", x: "size_t const &") -> "qvector< size_t >::iterator" + +ida_pro.sizevec_t.pop_back(self) -> None + +ida_pro.sizevec_t.push_back(self, *args) -> "size_t &" + +ida_pro.sizevec_t.qclear(self) -> None + +ida_pro.sizevec_t.reserve(self, cnt: "size_t") -> None + +ida_pro.sizevec_t.resize(self, *args) -> None + +ida_pro.sizevec_t.size(self) -> "size_t" + +ida_pro.sizevec_t.swap(self, r: "sizevec_t") -> None + +ida_pro.sizevec_t.truncate(self) -> None + +ida_pro.ssize_pointer + +ida_pro.ssize_pointer.__init__(self) + +ida_pro.ssize_pointer.assign(self, value: "ssize_t") -> None + +ida_pro.ssize_pointer.cast(self) -> "ssize_t *" + +ida_pro.ssize_pointer.frompointer(t: "ssize_t *") -> "ssize_pointer *" + +ida_pro.ssize_pointer.value(self) -> "ssize_t" + +ida_pro.str2user(str) Insert C-style escape characters to string - @param str: char const * - @return: new string with escape characters inserted - -ida_pro.strvec_t (class) - Proxy of C++ qvector< simpleline_t > class. - -ida_pro.strvec_t.__getitem__ (method) - __getitem__(self, i) -> simpleline_t const & - - @param i: size_t - -ida_pro.strvec_t.__init__ (method) - __init__(self) -> strvec_t - __init__(self, x) -> strvec_t - - @param x: qvector< simpleline_t > const & - -ida_pro.strvec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.strvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: simpleline_t const & - -ida_pro.strvec_t.at (method) - at(self, _idx) -> simpleline_t const & - - @param _idx: size_t - -ida_pro.strvec_t.begin (method) - begin(self) -> qvector< simpleline_t >::iterator - begin(self) -> qvector< simpleline_t >::const_iterator - -ida_pro.strvec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.strvec_t.clear (method) - clear(self) - -ida_pro.strvec_t.empty (method) - empty(self) -> bool - -ida_pro.strvec_t.end (method) - end(self) -> qvector< simpleline_t >::iterator - end(self) -> qvector< simpleline_t >::const_iterator - -ida_pro.strvec_t.erase (method) - erase(self, it) -> qvector< simpleline_t >::iterator - - @param it: qvector< simpleline_t >::iterator - - erase(self, first, last) -> qvector< simpleline_t >::iterator - - @param first: qvector< simpleline_t >::iterator - @param last: qvector< simpleline_t >::iterator - -ida_pro.strvec_t.extract (method) - extract(self) -> simpleline_t * - -ida_pro.strvec_t.grow (method) - grow(self, x=simpleline_t()) - - @param x: simpleline_t const & - -ida_pro.strvec_t.inject (method) - inject(self, s, len) - - @param s: simpleline_t * - @param len: size_t - -ida_pro.strvec_t.insert (method) - insert(self, it, x) -> qvector< simpleline_t >::iterator - - @param it: qvector< simpleline_t >::iterator - @param x: simpleline_t const & - -ida_pro.strvec_t.pop_back (method) - pop_back(self) - -ida_pro.strvec_t.push_back (method) - push_back(self, x) - - @param x: simpleline_t const & - - push_back(self) -> simpleline_t & - -ida_pro.strvec_t.qclear (method) - qclear(self) - -ida_pro.strvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.strvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: simpleline_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.strvec_t.size (method) - size(self) -> size_t - -ida_pro.strvec_t.swap (method) - swap(self, r) - - @param r: qvector< simpleline_t > & - -ida_pro.strvec_t.truncate (method) - truncate(self) - -ida_pro.sval_pointer (class) - Proxy of C++ sval_pointer class. - -ida_pro.sval_pointer.__init__ (method) - __init__(self) -> sval_pointer - -ida_pro.sval_pointer.assign (method) - assign(self, value) - - @param value: sval_t - -ida_pro.sval_pointer.cast (method) - cast(self) -> sval_t * - -ida_pro.sval_pointer.frompointer (method) - frompointer(t) -> sval_pointer - - @param t: sval_t * - -ida_pro.sval_pointer.value (method) - value(self) -> sval_t - -ida_pro.sval_pointer_frompointer (function) - sval_pointer_frompointer(t) -> sval_pointer - - @param t: sval_t * - -ida_pro.tid_array (class) - Proxy of C++ tid_array class. - -ida_pro.tid_array.__getitem__ (method) - __getitem__(self, index) -> tid_t - - @param index: size_t - -ida_pro.tid_array.__init__ (method) - __init__(self, nelements) -> tid_array - - @param nelements: size_t - -ida_pro.tid_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: tid_t - -ida_pro.tid_array.cast (method) - cast(self) -> tid_t * - -ida_pro.tid_array.frompointer (method) - frompointer(t) -> tid_array - - @param t: tid_t * - -ida_pro.tid_array_frompointer (function) - tid_array_frompointer(t) -> tid_array - - @param t: tid_t * - -ida_pro.uchar_array (class) - Proxy of C++ uchar_array class. - -ida_pro.uchar_array.__getitem__ (method) - __getitem__(self, index) -> uchar - - @param index: size_t - -ida_pro.uchar_array.__init__ (method) - __init__(self, nelements) -> uchar_array - - @param nelements: size_t - -ida_pro.uchar_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: uchar - -ida_pro.uchar_array.cast (method) - cast(self) -> uchar * - -ida_pro.uchar_array.frompointer (method) - frompointer(t) -> uchar_array - - @param t: uchar * - -ida_pro.uchar_array_frompointer (function) - uchar_array_frompointer(t) -> uchar_array - - @param t: uchar * - -ida_pro.uint64vec_t (class) - Proxy of C++ qvector< unsigned long long > class. - -ida_pro.uint64vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< unsigned long long > const & - -ida_pro.uint64vec_t.__getitem__ (method) - __getitem__(self, i) -> unsigned long long const & - - @param i: size_t - -ida_pro.uint64vec_t.__init__ (method) - __init__(self) -> uint64vec_t - __init__(self, x) -> uint64vec_t - - @param x: qvector< unsigned long long > const & - -ida_pro.uint64vec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.uint64vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< unsigned long long > const & - -ida_pro.uint64vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned long long const & - -ida_pro.uint64vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: unsigned long long const & - -ida_pro.uint64vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: unsigned long long const & - -ida_pro.uint64vec_t.at (method) - at(self, _idx) -> unsigned long long const & - - @param _idx: size_t - -ida_pro.uint64vec_t.begin (method) - begin(self) -> qvector< unsigned long long >::iterator - begin(self) -> qvector< unsigned long long >::const_iterator - -ida_pro.uint64vec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.uint64vec_t.clear (method) - clear(self) - -ida_pro.uint64vec_t.empty (method) - empty(self) -> bool - -ida_pro.uint64vec_t.end (method) - end(self) -> qvector< unsigned long long >::iterator - end(self) -> qvector< unsigned long long >::const_iterator - -ida_pro.uint64vec_t.erase (method) - erase(self, it) -> qvector< unsigned long long >::iterator - - @param it: qvector< unsigned long long >::iterator - - erase(self, first, last) -> qvector< unsigned long long >::iterator - - @param first: qvector< unsigned long long >::iterator - @param last: qvector< unsigned long long >::iterator - -ida_pro.uint64vec_t.extract (method) - extract(self) -> unsigned long long * - -ida_pro.uint64vec_t.find (method) - find(self, x) -> qvector< unsigned long long >::iterator - - @param x: unsigned long long const & - - find(self, x) -> qvector< unsigned long long >::const_iterator - - @param x: unsigned long long const & - -ida_pro.uint64vec_t.has (method) - has(self, x) -> bool - - @param x: unsigned long long const & - -ida_pro.uint64vec_t.inject (method) - inject(self, s, len) - - @param s: unsigned long long * - @param len: size_t - -ida_pro.uint64vec_t.insert (method) - insert(self, it, x) -> qvector< unsigned long long >::iterator - - @param it: qvector< unsigned long long >::iterator - @param x: unsigned long long const & - -ida_pro.uint64vec_t.pop_back (method) - pop_back(self) - -ida_pro.uint64vec_t.push_back (method) - push_back(self, x) - - @param x: unsigned long long const & - - push_back(self) -> unsigned long long & - -ida_pro.uint64vec_t.qclear (method) - qclear(self) - -ida_pro.uint64vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.uint64vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: unsigned long long const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.uint64vec_t.size (method) - size(self) -> size_t - -ida_pro.uint64vec_t.swap (method) - swap(self, r) - - @param r: qvector< unsigned long long > & - -ida_pro.uint64vec_t.truncate (method) - truncate(self) - -ida_pro.uintvec_t (class) - Proxy of C++ qvector< unsigned int > class. - -ida_pro.uintvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< unsigned int > const & - -ida_pro.uintvec_t.__getitem__ (method) - __getitem__(self, i) -> unsigned int const & - - @param i: size_t - -ida_pro.uintvec_t.__init__ (method) - __init__(self) -> uintvec_t - __init__(self, x) -> uintvec_t - - @param x: qvector< unsigned int > const & - -ida_pro.uintvec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.uintvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< unsigned int > const & - -ida_pro.uintvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned int const & - -ida_pro.uintvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: unsigned int const & - -ida_pro.uintvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: unsigned int const & - -ida_pro.uintvec_t.at (method) - at(self, _idx) -> unsigned int const & - - @param _idx: size_t - -ida_pro.uintvec_t.begin (method) - begin(self) -> qvector< unsigned int >::iterator - begin(self) -> qvector< unsigned int >::const_iterator - -ida_pro.uintvec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.uintvec_t.clear (method) - clear(self) - -ida_pro.uintvec_t.empty (method) - empty(self) -> bool - -ida_pro.uintvec_t.end (method) - end(self) -> qvector< unsigned int >::iterator - end(self) -> qvector< unsigned int >::const_iterator - -ida_pro.uintvec_t.erase (method) - erase(self, it) -> qvector< unsigned int >::iterator - - @param it: qvector< unsigned int >::iterator - - erase(self, first, last) -> qvector< unsigned int >::iterator - - @param first: qvector< unsigned int >::iterator - @param last: qvector< unsigned int >::iterator - -ida_pro.uintvec_t.extract (method) - extract(self) -> unsigned int * - -ida_pro.uintvec_t.find (method) - find(self, x) -> qvector< unsigned int >::iterator - - @param x: unsigned int const & - - find(self, x) -> qvector< unsigned int >::const_iterator - - @param x: unsigned int const & - -ida_pro.uintvec_t.has (method) - has(self, x) -> bool - - @param x: unsigned int const & - -ida_pro.uintvec_t.inject (method) - inject(self, s, len) - - @param s: unsigned int * - @param len: size_t - -ida_pro.uintvec_t.insert (method) - insert(self, it, x) -> qvector< unsigned int >::iterator - - @param it: qvector< unsigned int >::iterator - @param x: unsigned int const & - -ida_pro.uintvec_t.pop_back (method) - pop_back(self) - -ida_pro.uintvec_t.push_back (method) - push_back(self, x) - - @param x: unsigned int const & - - push_back(self) -> unsigned int & - -ida_pro.uintvec_t.qclear (method) - qclear(self) - -ida_pro.uintvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.uintvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: unsigned int const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.uintvec_t.size (method) - size(self) -> size_t - -ida_pro.uintvec_t.swap (method) - swap(self, r) - - @param r: qvector< unsigned int > & - -ida_pro.uintvec_t.truncate (method) - truncate(self) - -ida_pro.uval_array (class) - Proxy of C++ uval_array class. - -ida_pro.uval_array.__getitem__ (method) - __getitem__(self, index) -> uval_t - - @param index: size_t - -ida_pro.uval_array.__init__ (method) - __init__(self, nelements) -> uval_array - - @param nelements: size_t - -ida_pro.uval_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: uval_t - -ida_pro.uval_array.cast (method) - cast(self) -> uval_t * - -ida_pro.uval_array.frompointer (method) - frompointer(t) -> uval_array - - @param t: uval_t * - -ida_pro.uval_array_frompointer (function) - uval_array_frompointer(t) -> uval_array - - @param t: uval_t * - -ida_pro.writebytes (function) - writebytes(h, l, size, mf) -> int - Write at most 4 bytes to file. - - @param h: (C++: int) file handle - @param l: (C++: uint32) value to write - @param size: (C++: int) size of value in bytes (1,2,4) - @param mf: (C++: bool) is MSB first? - @return: 0 on success, nonzero otherwise - -ida_problems (module) + @param str: the input string + @return: new string with escape characters inserted, or None + +ida_pro.strvec_t + +ida_pro.strvec_t.__getitem__(self, i: "size_t") -> "simpleline_t const &" + +ida_pro.strvec_t.__init__(self, *args) + +ida_pro.strvec_t.__len__(self) -> "size_t" + +ida_pro.strvec_t.__setitem__(self, i: "size_t", v: "simpleline_t const &") -> None + +ida_pro.strvec_t.append(self, x: "simpleline_t const &") -> None + +ida_pro.strvec_t.at(self, _idx: "size_t") -> "simpleline_t const &" + +ida_pro.strvec_t.begin(self, *args) -> "qvector< simpleline_t >::const_iterator" + +ida_pro.strvec_t.capacity(self) -> "size_t" + +ida_pro.strvec_t.clear(self) -> None + +ida_pro.strvec_t.empty(self) -> bool + +ida_pro.strvec_t.end(self, *args) -> "qvector< simpleline_t >::const_iterator" + +ida_pro.strvec_t.erase(self, *args) -> "qvector< simpleline_t >::iterator" + +ida_pro.strvec_t.extend(self, x: "strvec_t") -> None + +ida_pro.strvec_t.extract(self) -> "simpleline_t *" + +ida_pro.strvec_t.grow(self, *args) -> None + +ida_pro.strvec_t.inject(self, s: "simpleline_t *", len: "size_t") -> None + +ida_pro.strvec_t.insert(self, it: "qvector< simpleline_t >::iterator", x: "simpleline_t const &") -> "qvector< simpleline_t >::iterator" + +ida_pro.strvec_t.pop_back(self) -> None + +ida_pro.strvec_t.push_back(self, *args) -> "simpleline_t &" + +ida_pro.strvec_t.qclear(self) -> None + +ida_pro.strvec_t.reserve(self, cnt: "size_t") -> None + +ida_pro.strvec_t.resize(self, *args) -> None + +ida_pro.strvec_t.size(self) -> "size_t" + +ida_pro.strvec_t.swap(self, r: "strvec_t") -> None + +ida_pro.strvec_t.truncate(self) -> None + +ida_pro.sval_pointer + +ida_pro.sval_pointer.__init__(self) + +ida_pro.sval_pointer.assign(self, value: int) -> None + +ida_pro.sval_pointer.cast(self) -> "sval_t *" + +ida_pro.sval_pointer.frompointer(t: "sval_t *") -> "sval_pointer *" + +ida_pro.sval_pointer.value(self) -> int + +ida_pro.tid_array + +ida_pro.tid_array.__getitem__(self, index: "size_t") -> "tid_t" + +ida_pro.tid_array.__init__(self, nelements: "size_t") + +ida_pro.tid_array.__setitem__(self, index: "size_t", value: "tid_t") -> None + +ida_pro.tid_array.cast(self) -> "tid_t *" + +ida_pro.tid_array.frompointer(t: "tid_t *") -> "tid_array *" + +ida_pro.tid_pointer + +ida_pro.tid_pointer.__init__(self) + +ida_pro.tid_pointer.assign(self, value: "tid_t") -> None + +ida_pro.tid_pointer.cast(self) -> "tid_t *" + +ida_pro.tid_pointer.frompointer(t: "tid_t *") -> "tid_pointer *" + +ida_pro.tid_pointer.value(self) -> "tid_t" + +ida_pro.uchar_array + +ida_pro.uchar_array.__getitem__(self, index: "size_t") -> "uchar" + +ida_pro.uchar_array.__init__(self, nelements: "size_t") + +ida_pro.uchar_array.__setitem__(self, index: "size_t", value: "uchar") -> None + +ida_pro.uchar_array.cast(self) -> "uchar *" + +ida_pro.uchar_array.frompointer(t: "uchar *") -> "uchar_array *" + +ida_pro.uchar_pointer + +ida_pro.uchar_pointer.__init__(self) + +ida_pro.uchar_pointer.assign(self, value: "uchar") -> None + +ida_pro.uchar_pointer.cast(self) -> "uchar *" + +ida_pro.uchar_pointer.frompointer(t: "uchar *") -> "uchar_pointer *" + +ida_pro.uchar_pointer.value(self) -> "uchar" + +ida_pro.uint16_pointer + +ida_pro.uint16_pointer.__init__(self) + +ida_pro.uint16_pointer.assign(self, value: "uint16") -> None + +ida_pro.uint16_pointer.cast(self) -> "uint16 *" + +ida_pro.uint16_pointer.frompointer(t: "uint16 *") -> "uint16_pointer *" + +ida_pro.uint16_pointer.value(self) -> "uint16" + +ida_pro.uint32_pointer + +ida_pro.uint32_pointer.__init__(self) + +ida_pro.uint32_pointer.assign(self, value: int) -> None + +ida_pro.uint32_pointer.cast(self) -> "uint32 *" + +ida_pro.uint32_pointer.frompointer(t: "uint32 *") -> "uint32_pointer *" + +ida_pro.uint32_pointer.value(self) -> int + +ida_pro.uint64_pointer + +ida_pro.uint64_pointer.__init__(self) + +ida_pro.uint64_pointer.assign(self, value: "uint64") -> None + +ida_pro.uint64_pointer.cast(self) -> "uint64 *" + +ida_pro.uint64_pointer.frompointer(t: "uint64 *") -> "uint64_pointer *" + +ida_pro.uint64_pointer.value(self) -> "uint64" + +ida_pro.uint64vec_t + +ida_pro.uint64vec_t.__eq__(self, r: "uint64vec_t") -> bool + +ida_pro.uint64vec_t.__getitem__(self, i: "size_t") -> "unsigned long long const &" + +ida_pro.uint64vec_t.__init__(self, *args) + +ida_pro.uint64vec_t.__len__(self) -> "size_t" + +ida_pro.uint64vec_t.__ne__(self, r: "uint64vec_t") -> bool + +ida_pro.uint64vec_t.__setitem__(self, i: "size_t", v: "unsigned long long const &") -> None + +ida_pro.uint64vec_t._del(self, x: "unsigned long long const &") -> bool + +ida_pro.uint64vec_t.add_unique(self, x: "unsigned long long const &") -> bool + +ida_pro.uint64vec_t.append(self, x: "unsigned long long const &") -> None + +ida_pro.uint64vec_t.at(self, _idx: "size_t") -> "unsigned long long const &" + +ida_pro.uint64vec_t.begin(self, *args) -> "qvector< unsigned long long >::const_iterator" + +ida_pro.uint64vec_t.capacity(self) -> "size_t" + +ida_pro.uint64vec_t.clear(self) -> None + +ida_pro.uint64vec_t.empty(self) -> bool + +ida_pro.uint64vec_t.end(self, *args) -> "qvector< unsigned long long >::const_iterator" + +ida_pro.uint64vec_t.erase(self, *args) -> "qvector< unsigned long long >::iterator" + +ida_pro.uint64vec_t.extend(self, x: "uint64vec_t") -> None + +ida_pro.uint64vec_t.extract(self) -> "unsigned long long *" + +ida_pro.uint64vec_t.find(self, *args) -> "qvector< unsigned long long >::const_iterator" + +ida_pro.uint64vec_t.has(self, x: "unsigned long long const &") -> bool + +ida_pro.uint64vec_t.inject(self, s: "unsigned long long *", len: "size_t") -> None + +ida_pro.uint64vec_t.insert(self, it: "qvector< unsigned long long >::iterator", x: "unsigned long long const &") -> "qvector< unsigned long long >::iterator" + +ida_pro.uint64vec_t.pop_back(self) -> None + +ida_pro.uint64vec_t.push_back(self, *args) -> "unsigned long long &" + +ida_pro.uint64vec_t.qclear(self) -> None + +ida_pro.uint64vec_t.reserve(self, cnt: "size_t") -> None + +ida_pro.uint64vec_t.resize(self, *args) -> None + +ida_pro.uint64vec_t.size(self) -> "size_t" + +ida_pro.uint64vec_t.swap(self, r: "uint64vec_t") -> None + +ida_pro.uint64vec_t.truncate(self) -> None + +ida_pro.uint8_pointer + +ida_pro.uint8_pointer.__init__(self) + +ida_pro.uint8_pointer.assign(self, value: "uint8") -> None + +ida_pro.uint8_pointer.cast(self) -> "uint8 *" + +ida_pro.uint8_pointer.frompointer(t: "uint8 *") -> "uint8_pointer *" + +ida_pro.uint8_pointer.value(self) -> "uint8" + +ida_pro.uint_pointer + +ida_pro.uint_pointer.__init__(self) + +ida_pro.uint_pointer.assign(self, value: "uint") -> None + +ida_pro.uint_pointer.cast(self) -> "uint *" + +ida_pro.uint_pointer.frompointer(t: "uint *") -> "uint_pointer *" + +ida_pro.uint_pointer.value(self) -> "uint" + +ida_pro.uintvec_t + +ida_pro.uintvec_t.__eq__(self, r: "uintvec_t") -> bool + +ida_pro.uintvec_t.__getitem__(self, i: "size_t") -> "unsigned int const &" + +ida_pro.uintvec_t.__init__(self, *args) + +ida_pro.uintvec_t.__len__(self) -> "size_t" + +ida_pro.uintvec_t.__ne__(self, r: "uintvec_t") -> bool + +ida_pro.uintvec_t.__setitem__(self, i: "size_t", v: "unsigned int const &") -> None + +ida_pro.uintvec_t._del(self, x: "unsigned int const &") -> bool + +ida_pro.uintvec_t.add_unique(self, x: "unsigned int const &") -> bool + +ida_pro.uintvec_t.append(self, x: "unsigned int const &") -> None + +ida_pro.uintvec_t.at(self, _idx: "size_t") -> "unsigned int const &" + +ida_pro.uintvec_t.begin(self, *args) -> "qvector< unsigned int >::const_iterator" + +ida_pro.uintvec_t.capacity(self) -> "size_t" + +ida_pro.uintvec_t.clear(self) -> None + +ida_pro.uintvec_t.empty(self) -> bool + +ida_pro.uintvec_t.end(self, *args) -> "qvector< unsigned int >::const_iterator" + +ida_pro.uintvec_t.erase(self, *args) -> "qvector< unsigned int >::iterator" + +ida_pro.uintvec_t.extend(self, x: "uintvec_t") -> None + +ida_pro.uintvec_t.extract(self) -> "unsigned int *" + +ida_pro.uintvec_t.find(self, *args) -> "qvector< unsigned int >::const_iterator" + +ida_pro.uintvec_t.has(self, x: "unsigned int const &") -> bool + +ida_pro.uintvec_t.inject(self, s: "unsigned int *", len: "size_t") -> None + +ida_pro.uintvec_t.insert(self, it: "qvector< unsigned int >::iterator", x: "unsigned int const &") -> "qvector< unsigned int >::iterator" + +ida_pro.uintvec_t.pop_back(self) -> None + +ida_pro.uintvec_t.push_back(self, *args) -> "unsigned int &" + +ida_pro.uintvec_t.qclear(self) -> None + +ida_pro.uintvec_t.reserve(self, cnt: "size_t") -> None + +ida_pro.uintvec_t.resize(self, *args) -> None + +ida_pro.uintvec_t.size(self) -> "size_t" + +ida_pro.uintvec_t.swap(self, r: "uintvec_t") -> None + +ida_pro.uintvec_t.truncate(self) -> None + +ida_pro.ushort_pointer + +ida_pro.ushort_pointer.__init__(self) + +ida_pro.ushort_pointer.assign(self, value: "ushort") -> None + +ida_pro.ushort_pointer.cast(self) -> "ushort *" + +ida_pro.ushort_pointer.frompointer(t: "ushort *") -> "ushort_pointer *" + +ida_pro.ushort_pointer.value(self) -> "ushort" + +ida_pro.uval_array + +ida_pro.uval_array.__getitem__(self, index: "size_t") -> int + +ida_pro.uval_array.__init__(self, nelements: "size_t") + +ida_pro.uval_array.__setitem__(self, index: "size_t", value: int) -> None + +ida_pro.uval_array.cast(self) -> "uval_t *" + +ida_pro.uval_array.frompointer(t: "uval_t *") -> "uval_array *" + +ida_pro.uval_pointer + +ida_pro.uval_pointer.__init__(self) + +ida_pro.uval_pointer.assign(self, value: int) -> None + +ida_pro.uval_pointer.cast(self) -> "uval_t *" + +ida_pro.uval_pointer.frompointer(t: "uval_t *") -> "uval_pointer *" + +ida_pro.uval_pointer.value(self) -> int + +ida_pro.writebytes(h: int, l: int, size: int, mf: bool) -> int + Write at most 4 bytes to file. + + @param h: file handle + @param l: value to write + @param size: size of value in bytes (1,2,4) + @param mf: is MSB first? + @returns 0 on success, nonzero otherwise + +ida_problems Functions that deal with the list of problems. - There are several problem lists. An address may be inserted to any list. The - kernel simply maintains these lists, no additional processing is done. - - The problem lists are accessible for the user from the View->Subviews->Problems - menu item. - - Addresses in the lists are kept sorted. In general IDA just maintains these - lists without using them during analysis (except PR_ROLLED). + There are several problem lists. An address may be inserted to any list. The kernel simply maintains these lists, no additional processing is done. + The problem lists are accessible for the user from the View->Subviews->Problems menu item. + Addresses in the lists are kept sorted. In general IDA just maintains these lists without using them during analysis (except PR_ROLLED). + -ida_problems.PR_ATTN (variable) +ida_problems.PR_ATTN Attention! Probably erroneous situation. -ida_problems.PR_BADSTACK (variable) +ida_problems.PR_BADSTACK Failed to trace the value of the stack pointer. -ida_problems.PR_COLLISION (variable) +ida_problems.PR_COLLISION FLAIR collision: the function with the given name already exists. -ida_problems.PR_DECIMP (variable) - FLAIR match indecision: the patterns matched, but not the function(s) being - referenced. +ida_problems.PR_DECIMP + FLAIR match indecision: the patterns matched, but not the function(s) being referenced. -ida_problems.PR_DISASM (variable) +ida_problems.PR_DISASM Can't disasm. -ida_problems.PR_END (variable) +ida_problems.PR_END Number of problem types. -ida_problems.PR_FINAL (variable) +ida_problems.PR_FINAL Decision to convert to instruction/data is made by IDA. -ida_problems.PR_HEAD (variable) +ida_problems.PR_HEAD Already head. -ida_problems.PR_ILLADDR (variable) +ida_problems.PR_ILLADDR Exec flows beyond limits. -ida_problems.PR_JUMP (variable) +ida_problems.PR_JUMP Jump by table !!!! ignored. -ida_problems.PR_MANYLINES (variable) +ida_problems.PR_MANYLINES Too many lines. -ida_problems.PR_NOBASE (variable) +ida_problems.PR_NOBASE Can't find offset base. -ida_problems.PR_NOCMT (variable) +ida_problems.PR_NOCMT Can't find comment (not used anymore) -ida_problems.PR_NOFOP (variable) +ida_problems.PR_NOFOP Can't find forced op (not used anymore) -ida_problems.PR_NONAME (variable) +ida_problems.PR_NONAME Can't find name. -ida_problems.PR_NOXREFS (variable) +ida_problems.PR_NOXREFS Can't find references. -ida_problems.PR_ROLLED (variable) +ida_problems.PR_ROLLED The decision made by IDA was wrong and rolled back. -ida_problems.forget_problem (function) - forget_problem(type, ea) -> bool - Remove an address from a problem list - - @param type: (C++: problist_id_t) problem list type - @param ea: (C++: ea_t) linear address - @return: success +ida_problems.forget_problem(type: "problist_id_t", ea: ida_idaapi.ea_t) -> bool + Remove an address from a problem list + + @param type: problem list type + @param ea: linear address + @returns success -ida_problems.get_problem (function) - get_problem(type, lowea) -> ea_t - Get an address from the specified problem list. The address is not removed from - the list. - - @param type: (C++: problist_id_t) problem list type - @param lowea: (C++: ea_t) the returned address will be higher or equal than the specified - address - @return: linear address or BADADDR +ida_problems.get_problem(type: "problist_id_t", lowea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get an address from the specified problem list. The address is not removed from the list. + + @param type: problem list type + @param lowea: the returned address will be higher or equal than the specified address + @returns linear address or BADADDR -ida_problems.get_problem_desc (function) - get_problem_desc(t, ea) -> str - Get the human-friendly description of the problem, if one was provided to - remember_problem. - - @param t: (C++: problist_id_t) problem list type. - @param ea: (C++: ea_t) linear address. - @return: the message length or -1 if none +ida_problems.get_problem_desc(t: "problist_id_t", ea: ida_idaapi.ea_t) -> str + Get the human-friendly description of the problem, if one was provided to remember_problem. + + @param t: problem list type. + @param ea: linear address. + @returns the message length or -1 if none -ida_problems.get_problem_name (function) - get_problem_name(type, longname=True) -> char const * +ida_problems.get_problem_name(type: "problist_id_t", longname: bool = True) -> str Get problem list description. - - @param type: (C++: problist_id_t) - @param longname: (C++: bool) -ida_problems.is_problem_present (function) - is_problem_present(t, ea) -> bool +ida_problems.is_problem_present(t: "problist_id_t", ea: ida_idaapi.ea_t) -> bool Check if the specified address is present in the problem list. - - @param t: (C++: problist_id_t) - @param ea: (C++: ea_t) -ida_problems.remember_problem (function) - remember_problem(type, ea, msg=None) - Insert an address to a list of problems. Display a message saying about the - problem (except of PR_ATTN,PR_FINAL) PR_JUMP is temporarily ignored. - - @param type: (C++: problist_id_t) problem list type - @param ea: (C++: ea_t) linear address - @param msg: (C++: const char *) a user-friendly message to be displayed instead of the default more - generic one associated with the type of problem. Defaults to - nullptr. +ida_problems.remember_problem(type: "problist_id_t", ea: ida_idaapi.ea_t, msg: str = None) -> None + Insert an address to a list of problems. Display a message saying about the problem (except of PR_ATTN,PR_FINAL) PR_JUMP is temporarily ignored. + + @param type: problem list type + @param ea: linear address + @param msg: a user-friendly message to be displayed instead of the default more generic one associated with the type of problem. Defaults to nullptr. -ida_problems.was_ida_decision (function) - was_ida_decision(ea) -> bool - - @param ea: ea_t +ida_problems.was_ida_decision(ea: ida_idaapi.ea_t) -> bool -ida_range (module) +ida_range Contains the definition of range_t. - A range is a non-empty continuous range of addresses (specified by its start and - end addresses, the end address is excluded from the range). - - Ranges are stored in the Btree part of the IDA database. To learn more about - Btrees (Balanced Trees): \link{http://www.bluerwhite.org/btree/} + A range is a non-empty continuous range of addresses (specified by its start and end addresses, the end address is excluded from the range). + Ranges are stored in the Btree part of the IDA database. To learn more about Btrees (Balanced Trees): [http://www.bluerwhite.org/btree/](http://www.bluerwhite.org/btree/) + -ida_range.RANGE_KIND_FUNC (variable) +ida_range.RANGE_KIND_FUNC func_t -ida_range.RANGE_KIND_HIDDEN_RANGE (variable) +ida_range.RANGE_KIND_HIDDEN_RANGE hidden_range_t -ida_range.RANGE_KIND_SEGMENT (variable) +ida_range.RANGE_KIND_SEGMENT segment_t -ida_range.array_of_rangesets (class) - Proxy of C++ qvector< rangeset_t > class. +ida_range.array_of_rangesets -ida_range.array_of_rangesets.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< rangeset_t > const & +ida_range.array_of_rangesets.__eq__(self, r: "array_of_rangesets") -> bool -ida_range.array_of_rangesets.__getitem__ (method) - __getitem__(self, i) -> rangeset_t - - @param i: size_t +ida_range.array_of_rangesets.__getitem__(self, i: "size_t") -> "rangeset_t const &" -ida_range.array_of_rangesets.__init__ (method) - __init__(self) -> array_of_rangesets - __init__(self, x) -> array_of_rangesets - - @param x: qvector< rangeset_t > const & +ida_range.array_of_rangesets.__init__(self, *args) -ida_range.array_of_rangesets.__len__ (method) - __len__(self) -> size_t +ida_range.array_of_rangesets.__len__(self) -> "size_t" -ida_range.array_of_rangesets.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< rangeset_t > const & +ida_range.array_of_rangesets.__ne__(self, r: "array_of_rangesets") -> bool -ida_range.array_of_rangesets.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: rangeset_t const & +ida_range.array_of_rangesets.__setitem__(self, i: "size_t", v: "rangeset_t") -> None -ida_range.array_of_rangesets._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: rangeset_t const & +ida_range.array_of_rangesets._del(self, x: "rangeset_t") -> bool -ida_range.array_of_rangesets.add_unique (method) - add_unique(self, x) -> bool - - @param x: rangeset_t const & +ida_range.array_of_rangesets.add_unique(self, x: "rangeset_t") -> bool -ida_range.array_of_rangesets.at (method) - at(self, _idx) -> rangeset_t - - @param _idx: size_t +ida_range.array_of_rangesets.append(self, x: "rangeset_t") -> None -ida_range.array_of_rangesets.begin (method) - begin(self) -> rangeset_t +ida_range.array_of_rangesets.at(self, _idx: "size_t") -> "rangeset_t const &" -ida_range.array_of_rangesets.capacity (method) - capacity(self) -> size_t +ida_range.array_of_rangesets.begin(self, *args) -> "qvector< rangeset_t >::const_iterator" -ida_range.array_of_rangesets.clear (method) - clear(self) +ida_range.array_of_rangesets.capacity(self) -> "size_t" -ida_range.array_of_rangesets.empty (method) - empty(self) -> bool +ida_range.array_of_rangesets.clear(self) -> None -ida_range.array_of_rangesets.end (method) - end(self) -> rangeset_t +ida_range.array_of_rangesets.empty(self) -> bool -ida_range.array_of_rangesets.erase (method) - erase(self, it) -> rangeset_t - - @param it: qvector< rangeset_t >::iterator - - erase(self, first, last) -> rangeset_t - - @param first: qvector< rangeset_t >::iterator - @param last: qvector< rangeset_t >::iterator +ida_range.array_of_rangesets.end(self, *args) -> "qvector< rangeset_t >::const_iterator" -ida_range.array_of_rangesets.extract (method) - extract(self) -> rangeset_t +ida_range.array_of_rangesets.erase(self, *args) -> "qvector< rangeset_t >::iterator" -ida_range.array_of_rangesets.find (method) - find(self, x) -> rangeset_t - - @param x: rangeset_t const & +ida_range.array_of_rangesets.extend(self, x: "array_of_rangesets") -> None -ida_range.array_of_rangesets.grow (method) - grow(self, x=rangeset_t()) - - @param x: rangeset_t const & +ida_range.array_of_rangesets.extract(self) -> "rangeset_t *" -ida_range.array_of_rangesets.has (method) - has(self, x) -> bool - - @param x: rangeset_t const & +ida_range.array_of_rangesets.find(self, *args) -> "qvector< rangeset_t >::const_iterator" -ida_range.array_of_rangesets.inject (method) - inject(self, s, len) - - @param s: rangeset_t * - @param len: size_t +ida_range.array_of_rangesets.grow(self, *args) -> None -ida_range.array_of_rangesets.insert (method) - insert(self, it, x) -> rangeset_t - - @param it: qvector< rangeset_t >::iterator - @param x: rangeset_t const & +ida_range.array_of_rangesets.has(self, x: "rangeset_t") -> bool -ida_range.array_of_rangesets.pop_back (method) - pop_back(self) +ida_range.array_of_rangesets.inject(self, s: "rangeset_t", len: "size_t") -> None -ida_range.array_of_rangesets.push_back (method) - push_back(self, x) - - @param x: rangeset_t const & - - push_back(self) -> rangeset_t +ida_range.array_of_rangesets.insert(self, it: "rangeset_t", x: "rangeset_t") -> "qvector< rangeset_t >::iterator" -ida_range.array_of_rangesets.qclear (method) - qclear(self) +ida_range.array_of_rangesets.pop_back(self) -> None -ida_range.array_of_rangesets.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_range.array_of_rangesets.push_back(self, *args) -> "rangeset_t &" -ida_range.array_of_rangesets.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: rangeset_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_range.array_of_rangesets.qclear(self) -> None -ida_range.array_of_rangesets.size (method) - size(self) -> size_t +ida_range.array_of_rangesets.reserve(self, cnt: "size_t") -> None -ida_range.array_of_rangesets.swap (method) - swap(self, r) - - @param r: qvector< rangeset_t > & +ida_range.array_of_rangesets.resize(self, *args) -> None -ida_range.array_of_rangesets.truncate (method) - truncate(self) +ida_range.array_of_rangesets.size(self) -> "size_t" -ida_range.range_t (class) - Proxy of C++ range_t class. +ida_range.array_of_rangesets.swap(self, r: "array_of_rangesets") -> None -ida_range.range_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: range_t const & +ida_range.array_of_rangesets.truncate(self) -> None -ida_range.range_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: range_t const & +ida_range.range_t -ida_range.range_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: range_t const & +ida_range.range_t.__eq__(self, r: "range_t") -> bool -ida_range.range_t.__init__ (method) - __init__(self, ea1=0, ea2=0) -> range_t - - @param ea1: ea_t - @param ea2: ea_t +ida_range.range_t.__ge__(self, r: "range_t") -> bool -ida_range.range_t.__le__ (method) - __le__(self, r) -> bool - - @param r: range_t const & +ida_range.range_t.__gt__(self, r: "range_t") -> bool -ida_range.range_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: range_t const & +ida_range.range_t.__init__(self, ea1: ida_idaapi.ea_t = 0, ea2: ida_idaapi.ea_t = 0) -ida_range.range_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: range_t const & +ida_range.range_t.__le__(self, r: "range_t") -> bool -ida_range.range_t._print (method) - _print(self) -> size_t +ida_range.range_t.__lt__(self, r: "range_t") -> bool -ida_range.range_t.clear (method) - clear(self) +ida_range.range_t.__ne__(self, r: "range_t") -> bool + +ida_range.range_t._print(self, *args) -> "size_t" + +ida_range.range_t.clear(self) -> None Set start_ea, end_ea to 0. -ida_range.range_t.compare (method) - compare(self, r) -> int - - @param r: range_t const & +ida_range.range_t.compare(self, r: "range_t") -> int -ida_range.range_t.contains (method) - contains(self, ea) -> bool +ida_range.range_t.contains(self, *args) -> bool + This function has the following signatures: + + 0. contains(ea: ida_idaapi.ea_t) -> bool + 1. contains(r: const range_t &) -> bool + + # 0: contains(ea: ida_idaapi.ea_t) -> bool + + Compare two range_t instances, based on the start_ea. + + Is 'ea' in the address range? + + + # 1: contains(r: const range_t &) -> bool + Is every ea in 'r' also in this range_t? - - @param ea: ea_t - - contains(self, r) -> bool - - @param r: range_t const & -ida_range.range_t.empty (method) - empty(self) -> bool +ida_range.range_t.empty(self) -> bool Is the size of the range_t <= 0? -ida_range.range_t.end_ea (variable) +ida_range.range_t.end_ea end_ea excluded -ida_range.range_t.extend (method) - extend(self, ea) +ida_range.range_t.extend(self, ea: ida_idaapi.ea_t) -> None Ensure that the range_t includes 'ea'. - - @param ea: (C++: ea_t) -ida_range.range_t.intersect (method) - intersect(self, r) +ida_range.range_t.intersect(self, r: "range_t") -> None Assign the range_t to the intersection between the range_t and 'r'. - - @param r: (C++: const range_t &) range_t const & -ida_range.range_t.overlaps (method) - overlaps(self, r) -> bool +ida_range.range_t.overlaps(self, r: "range_t") -> bool Is there an ea in 'r' that is also in this range_t? - - @param r: (C++: const range_t &) range_t const & -ida_range.range_t.size (method) - size(self) -> asize_t +ida_range.range_t.size(self) -> "asize_t" Get end_ea - start_ea. -ida_range.range_t.start_ea (variable) +ida_range.range_t.start_ea start_ea included -ida_range.range_t_print (function) - range_t_print(cb) -> str +ida_range.range_t_print(cb: "range_t") -> str Helper function. Should not be called directly! - - @param cb: range_t const * -ida_range.rangeset_t (class) - Proxy of C++ rangeset_t class. +ida_range.rangeset_t -ida_range.rangeset_t.__eq__ (method) - __eq__(self, aset) -> bool - - @param aset: rangeset_t const & +ida_range.rangeset_t.__eq__(self, aset: "rangeset_t") -> bool -ida_range.rangeset_t.__getitem__ (method) +ida_range.rangeset_t.__getitem__(self, idx) -ida_range.rangeset_t.__init__ (method) - __init__(self) -> rangeset_t - __init__(self, range) -> rangeset_t - - @param range: range_t const & - - __init__(self, ivs) -> rangeset_t - - @param ivs: rangeset_t const & +ida_range.rangeset_t.__init__(self, *args) -ida_range.rangeset_t.__ne__ (method) - __ne__(self, aset) -> bool - - @param aset: rangeset_t const & +ida_range.rangeset_t.__ne__(self, aset: "rangeset_t") -> bool -ida_range.rangeset_t._print (method) - _print(self) -> size_t +ida_range.rangeset_t._print(self, *args) -> "size_t" -ida_range.rangeset_t.add (method) - add(self, range) -> bool - Add each element of 'aset' to the set. +ida_range.rangeset_t.add(self, *args) -> bool + This function has the following signatures: - @param range: range_t const & + 0. add(range: const range_t &) -> bool + 1. add(start: ida_idaapi.ea_t, _end: ida_idaapi.ea_t) -> bool + 2. add(aset: const rangeset_t &) -> bool - @return: false if no elements were added (the set was unchanged) - add(self, start, _end) -> bool + # 0: add(range: const range_t &) -> bool - @param start: ea_t - @param _end: ea_t + Add an address range to the set. If 'range' intersects an existing element e, then e is extended to include 'range', and any superfluous elements (subsets of e) are removed. + + @returns false if 'range' was not added (the set was unchanged) - add(self, aset) -> bool + # 1: add(start: ida_idaapi.ea_t, _end: ida_idaapi.ea_t) -> bool - @param aset: rangeset_t const & + Create a new range_t from 'start' and 'end' and add it to the set. + + + # 2: add(aset: const rangeset_t &) -> bool + + Add each element of 'aset' to the set. + + @returns false if no elements were added (the set was unchanged) -ida_range.rangeset_t.begin (method) - begin(self) -> range_t +ida_range.rangeset_t.begin(self) -> "rangeset_t::iterator" Get an iterator that points to the first element in the set. -ida_range.rangeset_t.cached_range (method) - cached_range(self) -> range_t - When searching the rangeset, we keep a cached element to help speed up searches. - - @return: a pointer to the cached element +ida_range.rangeset_t.cached_range(self) -> "range_t const *" + When searching the rangeset, we keep a cached element to help speed up searches. + + @returns a pointer to the cached element -ida_range.rangeset_t.clear (method) - clear(self) +ida_range.rangeset_t.clear(self) -> None Delete all elements from the set. See qvector::clear() -ida_range.rangeset_t.contains (method) - contains(self, ea) -> bool - Is every element in 'aset' contained in an element of this rangeset?. See - range_t::contains(range_t) +ida_range.rangeset_t.contains(self, *args) -> bool + This function has the following signatures: - @param ea: ea_t + 0. contains(ea: ida_idaapi.ea_t) -> bool + 1. contains(aset: const rangeset_t &) -> bool - contains(self, aset) -> bool + # 0: contains(ea: ida_idaapi.ea_t) -> bool - @param aset: rangeset_t const & + Does an element of the rangeset contain 'ea'? See range_t::contains(ea_t) + + + # 1: contains(aset: const rangeset_t &) -> bool + + Is every element in 'aset' contained in an element of this rangeset?. See range_t::contains(range_t) -ida_range.rangeset_t.empty (method) - empty(self) -> bool +ida_range.rangeset_t.empty(self) -> bool Does the set have zero elements. -ida_range.rangeset_t.end (method) - end(self) -> range_t - Get an iterator that points to the end of the set. (This is NOT the last - element) +ida_range.rangeset_t.end(self) -> "rangeset_t::iterator" + Get an iterator that points to the end of the set. (This is NOT the last element) -ida_range.rangeset_t.find_range (method) - find_range(self, ea) -> range_t - Get the element from the set that contains 'ea'. - - @param ea: (C++: ea_t) - @return: nullptr if there is no such element +ida_range.rangeset_t.find_range(self, ea: ida_idaapi.ea_t) -> "range_t const *" + Get the element from the set that contains 'ea'. + + @returns nullptr if there is no such element -ida_range.rangeset_t.getrange (method) - getrange(self, idx) -> range_t +ida_range.rangeset_t.getrange(self, idx: int) -> "range_t const &" Get the range_t at index 'idx'. - - @param idx: (C++: int) -ida_range.rangeset_t.has_common (method) - has_common(self, range) -> bool - Does any element of 'aset' overlap with an element in this rangeset?. See - range_t::overlaps() +ida_range.rangeset_t.has_common(self, *args) -> bool + This function has the following signatures: - @param range: range_t const & + 0. has_common(range: const range_t &) -> bool + 1. has_common(aset: const rangeset_t &) -> bool - has_common(self, aset) -> bool + # 0: has_common(range: const range_t &) -> bool - @param aset: rangeset_t const & + Is there an ea in 'range' that is also in the rangeset? + + + # 1: has_common(aset: const rangeset_t &) -> bool + + Does any element of 'aset' overlap with an element in this rangeset?. See range_t::overlaps() -ida_range.rangeset_t.includes (method) - includes(self, range) -> bool +ida_range.rangeset_t.includes(self, range: "range_t") -> bool Is every ea in 'range' contained in the rangeset? - - @param range: (C++: const range_t &) range_t const & -ida_range.rangeset_t.intersect (method) - intersect(self, aset) -> bool - Set the rangeset to its intersection with 'aset'. - - @param aset: (C++: const rangeset_t &) rangeset_t const & - @return: false if the set was unchanged +ida_range.rangeset_t.intersect(self, aset: "rangeset_t") -> bool + Set the rangeset to its intersection with 'aset'. + + @returns false if the set was unchanged -ida_range.rangeset_t.is_equal (method) - is_equal(self, aset) -> bool +ida_range.rangeset_t.is_equal(self, aset: "rangeset_t") -> bool Do this rangeset and 'aset' have identical elements? - - @param aset: (C++: const rangeset_t &) rangeset_t const & -ida_range.rangeset_t.is_subset_of (method) - is_subset_of(self, aset) -> bool +ida_range.rangeset_t.is_subset_of(self, aset: "rangeset_t") -> bool Is every element in the rangeset contained in an element of 'aset'? - - @param aset: (C++: const rangeset_t &) rangeset_t const & -ida_range.rangeset_t.lastrange (method) - lastrange(self) -> range_t +ida_range.rangeset_t.lastrange(self) -> "range_t const &" Get the last range_t in the set. -ida_range.rangeset_t.next_addr (method) - next_addr(self, ea) -> ea_t +ida_range.rangeset_t.next_addr(self, ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Get the smallest ea_t value greater than 'ea' contained in the rangeset. - - @param ea: (C++: ea_t) -ida_range.rangeset_t.next_range (method) - next_range(self, ea) -> ea_t - Get the smallest ea_t value greater than 'ea' that is not in the same range as - 'ea'. - - @param ea: (C++: ea_t) +ida_range.rangeset_t.next_range(self, ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get the smallest ea_t value greater than 'ea' that is not in the same range as 'ea'. -ida_range.rangeset_t.nranges (method) - nranges(self) -> size_t +ida_range.rangeset_t.nranges(self) -> "size_t" Get the number of range_t elements in the set. -ida_range.rangeset_t.prev_addr (method) - prev_addr(self, ea) -> ea_t +ida_range.rangeset_t.prev_addr(self, ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Get the largest ea_t value less than 'ea' contained in the rangeset. - - @param ea: (C++: ea_t) -ida_range.rangeset_t.prev_range (method) - prev_range(self, ea) -> ea_t +ida_range.rangeset_t.prev_range(self, ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Get the largest ea_t value less than 'ea' that is not in the same range as 'ea'. - - @param ea: (C++: ea_t) -ida_range.rangeset_t.sub (method) - sub(self, range) -> bool - Subtract each range in 'aset' from the set +ida_range.rangeset_t.sub(self, *args) -> bool + This function has the following signatures: - @param range: range_t const & + 0. sub(range: const range_t &) -> bool + 1. sub(ea: ida_idaapi.ea_t) -> bool + 2. sub(aset: const rangeset_t &) -> bool - @return: false if nothing was subtracted (the set was unchanged) - sub(self, ea) -> bool + # 0: sub(range: const range_t &) -> bool - @param ea: ea_t + Subtract an address range from the set. All subsets of 'range' will be removed, and all elements that intersect 'range' will be truncated/split so they do not include 'range'. + + @returns false if 'range' was not subtracted (the set was unchanged) - sub(self, aset) -> bool + # 1: sub(ea: ida_idaapi.ea_t) -> bool - @param aset: rangeset_t const & + Subtract an ea (an range of size 1) from the set. See sub(const range_t &) + + + # 2: sub(aset: const rangeset_t &) -> bool + + Subtract each range in 'aset' from the set + + @returns false if nothing was subtracted (the set was unchanged) -ida_range.rangeset_t.swap (method) - swap(self, r) +ida_range.rangeset_t.swap(self, r: "rangeset_t") -> None Set this = 'r' and 'r' = this. See qvector::swap() - - @param r: (C++: rangeset_t &) -ida_range.rangevec_base_t (class) - Proxy of C++ qvector< range_t > class. +ida_range.rangevec_base_t -ida_range.rangevec_base_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< range_t > const & +ida_range.rangevec_base_t.__eq__(self, r: "rangevec_base_t") -> bool -ida_range.rangevec_base_t.__getitem__ (method) - __getitem__(self, i) -> range_t - - @param i: size_t +ida_range.rangevec_base_t.__getitem__(self, i: "size_t") -> "range_t const &" -ida_range.rangevec_base_t.__init__ (method) - __init__(self) -> rangevec_base_t - __init__(self, x) -> rangevec_base_t - - @param x: qvector< range_t > const & +ida_range.rangevec_base_t.__init__(self, *args) -ida_range.rangevec_base_t.__len__ (method) - __len__(self) -> size_t +ida_range.rangevec_base_t.__len__(self) -> "size_t" -ida_range.rangevec_base_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< range_t > const & +ida_range.rangevec_base_t.__ne__(self, r: "rangevec_base_t") -> bool -ida_range.rangevec_base_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: range_t const & +ida_range.rangevec_base_t.__setitem__(self, i: "size_t", v: "range_t") -> None -ida_range.rangevec_base_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: range_t const & +ida_range.rangevec_base_t._del(self, x: "range_t") -> bool -ida_range.rangevec_base_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: range_t const & +ida_range.rangevec_base_t.add_unique(self, x: "range_t") -> bool -ida_range.rangevec_base_t.at (method) - at(self, _idx) -> range_t - - @param _idx: size_t +ida_range.rangevec_base_t.append(self, x: "range_t") -> None -ida_range.rangevec_base_t.begin (method) - begin(self) -> range_t +ida_range.rangevec_base_t.at(self, _idx: "size_t") -> "range_t const &" -ida_range.rangevec_base_t.capacity (method) - capacity(self) -> size_t +ida_range.rangevec_base_t.begin(self, *args) -> "qvector< range_t >::const_iterator" -ida_range.rangevec_base_t.clear (method) - clear(self) +ida_range.rangevec_base_t.capacity(self) -> "size_t" -ida_range.rangevec_base_t.empty (method) - empty(self) -> bool +ida_range.rangevec_base_t.clear(self) -> None -ida_range.rangevec_base_t.end (method) - end(self) -> range_t +ida_range.rangevec_base_t.empty(self) -> bool -ida_range.rangevec_base_t.erase (method) - erase(self, it) -> range_t - - @param it: qvector< range_t >::iterator - - erase(self, first, last) -> range_t - - @param first: qvector< range_t >::iterator - @param last: qvector< range_t >::iterator +ida_range.rangevec_base_t.end(self, *args) -> "qvector< range_t >::const_iterator" -ida_range.rangevec_base_t.extract (method) - extract(self) -> range_t +ida_range.rangevec_base_t.erase(self, *args) -> "qvector< range_t >::iterator" -ida_range.rangevec_base_t.find (method) - find(self, x) -> range_t - - @param x: range_t const & +ida_range.rangevec_base_t.extend(self, x: "rangevec_base_t") -> None -ida_range.rangevec_base_t.grow (method) - grow(self, x=range_t()) - - @param x: range_t const & +ida_range.rangevec_base_t.extract(self) -> "range_t *" -ida_range.rangevec_base_t.has (method) - has(self, x) -> bool - - @param x: range_t const & +ida_range.rangevec_base_t.find(self, *args) -> "qvector< range_t >::const_iterator" -ida_range.rangevec_base_t.inject (method) - inject(self, s, len) - - @param s: range_t * - @param len: size_t +ida_range.rangevec_base_t.grow(self, *args) -> None -ida_range.rangevec_base_t.insert (method) - insert(self, it, x) -> range_t - - @param it: qvector< range_t >::iterator - @param x: range_t const & +ida_range.rangevec_base_t.has(self, x: "range_t") -> bool -ida_range.rangevec_base_t.pop_back (method) - pop_back(self) +ida_range.rangevec_base_t.inject(self, s: "range_t", len: "size_t") -> None -ida_range.rangevec_base_t.push_back (method) - push_back(self, x) - - @param x: range_t const & - - push_back(self) -> range_t +ida_range.rangevec_base_t.insert(self, it: "range_t", x: "range_t") -> "qvector< range_t >::iterator" -ida_range.rangevec_base_t.qclear (method) - qclear(self) +ida_range.rangevec_base_t.pop_back(self) -> None -ida_range.rangevec_base_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_range.rangevec_base_t.push_back(self, *args) -> "range_t &" -ida_range.rangevec_base_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: range_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_range.rangevec_base_t.qclear(self) -> None -ida_range.rangevec_base_t.size (method) - size(self) -> size_t +ida_range.rangevec_base_t.reserve(self, cnt: "size_t") -> None -ida_range.rangevec_base_t.swap (method) - swap(self, r) - - @param r: qvector< range_t > & +ida_range.rangevec_base_t.resize(self, *args) -> None -ida_range.rangevec_base_t.truncate (method) - truncate(self) +ida_range.rangevec_base_t.size(self) -> "size_t" -ida_range.rangevec_t (class) - Proxy of C++ rangevec_t class. +ida_range.rangevec_base_t.swap(self, r: "rangevec_base_t") -> None -ida_range.rangevec_t.__init__ (method) - __init__(self) -> rangevec_t +ida_range.rangevec_base_t.truncate(self) -> None -ida_registry (module) +ida_range.rangevec_t + +ida_range.rangevec_t.__init__(self) + +ida_registry Registry related functions. - IDA uses the registry to store global configuration options that must persist - after IDA has been closed. - - On Windows, IDA uses the Windows registry directly. On Unix systems, the - registry is stored in a file (typically ~/.idapro/ida.reg). - - The root key for accessing IDA settings in the registry is defined by - ROOT_KEY_NAME. + IDA uses the registry to store global configuration options that must persist after IDA has been closed. + On Windows, IDA uses the Windows registry directly. On Unix systems, the registry is stored in a file (typically ~/.idapro/ida.reg). + The root key for accessing IDA settings in the registry is defined by ROOT_KEY_NAME. + -ida_registry.ROOT_KEY_NAME (variable) - Default key used to store IDA settings in registry (Windows version). - @note: this name is automatically prepended to all key names passed to functions - in this file. +ida_registry.ROOT_KEY_NAME + Default key used to store IDA settings in registry (Windows version). + -ida_registry.reg_binary (variable) +ida_registry.reg_binary binary data -ida_registry.reg_data_type (function) - reg_data_type(name, subkey=None) -> regval_type_t - Get data type of a given value. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) key name - @return: false if the [key+]value doesn't exist +ida_registry.reg_data_type(name: str, subkey: str = None) -> "regval_type_t" + Get data type of a given value. + + @param name: value name + @param subkey: key name + @returns false if the [key+]value doesn't exist -ida_registry.reg_delete (function) - reg_delete(name, subkey=None) -> bool - Delete a value from the registry. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) parent key - @return: success +ida_registry.reg_delete(name: str, subkey: str = None) -> bool + Delete a value from the registry. + + @param name: value name + @param subkey: parent key + @returns success -ida_registry.reg_delete_subkey (function) - reg_delete_subkey(name) -> bool +ida_registry.reg_delete_subkey(name: str) -> bool Delete a key from the registry. - - @param name: (C++: const char *) char const * -ida_registry.reg_delete_tree (function) - reg_delete_tree(name) -> bool +ida_registry.reg_delete_tree(name: str) -> bool Delete a subtree from the registry. - - @param name: (C++: const char *) char const * -ida_registry.reg_dword (variable) +ida_registry.reg_dword 32-bit number -ida_registry.reg_exists (function) - reg_exists(name, subkey=None) -> bool - Is there already a value with the given name? - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) parent key +ida_registry.reg_exists(name: str, subkey: str = None) -> bool + Is there already a value with the given name? + + @param name: value name + @param subkey: parent key -ida_registry.reg_flush (function) - reg_flush() +ida_registry.reg_read_binary(name: str, subkey: str = None) -> "PyObject *" + Read binary data from the registry. + + @param name: value name + @param subkey: key name + @returns false if 'data' is not large enough to hold all data present. in this case 'data' is left untouched. -ida_registry.reg_load (function) - reg_load() +ida_registry.reg_read_bool(name: str, defval: bool, subkey: str = None) -> bool + Read boolean value from the registry. + + @param name: value name + @param defval: default value + @param subkey: key name + @returns boolean read from registry, or 'defval' if the read failed -ida_registry.reg_read_binary (function) - reg_read_binary(name, subkey=None) -> bytes or None - Read binary data from the registry. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) key name - @return: success +ida_registry.reg_read_int(name: str, defval: int, subkey: str = None) -> int + Read integer value from the registry. + + @param name: value name + @param defval: default value + @param subkey: key name + @returns the value read from the registry, or 'defval' if the read failed -ida_registry.reg_read_bool (function) - reg_read_bool(name, defval, subkey=None) -> bool - Read boolean value from the registry. - - @param name: (C++: const char *) value name - @param defval: (C++: bool) default value - @param subkey: (C++: const char *) key name - @return: boolean read from registry, or 'defval' if the read failed +ida_registry.reg_read_string(name: str, subkey: str = None, _def: str = None) -> "PyObject *" + Read a string from the registry. + + @param name: value name + @param subkey: key name + @returns success -ida_registry.reg_read_int (function) - reg_read_int(name, defval, subkey=None) -> int - Read integer value from the registry. - - @param name: (C++: const char *) value name - @param defval: (C++: int) default value - @param subkey: (C++: const char *) key name - @return: the value read from the registry, or 'defval' if the read failed +ida_registry.reg_read_strlist(subkey: str) -> "qstrvec_t *" + Retrieve all string values associated with the given key. Also see reg_update_strlist(), reg_write_strlist() + -ida_registry.reg_read_string (function) - reg_read_string(name, subkey=None, _def=None) -> str - Read a string from the registry. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) key name - @param def: char const * - @return: success - -ida_registry.reg_read_strlist (function) - reg_read_strlist(subkey) - Retrieve all string values associated with the given key. Also see - reg_update_strlist(). - - @param subkey: (C++: const char *) char const * - -ida_registry.reg_subkey_exists (function) - reg_subkey_exists(name) -> bool +ida_registry.reg_subkey_exists(name: str) -> bool Is there already a key with the given name? - - @param name: (C++: const char *) char const * -ida_registry.reg_subkey_subkeys (function) - reg_subkey_subkeys(name) -> [str, ...] +ida_registry.reg_subkey_subkeys(name: str) -> "PyObject *" Get all subkey names of given key. - - @param name: (C++: const char *) char const * -ida_registry.reg_subkey_values (function) - reg_subkey_values(name) -> [str, ...] +ida_registry.reg_subkey_values(name: str) -> "PyObject *" Get all value names under given key. - - @param name: (C++: const char *) char const * -ida_registry.reg_sz (variable) +ida_registry.reg_sz utf8 string -ida_registry.reg_unknown (variable) +ida_registry.reg_unknown unknown -ida_registry.reg_update_filestrlist (function) - reg_update_filestrlist(subkey, add, maxrecs, rem=None) - Update registry with a file list. Case sensitivity will vary depending on the - target OS. - @note: 'add' and 'rem' must be UTF-8, just like for regular string operations. - - @param subkey: (C++: const char *) char const * - @param add: (C++: const char *) char const * - @param maxrecs: (C++: size_t) - @param rem: (C++: const char *) char const * +ida_registry.reg_update_filestrlist(subkey: str, add: str, maxrecs: "size_t", rem: str = None) -> None + Update registry with a file list. Case sensitivity will vary depending on the target OS. + -ida_registry.reg_update_strlist (function) - reg_update_strlist(subkey, add, maxrecs, rem=None, ignorecase=False) - Update list of strings associated with given key. - - @param subkey: (C++: const char *) key name - @param add: (C++: const char *) string to be added to list, can be nullptr - @param maxrecs: (C++: size_t) limit list to this size - @param rem: (C++: const char *) string to be removed from list, can be nullptr - @param ignorecase: (C++: bool) ignore case for 'add' and 'rem' +ida_registry.reg_update_strlist(subkey: str, add: str, maxrecs: "size_t", rem: str = None, ignorecase: bool = False) -> None + Update list of strings associated with given key. + + @param subkey: key name + @param add: string to be added to list, can be nullptr + @param maxrecs: limit list to this size + @param rem: string to be removed from list, can be nullptr + @param ignorecase: ignore case for 'add' and 'rem' -ida_registry.reg_write_binary (function) - reg_write_binary(name, py_bytes, subkey=None) -> PyObject * - Write binary data to the registry. - - @param name: (C++: const char *) value name - @param py_bytes: PyObject * - @param subkey: (C++: const char *) key name +ida_registry.reg_write_binary(name: str, py_bytes: "PyObject *", subkey: str = None) -> "PyObject *" + Write binary data to the registry. + + @param name: value name + @param subkey: key name -ida_registry.reg_write_bool (function) - reg_write_bool(name, value, subkey=None) - Write boolean value to the registry. - - @param name: (C++: const char *) value name - @param value: (C++: int) boolean to write (nonzero = true) - @param subkey: (C++: const char *) key name +ida_registry.reg_write_bool(name: str, value: int, subkey: str = None) -> None + Write boolean value to the registry. + + @param name: value name + @param value: boolean to write (nonzero = true) + @param subkey: key name -ida_registry.reg_write_int (function) - reg_write_int(name, value, subkey=None) - Write integer value to the registry. - - @param name: (C++: const char *) value name - @param value: (C++: int) value to write - @param subkey: (C++: const char *) key name +ida_registry.reg_write_int(name: str, value: int, subkey: str = None) -> None + Write integer value to the registry. + + @param name: value name + @param value: value to write + @param subkey: key name -ida_registry.reg_write_string (function) - reg_write_string(name, utf8, subkey=None) - Write a string to the registry. - - @param name: (C++: const char *) value name - @param utf8: (C++: const char *) utf8-encoded string - @param subkey: (C++: const char *) key name +ida_registry.reg_write_string(name: str, utf8: str, subkey: str = None) -> None + Write a string to the registry. + + @param name: value name + @param utf8: utf8-encoded string + @param subkey: key name -ida_registry.set_registry_root (function) - set_registry_root(name) -> bool - - @param name: char const * +ida_registry.reg_write_strlist(_in: "qstrvec_t const &", subkey: str) -> None + Write string values associated with the given key. Also see reg_read_strlist(), reg_update_strlist() + -ida_regfinder (module) - +ida_registry.set_registry_name(name: str) -> bool -ida_regfinder.find_nearest_rvi (function) - find_nearest_rvi(rvi, ea, reg) -> int - Find the value of any of the two registers using the register tracker. First, - this function tries to find the registers in the basic block of EA, and if it - could not do this, then it tries to find in the entire function. - - @param rvi: (C++: reg_value_info_t *) the found value with additional attributes - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: const int) the registers to find - @return: the index of the found register or -1 +ida_regfinder -ida_regfinder.find_reg_value (function) - find_reg_value(ea, reg) -> int - Find register value using the register tracker. - @note: The returned value is valid *before* executing the instruction. - - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: int) the register to find - @retval 0: no value (the value is varying or the find depth is not enough to - find a value) +ida_regfinder.find_nearest_rvi(rvi: "reg_value_info_t", ea: ida_idaapi.ea_t, reg: "int const [2]") -> int + Find the value of any of the two registers using the register tracker. First, this function tries to find the registers in the basic block of EA, and if it could not do this, then it tries to find in the entire function. + + @param rvi: the found value with additional attributes + @param ea: the address to find a value at + @param reg: the registers to find + @returns the index of the found register or -1 + +ida_regfinder.find_reg_value(ea: ida_idaapi.ea_t, reg: int) -> "uint64 *" + Find register value using the register tracker. + + @param ea: the address to find a value at + @param reg: the register to find + @retval 0: no value (the value is varying or the find depth is not enough to find a value) @retval 1: the found value is in VAL @retval -1: the processor module does not support a register tracker -ida_regfinder.find_reg_value_info (function) - find_reg_value_info(rvi, ea, reg, max_depth=0) -> bool - Find register value using the register tracker. - @note: The returned value is valid *before* executing the instruction. - @note: The _undefined_ value means that there is no execution flow to EA, e.g. - we try to find a value after the call of NORET function. - @note: The _unknown_ value means that the value is: - * a result of unsupported instruction, e.g. the result of a call, - * a function argument, - * is varying, e.g. it is a loop counter. - - @param rvi: (C++: reg_value_info_t *) the found value with additional attributes - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: int) the register to find - @param max_depth: (C++: int) the number of basic blocks to look before aborting the search - and returning the unknown value. 0 means the value of - REGTRACK_MAX_DEPTH from ida.cfg for ordinal registers or - REGTRACK_FUNC_MAX_DEPTH for the function-wide registers, -1 - means the value of REGTRACK_FUNC_MAX_DEPTH from ida.cfg. +ida_regfinder.find_reg_value_info(rvi: "reg_value_info_t", ea: ida_idaapi.ea_t, reg: int, max_depth: int = 0) -> bool + Find register value using the register tracker. + + @param rvi: the found value with additional attributes + @param ea: the address to find a value at + @param reg: the register to find + @param max_depth: the number of basic blocks to look before aborting the search and returning the unknown value. 0 means the value of REGTRACK_MAX_DEPTH from ida.cfg for ordinal registers or REGTRACK_FUNC_MAX_DEPTH for the function-wide registers, -1 means the value of REGTRACK_FUNC_MAX_DEPTH from ida.cfg. @retval 'false': the processor module does not support a register tracker @retval 'true': the found value is in RVI -ida_regfinder.find_sp_value (function) - find_sp_value(ea, reg=-1) -> int - Find a value of the SP based register using the register tracker. - @note: The returned value is valid *before* executing the instruction. - - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: int) the register to find. by default the SP register is used. - @retval 0: no value (the value is varying or the find depth is not enough to - find a value) +ida_regfinder.find_sp_value(ea: ida_idaapi.ea_t, reg: int = -1) -> "int64 *" + Find a value of the SP based register using the register tracker. + + @param ea: the address to find a value at + @param reg: the register to find. by default the SP register is used. + @retval 0: no value (the value is varying or the find depth is not enough to find a value) @retval 1: the found value is in VAL @retval -1: the processor module does not support a register tracker -ida_regfinder.invalidate_regfinder_cache (function) - invalidate_regfinder_cache(ea=BADADDR) - Remove from the register tracker cache all values at EA and all dependent - values. As if the control flow to this instruction has changed. if EA == BADADDR - then clear the entire cache. - - @param ea: (C++: ea_t) +ida_regfinder.invalidate_regfinder_cache(*args) -> None + The control flow from FROM to TO has changed. Remove from the register tracker cache all values at TO and all dependent values. if TO == BADADDR then clear the entire cache. + -ida_regfinder.reg_value_def_t (class) - Proxy of C++ reg_value_def_t class. +ida_regfinder.reg_value_def_t -ida_regfinder.reg_value_def_t.LIKE_GOT (variable) - the value is like GOT only for numbers - @see: is_num() +ida_regfinder.reg_value_def_t.LIKE_GOT + the value is like GOT only for numbers + -ida_regfinder.reg_value_def_t.NOVAL (variable) +ida_regfinder.reg_value_def_t.NOVAL without a value -ida_regfinder.reg_value_def_t.PC_BASED (variable) - the value depends on DEF_EA only for numbers - @see: is_num() +ida_regfinder.reg_value_def_t.PC_BASED + the value depends on DEF_EA only for numbers + -ida_regfinder.reg_value_def_t.SHORT_INSN (variable) +ida_regfinder.reg_value_def_t.SHORT_INSN like 'addi reg, imm' -ida_regfinder.reg_value_def_t.SPVAL (variable) +ida_regfinder.reg_value_def_t.SPVAL as a SP delta -ida_regfinder.reg_value_def_t.UVAL (variable) +ida_regfinder.reg_value_def_t.UVAL as a number -ida_regfinder.reg_value_def_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: reg_value_def_t const & +ida_regfinder.reg_value_def_t.__eq__(self, r: "reg_value_def_t") -> bool -ida_regfinder.reg_value_def_t.__init__ (method) - __init__(self) -> reg_value_def_t - __init__(self, _val, ea, _flags=0) -> reg_value_def_t - - @param _val: uval_t - @param ea: ea_t - @param _flags: uint16 - - __init__(self, _val, insn, _flags=0) -> reg_value_def_t - - @param _val: uval_t - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param _flags: uint16 +ida_regfinder.reg_value_def_t.__init__(self, *args) -ida_regfinder.reg_value_def_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: reg_value_def_t const & +ida_regfinder.reg_value_def_t.__lt__(self, r: "reg_value_def_t") -> bool -ida_regfinder.reg_value_def_t.def_ea (variable) +ida_regfinder.reg_value_def_t.def_ea the instruction address -ida_regfinder.reg_value_def_t.def_itype (variable) +ida_regfinder.reg_value_def_t.def_itype the instruction code (processor specific) -ida_regfinder.reg_value_def_t.dstr (method) - dstr(self, how, pm=None) -> qstring +ida_regfinder.reg_value_def_t.dstr(self, how: "reg_value_def_t::dstr_val_t", pm: "procmod_t" = None) -> str Return the string representation. - - @param how: (C++: dstr_val_t) enum reg_value_def_t::dstr_val_t - @param pm: (C++: const procmod_t *) procmod_t const * -ida_regfinder.reg_value_def_t.flags (variable) +ida_regfinder.reg_value_def_t.flags additional info about the value -ida_regfinder.reg_value_def_t.is_like_got (method) - is_like_got(self) -> bool +ida_regfinder.reg_value_def_t.is_like_got(self) -> bool -ida_regfinder.reg_value_def_t.is_pc_based (method) - is_pc_based(self) -> bool +ida_regfinder.reg_value_def_t.is_pc_based(self) -> bool -ida_regfinder.reg_value_def_t.is_short_insn (method) - is_short_insn(self, insn) -> bool +ida_regfinder.reg_value_def_t.is_short_insn(self, *args) -> bool + This function has the following signatures: - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) + 0. is_short_insn() -> bool + 1. is_short_insn(insn: const insn_t &) -> bool - is_short_insn(self) -> bool + # 0: is_short_insn() -> bool + + + # 1: is_short_insn(insn: const insn_t &) -> bool -ida_regfinder.reg_value_def_t.val (variable) +ida_regfinder.reg_value_def_t.val the value -ida_regfinder.reg_value_info_t (class) - Proxy of C++ reg_value_info_t class. +ida_regfinder.reg_value_info_t -ida_regfinder.reg_value_info_t.CONTAINED (variable) +ida_regfinder.reg_value_info_t.CONTAINED L is contained in R (i.e. L\R is empty) -ida_regfinder.reg_value_info_t.CONTAINS (variable) +ida_regfinder.reg_value_info_t.CONTAINS L contains R (i.e. R\L is empty) -ida_regfinder.reg_value_info_t.EQUAL (variable) +ida_regfinder.reg_value_info_t.EQUAL L==R. -ida_regfinder.reg_value_info_t.NOT_COMPARABLE (variable) +ida_regfinder.reg_value_info_t.NOT_COMPARABLE L\R is not empty and R\L is not empty. -ida_regfinder.reg_value_info_t.__getitem__ (method) - __getitem__(self, i) -> reg_value_def_t - - @param i: size_t +ida_regfinder.reg_value_info_t.__getitem__(self, i: "size_t") -> "reg_value_def_t const &" -ida_regfinder.reg_value_info_t.__init__ (method) - __init__(self) -> reg_value_info_t +ida_regfinder.reg_value_info_t.__init__(self) -ida_regfinder.reg_value_info_t.__len__ (method) - __len__(self) -> size_t +ida_regfinder.reg_value_info_t.__len__(self) -> "size_t" -ida_regfinder.reg_value_info_t.__str__ (method) - __str__(self) -> qstring +ida_regfinder.reg_value_info_t.__str__(self) -> str -ida_regfinder.reg_value_info_t.aborted (method) - aborted(self) -> bool +ida_regfinder.reg_value_info_t.aborted(self) -> bool Return 'true' if the tracking process was aborted. -ida_regfinder.reg_value_info_t.add (method) - add(self, r, insn) - Add R to the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.add(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Add R to the value, save INSN as a defining instruction. + -ida_regfinder.reg_value_info_t.add_num (method) - add_num(self, r, insn) - Add R to the value, do not change the defining instructions. - @note: This method do nothing for unknown values. +ida_regfinder.reg_value_info_t.add_num(self, *args) -> None + This function has the following signatures: - @param r: (C++: uval_t) - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) + 0. add_num(r: int, insn: const insn_t &) -> None + 1. add_num(r: int) -> None - add_num(self, r) + # 0: add_num(r: int, insn: const insn_t &) -> None - @param r: uval_t + Add R to the value, save INSN as a defining instruction. + + + # 1: add_num(r: int) -> None + + Add R to the value, do not change the defining instructions. + -ida_regfinder.reg_value_info_t.band (method) - band(self, r, insn) - Make bitwise AND of R to the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.band(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Make bitwise AND of R to the value, save INSN as a defining instruction. + -ida_regfinder.reg_value_info_t.bandnot (method) - bandnot(self, r, insn) - Make bitwise AND of the inverse of R to the value, save INSN as a defining - instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.bandnot(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Make bitwise AND of the inverse of R to the value, save INSN as a defining instruction. + -ida_regfinder.reg_value_info_t.bnot (method) - bnot(self, insn) - Make bitwise inverse of the value, save INSN as a defining instruction. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.bnot(self, insn: "insn_t const &") -> None + Make bitwise inverse of the value, save INSN as a defining instruction. + -ida_regfinder.reg_value_info_t.bor (method) - bor(self, r, insn) - Make bitwise OR of R to the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.bor(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Make bitwise OR of R to the value, save INSN as a defining instruction. + -ida_regfinder.reg_value_info_t.bxor (method) - bxor(self, r, insn) - Make bitwise eXclusive OR of R to the value, save INSN as a defining - instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.bxor(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Make bitwise eXclusive OR of R to the value, save INSN as a defining instruction. + -ida_regfinder.reg_value_info_t.clear (method) - clear(self) +ida_regfinder.reg_value_info_t.clear(self) -> None Undefine the value. -ida_regfinder.reg_value_info_t.empty (method) - empty(self) -> bool +ida_regfinder.reg_value_info_t.empty(self) -> bool Return 'true' if we know nothing about a value. -ida_regfinder.reg_value_info_t.extend (method) - extend(self, pm, width, is_signed) - Sign-, or zero-extend the number or SP delta value to full size. The initial - value is considered to be of size WIDTH. - @note: This method do nothing for unknown values. - - @param pm: (C++: const procmod_t &) procmod_t const & - @param width: (C++: int) - @param is_signed: (C++: bool) +ida_regfinder.reg_value_info_t.extend(self, pm: "procmod_t", width: int, is_signed: bool) -> None + Sign-, or zero-extend the number or SP delta value to full size. The initial value is considered to be of size WIDTH. + -ida_regfinder.reg_value_info_t.get_def_ea (method) - get_def_ea(self) -> ea_t +ida_regfinder.reg_value_info_t.get_def_ea(self) -> ida_idaapi.ea_t Return the defining address. -ida_regfinder.reg_value_info_t.get_def_itype (method) - get_def_itype(self) -> uint16 +ida_regfinder.reg_value_info_t.get_def_itype(self) -> "uint16" Return the defining instruction code (processor specific). -ida_regfinder.reg_value_info_t.get_num (method) - get_num(self) -> bool - Return the number if the value is a constant. - @see: is_num() +ida_regfinder.reg_value_info_t.get_num(self) -> bool + Return the number if the value is a constant. + -ida_regfinder.reg_value_info_t.get_spd (method) - get_spd(self) -> bool - Return the SP delta if the value depends on the stack pointer. - @see: is_spd() +ida_regfinder.reg_value_info_t.get_spd(self) -> bool + Return the SP delta if the value depends on the stack pointer. + -ida_regfinder.reg_value_info_t.have_all_vals_flag (method) - have_all_vals_flag(self, val_flags) -> bool +ida_regfinder.reg_value_info_t.has_any_vals_flag(self, val_flags: "uint16") -> bool + +ida_regfinder.reg_value_info_t.have_all_vals_flag(self, val_flags: "uint16") -> bool Check the given flag for each value. - - @param val_flags: (C++: uint16) -ida_regfinder.reg_value_info_t.is_all_vals_like_got (method) - is_all_vals_like_got(self) -> bool +ida_regfinder.reg_value_info_t.is_all_vals_like_got(self) -> bool -ida_regfinder.reg_value_info_t.is_all_vals_pc_based (method) - is_all_vals_pc_based(self) -> bool +ida_regfinder.reg_value_info_t.is_all_vals_pc_based(self) -> bool -ida_regfinder.reg_value_info_t.is_badinsn (method) - is_badinsn(self) -> bool +ida_regfinder.reg_value_info_t.is_any_vals_like_got(self) -> bool + +ida_regfinder.reg_value_info_t.is_any_vals_pc_based(self) -> bool + +ida_regfinder.reg_value_info_t.is_badinsn(self) -> bool Return 'true' if the value is unknown because of a bad insn. -ida_regfinder.reg_value_info_t.is_dead_end (method) - is_dead_end(self) -> bool +ida_regfinder.reg_value_info_t.is_dead_end(self) -> bool Return 'true' if the value is undefined because of a dead end. -ida_regfinder.reg_value_info_t.is_known (method) - is_known(self) -> bool +ida_regfinder.reg_value_info_t.is_known(self) -> bool Return 'true' if the value is known (i.e. it is a number or SP delta). -ida_regfinder.reg_value_info_t.is_num (method) - is_num(self) -> bool +ida_regfinder.reg_value_info_t.is_num(self) -> bool Return 'true' if the value is a constant. -ida_regfinder.reg_value_info_t.is_spd (method) - is_spd(self) -> bool +ida_regfinder.reg_value_info_t.is_spd(self) -> bool Return 'true' if the value depends on the stack pointer. -ida_regfinder.reg_value_info_t.is_special (method) - is_special(self) -> bool +ida_regfinder.reg_value_info_t.is_special(self) -> bool Return 'true' if the value requires special handling. -ida_regfinder.reg_value_info_t.is_unkfunc (method) - is_unkfunc(self) -> bool +ida_regfinder.reg_value_info_t.is_unkfunc(self) -> bool Return 'true' if the value is unknown from the function start. -ida_regfinder.reg_value_info_t.is_unkinsn (method) - is_unkinsn(self) -> bool +ida_regfinder.reg_value_info_t.is_unkinsn(self) -> bool Return 'true' if the value is unknown after executing the insn. -ida_regfinder.reg_value_info_t.is_unkloop (method) - is_unkloop(self) -> bool +ida_regfinder.reg_value_info_t.is_unkloop(self) -> bool Return 'true' if the value is unknown because it changes in a loop. -ida_regfinder.reg_value_info_t.is_unkmult (method) - is_unkmult(self) -> bool - Return 'true' if the value is unknown because the register has incompatible - values (a number and SP delta). +ida_regfinder.reg_value_info_t.is_unkmult(self) -> bool + Return 'true' if the value is unknown because the register has incompatible values (a number and SP delta). + -ida_regfinder.reg_value_info_t.is_unknown (method) - is_unknown(self) -> bool +ida_regfinder.reg_value_info_t.is_unknown(self) -> bool Return 'true' if the value is unknown. -ida_regfinder.reg_value_info_t.is_value_unique (method) - is_value_unique(self) -> bool +ida_regfinder.reg_value_info_t.is_unkvals(self) -> bool + Return 'true' if the value is unknown because the register has too many values. + + +ida_regfinder.reg_value_info_t.is_unkxref(self) -> bool + Return 'true' if the value is unknown because there are too many xrefs. + +ida_regfinder.reg_value_info_t.is_value_unique(self) -> bool Check that the value is unique. -ida_regfinder.reg_value_info_t.make_aborted (method) - make_aborted(bblk_ea) -> reg_value_info_t - Return the value after aborting. - @see: aborted() - - @param bblk_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.make_aborted(bblk_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the value after aborting. + -ida_regfinder.reg_value_info_t.make_badinsn (method) - make_badinsn(insn_ea) -> reg_value_info_t - Return the unknown value after a bad insn. - @see: is_badinsn() - - @param insn_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.make_badinsn(insn_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the unknown value after a bad insn. + -ida_regfinder.reg_value_info_t.make_dead_end (method) - make_dead_end(dead_end_ea) -> reg_value_info_t - Return the undefined value because of a dead end. - @see: is_dead_end() - - @param dead_end_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.make_dead_end(dead_end_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the undefined value because of a dead end. + -ida_regfinder.reg_value_info_t.make_initial_sp (method) - make_initial_sp(func_ea) -> reg_value_info_t - Return the value that is the initial stack pointer. - @see: is_spd() - - @param func_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.make_initial_sp(func_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the value that is the initial stack pointer. + -ida_regfinder.reg_value_info_t.make_num (method) - make_num(rval, insn, val_flags=0) -> reg_value_info_t - Return the value that is the RVAL number. - @see: is_num() +ida_regfinder.reg_value_info_t.make_num(*args) -> "reg_value_info_t" + This function has the following signatures: - @param rval: (C++: uval_t) - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param val_flags: (C++: uint16) + 0. make_num(rval: int, insn: const insn_t &, val_flags: uint16=0) -> reg_value_info_t + 1. make_num(rval: int, val_ea: ida_idaapi.ea_t, val_flags: uint16=0) -> reg_value_info_t - make_num(rval, val_ea, val_flags=0) -> reg_value_info_t + # 0: make_num(rval: int, insn: const insn_t &, val_flags: uint16=0) -> reg_value_info_t - @param rval: uval_t - @param val_ea: ea_t - @param val_flags: uint16 + Return the value that is the RVAL number. + + + # 1: make_num(rval: int, val_ea: ida_idaapi.ea_t, val_flags: uint16=0) -> reg_value_info_t + + Return the value that is the RVAL number. + -ida_regfinder.reg_value_info_t.make_unkfunc (method) - make_unkfunc(func_ea) -> reg_value_info_t - Return the unknown value from the function start. - @see: is_unkfunc() - - @param func_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.make_unkfunc(func_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the unknown value from the function start. + -ida_regfinder.reg_value_info_t.make_unkinsn (method) - make_unkinsn(insn) -> reg_value_info_t - Return the unknown value after executing the insn. - @see: is_unkinsn() - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.make_unkinsn(insn: "insn_t const &") -> "reg_value_info_t" + Return the unknown value after executing the insn. + -ida_regfinder.reg_value_info_t.make_unkloop (method) - make_unkloop(bblk_ea) -> reg_value_info_t - Return the unknown value if it changes in a loop. - @see: is_unkloop() - - @param bblk_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.make_unkloop(bblk_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the unknown value if it changes in a loop. + -ida_regfinder.reg_value_info_t.make_unkmult (method) - make_unkmult(bblk_ea) -> reg_value_info_t - Return the unknown value if the register has incompatible values. - @see: is_unkmult() - - @param bblk_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.make_unkmult(bblk_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the unknown value if the register has incompatible values. + -ida_regfinder.reg_value_info_t.neg (method) - neg(self, insn) +ida_regfinder.reg_value_info_t.make_unkvals(bblk_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the unknown value if the register has too many values. + + +ida_regfinder.reg_value_info_t.make_unkxref(bblk_ea: ida_idaapi.ea_t) -> "reg_value_info_t" + Return the unknown value if there are too many xrefs. + + +ida_regfinder.reg_value_info_t.movt(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Replace the top 16 bits with bottom 16 bits of R, leaving the bottom 16 bits untouched, save INSN as a defining instruction. + + +ida_regfinder.reg_value_info_t.neg(self, insn: "insn_t const &") -> None Negate the value, save INSN as a defining instruction. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) -ida_regfinder.reg_value_info_t.set_aborted (method) - set_aborted(self, bblk_ea) - Set the value after aborting. - @see: aborted() - - @param bblk_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.set_aborted(self, bblk_ea: ida_idaapi.ea_t) -> None + Set the value after aborting. + -ida_regfinder.reg_value_info_t.set_badinsn (method) - set_badinsn(self, insn_ea) - Set the value to be unknown after a bad insn. - @see: is_badinsn() - - @param insn_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.set_all_vals_flag(self, val_flags: "uint16") -> None + Set the given flag for each value. -ida_regfinder.reg_value_info_t.set_dead_end (method) - set_dead_end(self, dead_end_ea) - Set the value to be undefined because of a dead end. - @see: is_dead_end() - - @param dead_end_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.set_all_vals_got_based(self) -> None -ida_regfinder.reg_value_info_t.set_num (method) - set_num(self, rval, insn, val_flags=0) - Set the value to be a number before an address. - @see: is_num() - - @param rval: (C++: uval_t) - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param val_flags: (C++: uint16) - - set_num(self, rvals, insn) - - @param rvals: uvalvec_t * - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - - set_num(self, rval, val_ea, val_flags=0) - - @param rval: uval_t - @param val_ea: ea_t - @param val_flags: uint16 +ida_regfinder.reg_value_info_t.set_all_vals_pc_based(self) -> None -ida_regfinder.reg_value_info_t.set_unkfunc (method) - set_unkfunc(self, func_ea) - Set the value to be unknown from the function start. - @see: is_unkfunc() - - @param func_ea: (C++: ea_t) +ida_regfinder.reg_value_info_t.set_badinsn(self, insn_ea: ida_idaapi.ea_t) -> None + Set the value to be unknown after a bad insn. + -ida_regfinder.reg_value_info_t.set_unkinsn (method) - set_unkinsn(self, insn) - Set the value to be unknown after executing the insn. - @see: is_unkinsn() - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_regfinder.reg_value_info_t.set_dead_end(self, dead_end_ea: ida_idaapi.ea_t) -> None + Set the value to be undefined because of a dead end. + -ida_regfinder.reg_value_info_t.set_unkloop (method) - set_unkloop(self, bblk_ea) - Set the value to be unknown because it changes in a loop. - @see: is_unkloop() +ida_regfinder.reg_value_info_t.set_num(self, *args) -> None + This function has the following signatures: - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.set_unkmult (method) - set_unkmult(self, bblk_ea) - Set the value to be unknown because the register has incompatible values. - @see: is_unkmult() + 0. set_num(rval: int, insn: const insn_t &, val_flags: uint16=0) -> None + 1. set_num(rvals: uvalvec_t *, insn: const insn_t &) -> None + 2. set_num(rval: int, val_ea: ida_idaapi.ea_t, val_flags: uint16=0) -> None - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.shift_left (method) - shift_left(self, r) - Shift the value left by R, do not change the defining instructions. - @note: This method do nothing for unknown values. + # 0: set_num(rval: int, insn: const insn_t &, val_flags: uint16=0) -> None - @param r: (C++: uval_t) - -ida_regfinder.reg_value_info_t.shift_right (method) - shift_right(self, r) - Shift the value right by R, do not change the defining instructions. - @note: This method do nothing for unknown values. + Set the value to be a number after executing an insn. + - @param r: (C++: uval_t) - -ida_regfinder.reg_value_info_t.sll (method) - sll(self, r, insn) - Shift the value left by R, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. + # 1: set_num(rvals: uvalvec_t *, insn: const insn_t &) -> None - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.slr (method) - slr(self, r, insn) - Shift the value right by R, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. + Set the value to be numbers after executing an insn. + - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.sub (method) - sub(self, r, insn) - Subtract R from the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. + # 2: set_num(rval: int, val_ea: ida_idaapi.ea_t, val_flags: uint16=0) -> None - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) + Set the value to be a number before an address. + -ida_regfinder.reg_value_info_t.trunc_uval (method) - trunc_uval(self, pm) - Truncate the number to the application bitness. - @note: This method do nothing for non-number values. - - @param pm: (C++: const procmod_t &) procmod_t const & +ida_regfinder.reg_value_info_t.set_unkfunc(self, func_ea: ida_idaapi.ea_t) -> None + Set the value to be unknown from the function start. + -ida_regfinder.reg_value_info_t.vals_union (method) - vals_union(self, r) -> reg_value_info_t::set_compare_res_t - Add values from R into THIS ignoring duplicates. - @note: This method is the only way to get multiple values. +ida_regfinder.reg_value_info_t.set_unkinsn(self, insn: "insn_t const &") -> None + Set the value to be unknown after executing the insn. + + +ida_regfinder.reg_value_info_t.set_unkloop(self, bblk_ea: ida_idaapi.ea_t) -> None + Set the value to be unknown because it changes in a loop. + + +ida_regfinder.reg_value_info_t.set_unkmult(self, bblk_ea: ida_idaapi.ea_t) -> None + Set the value to be unknown because the register has incompatible values. + + +ida_regfinder.reg_value_info_t.set_unkvals(self, bblk_ea: ida_idaapi.ea_t) -> None + Set the value to be unknown because the register has too many values. + + +ida_regfinder.reg_value_info_t.set_unkxref(self, bblk_ea: ida_idaapi.ea_t) -> None + Set the value to be unknown because there are too many xrefs. + + +ida_regfinder.reg_value_info_t.shift_left(self, r: int) -> None + Shift the value left by R, do not change the defining instructions. + + +ida_regfinder.reg_value_info_t.shift_right(self, r: int) -> None + Shift the value right by R, do not change the defining instructions. + + +ida_regfinder.reg_value_info_t.sll(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Shift the value left by R, save INSN as a defining instruction. + + +ida_regfinder.reg_value_info_t.slr(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Shift the value right by R, save INSN as a defining instruction. + + +ida_regfinder.reg_value_info_t.sub(self, r: "reg_value_info_t", insn: "insn_t const &") -> None + Subtract R from the value, save INSN as a defining instruction. + + +ida_regfinder.reg_value_info_t.swap(self, r: "reg_value_info_t") -> None + +ida_regfinder.reg_value_info_t.trunc_uval(self, pm: "procmod_t") -> None + Truncate the number to the application bitness. + + +ida_regfinder.reg_value_info_t.vals_union(self, r: "reg_value_info_t") -> "reg_value_info_t::set_compare_res_t" + Add values from R into THIS ignoring duplicates. + @retval EQUAL: THIS is not changed @retval CONTAINS: THIS is not changed @retval CONTAINED: THIS is a copy of R @retval NOT_COMPARABLE: values from R are added to THIS - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & -ida_regfinder.reg_value_info_t_make_aborted (function) - reg_value_info_t_make_aborted(bblk_ea) -> reg_value_info_t - - @param bblk_ea: ea_t - -ida_regfinder.reg_value_info_t_make_badinsn (function) - reg_value_info_t_make_badinsn(insn_ea) -> reg_value_info_t - - @param insn_ea: ea_t - -ida_regfinder.reg_value_info_t_make_dead_end (function) - reg_value_info_t_make_dead_end(dead_end_ea) -> reg_value_info_t - - @param dead_end_ea: ea_t - -ida_regfinder.reg_value_info_t_make_initial_sp (function) - reg_value_info_t_make_initial_sp(func_ea) -> reg_value_info_t - - @param func_ea: ea_t - -ida_regfinder.reg_value_info_t_make_num (function) - reg_value_info_t_make_num(rval, insn, val_flags=0) -> reg_value_info_t - - @param rval: uval_t - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param val_flags: uint16 - - reg_value_info_t_make_num(rval, val_ea, val_flags=0) -> reg_value_info_t - - @param rval: uval_t - @param val_ea: ea_t - @param val_flags: uint16 - -ida_regfinder.reg_value_info_t_make_unkfunc (function) - reg_value_info_t_make_unkfunc(func_ea) -> reg_value_info_t - - @param func_ea: ea_t - -ida_regfinder.reg_value_info_t_make_unkinsn (function) - reg_value_info_t_make_unkinsn(insn) -> reg_value_info_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t_make_unkloop (function) - reg_value_info_t_make_unkloop(bblk_ea) -> reg_value_info_t - - @param bblk_ea: ea_t - -ida_regfinder.reg_value_info_t_make_unkmult (function) - reg_value_info_t_make_unkmult(bblk_ea) -> reg_value_info_t - - @param bblk_ea: ea_t - -ida_search (module) +ida_search Middle-level search functions. - They all are controlled by Search flags + They all are controlled by Search flags + -ida_search.SEARCH_BRK (variable) +ida_search.SEARCH_BRK return BADADDR if the search was cancelled. -ida_search.SEARCH_CASE (variable) +ida_search.SEARCH_CASE case-sensitive search (case-insensitive otherwise) -ida_search.SEARCH_DOWN (variable) +ida_search.SEARCH_DEF + find_reg_access: search for a definition (write access) + +ida_search.SEARCH_DOWN search towards higher addresses -ida_search.SEARCH_IDENT (variable) - search for an identifier (text search). it means that the characters before and - after the match cannot be is_visible_char(). +ida_search.SEARCH_IDENT + search for an identifier (text search). it means that the characters before and after the match cannot be is_visible_char(). + -ida_search.SEARCH_NEXT (variable) - skip the starting address when searching. this bit is useful only for search(), - bin_search2(), find_reg_access(). find_.. functions skip the starting address - automatically. +ida_search.SEARCH_NEXT + skip the starting address when searching. this bit is useful only for search(), bin_search(), find_reg_access(). find_.. functions skip the starting address automatically. + -ida_search.SEARCH_NOBRK (variable) +ida_search.SEARCH_NOBRK do not test if the user clicked cancel to interrupt the search -ida_search.SEARCH_NOSHOW (variable) +ida_search.SEARCH_NOSHOW do not display the search progress/refresh screen -ida_search.SEARCH_REGEX (variable) +ida_search.SEARCH_REGEX regular expressions in search string (supported only for the text search) -ida_search.SEARCH_UP (variable) +ida_search.SEARCH_UP search towards lower addresses -ida_search.SEARCH_USESEL (variable) - query the UI for a possible current selection to limit the search to +ida_search.SEARCH_USE + find_reg_access: search for a use (read access) -ida_search.find_binary (function) - find_binary(arg1, arg2, arg3, arg4, arg5) -> ea_t - Deprecated. Please use ida_bytes.bin_search() instead. - - @param arg1: ea_t - @param arg2: ea_t - @param arg3: char const * - @param arg4: int - @param arg5: int +ida_search.SEARCH_USESEL + query the UI for a possible current selection to limit the search to + -ida_search.find_code (function) - find_code(ea, sflag) -> ea_t - Find next code address. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_code(ea: ida_idaapi.ea_t, sflag: int) -> ida_idaapi.ea_t -ida_search.find_data (function) - find_data(ea, sflag) -> ea_t - Find next data address. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_data(ea: ida_idaapi.ea_t, sflag: int) -> ida_idaapi.ea_t -ida_search.find_defined (function) - find_defined(ea, sflag) -> ea_t - Find next ea that is the start of an instruction or data. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_defined(ea: ida_idaapi.ea_t, sflag: int) -> ida_idaapi.ea_t -ida_search.find_error (function) - find_error(ea, sflag) -> ea_t - Find next error or problem. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_error(ea: ida_idaapi.ea_t, sflag: int) -> "int *" -ida_search.find_imm (function) - find_imm(ea, sflag, search_value) -> ea_t - Find next immediate operand with the given value. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - @param search_value: (C++: uval_t) +ida_search.find_imm(ea: ida_idaapi.ea_t, sflag: int, search_value: int) -> "int *" -ida_search.find_not_func (function) - find_not_func(ea, sflag) -> ea_t - Find next code address that does not belong to a function. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_not_func(ea: ida_idaapi.ea_t, sflag: int) -> ida_idaapi.ea_t -ida_search.find_notype (function) - find_notype(ea, sflag) -> ea_t - Find next operand without any type info. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_notype(ea: ida_idaapi.ea_t, sflag: int) -> "int *" -ida_search.find_reg_access (function) - find_reg_access(out, start_ea, end_ea, regname, sflag) -> ea_t - Find access to a register. - - @param out: (C++: struct reg_access_t *) pointer to the output buffer. must be non-null. upon success - contains info about the found register. upon failed search for a - read access out->range contains the info about the non-redefined - parts of the register. - @param start_ea: (C++: ea_t) starting address - @param end_ea: (C++: ea_t) ending address. BADADDR means that the end limit is missing. - otherwise, if the search direction is SEARCH_UP, END_EA must be - lower than START_EA. - @param regname: (C++: const char *) the register to search for. - @param sflag: (C++: int) combination of Search flags bits. - @note: This function does not care about the control flow and probes all - instructions in the specified range, starting from START_EA. Only direct - references to registers are detected. Function calls and system traps are - ignored. - @return: the found address. BADADDR if not found or error. +ida_search.find_reg_access(out: "reg_access_t", start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, regname: str, sflag: int) -> ida_idaapi.ea_t -ida_search.find_suspop (function) - find_suspop(ea, sflag) -> ea_t - Find next suspicious operand. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_suspop(ea: ida_idaapi.ea_t, sflag: int) -> "int *" -ida_search.find_text (function) - find_text(start_ea, y, x, ustr, sflag) -> ea_t - See search() - - @param start_ea: (C++: ea_t) - @param y: (C++: int) - @param x: (C++: int) - @param ustr: (C++: const char *) char const * - @param sflag: (C++: int) +ida_search.find_text(start_ea: ida_idaapi.ea_t, y: int, x: int, ustr: str, sflag: int) -> ida_idaapi.ea_t -ida_search.find_unknown (function) - find_unknown(ea, sflag) -> ea_t - Find next unexplored address. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) +ida_search.find_unknown(ea: ida_idaapi.ea_t, sflag: int) -> ida_idaapi.ea_t -ida_search.search_down (function) - search_down(sflag) -> bool +ida_search.search_down(sflag: int) -> bool Is the SEARCH_DOWN bit set? - - @param sflag: (C++: int) -ida_segment (module) +ida_segment Functions that deal with segments. - IDA requires that all program addresses belong to segments (each address must - belong to exactly one segment). The situation when an address doesn't belong to - any segment is allowed as a temporary situation only when the user changes - program segmentation. Bytes outside a segment can't be converted to - instructions, have names, comments, etc. Each segment has its start address, - ending address and represents a contiguous range of addresses. There might be - unused holes between segments. - - Each segment has its unique segment selector. This selector is used to - distinguish the segment from other segments. For 16-bit programs the selector is - equal to the segment base paragraph. For 32-bit programs there is special array - to translate the selectors to the segment base paragraphs. A selector is a 32/64 - bit value. - - The segment base paragraph determines the offsets in the segment. If the start - address of the segment == (base << 4) then the first offset in the segment will - be 0. The start address should be higher or equal to (base << 4). We will call - the offsets in the segment 'virtual addresses'. So, the virtual address of the - first byte of the segment is - + IDA requires that all program addresses belong to segments (each address must belong to exactly one segment). The situation when an address doesn't belong to any segment is allowed as a temporary situation only when the user changes program segmentation. Bytes outside a segment can't be converted to instructions, have names, comments, etc. Each segment has its start address, ending address and represents a contiguous range of addresses. There might be unused holes between segments. + Each segment has its unique segment selector. This selector is used to distinguish the segment from other segments. For 16-bit programs the selector is equal to the segment base paragraph. For 32-bit programs there is special array to translate the selectors to the segment base paragraphs. A selector is a 32/64 bit value. + The segment base paragraph determines the offsets in the segment. If the start address of the segment == (base << 4) then the first offset in the segment will be 0. The start address should be higher or equal to (base << 4). We will call the offsets in the segment 'virtual addresses'. So, the virtual address of the first byte of the segment is (start address of segment - segment base linear address) - - For IBM PC, the virtual address corresponds to the offset part of the address. - For other processors (Z80, for example), virtual addresses correspond to Z80 - addresses and linear addresses are used only internally. For MS Windows programs - the segment base paragraph is 0 and therefore the segment virtual addresses are - equal to linear addresses. + For IBM PC, the virtual address corresponds to the offset part of the address. For other processors (Z80, for example), virtual addresses correspond to Z80 addresses and linear addresses are used only internally. For MS Windows programs the segment base paragraph is 0 and therefore the segment virtual addresses are equal to linear addresses. + -ida_segment.ADDSEG_FILLGAP (variable) - fill gap between new segment and previous one. i.e. if such a gap exists, and - this gap is less than 64K, then fill the gap by extending the previous segment - and adding .align directive to it. This way we avoid gaps between segments. too - many gaps lead to a virtual array failure. it cannot hold more than ~1000 gaps. +ida_segment.ADDSEG_FILLGAP + fill gap between new segment and previous one. i.e. if such a gap exists, and this gap is less than 64K, then fill the gap by extending the previous segment and adding .align directive to it. This way we avoid gaps between segments. too many gaps lead to a virtual array failure. it cannot hold more than ~1000 gaps. + -ida_segment.ADDSEG_IDBENC (variable) - 'name' and 'sclass' are given in the IDB encoding; non-ASCII bytes will be - decoded accordingly +ida_segment.ADDSEG_IDBENC + 'name' and 'sclass' are given in the IDB encoding; non-ASCII bytes will be decoded accordingly + -ida_segment.ADDSEG_NOAA (variable) +ida_segment.ADDSEG_NOAA do not mark new segment for auto-analysis -ida_segment.ADDSEG_NOSREG (variable) - set all default segment register values to BADSEL (undefine all default segment - registers) +ida_segment.ADDSEG_NOSREG + set all default segment register values to BADSEL (undefine all default segment registers) + -ida_segment.ADDSEG_NOTRUNC (variable) - don't truncate the new segment at the beginning of the next segment if they - overlap. destroy/truncate old segments instead. +ida_segment.ADDSEG_NOTRUNC + don't truncate the new segment at the beginning of the next segment if they overlap. destroy/truncate old segments instead. + -ida_segment.ADDSEG_OR_DIE (variable) +ida_segment.ADDSEG_OR_DIE qexit() if can't add a segment -ida_segment.ADDSEG_QUIET (variable) +ida_segment.ADDSEG_QUIET silent mode, no "Adding segment..." in the messages window -ida_segment.ADDSEG_SPARSE (variable) - use sparse storage method for the new ranges of the created segment. please note - that the ranges that were already enabled before creating the segment will not - change their storage type. +ida_segment.ADDSEG_SPARSE + use sparse storage method for the new ranges of the created segment. please note that the ranges that were already enabled before creating the segment will not change their storage type. + -ida_segment.CSS_BREAK (variable) +ida_segment.CSS_BREAK memory reading process stopped by user -ida_segment.CSS_NODBG (variable) +ida_segment.CSS_NODBG debugger is not running -ida_segment.CSS_NOMEM (variable) - not enough memory (might be because the segment is too big) +ida_segment.CSS_NOMEM + not enough memory (might be because the segment is too big) + -ida_segment.CSS_NORANGE (variable) +ida_segment.CSS_NORANGE could not find corresponding memory range -ida_segment.CSS_OK (variable) +ida_segment.CSS_OK ok -ida_segment.MAX_GROUPS (variable) +ida_segment.MAX_GROUPS max number of segment groups -ida_segment.MAX_SEGM_TRANSLATIONS (variable) +ida_segment.MAX_SEGM_TRANSLATIONS max number of segment translations -ida_segment.MOVE_SEGM_CHUNK (variable) +ida_segment.MOVE_SEGM_CHUNK Too many chunks are defined, can't move. -ida_segment.MOVE_SEGM_DEBUG (variable) +ida_segment.MOVE_SEGM_DEBUG Debugger segments cannot be moved. -ida_segment.MOVE_SEGM_IDP (variable) +ida_segment.MOVE_SEGM_IDP IDP module forbids moving the segment. -ida_segment.MOVE_SEGM_INVAL (variable) +ida_segment.MOVE_SEGM_INVAL Invalid argument (delta/target does not fit the address space) -ida_segment.MOVE_SEGM_LOADER (variable) +ida_segment.MOVE_SEGM_LOADER The segment has been moved but the loader complained. -ida_segment.MOVE_SEGM_MAPPING (variable) +ida_segment.MOVE_SEGM_MAPPING Memory mapping ranges of addresses hinder segment movement. -ida_segment.MOVE_SEGM_ODD (variable) +ida_segment.MOVE_SEGM_ODD Cannot move segments by an odd number of bytes. -ida_segment.MOVE_SEGM_OK (variable) +ida_segment.MOVE_SEGM_OK all ok -ida_segment.MOVE_SEGM_ORPHAN (variable) +ida_segment.MOVE_SEGM_ORPHAN Orphan bytes hinder segment movement. -ida_segment.MOVE_SEGM_PARAM (variable) +ida_segment.MOVE_SEGM_PARAM The specified segment does not exist. -ida_segment.MOVE_SEGM_ROOM (variable) +ida_segment.MOVE_SEGM_ROOM Not enough free room at the target address. -ida_segment.MOVE_SEGM_SOURCEFILES (variable) +ida_segment.MOVE_SEGM_SOURCEFILES Source files ranges of addresses hinder segment movement. -ida_segment.MSF_FIXONCE (variable) - call loader only once with the special calling method. valid for - rebase_program(). see loader_t::move_segm. +ida_segment.MSF_FIXONCE + call loader only once with the special calling method. valid for rebase_program(). see loader_t::move_segm. + -ida_segment.MSF_LDKEEP (variable) +ida_segment.MSF_LDKEEP keep the loader in the memory (optimization) -ida_segment.MSF_NETNODES (variable) - move netnodes instead of changing inf.netdelta (this is slower); valid for - rebase_program() +ida_segment.MSF_NETNODES + move netnodes instead of changing inf.netdelta (this is slower); valid for rebase_program() + -ida_segment.MSF_NOFIX (variable) +ida_segment.MSF_NOFIX don't call the loader to fix relocations -ida_segment.MSF_PRIORITY (variable) - loader segments will overwrite any existing debugger segments when moved. valid - for move_segm() +ida_segment.MSF_PRIORITY + loader segments will overwrite any existing debugger segments when moved. valid for move_segm() + -ida_segment.MSF_SILENT (variable) +ida_segment.MSF_SILENT don't display a "please wait" box on the screen -ida_segment.SEGMOD_KEEP (variable) +ida_segment.SEGMOD_KEEP keep information (code & data, etc) -ida_segment.SEGMOD_KEEP0 (variable) +ida_segment.SEGMOD_KEEP0 flag for internal use, don't set -ida_segment.SEGMOD_KEEPSEL (variable) +ida_segment.SEGMOD_KEEPSEL do not try to delete unused selector -ida_segment.SEGMOD_KILL (variable) +ida_segment.SEGMOD_KILL disable addresses if segment gets shrinked or deleted -ida_segment.SEGMOD_NOMOVE (variable) - don't move info from the start of segment to the new start address (for - set_segm_start()) +ida_segment.SEGMOD_NOMOVE + don't move info from the start of segment to the new start address (for set_segm_start()) + -ida_segment.SEGMOD_SILENT (variable) +ida_segment.SEGMOD_SILENT be silent -ida_segment.SEGMOD_SPARSE (variable) - use sparse storage if extending the segment (for set_segm_start(), - set_segm_end()) +ida_segment.SEGMOD_SPARSE + use sparse storage if extending the segment (for set_segm_start(), set_segm_end()) + -ida_segment.SEGPERM_EXEC (variable) +ida_segment.SEGPERM_EXEC Execute. -ida_segment.SEGPERM_READ (variable) +ida_segment.SEGPERM_MAXVAL + Execute + Write + Read. + +ida_segment.SEGPERM_READ Read. -ida_segment.SEGPERM_WRITE (variable) +ida_segment.SEGPERM_WRITE Write. -ida_segment.SEG_ABSSYM (variable) +ida_segment.SEG_ABSSYM * segment with definitions of absolute symbols -ida_segment.SEG_BSS (variable) +ida_segment.SEG_BSS uninitialized segment -ida_segment.SEG_CODE (variable) +ida_segment.SEG_CODE code segment -ida_segment.SEG_COMM (variable) +ida_segment.SEG_COMM * segment with communal definitions -ida_segment.SEG_DATA (variable) +ida_segment.SEG_DATA data segment -ida_segment.SEG_GRP (variable) +ida_segment.SEG_GRP * group of segments -ida_segment.SEG_IMEM (variable) +ida_segment.SEG_IMEM internal processor memory & sfr (8051) -ida_segment.SEG_NORM (variable) +ida_segment.SEG_IMP + java: implementation segment + +ida_segment.SEG_MAX_BITNESS_CODE + Maximum segment bitness value. + +ida_segment.SEG_MAX_SEGTYPE_CODE + maximum value segment type can take + +ida_segment.SEG_NORM unknown type, no assumptions -ida_segment.SEG_NULL (variable) +ida_segment.SEG_NULL zero-length segment -ida_segment.SEG_UNDF (variable) +ida_segment.SEG_UNDF undefined segment type (not used) -ida_segment.SEG_XTRN (variable) - * segment with 'extern' definitions. no instructions are allowed +ida_segment.SEG_XTRN + * segment with 'extern' definitions. no instructions are allowed + -ida_segment.SFL_COMORG (variable) - IDP dependent field (IBM PC: if set, ORG directive is not commented out) +ida_segment.SFL_COMORG + IDP dependent field (IBM PC: if set, ORG directive is not commented out) + -ida_segment.SFL_DEBUG (variable) - Is the segment created for the debugger?. Such segments are temporary and do not - have permanent flags. +ida_segment.SFL_DEBUG + Is the segment created for the debugger?. Such segments are temporary and do not have permanent flags. + -ida_segment.SFL_HEADER (variable) - Header segment (do not create offsets to it in the disassembly) +ida_segment.SFL_HEADER + Header segment (do not create offsets to it in the disassembly) + -ida_segment.SFL_HIDDEN (variable) - Is the segment hidden? +ida_segment.SFL_HIDDEN + Is the segment hidden? + -ida_segment.SFL_HIDETYPE (variable) - Hide segment type (do not print it in the listing) +ida_segment.SFL_HIDETYPE + Hide segment type (do not print it in the listing) + -ida_segment.SFL_LOADER (variable) - Is the segment created by the loader? +ida_segment.SFL_LOADER + Is the segment created by the loader? + -ida_segment.SFL_OBOK (variable) - Orgbase is present? (IDP dependent field) +ida_segment.SFL_OBOK + Orgbase is present? (IDP dependent field) + -ida_segment.SNAP_ALL_SEG (variable) +ida_segment.SNAP_ALL_SEG Take a snapshot of all segments. -ida_segment.SNAP_CUR_SEG (variable) +ida_segment.SNAP_CUR_SEG Take a snapshot of current segment. -ida_segment.SNAP_LOAD_SEG (variable) +ida_segment.SNAP_LOAD_SEG Take a snapshot of loader segments. -ida_segment.SREG_NUM (variable) +ida_segment.SREG_NUM Maximum number of segment registers is 16 (see segregs.hpp) -ida_segment.add_segm (function) - add_segm(para, start, end, name, sclass, flags=0) -> bool - Add a new segment, second form. Segment alignment is set to saRelByte. Segment - combination is "public" or "stack" (if segment class is "STACK"). Addressing - mode of segment is taken as default (16bit or 32bit). Default segment registers - are set to BADSEL. If a segment already exists at the specified range of - addresses, this segment will be truncated. Instructions and data in the old - segment will be deleted if the new segment has another addressing mode or - another segment base address. - - @param para: (C++: ea_t) segment base paragraph. if paragraph can't fit in 16bit, then a new - selector is allocated and mapped to the paragraph. - @param start: (C++: ea_t) start address of the segment. if start==BADADDR then start <- - to_ea(para,0). - @param end: (C++: ea_t) end address of the segment. end address should be higher than start - address. For emulate empty segments, use SEG_NULL segment type. If - the end address is lower than start address, then fail. If - end==BADADDR, then a segment up to the next segment will be created - (if the next segment doesn't exist, then 1 byte segment will be - created). If 'end' is too high and the new segment would overlap the - next segment, 'end' is adjusted properly. - @param name: (C++: const char *) name of new segment. may be nullptr - @param sclass: (C++: const char *) class of the segment. may be nullptr. type of the new segment is - modified if class is one of predefined names: +ida_segment.add_segm(para: ida_idaapi.ea_t, start: ida_idaapi.ea_t, end: ida_idaapi.ea_t, name: str, sclass: str, flags: int = 0) -> bool + Add a new segment, second form. Segment alignment is set to saRelByte. Segment combination is "public" or "stack" (if segment class is "STACK"). Addressing mode of segment is taken as default (16bit or 32bit). Default segment registers are set to BADSEL. If a segment already exists at the specified range of addresses, this segment will be truncated. Instructions and data in the old segment will be deleted if the new segment has another addressing mode or another segment base address. + + @param para: segment base paragraph. if paragraph can't fit in 16bit, then a new selector is allocated and mapped to the paragraph. + @param start: start address of the segment. if start==BADADDR then start <- to_ea(para,0). + @param end: end address of the segment. end address should be higher than start address. For emulate empty segments, use SEG_NULL segment type. If the end address is lower than start address, then fail. If end==BADADDR, then a segment up to the next segment will be created (if the next segment doesn't exist, then 1 byte segment will be created). If 'end' is too high and the new segment would overlap the next segment, 'end' is adjusted properly. + @param name: name of new segment. may be nullptr + @param sclass: class of the segment. may be nullptr. type of the new segment is modified if class is one of predefined names: * "CODE" -> SEG_CODE * "DATA" -> SEG_DATA * "CONST" -> SEG_DATA @@ -56653,11041 +38704,7688 @@ ida_segment.add_segm (function) * "XTRN" -> SEG_XTRN * "COMM" -> SEG_COMM * "ABS" -> SEG_ABSSYM - @param flags: (C++: int) Add segment flags + @param flags: Add segment flags @retval 1: ok @retval 0: failed, a warning message is displayed -ida_segment.add_segm_ex (function) - add_segm_ex(NONNULL_s, name, sclass, flags) -> bool - Add a new segment. If a segment already exists at the specified range of - addresses, this segment will be truncated. Instructions and data in the old - segment will be deleted if the new segment has another addressing mode or - another segment base address. - - @param NONNULL_s: (C++: segment_t *) - @param name: (C++: const char *) name of new segment. may be nullptr. if specified, the segment is - immediately renamed - @param sclass: (C++: const char *) class of the segment. may be nullptr. if specified, the segment - class is immediately changed - @param flags: (C++: int) Add segment flags +ida_segment.add_segm_ex(NONNULL_s: "segment_t", name: str, sclass: str, flags: int) -> bool + Add a new segment. If a segment already exists at the specified range of addresses, this segment will be truncated. Instructions and data in the old segment will be deleted if the new segment has another addressing mode or another segment base address. + + @param name: name of new segment. may be nullptr. if specified, the segment is immediately renamed + @param sclass: class of the segment. may be nullptr. if specified, the segment class is immediately changed + @param flags: Add segment flags @retval 1: ok @retval 0: failed, a warning message is displayed -ida_segment.add_segment_translation (function) - add_segment_translation(segstart, mappedseg) -> bool - Add segment translation. - - @param segstart: (C++: ea_t) start address of the segment to add translation to - @param mappedseg: (C++: ea_t) start address of the overlayed segment +ida_segment.add_segment_translation(segstart: ida_idaapi.ea_t, mappedseg: ida_idaapi.ea_t) -> bool + Add segment translation. + + @param segstart: start address of the segment to add translation to + @param mappedseg: start address of the overlayed segment @retval 1: ok @retval 0: too many translations or bad segstart -ida_segment.allocate_selector (function) - allocate_selector(segbase) -> sel_t - Allocate a selector for a segment unconditionally. You must call this function - before calling add_segm_ex(). add_segm() calls this function itself, so you - don't need to allocate a selector. This function will allocate a new free - selector and setup its mapping using find_free_selector() and set_selector() - functions. - - @param segbase: (C++: ea_t) a new segment base paragraph - @return: the allocated selector number +ida_segment.allocate_selector(segbase: ida_idaapi.ea_t) -> "sel_t" + Allocate a selector for a segment unconditionally. You must call this function before calling add_segm_ex(). add_segm() calls this function itself, so you don't need to allocate a selector. This function will allocate a new free selector and setup its mapping using find_free_selector() and set_selector() functions. + + @param segbase: a new segment base paragraph + @returns the allocated selector number -ida_segment.change_segment_status (function) - change_segment_status(s, is_deb_segm) -> int - Convert a debugger segment to a regular segment and vice versa. When converting - debug->regular, the memory contents will be copied to the database. - - @param s: (C++: segment_t *) segment to modify - @param is_deb_segm: (C++: bool) new status of the segment - @return: Change segment status result codes +ida_segment.change_segment_status(s: "segment_t", is_deb_segm: bool) -> int + Convert a debugger segment to a regular segment and vice versa. When converting debug->regular, the memory contents will be copied to the database. + + @param s: segment to modify + @param is_deb_segm: new status of the segment + @returns Change segment status result codes -ida_segment.del_segm (function) - del_segm(ea, flags) -> bool - Delete a segment. - - @param ea: (C++: ea_t) any address belonging to the segment - @param flags: (C++: int) Segment modification flags +ida_segment.del_segm(ea: ida_idaapi.ea_t, flags: int) -> bool + Delete a segment. + + @param ea: any address belonging to the segment + @param flags: Segment modification flags @retval 1: ok @retval 0: failed, no segment at 'ea'. -ida_segment.del_segment_translations (function) - del_segment_translations(segstart) - Delete the translation list - - @param segstart: (C++: ea_t) start address of the segment to delete translation list +ida_segment.del_segment_translations(segstart: ida_idaapi.ea_t) -> None + Delete the translation list + + @param segstart: start address of the segment to delete translation list -ida_segment.del_selector (function) - del_selector(selector) - Delete mapping of a selector. Be wary of deleting selectors that are being used - in the program, this can make a mess in the segments. - - @param selector: (C++: sel_t) number of selector to remove from the translation table +ida_segment.del_selector(selector: "sel_t") -> None + Delete mapping of a selector. Be wary of deleting selectors that are being used in the program, this can make a mess in the segments. + + @param selector: number of selector to remove from the translation table -ida_segment.find_free_selector (function) - find_free_selector() -> sel_t - Find first unused selector. - - @return: a number >= 1 +ida_segment.find_free_selector() -> "sel_t" + Find first unused selector. + + @returns a number >= 1 -ida_segment.find_selector (function) - find_selector(base) -> sel_t - Find a selector that has mapping to the specified paragraph. - - @param base: (C++: ea_t) paragraph to search in the translation table - @return: selector value or base +ida_segment.find_selector(base: ida_idaapi.ea_t) -> "sel_t" + Find a selector that has mapping to the specified paragraph. + + @param base: paragraph to search in the translation table + @returns selector value or base -ida_segment.get_defsr (function) - get_defsr(s, reg) -> sel_t +ida_segment.get_defsr(s, reg) Deprecated, use instead: - value = s.defsr[reg] - - @param s: segment_t * - @param reg: int + value = s.defsr[reg] -ida_segment.get_first_seg (function) - get_first_seg() -> segment_t +ida_segment.get_first_seg() -> "segment_t *" Get pointer to the first segment. -ida_segment.get_group_selector (function) - get_group_selector(grpsel) -> sel_t - Get common selector for a group of segments. - - @param grpsel: (C++: sel_t) selector of group segment - @return: common selector of the group or 'grpsel' if no such group is found +ida_segment.get_group_selector(grpsel: "sel_t") -> "sel_t" + Get common selector for a group of segments. + + @param grpsel: selector of group segment + @returns common selector of the group or 'grpsel' if no such group is found -ida_segment.get_last_seg (function) - get_last_seg() -> segment_t +ida_segment.get_last_seg() -> "segment_t *" Get pointer to the last segment. -ida_segment.get_next_seg (function) - get_next_seg(ea) -> segment_t +ida_segment.get_next_seg(ea: ida_idaapi.ea_t) -> "segment_t *" Get pointer to the next segment. - - @param ea: (C++: ea_t) -ida_segment.get_prev_seg (function) - get_prev_seg(ea) -> segment_t +ida_segment.get_prev_seg(ea: ida_idaapi.ea_t) -> "segment_t *" Get pointer to the previous segment. - - @param ea: (C++: ea_t) -ida_segment.get_segm_base (function) - get_segm_base(s) -> ea_t - Get segment base linear address. Segment base linear address is used to - calculate virtual addresses. The virtual address of the first byte of the - segment will be (start address of segment - segment base linear address) - - @param s: (C++: const segment_t *) pointer to segment - @return: 0 if s == nullptr, otherwise segment base linear address +ida_segment.get_segm_base(s: "segment_t") -> ida_idaapi.ea_t + Get segment base linear address. Segment base linear address is used to calculate virtual addresses. The virtual address of the first byte of the segment will be (start address of segment - segment base linear address) + + @param s: pointer to segment + @returns 0 if s == nullptr, otherwise segment base linear address -ida_segment.get_segm_by_name (function) - get_segm_by_name(name) -> segment_t - Get pointer to segment by its name. If there are several segments with the same - name, returns the first of them. - - @param name: (C++: const char *) segment name. may be nullptr. - @return: nullptr or pointer to segment structure +ida_segment.get_segm_by_name(name: str) -> "segment_t *" + Get pointer to segment by its name. If there are several segments with the same name, returns the first of them. + + @param name: segment name. may be nullptr. + @returns nullptr or pointer to segment structure -ida_segment.get_segm_by_sel (function) - get_segm_by_sel(selector) -> segment_t - Get pointer to segment structure. This function finds a segment by its selector. - If there are several segments with the same selectors, the last one will be - returned. - - @param selector: (C++: sel_t) a segment with the specified selector will be returned - @return: pointer to segment or nullptr +ida_segment.get_segm_by_sel(selector: "sel_t") -> "segment_t *" + Get pointer to segment structure. This function finds a segment by its selector. If there are several segments with the same selectors, the last one will be returned. + + @param selector: a segment with the specified selector will be returned + @returns pointer to segment or nullptr -ida_segment.get_segm_class (function) - get_segm_class(s) -> str - Get segment class. Segment class is arbitrary text (max 8 characters). - - @param s: (C++: const segment_t *) pointer to segment - @return: size of segment class (-1 if s==nullptr or bufsize<=0) +ida_segment.get_segm_class(s: "segment_t") -> str + Get segment class. Segment class is arbitrary text (max 8 characters). + + @param s: pointer to segment + @returns size of segment class (-1 if s==nullptr or bufsize<=0) -ida_segment.get_segm_name (function) - get_segm_name(s, flags=0) -> str - Get true segment name by pointer to segment. - - @param s: (C++: const segment_t *) pointer to segment - @param flags: (C++: int) 0-return name as is; 1-substitute bad symbols with _ 1 corresponds - to GN_VISIBLE - @return: size of segment name (-1 if s==nullptr) +ida_segment.get_segm_name(s: "segment_t", flags: int = 0) -> str + Get true segment name by pointer to segment. + + @param s: pointer to segment + @param flags: 0-return name as is; 1-substitute bad symbols with _ 1 corresponds to GN_VISIBLE + @returns size of segment name (-1 if s==nullptr) -ida_segment.get_segm_num (function) - get_segm_num(ea) -> int - Get number of segment by address. - - @param ea: (C++: ea_t) linear address belonging to the segment - @return: -1 if no segment occupies the specified address. otherwise returns - number of the specified segment (0..get_segm_qty()-1) +ida_segment.get_segm_num(ea: ida_idaapi.ea_t) -> int + Get number of segment by address. + + @param ea: linear address belonging to the segment + @returns -1 if no segment occupies the specified address. otherwise returns number of the specified segment (0..get_segm_qty()-1) -ida_segment.get_segm_para (function) - get_segm_para(s) -> ea_t - Get segment base paragraph. Segment base paragraph may be converted to segment - base linear address using to_ea() function. In fact, to_ea(get_segm_para(s), 0) - == get_segm_base(s). - - @param s: (C++: const segment_t *) pointer to segment - @return: 0 if s == nullptr, the segment base paragraph +ida_segment.get_segm_para(s: "segment_t") -> ida_idaapi.ea_t + Get segment base paragraph. Segment base paragraph may be converted to segment base linear address using to_ea() function. In fact, to_ea(get_segm_para(s), 0) == get_segm_base(s). + + @param s: pointer to segment + @returns 0 if s == nullptr, the segment base paragraph -ida_segment.get_segm_qty (function) - get_segm_qty() -> int +ida_segment.get_segm_qty() -> int Get number of segments. -ida_segment.get_segment_alignment (function) - get_segment_alignment(align) -> char const * - Get text representation of segment alignment code. - - @param align: (C++: uchar) - @return: text digestable by IBM PC assembler. +ida_segment.get_segment_alignment(align: "uchar") -> str + Get text representation of segment alignment code. + + @returns text digestable by IBM PC assembler. -ida_segment.get_segment_cmt (function) - get_segment_cmt(s, repeatable) -> str - Get segment comment. - - @param s: (C++: const segment_t *) pointer to segment structure - @param repeatable: (C++: bool) 0: get regular comment. 1: get repeatable comment. - @return: size of comment or -1 +ida_segment.get_segment_cmt(s: "segment_t", repeatable: bool) -> str + Get segment comment. + + @param s: pointer to segment structure + @param repeatable: 0: get regular comment. 1: get repeatable comment. + @returns size of comment or -1 -ida_segment.get_segment_combination (function) - get_segment_combination(comb) -> char const * - Get text representation of segment combination code. - - @param comb: (C++: uchar) - @return: text digestable by IBM PC assembler. +ida_segment.get_segment_combination(comb: "uchar") -> str + Get text representation of segment combination code. + + @returns text digestable by IBM PC assembler. -ida_segment.get_segment_translations (function) - get_segment_translations(transmap, segstart) -> ssize_t - Get segment translation list. - - @param transmap: (C++: eavec_t *) vector of segment start addresses for the translation list - @param segstart: (C++: ea_t) start address of the segment to get information about - @return: -1 if no translation list or bad segstart. otherwise returns size of - translation list. +ida_segment.get_segment_translations(transmap: "eavec_t *", segstart: ida_idaapi.ea_t) -> "ssize_t" + Get segment translation list. + + @param transmap: vector of segment start addresses for the translation list + @param segstart: start address of the segment to get information about + @returns -1 if no translation list or bad segstart. otherwise returns size of translation list. -ida_segment.get_selector_qty (function) - get_selector_qty() -> size_t +ida_segment.get_selector_qty() -> "size_t" Get number of defined selectors. -ida_segment.get_visible_segm_name (function) - get_visible_segm_name(s) -> str - Get segment name by pointer to segment. - - @param s: (C++: const segment_t *) pointer to segment - @return: size of segment name (-1 if s==nullptr) +ida_segment.get_visible_segm_name(s: "segment_t") -> str + Get segment name by pointer to segment. + + @param s: pointer to segment + @returns size of segment name (-1 if s==nullptr) -ida_segment.getn_selector (function) - getn_selector(n) -> bool +ida_segment.getn_selector(n: int) -> "sel_t *, ea_t *" Get description of selector (0..get_selector_qty()-1) - - @param n: (C++: int) -ida_segment.getnseg (function) - getnseg(n) -> segment_t - Get pointer to segment by its number. - @warning: Obsoleted because it can slow down the debugger (it has to refresh the - whole memory segmentation to calculate the correct answer) - - @param n: (C++: int) segment number in the range (0..get_segm_qty()-1) - @return: nullptr or pointer to segment structure +ida_segment.getnseg(n: int) -> "segment_t *" + Get pointer to segment by its number. + + @param n: segment number in the range (0..get_segm_qty()-1) + @returns nullptr or pointer to segment structure -ida_segment.getseg (function) - getseg(ea) -> segment_t - Get pointer to segment by linear address. - - @param ea: (C++: ea_t) linear address belonging to the segment - @return: nullptr or pointer to segment structure +ida_segment.getseg(ea: ida_idaapi.ea_t) -> "segment_t *" + Get pointer to segment by linear address. + + @param ea: linear address belonging to the segment + @returns nullptr or pointer to segment structure -ida_segment.is_finally_visible_segm (function) - is_finally_visible_segm(s) -> bool +ida_segment.is_finally_visible_segm(s: "segment_t") -> bool See SFL_HIDDEN, SCF_SHHID_SEGM. - - @param s: (C++: segment_t *) -ida_segment.is_miniidb (function) - is_miniidb() -> bool - Is the database a miniidb created by the debugger?. - - @return: true if the database contains no segments or only debugger segments +ida_segment.is_miniidb() -> bool + Is the database a miniidb created by the debugger?. + + @returns true if the database contains no segments or only debugger segments -ida_segment.is_segm_locked (function) - is_segm_locked(segm) -> bool +ida_segment.is_segm_locked(segm: "segment_t") -> bool Is a segment pointer locked? - - @param segm: (C++: const segment_t *) segment_t const * -ida_segment.is_spec_ea (function) - is_spec_ea(ea) -> bool - Does the address belong to a segment with a special type?. (SEG_XTRN, SEG_GRP, - SEG_ABSSYM, SEG_COMM) - - @param ea: (C++: ea_t) linear address +ida_segment.is_spec_ea(ea: ida_idaapi.ea_t) -> bool + Does the address belong to a segment with a special type?. (SEG_XTRN, SEG_GRP, SEG_ABSSYM, SEG_COMM) + + @param ea: linear address -ida_segment.is_spec_segm (function) - is_spec_segm(seg_type) -> bool - Has segment a special type?. (SEG_XTRN, SEG_GRP, SEG_ABSSYM, SEG_COMM) - - @param seg_type: (C++: uchar) +ida_segment.is_spec_segm(seg_type: "uchar") -> bool + Has segment a special type?. (SEG_XTRN, SEG_GRP, SEG_ABSSYM, SEG_COMM) + -ida_segment.is_visible_segm (function) - is_visible_segm(s) -> bool +ida_segment.is_visible_segm(s: "segment_t") -> bool See SFL_HIDDEN. - - @param s: (C++: segment_t *) -ida_segment.lock_segm (function) - lock_segm(segm, lock) - Lock segment pointer Locked pointers are guaranteed to remain valid until they - are unlocked. Ranges with locked pointers cannot be deleted or moved. - - @param segm: (C++: const segment_t *) segment_t const * - @param lock: (C++: bool) +ida_segment.lock_segm(segm: "segment_t", lock: bool) -> None + Lock segment pointer Locked pointers are guaranteed to remain valid until they are unlocked. Ranges with locked pointers cannot be deleted or moved. + -ida_segment.lock_segment (class) - Proxy of C++ lock_segment class. +ida_segment.lock_segment -ida_segment.lock_segment.__init__ (method) - __init__(self, _segm) -> lock_segment - - @param _segm: segment_t const * +ida_segment.lock_segment.__init__(self, _segm: "segment_t") -ida_segment.move_segm (function) - move_segm(s, to, flags=0) -> move_segm_code_t - This function moves all information to the new address. It fixes up address - sensitive information in the kernel. The total effect is equal to reloading the - segment to the target address. For the file format dependent address sensitive - information, loader_t::move_segm is called. Also IDB notification event - idb_event::segm_moved is called. - - @param s: (C++: segment_t *) segment to move - @param to: (C++: ea_t) new segment start address - @param flags: (C++: int) Move segment flags - @return: Move segment result codes +ida_segment.move_segm(s: "segment_t", to: ida_idaapi.ea_t, flags: int = 0) -> "move_segm_code_t" + This function moves all information to the new address. It fixes up address sensitive information in the kernel. The total effect is equal to reloading the segment to the target address. For the file format dependent address sensitive information, loader_t::move_segm is called. Also IDB notification event idb_event::segm_moved is called. + + @param s: segment to move + @param to: new segment start address + @param flags: Move segment flags + @returns Move segment result codes -ida_segment.move_segm_start (function) - move_segm_start(ea, newstart, mode) -> bool - Move segment start. The main difference between this function and - set_segm_start() is that this function may expand the previous segment while - set_segm_start() never does it. So, this function allows to change bounds of two - segments simultaneously. If the previous segment and the specified segment have - the same addressing mode and segment base, then instructions and data are not - destroyed - they simply move from one segment to another. Otherwise all - instructions/data which migrate from one segment to another are destroyed. - @note: this function never disables addresses. - - @param ea: (C++: ea_t) any address belonging to the segment - @param newstart: (C++: ea_t) new start address of the segment note that segment start - address should be higher than segment base linear address. - @param mode: (C++: int) policy for destroying defined items - * 0: if it is necessary to destroy defined items, display a dialog box and ask - confirmation - * 1: if it is necessary to destroy defined items, just destroy them without - asking the user - * -1: if it is necessary to destroy defined items, don't destroy them (i.e. - function will fail) +ida_segment.move_segm_start(ea: ida_idaapi.ea_t, newstart: ida_idaapi.ea_t, mode: int) -> bool + Move segment start. The main difference between this function and set_segm_start() is that this function may expand the previous segment while set_segm_start() never does it. So, this function allows to change bounds of two segments simultaneously. If the previous segment and the specified segment have the same addressing mode and segment base, then instructions and data are not destroyed - they simply move from one segment to another. Otherwise all instructions/data which migrate from one segment to another are destroyed. + + @param ea: any address belonging to the segment + @param newstart: new start address of the segment note that segment start address should be higher than segment base linear address. + @param mode: policy for destroying defined items + * 0: if it is necessary to destroy defined items, display a dialog box and ask confirmation + * 1: if it is necessary to destroy defined items, just destroy them without asking the user + * -1: if it is necessary to destroy defined items, don't destroy them (i.e. function will fail) * -2: don't destroy defined items (function will succeed) @retval 1: ok @retval 0: failed, a warning message is displayed -ida_segment.move_segm_strerror (function) - move_segm_strerror(code) -> char const * +ida_segment.move_segm_strerror(code: "move_segm_code_t") -> str Return string describing error MOVE_SEGM_... code. - - @param code: (C++: move_segm_code_t) enum move_segm_code_t -ida_segment.rebase_program (function) - rebase_program(delta, flags) -> int - Rebase the whole program by 'delta' bytes. - - @param delta: (C++: adiff_t) number of bytes to move the program - @param flags: (C++: int) Move segment flags it is recommended to use MSF_FIXONCE so that - the loader takes care of global variables it stored in the - database - @return: Move segment result codes +ida_segment.rebase_program(delta: "PyObject *", flags: int) -> int + Rebase the whole program by 'delta' bytes. + + @param delta: number of bytes to move the program + @param flags: Move segment flags it is recommended to use MSF_FIXONCE so that the loader takes care of global variables it stored in the database + @returns Move segment result codes -ida_segment.saAbs (variable) +ida_segment.saAbs Absolute segment. -ida_segment.saGroup (variable) +ida_segment.saGroup Segment group. -ida_segment.saRel1024Bytes (variable) +ida_segment.saRel1024Bytes 1024 bytes -ida_segment.saRel128Bytes (variable) +ida_segment.saRel128Bytes 128 bytes -ida_segment.saRel2048Bytes (variable) +ida_segment.saRel2048Bytes 2048 bytes -ida_segment.saRel32Bytes (variable) +ida_segment.saRel32Bytes 32 bytes -ida_segment.saRel4K (variable) - This value is used by the PharLap OMF for page (4K) alignment. It is not - supported by LINK. +ida_segment.saRel4K + This value is used by the PharLap OMF for page (4K) alignment. It is not supported by LINK. + -ida_segment.saRel512Bytes (variable) +ida_segment.saRel512Bytes 512 bytes -ida_segment.saRel64Bytes (variable) +ida_segment.saRel64Bytes 64 bytes -ida_segment.saRelByte (variable) +ida_segment.saRelByte Relocatable, byte aligned. -ida_segment.saRelDble (variable) - Relocatable, aligned on a double word (4-byte) boundary. +ida_segment.saRelDble + Relocatable, aligned on a double word (4-byte) boundary. + -ida_segment.saRelPage (variable) +ida_segment.saRelPage Relocatable, aligned on 256-byte boundary. -ida_segment.saRelPara (variable) +ida_segment.saRelPara Relocatable, paragraph (16-byte) aligned. -ida_segment.saRelQword (variable) +ida_segment.saRelQword 8 bytes -ida_segment.saRelWord (variable) +ida_segment.saRelWord Relocatable, word (2-byte) aligned. -ida_segment.scCommon (variable) +ida_segment.scCommon Common. Combine by overlay using maximum size. -ida_segment.scGroup (variable) +ida_segment.scGroup Segment group. -ida_segment.scPriv (variable) - Private. Do not combine with any other program segment. +ida_segment.scPriv + Private. Do not combine with any other program segment. + -ida_segment.scPub (variable) - Public. Combine by appending at an offset that meets the alignment requirement. +ida_segment.scPub + Public. Combine by appending at an offset that meets the alignment requirement. + -ida_segment.scPub2 (variable) +ida_segment.scPub2 As defined by Microsoft, same as C=2 (public). -ida_segment.scPub3 (variable) +ida_segment.scPub3 As defined by Microsoft, same as C=2 (public). -ida_segment.scStack (variable) - Stack. Combine as for C=2. This combine type forces byte alignment. +ida_segment.scStack + Stack. Combine as for C=2. This combine type forces byte alignment. + -ida_segment.segm_adjust_diff (function) - segm_adjust_diff(s, delta) -> adiff_t +ida_segment.segm_adjust_diff(s: "segment_t", delta: "adiff_t") -> "adiff_t" Truncate and sign extend a delta depending on the segment. - - @param s: (C++: const segment_t *) segment_t const * - @param delta: (C++: adiff_t) -ida_segment.segm_adjust_ea (function) - segm_adjust_ea(s, ea) -> ea_t +ida_segment.segm_adjust_ea(s: "segment_t", ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t Truncate an address depending on the segment. - - @param s: (C++: const segment_t *) segment_t const * - @param ea: (C++: ea_t) -ida_segment.segment_defsr_array (class) - Proxy of C++ wrapped_array_t< sel_t,SREG_NUM > class. +ida_segment.segment_defsr_array -ida_segment.segment_defsr_array.__getitem__ (method) - __getitem__(self, i) -> unsigned-ea-like-numeric-type const & - - @param i: size_t +ida_segment.segment_defsr_array.__getitem__(self, i: "size_t") -> "unsigned long long const &" -ida_segment.segment_defsr_array.__init__ (method) - __init__(self, data) -> segment_defsr_array - - @param data: unsigned-ea-like-numeric-type (&)[SREG_NUM] +ida_segment.segment_defsr_array.__init__(self, data: "unsigned long long (&)[SREG_NUM]") -ida_segment.segment_defsr_array.__len__ (method) - __len__(self) -> size_t +ida_segment.segment_defsr_array.__len__(self) -> "size_t" -ida_segment.segment_defsr_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned-ea-like-numeric-type const & +ida_segment.segment_defsr_array.__setitem__(self, i: "size_t", v: "unsigned long long const &") -> None -ida_segment.segment_defsr_array._get_bytes (method) - _get_bytes(self) -> bytevec_t +ida_segment.segment_defsr_array._get_bytes(self) -> "bytevec_t" -ida_segment.segment_defsr_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & +ida_segment.segment_defsr_array._set_bytes(self, bts: "bytevec_t const &") -> None -ida_segment.segment_t (class) - Proxy of C++ segment_t class. +ida_segment.segment_t -ida_segment.segment_t.__getDefsr (method) - __getDefsr(self) -> segment_defsr_array +ida_segment.segment_t.__getDefsr(self) -> "wrapped_array_t< sel_t,SREG_NUM >" -ida_segment.segment_t.__init__ (method) - __init__(self) -> segment_t +ida_segment.segment_t.__init__(self) -ida_segment.segment_t.abits (method) - abits(self) -> int +ida_segment.segment_t.abits(self) -> int Get number of address bits. -ida_segment.segment_t.abytes (method) - abytes(self) -> int +ida_segment.segment_t.abytes(self) -> int Get number of address bytes. -ida_segment.segment_t.align (variable) - Segment alignment codes +ida_segment.segment_t.align + Segment alignment codes + -ida_segment.segment_t.bitness (variable) +ida_segment.segment_t.bitness Number of bits in the segment addressing * 0: 16 bits * 1: 32 bits - * 2: 64 bits + * 2: 64 bits + + + -ida_segment.segment_t.clr_comorg (method) - clr_comorg(self) +ida_segment.segment_t.clr_comorg(self) -> None -ida_segment.segment_t.clr_ob_ok (method) - clr_ob_ok(self) +ida_segment.segment_t.clr_ob_ok(self) -> None -ida_segment.segment_t.color (variable) +ida_segment.segment_t.color the segment color -ida_segment.segment_t.comb (variable) - Segment combination codes +ida_segment.segment_t.comb + Segment combination codes + -ida_segment.segment_t.comorg (method) - comorg(self) -> bool +ida_segment.segment_t.comorg(self) -> bool -ida_segment.segment_t.defsr (variable) - default segment register values. first element of this array keeps information - about value of processor_t::reg_first_sreg +ida_segment.segment_t.defsr + default segment register values. first element of this array keeps information about value of processor_t::reg_first_sreg + -ida_segment.segment_t.flags (variable) +ida_segment.segment_t.defsr + default segment register values. first element of this array keeps information about value of processor_t::reg_first_sreg + + +ida_segment.segment_t.flags Segment flags -ida_segment.segment_t.is_16bit (method) - is_16bit(self) -> bool +ida_segment.segment_t.is_16bit(self) -> bool Is a 16-bit segment? -ida_segment.segment_t.is_32bit (method) - is_32bit(self) -> bool +ida_segment.segment_t.is_32bit(self) -> bool Is a 32-bit segment? -ida_segment.segment_t.is_64bit (method) - is_64bit(self) -> bool +ida_segment.segment_t.is_64bit(self) -> bool Is a 64-bit segment? -ida_segment.segment_t.is_header_segm (method) - is_header_segm(self) -> bool +ida_segment.segment_t.is_header_segm(self) -> bool -ida_segment.segment_t.is_hidden_segtype (method) - is_hidden_segtype(self) -> bool +ida_segment.segment_t.is_hidden_segtype(self) -> bool -ida_segment.segment_t.is_loader_segm (method) - is_loader_segm(self) -> bool +ida_segment.segment_t.is_loader_segm(self) -> bool -ida_segment.segment_t.is_visible_segm (method) - is_visible_segm(self) -> bool +ida_segment.segment_t.is_visible_segm(self) -> bool -ida_segment.segment_t.name (variable) +ida_segment.segment_t.name use get/set_segm_name() functions -ida_segment.segment_t.ob_ok (method) - ob_ok(self) -> bool +ida_segment.segment_t.ob_ok(self) -> bool -ida_segment.segment_t.orgbase (variable) - this field is IDP dependent. you may keep your information about the segment - here +ida_segment.segment_t.orgbase + this field is IDP dependent. you may keep your information about the segment here + -ida_segment.segment_t.perm (variable) - Segment permissions (0 means no information) +ida_segment.segment_t.perm + Segment permissions (0 means no information) + -ida_segment.segment_t.sclass (variable) +ida_segment.segment_t.sclass use get/set_segm_class() functions -ida_segment.segment_t.sel (variable) - segment selector - should be unique. You can't change this field after creating - the segment. Exception: 16bit OMF files may have several segments with the same - selector, but this is not good (no way to denote a segment exactly) so it should - be fixed in the future. +ida_segment.segment_t.sel + segment selector - should be unique. You can't change this field after creating the segment. Exception: 16bit OMF files may have several segments with the same selector, but this is not good (no way to denote a segment exactly) so it should be fixed in the future. + -ida_segment.segment_t.set_comorg (method) - set_comorg(self) +ida_segment.segment_t.set_comorg(self) -> None -ida_segment.segment_t.set_debugger_segm (method) - set_debugger_segm(self, debseg) - - @param debseg: bool +ida_segment.segment_t.set_debugger_segm(self, debseg: bool) -> None -ida_segment.segment_t.set_header_segm (method) - set_header_segm(self, on) - - @param on: bool +ida_segment.segment_t.set_header_segm(self, on: bool) -> None -ida_segment.segment_t.set_hidden_segtype (method) - set_hidden_segtype(self, hide) - - @param hide: bool +ida_segment.segment_t.set_hidden_segtype(self, hide: bool) -> None -ida_segment.segment_t.set_loader_segm (method) - set_loader_segm(self, ldrseg) - - @param ldrseg: bool +ida_segment.segment_t.set_loader_segm(self, ldrseg: bool) -> None -ida_segment.segment_t.set_ob_ok (method) - set_ob_ok(self) +ida_segment.segment_t.set_ob_ok(self) -> None -ida_segment.segment_t.set_visible_segm (method) - set_visible_segm(self, visible) - - @param visible: bool +ida_segment.segment_t.set_visible_segm(self, visible: bool) -> None -ida_segment.segment_t.type (variable) - segment type (see Segment types). The kernel treats different segment types - differently. Segments marked with '*' contain no instructions or data and are - not declared as 'segments' in the disassembly. +ida_segment.segment_t.type + segment type (see Segment types). The kernel treats different segment types differently. Segments marked with '*' contain no instructions or data and are not declared as 'segments' in the disassembly. + -ida_segment.segment_t.update (method) - update(self) -> bool - Update segment information. You must call this function after modification of - segment characteristics. Note that not all fields of segment structure may be - modified directly, there are special functions to modify some fields. - - @return: success +ida_segment.segment_t.update(self) -> bool + Update segment information. You must call this function after modification of segment characteristics. Note that not all fields of segment structure may be modified directly, there are special functions to modify some fields. + + @returns success -ida_segment.segtype (function) - segtype(ea) -> uchar - Get segment type. - - @param ea: (C++: ea_t) any linear address within the segment - @return: Segment types, SEG_UNDF if no segment found at 'ea' +ida_segment.segtype(ea: ida_idaapi.ea_t) -> "uchar" + Get segment type. + + @param ea: any linear address within the segment + @returns Segment types, SEG_UNDF if no segment found at 'ea' -ida_segment.sel2ea (function) - sel2ea(selector) -> ea_t - Get mapping of a selector as a linear address. - - @param selector: (C++: sel_t) number of selector to translate to linear address - @return: linear address the specified selector is mapped to. if there is no - mapping, returns to_ea(selector,0); +ida_segment.sel2ea(selector: "sel_t") -> ida_idaapi.ea_t + Get mapping of a selector as a linear address. + + @param selector: number of selector to translate to linear address + @returns linear address the specified selector is mapped to. if there is no mapping, returns to_ea(selector,0); -ida_segment.sel2para (function) - sel2para(selector) -> ea_t - Get mapping of a selector. - - @param selector: (C++: sel_t) number of selector to translate - @return: paragraph the specified selector is mapped to. if there is no mapping, - returns 'selector'. +ida_segment.sel2para(selector: "sel_t") -> ida_idaapi.ea_t + Get mapping of a selector. + + @param selector: number of selector to translate + @returns paragraph the specified selector is mapped to. if there is no mapping, returns 'selector'. -ida_segment.set_defsr (function) - set_defsr(s, reg, value) +ida_segment.set_defsr(s, reg, value) Deprecated, use instead: - s.defsr[reg] = value - - @param s: segment_t * - @param reg: int - @param value: sel_t + s.defsr[reg] = value -ida_segment.set_group_selector (function) - set_group_selector(grp, sel) -> int - Create a new group of segments (used OMF files). - - @param grp: (C++: sel_t) selector of group segment (segment type is SEG_GRP) You should - create an 'empty' (1 byte) group segment It won't contain anything - and will be used to redirect references to the group of segments to - the common selector. - @param sel: (C++: sel_t) common selector of all segments belonging to the segment You should - create all segments within the group with the same selector value. - @return: 1 ok - 0 too many groups (see MAX_GROUPS) +ida_segment.set_group_selector(grp: "sel_t", sel: "sel_t") -> int + Create a new group of segments (used OMF files). + + @param grp: selector of group segment (segment type is SEG_GRP) You should create an 'empty' (1 byte) group segment It won't contain anything and will be used to redirect references to the group of segments to the common selector. + @param sel: common selector of all segments belonging to the segment You should create all segments within the group with the same selector value. + @retval 1: ok + @retval 0: too many groups (see MAX_GROUPS) -ida_segment.set_segm_addressing (function) - set_segm_addressing(s, bitness) -> bool - Change segment addressing mode (16, 32, 64 bits). You must use this function to - change segment addressing, never change the 'bitness' field directly. This - function will delete all instructions, comments and names in the segment - - @param s: (C++: segment_t *) pointer to segment - @param bitness: (C++: size_t) new addressing mode of segment +ida_segment.set_segm_addressing(s: "segment_t", bitness: "size_t") -> bool + Change segment addressing mode (16, 32, 64 bits). You must use this function to change segment addressing, never change the 'bitness' field directly. This function will delete all instructions, comments and names in the segment + + @param s: pointer to segment + @param bitness: new addressing mode of segment * 2: 64bit segment * 1: 32bit segment * 0: 16bit segment - @return: success + @returns success -ida_segment.set_segm_base (function) - set_segm_base(s, newbase) -> bool +ida_segment.set_segm_base(s: "segment_t", newbase: ida_idaapi.ea_t) -> bool Internal function. - - @param s: (C++: segment_t *) - @param newbase: (C++: ea_t) -ida_segment.set_segm_class (function) - set_segm_class(s, sclass, flags=0) -> int - Set segment class. - - @param s: (C++: segment_t *) pointer to segment (may be nullptr) - @param sclass: (C++: const char *) segment class (may be nullptr). If segment type is SEG_NORM and - segment class is one of predefined names, then segment type is - changed to: +ida_segment.set_segm_class(s: "segment_t", sclass: str, flags: int = 0) -> int + Set segment class. + + @param s: pointer to segment (may be nullptr) + @param sclass: segment class (may be nullptr). If segment type is SEG_NORM and segment class is one of predefined names, then segment type is changed to: * "CODE" -> SEG_CODE * "DATA" -> SEG_DATA * "STACK" -> SEG_BSS * "BSS" -> SEG_BSS * if "UNK" then segment type is reset to SEG_NORM. - @param flags: (C++: int) Add segment flags + @param flags: Add segment flags @retval 1: ok, name is good and segment is renamed @retval 0: failure, name is nullptr or bad or segment is nullptr -ida_segment.set_segm_end (function) - set_segm_end(ea, newend, flags) -> bool - Set segment end address. The next segment is shrinked to allow expansion of the - specified segment. The kernel might even delete the next segment if necessary. - The kernel will ask the user for a permission to destroy instructions or data - going out of segment scope if such instructions exist. - - @param ea: (C++: ea_t) any address belonging to the segment - @param newend: (C++: ea_t) new end address of the segment - @param flags: (C++: int) Segment modification flags +ida_segment.set_segm_end(ea: ida_idaapi.ea_t, newend: ida_idaapi.ea_t, flags: int) -> bool + Set segment end address. The next segment is shrinked to allow expansion of the specified segment. The kernel might even delete the next segment if necessary. The kernel will ask the user for a permission to destroy instructions or data going out of segment scope if such instructions exist. + + @param ea: any address belonging to the segment + @param newend: new end address of the segment + @param flags: Segment modification flags @retval 1: ok @retval 0: failed, a warning message is displayed -ida_segment.set_segm_name (function) - set_segm_name(s, name, flags=0) -> int - Rename segment. The new name is validated (see validate_name). A segment always - has a name. If you hadn't specified a name, the kernel will assign it "seg###" - name where ### is segment number. - - @param s: (C++: segment_t *) pointer to segment (may be nullptr) - @param name: (C++: const char *) new segment name - @param flags: (C++: int) ADDSEG_IDBENC or 0 +ida_segment.set_segm_name(s: "segment_t", name: str, flags: int = 0) -> int + Rename segment. The new name is validated (see validate_name). A segment always has a name. If you hadn't specified a name, the kernel will assign it "seg###" name where ### is segment number. + + @param s: pointer to segment (may be nullptr) + @param name: new segment name + @param flags: ADDSEG_IDBENC or 0 @retval 1: ok, name is good and segment is renamed @retval 0: failure, name is bad or segment is nullptr -ida_segment.set_segm_start (function) - set_segm_start(ea, newstart, flags) -> bool - Set segment start address. The previous segment is trimmed to allow expansion of - the specified segment. The kernel might even delete the previous segment if - necessary. The kernel will ask the user for a permission to destroy instructions - or data going out of segment scope if such instructions exist. - - @param ea: (C++: ea_t) any address belonging to the segment - @param newstart: (C++: ea_t) new start address of the segment note that segment start - address should be higher than segment base linear address. - @param flags: (C++: int) Segment modification flags +ida_segment.set_segm_start(ea: ida_idaapi.ea_t, newstart: ida_idaapi.ea_t, flags: int) -> bool + Set segment start address. The previous segment is trimmed to allow expansion of the specified segment. The kernel might even delete the previous segment if necessary. The kernel will ask the user for a permission to destroy instructions or data going out of segment scope if such instructions exist. + + @param ea: any address belonging to the segment + @param newstart: new start address of the segment note that segment start address should be higher than segment base linear address. + @param flags: Segment modification flags @retval 1: ok @retval 0: failed, a warning message is displayed -ida_segment.set_segment_cmt (function) - set_segment_cmt(s, cmt, repeatable) - Set segment comment. - - @param s: (C++: const segment_t *) pointer to segment structure - @param cmt: (C++: const char *) comment string, may be multiline (with ' +ida_segment.set_segment_cmt(s: "segment_t", cmt: str, repeatable: bool) -> None + Set segment comment. + + @param s: pointer to segment structure + @param cmt: comment string, may be multiline (with ' '). maximal size is 4096 bytes. Use empty str ("") to delete comment - @param repeatable: (C++: bool) 0: set regular comment. 1: set repeatable comment. + @param repeatable: 0: set regular comment. 1: set repeatable comment. -ida_segment.set_segment_translations (function) - set_segment_translations(segstart, transmap) -> bool - Set new translation list. - - @param segstart: (C++: ea_t) start address of the segment to add translation to - @param transmap: (C++: const eavec_t &) vector of segment start addresses for the translation list. If - transmap is empty, the translation list is deleted. +ida_segment.set_segment_translations(segstart: ida_idaapi.ea_t, transmap: "eavec_t const &") -> bool + Set new translation list. + + @param segstart: start address of the segment to add translation to + @param transmap: vector of segment start addresses for the translation list. If transmap is empty, the translation list is deleted. @retval 1: ok @retval 0: too many translations or bad segstart -ida_segment.set_selector (function) - set_selector(selector, paragraph) -> int - Set mapping of selector to a paragraph. You should call this function _before_ - creating a segment which uses the selector, otherwise the creation of the - segment will fail. - - @param selector: (C++: sel_t) number of selector to map +ida_segment.set_selector(selector: "sel_t", paragraph: ida_idaapi.ea_t) -> int + Set mapping of selector to a paragraph. You should call this function _before_ creating a segment which uses the selector, otherwise the creation of the segment will fail. + + @param selector: number of selector to map * if selector == BADSEL, then return 0 (fail) * if the selector has had a mapping, old mapping is destroyed - * if the selector number is equal to paragraph value, then the mapping is - destroyed because we don't need to keep trivial mappings. - @param paragraph: (C++: ea_t) paragraph to map selector + * if the selector number is equal to paragraph value, then the mapping is destroyed because we don't need to keep trivial mappings. + @param paragraph: paragraph to map selector @retval 1: ok @retval 0: failure (bad selector or too many mappings) -ida_segment.set_visible_segm (function) - set_visible_segm(s, visible) +ida_segment.set_visible_segm(s: "segment_t", visible: bool) -> None See SFL_HIDDEN. - - @param s: (C++: segment_t *) - @param visible: (C++: bool) -ida_segment.setup_selector (function) - setup_selector(segbase) -> sel_t - Allocate a selector for a segment if necessary. You must call this function - before calling add_segm_ex(). add_segm() calls this function itself, so you - don't need to allocate a selector. This function will allocate a selector if - 'segbase' requires more than 16 bits and the current processor is IBM PC. - Otherwise it will return the segbase value. - - @param segbase: (C++: ea_t) a new segment base paragraph - @return: the allocated selector number +ida_segment.setup_selector(segbase: ida_idaapi.ea_t) -> "sel_t" + Allocate a selector for a segment if necessary. You must call this function before calling add_segm_ex(). add_segm() calls this function itself, so you don't need to allocate a selector. This function will allocate a selector if 'segbase' requires more than 16 bits and the current processor is IBM PC. Otherwise it will return the segbase value. + + @param segbase: a new segment base paragraph + @returns the allocated selector number -ida_segment.std_out_segm_footer (function) - std_out_segm_footer(ctx, seg) - Generate segment footer line as a comment line. This function may be used in IDP - modules to generate segment footer if the target assembler doesn't have 'ends' - directive. - - @param ctx: (C++: struct outctx_t &) outctx_t & - @param seg: (C++: segment_t *) +ida_segment.std_out_segm_footer(ctx: "outctx_t &", seg: "segment_t") -> None + Generate segment footer line as a comment line. This function may be used in IDP modules to generate segment footer if the target assembler doesn't have 'ends' directive. + -ida_segment.take_memory_snapshot (function) - take_memory_snapshot(type) -> bool - Take a memory snapshot of the running process. - - @param type: (C++: int) specifies which snapshot we want (see SNAP_ Snapshot types) - @return: success +ida_segment.take_memory_snapshot(type: int) -> bool + Take a memory snapshot of the running process. + + @param type: specifies which snapshot we want (see SNAP_ Snapshot types) + @returns success -ida_segment.update_segm (function) - update_segm(s) -> bool - - @param s: segment_t * +ida_segment.update_segm(s: "segment_t") -> bool -ida_segregs (module) +ida_segregs Functions that deal with the segment registers. - If your processor doesn't use segment registers, then these functions are of no - use for you. However, you should define two virtual segment registers - CS and - DS (for code segment and data segment) and specify their internal numbers in the - LPH structure (processor_t::reg_code_sreg and processor_t::reg_data_sreg). + If your processor doesn't use segment registers, then these functions are of no use for you. However, you should define two virtual segment registers - CS and DS (for code segment and data segment) and specify their internal numbers in the LPH structure (processor_t::reg_code_sreg and processor_t::reg_data_sreg). + -ida_segregs.SR_auto (variable) +ida_segregs.SR_auto the value is determined by IDA -ida_segregs.SR_autostart (variable) +ida_segregs.SR_autostart used as SR_auto for segment starting address -ida_segregs.SR_inherit (variable) +ida_segregs.SR_inherit the value is inherited from the previous range -ida_segregs.SR_user (variable) +ida_segregs.SR_user the value is specified by the user -ida_segregs.copy_sreg_ranges (function) - copy_sreg_ranges(dst_rg, src_rg, map_selector=False) - Duplicate segment register ranges. - - @param dst_rg: (C++: int) number of destination segment register - @param src_rg: (C++: int) copy ranges from - @param map_selector: (C++: bool) map selectors to linear addresses using sel2ea() +ida_segregs.copy_sreg_ranges(dst_rg: int, src_rg: int, map_selector: bool = False) -> None + Duplicate segment register ranges. + + @param dst_rg: number of destination segment register + @param src_rg: copy ranges from + @param map_selector: map selectors to linear addresses using sel2ea() -ida_segregs.del_sreg_range (function) - del_sreg_range(ea, rg) -> bool - Delete segment register range started at ea. When a segment register range is - deleted, the previous range is extended to cover the empty space. The segment - register range at the beginning of a segment cannot be deleted. - - @param ea: (C++: ea_t) start_ea of the deleted range - @param rg: (C++: int) the segment register number - @return: success +ida_segregs.del_sreg_range(ea: ida_idaapi.ea_t, rg: int) -> bool + Delete segment register range started at ea. When a segment register range is deleted, the previous range is extended to cover the empty space. The segment register range at the beginning of a segment cannot be deleted. + + @param ea: start_ea of the deleted range + @param rg: the segment register number + @returns success -ida_segregs.get_prev_sreg_range (function) - get_prev_sreg_range(out, ea, rg) -> bool - Get segment register range previous to one with address. - @note: more efficient then get_sreg_range(reg, ea-1) - - @param out: (C++: sreg_range_t *) segment register range - @param ea: (C++: ea_t) any linear address in the program - @param rg: (C++: int) the segment register number - @return: success +ida_segregs.get_prev_sreg_range(out: "sreg_range_t", ea: ida_idaapi.ea_t, rg: int) -> bool + Get segment register range previous to one with address. + + @param out: segment register range + @param ea: any linear address in the program + @param rg: the segment register number + @returns success -ida_segregs.get_sreg (function) - get_sreg(ea, rg) -> sel_t - Get value of a segment register. This function uses segment register range and - default segment register values stored in the segment structure. - - @param ea: (C++: ea_t) linear address in the program - @param rg: (C++: int) number of the segment register - @return: value of the segment register, BADSEL if value is unknown. +ida_segregs.get_sreg(ea: ida_idaapi.ea_t, rg: int) -> "sel_t" + Get value of a segment register. This function uses segment register range and default segment register values stored in the segment structure. + + @param ea: linear address in the program + @param rg: number of the segment register + @returns value of the segment register, BADSEL if value is unknown or rg is not a segment register. -ida_segregs.get_sreg_range (function) - get_sreg_range(out, ea, rg) -> bool - Get segment register range by linear address. - - @param out: (C++: sreg_range_t *) segment register range - @param ea: (C++: ea_t) any linear address in the program - @param rg: (C++: int) the segment register number - @return: success +ida_segregs.get_sreg_range(out: "sreg_range_t", ea: ida_idaapi.ea_t, rg: int) -> bool + Get segment register range by linear address. + + @param out: segment register range + @param ea: any linear address in the program + @param rg: the segment register number + @returns success -ida_segregs.get_sreg_range_num (function) - get_sreg_range_num(ea, rg) -> int - Get number of segment register range by address. - - @param ea: (C++: ea_t) any address in the range - @param rg: (C++: int) the segment register number - @return: -1 if no range occupies the specified address. otherwise returns number - of the specified range (0..get_srranges_qty()-1) +ida_segregs.get_sreg_range_num(ea: ida_idaapi.ea_t, rg: int) -> int + Get number of segment register range by address. + + @param ea: any address in the range + @param rg: the segment register number + @returns -1 if no range occupies the specified address. otherwise returns number of the specified range (0..get_srranges_qty()-1) -ida_segregs.get_sreg_ranges_qty (function) - get_sreg_ranges_qty(rg) -> size_t - Get number of segment register ranges. - - @param rg: (C++: int) the segment register number +ida_segregs.get_sreg_ranges_qty(rg: int) -> "size_t" + Get number of segment register ranges. + + @param rg: the segment register number -ida_segregs.getn_sreg_range (function) - getn_sreg_range(out, rg, n) -> bool - Get segment register range by its number. - - @param out: (C++: sreg_range_t *) segment register range - @param rg: (C++: int) the segment register number - @param n: (C++: int) number of range (0..qty()-1) - @return: success +ida_segregs.getn_sreg_range(out: "sreg_range_t", rg: int, n: int) -> bool + Get segment register range by its number. + + @param out: segment register range + @param rg: the segment register number + @param n: number of range (0..qty()-1) + @returns success -ida_segregs.set_default_dataseg (function) - set_default_dataseg(ds_sel) +ida_segregs.set_default_dataseg(ds_sel: "sel_t") -> None Set default value of DS register for all segments. - - @param ds_sel: (C++: sel_t) -ida_segregs.set_default_sreg_value (function) - set_default_sreg_value(sg, rg, value) -> bool - Set default value of a segment register for a segment. - - @param sg: (C++: segment_t *) pointer to segment structure if nullptr, then set the register for - all segments - @param rg: (C++: int) number of segment register - @param value: (C++: sel_t) its default value. this value will be used by get_sreg() if value - of the register is unknown at the specified address. - @return: success +ida_segregs.set_default_sreg_value(sg: "segment_t *", rg: int, value: "sel_t") -> bool + Set default value of a segment register for a segment. + + @param sg: pointer to segment structure if nullptr, then set the register for all segments + @param rg: number of segment register + @param value: its default value. this value will be used by get_sreg() if value of the register is unknown at the specified address. + @returns success -ida_segregs.set_sreg_at_next_code (function) - set_sreg_at_next_code(ea1, ea2, rg, value) - Set the segment register value at the next instruction. This function is - designed to be called from idb_event::sgr_changed handler in order to contain - the effect of changing a segment register value only until the next instruction. - - It is useful, for example, in the ARM module: the modification of the T register - does not affect existing instructions later in the code. - - @param ea1: (C++: ea_t) address to start to search for an instruction - @param ea2: (C++: ea_t) the maximal address - @param rg: (C++: int) the segment register number - @param value: (C++: sel_t) the segment register value +ida_segregs.set_sreg_at_next_code(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, rg: int, value: "sel_t") -> None + Set the segment register value at the next instruction. This function is designed to be called from idb_event::sgr_changed handler in order to contain the effect of changing a segment register value only until the next instruction. + It is useful, for example, in the ARM module: the modification of the T register does not affect existing instructions later in the code. + + @param ea1: address to start to search for an instruction + @param ea2: the maximal address + @param rg: the segment register number + @param value: the segment register value -ida_segregs.split_sreg_range (function) - split_sreg_range(ea, rg, v, tag, silent=False) -> bool - Create a new segment register range. This function is used when the IDP emulator - detects that a segment register changes its value. - - @param ea: (C++: ea_t) linear address where the segment register will have a new value. if - ea==BADADDR, nothing to do. - @param rg: (C++: int) the number of the segment register - @param v: (C++: sel_t) the new value of the segment register. If the value is unknown, you - should specify BADSEL. - @param tag: (C++: uchar) the register info tag. see Segment register range tags - @param silent: (C++: bool) if false, display a warning() in the case of failure - @return: success +ida_segregs.split_sreg_range(ea: ida_idaapi.ea_t, rg: int, v: "sel_t", tag: "uchar", silent: bool = False) -> bool + Create a new segment register range. This function is used when the IDP emulator detects that a segment register changes its value. + + @param ea: linear address where the segment register will have a new value. if ea==BADADDR, nothing to do. + @param rg: the number of the segment register + @param v: the new value of the segment register. If the value is unknown, you should specify BADSEL. + @param tag: the register info tag. see Segment register range tags + @param silent: if false, display a warning() in the case of failure + @returns success -ida_segregs.sreg_range_t (class) - Proxy of C++ sreg_range_t class. +ida_segregs.sreg_range_t -ida_segregs.sreg_range_t.__init__ (method) - __init__(self) -> sreg_range_t +ida_segregs.sreg_range_t.__init__(self) -ida_segregs.sreg_range_t.tag (variable) +ida_segregs.sreg_range_t.tag Segment register range tags -ida_segregs.sreg_range_t.val (variable) +ida_segregs.sreg_range_t.val segment register value -ida_srclang (module) +ida_srclang Third-party compiler support. -ida_srclang.SRCLANG_C (variable) +ida_srclang.SRCLANG_C C. -ida_srclang.SRCLANG_CPP (variable) +ida_srclang.SRCLANG_CPP C++. -ida_srclang.SRCLANG_GO (variable) +ida_srclang.SRCLANG_GO Golang (not supported yet) -ida_srclang.SRCLANG_OBJC (variable) +ida_srclang.SRCLANG_OBJC Objective-C. -ida_srclang.SRCLANG_SWIFT (variable) +ida_srclang.SRCLANG_SWIFT Swift (not supported yet) -ida_srclang.parse_decls_for_srclang (function) - parse_decls_for_srclang(lang, til, input, is_path) -> int - Parse type declarations in the specified language - - @param lang: (C++: srclang_t) the source language(s) expected in the input - @param til: (C++: til_t *) type library to store the types - @param input: (C++: const char *) input source. can be a file path or decl string - @param is_path: (C++: bool) true if input parameter is a path to a source file, false if the - input is an in-memory source snippet +ida_srclang.parse_decls_for_srclang(lang: "srclang_t", til: "til_t", input: str, is_path: bool) -> int + Parse type declarations in the specified language + + @param lang: the source language(s) expected in the input + @param til: type library to store the types + @param input: input source. can be a file path or decl string + @param is_path: true if input parameter is a path to a source file, false if the input is an in-memory source snippet @retval -1: no parser was found that supports the given source language(s) @retval else: the number of errors encountered in the input source -ida_srclang.parse_decls_with_parser (function) - parse_decls_with_parser(parser_name, til, input, is_path) -> int - Parse type declarations using the parser with the specified name - - @param parser_name: (C++: const char *) name of the target parser - @param til: (C++: til_t *) type library to store the types - @param input: (C++: const char *) input source. can be a file path or decl string - @param is_path: (C++: bool) true if input parameter is a path to a source file, false if the - input is an in-memory source snippet +ida_srclang.parse_decls_with_parser(parser_name: str, til: "til_t", input: str, is_path: bool) -> int + Parse type declarations using the parser with the specified name + + @param parser_name: name of the target parser + @param til: type library to store the types + @param input: input source. can be a file path or decl string + @param is_path: true if input parameter is a path to a source file, false if the input is an in-memory source snippet @retval -1: no parser was found with the given name @retval else: the number of errors encountered in the input source -ida_srclang.select_parser_by_name (function) - select_parser_by_name(name) -> bool - Set the parser with the given name as the current parser. Pass nullptr or an - empty string to select the default parser. - - @param name: (C++: const char *) char const * - @return: false if no parser was found with the given name +ida_srclang.select_parser_by_name(name: str) -> bool + Set the parser with the given name as the current parser. Pass nullptr or an empty string to select the default parser. + + @returns false if no parser was found with the given name -ida_srclang.select_parser_by_srclang (function) - select_parser_by_srclang(lang) -> bool - Set the parser that supports the given language(s) as the current parser. The - selected parser must support all languages specified by the given srclang_t. - - @param lang: (C++: srclang_t) - @return: false if no such parser was found +ida_srclang.select_parser_by_srclang(lang: "srclang_t") -> bool + Set the parser that supports the given language(s) as the current parser. The selected parser must support all languages specified by the given srclang_t. + + @returns false if no such parser was found -ida_srclang.set_parser_argv (function) - set_parser_argv(parser_name, argv) -> int - Set the command-line args to use for invocations of the parser with the given - name - - @param parser_name: (C++: const char *) name of the target parser - @param argv: (C++: const char *) argument list +ida_srclang.set_parser_argv(parser_name: str, argv: str) -> int + Set the command-line args to use for invocations of the parser with the given name + + @param parser_name: name of the target parser + @param argv: argument list @retval -1: no parser was found with the given name @retval -2: the operation is not supported by the given parser @retval 0: success -ida_strlist (module) +ida_strlist Functions that deal with the string list. - While the kernel keeps the string list, it does not update it. The string list - is not used by the kernel because keeping it up-to-date would slow down IDA - without any benefit. If the string list is not cleared using clear_strlist(), - the list will be saved to the database and restored on the next startup. - - The users of this list should call build_strlist() if they need an up-to-date - version. + While the kernel keeps the string list, it does not update it. The string list is not used by the kernel because keeping it up-to-date would slow down IDA without any benefit. If the string list is not cleared using clear_strlist(), the list will be saved to the database and restored on the next startup. + The users of this list should call build_strlist() if they need an up-to-date version. + -ida_strlist.build_strlist (function) - build_strlist() +ida_strlist.build_strlist() -> None Rebuild the string list. -ida_strlist.clear_strlist (function) - clear_strlist() +ida_strlist.clear_strlist() -> None Clear the string list. -ida_strlist.get_strlist_item (function) - get_strlist_item(si, n) -> bool +ida_strlist.get_strlist_item(si: "string_info_t", n: "size_t") -> bool Get nth element of the string list (n=0..get_strlist_qty()-1) - - @param si: (C++: string_info_t *) - @param n: (C++: size_t) -ida_strlist.get_strlist_options (function) - get_strlist_options() -> strwinsetup_t +ida_strlist.get_strlist_options() -> "strwinsetup_t const *" Get the static string list options. -ida_strlist.get_strlist_qty (function) - get_strlist_qty() -> size_t - Get number of elements in the string list. The list will be loaded from the - database (if saved) or built from scratch. +ida_strlist.get_strlist_qty() -> "size_t" + Get number of elements in the string list. The list will be loaded from the database (if saved) or built from scratch. + -ida_strlist.string_info_t (class) - Proxy of C++ string_info_t class. +ida_strlist.string_info_t -ida_strlist.string_info_t.__init__ (method) - __init__(self, _ea=BADADDR) -> string_info_t - - @param _ea: ea_t +ida_strlist.string_info_t.__init__(self, *args) -ida_strlist.string_info_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: string_info_t const & +ida_strlist.string_info_t.__lt__(self, r: "string_info_t") -> bool -ida_strlist.strwinsetup_t (class) - Proxy of C++ strwinsetup_t class. +ida_strlist.strwinsetup_t -ida_strlist.strwinsetup_t.__init__ (method) - __init__(self) -> strwinsetup_t +ida_strlist.strwinsetup_t.__init__(self) -ida_strlist.strwinsetup_t._get_strtypes (method) - _get_strtypes(self) -> PyObject * +ida_strlist.strwinsetup_t._get_strtypes(self) -> "PyObject *" -ida_strlist.strwinsetup_t._set_strtypes (method) - _set_strtypes(self, py_t) -> PyObject * - - Parameters - ---------- - py_t: PyObject * +ida_strlist.strwinsetup_t._set_strtypes(self, py_t: "PyObject *") -> "PyObject *" -ida_struct (module) - Structure type management (assembly level types) - -ida_struct.MF_BASECLASS (variable) - a special member representing base class - -ida_struct.MF_BYTIL (variable) - the member was created due to the type system - -ida_struct.MF_DTOR (variable) - a special member representing destructor - -ida_struct.MF_DUPNAME (variable) - duplicate name resolved with _N suffix (N==soff) - -ida_struct.MF_HASTI (variable) - has type information? - -ida_struct.MF_HASUNI (variable) - has members of type "union"? - -ida_struct.MF_OK (variable) - is the member ok? (always yes) - -ida_struct.MF_UNIMEM (variable) - is a member of a union? - -ida_struct.SET_MEMTI_BYTIL (variable) - new type was created by the type subsystem - -ida_struct.SET_MEMTI_COMPATIBLE (variable) - new type must be compatible with the old - -ida_struct.SET_MEMTI_FUNCARG (variable) - mptr is function argument (cannot create arrays) - -ida_struct.SET_MEMTI_MAY_DESTROY (variable) - may destroy other members - -ida_struct.SET_MEMTI_USERTI (variable) - user-specified type - -ida_struct.SF_ALIGN (variable) - alignment (shift amount: 0..31) - -ida_struct.SF_FRAME (variable) - the structure is a function frame - -ida_struct.SF_GHOST (variable) - ghost copy of a local type - -ida_struct.SF_HASUNI (variable) - has members of type "union"? - -ida_struct.SF_HIDDEN (variable) - the structure is collapsed - -ida_struct.SF_NOLIST (variable) - don't include in the chooser list - -ida_struct.SF_TYPLIB (variable) - the structure comes from type library - -ida_struct.SF_UNION (variable) - is a union? varunions are prohibited! - -ida_struct.SF_VAR (variable) - is variable size structure (varstruct)? a variable size structure is one with - the zero size last member. if the last member is a varstruct, then the current - structure is a varstruct too. - -ida_struct.SMT_ARRAY (variable) - arrays are forbidden as function arguments - -ida_struct.SMT_BADARG (variable) - bad parameters - -ida_struct.SMT_FAILED (variable) - failed to set new member type - -ida_struct.SMT_KEEP (variable) - no need to change the member type, the old type is better - -ida_struct.SMT_NOCOMPAT (variable) - the new type is not compatible with the old type - -ida_struct.SMT_OVERLAP (variable) - member would overlap with members that cannot be deleted - -ida_struct.SMT_SIZE (variable) - the new type is incompatible with the member size - -ida_struct.SMT_WORSE (variable) - the new type is worse than the old type - -ida_struct.STRNFL_REGEX (variable) - apply regular expressions to beautify the name - -ida_struct.STRUC_ERROR_MEMBER_LTUDT (variable) - failed to change corresponding local type - -ida_struct.STRUC_ERROR_MEMBER_NAME (variable) - already has member with this name (bad name) - -ida_struct.STRUC_ERROR_MEMBER_NESTED (variable) - recursive structure nesting is forbidden - -ida_struct.STRUC_ERROR_MEMBER_OFFSET (variable) - already has member at this offset - -ida_struct.STRUC_ERROR_MEMBER_OK (variable) - success - -ida_struct.STRUC_ERROR_MEMBER_SIZE (variable) - bad number of bytes or bad sizeof(type) - -ida_struct.STRUC_ERROR_MEMBER_STRUCT (variable) - bad struct id (the 1st argument) - -ida_struct.STRUC_ERROR_MEMBER_TINFO (variable) - bad typeid parameter - -ida_struct.STRUC_ERROR_MEMBER_UNIVAR (variable) - unions can't have variable sized members - -ida_struct.STRUC_ERROR_MEMBER_VARLAST (variable) - variable sized member should be the last member in the structure - -ida_struct.STRUC_SEPARATOR (variable) - structname.fieldname - -ida_struct.add_struc (function) - add_struc(idx, name, is_union=False) -> tid_t - Create a structure type. if idx==BADADDR then add as the last idx. if - name==nullptr then a name will be generated "struct_%d". - - @param idx: (C++: uval_t) - @param name: (C++: const char *) char const * - @param is_union: (C++: bool) - -ida_struct.add_struc_member (function) - add_struc_member(sptr, fieldname, offset, flag, mt, nbytes) -> struc_error_t - Add member to existing structure. - - @param sptr: (C++: struc_t *) structure to modify - @param fieldname: (C++: const char *) if nullptr, then "anonymous_#" name will be generated - @param offset: (C++: ea_t) BADADDR means add to the end of structure - @param flag: (C++: flags64_t) type + representation bits - @param mt: (C++: const opinfo_t *) additional info about member type. must be present for structs, - offsets, enums, strings, struct offsets. - @param nbytes: (C++: asize_t) if == 0 then the structure will be a varstruct. in this case the - member should be the last member in the structure - -ida_struct.del_member_tinfo (function) - del_member_tinfo(sptr, mptr) -> bool - Delete tinfo for given member. - - @param sptr: (C++: struc_t *) - @param mptr: (C++: member_t *) - -ida_struct.del_struc (function) - del_struc(sptr) -> bool - Delete a structure type This function deletes as well local type synced with the - structure - - @param sptr: (C++: struc_t *) - -ida_struct.del_struc_member (function) - del_struc_member(sptr, offset) -> bool - Delete member at given offset. - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - -ida_struct.del_struc_members (function) - del_struc_members(sptr, off1, off2) -> int - Delete members which occupy range of offsets (off1..off2). - - @param sptr: (C++: struc_t *) - @param off1: (C++: ea_t) - @param off2: (C++: ea_t) - @return: number of deleted members or -1 on error - -ida_struct.dyn_member_ref_array (class) - Proxy of C++ dynamic_wrapped_array_t< member_t > class. - -ida_struct.dyn_member_ref_array.__getitem__ (method) - __getitem__(self, i) -> member_t - - @param i: size_t - -ida_struct.dyn_member_ref_array.__init__ (method) - __init__(self, _data, _count) -> dyn_member_ref_array - - @param _data: member_t * - @param _count: size_t - -ida_struct.dyn_member_ref_array.__len__ (method) - __len__(self) -> size_t - -ida_struct.dyn_member_ref_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: member_t const & - -ida_struct.expand_struc (function) - expand_struc(sptr, offset, delta, recalc=True) -> bool - Expand/Shrink structure type. - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - @param delta: (C++: adiff_t) - @param recalc: (C++: bool) - -ida_struct.get_best_fit_member (function) - get_best_fit_member(sptr, offset) -> member_t - Get member that is most likely referenced by the specified offset. Useful for - offsets > sizeof(struct). - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: asize_t) - -ida_struct.get_first_struc_idx (function) - get_first_struc_idx() -> uval_t - Get index of first structure. - - @return: BADADDR if no known structures, 0 otherwise - -ida_struct.get_innermost_member (function) - get_innermost_member(sptr, offset) -> (member_t, struc_t, int) - Get the innermost member at the given offset - - @param sptr: the starting structure - @param offset: offset into the starting structure - @return: - None on failure - - tuple(member_t, struct_t, offset) - where member_t: a member in SPTR (it is not a structure), - struct_t: the innermost structure, - offset: remaining offset into the returned member - -ida_struct.get_last_struc_idx (function) - get_last_struc_idx() -> uval_t - Get index of last structure. - - @return: BADADDR if no known structures, get_struc_qty()-1 otherwise - -ida_struct.get_max_offset (function) - get_max_offset(sptr) -> ea_t - For unions: returns number of members, for structs: returns size of structure. - - @param sptr: (C++: struc_t *) - -ida_struct.get_member (function) - get_member(sptr, offset) -> member_t - Get member at given offset. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: asize_t) - -ida_struct.get_member_by_fullname (function) - get_member_by_fullname(fullname) -> member_t - Get a member by its fully qualified name, "struct.field". - - @param fullname: (C++: const char *) char const * - -ida_struct.get_member_by_id (function) - get_member_by_id(mid) -> member_t - Check if the specified member id points to a struct member. convenience - function. - - @param mid: (C++: tid_t) - -ida_struct.get_member_by_name (function) - get_member_by_name(sptr, membername) -> member_t - Get a member by its name, like "field44". - - @param sptr: (C++: const struc_t *) struc_t const * - @param membername: (C++: const char *) char const * - -ida_struct.get_member_cmt (function) - get_member_cmt(mid, repeatable) -> str - Get comment of structure member. - - @param mid: (C++: tid_t) - @param repeatable: (C++: bool) - -ida_struct.get_member_fullname (function) - get_member_fullname(mid) -> str - Get a member's fully qualified name, "struct.field". - - @param mid: (C++: tid_t) - -ida_struct.get_member_id (function) - get_member_id(sptr, offset) -> tid_t - Get member id at given offset. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: asize_t) - -ida_struct.get_member_name (function) - get_member_name(mid) -> str - - @param mid: tid_t - -ida_struct.get_member_size (function) - get_member_size(NONNULL_mptr) -> asize_t - Get size of structure member. May return 0 for the last member of varstruct. For - union members, returns member_t::eoff. - - @param NONNULL_mptr: (C++: const member_t *) member_t const * - -ida_struct.get_member_struc (function) - get_member_struc(fullname) -> struc_t - Get containing structure of member by its full name "struct.field". - - @param fullname: (C++: const char *) char const * - -ida_struct.get_member_tinfo (function) - get_member_tinfo(tif, mptr) -> bool - Get tinfo for given member. - - @param tif: (C++: tinfo_t *) - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.get_next_member_idx (function) - get_next_member_idx(sptr, off) -> ssize_t - Get the next member idx, if it does not exist, return -1. - - @param sptr: (C++: const struc_t *) struc_t const * - @param off: (C++: asize_t) - -ida_struct.get_next_struc_idx (function) - get_next_struc_idx(idx) -> uval_t - Get next struct index. - - @param idx: (C++: uval_t) - @return: BADADDR if resulting index is out of bounds, otherwise idx++ - -ida_struct.get_or_guess_member_tinfo (function) - get_or_guess_member_tinfo(tif, mptr) -> bool - Try to get tinfo for given member - if failed, generate a tinfo using - information about the member id from the disassembly - - @param tif: (C++: tinfo_t *) - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.get_prev_member_idx (function) - get_prev_member_idx(sptr, off) -> ssize_t - Get the prev member idx, if it does not exist, return -1. - - @param sptr: (C++: const struc_t *) struc_t const * - @param off: (C++: asize_t) - -ida_struct.get_prev_struc_idx (function) - get_prev_struc_idx(idx) -> uval_t - Get previous struct index. - - @param idx: (C++: uval_t) - @return: BADADDR if resulting index is negative, otherwise idx - 1 - -ida_struct.get_sptr (function) - get_sptr(mptr) -> struc_t - Get child struct if member is a struct. - - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.get_struc (function) - get_struc(id) -> struc_t - Get pointer to struct type info. - - @param id: (C++: tid_t) - -ida_struct.get_struc_by_idx (function) - get_struc_by_idx(idx) -> tid_t - Get struct id by struct number. - - @param idx: (C++: uval_t) - -ida_struct.get_struc_cmt (function) - get_struc_cmt(id, repeatable) -> str - Get struct comment. - - @param id: (C++: tid_t) - @param repeatable: (C++: bool) - -ida_struct.get_struc_first_offset (function) - get_struc_first_offset(sptr) -> ea_t - Get offset of first member. - - @param sptr: (C++: const struc_t *) struc_t const * - @return: BADADDR if memqty == 0 - -ida_struct.get_struc_id (function) - get_struc_id(name) -> tid_t - Get struct id by name. - - @param name: (C++: const char *) char const * - -ida_struct.get_struc_idx (function) - get_struc_idx(id) -> uval_t - Get internal number of the structure. - - @param id: (C++: tid_t) - -ida_struct.get_struc_last_offset (function) - get_struc_last_offset(sptr) -> ea_t - Get offset of last member. - - @param sptr: (C++: const struc_t *) struc_t const * - @return: BADADDR if memqty == 0 - -ida_struct.get_struc_name (function) - get_struc_name(id, flags=0) -> str - - @param id: tid_t - @param flags: int - -ida_struct.get_struc_next_offset (function) - get_struc_next_offset(sptr, offset) -> ea_t - Get offset of member with smallest offset larger than 'offset'. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: ea_t) - @return: BADADDR if no next offset - -ida_struct.get_struc_prev_offset (function) - get_struc_prev_offset(sptr, offset) -> ea_t - Get offset of member with largest offset less than 'offset'. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: ea_t) - @return: BADADDR if no prev offset - -ida_struct.get_struc_qty (function) - get_struc_qty() -> size_t - Get number of known structures. - -ida_struct.get_struc_size (function) - get_struc_size(sptr) -> asize_t - Get struct size (also see get_struc_size(const struc_t *)) - - @param sptr: struc_t const * - - get_struc_size(id) -> asize_t - - @param id: tid_t - -ida_struct.is_anonymous_member_name (function) - is_anonymous_member_name(name) -> bool - Is member name prefixed with "anonymous"? - - @param name: (C++: const char *) char const * - -ida_struct.is_dummy_member_name (function) - is_dummy_member_name(name) -> bool - Is member name an auto-generated name? - - @param name: (C++: const char *) char const * - -ida_struct.is_member_id (function) - is_member_id(mid) -> bool - Is a member id? - - @param mid: (C++: tid_t) - -ida_struct.is_special_member (function) - is_special_member(id) -> bool - Is a special member with the name beginning with ' '? - - @param id: (C++: tid_t) - -ida_struct.is_union (function) - is_union(id) -> bool - Is a union? - - @param id: (C++: tid_t) - -ida_struct.is_varmember (function) - is_varmember(mptr) -> bool - Is variable size member? - - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.is_varstr (function) - is_varstr(id) -> bool - Is variable size structure? - - @param id: (C++: tid_t) - -ida_struct.member_t (class) - Proxy of C++ member_t class. - -ida_struct.member_t.__init__ (method) - __init__(self) -> member_t - -ida_struct.member_t.by_til (method) - by_til(self) -> bool - Was the member created due to the type system? - -ida_struct.member_t.eoff (variable) - end offset - -ida_struct.member_t.flag (variable) - type+representation bits - -ida_struct.member_t.get_size (method) - get_size(self) -> asize_t - Get member size. - -ida_struct.member_t.get_soff (method) - get_soff(self) -> ea_t - Get start offset (for unions - returns 0) - -ida_struct.member_t.has_ti (method) - has_ti(self) -> bool - Has type information? - -ida_struct.member_t.has_union (method) - has_union(self) -> bool - Has members of type "union"? - -ida_struct.member_t.id (variable) - name(), cmt, rptcmt - -ida_struct.member_t.is_baseclass (method) - is_baseclass(self) -> bool - Is a base class member? - -ida_struct.member_t.is_destructor (method) - is_destructor(self) -> bool - Is a virtual destructor? - -ida_struct.member_t.is_dupname (method) - is_dupname(self) -> bool - Duplicate name was resolved during import? - -ida_struct.member_t.props (variable) - Struct member properties - -ida_struct.member_t.soff (variable) - start offset (for unions - number of the member 0..n) - -ida_struct.member_t.unimem (method) - unimem(self) -> bool - Is a member of a union? - -ida_struct.retrieve_member_info (function) - retrieve_member_info(buf, mptr) -> opinfo_t - Get operand type info for member. - - @param buf: (C++: opinfo_t *) - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.save_struc (function) - save_struc(sptr, may_update_ltypes=True) - Update struct information in the database (internal function) - - @param sptr: (C++: const struc_t *) struc_t const * - @param may_update_ltypes: (C++: bool) - -ida_struct.set_member_cmt (function) - set_member_cmt(mptr, cmt, repeatable) -> bool - Set member comment. - - @param mptr: (C++: member_t *) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_struct.set_member_name (function) - set_member_name(sptr, offset, name) -> bool - Set name of member at given offset. - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - @param name: (C++: const char *) char const * - -ida_struct.set_member_tinfo (function) - set_member_tinfo(sptr, mptr, memoff, tif, flags) -> smt_code_t - Set tinfo for given member. - - @param sptr: (C++: struc_t *) containing struct - @param mptr: (C++: member_t *) target member - @param memoff: (C++: uval_t) offset within member - @param tif: (C++: const tinfo_t &) type info - @param flags: (C++: int) Set member tinfo flags - -ida_struct.set_member_type (function) - set_member_type(sptr, offset, flag, mt, nbytes) -> bool - Set type of member at given offset (also see add_struc_member()) - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - @param flag: (C++: flags64_t) - @param mt: (C++: const opinfo_t *) opinfo_t const * - @param nbytes: (C++: asize_t) - -ida_struct.set_struc_align (function) - set_struc_align(sptr, shift) -> bool - Set structure alignment (SF_ALIGN) - - @param sptr: (C++: struc_t *) - @param shift: (C++: int) - -ida_struct.set_struc_cmt (function) - set_struc_cmt(id, cmt, repeatable) -> bool - Set structure comment. - - @param id: (C++: tid_t) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_struct.set_struc_hidden (function) - set_struc_hidden(sptr, is_hidden) - Hide/unhide a struct type. - - @param sptr: (C++: struc_t *) - @param is_hidden: (C++: bool) - -ida_struct.set_struc_idx (function) - set_struc_idx(sptr, idx) -> bool - Set internal number of struct. Also see get_struc_idx(), get_struc_by_idx(). - - @param sptr: (C++: const struc_t *) struc_t const * - @param idx: (C++: uval_t) - -ida_struct.set_struc_listed (function) - set_struc_listed(sptr, is_listed) - Add/remove a struct type from the struct list. - - @param sptr: (C++: struc_t *) - @param is_listed: (C++: bool) - -ida_struct.set_struc_name (function) - set_struc_name(id, name) -> bool - Set structure name. - - @param id: (C++: tid_t) - @param name: (C++: const char *) char const * - -ida_struct.stroff_as_size (function) - stroff_as_size(plen, sptr, value) -> bool - - @param plen: int - @param sptr: struc_t const * - @param value: asize_t - - stroff_as_size(plen, tif, value) -> bool - - @param plen: int - @param tif: tinfo_t const & - @param value: asize_t - -ida_struct.struc_t (class) - Proxy of C++ struc_t class. - -ida_struct.struc_t.__get_members__ (method) - __get_members__(self) -> dyn_member_ref_array - -ida_struct.struc_t.__init__ (method) - -ida_struct.struc_t.age (variable) - not used - -ida_struct.struc_t.from_til (method) - from_til(self) -> bool - Does structure come from a type library? - -ida_struct.struc_t.get_alignment (method) - get_alignment(self) -> int - See SF_ALIGN. - -ida_struct.struc_t.get_last_member (method) - get_last_member(self) -> member_t - -ida_struct.struc_t.get_member (method) - -ida_struct.struc_t.has_union (method) - has_union(self) -> bool - Has members of type "union"? - -ida_struct.struc_t.id (variable) - struct id - -ida_struct.struc_t.is_choosable (method) - is_choosable(self) -> bool - Is included in chooser list? Use set_struc_listed to change the listed status - -ida_struct.struc_t.is_copyof (method) - is_copyof(self) -> bool - Is copied from a local type? - -ida_struct.struc_t.is_frame (method) - is_frame(self) -> bool - Is this structure a function frame? - -ida_struct.struc_t.is_ghost (method) - is_ghost(self) -> bool - Is a ghost copy of a local type? - -ida_struct.struc_t.is_hidden (method) - is_hidden(self) -> bool - Is the structure collapsed? Use set_struc_hidden to change the hidden status - -ida_struct.struc_t.is_mappedto (method) - is_mappedto(self) -> bool - Is mapped to a local type? - -ida_struct.struc_t.is_synced (method) - is_synced(self) -> bool - Is synced with a local type? - -ida_struct.struc_t.is_union (method) - is_union(self) -> bool - Is a union? - -ida_struct.struc_t.is_varstr (method) - is_varstr(self) -> bool - Is variable size structure? - -ida_struct.struc_t.like_union (method) - like_union(self) -> bool - Is a union or contains members of type "union"? - -ida_struct.struc_t.members (variable) - only defined members are stored here. there may be gaps between members. - -ida_struct.struc_t.memqty (variable) - number of members - -ida_struct.struc_t.ordinal (variable) - corresponding local type ordinal number - -ida_struct.struc_t.props (variable) - Structure properties - -ida_struct.struc_t.set_alignment (method) - set_alignment(self, shift) - Do not use; use set_struc_align() - - @param shift: (C++: int) - -ida_struct.struct_field_visitor_t (class) - Proxy of C++ struct_field_visitor_t class. - -ida_struct.struct_field_visitor_t.__disown__ (method) - -ida_struct.struct_field_visitor_t.__init__ (method) - __init__(self) -> struct_field_visitor_t - - @param self: PyObject * - -ida_struct.struct_field_visitor_t.visit_field (method) - visit_field(self, sptr, mptr) -> int - - @param sptr: struc_t * - @param mptr: member_t * - -ida_struct.udm_visitor_t (class) - Proxy of C++ udm_visitor_t class. - -ida_struct.udm_visitor_t.__disown__ (method) - -ida_struct.udm_visitor_t.__init__ (method) - __init__(self) -> udm_visitor_t - - @param self: PyObject * - -ida_struct.udm_visitor_t.visit_udm (method) - visit_udm(self, tid, tif, udt, idx) -> int - - @param tid: (C++: tid_t) udt tid - @param tif: (C++: const tinfo_t *) udt type info (may be nullptr for corrupted idbs) - @param udt: (C++: const udt_type_data_t *) udt type data (may be nullptr for corrupted idbs) - @param idx: (C++: ssize_t) the index of udt the member (may be -1 if udm was not found) - -ida_struct.unsync_and_delete_struc (function) - unsync_and_delete_struc(sptr) - Delete the structure but leave synced ltudt unchanged. Note del_struc() deletes - both ASM struc and the corresponding local type - - @param sptr: (C++: struc_t *) - -ida_struct.visit_stroff_fields (function) - visit_stroff_fields(sfv, path, disp, appzero) -> flags64_t - - @param sfv: struct_field_visitor_t & - @param path: tid_t const * - @param disp: adiff_t * - @param appzero: bool - -ida_struct.visit_stroff_udms (function) - visit_stroff_udms(sfv, path, disp, appzero) -> int - Visit structure fields in a stroff expression or in a reference to a struct data - variable. This function can be used to enumerate all components of an expression - like 'a.b.c'. - - @param sfv: (C++: udm_visitor_t &) visitor object - @param path: (C++: const tid_t *) struct path (path[0] contains the initial struct id) - @param disp: (C++: adiff_t *) offset into structure - @param appzero: (C++: bool) should visit field at offset zero? - @return: visitor result - -ida_tryblks (module) +ida_tryblks Architecture independent exception handling info. Try blocks have the following general properties: * A try block specifies a possibly fragmented guarded code region. * Each try block has always at least one catch/except block description * Each catch block contains its boundaries and a filter. - * Additionally a catch block can hold sp adjustment and the offset to the - exception object offset (C++). - * Try blocks can be nested. Nesting is automatically calculated at the retrieval - time. + * Additionally a catch block can hold sp adjustment and the offset to the exception object offset (C++). + * Try blocks can be nested. Nesting is automatically calculated at the retrieval time. * There may be (nested) multiple try blocks starting at the same address. - See examples in tests/input/src/eh_tests. + + See examples in tests/input/src/eh_tests. + -ida_tryblks.TBERR_EMPTY (variable) +ida_tryblks.TBEA_CATCH + is EA the start of a c++ catch/cleanup block? + +ida_tryblks.TBEA_FALLTHRU + is there a fall through into provided ea from an unwind region + +ida_tryblks.TBEA_SEHFILT + is EA the start of a seh filter? + +ida_tryblks.TBEA_SEHLPAD + is EA the start of a seh finally/except block? + +ida_tryblks.TBEA_SEHTRY + is EA within a seh try block + +ida_tryblks.TBEA_TRY + is EA within a c++ try block? + +ida_tryblks.TBERR_EMPTY empty try block -ida_tryblks.TBERR_END (variable) +ida_tryblks.TBERR_END bad end address -ida_tryblks.TBERR_INTERSECT (variable) +ida_tryblks.TBERR_INTERSECT range would intersect inner tryblk -ida_tryblks.TBERR_KIND (variable) +ida_tryblks.TBERR_KIND illegal try block kind -ida_tryblks.TBERR_NO_CATCHES (variable) +ida_tryblks.TBERR_NO_CATCHES no catch blocks at all -ida_tryblks.TBERR_OK (variable) +ida_tryblks.TBERR_OK ok -ida_tryblks.TBERR_ORDER (variable) +ida_tryblks.TBERR_ORDER bad address order -ida_tryblks.TBERR_START (variable) +ida_tryblks.TBERR_START bad start address -ida_tryblks.add_tryblk (function) - add_tryblk(tb) -> int - Add one try block information. +ida_tryblks.add_tryblk(tb: "tryblk_t") -> int + Add one try block information. + + @param tb: try block to add. + @returns error code; 0 means good + +ida_tryblks.catch_t + +ida_tryblks.catch_t.__init__(self) + +ida_tryblks.catchvec_t + +ida_tryblks.catchvec_t.__eq__(self, r: "catchvec_t") -> bool + +ida_tryblks.catchvec_t.__getitem__(self, i: "size_t") -> "catch_t const &" + +ida_tryblks.catchvec_t.__init__(self, *args) + +ida_tryblks.catchvec_t.__len__(self) -> "size_t" + +ida_tryblks.catchvec_t.__ne__(self, r: "catchvec_t") -> bool + +ida_tryblks.catchvec_t.__setitem__(self, i: "size_t", v: "catch_t") -> None + +ida_tryblks.catchvec_t._del(self, x: "catch_t") -> bool + +ida_tryblks.catchvec_t.add_unique(self, x: "catch_t") -> bool + +ida_tryblks.catchvec_t.append(self, x: "catch_t") -> None + +ida_tryblks.catchvec_t.at(self, _idx: "size_t") -> "catch_t const &" + +ida_tryblks.catchvec_t.begin(self, *args) -> "qvector< catch_t >::const_iterator" + +ida_tryblks.catchvec_t.capacity(self) -> "size_t" + +ida_tryblks.catchvec_t.clear(self) -> None + +ida_tryblks.catchvec_t.empty(self) -> bool + +ida_tryblks.catchvec_t.end(self, *args) -> "qvector< catch_t >::const_iterator" + +ida_tryblks.catchvec_t.erase(self, *args) -> "qvector< catch_t >::iterator" + +ida_tryblks.catchvec_t.extend(self, x: "catchvec_t") -> None + +ida_tryblks.catchvec_t.extract(self) -> "catch_t *" + +ida_tryblks.catchvec_t.find(self, *args) -> "qvector< catch_t >::const_iterator" + +ida_tryblks.catchvec_t.grow(self, *args) -> None + +ida_tryblks.catchvec_t.has(self, x: "catch_t") -> bool + +ida_tryblks.catchvec_t.inject(self, s: "catch_t", len: "size_t") -> None + +ida_tryblks.catchvec_t.insert(self, it: "catch_t", x: "catch_t") -> "qvector< catch_t >::iterator" + +ida_tryblks.catchvec_t.pop_back(self) -> None + +ida_tryblks.catchvec_t.push_back(self, *args) -> "catch_t &" + +ida_tryblks.catchvec_t.qclear(self) -> None + +ida_tryblks.catchvec_t.reserve(self, cnt: "size_t") -> None + +ida_tryblks.catchvec_t.resize(self, *args) -> None + +ida_tryblks.catchvec_t.size(self) -> "size_t" + +ida_tryblks.catchvec_t.swap(self, r: "catchvec_t") -> None + +ida_tryblks.catchvec_t.truncate(self) -> None + +ida_tryblks.del_tryblks(range: "range_t") -> None + Delete try block information in the specified range. + + @param range: the range to be cleared + +ida_tryblks.find_syseh(ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Find the start address of the system eh region including the argument. + + @param ea: search address + @returns start address of surrounding tryblk, otherwise BADADDR + +ida_tryblks.get_tryblks(tbv: "tryblks_t", range: "range_t") -> "size_t" + ------------------------------------------------------------------------- Retrieve try block information from the specified address range. Try blocks are sorted by starting address and their nest levels calculated. + + @param tbv: output buffer; may be nullptr + @param range: address range to change + @returns number of found try blocks + +ida_tryblks.is_ea_tryblks(ea: ida_idaapi.ea_t, flags: int) -> bool + Check if the given address ea is part of tryblks description. + + @param ea: address to check + @param flags: combination of flags for is_ea_tryblks() + +ida_tryblks.seh_t + +ida_tryblks.seh_t.__init__(self) + +ida_tryblks.seh_t.clear(self) -> None + +ida_tryblks.try_handler_t + +ida_tryblks.try_handler_t.__init__(self) + +ida_tryblks.try_handler_t.clear(self) -> None + +ida_tryblks.tryblk_t + +ida_tryblks.tryblk_t.__init__(self, *args) + +ida_tryblks.tryblk_t.clear(self) -> None + +ida_tryblks.tryblk_t.cpp(self) -> "catchvec_t &" + +ida_tryblks.tryblk_t.empty(self) -> bool + +ida_tryblks.tryblk_t.get_kind(self) -> "uchar" + +ida_tryblks.tryblk_t.is_cpp(self) -> bool + +ida_tryblks.tryblk_t.is_seh(self) -> bool + +ida_tryblks.tryblk_t.seh(self) -> "seh_t &" + +ida_tryblks.tryblk_t.set_cpp(self) -> "catchvec_t &" + +ida_tryblks.tryblk_t.set_seh(self) -> "seh_t &" + +ida_tryblks.tryblks_t + +ida_tryblks.tryblks_t.__eq__(self, r: "tryblks_t") -> bool + +ida_tryblks.tryblks_t.__getitem__(self, i: "size_t") -> "tryblk_t const &" + +ida_tryblks.tryblks_t.__init__(self, *args) + +ida_tryblks.tryblks_t.__len__(self) -> "size_t" + +ida_tryblks.tryblks_t.__ne__(self, r: "tryblks_t") -> bool + +ida_tryblks.tryblks_t.__setitem__(self, i: "size_t", v: "tryblk_t") -> None + +ida_tryblks.tryblks_t._del(self, x: "tryblk_t") -> bool + +ida_tryblks.tryblks_t.add_unique(self, x: "tryblk_t") -> bool + +ida_tryblks.tryblks_t.append(self, x: "tryblk_t") -> None + +ida_tryblks.tryblks_t.at(self, _idx: "size_t") -> "tryblk_t const &" + +ida_tryblks.tryblks_t.begin(self, *args) -> "qvector< tryblk_t >::const_iterator" + +ida_tryblks.tryblks_t.capacity(self) -> "size_t" + +ida_tryblks.tryblks_t.clear(self) -> None + +ida_tryblks.tryblks_t.empty(self) -> bool + +ida_tryblks.tryblks_t.end(self, *args) -> "qvector< tryblk_t >::const_iterator" + +ida_tryblks.tryblks_t.erase(self, *args) -> "qvector< tryblk_t >::iterator" + +ida_tryblks.tryblks_t.extend(self, x: "tryblks_t") -> None + +ida_tryblks.tryblks_t.extract(self) -> "tryblk_t *" + +ida_tryblks.tryblks_t.find(self, *args) -> "qvector< tryblk_t >::const_iterator" + +ida_tryblks.tryblks_t.grow(self, *args) -> None + +ida_tryblks.tryblks_t.has(self, x: "tryblk_t") -> bool + +ida_tryblks.tryblks_t.inject(self, s: "tryblk_t", len: "size_t") -> None + +ida_tryblks.tryblks_t.insert(self, it: "tryblk_t", x: "tryblk_t") -> "qvector< tryblk_t >::iterator" + +ida_tryblks.tryblks_t.pop_back(self) -> None + +ida_tryblks.tryblks_t.push_back(self, *args) -> "tryblk_t &" + +ida_tryblks.tryblks_t.qclear(self) -> None + +ida_tryblks.tryblks_t.reserve(self, cnt: "size_t") -> None + +ida_tryblks.tryblks_t.resize(self, *args) -> None + +ida_tryblks.tryblks_t.size(self) -> "size_t" + +ida_tryblks.tryblks_t.swap(self, r: "tryblks_t") -> None + +ida_tryblks.tryblks_t.truncate(self) -> None + +ida_typeinf + Type information in IDA. - @param tb: (C++: const tryblk_t &) try block to add. - @return: error code; 0 means good - -ida_tryblks.catch_t (class) - Proxy of C++ catch_t class. - -ida_tryblks.catch_t.__init__ (method) - __init__(self) -> catch_t - -ida_tryblks.catchvec_t (class) - Proxy of C++ qvector< catch_t > class. - -ida_tryblks.catchvec_t.__eq__ (method) - __eq__(self, r) -> bool + In IDA, types are represented by and manipulated through tinfo_t objects. + A tinfo_t can represent a simple type (e.g., `int`, `float`), a complex type (a structure, enum, union, typedef), or even an array, or a function prototype. + The key types in this file are: - @param r: qvector< catch_t > const & - -ida_tryblks.catchvec_t.__getitem__ (method) - __getitem__(self, i) -> catch_t + * til_t - a type info library. Holds type information in serialized form. + * tinfo_t - information about a type (simple, complex, ...) - @param i: size_t - -ida_tryblks.catchvec_t.__init__ (method) - __init__(self) -> catchvec_t - __init__(self, x) -> catchvec_t - @param x: qvector< catch_t > const & - -ida_tryblks.catchvec_t.__len__ (method) - __len__(self) -> size_t - -ida_tryblks.catchvec_t.__ne__ (method) - __ne__(self, r) -> bool + # Glossary + All throughout this file, there are certain terms that will keep appearing: - @param r: qvector< catch_t > const & - -ida_tryblks.catchvec_t.__setitem__ (method) - __setitem__(self, i, v) + * udt: "user-defined type": a structure or union - but not enums. See udt_type_data_t + * udm: "udt member": i.e., a structure or union member. See udm_t + * edm: "enum member": i.e., an enumeration member - i.e., an enumerator. See edm_t - @param i: size_t - @param v: catch_t const & - -ida_tryblks.catchvec_t._del (method) - _del(self, x) -> bool - Parameters - ---------- - x: catch_t const & - -ida_tryblks.catchvec_t.add_unique (method) - add_unique(self, x) -> bool + # Under the hood + The tinfo_t type provides a lot of useful methods already, but it's possible to achieve even more by retrieving its contents into the container classes: - @param x: catch_t const & - -ida_tryblks.catchvec_t.at (method) - at(self, _idx) -> catch_t + * udt_type_data_t - for structures & unions. See tinfo_t::get_udt_details . Essentially, a vector of udm_t + * enum_type_data_t - for enumerations. See tinfo_t::get_enum_details . Essentially, a vector of edm_t + * ptr_type_data_t - for pointers. See tinfo_t::get_ptr_details + * array_type_data_t - for arrays. See tinfo_t::get_array_details + * func_type_data_t - for function prototypes. See tinfo_t::get_func_details + * bitfield_type_data_t - for bitfields. See tinfo_t::get_bitfield_details - @param _idx: size_t - -ida_tryblks.catchvec_t.begin (method) - begin(self) -> catch_t - -ida_tryblks.catchvec_t.capacity (method) - capacity(self) -> size_t - -ida_tryblks.catchvec_t.clear (method) - clear(self) - -ida_tryblks.catchvec_t.empty (method) - empty(self) -> bool - -ida_tryblks.catchvec_t.end (method) - end(self) -> catch_t - -ida_tryblks.catchvec_t.erase (method) - erase(self, it) -> catch_t - @param it: qvector< catch_t >::iterator - - erase(self, first, last) -> catch_t - - @param first: qvector< catch_t >::iterator - @param last: qvector< catch_t >::iterator - -ida_tryblks.catchvec_t.extract (method) - extract(self) -> catch_t - -ida_tryblks.catchvec_t.find (method) - find(self, x) -> catch_t - - @param x: catch_t const & - -ida_tryblks.catchvec_t.grow (method) - grow(self, x=catch_t()) - - @param x: catch_t const & - -ida_tryblks.catchvec_t.has (method) - has(self, x) -> bool - - @param x: catch_t const & - -ida_tryblks.catchvec_t.inject (method) - inject(self, s, len) - - @param s: catch_t * - @param len: size_t - -ida_tryblks.catchvec_t.insert (method) - insert(self, it, x) -> catch_t - - @param it: qvector< catch_t >::iterator - @param x: catch_t const & - -ida_tryblks.catchvec_t.pop_back (method) - pop_back(self) - -ida_tryblks.catchvec_t.push_back (method) - push_back(self, x) - - @param x: catch_t const & - - push_back(self) -> catch_t - -ida_tryblks.catchvec_t.qclear (method) - qclear(self) - -ida_tryblks.catchvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_tryblks.catchvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: catch_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_tryblks.catchvec_t.size (method) - size(self) -> size_t - -ida_tryblks.catchvec_t.swap (method) - swap(self, r) - - @param r: qvector< catch_t > & - -ida_tryblks.catchvec_t.truncate (method) - truncate(self) - -ida_tryblks.del_tryblks (function) - del_tryblks(range) - Delete try block information in the specified range. - - @param range: (C++: const range_t &) the range to be cleared - -ida_tryblks.find_syseh (function) - find_syseh(ea) -> ea_t - Find the start address of the system eh region including the argument. - - @param ea: (C++: ea_t) search address - @return: start address of surrounding tryblk, otherwise BADADDR - -ida_tryblks.get_tryblks (function) - get_tryblks(tbv, range) -> size_t - Retrieve try block information from the specified address range. Try blocks are - sorted by starting address and their nest levels calculated. - - @param tbv: (C++: tryblks_t *) output buffer; may be nullptr - @param range: (C++: const range_t &) address range to change - @return: number of found try blocks - -ida_tryblks.is_ea_tryblks (function) - is_ea_tryblks(ea, flags) -> bool - Check if the given address ea is part of tryblks description. - - @param ea: (C++: ea_t) address to check - @param flags: (C++: uint32) combination of flags for is_ea_tryblks() - -ida_tryblks.seh_t (class) - Proxy of C++ seh_t class. - -ida_tryblks.seh_t.__init__ (method) - __init__(self) -> seh_t - -ida_tryblks.seh_t.clear (method) - clear(self) - -ida_tryblks.try_handler_t (class) - Proxy of C++ try_handler_t class. - -ida_tryblks.try_handler_t.__init__ (method) - __init__(self) -> try_handler_t - -ida_tryblks.try_handler_t.clear (method) - clear(self) - -ida_tryblks.tryblk_t (class) - Proxy of C++ tryblk_t class. - -ida_tryblks.tryblk_t.__init__ (method) - __init__(self) -> tryblk_t - __init__(self, r) -> tryblk_t - - @param r: tryblk_t const & - -ida_tryblks.tryblk_t.clear (method) - clear(self) - -ida_tryblks.tryblk_t.cpp (method) - cpp(self) -> catchvec_t - -ida_tryblks.tryblk_t.empty (method) - empty(self) -> bool - -ida_tryblks.tryblk_t.get_kind (method) - get_kind(self) -> uchar - -ida_tryblks.tryblk_t.is_cpp (method) - is_cpp(self) -> bool - -ida_tryblks.tryblk_t.is_seh (method) - is_seh(self) -> bool - -ida_tryblks.tryblk_t.seh (method) - seh(self) -> seh_t - -ida_tryblks.tryblk_t.set_cpp (method) - set_cpp(self) -> catchvec_t - -ida_tryblks.tryblk_t.set_seh (method) - set_seh(self) -> seh_t - -ida_tryblks.tryblks_t (class) - Proxy of C++ qvector< tryblk_t > class. - -ida_tryblks.tryblks_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< tryblk_t > const & - -ida_tryblks.tryblks_t.__getitem__ (method) - __getitem__(self, i) -> tryblk_t - - @param i: size_t - -ida_tryblks.tryblks_t.__init__ (method) - __init__(self) -> tryblks_t - __init__(self, x) -> tryblks_t - - @param x: qvector< tryblk_t > const & - -ida_tryblks.tryblks_t.__len__ (method) - __len__(self) -> size_t - -ida_tryblks.tryblks_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< tryblk_t > const & - -ida_tryblks.tryblks_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: tryblk_t const & - -ida_tryblks.tryblks_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: tryblk_t const & - -ida_tryblks.tryblks_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.at (method) - at(self, _idx) -> tryblk_t - - @param _idx: size_t - -ida_tryblks.tryblks_t.begin (method) - begin(self) -> tryblk_t - -ida_tryblks.tryblks_t.capacity (method) - capacity(self) -> size_t - -ida_tryblks.tryblks_t.clear (method) - clear(self) - -ida_tryblks.tryblks_t.empty (method) - empty(self) -> bool - -ida_tryblks.tryblks_t.end (method) - end(self) -> tryblk_t - -ida_tryblks.tryblks_t.erase (method) - erase(self, it) -> tryblk_t - - @param it: qvector< tryblk_t >::iterator - - erase(self, first, last) -> tryblk_t - - @param first: qvector< tryblk_t >::iterator - @param last: qvector< tryblk_t >::iterator - -ida_tryblks.tryblks_t.extract (method) - extract(self) -> tryblk_t - -ida_tryblks.tryblks_t.find (method) - find(self, x) -> tryblk_t - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.grow (method) - grow(self, x=tryblk_t()) - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.has (method) - has(self, x) -> bool - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.inject (method) - inject(self, s, len) - - @param s: tryblk_t * - @param len: size_t - -ida_tryblks.tryblks_t.insert (method) - insert(self, it, x) -> tryblk_t - - @param it: qvector< tryblk_t >::iterator - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.pop_back (method) - pop_back(self) - -ida_tryblks.tryblks_t.push_back (method) - push_back(self, x) - - @param x: tryblk_t const & - - push_back(self) -> tryblk_t - -ida_tryblks.tryblks_t.qclear (method) - qclear(self) - -ida_tryblks.tryblks_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_tryblks.tryblks_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: tryblk_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_tryblks.tryblks_t.size (method) - size(self) -> size_t - -ida_tryblks.tryblks_t.swap (method) - swap(self, r) - - @param r: qvector< tryblk_t > & - -ida_tryblks.tryblks_t.truncate (method) - truncate(self) - -ida_typeinf (module) - Describes the type information records in IDA. - - The recommended way of using type info is to use the tinfo_t class. The type - information is internally kept as an array of bytes terminated by 0. - - Items in brackets [] are optional and sometimes are omitted. type_t... means a - sequence of type_t bytes which defines a type. - - @note: to work with the types of instructions or data in the database, use - get_tinfo()/set_tinfo() and similar functions. - -ida_typeinf.ADDTIL_ABORTED (variable) + # Attached & detached tinfo_t objects + tinfo_t objects can be attached to a til_t library, or can be created without using any til_t. + Here is an example, assigning a function prototype: + func_type_data_t func_info; + funcarg_t argc; argc.name = "argc"; argc.type = tinfo_t(BT_INT); func_info.push_back(argc); + funcarg_t argv; argc.name = "argv"; argc.type = tinfo_t("const char **"); func_info.push_back(argv) + tinfo_t tif; if ( tif.create_func(func_info) ) { ea_t ea = // get address of "main" apply_tinfo(ea, tif, TINFO_DEFINITE); } + This code manipulates a "detached" tinfo_t object, which does not depend on any til_t file. However, any complex type will require a til_t file. In IDA, there is always a default til_t file for each idb file. This til_t file can be specified by nullptr. + On the other hand, the following code manipulates an "attached" tinfo_t object, and any operation that modifies it, will also modify it in the hosting til_t: + tinfo_t tif; Load type from the "Local Types" til_t. Note: we could have used `get_idati()` instead of nullptr if ( tif.get_named_type(nullptr, "my_struct_t") ) tif.add_udm("extra_field", "unsigned long long"); + You can check if a tinfo_t instance is attached to a type in a til_t file by calling tinfo_t::is_typeref + + +ida_typeinf.ADDTIL_ABORTED til was not loaded (incompatible til rejected by user) -ida_typeinf.ADDTIL_COMP (variable) +ida_typeinf.ADDTIL_COMP ok, but til is not compatible with the current compiler -ida_typeinf.ADDTIL_DEFAULT (variable) +ida_typeinf.ADDTIL_DEFAULT default behavior -ida_typeinf.ADDTIL_FAILED (variable) +ida_typeinf.ADDTIL_FAILED something bad, the warning is displayed -ida_typeinf.ADDTIL_INCOMP (variable) +ida_typeinf.ADDTIL_INCOMP load incompatible tils -ida_typeinf.ADDTIL_OK (variable) +ida_typeinf.ADDTIL_OK ok, til is loaded -ida_typeinf.ADDTIL_SILENT (variable) +ida_typeinf.ADDTIL_SILENT do not ask any questions -ida_typeinf.ALOC_CUSTOM (variable) +ida_typeinf.ALOC_CUSTOM custom argloc (7 or higher) -ida_typeinf.ALOC_DIST (variable) +ida_typeinf.ALOC_DIST distributed (scattered) -ida_typeinf.ALOC_NONE (variable) +ida_typeinf.ALOC_NONE none -ida_typeinf.ALOC_REG1 (variable) +ida_typeinf.ALOC_REG1 one register (and offset within it) -ida_typeinf.ALOC_REG2 (variable) +ida_typeinf.ALOC_REG2 register pair -ida_typeinf.ALOC_RREL (variable) +ida_typeinf.ALOC_RREL register relative -ida_typeinf.ALOC_STACK (variable) +ida_typeinf.ALOC_STACK stack offset -ida_typeinf.ALOC_STATIC (variable) +ida_typeinf.ALOC_STATIC global address -ida_typeinf.ARGREGS_BY_SLOTS (variable) +ida_typeinf.ARGREGS_BY_SLOTS fixed FP/GP register per each slot (like vc64) -ida_typeinf.ARGREGS_FP_CONSUME_GP (variable) +ida_typeinf.ARGREGS_FP_MASKS_GP FP register also consumes one or more GP regs but not vice versa (aix ppc ABI) -ida_typeinf.ARGREGS_GP_ONLY (variable) +ida_typeinf.ARGREGS_GP_ONLY GP registers used for all arguments. -ida_typeinf.ARGREGS_INDEPENDENT (variable) +ida_typeinf.ARGREGS_INDEPENDENT FP/GP registers used separately (like gcc64) -ida_typeinf.ARGREGS_MIPS_O32 (variable) +ida_typeinf.ARGREGS_MIPS_O32 MIPS ABI o32. -ida_typeinf.BADSIZE (variable) +ida_typeinf.ARGREGS_RISCV + Risc-V API FP arguments are passed in GP registers if FP registers are exhausted and GP ones are not. Wide FP arguments are passed in GP registers. Variadic FP arguments are passed in GP registers. + + +ida_typeinf.BADSIZE bad type size -ida_typeinf.BFA_FUNC_EXT_FORMAT (variable) +ida_typeinf.BFA_FUNC_EXT_FORMAT This is NOT a real attribute (used internally as marker for extended format) -ida_typeinf.BFA_FUNC_MARKER (variable) +ida_typeinf.BFA_FUNC_MARKER This is NOT a cc! (used internally as a marker) -ida_typeinf.BFA_HIGH (variable) +ida_typeinf.BFA_HIGH high level prototype (with possibly hidden args) -ida_typeinf.BFA_NORET (variable) +ida_typeinf.BFA_NORET __noreturn -ida_typeinf.BFA_PURE (variable) +ida_typeinf.BFA_PURE __pure -ida_typeinf.BFA_STATIC (variable) +ida_typeinf.BFA_STATIC static -ida_typeinf.BFA_VIRTUAL (variable) +ida_typeinf.BFA_VIRTUAL virtual -ida_typeinf.BTE_ALWAYS (variable) +ida_typeinf.BTE_ALWAYS this bit MUST be present -ida_typeinf.BTE_BITMASK (variable) +ida_typeinf.BTE_BITMASK 'subarrays'. In this case ANY record has the following format: * 'de' mask (has name) * 'dt' cnt * cnt records of 'de' values (cnt CAN be 0) - @note: delta for ALL subsegment is ONE -ida_typeinf.BTE_CHAR (variable) +ida_typeinf.BTE_CHAR char or hex -ida_typeinf.BTE_HEX (variable) +ida_typeinf.BTE_HEX hex -ida_typeinf.BTE_OUT_MASK (variable) +ida_typeinf.BTE_OUT_MASK output style mask -ida_typeinf.BTE_RESERVED (variable) - must be 0, in order to distinguish from a tah-byte +ida_typeinf.BTE_RESERVED + must be 0, in order to distinguish from a tah-byte + -ida_typeinf.BTE_SDEC (variable) +ida_typeinf.BTE_SDEC signed decimal -ida_typeinf.BTE_SIZE_MASK (variable) +ida_typeinf.BTE_SIZE_MASK storage size. * if == 0 then inf_get_cc_size_e() * else 1 << (n -1) = 1,2,4,8 - * n == 5,6,7 are reserved + * n == 5,6,7 are reserved + + + -ida_typeinf.BTE_UDEC (variable) +ida_typeinf.BTE_UDEC unsigned decimal -ida_typeinf.BTF_BOOL (variable) +ida_typeinf.BTF_BOOL boolean -ida_typeinf.BTF_BYTE (variable) +ida_typeinf.BTF_BYTE byte -ida_typeinf.BTF_CHAR (variable) +ida_typeinf.BTF_CHAR signed char -ida_typeinf.BTF_DOUBLE (variable) +ida_typeinf.BTF_DOUBLE double -ida_typeinf.BTF_ENUM (variable) +ida_typeinf.BTF_ENUM enum -ida_typeinf.BTF_FLOAT (variable) +ida_typeinf.BTF_FLOAT float -ida_typeinf.BTF_INT (variable) +ida_typeinf.BTF_INT int, unknown signedness -ida_typeinf.BTF_INT128 (variable) +ida_typeinf.BTF_INT128 signed 128-bit value -ida_typeinf.BTF_INT16 (variable) +ida_typeinf.BTF_INT16 signed short -ida_typeinf.BTF_INT32 (variable) +ida_typeinf.BTF_INT32 signed int -ida_typeinf.BTF_INT64 (variable) +ida_typeinf.BTF_INT64 signed long -ida_typeinf.BTF_INT8 (variable) +ida_typeinf.BTF_INT8 signed byte -ida_typeinf.BTF_LDOUBLE (variable) +ida_typeinf.BTF_LDOUBLE long double -ida_typeinf.BTF_SINT (variable) +ida_typeinf.BTF_SINT singed int -ida_typeinf.BTF_STRUCT (variable) +ida_typeinf.BTF_STRUCT struct -ida_typeinf.BTF_TBYTE (variable) +ida_typeinf.BTF_TBYTE see BTMT_SPECFLT -ida_typeinf.BTF_TYPEDEF (variable) +ida_typeinf.BTF_TYPEDEF typedef -ida_typeinf.BTF_UCHAR (variable) +ida_typeinf.BTF_UCHAR unsigned char -ida_typeinf.BTF_UINT (variable) +ida_typeinf.BTF_UINT unsigned int -ida_typeinf.BTF_UINT128 (variable) +ida_typeinf.BTF_UINT128 unsigned 128-bit value -ida_typeinf.BTF_UINT16 (variable) +ida_typeinf.BTF_UINT16 unsigned short -ida_typeinf.BTF_UINT32 (variable) +ida_typeinf.BTF_UINT32 unsigned int -ida_typeinf.BTF_UINT64 (variable) +ida_typeinf.BTF_UINT64 unsigned long -ida_typeinf.BTF_UINT8 (variable) +ida_typeinf.BTF_UINT8 unsigned byte -ida_typeinf.BTF_UNION (variable) +ida_typeinf.BTF_UNION union -ida_typeinf.BTF_UNK (variable) +ida_typeinf.BTF_UNK unknown -ida_typeinf.BTF_VOID (variable) +ida_typeinf.BTF_VOID void -ida_typeinf.BTMT_ARRESERV (variable) +ida_typeinf.BTMT_ARRESERV reserved bit -ida_typeinf.BTMT_BFLDI16 (variable) +ida_typeinf.BTMT_BFLDI16 __int16 -ida_typeinf.BTMT_BFLDI32 (variable) +ida_typeinf.BTMT_BFLDI32 __int32 -ida_typeinf.BTMT_BFLDI64 (variable) +ida_typeinf.BTMT_BFLDI64 __int64 -ida_typeinf.BTMT_BFLDI8 (variable) +ida_typeinf.BTMT_BFLDI8 __int8 -ida_typeinf.BTMT_BOOL1 (variable) +ida_typeinf.BTMT_BOOL1 size 1byte -ida_typeinf.BTMT_BOOL2 (variable) +ida_typeinf.BTMT_BOOL2 size 2bytes - !inf_is_64bit() -ida_typeinf.BTMT_BOOL4 (variable) +ida_typeinf.BTMT_BOOL4 size 4bytes -ida_typeinf.BTMT_BOOL8 (variable) +ida_typeinf.BTMT_BOOL8 size 8bytes - inf_is_64bit() -ida_typeinf.BTMT_CHAR (variable) +ida_typeinf.BTMT_CHAR specify char or segment register * BT_INT8 - char * BT_INT - segment register - * other BT_INT... - don't use + * other BT_INT... - don't use + + + -ida_typeinf.BTMT_CLOSURE (variable) +ida_typeinf.BTMT_CLOSURE closure. - * if ptr to BT_FUNC - __closure. in this case next byte MUST be RESERVED_BYTE, - and after it BT_FUNC + * if ptr to BT_FUNC - __closure. in this case next byte MUST be RESERVED_BYTE, and after it BT_FUNC * else the next byte contains sizeof(ptr) allowed values are 1 - ph.max_ptr_size - * if value is bigger than ph.max_ptr_size, based_ptr_name_and_size() is called - to find out the typeinfo + * if value is bigger than ph.max_ptr_size, based_ptr_name_and_size() is called to find out the typeinfo + + + -ida_typeinf.BTMT_DEFBOOL (variable) +ida_typeinf.BTMT_DEFBOOL size is model specific or unknown(?) -ida_typeinf.BTMT_DEFCALL (variable) +ida_typeinf.BTMT_DEFCALL call method - default for model or unknown -ida_typeinf.BTMT_DEFPTR (variable) +ida_typeinf.BTMT_DEFPTR default for model -ida_typeinf.BTMT_DOUBLE (variable) +ida_typeinf.BTMT_DOUBLE double (8 bytes) -ida_typeinf.BTMT_FAR (variable) +ida_typeinf.BTMT_ENUM + enum: next byte bte_t (see below) N records: de delta(s) OR blocks (see below) + + +ida_typeinf.BTMT_FAR far -ida_typeinf.BTMT_FARCALL (variable) +ida_typeinf.BTMT_FARCALL function returns by retf -ida_typeinf.BTMT_FLOAT (variable) +ida_typeinf.BTMT_FLOAT float (4 bytes) -ida_typeinf.BTMT_INTCALL (variable) - function returns by iret in this case cc MUST be 'unknown' +ida_typeinf.BTMT_INTCALL + function returns by iret in this case cc MUST be 'unknown' + -ida_typeinf.BTMT_LNGDBL (variable) +ida_typeinf.BTMT_LNGDBL long double (compiler specific) -ida_typeinf.BTMT_NEAR (variable) +ida_typeinf.BTMT_NEAR near -ida_typeinf.BTMT_NEARCALL (variable) +ida_typeinf.BTMT_NEARCALL function returns by retn -ida_typeinf.BTMT_NONBASED (variable) - if set - array base==0 - format: dt num_elem; [tah-typeattrs]; type_t... - if num_elem==0 then the array size is unknown - else - format: da num_elem, base; [tah-typeattrs]; type_t... - used only for serialization +ida_typeinf.BTMT_NONBASED + set + array base==0 + format: dt num_elem; [tah-typeattrs]; type_t... + if num_elem==0 then the array size is unknown + + format: da num_elem, base; [tah-typeattrs]; type_t... + + + -ida_typeinf.BTMT_SIGNED (variable) +ida_typeinf.BTMT_SIGNED signed -ida_typeinf.BTMT_SIZE0 (variable) +ida_typeinf.BTMT_SIZE0 BT_VOID - normal void; BT_UNK - don't use -ida_typeinf.BTMT_SIZE12 (variable) +ida_typeinf.BTMT_SIZE12 size = 1 byte if BT_VOID; 2 if BT_UNK -ida_typeinf.BTMT_SIZE128 (variable) - size = 16 bytes if BT_VOID; unknown if BT_UNK (IN struct alignment - see below) +ida_typeinf.BTMT_SIZE128 + size = 16 bytes if BT_VOID; unknown if BT_UNK (IN struct alignment - see below) + -ida_typeinf.BTMT_SIZE48 (variable) +ida_typeinf.BTMT_SIZE48 size = 4 bytes if BT_VOID; 8 if BT_UNK -ida_typeinf.BTMT_SPECFLT (variable) - float (variable size). if processor_t::use_tbyte() then use - processor_t::tbyte_size, otherwise 2 bytes +ida_typeinf.BTMT_SPECFLT + float (variable size). if processor_t::use_tbyte() then use processor_t::tbyte_size, otherwise 2 bytes + -ida_typeinf.BTMT_TYPEDEF (variable) - named reference always p_string name +ida_typeinf.BTMT_STRUCT + struct: MCNT records: type_t; [sdacl-typeattrs]; + -ida_typeinf.BTMT_UNKSIGN (variable) +ida_typeinf.BTMT_TYPEDEF + named reference always p_string name + + +ida_typeinf.BTMT_UNION + union: MCNT records: type_t... + + +ida_typeinf.BTMT_UNKSIGN unknown signedness -ida_typeinf.BTMT_USIGNED (variable) +ida_typeinf.BTMT_USIGNED unsigned -ida_typeinf.BTM_CONST (variable) +ida_typeinf.BTM_CONST const -ida_typeinf.BTM_VOLATILE (variable) +ida_typeinf.BTM_VOLATILE volatile -ida_typeinf.BT_ARRAY (variable) +ida_typeinf.BT_ARRAY array -ida_typeinf.BT_BITFIELD (variable) - bitfield (only in struct) ['bitmasked' enum see below] next byte is dt ((size in - bits << 1) | (unsigned ? 1 : 0)) +ida_typeinf.BT_BITFIELD + bitfield (only in struct) ['bitmasked' enum see below] next byte is dt ((size in bits << 1) | (unsigned ? 1 : 0)) + -ida_typeinf.BT_BOOL (variable) +ida_typeinf.BT_BOOL bool -ida_typeinf.BT_COMPLEX (variable) - struct/union/enum/typedef. format: +ida_typeinf.BT_COMPLEX + struct/union/enum/typedef. format: [dt N (N=field count) if !BTMT_TYPEDEF] - if N == 0: - p_string name (unnamed types have names "anon_...") - [sdacl-typeattrs]; - else, for struct & union: - if N == 0x7FFE // Support for high (i.e., > 4095) members count - N = deserialize_de() - ALPOW = N & 0x7 - MCNT = N >> 3 - if MCNT == 0 - empty struct - if ALPOW == 0 - ALIGN = get_default_align() - else - ALIGN = (1 << (ALPOW - 1)) - [sdacl-typeattrs]; - else, for enums: - if N == 0x7FFE // Support for high enum entries count. - N = deserialize_de() - [tah-typeattrs]; + if N == 0: + p_string name (unnamed types have names "anon_...") + [sdacl-typeattrs]; + else, for struct & union: + if N == 0x7FFE // Support for high (i.e., > 4095) members count + N = deserialize_de() + ALPOW = N & 0x7 + MCNT = N >> 3 + if MCNT == 0 + empty struct + if ALPOW == 0 + ALIGN = get_default_align() + else + ALIGN = (1 << (ALPOW - 1)) + [sdacl-typeattrs]; + else, for enums: + if N == 0x7FFE // Support for high enum entries count. + N = deserialize_de() + [tah-typeattrs]; + -ida_typeinf.BT_FLOAT (variable) +ida_typeinf.BT_FLOAT float -ida_typeinf.BT_FUNC (variable) - function. format: +ida_typeinf.BT_FUNC + function. format: optional: CM_CC_SPOILED | num_of_spoiled_regs - if num_of_spoiled_reg == BFA_FUNC_MARKER: - ::bfa_byte - if (bfa_byte & BFA_FUNC_EXT_FORMAT) != 0 - ::fti_bits (only low bits: FTI_SPOILED,...,FTI_VIRTUAL) - num_of_spoiled_reg times: spoiled reg info (see - extract_spoiledreg) - else - bfa_byte is function attribute byte (see Function attribute - byte...) - else: - num_of_spoiled_reg times: spoiled reg info (see - extract_spoiledreg) - cm_t ... calling convention and memory model - [tah-typeattrs]; - type_t ... return type; - [serialized argloc_t of returned value (if CM_CC_SPECIAL{PE} && !return - void); - if !CM_CC_VOIDARG: - dt N (N=number of parameters) - if ( N == 0 ) - if CM_CC_ELLIPSIS or CM_CC_SPECIALE - func(...) - else - parameters are unknown - else - N records: - type_t ... (i.e. type of each parameter) - [serialized argloc_t (if CM_CC_SPECIAL{PE})] (i.e. place of each - parameter) - [FAH_BYTE + de( funcarg_t::flags )] + if num_of_spoiled_reg == BFA_FUNC_MARKER: + ::bfa_byte + if (bfa_byte & BFA_FUNC_EXT_FORMAT) != 0 + ::fti_bits (only low bits: FTI_SPOILED,...,FTI_VIRTUAL) + num_of_spoiled_reg times: spoiled reg info (see extract_spoiledreg) + else + bfa_byte is function attribute byte (see Function attribute byte...) + else: + num_of_spoiled_reg times: spoiled reg info (see extract_spoiledreg) + cm_t ... calling convention and memory model + [tah-typeattrs]; + type_t ... return type; + [serialized argloc_t of returned value (if CM_CC_SPECIAL{PE} && !return void); + if !CM_CC_VOIDARG: + dt N (N=number of parameters) + if ( N == 0 ) + if CM_CC_ELLIPSIS or CM_CC_SPECIALE + func(...) + else + parameters are unknown + else + N records: + type_t ... (i.e. type of each parameter) + [serialized argloc_t (if CM_CC_SPECIAL{PE})] (i.e. place of each parameter) + [FAH_BYTE + de( funcarg_t::flags )] + -ida_typeinf.BT_INT (variable) +ida_typeinf.BT_INT natural int. (size provided by idp module) -ida_typeinf.BT_INT128 (variable) +ida_typeinf.BT_INT128 __int128 (for alpha & future use) -ida_typeinf.BT_INT16 (variable) +ida_typeinf.BT_INT16 __int16 -ida_typeinf.BT_INT32 (variable) +ida_typeinf.BT_INT32 __int32 -ida_typeinf.BT_INT64 (variable) +ida_typeinf.BT_INT64 __int64 -ida_typeinf.BT_INT8 (variable) +ida_typeinf.BT_INT8 __int8 -ida_typeinf.BT_PTR (variable) - pointer. has the following format: [db sizeof(ptr)]; [tah-typeattrs]; type_t... +ida_typeinf.BT_PTR + pointer. has the following format: [db sizeof(ptr)]; [tah-typeattrs]; type_t... + -ida_typeinf.BT_RESERVED (variable) +ida_typeinf.BT_RESERVED RESERVED. -ida_typeinf.BT_SEGREG (variable) +ida_typeinf.BT_SEGREG segment register -ida_typeinf.BT_UNK (variable) +ida_typeinf.BT_UNK unknown -ida_typeinf.BT_UNKNOWN (variable) +ida_typeinf.BT_UNKNOWN unknown size - for parameters -ida_typeinf.BT_UNK_BYTE (variable) +ida_typeinf.BT_UNK_BYTE 1 byte -ida_typeinf.BT_UNK_DWORD (variable) +ida_typeinf.BT_UNK_DWORD 4 bytes -ida_typeinf.BT_UNK_OWORD (variable) +ida_typeinf.BT_UNK_OWORD 16 bytes -ida_typeinf.BT_UNK_QWORD (variable) +ida_typeinf.BT_UNK_QWORD 8 bytes -ida_typeinf.BT_UNK_WORD (variable) +ida_typeinf.BT_UNK_WORD 2 bytes -ida_typeinf.BT_VOID (variable) +ida_typeinf.BT_VOID void -ida_typeinf.CC_ALLOW_ARGPERM (variable) +ida_typeinf.CC_ALLOW_ARGPERM disregard argument order? -ida_typeinf.CC_ALLOW_REGHOLES (variable) +ida_typeinf.CC_ALLOW_REGHOLES allow holes in register argument list? -ida_typeinf.CC_CDECL_OK (variable) +ida_typeinf.CC_CDECL_OK can use __cdecl calling convention? -ida_typeinf.CC_GOLANG_OK (variable) - can use __golang calling convention +ida_typeinf.CC_GOLANG_OK + can use __golang calling convention + -ida_typeinf.CC_HAS_ELLIPSIS (variable) +ida_typeinf.CC_HAS_ELLIPSIS function has a variable list of arguments? -ida_typeinf.CM_CC_CDECL (variable) +ida_typeinf.CM_CC_CDECL stack -ida_typeinf.CM_CC_ELLIPSIS (variable) +ida_typeinf.CM_CC_ELLIPSIS cdecl + ellipsis -ida_typeinf.CM_CC_FASTCALL (variable) +ida_typeinf.CM_CC_FASTCALL stack, purged (x86), first args are in regs (compiler-dependent) -ida_typeinf.CM_CC_GOLANG (variable) +ida_typeinf.CM_CC_GOLANG (Go) arguments and return value in stack -ida_typeinf.CM_CC_INVALID (variable) +ida_typeinf.CM_CC_INVALID this value is invalid -ida_typeinf.CM_CC_PASCAL (variable) +ida_typeinf.CM_CC_PASCAL stack, purged, reverse order of args -ida_typeinf.CM_CC_SPECIALE (variable) +ida_typeinf.CM_CC_SPECIAL + usercall: locations of all arguments and the return value are explicitly specified + + +ida_typeinf.CM_CC_SPECIALE CM_CC_SPECIAL with ellipsis -ida_typeinf.CM_CC_SPECIALP (variable) +ida_typeinf.CM_CC_SPECIALP Equal to CM_CC_SPECIAL, but with purged stack. -ida_typeinf.CM_CC_SPOILED (variable) - This is NOT a cc! Mark of __spoil record the low nibble is count and after n - {spoilreg_t} present real cm_t byte. if n == BFA_FUNC_MARKER, the next byte is - the function attribute byte. +ida_typeinf.CM_CC_SPOILED + This is NOT a cc! Mark of __spoil record the low nibble is count and after n {spoilreg_t} present real cm_t byte. if n == BFA_FUNC_MARKER, the next byte is the function attribute byte. + -ida_typeinf.CM_CC_STDCALL (variable) +ida_typeinf.CM_CC_STDCALL stack, purged -ida_typeinf.CM_CC_SWIFT (variable) +ida_typeinf.CM_CC_SWIFT (Swift) arguments and return values in registers (compiler-dependent) -ida_typeinf.CM_CC_THISCALL (variable) +ida_typeinf.CM_CC_THISCALL stack, purged (x86), first arg is in reg (compiler-dependent) -ida_typeinf.CM_CC_UNKNOWN (variable) +ida_typeinf.CM_CC_UNKNOWN unknown calling convention -ida_typeinf.CM_CC_VOIDARG (variable) - function without arguments if has other cc and argnum == 0, represent as f() - - unknown list +ida_typeinf.CM_CC_VOIDARG + function without arguments if has other cc and argnum == 0, represent as f() - unknown list + -ida_typeinf.CM_N16_F32 (variable) +ida_typeinf.CM_M_FF + large: code=far, data=far + +ida_typeinf.CM_M_FN + medium: code=far, data=near + +ida_typeinf.CM_M_NF + compact: code=near, data=far + +ida_typeinf.CM_M_NN + small: code=near, data=near (or unknown if CM_UNKNOWN) + +ida_typeinf.CM_N16_F32 near 2 bytes, far 4 bytes -ida_typeinf.CM_N32_F48 (variable) +ida_typeinf.CM_N32_F48 near 4 bytes, far 6 bytes -ida_typeinf.CM_N64 (variable) +ida_typeinf.CM_N64 if sizeof(int)>2: near 8 bytes, far 8 bytes -ida_typeinf.CM_N8_F16 (variable) +ida_typeinf.CM_N8_F16 if sizeof(int)<=2: near 1 byte, far 2 bytes -ida_typeinf.CM_UNKNOWN (variable) +ida_typeinf.CM_UNKNOWN unknown -ida_typeinf.COMP_BC (variable) +ida_typeinf.COMP_BC Borland C++. -ida_typeinf.COMP_BP (variable) +ida_typeinf.COMP_BP Delphi. -ida_typeinf.COMP_GNU (variable) +ida_typeinf.COMP_GNU GNU C++. -ida_typeinf.COMP_MS (variable) +ida_typeinf.COMP_MS Visual C++. -ida_typeinf.COMP_UNK (variable) +ida_typeinf.COMP_UNK Unknown. -ida_typeinf.COMP_UNSURE (variable) +ida_typeinf.COMP_UNSURE uncertain compiler id -ida_typeinf.COMP_VISAGE (variable) +ida_typeinf.COMP_VISAGE Visual Age C++. -ida_typeinf.COMP_WATCOM (variable) +ida_typeinf.COMP_WATCOM Watcom C++. -ida_typeinf.DEFMASK64 (variable) +ida_typeinf.DEFMASK64 default bitmask 64bits -ida_typeinf.ETF_ASMENUM (variable) - asm enum compatibility mode *- +ida_typeinf.ETF_AUTONAME + udm - generate a member name if was not specified (add_udm, set_udm_type) -ida_typeinf.ETF_AUTONAME (variable) - generate a member name if was not specified (add_udm, set_udm_type) +ida_typeinf.ETF_BYTIL + udm - new type was created by the type subsystem -ida_typeinf.ETF_COMPATIBLE (variable) +ida_typeinf.ETF_COMPATIBLE new type must be compatible with the old -ida_typeinf.ETF_FORCENAME (variable) +ida_typeinf.ETF_FORCENAME anyway use name, see below for more usage description -ida_typeinf.ETF_FUNCARG (variable) - mptr is function argument (cannot create arrays) +ida_typeinf.ETF_FUNCARG + udm - member is a function argument (cannot create arrays) -ida_typeinf.ETF_MAY_DESTROY (variable) +ida_typeinf.ETF_MAY_DESTROY may destroy other members -ida_typeinf.ETF_NO_IDBSYNC (variable) - do not sync type to IDB (udt only) *- +ida_typeinf.ETF_NO_ARRAY + add_udm, set_udm_type - do not convert type to an array on the size mismatch -ida_typeinf.ETF_NO_LAYOUT (variable) +ida_typeinf.ETF_NO_LAYOUT don't calc type layout before editing -ida_typeinf.ETF_NO_SAVE (variable) - don't save to til (normally typerefs are saved to til) A call with ETF_NO_SAVE - must be followed by a call without it. Otherwise there may be inconsistencies - between the memory and the type library. +ida_typeinf.ETF_NO_SAVE + don't save to til (normally typerefs are saved to til) A call with ETF_NO_SAVE must be followed by a call without it. Otherwise there may be inconsistencies between the memory and the type library. + -ida_typeinf.FAH_BYTE (variable) +ida_typeinf.FAH_BYTE function argument attribute header byte -ida_typeinf.FAI_ARRAY (variable) - was initially an array; see "__org_typedef" or "__org_arrdim" type attributes to - determine the original type +ida_typeinf.FAI_ARRAY + was initially an array; see "__org_typedef" or "__org_arrdim" type attributes to determine the original type + -ida_typeinf.FAI_HIDDEN (variable) +ida_typeinf.FAI_HIDDEN hidden argument -ida_typeinf.FAI_RETPTR (variable) +ida_typeinf.FAI_RETPTR pointer to return value. implies hidden -ida_typeinf.FAI_STRUCT (variable) +ida_typeinf.FAI_STRUCT was initially a structure -ida_typeinf.FAI_UNUSED (variable) +ida_typeinf.FAI_UNUSED argument is not used by the function -ida_typeinf.FIRST_NONTRIVIAL_TYPID (variable) +ida_typeinf.FIRST_NONTRIVIAL_TYPID Denotes the first bit describing a nontrivial type. -ida_typeinf.FRB_CHAR (variable) +ida_typeinf.FRB_CHAR Char. -ida_typeinf.FRB_CUSTOM (variable) +ida_typeinf.FRB_CUSTOM *Custom data type -ida_typeinf.FRB_ENUM (variable) +ida_typeinf.FRB_ENUM *Enumeration -ida_typeinf.FRB_FLOAT (variable) - Floating point number (for interpreting an integer type as a floating value) +ida_typeinf.FRB_FLOAT + Floating point number (for interpreting an integer type as a floating value) + -ida_typeinf.FRB_INVBITS (variable) +ida_typeinf.FRB_INVBITS Invert bits (0x01 is represented as ~0xFE) -ida_typeinf.FRB_INVSIGN (variable) +ida_typeinf.FRB_INVSIGN Invert sign (0x01 is represented as -0xFF) -ida_typeinf.FRB_LZERO (variable) +ida_typeinf.FRB_LZERO Toggle leading zeroes (used for integers) -ida_typeinf.FRB_MASK (variable) +ida_typeinf.FRB_MASK Mask for the value type (* means requires additional info): -ida_typeinf.FRB_NUMB (variable) +ida_typeinf.FRB_NUMB Binary number. -ida_typeinf.FRB_NUMD (variable) +ida_typeinf.FRB_NUMD Decimal number. -ida_typeinf.FRB_NUMH (variable) +ida_typeinf.FRB_NUMH Hexadecimal number. -ida_typeinf.FRB_NUMO (variable) +ida_typeinf.FRB_NUMO Octal number. -ida_typeinf.FRB_OFFSET (variable) +ida_typeinf.FRB_OFFSET *Offset -ida_typeinf.FRB_SEG (variable) +ida_typeinf.FRB_SEG Segment. -ida_typeinf.FRB_SIGNED (variable) +ida_typeinf.FRB_SIGNED Force signed representation. -ida_typeinf.FRB_STRLIT (variable) +ida_typeinf.FRB_STRLIT *String literal (used for arrays) -ida_typeinf.FRB_STROFF (variable) +ida_typeinf.FRB_STROFF *Struct offset -ida_typeinf.FRB_TABFORM (variable) - has additional tabular parameters +ida_typeinf.FRB_TABFORM + has additional tabular parameters + -ida_typeinf.FRB_UNK (variable) +ida_typeinf.FRB_UNK Unknown. -ida_typeinf.FTI_ALL (variable) +ida_typeinf.FTI_ALL all defined bits -ida_typeinf.FTI_ARGLOCS (variable) - info about argument locations has been calculated (stkargs and retloc too) +ida_typeinf.FTI_ARGLOCS + info about argument locations has been calculated (stkargs and retloc too) + -ida_typeinf.FTI_CALLTYPE (variable) +ida_typeinf.FTI_CALLTYPE mask for FTI_*CALL -ida_typeinf.FTI_CONST (variable) +ida_typeinf.FTI_CONST const member function -ida_typeinf.FTI_CTOR (variable) +ida_typeinf.FTI_CTOR constructor -ida_typeinf.FTI_DEFCALL (variable) +ida_typeinf.FTI_DEFCALL default call -ida_typeinf.FTI_DTOR (variable) +ida_typeinf.FTI_DTOR destructor -ida_typeinf.FTI_EXPLOCS (variable) +ida_typeinf.FTI_EXPLOCS all arglocs are specified explicitly -ida_typeinf.FTI_FARCALL (variable) +ida_typeinf.FTI_FARCALL far call -ida_typeinf.FTI_HIGH (variable) +ida_typeinf.FTI_HIGH high level prototype (with possibly hidden args) -ida_typeinf.FTI_INTCALL (variable) +ida_typeinf.FTI_INTCALL interrupt call -ida_typeinf.FTI_NEARCALL (variable) +ida_typeinf.FTI_NEARCALL near call -ida_typeinf.FTI_NORET (variable) +ida_typeinf.FTI_NORET noreturn -ida_typeinf.FTI_PURE (variable) +ida_typeinf.FTI_PURE __pure -ida_typeinf.FTI_SPOILED (variable) +ida_typeinf.FTI_SPOILED information about spoiled registers is present -ida_typeinf.FTI_STATIC (variable) +ida_typeinf.FTI_STATIC static -ida_typeinf.FTI_VIRTUAL (variable) +ida_typeinf.FTI_VIRTUAL virtual -ida_typeinf.GTD_CALC_ARGLOCS (variable) +ida_typeinf.GTD_CALC_ARGLOCS calculate func arg locations -ida_typeinf.GTD_CALC_LAYOUT (variable) +ida_typeinf.GTD_CALC_LAYOUT calculate udt layout -ida_typeinf.GTD_DEL_BITFLDS (variable) +ida_typeinf.GTD_DEL_BITFLDS delete udt bitfields -ida_typeinf.GTD_NO_ARGLOCS (variable) - don't calculate func arg locations please note that the locations may have been - calculated earlier +ida_typeinf.GTD_NO_ARGLOCS + don't calculate func arg locations please note that the locations may have been calculated earlier + -ida_typeinf.GTD_NO_LAYOUT (variable) - don't calculate udt layout please note that udt layout may have been calculated - earlier +ida_typeinf.GTD_NO_LAYOUT + don't calculate udt layout please note that udt layout may have been calculated earlier + -ida_typeinf.GTS_BASECLASS (variable) +ida_typeinf.GTS_BASECLASS is baseclass of a udt -ida_typeinf.GTS_NESTED (variable) +ida_typeinf.GTS_NESTED nested type (embedded into a udt) -ida_typeinf.GUESS_FUNC_FAILED (variable) +ida_typeinf.GUESS_FUNC_FAILED couldn't guess the function type -ida_typeinf.GUESS_FUNC_OK (variable) +ida_typeinf.GUESS_FUNC_OK ok, some non-trivial information is gathered -ida_typeinf.GUESS_FUNC_TRIVIAL (variable) +ida_typeinf.GUESS_FUNC_TRIVIAL the function type doesn't have interesting info -ida_typeinf.HTI_CPP (variable) +ida_typeinf.HTI_CPP C++ mode (not implemented) -ida_typeinf.HTI_DCL (variable) +ida_typeinf.HTI_DCL don't complain about redeclarations -ida_typeinf.HTI_FIL (variable) - "input" is file name, otherwise "input" contains a C declaration +ida_typeinf.HTI_EXT + debug: print external representation of types -ida_typeinf.HTI_HIGH (variable) - assume high level prototypes (with hidden args, etc) +ida_typeinf.HTI_FIL + "input" is file name, otherwise "input" contains a C declaration + -ida_typeinf.HTI_LOWER (variable) +ida_typeinf.HTI_HIGH + assume high level prototypes (with hidden args, etc) + + +ida_typeinf.HTI_INT + debug: print internal representation of types + +ida_typeinf.HTI_LEX + debug: print tokens + +ida_typeinf.HTI_LOWER lower the function prototypes -ida_typeinf.HTI_MAC (variable) +ida_typeinf.HTI_MAC define macros from the base tils -ida_typeinf.HTI_NDC (variable) +ida_typeinf.HTI_NDC don't decorate names -ida_typeinf.HTI_NER (variable) +ida_typeinf.HTI_NER ignore all errors but display them -ida_typeinf.HTI_NOBASE (variable) +ida_typeinf.HTI_NOBASE do not inspect base tils -ida_typeinf.HTI_NWR (variable) +ida_typeinf.HTI_NWR no warning messages -ida_typeinf.HTI_PAK (variable) +ida_typeinf.HTI_PAK explicit structure pack value (#pragma pack) -ida_typeinf.HTI_PAK1 (variable) +ida_typeinf.HTI_PAK1 #pragma pack(1) -ida_typeinf.HTI_PAK16 (variable) +ida_typeinf.HTI_PAK16 #pragma pack(16) -ida_typeinf.HTI_PAK2 (variable) +ida_typeinf.HTI_PAK2 #pragma pack(2) -ida_typeinf.HTI_PAK4 (variable) +ida_typeinf.HTI_PAK4 #pragma pack(4) -ida_typeinf.HTI_PAK8 (variable) +ida_typeinf.HTI_PAK8 #pragma pack(8) -ida_typeinf.HTI_PAKDEF (variable) +ida_typeinf.HTI_PAKDEF default pack value -ida_typeinf.HTI_PAK_SHIFT (variable) - shift for HTI_PAK. This field should be used if you want to remember an explicit - pack value for each structure/union type. See HTI_PAK... definitions +ida_typeinf.HTI_PAK_SHIFT + shift for HTI_PAK. This field should be used if you want to remember an explicit pack value for each structure/union type. See HTI_PAK... definitions + -ida_typeinf.HTI_RAWARGS (variable) +ida_typeinf.HTI_RAWARGS leave argument names unchanged (do not remove underscores) -ida_typeinf.HTI_RELAXED (variable) +ida_typeinf.HTI_RELAXED accept references to unknown namespaces -ida_typeinf.HTI_TST (variable) +ida_typeinf.HTI_SEMICOLON + do not complain if the terminated semicolon is absent + +ida_typeinf.HTI_TST test mode: discard the result -ida_typeinf.IMPTYPE_LOCAL (variable) - the type is local, the struct/enum won't be marked as til type. there is no need - to specify this bit if til==idati, the kernel will set it automatically +ida_typeinf.HTI_UNP + debug: check the result by unpacking it -ida_typeinf.MAX_FUNC_ARGS (variable) +ida_typeinf.MAX_ENUM_SERIAL + Max number of identical constants allowed for one enum type. + +ida_typeinf.MAX_FUNC_ARGS max number of function arguments -ida_typeinf.NTF_64BIT (variable) +ida_typeinf.NTF_64BIT value is 64bit -ida_typeinf.NTF_CHKSYNC (variable) - check that synchronization to IDB passed OK (set_numbered_type, set_named_type) +ida_typeinf.NTF_CHKSYNC + check that synchronization to IDB passed OK (set_numbered_type, set_named_type) + -ida_typeinf.NTF_COPY (variable) - save a new type definition, not a typeref (tinfo_t::set_numbered_type, - tinfo_t::set_named_type) +ida_typeinf.NTF_COPY + save a new type definition, not a typeref (tinfo_t::set_numbered_type, tinfo_t::set_named_type) -ida_typeinf.NTF_FIXNAME (variable) - force-validate the name of the type when setting (set_named_type, - set_numbered_type only) +ida_typeinf.NTF_FIXNAME + force-validate the name of the type when setting (set_named_type, set_numbered_type only) + -ida_typeinf.NTF_IDBENC (variable) - the name is given in the IDB encoding; non-ASCII bytes will be decoded - accordingly (set_named_type, set_numbered_type only) +ida_typeinf.NTF_IDBENC + the name is given in the IDB encoding; non-ASCII bytes will be decoded accordingly (set_named_type, set_numbered_type only) + -ida_typeinf.NTF_NOBASE (variable) +ida_typeinf.NTF_NOBASE don't inspect base tils (for get_named_type) -ida_typeinf.NTF_NOCUR (variable) +ida_typeinf.NTF_NOCUR don't inspect current til file (for get_named_type) -ida_typeinf.NTF_NO_NAMECHK (variable) - do not validate type name (set_numbered_type, set_named_type) +ida_typeinf.NTF_NO_NAMECHK + do not validate type name (set_numbered_type, set_named_type) + -ida_typeinf.NTF_REPLACE (variable) +ida_typeinf.NTF_REPLACE replace original type (for set_named_type) -ida_typeinf.NTF_SYMM (variable) - symbol, name is mangled ('_func'); only one of NTF_TYPE and NTF_SYMU, NTF_SYMM - can be used +ida_typeinf.NTF_SYMM + symbol, name is mangled ('_func'); only one of NTF_TYPE and NTF_SYMU, NTF_SYMM can be used + -ida_typeinf.NTF_SYMU (variable) +ida_typeinf.NTF_SYMU symbol, name is unmangled ('func') -ida_typeinf.NTF_TYPE (variable) +ida_typeinf.NTF_TYPE type name -ida_typeinf.NTF_UMANGLED (variable) +ida_typeinf.NTF_UMANGLED name is unmangled (don't use this flag) -ida_typeinf.PDF_DEF_BASE (variable) +ida_typeinf.PDF_DEF_BASE Include base types: __int8, __int16, etc.. -ida_typeinf.PDF_DEF_FWD (variable) +ida_typeinf.PDF_DEF_FWD Allow forward declarations. -ida_typeinf.PDF_HEADER_CMT (variable) +ida_typeinf.PDF_HEADER_CMT Prepend output with a descriptive comment. -ida_typeinf.PDF_INCL_DEPS (variable) +ida_typeinf.PDF_INCL_DEPS Include all type dependencies. -ida_typeinf.PIO_IGNORE_PTRS (variable) +ida_typeinf.PIO_IGNORE_PTRS do not follow pointers -ida_typeinf.PIO_NOATTR_FAIL (variable) +ida_typeinf.PIO_NOATTR_FAIL missing attributes are not ok -ida_typeinf.PRALOC_STKOFF (variable) +ida_typeinf.PRALOC_STKOFF print stack offsets -ida_typeinf.PRALOC_VERIFY (variable) +ida_typeinf.PRALOC_VERIFY interr if illegal argloc -ida_typeinf.PRTYPE_1LINCMT (variable) +ida_typeinf.PRTYPE_1LINCMT print comments even in the one line mode -ida_typeinf.PRTYPE_1LINE (variable) +ida_typeinf.PRTYPE_1LINE print to one line -ida_typeinf.PRTYPE_COLORED (variable) +ida_typeinf.PRTYPE_ARGLOCS + print function arglocs (not only for usercall) + +ida_typeinf.PRTYPE_COLORED add color tag COLOR_SYMBOL for any parentheses, commas and colons -ida_typeinf.PRTYPE_CPP (variable) +ida_typeinf.PRTYPE_CPP use c++ name (only for print_type()) -ida_typeinf.PRTYPE_HEADER (variable) +ida_typeinf.PRTYPE_DEF + tinfo_t: print definition, if available + +ida_typeinf.PRTYPE_HEADER print only type header (only for definitions) -ida_typeinf.PRTYPE_MAXSTR (variable) +ida_typeinf.PRTYPE_MAXSTR limit the output length to 1024 bytes (the output may be slightly longer) -ida_typeinf.PRTYPE_MULTI (variable) +ida_typeinf.PRTYPE_METHODS + tinfo_t: print udt methods + +ida_typeinf.PRTYPE_MULTI print to many lines -ida_typeinf.PRTYPE_NOREGEX (variable) +ida_typeinf.PRTYPE_NOARGS + tinfo_t: do not print function argument names + +ida_typeinf.PRTYPE_NOARRS + tinfo_t: print arguments with FAI_ARRAY as pointers + +ida_typeinf.PRTYPE_NOREGEX do not apply regular expressions to beautify name -ida_typeinf.PRTYPE_PRAGMA (variable) +ida_typeinf.PRTYPE_NORES + tinfo_t: never resolve types (meaningful with PRTYPE_DEF) + +ida_typeinf.PRTYPE_OFFSETS + print udt member offsets + +ida_typeinf.PRTYPE_PRAGMA print pragmas for alignment -ida_typeinf.PRTYPE_SEMI (variable) +ida_typeinf.PRTYPE_RESTORE + tinfo_t: print restored types for FAI_ARRAY and FAI_STRUCT + +ida_typeinf.PRTYPE_SEMI append ; to the end -ida_typeinf.PRTYPE_TYPE (variable) +ida_typeinf.PRTYPE_TAIL + print only the definition tail (only for definitions, exclusive with PRTYPE_HEADER) + +ida_typeinf.PRTYPE_TYPE print type declaration (not variable declaration) -ida_typeinf.PT_HIGH (variable) - assume high level prototypes (with hidden args, etc) +ida_typeinf.PT_EMPTY + accept empty decl -ida_typeinf.PT_LOWER (variable) +ida_typeinf.PT_HIGH + assume high level prototypes (with hidden args, etc) + + +ida_typeinf.PT_LOWER lower the function prototypes -ida_typeinf.PT_NDC (variable) +ida_typeinf.PT_NDC don't decorate names -ida_typeinf.PT_PACKMASK (variable) +ida_typeinf.PT_PACKMASK mask for pack alignment values -ida_typeinf.PT_RAWARGS (variable) +ida_typeinf.PT_RAWARGS leave argument names unchanged (do not remove underscores) -ida_typeinf.PT_RELAXED (variable) +ida_typeinf.PT_RELAXED accept references to unknown namespaces -ida_typeinf.PT_REPLACE (variable) +ida_typeinf.PT_REPLACE replace the old type (used in idc) -ida_typeinf.PT_SIL (variable) +ida_typeinf.PT_SEMICOLON + append the terminated semicolon + +ida_typeinf.PT_SIL silent, no messages -ida_typeinf.PT_TYP (variable) +ida_typeinf.PT_TYP return declared type information -ida_typeinf.PT_VAR (variable) +ida_typeinf.PT_VAR return declared object information -ida_typeinf.RESERVED_BYTE (variable) +ida_typeinf.RESERVED_BYTE multifunctional purpose -ida_typeinf.SC_AUTO (variable) +ida_typeinf.SC_AUTO auto -ida_typeinf.SC_EXT (variable) +ida_typeinf.SC_EXT extern -ida_typeinf.SC_FRIEND (variable) +ida_typeinf.SC_FRIEND friend -ida_typeinf.SC_REG (variable) +ida_typeinf.SC_REG register -ida_typeinf.SC_STAT (variable) +ida_typeinf.SC_STAT static -ida_typeinf.SC_TYPE (variable) +ida_typeinf.SC_TYPE typedef -ida_typeinf.SC_UNK (variable) +ida_typeinf.SC_UNK unknown -ida_typeinf.SC_VIRT (variable) +ida_typeinf.SC_VIRT virtual -ida_typeinf.SETCOMP_BY_USER (variable) +ida_typeinf.SETCOMP_BY_USER invoked by user, cannot be replaced by module/loader -ida_typeinf.SETCOMP_ONLY_ABI (variable) +ida_typeinf.SETCOMP_ONLY_ABI ignore cc field complete, use only abiname -ida_typeinf.SETCOMP_ONLY_ID (variable) - cc has only 'id' field; the rest will be set to defaults corresponding to the - program bitness +ida_typeinf.SETCOMP_ONLY_ID + cc has only 'id' field; the rest will be set to defaults corresponding to the program bitness + -ida_typeinf.SETCOMP_OVERRIDE (variable) +ida_typeinf.SETCOMP_OVERRIDE may override old compiler info -ida_typeinf.STI_ACCHAR (variable) +ida_typeinf.STI_ACCHAR const char[] -ida_typeinf.STI_ACHAR (variable) +ida_typeinf.STI_ACHAR char[] -ida_typeinf.STI_ACUCHAR (variable) +ida_typeinf.STI_ACUCHAR const uint8[] -ida_typeinf.STI_AEABI_LCMP (variable) +ida_typeinf.STI_AEABI_LCMP int __fastcall __pure(int64 x, int64 y) -ida_typeinf.STI_AEABI_MEMCLR (variable) +ida_typeinf.STI_AEABI_MEMCLR void __fastcall(void *, size_t) -ida_typeinf.STI_AEABI_MEMCPY (variable) +ida_typeinf.STI_AEABI_MEMCPY void __fastcall(void *, const void *, size_t) -ida_typeinf.STI_AEABI_MEMSET (variable) +ida_typeinf.STI_AEABI_MEMSET void __fastcall(void *, size_t, int) -ida_typeinf.STI_AEABI_ULCMP (variable) +ida_typeinf.STI_AEABI_ULCMP int __fastcall __pure(uint64 x, uint64 y) -ida_typeinf.STI_AUCHAR (variable) +ida_typeinf.STI_AUCHAR uint8[] -ida_typeinf.STI_COMPLEX128 (variable) +ida_typeinf.STI_COMPLEX128 struct complex128_t { double real, imag; } -ida_typeinf.STI_COMPLEX64 (variable) +ida_typeinf.STI_COMPLEX64 struct complex64_t { float real, imag; } -ida_typeinf.STI_DONT_USE (variable) +ida_typeinf.STI_DONT_USE unused stock type id; should not be used -ida_typeinf.STI_FDELOP (variable) +ida_typeinf.STI_FDELOP void __cdecl(void *) -ida_typeinf.STI_FPURGING (variable) +ida_typeinf.STI_FPURGING void __userpurge(int) -ida_typeinf.STI_MSGSEND (variable) +ida_typeinf.STI_MSGSEND void *(void *, const char *, ...) -ida_typeinf.STI_PBYTE (variable) +ida_typeinf.STI_PBYTE _BYTE * -ida_typeinf.STI_PCCHAR (variable) +ida_typeinf.STI_PCCHAR const char * -ida_typeinf.STI_PCHAR (variable) +ida_typeinf.STI_PCHAR char * -ida_typeinf.STI_PCUCHAR (variable) +ida_typeinf.STI_PCUCHAR const uint8 * -ida_typeinf.STI_PCVOID (variable) +ida_typeinf.STI_PCVOID const void * -ida_typeinf.STI_PINT (variable) +ida_typeinf.STI_PINT int * -ida_typeinf.STI_PPVOID (variable) +ida_typeinf.STI_PPVOID void ** -ida_typeinf.STI_PUCHAR (variable) +ida_typeinf.STI_PUCHAR uint8 * -ida_typeinf.STI_PUINT (variable) +ida_typeinf.STI_PUINT unsigned int * -ida_typeinf.STI_PVOID (variable) +ida_typeinf.STI_PUNKNOWN + _UNKNOWN * + +ida_typeinf.STI_PVOID void * -ida_typeinf.STI_RTC_CHECK_2 (variable) +ida_typeinf.STI_RTC_CHECK_2 int16 __fastcall(int16 x) -ida_typeinf.STI_RTC_CHECK_4 (variable) +ida_typeinf.STI_RTC_CHECK_4 int32 __fastcall(int32 x) -ida_typeinf.STI_RTC_CHECK_8 (variable) +ida_typeinf.STI_RTC_CHECK_8 int64 __fastcall(int64 x) -ida_typeinf.STI_SIZE_T (variable) +ida_typeinf.STI_SIZE_T size_t -ida_typeinf.STI_SSIZE_T (variable) +ida_typeinf.STI_SSIZE_T ssize_t -ida_typeinf.STRMEM_ANON (variable) - can be combined with STRMEM_NAME: look inside anonymous members too. +ida_typeinf.STRMEM_ANON + can be combined with STRMEM_NAME: look inside anonymous members too. + -ida_typeinf.STRMEM_AUTO (variable) +ida_typeinf.STRMEM_AUTO get member by offset if struct, or get member by index if union * nb: union: index is stored in the udm->offset field! - * nb: struct: offset is in bytes (not in bits)! + * nb: struct: offset is in bytes (not in bits)! + + + -ida_typeinf.STRMEM_CASTABLE_TO (variable) - can be combined with STRMEM_TYPE: member type must be castable to the specified - type +ida_typeinf.STRMEM_CASTABLE_TO + can be combined with STRMEM_TYPE: member type must be castable to the specified type + -ida_typeinf.STRMEM_INDEX (variable) +ida_typeinf.STRMEM_INDEX get member by number - * in: udm->offset - is a member number + * in: udm->offset - is a member number + + + -ida_typeinf.STRMEM_MAXS (variable) +ida_typeinf.STRMEM_LOWBND + get member by offset or the next member (lower bound) + * in: udm->offset - is a member offset in bits + + + + +ida_typeinf.STRMEM_MAXS get biggest member by size. -ida_typeinf.STRMEM_MINS (variable) +ida_typeinf.STRMEM_MINS get smallest member by size. -ida_typeinf.STRMEM_NAME (variable) +ida_typeinf.STRMEM_NAME get member by name - * in: udm->name - the desired member name. + * in: udm->name - the desired member name. + + + -ida_typeinf.STRMEM_OFFSET (variable) +ida_typeinf.STRMEM_NEXT + get next member after the offset + * in: udm->offset - is a member offset in bits + + + + +ida_typeinf.STRMEM_OFFSET get member by offset - * in: udm->offset - is a member offset in bits + * in: udm->offset - is a member offset in bits + + + -ida_typeinf.STRMEM_SIZE (variable) +ida_typeinf.STRMEM_SIZE get member by size. - * in: udm->size - the desired member size. + * in: udm->size - the desired member size. + + + -ida_typeinf.STRMEM_SKIP_EMPTY (variable) - can be combined with STRMEM_OFFSET, STRMEM_AUTO skip empty members (i.e. having - zero size) only last empty member can be returned +ida_typeinf.STRMEM_SKIP_EMPTY + can be combined with STRMEM_OFFSET, STRMEM_AUTO skip empty members (i.e. having zero size) only last empty member can be returned + -ida_typeinf.STRMEM_TYPE (variable) +ida_typeinf.STRMEM_SKIP_GAPS + can be combined with STRMEM_OFFSET, STRMEM_LOWBND skip gap members + + +ida_typeinf.STRMEM_TYPE get member by type. - * in: udm->type - the desired member type. member types are compared with - tinfo_t::equals_to() + * in: udm->type - the desired member type. member types are compared with tinfo_t::equals_to() + + + -ida_typeinf.STRMEM_VFTABLE (variable) - can be combined with STRMEM_OFFSET, STRMEM_AUTO get vftable instead of the base - class +ida_typeinf.STRMEM_VFTABLE + can be combined with STRMEM_OFFSET, STRMEM_AUTO get vftable instead of the base class + -ida_typeinf.SUDT_ALIGN (variable) - recalculate field alignments, struct packing, etc to match the offsets and size - info +ida_typeinf.STRUC_SEPARATOR + structname.fieldname -ida_typeinf.SUDT_CONST (variable) +ida_typeinf.SUDT_ALIGN + recalculate field alignments, struct packing, etc to match the offsets and size info + + +ida_typeinf.SUDT_CONST only for serialize_udt: make type const -ida_typeinf.SUDT_FAST (variable) +ida_typeinf.SUDT_FAST serialize without verifying offsets and alignments -ida_typeinf.SUDT_GAPS (variable) +ida_typeinf.SUDT_GAPS allow to fill gaps with additional members (_BYTE[]) -ida_typeinf.SUDT_SORT (variable) +ida_typeinf.SUDT_SERDEF + serialize: if a typeref, serialize its definition + +ida_typeinf.SUDT_SORT fields are not sorted by offset, sort them first -ida_typeinf.SUDT_UNEX (variable) - references to nonexistent member types are acceptable; in this case it is better - to set the corresponding udm_t::fda field to the type alignment. If this field - is not set, ida will try to guess the alignment. +ida_typeinf.SUDT_TRUNC + serialize: truncate useless strings from fields, fldcmts -ida_typeinf.SUDT_VOLATILE (variable) +ida_typeinf.SUDT_UNEX + references to nonexistent member types are acceptable; in this case it is better to set the corresponding udm_t::fda field to the type alignment. If this field is not set, ida will try to guess the alignment. + + +ida_typeinf.SUDT_VOLATILE only for serialize_udt: make type volatile -ida_typeinf.TAFLD_METHOD (variable) +ida_typeinf.TAENUM_64BIT + enum: store 64-bit values + +ida_typeinf.TAENUM_BIN + enum: binary representation, if BTE_HEX only one of OCT/BIN bits can be set. they are meaningful only if BTE_HEX is used. + + +ida_typeinf.TAENUM_LZERO + enum: print numbers with leading zeroes (only for HEX/OCT/BIN) + +ida_typeinf.TAENUM_NUMSIGN + enum: signed representation, if BTE_HEX + +ida_typeinf.TAENUM_OCT + enum: octal representation, if BTE_HEX + +ida_typeinf.TAENUM_SIGNED + enum: signed + +ida_typeinf.TAENUM_UNSIGNED + enum: unsigned + +ida_typeinf.TAFLD_BASECLASS + field: do not include but inherit from the current field + +ida_typeinf.TAFLD_BYTIL + field: was the member created due to the type system + +ida_typeinf.TAFLD_FRAME_R + frame: function return address frame slot + +ida_typeinf.TAFLD_FRAME_S + frame: function saved registers frame slot + +ida_typeinf.TAFLD_GAP + field: gap member (displayed as padding in type details) + +ida_typeinf.TAFLD_METHOD denotes a udt member function -ida_typeinf.TAH_ALL (variable) +ida_typeinf.TAFLD_REGCMT + field: the comment is regular (if not set, it is repeatable) + +ida_typeinf.TAFLD_UNALIGNED + field: unaligned field + +ida_typeinf.TAFLD_VFTABLE + field: ptr to virtual function table + +ida_typeinf.TAFLD_VIRTBASE + field: virtual base (not supported yet) + +ida_typeinf.TAH_ALL all defined bits -ida_typeinf.TAH_BYTE (variable) +ida_typeinf.TAH_BYTE type attribute header byte -ida_typeinf.TAH_HASATTRS (variable) +ida_typeinf.TAH_HASATTRS has extended attributes -ida_typeinf.TA_FORMAT (variable) - info about the 'format' argument. 3 times pack_dd: format_functype_t, argument - number of 'format', argument number of '...' +ida_typeinf.TAPTR_PTR32 + ptr: __ptr32 -ida_typeinf.TA_ORG_ARRDIM (variable) +ida_typeinf.TAPTR_PTR64 + ptr: __ptr64 + +ida_typeinf.TAPTR_RESTRICT + ptr: __restrict + +ida_typeinf.TAPTR_SHIFTED + ptr: __shifted(parent_struct, delta) + +ida_typeinf.TAUDT_CPPOBJ + struct: a c++ object, not simple pod type + +ida_typeinf.TAUDT_FIXED + struct: fixed field offsets, stored in serialized form; cannot be set for unions + + +ida_typeinf.TAUDT_MSSTRUCT + struct: gcc msstruct attribute + +ida_typeinf.TAUDT_UNALIGNED + struct: unaligned struct + +ida_typeinf.TAUDT_VFTABLE + struct: is virtual function table + +ida_typeinf.TA_FORMAT + info about the 'format' argument. 3 times pack_dd: format_functype_t, argument number of 'format', argument number of '...' + + +ida_typeinf.TA_ORG_ARRDIM the original array dimension (pack_dd) -ida_typeinf.TA_ORG_TYPEDEF (variable) +ida_typeinf.TA_ORG_TYPEDEF the original typedef name (simple string) -ida_typeinf.TA_VALUE_REPR (variable) +ida_typeinf.TA_VALUE_REPR serialized value_repr_t (used for scalars and arrays) -ida_typeinf.TCMP_ANYBASE (variable) +ida_typeinf.TCMP_ANYBASE accept any base class when casting -ida_typeinf.TCMP_AUTOCAST (variable) +ida_typeinf.TCMP_AUTOCAST can t1 be cast into t2 automatically? -ida_typeinf.TCMP_CALL (variable) +ida_typeinf.TCMP_CALL can t1 be called with t2 type? -ida_typeinf.TCMP_DECL (variable) +ida_typeinf.TCMP_DECL compare declarations without resolving them -ida_typeinf.TCMP_DELPTR (variable) +ida_typeinf.TCMP_DELPTR remove pointer from types before comparing -ida_typeinf.TCMP_EQUAL (variable) +ida_typeinf.TCMP_EQUAL are types equal? -ida_typeinf.TCMP_IGNMODS (variable) +ida_typeinf.TCMP_IGNMODS ignore const/volatile modifiers -ida_typeinf.TCMP_MANCAST (variable) +ida_typeinf.TCMP_MANCAST can t1 be cast into t2 manually? -ida_typeinf.TCMP_SKIPTHIS (variable) +ida_typeinf.TCMP_SKIPTHIS skip the first function argument in comparison -ida_typeinf.TERR_ALIEN_NAME (variable) +ida_typeinf.TERR_ALIEN_NAME enum member name is used in another enum -ida_typeinf.TERR_BAD_ARG (variable) +ida_typeinf.TERR_BAD_ARG bad argument -ida_typeinf.TERR_BAD_ARRAY (variable) +ida_typeinf.TERR_BAD_ARRAY arrays are forbidden as function arguments -ida_typeinf.TERR_BAD_BASE (variable) +ida_typeinf.TERR_BAD_BASE bad base class -ida_typeinf.TERR_BAD_BF (variable) +ida_typeinf.TERR_BAD_BF bitfields are forbidden as function arguments -ida_typeinf.TERR_BAD_BMASK (variable) - Bad enum member mask 0xI64X. The specified mask should not intersect with any - existing mask in the enum. Zero masks are prohibited too. +ida_typeinf.TERR_BAD_BMASK + Bad enum member mask 0xI64X. The specified mask should not intersect with any existing mask in the enum. Zero masks are prohibited too. -ida_typeinf.TERR_BAD_GAP (variable) +ida_typeinf.TERR_BAD_FX_SIZE + cannot extend struct beyond fixed size + +ida_typeinf.TERR_BAD_GAP bad gap -ida_typeinf.TERR_BAD_GROUPS (variable) +ida_typeinf.TERR_BAD_GROUPS bad group sizes for bitmask enum -ida_typeinf.TERR_BAD_INDEX (variable) +ida_typeinf.TERR_BAD_INDEX bad index d -ida_typeinf.TERR_BAD_LAYOUT (variable) +ida_typeinf.TERR_BAD_LAYOUT failed to calculate the structure/union layout -ida_typeinf.TERR_BAD_MSKVAL (variable) +ida_typeinf.TERR_BAD_MSKVAL bad bmask and value combination (value=0xI64X; bitmask 0xI64X) -ida_typeinf.TERR_BAD_NAME (variable) +ida_typeinf.TERR_BAD_NAME name s is not acceptable -ida_typeinf.TERR_BAD_OFFSET (variable) +ida_typeinf.TERR_BAD_OFFSET bad member offset s -ida_typeinf.TERR_BAD_REPR (variable) +ida_typeinf.TERR_BAD_REPR bad or incompatible field representation -ida_typeinf.TERR_BAD_SERIAL (variable) +ida_typeinf.TERR_BAD_SERIAL enum value has too many serials -ida_typeinf.TERR_BAD_SIZE (variable) +ida_typeinf.TERR_BAD_SIZE bad size d -ida_typeinf.TERR_BAD_SUBTYPE (variable) +ida_typeinf.TERR_BAD_SUBTYPE recursive structure nesting is forbidden -ida_typeinf.TERR_BAD_SYNC (variable) - failed to synchronize with IDB - -ida_typeinf.TERR_BAD_TAH (variable) +ida_typeinf.TERR_BAD_TAH bad bits in the type attributes (TAH bits) -ida_typeinf.TERR_BAD_TYPE (variable) +ida_typeinf.TERR_BAD_TYPE bad type -ida_typeinf.TERR_BAD_UNIVAR (variable) +ida_typeinf.TERR_BAD_UNIVAR unions cannot have variable sized members -ida_typeinf.TERR_BAD_VALUE (variable) +ida_typeinf.TERR_BAD_VALUE value 0xI64X is not acceptable -ida_typeinf.TERR_BAD_VARLAST (variable) +ida_typeinf.TERR_BAD_VARLAST variable sized member must be the last member in the structure -ida_typeinf.TERR_DUPNAME (variable) +ida_typeinf.TERR_DUPNAME duplicate name s -ida_typeinf.TERR_ENUM_SIZE (variable) +ida_typeinf.TERR_ENUM_SIZE bad enum size -ida_typeinf.TERR_GRP_NOEMPTY (variable) +ida_typeinf.TERR_GRP_NOEMPTY could not delete group mask for not empty group 0xI64X -ida_typeinf.TERR_NESTED (variable) +ida_typeinf.TERR_NESTED recursive structure nesting is forbidden -ida_typeinf.TERR_NOT_COMPAT (variable) +ida_typeinf.TERR_NOT_COMPAT the new type is not compatible with the old type -ida_typeinf.TERR_NOT_IMPL (variable) +ida_typeinf.TERR_NOT_FOUND + member not found + +ida_typeinf.TERR_NOT_IMPL not implemented -ida_typeinf.TERR_NO_BMASK (variable) +ida_typeinf.TERR_NO_BMASK bitmask 0xI64X is not found -ida_typeinf.TERR_OK (variable) +ida_typeinf.TERR_OK ok -ida_typeinf.TERR_OVERLAP (variable) +ida_typeinf.TERR_OVERLAP the member overlaps with other members that cannot be deleted -ida_typeinf.TERR_SAVE_ERROR (variable) +ida_typeinf.TERR_SAVE_ERROR failed to save -ida_typeinf.TERR_SERIALIZE (variable) +ida_typeinf.TERR_SERIALIZE failed to serialize -ida_typeinf.TERR_STOCK (variable) +ida_typeinf.TERR_STOCK stock type info cannot be modified -ida_typeinf.TERR_UNION_BF (variable) +ida_typeinf.TERR_STRUCT_SIZE + bad fixed structure size + +ida_typeinf.TERR_TYPE_WORSE + the new type is worse than the old type + +ida_typeinf.TERR_UNION_BF unions cannot have bitfields -ida_typeinf.TIL_ADD_ALREADY (variable) +ida_typeinf.TIL_ADD_ALREADY the base til was already added -ida_typeinf.TIL_ADD_FAILED (variable) +ida_typeinf.TIL_ADD_FAILED see errbuf -ida_typeinf.TIL_ADD_OK (variable) +ida_typeinf.TIL_ADD_OK some tils were added -ida_typeinf.TIL_ALI (variable) +ida_typeinf.TIL_ALI type aliases are present (this bit is used only on the disk) -ida_typeinf.TIL_ESI (variable) +ida_typeinf.TIL_ESI extended sizeof info (short, long, longlong) -ida_typeinf.TIL_MAC (variable) +ida_typeinf.TIL_MAC til has macro table -ida_typeinf.TIL_MOD (variable) +ida_typeinf.TIL_MOD til has been modified, should be saved -ida_typeinf.TIL_ORD (variable) +ida_typeinf.TIL_ORD type ordinal numbers are present -ida_typeinf.TIL_SLD (variable) +ida_typeinf.TIL_SLD sizeof(long double) -ida_typeinf.TIL_STM (variable) +ida_typeinf.TIL_STM til has extra streams -ida_typeinf.TIL_UNI (variable) +ida_typeinf.TIL_UNI universal til for any compiler -ida_typeinf.TIL_ZIP (variable) +ida_typeinf.TIL_ZIP pack buckets using zip -ida_typeinf.TINFO_DEFINITE (variable) +ida_typeinf.TINFO_DEFINITE this is a definite type -ida_typeinf.TINFO_DELAYFUNC (variable) - if type is a function and no function exists at ea, schedule its creation and - argument renaming to auto-analysis, otherwise try to create it immediately +ida_typeinf.TINFO_DELAYFUNC + if type is a function and no function exists at ea, schedule its creation and argument renaming to auto-analysis, otherwise try to create it immediately + -ida_typeinf.TINFO_GUESSED (variable) +ida_typeinf.TINFO_GUESSED this is a guessed type -ida_typeinf.TINFO_STRICT (variable) +ida_typeinf.TINFO_STRICT never convert given type to another one before applying -ida_typeinf.TVIS_CMT (variable) +ida_typeinf.TVIS_CMT new comment is present (only for udt members) -ida_typeinf.TVIS_NAME (variable) +ida_typeinf.TVIS_NAME new name is present (only for funcargs and udt members) -ida_typeinf.TVIS_RPTCMT (variable) +ida_typeinf.TVIS_RPTCMT the new comment is repeatable -ida_typeinf.TVIS_TYPE (variable) +ida_typeinf.TVIS_TYPE new type info is present -ida_typeinf.TVST_DEF (variable) +ida_typeinf.TVST_DEF visit type definition (meaningful for typerefs) -ida_typeinf.TVST_PRUNE (variable) +ida_typeinf.TVST_PRUNE don't visit children of current type -ida_typeinf.TYPE_BASE_MASK (variable) +ida_typeinf.TYPE_BASE_MASK the low 4 bits define the basic type -ida_typeinf.TYPE_FLAGS_MASK (variable) - type flags - they have different meaning depending on the basic type +ida_typeinf.TYPE_FLAGS_MASK + type flags - they have different meaning depending on the basic type + -ida_typeinf.TYPE_FULL_MASK (variable) +ida_typeinf.TYPE_FULL_MASK basic type with type flags -ida_typeinf.TYPE_MODIF_MASK (variable) +ida_typeinf.TYPE_MODIF_MASK modifiers. * for BT_ARRAY see Derived type: array - * BT_VOID can have them ONLY in 'void *' + * BT_VOID can have them ONLY in 'void *' + + + -ida_typeinf.TYPID_ISREF (variable) +ida_typeinf.TYPID_ISREF Identifies that a type that is a typeref. -ida_typeinf.TYPID_SHIFT (variable) +ida_typeinf.TYPID_SHIFT First type detail bit. -ida_typeinf.VALSTR_OPEN (variable) +ida_typeinf.VALSTR_OPEN printed opening curly brace '{' -ida_typeinf._BT_LAST_BASIC (variable) - the last basic type, all basic types may be followed by [tah-typeattrs] +ida_typeinf._BT_LAST_BASIC + the last basic type, all basic types may be followed by [tah-typeattrs] + -ida_typeinf._wrap_cvar (class) +ida_typeinf._wrap_cvar -ida_typeinf._wrap_cvar.__getattr__ (method) +ida_typeinf._wrap_cvar.__getattr__(self, attr) -ida_typeinf._wrap_cvar.__setattr__ (method) +ida_typeinf._wrap_cvar.__setattr__(self, attr, value) -ida_typeinf.add_til (function) - add_til(name, flags) -> int - Load a til file and add it the database type libraries list. IDA will also apply - function prototypes for matching function names. - - @param name: (C++: const char *) til name - @param flags: (C++: int) combination of Load TIL flags - @return: one of Load TIL result codes +ida_typeinf.add_til(name: str, flags: int) -> int + Load a til file and add it the database type libraries list. IDA will also apply function prototypes for matching function names. + + @param name: til name + @param flags: combination of Load TIL flags + @returns one of Load TIL result codes -ida_typeinf.alloc_type_ordinal (function) - alloc_type_ordinal(ti) -> uint32 +ida_typeinf.alloc_type_ordinal(ti: "til_t") -> int alloc_type_ordinals(ti, 1) - - @param ti: (C++: til_t *) -ida_typeinf.alloc_type_ordinals (function) - alloc_type_ordinals(ti, qty) -> uint32 - Allocate a range of ordinal numbers for new types. - - @param ti: (C++: til_t *) type library - @param qty: (C++: int) number of ordinals to allocate - @return: the first ordinal. 0 means failure. +ida_typeinf.alloc_type_ordinals(ti: "til_t", qty: int) -> int + Allocate a range of ordinal numbers for new types. + + @param ti: type library + @param qty: number of ordinals to allocate + @returns the first ordinal. 0 means failure. -ida_typeinf.aloc_visitor_t (class) - Proxy of C++ aloc_visitor_t class. +ida_typeinf.aloc_visitor_t -ida_typeinf.aloc_visitor_t.__disown__ (method) +ida_typeinf.aloc_visitor_t.__disown__(self) -ida_typeinf.aloc_visitor_t.__init__ (method) - __init__(self) -> aloc_visitor_t - - @param self: PyObject * +ida_typeinf.aloc_visitor_t.__init__(self) -ida_typeinf.aloc_visitor_t.visit_location (method) - visit_location(self, v, off, size) -> int - - @param v: argloc_t & - @param off: int - @param size: int +ida_typeinf.aloc_visitor_t.visit_location(self, v: "argloc_t", off: int, size: int) -> int -ida_typeinf.append_abi_opts (function) - append_abi_opts(abi_opts, user_level=False) -> bool - Add/remove/check ABI option General form of full abi name: abiname-opt1-opt2-... - or -opt1-opt2-... - - @param abi_opts: (C++: const char *) - ABI options to add/remove in form opt1-opt2-... - @param user_level: (C++: bool) - initiated by user if TRUE (==SETCOMP_BY_USER) - @return: success +ida_typeinf.append_abi_opts(abi_opts: str, user_level: bool = False) -> bool + Add/remove/check ABI option General form of full abi name: abiname-opt1-opt2-... or -opt1-opt2-... + + @param abi_opts: - ABI options to add/remove in form opt1-opt2-... + @param user_level: - initiated by user if TRUE (==SETCOMP_BY_USER) + @returns success -ida_typeinf.append_argloc (function) - append_argloc(out, vloc) -> bool - Serialize argument location - - @param out: (C++: qtype *) - @param vloc: (C++: const argloc_t &) argloc_t const & +ida_typeinf.append_argloc(out: "qtype *", vloc: "argloc_t") -> bool + Serialize argument location + -ida_typeinf.append_tinfo_covered (function) - append_tinfo_covered(out, typid, offset) -> bool - - @param out: rangeset_t * - @param typid: uint32 - @param offset: uint64 +ida_typeinf.append_tinfo_covered(out: "rangeset_t", typid: "typid_t", offset: "uint64") -> bool -ida_typeinf.apply_callee_tinfo (function) - apply_callee_tinfo(caller, tif) -> bool - Apply the type of the called function to the calling instruction. This function - will append parameter comments and rename the local variables of the calling - function. It also stores information about the instructions that initialize call - arguments in the database. Use get_arg_addrs() to retrieve it if necessary. - Alternatively it is possible to hook to processor_t::arg_addrs_ready event. - - @param caller: (C++: ea_t) linear address of the calling instruction. must belong to a - function. - @param tif: (C++: const tinfo_t &) type info - @return: success +ida_typeinf.apply_callee_tinfo(caller: ida_idaapi.ea_t, tif: "tinfo_t") -> bool + Apply the type of the called function to the calling instruction. This function will append parameter comments and rename the local variables of the calling function. It also stores information about the instructions that initialize call arguments in the database. Use get_arg_addrs() to retrieve it if necessary. Alternatively it is possible to hook to processor_t::arg_addrs_ready event. + + @param caller: linear address of the calling instruction. must belong to a function. + @param tif: type info + @returns success -ida_typeinf.apply_cdecl (function) - apply_cdecl(til, ea, decl, flags=0) -> bool - Apply the specified type to the address. This function parses the declaration - and calls apply_tinfo() - - @param til: (C++: til_t *) type library - @param ea: (C++: ea_t) linear address - @param decl: (C++: const char *) type declaration in C form - @param flags: (C++: int) flags to pass to apply_tinfo (TINFO_DEFINITE is always passed) - @return: success +ida_typeinf.apply_cdecl(til: "til_t", ea: ida_idaapi.ea_t, decl: str, flags: int = 0) -> bool + Apply the specified type to the address. This function parses the declaration and calls apply_tinfo() + + @param til: type library + @param ea: linear address + @param decl: type declaration in C form + @param flags: flags to pass to apply_tinfo (TINFO_DEFINITE is always passed) + @returns success -ida_typeinf.apply_named_type (function) - apply_named_type(ea, name) -> bool - Apply the specified named type to the address. - - @param ea: (C++: ea_t) linear address - @param name: (C++: const char *) the type name, e.g. "FILE" - @return: success +ida_typeinf.apply_named_type(ea: ida_idaapi.ea_t, name: str) -> bool + Apply the specified named type to the address. + + @param ea: linear address + @param name: the type name, e.g. "FILE" + @returns success -ida_typeinf.apply_once_tinfo_and_name (function) - apply_once_tinfo_and_name(dea, tif, name) -> bool - Apply the specified type and name to the address. This function checks if the - address already has a type. If the old type - does not exist or the new type is 'better' than the old type, then the - new type will be applied. A type is considered better if it has more - information (e.g. BTMT_STRUCT is better than BT_INT). - The same logic is with the name: if the address already have a meaningful - name, it will be preserved. Only if the old name does not exist or it - is a dummy name like byte_123, it will be replaced by the new name. - - @param dea: (C++: ea_t) linear address - @param tif: (C++: const tinfo_t &) type string in the internal format - @param name: (C++: const char *) new name for the address - @return: success +ida_typeinf.apply_once_tinfo_and_name(dea: ida_idaapi.ea_t, tif: "tinfo_t", name: str) -> bool + Apply the specified type and name to the address. This function checks if the address already has a type. If the old type + does not exist or the new type is 'better' than the old type, then the + new type will be applied. A type is considered better if it has more + information (e.g. BTMT_STRUCT is better than BT_INT). + The same logic is with the name: if the address already have a meaningful + name, it will be preserved. Only if the old name does not exist or it + is a dummy name like byte_123, it will be replaced by the new name. + + @param dea: linear address + @param tif: type string in the internal format + @param name: new name for the address + @returns success -ida_typeinf.apply_tinfo (function) - apply_tinfo(ea, tif, flags) -> bool - Apply the specified type to the specified address. This function sets the type - and tries to convert the item at the specified address to conform the type. - - @param ea: (C++: ea_t) linear address - @param tif: (C++: const tinfo_t &) type string in internal format - @param flags: (C++: uint32) combination of Apply tinfo flags - @return: success +ida_typeinf.apply_tinfo(ea: ida_idaapi.ea_t, tif: "tinfo_t", flags: int) -> bool + Apply the specified type to the specified address. This function sets the type and tries to convert the item at the specified address to conform the type. + + @param ea: linear address + @param tif: type string in internal format + @param flags: combination of Apply tinfo flags + @returns success -ida_typeinf.apply_tinfo_to_stkarg (function) - apply_tinfo_to_stkarg(insn, x, v, tif, name) -> bool - Helper function for the processor modules. to be called from - processor_t::use_stkarg_type - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: (C++: const op_t &) op_t const & - @param v: (C++: uval_t) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param name: (C++: const char *) char const * +ida_typeinf.apply_tinfo_to_stkarg(insn: "insn_t const &", x: "op_t const &", v: int, tif: "tinfo_t", name: str) -> bool + Helper function for the processor modules. to be called from processor_t::use_stkarg_type + -ida_typeinf.apply_type (function) - apply_type(ti, type, fields, ea, flags) -> bool +ida_typeinf.apply_type(til: til_t, type: bytes, fields: bytes, ea: ida_idaapi.ea_t, flags: int) -> bool Apply the specified type to the address - @param ti: Type info library. 'None' can be used. - @param type: type_t const * - @param fields: p_list const * + @param til: Type info library. 'None' can be used. + @param type: type string + @param fields: fields string (may be empty or None) @param ea: the address of the object @param flags: combination of TINFO_... constants or 0 @return: Boolean -ida_typeinf.argloc_t (class) - Proxy of C++ argloc_t class. +ida_typeinf.argloc_t -ida_typeinf.argloc_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: argloc_t const & +ida_typeinf.argloc_t.__eq__(self, r: "argloc_t") -> bool -ida_typeinf.argloc_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: argloc_t const & +ida_typeinf.argloc_t.__ge__(self, r: "argloc_t") -> bool -ida_typeinf.argloc_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: argloc_t const & +ida_typeinf.argloc_t.__gt__(self, r: "argloc_t") -> bool -ida_typeinf.argloc_t.__init__ (method) - __init__(self) -> argloc_t - __init__(self, r) -> argloc_t - - @param r: argloc_t const & +ida_typeinf.argloc_t.__init__(self, *args) -ida_typeinf.argloc_t.__le__ (method) - __le__(self, r) -> bool - - @param r: argloc_t const & +ida_typeinf.argloc_t.__le__(self, r: "argloc_t") -> bool -ida_typeinf.argloc_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: argloc_t const & +ida_typeinf.argloc_t.__lt__(self, r: "argloc_t") -> bool -ida_typeinf.argloc_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: argloc_t const & +ida_typeinf.argloc_t.__ne__(self, r: "argloc_t") -> bool -ida_typeinf.argloc_t._consume_rrel (method) - _consume_rrel(self, p) -> bool - - Parameters - ---------- - p: rrel_t * +ida_typeinf.argloc_t._consume_rrel(self, p: "rrel_t") -> bool + Use consume_rrel() -ida_typeinf.argloc_t._consume_scattered (method) - _consume_scattered(self, p) -> bool - - Parameters - ---------- - p: scattered_aloc_t * +ida_typeinf.argloc_t._consume_scattered(self, p: "scattered_aloc_t") -> bool + Use consume_scattered() -ida_typeinf.argloc_t._set_badloc (method) - _set_badloc(self) +ida_typeinf.argloc_t._set_badloc(self) -> None + Use set_badloc() -ida_typeinf.argloc_t._set_biggest (method) - _set_biggest(self, ct, data) - - Parameters - ---------- - ct: argloc_type_t - data: argloc_t::biggest_t +ida_typeinf.argloc_t._set_biggest(self, ct: "argloc_type_t", data: "argloc_t::biggest_t") -> None + Set biggest element in internal union (careful - this function does not clean up!) -ida_typeinf.argloc_t._set_custom (method) - _set_custom(self, ct, pdata) - - Parameters - ---------- - ct: argloc_type_t - pdata: void * +ida_typeinf.argloc_t._set_custom(self, ct: "argloc_type_t", pdata: "void *") -> None + Set custom argument location (careful - this function does not clean up!) -ida_typeinf.argloc_t._set_ea (method) - _set_ea(self, _ea) - - Parameters - ---------- - _ea: ea_t +ida_typeinf.argloc_t._set_ea(self, _ea: ida_idaapi.ea_t) -> None + Use set_ea + -ida_typeinf.argloc_t._set_reg1 (method) - _set_reg1(self, reg, off=0) - - Parameters - ---------- - reg: int - off: int +ida_typeinf.argloc_t._set_reg1(self, reg: int, off: int = 0) -> None + Use set_reg1() -ida_typeinf.argloc_t._set_reg2 (method) - _set_reg2(self, _reg1, _reg2) - - Parameters - ---------- - _reg1: int - _reg2: int +ida_typeinf.argloc_t._set_reg2(self, _reg1: int, _reg2: int) -> None + Use set_reg2() -ida_typeinf.argloc_t._set_stkoff (method) - _set_stkoff(self, off) - - Parameters - ---------- - off: sval_t +ida_typeinf.argloc_t._set_stkoff(self, off: int) -> None + Use set_stkoff() -ida_typeinf.argloc_t.advance (method) - advance(self, delta) -> bool +ida_typeinf.argloc_t.advance(self, delta: int) -> bool Move the location to point 'delta' bytes further. - - @param delta: (C++: int) -ida_typeinf.argloc_t.align_reg_high (method) - align_reg_high(self, size, _slotsize) +ida_typeinf.argloc_t.align_reg_high(self, size: "size_t", _slotsize: "size_t") -> None Set register offset to align it to the upper part of _SLOTSIZE. - - @param size: (C++: size_t) - @param _slotsize: (C++: size_t) -ida_typeinf.argloc_t.align_stkoff_high (method) - align_stkoff_high(self, size, _slotsize) +ida_typeinf.argloc_t.align_stkoff_high(self, size: "size_t", _slotsize: "size_t") -> None Set stack offset to align to the upper part of _SLOTSIZE. - - @param size: (C++: size_t) - @param _slotsize: (C++: size_t) -ida_typeinf.argloc_t.atype (method) - atype(self) -> argloc_type_t +ida_typeinf.argloc_t.atype(self) -> "argloc_type_t" Get type (Argument location types) -ida_typeinf.argloc_t.calc_offset (method) - calc_offset(self) -> sval_t +ida_typeinf.argloc_t.calc_offset(self) -> int Calculate offset that can be used to compare 2 similar arglocs. -ida_typeinf.argloc_t.compare (method) - compare(self, r) -> int - - @param r: argloc_t const & +ida_typeinf.argloc_t.compare(self, r: "argloc_t") -> int -ida_typeinf.argloc_t.consume_rrel (method) - consume_rrel(self, p) +ida_typeinf.argloc_t.consume_rrel(self, p: "rrel_t") -> None Set register-relative location - can't be nullptr. - - @param p: (C++: rrel_t *) -ida_typeinf.argloc_t.consume_scattered (method) - consume_scattered(self, p) +ida_typeinf.argloc_t.consume_scattered(self, p: "scattered_aloc_t") -> None Set distributed argument location. - - @param p: (C++: scattered_aloc_t *) scattered_aloc_t const & -ida_typeinf.argloc_t.get_biggest (method) - get_biggest(self) -> argloc_t::biggest_t +ida_typeinf.argloc_t.get_biggest(self) -> "argloc_t::biggest_t" Get largest element in internal union. -ida_typeinf.argloc_t.get_custom (method) - get_custom(self) -> void * - Get custom argloc info. Use if atype() == ALOC_CUSTOM +ida_typeinf.argloc_t.get_custom(self) -> "void *" + Get custom argloc info. Use if atype() == ALOC_CUSTOM + -ida_typeinf.argloc_t.get_ea (method) - get_ea(self) -> ea_t - Get the global address. Use when atype() == ALOC_STATIC +ida_typeinf.argloc_t.get_ea(self) -> ida_idaapi.ea_t + Get the global address. Use when atype() == ALOC_STATIC + -ida_typeinf.argloc_t.get_reginfo (method) - get_reginfo(self) -> uint32 - Get all register info. Use when atype() == ALOC_REG1 or ALOC_REG2 +ida_typeinf.argloc_t.get_reginfo(self) -> int + Get all register info. Use when atype() == ALOC_REG1 or ALOC_REG2 + -ida_typeinf.argloc_t.get_rrel (method) - get_rrel(self) -> rrel_t - Get register-relative info. Use when atype() == ALOC_RREL +ida_typeinf.argloc_t.get_rrel(self) -> "rrel_t &" + Get register-relative info. Use when atype() == ALOC_RREL + -ida_typeinf.argloc_t.has_reg (method) - has_reg(self) -> bool +ida_typeinf.argloc_t.has_reg(self) -> bool TRUE if argloc has a register part. -ida_typeinf.argloc_t.has_stkoff (method) - has_stkoff(self) -> bool +ida_typeinf.argloc_t.has_stkoff(self) -> bool TRUE if argloc has a stack part. -ida_typeinf.argloc_t.in_stack (method) - in_stack(self) -> bool +ida_typeinf.argloc_t.in_stack(self) -> bool TRUE if argloc is in stack entirely. -ida_typeinf.argloc_t.is_badloc (method) - is_badloc(self) -> bool +ida_typeinf.argloc_t.is_badloc(self) -> bool See ALOC_NONE. -ida_typeinf.argloc_t.is_custom (method) - is_custom(self) -> bool +ida_typeinf.argloc_t.is_custom(self) -> bool See ALOC_CUSTOM. -ida_typeinf.argloc_t.is_ea (method) - is_ea(self) -> bool +ida_typeinf.argloc_t.is_ea(self) -> bool See ALOC_STATIC. -ida_typeinf.argloc_t.is_fragmented (method) - is_fragmented(self) -> bool +ida_typeinf.argloc_t.is_fragmented(self) -> bool is_scattered() || is_reg2() -ida_typeinf.argloc_t.is_mixed_scattered (method) - is_mixed_scattered(self) -> bool +ida_typeinf.argloc_t.is_mixed_scattered(self) -> bool mixed scattered: consists of register and stack parts -ida_typeinf.argloc_t.is_reg (method) - is_reg(self) -> bool +ida_typeinf.argloc_t.is_reg(self) -> bool is_reg1() || is_reg2() -ida_typeinf.argloc_t.is_reg1 (method) - is_reg1(self) -> bool +ida_typeinf.argloc_t.is_reg1(self) -> bool See ALOC_REG1. -ida_typeinf.argloc_t.is_reg2 (method) - is_reg2(self) -> bool +ida_typeinf.argloc_t.is_reg2(self) -> bool See ALOC_REG2. -ida_typeinf.argloc_t.is_rrel (method) - is_rrel(self) -> bool +ida_typeinf.argloc_t.is_rrel(self) -> bool See ALOC_RREL. -ida_typeinf.argloc_t.is_scattered (method) - is_scattered(self) -> bool +ida_typeinf.argloc_t.is_scattered(self) -> bool See ALOC_DIST. -ida_typeinf.argloc_t.is_stkoff (method) - is_stkoff(self) -> bool +ida_typeinf.argloc_t.is_stkoff(self) -> bool See ALOC_STACK. -ida_typeinf.argloc_t.reg1 (method) - reg1(self) -> int - Get the register info. Use when atype() == ALOC_REG1 or ALOC_REG2 +ida_typeinf.argloc_t.reg1(self) -> int + Get the register info. Use when atype() == ALOC_REG1 or ALOC_REG2 + -ida_typeinf.argloc_t.reg2 (method) - reg2(self) -> int - Get info for the second register. Use when atype() == ALOC_REG2 +ida_typeinf.argloc_t.reg2(self) -> int + Get info for the second register. Use when atype() == ALOC_REG2 + -ida_typeinf.argloc_t.regoff (method) - regoff(self) -> int - Get offset from the beginning of the register in bytes. Use when atype() == - ALOC_REG1 +ida_typeinf.argloc_t.regoff(self) -> int + Get offset from the beginning of the register in bytes. Use when atype() == ALOC_REG1 + -ida_typeinf.argloc_t.scattered (method) - scattered(self) -> scattered_aloc_t - Get scattered argument info. Use when atype() == ALOC_DIST +ida_typeinf.argloc_t.scattered(self) -> "scattered_aloc_t &" + Get scattered argument info. Use when atype() == ALOC_DIST + -ida_typeinf.argloc_t.set_badloc (method) - set_badloc(self) +ida_typeinf.argloc_t.set_badloc(self) -> None Set to invalid location. -ida_typeinf.argloc_t.set_ea (method) - set_ea(self, _ea) +ida_typeinf.argloc_t.set_ea(self, _ea: ida_idaapi.ea_t) -> None Set static ea location. - - @param _ea: (C++: ea_t) -ida_typeinf.argloc_t.set_reg1 (method) - set_reg1(self, reg, off=0) +ida_typeinf.argloc_t.set_reg1(self, reg: int, off: int = 0) -> None Set register location. - - @param reg: (C++: int) - @param off: (C++: int) -ida_typeinf.argloc_t.set_reg2 (method) - set_reg2(self, _reg1, _reg2) +ida_typeinf.argloc_t.set_reg2(self, _reg1: int, _reg2: int) -> None Set secondary register location. - - @param _reg1: (C++: int) - @param _reg2: (C++: int) -ida_typeinf.argloc_t.set_stkoff (method) - set_stkoff(self, off) +ida_typeinf.argloc_t.set_stkoff(self, off: int) -> None Set stack offset location. - - @param off: (C++: sval_t) -ida_typeinf.argloc_t.stkoff (method) - stkoff(self) -> sval_t - Get the stack offset. Use if atype() == ALOC_STACK +ida_typeinf.argloc_t.stkoff(self) -> int + Get the stack offset. Use if atype() == ALOC_STACK + -ida_typeinf.argloc_t.swap (method) - swap(self, r) +ida_typeinf.argloc_t.swap(self, r: "argloc_t") -> None Assign this == r and r == this. - - @param r: (C++: argloc_t &) -ida_typeinf.argpart_t (class) - Proxy of C++ argpart_t class. +ida_typeinf.argpart_t -ida_typeinf.argpart_t.__init__ (method) - __init__(self, a) -> argpart_t - - @param a: argloc_t const & - - __init__(self) -> argpart_t +ida_typeinf.argpart_t.__init__(self, *args) -ida_typeinf.argpart_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: argpart_t const & +ida_typeinf.argpart_t.__lt__(self, r: "argpart_t") -> bool -ida_typeinf.argpart_t.bad_offset (method) - bad_offset(self) -> bool +ida_typeinf.argpart_t.bad_offset(self) -> bool Does this argpart have a valid offset? -ida_typeinf.argpart_t.bad_size (method) - bad_size(self) -> bool +ida_typeinf.argpart_t.bad_size(self) -> bool Does this argpart have a valid size? -ida_typeinf.argpart_t.off (variable) +ida_typeinf.argpart_t.off offset from the beginning of the argument -ida_typeinf.argpart_t.size (variable) +ida_typeinf.argpart_t.size the number of bytes -ida_typeinf.argpart_t.swap (method) - swap(self, r) +ida_typeinf.argpart_t.swap(self, r: "argpart_t") -> None Assign this = r and r = this. - - @param r: (C++: argpart_t &) -ida_typeinf.argpartvec_t (class) - Proxy of C++ qvector< argpart_t > class. +ida_typeinf.argpartvec_t -ida_typeinf.argpartvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< argpart_t > const & +ida_typeinf.argpartvec_t.__eq__(self, r: "argpartvec_t") -> bool -ida_typeinf.argpartvec_t.__getitem__ (method) - __getitem__(self, i) -> argpart_t - - @param i: size_t +ida_typeinf.argpartvec_t.__getitem__(self, i: "size_t") -> "argpart_t const &" -ida_typeinf.argpartvec_t.__init__ (method) - __init__(self) -> argpartvec_t - __init__(self, x) -> argpartvec_t - - @param x: qvector< argpart_t > const & +ida_typeinf.argpartvec_t.__init__(self, *args) -ida_typeinf.argpartvec_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.argpartvec_t.__len__(self) -> "size_t" -ida_typeinf.argpartvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< argpart_t > const & +ida_typeinf.argpartvec_t.__ne__(self, r: "argpartvec_t") -> bool -ida_typeinf.argpartvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: argpart_t const & +ida_typeinf.argpartvec_t.__setitem__(self, i: "size_t", v: "argpart_t") -> None -ida_typeinf.argpartvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: argpart_t const & +ida_typeinf.argpartvec_t._del(self, x: "argpart_t") -> bool -ida_typeinf.argpartvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: argpart_t const & +ida_typeinf.argpartvec_t.add_unique(self, x: "argpart_t") -> bool -ida_typeinf.argpartvec_t.at (method) - at(self, _idx) -> argpart_t - - @param _idx: size_t +ida_typeinf.argpartvec_t.append(self, x: "argpart_t") -> None -ida_typeinf.argpartvec_t.begin (method) - begin(self) -> argpart_t +ida_typeinf.argpartvec_t.at(self, _idx: "size_t") -> "argpart_t const &" -ida_typeinf.argpartvec_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.argpartvec_t.begin(self, *args) -> "qvector< argpart_t >::const_iterator" -ida_typeinf.argpartvec_t.clear (method) - clear(self) +ida_typeinf.argpartvec_t.capacity(self) -> "size_t" -ida_typeinf.argpartvec_t.empty (method) - empty(self) -> bool +ida_typeinf.argpartvec_t.clear(self) -> None -ida_typeinf.argpartvec_t.end (method) - end(self) -> argpart_t +ida_typeinf.argpartvec_t.empty(self) -> bool -ida_typeinf.argpartvec_t.erase (method) - erase(self, it) -> argpart_t - - @param it: qvector< argpart_t >::iterator - - erase(self, first, last) -> argpart_t - - @param first: qvector< argpart_t >::iterator - @param last: qvector< argpart_t >::iterator +ida_typeinf.argpartvec_t.end(self, *args) -> "qvector< argpart_t >::const_iterator" -ida_typeinf.argpartvec_t.extract (method) - extract(self) -> argpart_t +ida_typeinf.argpartvec_t.erase(self, *args) -> "qvector< argpart_t >::iterator" -ida_typeinf.argpartvec_t.find (method) - find(self, x) -> argpart_t - - @param x: argpart_t const & +ida_typeinf.argpartvec_t.extend(self, x: "argpartvec_t") -> None -ida_typeinf.argpartvec_t.grow (method) - grow(self, x=argpart_t()) - - @param x: argpart_t const & +ida_typeinf.argpartvec_t.extract(self) -> "argpart_t *" -ida_typeinf.argpartvec_t.has (method) - has(self, x) -> bool - - @param x: argpart_t const & +ida_typeinf.argpartvec_t.find(self, *args) -> "qvector< argpart_t >::const_iterator" -ida_typeinf.argpartvec_t.inject (method) - inject(self, s, len) - - @param s: argpart_t * - @param len: size_t +ida_typeinf.argpartvec_t.grow(self, *args) -> None -ida_typeinf.argpartvec_t.insert (method) - insert(self, it, x) -> argpart_t - - @param it: qvector< argpart_t >::iterator - @param x: argpart_t const & +ida_typeinf.argpartvec_t.has(self, x: "argpart_t") -> bool -ida_typeinf.argpartvec_t.pop_back (method) - pop_back(self) +ida_typeinf.argpartvec_t.inject(self, s: "argpart_t", len: "size_t") -> None -ida_typeinf.argpartvec_t.push_back (method) - push_back(self, x) - - @param x: argpart_t const & - - push_back(self) -> argpart_t +ida_typeinf.argpartvec_t.insert(self, it: "argpart_t", x: "argpart_t") -> "qvector< argpart_t >::iterator" -ida_typeinf.argpartvec_t.qclear (method) - qclear(self) +ida_typeinf.argpartvec_t.pop_back(self) -> None -ida_typeinf.argpartvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.argpartvec_t.push_back(self, *args) -> "argpart_t &" -ida_typeinf.argpartvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: argpart_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.argpartvec_t.qclear(self) -> None -ida_typeinf.argpartvec_t.size (method) - size(self) -> size_t +ida_typeinf.argpartvec_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.argpartvec_t.swap (method) - swap(self, r) - - @param r: qvector< argpart_t > & +ida_typeinf.argpartvec_t.resize(self, *args) -> None -ida_typeinf.argpartvec_t.truncate (method) - truncate(self) +ida_typeinf.argpartvec_t.size(self) -> "size_t" -ida_typeinf.argtinfo_helper_t (class) - Proxy of C++ argtinfo_helper_t class. +ida_typeinf.argpartvec_t.swap(self, r: "argpartvec_t") -> None -ida_typeinf.argtinfo_helper_t.__disown__ (method) +ida_typeinf.argpartvec_t.truncate(self) -> None -ida_typeinf.argtinfo_helper_t.__init__ (method) - __init__(self) -> argtinfo_helper_t - - @param self: PyObject * +ida_typeinf.argtinfo_helper_t -ida_typeinf.argtinfo_helper_t.has_delay_slot (method) - has_delay_slot(self, arg0) -> bool +ida_typeinf.argtinfo_helper_t.__disown__(self) + +ida_typeinf.argtinfo_helper_t.__init__(self) + +ida_typeinf.argtinfo_helper_t.has_delay_slot(self, arg0: ida_idaapi.ea_t) -> bool The call instruction with a delay slot?. - - @param arg0: ea_t -ida_typeinf.argtinfo_helper_t.is_stkarg_load (method) - is_stkarg_load(self, insn, src, dst) -> bool +ida_typeinf.argtinfo_helper_t.is_stkarg_load(self, insn: "insn_t const &", src: "int *", dst: "int *") -> bool Is the current insn a stkarg load?. if yes: * src: index of the source operand in insn_t::ops - * dst: index of the destination operand in insn_t::ops insn_t::ops[dst].addr is - expected to have the stack offset + * dst: index of the destination operand in insn_t::ops insn_t::ops[dst].addr is expected to have the stack offset - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param src: (C++: int *) - @param dst: (C++: int *) + + -ida_typeinf.argtinfo_helper_t.set_op_tinfo (method) - set_op_tinfo(self, insn, x, tif, name) -> bool +ida_typeinf.argtinfo_helper_t.set_op_tinfo(self, insn: "insn_t const &", x: "op_t const &", tif: "tinfo_t", name: str) -> bool Set the operand type as specified. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: (C++: const op_t &) op_t const & - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param name: (C++: const char *) char const * -ida_typeinf.argtinfo_helper_t.use_arg_tinfos (method) - use_arg_tinfos(self, caller, fti, rargs) - This function is to be called by the processor module in response to - ev_use_arg_types. - - @param caller: (C++: ea_t) - @param fti: (C++: func_type_data_t *) - @param rargs: (C++: funcargvec_t *) +ida_typeinf.argtinfo_helper_t.use_arg_tinfos(self, caller: ida_idaapi.ea_t, fti: "func_type_data_t", rargs: "funcargvec_t") -> None + This function is to be called by the processor module in response to ev_use_arg_types. + -ida_typeinf.array_type_data_t (class) - Proxy of C++ array_type_data_t class. +ida_typeinf.array_type_data_t -ida_typeinf.array_type_data_t.__init__ (method) - __init__(self, b=0, n=0) -> array_type_data_t - - @param b: size_t - @param n: size_t +ida_typeinf.array_type_data_t.__init__(self, b: "size_t" = 0, n: "size_t" = 0) -ida_typeinf.array_type_data_t.base (variable) +ida_typeinf.array_type_data_t.base array base -ida_typeinf.array_type_data_t.elem_type (variable) +ida_typeinf.array_type_data_t.elem_type element type -ida_typeinf.array_type_data_t.nelems (variable) +ida_typeinf.array_type_data_t.nelems number of elements -ida_typeinf.array_type_data_t.swap (method) - swap(self, r) +ida_typeinf.array_type_data_t.swap(self, r: "array_type_data_t") -> None set this = r and r = this - - @param r: (C++: array_type_data_t &) -ida_typeinf.begin_type_updating (function) - begin_type_updating(utp) - Mark the beginning of a large update operation on the types. Can be used with - add_enum_member(), add_struc_member, etc... Also see end_type_updating() - - @param utp: (C++: update_type_t) enum update_type_t +ida_typeinf.begin_type_updating(utp: "update_type_t") -> None + Mark the beginning of a large update operation on the types. Can be used with add_enum_member(), add_struc_member, etc... Also see end_type_updating() + -ida_typeinf.bitfield_type_data_t (class) - Proxy of C++ bitfield_type_data_t class. +ida_typeinf.bitfield_type_data_t -ida_typeinf.bitfield_type_data_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bitfield_type_data_t const & +ida_typeinf.bitfield_type_data_t.__eq__(self, r: "bitfield_type_data_t") -> bool -ida_typeinf.bitfield_type_data_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bitfield_type_data_t const & +ida_typeinf.bitfield_type_data_t.__ge__(self, r: "bitfield_type_data_t") -> bool -ida_typeinf.bitfield_type_data_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bitfield_type_data_t const & +ida_typeinf.bitfield_type_data_t.__gt__(self, r: "bitfield_type_data_t") -> bool -ida_typeinf.bitfield_type_data_t.__init__ (method) - __init__(self, _nbytes=0, _width=0, _is_unsigned=False) -> bitfield_type_data_t - - @param _nbytes: uchar - @param _width: uchar - @param _is_unsigned: bool +ida_typeinf.bitfield_type_data_t.__init__(self, _nbytes: "uchar" = 0, _width: "uchar" = 0, _is_unsigned: bool = False) -ida_typeinf.bitfield_type_data_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bitfield_type_data_t const & +ida_typeinf.bitfield_type_data_t.__le__(self, r: "bitfield_type_data_t") -> bool -ida_typeinf.bitfield_type_data_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bitfield_type_data_t const & +ida_typeinf.bitfield_type_data_t.__lt__(self, r: "bitfield_type_data_t") -> bool -ida_typeinf.bitfield_type_data_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bitfield_type_data_t const & +ida_typeinf.bitfield_type_data_t.__ne__(self, r: "bitfield_type_data_t") -> bool -ida_typeinf.bitfield_type_data_t.compare (method) - compare(self, r) -> int - - @param r: bitfield_type_data_t const & +ida_typeinf.bitfield_type_data_t.compare(self, r: "bitfield_type_data_t") -> int -ida_typeinf.bitfield_type_data_t.is_unsigned (variable) +ida_typeinf.bitfield_type_data_t.is_unsigned is bitfield unsigned? -ida_typeinf.bitfield_type_data_t.is_valid_bitfield (method) - is_valid_bitfield(self) -> bool +ida_typeinf.bitfield_type_data_t.is_valid_bitfield(self) -> bool -ida_typeinf.bitfield_type_data_t.nbytes (variable) +ida_typeinf.bitfield_type_data_t.nbytes enclosing type size (1,2,4,8 bytes) -ida_typeinf.bitfield_type_data_t.swap (method) - swap(self, r) - - @param r: bitfield_type_data_t & +ida_typeinf.bitfield_type_data_t.swap(self, r: "bitfield_type_data_t") -> None -ida_typeinf.bitfield_type_data_t.width (variable) +ida_typeinf.bitfield_type_data_t.width number of bits -ida_typeinf.calc_c_cpp_name (function) - calc_c_cpp_name(name, type, ccn_flags) -> str - Get C or C++ form of the name. - - @param name: (C++: const char *) original (mangled or decorated) name - @param type: (C++: const tinfo_t *) name type if known, otherwise nullptr - @param ccn_flags: (C++: int) one of C/C++ naming flags +ida_typeinf.calc_c_cpp_name(name: str, type: "tinfo_t", ccn_flags: int) -> str + Get C or C++ form of the name. + + @param name: original (mangled or decorated) name + @param type: name type if known, otherwise nullptr + @param ccn_flags: one of C/C++ naming flags -ida_typeinf.calc_number_of_children (function) - calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int - Calculate max number of lines of a formatted c data, when expanded (PTV_EXPAND). - - @param loc: (C++: const argloc_t &) location of the data (ALOC_STATIC or ALOC_CUSTOM) - @param tif: (C++: const tinfo_t &) type info - @param dont_deref_ptr: (C++: bool) consider 'ea' as the ptr value +ida_typeinf.calc_number_of_children(loc: "argloc_t", tif: "tinfo_t", dont_deref_ptr: bool = False) -> int + Calculate max number of lines of a formatted c data, when expanded (PTV_EXPAND). + + @param loc: location of the data (ALOC_STATIC or ALOC_CUSTOM) + @param tif: type info + @param dont_deref_ptr: consider 'ea' as the ptr value @retval 0: data is not expandable @retval -1: error, see qerrno @retval else: the max number of lines -ida_typeinf.calc_tinfo_gaps (function) - calc_tinfo_gaps(out, typid) -> bool - - @param out: rangeset_t * - @param typid: uint32 +ida_typeinf.calc_tinfo_gaps(out: "rangeset_t", typid: "typid_t") -> bool -ida_typeinf.calc_type_size (function) - calc_type_size(ti, tp) -> PyObject * +ida_typeinf.calc_type_size(til: til_t, type: bytes) Returns the size of a type - - @param ti: Type info library. 'None' can be passed. - @param tp: serialized type byte string - @return: - None on failure + @param til: Type info library. 'None' can be passed. + @param type: serialized type byte string + @return: + - None on failure - The size of the type -ida_typeinf.callregs_t (class) - Proxy of C++ callregs_t class. +ida_typeinf.callregs_t -ida_typeinf.callregs_t.__init__ (method) - __init__(self) -> callregs_t - __init__(self, cc) -> callregs_t - - @param cc: cm_t +ida_typeinf.callregs_t.__init__(self, *args) -ida_typeinf.callregs_t.by_slots (method) - by_slots(self) -> bool +ida_typeinf.callregs_t.by_slots(self) -> bool -ida_typeinf.callregs_t.fpregs (variable) +ida_typeinf.callregs_t.fpregs array of fp registers -ida_typeinf.callregs_t.gpregs (variable) +ida_typeinf.callregs_t.gpregs array of gp registers -ida_typeinf.callregs_t.init_regs (method) - init_regs(self, cc) +ida_typeinf.callregs_t.init_regs(self, cc: "cm_t") -> None Init policy & registers for given CC. - - @param cc: (C++: cm_t) -ida_typeinf.callregs_t.nregs (variable) +ida_typeinf.callregs_t.nregs max number of registers that can be used in a call -ida_typeinf.callregs_t.policy (variable) +ida_typeinf.callregs_t.policy argument policy -ida_typeinf.callregs_t.regcount (method) - regcount(cc) -> int +ida_typeinf.callregs_t.regcount(cc: "cm_t") -> int Get max number of registers may be used in a function call. - - @param cc: (C++: cm_t) -ida_typeinf.callregs_t.reginds (method) - reginds(self, gp_ind, fp_ind, r) -> bool - Get register indexes within GP/FP arrays. (-1 -> is not present in the - corresponding array) - - @param gp_ind: (C++: int *) - @param fp_ind: (C++: int *) - @param r: (C++: int) +ida_typeinf.callregs_t.reginds(self, gp_ind: "int *", fp_ind: "int *", r: int) -> bool + Get register indexes within GP/FP arrays. (-1 -> is not present in the corresponding array) + -ida_typeinf.callregs_t.reset (method) - reset(self) +ida_typeinf.callregs_t.reset(self) -> None Set policy and registers to invalid values. -ida_typeinf.callregs_t.set (method) - set(self, _policy, gprs, fprs) +ida_typeinf.callregs_t.set(self, _policy: "argreg_policy_t", gprs: "int const *", fprs: "int const *") -> None Init policy & registers (arrays are -1-terminated) - - @param _policy: (C++: argreg_policy_t) enum argreg_policy_t - @param gprs: (C++: const int *) int const * - @param fprs: (C++: const int *) int const * -ida_typeinf.callregs_t.swap (method) - swap(self, r) +ida_typeinf.callregs_t.set_registers(self, kind: "callregs_t::reg_kind_t", first_reg: int, last_reg: int) -> None + +ida_typeinf.callregs_t.swap(self, r: "callregs_t") -> None swap two instances - - @param r: (C++: callregs_t &) -ida_typeinf.callregs_t_regcount (function) - callregs_t_regcount(cc) -> int - - @param cc: cm_t +ida_typeinf.choose_local_tinfo(ti: "til_t", title: str, func: "local_tinfo_predicate_t *" = None, def_ord: int = 0, ud: "void *" = None) -> int + Choose a type from the local type library. + + @param ti: pointer to til + @param title: title of listbox to display + @param func: predicate to select types to display (maybe nullptr) + @param def_ord: ordinal to position cursor before choose + @param ud: user data + @returns == 0 means nothing is chosen, otherwise an ordinal number -ida_typeinf.choose_local_tinfo (function) - choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None) -> uint32 - Choose a type from the local type library. - - @param ti: (C++: const til_t *) pointer to til - @param title: (C++: const char *) title of listbox to display - @param func: (C++: local_tinfo_predicate_t *) predicate to select types to display (maybe nullptr) - @param def_ord: (C++: uint32) ordinal to position cursor before choose - @param ud: (C++: void *) user data - @return: == 0 means nothing is chosen, otherwise an ordinal number +ida_typeinf.choose_local_tinfo_and_delta(delta: "int32 *", ti: "til_t", title: str, func: "local_tinfo_predicate_t *" = None, def_ord: int = 0, ud: "void *" = None) -> int + Choose a type from the local type library and specify the pointer shift value. + + @param delta: pointer shift value + @param ti: pointer to til + @param title: title of listbox to display + @param func: predicate to select types to display (maybe nullptr) + @param def_ord: ordinal to position cursor before choose + @param ud: user data + @returns == 0 means nothing is chosen, otherwise an ordinal number -ida_typeinf.choose_local_tinfo_and_delta (function) - choose_local_tinfo_and_delta(delta, ti, title, func=None, def_ord=0, ud=None) -> uint32 - Choose a type from the local type library and specify the pointer shift value. - - @param delta: (C++: int32 *) pointer shift value - @param ti: (C++: const til_t *) pointer to til - @param title: (C++: const char *) title of listbox to display - @param func: (C++: local_tinfo_predicate_t *) predicate to select types to display (maybe nullptr) - @param def_ord: (C++: uint32) ordinal to position cursor before choose - @param ud: (C++: void *) user data - @return: == 0 means nothing is chosen, otherwise an ordinal number +ida_typeinf.choose_named_type(out_sym: "til_symbol_t", root_til: "til_t", title: str, ntf_flags: int, predicate: "predicate_t" = None) -> bool + Choose a type from a type library. + + @param out_sym: pointer to be filled with the chosen type + @param root_til: pointer to starting til (the function will inspect the base tils if allowed by flags) + @param title: title of listbox to display + @param ntf_flags: combination of Flags for named types + @param predicate: predicate to select types to display (maybe nullptr) + @returns false if nothing is chosen, otherwise true -ida_typeinf.choose_named_type (function) - choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None) -> bool - Choose a type from a type library. - - @param out_sym: (C++: til_symbol_t *) pointer to be filled with the chosen type - @param root_til: (C++: const til_t *) pointer to starting til (the function will inspect the base - tils if allowed by flags) - @param title: (C++: const char *) title of listbox to display - @param ntf_flags: (C++: int) combination of Flags for named types - @param predicate: (C++: predicate_t *) predicate to select types to display (maybe nullptr) - @return: false if nothing is chosen, otherwise true +ida_typeinf.clear_tinfo_t(_this: "tinfo_t") -> None -ida_typeinf.clear_tinfo_t (function) - clear_tinfo_t(_this) - - @param _this: tinfo_t * +ida_typeinf.compact_til(ti: "til_t") -> bool + Collect garbage in til. Must be called before storing the til. + + @returns true if any memory was freed -ida_typeinf.compact_til (function) - compact_til(ti) -> bool - Collect garbage in til. Must be called before storing the til. - - @param ti: (C++: til_t *) - @return: true if any memory was freed +ida_typeinf.compare_tinfo(t1: "typid_t", t2: "typid_t", tcflags: int) -> bool -ida_typeinf.compare_tinfo (function) - compare_tinfo(t1, t2, tcflags) -> bool - - @param t1: uint32 - @param t2: uint32 - @param tcflags: int +ida_typeinf.const_aloc_visitor_t -ida_typeinf.const_aloc_visitor_t (class) - Proxy of C++ const_aloc_visitor_t class. +ida_typeinf.const_aloc_visitor_t.__disown__(self) -ida_typeinf.const_aloc_visitor_t.__disown__ (method) +ida_typeinf.const_aloc_visitor_t.__init__(self) -ida_typeinf.const_aloc_visitor_t.__init__ (method) - __init__(self) -> const_aloc_visitor_t - - @param self: PyObject * +ida_typeinf.const_aloc_visitor_t.visit_location(self, v: "argloc_t", off: int, size: int) -> int -ida_typeinf.const_aloc_visitor_t.visit_location (method) - visit_location(self, v, off, size) -> int - - @param v: argloc_t const & - @param off: int - @param size: int +ida_typeinf.convert_pt_flags_to_hti(pt_flags: int) -> int + Convert Type parsing flags to Type formatting flags. Type parsing flags lesser than 0x10 don't have stable meaning and will be ignored (more on these flags can be seen in idc.idc) + -ida_typeinf.convert_pt_flags_to_hti (function) - convert_pt_flags_to_hti(pt_flags) -> int - Convert Type parsing flags to Type formatting flags. Type parsing flags lesser - than 0x10 don't have stable meaning and will be ignored (more on these flags can - be seen in idc.idc) - - @param pt_flags: (C++: int) +ida_typeinf.copy_named_type(dsttil: "til_t", srctil: "til_t", name: str) -> int + Copy a named type from one til to another. This function will copy the specified type and all dependent types from the source type library to the destination library. + + @param dsttil: Destination til. It must have original types enabled + @param srctil: Source til. + @param name: name of the type to copy + @returns ordinal number of the copied type. 0 means error -ida_typeinf.copy_named_type (function) - copy_named_type(dsttil, srctil, name) -> uint32 - Copy a named type from one til to another. This function will copy the specified - type and all dependent types from the source type library to the destination - library. - - @param dsttil: (C++: til_t *) Destination til. It must have orginal types enabled - @param srctil: (C++: const til_t *) Source til. - @param name: (C++: const char *) name of the type to copy - @return: ordinal number of the copied type. 0 means error +ida_typeinf.copy_tinfo_t(_this: "tinfo_t", r: "tinfo_t") -> None -ida_typeinf.copy_tinfo_t (function) - copy_tinfo_t(_this, r) - - @param _this: tinfo_t * - @param r: tinfo_t const & +ida_typeinf.create_enum_type(enum_name: str, ei: "enum_type_data_t", enum_width: int, sign: "type_sign_t", convert_to_bitmask: bool, enum_cmt: str = None) -> "tid_t" + Create type enum + + @param enum_name: type name + @param ei: enum type data + @param enum_width: the width of an enum element allowed values: 0 (unspecified),1,2,4,8,16,32,64 + @param sign: enum sign + @param convert_to_bitmask: try convert enum to bitmask enum + @param enum_cmt: enum type comment + @returns enum TID -ida_typeinf.create_enum_type (function) - create_enum_type(enum_name, ei, enum_width, sign, convert_to_bitmask, enum_cmt=None) -> tid_t - Create type enum - - @param enum_name: (C++: const char *) type name - @param ei: (C++: enum_type_data_t &) enum type data - @param enum_width: (C++: int) the width of an enum element allowed values: 0 - (unspecified),1,2,4,8,16,32,64 - @param sign: (C++: type_sign_t) enum sign - @param convert_to_bitmask: (C++: bool) try convert enum to bitmask enum - @param enum_cmt: (C++: const char *) enum type comment - @return: enum TID +ida_typeinf.create_numbered_type_name(ord: int) -> str + Create anonymous name for numbered type. This name can be used to reference a numbered type by its ordinal Ordinal names have the following format: '#' + set_de(ord) Returns: -1 if error, otherwise the name length + -ida_typeinf.create_numbered_type_name (function) - create_numbered_type_name(ord) -> str - Create anonymous name for numbered type. This name can be used to reference a - numbered type by its ordinal Ordinal names have the following format: '#' + - set_de(ord) Returns: -1 if error, otherwise the name length - - @param ord: (C++: int32) +ida_typeinf.create_tinfo(_this: "tinfo_t", bt: "type_t", bt2: "type_t", ptr: "void *") -> bool -ida_typeinf.create_tinfo (function) - create_tinfo(_this, bt, bt2, ptr) -> bool - - @param _this: tinfo_t * - @param bt: type_t - @param bt2: type_t - @param ptr: void * +ida_typeinf.custom_data_type_info_t -ida_typeinf.create_tinfo2 (function) - create_tinfo2(_this, bt, bt2, ptr) -> bool - - @param _this: tinfo_t * - @param bt: type_t - @param bt2: type_t - @param ptr: void * +ida_typeinf.custom_data_type_info_t.__init__(self) -ida_typeinf.custom_data_type_info_t (class) - Proxy of C++ custom_data_type_info_t class. - -ida_typeinf.custom_data_type_info_t.__init__ (method) - __init__(self) -> custom_data_type_info_t - -ida_typeinf.custom_data_type_info_t.dtid (variable) +ida_typeinf.custom_data_type_info_t.dtid data type id -ida_typeinf.custom_data_type_info_t.fid (variable) +ida_typeinf.custom_data_type_info_t.fid data format ids -ida_typeinf.default_compiler (function) - default_compiler() -> comp_t +ida_typeinf.default_compiler() -> "comp_t" Get compiler specified by inf.cc. -ida_typeinf.del_named_type (function) - del_named_type(ti, name, ntf_flags) -> bool - Delete information about a symbol. - - @param ti: (C++: til_t *) type library - @param name: (C++: const char *) name of symbol - @param ntf_flags: (C++: int) combination of Flags for named types - @return: success +ida_typeinf.del_named_type(ti: "til_t", name: str, ntf_flags: int) -> bool + Delete information about a symbol. + + @param ti: type library + @param name: name of symbol + @param ntf_flags: combination of Flags for named types + @returns success -ida_typeinf.del_numbered_type (function) - del_numbered_type(ti, ordinal) -> bool +ida_typeinf.del_numbered_type(ti: "til_t", ordinal: int) -> bool Delete a numbered type. - - @param ti: (C++: til_t *) - @param ordinal: (C++: uint32) -ida_typeinf.del_til (function) - del_til(name) -> bool +ida_typeinf.del_til(name: str) -> bool Unload a til file. - - @param name: (C++: const char *) char const * -ida_typeinf.del_tinfo_attr (function) - del_tinfo_attr(tif, key, make_copy) -> bool - - @param tif: tinfo_t * - @param key: qstring const & - @param make_copy: bool +ida_typeinf.del_tinfo_attr(tif: "tinfo_t", key: str, make_copy: bool) -> bool -ida_typeinf.del_vftable_ea (function) - del_vftable_ea(ordinal) -> bool - Delete the address of a vftable instance for a vftable type. - - @param ordinal: (C++: uint32) ordinal number of a vftable type. - @return: success +ida_typeinf.del_vftable_ea(ordinal: int) -> bool + Delete the address of a vftable instance for a vftable type. + + @param ordinal: ordinal number of a vftable type. + @returns success -ida_typeinf.deref_ptr (function) - deref_ptr(ptr_ea, tif, closure_obj=None) -> bool - Dereference a pointer. - - @param ptr_ea: (C++: ea_t *) in/out parameter +ida_typeinf.deref_ptr(ptr_ea: "ea_t *", tif: "tinfo_t", closure_obj: "ea_t *" = None) -> bool + Dereference a pointer. + + @param ptr_ea: in/out parameter * in: address of the pointer * out: the pointed address - @param tif: (C++: const tinfo_t &) type of the pointer - @param closure_obj: (C++: ea_t *) closure object (not used yet) - @return: success + @param tif: type of the pointer + @param closure_obj: closure object (not used yet) + @returns success -ida_typeinf.deserialize_tinfo (function) - deserialize_tinfo(tif, til, ptype, pfields, pfldcmts, cmt=None) -> bool - - @param tif: tinfo_t * - @param til: til_t const * - @param ptype: type_t const ** - @param pfields: p_list const ** - @param pfldcmts: p_list const ** - @param cmt: char const * +ida_typeinf.deserialize_tinfo(tif: "tinfo_t", til: "til_t", ptype: "type_t const **", pfields: "p_list const **", pfldcmts: "p_list const **", cmt: str = None) -> bool -ida_typeinf.dstr_tinfo (function) - dstr_tinfo(tif) -> char const * - - @param tif: tinfo_t const * +ida_typeinf.detach_tinfo_t(_this: "tinfo_t") -> bool -ida_typeinf.dump_func_type_data (function) - dump_func_type_data(fti, praloc_bits) -> str +ida_typeinf.dstr_tinfo(tif: "tinfo_t") -> str + +ida_typeinf.dump_func_type_data(fti: "func_type_data_t", praloc_bits: int) -> str Use func_type_data_t::dump() + +ida_typeinf.edm_t + +ida_typeinf.edm_t.__eq__(self, r: "edm_t") -> bool + +ida_typeinf.edm_t.__init__(self, *args) + Create an enumerator, with the specified name and value - @param fti: (C++: const func_type_data_t &) func_type_data_t const & - @param praloc_bits: (C++: int) - -ida_typeinf.edm_t (class) - Proxy of C++ edm_t class. - -ida_typeinf.edm_t.__eq__ (method) - __eq__(self, r) -> bool + This constructor has the following signatures: - @param r: edm_t const & - -ida_typeinf.edm_t.__init__ (method) - __init__(self) -> edm_t - -ida_typeinf.edm_t.__ne__ (method) - __ne__(self, r) -> bool + 1. edm_t(edm: edm_t) + 2. edm_t(name: str, value: int, cmt: str=None) - @param r: edm_t const & + @param name Enumerator name. Must not be empty (1st form) + @param value Enumerator value (1st form) + @param cmt Enumerator repeatable comment. May be empty (1st form) + @param edm An enum member to copy -ida_typeinf.edm_t.get_tid (method) - get_tid(self) -> tid_t +ida_typeinf.edm_t.__ne__(self, r: "edm_t") -> bool -ida_typeinf.edm_t.swap (method) - swap(self, r) - - @param r: edm_t & +ida_typeinf.edm_t.empty(self) -> bool -ida_typeinf.edmvec_t (class) - Proxy of C++ qvector< edm_t > class. +ida_typeinf.edm_t.get_tid(self) -> "tid_t" -ida_typeinf.edmvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< edm_t > const & +ida_typeinf.edm_t.swap(self, r: "edm_t") -> None -ida_typeinf.edmvec_t.__getitem__ (method) - __getitem__(self, i) -> edm_t - - @param i: size_t +ida_typeinf.edmvec_t -ida_typeinf.edmvec_t.__init__ (method) - __init__(self) -> edmvec_t - __init__(self, x) -> edmvec_t - - @param x: qvector< edm_t > const & +ida_typeinf.edmvec_t.__eq__(self, r: "edmvec_t") -> bool -ida_typeinf.edmvec_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.edmvec_t.__getitem__(self, i: "size_t") -> "edm_t const &" -ida_typeinf.edmvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< edm_t > const & +ida_typeinf.edmvec_t.__init__(self, *args) -ida_typeinf.edmvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: edm_t const & +ida_typeinf.edmvec_t.__len__(self) -> "size_t" -ida_typeinf.edmvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: edm_t const & +ida_typeinf.edmvec_t.__ne__(self, r: "edmvec_t") -> bool -ida_typeinf.edmvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: edm_t const & +ida_typeinf.edmvec_t.__setitem__(self, i: "size_t", v: "edm_t") -> None -ida_typeinf.edmvec_t.at (method) - at(self, _idx) -> edm_t - - @param _idx: size_t +ida_typeinf.edmvec_t._del(self, x: "edm_t") -> bool -ida_typeinf.edmvec_t.begin (method) - begin(self) -> edm_t +ida_typeinf.edmvec_t.add_unique(self, x: "edm_t") -> bool -ida_typeinf.edmvec_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.edmvec_t.append(self, x: "edm_t") -> None -ida_typeinf.edmvec_t.clear (method) - clear(self) +ida_typeinf.edmvec_t.at(self, _idx: "size_t") -> "edm_t const &" -ida_typeinf.edmvec_t.empty (method) - empty(self) -> bool +ida_typeinf.edmvec_t.begin(self, *args) -> "qvector< edm_t >::const_iterator" -ida_typeinf.edmvec_t.end (method) - end(self) -> edm_t +ida_typeinf.edmvec_t.capacity(self) -> "size_t" -ida_typeinf.edmvec_t.erase (method) - erase(self, it) -> edm_t - - @param it: qvector< edm_t >::iterator - - erase(self, first, last) -> edm_t - - @param first: qvector< edm_t >::iterator - @param last: qvector< edm_t >::iterator +ida_typeinf.edmvec_t.clear(self) -> None -ida_typeinf.edmvec_t.extract (method) - extract(self) -> edm_t +ida_typeinf.edmvec_t.empty(self) -> bool -ida_typeinf.edmvec_t.find (method) - find(self, x) -> edm_t - - @param x: edm_t const & +ida_typeinf.edmvec_t.end(self, *args) -> "qvector< edm_t >::const_iterator" -ida_typeinf.edmvec_t.grow (method) - grow(self, x=edm_t()) - - @param x: edm_t const & +ida_typeinf.edmvec_t.erase(self, *args) -> "qvector< edm_t >::iterator" -ida_typeinf.edmvec_t.has (method) - has(self, x) -> bool - - @param x: edm_t const & +ida_typeinf.edmvec_t.extend(self, x: "edmvec_t") -> None -ida_typeinf.edmvec_t.inject (method) - inject(self, s, len) - - @param s: edm_t * - @param len: size_t +ida_typeinf.edmvec_t.extract(self) -> "edm_t *" -ida_typeinf.edmvec_t.insert (method) - insert(self, it, x) -> edm_t - - @param it: qvector< edm_t >::iterator - @param x: edm_t const & +ida_typeinf.edmvec_t.find(self, *args) -> "qvector< edm_t >::const_iterator" -ida_typeinf.edmvec_t.pop_back (method) - pop_back(self) +ida_typeinf.edmvec_t.grow(self, *args) -> None -ida_typeinf.edmvec_t.push_back (method) - push_back(self, x) - - @param x: edm_t const & - - push_back(self) -> edm_t +ida_typeinf.edmvec_t.has(self, x: "edm_t") -> bool -ida_typeinf.edmvec_t.qclear (method) - qclear(self) +ida_typeinf.edmvec_t.inject(self, s: "edm_t", len: "size_t") -> None -ida_typeinf.edmvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.edmvec_t.insert(self, it: "edm_t", x: "edm_t") -> "qvector< edm_t >::iterator" -ida_typeinf.edmvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: edm_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.edmvec_t.pop_back(self) -> None -ida_typeinf.edmvec_t.size (method) - size(self) -> size_t +ida_typeinf.edmvec_t.push_back(self, *args) -> "edm_t &" -ida_typeinf.edmvec_t.swap (method) - swap(self, r) - - @param r: qvector< edm_t > & +ida_typeinf.edmvec_t.qclear(self) -> None -ida_typeinf.edmvec_t.truncate (method) - truncate(self) +ida_typeinf.edmvec_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.enable_numbered_types (function) - enable_numbered_types(ti, enable) -> bool - Enable the use of numbered types in til. Currently it is impossible to disable - numbered types once they are enabled - - @param ti: (C++: til_t *) - @param enable: (C++: bool) +ida_typeinf.edmvec_t.resize(self, *args) -> None -ida_typeinf.end_type_updating (function) - end_type_updating(utp) - Mark the end of a large update operation on the types (see - begin_type_updating()) - - @param utp: (C++: update_type_t) enum update_type_t +ida_typeinf.edmvec_t.size(self) -> "size_t" -ida_typeinf.enum_type_data_t (class) - Proxy of C++ enum_type_data_t class. +ida_typeinf.edmvec_t.swap(self, r: "edmvec_t") -> None -ida_typeinf.enum_type_data_t.__init__ (method) - __init__(self, _bte=BTE_ALWAYS|BTE_HEX) -> enum_type_data_t - - @param _bte: bte_t +ida_typeinf.edmvec_t.truncate(self) -> None -ida_typeinf.enum_type_data_t.add_constant (method) - add_constant(self, name, value, cmt=None) +ida_typeinf.enable_numbered_types(ti: "til_t", enable: bool) -> bool + Enable the use of numbered types in til. Currently it is impossible to disable numbered types once they are enabled + + +ida_typeinf.end_type_updating(utp: "update_type_t") -> None + Mark the end of a large update operation on the types (see begin_type_updating()) + +ida_typeinf.enum_type_data_t + +ida_typeinf.enum_type_data_t.__init__(self, *args) + +ida_typeinf.enum_type_data_t.add_constant(self, name: str, value: "uint64", cmt: str = None) -> None add constant for regular enum - - @param name: (C++: const char *) char const * - @param value: (C++: uint64) - @param cmt: (C++: const char *) char const * -ida_typeinf.enum_type_data_t.bte (variable) - enum member sizes (shift amount) and style. do not manually set BTE_BITMASK, use - set_enum_is_bitmask() +ida_typeinf.enum_type_data_t.all_constants(self) + Generate tupples of all constants except of bitmasks. + Each tupple is: + [0] constant index + [1] enum member index of group start + [2] group size + In case of regular enum the second element of tupple is 0 and the third element of tupple is the number of enum members. -ida_typeinf.enum_type_data_t.calc_mask (method) - calc_mask(self) -> uint64 +ida_typeinf.enum_type_data_t.all_groups(self, skip_trivial = False) + Generate tuples for bitmask enum groups. + Each tupple is: + [0] enum member index of group start + [1] group size + Tupples may include or not the group with 1 element. -ida_typeinf.enum_type_data_t.calc_nbytes (method) - calc_nbytes(self) -> int +ida_typeinf.enum_type_data_t.bte + enum member sizes (shift amount) and style. do not manually set BTE_BITMASK, use set_enum_is_bitmask() + + +ida_typeinf.enum_type_data_t.calc_mask(self) -> "uint64" + +ida_typeinf.enum_type_data_t.calc_nbytes(self) -> int get the width of enum in bytes -ida_typeinf.enum_type_data_t.find_member (method) - find_member(self, name, _from=0, to=size_t(-1)) -> ssize_t +ida_typeinf.enum_type_data_t.find_member(self, *args) -> "ssize_t" + This function has the following signatures: + + 0. find_member(name: str, from: size_t=0, to: size_t=size_t(-1)) -> ssize_t + 1. find_member(value: uint64, serial: uchar, from: size_t=0, to: size_t=size_t(-1), vmask: uint64=uint64(-1)) -> ssize_t + + # 0: find_member(name: str, from: size_t=0, to: size_t=size_t(-1)) -> ssize_t + + find member (constant or bmask) by name + + + # 1: find_member(value: uint64, serial: uchar, from: size_t=0, to: size_t=size_t(-1), vmask: uint64=uint64(-1)) -> ssize_t + find member (constant or bmask) by value - - @param name: char const * - @param from: (C++: size_t) - @param to: (C++: size_t) - - find_member(self, value, serial, _from=0, to=size_t(-1), vmask=uint64(-1)) -> ssize_t - - @param value: uint64 - @param serial: uchar - @param from: size_t - @param to: size_t - @param vmask: uint64 -ida_typeinf.enum_type_data_t.get_constant_group (method) - get_constant_group(self, group_start_index, group_size, idx) -> bool - get group parameters for the constant, valid for etimask enum - - @param group_start_index: (C++: size_t *) index of the group mask - @param group_size: (C++: size_t *) group size (>=1) - @param idx: (C++: size_t) constant index - @return: success +ida_typeinf.enum_type_data_t.get_constant_group(self, *args) -> "PyObject *" + get group parameters for the constant, valid for bitmask enum + + @param group_start_index: index of the group mask + @param group_size: group size (>=1) + @param idx: constant index + @returns success -ida_typeinf.enum_type_data_t.get_enum_radix (method) - get_enum_radix(self) -> int - Get enum constant radix - - @return: radix or 1 for BTE_CHAR +ida_typeinf.enum_type_data_t.get_enum_radix(self) -> int + Get enum constant radix + + @returns radix or 1 for BTE_CHAR -ida_typeinf.enum_type_data_t.group_sizes (variable) - if present, specifies bitmask group sizes each non-trivial group starts with a - mask member +ida_typeinf.enum_type_data_t.get_max_serial(self, value: "uint64") -> "uchar" + return the maximum serial for the value -ida_typeinf.enum_type_data_t.has_lzero (method) - has_lzero(self) -> bool +ida_typeinf.enum_type_data_t.get_serial(self, index: "size_t") -> "uchar" + returns serial for the constant -ida_typeinf.enum_type_data_t.is_bf (method) - is_bf(self) -> bool +ida_typeinf.enum_type_data_t.get_value_repr(self, repr: "value_repr_t") -> "tinfo_code_t" + get enum radix and other representation info + + @param repr: value display info + +ida_typeinf.enum_type_data_t.group_sizes + if present, specifies bitmask group sizes each non-trivial group starts with a mask member + + +ida_typeinf.enum_type_data_t.has_lzero(self) -> bool + +ida_typeinf.enum_type_data_t.is_bf(self) -> bool is bitmask or ordinary enum? -ida_typeinf.enum_type_data_t.is_bin (method) - is_bin(self) -> bool +ida_typeinf.enum_type_data_t.is_bin(self) -> bool -ida_typeinf.enum_type_data_t.is_char (method) - is_char(self) -> bool +ida_typeinf.enum_type_data_t.is_char(self) -> bool -ida_typeinf.enum_type_data_t.is_dec (method) - is_dec(self) -> bool +ida_typeinf.enum_type_data_t.is_dec(self) -> bool -ida_typeinf.enum_type_data_t.is_group_mask_at (method) - is_group_mask_at(self, idx) -> bool - is the enum member at IDX a non-trivial group mask? a trivial group consist of - one bit and has just one member, which can be considered as a mask or a bitfield - constant - - @param idx: (C++: size_t) index - @return: success +ida_typeinf.enum_type_data_t.is_group_mask_at(self, idx: "size_t") -> bool + is the enum member at IDX a non-trivial group mask? a trivial group consist of one bit and has just one member, which can be considered as a mask or a bitfield constant + + @param idx: index + @returns success -ida_typeinf.enum_type_data_t.is_hex (method) - is_hex(self) -> bool +ida_typeinf.enum_type_data_t.is_hex(self) -> bool -ida_typeinf.enum_type_data_t.is_number_signed (method) - is_number_signed(self) -> bool +ida_typeinf.enum_type_data_t.is_number_signed(self) -> bool -ida_typeinf.enum_type_data_t.is_oct (method) - is_oct(self) -> bool +ida_typeinf.enum_type_data_t.is_oct(self) -> bool -ida_typeinf.enum_type_data_t.is_sbin (method) - is_sbin(self) -> bool +ida_typeinf.enum_type_data_t.is_sbin(self) -> bool -ida_typeinf.enum_type_data_t.is_shex (method) - is_shex(self) -> bool +ida_typeinf.enum_type_data_t.is_shex(self) -> bool -ida_typeinf.enum_type_data_t.is_soct (method) - is_soct(self) -> bool +ida_typeinf.enum_type_data_t.is_soct(self) -> bool -ida_typeinf.enum_type_data_t.is_udec (method) - is_udec(self) -> bool +ida_typeinf.enum_type_data_t.is_udec(self) -> bool -ida_typeinf.enum_type_data_t.is_valid_group_sizes (method) - is_valid_group_sizes(self) -> bool +ida_typeinf.enum_type_data_t.is_valid_group_sizes(self) -> bool is valid group sizes -ida_typeinf.enum_type_data_t.set_enum_radix (method) - set_enum_radix(self, radix, sign) - Set radix to display constants - - @param radix: (C++: int) radix with the special case 1 to display as character - @param sign: (C++: bool) +ida_typeinf.enum_type_data_t.set_enum_radix(self, radix: int, sign: bool) -> None + Set radix to display constants + + @param radix: radix with the special case 1 to display as character -ida_typeinf.enum_type_data_t.set_lzero (method) - set_lzero(self, on) - - @param on: bool +ida_typeinf.enum_type_data_t.set_lzero(self, on: bool) -> None -ida_typeinf.enum_type_data_t.set_nbytes (method) - set_nbytes(self, nbytes) -> bool +ida_typeinf.enum_type_data_t.set_nbytes(self, nbytes: int) -> bool set enum width (nbytes) - - @param nbytes: (C++: int) -ida_typeinf.enum_type_data_t.set_value_repr (method) - set_value_repr(self, repr) -> tinfo_code_t - set enum radix and other representation info - - @param repr: (C++: const value_repr_t &) value display info +ida_typeinf.enum_type_data_t.set_value_repr(self, repr: "value_repr_t") -> "tinfo_code_t" + set enum radix and other representation info + + @param repr: value display info -ida_typeinf.enum_type_data_t.store_64bit_values (method) - store_64bit_values(self) -> bool +ida_typeinf.enum_type_data_t.store_64bit_values(self) -> bool -ida_typeinf.enum_type_data_t.swap (method) - swap(self, r) +ida_typeinf.enum_type_data_t.swap(self, r: "enum_type_data_t") -> None swap two instances - - @param r: (C++: enum_type_data_t &) -ida_typeinf.enum_type_data_t.taenum_bits (variable) +ida_typeinf.enum_type_data_t.taenum_bits Type attributes for enums -ida_typeinf.enum_type_data_t__get_max_serial (function) - enum_type_data_t__get_max_serial(ei, value) -> uchar - - @param ei: enum_type_data_t const * - @param value: uint64 +ida_typeinf.extract_argloc(vloc: "argloc_t", ptype: "type_t const **", forbid_stkoff: bool) -> bool + Deserialize an argument location. Argument FORBID_STKOFF checks location type. It can be used, for example, to check the return location of a function that cannot return a value in the stack + -ida_typeinf.extract_argloc (function) - extract_argloc(vloc, ptype, forbid_stkoff) -> bool - Deserialize an argument location. Argument FORBID_STKOFF checks location type. - It can be used, for example, to check the return location of a function that - cannot return a value in the stack - - @param vloc: (C++: argloc_t *) - @param ptype: (C++: const type_t **) type_t const ** - @param forbid_stkoff: (C++: bool) +ida_typeinf.find_tinfo_udt_member(udm: "udm_t", typid: "typid_t", strmem_flags: int) -> int -ida_typeinf.find_tinfo_udt_member (function) - find_tinfo_udt_member(udm, typid, strmem_flags) -> int - - @param udm: udm_t * - @param typid: uint32 - @param strmem_flags: int +ida_typeinf.first_named_type(ti: "til_t", ntf_flags: int) -> str + Enumerate types. + + @param ti: type library. nullptr means the local type library for the current database. + @param ntf_flags: combination of Flags for named types + @returns Type or symbol names, depending of ntf_flags. Returns mangled names. Never returns anonymous types. To include them, enumerate types by ordinals. -ida_typeinf.first_named_type (function) - first_named_type(ti, ntf_flags) -> char const * - Enumerate types. - - @param ti: (C++: const til_t *) type library. nullptr means the local type library for the current - database. - @param ntf_flags: (C++: int) combination of Flags for named types - @return: Type or symbol names, depending of ntf_flags. Returns mangled names. - Never returns anonymous types. To include them, enumerate types by - ordinals. - -ida_typeinf.for_all_arglocs (function) - for_all_arglocs(vv, vloc, size, off=0) -> int +ida_typeinf.for_all_arglocs(vv: "aloc_visitor_t", vloc: "argloc_t", size: int, off: int = 0) -> int Compress larger argloc types and initiate the aloc visitor. - - @param vv: (C++: aloc_visitor_t &) - @param vloc: (C++: argloc_t &) - @param size: (C++: int) - @param off: (C++: int) -ida_typeinf.for_all_const_arglocs (function) - for_all_const_arglocs(vv, vloc, size, off=0) -> int +ida_typeinf.for_all_const_arglocs(vv: "const_aloc_visitor_t", vloc: "argloc_t", size: int, off: int = 0) -> int See for_all_arglocs() - - @param vv: (C++: const_aloc_visitor_t &) - @param vloc: (C++: const argloc_t &) argloc_t const & - @param size: (C++: int) - @param off: (C++: int) -ida_typeinf.free_til (function) - free_til(ti) +ida_typeinf.free_til(ti: "til_t") -> None Free memory allocated by til. - - @param ti: (C++: til_t *) -ida_typeinf.func_has_stkframe_hole (function) - func_has_stkframe_hole(ea, fti) -> bool - Looks for a hole at the beginning of the stack arguments. Will make use of the - IDB's func_t function at that place (if present) to help determine the presence - of such a hole. - - @param ea: (C++: ea_t) - @param fti: (C++: const func_type_data_t &) func_type_data_t const & +ida_typeinf.func_has_stkframe_hole(ea: ida_idaapi.ea_t, fti: "func_type_data_t") -> bool + Looks for a hole at the beginning of the stack arguments. Will make use of the IDB's func_t function at that place (if present) to help determine the presence of such a hole. + -ida_typeinf.func_type_data_t (class) - Proxy of C++ func_type_data_t class. +ida_typeinf.func_type_data_t -ida_typeinf.func_type_data_t.__init__ (method) - __init__(self) -> func_type_data_t +ida_typeinf.func_type_data_t.__init__(self) -ida_typeinf.func_type_data_t.cc (variable) +ida_typeinf.func_type_data_t.cc calling convention -ida_typeinf.func_type_data_t.dump (method) - dump(self, praloc_bits=0x02) -> bool - Dump information that is not always visible in the function prototype. (argument - locations, return location, total stkarg size) - - @param praloc_bits: (C++: int) +ida_typeinf.func_type_data_t.dump(self, praloc_bits: int = 2) -> bool + Dump information that is not always visible in the function prototype. (argument locations, return location, total stkarg size) + -ida_typeinf.func_type_data_t.flags (variable) - Function type data property bits +ida_typeinf.func_type_data_t.find_argument(self, *args) -> "ssize_t" + find argument by name -ida_typeinf.func_type_data_t.get_call_method (method) - get_call_method(self) -> int +ida_typeinf.func_type_data_t.flags + Function type data property bits + -ida_typeinf.func_type_data_t.guess_cc (method) - guess_cc(self, purged, cc_flags) -> cm_t - Guess function calling convention use the following info: argument locations and - 'stkargs' - - @param purged: (C++: int) - @param cc_flags: (C++: int) +ida_typeinf.func_type_data_t.get_call_method(self) -> int -ida_typeinf.func_type_data_t.is_const (method) - is_const(self) -> bool +ida_typeinf.func_type_data_t.guess_cc(self, purged: int, cc_flags: int) -> "cm_t" + Guess function calling convention use the following info: argument locations and 'stkargs' + -ida_typeinf.func_type_data_t.is_ctor (method) - is_ctor(self) -> bool +ida_typeinf.func_type_data_t.is_const(self) -> bool -ida_typeinf.func_type_data_t.is_dtor (method) - is_dtor(self) -> bool +ida_typeinf.func_type_data_t.is_ctor(self) -> bool -ida_typeinf.func_type_data_t.is_golang_cc (method) - is_golang_cc(self) -> bool +ida_typeinf.func_type_data_t.is_dtor(self) -> bool -ida_typeinf.func_type_data_t.is_high (method) - is_high(self) -> bool +ida_typeinf.func_type_data_t.is_golang_cc(self) -> bool -ida_typeinf.func_type_data_t.is_noret (method) - is_noret(self) -> bool +ida_typeinf.func_type_data_t.is_high(self) -> bool -ida_typeinf.func_type_data_t.is_pure (method) - is_pure(self) -> bool +ida_typeinf.func_type_data_t.is_noret(self) -> bool -ida_typeinf.func_type_data_t.is_static (method) - is_static(self) -> bool +ida_typeinf.func_type_data_t.is_pure(self) -> bool -ida_typeinf.func_type_data_t.is_swift_cc (method) - is_swift_cc(self) -> bool +ida_typeinf.func_type_data_t.is_static(self) -> bool -ida_typeinf.func_type_data_t.is_vararg_cc (method) - is_vararg_cc(self) -> bool +ida_typeinf.func_type_data_t.is_swift_cc(self) -> bool -ida_typeinf.func_type_data_t.is_virtual (method) - is_virtual(self) -> bool +ida_typeinf.func_type_data_t.is_vararg_cc(self) -> bool -ida_typeinf.func_type_data_t.retloc (variable) +ida_typeinf.func_type_data_t.is_virtual(self) -> bool + +ida_typeinf.func_type_data_t.retloc return location -ida_typeinf.func_type_data_t.rettype (variable) +ida_typeinf.func_type_data_t.rettype return type -ida_typeinf.func_type_data_t.spoiled (variable) - spoiled register information. if spoiled register info is present, it overrides - the standard spoil info (eax, edx, ecx for x86) +ida_typeinf.func_type_data_t.spoiled + spoiled register information. if spoiled register info is present, it overrides the standard spoil info (eax, edx, ecx for x86) + -ida_typeinf.func_type_data_t.stkargs (variable) +ida_typeinf.func_type_data_t.stkargs size of stack arguments (not used in build_func_type) -ida_typeinf.func_type_data_t.swap (method) - swap(self, r) +ida_typeinf.func_type_data_t.swap(self, r: "func_type_data_t") -> None + +ida_typeinf.funcarg_t + +ida_typeinf.funcarg_t.__eq__(self, r: "funcarg_t") -> bool + +ida_typeinf.funcarg_t.__init__(self, *args) + Create a function argument, with the specified name and type. - @param r: func_type_data_t & - -ida_typeinf.funcarg_t (class) - Proxy of C++ funcarg_t class. - -ida_typeinf.funcarg_t.__eq__ (method) - __eq__(self, r) -> bool + This constructor has the following signatures: - @param r: funcarg_t const & - -ida_typeinf.funcarg_t.__init__ (method) - __init__(self) -> funcarg_t - -ida_typeinf.funcarg_t.__ne__ (method) - __ne__(self, r) -> bool + 1. funcarg_t(name: str, type, argloc: argloc_t) + 2. funcarg_t(funcarg: funcarg_t) - @param r: funcarg_t const & + In the 1st form, the 'type' descriptor, can be one of: + + * type_t: if the type is simple (integral/floating/bool). E.g., `BTF_INT` + * tinfo_t: can handle more complex types (structures, pointers, arrays, ...) + * str: a C type declaration + + If an input argument is incorrect, the constructor may raise an exception + + @param name a valid argument name. May not be empty (1st form). + @param type the member type (1st form). + @param argloc the argument location. Can be empty (1st form). + @param funcarg a funcarg_t to copy -ida_typeinf.funcarg_t.argloc (variable) +ida_typeinf.funcarg_t.__ne__(self, r: "funcarg_t") -> bool + +ida_typeinf.funcarg_t.argloc argument location -ida_typeinf.funcarg_t.cmt (variable) +ida_typeinf.funcarg_t.cmt argument comment (may be empty) -ida_typeinf.funcarg_t.flags (variable) - Function argument property bits +ida_typeinf.funcarg_t.flags + Function argument property bits + -ida_typeinf.funcarg_t.name (variable) +ida_typeinf.funcarg_t.name argument name (may be empty) -ida_typeinf.funcarg_t.type (variable) +ida_typeinf.funcarg_t.type argument type -ida_typeinf.funcargvec_t (class) - Proxy of C++ qvector< funcarg_t > class. +ida_typeinf.funcargvec_t -ida_typeinf.funcargvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< funcarg_t > const & +ida_typeinf.funcargvec_t.__eq__(self, r: "funcargvec_t") -> bool -ida_typeinf.funcargvec_t.__getitem__ (method) - __getitem__(self, i) -> funcarg_t - - @param i: size_t +ida_typeinf.funcargvec_t.__getitem__(self, i: "size_t") -> "funcarg_t const &" -ida_typeinf.funcargvec_t.__init__ (method) - __init__(self) -> funcargvec_t - __init__(self, x) -> funcargvec_t - - @param x: qvector< funcarg_t > const & +ida_typeinf.funcargvec_t.__init__(self, *args) -ida_typeinf.funcargvec_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.funcargvec_t.__len__(self) -> "size_t" -ida_typeinf.funcargvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< funcarg_t > const & +ida_typeinf.funcargvec_t.__ne__(self, r: "funcargvec_t") -> bool -ida_typeinf.funcargvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: funcarg_t const & +ida_typeinf.funcargvec_t.__setitem__(self, i: "size_t", v: "funcarg_t") -> None -ida_typeinf.funcargvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: funcarg_t const & +ida_typeinf.funcargvec_t._del(self, x: "funcarg_t") -> bool -ida_typeinf.funcargvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: funcarg_t const & +ida_typeinf.funcargvec_t.add_unique(self, x: "funcarg_t") -> bool -ida_typeinf.funcargvec_t.at (method) - at(self, _idx) -> funcarg_t - - @param _idx: size_t +ida_typeinf.funcargvec_t.append(self, x: "funcarg_t") -> None -ida_typeinf.funcargvec_t.begin (method) - begin(self) -> funcarg_t +ida_typeinf.funcargvec_t.at(self, _idx: "size_t") -> "funcarg_t const &" -ida_typeinf.funcargvec_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.funcargvec_t.begin(self, *args) -> "qvector< funcarg_t >::const_iterator" -ida_typeinf.funcargvec_t.clear (method) - clear(self) +ida_typeinf.funcargvec_t.capacity(self) -> "size_t" -ida_typeinf.funcargvec_t.empty (method) - empty(self) -> bool +ida_typeinf.funcargvec_t.clear(self) -> None -ida_typeinf.funcargvec_t.end (method) - end(self) -> funcarg_t +ida_typeinf.funcargvec_t.empty(self) -> bool -ida_typeinf.funcargvec_t.erase (method) - erase(self, it) -> funcarg_t - - @param it: qvector< funcarg_t >::iterator - - erase(self, first, last) -> funcarg_t - - @param first: qvector< funcarg_t >::iterator - @param last: qvector< funcarg_t >::iterator +ida_typeinf.funcargvec_t.end(self, *args) -> "qvector< funcarg_t >::const_iterator" -ida_typeinf.funcargvec_t.extract (method) - extract(self) -> funcarg_t +ida_typeinf.funcargvec_t.erase(self, *args) -> "qvector< funcarg_t >::iterator" -ida_typeinf.funcargvec_t.find (method) - find(self, x) -> funcarg_t - - @param x: funcarg_t const & +ida_typeinf.funcargvec_t.extend(self, x: "funcargvec_t") -> None -ida_typeinf.funcargvec_t.grow (method) - grow(self, x=funcarg_t()) - - @param x: funcarg_t const & +ida_typeinf.funcargvec_t.extract(self) -> "funcarg_t *" -ida_typeinf.funcargvec_t.has (method) - has(self, x) -> bool - - @param x: funcarg_t const & +ida_typeinf.funcargvec_t.find(self, *args) -> "qvector< funcarg_t >::const_iterator" -ida_typeinf.funcargvec_t.inject (method) - inject(self, s, len) - - @param s: funcarg_t * - @param len: size_t +ida_typeinf.funcargvec_t.grow(self, *args) -> None -ida_typeinf.funcargvec_t.insert (method) - insert(self, it, x) -> funcarg_t - - @param it: qvector< funcarg_t >::iterator - @param x: funcarg_t const & +ida_typeinf.funcargvec_t.has(self, x: "funcarg_t") -> bool -ida_typeinf.funcargvec_t.pop_back (method) - pop_back(self) +ida_typeinf.funcargvec_t.inject(self, s: "funcarg_t", len: "size_t") -> None -ida_typeinf.funcargvec_t.push_back (method) - push_back(self, x) - - @param x: funcarg_t const & - - push_back(self) -> funcarg_t +ida_typeinf.funcargvec_t.insert(self, it: "funcarg_t", x: "funcarg_t") -> "qvector< funcarg_t >::iterator" -ida_typeinf.funcargvec_t.qclear (method) - qclear(self) +ida_typeinf.funcargvec_t.pop_back(self) -> None -ida_typeinf.funcargvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.funcargvec_t.push_back(self, *args) -> "funcarg_t &" -ida_typeinf.funcargvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: funcarg_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.funcargvec_t.qclear(self) -> None -ida_typeinf.funcargvec_t.size (method) - size(self) -> size_t +ida_typeinf.funcargvec_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.funcargvec_t.swap (method) - swap(self, r) - - @param r: qvector< funcarg_t > & +ida_typeinf.funcargvec_t.resize(self, *args) -> None -ida_typeinf.funcargvec_t.truncate (method) - truncate(self) +ida_typeinf.funcargvec_t.size(self) -> "size_t" -ida_typeinf.gcc_layout (function) - gcc_layout() -> bool +ida_typeinf.funcargvec_t.swap(self, r: "funcargvec_t") -> None + +ida_typeinf.funcargvec_t.truncate(self) -> None + +ida_typeinf.gcc_layout() -> bool Should use the struct/union layout as done by gcc? -ida_typeinf.gen_decorate_name (function) - gen_decorate_name(name, mangle, cc, type) -> str +ida_typeinf.gen_decorate_name(name: str, mangle: bool, cc: "cm_t", type: "tinfo_t") -> str Generic function for decorate_name() (may be used in IDP modules) - - @param name: (C++: const char *) char const * - @param mangle: (C++: bool) - @param cc: (C++: cm_t) - @param type: (C++: const tinfo_t *) tinfo_t const * -ida_typeinf.gen_use_arg_tinfos (function) - gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot) - - @param caller: ea_t - @param fti: func_type_data_t * - @param rargs: funcargvec_t * - @param set_optype: set_op_tinfo_t * - @param is_stkarg_load: is_stkarg_load_t * - @param has_delay_slot: has_delay_slot_t * - -ida_typeinf.gen_use_arg_tinfos2 (function) - gen_use_arg_tinfos2(_this, caller, fti, rargs) +ida_typeinf.gen_use_arg_tinfos(_this: "argtinfo_helper_t", caller: ida_idaapi.ea_t, fti: "func_type_data_t", rargs: "funcargvec_t") -> None Do not call this function directly, use argtinfo_helper_t. - - @param _this: (C++: struct argtinfo_helper_t *) argtinfo_helper_t * - @param caller: (C++: ea_t) - @param fti: (C++: func_type_data_t *) - @param rargs: (C++: funcargvec_t *) -ida_typeinf.get_abi_name (function) - get_abi_name() -> str - Get ABI name. - - @return: length of the name (>=0) +ida_typeinf.get_abi_name() -> str + Get ABI name. + + @returns length of the name (>=0) -ida_typeinf.get_alias_target (function) - get_alias_target(ti, ordinal) -> uint32 - Find the final alias destination. If the ordinal has not been aliased, return - the specified ordinal itself If failed, returns 0. - - @param ti: (C++: const til_t *) til_t const * - @param ordinal: (C++: uint32) +ida_typeinf.get_alias_target(ti: "til_t", ordinal: int) -> int + Find the final alias destination. If the ordinal has not been aliased, return the specified ordinal itself If failed, returns 0. + -ida_typeinf.get_arg_addrs (function) - get_arg_addrs(caller) -> PyObject * +ida_typeinf.get_arg_addrs(caller: ida_idaapi.ea_t) Retrieve addresses of argument initialization instructions @param caller: the address of the call instruction @return: list of instruction addresses -ida_typeinf.get_base_type (function) - get_base_type(t) -> type_t +ida_typeinf.get_base_type(t: "type_t") -> "type_t" Get get basic type bits (TYPE_BASE_MASK) - - @param t: (C++: type_t) -ida_typeinf.get_c_header_path (function) - get_c_header_path() -> str +ida_typeinf.get_c_header_path() -> str Get the include directory path of the target compiler. -ida_typeinf.get_c_macros (function) - get_c_macros() -> str +ida_typeinf.get_c_macros() -> str Get predefined macros for the target compiler. -ida_typeinf.get_comp (function) - get_comp(comp) -> comp_t +ida_typeinf.get_comp(comp: "comp_t") -> "comp_t" Get compiler bits. - - @param comp: (C++: comp_t) -ida_typeinf.get_compiler_abbr (function) - get_compiler_abbr(id) -> char const * +ida_typeinf.get_compiler_abbr(id: "comp_t") -> str Get abbreviated compiler name. - - @param id: (C++: comp_t) -ida_typeinf.get_compiler_name (function) - get_compiler_name(id) -> char const * +ida_typeinf.get_compiler_name(id: "comp_t") -> str Get full compiler name. - - @param id: (C++: comp_t) -ida_typeinf.get_compilers (function) - get_compilers(ids, names, abbrs) +ida_typeinf.get_compilers(ids: "compvec_t *", names: "qstrvec_t *", abbrs: "qstrvec_t *") -> None Get names of all built-in compilers. - - @param ids: (C++: compvec_t *) - @param names: (C++: qstrvec_t *) - @param abbrs: (C++: qstrvec_t *) -ida_typeinf.get_enum_member_expr (function) - get_enum_member_expr(tif, serial, value) -> str - Return a C expression that can be used to represent an enum member. If the value - does not correspond to any single enum member, this function tries to find a - bitwise combination of enum members that correspond to it. If more than half of - value bits do not match any enum members, it fails. - - @param tif: (C++: const tinfo_t &) enumeration type - @param serial: (C++: int) which enumeration member to use (0 means the first with the given - value) - @param value: (C++: uint64) value to search in the enumeration type - @return: success +ida_typeinf.get_enum_member_expr(tif: "tinfo_t", serial: int, value: "uint64") -> str + Return a C expression that can be used to represent an enum member. If the value does not correspond to any single enum member, this function tries to find a bitwise combination of enum members that correspond to it. If more than half of value bits do not match any enum members, it fails. + + @param tif: enumeration type + @param serial: which enumeration member to use (0 means the first with the given value) + @param value: value to search in the enumeration type + @returns success -ida_typeinf.get_full_type (function) - get_full_type(t) -> type_t +ida_typeinf.get_full_type(t: "type_t") -> "type_t" Get basic type bits + type flags (TYPE_FULL_MASK) - - @param t: (C++: type_t) -ida_typeinf.get_idainfo64_by_type (function) - get_idainfo64_by_type(out_flags, tif) -> bool - Extract information from a tinfo_t. - - @param out_flags: (C++: flags64_t *) description of type using flags64_t - @param tif: (C++: const tinfo_t &) the type to inspect +ida_typeinf.get_idainfo_by_type(tif: "tinfo_t") -> "size_t *, flags64_t *, opinfo_t *, size_t *" + Extract information from a tinfo_t. + + @param tif: the type to inspect -ida_typeinf.get_idainfo_by_type (function) - get_idainfo_by_type(tif) -> bool - Extract information from a tinfo_t. - - @param tif: (C++: const tinfo_t &) the type to inspect +ida_typeinf.get_idainfo_by_udm(*args) -> bool + Calculate IDA info from udt member + + @param udm: udt member + @param refinfo_ea: if specified will be used to adjust the refinfo_t data -ida_typeinf.get_idati (function) - get_idati() -> til_t - Pointer to the local type library - this til is private for each IDB file - Functions that accept til_t* default to `idati` when is nullptr provided. +ida_typeinf.get_idati() -> "til_t *" + Pointer to the local type library - this til is private for each IDB file Functions that accept til_t* default to `idati` when is nullptr provided. + -ida_typeinf.get_named_type (function) - get_named_type(til, name, ntf_flags) -> (int, bytes, bytes, NoneType, NoneType, int, int) +ida_typeinf.get_named_type(til: til_t, name: str, ntf_flags: int) Get a type data by its name. - @param til: the type library + @param til: Type library @param name: the type name @param ntf_flags: a combination of NTF_* constants - @return: None on failure + @return: + None on failure tuple(code, type_str, fields_str, cmt, field_cmts, sclass, value) on success -ida_typeinf.get_named_type64 (function) - get_named_type64(til, name, ntf_flags) -> (int, bytes, NoneType, NoneType, NoneType, int, int) - See get_named_type() above. - @note: If the value in the 'ti' library is 32-bit, it will be sign-extended - before being stored in the 'value' pointer. +ida_typeinf.get_named_type64(til: til_t, name: str, ntf_flags: int = 0) -> Union[Tuple[int, bytes, bytes, str, str, int, int], None] + Get a named type from a type library. - @param til: til_t const * - @param name: (C++: const char *) char const * - @param ntf_flags: (C++: int) + Please use til_t.get_named_type instead. -ida_typeinf.get_named_type_tid (function) - get_named_type_tid(name) -> tid_t - Get named local type TID +ida_typeinf.get_named_type_tid(name: str) -> "tid_t" + Get named local type TID + + @param name: type name + @returns TID or BADADDR + +ida_typeinf.get_numbered_type(til: til_t, ordinal: int) -> Union[Tuple[bytes, bytes, str, str, int], None] + Get a type from a type library, by its ordinal - @param name: (C++: const char *) type name - @return: TID or BADADDR + Please use til_t.get_numbered_type instead. -ida_typeinf.get_numbered_type (function) - get_numbered_type(til, ordinal) -> (bytes, NoneType, NoneType, NoneType, int), (bytes, bytes, NoneType, NoneType, int) - Retrieve a type by its ordinal number. - - @param til: til_t const * - @param ordinal: (C++: uint32) +ida_typeinf.get_numbered_type_name(ti: "til_t", ordinal: int) -> str + Get type name (if exists) by its ordinal. If the type is anonymous, returns "". If failed, returns nullptr + -ida_typeinf.get_numbered_type_name (function) - get_numbered_type_name(ti, ordinal) -> char const * - Get type name (if exists) by its ordinal. If the type is anonymous, returns "". - If failed, returns nullptr - - @param ti: (C++: const til_t *) til_t const * - @param ordinal: (C++: uint32) +ida_typeinf.get_ordinal_count(ti: "til_t" = None) -> int + Get number of allocated ordinals. + + @param ti: type library; nullptr means the local types for the current database. + @returns 0 if ordinals have not been enabled for the til. -ida_typeinf.get_ordinal_count (function) - get_ordinal_count(ti=None) -> uint32 - Get number of allocated ordinals. - - @param ti: (C++: const til_t *) type library; nullptr means the local types for the current database. - @return: 0 if ordinals have not been enabled for the til. +ida_typeinf.get_ordinal_limit(ti: "til_t" = None) -> int + Get number of allocated ordinals + 1. If there are no allocated ordinals, return 0. To enumerate all ordinals, use: for ( uint32 i = 1; i < limit; ++i ) + + @param ti: type library; nullptr means the local types for the current database. + @returns uint32(-1) if ordinals have not been enabled for the til. For local types (idati), ordinals are always enabled. -ida_typeinf.get_ordinal_from_idb_type (function) - get_ordinal_from_idb_type(name, type) -> int - Get ordinal number of an idb type (struct/enum). The 'type' parameter is used - only to determine the kind of the type (struct or enum) Use this function to - find out the correspondence between idb types and til types - - @param name: (C++: const char *) char const * - @param type: (C++: const type_t *) type_t const * +ida_typeinf.get_scalar_bt(size: int) -> "type_t" -ida_typeinf.get_ordinal_limit (function) - get_ordinal_limit(ti=None) -> uint32 - Get number of allocated ordinals + 1. If there are no allocated ordinals, return - 0. To enumerate all ordinals, use: for ( uint32 i = 1; i < limit; ++i ) - - @param ti: (C++: const til_t *) type library; nullptr means the local types for the current database. - @return: uint32(-1) if ordinals have not been enabled for the til. For local - types (idati), ordinals are always enabled. +ida_typeinf.get_stock_tinfo(tif: "tinfo_t", id: "stock_type_id_t") -> bool -ida_typeinf.get_ordinal_qty (function) - get_ordinal_qty(ti) -> uint32 - - @param ti: til_t const * +ida_typeinf.get_tid_name(tid: "tid_t") -> str + Get a type name for the specified TID + + @param tid: type TID + @returns true if there is type with TID -ida_typeinf.get_scalar_bt (function) - get_scalar_bt(size) -> type_t - - @param size: int +ida_typeinf.get_tid_ordinal(tid: "tid_t") -> int + Get type ordinal number for TID + + @param tid: type/enum constant/udt member TID + @returns type ordinal number or 0 -ida_typeinf.get_stock_tinfo (function) - get_stock_tinfo(tif, id) -> bool - - @param tif: tinfo_t * - @param id: enum stock_type_id_t +ida_typeinf.get_tinfo_attr(typid: "typid_t", key: str, bv: "bytevec_t *", all_attrs: bool) -> bool -ida_typeinf.get_tid_name (function) - get_tid_name(tid) -> str - Get a type name for the specified TID - - @param tid: (C++: tid_t) type TID - @return: true if there is type with TID - @note: this function is the inverse to get_named_type_tid +ida_typeinf.get_tinfo_attrs(typid: "typid_t", tav: "type_attrs_t", include_ref_attrs: bool) -> bool -ida_typeinf.get_tid_ordinal (function) - get_tid_ordinal(tid) -> uint32 - Get type ordinal number for TID - - @param tid: (C++: tid_t) type/enum constant/udt member TID - @return: type ordinal number or 0 +ida_typeinf.get_tinfo_by_edm_name(tif: "tinfo_t", til: "til_t", mname: str) -> "ssize_t" -ida_typeinf.get_tinfo_attr (function) - get_tinfo_attr(typid, key, bv, all_attrs) -> bool - - @param typid: uint32 - @param key: qstring const & - @param bv: bytevec_t * - @param all_attrs: bool +ida_typeinf.get_tinfo_by_flags(out: "tinfo_t", flags: "flags64_t") -> bool + Get tinfo object that corresponds to data flags + + @param out: type info + @param flags: simple flags (byte, word, ..., zword) -ida_typeinf.get_tinfo_attrs (function) - get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool - - @param typid: uint32 - @param tav: type_attrs_t * - @param include_ref_attrs: bool +ida_typeinf.get_tinfo_details(typid: "typid_t", bt2: "type_t", buf: "void *") -> bool -ida_typeinf.get_tinfo_by_flags (function) - get_tinfo_by_flags(out, flags) -> bool - Get tinfo object that corresponds to data flags - - @param out: (C++: tinfo_t *) type info - @param flags: (C++: flags64_t) simple flags (byte, word, ..., zword) +ida_typeinf.get_tinfo_pdata(outptr: "void *", typid: "typid_t", what: int) -> "size_t" -ida_typeinf.get_tinfo_details (function) - get_tinfo_details(typid, bt2, buf) -> bool - - @param typid: uint32 - @param bt2: type_t - @param buf: void * +ida_typeinf.get_tinfo_property(typid: "typid_t", gta_prop: int) -> "size_t" -ida_typeinf.get_tinfo_details2 (function) - get_tinfo_details2(typid, bt2, buf) -> bool - - @param typid: uint32 - @param bt2: type_t - @param buf: void * +ida_typeinf.get_tinfo_property4(typid: "typid_t", gta_prop: int, p1: "size_t", p2: "size_t", p3: "size_t", p4: "size_t") -> "size_t" -ida_typeinf.get_tinfo_pdata (function) - get_tinfo_pdata(outptr, typid, what) -> size_t - - @param outptr: void * - @param typid: uint32 - @param what: int +ida_typeinf.get_tinfo_size(p_effalign: "uint32 *", typid: "typid_t", gts_code: int) -> "size_t" -ida_typeinf.get_tinfo_property (function) - get_tinfo_property(typid, gta_prop) -> size_t - - @param typid: uint32 - @param gta_prop: int - -ida_typeinf.get_tinfo_property4 (function) - get_tinfo_property4(typid, gta_prop, p1, p2, p3, p4) -> size_t - - @param typid: uint32 - @param gta_prop: int - @param p1: size_t - @param p2: size_t - @param p3: size_t - @param p4: size_t - -ida_typeinf.get_tinfo_size (function) - get_tinfo_size(p_effalign, typid, gts_code) -> size_t - - @param p_effalign: uint32 * - @param typid: uint32 - @param gts_code: int - -ida_typeinf.get_tinfo_tid (function) - get_tinfo_tid(tif, force_tid) -> tid_t - - @param tif: tinfo_t * - @param force_tid: bool - -ida_typeinf.get_type_flags (function) - get_type_flags(t) -> type_t +ida_typeinf.get_type_flags(t: "type_t") -> "type_t" Get type flags (TYPE_FLAGS_MASK) - - @param t: (C++: type_t) -ida_typeinf.get_type_ordinal (function) - get_type_ordinal(ti, name) -> int32 +ida_typeinf.get_type_ordinal(ti: "til_t", name: str) -> int Get type ordinal by its name. - - @param ti: (C++: const til_t *) til_t const * - @param name: (C++: const char *) char const * -ida_typeinf.get_udm_by_fullname (function) - get_udm_by_fullname(udm, fullname) -> ssize_t - Get udt member by full name - - @param udm: (C++: udm_t *) member, can be NULL - @param fullname: (C++: const char *) udt member name in format <udt name>.<member name> - @return: member index into udt_type_data_t or -1 +ida_typeinf.get_udm_by_fullname(udm: "udm_t", fullname: str) -> "ssize_t" + Get udt member by full name + + @param udm: member, can be NULL + @param fullname: udt member name in format <udt name>.<member name> + @returns member index into udt_type_data_t or -1 -ida_typeinf.get_udm_tid (function) - get_udm_tid(udm, udt_name) -> tid_t - - @param udm: udm_t const * - @param udt_name: char const * +ida_typeinf.get_vftable_ea(ordinal: int) -> ida_idaapi.ea_t + Get address of a virtual function table. + + @param ordinal: ordinal number of a vftable type. + @returns address of the corresponding virtual function table in the current database. -ida_typeinf.get_vftable_ea (function) - get_vftable_ea(ordinal) -> ea_t - Get address of a virtual function table. - - @param ordinal: (C++: uint32) ordinal number of a vftable type. - @return: address of the corresponding virtual function table in the current - database. +ida_typeinf.get_vftable_ordinal(vftable_ea: ida_idaapi.ea_t) -> int + Get ordinal number of the virtual function table. + + @param vftable_ea: address of a virtual function table. + @returns ordinal number of the corresponding vftable type. 0 - failure. -ida_typeinf.get_vftable_ordinal (function) - get_vftable_ordinal(vftable_ea) -> uint32 - Get ordinal number of the virtual function table. - - @param vftable_ea: (C++: ea_t) address of a virtual function table. - @return: ordinal number of the corresponding vftable type. 0 - failure. - -ida_typeinf.guess_func_cc (function) - guess_func_cc(fti, npurged, cc_flags) -> cm_t +ida_typeinf.guess_func_cc(fti: "func_type_data_t", npurged: int, cc_flags: int) -> "cm_t" Use func_type_data_t::guess_cc() - - @param fti: (C++: const func_type_data_t &) func_type_data_t const & - @param npurged: (C++: int) - @param cc_flags: (C++: int) -ida_typeinf.guess_tinfo (function) - guess_tinfo(out, id) -> int - Generate a type information about the id from the disassembly. id can be a - structure/union/enum id or an address. - - @param out: (C++: tinfo_t *) - @param id: (C++: tid_t) - @return: one of Guess tinfo codes +ida_typeinf.guess_tinfo(out: "tinfo_t", id: "tid_t") -> int + Generate a type information about the id from the disassembly. id can be a structure/union/enum id or an address. + + @returns one of Guess tinfo codes -ida_typeinf.ida_lowertype_helper_t (class) - Proxy of C++ ida_lowertype_helper_t class. +ida_typeinf.ida_lowertype_helper_t -ida_typeinf.ida_lowertype_helper_t.__init__ (method) - __init__(self, _tif, _ea, _pb) -> ida_lowertype_helper_t - - @param _tif: tinfo_t const & - @param _ea: ea_t - @param _pb: int +ida_typeinf.ida_lowertype_helper_t.__init__(self, _tif: "tinfo_t", _ea: ida_idaapi.ea_t, _pb: int) -ida_typeinf.ida_lowertype_helper_t.func_has_stkframe_hole (method) - func_has_stkframe_hole(self, candidate, candidate_data) -> bool - - @param candidate: tinfo_t const & - @param candidate_data: func_type_data_t const & +ida_typeinf.ida_lowertype_helper_t.func_has_stkframe_hole(self, candidate: "tinfo_t", candidate_data: "func_type_data_t") -> bool -ida_typeinf.ida_lowertype_helper_t.get_func_purged_bytes (method) - get_func_purged_bytes(self, candidate, arg3) -> int - - @param candidate: tinfo_t const & - @param arg3: func_type_data_t const & +ida_typeinf.ida_lowertype_helper_t.get_func_purged_bytes(self, candidate: "tinfo_t", arg3: "func_type_data_t") -> int -ida_typeinf.idc_get_local_type (function) - idc_get_local_type(ordinal, flags) -> str - - @param ordinal: int - @param flags: int +ida_typeinf.idc_get_local_type(ordinal: int, flags: int) -> str -ida_typeinf.idc_get_local_type_name (function) - idc_get_local_type_name(ordinal) -> str - - @param ordinal: int +ida_typeinf.idc_get_local_type_name(ordinal: int) -> str -ida_typeinf.idc_get_local_type_raw (function) - idc_get_local_type_raw(ordinal) -> (bytes, bytes) +ida_typeinf.idc_get_local_type_raw(ordinal) -> Tuple[bytes, bytes] - @param ordinal: int -ida_typeinf.idc_get_type (function) - idc_get_type(ea) -> str - - @param ea: ea_t +ida_typeinf.idc_get_type(ea: ida_idaapi.ea_t) -> str -ida_typeinf.idc_get_type_raw (function) - idc_get_type_raw(ea) -> PyObject * - - @param ea: ea_t +ida_typeinf.idc_get_type_raw(ea: ida_idaapi.ea_t) -> "PyObject *" -ida_typeinf.idc_guess_type (function) - idc_guess_type(ea) -> str - - @param ea: ea_t +ida_typeinf.idc_guess_type(ea: ida_idaapi.ea_t) -> str -ida_typeinf.idc_parse_decl (function) - idc_parse_decl(ti, decl, flags) -> (str, bytes, bytes) or None +ida_typeinf.idc_parse_decl(til: til_t, decl: str, flags: int) -> Tuple[str, bytes, bytes] - @param ti: til_t * - @param decl: char const * - @param flags: int -ida_typeinf.idc_parse_types (function) - idc_parse_types(input, flags) -> int - - @param input: char const * - @param flags: int +ida_typeinf.idc_parse_types(input: str, flags: int) -> int -ida_typeinf.idc_print_type (function) - idc_print_type(type, fields, name, flags) -> str +ida_typeinf.idc_print_type(type: bytes, fields: bytes, name: str, flags: int) -> str - @param type: type_t const * - @param fields: p_list const * - @param name: char const * - @param flags: int -ida_typeinf.idc_set_local_type (function) - idc_set_local_type(ordinal, dcl, flags) -> int - - @param ordinal: int - @param dcl: char const * - @param flags: int +ida_typeinf.idc_set_local_type(ordinal: int, dcl: str, flags: int) -> int -ida_typeinf.import_type (function) - import_type(til, idx, name, flags=0) -> tid_t - Copy a named type from til to idb. - - @param til: (C++: const til_t *) type library - @param idx: (C++: int) the position of the new type in the list of types (structures or - enums). -1 means at the end of the list - @param name: (C++: const char *) the type name - @param flags: (C++: int) combination of Import type flags - @return: BADNODE on error +ida_typeinf.inf_big_arg_align(*args) -> bool -ida_typeinf.inf_big_arg_align (function) - inf_big_arg_align() -> bool - inf_big_arg_align(cc) -> bool - - @param cc: cm_t +ida_typeinf.inf_huge_arg_align(*args) -> bool -ida_typeinf.inf_huge_arg_align (function) - inf_huge_arg_align() -> bool - inf_huge_arg_align(cc) -> bool - - @param cc: cm_t +ida_typeinf.inf_pack_stkargs(*args) -> bool -ida_typeinf.inf_pack_stkargs (function) - inf_pack_stkargs() -> bool - inf_pack_stkargs(cc) -> bool - - @param cc: cm_t - -ida_typeinf.is_autosync (function) - is_autosync(name, type) -> bool - Is the specified idb type automatically synchronized? - - @param name: (C++: const char *) char const * - @param type: type_t const * - - is_autosync(name, tif) -> bool - - @param name: char const * - @param tif: tinfo_t const & - -ida_typeinf.is_code_far (function) - is_code_far(cm) -> bool +ida_typeinf.is_code_far(cm: "cm_t") -> bool Does the given model specify far code?. - - @param cm: (C++: cm_t) -ida_typeinf.is_comp_unsure (function) - is_comp_unsure(comp) -> comp_t +ida_typeinf.is_comp_unsure(comp: "comp_t") -> "comp_t" See COMP_UNSURE. - - @param comp: (C++: comp_t) -ida_typeinf.is_data_far (function) - is_data_far(cm) -> bool +ida_typeinf.is_data_far(cm: "cm_t") -> bool Does the given model specify far data?. - - @param cm: (C++: cm_t) -ida_typeinf.is_gcc (function) - is_gcc() -> bool +ida_typeinf.is_gcc() -> bool Is the target compiler COMP_GNU? -ida_typeinf.is_gcc32 (function) - is_gcc32() -> bool +ida_typeinf.is_gcc32() -> bool Is the target compiler 32 bit gcc? -ida_typeinf.is_gcc64 (function) - is_gcc64() -> bool +ida_typeinf.is_gcc64() -> bool Is the target compiler 64 bit gcc? -ida_typeinf.is_golang_cc (function) - is_golang_cc(cc) -> bool +ida_typeinf.is_golang_cc(cc: "cm_t") -> bool GO language calling convention (return value in stack)? - - @param cc: (C++: cm_t) -ida_typeinf.is_ordinal_name (function) - is_ordinal_name(name, ord=None) -> bool - Check if the name is an ordinal name. Ordinal names have the following format: - '#' + set_de(ord) - - @param name: (C++: const char *) char const * - @param ord: (C++: uint32 *) +ida_typeinf.is_one_bit_mask(mask: int) -> bool + Is bitmask one bit? -ida_typeinf.is_purging_cc (function) - is_purging_cc(cm) -> bool - Does the calling convention clean the stack arguments upon return?. - @note: this function is valid only for x86 code - - @param cm: (C++: cm_t) +ida_typeinf.is_ordinal_name(name: str, ord: "uint32 *" = None) -> bool + Check if the name is an ordinal name. Ordinal names have the following format: '#' + set_de(ord) + -ida_typeinf.is_restype_enum (function) - is_restype_enum(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * +ida_typeinf.is_purging_cc(cm: "cm_t") -> bool + Does the calling convention clean the stack arguments upon return?. + -ida_typeinf.is_restype_struct (function) - is_restype_struct(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * +ida_typeinf.is_restype_enum(til: "til_t", type: "type_t const *") -> bool -ida_typeinf.is_restype_struni (function) - is_restype_struni(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * +ida_typeinf.is_restype_struct(til: "til_t", type: "type_t const *") -> bool -ida_typeinf.is_restype_void (function) - is_restype_void(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * +ida_typeinf.is_restype_struni(til: "til_t", type: "type_t const *") -> bool -ida_typeinf.is_sdacl_byte (function) - is_sdacl_byte(t) -> bool - Identify an sdacl byte. The first sdacl byte has the following format: 11xx000x. - The sdacl bytes are appended to udt fields. They indicate the start of type - attributes (as the tah-bytes do). The sdacl bytes are used in the udt headers - instead of the tah-byte. This is done for compatibility with old databases, they - were already using sdacl bytes in udt headers and as udt field postfixes. (see - "sdacl-typeattrs" in the type bit definitions) - - @param t: (C++: type_t) +ida_typeinf.is_restype_void(til: "til_t", type: "type_t const *") -> bool -ida_typeinf.is_swift_cc (function) - is_swift_cc(cc) -> bool +ida_typeinf.is_sdacl_byte(t: "type_t") -> bool + Identify an sdacl byte. The first sdacl byte has the following format: 11xx000x. The sdacl bytes are appended to udt fields. They indicate the start of type attributes (as the tah-bytes do). The sdacl bytes are used in the udt headers instead of the tah-byte. This is done for compatibility with old databases, they were already using sdacl bytes in udt headers and as udt field postfixes. (see "sdacl-typeattrs" in the type bit definitions) + + +ida_typeinf.is_swift_cc(cc: "cm_t") -> bool Swift calling convention (arguments and return values in registers)? - - @param cc: (C++: cm_t) -ida_typeinf.is_tah_byte (function) - is_tah_byte(t) -> bool - The TAH byte (type attribute header byte) denotes the start of type attributes. - (see "tah-typeattrs" in the type bit definitions) - - @param t: (C++: type_t) +ida_typeinf.is_tah_byte(t: "type_t") -> bool + The TAH byte (type attribute header byte) denotes the start of type attributes. (see "tah-typeattrs" in the type bit definitions) + -ida_typeinf.is_type_arithmetic (function) - is_type_arithmetic(t) -> bool +ida_typeinf.is_type_arithmetic(t: "type_t") -> bool Is the type an arithmetic type? (floating or integral) - - @param t: (C++: type_t) -ida_typeinf.is_type_array (function) - is_type_array(t) -> bool +ida_typeinf.is_type_array(t: "type_t") -> bool See BT_ARRAY. - - @param t: (C++: type_t) -ida_typeinf.is_type_bitfld (function) - is_type_bitfld(t) -> bool +ida_typeinf.is_type_bitfld(t: "type_t") -> bool See BT_BITFIELD. - - @param t: (C++: type_t) -ida_typeinf.is_type_bool (function) - is_type_bool(t) -> bool +ida_typeinf.is_type_bool(t: "type_t") -> bool See BTF_BOOL. - - @param t: (C++: type_t) -ida_typeinf.is_type_char (function) - is_type_char(t) -> bool - Does the type specify a char value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) +ida_typeinf.is_type_char(t: "type_t") -> bool + Does the type specify a char value? (signed or unsigned, see Basic type: integer) -ida_typeinf.is_type_choosable (function) - is_type_choosable(ti, ordinal) -> bool - Check if a struct/union type is choosable - - @param ti: (C++: const til_t *) type library - @param ordinal: (C++: uint32) ordinal number of a UDT type +ida_typeinf.is_type_choosable(ti: "til_t", ordinal: int) -> bool + Check if a struct/union type is choosable + + @param ti: type library + @param ordinal: ordinal number of a UDT type -ida_typeinf.is_type_complex (function) - is_type_complex(t) -> bool +ida_typeinf.is_type_complex(t: "type_t") -> bool See BT_COMPLEX. - - @param t: (C++: type_t) -ida_typeinf.is_type_const (function) - is_type_const(t) -> bool +ida_typeinf.is_type_const(t: "type_t") -> bool See BTM_CONST. - - @param t: (C++: type_t) -ida_typeinf.is_type_double (function) - is_type_double(t) -> bool +ida_typeinf.is_type_double(t: "type_t") -> bool See BTF_DOUBLE. - - @param t: (C++: type_t) -ida_typeinf.is_type_enum (function) - is_type_enum(t) -> bool +ida_typeinf.is_type_enum(t: "type_t") -> bool See BTF_ENUM. - - @param t: (C++: type_t) -ida_typeinf.is_type_ext_arithmetic (function) - is_type_ext_arithmetic(t) -> bool +ida_typeinf.is_type_ext_arithmetic(t: "type_t") -> bool Is the type an extended arithmetic type? (arithmetic or enum) - - @param t: (C++: type_t) -ida_typeinf.is_type_ext_integral (function) - is_type_ext_integral(t) -> bool +ida_typeinf.is_type_ext_integral(t: "type_t") -> bool Is the type an extended integral type? (integral or enum) - - @param t: (C++: type_t) -ida_typeinf.is_type_float (function) - is_type_float(t) -> bool +ida_typeinf.is_type_float(t: "type_t") -> bool See BTF_FLOAT. - - @param t: (C++: type_t) -ida_typeinf.is_type_floating (function) - is_type_floating(t) -> bool +ida_typeinf.is_type_floating(t: "type_t") -> bool Is the type a floating point type? - - @param t: (C++: type_t) -ida_typeinf.is_type_func (function) - is_type_func(t) -> bool +ida_typeinf.is_type_func(t: "type_t") -> bool See BT_FUNC. - - @param t: (C++: type_t) -ida_typeinf.is_type_int (function) - is_type_int(bt) -> bool +ida_typeinf.is_type_int(bt: "type_t") -> bool Does the type_t specify one of the basic types in Basic type: integer? - - @param bt: (C++: type_t) -ida_typeinf.is_type_int128 (function) - is_type_int128(t) -> bool - Does the type specify a 128-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) +ida_typeinf.is_type_int128(t: "type_t") -> bool + Does the type specify a 128-bit value? (signed or unsigned, see Basic type: integer) -ida_typeinf.is_type_int16 (function) - is_type_int16(t) -> bool - Does the type specify a 16-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) +ida_typeinf.is_type_int16(t: "type_t") -> bool + Does the type specify a 16-bit value? (signed or unsigned, see Basic type: integer) -ida_typeinf.is_type_int32 (function) - is_type_int32(t) -> bool - Does the type specify a 32-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) +ida_typeinf.is_type_int32(t: "type_t") -> bool + Does the type specify a 32-bit value? (signed or unsigned, see Basic type: integer) -ida_typeinf.is_type_int64 (function) - is_type_int64(t) -> bool - Does the type specify a 64-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) +ida_typeinf.is_type_int64(t: "type_t") -> bool + Does the type specify a 64-bit value? (signed or unsigned, see Basic type: integer) -ida_typeinf.is_type_integral (function) - is_type_integral(t) -> bool +ida_typeinf.is_type_integral(t: "type_t") -> bool Is the type an integral type (char/short/int/long/bool)? - - @param t: (C++: type_t) -ida_typeinf.is_type_ldouble (function) - is_type_ldouble(t) -> bool +ida_typeinf.is_type_ldouble(t: "type_t") -> bool See BTF_LDOUBLE. - - @param t: (C++: type_t) -ida_typeinf.is_type_paf (function) - is_type_paf(t) -> bool +ida_typeinf.is_type_paf(t: "type_t") -> bool Is the type a pointer, array, or function type? - - @param t: (C++: type_t) -ida_typeinf.is_type_partial (function) - is_type_partial(t) -> bool - Identifies an unknown or void type with a known size (see Basic type: unknown & - void) - - @param t: (C++: type_t) +ida_typeinf.is_type_partial(t: "type_t") -> bool + Identifies an unknown or void type with a known size (see Basic type: unknown & void) -ida_typeinf.is_type_ptr (function) - is_type_ptr(t) -> bool +ida_typeinf.is_type_ptr(t: "type_t") -> bool See BT_PTR. - - @param t: (C++: type_t) -ida_typeinf.is_type_ptr_or_array (function) - is_type_ptr_or_array(t) -> bool +ida_typeinf.is_type_ptr_or_array(t: "type_t") -> bool Is the type a pointer or array type? - - @param t: (C++: type_t) -ida_typeinf.is_type_struct (function) - is_type_struct(t) -> bool +ida_typeinf.is_type_struct(t: "type_t") -> bool See BTF_STRUCT. - - @param t: (C++: type_t) -ida_typeinf.is_type_struni (function) - is_type_struni(t) -> bool +ida_typeinf.is_type_struni(t: "type_t") -> bool Is the type a struct or union? - - @param t: (C++: type_t) -ida_typeinf.is_type_sue (function) - is_type_sue(t) -> bool +ida_typeinf.is_type_sue(t: "type_t") -> bool Is the type a struct/union/enum? - - @param t: (C++: type_t) -ida_typeinf.is_type_tbyte (function) - is_type_tbyte(t) -> bool +ida_typeinf.is_type_tbyte(t: "type_t") -> bool See BTF_FLOAT. - - @param t: (C++: type_t) -ida_typeinf.is_type_typedef (function) - is_type_typedef(t) -> bool +ida_typeinf.is_type_typedef(t: "type_t") -> bool See BTF_TYPEDEF. - - @param t: (C++: type_t) -ida_typeinf.is_type_uchar (function) - is_type_uchar(t) -> bool +ida_typeinf.is_type_uchar(t: "type_t") -> bool See BTF_UCHAR. - - @param t: (C++: type_t) -ida_typeinf.is_type_uint (function) - is_type_uint(t) -> bool +ida_typeinf.is_type_uint(t: "type_t") -> bool See BTF_UINT. - - @param t: (C++: type_t) -ida_typeinf.is_type_uint128 (function) - is_type_uint128(t) -> bool +ida_typeinf.is_type_uint128(t: "type_t") -> bool See BTF_UINT128. - - @param t: (C++: type_t) -ida_typeinf.is_type_uint16 (function) - is_type_uint16(t) -> bool +ida_typeinf.is_type_uint16(t: "type_t") -> bool See BTF_UINT16. - - @param t: (C++: type_t) -ida_typeinf.is_type_uint32 (function) - is_type_uint32(t) -> bool +ida_typeinf.is_type_uint32(t: "type_t") -> bool See BTF_UINT32. - - @param t: (C++: type_t) -ida_typeinf.is_type_uint64 (function) - is_type_uint64(t) -> bool +ida_typeinf.is_type_uint64(t: "type_t") -> bool See BTF_UINT64. - - @param t: (C++: type_t) -ida_typeinf.is_type_union (function) - is_type_union(t) -> bool +ida_typeinf.is_type_union(t: "type_t") -> bool See BTF_UNION. - - @param t: (C++: type_t) -ida_typeinf.is_type_unknown (function) - is_type_unknown(t) -> bool +ida_typeinf.is_type_unknown(t: "type_t") -> bool See BT_UNKNOWN. - - @param t: (C++: type_t) -ida_typeinf.is_type_void (function) - is_type_void(t) -> bool +ida_typeinf.is_type_void(t: "type_t") -> bool See BTF_VOID. - - @param t: (C++: type_t) -ida_typeinf.is_type_volatile (function) - is_type_volatile(t) -> bool +ida_typeinf.is_type_volatile(t: "type_t") -> bool See BTM_VOLATILE. - - @param t: (C++: type_t) -ida_typeinf.is_typeid_last (function) - is_typeid_last(t) -> bool - Is the type_t the last byte of type declaration? (there are no additional bytes - after a basic type, see _BT_LAST_BASIC) - - @param t: (C++: type_t) +ida_typeinf.is_typeid_last(t: "type_t") -> bool + Is the type_t the last byte of type declaration? (there are no additional bytes after a basic type, see _BT_LAST_BASIC) + -ida_typeinf.is_user_cc (function) - is_user_cc(cm) -> bool +ida_typeinf.is_user_cc(cm: "cm_t") -> bool Does the calling convention specify argument locations explicitly? - - @param cm: (C++: cm_t) -ida_typeinf.is_vararg_cc (function) - is_vararg_cc(cm) -> bool +ida_typeinf.is_vararg_cc(cm: "cm_t") -> bool Does the calling convention use ellipsis? - - @param cm: (C++: cm_t) -ida_typeinf.lexcompare_tinfo (function) - lexcompare_tinfo(t1, t2, arg3) -> int - - @param t1: uint32 - @param t2: uint32 - @param arg3: int +ida_typeinf.lexcompare_tinfo(t1: "typid_t", t2: "typid_t", arg3: int) -> int -ida_typeinf.load_til (function) - load_til(name, tildir=None) -> til_t - Load til from a file without adding it to the database list (see also add_til). - Failure to load base tils are reported into 'errbuf'. They do not prevent - loading of the main til. - - @param name: (C++: const char *) filename of the til. If it's an absolute path, tildir is ignored. +ida_typeinf.load_til(name: str, tildir: str = None) -> str + Load til from a file without adding it to the database list (see also add_til). Failure to load base tils are reported into 'errbuf'. They do not prevent loading of the main til. + + @param name: filename of the til. If it's an absolute path, tildir is ignored. * NB: the file extension is forced to .til - @param tildir: (C++: const char *) directory where to load the til from. nullptr means default til - subdirectories. - @return: pointer to resulting til, nullptr if failed and error message is in - errbuf + @param tildir: directory where to load the til from. nullptr means default til subdirectories. + @returns pointer to resulting til, nullptr if failed and error message is in errbuf -ida_typeinf.load_til_header (function) - load_til_header(tildir, name) -> til_t +ida_typeinf.load_til_header(tildir: str, name: str) -> str Get human-readable til description. - - @param tildir: (C++: const char *) char const * - @param name: (C++: const char *) char const * -ida_typeinf.lower_type (function) - lower_type(til, tif, name=None, _helper=None) -> int - Lower type. Inspect the type and lower all function subtypes using - lower_func_type(). - We call the prototypes usually encountered in source files "high level" - They may have implicit arguments, array arguments, big structure retvals, etc - We introduce explicit arguments (i.e. 'this' pointer) and call the result +ida_typeinf.lower_type(til: "til_t", tif: "tinfo_t", name: str = None, _helper: "lowertype_helper_t" = None) -> int + Lower type. Inspect the type and lower all function subtypes using lower_func_type(). + We call the prototypes usually encountered in source files "high level" + They may have implicit arguments, array arguments, big structure retvals, etc + We introduce explicit arguments (i.e. 'this' pointer) and call the result "low level prototype". See FTI_HIGH. - - In order to improve heuristics for recognition of big structure retvals, - it is recommended to pass a helper that will be used to make decisions. - That helper will be used only for lowering 'tif', and not for the children - types walked through by recursion. + In order to improve heuristics for recognition of big structure retvals, + it is recommended to pass a helper that will be used to make decisions. + That helper will be used only for lowering 'tif', and not for the children + types walked through by recursion. + @retval 1: removed FTI_HIGH, @retval 2: made substantial changes @retval -1: failure - - @param til: (C++: til_t *) - @param tif: (C++: tinfo_t *) - @param name: (C++: const char *) char const * - @param _helper: (C++: lowertype_helper_t *) -ida_typeinf.lowertype_helper_t (class) - Proxy of C++ lowertype_helper_t class. +ida_typeinf.lowertype_helper_t -ida_typeinf.lowertype_helper_t.__init__ (method) +ida_typeinf.lowertype_helper_t.__init__(self, *args, **kwargs) -ida_typeinf.lowertype_helper_t.func_has_stkframe_hole (method) - func_has_stkframe_hole(self, candidate, candidate_data) -> bool - - @param candidate: tinfo_t const & - @param candidate_data: func_type_data_t const & +ida_typeinf.lowertype_helper_t.func_has_stkframe_hole(self, candidate: "tinfo_t", candidate_data: "func_type_data_t") -> bool -ida_typeinf.lowertype_helper_t.get_func_purged_bytes (method) - get_func_purged_bytes(self, candidate, candidate_data) -> int - - @param candidate: tinfo_t const & - @param candidate_data: func_type_data_t const & +ida_typeinf.lowertype_helper_t.get_func_purged_bytes(self, candidate: "tinfo_t", candidate_data: "func_type_data_t") -> int -ida_typeinf.new_til (function) - new_til(name, desc) -> til_t +ida_typeinf.new_til(name: str, desc: str) -> "til_t *" Initialize a til. - - @param name: (C++: const char *) char const * - @param desc: (C++: const char *) char const * -ida_typeinf.next_named_type (function) - next_named_type(ti, name, ntf_flags) -> char const * - Enumerate types. - - @param ti: (C++: const til_t *) type library. nullptr means the local type library for the current - database. - @param name: (C++: const char *) the current name. the name that follows this one will be returned. - @param ntf_flags: (C++: int) combination of Flags for named types - @return: Type or symbol names, depending of ntf_flags. Returns mangled names. - Never returns anonymous types. To include them, enumerate types by - ordinals. +ida_typeinf.next_named_type(ti: "til_t", name: str, ntf_flags: int) -> str + Enumerate types. + + @param ti: type library. nullptr means the local type library for the current database. + @param name: the current name. the name that follows this one will be returned. + @param ntf_flags: combination of Flags for named types + @returns Type or symbol names, depending of ntf_flags. Returns mangled names. Never returns anonymous types. To include them, enumerate types by ordinals. -ida_typeinf.no_sign (variable) +ida_typeinf.no_sign no sign, or unknown -ida_typeinf.optimize_argloc (function) - optimize_argloc(vloc, size, gaps) -> bool - Verify and optimize scattered argloc into simple form. All new arglocs must be - processed by this function. +ida_typeinf.optimize_argloc(vloc: "argloc_t", size: int, gaps: "rangeset_t") -> bool + Verify and optimize scattered argloc into simple form. All new arglocs must be processed by this function. + @retval true: success @retval false: the input argloc was illegal - - @param vloc: (C++: argloc_t *) - @param size: (C++: int) - @param gaps: (C++: const rangeset_t *) rangeset_t const * -ida_typeinf.pack_idcobj_to_bv (function) - pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t - Write a typed idc object to the byte vector. Byte vector may be non-empty, this - function will append data to it - - @param obj: (C++: const idc_value_t *) idc_value_t const * - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param bytes: (C++: relobj_t *) - @param objoff: (C++: void *) - @param pio_flags: (C++: int) +ida_typeinf.pack_idcobj_to_bv(obj: "idc_value_t const *", tif: "tinfo_t", bytes: "relobj_t", objoff: "void *", pio_flags: int = 0) -> "error_t" + Write a typed idc object to the byte vector. Byte vector may be non-empty, this function will append data to it + -ida_typeinf.pack_idcobj_to_idb (function) - pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t +ida_typeinf.pack_idcobj_to_idb(obj: "idc_value_t const *", tif: "tinfo_t", ea: ida_idaapi.ea_t, pio_flags: int = 0) -> "error_t" Write a typed idc object to the database. - - @param obj: (C++: const idc_value_t *) idc_value_t const * - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param ea: (C++: ea_t) - @param pio_flags: (C++: int) -ida_typeinf.pack_object_to_bv (function) - pack_object_to_bv(py_obj, ti, type, fields, base_ea, pio_flags=0) -> PyObject * +ida_typeinf.pack_object_to_bv(obj, til: til_t, type: bytes, fields: bytes, base_ea: ida_idaapi.ea_t, pio_flags: int = 0) Packs a typed object to a string - @param py_obj: PyObject * - @param ti: Type info. 'None' can be passed. - @param type: type_t const * + @param til: Type library. 'None' can be passed. + @param type: type string @param fields: fields string (may be empty or None) @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 + @return: + tuple(0, err_code) on failure tuple(1, packed_buf) on success -ida_typeinf.pack_object_to_idb (function) - pack_object_to_idb(py_obj, ti, type, fields, ea, pio_flags=0) -> PyObject * +ida_typeinf.pack_object_to_idb(obj, til: til_t, type: bytes, fields: bytes, ea: ida_idaapi.ea_t, pio_flags: int = 0) 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 py_obj: PyObject * - @param ti: Type info. 'None' can be passed. - @param type: type_t const * + @param til: Type library. 'None' can be passed. + @param type: type string @param fields: fields string (may be empty or None) @param ea: ea to be used while packing @param pio_flags: flags used while unpacking -ida_typeinf.parse_decl (function) - parse_decl(out_tif, til, decl, pt_flags) -> str - Parse ONE declaration. If the input string contains more than one declaration, - the first complete type declaration (PT_TYP) or the last variable declaration - (PT_VAR) will be used. - @note: name & tif may be empty after the call! - - @param out_tif: (C++: tinfo_t *) type info - @param til: (C++: til_t *) type library to use. may be nullptr - @param decl: (C++: const char *) C declaration to parse - @param pt_flags: (C++: int) combination of Type parsing flags bits +ida_typeinf.parse_decl(out_tif: "tinfo_t", til: "til_t", decl: str, pt_flags: int) -> str + Parse ONE declaration. If the input string contains more than one declaration, the first complete type declaration (PT_TYP) or the last variable declaration (PT_VAR) will be used. + + @param out_tif: type info + @param til: type library to use. may be nullptr + @param decl: C declaration to parse + @param pt_flags: combination of Type parsing flags bits @retval true: ok @retval false: declaration is bad, the error message is displayed if !PT_SIL -ida_typeinf.parse_decls (function) - parse_decls(til, input, printer, hti_flags) -> int - Parse many declarations and store them in a til. If there are any errors, they - will be printed using 'printer'. This function uses default include path and - predefined macros from the database settings. It always uses the HTI_DCL bit. - - @param til: (C++: til_t *) type library to store the result - @param input: (C++: const char *) input string or file name (see hti_flags) - @param printer: (C++: printer_t *) function to output error messages (use msg or nullptr or your - own callback) - @param hti_flags: (C++: int) combination of Type formatting flags - @return: number of errors, 0 means ok. +ida_typeinf.parse_decls(til: "til_t", input: str, printer: "printer_t *", hti_flags: int) -> int + Parse many declarations and store them in a til. If there are any errors, they will be printed using 'printer'. This function uses default include path and predefined macros from the database settings. It always uses the HTI_DCL bit. + + @param til: type library to store the result + @param input: input string or file name (see hti_flags) + @param printer: function to output error messages (use msg or nullptr or your own callback) + @param hti_flags: combination of Type formatting flags + @returns number of errors, 0 means ok. -ida_typeinf.predicate_t (class) - Proxy of C++ predicate_t class. +ida_typeinf.predicate_t -ida_typeinf.predicate_t.__disown__ (method) +ida_typeinf.predicate_t.__disown__(self) -ida_typeinf.predicate_t.__init__ (method) - __init__(self) -> predicate_t - - @param self: PyObject * +ida_typeinf.predicate_t.__init__(self) -ida_typeinf.predicate_t.should_display (method) - should_display(self, til, name, type, fields) -> bool - - @param til: til_t const * - @param name: char const * - @param type: type_t const * - @param fields: p_list const * +ida_typeinf.predicate_t.should_display(self, til: "til_t", name: str, type: "type_t const *", fields: "p_list const *") -> bool -ida_typeinf.print_argloc (function) - print_argloc(vloc, size=0, vflags=0) -> str +ida_typeinf.print_argloc(vloc: "argloc_t", size: int = 0, vflags: int = 0) -> "size_t" Convert an argloc to human readable form. - - @param vloc: (C++: const argloc_t &) argloc_t const & - @param size: (C++: int) - @param vflags: (C++: int) -ida_typeinf.print_decls (function) - print_decls(printer, til, py_ordinals, flags) -> int +ida_typeinf.print_decls(printer: text_sink_t, til: til_t, ordinals: List[int], flags: int) -> int Print types (and possibly their dependencies) in a format suitable for using in a header file. This is the reverse parse_decls(). - @param printer: (C++: text_sink_t &) a handler for printing text - @param til: (C++: til_t *) the type library holding the ordinals - @param py_ordinals: ordinals of types to export. nullptr means: all ordinals in til - @param pdf_flags: (C++: uint32) flags for the algorithm. A combination of PDF_ constants - @retval >0: the number of types exported - @retval 0: an error occurred - @retval <0: the negated number of types exported. There were minor errors and + @param printer a handler for printing text + @param til the type library holding the ordinals + @param ordinals a list of ordinals corresponding to the types to print + @param flags a combination of PDF_ constants + @return + >0: the number of types exported + 0: an error occurred + <0: the negated number of types exported. There were minor errors and the resulting output might not be compilable. -ida_typeinf.print_tinfo (function) - print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> str - - @param prefix: char const * - @param indent: int - @param cmtindent: int - @param flags: int - @param tif: tinfo_t const * - @param name: char const * - @param cmt: char const * +ida_typeinf.print_tinfo(prefix: str, indent: int, cmtindent: int, flags: int, tif: "tinfo_t", name: str, cmt: str) -> str -ida_typeinf.print_type (function) - print_type(ea, prtype_flags) -> str - Get type declaration for the specified address. - - @param ea: (C++: ea_t) address - @param prtype_flags: (C++: int) combination of Type printing flags - @return: success +ida_typeinf.print_type(ea: ida_idaapi.ea_t, prtype_flags: int) -> str + Get type declaration for the specified address. + + @param ea: address + @param prtype_flags: combination of Type printing flags + @returns success -ida_typeinf.ptr_type_data_t (class) - Proxy of C++ ptr_type_data_t class. +ida_typeinf.ptr_type_data_t -ida_typeinf.ptr_type_data_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ptr_type_data_t const & +ida_typeinf.ptr_type_data_t.__eq__(self, r: "ptr_type_data_t") -> bool -ida_typeinf.ptr_type_data_t.__init__ (method) - __init__(self, c=tinfo_t(), bps=0, p=tinfo_t(), d=0) -> ptr_type_data_t - - @param c: tinfo_t - @param bps: uchar - @param p: tinfo_t - @param d: int32 +ida_typeinf.ptr_type_data_t.__init__(self, *args) -ida_typeinf.ptr_type_data_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ptr_type_data_t const & +ida_typeinf.ptr_type_data_t.__ne__(self, r: "ptr_type_data_t") -> bool -ida_typeinf.ptr_type_data_t.closure (variable) +ida_typeinf.ptr_type_data_t.closure cannot have both closure and based_ptr_size -ida_typeinf.ptr_type_data_t.delta (variable) +ida_typeinf.ptr_type_data_t.delta Offset from the beginning of the parent struct. -ida_typeinf.ptr_type_data_t.is_code_ptr (method) - is_code_ptr(self) -> bool +ida_typeinf.ptr_type_data_t.is_code_ptr(self) -> bool Are we pointing to code? -ida_typeinf.ptr_type_data_t.is_shifted (method) - is_shifted(self) -> bool +ida_typeinf.ptr_type_data_t.is_shifted(self) -> bool -ida_typeinf.ptr_type_data_t.obj_type (variable) +ida_typeinf.ptr_type_data_t.obj_type pointed object type -ida_typeinf.ptr_type_data_t.parent (variable) +ida_typeinf.ptr_type_data_t.parent Parent struct. -ida_typeinf.ptr_type_data_t.swap (method) - swap(self, r) +ida_typeinf.ptr_type_data_t.swap(self, r: "ptr_type_data_t") -> None Set this = r and r = this. - - @param r: (C++: ptr_type_data_t &) -ida_typeinf.ptr_type_data_t.taptr_bits (variable) +ida_typeinf.ptr_type_data_t.taptr_bits TAH bits. -ida_typeinf.read_tinfo_bitfield_value (function) - read_tinfo_bitfield_value(typid, v, bitoff) -> uint64 - - @param typid: uint32 - @param v: uint64 - @param bitoff: int +ida_typeinf.read_tinfo_bitfield_value(typid: "typid_t", v: "uint64", bitoff: int) -> "uint64" -ida_typeinf.reginfovec_t (class) - Proxy of C++ qvector< reg_info_t > class. +ida_typeinf.reginfovec_t -ida_typeinf.reginfovec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< reg_info_t > const & +ida_typeinf.reginfovec_t.__eq__(self, r: "reginfovec_t") -> bool -ida_typeinf.reginfovec_t.__getitem__ (method) - __getitem__(self, i) -> reg_info_t - - @param i: size_t +ida_typeinf.reginfovec_t.__getitem__(self, i: "size_t") -> "reg_info_t const &" -ida_typeinf.reginfovec_t.__init__ (method) - __init__(self) -> reginfovec_t - __init__(self, x) -> reginfovec_t - - @param x: qvector< reg_info_t > const & +ida_typeinf.reginfovec_t.__init__(self, *args) -ida_typeinf.reginfovec_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.reginfovec_t.__len__(self) -> "size_t" -ida_typeinf.reginfovec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< reg_info_t > const & +ida_typeinf.reginfovec_t.__ne__(self, r: "reginfovec_t") -> bool -ida_typeinf.reginfovec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: reg_info_t const & +ida_typeinf.reginfovec_t.__setitem__(self, i: "size_t", v: "reg_info_t") -> None -ida_typeinf.reginfovec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: reg_info_t const & +ida_typeinf.reginfovec_t._del(self, x: "reg_info_t") -> bool -ida_typeinf.reginfovec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: reg_info_t const & +ida_typeinf.reginfovec_t.add_unique(self, x: "reg_info_t") -> bool -ida_typeinf.reginfovec_t.at (method) - at(self, _idx) -> reg_info_t - - @param _idx: size_t +ida_typeinf.reginfovec_t.append(self, x: "reg_info_t") -> None -ida_typeinf.reginfovec_t.begin (method) - begin(self) -> reg_info_t +ida_typeinf.reginfovec_t.at(self, _idx: "size_t") -> "reg_info_t const &" -ida_typeinf.reginfovec_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.reginfovec_t.begin(self, *args) -> "qvector< reg_info_t >::const_iterator" -ida_typeinf.reginfovec_t.clear (method) - clear(self) +ida_typeinf.reginfovec_t.capacity(self) -> "size_t" -ida_typeinf.reginfovec_t.empty (method) - empty(self) -> bool +ida_typeinf.reginfovec_t.clear(self) -> None -ida_typeinf.reginfovec_t.end (method) - end(self) -> reg_info_t +ida_typeinf.reginfovec_t.empty(self) -> bool -ida_typeinf.reginfovec_t.erase (method) - erase(self, it) -> reg_info_t - - @param it: qvector< reg_info_t >::iterator - - erase(self, first, last) -> reg_info_t - - @param first: qvector< reg_info_t >::iterator - @param last: qvector< reg_info_t >::iterator +ida_typeinf.reginfovec_t.end(self, *args) -> "qvector< reg_info_t >::const_iterator" -ida_typeinf.reginfovec_t.extract (method) - extract(self) -> reg_info_t +ida_typeinf.reginfovec_t.erase(self, *args) -> "qvector< reg_info_t >::iterator" -ida_typeinf.reginfovec_t.find (method) - find(self, x) -> reg_info_t - - @param x: reg_info_t const & +ida_typeinf.reginfovec_t.extend(self, x: "reginfovec_t") -> None -ida_typeinf.reginfovec_t.grow (method) - grow(self, x=reg_info_t()) - - @param x: reg_info_t const & +ida_typeinf.reginfovec_t.extract(self) -> "reg_info_t *" -ida_typeinf.reginfovec_t.has (method) - has(self, x) -> bool - - @param x: reg_info_t const & +ida_typeinf.reginfovec_t.find(self, *args) -> "qvector< reg_info_t >::const_iterator" -ida_typeinf.reginfovec_t.inject (method) - inject(self, s, len) - - @param s: reg_info_t * - @param len: size_t +ida_typeinf.reginfovec_t.grow(self, *args) -> None -ida_typeinf.reginfovec_t.insert (method) - insert(self, it, x) -> reg_info_t - - @param it: qvector< reg_info_t >::iterator - @param x: reg_info_t const & +ida_typeinf.reginfovec_t.has(self, x: "reg_info_t") -> bool -ida_typeinf.reginfovec_t.pop_back (method) - pop_back(self) +ida_typeinf.reginfovec_t.inject(self, s: "reg_info_t", len: "size_t") -> None -ida_typeinf.reginfovec_t.push_back (method) - push_back(self, x) - - @param x: reg_info_t const & - - push_back(self) -> reg_info_t +ida_typeinf.reginfovec_t.insert(self, it: "reg_info_t", x: "reg_info_t") -> "qvector< reg_info_t >::iterator" -ida_typeinf.reginfovec_t.qclear (method) - qclear(self) +ida_typeinf.reginfovec_t.pop_back(self) -> None -ida_typeinf.reginfovec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.reginfovec_t.push_back(self, *args) -> "reg_info_t &" -ida_typeinf.reginfovec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: reg_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.reginfovec_t.qclear(self) -> None -ida_typeinf.reginfovec_t.size (method) - size(self) -> size_t +ida_typeinf.reginfovec_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.reginfovec_t.swap (method) - swap(self, r) - - @param r: qvector< reg_info_t > & +ida_typeinf.reginfovec_t.resize(self, *args) -> None -ida_typeinf.reginfovec_t.truncate (method) - truncate(self) +ida_typeinf.reginfovec_t.size(self) -> "size_t" -ida_typeinf.regobj_t (class) - Proxy of C++ regobj_t class. +ida_typeinf.reginfovec_t.swap(self, r: "reginfovec_t") -> None -ida_typeinf.regobj_t.__init__ (method) - __init__(self) -> regobj_t +ida_typeinf.reginfovec_t.truncate(self) -> None -ida_typeinf.regobj_t.regidx (variable) +ida_typeinf.regobj_t + +ida_typeinf.regobj_t.__init__(self) + +ida_typeinf.regobj_t.regidx index into dbg->registers -ida_typeinf.regobj_t.relocate (variable) +ida_typeinf.regobj_t.relocate 0-plain num, 1-must relocate -ida_typeinf.regobj_t.size (method) - size(self) -> size_t +ida_typeinf.regobj_t.size(self) -> "size_t" -ida_typeinf.regobjs_t (class) - Proxy of C++ regobjs_t class. +ida_typeinf.regobjs_t -ida_typeinf.regobjs_t.__init__ (method) - __init__(self) -> regobjs_t +ida_typeinf.regobjs_t.__init__(self) -ida_typeinf.regobjvec_t (class) - Proxy of C++ qvector< regobj_t > class. +ida_typeinf.regobjvec_t -ida_typeinf.regobjvec_t.__getitem__ (method) - __getitem__(self, i) -> regobj_t - - @param i: size_t +ida_typeinf.regobjvec_t.__getitem__(self, i: "size_t") -> "regobj_t const &" -ida_typeinf.regobjvec_t.__init__ (method) - __init__(self) -> regobjvec_t - __init__(self, x) -> regobjvec_t - - @param x: qvector< regobj_t > const & +ida_typeinf.regobjvec_t.__init__(self, *args) -ida_typeinf.regobjvec_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.regobjvec_t.__len__(self) -> "size_t" -ida_typeinf.regobjvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regobj_t const & +ida_typeinf.regobjvec_t.__setitem__(self, i: "size_t", v: "regobj_t") -> None -ida_typeinf.regobjvec_t.at (method) - at(self, _idx) -> regobj_t - - @param _idx: size_t +ida_typeinf.regobjvec_t.append(self, x: "regobj_t") -> None -ida_typeinf.regobjvec_t.begin (method) - begin(self) -> regobj_t +ida_typeinf.regobjvec_t.at(self, _idx: "size_t") -> "regobj_t const &" -ida_typeinf.regobjvec_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.regobjvec_t.begin(self, *args) -> "qvector< regobj_t >::const_iterator" -ida_typeinf.regobjvec_t.clear (method) - clear(self) +ida_typeinf.regobjvec_t.capacity(self) -> "size_t" -ida_typeinf.regobjvec_t.empty (method) - empty(self) -> bool +ida_typeinf.regobjvec_t.clear(self) -> None -ida_typeinf.regobjvec_t.end (method) - end(self) -> regobj_t +ida_typeinf.regobjvec_t.empty(self) -> bool -ida_typeinf.regobjvec_t.erase (method) - erase(self, it) -> regobj_t - - @param it: qvector< regobj_t >::iterator - - erase(self, first, last) -> regobj_t - - @param first: qvector< regobj_t >::iterator - @param last: qvector< regobj_t >::iterator +ida_typeinf.regobjvec_t.end(self, *args) -> "qvector< regobj_t >::const_iterator" -ida_typeinf.regobjvec_t.extract (method) - extract(self) -> regobj_t +ida_typeinf.regobjvec_t.erase(self, *args) -> "qvector< regobj_t >::iterator" -ida_typeinf.regobjvec_t.grow (method) - grow(self, x=regobj_t()) - - @param x: regobj_t const & +ida_typeinf.regobjvec_t.extend(self, x: "regobjvec_t") -> None -ida_typeinf.regobjvec_t.inject (method) - inject(self, s, len) - - @param s: regobj_t * - @param len: size_t +ida_typeinf.regobjvec_t.extract(self) -> "regobj_t *" -ida_typeinf.regobjvec_t.insert (method) - insert(self, it, x) -> regobj_t - - @param it: qvector< regobj_t >::iterator - @param x: regobj_t const & +ida_typeinf.regobjvec_t.grow(self, *args) -> None -ida_typeinf.regobjvec_t.pop_back (method) - pop_back(self) +ida_typeinf.regobjvec_t.inject(self, s: "regobj_t", len: "size_t") -> None -ida_typeinf.regobjvec_t.push_back (method) - push_back(self, x) - - @param x: regobj_t const & - - push_back(self) -> regobj_t +ida_typeinf.regobjvec_t.insert(self, it: "regobj_t", x: "regobj_t") -> "qvector< regobj_t >::iterator" -ida_typeinf.regobjvec_t.qclear (method) - qclear(self) +ida_typeinf.regobjvec_t.pop_back(self) -> None -ida_typeinf.regobjvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.regobjvec_t.push_back(self, *args) -> "regobj_t &" -ida_typeinf.regobjvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: regobj_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.regobjvec_t.qclear(self) -> None -ida_typeinf.regobjvec_t.size (method) - size(self) -> size_t +ida_typeinf.regobjvec_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.regobjvec_t.swap (method) - swap(self, r) - - @param r: qvector< regobj_t > & +ida_typeinf.regobjvec_t.resize(self, *args) -> None -ida_typeinf.regobjvec_t.truncate (method) - truncate(self) +ida_typeinf.regobjvec_t.size(self) -> "size_t" -ida_typeinf.remove_abi_opts (function) - remove_abi_opts(abi_opts, user_level=False) -> bool - - @param abi_opts: char const * - @param user_level: bool +ida_typeinf.regobjvec_t.swap(self, r: "regobjvec_t") -> None -ida_typeinf.remove_pointer (function) - remove_pointer(tif) -> tinfo_t - - @param BT_PTR: If the current type is a pointer, return the pointed object. If the - current type is not a pointer, return the current type. See also - get_ptrarr_object() and get_pointed_object() +ida_typeinf.regobjvec_t.truncate(self) -> None -ida_typeinf.remove_tinfo_pointer (function) - remove_tinfo_pointer(tif, name, til) -> (bool, NoneType), (bool, str) +ida_typeinf.remove_abi_opts(abi_opts: str, user_level: bool = False) -> bool + +ida_typeinf.remove_pointer(tif: "tinfo_t") -> "tinfo_t" + BT_PTR: If the current type is a pointer, return the pointed object. If the current type is not a pointer, return the current type. See also get_ptrarr_object() and get_pointed_object() + + +ida_typeinf.remove_tinfo_pointer(tif: tinfo_t, name: str, til: til_t) -> Tuple[bool, str] Remove pointer of a type. (i.e. convert "char *" into "char"). Optionally remove the "lp" (or similar) prefix of the input name. If the input type is not a pointer, then fail. - @param tif: (C++: tinfo_t *) - @param name: char const * - @param til: (C++: const til_t *) til_t const * + @param tif the type info + @param name the name of the type to "unpointerify" + @param til the type library + @return a tuple (success, new-name) -ida_typeinf.replace_ordinal_typerefs (function) - replace_ordinal_typerefs(til, tif) -> int - Replace references to ordinal types by name references. This function 'unties' - the type from the current local type library and makes it easier to export it. - - @param til: (C++: til_t *) type library to use. may be nullptr. - @param tif: (C++: tinfo_t *) type to modify (in/out) +ida_typeinf.replace_ordinal_typerefs(til: "til_t", tif: "tinfo_t") -> int + Replace references to ordinal types by name references. This function 'unties' the type from the current local type library and makes it easier to export it. + + @param til: type library to use. may be nullptr. + @param tif: type to modify (in/out) @retval number: of replaced subtypes, -1 on failure -ida_typeinf.resolve_typedef (function) - resolve_typedef(til, type) -> type_t const * - - @param til: til_t const * - @param type: type_t const * +ida_typeinf.resolve_typedef(til: "til_t", type: "type_t const *") -> "type_t const *" -ida_typeinf.rrel_t (class) - Proxy of C++ rrel_t class. +ida_typeinf.rrel_t -ida_typeinf.rrel_t.__init__ (method) - __init__(self) -> rrel_t +ida_typeinf.rrel_t.__init__(self) -ida_typeinf.rrel_t.off (variable) +ida_typeinf.rrel_t.off displacement from the address pointed by the register -ida_typeinf.rrel_t.reg (variable) +ida_typeinf.rrel_t.reg register index (into ph.reg_names) -ida_typeinf.save_tinfo (function) - save_tinfo(tif, til, ord, name, ntf_flags) -> tinfo_code_t - - @param tif: tinfo_t * - @param til: til_t * - @param ord: size_t - @param name: char const * - @param ntf_flags: int +ida_typeinf.save_tinfo(tif: "tinfo_t", til: "til_t", ord: "size_t", name: str, ntf_flags: int) -> "tinfo_code_t" -ida_typeinf.scattered_aloc_t (class) - Proxy of C++ scattered_aloc_t class. +ida_typeinf.scattered_aloc_t -ida_typeinf.scattered_aloc_t.__init__ (method) - __init__(self) -> scattered_aloc_t +ida_typeinf.scattered_aloc_t.__init__(self) -ida_typeinf.score_tinfo (function) - score_tinfo(tif) -> uint32 - - @param tif: tinfo_t const * +ida_typeinf.score_tinfo(tif: "tinfo_t") -> int -ida_typeinf.serialize_tinfo (function) - serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool - - @param type: qtype * - @param fields: qtype * - @param fldcmts: qtype * - @param tif: tinfo_t const * - @param sudt_flags: int +ida_typeinf.serialize_tinfo(type: "qtype *", fields: "qtype *", fldcmts: "qtype *", tif: "tinfo_t", sudt_flags: int) -> bool -ida_typeinf.set_abi_name (function) - set_abi_name(abiname, user_level=False) -> bool +ida_typeinf.set_abi_name(abiname: str, user_level: bool = False) -> bool Set abi name (see Compiler IDs) - - @param abiname: (C++: const char *) char const * - @param user_level: (C++: bool) -ida_typeinf.set_c_header_path (function) - set_c_header_path(incdir) +ida_typeinf.set_c_header_path(incdir: str) -> None Set include directory path the target compiler. - - @param incdir: (C++: const char *) char const * -ida_typeinf.set_c_macros (function) - set_c_macros(macros) +ida_typeinf.set_c_macros(macros: str) -> None Set predefined macros for the target compiler. - - @param macros: (C++: const char *) char const * -ida_typeinf.set_compiler (function) - set_compiler(cc, flags, abiname=None) -> bool - Change current compiler. - - @param cc: (C++: const compiler_info_t &) compiler to switch to - @param flags: (C++: int) Set compiler flags - @param abiname: (C++: const char *) ABI name - @return: success +ida_typeinf.set_compiler(cc: "compiler_info_t", flags: int, abiname: str = None) -> bool + Change current compiler. + + @param cc: compiler to switch to + @param flags: Set compiler flags + @param abiname: ABI name + @returns success -ida_typeinf.set_compiler_id (function) - set_compiler_id(id, abiname=None) -> bool +ida_typeinf.set_compiler_id(id: "comp_t", abiname: str = None) -> bool Set the compiler id (see Compiler IDs) - - @param id: (C++: comp_t) - @param abiname: (C++: const char *) char const * -ida_typeinf.set_compiler_string (function) - set_compiler_string(compstr, user_level) -> bool - - @param compstr: (C++: const char *) - compiler description in form <abbr>:<abiname> - @param user_level: (C++: bool) - initiated by user if TRUE - @return: success +ida_typeinf.set_compiler_string(compstr: str, user_level: bool) -> bool + @param compstr: - compiler description in form <abbr>:<abiname> + @param user_level: - initiated by user if TRUE + @returns success -ida_typeinf.set_numbered_type (function) - set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> tinfo_code_t - Store a type in the til. 'name' may be nullptr for anonymous types. To replace - the existed type use NTF_REPLACE - - @param ti: (C++: til_t *) - @param ordinal: (C++: uint32) - @param ntf_flags: (C++: int) - @param name: (C++: const char *) char const * - @param type: (C++: const type_t *) type_t const * - @param fields: (C++: const p_list *) p_list const * - @param cmt: (C++: const char *) char const * - @param fldcmts: (C++: const p_list *) p_list const * - @param sclass: (C++: const sclass_t *) sclass_t const * +ida_typeinf.set_numbered_type(ti: "til_t", ordinal: int, ntf_flags: int, name: str, type: "type_t const *", fields: "p_list const *" = None, cmt: str = None, fldcmts: "p_list const *" = None, sclass: "sclass_t const *" = None) -> "tinfo_code_t" -ida_typeinf.set_tinfo_attr (function) - set_tinfo_attr(tif, ta, may_overwrite) -> bool - - @param tif: tinfo_t * - @param ta: type_attr_t const & - @param may_overwrite: bool +ida_typeinf.set_tinfo_attr(tif: "tinfo_t", ta: "type_attr_t", may_overwrite: bool) -> bool -ida_typeinf.set_tinfo_attrs (function) - set_tinfo_attrs(tif, ta) -> bool - - @param tif: tinfo_t * - @param ta: type_attrs_t * +ida_typeinf.set_tinfo_attrs(tif: "tinfo_t", ta: "type_attrs_t") -> bool -ida_typeinf.set_tinfo_property (function) - set_tinfo_property(tif, sta_prop, x) -> size_t - - @param tif: tinfo_t * - @param sta_prop: int - @param x: size_t +ida_typeinf.set_tinfo_property(tif: "tinfo_t", sta_prop: int, x: "size_t") -> "size_t" -ida_typeinf.set_tinfo_property4 (function) - set_tinfo_property4(tif, sta_prop, p1, p2, p3, p4) -> size_t - - @param tif: tinfo_t * - @param sta_prop: int - @param p1: size_t - @param p2: size_t - @param p3: size_t - @param p4: size_t +ida_typeinf.set_tinfo_property4(tif: "tinfo_t", sta_prop: int, p1: "size_t", p2: "size_t", p3: "size_t", p4: "size_t") -> "size_t" -ida_typeinf.set_type_alias (function) - set_type_alias(ti, src_ordinal, dst_ordinal) -> bool - Create a type alias. Redirects all references to source type to the destination - type. This is equivalent to instantaneous replacement all references to srctype - by dsttype. - - @param ti: (C++: til_t *) - @param src_ordinal: (C++: uint32) - @param dst_ordinal: (C++: uint32) +ida_typeinf.set_type_alias(ti: "til_t", src_ordinal: int, dst_ordinal: int) -> bool + Create a type alias. Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all references to srctype by dsttype. + -ida_typeinf.set_type_choosable (function) - set_type_choosable(ti, ordinal, value) - Enable/disable 'choosability' flag for a struct/union type - - @param ti: (C++: til_t *) type library - @param ordinal: (C++: uint32) ordinal number of a UDT type - @param value: (C++: bool) flag value +ida_typeinf.set_type_choosable(ti: "til_t", ordinal: int, value: bool) -> None + Enable/disable 'choosability' flag for a struct/union type + + @param ti: type library + @param ordinal: ordinal number of a UDT type + @param value: flag value -ida_typeinf.set_vftable_ea (function) - set_vftable_ea(ordinal, vftable_ea) -> bool - Set the address of a vftable instance for a vftable type. - - @param ordinal: (C++: uint32) ordinal number of the corresponding vftable type. - @param vftable_ea: (C++: ea_t) address of a virtual function table. - @return: success +ida_typeinf.set_vftable_ea(ordinal: int, vftable_ea: ida_idaapi.ea_t) -> bool + Set the address of a vftable instance for a vftable type. + + @param ordinal: ordinal number of the corresponding vftable type. + @param vftable_ea: address of a virtual function table. + @returns success -ida_typeinf.simd_info_t (class) - Proxy of C++ simd_info_t class. +ida_typeinf.simd_info_t -ida_typeinf.simd_info_t.__init__ (method) - __init__(self, nm=None, sz=0, memt=BTF_UNK) -> simd_info_t - - @param nm: char const * - @param sz: uint16 - @param memt: type_t +ida_typeinf.simd_info_t.__init__(self, *args) -ida_typeinf.simd_info_t.match_pattern (method) - match_pattern(self, pattern) -> bool - - @param pattern: simd_info_t const * +ida_typeinf.simd_info_t.match_pattern(self, pattern: "simd_info_t") -> bool -ida_typeinf.simd_info_t.memtype (variable) - member type BTF_INT8/16/32/64/128, BTF_UINT8/16/32/64/128 BTF_INT - integrals of - any size/sign BTF_FLOAT, BTF_DOUBLE BTF_TBYTE - floatings of any size BTF_UNION - - union of integral and floating types BTF_UNK - undefined +ida_typeinf.simd_info_t.memtype + member type BTF_INT8/16/32/64/128, BTF_UINT8/16/32/64/128 BTF_INT - integrals of any size/sign BTF_FLOAT, BTF_DOUBLE BTF_TBYTE - floatings of any size BTF_UNION - union of integral and floating types BTF_UNK - undefined + -ida_typeinf.simd_info_t.name (variable) +ida_typeinf.simd_info_t.name name of SIMD type (nullptr-undefined) -ida_typeinf.simd_info_t.size (variable) +ida_typeinf.simd_info_t.size SIMD type size in bytes (0-undefined) -ida_typeinf.simd_info_t.tif (variable) +ida_typeinf.simd_info_t.tif SIMD type (empty-undefined) -ida_typeinf.stkarg_area_info_t (class) - Proxy of C++ stkarg_area_info_t class. +ida_typeinf.stkarg_area_info_t -ida_typeinf.stkarg_area_info_t.__init__ (method) - __init__(self) -> stkarg_area_info_t +ida_typeinf.stkarg_area_info_t.__init__(self) -ida_typeinf.stkarg_area_info_t.linkage_area (variable) - Size of the linkage area. explanations at: \link{https://www.ibm.com/docs/en/xl- - fortran-aix/16.1.0?topic=conventions-linkage-area} examples: pc: 0, hppa: 0, ppc - aix: 0x18 (equal to stkarg_offset) +ida_typeinf.stkarg_area_info_t.linkage_area + Size of the linkage area. explanations at: [https://www.ibm.com/docs/en/xl-fortran-aix/16.1.0?topic=conventions-linkage-area](https://www.ibm.com/docs/en/xl-fortran-aix/16.1.0?topic=conventions-linkage-area) examples: pc: 0, hppa: 0, ppc aix: 0x18 (equal to stkarg_offset) + -ida_typeinf.stkarg_area_info_t.shadow_size (variable) - Size of the shadow area. explanations at: - \link{https://stackoverflow.com/questions/30190132/what-is-the-shadow-space- - in-x64-assembly} examples: x64 Visual Studio C++: 0x20, x64 gcc: 0, ppc aix: - 0x20 +ida_typeinf.stkarg_area_info_t.shadow_size + Size of the shadow area. explanations at: [https://stackoverflow.com/questions/30190132/what-is-the-shadow-space-in-x64-assembly](https://stackoverflow.com/questions/30190132/what-is-the-shadow-space-in-x64-assembly) examples: x64 Visual Studio C++: 0x20, x64 gcc: 0, ppc aix: 0x20 + -ida_typeinf.stkarg_area_info_t.stkarg_offset (variable) - Offset from the SP to the first stack argument (can include linkage area) - examples: pc: 0, hppa: -0x34, ppc aix: 0x18 +ida_typeinf.stkarg_area_info_t.stkarg_offset + Offset from the SP to the first stack argument (can include linkage area) examples: pc: 0, hppa: -0x34, ppc aix: 0x18 + -ida_typeinf.store_til (function) - store_til(ti, tildir, name) -> bool - Store til to a file. If the til contains garbage, it will be collected before - storing the til. Your plugin should call compact_til() before calling - store_til(). - - @param ti: (C++: til_t *) type library to store - @param tildir: (C++: const char *) directory where to store the til. nullptr means current - directory. - @param name: (C++: const char *) filename of the til. If it's an absolute path, tildir is ignored. +ida_typeinf.store_til(ti: "til_t", tildir: str, name: str) -> bool + Store til to a file. If the til contains garbage, it will be collected before storing the til. Your plugin should call compact_til() before calling store_til(). + + @param ti: type library to store + @param tildir: directory where to store the til. nullptr means current directory. + @param name: filename of the til. If it's an absolute path, tildir is ignored. * NB: the file extension is forced to .til - @return: success + @returns success -ida_typeinf.switch_to_golang (function) - switch_to_golang() +ida_typeinf.stroff_as_size(plen: int, tif: "tinfo_t", value: "asize_t") -> bool + Should display a structure offset expression as the structure size? + +ida_typeinf.switch_to_golang() -> None switch to GOLANG calling convention (to be used as default CC) -ida_typeinf.text_sink_t (class) - Proxy of C++ text_sink_t class. +ida_typeinf.text_sink_t -ida_typeinf.text_sink_t.__disown__ (method) +ida_typeinf.text_sink_t.__disown__(self) -ida_typeinf.text_sink_t.__init__ (method) - __init__(self) -> text_sink_t - - @param self: PyObject * +ida_typeinf.text_sink_t.__init__(self) -ida_typeinf.text_sink_t._print (method) - _print(self, str) -> int - - Parameters - ---------- - str: char const * +ida_typeinf.text_sink_t._print(self, str: str) -> int -ida_typeinf.til_symbol_t (class) - Proxy of C++ til_symbol_t class. +ida_typeinf.til_symbol_t -ida_typeinf.til_symbol_t.__init__ (method) - __init__(self, n=None, t=None) -> til_symbol_t - - @param n: char const * - @param t: til_t const * +ida_typeinf.til_symbol_t.__init__(self, n: str = None, t: "til_t" = None) -ida_typeinf.til_symbol_t.name (variable) +ida_typeinf.til_symbol_t.name symbol name -ida_typeinf.til_symbol_t.til (variable) +ida_typeinf.til_symbol_t.til pointer to til -ida_typeinf.til_t (class) - Proxy of C++ til_t class. +ida_typeinf.til_t -ida_typeinf.til_t.__init__ (method) - __init__(self) -> til_t +ida_typeinf.til_t.__eq__(self, r: "til_t") -> bool -ida_typeinf.til_t.base (method) - base(self, n) -> til_t - tils that our til is based on - - @param n: int +ida_typeinf.til_t.__init__(self) -ida_typeinf.til_t.cc (variable) +ida_typeinf.til_t.__ne__(self, r: "til_t") -> bool + +ida_typeinf.til_t.base(self, n: int) -> "til_t *" + +ida_typeinf.til_t.cc information about the target compiler -ida_typeinf.til_t.desc (variable) +ida_typeinf.til_t.desc human readable til description -ida_typeinf.til_t.flags (variable) - Type info library property bits +ida_typeinf.til_t.find_base(self, n: str) -> "til_t *" + Find the base til with the provided name + + @param n: the base til name + @returns the found til_t, or nullptr -ida_typeinf.til_t.is_dirty (method) - is_dirty(self) -> bool +ida_typeinf.til_t.flags + Type info library property bits + + +ida_typeinf.til_t.get_named_type(self, name) + Retrieves a tinfo_t representing the named type in this type library. + + @param name a type name + @return a new tinfo_t object, or None if not found + +ida_typeinf.til_t.get_numbered_type(self, ordinal) + Retrieves a tinfo_t representing the numbered type in this type library. + + @param ordinal a type ordinal + @return a new tinfo_t object, or None if not found + +ida_typeinf.til_t.get_type_names(self) + +ida_typeinf.til_t.import_type(self, src) + Import a type (and all its dependencies) into this type info library. + + @param src The type to import + @return the imported copy, or None + +ida_typeinf.til_t.is_dirty(self) -> bool Has the til been modified? (TIL_MOD) -ida_typeinf.til_t.name (variable) +ida_typeinf.til_t.name short file name (without path and extension) -ida_typeinf.til_t.nbases (variable) +ida_typeinf.til_t.named_types(self) + Returns a generator over the named types contained in this + type library. + + Every iteration returns a fresh new tinfo_t object + + @return a tinfo_t-producing generator + +ida_typeinf.til_t.nbases number of base tils -ida_typeinf.til_t.nrefs (variable) +ida_typeinf.til_t.nrefs number of references to the til -ida_typeinf.til_t.nstreams (variable) +ida_typeinf.til_t.nstreams number of extra streams -ida_typeinf.til_t.set_dirty (method) - set_dirty(self) +ida_typeinf.til_t.numbered_types(self) + Returns a generator over the numbered types contained in this + type library. + + Every iteration returns a fresh new tinfo_t object + + @return a tinfo_t-producing generator + +ida_typeinf.til_t.set_dirty(self) -> None Mark the til as modified (TIL_MOD) -ida_typeinf.til_t.streams (variable) +ida_typeinf.til_t.streams symbol stream storage -ida_typeinf.tinfo_errstr (function) - tinfo_errstr(code) -> char const * - Helper function to convert an error code into a printable string. Additional - arguments are handled using the functions from err.h - - @param code: (C++: tinfo_code_t) enum tinfo_code_t +ida_typeinf.til_type_ref_t -ida_typeinf.tinfo_t (class) - Proxy of C++ tinfo_t class. +ida_typeinf.til_type_ref_t.__init__(self) -ida_typeinf.tinfo_t.ENUMBM_AUTO (variable) +ida_typeinf.til_type_ref_t.clear(self) -> None + +ida_typeinf.til_type_ref_t.edm + BTF_ENUM: the current enum member. + +ida_typeinf.til_type_ref_t.fa + BT_FUNC: the current argument, nullptr - ellipsis. + +ida_typeinf.til_type_ref_t.is_enum(self) -> bool + +ida_typeinf.til_type_ref_t.is_func(self) -> bool + +ida_typeinf.til_type_ref_t.is_struct(self) -> bool + +ida_typeinf.til_type_ref_t.is_typedef(self) -> bool + +ida_typeinf.til_type_ref_t.is_udt(self) -> bool + +ida_typeinf.til_type_ref_t.is_union(self) -> bool + +ida_typeinf.til_type_ref_t.on_member(self) -> bool + +ida_typeinf.til_type_ref_t.udm + BTF_STRUCT or BTF_UNION: the current member. + +ida_typeinf.tinfo_errstr(code: "tinfo_code_t") -> str + Helper function to convert an error code into a printable string. Additional arguments are handled using the functions from err.h + + +ida_typeinf.tinfo_t + +ida_typeinf.tinfo_t.ENUMBM_AUTO convert to bitmask if the outcome is nice and useful -ida_typeinf.tinfo_t.ENUMBM_OFF (variable) +ida_typeinf.tinfo_t.ENUMBM_OFF convert to ordinal enum -ida_typeinf.tinfo_t.ENUMBM_ON (variable) +ida_typeinf.tinfo_t.ENUMBM_ON convert to bitmask enum -ida_typeinf.tinfo_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: tinfo_t const & +ida_typeinf.tinfo_t.__eq__(self, r: "tinfo_t") -> bool -ida_typeinf.tinfo_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: tinfo_t const & +ida_typeinf.tinfo_t.__ge__(self, r: "tinfo_t") -> bool -ida_typeinf.tinfo_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: tinfo_t const & +ida_typeinf.tinfo_t.__gt__(self, r: "tinfo_t") -> bool -ida_typeinf.tinfo_t.__init__ (method) - __init__(self) -> tinfo_t - __init__(self, decl_type) -> tinfo_t +ida_typeinf.tinfo_t.__init__(self, *args, ordinal = None, name = None, tid = None, til = None) + Create a type object with the provided argumens. - @param decl_type: type_t + This constructor has the following signatures: - __init__(self, r) -> tinfo_t + 1. tinfo_t(decl_type: type_t) + 2. tinfo_t(decl: str, til: til_t = None, pt_flags: int = 0) - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__le__ (method) - __le__(self, r) -> bool + The latter form will create the type object by parsing the type declaration - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__lt__ (method) - __lt__(self, r) -> bool + Alternatively, you can use a form accepting the following keyword arguments: - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__ne__ (method) - __ne__(self, r) -> bool + * ordinal: int + * name: str + * tid: int + * til: til_t=None # `None` means `get_idati()` - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__str__ (method) - __str__(self) -> qstring - -ida_typeinf.tinfo_t._print (method) - _print(self, name=None, prtype_flags=0, indent=0, cmtindent=0, prefix=None, cmt=None) -> bool + E.g., - Parameters - ---------- - name: char const * - prtype_flags: int - indent: int - cmtindent: int - prefix: char const * - cmt: char const * - -ida_typeinf.tinfo_t.add_edm (method) - add_edm(self, edm, bmask=bmask64_t(-1), etf_flags=0, idx=-1) -> tinfo_code_t - Add a new enum member (a new symbolic constant) + * tinfo_t(ordinal=3) + * tinfo_t(ordinal=10, til=get_idati()) + * tinfo_t(name="mytype_t") + * tinfo_t(name="thattype_t", til=my_other_til) + * tinfo_t(tid=ida_nalt.get_strid(some_address)) - @param edm: (C++: const edm_t &) the constant name, value, and comment - @param bmask: (C++: bmask64_t) bmask of the group to add the constant to - @note: 1. For non-bitmask enum push back constant, BMASK is not used (set it ot - -1), never failed 2. For bitmask enum: - * if VAL and BMASK are not agreed, return TERR_BAD_MSKVAL - * if group with BMASK exists, push back constant to group - * otherwise use constant as bitmask for a new group - @note: ETF_NO_SAVE is ignored - -ida_typeinf.tinfo_t.add_udm (method) - add_udm(self, udm, etf_flags=0, times=1, idx=-1) -> tinfo_code_t - Add a structure/union member. + The constructor may raise an exception if data was invalid, or if parsing failed. - @param udm: (C++: const udm_t &) member to add - @param etf_flags: (C++: uint) edit_type() flags flags - @param times: (C++: size_t) how many times to add. if times > 1, the member name will be - appended a suffix like "_2" and so on - @param idx: (C++: ssize_t) the index in the udm array where the new udm should be placed. if - the specified index cannot be honored because it would spoil the udm - sorting order, it is silently ignored. - @note: ETF_NO_SAVE is ignored + @param decl_type A simple type + @param decl A valid C declaration + @param til A type library, or `None` to use the (`get_idati()`) default + @param ordinal An ordinal in the type library + @param name A valid type name + @param pt_flags Parsing flags -ida_typeinf.tinfo_t.append_covered (method) - append_covered(self, out, offset=0) -> bool - Calculate set of covered bytes for the type +ida_typeinf.tinfo_t.__le__(self, r: "tinfo_t") -> bool + +ida_typeinf.tinfo_t.__lt__(self, r: "tinfo_t") -> bool + +ida_typeinf.tinfo_t.__ne__(self, r: "tinfo_t") -> bool + +ida_typeinf.tinfo_t.__repr__(self) + +ida_typeinf.tinfo_t.__str__(self) -> str + +ida_typeinf.tinfo_t._print(self, name: str = None, prtype_flags: int = 0, indent: int = 0, cmtindent: int = 0, prefix: str = None, cmt: str = None) -> bool + +ida_typeinf.tinfo_t.add_edm(self, *args) + Add an enumerator to the current enumeration. - @param out: (C++: rangeset_t *) pointer to the output buffer. covered bytes will be appended to it. - @param offset: (C++: uint64) delta in bytes to add to all calculations. used internally during - recurion. - -ida_typeinf.tinfo_t.calc_gaps (method) - calc_gaps(self, out) -> bool - Calculate set of padding bytes for the type + When creating a new enumeration from scratch, you might + want to first call `create_enum()` - @param out: (C++: rangeset_t *) pointer to the output buffer; old buffer contents will be lost. + This method has the following signatures: + + 1. add_edm(edm: edm_t, bmask: int = -1, etf_flags: int = 0, idx: int = -1) + 2. add_edm(name: str, value: int, bmask: int = -1, etf_flags: int = 0, idx: int = -1) + + If an input argument is incorrect, the constructor may raise an exception + + @param edm The member, fully initialized (1st form) + @param name Enumerator name - must not be empty + @param value Enumerator value + @param bmask A bitmask to which the enumerator belongs + @param etf_flags an OR'ed combination of ETF_ flags + @param idx the index in the edm array where the new udm should be placed. + If the specified index cannot be honored because it would spoil + the edm sorting order, it is silently ignored. -ida_typeinf.tinfo_t.calc_purged_bytes (method) - calc_purged_bytes(self) -> int +ida_typeinf.tinfo_t.add_funcarg(self, farg: "funcarg_t", etf_flags: "uint" = 0, idx: "ssize_t" = -1) -> "tinfo_code_t" + Add a function argument. + + @param farg: argument to add + @param etf_flags: type changing flags flags + @param idx: the index in the funcarg array where the new funcarg should be placed. if the specified index cannot be honored because it would spoil the funcarg sorting order, it is silently ignored. -ida_typeinf.tinfo_t.calc_score (method) - calc_score(self) -> uint32 +ida_typeinf.tinfo_t.add_udm(self, *args) + Add a member to the current structure/union. + + When creating a new structure/union from scratch, you might + want to first call `create_udt()` + + This method has the following signatures: + + 1. add_udm(udm: udm_t, etf_flags: int = 0, times: int = 1, idx: int = -1) + 2. add_udm(name: str, type: type_t | tinfo_t | str, offset: int = 0, etf_flags: int = 0, times: int = 1, idx: int = -1) + + In the 2nd form, the 'type' descriptor, can be one of: + + * type_t: if the type is simple (integral/floating/bool). E.g., `BTF_INT` + * tinfo_t: can handle more complex types (structures, pointers, arrays, ...) + * str: a C type declaration + + If an input argument is incorrect, the constructor may raise an exception + + @param udm The member, fully initialized (1st form) + @param name Member name - must not be empty + @param type Member type + @param offset the member offset in bits. It is the caller's responsibility + to specify correct offsets. + @param etf_flags an OR'ed combination of ETF_ flags + @param times how many times to add the new member + @param idx the index in the udm array where the new udm should be placed. + If the specified index cannot be honored because it would spoil + the udm sorting order, it is silently ignored. + +ida_typeinf.tinfo_t.append_covered(self, out: "rangeset_t", offset: "uint64" = 0) -> bool + Calculate set of covered bytes for the type + + @param out: pointer to the output buffer. covered bytes will be appended to it. + @param offset: delta in bytes to add to all calculations. used internally during recurion. + +ida_typeinf.tinfo_t.calc_enum_mask(self) -> "uint64" + +ida_typeinf.tinfo_t.calc_gaps(self, out: "rangeset_t") -> bool + Calculate set of padding bytes for the type + + @param out: pointer to the output buffer; old buffer contents will be lost. + +ida_typeinf.tinfo_t.calc_purged_bytes(self) -> int + BT_FUNC: Calculate number of purged bytes + +ida_typeinf.tinfo_t.calc_score(self) -> int Calculate the type score (the higher - the nicer is the type) -ida_typeinf.tinfo_t.calc_udt_aligns (method) - calc_udt_aligns(self, sudt_flags=0x0004) -> bool - Calculate the udt alignments using the field offsets/sizes and the total udt - size This function does not work on typerefs - - @param sudt_flags: (C++: int) +ida_typeinf.tinfo_t.calc_udt_aligns(self, sudt_flags: int = 4) -> bool + Calculate the udt alignments using the field offsets/sizes and the total udt size This function does not work on typerefs + -ida_typeinf.tinfo_t.change_sign (method) - change_sign(self, sign) -> bool +ida_typeinf.tinfo_t.change_sign(self, sign: "type_sign_t") -> bool Change the type sign. Works only for the types that may have sign. - - @param sign: (C++: type_sign_t) -ida_typeinf.tinfo_t.clear (method) - clear(self) +ida_typeinf.tinfo_t.clear(self) -> None Clear contents of this tinfo, and remove from the type system. -ida_typeinf.tinfo_t.clr_const (method) - clr_const(self) -> bool +ida_typeinf.tinfo_t.clr_const(self) -> bool -ida_typeinf.tinfo_t.clr_const_volatile (method) - clr_const_volatile(self) -> bool +ida_typeinf.tinfo_t.clr_const_volatile(self) -> bool -ida_typeinf.tinfo_t.clr_decl_const_volatile (method) - clr_decl_const_volatile(self) +ida_typeinf.tinfo_t.clr_decl_const_volatile(self) -> None -ida_typeinf.tinfo_t.clr_volatile (method) - clr_volatile(self) -> bool +ida_typeinf.tinfo_t.clr_volatile(self) -> bool -ida_typeinf.tinfo_t.compare (method) - compare(self, r) -> int - - @param r: tinfo_t const & +ida_typeinf.tinfo_t.compare(self, r: "tinfo_t") -> int -ida_typeinf.tinfo_t.compare_with (method) - compare_with(self, r, tcflags=0) -> bool +ida_typeinf.tinfo_t.compare_with(self, r: "tinfo_t", tcflags: int = 0) -> bool Compare two types, based on given flags (see tinfo_t comparison flags) - - @param r: (C++: const tinfo_t &) tinfo_t const & - @param tcflags: (C++: int) -ida_typeinf.tinfo_t.convert_array_to_ptr (method) - convert_array_to_ptr(self) -> bool - Convert an array into a pointer. type[] => type * +ida_typeinf.tinfo_t.convert_array_to_ptr(self) -> bool + Convert an array into a pointer. type[] => type * + -ida_typeinf.tinfo_t.copy (method) - copy(self) -> tinfo_t +ida_typeinf.tinfo_t.copy(self) -> "tinfo_t" -ida_typeinf.tinfo_t.copy_type (method) - copy_type(self, til, name, ntf_flags=0x0001|0x1000) -> tinfo_code_t - - @param til: til_t * - @param name: char const * - @param ntf_flags: int +ida_typeinf.tinfo_t.copy_type(self, *args) -> "tinfo_code_t" -ida_typeinf.tinfo_t.create_array (method) - create_array(self, p, decl_type=BT_ARRAY) -> bool - - @param p: array_type_data_t const & - @param decl_type: type_t - - create_array(self, tif, nelems=0, base=0, decl_type=BT_ARRAY) -> bool - - @param tif: tinfo_t const & - @param nelems: uint32 - @param base: uint32 - @param decl_type: type_t +ida_typeinf.tinfo_t.create_array(self, *args) -> bool -ida_typeinf.tinfo_t.create_bitfield (method) - create_bitfield(self, p, decl_type=BT_BITFIELD) -> bool - - @param p: bitfield_type_data_t const & - @param decl_type: type_t - - create_bitfield(self, nbytes, width, is_unsigned=False, decl_type=BT_BITFIELD) -> bool - - @param nbytes: uchar - @param width: uchar - @param is_unsigned: bool - @param decl_type: type_t +ida_typeinf.tinfo_t.create_bitfield(self, *args) -> bool -ida_typeinf.tinfo_t.create_enum (method) - create_enum(self, p, decl_type=BTF_ENUM) -> bool - - @param p: enum_type_data_t & - @param decl_type: type_t +ida_typeinf.tinfo_t.create_enum(self, *args) -> bool + Create an empty enum. -ida_typeinf.tinfo_t.create_forward_decl (method) - create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> tinfo_code_t - Create a forward declaration. decl_type: BTF_STRUCT, BTF_UNION, or BTF_ENUM - - @param til: (C++: til_t *) - @param decl_type: (C++: type_t) - @param name: (C++: const char *) char const * - @param ntf_flags: (C++: int) +ida_typeinf.tinfo_t.create_forward_decl(self, til: "til_t", decl_type: "type_t", name: str, ntf_flags: int = 0) -> "tinfo_code_t" + Create a forward declaration. decl_type: BTF_STRUCT, BTF_UNION, or BTF_ENUM + -ida_typeinf.tinfo_t.create_func (method) - create_func(self, p, decl_type=BT_FUNC) -> bool - - @param p: func_type_data_t & - @param decl_type: type_t +ida_typeinf.tinfo_t.create_func(self, *args) -> bool -ida_typeinf.tinfo_t.create_ptr (method) - create_ptr(self, p, decl_type=BT_PTR) -> bool - - @param p: ptr_type_data_t const & - @param decl_type: type_t - - create_ptr(self, tif, bps=0, decl_type=BT_PTR) -> bool - - @param tif: tinfo_t const & - @param bps: uchar - @param decl_type: type_t +ida_typeinf.tinfo_t.create_ptr(self, *args) -> bool -ida_typeinf.tinfo_t.create_simple_type (method) - create_simple_type(self, decl_type) -> bool - - @param decl_type: type_t +ida_typeinf.tinfo_t.create_simple_type(self, decl_type: "type_t") -> bool -ida_typeinf.tinfo_t.create_typedef (method) - create_typedef(self, p, decl_type=BTF_TYPEDEF, try_ordinal=True) -> bool - - @param p: typedef_type_data_t const & - @param decl_type: type_t - @param try_ordinal: bool - - create_typedef(self, til, name, decl_type=BTF_TYPEDEF, try_ordinal=True) - - @param til: til_t const * - @param name: char const * - @param decl_type: type_t - @param try_ordinal: bool - - create_typedef(self, til, ord, decl_type=BTF_TYPEDEF) - - @param til: til_t const * - @param ord: uint - @param decl_type: type_t +ida_typeinf.tinfo_t.create_typedef(self, *args) -> None -ida_typeinf.tinfo_t.create_udt (method) - create_udt(self, p) -> bool - - @param p: udt_type_data_t & - - create_udt(self, p, decl_type) -> bool - - @param p: udt_type_data_t & - @param decl_type: type_t +ida_typeinf.tinfo_t.create_udt(self, *args) -> bool + Create an empty structure/union. -ida_typeinf.tinfo_t.del_attr (method) - del_attr(self, key, make_copy=True) -> bool +ida_typeinf.tinfo_t.del_attr(self, key: str, make_copy: bool = True) -> bool Del a type attribute. typerefs cannot be modified by this function. - - @param key: (C++: const qstring &) qstring const & - @param make_copy: (C++: bool) -ida_typeinf.tinfo_t.del_attrs (method) - del_attrs(self) +ida_typeinf.tinfo_t.del_attrs(self) -> None Del all type attributes. typerefs cannot be modified by this function. -ida_typeinf.tinfo_t.del_edm (method) - del_edm(self, idx, etf_flags=0) -> tinfo_code_t +ida_typeinf.tinfo_t.del_edm(self, *args) + Delete an enumerator with the specified name + or the specified index, in the specified tinfo_t object. - @param idx: size_t - @param etf_flags: uint - -ida_typeinf.tinfo_t.del_edms (method) - del_edms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t - Delete enum members + This method has the following signatures: - @param idx1: (C++: size_t) index in edmvec_t - @param idx2: (C++: size_t) index in edmvec_t or size_t(-1) - @param etf_flags: (C++: uint) etf_flag_t Delete enum members in [idx1, idx2) - @note: For bitmask enum, the first member of a non-trivial group (having 2 or - more members) is considered as a group mask. It is impossible to delete - the group mask of a non-trivial group, other members of the group must be - deleted first. Empty groups are automatically deleted. + 1. del_edm(name: str) -> int + 2. del_edm(index: int) -> int + + @param name an enumerator name (1st form) + @param index an enumerator index (2nd form) + @return TERR_OK in case of success, or another TERR_* value in case of error -ida_typeinf.tinfo_t.del_udm (method) - del_udm(self, index, etf_flags=0) -> tinfo_code_t +ida_typeinf.tinfo_t.del_edm_by_value(self, value: int, etf_flags: int = 0, bmask: int = DEFMASK64, serial: int = 0) + Delete an enumerator with the specified value, + in the specified tinfo_t object. + + @param value the enumerator value + @return TERR_OK in case of success, or another TERR_* value in case of error + +ida_typeinf.tinfo_t.del_edms(self, idx1: "size_t", idx2: "size_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Delete enum members + + @param idx1: index in edmvec_t + @param idx2: index in edmvec_t or size_t(-1) + @param etf_flags: etf_flag_t Delete enum members in [idx1, idx2) + +ida_typeinf.tinfo_t.del_funcarg(self, idx: "size_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + +ida_typeinf.tinfo_t.del_funcargs(self, idx1: "size_t", idx2: "size_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Delete function arguments + + @param idx1: index in funcargvec_t + @param idx2: index in funcargvec_t or size_t(-1) + @param etf_flags: etf_flag_t Delete function arguments in [idx1, idx2) + +ida_typeinf.tinfo_t.del_udm(self, index: "size_t", etf_flags: "uint" = 0) -> "tinfo_code_t" Delete a structure/union member. - - @param index: (C++: size_t) - @param etf_flags: (C++: uint) -ida_typeinf.tinfo_t.del_udms (method) - del_udms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t +ida_typeinf.tinfo_t.del_udms(self, idx1: "size_t", idx2: "size_t", etf_flags: "uint" = 0) -> "tinfo_code_t" Delete structure/union members in the range [idx1, idx2) - - @param idx1: (C++: size_t) - @param idx2: (C++: size_t) - @param etf_flags: (C++: uint) -ida_typeinf.tinfo_t.deserialize (method) - deserialize(self, til, ptype, pfields=None, pfldcmts=None, cmt=None) -> bool +ida_typeinf.tinfo_t.deserialize(self, *args) -> bool + This function has the following signatures: + + 0. deserialize(til: const til_t *, ptype: const type_t **, pfields: const p_list **=nullptr, pfldcmts: const p_list **=nullptr, cmt: str=nullptr) -> bool + 1. deserialize(til: const til_t *, ptype: const qtype *, pfields: const qtype *=nullptr, pfldcmts: const qtype *=nullptr, cmt: str=nullptr) -> bool + + # 0: deserialize(til: const til_t *, ptype: const type_t **, pfields: const p_list **=nullptr, pfldcmts: const p_list **=nullptr, cmt: str=nullptr) -> bool + Deserialize a type string into a tinfo_t object. - @param til: (C++: const til_t *) til_t const * - @param ptype: (C++: const qtype *) type_t const ** - @param pfields: (C++: const qtype *) p_list const ** - @param pfldcmts: (C++: const qtype *) p_list const ** - @param cmt: (C++: const char *) char const * - deserialize(self, til, type, fields, cmts=None) -> bool + # 1: deserialize(til: const til_t *, ptype: const qtype *, pfields: const qtype *=nullptr, pfldcmts: const qtype *=nullptr, cmt: str=nullptr) -> bool - @param til: til_t const * - @param type: type_t const * - @param fields: p_list const * - @param cmts: p_list const * + Deserialize a type string into a tinfo_t object. -ida_typeinf.tinfo_t.dstr (method) - dstr(self) -> char const * +ida_typeinf.tinfo_t.detach(self) -> bool + Detach tinfo_t from the underlying type. After calling this finction, tinfo_t will lose its link to the underlying named or numbered type (if any) and will become a reference to a unique type. After that, any modifications to tinfo_t will affect only its type. + + +ida_typeinf.tinfo_t.dstr(self) -> str Function to facilitate debugging. -ida_typeinf.tinfo_t.edit_array (method) - edit_array(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (array_type_data_t *) > const & - @param etf_flags: uint +ida_typeinf.tinfo_t.edit_edm(self, *args) -> "tinfo_code_t" + Change constant value and/or bitmask + + @param idx: index in edmvec_t + @param value: old or new value + @param bmask: old or new bitmask + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.edit_bitfield (method) - edit_bitfield(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (bitfield_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_edm (method) - edit_edm(self, idx, value, bmask=bmask64_t(-1), etf_flags=0) -> tinfo_code_t - Change constant value and/or bitmask - - @param idx: (C++: size_t) index in edmvec_t - @param value: (C++: uint64) old or new value - @param bmask: (C++: bmask64_t) old or new bitmask - @note: if new bitmask is specified the index of constant may be changed - -ida_typeinf.tinfo_t.edit_enum (method) - edit_enum(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (enum_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_func (method) - edit_func(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (func_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_ptr (method) - edit_ptr(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (ptr_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_udt (method) - edit_udt(self, editor, etf_flags=0) -> tinfo_code_t - Edit udt/enum/func/array/ptr/bitfield. These functions may be used if the - desired functionality is not provided by the STA_... based functions. - - @param editor: (C++: const std::function< tinfo_code_t(udt_type_data_t *)> &) callback to modify the type details; should return true on - success - @param etf_flags: (C++: uint) combination of etf_flag_t constants - -ida_typeinf.tinfo_t.empty (method) - empty(self) -> bool +ida_typeinf.tinfo_t.empty(self) -> bool Was tinfo_t initialized with some type info or not? -ida_typeinf.tinfo_t.equals_to (method) - equals_to(self, r) -> bool - - @param r: tinfo_t const & +ida_typeinf.tinfo_t.equals_to(self, r: "tinfo_t") -> bool -ida_typeinf.tinfo_t.expand_udt (method) - expand_udt(self, idx, delta, etf_flags=0) -> tinfo_code_t - Expand/shtrink a structure by adding/removing a gap before the specified member. +ida_typeinf.tinfo_t.expand_udt(self, idx: "size_t", delta: "adiff_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Expand/shrink a structure by adding/removing a gap before the specified member. + For regular structures, either the gap can be accommodated by aligning the next member with an alignment directive, or an explicit "gap" member will be inserted. Also note that it is impossible to add a gap at the end of a regular structure. + When it comes to fixed-layout structures, there is no need to either add new "gap" members or align existing members, since all members have a fixed offset. It is possible to add a gap at the end of a fixed-layout structure, by passing `-1` as index. - @param idx: (C++: size_t) index of the member - @param delta: (C++: adiff_t) number of bytes to add or remove - @param etf_flags: (C++: uint) etf_flag_t Please note that it is impossible to add a gap at - the very end of a structure. However, adding before a regular - member is possible. This function can be used to remove gaps - in the middle of a structure by specifying a negative delta - value. + @param idx: index of the member + @param delta: number of bytes to add or remove + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.find_edm (method) - find_edm(self, edm, value, bmask=bmask64_t(-1), serial=0) -> tinfo_code_t - Find enum member - - @param edm: (C++: edm_t *) enum type member - @param value: uint64 - @param bmask: bmask64_t - find_edm(self, edm, name) -> tinfo_code_t - - @param edm: edm_t * - @param name: char const * +ida_typeinf.tinfo_t.find_edm(self, *args) -> "ssize_t" -ida_typeinf.tinfo_t.find_udm (method) - find_udm(self, udm, strmem_flags) -> int +ida_typeinf.tinfo_t.find_udm(self, *args) -> int + This function has the following signatures: + + 0. find_udm(udm: udm_t *, strmem_flags: int) -> int + 1. find_udm(offset: uint64, strmem_flags: int=0) -> int + 2. find_udm(name: str, strmem_flags: int=0) -> int + + # 0: find_udm(udm: udm_t *, strmem_flags: int) -> int + BTF_STRUCT,BTF_UNION: Find a udt member. * at the specified offset (STRMEM_OFFSET) * with the specified index (STRMEM_INDEX) * with the specified type (STRMEM_TYPE) * with the specified name (STRMEM_NAME) - @param udm: (C++: struct udm_t *) udm_t * - @param strmem_flags: (C++: int) - @return: the index of the found member or -1 - -ida_typeinf.tinfo_t.force_tid (method) - force_tid(self) -> tid_t - Get the type tid. Create if it does not exist yet. If the type comes from a base - til, the type will be copied to the local til and a new tid will be created for - it. (if the type comes from a base til, it does not have a tid yet). If the type - comes from the local til, this function is equivalent to get_tid() - @return: tid or BADADDR + + @returns the index of the found member or -1 + + # 1: find_udm(offset: uint64, strmem_flags: int=0) -> int + + BTF_STRUCT,BTF_UNION: Find an udt member at the specified offset + + @returns the index of the found member or -1 + + # 2: find_udm(name: str, strmem_flags: int=0) -> int + + BTF_STRUCT,BTF_UNION: Find an udt member by name + + @returns the index of the found member or -1 -ida_typeinf.tinfo_t.get_alias_target (method) - get_alias_target(self) -> uint32 - Get type alias If the type has no alias, return 0. +ida_typeinf.tinfo_t.force_tid(self) -> "tid_t" + Get the type tid. Create if it does not exist yet. If the type comes from a base til, the type will be copied to the local til and a new tid will be created for it. (if the type comes from a base til, it does not have a tid yet). If the type comes from the local til, this function is equivalent to get_tid() + + @returns tid or BADADDR -ida_typeinf.tinfo_t.get_array_details (method) - get_array_details(self, ai) -> bool +ida_typeinf.tinfo_t.get_alias_target(self) -> int + Get type alias If the type has no alias, return 0. + + +ida_typeinf.tinfo_t.get_alignment(self) -> int + Get type alignment This function returns the effective type alignment. Zero means error. + + +ida_typeinf.tinfo_t.get_array_details(self, ai: "array_type_data_t") -> bool Get the array specific info. - - @param ai: (C++: array_type_data_t *) -ida_typeinf.tinfo_t.get_array_element (method) - get_array_element(self) -> tinfo_t +ida_typeinf.tinfo_t.get_array_element(self) -> "tinfo_t" + BT_ARRAY: get type of array element. See also get_ptrarr_object() -ida_typeinf.tinfo_t.get_array_nelems (method) - get_array_nelems(self) -> int +ida_typeinf.tinfo_t.get_array_nelems(self) -> int + BT_ARRAY: get number of elements (-1 means error) -ida_typeinf.tinfo_t.get_attr (method) - get_attr(self, key, all_attrs=True) -> str or None +ida_typeinf.tinfo_t.get_attr(self, key: str, all_attrs: bool = True) -> "PyObject *" Get a type attribute. - - @param key: (C++: const qstring &) qstring const & - @param all_attrs: (C++: bool) -ida_typeinf.tinfo_t.get_attrs (method) - get_attrs(self, tav, all_attrs=False) -> bool +ida_typeinf.tinfo_t.get_attrs(self, tav: "type_attrs_t", all_attrs: bool = False) -> bool Get type attributes (all_attrs: include attributes of referenced types, if any) - - @param tav: (C++: type_attrs_t *) - @param all_attrs: (C++: bool) -ida_typeinf.tinfo_t.get_bit_buckets (method) - get_bit_buckets(self, buckets) -> bool - ::BT_STRUCT: get bit buckets Bit buckets are used to layout bitfields - - @param buckets: (C++: range64vec_t *) - @return: false if wrong type was passed +ida_typeinf.tinfo_t.get_bit_buckets(self, buckets: "range64vec_t") -> bool + ::BT_STRUCT: get bit buckets Bit buckets are used to layout bitfields + + @returns false if wrong type was passed -ida_typeinf.tinfo_t.get_bitfield_details (method) - get_bitfield_details(self, bi) -> bool +ida_typeinf.tinfo_t.get_bitfield_details(self, bi: "bitfield_type_data_t") -> bool Get the bitfield specific info. - - @param bi: (C++: bitfield_type_data_t *) -ida_typeinf.tinfo_t.get_declalign (method) - get_declalign(self) -> uchar +ida_typeinf.tinfo_t.get_by_edm_name(self, mname: str, til: "til_t" = None) -> "ssize_t" + Retrieve enum tinfo using enum member name + + @param mname: enum type member name + @param til: type library + @returns member index, otherwise returns -1. If the function fails, THIS object becomes empty. + +ida_typeinf.tinfo_t.get_declalign(self) -> "uchar" Get declared alignment of the type. -ida_typeinf.tinfo_t.get_decltype (method) - get_decltype(self) -> type_t - Get declared type (without resolving type references; they are returned as is). - Obviously this is a very fast function and should be used instead of - get_realtype() if possible. Please note that for typerefs this function will - return BTF_TYPEDEF. To determine if a typeref is a typedef, use is_typedef() +ida_typeinf.tinfo_t.get_decltype(self) -> "type_t" + Get declared type (without resolving type references; they are returned as is). Obviously this is a very fast function and should be used instead of get_realtype() if possible. Please note that for typerefs this function will return BTF_TYPEDEF. To determine if a typeref is a typedef, use is_typedef() + -ida_typeinf.tinfo_t.get_edm (method) - get_edm(self, edm, idx) -> tinfo_code_t - Get enum member +ida_typeinf.tinfo_t.get_edm(self, *args) -> Tuple[int, "edm_t"] + Retrieve an enumerator with either the specified name + or the specified index, in the specified tinfo_t object. - @param edm: (C++: edm_t *) enum type member - @param idx: (C++: size_t) enum member index - -ida_typeinf.tinfo_t.get_edm_by_tid (method) - get_edm_by_tid(self, edm, tid) -> ssize_t + This function has the following signatures: - @param edm: edm_t * - @param tid: tid_t + 1. get_edm(index: int) + 2. get_edm(name: str) + + @param index an enumerator index (1st form). + @param name an enumerator name (2nd form). + @return a tuple (int, edm_t), or (-1, None) if member not found -ida_typeinf.tinfo_t.get_enum_base_type (method) - get_enum_base_type(self) -> type_t - Get enum base type (convert enum to integer type) Returns BT_UNK if failed to - convert +ida_typeinf.tinfo_t.get_edm_by_tid(self, edm: "edm_t", tid: "tid_t") -> "ssize_t" -ida_typeinf.tinfo_t.get_enum_details (method) - get_enum_details(self, ei) -> bool +ida_typeinf.tinfo_t.get_edm_by_value(self, value: int, bmask: int = DEFMASK64, serial: int = 0) -> Tuple[int, "edm_t"] + Retrieve an enumerator with the specified value, + in the specified tinfo_t object. + + @param value the enumerator value + @return a tuple (int, edm_t), or (-1, None) if member not found + +ida_typeinf.tinfo_t.get_edm_tid(self, idx: "size_t") -> "tid_t" + Get enum member TID + + @param idx: enum member index + @returns tid or BADADDR The tid is used to collect xrefs to the member, it can be passed to xref-related functions instead of the address. + +ida_typeinf.tinfo_t.get_enum_base_type(self) -> "type_t" + Get enum base type (convert enum to integer type) Returns BT_UNK if failed to convert + + +ida_typeinf.tinfo_t.get_enum_details(self, ei: "enum_type_data_t") -> bool Get the enum specific info. - - @param ei: (C++: enum_type_data_t *) -ida_typeinf.tinfo_t.get_enum_radix (method) - get_enum_radix(self) -> int - Get enum constant radix - - @return: radix or 1 for BTE_CHAR enum_type_data_t::get_enum_radix() +ida_typeinf.tinfo_t.get_enum_nmembers(self) -> "size_t" + Get number of enum members. + + @returns BADSIZE if error -ida_typeinf.tinfo_t.get_final_element (method) - get_final_element(self) -> tinfo_t - repeat recursively: if an array, return the type of its element; else return the - type itself. +ida_typeinf.tinfo_t.get_enum_radix(self) -> int + Get enum constant radix + + @returns radix or 1 for BTE_CHAR enum_type_data_t::get_enum_radix() -ida_typeinf.tinfo_t.get_final_ordinal (method) - get_final_ordinal(self) -> uint32 +ida_typeinf.tinfo_t.get_enum_repr(self, repr: "value_repr_t") -> "tinfo_code_t" + Set the representation of enum members. + + @param repr: value_repr_t + +ida_typeinf.tinfo_t.get_enum_width(self) -> int + Get enum width + + @returns width of enum base type in bytes, 0 - unspecified, or -1 enum_type_data_t::calc_nbytes() + +ida_typeinf.tinfo_t.get_final_element(self) -> "tinfo_t" + repeat recursively: if an array, return the type of its element; else return the type itself. + +ida_typeinf.tinfo_t.get_final_ordinal(self) -> int Get final type ordinal (0 if none) -ida_typeinf.tinfo_t.get_final_type_name (method) - get_final_type_name(self) -> bool - Use in the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn). - - @return: the name of the last type in the chain (TYPEn). if there is no chain, - returns TYPE1 +ida_typeinf.tinfo_t.get_final_type_name(self) -> bool + Use in the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn). + + @returns the name of the last type in the chain (TYPEn). if there is no chain, returns TYPE1 -ida_typeinf.tinfo_t.get_forward_type (method) - get_forward_type(self) -> type_t - Get type of a forward declaration. For a forward declaration this function - returns its base type. In other cases it returns BT_UNK +ida_typeinf.tinfo_t.get_forward_type(self) -> "type_t" + Get type of a forward declaration. For a forward declaration this function returns its base type. In other cases it returns BT_UNK + -ida_typeinf.tinfo_t.get_func_details (method) - get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool +ida_typeinf.tinfo_t.get_frame_func(self) -> ida_idaapi.ea_t + Get function address for the frame. + +ida_typeinf.tinfo_t.get_func_details(self, fi: "func_type_data_t", gtd: "gtd_func_t" = GTD_CALC_ARGLOCS) -> bool Get only the function specific info for this tinfo_t. - - @param fi: (C++: func_type_data_t *) - @param gtd: (C++: gtd_func_t) enum gtd_func_t -ida_typeinf.tinfo_t.get_innermost_udm (method) - get_innermost_udm(self, bitoffset) -> tinfo_t - Get the innermost member at the given offset - - @param bitoffset: (C++: uint64) bit offset into the structure +ida_typeinf.tinfo_t.get_func_frame(self, pfn: "func_t const *") -> bool + Create a tinfo_t object for the function frame + + @param pfn: function + +ida_typeinf.tinfo_t.get_innermost_member_type(self, bitoffset: "uint64") -> "tinfo_t" + Get the innermost member type at the given offset + + @param bitoffset: bit offset into the structure + @retval the: innermost member type + +ida_typeinf.tinfo_t.get_innermost_udm(self, bitoffset: "uint64") -> "tinfo_t" + Get the innermost member at the given offset + + @param bitoffset: bit offset into the structure @retval udt: with the innermost member @retval empty: type if it is not a struct type or OFFSET could not be found -ida_typeinf.tinfo_t.get_methods (method) - get_methods(self, methods) -> bool +ida_typeinf.tinfo_t.get_methods(self, methods: "udtmembervec_t") -> bool + BT_COMPLEX: get a list of member functions declared in this udt. + + @returns false if no member functions exist + +ida_typeinf.tinfo_t.get_modifiers(self) -> "type_t" + +ida_typeinf.tinfo_t.get_named_type(self, *args) -> bool + This function has the following signatures: - @param BT_COMPLEX: get a list of member functions declared in this udt. - @return: false if no member functions exist - -ida_typeinf.tinfo_t.get_modifiers (method) - get_modifiers(self) -> type_t - -ida_typeinf.tinfo_t.get_named_type (method) - get_named_type(self, til, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool - Create a tinfo_t object for an existing named type. + 0. get_named_type(til: const til_t *, name: str, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true, try_ordinal: bool=true) -> bool + 1. get_named_type(name: str, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true, try_ordinal: bool=true) -> bool - @param til: (C++: const til_t *) type library to use - @param name: (C++: const char *) name of the type to link to - @param decl_type: (C++: type_t) if the reference was explicitly specified with the type tag - (BTF_STRUCT/BTF_UNION/BTF_ENUM) you may specify it. - the kernel will accept only the specified tag after resolving - the type. If the resolved type does not correspond to the - explicitly specified tag, the type will be considered as undefined - @param resolve: (C++: bool) true: immediately resolve the type and return success code. - @param try_ordinal: (C++: bool) true: try to replace name reference by an ordinal reference + # 0: get_named_type(til: const til_t *, name: str, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true, try_ordinal: bool=true) -> bool + + Create a tinfo_t object for an existing named type. + + + # 1: get_named_type(name: str, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true, try_ordinal: bool=true) -> bool -ida_typeinf.tinfo_t.get_nargs (method) - get_nargs(self) -> int +ida_typeinf.tinfo_t.get_nargs(self) -> int BT_FUNC or BT_PTR BT_FUNC: Calculate number of arguments (-1 - error) -ida_typeinf.tinfo_t.get_next_type_name (method) - get_next_type_name(self) -> bool - Use In the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn). +ida_typeinf.tinfo_t.get_next_type_name(self) -> bool + Use In the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn). + + @returns the name of the next type in the chain (TYPE2). if there is no chain, returns failure + +ida_typeinf.tinfo_t.get_nice_type_name(self) -> bool + Get the beautified type name. Get the referenced name and apply regular expressions from goodname.cfg to beautify the name + + +ida_typeinf.tinfo_t.get_nth_arg(self, n: int) -> "tinfo_t" + BT_FUNC or BT_PTR BT_FUNC: Get type of n-th arg (-1 means return type, see get_rettype()) + +ida_typeinf.tinfo_t.get_numbered_type(self, *args) -> bool + This function has the following signatures: - @return: the name of the next type in the chain (TYPE2). if there is no chain, - returns failure - -ida_typeinf.tinfo_t.get_nice_type_name (method) - get_nice_type_name(self) -> bool - Get the beautified type name. Get the referenced name and apply regular - expressions from goodname.cfg to beautify the name - -ida_typeinf.tinfo_t.get_nth_arg (method) - get_nth_arg(self, n) -> tinfo_t - BT_FUNC or BT_PTR BT_FUNC: Get type of n-th arg (-1 means return type, see - get_rettype()) + 0. get_numbered_type(til: const til_t *, ordinal: int, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true) -> bool + 1. get_numbered_type(ordinal: int, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true) -> bool - @param n: (C++: int) - -ida_typeinf.tinfo_t.get_numbered_type (method) - get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool - Create a tinfo_t object for an existing ordinal type. + # 0: get_numbered_type(til: const til_t *, ordinal: int, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true) -> bool - @param til: (C++: const til_t *) type library to use - @param ordinal: (C++: uint32) number of the type to link to - @param decl_type: (C++: type_t) if the reference was explicitly specified with the type tag - (BTF_STRUCT/BTF_UNION/BTF_ENUM) you may specify it. the kernel - will accept only the specified tag after resolving the type. - If the resolved type does not correspond to the explicitly - specified tag, the type will be considered as undefined - @param resolve: (C++: bool) true: immediately resolve the type and return success code + Create a tinfo_t object for an existing ordinal type. + + + # 1: get_numbered_type(ordinal: int, decl_type: type_t=BTF_TYPEDEF, resolve: bool=true) -> bool -ida_typeinf.tinfo_t.get_onemember_type (method) - get_onemember_type(self) -> tinfo_t +ida_typeinf.tinfo_t.get_onemember_type(self) -> "tinfo_t" For objects consisting of one member entirely: return type of the member. -ida_typeinf.tinfo_t.get_ordinal (method) - get_ordinal(self) -> uint32 +ida_typeinf.tinfo_t.get_ordinal(self) -> int Get type ordinal (only if the type was created as a numbered type, 0 if none) -ida_typeinf.tinfo_t.get_pointed_object (method) - get_pointed_object(self) -> tinfo_t +ida_typeinf.tinfo_t.get_pointed_object(self) -> "tinfo_t" + BT_PTR: get type of pointed object. If the current type is not a pointer, return empty type info. See also get_ptrarr_object() and remove_pointer() + -ida_typeinf.tinfo_t.get_ptr_details (method) - get_ptr_details(self, pi) -> bool +ida_typeinf.tinfo_t.get_ptr_details(self, pi: "ptr_type_data_t") -> bool Get the pointer info. - - @param pi: (C++: ptr_type_data_t *) -ida_typeinf.tinfo_t.get_ptrarr_object (method) - get_ptrarr_object(self) -> tinfo_t - BT_PTR & BT_ARRAY: get the pointed object or array element. If the current type - is not a pointer or array, return empty type info. +ida_typeinf.tinfo_t.get_ptrarr_object(self) -> "tinfo_t" + BT_PTR & BT_ARRAY: get the pointed object or array element. If the current type is not a pointer or array, return empty type info. + -ida_typeinf.tinfo_t.get_ptrarr_objsize (method) - get_ptrarr_objsize(self) -> int - BT_PTR & BT_ARRAY: get size of pointed object or array element. On error returns - -1 +ida_typeinf.tinfo_t.get_ptrarr_objsize(self) -> int + BT_PTR & BT_ARRAY: get size of pointed object or array element. On error returns -1 -ida_typeinf.tinfo_t.get_realtype (method) - get_realtype(self, full=False) -> type_t +ida_typeinf.tinfo_t.get_realtype(self, full: bool = False) -> "type_t" Get the resolved base type. Deserialization options: - * if full=true, the referenced type will be deserialized fully, this may not - always be desirable (slows down things) - * if full=false, we just return the base type, the referenced type will be - resolved again later if necessary (this may lead to multiple resolvings of the - same type) imho full=false is a better approach because it does not perform - unnecessary actions just in case. however, in some cases the caller knows that - it is very likely that full type info will be required. in those cases full=true - makes sense + * if full=true, the referenced type will be deserialized fully, this may not always be desirable (slows down things) + * if full=false, we just return the base type, the referenced type will be resolved again later if necessary (this may lead to multiple resolvings of the same type) imho full=false is a better approach because it does not perform unnecessary actions just in case. however, in some cases the caller knows that it is very likely that full type info will be required. in those cases full=true makes sense - @param full: (C++: bool) + + -ida_typeinf.tinfo_t.get_rettype (method) - get_rettype(self) -> tinfo_t +ida_typeinf.tinfo_t.get_rettype(self) -> "tinfo_t" BT_FUNC or BT_PTR BT_FUNC: Get the function's return type -ida_typeinf.tinfo_t.get_sign (method) - get_sign(self) -> type_sign_t +ida_typeinf.tinfo_t.get_sign(self) -> "type_sign_t" Get type sign. -ida_typeinf.tinfo_t.get_size (method) - get_size(self, p_effalign=None, gts_code=0) -> size_t - Get the type size in bytes. - - @param p_effalign: (C++: uint32 *) buffer for the alignment value - @param gts_code: (C++: int) combination of GTS_... constants - @return: BADSIZE in case of problems +ida_typeinf.tinfo_t.get_size(self, p_effalign: "uint32 *" = None, gts_code: int = 0) -> "size_t" + Get the type size in bytes. + + @param p_effalign: buffer for the alignment value + @param gts_code: combination of GTS_... constants + @returns BADSIZE in case of problems -ida_typeinf.tinfo_t.get_stock (method) - get_stock(id) -> tinfo_t - Get stock type information. This function can be used to get tinfo_t for some - common types. The same tinfo_t will be returned for the same id, thus saving - memory and increasing the speed Please note that retrieving the STI_SIZE_T or - STI_SSIZE_T stock type, will also have the side-effect of adding that type to - the 'idati' TIL, under the well-known name 'size_t' or 'ssize_t' (respectively). - The same is valid for STI_COMPLEX64 and STI_COMPLEX64 stock types with names - 'complex64_t' and 'complex128_t' (respectively). - - @param id: (C++: stock_type_id_t) enum stock_type_id_t +ida_typeinf.tinfo_t.get_stkvar(self, insn: "insn_t const &", x: "op_t const", v: int) -> "ssize_t" + Retrieve frame tinfo for a stack variable + + @param insn: the instruction + @param x: reference to instruction operand, may be nullptr + @param v: immediate value in the operand (usually x.addr) + @returns returns the member index, otherwise returns -1. if the function fails, THIS object becomes empty. -ida_typeinf.tinfo_t.get_tid (method) - get_tid(self) -> tid_t - Get the type tid Each type in the local type library has a so-called `tid` - associated with it. The tid is used to collect xrefs to the type. The tid is - created when the type is created in the local type library and does not change - afterwards. It can be passed to xref-related functions instead of the address. - - @return: tid or BADADDR - @note: types that do not come from a type library (that exist only in the - memory) can not have a tid. +ida_typeinf.tinfo_t.get_stock(id: "stock_type_id_t") -> "tinfo_t" + Get stock type information. This function can be used to get tinfo_t for some common types. The same tinfo_t will be returned for the same id, thus saving memory and increasing the speed Please note that retrieving the STI_SIZE_T or STI_SSIZE_T stock type, will also have the side-effect of adding that type to the 'idati' TIL, under the well-known name 'size_t' or 'ssize_t' (respectively). The same is valid for STI_COMPLEX64 and STI_COMPLEX64 stock types with names 'complex64_t' and 'complex128_t' (respectively). + -ida_typeinf.tinfo_t.get_til (method) - get_til(self) -> til_t +ida_typeinf.tinfo_t.get_tid(self) -> "tid_t" + Get the type tid Each type in the local type library has a so-called `tid` associated with it. The tid is used to collect xrefs to the type. The tid is created when the type is created in the local type library and does not change afterwards. It can be passed to xref-related functions instead of the address. + + @returns tid or BADADDR + +ida_typeinf.tinfo_t.get_til(self) -> "til_t *" Get the type library for tinfo_t. -ida_typeinf.tinfo_t.get_type_by_edm_name (method) - get_type_by_edm_name(self, mname, til=None) -> bool - Retrieve enum tinfo using enum member name - - @param mname: (C++: const char *) enum type member name - @param til: (C++: til_t *) type library - @return: success If the function fails, THIS object becomes empty. +ida_typeinf.tinfo_t.get_type_by_tid(self, tid: "tid_t") -> bool -ida_typeinf.tinfo_t.get_type_by_tid (method) - get_type_by_tid(self, tid) -> bool - - @param tid: tid_t +ida_typeinf.tinfo_t.get_type_cmt(self) -> int + Get type comment + + @returns 0-failed, 1-returned regular comment, 2-returned repeatable comment -ida_typeinf.tinfo_t.get_type_cmt (method) - get_type_cmt(self) -> int - Get type comment - - @return: 0-failed, 1-returned regular comment, 2-returned repeatable comment +ida_typeinf.tinfo_t.get_type_name(self) -> bool + Does a type refer to a name?. If yes, fill the provided buffer with the type name and return true. Names are returned for numbered types too: either a user-defined nice name or, if a user-provided name does not exist, an ordinal name (like #xx, see create_numbered_type_name()). + -ida_typeinf.tinfo_t.get_type_name (method) - get_type_name(self) -> bool - Does a type refer to a name?. If yes, fill the provided buffer with the type - name and return true. Names are returned for numbered types too: either a user- - defined nice name or, if a user-provided name does not exist, an ordinal name - (like #xx, see create_numbered_type_name()). - -ida_typeinf.tinfo_t.get_type_rptcmt (method) - get_type_rptcmt(self) -> bool +ida_typeinf.tinfo_t.get_type_rptcmt(self) -> bool Get type comment only if it is repeatable. -ida_typeinf.tinfo_t.get_udm_by_tid (method) - get_udm_by_tid(self, udm, tid) -> ssize_t - Retrive tinfo using type TID or struct/enum member MID +ida_typeinf.tinfo_t.get_udm(self, *args) -> Union[Tuple[int, "udm_t"], Tuple[None, None]] + Retrieve a structure/union member with either the specified name + or the specified index, in the specified tinfo_t object. - @param udm: (C++: udm_t *) [out]: place to save the found member to, may be nullptr - @param tid: (C++: tid_t) tid can denote a type tid or a member tid. - @return: if a member tid was specified, returns the member index, otherwise - returns -1. if the function fails, THIS object becomes empty. - -ida_typeinf.tinfo_t.get_udm_tid (method) - get_udm_tid(self, idx) -> tid_t - Get udt member TID + This function has the following signatures: - @param idx: (C++: size_t) the index of udt the member - @return: tid or BADADDR The tid is used to collect xrefs to the member, it can - be passed to xref-related functions instead of the address. + 1. get_udm(index: int) + 2. get_udm(name: str) + + @param index a member index (1st form) + @param name a member name (2nd form) + @return a tuple (int, udm_t), or (-1, None) if member not found -ida_typeinf.tinfo_t.get_udt_details (method) - get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool +ida_typeinf.tinfo_t.get_udm_by_offset(self, offset: int) + Retrieve a structure/union member with the specified offset, + in the specified tinfo_t object. + + @param offset the member offset + @return a tuple (int, udm_t), or (-1, None) if member not found + +ida_typeinf.tinfo_t.get_udm_by_tid(self, udm: "udm_t", tid: "tid_t") -> "ssize_t" + +ida_typeinf.tinfo_t.get_udm_tid(self, idx: "size_t") -> "tid_t" + Get udt member TID + + @param idx: the index of udt the member + @returns tid or BADADDR The tid is used to collect xrefs to the member, it can be passed to xref-related functions instead of the address. + +ida_typeinf.tinfo_t.get_udt_details(self, udt: "udt_type_data_t", gtd: "gtd_udt_t" = GTD_CALC_LAYOUT) -> bool Get the udt specific info. - - @param udt: (C++: udt_type_data_t *) - @param gtd: (C++: gtd_udt_t) enum gtd_udt_t -ida_typeinf.tinfo_t.get_udt_nmembers (method) - get_udt_nmembers(self) -> int +ida_typeinf.tinfo_t.get_udt_nmembers(self) -> int Get number of udt members. -1-error. -ida_typeinf.tinfo_t.get_unpadded_size (method) - get_unpadded_size(self) -> size_t - Get the type size in bytes without the final padding, in bytes. For some UDTs - get_unpadded_size() != get_size() +ida_typeinf.tinfo_t.get_unpadded_size(self) -> "size_t" + Get the type size in bytes without the final padding, in bytes. For some UDTs get_unpadded_size() != get_size() + -ida_typeinf.tinfo_t.has_details (method) - has_details(self) -> bool +ida_typeinf.tinfo_t.has_details(self) -> bool Does this type refer to a nontrivial type? -ida_typeinf.tinfo_t.has_union (method) - has_union(self) -> bool +ida_typeinf.tinfo_t.has_union(self) -> bool Has a member of type "union"? -ida_typeinf.tinfo_t.has_vftable (method) - has_vftable(self) -> bool +ida_typeinf.tinfo_t.has_vftable(self) -> bool Has a vftable? -ida_typeinf.tinfo_t.is_aliased (method) - is_aliased(self) -> bool +ida_typeinf.tinfo_t.is_aliased(self) -> bool -ida_typeinf.tinfo_t.is_anonymous_udt (method) - is_anonymous_udt(self) -> bool - Is an anonymous struct/union? We assume that types with names are anonymous if - the name starts with $ +ida_typeinf.tinfo_t.is_anonymous_udt(self) -> bool + Is an anonymous struct/union? We assume that types with names are anonymous if the name starts with $ + -ida_typeinf.tinfo_t.is_arithmetic (method) - is_arithmetic(self) -> bool +ida_typeinf.tinfo_t.is_arithmetic(self) -> bool is_type_arithmetic(get_realtype()) -ida_typeinf.tinfo_t.is_array (method) - is_array(self) -> bool +ida_typeinf.tinfo_t.is_array(self) -> bool is_type_array(get_realtype()) -ida_typeinf.tinfo_t.is_bitfield (method) - is_bitfield(self) -> bool +ida_typeinf.tinfo_t.is_bitfield(self) -> bool is_type_bitfld(get_realtype()) -ida_typeinf.tinfo_t.is_bitmask_enum (method) - is_bitmask_enum(self) -> bool - Is bitmask enum? - - @return: true for bitmask enum and false in other cases - enum_type_data_t::is_bf() +ida_typeinf.tinfo_t.is_bitmask_enum(self) -> bool + Is bitmask enum? + + @returns true for bitmask enum and false in other cases enum_type_data_t::is_bf() -ida_typeinf.tinfo_t.is_bool (method) - is_bool(self) -> bool +ida_typeinf.tinfo_t.is_bool(self) -> bool is_type_bool(get_realtype()) -ida_typeinf.tinfo_t.is_castable_to (method) - is_castable_to(self, target) -> bool - - @param target: tinfo_t const & +ida_typeinf.tinfo_t.is_castable_to(self, target: "tinfo_t") -> bool -ida_typeinf.tinfo_t.is_char (method) - is_char(self) -> bool +ida_typeinf.tinfo_t.is_char(self) -> bool is_type_char(get_realtype()) -ida_typeinf.tinfo_t.is_complex (method) - is_complex(self) -> bool +ida_typeinf.tinfo_t.is_complex(self) -> bool is_type_complex(get_realtype()) -ida_typeinf.tinfo_t.is_const (method) - is_const(self) -> bool +ida_typeinf.tinfo_t.is_const(self) -> bool is_type_const(get_realtype()) -ida_typeinf.tinfo_t.is_correct (method) - is_correct(self) -> bool - Is the type object correct?. It is possible to create incorrect types. For - example, we can define a function that returns an enum and then delete the enum - type. If this function returns false, the type should not be used in - disassembly. Please note that this function does not verify all involved types: - for example, pointers to undefined types are permitted. +ida_typeinf.tinfo_t.is_correct(self) -> bool + Is the type object correct?. It is possible to create incorrect types. For example, we can define a function that returns an enum and then delete the enum type. If this function returns false, the type should not be used in disassembly. Please note that this function does not verify all involved types: for example, pointers to undefined types are permitted. + -ida_typeinf.tinfo_t.is_decl_array (method) - is_decl_array(self) -> bool +ida_typeinf.tinfo_t.is_decl_array(self) -> bool is_type_array(get_decltype()) -ida_typeinf.tinfo_t.is_decl_bitfield (method) - is_decl_bitfield(self) -> bool +ida_typeinf.tinfo_t.is_decl_bitfield(self) -> bool is_type_bitfld(get_decltype()) -ida_typeinf.tinfo_t.is_decl_bool (method) - is_decl_bool(self) -> bool +ida_typeinf.tinfo_t.is_decl_bool(self) -> bool is_type_bool(get_decltype()) -ida_typeinf.tinfo_t.is_decl_char (method) - is_decl_char(self) -> bool +ida_typeinf.tinfo_t.is_decl_char(self) -> bool is_type_char(get_decltype()) -ida_typeinf.tinfo_t.is_decl_complex (method) - is_decl_complex(self) -> bool +ida_typeinf.tinfo_t.is_decl_complex(self) -> bool is_type_complex(get_decltype()) -ida_typeinf.tinfo_t.is_decl_const (method) - is_decl_const(self) -> bool +ida_typeinf.tinfo_t.is_decl_const(self) -> bool is_type_const(get_decltype()) -ida_typeinf.tinfo_t.is_decl_double (method) - is_decl_double(self) -> bool +ida_typeinf.tinfo_t.is_decl_double(self) -> bool is_type_double(get_decltype()) -ida_typeinf.tinfo_t.is_decl_enum (method) - is_decl_enum(self) -> bool +ida_typeinf.tinfo_t.is_decl_enum(self) -> bool is_type_enum(get_decltype()) -ida_typeinf.tinfo_t.is_decl_float (method) - is_decl_float(self) -> bool +ida_typeinf.tinfo_t.is_decl_float(self) -> bool is_type_float(get_decltype()) -ida_typeinf.tinfo_t.is_decl_floating (method) - is_decl_floating(self) -> bool +ida_typeinf.tinfo_t.is_decl_floating(self) -> bool is_type_floating(get_decltype()) -ida_typeinf.tinfo_t.is_decl_func (method) - is_decl_func(self) -> bool +ida_typeinf.tinfo_t.is_decl_func(self) -> bool is_type_func(get_decltype()) -ida_typeinf.tinfo_t.is_decl_int (method) - is_decl_int(self) -> bool +ida_typeinf.tinfo_t.is_decl_int(self) -> bool is_type_int(get_decltype()) -ida_typeinf.tinfo_t.is_decl_int128 (method) - is_decl_int128(self) -> bool +ida_typeinf.tinfo_t.is_decl_int128(self) -> bool is_type_int128(get_decltype()) -ida_typeinf.tinfo_t.is_decl_int16 (method) - is_decl_int16(self) -> bool +ida_typeinf.tinfo_t.is_decl_int16(self) -> bool is_type_int16(get_decltype()) -ida_typeinf.tinfo_t.is_decl_int32 (method) - is_decl_int32(self) -> bool +ida_typeinf.tinfo_t.is_decl_int32(self) -> bool is_type_int32(get_decltype()) -ida_typeinf.tinfo_t.is_decl_int64 (method) - is_decl_int64(self) -> bool +ida_typeinf.tinfo_t.is_decl_int64(self) -> bool is_type_int64(get_decltype()) -ida_typeinf.tinfo_t.is_decl_last (method) - is_decl_last(self) -> bool +ida_typeinf.tinfo_t.is_decl_last(self) -> bool is_typeid_last(get_decltype()) -ida_typeinf.tinfo_t.is_decl_ldouble (method) - is_decl_ldouble(self) -> bool +ida_typeinf.tinfo_t.is_decl_ldouble(self) -> bool is_type_ldouble(get_decltype()) -ida_typeinf.tinfo_t.is_decl_paf (method) - is_decl_paf(self) -> bool +ida_typeinf.tinfo_t.is_decl_paf(self) -> bool is_type_paf(get_decltype()) -ida_typeinf.tinfo_t.is_decl_partial (method) - is_decl_partial(self) -> bool +ida_typeinf.tinfo_t.is_decl_partial(self) -> bool is_type_partial(get_decltype()) -ida_typeinf.tinfo_t.is_decl_ptr (method) - is_decl_ptr(self) -> bool +ida_typeinf.tinfo_t.is_decl_ptr(self) -> bool is_type_ptr(get_decltype()) -ida_typeinf.tinfo_t.is_decl_struct (method) - is_decl_struct(self) -> bool +ida_typeinf.tinfo_t.is_decl_struct(self) -> bool is_type_struct(get_decltype()) -ida_typeinf.tinfo_t.is_decl_sue (method) - is_decl_sue(self) -> bool +ida_typeinf.tinfo_t.is_decl_sue(self) -> bool is_type_sue(get_decltype()) -ida_typeinf.tinfo_t.is_decl_tbyte (method) - is_decl_tbyte(self) -> bool +ida_typeinf.tinfo_t.is_decl_tbyte(self) -> bool is_type_tbyte(get_decltype()) -ida_typeinf.tinfo_t.is_decl_typedef (method) - is_decl_typedef(self) -> bool +ida_typeinf.tinfo_t.is_decl_typedef(self) -> bool is_type_typedef(get_decltype()) -ida_typeinf.tinfo_t.is_decl_uchar (method) - is_decl_uchar(self) -> bool +ida_typeinf.tinfo_t.is_decl_uchar(self) -> bool is_type_uchar(get_decltype()) -ida_typeinf.tinfo_t.is_decl_udt (method) - is_decl_udt(self) -> bool +ida_typeinf.tinfo_t.is_decl_udt(self) -> bool is_type_struni(get_decltype()) -ida_typeinf.tinfo_t.is_decl_uint (method) - is_decl_uint(self) -> bool +ida_typeinf.tinfo_t.is_decl_uint(self) -> bool is_type_uint(get_decltype()) -ida_typeinf.tinfo_t.is_decl_uint128 (method) - is_decl_uint128(self) -> bool +ida_typeinf.tinfo_t.is_decl_uint128(self) -> bool is_type_uint128(get_decltype()) -ida_typeinf.tinfo_t.is_decl_uint16 (method) - is_decl_uint16(self) -> bool +ida_typeinf.tinfo_t.is_decl_uint16(self) -> bool is_type_uint16(get_decltype()) -ida_typeinf.tinfo_t.is_decl_uint32 (method) - is_decl_uint32(self) -> bool +ida_typeinf.tinfo_t.is_decl_uint32(self) -> bool is_type_uint32(get_decltype()) -ida_typeinf.tinfo_t.is_decl_uint64 (method) - is_decl_uint64(self) -> bool +ida_typeinf.tinfo_t.is_decl_uint64(self) -> bool is_type_uint64(get_decltype()) -ida_typeinf.tinfo_t.is_decl_union (method) - is_decl_union(self) -> bool +ida_typeinf.tinfo_t.is_decl_union(self) -> bool is_type_union(get_decltype()) -ida_typeinf.tinfo_t.is_decl_unknown (method) - is_decl_unknown(self) -> bool +ida_typeinf.tinfo_t.is_decl_unknown(self) -> bool is_type_unknown(get_decltype()) -ida_typeinf.tinfo_t.is_decl_void (method) - is_decl_void(self) -> bool +ida_typeinf.tinfo_t.is_decl_void(self) -> bool is_type_void(get_decltype()) -ida_typeinf.tinfo_t.is_decl_volatile (method) - is_decl_volatile(self) -> bool +ida_typeinf.tinfo_t.is_decl_volatile(self) -> bool is_type_volatile(get_decltype()) -ida_typeinf.tinfo_t.is_double (method) - is_double(self) -> bool +ida_typeinf.tinfo_t.is_double(self) -> bool is_type_double(get_realtype()) -ida_typeinf.tinfo_t.is_empty_udt (method) - is_empty_udt(self) -> bool +ida_typeinf.tinfo_t.is_empty_enum(self) -> bool + Is an empty enum? (has no constants) + +ida_typeinf.tinfo_t.is_empty_udt(self) -> bool Is an empty struct/union? (has no fields) -ida_typeinf.tinfo_t.is_enum (method) - is_enum(self) -> bool +ida_typeinf.tinfo_t.is_enum(self) -> bool is_type_enum(get_realtype()) -ida_typeinf.tinfo_t.is_ext_arithmetic (method) - is_ext_arithmetic(self) -> bool - is_type_ext_arithmetic(get_realtype()) +ida_typeinf.tinfo_t.is_ext_arithmetic(self) -> bool + is_type_ext_arithmetic(get_realtype()) + -ida_typeinf.tinfo_t.is_ext_integral (method) - is_ext_integral(self) -> bool +ida_typeinf.tinfo_t.is_ext_integral(self) -> bool is_type_ext_integral(get_realtype()) -ida_typeinf.tinfo_t.is_float (method) - is_float(self) -> bool +ida_typeinf.tinfo_t.is_fixed_struct(self) -> bool + Is a structure with fixed offsets? + +ida_typeinf.tinfo_t.is_float(self) -> bool is_type_float(get_realtype()) -ida_typeinf.tinfo_t.is_floating (method) - is_floating(self) -> bool +ida_typeinf.tinfo_t.is_floating(self) -> bool is_type_floating(get_realtype()) -ida_typeinf.tinfo_t.is_forward_decl (method) - is_forward_decl(self) -> bool - Is this a forward declaration?. Forward declarations are placeholders: the type - definition does not exist +ida_typeinf.tinfo_t.is_forward_decl(self) -> bool + Is this a forward declaration?. Forward declarations are placeholders: the type definition does not exist + -ida_typeinf.tinfo_t.is_forward_enum (method) - is_forward_enum(self) -> bool +ida_typeinf.tinfo_t.is_forward_enum(self) -> bool -ida_typeinf.tinfo_t.is_forward_struct (method) - is_forward_struct(self) -> bool +ida_typeinf.tinfo_t.is_forward_struct(self) -> bool -ida_typeinf.tinfo_t.is_forward_union (method) - is_forward_union(self) -> bool +ida_typeinf.tinfo_t.is_forward_union(self) -> bool -ida_typeinf.tinfo_t.is_from_subtil (method) - is_from_subtil(self) -> bool - Was the named type found in some base type library (not the top level type - library)?. If yes, it usually means that the type comes from some loaded type - library, not the local type library for the database +ida_typeinf.tinfo_t.is_frame(self) -> bool + Is a function frame? -ida_typeinf.tinfo_t.is_func (method) - is_func(self) -> bool +ida_typeinf.tinfo_t.is_from_subtil(self) -> bool + Was the named type found in some base type library (not the top level type library)?. If yes, it usually means that the type comes from some loaded type library, not the local type library for the database + + +ida_typeinf.tinfo_t.is_func(self) -> bool is_type_func(get_realtype()) -ida_typeinf.tinfo_t.is_funcptr (method) - is_funcptr(self) -> bool +ida_typeinf.tinfo_t.is_funcptr(self) -> bool Is this pointer to a function? -ida_typeinf.tinfo_t.is_high_func (method) - is_high_func(self) -> bool +ida_typeinf.tinfo_t.is_high_func(self) -> bool + BT_FUNC: Is high level type? -ida_typeinf.tinfo_t.is_int (method) - is_int(self) -> bool +ida_typeinf.tinfo_t.is_int(self) -> bool is_type_int(get_realtype()) -ida_typeinf.tinfo_t.is_int128 (method) - is_int128(self) -> bool +ida_typeinf.tinfo_t.is_int128(self) -> bool is_type_int128(get_realtype()) -ida_typeinf.tinfo_t.is_int16 (method) - is_int16(self) -> bool +ida_typeinf.tinfo_t.is_int16(self) -> bool is_type_int16(get_realtype()) -ida_typeinf.tinfo_t.is_int32 (method) - is_int32(self) -> bool +ida_typeinf.tinfo_t.is_int32(self) -> bool is_type_int32(get_realtype()) -ida_typeinf.tinfo_t.is_int64 (method) - is_int64(self) -> bool +ida_typeinf.tinfo_t.is_int64(self) -> bool is_type_int64(get_realtype()) -ida_typeinf.tinfo_t.is_integral (method) - is_integral(self) -> bool +ida_typeinf.tinfo_t.is_integral(self) -> bool is_type_integral(get_realtype()) -ida_typeinf.tinfo_t.is_ldouble (method) - is_ldouble(self) -> bool +ida_typeinf.tinfo_t.is_ldouble(self) -> bool is_type_ldouble(get_realtype()) -ida_typeinf.tinfo_t.is_manually_castable_to (method) - is_manually_castable_to(self, target) -> bool - - @param target: tinfo_t const & +ida_typeinf.tinfo_t.is_manually_castable_to(self, target: "tinfo_t") -> bool -ida_typeinf.tinfo_t.is_one_fpval (method) - is_one_fpval(self) -> bool +ida_typeinf.tinfo_t.is_one_fpval(self) -> bool Floating value or an object consisting of one floating member entirely. -ida_typeinf.tinfo_t.is_paf (method) - is_paf(self) -> bool +ida_typeinf.tinfo_t.is_paf(self) -> bool is_type_paf(get_realtype()) -ida_typeinf.tinfo_t.is_partial (method) - is_partial(self) -> bool +ida_typeinf.tinfo_t.is_partial(self) -> bool is_type_partial(get_realtype()) -ida_typeinf.tinfo_t.is_ptr (method) - is_ptr(self) -> bool +ida_typeinf.tinfo_t.is_ptr(self) -> bool is_type_ptr(get_realtype()) -ida_typeinf.tinfo_t.is_ptr_or_array (method) - is_ptr_or_array(self) -> bool +ida_typeinf.tinfo_t.is_ptr_or_array(self) -> bool is_type_ptr_or_array(get_realtype()) -ida_typeinf.tinfo_t.is_purging_cc (method) - is_purging_cc(self) -> bool +ida_typeinf.tinfo_t.is_punknown(self) -> bool + Is "_UNKNOWN *"?. This function does not check the pointer attributes and type modifiers. + +ida_typeinf.tinfo_t.is_purging_cc(self) -> bool is_purging_cc(get_cc()) -ida_typeinf.tinfo_t.is_pvoid (method) - is_pvoid(self) -> bool - Is "void *"?. This function does not check the pointer attributes and type - modifiers. +ida_typeinf.tinfo_t.is_pvoid(self) -> bool + Is "void *"?. This function does not check the pointer attributes and type modifiers. -ida_typeinf.tinfo_t.is_scalar (method) - is_scalar(self) -> bool +ida_typeinf.tinfo_t.is_scalar(self) -> bool Does the type represent a single number? -ida_typeinf.tinfo_t.is_shifted_ptr (method) - is_shifted_ptr(self) -> bool +ida_typeinf.tinfo_t.is_shifted_ptr(self) -> bool Is a shifted pointer? -ida_typeinf.tinfo_t.is_signed (method) - is_signed(self) -> bool +ida_typeinf.tinfo_t.is_signed(self) -> bool Is this a signed type? -ida_typeinf.tinfo_t.is_small_udt (method) - is_small_udt(self) -> bool +ida_typeinf.tinfo_t.is_small_udt(self) -> bool Is a small udt? (can fit a register or a pair of registers) -ida_typeinf.tinfo_t.is_sse_type (method) - is_sse_type(self) -> bool +ida_typeinf.tinfo_t.is_sse_type(self) -> bool Is a SSE vector type? -ida_typeinf.tinfo_t.is_struct (method) - is_struct(self) -> bool +ida_typeinf.tinfo_t.is_struct(self) -> bool is_type_struct(get_realtype()) -ida_typeinf.tinfo_t.is_sue (method) - is_sue(self) -> bool +ida_typeinf.tinfo_t.is_sue(self) -> bool is_type_sue(get_realtype()) -ida_typeinf.tinfo_t.is_tbyte (method) - is_tbyte(self) -> bool +ida_typeinf.tinfo_t.is_tbyte(self) -> bool is_type_tbyte(get_realtype()) -ida_typeinf.tinfo_t.is_typedef (method) - is_typedef(self) -> bool - Is this a typedef?. This function will return true for a reference to a local - type that is declared as a typedef. +ida_typeinf.tinfo_t.is_typedef(self) -> bool + Is this a typedef?. This function will return true for a reference to a local type that is declared as a typedef. + -ida_typeinf.tinfo_t.is_typeref (method) - is_typeref(self) -> bool +ida_typeinf.tinfo_t.is_typeref(self) -> bool Is this type a type reference?. -ida_typeinf.tinfo_t.is_uchar (method) - is_uchar(self) -> bool +ida_typeinf.tinfo_t.is_uchar(self) -> bool is_type_uchar(get_realtype()) -ida_typeinf.tinfo_t.is_udt (method) - is_udt(self) -> bool +ida_typeinf.tinfo_t.is_udm_by_til(self, idx: "size_t") -> bool + Was the member created due to the type system + + @param idx: index of the member + +ida_typeinf.tinfo_t.is_udt(self) -> bool is_type_struni(get_realtype()) -ida_typeinf.tinfo_t.is_uint (method) - is_uint(self) -> bool +ida_typeinf.tinfo_t.is_uint(self) -> bool is_type_uint(get_realtype()) -ida_typeinf.tinfo_t.is_uint128 (method) - is_uint128(self) -> bool +ida_typeinf.tinfo_t.is_uint128(self) -> bool is_type_uint128(get_realtype()) -ida_typeinf.tinfo_t.is_uint16 (method) - is_uint16(self) -> bool +ida_typeinf.tinfo_t.is_uint16(self) -> bool is_type_uint16(get_realtype()) -ida_typeinf.tinfo_t.is_uint32 (method) - is_uint32(self) -> bool +ida_typeinf.tinfo_t.is_uint32(self) -> bool is_type_uint32(get_realtype()) -ida_typeinf.tinfo_t.is_uint64 (method) - is_uint64(self) -> bool +ida_typeinf.tinfo_t.is_uint64(self) -> bool is_type_uint64(get_realtype()) -ida_typeinf.tinfo_t.is_union (method) - is_union(self) -> bool +ida_typeinf.tinfo_t.is_union(self) -> bool is_type_union(get_realtype()) -ida_typeinf.tinfo_t.is_unknown (method) - is_unknown(self) -> bool +ida_typeinf.tinfo_t.is_unknown(self) -> bool is_type_unknown(get_realtype()) -ida_typeinf.tinfo_t.is_unsigned (method) - is_unsigned(self) -> bool +ida_typeinf.tinfo_t.is_unsigned(self) -> bool Is this an unsigned type? -ida_typeinf.tinfo_t.is_user_cc (method) - is_user_cc(self) -> bool +ida_typeinf.tinfo_t.is_user_cc(self) -> bool is_user_cc(get_cc()) -ida_typeinf.tinfo_t.is_vararg_cc (method) - is_vararg_cc(self) -> bool +ida_typeinf.tinfo_t.is_vararg_cc(self) -> bool is_vararg_cc(get_cc()) -ida_typeinf.tinfo_t.is_varmember (method) - is_varmember(self) -> bool - Can the type be of a variable struct member? This function checks for: - is_array() && array.nelems==0 Such a member can be only the very last member of - a structure +ida_typeinf.tinfo_t.is_varmember(self) -> bool + Can the type be of a variable struct member? This function checks for: is_array() && array.nelems==0 Such a member can be only the very last member of a structure + -ida_typeinf.tinfo_t.is_varstruct (method) - is_varstruct(self) -> bool +ida_typeinf.tinfo_t.is_varstruct(self) -> bool Is a variable-size structure? -ida_typeinf.tinfo_t.is_vftable (method) - is_vftable(self) -> bool +ida_typeinf.tinfo_t.is_vftable(self) -> bool Is a vftable type? -ida_typeinf.tinfo_t.is_void (method) - is_void(self) -> bool +ida_typeinf.tinfo_t.is_void(self) -> bool is_type_void(get_realtype()) -ida_typeinf.tinfo_t.is_volatile (method) - is_volatile(self) -> bool +ida_typeinf.tinfo_t.is_volatile(self) -> bool is_type_volatile(get_realtype()) -ida_typeinf.tinfo_t.is_well_defined (method) - is_well_defined(self) -> bool - !(empty()) && !(is_decl_partial()) +ida_typeinf.tinfo_t.is_well_defined(self) -> bool + !(empty()) && !(is_decl_partial()) && !(is_punknown()) -ida_typeinf.tinfo_t.parse (method) - parse(self, decl, til=None, pt_flags=0) -> bool - Convenience function to parse a string with a type declaration +ida_typeinf.tinfo_t.iter_enum(self) + Iterate on the members composing this enumeration. - @param decl: (C++: const char *) a type declaration - @param til: (C++: til_t *) type library to use - @param pt_flags: (C++: int) combination of Type parsing flags bits + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_enum") + for edm in tif.iter_enum(): + print(f"{edm.name} = {edm.value}") + + Will raise an exception if this type is not an enumeration + + @return a edm_t-producing generator -ida_typeinf.tinfo_t.present (method) - present(self) -> bool +ida_typeinf.tinfo_t.iter_func(self) + Iterate on the arguments contained in this function prototype + + Example: + + address = ... + func = ida_funcs.get_func(address) + func_type = func.prototype + for arg in func_type.iter_func(): + print(f"{arg.name}, of type {arg.type}") + + Will raise an exception if this type is not a function + + @return a funcarg_t-producing generator + +ida_typeinf.tinfo_t.iter_struct(self) + Iterate on the members composing this structure. + + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_struc") + for udm in tif.iter_struct(): + print(f"{udm.name} at bit offset {udm.offset}") + + Will raise an exception if this type is not a structure. + + @return a udm_t-producing generator + +ida_typeinf.tinfo_t.iter_udt(self) + Iterate on the members composing this structure, or union. + + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_type") + for udm in tif.iter_udt(): + print(f"{udm.name} at bit offset {udm.offset} with type {udm.type}") + + Will raise an exception if this type is not a structure, or union + + @return a udm_t-producing generator + +ida_typeinf.tinfo_t.iter_union(self) + Iterate on the members composing this union. + + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_union") + for udm in tif.iter_union(): + print(f"{udm.name}, with type {udm.type}") + + Will raise an exception if this type is not a union. + + @return a udm_t-producing generator + +ida_typeinf.tinfo_t.parse(self, decl: str, til: "til_t" = None, pt_flags: int = 0) -> bool + Convenience function to parse a string with a type declaration + + @param decl: a type declaration + @param til: type library to use + @param pt_flags: combination of Type parsing flags bits + +ida_typeinf.tinfo_t.present(self) -> bool Is the type really present? (not a reference to a missing type, for example) -ida_typeinf.tinfo_t.read_bitfield_value (method) - read_bitfield_value(self, v, bitoff) -> uint64 - - @param v: uint64 - @param bitoff: int +ida_typeinf.tinfo_t.read_bitfield_value(self, v: "uint64", bitoff: int) -> "uint64" -ida_typeinf.tinfo_t.remove_ptr_or_array (method) - remove_ptr_or_array(self) -> bool - Replace the current type with the ptr obj or array element. This function - performs one of the following conversions: +ida_typeinf.tinfo_t.remove_ptr_or_array(self) -> bool + Replace the current type with the ptr obj or array element. This function performs one of the following conversions: * type[] => type - * type* => type If the conversion is performed successfully, return true - -ida_typeinf.tinfo_t.rename_edm (method) - rename_edm(self, idx, name, etf_flags=0) -> tinfo_code_t - Rename a enum member + * type* => type If the conversion is performed successfully, return true - @param idx: (C++: size_t) index in edmvec_t - @param name: (C++: const char *) new name - @param etf_flags: (C++: uint) etf_flag_t ETF_FORCENAME may be used in case of - TERR_ALIEN_NAME - @note: ETF_NO_SAVE is ignored - -ida_typeinf.tinfo_t.rename_type (method) - rename_type(self, name, ntf_flags=0) -> tinfo_code_t - Rename a type - @param name: (C++: const char *) new type name - @param ntf_flags: (C++: int) Flags for named types - @note: The change is saved immediately + -ida_typeinf.tinfo_t.rename_udm (method) - rename_udm(self, index, name, etf_flags=0) -> tinfo_code_t - Rename a structure/union member. The new name must be unique. - @note: ETF_NO_SAVE is ignored - - @param index: (C++: size_t) - @param name: (C++: const char *) char const * - @param etf_flags: (C++: uint) +ida_typeinf.tinfo_t.rename_edm(self, idx: "size_t", name: str, etf_flags: "uint" = 0) -> "tinfo_code_t" + Rename a enum member + + @param idx: index in edmvec_t + @param name: new name + @param etf_flags: etf_flag_t ETF_FORCENAME may be used in case of TERR_ALIEN_NAME -ida_typeinf.tinfo_t.requires_qualifier (method) - requires_qualifier(self, name, offset) -> bool - Requires full qualifier? (name is not unique) - - @param name: (C++: const char *) field name - @param offset: (C++: uint64) field offset in bits - @return: if the name is not unique, returns true +ida_typeinf.tinfo_t.rename_funcarg(self, index: "size_t", name: str, etf_flags: "uint" = 0) -> "tinfo_code_t" + Rename a function argument. The new name must be unique. + + @param index: argument index in the function array + @param name: new name + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.save_type (method) - save_type(self, ntf_flags=0x0001|0x0004) -> tinfo_code_t - - @param ntf_flags: int +ida_typeinf.tinfo_t.rename_type(self, name: str, ntf_flags: int = 0) -> "tinfo_code_t" + Rename a type + + @param name: new type name + @param ntf_flags: Flags for named types -ida_typeinf.tinfo_t.serialize (method) - serialize(self, sudt_flags=SUDT_FAST|SUDT_TRUNC) -> (bytes, NoneType, NoneType), (bytes, bytes, NoneType) +ida_typeinf.tinfo_t.rename_udm(self, index: "size_t", name: str, etf_flags: "uint" = 0) -> "tinfo_code_t" + Rename a structure/union member. The new name must be unique. + + +ida_typeinf.tinfo_t.requires_qualifier(self, name: str, offset: "uint64") -> bool + Requires full qualifier? (name is not unique) + + @param name: field name + @param offset: field offset in bits + @returns if the name is not unique, returns true + +ida_typeinf.tinfo_t.save_type(self, *args) -> "tinfo_code_t" + +ida_typeinf.tinfo_t.serialize(self, *args) -> "PyObject *" Serialize tinfo_t object into a type string. - - @param sudt_flags: (C++: int) -ida_typeinf.tinfo_t.set_attr (method) - set_attr(self, ta, may_overwrite=True) -> bool +ida_typeinf.tinfo_t.set_attr(self, ta: "type_attr_t", may_overwrite: bool = True) -> bool Set a type attribute. If necessary, a new typid will be created. - - @param ta: (C++: const type_attr_t &) type_attr_t const & - @param may_overwrite: (C++: bool) -ida_typeinf.tinfo_t.set_attrs (method) - set_attrs(self, tav) -> bool - Set type attributes. If necessary, a new typid will be created. this function - modifies tav! (returns old attributes, if any) - - @param tav: (C++: type_attrs_t *) - @return: false: bad attributes +ida_typeinf.tinfo_t.set_attrs(self, tav: "type_attrs_t") -> bool + Set type attributes. If necessary, a new typid will be created. this function modifies tav! (returns old attributes, if any) + + @returns false: bad attributes -ida_typeinf.tinfo_t.set_const (method) - set_const(self) +ida_typeinf.tinfo_t.set_const(self) -> None -ida_typeinf.tinfo_t.set_declalign (method) - set_declalign(self, declalign) -> bool - - @param declalign: uchar +ida_typeinf.tinfo_t.set_declalign(self, declalign: "uchar") -> bool -ida_typeinf.tinfo_t.set_edm_cmt (method) - set_edm_cmt(self, idx, cmt, etf_flags=0) -> tinfo_code_t - Set a comment for an enum member. Such comments are always considered as - repeatable. - - @param idx: (C++: size_t) index in edmvec_t - @param cmt: (C++: const char *) comment - @param etf_flags: (C++: uint) etf_flag_t +ida_typeinf.tinfo_t.set_edm_cmt(self, idx: "size_t", cmt: str, etf_flags: "uint" = 0) -> "tinfo_code_t" + Set a comment for an enum member. Such comments are always considered as repeatable. + + @param idx: index in edmvec_t + @param cmt: comment + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.set_enum_is_bitmask (method) - set_enum_is_bitmask(self, stance=ENUMBM_ON, etf_flags=0) -> tinfo_code_t - - @param stance: enum tinfo_t::bitmask_cvt_stance_t - @param etf_flags: uint +ida_typeinf.tinfo_t.set_enum_is_bitmask(self, *args) -> "tinfo_code_t" -ida_typeinf.tinfo_t.set_enum_repr (method) - set_enum_repr(self, repr, etf_flags=0) -> tinfo_code_t - Set the representation of enum members. - - @param repr: (C++: const value_repr_t &) value_repr_t - @param etf_flags: (C++: uint) etf_flag_t +ida_typeinf.tinfo_t.set_enum_radix(self, radix: int, sign: bool, etf_flags: "uint" = 0) -> "tinfo_code_t" + Set enum radix to display constants + + @param radix: radix 2, 4, 8, 16, with the special case 1 to display as character + @param sign: display as signed or unsigned + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.set_enum_sign (method) - set_enum_sign(self, sign, etf_flags=0) -> tinfo_code_t - Set enum sign - - @param sign: (C++: type_sign_t) - @param etf_flags: (C++: uint) etf_flag_t +ida_typeinf.tinfo_t.set_enum_repr(self, repr: "value_repr_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Set the representation of enum members. + + @param repr: value_repr_t + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.set_enum_width (method) - set_enum_width(self, nbytes, etf_flags=0) -> tinfo_code_t - Set the width of enum base type - - @param nbytes: (C++: int) width of enum base type, allowed values: 0 - (unspecified),1,2,4,8,16,32,64 - @param etf_flags: (C++: uint) etf_flag_t +ida_typeinf.tinfo_t.set_enum_sign(self, sign: "type_sign_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Set enum sign + + @param sign: type_sign_t + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.set_methods (method) - set_methods(self, methods) -> bool - - @param BT_COMPLEX: set the list of member functions. This function consumes 'methods' - (makes it empty). - @return: false if this type is not a udt, or if the given list is empty +ida_typeinf.tinfo_t.set_enum_width(self, nbytes: int, etf_flags: "uint" = 0) -> "tinfo_code_t" + Set the width of enum base type + + @param nbytes: width of enum base type, allowed values: 0 (unspecified),1,2,4,8,16,32,64 + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.set_modifiers (method) - set_modifiers(self, mod) - - @param mod: type_t +ida_typeinf.tinfo_t.set_fixed_struct(self, on: bool = True) -> "tinfo_code_t" + Declare struct member offsets as fixed. For such structures, IDA will not recalculate the member offsets. If a member does not fit into its place anymore, it will be deleted. This function works only with structures (not unions). + -ida_typeinf.tinfo_t.set_named_type (method) - set_named_type(self, til, name, ntf_flags=0) -> tinfo_code_t - - @param til: til_t * - @param name: char const * - @param ntf_flags: int +ida_typeinf.tinfo_t.set_func_cc(self, cc: "cm_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Set function calling convention. -ida_typeinf.tinfo_t.set_numbered_type (method) - set_numbered_type(self, til, ord, ntf_flags=0, name=None) -> tinfo_code_t - - @param til: til_t * - @param ord: uint32 - @param ntf_flags: int - @param name: char const * +ida_typeinf.tinfo_t.set_func_retloc(self, argloc: "argloc_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Set location of function return value. + + @param argloc: new location for the return value + @param etf_flags: etf_flag_t + @returns tinfo_code_t -ida_typeinf.tinfo_t.set_symbol_type (method) - set_symbol_type(self, til, name, ntf_flags=0) -> tinfo_code_t - - @param til: til_t * - @param name: char const * - @param ntf_flags: int +ida_typeinf.tinfo_t.set_func_rettype(self, tif: "tinfo_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Set function return type . + + @param tif: new type for the return type + @param etf_flags: etf_flag_t + @returns tinfo_code_t -ida_typeinf.tinfo_t.set_type_alias (method) - set_type_alias(self, dest_ord) -> bool - Set type alias Redirects all references to source type to the destination type. - This is equivalent to instantaneous replacement all references to srctype by - dsttype. - - @param dest_ord: (C++: uint32) +ida_typeinf.tinfo_t.set_funcarg_loc(self, index: "size_t", argloc: "argloc_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Set location of a function argument. + + @param index: argument index in the function array + @param argloc: new location for the argument + @param etf_flags: etf_flag_t + @returns tinfo_code_t -ida_typeinf.tinfo_t.set_type_alignment (method) - set_type_alignment(self, declalign, etf_flags=0) -> tinfo_code_t +ida_typeinf.tinfo_t.set_funcarg_type(self, index: "size_t", tif: "tinfo_t", etf_flags: "uint" = 0) -> "tinfo_code_t" + Set type of a function argument. + + @param index: argument index in the function array + @param tif: new type for the argument + @param etf_flags: etf_flag_t + @returns tinfo_code_t + +ida_typeinf.tinfo_t.set_methods(self, methods: "udtmembervec_t") -> bool + BT_COMPLEX: set the list of member functions. This function consumes 'methods' (makes it empty). + + @returns false if this type is not a udt, or if the given list is empty + +ida_typeinf.tinfo_t.set_modifiers(self, mod: "type_t") -> None + +ida_typeinf.tinfo_t.set_named_type(self, til: "til_t", name: str, ntf_flags: int = 0) -> "tinfo_code_t" + +ida_typeinf.tinfo_t.set_numbered_type(self, til: "til_t", ord: int, ntf_flags: int = 0, name: str = None) -> "tinfo_code_t" + +ida_typeinf.tinfo_t.set_struct_size(self, new_size: "size_t") -> "tinfo_code_t" + Explicitly specify the struct size. This function works only with fixed structures. The new struct size can be equal or higher the unpadded struct size (IOW, all existing members should fit into the specified size). + + @param new_size: new structure size in bytes + +ida_typeinf.tinfo_t.set_symbol_type(self, til: "til_t", name: str, ntf_flags: int = 0) -> "tinfo_code_t" + +ida_typeinf.tinfo_t.set_type_alias(self, dest_ord: int) -> bool + Set type alias Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all references to srctype by dsttype. + + +ida_typeinf.tinfo_t.set_type_alignment(self, declalign: "uchar", etf_flags: "uint" = 0) -> "tinfo_code_t" Set type alignment. - - @param declalign: (C++: uchar) - @param etf_flags: (C++: uint) -ida_typeinf.tinfo_t.set_type_cmt (method) - set_type_cmt(self, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t - Set type comment This function works only for non-trivial types - - @param cmt: (C++: const char *) char const * - @param is_regcmt: (C++: bool) - @param etf_flags: (C++: uint) +ida_typeinf.tinfo_t.set_type_cmt(self, cmt: str, is_regcmt: bool = False, etf_flags: "uint" = 0) -> "tinfo_code_t" + Set type comment This function works only for non-trivial types + -ida_typeinf.tinfo_t.set_udm_cmt (method) - set_udm_cmt(self, index, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t - Set a comment for a structure/union member. A member may have just one comment, - and it is either repeatable or regular. - - @param index: (C++: size_t) - @param cmt: (C++: const char *) char const * - @param is_regcmt: (C++: bool) - @param etf_flags: (C++: uint) +ida_typeinf.tinfo_t.set_udm_by_til(self, idx: "size_t", on: bool = True, etf_flags: "uint" = 0) -> "tinfo_code_t" + The member is created due to the type system + + @param idx: index of the member + @param etf_flags: etf_flag_t -ida_typeinf.tinfo_t.set_udm_repr (method) - set_udm_repr(self, index, repr, etf_flags=0) -> tinfo_code_t +ida_typeinf.tinfo_t.set_udm_cmt(self, index: "size_t", cmt: str, is_regcmt: bool = False, etf_flags: "uint" = 0) -> "tinfo_code_t" + Set a comment for a structure/union member. A member may have just one comment, and it is either repeatable or regular. + + +ida_typeinf.tinfo_t.set_udm_repr(self, index: "size_t", repr: "value_repr_t", etf_flags: "uint" = 0) -> "tinfo_code_t" Set the representation of a structure/union member. - - @param index: (C++: size_t) - @param repr: (C++: const value_repr_t &) value_repr_t const & - @param etf_flags: (C++: uint) -ida_typeinf.tinfo_t.set_udm_type (method) - set_udm_type(self, index, tif, etf_flags=0, repr=None) -> tinfo_code_t - Set type of a structure/union member. - - @param index: (C++: size_t) member index in the udm array - @param tif: (C++: const tinfo_t &) new type for the member - @param etf_flags: (C++: uint) etf_flag_t - @param repr: (C++: const value_repr_t *) new representation for the member (optional) - @return: tinfo_code_t +ida_typeinf.tinfo_t.set_udm_type(self, index: "size_t", tif: "tinfo_t", etf_flags: "uint" = 0, repr: "value_repr_t" = None) -> "tinfo_code_t" + Set type of a structure/union member. + + @param index: member index in the udm array + @param tif: new type for the member + @param etf_flags: etf_flag_t + @param repr: new representation for the member (optional) + @returns tinfo_code_t -ida_typeinf.tinfo_t.set_udt_alignment (method) - set_udt_alignment(self, sda, etf_flags=0) -> tinfo_code_t - Set declared structure alignment (sda) This alignment supersedes the alignment - returned by get_declalign() and is really used when calculating the struct - layout. However, the effective structure alignment may differ from `sda` because - of packing. The type editing functions (they accept etf_flags) may overwrite - this attribute. - - @param sda: (C++: int) - @param etf_flags: (C++: uint) +ida_typeinf.tinfo_t.set_udt_alignment(self, sda: int, etf_flags: "uint" = 0) -> "tinfo_code_t" + Set declared structure alignment (sda) This alignment supersedes the alignment returned by get_declalign() and is really used when calculating the struct layout. However, the effective structure alignment may differ from `sda` because of packing. The type editing functions (they accept etf_flags) may overwrite this attribute. + -ida_typeinf.tinfo_t.set_udt_pack (method) - set_udt_pack(self, pack, etf_flags=0) -> tinfo_code_t - Set structure packing. The value controls how little a structure member - alignment can be. Example: if pack=1, then it is possible to align a double to a - byte. __attribute__((aligned(1))) double x; However, if pack=3, a double will be - aligned to 8 (2**3) even if requested to be aligned to a byte. pack==0 will have - the same effect. The type editing functions (they accept etf_flags) may - overwrite this attribute. - - @param pack: (C++: int) - @param etf_flags: (C++: uint) +ida_typeinf.tinfo_t.set_udt_pack(self, pack: int, etf_flags: "uint" = 0) -> "tinfo_code_t" + Set structure packing. The value controls how little a structure member alignment can be. Example: if pack=1, then it is possible to align a double to a byte. __attribute__((aligned(1))) double x; However, if pack=3, a double will be aligned to 8 (2**3) even if requested to be aligned to a byte. pack==0 will have the same effect. The type editing functions (they accept etf_flags) may overwrite this attribute. + -ida_typeinf.tinfo_t.set_volatile (method) - set_volatile(self) +ida_typeinf.tinfo_t.set_volatile(self) -> None -ida_typeinf.tinfo_t.swap (method) - swap(self, r) +ida_typeinf.tinfo_t.swap(self, r: "tinfo_t") -> None Assign this = r and r = this. - - @param r: (C++: tinfo_t &) -ida_typeinf.tinfo_t.write_bitfield_value (method) - write_bitfield_value(self, dst, v, bitoff) -> uint64 - - @param dst: uint64 - @param v: uint64 - @param bitoff: int +ida_typeinf.tinfo_t.write_bitfield_value(self, dst: "uint64", v: "uint64", bitoff: int) -> "uint64" -ida_typeinf.tinfo_t_get_stock (function) - tinfo_t_get_stock(id) -> tinfo_t - - @param id: enum stock_type_id_t +ida_typeinf.tinfo_visitor_t -ida_typeinf.tinfo_visitor_t (class) - Proxy of C++ tinfo_visitor_t class. +ida_typeinf.tinfo_visitor_t.__disown__(self) -ida_typeinf.tinfo_visitor_t.__disown__ (method) +ida_typeinf.tinfo_visitor_t.__init__(self, s: int = 0) -ida_typeinf.tinfo_visitor_t.__init__ (method) - __init__(self, s=0) -> tinfo_visitor_t - - @param s: int - -ida_typeinf.tinfo_visitor_t.apply_to (method) - apply_to(self, tif, out=None, name=None, cmt=None) -> int +ida_typeinf.tinfo_visitor_t.apply_to(self, tif: "tinfo_t", out: "type_mods_t" = None, name: str = None, cmt: str = None) -> int Call this function to initiate the traversal. - - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param out: (C++: type_mods_t *) - @param name: (C++: const char *) char const * - @param cmt: (C++: const char *) char const * -ida_typeinf.tinfo_visitor_t.prune_now (method) - prune_now(self) +ida_typeinf.tinfo_visitor_t.prune_now(self) -> None To refuse to visit children of the current type, use this: -ida_typeinf.tinfo_visitor_t.state (variable) - tinfo visitor states +ida_typeinf.tinfo_visitor_t.state + tinfo visitor states + -ida_typeinf.tinfo_visitor_t.visit_type (method) - visit_type(self, out, tif, name, cmt) -> int - Visit a subtype. this function must be implemented in the derived class. it may - optionally fill out with the new type info. this can be used to modify types (in - this case the 'out' argument of apply_to() may not be nullptr) return 0 to - continue the traversal. return !=0 to stop the traversal. - - @param out: (C++: type_mods_t *) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param name: (C++: const char *) char const * - @param cmt: (C++: const char *) char const * +ida_typeinf.tinfo_visitor_t.visit_type(self, out: "type_mods_t", tif: "tinfo_t", name: str, cmt: str) -> int + Visit a subtype. this function must be implemented in the derived class. it may optionally fill out with the new type info. this can be used to modify types (in this case the 'out' argument of apply_to() may not be nullptr) return 0 to continue the traversal. return !=0 to stop the traversal. + -ida_typeinf.type_attr_t (class) - Proxy of C++ type_attr_t class. +ida_typeinf.type_attr_t -ida_typeinf.type_attr_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: type_attr_t const & +ida_typeinf.type_attr_t.__ge__(self, r: "type_attr_t") -> bool -ida_typeinf.type_attr_t.__init__ (method) - __init__(self) -> type_attr_t +ida_typeinf.type_attr_t.__init__(self) -ida_typeinf.type_attr_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: type_attr_t const & +ida_typeinf.type_attr_t.__lt__(self, r: "type_attr_t") -> bool -ida_typeinf.type_attr_t.key (variable) - one symbol keys are reserved to be used by the kernel the ones starting with an - underscore are reserved too +ida_typeinf.type_attr_t.key + one symbol keys are reserved to be used by the kernel the ones starting with an underscore are reserved too + -ida_typeinf.type_attr_t.value (variable) +ida_typeinf.type_attr_t.value attribute bytes -ida_typeinf.type_attrs_t (class) - Proxy of C++ qvector< type_attr_t > class. +ida_typeinf.type_attrs_t -ida_typeinf.type_attrs_t.__getitem__ (method) - __getitem__(self, i) -> type_attr_t - - @param i: size_t +ida_typeinf.type_attrs_t.__getitem__(self, i: "size_t") -> "type_attr_t const &" -ida_typeinf.type_attrs_t.__init__ (method) - __init__(self) -> type_attrs_t - __init__(self, x) -> type_attrs_t - - @param x: qvector< type_attr_t > const & +ida_typeinf.type_attrs_t.__init__(self, *args) -ida_typeinf.type_attrs_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.type_attrs_t.__len__(self) -> "size_t" -ida_typeinf.type_attrs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: type_attr_t const & +ida_typeinf.type_attrs_t.__setitem__(self, i: "size_t", v: "type_attr_t") -> None -ida_typeinf.type_attrs_t.at (method) - at(self, _idx) -> type_attr_t - - @param _idx: size_t +ida_typeinf.type_attrs_t.append(self, x: "type_attr_t") -> None -ida_typeinf.type_attrs_t.begin (method) - begin(self) -> type_attr_t +ida_typeinf.type_attrs_t.at(self, _idx: "size_t") -> "type_attr_t const &" -ida_typeinf.type_attrs_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.type_attrs_t.begin(self, *args) -> "qvector< type_attr_t >::const_iterator" -ida_typeinf.type_attrs_t.clear (method) - clear(self) +ida_typeinf.type_attrs_t.capacity(self) -> "size_t" -ida_typeinf.type_attrs_t.empty (method) - empty(self) -> bool +ida_typeinf.type_attrs_t.clear(self) -> None -ida_typeinf.type_attrs_t.end (method) - end(self) -> type_attr_t +ida_typeinf.type_attrs_t.empty(self) -> bool -ida_typeinf.type_attrs_t.erase (method) - erase(self, it) -> type_attr_t - - @param it: qvector< type_attr_t >::iterator - - erase(self, first, last) -> type_attr_t - - @param first: qvector< type_attr_t >::iterator - @param last: qvector< type_attr_t >::iterator +ida_typeinf.type_attrs_t.end(self, *args) -> "qvector< type_attr_t >::const_iterator" -ida_typeinf.type_attrs_t.extract (method) - extract(self) -> type_attr_t +ida_typeinf.type_attrs_t.erase(self, *args) -> "qvector< type_attr_t >::iterator" -ida_typeinf.type_attrs_t.grow (method) - grow(self, x=type_attr_t()) - - @param x: type_attr_t const & +ida_typeinf.type_attrs_t.extend(self, x: "type_attrs_t") -> None -ida_typeinf.type_attrs_t.inject (method) - inject(self, s, len) - - @param s: type_attr_t * - @param len: size_t +ida_typeinf.type_attrs_t.extract(self) -> "type_attr_t *" -ida_typeinf.type_attrs_t.insert (method) - insert(self, it, x) -> type_attr_t - - @param it: qvector< type_attr_t >::iterator - @param x: type_attr_t const & +ida_typeinf.type_attrs_t.grow(self, *args) -> None -ida_typeinf.type_attrs_t.pop_back (method) - pop_back(self) +ida_typeinf.type_attrs_t.inject(self, s: "type_attr_t", len: "size_t") -> None -ida_typeinf.type_attrs_t.push_back (method) - push_back(self, x) - - @param x: type_attr_t const & - - push_back(self) -> type_attr_t +ida_typeinf.type_attrs_t.insert(self, it: "type_attr_t", x: "type_attr_t") -> "qvector< type_attr_t >::iterator" -ida_typeinf.type_attrs_t.qclear (method) - qclear(self) +ida_typeinf.type_attrs_t.pop_back(self) -> None -ida_typeinf.type_attrs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.type_attrs_t.push_back(self, *args) -> "type_attr_t &" -ida_typeinf.type_attrs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: type_attr_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.type_attrs_t.qclear(self) -> None -ida_typeinf.type_attrs_t.size (method) - size(self) -> size_t +ida_typeinf.type_attrs_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.type_attrs_t.swap (method) - swap(self, r) - - @param r: qvector< type_attr_t > & +ida_typeinf.type_attrs_t.resize(self, *args) -> None -ida_typeinf.type_attrs_t.truncate (method) - truncate(self) +ida_typeinf.type_attrs_t.size(self) -> "size_t" -ida_typeinf.type_mods_t (class) - Proxy of C++ type_mods_t class. +ida_typeinf.type_attrs_t.swap(self, r: "type_attrs_t") -> None -ida_typeinf.type_mods_t.__init__ (method) - __init__(self) -> type_mods_t +ida_typeinf.type_attrs_t.truncate(self) -> None -ida_typeinf.type_mods_t.clear (method) - clear(self) +ida_typeinf.type_mods_t -ida_typeinf.type_mods_t.cmt (variable) +ida_typeinf.type_mods_t.__init__(self) + +ida_typeinf.type_mods_t.clear(self) -> None + +ida_typeinf.type_mods_t.cmt comment for current type -ida_typeinf.type_mods_t.flags (variable) - Type modification bits +ida_typeinf.type_mods_t.flags + Type modification bits + -ida_typeinf.type_mods_t.has_cmt (method) - has_cmt(self) -> bool +ida_typeinf.type_mods_t.has_cmt(self) -> bool -ida_typeinf.type_mods_t.has_info (method) - has_info(self) -> bool +ida_typeinf.type_mods_t.has_info(self) -> bool -ida_typeinf.type_mods_t.has_name (method) - has_name(self) -> bool +ida_typeinf.type_mods_t.has_name(self) -> bool -ida_typeinf.type_mods_t.has_type (method) - has_type(self) -> bool +ida_typeinf.type_mods_t.has_type(self) -> bool -ida_typeinf.type_mods_t.is_rptcmt (method) - is_rptcmt(self) -> bool +ida_typeinf.type_mods_t.is_rptcmt(self) -> bool -ida_typeinf.type_mods_t.name (variable) +ida_typeinf.type_mods_t.name current type name -ida_typeinf.type_mods_t.set_new_cmt (method) - set_new_cmt(self, c, rptcmt) - - @param c: qstring const & - @param rptcmt: bool +ida_typeinf.type_mods_t.set_new_cmt(self, c: str, rptcmt: bool) -> None -ida_typeinf.type_mods_t.set_new_name (method) - set_new_name(self, n) - - @param n: qstring const & +ida_typeinf.type_mods_t.set_new_name(self, n: str) -> None -ida_typeinf.type_mods_t.set_new_type (method) - set_new_type(self, t) - The visit_type() function may optionally save the modified type info. Use the - following functions for that. The new name and comment will be applied only if - the current tinfo element has storage for them. - - @param t: (C++: const tinfo_t &) tinfo_t const & +ida_typeinf.type_mods_t.set_new_type(self, t: "tinfo_t") -> None + The visit_type() function may optionally save the modified type info. Use the following functions for that. The new name and comment will be applied only if the current tinfo element has storage for them. + -ida_typeinf.type_mods_t.type (variable) +ida_typeinf.type_mods_t.type current type -ida_typeinf.type_signed (variable) +ida_typeinf.type_signed signed type -ida_typeinf.type_unsigned (variable) +ida_typeinf.type_unsigned unsigned type -ida_typeinf.typedef_type_data_t (class) - Proxy of C++ typedef_type_data_t class. +ida_typeinf.typedef_type_data_t -ida_typeinf.typedef_type_data_t.__init__ (method) - __init__(self, _til, _name, _resolve=False) -> typedef_type_data_t - - @param _til: til_t const * - @param _name: char const * - @param _resolve: bool - - __init__(self, _til, ord, _resolve=False) -> typedef_type_data_t - - @param _til: til_t const * - @param ord: uint32 - @param _resolve: bool +ida_typeinf.typedef_type_data_t.__init__(self, *args) -ida_typeinf.typedef_type_data_t.is_ordref (variable) +ida_typeinf.typedef_type_data_t.is_ordref is reference by ordinal? -ida_typeinf.typedef_type_data_t.name (variable) +ida_typeinf.typedef_type_data_t.name is_ordref=false: target type name. we do not own this pointer! -ida_typeinf.typedef_type_data_t.ordinal (variable) +ida_typeinf.typedef_type_data_t.ordinal is_ordref=true: type ordinal number -ida_typeinf.typedef_type_data_t.resolve (variable) +ida_typeinf.typedef_type_data_t.resolve should resolve immediately? -ida_typeinf.typedef_type_data_t.swap (method) - swap(self, r) - - @param r: typedef_type_data_t & +ida_typeinf.typedef_type_data_t.swap(self, r: "typedef_type_data_t") -> None -ida_typeinf.typedef_type_data_t.til (variable) +ida_typeinf.typedef_type_data_t.til type library to use when resolving -ida_typeinf.udm_t (class) - Proxy of C++ udm_t class. +ida_typeinf.udm_t -ida_typeinf.udm_t.__eq__ (method) - __eq__(self, r) -> bool +ida_typeinf.udm_t.__eq__(self, r: "udm_t") -> bool + +ida_typeinf.udm_t.__init__(self, *args) + Create a structure/union member, with the specified name and type. - @param r: udm_t const & - -ida_typeinf.udm_t.__init__ (method) - __init__(self) -> udm_t - -ida_typeinf.udm_t.__lt__ (method) - __lt__(self, r) -> bool + This constructor has the following signatures: - @param r: udm_t const & - -ida_typeinf.udm_t.__ne__ (method) - __ne__(self, r) -> bool + 1. udm_t(udm: udm_t) + 2. udm_t(name: str, type, offset: int) - @param r: udm_t const & + The 'type' descriptor, can be one of: + + * type_t: if the type is simple (integral/floating/bool). E.g., `BTF_INT` + * tinfo_t: can handle more complex types (structures, pointers, arrays, ...) + * str: a C type declaration + + If an input argument is incorrect, the constructor may raise an exception + The size will be computed automatically. + + @param udm a source udm_t + @param name a valid member name. Must not be empty. + @param type the member type + @param offset the member offset in bits. It is the caller's responsibility + to specify correct offsets. -ida_typeinf.udm_t.begin (method) - begin(self) -> uint64 +ida_typeinf.udm_t.__lt__(self, r: "udm_t") -> bool -ida_typeinf.udm_t.can_be_dtor (method) - can_be_dtor(self) -> bool +ida_typeinf.udm_t.__ne__(self, r: "udm_t") -> bool -ida_typeinf.udm_t.can_rename (method) - can_rename(self) -> bool +ida_typeinf.udm_t.begin(self) -> "uint64" -ida_typeinf.udm_t.clr_baseclass (method) - clr_baseclass(self) +ida_typeinf.udm_t.can_be_dtor(self) -> bool -ida_typeinf.udm_t.clr_method (method) - clr_method(self) +ida_typeinf.udm_t.can_rename(self) -> bool -ida_typeinf.udm_t.clr_unaligned (method) - clr_unaligned(self) +ida_typeinf.udm_t.clr_baseclass(self) -> None -ida_typeinf.udm_t.clr_vftable (method) - clr_vftable(self) +ida_typeinf.udm_t.clr_method(self) -> None -ida_typeinf.udm_t.clr_virtbase (method) - clr_virtbase(self) +ida_typeinf.udm_t.clr_unaligned(self) -> None -ida_typeinf.udm_t.cmt (variable) +ida_typeinf.udm_t.clr_vftable(self) -> None + +ida_typeinf.udm_t.clr_virtbase(self) -> None + +ida_typeinf.udm_t.cmt member comment -ida_typeinf.udm_t.effalign (variable) +ida_typeinf.udm_t.effalign effective field alignment (in bytes) -ida_typeinf.udm_t.end (method) - end(self) -> uint64 +ida_typeinf.udm_t.empty(self) -> bool -ida_typeinf.udm_t.fda (variable) +ida_typeinf.udm_t.end(self) -> "uint64" + +ida_typeinf.udm_t.fda field alignment (shift amount) -ida_typeinf.udm_t.is_anonymous_udm (method) - is_anonymous_udm(self) -> bool +ida_typeinf.udm_t.is_anonymous_udm(self) -> bool -ida_typeinf.udm_t.is_baseclass (method) - is_baseclass(self) -> bool +ida_typeinf.udm_t.is_baseclass(self) -> bool -ida_typeinf.udm_t.is_bitfield (method) - is_bitfield(self) -> bool +ida_typeinf.udm_t.is_bitfield(self) -> bool -ida_typeinf.udm_t.is_gap (method) - is_gap(self) -> bool +ida_typeinf.udm_t.is_by_til(self) -> bool -ida_typeinf.udm_t.is_method (method) - is_method(self) -> bool +ida_typeinf.udm_t.is_gap(self) -> bool -ida_typeinf.udm_t.is_regcmt (method) - is_regcmt(self) -> bool +ida_typeinf.udm_t.is_method(self) -> bool -ida_typeinf.udm_t.is_unaligned (method) - is_unaligned(self) -> bool +ida_typeinf.udm_t.is_regcmt(self) -> bool -ida_typeinf.udm_t.is_vftable (method) - is_vftable(self) -> bool +ida_typeinf.udm_t.is_retaddr(self) -> bool -ida_typeinf.udm_t.is_virtbase (method) - is_virtbase(self) -> bool +ida_typeinf.udm_t.is_savregs(self) -> bool -ida_typeinf.udm_t.is_zero_bitfield (method) - is_zero_bitfield(self) -> bool +ida_typeinf.udm_t.is_special_member(self) -> bool -ida_typeinf.udm_t.make_gap (method) - make_gap(self, byteoff, nbytes) -> bool - - @param byteoff: uval_t - @param nbytes: uval_t +ida_typeinf.udm_t.is_unaligned(self) -> bool -ida_typeinf.udm_t.name (variable) +ida_typeinf.udm_t.is_vftable(self) -> bool + +ida_typeinf.udm_t.is_virtbase(self) -> bool + +ida_typeinf.udm_t.is_zero_bitfield(self) -> bool + +ida_typeinf.udm_t.name member name -ida_typeinf.udm_t.offset (variable) +ida_typeinf.udm_t.offset member offset in bits -ida_typeinf.udm_t.repr (variable) +ida_typeinf.udm_t.repr radix, refinfo, strpath, custom_id, strtype -ida_typeinf.udm_t.set_baseclass (method) - set_baseclass(self, on=True) - - @param on: bool +ida_typeinf.udm_t.set_baseclass(self, on: bool = True) -> None -ida_typeinf.udm_t.set_method (method) - set_method(self, on=True) - - @param on: bool +ida_typeinf.udm_t.set_by_til(self, on: bool = True) -> None -ida_typeinf.udm_t.set_regcmt (method) - set_regcmt(self, on=True) - - @param on: bool +ida_typeinf.udm_t.set_method(self, on: bool = True) -> None -ida_typeinf.udm_t.set_unaligned (method) - set_unaligned(self, on=True) - - @param on: bool +ida_typeinf.udm_t.set_regcmt(self, on: bool = True) -> None -ida_typeinf.udm_t.set_value_repr (method) - set_value_repr(self, r) - - @param r: value_repr_t const & +ida_typeinf.udm_t.set_retaddr(self, on: bool = True) -> None -ida_typeinf.udm_t.set_vftable (method) - set_vftable(self, on=True) - - @param on: bool +ida_typeinf.udm_t.set_savregs(self, on: bool = True) -> None -ida_typeinf.udm_t.set_virtbase (method) - set_virtbase(self, on=True) - - @param on: bool +ida_typeinf.udm_t.set_unaligned(self, on: bool = True) -> None -ida_typeinf.udm_t.size (variable) +ida_typeinf.udm_t.set_value_repr(self, r: "value_repr_t") -> None + +ida_typeinf.udm_t.set_vftable(self, on: bool = True) -> None + +ida_typeinf.udm_t.set_virtbase(self, on: bool = True) -> None + +ida_typeinf.udm_t.size size in bits -ida_typeinf.udm_t.swap (method) - swap(self, r) - - @param r: udm_t & +ida_typeinf.udm_t.swap(self, r: "udm_t") -> None -ida_typeinf.udm_t.tafld_bits (variable) +ida_typeinf.udm_t.tafld_bits TAH bits. -ida_typeinf.udm_t.type (variable) +ida_typeinf.udm_t.type member type -ida_typeinf.udm_t__make_gap (function) - udm_t__make_gap(_this, byteoff, nbytes) -> bool +ida_typeinf.udm_visitor_t + +ida_typeinf.udm_visitor_t.__disown__(self) + +ida_typeinf.udm_visitor_t.__init__(self) + +ida_typeinf.udm_visitor_t.visit_udm(self, tid: "tid_t", tif: "tinfo_t", udt: "udt_type_data_t", idx: "ssize_t") -> int + @param tid: udt tid + @param tif: udt type info (may be nullptr for corrupted idbs) + @param udt: udt type data (may be nullptr for corrupted idbs) + @param idx: the index of udt the member (may be -1 if udm was not found) + +ida_typeinf.udt_type_data_t + +ida_typeinf.udt_type_data_t.__init__(self) + +ida_typeinf.udt_type_data_t.add_member(self, _name: str, _type: "tinfo_t", _offset: "uint64" = 0) -> "udm_t &" + Add a new member to a structure or union. This function just pushes a new member to the back of the structure/union member vector. - @param _this: udm_t * - @param byteoff: uval_t - @param nbytes: uval_t + @param _name: Member name. Must not be nullptr. + @param _type: Member type. Must not be empty. + @param _offset: Member offset in bits. It is the caller's responsibility to specify correct offsets. + @returns { Reference to the newly added member } -ida_typeinf.udt_type_data_t (class) - Proxy of C++ udt_type_data_t class. - -ida_typeinf.udt_type_data_t.__init__ (method) - __init__(self) -> udt_type_data_t - -ida_typeinf.udt_type_data_t.effalign (variable) +ida_typeinf.udt_type_data_t.effalign effective structure alignment (in bytes) -ida_typeinf.udt_type_data_t.find_member (method) - find_member(self, pattern_udm, strmem_flags) -> ssize_t +ida_typeinf.udt_type_data_t.find_member(self, *args) -> "ssize_t" + This function has the following signatures: - @param pattern_udm: udm_t * - @param strmem_flags: int + 0. find_member(pattern_udm: udm_t *, strmem_flags: int) -> ssize_t + 1. find_member(name: str) -> ssize_t + 2. find_member(bit_offset: uint64) -> ssize_t - find_member(self, name) -> ssize_t + # 0: find_member(pattern_udm: udm_t *, strmem_flags: int) -> ssize_t - @param name: char const * + tinfo_t::find_udm + + @returns the index of the found member or -1 - find_member(self, bit_offset) -> ssize_t + # 1: find_member(name: str) -> ssize_t - @param bit_offset: uint64 + + # 2: find_member(bit_offset: uint64) -> ssize_t -ida_typeinf.udt_type_data_t.get_best_fit_member (method) - get_best_fit_member(self, disp) -> ssize_t - Get member that is most likely referenced by the specified offset. Useful for - offsets > sizeof(struct). +ida_typeinf.udt_type_data_t.get_best_fit_member(self, disp) + Get the member that is most likely referenced by the specified offset. - @param disp: (C++: asize_t) + @param disp the byte offset + @return a tuple (int, udm_t), or (-1, None) if member not found -ida_typeinf.udt_type_data_t.is_cppobj (method) - is_cppobj(self) -> bool +ida_typeinf.udt_type_data_t.is_cppobj(self) -> bool -ida_typeinf.udt_type_data_t.is_last_baseclass (method) - is_last_baseclass(self, idx) -> bool - - @param idx: size_t +ida_typeinf.udt_type_data_t.is_fixed(self) -> bool -ida_typeinf.udt_type_data_t.is_msstruct (method) - is_msstruct(self) -> bool +ida_typeinf.udt_type_data_t.is_last_baseclass(self, idx: "size_t") -> bool -ida_typeinf.udt_type_data_t.is_unaligned (method) - is_unaligned(self) -> bool +ida_typeinf.udt_type_data_t.is_msstruct(self) -> bool -ida_typeinf.udt_type_data_t.is_union (variable) +ida_typeinf.udt_type_data_t.is_unaligned(self) -> bool + +ida_typeinf.udt_type_data_t.is_union is union or struct? -ida_typeinf.udt_type_data_t.is_vftable (method) - is_vftable(self) -> bool +ida_typeinf.udt_type_data_t.is_vftable(self) -> bool -ida_typeinf.udt_type_data_t.pack (variable) +ida_typeinf.udt_type_data_t.pack #pragma pack() alignment (shift amount) -ida_typeinf.udt_type_data_t.sda (variable) +ida_typeinf.udt_type_data_t.sda declared structure alignment (shift amount+1). 0 - unspecified -ida_typeinf.udt_type_data_t.set_vftable (method) - set_vftable(self, on=True) - - @param on: bool +ida_typeinf.udt_type_data_t.set_fixed(self, on: bool = True) -> None -ida_typeinf.udt_type_data_t.swap (method) - swap(self, r) - - @param r: udt_type_data_t & +ida_typeinf.udt_type_data_t.set_vftable(self, on: bool = True) -> None -ida_typeinf.udt_type_data_t.taudt_bits (variable) +ida_typeinf.udt_type_data_t.swap(self, r: "udt_type_data_t") -> None + +ida_typeinf.udt_type_data_t.taudt_bits TA... and TAUDT... bits. -ida_typeinf.udt_type_data_t.total_size (variable) +ida_typeinf.udt_type_data_t.total_size total structure size in bytes -ida_typeinf.udt_type_data_t.unpadded_size (variable) +ida_typeinf.udt_type_data_t.unpadded_size unpadded structure size in bytes -ida_typeinf.udt_type_data_t.version (variable) +ida_typeinf.udt_type_data_t.version version of udt_type_data_t -ida_typeinf.udt_type_data_t__find_member (function) - udt_type_data_t__find_member(_this, udm, strmem_flags) -> ssize_t - - @param _this: udt_type_data_t const * - @param udm: udm_t * - @param strmem_flags: int +ida_typeinf.udt_type_data_t__find_member(_this: "udt_type_data_t", udm: "udm_t", strmem_flags: int) -> "ssize_t" -ida_typeinf.udt_type_data_t__get_best_fit_member (function) - udt_type_data_t__get_best_fit_member(_this, disp) -> ssize_t - - @param _this: udt_type_data_t const * - @param disp: asize_t +ida_typeinf.udt_type_data_t__get_best_fit_member(_this: "udt_type_data_t", disp: "asize_t") -> "ssize_t" -ida_typeinf.udtmembervec_t (class) - Proxy of C++ udtmembervec_t class. +ida_typeinf.udtmembervec_t -ida_typeinf.udtmembervec_t.__init__ (method) - __init__(self) -> udtmembervec_t +ida_typeinf.udtmembervec_t.__init__(self) -ida_typeinf.udtmembervec_template_t (class) - Proxy of C++ qvector< udm_t > class. +ida_typeinf.udtmembervec_template_t -ida_typeinf.udtmembervec_template_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< udm_t > const & +ida_typeinf.udtmembervec_template_t.__eq__(self, r: "udtmembervec_template_t") -> bool -ida_typeinf.udtmembervec_template_t.__getitem__ (method) - __getitem__(self, i) -> udm_t - - @param i: size_t +ida_typeinf.udtmembervec_template_t.__getitem__(self, i: "size_t") -> "udm_t const &" -ida_typeinf.udtmembervec_template_t.__init__ (method) - __init__(self) -> udtmembervec_template_t - __init__(self, x) -> udtmembervec_template_t - - @param x: qvector< udm_t > const & +ida_typeinf.udtmembervec_template_t.__init__(self, *args) -ida_typeinf.udtmembervec_template_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.udtmembervec_template_t.__len__(self) -> "size_t" -ida_typeinf.udtmembervec_template_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< udm_t > const & +ida_typeinf.udtmembervec_template_t.__ne__(self, r: "udtmembervec_template_t") -> bool -ida_typeinf.udtmembervec_template_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: udm_t const & +ida_typeinf.udtmembervec_template_t.__setitem__(self, i: "size_t", v: "udm_t") -> None -ida_typeinf.udtmembervec_template_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: udm_t const & +ida_typeinf.udtmembervec_template_t._del(self, x: "udm_t") -> bool -ida_typeinf.udtmembervec_template_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: udm_t const & +ida_typeinf.udtmembervec_template_t.add_unique(self, x: "udm_t") -> bool -ida_typeinf.udtmembervec_template_t.at (method) - at(self, _idx) -> udm_t - - @param _idx: size_t +ida_typeinf.udtmembervec_template_t.append(self, x: "udm_t") -> None -ida_typeinf.udtmembervec_template_t.begin (method) - begin(self) -> udm_t +ida_typeinf.udtmembervec_template_t.at(self, _idx: "size_t") -> "udm_t const &" -ida_typeinf.udtmembervec_template_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.udtmembervec_template_t.begin(self, *args) -> "qvector< udm_t >::const_iterator" -ida_typeinf.udtmembervec_template_t.clear (method) - clear(self) +ida_typeinf.udtmembervec_template_t.capacity(self) -> "size_t" -ida_typeinf.udtmembervec_template_t.empty (method) - empty(self) -> bool +ida_typeinf.udtmembervec_template_t.clear(self) -> None -ida_typeinf.udtmembervec_template_t.end (method) - end(self) -> udm_t +ida_typeinf.udtmembervec_template_t.empty(self) -> bool -ida_typeinf.udtmembervec_template_t.erase (method) - erase(self, it) -> udm_t - - @param it: qvector< udm_t >::iterator - - erase(self, first, last) -> udm_t - - @param first: qvector< udm_t >::iterator - @param last: qvector< udm_t >::iterator +ida_typeinf.udtmembervec_template_t.end(self, *args) -> "qvector< udm_t >::const_iterator" -ida_typeinf.udtmembervec_template_t.extract (method) - extract(self) -> udm_t +ida_typeinf.udtmembervec_template_t.erase(self, *args) -> "qvector< udm_t >::iterator" -ida_typeinf.udtmembervec_template_t.find (method) - find(self, x) -> udm_t - - @param x: udm_t const & +ida_typeinf.udtmembervec_template_t.extend(self, x: "udtmembervec_template_t") -> None -ida_typeinf.udtmembervec_template_t.grow (method) - grow(self, x=udm_t()) - - @param x: udm_t const & +ida_typeinf.udtmembervec_template_t.extract(self) -> "udm_t *" -ida_typeinf.udtmembervec_template_t.has (method) - has(self, x) -> bool - - @param x: udm_t const & +ida_typeinf.udtmembervec_template_t.find(self, *args) -> "qvector< udm_t >::const_iterator" -ida_typeinf.udtmembervec_template_t.inject (method) - inject(self, s, len) - - @param s: udm_t * - @param len: size_t +ida_typeinf.udtmembervec_template_t.grow(self, *args) -> None -ida_typeinf.udtmembervec_template_t.insert (method) - insert(self, it, x) -> udm_t - - @param it: qvector< udm_t >::iterator - @param x: udm_t const & +ida_typeinf.udtmembervec_template_t.has(self, x: "udm_t") -> bool -ida_typeinf.udtmembervec_template_t.pop_back (method) - pop_back(self) +ida_typeinf.udtmembervec_template_t.inject(self, s: "udm_t", len: "size_t") -> None -ida_typeinf.udtmembervec_template_t.push_back (method) - push_back(self, x) - - @param x: udm_t const & - - push_back(self) -> udm_t +ida_typeinf.udtmembervec_template_t.insert(self, it: "udm_t", x: "udm_t") -> "qvector< udm_t >::iterator" -ida_typeinf.udtmembervec_template_t.qclear (method) - qclear(self) +ida_typeinf.udtmembervec_template_t.pop_back(self) -> None -ida_typeinf.udtmembervec_template_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.udtmembervec_template_t.push_back(self, *args) -> "udm_t &" -ida_typeinf.udtmembervec_template_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: udm_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.udtmembervec_template_t.qclear(self) -> None -ida_typeinf.udtmembervec_template_t.size (method) - size(self) -> size_t +ida_typeinf.udtmembervec_template_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.udtmembervec_template_t.swap (method) - swap(self, r) - - @param r: qvector< udm_t > & +ida_typeinf.udtmembervec_template_t.resize(self, *args) -> None -ida_typeinf.udtmembervec_template_t.truncate (method) - truncate(self) +ida_typeinf.udtmembervec_template_t.size(self) -> "size_t" -ida_typeinf.unpack_idcobj_from_bv (function) - unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t +ida_typeinf.udtmembervec_template_t.swap(self, r: "udtmembervec_template_t") -> None + +ida_typeinf.udtmembervec_template_t.truncate(self) -> None + +ida_typeinf.unpack_idcobj_from_bv(obj: "idc_value_t *", tif: "tinfo_t", bytes: "bytevec_t const &", pio_flags: int = 0) -> "error_t" Read a typed idc object from the byte vector. - - @param obj: (C++: idc_value_t *) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param bytes: (C++: const bytevec_t &) bytevec_t const & - @param pio_flags: (C++: int) -ida_typeinf.unpack_idcobj_from_idb (function) - unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t +ida_typeinf.unpack_idcobj_from_idb(obj: "idc_value_t *", tif: "tinfo_t", ea: ida_idaapi.ea_t, off0: "bytevec_t const *", pio_flags: int = 0) -> "error_t" Collection of register objects. - Read a typed idc object from the database - - @param obj: (C++: idc_value_t *) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param ea: (C++: ea_t) - @param off0: (C++: const bytevec_t *) bytevec_t const * - @param pio_flags: (C++: int) + Read a typed idc object from the database + -ida_typeinf.unpack_object_from_bv (function) - unpack_object_from_bv(ti, type, fields, bytes, pio_flags=0) -> PyObject * +ida_typeinf.unpack_object_from_bv(til: til_t, type: bytes, fields: bytes, bytes, pio_flags: int = 0) Unpacks a buffer into an object. Returns the error_t returned by idaapi.pack_object_to_idb - @param ti: Type info. 'None' can be passed. - @param type: type_t const * + @param til: Type library. 'None' can be passed. + @param type: type string @param fields: fields string (may be empty or None) @param bytes: the bytes to unpack @param pio_flags: flags used while unpacking - @return: - tuple(0, err) on failure + @return: + - tuple(0, err) on failure - tuple(1, obj) on success -ida_typeinf.unpack_object_from_idb (function) - unpack_object_from_idb(ti, type, fields, ea, pio_flags=0) -> PyObject * - - @param ti: til_t * - @param type: type_t const * - @param fields: p_list const * - @param ea: ea_t - @param pio_flags: int +ida_typeinf.unpack_object_from_idb(til: til_t, type: bytes, fields: bytes, ea: ida_idaapi.ea_t, pio_flags: int = 0) + Unpacks from the database at 'ea' to an object. + Please refer to unpack_object_from_bv() -ida_typeinf.use_golang_cc (function) - use_golang_cc() -> bool +ida_typeinf.use_golang_cc() -> bool is GOLANG calling convention used by default? -ida_typeinf.valstr_t (class) - Proxy of C++ valstr_t class. +ida_typeinf.valstr_t -ida_typeinf.valstr_t.__init__ (method) - __init__(self) -> valstr_t +ida_typeinf.valstr_t.__init__(self) -ida_typeinf.valstr_t.info (variable) +ida_typeinf.valstr_t.info additional info -ida_typeinf.valstr_t.length (variable) +ida_typeinf.valstr_t.length length if printed on one line -ida_typeinf.valstr_t.members (variable) +ida_typeinf.valstr_t.members strings for members, each member separately -ida_typeinf.valstr_t.oneline (variable) +ida_typeinf.valstr_t.oneline result if printed on one line in UTF-8 encoding -ida_typeinf.valstr_t.props (variable) +ida_typeinf.valstr_t.props temporary properties, used internally -ida_typeinf.valstrs_t (class) - Proxy of C++ valstrs_t class. +ida_typeinf.valstrs_t -ida_typeinf.valstrs_t.__init__ (method) - __init__(self) -> valstrs_t +ida_typeinf.valstrs_t.__init__(self) -ida_typeinf.valstrvec_t (class) - Proxy of C++ qvector< valstr_t > class. +ida_typeinf.valstrvec_t -ida_typeinf.valstrvec_t.__getitem__ (method) - __getitem__(self, i) -> valstr_t - - @param i: size_t +ida_typeinf.valstrvec_t.__getitem__(self, i: "size_t") -> "valstr_t const &" -ida_typeinf.valstrvec_t.__init__ (method) - __init__(self) -> valstrvec_t - __init__(self, x) -> valstrvec_t - - @param x: qvector< valstr_t > const & +ida_typeinf.valstrvec_t.__init__(self, *args) -ida_typeinf.valstrvec_t.__len__ (method) - __len__(self) -> size_t +ida_typeinf.valstrvec_t.__len__(self) -> "size_t" -ida_typeinf.valstrvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: valstr_t const & +ida_typeinf.valstrvec_t.__setitem__(self, i: "size_t", v: "valstr_t") -> None -ida_typeinf.valstrvec_t.at (method) - at(self, _idx) -> valstr_t - - @param _idx: size_t +ida_typeinf.valstrvec_t.append(self, x: "valstr_t") -> None -ida_typeinf.valstrvec_t.begin (method) - begin(self) -> valstr_t +ida_typeinf.valstrvec_t.at(self, _idx: "size_t") -> "valstr_t const &" -ida_typeinf.valstrvec_t.capacity (method) - capacity(self) -> size_t +ida_typeinf.valstrvec_t.begin(self, *args) -> "qvector< valstr_t >::const_iterator" -ida_typeinf.valstrvec_t.clear (method) - clear(self) +ida_typeinf.valstrvec_t.capacity(self) -> "size_t" -ida_typeinf.valstrvec_t.empty (method) - empty(self) -> bool +ida_typeinf.valstrvec_t.clear(self) -> None -ida_typeinf.valstrvec_t.end (method) - end(self) -> valstr_t +ida_typeinf.valstrvec_t.empty(self) -> bool -ida_typeinf.valstrvec_t.erase (method) - erase(self, it) -> valstr_t - - @param it: qvector< valstr_t >::iterator - - erase(self, first, last) -> valstr_t - - @param first: qvector< valstr_t >::iterator - @param last: qvector< valstr_t >::iterator +ida_typeinf.valstrvec_t.end(self, *args) -> "qvector< valstr_t >::const_iterator" -ida_typeinf.valstrvec_t.extract (method) - extract(self) -> valstr_t +ida_typeinf.valstrvec_t.erase(self, *args) -> "qvector< valstr_t >::iterator" -ida_typeinf.valstrvec_t.grow (method) - grow(self, x=valstr_t()) - - @param x: valstr_t const & +ida_typeinf.valstrvec_t.extend(self, x: "valstrvec_t") -> None -ida_typeinf.valstrvec_t.inject (method) - inject(self, s, len) - - @param s: valstr_t * - @param len: size_t +ida_typeinf.valstrvec_t.extract(self) -> "valstr_t *" -ida_typeinf.valstrvec_t.insert (method) - insert(self, it, x) -> valstr_t - - @param it: qvector< valstr_t >::iterator - @param x: valstr_t const & +ida_typeinf.valstrvec_t.grow(self, *args) -> None -ida_typeinf.valstrvec_t.pop_back (method) - pop_back(self) +ida_typeinf.valstrvec_t.inject(self, s: "valstr_t", len: "size_t") -> None -ida_typeinf.valstrvec_t.push_back (method) - push_back(self, x) - - @param x: valstr_t const & - - push_back(self) -> valstr_t +ida_typeinf.valstrvec_t.insert(self, it: "valstr_t", x: "valstr_t") -> "qvector< valstr_t >::iterator" -ida_typeinf.valstrvec_t.qclear (method) - qclear(self) +ida_typeinf.valstrvec_t.pop_back(self) -> None -ida_typeinf.valstrvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_typeinf.valstrvec_t.push_back(self, *args) -> "valstr_t &" -ida_typeinf.valstrvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: valstr_t const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_typeinf.valstrvec_t.qclear(self) -> None -ida_typeinf.valstrvec_t.size (method) - size(self) -> size_t +ida_typeinf.valstrvec_t.reserve(self, cnt: "size_t") -> None -ida_typeinf.valstrvec_t.swap (method) - swap(self, r) - - @param r: qvector< valstr_t > & +ida_typeinf.valstrvec_t.resize(self, *args) -> None -ida_typeinf.valstrvec_t.truncate (method) - truncate(self) +ida_typeinf.valstrvec_t.size(self) -> "size_t" -ida_typeinf.value_repr_t (class) - Proxy of C++ value_repr_t class. +ida_typeinf.valstrvec_t.swap(self, r: "valstrvec_t") -> None -ida_typeinf.value_repr_t.__init__ (method) - __init__(self) -> value_repr_t +ida_typeinf.valstrvec_t.truncate(self) -> None -ida_typeinf.value_repr_t.__str__ (method) - __str__(self) -> qstring +ida_typeinf.value_repr_t -ida_typeinf.value_repr_t._print (method) - _print(self, colored=False) -> size_t - - Parameters - ---------- - colored: bool +ida_typeinf.value_repr_t.__init__(self) -ida_typeinf.value_repr_t.ap (variable) - FRB_TABFORM, AP_SIGNED is ignored, use FRB_SIGNED instead +ida_typeinf.value_repr_t.__str__(self) -> str -ida_typeinf.value_repr_t.cd (variable) +ida_typeinf.value_repr_t._print(self, colored: bool = False) -> "size_t" + +ida_typeinf.value_repr_t.ap + FRB_TABFORM, AP_SIGNED is ignored, use FRB_SIGNED instead + + +ida_typeinf.value_repr_t.cd FRB_CUSTOM. -ida_typeinf.value_repr_t.clear (method) - clear(self) +ida_typeinf.value_repr_t.clear(self) -> None -ida_typeinf.value_repr_t.delta (variable) +ida_typeinf.value_repr_t.delta FRB_STROFF. -ida_typeinf.value_repr_t.empty (method) - empty(self) -> bool +ida_typeinf.value_repr_t.empty(self) -> bool -ida_typeinf.value_repr_t.from_opinfo (method) - from_opinfo(self, flags, afl, opinfo, _ap) -> bool - - @param flags: flags64_t - @param afl: aflags_t - @param opinfo: opinfo_t const * - @param _ap: array_parameters_t const * +ida_typeinf.value_repr_t.from_opinfo(self, flags: "flags64_t", afl: "aflags_t", opinfo: "opinfo_t", _ap: "array_parameters_t") -> bool -ida_typeinf.value_repr_t.get_vtype (method) - get_vtype(self) -> uint64 +ida_typeinf.value_repr_t.get_vtype(self) -> "uint64" -ida_typeinf.value_repr_t.has_lzeroes (method) - has_lzeroes(self) -> bool +ida_typeinf.value_repr_t.has_lzeroes(self) -> bool -ida_typeinf.value_repr_t.has_tabform (method) - has_tabform(self) -> bool +ida_typeinf.value_repr_t.has_tabform(self) -> bool -ida_typeinf.value_repr_t.init_ap (method) - init_ap(self, _ap) - - @param _ap: array_parameters_t * +ida_typeinf.value_repr_t.init_ap(self, _ap: "array_parameters_t") -> None -ida_typeinf.value_repr_t.is_custom (method) - is_custom(self) -> bool +ida_typeinf.value_repr_t.is_custom(self) -> bool -ida_typeinf.value_repr_t.is_enum (method) - is_enum(self) -> bool +ida_typeinf.value_repr_t.is_enum(self) -> bool -ida_typeinf.value_repr_t.is_offset (method) - is_offset(self) -> bool +ida_typeinf.value_repr_t.is_offset(self) -> bool -ida_typeinf.value_repr_t.is_signed (method) - is_signed(self) -> bool +ida_typeinf.value_repr_t.is_signed(self) -> bool -ida_typeinf.value_repr_t.is_strlit (method) - is_strlit(self) -> bool +ida_typeinf.value_repr_t.is_strlit(self) -> bool -ida_typeinf.value_repr_t.is_stroff (method) - is_stroff(self) -> bool +ida_typeinf.value_repr_t.is_stroff(self) -> bool -ida_typeinf.value_repr_t.is_typref (method) - is_typref(self) -> bool +ida_typeinf.value_repr_t.is_typref(self) -> bool -ida_typeinf.value_repr_t.parse_value_repr (method) - parse_value_repr(self, attr, target_type=BTF_STRUCT) -> bool - - @param attr: qstring const & - @param target_type: type_t +ida_typeinf.value_repr_t.parse_value_repr(self, *args) -> bool -ida_typeinf.value_repr_t.ri (variable) +ida_typeinf.value_repr_t.ri FRB_OFFSET. -ida_typeinf.value_repr_t.set_ap (method) - set_ap(self, _ap) - - @param _ap: array_parameters_t const & +ida_typeinf.value_repr_t.set_ap(self, _ap: "array_parameters_t") -> None -ida_typeinf.value_repr_t.set_lzeroes (method) - set_lzeroes(self, on) - - @param on: bool +ida_typeinf.value_repr_t.set_lzeroes(self, on: bool) -> None -ida_typeinf.value_repr_t.set_signed (method) - set_signed(self, on) - - @param on: bool +ida_typeinf.value_repr_t.set_signed(self, on: bool) -> None -ida_typeinf.value_repr_t.set_tabform (method) - set_tabform(self, on) - - @param on: bool +ida_typeinf.value_repr_t.set_tabform(self, on: bool) -> None -ida_typeinf.value_repr_t.set_vtype (method) - set_vtype(self, vt) - - @param vt: uint64 +ida_typeinf.value_repr_t.set_vtype(self, vt: "uint64") -> None -ida_typeinf.value_repr_t.strtype (variable) +ida_typeinf.value_repr_t.strtype FRB_STRLIT. -ida_typeinf.value_repr_t.swap (method) - swap(self, r) - - @param r: value_repr_t & +ida_typeinf.value_repr_t.swap(self, r: "value_repr_t") -> None -ida_typeinf.value_repr_t.type_ordinal (variable) +ida_typeinf.value_repr_t.type_ordinal FRB_STROFF, FRB_ENUM. -ida_typeinf.value_repr_t__from_opinfo (function) - value_repr_t__from_opinfo(_this, flags, afl, opinfo, ap) -> bool - - @param _this: value_repr_t * - @param flags: flags64_t - @param afl: aflags_t - @param opinfo: opinfo_t const * - @param ap: array_parameters_t const * +ida_typeinf.value_repr_t__from_opinfo(_this: "value_repr_t", flags: "flags64_t", afl: "aflags_t", opinfo: "opinfo_t", ap: "array_parameters_t") -> bool -ida_typeinf.value_repr_t__print_ (function) - value_repr_t__print_(_this, colored) -> str - - @param _this: value_repr_t const * - @param colored: bool +ida_typeinf.value_repr_t__print_(_this: "value_repr_t", colored: bool) -> str -ida_typeinf.verify_argloc (function) - verify_argloc(vloc, size, gaps) -> int - Verify argloc_t. - - @param vloc: (C++: const argloc_t &) argloc to verify - @param size: (C++: int) total size of the variable - @param gaps: (C++: const rangeset_t *) if not nullptr, specifies gaps in structure definition. these gaps - should not map to any argloc, but everything else must be covered - @return: 0 if ok, otherwise an interr code. +ida_typeinf.verify_argloc(vloc: "argloc_t", size: int, gaps: "rangeset_t") -> int + Verify argloc_t. + + @param vloc: argloc to verify + @param size: total size of the variable + @param gaps: if not nullptr, specifies gaps in structure definition. these gaps should not map to any argloc, but everything else must be covered + @returns 0 if ok, otherwise an interr code. -ida_typeinf.verify_tinfo (function) - verify_tinfo(typid) -> int - - @param typid: uint32 +ida_typeinf.verify_tinfo(typid: "typid_t") -> int -ida_typeinf.visit_subtypes (function) - visit_subtypes(visitor, out, tif, name, cmt) -> int - - @param visitor: tinfo_visitor_t * - @param out: type_mods_t * - @param tif: tinfo_t const & - @param name: char const * - @param cmt: char const * +ida_typeinf.visit_stroff_udms(sfv: "udm_visitor_t", path: "tid_t const *", disp: "adiff_t *", appzero: bool) -> "adiff_t *" + Visit structure fields in a stroff expression or in a reference to a struct data variable. This function can be used to enumerate all components of an expression like 'a.b.c'. + + @param sfv: visitor object + @param path: struct path (path[0] contains the initial struct id) + @param disp: offset into structure + @param appzero: should visit field at offset zero? + @returns visitor result -ida_typeinf.write_tinfo_bitfield_value (function) - write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64 - - @param typid: uint32 - @param dst: uint64 - @param v: uint64 - @param bitoff: int +ida_typeinf.visit_subtypes(visitor: "tinfo_visitor_t", out: "type_mods_t", tif: "tinfo_t", name: str, cmt: str) -> int -ida_ua (module) +ida_typeinf.write_tinfo_bitfield_value(typid: "typid_t", dst: "uint64", v: "uint64", bitoff: int) -> "uint64" + +ida_ua Functions that deal with the disassembling of program instructions. There are 2 kinds of functions: - * functions that are called from the kernel to disassemble an instruction. These - functions call IDP module for it. - * functions that are called from IDP module to disassemble an instruction. We - will call them 'helper functions'. + * functions that are called from the kernel to disassemble an instruction. These functions call IDP module for it. + * functions that are called from IDP module to disassemble an instruction. We will call them 'helper functions'. + Disassembly of an instruction is made in three steps: - 1. analysis: ana.cpp - 2. emulation: emu.cpp - 3. conversion to text: out.cpp + 0. analysis: ana.cpp + 1. emulation: emu.cpp + 2. conversion to text: out.cpp - The kernel calls the IDP module to perform these steps. At first, the kernel - always calls the analysis. The analyzer must decode the instruction and fill the - insn_t instance that it receives through its callback. It must not change - anything in the database. - The second step, the emulation, is called for each instruction. This step must - make necessary changes to the database, plan analysis of subsequent - instructions, track register values, memory contents, etc. Please keep in mind - that the kernel may call the emulation step for any address in the program - - there is no ordering of addresses. Usually, the emulation is called for - consecutive addresses but this is not guaranteed. - - The last step, conversion to text, is called each time an instruction is - displayed on the screen. The kernel will always call the analysis step before - calling the text conversion step. The emulation and the text conversion steps - should use the information stored in the insn_t instance they receive. They - should not access the bytes of the instruction and decode it again - this should - only be done in the analysis step. + The kernel calls the IDP module to perform these steps. At first, the kernel always calls the analysis. The analyzer must decode the instruction and fill the insn_t instance that it receives through its callback. It must not change anything in the database. + The second step, the emulation, is called for each instruction. This step must make necessary changes to the database, plan analysis of subsequent instructions, track register values, memory contents, etc. Please keep in mind that the kernel may call the emulation step for any address in the program - there is no ordering of addresses. Usually, the emulation is called for consecutive addresses but this is not guaranteed. + The last step, conversion to text, is called each time an instruction is displayed on the screen. The kernel will always call the analysis step before calling the text conversion step. The emulation and the text conversion steps should use the information stored in the insn_t instance they receive. They should not access the bytes of the instruction and decode it again - this should only be done in the analysis step. + -ida_ua.FCBF_CONT (variable) +ida_ua.BINOPSTATE_DONE + have been generated + +ida_ua.BINOPSTATE_GO + being generated + +ida_ua.BINOPSTATE_NONE + not generated yet + +ida_ua.COMMSTATE_DONE + have been generated + +ida_ua.COMMSTATE_GO + being generated + +ida_ua.COMMSTATE_NONE + not generated yet + +ida_ua.CTXF_BINOP_STATE + opcode bytes state: + +ida_ua.CTXF_BIT_PREFIX + generate a line prefix with a bit offset, e.g.: 12345678.3 + +ida_ua.CTXF_CMT_STATE + comment state: + +ida_ua.CTXF_CODE + display as code regardless of the database flags + +ida_ua.CTXF_DBLIND_OPND + an operand was printed with double indirection (e.g. =var in arm) + +ida_ua.CTXF_DEMANGLED_LABEL + generate only demangled label as comment + +ida_ua.CTXF_DEMANGLED_OK + the label has been demangled successfully + +ida_ua.CTXF_GEN_CMT + generate the comment along with the next line + +ida_ua.CTXF_GEN_XREFS + generate the xrefs along with the next line + +ida_ua.CTXF_HIDDEN_ADDR + To generate an hidden addr tag at the beginning of the line. + +ida_ua.CTXF_LABEL_OK + the label have been generated + +ida_ua.CTXF_MAIN + produce only the essential line(s) + +ida_ua.CTXF_MULTI + enable multi-line essential lines + +ida_ua.CTXF_NORMAL_LABEL + generate plain label (+demangled label as cmt) + +ida_ua.CTXF_OUTCTX_T + instance is, in fact, a outctx_t + +ida_ua.CTXF_OVSTORE_PRNT + out_value should store modified values + +ida_ua.CTXF_STACK + stack view (display undefined items as 2/4/8 bytes) + +ida_ua.CTXF_VOIDS + display void marks + +ida_ua.CTXF_XREF_STATE + xref state: + +ida_ua.FCBF_CONT don't stop on decoding, or any other kind of error -ida_ua.FCBF_DELIM (variable) - add the 'ash'-specified delimiters around the generated data. Note: if those are - not defined and the INFFL_ALLASM is not set, format_charlit() will return an - error +ida_ua.FCBF_DELIM + add the 'ash'-specified delimiters around the generated data. Note: if those are not defined and the INFFL_ALLASM is not set, format_charlit() will return an error + -ida_ua.FCBF_ERR_REPL (variable) - in case of an error, use a CP_REPLCHAR instead of a hex representation of the - problematic byte +ida_ua.FCBF_ERR_REPL + in case of an error, use a CP_REPLCHAR instead of a hex representation of the problematic byte + -ida_ua.FCBF_FF_LIT (variable) - in case of codepoints == 0xFF, use it as-is (i.e., LATIN SMALL LETTER Y WITH - DIAERESIS). If both this, and FCBF_REPL are specified, this will take precedence +ida_ua.FCBF_FF_LIT + in case of codepoints == 0xFF, use it as-is (i.e., LATIN SMALL LETTER Y WITH DIAERESIS). If both this, and FCBF_REPL are specified, this will take precedence + -ida_ua.INSN_64BIT (variable) +ida_ua.GH_BYTESEX_HAS_HIGHBYTE + describe inf.is_wide_high_byte_first() + +ida_ua.GH_PRINT_ASM + selected assembler + +ida_ua.GH_PRINT_BYTESEX + byte sex + +ida_ua.GH_PRINT_HEADER + lines from ash.header + +ida_ua.GH_PRINT_PROC + processor name + +ida_ua.INSN_64BIT belongs to 64bit segment? -ida_ua.INSN_MACRO (variable) +ida_ua.INSN_MACRO macro instruction -ida_ua.INSN_MODMAC (variable) +ida_ua.INSN_MODMAC may modify the database to make room for the macro insn -ida_ua.OF_NO_BASE_DISP (variable) - base displacement doesn't exist. meaningful only for o_displ type. if set, base - displacement (op_t::addr) doesn't exist. +ida_ua.MAKELINE_BINPREF + allow display of binary prefix -ida_ua.OF_NUMBER (variable) +ida_ua.MAKELINE_STACK + allow display of sp trace prefix + +ida_ua.MAKELINE_VOID + allow display of '<suspicious>' marks + +ida_ua.OF_NO_BASE_DISP + base displacement doesn't exist. meaningful only for o_displ type. if set, base displacement (op_t::addr) doesn't exist. + + +ida_ua.OF_NUMBER the operand can be converted to a number only -ida_ua.OF_OUTER_DISP (variable) - outer displacement exists. meaningful only for o_displ type. if set, outer - displacement (op_t::value) exists. +ida_ua.OF_OUTER_DISP + outer displacement exists. meaningful only for o_displ type. if set, outer displacement (op_t::value) exists. + -ida_ua.OF_SHOW (variable) +ida_ua.OF_SHOW should the operand be displayed? -ida_ua.OOFS_IFSIGN (variable) +ida_ua.OOFS_IFSIGN output sign if needed -ida_ua.OOFS_NEEDSIGN (variable) +ida_ua.OOFS_NEEDSIGN always out sign (+-) -ida_ua.OOFS_NOSIGN (variable) +ida_ua.OOFS_NOSIGN don't output sign, forbid the user to change the sign -ida_ua.OOFW_16 (variable) +ida_ua.OOFW_16 16 bit width -ida_ua.OOFW_24 (variable) +ida_ua.OOFW_24 24 bit width -ida_ua.OOFW_32 (variable) +ida_ua.OOFW_32 32 bit width -ida_ua.OOFW_64 (variable) +ida_ua.OOFW_64 64 bit width -ida_ua.OOFW_8 (variable) +ida_ua.OOFW_8 8 bit width -ida_ua.OOFW_IMM (variable) +ida_ua.OOFW_IMM take from x.dtype -ida_ua.OOF_ADDR (variable) +ida_ua.OOF_ADDR output x.addr, otherwise x.value -ida_ua.OOF_ANYSERIAL (variable) +ida_ua.OOF_ANYSERIAL if enum: select first available serial -ida_ua.OOF_LZEROES (variable) +ida_ua.OOF_LZEROES print leading zeroes -ida_ua.OOF_NOBNOT (variable) +ida_ua.OOF_NOBNOT prohibit use of binary not -ida_ua.OOF_NO_LZEROES (variable) - do not print leading zeroes; if none of OOF_LZEROES and OOF_NO_LZEROES was - specified, is_lzero() is used +ida_ua.OOF_NO_LZEROES + do not print leading zeroes; if none of OOF_LZEROES and OOF_NO_LZEROES was specified, is_lzero() is used + -ida_ua.OOF_NUMBER (variable) +ida_ua.OOF_NUMBER always as a number -ida_ua.OOF_OUTER (variable) +ida_ua.OOF_OUTER output outer operand -ida_ua.OOF_SIGNED (variable) +ida_ua.OOF_SIGNED output as signed if < 0 -ida_ua.OOF_SIGNMASK (variable) +ida_ua.OOF_SIGNMASK sign symbol (+/-) output -ida_ua.OOF_SPACES (variable) - do not suppress leading spaces; currently works only for floating point numbers +ida_ua.OOF_SPACES + do not suppress leading spaces; currently works only for floating point numbers + -ida_ua.OOF_WIDTHMASK (variable) +ida_ua.OOF_WIDTHMASK width of value in bits -ida_ua.OOF_ZSTROFF (variable) - meaningful only if is_stroff(F); append a struct field name if the field offset - is zero? if AFL_ZSTROFF is set, then this flag is ignored. +ida_ua.OOF_ZSTROFF + meaningful only if is_stroff(F); append a struct field name if the field offset is zero? if AFL_ZSTROFF is set, then this flag is ignored. + -ida_ua.PACK_FORM_DEF (variable) - packed factor defined. (!o_reg + dt_packreal) +ida_ua.PACK_FORM_DEF + packed factor defined. (!o_reg + dt_packreal) + -ida_ua.STKVAR_VALID_SIZE (variable) - x.dtype contains correct variable type (for insns like 'lea' this bit must be - off). in general, dr_O references do not allow to determine the variable size +ida_ua.STKVAR_VALID_SIZE + x.dtype contains correct variable type (for insns like 'lea' this bit must be off). in general, dr_O references do not allow to determine the variable size + -ida_ua.calc_dataseg (function) - calc_dataseg(insn, n=-1, rgnum=-1) -> ea_t - Get data segment for the instruction operand. 'opnum' and 'rgnum' are meaningful - only if the processor has segment registers. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param n: (C++: int) - @param rgnum: (C++: int) +ida_ua.XREFSTATE_DONE + have been generated -ida_ua.can_decode (function) - can_decode(ea) -> bool - Can the bytes at address 'ea' be decoded as instruction? - - @param ea: (C++: ea_t) linear address - @return: whether or not the contents at that address could be a valid - instruction +ida_ua.XREFSTATE_GO + being generated -ida_ua.construct_macro (function) - construct_macro(insn, enable, build_macro) -> bool +ida_ua.XREFSTATE_NONE + not generated yet + +ida_ua.calc_dataseg(insn: "insn_t", n: int = -1, rgnum: int = -1) -> ida_idaapi.ea_t + +ida_ua.can_decode(ea: ida_idaapi.ea_t) -> bool + Can the bytes at address 'ea' be decoded as instruction? + + @param ea: linear address + @returns whether or not the contents at that address could be a valid instruction + +ida_ua.construct_macro(*args) See ua.hpp's construct_macro(). - @param insn: insn_t & - @param enable: bool - @param build_macro: PyObject * - -ida_ua.construct_macro2 (function) - construct_macro2(_this, insn, enable) -> bool + This function has the following signatures - @param _this: macro_constructor_t * - @param insn: insn_t * - @param enable: bool - -ida_ua.create_insn (function) - create_insn(ea, out=None) -> int - Create an instruction at the specified address. This function checks if an - instruction is present at the specified address and will try to create one if - there is none. It will fail if there is a data item or other items hindering the - creation of the new instruction. This function will also fill the 'out' - structure. + 1. construct_macro(insn: insn_t, enable: bool, build_macro: callable) -> bool + 2. construct_macro(constuctor: macro_constructor_t, insn: insn_t, enable: bool) -> bool - @param ea: (C++: ea_t) linear address - @param out: (C++: insn_t *) the resulting instruction - @return: the length of the instruction or 0 + @param insn: the instruction to build the macro for + @param enable: enable macro generation + @param build_macro: a callable with 2 arguments: an insn_t, and + whether it is ok to consider the next instruction + for the macro + @param constructor: a macro_constructor_t implementation + @return: success -ida_ua.create_outctx (function) - create_outctx(ea, F=0, suspop=0) -> outctx_base_t - Create a new output context. To delete it, just use "delete pctx" - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param suspop: (C++: int) +ida_ua.create_insn(ea: ida_idaapi.ea_t, out: "insn_t" = None) -> int + Create an instruction at the specified address. This function checks if an instruction is present at the specified address and will try to create one if there is none. It will fail if there is a data item or other items hindering the creation of the new instruction. This function will also fill the 'out' structure. + + @param ea: linear address + @param out: the resulting instruction + @returns the length of the instruction or 0 -ida_ua.decode_insn (function) - decode_insn(out, ea) -> int - Analyze the specified address and fill 'out'. This function does not modify the - database. It just tries to interpret the specified address as an instruction and - fills the 'out' structure. - - @param out: (C++: insn_t *) the resulting instruction - @param ea: (C++: ea_t) linear address - @return: the length of the (possible) instruction or 0 +ida_ua.create_outctx(ea: ida_idaapi.ea_t, F: "flags64_t" = 0, suspop: int = 0) -> "outctx_base_t *" + Create a new output context. To delete it, just use "delete pctx" + -ida_ua.decode_preceding_insn (function) - decode_preceding_insn(out, ea) -> (int, int) - Decodes the preceding instruction. Please check ua.hpp / decode_preceding_insn() +ida_ua.decode_insn(out: "insn_t", ea: ida_idaapi.ea_t) -> int + Analyze the specified address and fill 'out'. This function does not modify the database. It just tries to interpret the specified address as an instruction and fills the 'out' structure. + + @param out: the resulting instruction + @param ea: linear address + @returns the length of the (possible) instruction or 0 + +ida_ua.decode_preceding_insn(out: insn_t, ea: ida_idaapi.ea_t) -> Tuple[ida_idaapi.ea_t, bool] + Decodes the preceding instruction. @param out: instruction storage @param ea: current ea @return: tuple(preceeding_ea or BADADDR, farref = Boolean) -ida_ua.decode_prev_insn (function) - decode_prev_insn(out, ea) -> ea_t - Decode previous instruction if it exists, fill 'out'. - - @param out: (C++: insn_t *) the resulting instruction - @param ea: (C++: ea_t) the address to decode the previous instruction from - @return: the previous instruction address (BADADDR-no such insn) +ida_ua.decode_prev_insn(out: "insn_t", ea: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Decode previous instruction if it exists, fill 'out'. + + @param out: the resulting instruction + @param ea: the address to decode the previous instruction from + @returns the previous instruction address (BADADDR-no such insn) -ida_ua.dt_bitfild (variable) +ida_ua.dt_bitfild bit field (mc680x0) -ida_ua.dt_byte (variable) +ida_ua.dt_byte 8 bit integer -ida_ua.dt_byte16 (variable) +ida_ua.dt_byte16 128 bit integer -ida_ua.dt_byte32 (variable) +ida_ua.dt_byte32 256 bit integer -ida_ua.dt_byte64 (variable) +ida_ua.dt_byte64 512 bit integer -ida_ua.dt_code (variable) +ida_ua.dt_code ptr to code (not used?) -ida_ua.dt_double (variable) +ida_ua.dt_double 8 byte floating point -ida_ua.dt_dword (variable) +ida_ua.dt_dword 32 bit integer -ida_ua.dt_float (variable) +ida_ua.dt_float 4 byte floating point -ida_ua.dt_fword (variable) +ida_ua.dt_fword 48 bit -ida_ua.dt_half (variable) +ida_ua.dt_half 2-byte floating point -ida_ua.dt_ldbl (variable) +ida_ua.dt_ldbl long double (which may be different from tbyte) -ida_ua.dt_packreal (variable) +ida_ua.dt_packreal packed real format for mc68040 -ida_ua.dt_qword (variable) +ida_ua.dt_qword 64 bit integer -ida_ua.dt_string (variable) +ida_ua.dt_string pointer to asciiz string -ida_ua.dt_tbyte (variable) +ida_ua.dt_tbyte variable size ( processor_t::tbyte_size) floating point -ida_ua.dt_unicode (variable) +ida_ua.dt_unicode pointer to unicode string -ida_ua.dt_void (variable) +ida_ua.dt_void none -ida_ua.dt_word (variable) +ida_ua.dt_word 16 bit integer -ida_ua.get_dtype_by_size (function) - get_dtype_by_size(size) -> int +ida_ua.get_dtype_by_size(size: "asize_t") -> int Get op_t::dtype from size. - - @param size: (C++: asize_t) -ida_ua.get_dtype_flag (function) - get_dtype_flag(dtype) -> flags64_t +ida_ua.get_dtype_flag(dtype: "op_dtype_t") -> "flags64_t" Get flags for op_t::dtype field. - - @param dtype: (C++: op_dtype_t) -ida_ua.get_dtype_size (function) - get_dtype_size(dtype) -> size_t +ida_ua.get_dtype_size(dtype: "op_dtype_t") -> "size_t" Get size of opt_::dtype field. - - @param dtype: (C++: op_dtype_t) -ida_ua.get_immvals (function) - get_immvals(ea, n, F=0) -> [int, ...] - Get immediate values at the specified address. This function decodes instruction - at the specified address or inspects the data item. It finds immediate values - and copies them to 'out'. This function will store the original value of the - operands in 'out', unless the last bits of 'F' are "...0 11111111", in which - case the transformed values (as needed for printing) will be stored instead. - - @param ea: (C++: ea_t) address to analyze - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all the operands - @param F: (C++: flags64_t) flags for the specified address - @return: number of immediate values (0..2*UA_MAXOP) +ida_ua.get_immvals(ea: ida_idaapi.ea_t, n: int, F: "flags64_t" = 0) -> "PyObject *" + Get immediate values at the specified address. This function decodes instruction at the specified address or inspects the data item. It finds immediate values and copies them to 'out'. This function will store the original value of the operands in 'out', unless the last bits of 'F' are "...0 11111111", in which case the transformed values (as needed for printing) will be stored instead. + + @param ea: address to analyze + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all the operands + @param F: flags for the specified address + @returns number of immediate values (0..2*UA_MAXOP) -ida_ua.get_lookback (function) - get_lookback() -> int - Number of instructions to look back. This variable is not used by the kernel. - Its value may be specified in ida.cfg: LOOKBACK = <number>. IDP may use it as - you like it. (TMS module uses it) +ida_ua.get_lookback() -> int + Number of instructions to look back. This variable is not used by the kernel. Its value may be specified in ida.cfg: LOOKBACK = <number>. IDP may use it as you like it. (TMS module uses it) + -ida_ua.get_printable_immvals (function) - get_printable_immvals(ea, n, F=0) -> PyObject * - Get immediate ready-to-print values at the specified address - - @param ea: (C++: ea_t) address to analyze - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all the operands - @param F: (C++: flags64_t) flags for the specified address - @return: number of immediate values (0..2*UA_MAXOP) +ida_ua.get_printable_immvals(ea: ida_idaapi.ea_t, n: int, F: "flags64_t" = 0) -> "PyObject *" + Get immediate ready-to-print values at the specified address + + @param ea: address to analyze + @param n: 0..UA_MAXOP-1 operand number, OPND_ALL all the operands + @param F: flags for the specified address + @returns number of immediate values (0..2*UA_MAXOP) -ida_ua.insn_add_cref (function) - insn_add_cref(insn, to, opoff, type) - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param to: ea_t - @param opoff: int - @param type: enum cref_t +ida_ua.insn_add_cref(insn: "insn_t", to: ida_idaapi.ea_t, opoff: int, type: "cref_t") -> None -ida_ua.insn_add_dref (function) - insn_add_dref(insn, to, opoff, type) - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param to: ea_t - @param opoff: int - @param type: enum dref_t +ida_ua.insn_add_dref(insn: "insn_t", to: ida_idaapi.ea_t, opoff: int, type: "dref_t") -> None -ida_ua.insn_add_off_drefs (function) - insn_add_off_drefs(insn, x, type, outf) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: op_t const & - @param type: enum dref_t - @param outf: int +ida_ua.insn_add_off_drefs(insn: "insn_t", x: "op_t", type: "dref_t", outf: int) -> ida_idaapi.ea_t -ida_ua.insn_create_stkvar (function) - insn_create_stkvar(insn, x, v, flags) -> bool - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: op_t const & - @param v: adiff_t - @param flags: int +ida_ua.insn_create_stkvar(insn: "insn_t", x: "op_t", v: "adiff_t", flags: int) -> bool -ida_ua.insn_t (class) - Proxy of C++ insn_t class. +ida_ua.insn_t -ida_ua.insn_t.__get_auxpref__ (method) - __get_auxpref__(self) -> uint32 +ida_ua.insn_t.__get_auxpref__(self) -> int -ida_ua.insn_t.__get_operand__ (method) - __get_operand__(self, n) -> op_t - - @param n: int +ida_ua.insn_t.__get_operand__(self, n: int) -> "op_t *" -ida_ua.insn_t.__get_ops__ (method) - __get_ops__(self) -> operands_array +ida_ua.insn_t.__get_ops__(self) -> "wrapped_array_t< op_t,8 >" -ida_ua.insn_t.__getitem__ (method) +ida_ua.insn_t.__getitem__(self, idx) Operands can be accessed directly as indexes - @return: op_t: Returns an operand of type op_t + @return op_t: Returns an operand of type op_t -ida_ua.insn_t.__init__ (method) - __init__(self) -> insn_t +ida_ua.insn_t.__init__(self) -ida_ua.insn_t.__iter__ (method) +ida_ua.insn_t.__iter__(self) -ida_ua.insn_t.__set_auxpref__ (method) - __set_auxpref__(self, v) - - @param v: uint32 +ida_ua.insn_t.__set_auxpref__(self, v: int) -> None -ida_ua.insn_t.add_cref (method) - add_cref(self, to, opoff, type) - Add a code cross-reference from the instruction. - - @param to: (C++: ea_t) target linear address - @param opoff: (C++: int) offset of the operand from the start of instruction. if the offset - is unknown, then 0. - @param type: (C++: cref_t) type of xref +ida_ua.insn_t.add_cref(self, to: ida_idaapi.ea_t, opoff: int, type: "cref_t") -> None + Add a code cross-reference from the instruction. + + @param to: target linear address + @param opoff: offset of the operand from the start of instruction. if the offset is unknown, then 0. + @param type: type of xref -ida_ua.insn_t.add_dref (method) - add_dref(self, to, opoff, type) - Add a data cross-reference from the instruction. See add_off_drefs() - usually - it can be used in most cases. - - @param to: (C++: ea_t) target linear address - @param opoff: (C++: int) offset of the operand from the start of instruction if the offset - is unknown, then 0 - @param type: (C++: dref_t) type of xref +ida_ua.insn_t.add_dref(self, to: ida_idaapi.ea_t, opoff: int, type: "dref_t") -> None + Add a data cross-reference from the instruction. See add_off_drefs() - usually it can be used in most cases. + + @param to: target linear address + @param opoff: offset of the operand from the start of instruction if the offset is unknown, then 0 + @param type: type of xref -ida_ua.insn_t.add_off_drefs (method) - add_off_drefs(self, x, type, outf) -> ea_t - Add xrefs for an operand of the instruction. This function creates all cross - references for 'enum', 'offset' and 'structure offset' operands. Use - add_off_drefs() in the presence of negative offsets. - - @param x: (C++: const op_t &) reference to operand - @param type: (C++: dref_t) type of xref - @param outf: (C++: int) out_value() flags. These flags should match the flags used to - output the operand - @return: if is_off(): the reference target address (the same as - calc_reference_data). if is_stroff(): BADADDR because for stroffs the - target address is unknown else: BADADDR because enums do not represent - addresses +ida_ua.insn_t.add_off_drefs(self, x: "op_t", type: "dref_t", outf: int) -> ida_idaapi.ea_t + Add xrefs for an operand of the instruction. This function creates all cross references for 'enum', 'offset' and 'structure offset' operands. Use add_off_drefs() in the presence of negative offsets. + + @param x: reference to operand + @param type: type of xref + @param outf: out_value() flags. These flags should match the flags used to output the operand + @retval if: is_off(): the reference target address (the same as calc_reference_data). + @retval if: is_stroff(): BADADDR because for stroffs the target address is unknown + @retval otherwise: BADADDR because enums do not represent addresses -ida_ua.insn_t.assign (method) - assign(self, other) - - @param other: an ida_ua.insn_t, or an address (C++: const insn_t &) +ida_ua.insn_t.assign(self, other: "insn_t") -> None -ida_ua.insn_t.auxpref (variable) +ida_ua.insn_t.auxpref processor dependent field -ida_ua.insn_t.create_op_data (method) - create_op_data(self, ea_, opoff, dtype) -> bool - Convenient alias. - - @param ea_: (C++: ea_t) - @param opoff: int - @param dtype: op_dtype_t - - create_op_data(self, ea_, op) -> bool - - @param ea_: ea_t - @param op: op_t const & +ida_ua.insn_t.auxpref + processor dependent field -ida_ua.insn_t.create_stkvar (method) - create_stkvar(self, x, v, flags_) -> bool - Create or modify a stack variable in the function frame. The emulator could use - this function to create stack variables in the function frame before converting - the operand to a stack variable. Please check with may_create_stkvars() before - calling this function. - - @param x: (C++: const op_t &) operand (used to determine the addressing type) - @param v: (C++: adiff_t) a displacement in the operand - @param flags_: (C++: int) Stack variable flags - @retval 1: ok, a stack variable exists now - @retval 0: no, couldn't create stack variable +ida_ua.insn_t.create_op_data(self, *args) -> bool -ida_ua.insn_t.cs (variable) +ida_ua.insn_t.create_stkvar(self, x: "op_t", v: "adiff_t", flags_: int) -> bool + +ida_ua.insn_t.cs Current segment base paragraph. Initialized by the kernel. -ida_ua.insn_t.ea (variable) - Linear address of the instruction. Initialized by the kernel. +ida_ua.insn_t.ea + Linear address of the instruction. Initialized by the kernel. + -ida_ua.insn_t.flags (variable) +ida_ua.insn_t.flags Instruction flags -ida_ua.insn_t.get_canon_feature (method) - get_canon_feature(self, ph) -> uint32 +ida_ua.insn_t.get_canon_feature(self, *args) -> int see instruc_t::feature - - @param ph: (C++: const processor_t &) processor_t const & - - get_canon_feature(self) -> uint32 -ida_ua.insn_t.get_canon_mnem (method) - get_canon_mnem(self, ph) -> char const +ida_ua.insn_t.get_canon_mnem(self, *args) -> str see instruc_t::name - - @param ph: (C++: const processor_t &) processor_t const & - - get_canon_mnem(self) -> char const * -ida_ua.insn_t.get_next_byte (method) - get_next_byte(self) -> uint8 +ida_ua.insn_t.get_next_byte(self) -> "uint8" -ida_ua.insn_t.get_next_dword (method) - get_next_dword(self) -> uint32 +ida_ua.insn_t.get_next_dword(self) -> int -ida_ua.insn_t.get_next_qword (method) - get_next_qword(self) -> uint64 +ida_ua.insn_t.get_next_qword(self) -> "uint64" -ida_ua.insn_t.get_next_word (method) - get_next_word(self) -> uint16 +ida_ua.insn_t.get_next_word(self) -> "uint16" -ida_ua.insn_t.insnpref (variable) +ida_ua.insn_t.insnpref processor dependent field -ida_ua.insn_t.ip (variable) - Virtual address of the instruction (address within the segment). Initialized by - the kernel. +ida_ua.insn_t.ip + Virtual address of the instruction (address within the segment). Initialized by the kernel. + -ida_ua.insn_t.is_64bit (method) - is_64bit(self) -> bool +ida_ua.insn_t.is_64bit(self) -> bool Belongs to a 64bit segment? -ida_ua.insn_t.is_canon_insn (method) - is_canon_insn(self, ph) -> bool +ida_ua.insn_t.is_canon_insn(self, *args) -> bool see processor_t::is_canon_insn() - - @param ph: (C++: const processor_t &) processor_t const & - - is_canon_insn(self) -> bool -ida_ua.insn_t.is_macro (method) - is_macro(self) -> bool +ida_ua.insn_t.is_macro(self) -> bool Is a macro instruction? -ida_ua.insn_t.itype (variable) - Internal code of instruction (only for canonical insns - not user defined!). IDP - should define its own instruction codes. These codes are usually defined in - ins.hpp. The array of instruction names and features (ins.cpp) is accessed using - this code. +ida_ua.insn_t.itype + Internal code of instruction (only for canonical insns - not user defined!). IDP should define its own instruction codes. These codes are usually defined in ins.hpp. The array of instruction names and features (ins.cpp) is accessed using this code. + -ida_ua.insn_t.ops (variable) +ida_ua.insn_t.ops array of operands -ida_ua.insn_t.segpref (variable) +ida_ua.insn_t.ops + array of operands + +ida_ua.insn_t.segpref processor dependent field -ida_ua.insn_t.size (variable) - Size of instruction in bytes. The analyzer should put here the actual size of - the instruction. +ida_ua.insn_t.size + Size of instruction in bytes. The analyzer should put here the actual size of the instruction. + -ida_ua.insn_t__from_ptrval__ (function) - insn_t__from_ptrval__(ptrval) -> insn_t - - @param ptrval: size_t +ida_ua.insn_t__from_ptrval__(ptrval: "size_t") -> "insn_t *" -ida_ua.is_floating_dtype (function) - is_floating_dtype(dtype) -> bool +ida_ua.is_floating_dtype(dtype: "op_dtype_t") -> bool Is a floating type operand? - - @param dtype: (C++: op_dtype_t) -ida_ua.macro_constructor_t (class) - Proxy of C++ macro_constructor_t class. +ida_ua.macro_constructor_t -ida_ua.macro_constructor_t.__disown__ (method) +ida_ua.macro_constructor_t.__disown__(self) -ida_ua.macro_constructor_t.__init__ (method) - __init__(self) -> macro_constructor_t - - @param self: PyObject * +ida_ua.macro_constructor_t.__init__(self) -ida_ua.macro_constructor_t.build_macro (method) - build_macro(self, insn, may_go_forward) -> bool +ida_ua.macro_constructor_t.build_macro(self, insn: "insn_t", may_go_forward: bool) -> bool Try to extend the instruction. + This function may modify 'insn' and return false; these changes will be accepted by the kernel but the instruction will not be considered as a macro. - @param insn: (C++: insn_t *) Instruction to modify, usually the first instruction of the macro - @param may_go_forward: (C++: bool) Is it ok to consider the next instruction for the macro? - This argument may be false, for example, if there is a - cross reference to the end of INSN. In this case creating - a macro is not desired. However, it may still be useful - to perform minor tweaks to the instruction using the - information about the surrounding instructions. - @return: true if created an macro instruction. This function may modify 'insn' - and return false; these changes will be accepted by the kernel but the - instruction will not be considered as a macro. + @param insn: Instruction to modify, usually the first instruction of the macro + @param may_go_forward: Is it ok to consider the next instruction for the macro? This argument may be false, for example, if there is a cross reference to the end of INSN. In this case creating a macro is not desired. However, it may still be useful to perform minor tweaks to the instruction using the information about the surrounding instructions. + @returns true if created an macro instruction. -ida_ua.map_code_ea (function) - map_code_ea(insn, addr, opnum) -> ea_t +ida_ua.macro_constructor_t.construct_macro(self, insn: "insn_t", enable: bool) -> bool + Construct a macro instruction. This function may be called from ana() to generate a macro instruction. + The real work is done by the 'build_macro()' virtual function. It must be defined by the processor module. + construct_macro() modifies the database using the info provided by build_macro(). It verifies if the instruction can really be created (for example, that other items do not hinder), may plan to reanalyze the macro, etc. If the macro instructions are disabled by the user, construct_macro() will destroy the macro instruction. Note: if INSN_MODMAC is not set in insn.flags, the database will not be modified. - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param addr: ea_t - @param opnum: int - - map_code_ea(insn, op) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: op_t const & + @param insn: the instruction to modify into a macro + @param enable: enable macro generation + @retval true: the macro instruction is generated in 'insn' + @retval false: did not create a macro -ida_ua.map_data_ea (function) - map_data_ea(insn, addr, opnum=-1) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param addr: ea_t - @param opnum: int - - map_data_ea(insn, op) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: op_t const & +ida_ua.map_code_ea(*args) -> ida_idaapi.ea_t -ida_ua.map_ea (function) - map_ea(insn, op, iscode) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: op_t const & - @param iscode: bool - - map_ea(insn, addr, opnum, iscode) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param addr: ea_t - @param opnum: int - @param iscode: bool +ida_ua.map_data_ea(*args) -> ida_idaapi.ea_t -ida_ua.o_displ (variable) +ida_ua.map_ea(*args) -> ida_idaapi.ea_t + +ida_ua.o_displ Memory Ref [Base Reg + Index Reg + Displacement]. - A memory reference using register contents with displacement. The displacement - should be stored in the op_t::addr field. The rest of information is stored the - same way as in o_phrase. + A memory reference using register contents with displacement. The displacement should be stored in the op_t::addr field. The rest of information is stored the same way as in o_phrase. + -ida_ua.o_far (variable) +ida_ua.o_far Immediate Far Address (CODE). - If the current processor has a special addressing mode for inter-segment - references, then this operand type should be used instead of o_near. If you - want, you may use PR_CHK_XREF in processor_t::flag to disable inter-segment - calls if o_near operand type is used. Currently only IBM PC uses this flag. + If the current processor has a special addressing mode for inter-segment references, then this operand type should be used instead of o_near. If you want, you may use PR_CHK_XREF in processor_t::flag to disable inter-segment calls if o_near operand type is used. Currently only IBM PC uses this flag. + -ida_ua.o_idpspec0 (variable) +ida_ua.o_idpspec0 processor specific type. -ida_ua.o_idpspec1 (variable) +ida_ua.o_idpspec1 processor specific type. -ida_ua.o_idpspec2 (variable) +ida_ua.o_idpspec2 processor specific type. -ida_ua.o_idpspec3 (variable) +ida_ua.o_idpspec3 processor specific type. -ida_ua.o_idpspec4 (variable) +ida_ua.o_idpspec4 processor specific type. -ida_ua.o_idpspec5 (variable) - processor specific type. (there can be more processor specific types) +ida_ua.o_idpspec5 + processor specific type. (there can be more processor specific types) + -ida_ua.o_imm (variable) +ida_ua.o_imm Immediate Value. - Any operand consisting of only a number is represented by this operand type. The - value should be stored in op_t::value. You may sign extend short (1-2 byte) - values. In any case don't forget to specify op_t::dtype (should be set for all - operand types). + Any operand consisting of only a number is represented by this operand type. The value should be stored in op_t::value. You may sign extend short (1-2 byte) values. In any case don't forget to specify op_t::dtype (should be set for all operand types). + -ida_ua.o_mem (variable) +ida_ua.o_mem Direct Memory Reference (DATA). - A direct memory data reference whose target address is known at compilation - time. The target virtual address is stored in op_t::addr and the full address is - calculated as to_ea( insn_t::cs, op_t::addr ). For the processors with complex - memory organization the final address can be calculated using other segment - registers. For flat memories, op_t::addr is the final address and insn_t::cs is - usually equal to zero. In any case, the address within the segment should be - stored in op_t::addr. + A direct memory data reference whose target address is known at compilation time. The target virtual address is stored in op_t::addr and the full address is calculated as to_ea( insn_t::cs, op_t::addr ). For the processors with complex memory organization the final address can be calculated using other segment registers. For flat memories, op_t::addr is the final address and insn_t::cs is usually equal to zero. In any case, the address within the segment should be stored in op_t::addr. + -ida_ua.o_near (variable) +ida_ua.o_near Immediate Near Address (CODE). - A direct memory code reference whose target address is known at the compilation - time. The target virtual address is stored in op_t::addr and the final address - is always to_ea( insn_t::cs, op_t::addr). Usually this operand type is used for - the branches and calls whose target address is known. If the current processor - has 2 different types of references for inter-segment and intra-segment - references, then this should be used only for intra-segment references. - - If the above operand types do not cover all possible addressing modes, then use - o_idpspec... operand types. + A direct memory code reference whose target address is known at the compilation time. The target virtual address is stored in op_t::addr and the final address is always to_ea( insn_t::cs, op_t::addr). Usually this operand type is used for the branches and calls whose target address is known. If the current processor has 2 different types of references for inter-segment and intra-segment references, then this should be used only for intra-segment references. + If the above operand types do not cover all possible addressing modes, then use o_idpspec... operand types. + -ida_ua.o_phrase (variable) +ida_ua.o_phrase Memory Ref [Base Reg + Index Reg]. - A memory reference using register contents. Indexed, register based, and other - addressing modes can be represented with the operand type. This addressing mode - cannot contain immediate values (use o_displ instead). The phrase number should - be stored in op_t::phrase. To denote the pre-increment and similar features - please use additional operand fields like op_t::specflag... Usually op_t::phrase - contains the register number and additional information is stored in - op_t::specflags... Please note that this operand type cannot contain immediate - values (except the scaling coefficients). + A memory reference using register contents. Indexed, register based, and other addressing modes can be represented with the operand type. This addressing mode cannot contain immediate values (use o_displ instead). The phrase number should be stored in op_t::phrase. To denote the pre-increment and similar features please use additional operand fields like op_t::specflag... Usually op_t::phrase contains the register number and additional information is stored in op_t::specflags... Please note that this operand type cannot contain immediate values (except the scaling coefficients). + -ida_ua.o_reg (variable) +ida_ua.o_reg General Register (al,ax,es,ds...). - The register number should be stored in op_t::reg. All processor registers, - including special registers, can be represented by this operand type. + The register number should be stored in op_t::reg. All processor registers, including special registers, can be represented by this operand type. + -ida_ua.o_void (variable) +ida_ua.o_void No Operand. -ida_ua.op_t (class) - Proxy of C++ op_t class. +ida_ua.op_t -ida_ua.op_t.__get_addr__ (method) - __get_addr__(self) -> ea_t +ida_ua.op_t.__get_addr__(self) -> ida_idaapi.ea_t -ida_ua.op_t.__get_reg_phrase__ (method) - __get_reg_phrase__(self) -> uint16 +ida_ua.op_t.__get_reg_phrase__(self) -> "uint16" -ida_ua.op_t.__get_specval__ (method) - __get_specval__(self) -> ea_t +ida_ua.op_t.__get_specval__(self) -> ida_idaapi.ea_t -ida_ua.op_t.__get_value64__ (method) - __get_value64__(self) -> uint64 +ida_ua.op_t.__get_value64__(self) -> "uint64" -ida_ua.op_t.__get_value__ (method) - __get_value__(self) -> ea_t +ida_ua.op_t.__get_value__(self) -> ida_idaapi.ea_t -ida_ua.op_t.__init__ (method) - __init__(self) -> op_t +ida_ua.op_t.__init__(self) -ida_ua.op_t.__set_addr__ (method) - __set_addr__(self, v) - - @param v: ea_t +ida_ua.op_t.__set_addr__(self, v: ida_idaapi.ea_t) -> None -ida_ua.op_t.__set_reg_phrase__ (method) - __set_reg_phrase__(self, r) - - @param r: uint16 +ida_ua.op_t.__set_reg_phrase__(self, r: "uint16") -> None -ida_ua.op_t.__set_specval__ (method) - __set_specval__(self, v) - - @param v: ea_t +ida_ua.op_t.__set_specval__(self, v: ida_idaapi.ea_t) -> None -ida_ua.op_t.__set_value64__ (method) - __set_value64__(self, v) - - @param v: uint64 +ida_ua.op_t.__set_value64__(self, v: "uint64") -> None -ida_ua.op_t.__set_value__ (method) - __set_value__(self, v) - - @param v: ea_t +ida_ua.op_t.__set_value__(self, v: ida_idaapi.ea_t) -> None -ida_ua.op_t.addr (variable) - virtual address pointed or used by the operand. (o_mem,o_displ,o_far,o_near) +ida_ua.op_t.addr + virtual address pointed or used by the operand. (o_mem,o_displ,o_far,o_near) + -ida_ua.op_t.assign (method) - assign(self, other) - - @param other: op_t const & +ida_ua.op_t.addr + virtual address pointed or used by the operand. (o_mem,o_displ,o_far,o_near) + -ida_ua.op_t.clr_shown (method) - clr_shown(self) +ida_ua.op_t.assign(self, other: "op_t") -> None + +ida_ua.op_t.clr_shown(self) -> None Set operand to hidden. -ida_ua.op_t.dtype (variable) - Type of operand value (see Operand value types). Usually first 9 types are used. - This is the type of the operand itself, not the size of the addressing mode. for - example, byte ptr [epb+32_bit_offset] will have dt_byte type. +ida_ua.op_t.dtype + Type of operand value (see Operand value types). Usually first 9 types are used. This is the type of the operand itself, not the size of the addressing mode. for example, byte ptr [epb+32_bit_offset] will have dt_byte type. + -ida_ua.op_t.flags (variable) - Operand flags +ida_ua.op_t.flags + Operand flags + -ida_ua.op_t.has_reg (method) +ida_ua.op_t.has_reg(self, r) Checks if the operand accesses the given processor register -ida_ua.op_t.is_imm (method) - is_imm(self, v) -> bool +ida_ua.op_t.is_imm(self, v: int) -> bool Is immediate operand? - - @param v: (C++: uval_t) -ida_ua.op_t.is_reg (method) - is_reg(self, r) -> bool +ida_ua.op_t.is_reg(self, r: int) -> bool Is register operand? - - @param r: (C++: int) -ida_ua.op_t.n (variable) - Number of operand (0,1,2). Initialized once at the start of work. You have no - right to change its value. +ida_ua.op_t.n + Number of operand (0,1,2). Initialized once at the start of work. You have no right to change its value. + -ida_ua.op_t.offb (variable) - Offset of operand value from the instruction start (0 means unknown). Of course - this field is meaningful only for certain types of operands. Leave it equal to - zero if the operand has no offset. This offset should point to the 'interesting' - part of operand. For example, it may point to the address of a function in - call func or it may point to bytes holding '5' in - mov ax, [bx+5] Usually bytes pointed to this offset are relocated (have fixup - information). +ida_ua.op_t.offb + Offset of operand value from the instruction start (0 means unknown). Of course this field is meaningful only for certain types of operands. Leave it equal to zero if the operand has no offset. This offset should point to the 'interesting' part of operand. For example, it may point to the address of a function in `call func ` or it may point to bytes holding '5' in `mov ax, [bx+5] ` Usually bytes pointed to this offset are relocated (have fixup information). + -ida_ua.op_t.offo (variable) - Same as offb (some operands have 2 numeric values used to form an operand). This - field is used for the second part of operand if it exists. Currently this field - is used only for outer offsets of Motorola processors. Leave it equal to zero if - the operand has no offset. +ida_ua.op_t.offo + Same as offb (some operands have 2 numeric values used to form an operand). This field is used for the second part of operand if it exists. Currently this field is used only for outer offsets of Motorola processors. Leave it equal to zero if the operand has no offset. + -ida_ua.op_t.phrase (variable) - number of register phrase (o_phrase,o_displ). you yourself define numbers of - phrases as you like +ida_ua.op_t.phrase + number of register phrase (o_phrase,o_displ). you yourself define numbers of phrases as you like + -ida_ua.op_t.reg (variable) +ida_ua.op_t.phrase + number of register phrase (o_phrase,o_displ). you yourself define numbers of phrases as you like + + +ida_ua.op_t.reg number of register (o_reg) -ida_ua.op_t.set_shown (method) - set_shown(self) +ida_ua.op_t.reg + number of register (o_reg) + +ida_ua.op_t.set_shown(self) -> None Set operand to be shown. -ida_ua.op_t.shown (method) - shown(self) -> bool +ida_ua.op_t.shown(self) -> bool Is operand set to be shown? -ida_ua.op_t.specval (variable) - This field may be used as you want. +ida_ua.op_t.specval + This field may be used as you want. + -ida_ua.op_t.type (variable) +ida_ua.op_t.specval + This field may be used as you want. + + +ida_ua.op_t.type Type of operand (see Operand types) -ida_ua.op_t.value (variable) - operand value (o_imm) or outer displacement (o_displ+OF_OUTER_DISP). integer - values should be in IDA's (little-endian) order. when using ieee_realcvt(), - floating point values should be in the processor's native byte order. dt_double - and dt_qword values take up 8 bytes (value and addr fields for 32-bit modules). - NB: in case a dt_dword/dt_qword immediate is forced to float by user, the kernel - converts it to processor's native order before calling FP conversion routines. +ida_ua.op_t.value + operand value (o_imm) or outer displacement (o_displ+OF_OUTER_DISP). integer values should be in IDA's (little-endian) order. when using ieee_realcvt(), floating point values should be in the processor's native byte order. dt_double and dt_qword values take up 8 bytes (value and addr fields for 32-bit modules). NB: in case a dt_dword/dt_qword immediate is forced to float by user, the kernel converts it to processor's native order before calling FP conversion routines. + -ida_ua.op_t__from_ptrval__ (function) - op_t__from_ptrval__(ptrval) -> op_t - - @param ptrval: size_t +ida_ua.op_t.value + operand value (o_imm) or outer displacement (o_displ+OF_OUTER_DISP). integer values should be in IDA's (little-endian) order. when using ieee_realcvt(), floating point values should be in the processor's native byte order. dt_double and dt_qword values take up 8 bytes (value and addr fields for 32-bit modules). NB: in case a dt_dword/dt_qword immediate is forced to float by user, the kernel converts it to processor's native order before calling FP conversion routines. + -ida_ua.operands_array (class) - Proxy of C++ wrapped_array_t< op_t,8 > class. +ida_ua.op_t__from_ptrval__(ptrval: "size_t") -> "op_t *" -ida_ua.operands_array.__getitem__ (method) - __getitem__(self, i) -> op_t - - @param i: size_t +ida_ua.operands_array -ida_ua.operands_array.__init__ (method) - __init__(self, data) -> operands_array - - @param data: op_t (&)[8] +ida_ua.operands_array.__getitem__(self, i: "size_t") -> "op_t const &" -ida_ua.operands_array.__len__ (method) - __len__(self) -> size_t +ida_ua.operands_array.__init__(self, data: "op_t (&)[8]") -ida_ua.operands_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: op_t const & +ida_ua.operands_array.__len__(self) -> "size_t" -ida_ua.operands_array._get_bytes (method) - _get_bytes(self) -> bytevec_t +ida_ua.operands_array.__setitem__(self, i: "size_t", v: "op_t") -> None -ida_ua.operands_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & +ida_ua.operands_array._get_bytes(self) -> "bytevec_t" -ida_ua.outctx_base_t (class) - Proxy of C++ outctx_base_t class. +ida_ua.operands_array._set_bytes(self, bts: "bytevec_t const &") -> None -ida_ua.outctx_base_t.__init__ (method) +ida_ua.outctx_base_t -ida_ua.outctx_base_t.close_comment (method) - close_comment(self) +ida_ua.outctx_base_t.F32 + please use outctx_t::F instead -ida_ua.outctx_base_t.clr_gen_label (method) - clr_gen_label(self) +ida_ua.outctx_base_t.__init__(self, *args, **kwargs) -ida_ua.outctx_base_t.display_voids (method) - display_voids(self) -> bool +ida_ua.outctx_base_t.close_comment(self) -> None -ida_ua.outctx_base_t.flush_buf (method) - flush_buf(self, buf, indent=-1) -> bool - Append contents of 'buf' to the line array. Behaves like flush_outbuf but - accepts an arbitrary buffer - - @param buf: (C++: const char *) char const * - @param indent: (C++: int) +ida_ua.outctx_base_t.clr_gen_label(self) -> None -ida_ua.outctx_base_t.flush_outbuf (method) - flush_outbuf(self, indent=-1) -> bool - Functions to populate the output line array (lnar) Move the contents of the - output buffer to the line array (outbuf->lnar) The kernel augments the outbuf - contents with additional text like the line prefix, user-defined comments, - xrefs, etc at this call. - - @param indent: (C++: int) +ida_ua.outctx_base_t.default_lnnum + index of the most important line in lnar -ida_ua.outctx_base_t.forbid_annotations (method) - forbid_annotations(self) -> int +ida_ua.outctx_base_t.display_voids(self) -> bool -ida_ua.outctx_base_t.force_code (method) - force_code(self) -> bool +ida_ua.outctx_base_t.flush_buf(self, buf: str, indent: int = -1) -> bool + Append contents of 'buf' to the line array. Behaves like flush_outbuf but accepts an arbitrary buffer + -ida_ua.outctx_base_t.gen_block_cmt (method) - gen_block_cmt(self, cmt, color) -> bool - Generate big non-indented comment lines. - - @param cmt: (C++: const char *) comment text. may contain \n characters to denote new lines. should - not contain comment character (;) - @param color: (C++: color_t) color of comment text (one of Color tags) - @return: overflow, lnar_maxsize has been reached +ida_ua.outctx_base_t.flush_outbuf(self, indent: int = -1) -> bool + ------------------------------------------------------------------------- Functions to populate the output line array (lnar) Move the contents of the output buffer to the line array (outbuf->lnar) The kernel augments the outbuf contents with additional text like the line prefix, user-defined comments, xrefs, etc at this call. + -ida_ua.outctx_base_t.gen_border_line (method) - gen_border_line(self, solid=False) -> bool - Generate thin border line. This function does nothing if generation of border - lines is disabled. - - @param solid: (C++: bool) generate solid border line (with =), otherwise with - - @return: overflow, lnar_maxsize has been reached +ida_ua.outctx_base_t.forbid_annotations(self) -> int -ida_ua.outctx_base_t.gen_cmt_line (method) - gen_cmt_line(self, format) -> bool - Generate one non-indented comment line, colored with COLOR_AUTOCMT. - - @param format: (C++: const char *) printf() style format line. The resulting comment line should not - include comment character (;) - @return: overflow, lnar_maxsize has been reached +ida_ua.outctx_base_t.force_code(self) -> bool -ida_ua.outctx_base_t.gen_collapsed_line (method) - gen_collapsed_line(self, format) -> bool - Generate one non-indented comment line, colored with COLOR_COLLAPSED. - - @param format: (C++: const char *) printf() style format line. The resulting comment line should not - include comment character (;) - @return: overflow, lnar_maxsize has been reached +ida_ua.outctx_base_t.gen_block_cmt(self, cmt: str, color: "color_t") -> bool + Generate big non-indented comment lines. + + @param cmt: comment text. may contain \n characters to denote new lines. should not contain comment character (;) + @param color: color of comment text (one of Color tags) + @returns overflow, lnar_maxsize has been reached -ida_ua.outctx_base_t.gen_empty_line (method) - gen_empty_line(self) -> bool - Generate empty line. This function does nothing if generation of empty lines is - disabled. - - @return: overflow, lnar_maxsize has been reached +ida_ua.outctx_base_t.gen_border_line(self, solid: bool = False) -> bool + Generate thin border line. This function does nothing if generation of border lines is disabled. + + @param solid: generate solid border line (with =), otherwise with - + @returns overflow, lnar_maxsize has been reached -ida_ua.outctx_base_t.gen_empty_line_without_annotations (method) - gen_empty_line_without_annotations(self) +ida_ua.outctx_base_t.gen_cmt_line(self, format: str) -> bool + Generate one non-indented comment line, colored with COLOR_AUTOCMT. + + @param format: printf() style format line. The resulting comment line should not include comment character (;) + @returns overflow, lnar_maxsize has been reached -ida_ua.outctx_base_t.gen_printf (method) - gen_printf(self, indent, format) -> bool - printf-like function to add lines to the line array. - - @param indent: (C++: int) indention of the line. if indent == -1, the kernel will indent - the line at idainfo::indent. if indent < 0, -indent will be used - for indention. The first line printed with indent < 0 is - considered as the most important line at the current address. - Usually it is the line with the instruction itself. This line - will be displayed in the cross-reference lists and other places. - If you need to output an additional line before the main line - then pass DEFAULT_INDENT instead of -1. The kernel will know that - your line is not the most important one. - @param format: (C++: const char *) printf style colored line to generate - @return: overflow, lnar_maxsize has been reached +ida_ua.outctx_base_t.gen_collapsed_line(self, format: str) -> bool + Generate one non-indented comment line, colored with COLOR_COLLAPSED. + + @param format: printf() style format line. The resulting comment line should not include comment character (;) + @returns overflow, lnar_maxsize has been reached -ida_ua.outctx_base_t.gen_xref_lines (method) - gen_xref_lines(self) -> bool +ida_ua.outctx_base_t.gen_empty_line(self) -> bool + Generate empty line. This function does nothing if generation of empty lines is disabled. + + @returns overflow, lnar_maxsize has been reached -ida_ua.outctx_base_t.getF (method) - getF(self) -> flags64_t +ida_ua.outctx_base_t.gen_empty_line_without_annotations(self) -> None -ida_ua.outctx_base_t.get_stkvar (method) - get_stkvar(self, arg2, arg3, arg4, arg5) -> member_t * - - @param arg2: op_t const & - @param arg3: uval_t - @param arg4: sval_t * - @param arg5: int * +ida_ua.outctx_base_t.gen_printf(self, indent: int, format: str) -> bool + printf-like function to add lines to the line array. + + @param indent: indention of the line. if indent == -1, the kernel will indent the line at idainfo::indent. if indent < 0, -indent will be used for indention. The first line printed with indent < 0 is considered as the most important line at the current address. Usually it is the line with the instruction itself. This line will be displayed in the cross-reference lists and other places. If you need to output an additional line before the main line then pass DEFAULT_INDENT instead of -1. The kernel will know that your line is not the most important one. + @param format: printf style colored line to generate + @returns overflow, lnar_maxsize has been reached -ida_ua.outctx_base_t.init_lines_array (method) - init_lines_array(self, answers, maxsize) - - @param answers: qstrvec_t * - @param maxsize: int +ida_ua.outctx_base_t.gen_xref_lines(self) -> bool -ida_ua.outctx_base_t.multiline (method) - multiline(self) -> bool +ida_ua.outctx_base_t.getF(self) -> "flags64_t" -ida_ua.outctx_base_t.only_main_line (method) - only_main_line(self) -> bool +ida_ua.outctx_base_t.get_stkvar(self, x: "op_t", v: int, vv: "sval_t *", is_sp_based: "int *", _frame: "tinfo_t") -> "ssize_t" -ida_ua.outctx_base_t.out_addr_tag (method) - out_addr_tag(self, ea) +ida_ua.outctx_base_t.init_lines_array(self, answers: "qstrvec_t *", maxsize: int) -> None + +ida_ua.outctx_base_t.multiline(self) -> bool + +ida_ua.outctx_base_t.only_main_line(self) -> bool + +ida_ua.outctx_base_t.out_addr_tag(self, ea: ida_idaapi.ea_t) -> None Output "address" escape sequence. - - @param ea: (C++: ea_t) -ida_ua.outctx_base_t.out_btoa (method) - out_btoa(self, Word, radix=0) - Output a number with the specified base (binary, octal, decimal, hex) The number - is output without color codes. see also out_long() - - @param Word: (C++: uval_t) - @param radix: (C++: char) +ida_ua.outctx_base_t.out_btoa(self, Word: int, radix: "char" = 0) -> None + Output a number with the specified base (binary, octal, decimal, hex) The number is output without color codes. see also out_long() + -ida_ua.outctx_base_t.out_char (method) - out_char(self, c) - Output one character. The character is output without color codes. see also - out_symbol() - - @param c: (C++: char) +ida_ua.outctx_base_t.out_char(self, c: "char") -> None + Output one character. The character is output without color codes. see also out_symbol() + -ida_ua.outctx_base_t.out_chars (method) - out_chars(self, c, n) +ida_ua.outctx_base_t.out_chars(self, c: "char", n: int) -> None Append a character multiple times. - - @param c: (C++: char) - @param n: (C++: int) -ida_ua.outctx_base_t.out_colored_register_line (method) - out_colored_register_line(self, str) - Output a colored line with register names in it. The register names will be - substituted by user-defined names (regvar_t) Please note that out_tagoff tries - to make substitutions too (when called with COLOR_REG) - - @param str: (C++: const char *) char const * +ida_ua.outctx_base_t.out_colored_register_line(self, str: str) -> None + Output a colored line with register names in it. The register names will be substituted by user-defined names (regvar_t) Please note that out_tagoff tries to make substitutions too (when called with COLOR_REG) + -ida_ua.outctx_base_t.out_keyword (method) - out_keyword(self, str) +ida_ua.outctx_base_t.out_keyword(self, str: str) -> None Output a string with COLOR_KEYWORD color. - - @param str: (C++: const char *) char const * -ida_ua.outctx_base_t.out_line (method) - out_line(self, str, color=0) +ida_ua.outctx_base_t.out_line(self, str: str, color: "color_t" = 0) -> None Output a string with the specified color. - - @param str: (C++: const char *) char const * - @param color: (C++: color_t) -ida_ua.outctx_base_t.out_long (method) - out_long(self, v, radix) - Output a number with appropriate color. Low level function. Use out_value() if - you can. if 'suspop' is set then this function uses COLOR_VOIDOP instead of - COLOR_NUMBER. 'suspop' is initialized: +ida_ua.outctx_base_t.out_long(self, v: int, radix: "char") -> None + Output a number with appropriate color. Low level function. Use out_value() if you can. if 'suspop' is set then this function uses COLOR_VOIDOP instead of COLOR_NUMBER. 'suspop' is initialized: * in out_one_operand() * in ..\ida\gl.cpp (before calling processor_t::d_out()) - @param v: (C++: sval_t) value to output - @param radix: (C++: char) base (2,8,10,16) - -ida_ua.outctx_base_t.out_name_expr (method) - out_name_expr(self, x, ea, off=BADADDR) -> bool - Output a name expression. - @param x: (C++: const op_t &) instruction operand referencing the name expression - @param ea: (C++: ea_t) address to convert to name expression - @param off: (C++: adiff_t) 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 but I discourage it because it prohibits - checks. - @return: true if the name expression has been produced - -ida_ua.outctx_base_t.out_printf (method) - out_printf(self, format) -> size_t - Functions to append text to the current output buffer (outbuf) Append a - formatted string to the output string. - @param format: (C++: const char *) char const * - @return: the number of characters appended + @param v: value to output + @param radix: base (2,8,10,16) -ida_ua.outctx_base_t.out_register (method) - out_register(self, str) +ida_ua.outctx_base_t.out_lvar(self, name: str, width: int = -1) -> None + Output local variable name with COLOR_LOCNAME color. + +ida_ua.outctx_base_t.out_name_expr(self, *args) -> bool + Output a name expression. + + @param x: instruction operand referencing the name expression + @param ea: address to convert to name 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 but I discourage it because it prohibits checks. + @returns true if the name expression has been produced + +ida_ua.outctx_base_t.out_printf(self, format: str) -> "size_t" + ------------------------------------------------------------------------- Functions to append text to the current output buffer (outbuf) Append a formatted string to the output string. + + @returns the number of characters appended + +ida_ua.outctx_base_t.out_register(self, str: str) -> None Output a character with COLOR_REG color. - - @param str: (C++: const char *) char const * -ida_ua.outctx_base_t.out_spaces (method) - out_spaces(self, len) +ida_ua.outctx_base_t.out_spaces(self, len: "ssize_t") -> None Appends spaces to outbuf until its tag_strlen becomes 'len'. - - @param len: (C++: ssize_t) -ida_ua.outctx_base_t.out_symbol (method) - out_symbol(self, c) +ida_ua.outctx_base_t.out_symbol(self, c: "char") -> None Output a character with COLOR_SYMBOL color. - - @param c: (C++: char) -ida_ua.outctx_base_t.out_tagoff (method) - out_tagoff(self, tag) +ida_ua.outctx_base_t.out_tagoff(self, tag: "color_t") -> None Output "turn color off" escape sequence. - - @param tag: (C++: color_t) -ida_ua.outctx_base_t.out_tagon (method) - out_tagon(self, tag) +ida_ua.outctx_base_t.out_tagon(self, tag: "color_t") -> None Output "turn color on" escape sequence. - - @param tag: (C++: color_t) -ida_ua.outctx_base_t.out_value (method) - out_value(self, x, outf=0) -> flags64_t - Output immediate value. Try to use this function to output all constants of - instruction operands. This function outputs a number from x.addr or x.value in - the form determined by F. It outputs colored text. - - @param x: (C++: const op_t &) value to output - @param outf: (C++: int) Output value flags - @return: flags of the output value, otherwise: -1 if printed a number with - COLOR_ERROR 0 if printed a nice number or character or segment or enum +ida_ua.outctx_base_t.out_value(self, x: "op_t", outf: int = 0) -> "flags64_t" + Output immediate value. Try to use this function to output all constants of instruction operands. This function outputs a number from x.addr or x.value in the form determined by F. It outputs colored text. + + @param x: value to output + @param outf: Output value flags + @returns flags of the output value, otherwise: + @retval -1: if printed a number with COLOR_ERROR + @retval 0: if printed a nice number or character or segment or enum -ida_ua.outctx_base_t.print_label_now (method) - print_label_now(self) -> bool +ida_ua.outctx_base_t.outbuf + buffer for the current output line once ready, it is moved to lnar + -ida_ua.outctx_base_t.restore_ctxflags (method) - restore_ctxflags(self, saved_flags) - - @param saved_flags: int +ida_ua.outctx_base_t.print_label_now(self) -> bool -ida_ua.outctx_base_t.retrieve_cmt (method) - retrieve_cmt(self) -> ssize_t +ida_ua.outctx_base_t.restore_ctxflags(self, saved_flags: int) -> None -ida_ua.outctx_base_t.retrieve_name (method) - retrieve_name(self, arg2, arg3) -> ssize_t - - @param arg2: qstring * - @param arg3: color_t * +ida_ua.outctx_base_t.retrieve_cmt(self) -> "ssize_t" -ida_ua.outctx_base_t.set_comment_addr (method) - set_comment_addr(self, ea) - - @param ea: ea_t +ida_ua.outctx_base_t.retrieve_name(self, arg2: str, arg3: "color_t *") -> "ssize_t" -ida_ua.outctx_base_t.set_dlbind_opnd (method) - set_dlbind_opnd(self) +ida_ua.outctx_base_t.set_comment_addr(self, ea: ida_idaapi.ea_t) -> None -ida_ua.outctx_base_t.set_gen_cmt (method) - set_gen_cmt(self, on=True) - - @param on: bool +ida_ua.outctx_base_t.set_dlbind_opnd(self) -> None -ida_ua.outctx_base_t.set_gen_demangled_label (method) - set_gen_demangled_label(self) +ida_ua.outctx_base_t.set_gen_cmt(self, on: bool = True) -> None -ida_ua.outctx_base_t.set_gen_label (method) - set_gen_label(self) +ida_ua.outctx_base_t.set_gen_demangled_label(self) -> None -ida_ua.outctx_base_t.set_gen_xrefs (method) - set_gen_xrefs(self, on=True) - - @param on: bool +ida_ua.outctx_base_t.set_gen_label(self) -> None -ida_ua.outctx_base_t.setup_outctx (method) - setup_outctx(self, prefix, makeline_flags) +ida_ua.outctx_base_t.set_gen_xrefs(self, on: bool = True) -> None + +ida_ua.outctx_base_t.setup_outctx(self, prefix: str, makeline_flags: int) -> None Initialization; normally used only by the kernel. - - @param prefix: (C++: const char *) char const * - @param makeline_flags: (C++: int) -ida_ua.outctx_base_t.stack_view (method) - stack_view(self) -> bool +ida_ua.outctx_base_t.stack_view(self) -> bool -ida_ua.outctx_base_t.term_outctx (method) - term_outctx(self, prefix=None) -> int - Finalize the output context. - - @param prefix: (C++: const char *) char const * - @return: the number of generated lines. +ida_ua.outctx_base_t.term_outctx(self, prefix: str = None) -> int + Finalize the output context. + + @returns the number of generated lines. -ida_ua.outctx_base_t__from_ptrval__ (function) - outctx_base_t__from_ptrval__(ptrval) -> outctx_base_t - - @param ptrval: size_t +ida_ua.outctx_base_t__from_ptrval__(ptrval: "size_t") -> "outctx_base_t *" -ida_ua.outctx_t (class) - Proxy of C++ outctx_t class. +ida_ua.outctx_t -ida_ua.outctx_t.__init__ (method) +ida_ua.outctx_t.__init__(self, *args, **kwargs) -ida_ua.outctx_t.gen_func_footer (method) - gen_func_footer(self, pfn) - - @param pfn: func_t const * +ida_ua.outctx_t.gen_func_footer(self, pfn: "func_t const *") -> None -ida_ua.outctx_t.gen_func_header (method) - gen_func_header(self, pfn) - - @param pfn: func_t * +ida_ua.outctx_t.gen_func_header(self, pfn: "func_t *") -> None -ida_ua.outctx_t.gen_header (method) - gen_header(self, flags=((1 << 0)|(1 << 1)), proc_name=None, proc_flavour=None) - - @param flags: int - @param proc_name: char const * - @param proc_flavour: char const * +ida_ua.outctx_t.gen_header(self, *args) -> None -ida_ua.outctx_t.gen_header_extra (method) - gen_header_extra(self) +ida_ua.outctx_t.gen_header_extra(self) -> None -ida_ua.outctx_t.gen_xref_lines (method) - gen_xref_lines(self) -> bool +ida_ua.outctx_t.gen_xref_lines(self) -> bool -ida_ua.outctx_t.out_btoa (method) - out_btoa(self, Word, radix=0) - Output a number with the specified base (binary, octal, decimal, hex) The number - is output without color codes. see also out_long() - - @param Word: (C++: uval_t) - @param radix: (C++: char) +ida_ua.outctx_t.out_btoa(self, Word: int, radix: "char" = 0) -> None + Output a number with the specified base (binary, octal, decimal, hex) The number is output without color codes. see also out_long() + -ida_ua.outctx_t.out_custom_mnem (method) - out_custom_mnem(self, mnem, width=8, postfix=None) - Output custom mnemonic for 'insn'. E.g. if it should differ from the one in - 'ph.instruc'. This function outputs colored text. See out_mnem - - @param mnem: (C++: const char *) custom mnemonic - @param width: (C++: int) width of field with mnemonic. if < 0, then 'postfix' will be - output before the mnemonic, i.e. as a prefix - @param postfix: (C++: const char *) optional postfix added to 'mnem' +ida_ua.outctx_t.out_custom_mnem(self, mnem: str, width: int = 8, postfix: str = None) -> None + Output custom mnemonic for 'insn'. E.g. if it should differ from the one in 'ph.instruc'. This function outputs colored text. See out_mnem + + @param mnem: custom mnemonic + @param width: width of field with mnemonic. if < 0, then 'postfix' will be output before the mnemonic, i.e. as a prefix + @param postfix: optional postfix added to 'mnem' -ida_ua.outctx_t.out_data (method) - out_data(self, analyze_only) - - @param analyze_only: bool +ida_ua.outctx_t.out_data(self, analyze_only: bool) -> None -ida_ua.outctx_t.out_fcref_names (method) - out_fcref_names(self) - Print addresses referenced *from* the specified address as commented symbolic - names. This function is used to show, for example, multiple callees of an - indirect call. This function outputs colored text. +ida_ua.outctx_t.out_fcref_names(self) -> None + Print addresses referenced *from* the specified address as commented symbolic names. This function is used to show, for example, multiple callees of an indirect call. This function outputs colored text. + -ida_ua.outctx_t.out_immchar_cmts (method) - out_immchar_cmts(self) - Print all operand values as commented character constants. This function is used - to comment void operands with their representation in the form of character - constants. This function outputs colored text. +ida_ua.outctx_t.out_immchar_cmts(self) -> None + Print all operand values as commented character constants. This function is used to comment void operands with their representation in the form of character constants. This function outputs colored text. + -ida_ua.outctx_t.out_mnem (method) - out_mnem(self, width=8, postfix=None) - Output instruction mnemonic for 'insn' using information in 'ph.instruc' array. - This function outputs colored text. It should be called from - processor_t::ev_out_insn() or processor_t::ev_out_mnem() handler. It will output - at least one space after the instruction. mnemonic even if the specified 'width' - is not enough. - - @param width: (C++: int) width of field with mnemonic. if < 0, then 'postfix' will be - output before the mnemonic, i.e. as a prefix - @param postfix: (C++: const char *) optional postfix added to the instruction mnemonic +ida_ua.outctx_t.out_mnem(self, width: int = 8, postfix: str = None) -> None + Output instruction mnemonic for 'insn' using information in 'ph.instruc' array. This function outputs colored text. It should be called from processor_t::ev_out_insn() or processor_t::ev_out_mnem() handler. It will output at least one space after the instruction. mnemonic even if the specified 'width' is not enough. + + @param width: width of field with mnemonic. if < 0, then 'postfix' will be output before the mnemonic, i.e. as a prefix + @param postfix: optional postfix added to the instruction mnemonic -ida_ua.outctx_t.out_mnemonic (method) - out_mnemonic(self) - Output instruction mnemonic using information in 'insn'. It should be called - from processor_t::ev_out_insn() and it will call processor_t::ev_out_mnem() or - out_mnem. This function outputs colored text. +ida_ua.outctx_t.out_mnemonic(self) -> None + Output instruction mnemonic using information in 'insn'. It should be called from processor_t::ev_out_insn() and it will call processor_t::ev_out_mnem() or out_mnem. This function outputs colored text. + -ida_ua.outctx_t.out_one_operand (method) - out_one_operand(self, n) -> bool - Use this function to output an operand of an instruction. This function checks - for the existence of a manually defined operand and will output it if it exists. - It should be called from processor_t::ev_out_insn() and it will call - processor_t::ev_out_operand(). This function outputs colored text. - - @param n: (C++: int) 0..UA_MAXOP-1 operand number +ida_ua.outctx_t.out_one_operand(self, n: int) -> bool + Use this function to output an operand of an instruction. This function checks for the existence of a manually defined operand and will output it if it exists. It should be called from processor_t::ev_out_insn() and it will call processor_t::ev_out_operand(). This function outputs colored text. + + @param n: 0..UA_MAXOP-1 operand number @retval 1: operand is displayed @retval 0: operand is hidden -ida_ua.outctx_t.out_specea (method) - out_specea(self, segtype) -> bool - - @param segtype: uchar +ida_ua.outctx_t.out_specea(self, segtype: "uchar") -> bool -ida_ua.outctx_t.retrieve_cmt (method) - retrieve_cmt(self) -> ssize_t +ida_ua.outctx_t.retrieve_cmt(self) -> "ssize_t" -ida_ua.outctx_t.retrieve_name (method) - retrieve_name(self, arg2, arg3) -> ssize_t - - @param arg2: qstring * - @param arg3: color_t * +ida_ua.outctx_t.retrieve_name(self, arg2: str, arg3: "color_t *") -> "ssize_t" -ida_ua.outctx_t.set_bin_state (method) - set_bin_state(self, value) - - @param value: int +ida_ua.outctx_t.set_bin_state(self, value: int) -> None -ida_ua.outctx_t.setup_outctx (method) - setup_outctx(self, prefix, flags) +ida_ua.outctx_t.setup_outctx(self, prefix: str, flags: int) -> None Initialization; normally used only by the kernel. - - @param prefix: (C++: const char *) char const * - @param flags: int -ida_ua.outctx_t.term_outctx (method) - term_outctx(self, prefix=None) -> int - Finalize the output context. - - @param prefix: (C++: const char *) char const * - @return: the number of generated lines. +ida_ua.outctx_t.term_outctx(self, prefix: str = None) -> int + Finalize the output context. + + @returns the number of generated lines. -ida_ua.outctx_t__from_ptrval__ (function) - outctx_t__from_ptrval__(ptrval) -> outctx_t - - @param ptrval: size_t +ida_ua.outctx_t__from_ptrval__(ptrval: "size_t") -> "outctx_t *" -ida_ua.print_insn_mnem (function) - print_insn_mnem(ea) -> str - Print instruction mnemonics. - - @param ea: (C++: ea_t) linear address of the instruction - @return: success +ida_ua.print_insn_mnem(ea: ida_idaapi.ea_t) -> str + Print instruction mnemonics. + + @param ea: linear address of the instruction + @returns success -ida_ua.print_operand (function) - print_operand(ea, n, getn_flags=0, newtype=None) -> str - Generate text representation for operand #n. This function will generate the - text representation of the specified operand (includes color codes.) - - @param ea: (C++: ea_t) the item address (instruction or data) - @param n: (C++: int) 0..UA_MAXOP-1 operand number, meaningful only for instructions - @param getn_flags: (C++: int) Name expression flags Currently only GETN_NODUMMY is - accepted. - @param newtype: (C++: struct printop_t *) if specified, print the operand using the specified type - @return: success +ida_ua.print_operand(ea: ida_idaapi.ea_t, n: int, getn_flags: int = 0, newtype: "printop_t" = None) -> str + Generate text representation for operand #n. This function will generate the text representation of the specified operand (includes color codes.) + + @param ea: the item address (instruction or data) + @param n: 0..UA_MAXOP-1 operand number, meaningful only for instructions + @param getn_flags: Name expression flags Currently only GETN_NODUMMY is accepted. + @param newtype: if specified, print the operand using the specified type + @returns success -ida_xref (module) +ida_xref Functions that deal with cross-references. - There are 2 types of xrefs: CODE and DATA references. All xrefs are kept in the - bTree except ordinary execution flow to the next instruction. Ordinary execution - flow to the next instruction is kept in flags (see bytes.hpp) - - The source address of a cross-reference must be an item head (is_head) or a - structure member id. - - Cross-references are automatically sorted. + There are 2 types of xrefs: CODE and DATA references. All xrefs are kept in the bTree except ordinary execution flow to the next instruction. Ordinary execution flow to the next instruction is kept in flags (see bytes.hpp) + The source address of a cross-reference must be an item head (is_head) or a structure member id. + Cross-references are automatically sorted. + -ida_xref.XREF_ALL (variable) - return all references - -ida_xref.XREF_BASE (variable) +ida_xref.XREF_BASE Reference to the base part of an offset. -ida_xref.XREF_DATA (variable) - return data references only +ida_xref.XREF_CODE + return only code references (fl_...) -ida_xref.XREF_FAR (variable) - don't return ordinary flow xrefs +ida_xref.XREF_DATA + return only data references (dr_...) -ida_xref.XREF_MASK (variable) +ida_xref.XREF_EA + return only program addresses + +ida_xref.XREF_FLOW + return all references, including ordinary flow xrefs + +ida_xref.XREF_MASK Mask to get xref type. -ida_xref.XREF_PASTEND (variable) - Reference is past item. This bit may be passed to add_dref() functions but it - won't be saved in the database. It will prevent the destruction of eventual - alignment directives. +ida_xref.XREF_NOFLOW + skip ordinary flow xrefs (code xrefs to the next insn) + -ida_xref.XREF_TAIL (variable) +ida_xref.XREF_PASTEND + Reference is past item. This bit may be passed to add_dref() functions but it won't be saved in the database. It will prevent the destruction of eventual alignment directives. + + +ida_xref.XREF_TAIL Reference to tail byte in extrn symbols. -ida_xref.XREF_USER (variable) - User specified xref. This xref will not be deleted by IDA. This bit should be - combined with the existing xref types (cref_t & dref_t) Cannot be used for fl_F - xrefs +ida_xref.XREF_TID + return only type ids. XREF_EA and XREF_TID are exclusive, only one of them can be specified + -ida_xref.add_cref (function) - add_cref(frm, to, type) -> bool - Create a code cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction - @param to: (C++: ea_t) linear address of referenced instruction - @param type: (C++: cref_t) cross-reference type - @return: success +ida_xref.XREF_USER + User specified xref. This xref will not be deleted by IDA. This bit should be combined with the existing xref types (cref_t & dref_t) Cannot be used for fl_F xrefs + -ida_xref.add_dref (function) - add_dref(frm, to, type) -> bool - Create a data cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @param to: (C++: ea_t) linear address of referenced data - @param type: (C++: dref_t) cross-reference type - @return: success (may fail if user-defined xref exists from->to) +ida_xref.add_cref(frm: ida_idaapi.ea_t, to: ida_idaapi.ea_t, type: "cref_t") -> bool + Create a code cross-reference. + + @param to: linear address of referenced instruction + @param type: cross-reference type + @returns success -ida_xref.calc_switch_cases (function) - calc_switch_cases(ea, si) -> cases_and_targets_t +ida_xref.add_dref(frm: ida_idaapi.ea_t, to: ida_idaapi.ea_t, type: "dref_t") -> bool + Create a data cross-reference. + + @param to: linear address of referenced data + @param type: cross-reference type + @returns success (may fail if user-defined xref exists from->to) + +ida_xref.calc_switch_cases(ea, si) Get information about a switch's cases. The returned information can be used as follows: @@ -67703,164 +46401,75 @@ ida_xref.calc_switch_cases (function) @return: a structure with 2 members: 'cases', and 'targets'. -ida_xref.cases_and_targets_t (class) - Proxy of C++ cases_and_targets_t class. +ida_xref.cases_and_targets_t -ida_xref.cases_and_targets_t.__init__ (method) - __init__(self) -> cases_and_targets_t +ida_xref.cases_and_targets_t.__init__(self) -ida_xref.casevec_t (class) - Proxy of C++ qvector< qvector< sval_t > > class. +ida_xref.casevec_t -ida_xref.casevec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< qvector< signed-ea-like-numeric-type > > const & +ida_xref.casevec_t.__eq__(self, r: "casevec_t") -> bool -ida_xref.casevec_t.__getitem__ (method) - __getitem__(self, i) -> qvector< signed-ea-like-numeric-type > const & - - @param i: size_t +ida_xref.casevec_t.__getitem__(self, i: "size_t") -> "qvector< long long > const &" -ida_xref.casevec_t.__init__ (method) - __init__(self) -> casevec_t - __init__(self, x) -> casevec_t - - @param x: qvector< qvector< signed-ea-like-numeric-type > > const & +ida_xref.casevec_t.__init__(self, *args) -ida_xref.casevec_t.__len__ (method) - __len__(self) -> size_t +ida_xref.casevec_t.__len__(self) -> "size_t" -ida_xref.casevec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< qvector< signed-ea-like-numeric-type > > const & +ida_xref.casevec_t.__ne__(self, r: "casevec_t") -> bool -ida_xref.casevec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: qvector< signed-ea-like-numeric-type > const & +ida_xref.casevec_t.__setitem__(self, i: "size_t", v: "qvector< long long > const &") -> None -ida_xref.casevec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: qvector< signed-ea-like-numeric-type > const & +ida_xref.casevec_t._del(self, x: "qvector< long long > const &") -> bool -ida_xref.casevec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: qvector< signed-ea-like-numeric-type > const & +ida_xref.casevec_t.add_unique(self, x: "qvector< long long > const &") -> bool -ida_xref.casevec_t.at (method) - at(self, _idx) -> qvector< signed-ea-like-numeric-type > const & - - @param _idx: size_t +ida_xref.casevec_t.append(self, x: "qvector< long long > const &") -> None -ida_xref.casevec_t.begin (method) - begin(self) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - begin(self) -> qvector< qvector< signed-ea-like-numeric-type > >::const_iterator +ida_xref.casevec_t.at(self, _idx: "size_t") -> "qvector< long long > const &" -ida_xref.casevec_t.capacity (method) - capacity(self) -> size_t +ida_xref.casevec_t.begin(self, *args) -> "qvector< qvector< long long > >::const_iterator" -ida_xref.casevec_t.clear (method) - clear(self) +ida_xref.casevec_t.capacity(self) -> "size_t" -ida_xref.casevec_t.empty (method) - empty(self) -> bool +ida_xref.casevec_t.clear(self) -> None -ida_xref.casevec_t.end (method) - end(self) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - end(self) -> qvector< qvector< signed-ea-like-numeric-type > >::const_iterator +ida_xref.casevec_t.empty(self) -> bool -ida_xref.casevec_t.erase (method) - erase(self, it) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param it: qvector< qvector< signed-ea-like-numeric-type > >::iterator - - erase(self, first, last) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param first: qvector< qvector< signed-ea-like-numeric-type > >::iterator - @param last: qvector< qvector< signed-ea-like-numeric-type > >::iterator +ida_xref.casevec_t.end(self, *args) -> "qvector< qvector< long long > >::const_iterator" -ida_xref.casevec_t.extract (method) - extract(self) -> qvector< signed-ea-like-numeric-type > * +ida_xref.casevec_t.erase(self, *args) -> "qvector< qvector< long long > >::iterator" -ida_xref.casevec_t.find (method) - find(self, x) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param x: qvector< signed-ea-like-numeric-type > const & - - find(self, x) -> qvector< qvector< signed-ea-like-numeric-type > >::const_iterator - - @param x: qvector< signed-ea-like-numeric-type > const & +ida_xref.casevec_t.extend(self, x: "casevec_t") -> None -ida_xref.casevec_t.grow (method) - grow(self, x=qvector< signed-ea-like-numeric-type >()) - - @param x: qvector< signed-ea-like-numeric-type > const & +ida_xref.casevec_t.extract(self) -> "qvector< long long > *" -ida_xref.casevec_t.has (method) - has(self, x) -> bool - - @param x: qvector< signed-ea-like-numeric-type > const & +ida_xref.casevec_t.find(self, *args) -> "qvector< qvector< long long > >::const_iterator" -ida_xref.casevec_t.inject (method) - inject(self, s, len) - - @param s: qvector< signed-ea-like-numeric-type > * - @param len: size_t +ida_xref.casevec_t.grow(self, *args) -> None -ida_xref.casevec_t.insert (method) - insert(self, it, x) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param it: qvector< qvector< signed-ea-like-numeric-type > >::iterator - @param x: qvector< signed-ea-like-numeric-type > const & +ida_xref.casevec_t.has(self, x: "qvector< long long > const &") -> bool -ida_xref.casevec_t.pop_back (method) - pop_back(self) +ida_xref.casevec_t.inject(self, s: "qvector< long long > *", len: "size_t") -> None -ida_xref.casevec_t.push_back (method) - push_back(self, x) - - @param x: qvector< signed-ea-like-numeric-type > const & - - push_back(self) -> qvector< signed-ea-like-numeric-type > & +ida_xref.casevec_t.insert(self, it: "qvector< qvector< long long > >::iterator", x: "qvector< long long > const &") -> "qvector< qvector< long long > >::iterator" -ida_xref.casevec_t.qclear (method) - qclear(self) +ida_xref.casevec_t.pop_back(self) -> None -ida_xref.casevec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t +ida_xref.casevec_t.push_back(self, *args) -> "qvector< long long > &" -ida_xref.casevec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: qvector< signed-ea-like-numeric-type > const & - - resize(self, _newsize) - - @param _newsize: size_t +ida_xref.casevec_t.qclear(self) -> None -ida_xref.casevec_t.size (method) - size(self) -> size_t +ida_xref.casevec_t.reserve(self, cnt: "size_t") -> None -ida_xref.casevec_t.swap (method) - swap(self, r) - - @param r: qvector< qvector< signed-ea-like-numeric-type > > & +ida_xref.casevec_t.resize(self, *args) -> None -ida_xref.casevec_t.truncate (method) - truncate(self) +ida_xref.casevec_t.size(self) -> "size_t" -ida_xref.create_switch_table (function) - create_switch_table(ea, si) -> bool +ida_xref.casevec_t.swap(self, r: "casevec_t") -> None + +ida_xref.casevec_t.truncate(self) -> None + +ida_xref.create_switch_table(ea, si) Create switch table from the switch information @param ea: address of the 'indirect jump' instruction @@ -67868,8 +46477,7 @@ ida_xref.create_switch_table (function) @return: Boolean -ida_xref.create_switch_xrefs (function) - create_switch_xrefs(ea, si) -> bool +ida_xref.create_switch_xrefs(ea, si) This function creates xrefs from the indirect jump. Usually there is no need to call this function directly because the kernel @@ -67882,375 +46490,244 @@ ida_xref.create_switch_xrefs (function) @return: Boolean -ida_xref.del_cref (function) - del_cref(frm, to, expand) -> bool - Delete a code cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction - @param to: (C++: ea_t) linear address of referenced instruction - @param expand: (C++: bool) policy to delete the referenced instruction +ida_xref.del_cref(frm: ida_idaapi.ea_t, to: ida_idaapi.ea_t, expand: bool) -> bool + Delete a code cross-reference. + + @param to: linear address of referenced instruction + @param expand: policy to delete the referenced instruction * 1: plan to delete the referenced instruction if it has no more references. - * 0: don't delete the referenced instruction even if no more cross-references - point to it + * 0: don't delete the referenced instruction even if no more cross-references point to it @retval true: if the referenced instruction will be deleted -ida_xref.del_dref (function) - del_dref(frm, to) - Delete a data cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @param to: (C++: ea_t) linear address of referenced data +ida_xref.del_dref(frm: ida_idaapi.ea_t, to: ida_idaapi.ea_t) -> None + Delete a data cross-reference. + + @param to: linear address of referenced data -ida_xref.delete_switch_table (function) - delete_switch_table(jump_ea, si) - - @param jump_ea: ea_t - @param si: switch_info_t const & +ida_xref.delete_switch_table(jump_ea: ida_idaapi.ea_t, si: "switch_info_t") -> None -ida_xref.dr_I (variable) - Informational (a derived java class references its base class informationally) +ida_xref.dr_I + Informational (a derived java class references its base class informationally) + -ida_xref.dr_O (variable) - Offset The reference uses 'offset' of data rather than its value OR The - reference appeared because the "OFFSET" flag of instruction is set. The meaning - of this type is IDP dependent. +ida_xref.dr_O + Offset The reference uses 'offset' of data rather than its value OR The reference appeared because the "OFFSET" flag of instruction is set. The meaning of this type is IDP dependent. + -ida_xref.dr_R (variable) +ida_xref.dr_R Read access. -ida_xref.dr_S (variable) +ida_xref.dr_S Reference to enum member (symbolic constant) -ida_xref.dr_T (variable) - Text (for forced operands only) Name of data is used in manual operand +ida_xref.dr_T + Text (for forced operands only) Name of data is used in manual operand + -ida_xref.dr_U (variable) - Unknown - for compatibility with old versions. Should not be used anymore. +ida_xref.dr_U + Unknown - for compatibility with old versions. Should not be used anymore. + -ida_xref.dr_W (variable) +ida_xref.dr_W Write access. -ida_xref.fl_CF (variable) - Call Far This xref creates a function at the referenced location +ida_xref.fl_CF + Call Far This xref creates a function at the referenced location + -ida_xref.fl_CN (variable) - Call Near This xref creates a function at the referenced location +ida_xref.fl_CN + Call Near This xref creates a function at the referenced location + -ida_xref.fl_F (variable) - Ordinary flow: used to specify execution flow to the next instruction. +ida_xref.fl_F + Ordinary flow: used to specify execution flow to the next instruction. + -ida_xref.fl_JF (variable) +ida_xref.fl_JF Jump Far. -ida_xref.fl_JN (variable) +ida_xref.fl_JN Jump Near. -ida_xref.fl_U (variable) - unknown - for compatibility with old versions. Should not be used anymore. +ida_xref.fl_U + unknown - for compatibility with old versions. Should not be used anymore. + -ida_xref.fl_USobsolete (variable) +ida_xref.fl_USobsolete User specified (obsolete) -ida_xref.get_first_cref_from (function) - get_first_cref_from(frm) -> ea_t - Get first instruction referenced from the specified instruction. If the - specified instruction passes execution to the next instruction then the next - instruction is returned. Otherwise the lowest referenced address is returned - (remember that xrefs are kept sorted!). - - @param from: (C++: ea_t) linear address of referencing instruction - @return: first referenced address. If the specified instruction doesn't - reference to other instructions then returns BADADDR. +ida_xref.get_first_cref_from(frm: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get first instruction referenced from the specified instruction. If the specified instruction passes execution to the next instruction then the next instruction is returned. Otherwise the lowest referenced address is returned (remember that xrefs are kept sorted!). + + @returns first referenced address. If the specified instruction doesn't reference to other instructions then returns BADADDR. -ida_xref.get_first_cref_to (function) - get_first_cref_to(to) -> ea_t - Get first instruction referencing to the specified instruction. If the specified - instruction may be executed immediately after its previous instruction then the - previous instruction is returned. Otherwise the lowest referencing address is - returned. (remember that xrefs are kept sorted!). - - @param to: (C++: ea_t) linear address of referenced instruction - @return: linear address of the first referencing instruction or BADADDR. +ida_xref.get_first_cref_to(to: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get first instruction referencing to the specified instruction. If the specified instruction may be executed immediately after its previous instruction then the previous instruction is returned. Otherwise the lowest referencing address is returned. (remember that xrefs are kept sorted!). + + @param to: linear address of referenced instruction + @returns linear address of the first referencing instruction or BADADDR. -ida_xref.get_first_dref_from (function) - get_first_dref_from(frm) -> ea_t - Get first data referenced from the specified address. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @return: linear address of first (lowest) data referenced from the specified - address. Return BADADDR if the specified instruction/data doesn't - reference to anything. +ida_xref.get_first_dref_from(frm: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get first data referenced from the specified address. + + @returns linear address of first (lowest) data referenced from the specified address. Return BADADDR if the specified instruction/data doesn't reference to anything. -ida_xref.get_first_dref_to (function) - get_first_dref_to(to) -> ea_t - Get address of instruction/data referencing to the specified data. - - @param to: (C++: ea_t) linear address of referencing instruction or data - @return: BADADDR if nobody refers to the specified data. +ida_xref.get_first_dref_to(to: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get address of instruction/data referencing to the specified data. + + @param to: linear address of referencing instruction or data + @returns BADADDR if nobody refers to the specified data. -ida_xref.get_first_fcref_from (function) - get_first_fcref_from(frm) -> ea_t - - @param from: ea_t +ida_xref.get_first_fcref_from(frm: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_xref.get_first_fcref_to (function) - get_first_fcref_to(to) -> ea_t - - @param to: ea_t +ida_xref.get_first_fcref_to(to: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_xref.get_next_cref_from (function) - get_next_cref_from(frm, current) -> ea_t - Get next instruction referenced from the specified instruction. - - @param from: (C++: ea_t) linear address of referencing instruction - @param current: (C++: ea_t) linear address of current referenced instruction This value is - returned by get_first_cref_from() or previous call to - get_next_cref_from() functions. - @return: next referenced address or BADADDR. +ida_xref.get_next_cref_from(frm: ida_idaapi.ea_t, current: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get next instruction referenced from the specified instruction. + + @param current: linear address of current referenced instruction This value is returned by get_first_cref_from() or previous call to get_next_cref_from() functions. + @returns next referenced address or BADADDR. -ida_xref.get_next_cref_to (function) - get_next_cref_to(to, current) -> ea_t - Get next instruction referencing to the specified instruction. - - @param to: (C++: ea_t) linear address of referenced instruction - @param current: (C++: ea_t) linear address of current referenced instruction This value is - returned by get_first_cref_to() or previous call to - get_next_cref_to() functions. - @return: linear address of the next referencing instruction or BADADDR. +ida_xref.get_next_cref_to(to: ida_idaapi.ea_t, current: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get next instruction referencing to the specified instruction. + + @param to: linear address of referenced instruction + @param current: linear address of current referenced instruction This value is returned by get_first_cref_to() or previous call to get_next_cref_to() functions. + @returns linear address of the next referencing instruction or BADADDR. -ida_xref.get_next_dref_from (function) - get_next_dref_from(frm, current) -> ea_t - Get next data referenced from the specified address. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @param current: (C++: ea_t) linear address of current referenced data. This value is - returned by get_first_dref_from() or previous call to - get_next_dref_from() functions. - @return: linear address of next data or BADADDR. +ida_xref.get_next_dref_from(frm: ida_idaapi.ea_t, current: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get next data referenced from the specified address. + + @param current: linear address of current referenced data. This value is returned by get_first_dref_from() or previous call to get_next_dref_from() functions. + @returns linear address of next data or BADADDR. -ida_xref.get_next_dref_to (function) - get_next_dref_to(to, current) -> ea_t - Get address of instruction/data referencing to the specified data - - @param to: (C++: ea_t) linear address of referencing instruction or data - @param current: (C++: ea_t) current linear address. This value is returned by - get_first_dref_to() or previous call to get_next_dref_to() - functions. - @return: BADADDR if nobody refers to the specified data. +ida_xref.get_next_dref_to(to: ida_idaapi.ea_t, current: ida_idaapi.ea_t) -> ida_idaapi.ea_t + Get address of instruction/data referencing to the specified data + + @param to: linear address of referencing instruction or data + @param current: current linear address. This value is returned by get_first_dref_to() or previous call to get_next_dref_to() functions. + @returns BADADDR if nobody refers to the specified data. -ida_xref.get_next_fcref_from (function) - get_next_fcref_from(frm, current) -> ea_t - - @param from: ea_t - @param current: ea_t +ida_xref.get_next_fcref_from(frm: ida_idaapi.ea_t, current: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_xref.get_next_fcref_to (function) - get_next_fcref_to(to, current) -> ea_t - - @param to: ea_t - @param current: ea_t +ida_xref.get_next_fcref_to(to: ida_idaapi.ea_t, current: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_xref.has_external_refs (function) - has_external_refs(pfn, ea) -> bool +ida_xref.has_external_refs(pfn: "func_t *", ea: ida_idaapi.ea_t) -> bool Does 'ea' have references from outside of 'pfn'? - - @param pfn: (C++: func_t *) - @param ea: (C++: ea_t) -ida_xref.xrefblk_t (class) - Proxy of C++ xrefblk_t class. +ida_xref.has_jump_or_flow_xref(ea: ida_idaapi.ea_t) -> bool + Are there jump or flow references to EA? -ida_xref.xrefblk_t.__init__ (method) - __init__(self) -> xrefblk_t +ida_xref.xrefblk_t -ida_xref.xrefblk_t.crefs_from (method) +ida_xref.xrefblk_t.__init__(self) + +ida_xref.xrefblk_t.crefs_from(self, ea) Provide an iterator on code references from ea including flow references -ida_xref.xrefblk_t.crefs_to (method) +ida_xref.xrefblk_t.crefs_to(self, ea) Provide an iterator on code references to ea including flow references -ida_xref.xrefblk_t.drefs_from (method) +ida_xref.xrefblk_t.drefs_from(self, ea) Provide an iterator on data references from ea -ida_xref.xrefblk_t.drefs_to (method) +ida_xref.xrefblk_t.drefs_to(self, ea) Provide an iterator on data references to ea -ida_xref.xrefblk_t.fcrefs_from (method) +ida_xref.xrefblk_t.fcrefs_from(self, ea) Provide an iterator on code references from ea -ida_xref.xrefblk_t.fcrefs_to (method) +ida_xref.xrefblk_t.fcrefs_to(self, ea) Provide an iterator on code references to ea -ida_xref.xrefblk_t.first_from (method) - first_from(self, _from, flags) -> bool - Get first xref from the given address (store in to) - - @param _from: (C++: ea_t) - @param flags: (C++: int) +ida_xref.xrefblk_t.first_from(self, _from: ida_idaapi.ea_t, flags: int = 0) -> bool -ida_xref.xrefblk_t.first_to (method) - first_to(self, _to, flags) -> bool - Get xref to given address (store in from) - - @param _to: (C++: ea_t) - @param flags: (C++: int) +ida_xref.xrefblk_t.first_to(self, _to: ida_idaapi.ea_t, flags: int = 0) -> bool -ida_xref.xrefblk_t.iscode (variable) - 1-is code reference; 0-is data reference +ida_xref.xrefblk_t.iscode + is code reference (cref_t)? otherwise it is a data reference (dref_t) + -ida_xref.xrefblk_t.next_from (method) - next_from(self) -> bool - Get xref from '_from' that comes after '_to'. - next_from(self, _from, _to, flags) -> bool - - @param _from: ea_t - @param _to: ea_t - @param flags: int +ida_xref.xrefblk_t.next_from(self, *args) -> bool -ida_xref.xrefblk_t.next_to (method) - next_to(self) -> bool - Get xref to '_to' that comes after '_from'. - next_to(self, _from, _to, flags) -> bool - - @param _from: ea_t - @param _to: ea_t - @param flags: int +ida_xref.xrefblk_t.next_to(self, *args) -> bool -ida_xref.xrefblk_t.refs_from (method) +ida_xref.xrefblk_t.refs_from(self, ea, flag) Provide an iterator on from reference represented by flag -ida_xref.xrefblk_t.refs_from._copy_xref (function) +ida_xref.xrefblk_t.refs_from._copy_xref() Make a private copy of the xref class to preserve its contents -ida_xref.xrefblk_t.refs_to (method) +ida_xref.xrefblk_t.refs_to(self, ea, flag) Provide an iterator on to reference represented by flag -ida_xref.xrefblk_t.refs_to._copy_xref (function) +ida_xref.xrefblk_t.refs_to._copy_xref() Make a private copy of the xref class to preserve its contents -ida_xref.xrefblk_t.to (variable) +ida_xref.xrefblk_t.to the referenced address - filled by first_from(), next_from() -ida_xref.xrefblk_t.type (variable) +ida_xref.xrefblk_t.type type of the last returned reference (cref_t & dref_t) -ida_xref.xrefblk_t.user (variable) - 1-is user defined xref, 0-defined by ida +ida_xref.xrefblk_t.user + is user defined xref? otherwise defined by ida -ida_xref.xrefchar (function) - xrefchar(xrtype) -> char - Get character describing the xref type. - - @param xrtype: (C++: char) combination of Cross-Reference type flags and a cref_t of dref_t - value +ida_xref.xrefchar(xrtype: "char") -> "char" + Get character describing the xref type. + + @param xrtype: combination of Cross-Reference type flags and a cref_t of dref_t value -ida_mergemod (module) +ida_mergemod Merge functionality for modules. NOTE: this functionality is available in IDA Teams (not IDA Pro) - - This file contains helper classes and convenience functions for module (plugin - or processor module) merging. - - Each module is responsible for merging the data it owns (the module data). At - the very beginning, the merging engine generates the ev_create_merge_handlers - event. Modules should hook to this event to create merge handlers (mergers) that - are responsible for the module data. - + This file contains helper classes and convenience functions for module (plugin or processor module) merging. + Each module is responsible for merging the data it owns (the module data). At the very beginning, the merging engine generates the ev_create_merge_handlers event. Modules should hook to this event to create merge handlers (mergers) that are responsible for the module data. We assume that each module may have: - * its data structure, derived from plugmod_t or procmod_t. we call this - structure moddata. + * its data structure, derived from plugmod_t or procmod_t. we call this structure moddata. * a dedicated netnode (module node), modnode for short. - Moddata is registered with the IDA kernel using the set_module_data() function, - which returns an integer, moddata_id. moddata_id is used to access the module - data structure during merging, so it is mandatory for all modules that support - merging. + Moddata is registered with the IDA kernel using the set_module_data() function, which returns an integer, moddata_id. moddata_id is used to access the module data structure during merging, so it is mandatory for all modules that support merging. The following sources of mergeable data are supported: - - 1. Data fields inside moddata 2. Values (scalar or binary, including blobs) - stored in the module node 3. Values (scalar or binary, including blobs) stored - in arbitrary netnodes 4. Data fields inside an auxiliary structure (provided by - a special helper) 5. Indexed arrays of data stored in netnodes - - Usually the sources #1-4 are handled by a single merger, which can be - parameterized using the folowing information: + 1. Data fields inside moddata 2. Values (scalar or binary, including blobs) stored in the module node 3. Values (scalar or binary, including blobs) stored in arbitrary netnodes 4. Data fields inside an auxiliary structure (provided by a special helper) 5. Indexed arrays of data stored in netnodes + Usually the sources #1-4 are handled by a single merger, which can be parameterized using the folowing information: * moddata_id * module name * module node name * array of field descriptors (idbattr_info_t idpopts_info[], see ida.hpp) + See plugins/mex1 for an example of such a merger. - - These parameters are stored in a helper class (moddata_diff_helper_t or - derived). The helper class can override the following virtual methods: - - merge_starting - prepare module data for merging (e.g. load data from idb) - merge_ending - opposite to merge_starting (e.g. save merged data to idb) - get_struc_ptr - get pointer to the auxiliary structure (to handle source #4); - this method will be called only if the fields with the IDI_HLPSTRUC bit are - present in the idpopts_info[] array - - For most plugins, the default implementation of moddata_diff_helper_t or the - std_moddata_diff_helper_t helper (presented below) is sufficient. You can find - examples of non-standard helpers in plugins/mex2 and plugins/callgraph. - - The source #5 is handled by a different set of mergers described by an array of - merge_node_info_t entries: a merger per entry. A non-trivial example can be - found in plugins/mex3 and plugins/ex_merge_ldrdata. - - A module can use the create_std_modmerge_handlers() function to create necessary - merge handlers. Please pay attention to the following arguments: - - helper - a helper class responsible for access to the internal module data for - the sources #1-4. It can be used to prepare a pointer to the internal module - structure and load/save data before/after merging (example: plugins/mex2). Im - most cases the default helper class moddata_diff_helper_t can be used. - merge_node_info - array of descriptions for the source #5. Note that the same - module node is used for all array elements. If you need this kind of mergers for - other netnodes, you should add them manually using the - create_nodeval_merge_handler() function (example: plugins/mex3) - + These parameters are stored in a helper class (moddata_diff_helper_t or derived). The helper class can override the following virtual methods: + merge_starting - prepare module data for merging (e.g. load data from idb) merge_ending - opposite to merge_starting (e.g. save merged data to idb) get_struc_ptr - get pointer to the auxiliary structure (to handle source #4); this method will be called only if the fields with the IDI_HLPSTRUC bit are present in the idpopts_info[] array + For most plugins, the default implementation of moddata_diff_helper_t or the std_moddata_diff_helper_t helper (presented below) is sufficient. You can find examples of non-standard helpers in plugins/mex2 and plugins/callgraph. + The source #5 is handled by a different set of mergers described by an array of merge_node_info_t entries: a merger per entry. A non-trivial example can be found in plugins/mex3 and plugins/ex_merge_ldrdata. + A module can use the create_std_modmerge_handlers() function to create necessary merge handlers. Please pay attention to the following arguments: + helper - a helper class responsible for access to the internal module data for the sources #1-4. It can be used to prepare a pointer to the internal module structure and load/save data before/after merging (example: plugins/mex2). Im most cases the default helper class moddata_diff_helper_t can be used. merge_node_info - array of descriptions for the source #5. Note that the same module node is used for all array elements. If you need this kind of mergers for other netnodes, you should add them manually using the create_nodeval_merge_handler() function (example: plugins/mex3) See also module/mergecmn.cpp for procmod-specific functions and macros. - Glossary: - - modmerger = module merger moddata = module data moddata_id = module data id + modmerger = module merger moddata = module data moddata_id = module data id + -ida_mergemod.create_std_modmerge_handlers (function) - create_std_modmerge_handlers(mhp, helper, merge_node_info=None) +ida_mergemod.create_std_modmerge_handlers(mhp: "merge_handler_params_t &", helper: "moddata_diff_helper_t &", merge_node_info: "merge_node_info2_t const *" = None) -> None convinience function to create merge handlers for modules/plugins - - @param mhp: (C++: merge_handler_params_t &) - @param helper: (C++: moddata_diff_helper_t &) - @param merge_node_info: (C++: const merge_node_info_t *) merge_node_info2_t const * -ida_merge (module) +ida_merge Merge functionality. NOTE: this functionality is available in IDA Teams (not IDA Pro) - There are 3 databases involved in merging: base_idb, local_db, and remote_idb. - * base_idb: the common base ancestor of 'local_db' and 'remote_db'. in the UI - this database is located in the middle. - * local_idb: local database that will contain the result of the merging. in the - UI this database is located on the left. - * remote_idb: remote database that will merge into local_idb. It may reside - locally on the current computer, despite its name. in the UI this database is - located on the right. base_idb and remote_idb are opened for reading only. - base_idb may be absent, in this case a 2-way merging is performed. + * base_idb: the common base ancestor of 'local_db' and 'remote_db'. in the UI this database is located in the middle. + * local_idb: local database that will contain the result of the merging. in the UI this database is located on the left. + * remote_idb: remote database that will merge into local_idb. It may reside locally on the current computer, despite its name. in the UI this database is located on the right. base_idb and remote_idb are opened for reading only. base_idb may be absent, in this case a 2-way merging is performed. - Conflicts can be resolved automatically or interactively. The automatic - resolving scores the conflicting blocks and takes the better one. The - interactive resolving displays the full rendered contents side by side, and - expects the user to select the better side for each conflict. - Since IDB files contain various kinds of information, there are many merging - phases. The entire list can be found in merge.cpp. Below are just some selected - examples: + Conflicts can be resolved automatically or interactively. The automatic resolving scores the conflicting blocks and takes the better one. The interactive resolving displays the full rendered contents side by side, and expects the user to select the better side for each conflict. + Since IDB files contain various kinds of information, there are many merging phases. The entire list can be found in merge.cpp. Below are just some selected examples: * merge global database settings (inf and other global vars) * merge segmentation and changes to the database bytes * merge various lists: exports, imports, loaded tils, etc @@ -68258,735 +46735,609 @@ ida_merge (module) * merge debugger settings, breakpoints * merge struct/enum views * merge local type libraries - * merge the disassembly items (i.e. the segment contents) this includes operand - types, code/data separation, etc + * merge the disassembly items (i.e. the segment contents) this includes operand types, code/data separation, etc * merge plugin specific info like decompiler types, dwarf mappings, etc + To unify UI elements of each merge phase, we use merger views: - * A view that consists of 2 or 3 panes: left (local_idb) and right (remote_idb). - The common base is in the middle, if present. - * Rendering of the panes depends on the phase, different phases show different - contents. - * The conflicts are highlighted by a colored background. Also, the detail pane - can be consulted for additional info. - * The user can select a conflict (or a bunch of conflicts) and say "use this - block". - * The user can browse the panes as he wishes. He will not be forced to handle - conflicts in any particular order. However, once he finishes working with a - merge handler and proceeds to the next one, he cannot go back. - * Scrolling the left pane will synchronously scroll the right pane and vice - versa. + * A view that consists of 2 or 3 panes: left (local_idb) and right (remote_idb). The common base is in the middle, if present. + * Rendering of the panes depends on the phase, different phases show different contents. + * The conflicts are highlighted by a colored background. Also, the detail pane can be consulted for additional info. + * The user can select a conflict (or a bunch of conflicts) and say "use this block". + * The user can browse the panes as he wishes. He will not be forced to handle conflicts in any particular order. However, once he finishes working with a merge handler and proceeds to the next one, he cannot go back. + * Scrolling the left pane will synchronously scroll the right pane and vice versa. * There are the navigation commands like "go to the prev/next conflict" - * The number of remaining conflicts to resolve is printed in the "Progress" - chooser. - * The user may manually modify local database inside the merger view. For that - he may use the regular hotkeys. However, editing the database may lead to new - conflicts, so we better restrict the available actions to some reasonable - minimum. Currently, this is not implemented. + * The number of remaining conflicts to resolve is printed in the "Progress" chooser. + * The user may manually modify local database inside the merger view. For that he may use the regular hotkeys. However, editing the database may lead to new conflicts, so we better restrict the available actions to some reasonable minimum. Currently, this is not implemented. - IDA works in a new "merge" mode during merging. In this mode most events are not - generated. We forbid them to reduce the risk that a rogue third-party plugin - that is not aware of the "merge" mode would spoil something. - For example, normally renaming a function causes a cascade of events and may - lead to other database modifications. Some of them may be desired, some - not. - Since there are some undesired events, it is better to stop generating them. - However, some events are required to render the disassembly listing. For - example, ev_ana_insn, av_out_insn. This is why some events are still generated - in the "merge" mode. - - To let processor modules and plugins merge their data, we introduce a new event: - ev_create_merge_handlers. It is generated immediately after opening all three - idbs. The interested modules should react to this event by creating new merge - handlers, if they need them. - - While the kernel can create arbitrary merge handlers, modules can create only - the standard ones returned by: - - create_nodeval_merge_handler() create_nodeval_merge_handlers() - create_std_modmerge_handlers() - - We do not document merge_handler_t because once a merge handler is created, it - is used exclusively by the kernel. - - See mergemod.hpp for more information about the merge mode for modules. + IDA works in a new "merge" mode during merging. In this mode most events are not generated. We forbid them to reduce the risk that a rogue third-party plugin that is not aware of the "merge" mode would spoil something. + For example, normally renaming a function causes a cascade of events and may lead to other database modifications. Some of them may be desired, some - not. Since there are some undesired events, it is better to stop generating them. However, some events are required to render the disassembly listing. For example, ev_ana_insn, av_out_insn. This is why some events are still generated in the "merge" mode. + To let processor modules and plugins merge their data, we introduce a new event: ev_create_merge_handlers. It is generated immediately after opening all three idbs. The interested modules should react to this event by creating new merge handlers, if they need them. + While the kernel can create arbitrary merge handlers, modules can create only the standard ones returned by: + create_nodeval_merge_handler() create_nodeval_merge_handlers() create_std_modmerge_handlers() + We do not document merge_handler_t because once a merge handler is created, it is used exclusively by the kernel. + See mergemod.hpp for more information about the merge mode for modules. + -ida_merge.MERGE_KIND_AFLAGS_EA (variable) +ida_merge.MERGE_KIND_AFLAGS_EA merge aflags for mapped EA -ida_merge.MERGE_KIND_AUTOQ (variable) +ida_merge.MERGE_KIND_AUTOQ auto queues -ida_merge.MERGE_KIND_BOOKMARKS (variable) +ida_merge.MERGE_KIND_BOOKMARKS merge bookmarks -ida_merge.MERGE_KIND_BPTS (variable) +ida_merge.MERGE_KIND_BPTS merge breakpoints -ida_merge.MERGE_KIND_BYTEVAL (variable) +ida_merge.MERGE_KIND_BYTEVAL merge byte values -ida_merge.MERGE_KIND_CREFS (variable) +ida_merge.MERGE_KIND_CREFS merge crefs -ida_merge.MERGE_KIND_CUSTDATA (variable) +ida_merge.MERGE_KIND_CUSTDATA merge custom data type and formats -ida_merge.MERGE_KIND_DBG_MEMREGS (variable) +ida_merge.MERGE_KIND_DBG_MEMREGS manual memory regions (debugger) -ida_merge.MERGE_KIND_DEBUGGER (variable) +ida_merge.MERGE_KIND_DEBUGGER debugger data -ida_merge.MERGE_KIND_DEKSTOPS (variable) +ida_merge.MERGE_KIND_DEKSTOPS dekstops -ida_merge.MERGE_KIND_DIRTREE (variable) +ida_merge.MERGE_KIND_DIRTREE merge std dirtrees -ida_merge.MERGE_KIND_DREFS (variable) +ida_merge.MERGE_KIND_DREFS merge drefs -ida_merge.MERGE_KIND_ENCODINGS (variable) +ida_merge.MERGE_KIND_ENCODINGS merge encodings -ida_merge.MERGE_KIND_ENCODINGS2 (variable) +ida_merge.MERGE_KIND_ENCODINGS2 merge default encodings -ida_merge.MERGE_KIND_END (variable) - insert to the end of handler list, valid for - merge_handler_params_t::insert_after +ida_merge.MERGE_KIND_END + insert to the end of handler list, valid for merge_handler_params_t::insert_after + -ida_merge.MERGE_KIND_ENUMS (variable) +ida_merge.MERGE_KIND_ENUMS merge enums -ida_merge.MERGE_KIND_EXPORTS (variable) +ida_merge.MERGE_KIND_EXPORTS merge exports -ida_merge.MERGE_KIND_EXTRACMT (variable) +ida_merge.MERGE_KIND_EXTRACMT merge extra next or prev lines -ida_merge.MERGE_KIND_FILEREGIONS (variable) +ida_merge.MERGE_KIND_FILEREGIONS merge fileregions -ida_merge.MERGE_KIND_FIXUPS (variable) +ida_merge.MERGE_KIND_FIXUPS merge fixups -ida_merge.MERGE_KIND_FLAGS (variable) +ida_merge.MERGE_KIND_FLAGS merge flags64_t -ida_merge.MERGE_KIND_FLOWS (variable) +ida_merge.MERGE_KIND_FLOWS merge flows -ida_merge.MERGE_KIND_FRAME (variable) +ida_merge.MERGE_KIND_FRAME merge function frame info (frame members) -ida_merge.MERGE_KIND_FRAMEMGR (variable) +ida_merge.MERGE_KIND_FRAMEMGR merge frames (globally: add/delete frames entirely) -ida_merge.MERGE_KIND_FUNC (variable) +ida_merge.MERGE_KIND_FUNC merge func info -ida_merge.MERGE_KIND_GHSTRCMT (variable) +ida_merge.MERGE_KIND_GHSTRCMT merge ghost structure comment -ida_merge.MERGE_KIND_HIDDENRANGES (variable) +ida_merge.MERGE_KIND_HIDDENRANGES merge hidden ranges -ida_merge.MERGE_KIND_IGNOREMICRO (variable) +ida_merge.MERGE_KIND_IGNOREMICRO IM ("$ ignore micro") flags. -ida_merge.MERGE_KIND_IMPORTS (variable) +ida_merge.MERGE_KIND_IMPORTS merge imports -ida_merge.MERGE_KIND_INF (variable) +ida_merge.MERGE_KIND_INF merge the inf variable (global settings) -ida_merge.MERGE_KIND_LAST (variable) - last predefined merge handler type. please note that there can be more merge - handler types, registered by plugins and processor modules. +ida_merge.MERGE_KIND_LAST + last predefined merge handler type. please note that there can be more merge handler types, registered by plugins and processor modules. + -ida_merge.MERGE_KIND_LOADER (variable) +ida_merge.MERGE_KIND_LOADER loader data -ida_merge.MERGE_KIND_LUMINA (variable) +ida_merge.MERGE_KIND_LUMINA lumina function metadata -ida_merge.MERGE_KIND_MAPPING (variable) +ida_merge.MERGE_KIND_MAPPING merge manual memory mapping -ida_merge.MERGE_KIND_NETNODE (variable) +ida_merge.MERGE_KIND_NETNODE netnode (no merging, to be used in idbunits) -ida_merge.MERGE_KIND_NOTEPAD (variable) +ida_merge.MERGE_KIND_NOTEPAD notepad -ida_merge.MERGE_KIND_ORPHANS (variable) +ida_merge.MERGE_KIND_ORPHANS merge orphan bytes -ida_merge.MERGE_KIND_PATCHES (variable) +ida_merge.MERGE_KIND_PATCHES merge patched bytes -ida_merge.MERGE_KIND_PROBLEMS (variable) +ida_merge.MERGE_KIND_PROBLEMS problems -ida_merge.MERGE_KIND_SCRIPTS (variable) +ida_merge.MERGE_KIND_SCRIPTS merge scripts -ida_merge.MERGE_KIND_SCRIPTS2 (variable) +ida_merge.MERGE_KIND_SCRIPTS2 merge scripts common info -ida_merge.MERGE_KIND_SEGGRPS (variable) +ida_merge.MERGE_KIND_SEGGRPS merge segment groups -ida_merge.MERGE_KIND_SEGMENTS (variable) +ida_merge.MERGE_KIND_SEGMENTS merge segments -ida_merge.MERGE_KIND_SEGREGS (variable) +ida_merge.MERGE_KIND_SEGREGS merge segment registers -ida_merge.MERGE_KIND_SELECTORS (variable) +ida_merge.MERGE_KIND_SELECTORS merge selectors -ida_merge.MERGE_KIND_SIGNATURES (variable) +ida_merge.MERGE_KIND_SIGNATURES signatures -ida_merge.MERGE_KIND_SOURCEFILES (variable) +ida_merge.MERGE_KIND_SOURCEFILES merge source files ranges -ida_merge.MERGE_KIND_STKPNTS (variable) +ida_merge.MERGE_KIND_STKPNTS merge SP change points -ida_merge.MERGE_KIND_STRMEM (variable) +ida_merge.MERGE_KIND_STRMEM merge struct members -ida_merge.MERGE_KIND_STRMEMCMT (variable) +ida_merge.MERGE_KIND_STRMEMCMT merge member comments for ghost struc -ida_merge.MERGE_KIND_STRUCTS (variable) +ida_merge.MERGE_KIND_STRUCTS merge structs (globally: add/delete structs entirely) -ida_merge.MERGE_KIND_STT (variable) +ida_merge.MERGE_KIND_STT merge flag storage types -ida_merge.MERGE_KIND_TILS (variable) +ida_merge.MERGE_KIND_TILS merge type libraries -ida_merge.MERGE_KIND_TINFO (variable) +ida_merge.MERGE_KIND_TINFO merge tinfo -ida_merge.MERGE_KIND_TRYBLKS (variable) +ida_merge.MERGE_KIND_TRYBLKS merge try blocks -ida_merge.MERGE_KIND_UDTMEM (variable) +ida_merge.MERGE_KIND_UDTMEM merge UDT members (local types) -ida_merge.MERGE_KIND_UI (variable) +ida_merge.MERGE_KIND_UI UI. -ida_merge.MERGE_KIND_VFTABLES (variable) +ida_merge.MERGE_KIND_VFTABLES merge vftables -ida_merge.MERGE_KIND_WATCHPOINTS (variable) +ida_merge.MERGE_KIND_WATCHPOINTS merge watchpoints -ida_merge.MH_LISTEN (variable) +ida_merge.MH_LISTEN merge handler will receive merge events -ida_merge.MH_TERSE (variable) +ida_merge.MH_TERSE do not display equal lines in the merge results table -ida_merge.MH_UI_CHAR_MASK (variable) +ida_merge.MH_UI_CHAR_MASK 7-bit ASCII split character -ida_merge.MH_UI_COLONNAME (variable) +ida_merge.MH_UI_COLONNAME ida will split the diffpos name by ':' to create chooser columns -ida_merge.MH_UI_COMMANAME (variable) +ida_merge.MH_UI_COMMANAME ida will split the diffpos name by ',' to create chooser columns -ida_merge.MH_UI_COMPLEX (variable) +ida_merge.MH_UI_COMPLEX diffpos details won't be displayed in the diffpos chooser -ida_merge.MH_UI_DP_NOLINEDIFF (variable) +ida_merge.MH_UI_DP_NOLINEDIFF Detail pane: do not show differences inside the line. -ida_merge.MH_UI_DP_SHORTNAME (variable) +ida_merge.MH_UI_DP_SHORTNAME Detail pane: use the first part of a complex diffpos name as the tree node name. -ida_merge.MH_UI_INDENT (variable) +ida_merge.MH_UI_INDENT preserve indent for diffpos name in diffpos chooser -ida_merge.MH_UI_NODETAILS (variable) +ida_merge.MH_UI_NODETAILS ida will not show the diffpos details -ida_merge.MH_UI_SPLITNAME (variable) - ida will split the diffpos name by 7-bit ASCII char to create chooser columns +ida_merge.MH_UI_SPLITNAME + ida will split the diffpos name by 7-bit ASCII char to create chooser columns + -ida_merge.NDS_BLOB (variable) +ida_merge.NDS_BLOB stored as netnode blobs -ida_merge.NDS_EV_FUNC (variable) +ida_merge.NDS_EV_FUNC enable default handling of mev_added_func/mev_deleting_func -ida_merge.NDS_EV_RANGE (variable) +ida_merge.NDS_EV_RANGE enable default handling of mev_modified_ranges, mev_deleting_segm -ida_merge.NDS_INC (variable) +ida_merge.NDS_INC stored value is incremented (scalars only) -ida_merge.NDS_IS_BOOL (variable) +ida_merge.NDS_IS_BOOL boolean value -ida_merge.NDS_IS_EA (variable) +ida_merge.NDS_IS_EA EA value. -ida_merge.NDS_IS_RELATIVE (variable) +ida_merge.NDS_IS_RELATIVE value is relative to index (stored as delta) -ida_merge.NDS_IS_STR (variable) +ida_merge.NDS_IS_STR string value -ida_merge.NDS_MAP_IDX (variable) +ida_merge.NDS_MAP_IDX apply ea2node() to index (==NETMAP_IDX) -ida_merge.NDS_MAP_VAL (variable) - apply ea2node() to value. Along with NDS_INC it gives effect of NETMAP_VAL, - examples: altval_ea : NDS_MAP_IDX charval : NDS_VAL8 charval_ea: - NDS_MAP_IDX|NDS_VAL8 eaget : NDS_MAP_IDX|NDS_MAP_VAL|NDS_INC +ida_merge.NDS_MAP_VAL + apply ea2node() to value. Along with NDS_INC it gives effect of NETMAP_VAL, examples: altval_ea : NDS_MAP_IDX charval : NDS_VAL8 charval_ea: NDS_MAP_IDX|NDS_VAL8 eaget : NDS_MAP_IDX|NDS_MAP_VAL|NDS_INC + -ida_merge.NDS_SUPVAL (variable) +ida_merge.NDS_SUPVAL stored as netnode supvals (not scalar) -ida_merge.NDS_VAL8 (variable) +ida_merge.NDS_UI_ND + UI: no need to show diffpos detail pane, MH_UI_NODETAILS, make sense if merge_node_helper_t is used + + +ida_merge.NDS_VAL8 use 8-bit values (==NETMAP_V8) -ida_merge.create_nodeval_merge_handler (function) - create_nodeval_merge_handler(mhp, label, nodename, tag, nds_flags, node_helper=None, skip_empty_nodes=True) -> merge_handler_t * - Create a merge handler for netnode scalar/string values - - @param mhp: (C++: const merge_handler_params_t &) merging parameters - @param label: (C++: const char *) handler short name (to be be appended to mhp.label) - @param nodename: (C++: const char *) netnode name - @param tag: (C++: uchar) a tag used to access values in the netnode - @param nds_flags: (C++: uint32) netnode value attributes (a combination of nds_flags_t) - @param node_helper: merge_node_helper_t * - @param skip_empty_nodes: (C++: bool) do not create handler in case of empty netnode - @return: diff source object (normally should be attahced to a merge handler) +ida_merge.create_nodeval_merge_handler(mhp: "merge_handler_params_t", label: str, nodename: str, tag: "uchar", nds_flags: int, node_helper: "merge_node_helper_t" = None, skip_empty_nodes: bool = True) -> "merge_handler_t *" + Create a merge handler for netnode scalar/string values + + @param mhp: merging parameters + @param label: handler short name (to be be appended to mhp.label) + @param nodename: netnode name + @param tag: a tag used to access values in the netnode + @param nds_flags: netnode value attributes (a combination of nds_flags_t) + @param skip_empty_nodes: do not create handler in case of empty netnode + @returns diff source object (normally should be attahced to a merge handler) -ida_merge.create_nodeval_merge_handlers (function) - create_nodeval_merge_handlers(out, mhp, nodename, valdesc, skip_empty_nodes=True) - Create a serie of merge handlers for netnode scalar/string values (call - create_nodeval_merge_handler() for each member of VALDESC) - - @param out: (C++: merge_handlers_t *) [out] created handlers will be placed here - @param mhp: (C++: const merge_handler_params_t &) merging parameters - @param nodename: (C++: const char *) netnode name - @param valdesc: (C++: const merge_node_info_t *) array of handler descriptions - @param skip_empty_nodes: (C++: bool) do not create handlers for empty netnodes - @return: diff source object (normally should be attahced to a merge handler) +ida_merge.create_nodeval_merge_handlers(out: "merge_handlers_t *", mhp: "merge_handler_params_t", nodename: str, valdesc: "merge_node_info_t", skip_empty_nodes: bool = True) -> None + Create a serie of merge handlers for netnode scalar/string values (call create_nodeval_merge_handler() for each member of VALDESC) + + @param out: [out] created handlers will be placed here + @param mhp: merging parameters + @param nodename: netnode name + @param valdesc: array of handler descriptions + @param skip_empty_nodes: do not create handlers for empty netnodes + @returns diff source object (normally should be attahced to a merge handler) -ida_merge.destroy_moddata_merge_handlers (function) - destroy_moddata_merge_handlers(data_id) - - @param data_id: int +ida_merge.destroy_moddata_merge_handlers(data_id: int) -> None -ida_merge.get_ea_diffpos_name (function) - get_ea_diffpos_name(ea) -> str - Get nice name for EA diffpos - - @param ea: (C++: ea_t) diffpos - @note - @see: get_nice_colored_name +ida_merge.get_ea_diffpos_name(ea: ida_idaapi.ea_t) -> str + Get nice name for EA diffpos + + @param ea: diffpos -ida_merge.is_diff_merge_mode (function) - is_diff_merge_mode() -> bool - Return TRUE if IDA is running in diff mode - (MERGE_POLICY_MDIFF/MERGE_POLICY_VDIFF) +ida_merge.is_diff_merge_mode() -> bool + Return TRUE if IDA is running in diff mode (MERGE_POLICY_MDIFF/MERGE_POLICY_VDIFF) -ida_merge.item_block_locator_t (class) - Proxy of C++ merge_data_t::item_block_locator_t class. +ida_merge.item_block_locator_t -ida_merge.item_block_locator_t.__disown__ (method) +ida_merge.item_block_locator_t.__disown__(self) -ida_merge.item_block_locator_t.__init__ (method) - __init__(self) -> item_block_locator_t - - @param self: PyObject * +ida_merge.item_block_locator_t.__init__(self) -ida_merge.item_block_locator_t.get_block_head (method) - get_block_head(self, md, idx, item_head) -> ea_t - - @param md: merge_data_t & - @param idx: diff_source_idx_t - @param item_head: ea_t +ida_merge.item_block_locator_t.get_block_head(self, md: "merge_data_t", idx: "diff_source_idx_t", item_head: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_merge.item_block_locator_t.setup_blocks (method) - setup_blocks(self, md, _from, to, region) -> bool - - @param md: merge_data_t & - @param from: diff_source_idx_t - @param to: diff_source_idx_t - @param region: diff_range_t const & +ida_merge.item_block_locator_t.setup_blocks(self, md: "merge_data_t", _from: "diff_source_idx_t", to: "diff_source_idx_t", region: "diff_range_t const &") -> bool -ida_merge.merge_data_t (class) - Proxy of C++ merge_data_t class. +ida_merge.merge_data_t -ida_merge.merge_data_t.__init__ (method) +ida_merge.merge_data_t.__init__(self, *args, **kwargs) -ida_merge.merge_data_t.add_event_handler (method) - add_event_handler(self, handler) - - @param handler: merge_handler_t * +ida_merge.merge_data_t.add_event_handler(self, handler: "merge_handler_t *") -> None -ida_merge.merge_data_t.base_id (method) - base_id(self) -> int +ida_merge.merge_data_t.base_id(self) -> int -ida_merge.merge_data_t.compare_merging_tifs (method) - compare_merging_tifs(self, tif1, diffidx1, tif2, diffidx2) -> int - compare types from two databases - - @param tif1: (C++: const tinfo_t &) type - @param diffidx1: (C++: diff_source_idx_t) database index, diff_source_idx_t - @param tif2: (C++: const tinfo_t &) type - @param diffidx2: (C++: diff_source_idx_t) database index, diff_source_idx_t - @return: -1, 0, 1 +ida_merge.merge_data_t.compare_merging_tifs(self, tif1: "tinfo_t", diffidx1: "diff_source_idx_t", tif2: "tinfo_t", diffidx2: "diff_source_idx_t") -> int + compare types from two databases + + @param tif1: type + @param diffidx1: database index, diff_source_idx_t + @param tif2: type + @param diffidx2: database index, diff_source_idx_t + @returns -1, 0, 1 -ida_merge.merge_data_t.dbctx_ids (variable) +ida_merge.merge_data_t.dbctx_ids local, remote, base ids -ida_merge.merge_data_t.ev_handlers (variable) +ida_merge.merge_data_t.ev_handlers event handlers -ida_merge.merge_data_t.get_block_head (method) - get_block_head(self, idx, item_head) -> ea_t - - @param idx: diff_source_idx_t - @param item_head: ea_t +ida_merge.merge_data_t.get_block_head(self, idx: "diff_source_idx_t", item_head: ida_idaapi.ea_t) -> ida_idaapi.ea_t -ida_merge.merge_data_t.has_existing_node (method) - has_existing_node(self, nodename) -> bool +ida_merge.merge_data_t.has_existing_node(self, nodename: str) -> bool check that node exists in any of databases - - @param nodename: (C++: const char *) char const * -ida_merge.merge_data_t.local_id (method) - local_id(self) -> int +ida_merge.merge_data_t.local_id(self) -> int -ida_merge.merge_data_t.map_privrange_id (method) - map_privrange_id(self, tid, ea, _from, to, strict=True) -> bool - map IDs of structures, enumerations and their members - - @param tid: (C++: tid_t *) item ID in TO database - @param ea: (C++: ea_t) item ID to find counterpart - @param from: (C++: diff_source_idx_t) source database index, diff_source_idx_t - @param to: (C++: diff_source_idx_t) destination database index, diff_source_idx_t - @param strict: (C++: bool) raise interr if could not map - @return: success +ida_merge.merge_data_t.map_privrange_id(self, tid: "tid_t *", ea: ida_idaapi.ea_t, _from: "diff_source_idx_t", to: "diff_source_idx_t", strict: bool = True) -> bool + map IDs of structures, enumerations and their members + + @param tid: item ID in TO database + @param ea: item ID to find counterpart + @param to: destination database index, diff_source_idx_t + @param strict: raise interr if could not map + @returns success -ida_merge.merge_data_t.map_tinfo (method) - map_tinfo(self, tif, _from, to, strict=True) -> bool - migrate type, replaces type references into FROM database to references into TO - database - - @param tif: (C++: tinfo_t *) type to migrate, will be cleared in case of fail - @param from: (C++: diff_source_idx_t) source database index, diff_source_idx_t - @param to: (C++: diff_source_idx_t) destination database index, diff_source_idx_t - @param strict: (C++: bool) raise interr if could not map - @return: success +ida_merge.merge_data_t.map_tinfo(self, tif: "tinfo_t", _from: "diff_source_idx_t", to: "diff_source_idx_t", strict: bool = True) -> bool + migrate type, replaces type references into FROM database to references into TO database + + @param tif: type to migrate, will be cleared in case of fail + @param to: destination database index, diff_source_idx_t + @param strict: raise interr if could not map + @returns success -ida_merge.merge_data_t.nbases (variable) - number of database participating in merge process, maybe 2 or 3 +ida_merge.merge_data_t.nbases + number of database participating in merge process, maybe 2 or 3 + -ida_merge.merge_data_t.remote_id (method) - remote_id(self) -> int +ida_merge.merge_data_t.remote_id(self) -> int -ida_merge.merge_data_t.remove_event_handler (method) - remove_event_handler(self, handler) - - @param handler: merge_handler_t * +ida_merge.merge_data_t.remove_event_handler(self, handler: "merge_handler_t *") -> None -ida_merge.merge_data_t.set_dbctx_ids (method) - set_dbctx_ids(self, local, remote, base) - - @param local: int - @param remote: int - @param base: int +ida_merge.merge_data_t.set_dbctx_ids(self, local: int, remote: int, base: int) -> None -ida_merge.merge_data_t.setup_blocks (method) - setup_blocks(self, dst_idx, src_idx, region) -> bool - - @param dst_idx: diff_source_idx_t - @param src_idx: diff_source_idx_t - @param region: diff_range_t const & +ida_merge.merge_data_t.setup_blocks(self, dst_idx: "diff_source_idx_t", src_idx: "diff_source_idx_t", region: "diff_range_t const &") -> bool -ida_merge.merge_handler_params_t (class) - Proxy of C++ merge_handler_params_t class. +ida_merge.merge_handler_params_t -ida_merge.merge_handler_params_t.__init__ (method) - __init__(self, _md, _label, _kind, _insert_after, _mh_flags) -> merge_handler_params_t - - @param _md: merge_data_t & - @param _label: qstring const & - @param _kind: enum merge_kind_t - @param _insert_after: enum merge_kind_t - @param _mh_flags: uint32 +ida_merge.merge_handler_params_t.__init__(self, _md: "merge_data_t", _label: str, _kind: "merge_kind_t", _insert_after: "merge_kind_t", _mh_flags: int) -ida_merge.merge_handler_params_t.insert_after (variable) +ida_merge.merge_handler_params_t.insert_after desired position inside 'handlers' merge_kind_t -ida_merge.merge_handler_params_t.kind (variable) +ida_merge.merge_handler_params_t.kind merge handler kind merge_kind_t -ida_merge.merge_handler_params_t.ui_complex_details (method) - ui_complex_details(self, _mh_flags) -> bool - Do not display the diffpos details in the chooser. For example, the - MERGE_KIND_SCRIPTS handler puts the script body as the diffpos detail. It would - not be great to show them as part of the chooser. +ida_merge.merge_handler_params_t.ui_complex_details(self, *args) -> bool + This function has the following signatures: - @param _mh_flags: (C++: uint32) + 0. ui_complex_details() -> bool + 1. ui_complex_details(_mh_flags: int) -> bool - ui_complex_details(self) -> bool + # 0: ui_complex_details() -> bool + + + # 1: ui_complex_details(_mh_flags: int) -> bool + + Do not display the diffpos details in the chooser. For example, the MERGE_KIND_SCRIPTS handler puts the script body as the diffpos detail. It would not be great to show them as part of the chooser. + -ida_merge.merge_handler_params_t.ui_complex_name (method) - ui_complex_name(self, _mh_flags) -> bool - It customary to create long diffpos names having many components that are - separated by any 7-bit ASCII character (besides of '\0'). In this case it is - possible to instruct IDA to use this separator to create a multi-column chooser. - For example the MERGE_KIND_ENUMS handler has the following diffpos name: - enum_1,enum_2 If MH_UI_COMMANAME is specified, IDA will create 2 columns for - these names. +ida_merge.merge_handler_params_t.ui_complex_name(self, *args) -> bool + This function has the following signatures: - @param _mh_flags: (C++: uint32) + 0. ui_complex_name() -> bool + 1. ui_complex_name(_mh_flags: int) -> bool - ui_complex_name(self) -> bool + # 0: ui_complex_name() -> bool + + + # 1: ui_complex_name(_mh_flags: int) -> bool + + It customary to create long diffpos names having many components that are separated by any 7-bit ASCII character (besides of '\0'). In this case it is possible to instruct IDA to use this separator to create a multi-column chooser. For example the MERGE_KIND_ENUMS handler has the following diffpos name: enum_1,enum_2 If MH_UI_COMMANAME is specified, IDA will create 2 columns for these names. + -ida_merge.merge_handler_params_t.ui_dp_shortname (method) - ui_dp_shortname(self, _mh_flags) -> bool - The detail pane shows the diffpos details for the current diffpos range as a - tree-like view. In this pane the diffpos names are used as tree node names and - the diffpos details as their children. Sometimes, for complex diffpos names, the - first part of the name looks better than the entire name. For example, the - MERGE_KIND_SEGMENTS handler has the following diffpos name: - <range>,<segm1>,<segm2>,<segm3> if MH_UI_DP_SHORTNAME is specified, IDA will use - <range> as a tree node name +ida_merge.merge_handler_params_t.ui_dp_shortname(self, *args) -> bool + This function has the following signatures: - @param _mh_flags: (C++: uint32) + 0. ui_dp_shortname() -> bool + 1. ui_dp_shortname(_mh_flags: int) -> bool - ui_dp_shortname(self) -> bool + # 0: ui_dp_shortname() -> bool + + + # 1: ui_dp_shortname(_mh_flags: int) -> bool + + The detail pane shows the diffpos details for the current diffpos range as a tree-like view. In this pane the diffpos names are used as tree node names and the diffpos details as their children. Sometimes, for complex diffpos names, the first part of the name looks better than the entire name. For example, the MERGE_KIND_SEGMENTS handler has the following diffpos name: <range>,<segm1>,<segm2>,<segm3> if MH_UI_DP_SHORTNAME is specified, IDA will use <range> as a tree node name + -ida_merge.merge_handler_params_t.ui_has_details (method) - ui_has_details(self, _mh_flags) -> bool +ida_merge.merge_handler_params_t.ui_has_details(self, *args) -> bool + This function has the following signatures: + + 0. ui_has_details() -> bool + 1. ui_has_details(_mh_flags: int) -> bool + + # 0: ui_has_details() -> bool + + + # 1: ui_has_details(_mh_flags: int) -> bool + Should IDA display the diffpos detail pane? - - @param _mh_flags: (C++: uint32) - - ui_has_details(self) -> bool -ida_merge.merge_handler_params_t.ui_indent (method) - ui_indent(self, _mh_flags) -> bool - In the ordinary situation the spaces from the both sides of diffpos name are - trimmed. Use this UI hint to preserve the leading spaces. +ida_merge.merge_handler_params_t.ui_indent(self, *args) -> bool + This function has the following signatures: - @param _mh_flags: (C++: uint32) + 0. ui_indent() -> bool + 1. ui_indent(_mh_flags: int) -> bool - ui_indent(self) -> bool + # 0: ui_indent() -> bool + + + # 1: ui_indent(_mh_flags: int) -> bool + + In the ordinary situation the spaces from the both sides of diffpos name are trimmed. Use this UI hint to preserve the leading spaces. + -ida_merge.merge_handler_params_t.ui_linediff (method) - ui_linediff(self, _mh_flags) -> bool - In detail pane IDA shows difference between diffpos details. IDA marks added or - deleted detail by color. In the modified detail the changes are marked. Use this - UI hint if you do not want to show the differences inside detail. +ida_merge.merge_handler_params_t.ui_linediff(self, *args) -> bool + This function has the following signatures: - @param _mh_flags: (C++: uint32) + 0. ui_linediff() -> bool + 1. ui_linediff(_mh_flags: int) -> bool - ui_linediff(self) -> bool + # 0: ui_linediff() -> bool + + + # 1: ui_linediff(_mh_flags: int) -> bool + + In detail pane IDA shows difference between diffpos details. IDA marks added or deleted detail by color. In the modified detail the changes are marked. Use this UI hint if you do not want to show the differences inside detail. + -ida_merge.merge_handler_params_t.ui_split_char (method) - ui_split_char(self, _mh_flags) -> char +ida_merge.merge_handler_params_t.ui_split_char(self, *args) -> "char" + This function has the following signatures: - @param _mh_flags: uint32 + 0. ui_split_char() -> char + 1. ui_split_char(_mh_flags: int) -> char - ui_split_char(self) -> char - -ida_merge.merge_handler_params_t.ui_split_str (method) - ui_split_str(self, _mh_flags) -> qstring + # 0: ui_split_char() -> char - @param _mh_flags: uint32 - ui_split_str(self) -> qstring + # 1: ui_split_char(_mh_flags: int) -> char -ida_merge.merge_node_helper_t (class) - Proxy of C++ merge_node_helper_t class. - -ida_merge.merge_node_helper_t.__disown__ (method) - -ida_merge.merge_node_helper_t.__init__ (method) - __init__(self) -> merge_node_helper_t +ida_merge.merge_handler_params_t.ui_split_str(self, *args) -> str + This function has the following signatures: - @param self: PyObject * + 0. ui_split_str() -> str + 1. ui_split_str(_mh_flags: int) -> str + + # 0: ui_split_str() -> str + + + # 1: ui_split_str(_mh_flags: int) -> str -ida_merge.merge_node_helper_t.append_eavec (method) - append_eavec(s, prefix, eas) +ida_merge.merge_node_helper_t + +ida_merge.merge_node_helper_t.__disown__(self) + +ida_merge.merge_node_helper_t.__init__(self) + +ida_merge.merge_node_helper_t.append_eavec(s: str, prefix: str, eas: "eavec_t const &") -> None can be used by derived classes - - @param s: (C++: qstring *) - @param prefix: (C++: const char *) char const * - @param eas: (C++: const eavec_t &) eavec_t const & -ida_merge.merge_node_helper_t.get_column_headers (method) - get_column_headers(self, arg0, arg1, arg2) - get column headers for chooser (to be used in - linear_diff_source_t::get_column_headers) - - @param arg0: qstrvec_t * - @param arg1: uchar - @param arg2: void * +ida_merge.merge_node_helper_t.get_column_headers(self, arg0: "qstrvec_t *", arg1: "uchar", arg2: "void *") -> None + get column headers for chooser (to be used in linear_diff_source_t::get_column_headers) + -ida_merge.merge_node_helper_t.get_netnode (method) - get_netnode(self) -> netnode - return netnode to be used as source. If this function returns BADNODE netnode - will be created using netnode name passed to create_nodeval_diff_source +ida_merge.merge_node_helper_t.get_netnode(self) -> "netnode" + return netnode to be used as source. If this function returns BADNODE netnode will be created using netnode name passed to create_nodeval_diff_source + -ida_merge.merge_node_helper_t.is_mergeable (method) - is_mergeable(self, arg0, arg1) -> bool - - @param filter: check if we should perform merging for given record - @param arg1: nodeidx_t +ida_merge.merge_node_helper_t.is_mergeable(self, arg0: "uchar", arg1: "nodeidx_t") -> bool + filter: check if we should perform merging for given record -ida_merge.merge_node_helper_t.map_scalar (method) - map_scalar(self, arg0, arg1, arg2, arg3) +ida_merge.merge_node_helper_t.map_scalar(self, arg0: "nodeidx_t *", arg1: "void *", arg2: "diff_source_idx_t", arg3: "diff_source_idx_t") -> None map scalar/string/buffered value - - @param arg0: nodeidx_t * - @param arg1: void * - @param arg2: diff_source_idx_t - @param arg3: diff_source_idx_t -ida_merge.merge_node_helper_t.map_string (method) - map_string(self, arg0, arg1, arg2, arg3) - - @param arg0: qstring * - @param arg1: void * - @param arg2: diff_source_idx_t - @param arg3: diff_source_idx_t +ida_merge.merge_node_helper_t.map_string(self, arg0: str, arg1: "void *", arg2: "diff_source_idx_t", arg3: "diff_source_idx_t") -> None -ida_merge.merge_node_helper_t.print_entry_details (method) - print_entry_details(self, arg0, arg1, arg2, arg3) - print the details of the specified entry usually contains multiple lines, one - for each attribute or detail. (to be used in print_diffpos_details) - - @param arg0: qstrvec_t * - @param arg1: uchar - @param arg2: nodeidx_t - @param arg3: void * +ida_merge.merge_node_helper_t.print_entry_details(self, arg0: "qstrvec_t *", arg1: "uchar", arg2: "nodeidx_t", arg3: "void *") -> None + print the details of the specified entry usually contains multiple lines, one for each attribute or detail. (to be used in print_diffpos_details) + -ida_merge.merge_node_helper_t.print_entry_name (method) - print_entry_name(self, arg0, arg1, arg2) -> qstring - print the name of the specified entry (to be used in print_diffpos_name) - - @param arg0: uchar - @param arg1: nodeidx_t - @param arg2: void * +ida_merge.merge_node_helper_t.print_entry_name(self, arg0: "uchar", arg1: "nodeidx_t", arg2: "void *") -> str + print the name of the specified entry (to be used in print_diffpos_name) + -ida_merge.merge_node_helper_t.refresh (method) - refresh(self, arg0, arg1) - notify helper that some data was changed in the database and internal structures - (e.g. caches) should be refreshed - - @param arg0: uchar - @param arg1: void * +ida_merge.merge_node_helper_t.refresh(self, arg0: "uchar", arg1: "void *") -> None + notify helper that some data was changed in the database and internal structures (e.g. caches) should be refreshed + -ida_merge.merge_node_helper_t_append_eavec (function) - merge_node_helper_t_append_eavec(s, prefix, eas) - - @param s: qstring * - @param prefix: char const * - @param eas: eavec_t const & +ida_merge.merge_node_info_t -ida_merge.merge_node_info_t (class) - Proxy of C++ merge_node_info2_t class. +ida_merge.merge_node_info_t.__init__(self, name: str, tag: "uchar", nds_flags: int, node_helper: "merge_node_helper_t" = None) -ida_merge.merge_node_info_t.__init__ (method) - __init__(self, name, tag, nds_flags, node_helper=None) -> merge_node_info_t - - @param name: char const * - @param tag: uchar - @param nds_flags: uint32 - @param node_helper: merge_node_helper_t * - -ida_merge.merge_node_info_t.name (variable) +ida_merge.merge_node_info_t.name name of the array (label) -ida_merge.merge_node_info_t.nds_flags (variable) +ida_merge.merge_node_info_t.nds_flags node value attributes (a combination of nds_flags_t) -ida_merge.merge_node_info_t.tag (variable) +ida_merge.merge_node_info_t.tag a tag used to access values in the netnode -ida_merge.moddata_diff_helper_t (class) - Proxy of C++ moddata_diff_helper_t class. +ida_merge.moddata_diff_helper_t -ida_merge.moddata_diff_helper_t.__disown__ (method) +ida_merge.moddata_diff_helper_t.__disown__(self) -ida_merge.moddata_diff_helper_t.__init__ (method) - __init__(self, _module_name, _netnode_name, _fields) -> moddata_diff_helper_t - - @param _module_name: char const * - @param _netnode_name: char const * - @param _fields: idbattr_info_t const * +ida_merge.moddata_diff_helper_t.__init__(self, _module_name: str, _netnode_name: str, _fields: "idbattr_info_t") -ida_merge.moddata_diff_helper_t.additional_mh_flags (variable) +ida_merge.moddata_diff_helper_t.additional_mh_flags additional merge handler flags -ida_merge.moddata_diff_helper_t.fields (variable) +ida_merge.moddata_diff_helper_t.fields module data attribute descriptions -ida_merge.moddata_diff_helper_t.get_struc_ptr (method) - get_struc_ptr(self, arg0, arg1, arg2) -> void * - - @param arg0: merge_data_t & - @param arg1: diff_source_idx_t - @param arg2: idbattr_info_t const & +ida_merge.moddata_diff_helper_t.get_struc_ptr(self, arg0: "merge_data_t", arg1: "diff_source_idx_t", arg2: "idbattr_info_t") -> "void *" -ida_merge.moddata_diff_helper_t.merge_ending (method) - merge_ending(self, arg0, arg1) - - @param arg0: diff_source_idx_t - @param arg1: void * +ida_merge.moddata_diff_helper_t.merge_ending(self, arg0: "diff_source_idx_t", arg1: "void *") -> None -ida_merge.moddata_diff_helper_t.merge_starting (method) - merge_starting(self, arg0, arg1) - - @param arg0: diff_source_idx_t - @param arg1: void * +ida_merge.moddata_diff_helper_t.merge_starting(self, arg0: "diff_source_idx_t", arg1: "void *") -> None -ida_merge.moddata_diff_helper_t.module_name (variable) +ida_merge.moddata_diff_helper_t.module_name will be used as a prefix for field desc -ida_merge.moddata_diff_helper_t.netnode_name (variable) +ida_merge.moddata_diff_helper_t.netnode_name name of netnode with module data attributes -ida_merge.moddata_diff_helper_t.nfields (variable) +ida_merge.moddata_diff_helper_t.nfields number of descriptions -ida_merge.moddata_diff_helper_t.print_diffpos_details (method) - print_diffpos_details(self, arg0, arg1) - - @param arg0: qstrvec_t * - @param arg1: idbattr_info_t const & +ida_merge.moddata_diff_helper_t.print_diffpos_details(self, arg0: "qstrvec_t *", arg1: "idbattr_info_t") -> None -ida_merge.moddata_diff_helper_t.str2val (method) - str2val(self, arg0, arg1, arg2) -> bool - - @param arg0: uint64 * - @param arg1: idbattr_info_t const & - @param arg2: char const * +ida_merge.moddata_diff_helper_t.str2val(self, arg0: "uint64 *", arg1: "idbattr_info_t", arg2: str) -> bool -ida_merge.moddata_diff_helper_t.val2str (method) - val2str(self, arg0, arg1, arg2) -> bool - - @param arg0: qstring * - @param arg1: idbattr_info_t const & - @param arg2: uint64 +ida_merge.moddata_diff_helper_t.val2str(self, arg0: str, arg1: "idbattr_info_t", arg2: "uint64") -> bool + +ida_undo + +ida_undo.create_undo_point(*args) -> bool + Create a new restore point. The user can undo to this point in the future. + + @param bytes: body of the record for UNDO_ACTION_START + @param size: size of the record for UNDO_ACTION_START + @returns success; fails if undo is disabled + +ida_undo.get_redo_action_label() -> str + Get the label of the action that will be redone. This function returns the text that can be displayed in the redo menu + + @returns success + +ida_undo.get_undo_action_label() -> str + Get the label of the action that will be undone. This function returns the text that can be displayed in the undo menu + + @returns success + +ida_undo.perform_redo() -> bool + Perform redo. + + @returns success + +ida_undo.perform_undo() -> bool + Perform undo. + + @returns success diff --git a/api_contents_pro.brief b/api_contents_pro.brief deleted file mode 100644 index c96f68e..0000000 --- a/api_contents_pro.brief +++ /dev/null @@ -1,14228 +0,0 @@ -ida_hexrays (module) -ida_hexrays.ACFL_BLKOPT (variable) -ida_hexrays.ACFL_GLBDEL (variable) -ida_hexrays.ACFL_GLBPROP (variable) -ida_hexrays.ACFL_GUESS (variable) -ida_hexrays.ACFL_LOCOPT (variable) -ida_hexrays.ALLOW_UNUSED_LABELS (variable) -ida_hexrays.ANCHOR_BLKCMT (variable) -ida_hexrays.ANCHOR_CITEM (variable) -ida_hexrays.ANCHOR_ITP (variable) -ida_hexrays.ANCHOR_LVAR (variable) -ida_hexrays.ANY_FPSIZE (variable) -ida_hexrays.ANY_REGSIZE (variable) -ida_hexrays.BLT_0WAY (variable) -ida_hexrays.BLT_1WAY (variable) -ida_hexrays.BLT_2WAY (variable) -ida_hexrays.BLT_NONE (variable) -ida_hexrays.BLT_NWAY (variable) -ida_hexrays.BLT_STOP (variable) -ida_hexrays.BLT_XTRN (variable) -ida_hexrays.CALC_CURLY_BRACES (variable) -ida_hexrays.CFL_FINAL (variable) -ida_hexrays.CFL_HELPER (variable) -ida_hexrays.CFL_NORET (variable) -ida_hexrays.CFS_BOUNDS (variable) -ida_hexrays.CFS_LOCKED (variable) -ida_hexrays.CFS_LVARS_HIDDEN (variable) -ida_hexrays.CFS_TEXT (variable) -ida_hexrays.CHF_FAKE (variable) -ida_hexrays.CHF_INITED (variable) -ida_hexrays.CHF_OVER (variable) -ida_hexrays.CHF_PASSTHRU (variable) -ida_hexrays.CHF_REPLACED (variable) -ida_hexrays.CHF_TERM (variable) -ida_hexrays.CIT_COLLAPSED (variable) -ida_hexrays.CMAT_BUILT (variable) -ida_hexrays.CMAT_CASTED (variable) -ida_hexrays.CMAT_CPA (variable) -ida_hexrays.CMAT_FINAL (variable) -ida_hexrays.CMAT_NICE (variable) -ida_hexrays.CMAT_TRANS1 (variable) -ida_hexrays.CMAT_TRANS2 (variable) -ida_hexrays.CMAT_TRANS3 (variable) -ida_hexrays.CMAT_ZERO (variable) -ida_hexrays.CMT_ALL (variable) -ida_hexrays.CMT_BLOCK1 (variable) -ida_hexrays.CMT_BLOCK2 (variable) -ida_hexrays.CMT_FUNC (variable) -ida_hexrays.CMT_LVAR (variable) -ida_hexrays.CMT_NONE (variable) -ida_hexrays.CMT_TAIL (variable) -ida_hexrays.CPBLK_FAST (variable) -ida_hexrays.CPBLK_MINREF (variable) -ida_hexrays.CPBLK_OPTJMP (variable) -ida_hexrays.CV_FAST (variable) -ida_hexrays.CV_INSNS (variable) -ida_hexrays.CV_PARENTS (variable) -ida_hexrays.CV_POST (variable) -ida_hexrays.CV_PRUNE (variable) -ida_hexrays.CV_RESTART (variable) -ida_hexrays.DECOMP_ALL_BLKS (variable) -ida_hexrays.DECOMP_GXREFS_DEFLT (variable) -ida_hexrays.DECOMP_GXREFS_FORCE (variable) -ida_hexrays.DECOMP_GXREFS_NOUPD (variable) -ida_hexrays.DECOMP_NO_CACHE (variable) -ida_hexrays.DECOMP_NO_FRAME (variable) -ida_hexrays.DECOMP_NO_HIDE (variable) -ida_hexrays.DECOMP_NO_WAIT (variable) -ida_hexrays.DECOMP_NO_XREFS (variable) -ida_hexrays.DECOMP_VOID_MBA (variable) -ida_hexrays.DECOMP_WARNINGS (variable) -ida_hexrays.DecompilationFailure (class) -ida_hexrays.EQ_CMPDEST (variable) -ida_hexrays.EQ_IGNCODE (variable) -ida_hexrays.EQ_IGNSIZE (variable) -ida_hexrays.EQ_OPTINSN (variable) -ida_hexrays.EXFL_ALL (variable) -ida_hexrays.EXFL_ALONE (variable) -ida_hexrays.EXFL_CPADONE (variable) -ida_hexrays.EXFL_CSTR (variable) -ida_hexrays.EXFL_FPOP (variable) -ida_hexrays.EXFL_JUMPOUT (variable) -ida_hexrays.EXFL_LVALUE (variable) -ida_hexrays.EXFL_PARTIAL (variable) -ida_hexrays.EXFL_UNDEF (variable) -ida_hexrays.EXFL_VFTABLE (variable) -ida_hexrays.FCI_DEAD (variable) -ida_hexrays.FCI_EXPLOCS (variable) -ida_hexrays.FCI_FINAL (variable) -ida_hexrays.FCI_HASCALL (variable) -ida_hexrays.FCI_HASFMT (variable) -ida_hexrays.FCI_NORET (variable) -ida_hexrays.FCI_NOSIDE (variable) -ida_hexrays.FCI_PROP (variable) -ida_hexrays.FCI_PURE (variable) -ida_hexrays.FCI_SPLOK (variable) -ida_hexrays.FD_BACKWARD (variable) -ida_hexrays.FD_DEF (variable) -ida_hexrays.FD_DIRTY (variable) -ida_hexrays.FD_FORWARD (variable) -ida_hexrays.FD_USE (variable) -ida_hexrays.FORBID_UNUSED_LABELS (variable) -ida_hexrays.GCA_ALLOC (variable) -ida_hexrays.GCA_EMPTY (variable) -ida_hexrays.GCA_NALLOC (variable) -ida_hexrays.GCA_OFIRST (variable) -ida_hexrays.GCA_OLAST (variable) -ida_hexrays.GCA_SPEC (variable) -ida_hexrays.GCO_DEF (variable) -ida_hexrays.GCO_REG (variable) -ida_hexrays.GCO_STK (variable) -ida_hexrays.GCO_USE (variable) -ida_hexrays.GC_ASR (variable) -ida_hexrays.GC_DIRTY_ALL (variable) -ida_hexrays.GC_END (variable) -ida_hexrays.GC_REGS_AND_STKVARS (variable) -ida_hexrays.GC_XDSU (variable) -ida_hexrays.GLN_ALL (variable) -ida_hexrays.GLN_CURRENT (variable) -ida_hexrays.GLN_GOTO_TARGET (variable) -ida_hexrays.Hexrays_Hooks (class) -ida_hexrays.Hexrays_Hooks.__disown__ (method) -ida_hexrays.Hexrays_Hooks.__init__ (method) -ida_hexrays.Hexrays_Hooks.build_callinfo (method) -ida_hexrays.Hexrays_Hooks.callinfo_built (method) -ida_hexrays.Hexrays_Hooks.calls_done (method) -ida_hexrays.Hexrays_Hooks.close_pseudocode (method) -ida_hexrays.Hexrays_Hooks.cmt_changed (method) -ida_hexrays.Hexrays_Hooks.combine (method) -ida_hexrays.Hexrays_Hooks.create_hint (method) -ida_hexrays.Hexrays_Hooks.curpos (method) -ida_hexrays.Hexrays_Hooks.double_click (method) -ida_hexrays.Hexrays_Hooks.flowchart (method) -ida_hexrays.Hexrays_Hooks.func_printed (method) -ida_hexrays.Hexrays_Hooks.glbopt (method) -ida_hexrays.Hexrays_Hooks.hook (method) -ida_hexrays.Hexrays_Hooks.interr (method) -ida_hexrays.Hexrays_Hooks.keyboard (method) -ida_hexrays.Hexrays_Hooks.locopt (method) -ida_hexrays.Hexrays_Hooks.lvar_cmt_changed (method) -ida_hexrays.Hexrays_Hooks.lvar_mapping_changed (method) -ida_hexrays.Hexrays_Hooks.lvar_name_changed (method) -ida_hexrays.Hexrays_Hooks.lvar_type_changed (method) -ida_hexrays.Hexrays_Hooks.maturity (method) -ida_hexrays.Hexrays_Hooks.microcode (method) -ida_hexrays.Hexrays_Hooks.open_pseudocode (method) -ida_hexrays.Hexrays_Hooks.populating_popup (method) -ida_hexrays.Hexrays_Hooks.prealloc (method) -ida_hexrays.Hexrays_Hooks.preoptimized (method) -ida_hexrays.Hexrays_Hooks.print_func (method) -ida_hexrays.Hexrays_Hooks.prolog (method) -ida_hexrays.Hexrays_Hooks.refresh_pseudocode (method) -ida_hexrays.Hexrays_Hooks.resolve_stkaddrs (method) -ida_hexrays.Hexrays_Hooks.right_click (method) -ida_hexrays.Hexrays_Hooks.stkpnts (method) -ida_hexrays.Hexrays_Hooks.structural (method) -ida_hexrays.Hexrays_Hooks.switch_pseudocode (method) -ida_hexrays.Hexrays_Hooks.text_ready (method) -ida_hexrays.Hexrays_Hooks.unhook (method) -ida_hexrays.IPROP_CLNPOP (variable) -ida_hexrays.IPROP_COMBINED (variable) -ida_hexrays.IPROP_DONT_COMB (variable) -ida_hexrays.IPROP_DONT_PROP (variable) -ida_hexrays.IPROP_EXTSTX (variable) -ida_hexrays.IPROP_FARCALL (variable) -ida_hexrays.IPROP_FPINSN (variable) -ida_hexrays.IPROP_IGNLOWSRC (variable) -ida_hexrays.IPROP_INV_JX (variable) -ida_hexrays.IPROP_MBARRIER (variable) -ida_hexrays.IPROP_MULTI_MOV (variable) -ida_hexrays.IPROP_OPTIONAL (variable) -ida_hexrays.IPROP_PERSIST (variable) -ida_hexrays.IPROP_SPLIT (variable) -ida_hexrays.IPROP_SPLIT1 (variable) -ida_hexrays.IPROP_SPLIT2 (variable) -ida_hexrays.IPROP_SPLIT4 (variable) -ida_hexrays.IPROP_SPLIT8 (variable) -ida_hexrays.IPROP_TAILCALL (variable) -ida_hexrays.IPROP_UNMERGED (variable) -ida_hexrays.IPROP_WAS_NORET (variable) -ida_hexrays.IPROP_WILDMATCH (variable) -ida_hexrays.ITP_ARG1 (variable) -ida_hexrays.ITP_ASM (variable) -ida_hexrays.ITP_BLOCK1 (variable) -ida_hexrays.ITP_BLOCK2 (variable) -ida_hexrays.ITP_BRACE2 (variable) -ida_hexrays.ITP_CASE (variable) -ida_hexrays.ITP_COLON (variable) -ida_hexrays.ITP_CURLY1 (variable) -ida_hexrays.ITP_CURLY2 (variable) -ida_hexrays.ITP_DO (variable) -ida_hexrays.ITP_ELSE (variable) -ida_hexrays.ITP_EMPTY (variable) -ida_hexrays.ITP_SEMI (variable) -ida_hexrays.ITP_SIGN (variable) -ida_hexrays.LOCOPT_ALL (variable) -ida_hexrays.LOCOPT_REFINE (variable) -ida_hexrays.LOCOPT_REFINE2 (variable) -ida_hexrays.LVINF_KEEP (variable) -ida_hexrays.LVINF_NOMAP (variable) -ida_hexrays.LVINF_NOPTR (variable) -ida_hexrays.LVINF_SPLIT (variable) -ida_hexrays.LVINF_UNUSED (variable) -ida_hexrays.MBA2_ARGIDX_OK (variable) -ida_hexrays.MBA2_ARGIDX_SORTED (variable) -ida_hexrays.MBA2_CODE16_BIT (variable) -ida_hexrays.MBA2_DONT_VERIFY (variable) -ida_hexrays.MBA2_HAS_OUTLINES (variable) -ida_hexrays.MBA2_IS_CTR (variable) -ida_hexrays.MBA2_IS_DTR (variable) -ida_hexrays.MBA2_LVARNAMES_OK (variable) -ida_hexrays.MBA2_LVARS_RENAMED (variable) -ida_hexrays.MBA2_NO_DUP_CALLS (variable) -ida_hexrays.MBA2_NO_DUP_LVARS (variable) -ida_hexrays.MBA2_NO_FRAME (variable) -ida_hexrays.MBA2_OVER_CHAINS (variable) -ida_hexrays.MBA2_PROP_COMPLEX (variable) -ida_hexrays.MBA2_STACK_RETVAL (variable) -ida_hexrays.MBA2_UNDEF_RETVAR (variable) -ida_hexrays.MBA2_VALRNG_DONE (variable) -ida_hexrays.MBA_ASRPROP (variable) -ida_hexrays.MBA_ASRTOK (variable) -ida_hexrays.MBA_CALLS (variable) -ida_hexrays.MBA_CHVARS (variable) -ida_hexrays.MBA_CMBBLK (variable) -ida_hexrays.MBA_CMNSTK (variable) -ida_hexrays.MBA_COLGDL (variable) -ida_hexrays.MBA_DELPAIRS (variable) -ida_hexrays.MBA_GLBOPT (variable) -ida_hexrays.MBA_INSGDL (variable) -ida_hexrays.MBA_LOADED (variable) -ida_hexrays.MBA_LVARS0 (variable) -ida_hexrays.MBA_LVARS1 (variable) -ida_hexrays.MBA_NICE (variable) -ida_hexrays.MBA_NOFUNC (variable) -ida_hexrays.MBA_NUMADDR (variable) -ida_hexrays.MBA_PASSREGS (variable) -ida_hexrays.MBA_PATTERN (variable) -ida_hexrays.MBA_PRCDEFS (variable) -ida_hexrays.MBA_PREOPT (variable) -ida_hexrays.MBA_REFINE (variable) -ida_hexrays.MBA_RETFP (variable) -ida_hexrays.MBA_RETREF (variable) -ida_hexrays.MBA_SAVRST (variable) -ida_hexrays.MBA_SHORT (variable) -ida_hexrays.MBA_SPLINFO (variable) -ida_hexrays.MBA_THUNK (variable) -ida_hexrays.MBA_VALNUM (variable) -ida_hexrays.MBA_WINGR32 (variable) -ida_hexrays.MBL_BACKPROP (variable) -ida_hexrays.MBL_CALL (variable) -ida_hexrays.MBL_COMB (variable) -ida_hexrays.MBL_DEAD (variable) -ida_hexrays.MBL_DMT64 (variable) -ida_hexrays.MBL_DSLOT (variable) -ida_hexrays.MBL_FAKE (variable) -ida_hexrays.MBL_GOTO (variable) -ida_hexrays.MBL_INCONST (variable) -ida_hexrays.MBL_KEEP (variable) -ida_hexrays.MBL_LIST (variable) -ida_hexrays.MBL_NONFAKE (variable) -ida_hexrays.MBL_NORET (variable) -ida_hexrays.MBL_PRIV (variable) -ida_hexrays.MBL_PROP (variable) -ida_hexrays.MBL_PUSH (variable) -ida_hexrays.MBL_TCAL (variable) -ida_hexrays.MBL_VALRANGES (variable) -ida_hexrays.MERR_BADARCH (variable) -ida_hexrays.MERR_BADBLK (variable) -ida_hexrays.MERR_BADCALL (variable) -ida_hexrays.MERR_BADFRAME (variable) -ida_hexrays.MERR_BADIDB (variable) -ida_hexrays.MERR_BADRANGES (variable) -ida_hexrays.MERR_BADSP (variable) -ida_hexrays.MERR_BITNESS (variable) -ida_hexrays.MERR_BLOCK (variable) -ida_hexrays.MERR_BUSY (variable) -ida_hexrays.MERR_CANCELED (variable) -ida_hexrays.MERR_COMPLEX (variable) -ida_hexrays.MERR_DSLOT (variable) -ida_hexrays.MERR_EXCEPTION (variable) -ida_hexrays.MERR_EXTERN (variable) -ida_hexrays.MERR_FARPTR (variable) -ida_hexrays.MERR_FUNCSIZE (variable) -ida_hexrays.MERR_HUGESTACK (variable) -ida_hexrays.MERR_INSN (variable) -ida_hexrays.MERR_INTERR (variable) -ida_hexrays.MERR_LICENSE (variable) -ida_hexrays.MERR_LOOP (variable) -ida_hexrays.MERR_LVARS (variable) -ida_hexrays.MERR_MEM (variable) -ida_hexrays.MERR_OK (variable) -ida_hexrays.MERR_ONLY32 (variable) -ida_hexrays.MERR_ONLY64 (variable) -ida_hexrays.MERR_OVERLAP (variable) -ida_hexrays.MERR_PARTINIT (variable) -ida_hexrays.MERR_PROLOG (variable) -ida_hexrays.MERR_RECDEPTH (variable) -ida_hexrays.MERR_REDO (variable) -ida_hexrays.MERR_SIZEOF (variable) -ida_hexrays.MERR_STOP (variable) -ida_hexrays.MERR_SWITCH (variable) -ida_hexrays.MERR_UNKTYPE (variable) -ida_hexrays.MLI_CLR_FLAGS (variable) -ida_hexrays.MLI_CMT (variable) -ida_hexrays.MLI_NAME (variable) -ida_hexrays.MLI_SET_FLAGS (variable) -ida_hexrays.MLI_TYPE (variable) -ida_hexrays.MMAT_CALLS (variable) -ida_hexrays.MMAT_GENERATED (variable) -ida_hexrays.MMAT_GLBOPT1 (variable) -ida_hexrays.MMAT_GLBOPT2 (variable) -ida_hexrays.MMAT_GLBOPT3 (variable) -ida_hexrays.MMAT_LOCOPT (variable) -ida_hexrays.MMAT_LVARS (variable) -ida_hexrays.MMAT_PREOPTIMIZED (variable) -ida_hexrays.MMAT_ZERO (variable) -ida_hexrays.MMIDX_GLBHIGH (variable) -ida_hexrays.MMIDX_GLBLOW (variable) -ida_hexrays.NALT_VD (variable) -ida_hexrays.NF_BINVDONE (variable) -ida_hexrays.NF_BITNOT (variable) -ida_hexrays.NF_FIXED (variable) -ida_hexrays.NF_NEGATE (variable) -ida_hexrays.NF_NEGDONE (variable) -ida_hexrays.NF_VALID (variable) -ida_hexrays.NOSIZE (variable) -ida_hexrays.NO_CURLY_BRACES (variable) -ida_hexrays.NO_SIDEFF (variable) -ida_hexrays.ONLY_SIDEFF (variable) -ida_hexrays.OPF_NEW_WINDOW (variable) -ida_hexrays.OPF_NO_WAIT (variable) -ida_hexrays.OPF_REUSE (variable) -ida_hexrays.OPF_REUSE_ACTIVE (variable) -ida_hexrays.OPROP_FLOAT (variable) -ida_hexrays.OPROP_IMPDONE (variable) -ida_hexrays.OPROP_LOWADDR (variable) -ida_hexrays.OPROP_UDEFVAL (variable) -ida_hexrays.OPROP_UDT (variable) -ida_hexrays.OPTI_ADDREXPRS (variable) -ida_hexrays.OPTI_COMBINSNS (variable) -ida_hexrays.OPTI_MINSTKREF (variable) -ida_hexrays.OPTI_NO_LDXOPT (variable) -ida_hexrays.RETRIEVE_ALWAYS (variable) -ida_hexrays.RETRIEVE_ONCE (variable) -ida_hexrays.ROLE_3WAYCMP0 (variable) -ida_hexrays.ROLE_3WAYCMP1 (variable) -ida_hexrays.ROLE_ABS (variable) -ida_hexrays.ROLE_ALLOCA (variable) -ida_hexrays.ROLE_BITTEST (variable) -ida_hexrays.ROLE_BITTESTANDCOMPLEMENT (variable) -ida_hexrays.ROLE_BITTESTANDRESET (variable) -ida_hexrays.ROLE_BITTESTANDSET (variable) -ida_hexrays.ROLE_BSWAP (variable) -ida_hexrays.ROLE_BUG (variable) -ida_hexrays.ROLE_CFSUB3 (variable) -ida_hexrays.ROLE_CONTAINING_RECORD (variable) -ida_hexrays.ROLE_EMPTY (variable) -ida_hexrays.ROLE_FASTFAIL (variable) -ida_hexrays.ROLE_IS_MUL_OK (variable) -ida_hexrays.ROLE_MEMCPY (variable) -ida_hexrays.ROLE_MEMSET (variable) -ida_hexrays.ROLE_MEMSET32 (variable) -ida_hexrays.ROLE_MEMSET64 (variable) -ida_hexrays.ROLE_OFSUB3 (variable) -ida_hexrays.ROLE_PRESENT (variable) -ida_hexrays.ROLE_READFLAGS (variable) -ida_hexrays.ROLE_ROL (variable) -ida_hexrays.ROLE_ROR (variable) -ida_hexrays.ROLE_SATURATED_MUL (variable) -ida_hexrays.ROLE_SSE_CMP4 (variable) -ida_hexrays.ROLE_SSE_CMP8 (variable) -ida_hexrays.ROLE_STRCAT (variable) -ida_hexrays.ROLE_STRCPY (variable) -ida_hexrays.ROLE_STRLEN (variable) -ida_hexrays.ROLE_TAIL (variable) -ida_hexrays.ROLE_UNK (variable) -ida_hexrays.ROLE_VA_ARG (variable) -ida_hexrays.ROLE_VA_COPY (variable) -ida_hexrays.ROLE_VA_END (variable) -ida_hexrays.ROLE_VA_START (variable) -ida_hexrays.ROLE_WCSCAT (variable) -ida_hexrays.ROLE_WCSCPY (variable) -ida_hexrays.ROLE_WCSLEN (variable) -ida_hexrays.ROLE_WMEMCPY (variable) -ida_hexrays.ROLE_WMEMSET (variable) -ida_hexrays.SHINS_LDXEA (variable) -ida_hexrays.SHINS_NUMADDR (variable) -ida_hexrays.SHINS_SHORT (variable) -ida_hexrays.SHINS_VALNUM (variable) -ida_hexrays.ULV_PRECISE_DEFEA (variable) -ida_hexrays.USE_CURLY_BRACES (variable) -ida_hexrays.USE_KEYBOARD (variable) -ida_hexrays.USE_MOUSE (variable) -ida_hexrays.VDI_EXPR (variable) -ida_hexrays.VDI_FUNC (variable) -ida_hexrays.VDI_LVAR (variable) -ida_hexrays.VDI_NONE (variable) -ida_hexrays.VDI_TAIL (variable) -ida_hexrays.VDRUN_APPEND (variable) -ida_hexrays.VDRUN_CMDLINE (variable) -ida_hexrays.VDRUN_LUMINA (variable) -ida_hexrays.VDRUN_MAYSTOP (variable) -ida_hexrays.VDRUN_NEWFILE (variable) -ida_hexrays.VDRUN_ONLYNEW (variable) -ida_hexrays.VDRUN_SENDIDB (variable) -ida_hexrays.VDRUN_SILENT (variable) -ida_hexrays.VDRUN_STATS (variable) -ida_hexrays.VDUI_VALID (variable) -ida_hexrays.VDUI_VISIBLE (variable) -ida_hexrays.VR_AT_END (variable) -ida_hexrays.VR_AT_START (variable) -ida_hexrays.VR_EXACT (variable) -ida_hexrays.WARN_ADDR_OUTARGS (variable) -ida_hexrays.WARN_ARRAY_INARG (variable) -ida_hexrays.WARN_BAD_CALL_SP (variable) -ida_hexrays.WARN_BAD_FIELD_TYPE (variable) -ida_hexrays.WARN_BAD_INSN (variable) -ida_hexrays.WARN_BAD_MAPDST (variable) -ida_hexrays.WARN_BAD_PURGED (variable) -ida_hexrays.WARN_BAD_RETVAR (variable) -ida_hexrays.WARN_BAD_SHADOW (variable) -ida_hexrays.WARN_BAD_SP (variable) -ida_hexrays.WARN_BAD_STD_TYPE (variable) -ida_hexrays.WARN_BAD_STKPNT (variable) -ida_hexrays.WARN_BAD_STROFF (variable) -ida_hexrays.WARN_BAD_VALRNG (variable) -ida_hexrays.WARN_BAD_VARSIZE (variable) -ida_hexrays.WARN_CBUILD_LOOPS (variable) -ida_hexrays.WARN_CR_BADOFF (variable) -ida_hexrays.WARN_CR_NOFIELD (variable) -ida_hexrays.WARN_DEP_UNK_CALLS (variable) -ida_hexrays.WARN_EXP_LINVAR (variable) -ida_hexrays.WARN_FIXED_MACRO (variable) -ida_hexrays.WARN_FRAG_LVAR (variable) -ida_hexrays.WARN_GUESSED_TYPE (variable) -ida_hexrays.WARN_HUGE_STKOFF (variable) -ida_hexrays.WARN_ILL_ELLIPSIS (variable) -ida_hexrays.WARN_ILL_FPU_STACK (variable) -ida_hexrays.WARN_ILL_FUNCTYPE (variable) -ida_hexrays.WARN_ILL_PURGED (variable) -ida_hexrays.WARN_JUMPOUT (variable) -ida_hexrays.WARN_MAX (variable) -ida_hexrays.WARN_MAX_ARGS (variable) -ida_hexrays.WARN_MISSED_SWITCH (variable) -ida_hexrays.WARN_MUST_RET_FP (variable) -ida_hexrays.WARN_NO_SAVE_REST (variable) -ida_hexrays.WARN_ODD_ABI (variable) -ida_hexrays.WARN_ODD_ADDR_USE (variable) -ida_hexrays.WARN_ODD_INPUT_REG (variable) -ida_hexrays.WARN_OPT_USELESS_JCND (variable) -ida_hexrays.WARN_OPT_VALRNG (variable) -ida_hexrays.WARN_OPT_VALRNG2 (variable) -ida_hexrays.WARN_OPT_VALRNG3 (variable) -ida_hexrays.WARN_RET_LOCREF (variable) -ida_hexrays.WARN_SELFREF_PROP (variable) -ida_hexrays.WARN_UNALIGNED_ARG (variable) -ida_hexrays.WARN_UNBALANCED_STACK (variable) -ida_hexrays.WARN_UNDEF_LVAR (variable) -ida_hexrays.WARN_UNINITED_REG (variable) -ida_hexrays.WARN_UNSUPP_REG (variable) -ida_hexrays.WARN_VARARG_MANY (variable) -ida_hexrays.WARN_VARARG_NOSTK (variable) -ida_hexrays.WARN_VARARG_REGS (variable) -ida_hexrays.WARN_VARARG_TCAL (variable) -ida_hexrays.WARN_WIDEN_CHAINS (variable) -ida_hexrays.WARN_WOULD_OVERLAP (variable) -ida_hexrays.WARN_WRITE_CONST (variable) -ida_hexrays.WARN_WRONG_VA_OFF (variable) -ida_hexrays.WITH_SIDEFF (variable) -ida_hexrays.__cbhooks_t (class) -ida_hexrays.__cbhooks_t.__init__ (method) -ida_hexrays.__cbhooks_t.close_pseudocode (method) -ida_hexrays.__cbhooks_t.create_hint (method) -ida_hexrays.__cbhooks_t.curpos (method) -ida_hexrays.__cbhooks_t.double_click (method) -ida_hexrays.__cbhooks_t.func_printed (method) -ida_hexrays.__cbhooks_t.interr (method) -ida_hexrays.__cbhooks_t.keyboard (method) -ida_hexrays.__cbhooks_t.maturity (method) -ida_hexrays.__cbhooks_t.open_pseudocode (method) -ida_hexrays.__cbhooks_t.populating_popup (method) -ida_hexrays.__cbhooks_t.print_func (method) -ida_hexrays.__cbhooks_t.refresh_pseudocode (method) -ida_hexrays.__cbhooks_t.right_click (method) -ida_hexrays.__cbhooks_t.switch_pseudocode (method) -ida_hexrays.__cbhooks_t.text_ready (method) -ida_hexrays._call_with_transferrable_ownership (function) -ida_hexrays._kludge_force_declare_TPopupMenu (function) -ida_hexrays._ll_call_helper (function) -ida_hexrays._ll_create_helper (function) -ida_hexrays._ll_dereference (function) -ida_hexrays._ll_lnot (function) -ida_hexrays._ll_make_num (function) -ida_hexrays._ll_make_ref (function) -ida_hexrays._ll_new_block (function) -ida_hexrays._map_as_dict (function) -ida_hexrays._map_as_dict._map___contains__ (function) -ida_hexrays._map_as_dict._map___delitem__ (function) -ida_hexrays._map_as_dict._map___getitem__ (function) -ida_hexrays._map_as_dict._map___iter__ (function) -ida_hexrays._map_as_dict._map___setitem__ (function) -ida_hexrays._map_as_dict._map_clear (function) -ida_hexrays._map_as_dict._map_copy (function) -ida_hexrays._map_as_dict._map_get (function) -ida_hexrays._map_as_dict._map_has_key (function) -ida_hexrays._map_as_dict._map_items (function) -ida_hexrays._map_as_dict._map_iteritems (function) -ida_hexrays._map_as_dict._map_iterkeys (function) -ida_hexrays._map_as_dict._map_itervalues (function) -ida_hexrays._map_as_dict._map_keys (function) -ida_hexrays._map_as_dict._map_pop (function) -ida_hexrays._map_as_dict._map_popitem (function) -ida_hexrays._map_as_dict._map_setdefault (function) -ida_hexrays._map_as_dict._map_values (function) -ida_hexrays.accepts_small_udts (function) -ida_hexrays.accepts_udts (function) -ida_hexrays.arglocs_overlap (function) -ida_hexrays.array_of_bitsets (class) -ida_hexrays.array_of_bitsets.__eq__ (method) -ida_hexrays.array_of_bitsets.__getitem__ (method) -ida_hexrays.array_of_bitsets.__init__ (method) -ida_hexrays.array_of_bitsets.__len__ (method) -ida_hexrays.array_of_bitsets.__ne__ (method) -ida_hexrays.array_of_bitsets.__setitem__ (method) -ida_hexrays.array_of_bitsets._del (method) -ida_hexrays.array_of_bitsets.add_unique (method) -ida_hexrays.array_of_bitsets.at (method) -ida_hexrays.array_of_bitsets.begin (method) -ida_hexrays.array_of_bitsets.capacity (method) -ida_hexrays.array_of_bitsets.clear (method) -ida_hexrays.array_of_bitsets.empty (method) -ida_hexrays.array_of_bitsets.end (method) -ida_hexrays.array_of_bitsets.erase (method) -ida_hexrays.array_of_bitsets.extract (method) -ida_hexrays.array_of_bitsets.find (method) -ida_hexrays.array_of_bitsets.grow (method) -ida_hexrays.array_of_bitsets.has (method) -ida_hexrays.array_of_bitsets.inject (method) -ida_hexrays.array_of_bitsets.insert (method) -ida_hexrays.array_of_bitsets.pop_back (method) -ida_hexrays.array_of_bitsets.push_back (method) -ida_hexrays.array_of_bitsets.qclear (method) -ida_hexrays.array_of_bitsets.reserve (method) -ida_hexrays.array_of_bitsets.resize (method) -ida_hexrays.array_of_bitsets.size (method) -ida_hexrays.array_of_bitsets.swap (method) -ida_hexrays.array_of_bitsets.truncate (method) -ida_hexrays.array_of_ivlsets (class) -ida_hexrays.array_of_ivlsets.__eq__ (method) -ida_hexrays.array_of_ivlsets.__getitem__ (method) -ida_hexrays.array_of_ivlsets.__init__ (method) -ida_hexrays.array_of_ivlsets.__len__ (method) -ida_hexrays.array_of_ivlsets.__ne__ (method) -ida_hexrays.array_of_ivlsets.__setitem__ (method) -ida_hexrays.array_of_ivlsets._del (method) -ida_hexrays.array_of_ivlsets.add_unique (method) -ida_hexrays.array_of_ivlsets.at (method) -ida_hexrays.array_of_ivlsets.begin (method) -ida_hexrays.array_of_ivlsets.capacity (method) -ida_hexrays.array_of_ivlsets.clear (method) -ida_hexrays.array_of_ivlsets.empty (method) -ida_hexrays.array_of_ivlsets.end (method) -ida_hexrays.array_of_ivlsets.erase (method) -ida_hexrays.array_of_ivlsets.extract (method) -ida_hexrays.array_of_ivlsets.find (method) -ida_hexrays.array_of_ivlsets.grow (method) -ida_hexrays.array_of_ivlsets.has (method) -ida_hexrays.array_of_ivlsets.inject (method) -ida_hexrays.array_of_ivlsets.insert (method) -ida_hexrays.array_of_ivlsets.pop_back (method) -ida_hexrays.array_of_ivlsets.push_back (method) -ida_hexrays.array_of_ivlsets.qclear (method) -ida_hexrays.array_of_ivlsets.reserve (method) -ida_hexrays.array_of_ivlsets.resize (method) -ida_hexrays.array_of_ivlsets.size (method) -ida_hexrays.array_of_ivlsets.swap (method) -ida_hexrays.array_of_ivlsets.truncate (method) -ida_hexrays.asgop (function) -ida_hexrays.asgop_revert (function) -ida_hexrays.bit_bound_t (class) -ida_hexrays.bit_bound_t.__init__ (method) -ida_hexrays.bitset_t (class) -ida_hexrays.bitset_t.__eq__ (method) -ida_hexrays.bitset_t.__ge__ (method) -ida_hexrays.bitset_t.__gt__ (method) -ida_hexrays.bitset_t.__init__ (method) -ida_hexrays.bitset_t.__iter__ (method) -ida_hexrays.bitset_t.__le__ (method) -ida_hexrays.bitset_t.__lt__ (method) -ida_hexrays.bitset_t.__ne__ (method) -ida_hexrays.bitset_t.add (method) -ida_hexrays.bitset_t.back (method) -ida_hexrays.bitset_t.begin (method) -ida_hexrays.bitset_t.clear (method) -ida_hexrays.bitset_t.compare (method) -ida_hexrays.bitset_t.copy (method) -ida_hexrays.bitset_t.count (method) -ida_hexrays.bitset_t.cut_at (method) -ida_hexrays.bitset_t.dstr (method) -ida_hexrays.bitset_t.empty (method) -ida_hexrays.bitset_t.end (method) -ida_hexrays.bitset_t.fill_with_ones (method) -ida_hexrays.bitset_t.front (method) -ida_hexrays.bitset_t.has (method) -ida_hexrays.bitset_t.has_all (method) -ida_hexrays.bitset_t.has_any (method) -ida_hexrays.bitset_t.has_common (method) -ida_hexrays.bitset_t.inc (method) -ida_hexrays.bitset_t.includes (method) -ida_hexrays.bitset_t.intersect (method) -ida_hexrays.bitset_t.is_subset_of (method) -ida_hexrays.bitset_t.itat (method) -ida_hexrays.bitset_t.itv (method) -ida_hexrays.bitset_t.last (method) -ida_hexrays.bitset_t.shift_down (method) -ida_hexrays.bitset_t.sub (method) -ida_hexrays.bitset_t.swap (method) -ida_hexrays.block_chains_begin (function) -ida_hexrays.block_chains_clear (function) -ida_hexrays.block_chains_end (function) -ida_hexrays.block_chains_erase (function) -ida_hexrays.block_chains_find (function) -ida_hexrays.block_chains_free (function) -ida_hexrays.block_chains_get (function) -ida_hexrays.block_chains_insert (function) -ida_hexrays.block_chains_iterator_t (class) -ida_hexrays.block_chains_iterator_t.__eq__ (method) -ida_hexrays.block_chains_iterator_t.__init__ (method) -ida_hexrays.block_chains_iterator_t.__ne__ (method) -ida_hexrays.block_chains_new (function) -ida_hexrays.block_chains_next (function) -ida_hexrays.block_chains_prev (function) -ida_hexrays.block_chains_size (function) -ida_hexrays.block_chains_t (class) -ida_hexrays.block_chains_t.__init__ (method) -ida_hexrays.block_chains_t._print (method) -ida_hexrays.block_chains_t.dstr (method) -ida_hexrays.block_chains_t.get_chain (method) -ida_hexrays.block_chains_t.get_reg_chain (method) -ida_hexrays.block_chains_t.get_stk_chain (method) -ida_hexrays.block_chains_vec_t (class) -ida_hexrays.block_chains_vec_t.__getitem__ (method) -ida_hexrays.block_chains_vec_t.__init__ (method) -ida_hexrays.block_chains_vec_t.__len__ (method) -ida_hexrays.block_chains_vec_t.__setitem__ (method) -ida_hexrays.block_chains_vec_t.at (method) -ida_hexrays.block_chains_vec_t.begin (method) -ida_hexrays.block_chains_vec_t.capacity (method) -ida_hexrays.block_chains_vec_t.clear (method) -ida_hexrays.block_chains_vec_t.empty (method) -ida_hexrays.block_chains_vec_t.end (method) -ida_hexrays.block_chains_vec_t.erase (method) -ida_hexrays.block_chains_vec_t.extract (method) -ida_hexrays.block_chains_vec_t.grow (method) -ida_hexrays.block_chains_vec_t.inject (method) -ida_hexrays.block_chains_vec_t.insert (method) -ida_hexrays.block_chains_vec_t.pop_back (method) -ida_hexrays.block_chains_vec_t.push_back (method) -ida_hexrays.block_chains_vec_t.qclear (method) -ida_hexrays.block_chains_vec_t.reserve (method) -ida_hexrays.block_chains_vec_t.resize (method) -ida_hexrays.block_chains_vec_t.size (method) -ida_hexrays.block_chains_vec_t.swap (method) -ida_hexrays.block_chains_vec_t.truncate (method) -ida_hexrays.boundaries_begin (function) -ida_hexrays.boundaries_clear (function) -ida_hexrays.boundaries_end (function) -ida_hexrays.boundaries_erase (function) -ida_hexrays.boundaries_find (function) -ida_hexrays.boundaries_first (function) -ida_hexrays.boundaries_free (function) -ida_hexrays.boundaries_insert (function) -ida_hexrays.boundaries_iterator_t (class) -ida_hexrays.boundaries_iterator_t.__eq__ (method) -ida_hexrays.boundaries_iterator_t.__init__ (method) -ida_hexrays.boundaries_iterator_t.__ne__ (method) -ida_hexrays.boundaries_new (function) -ida_hexrays.boundaries_next (function) -ida_hexrays.boundaries_prev (function) -ida_hexrays.boundaries_second (function) -ida_hexrays.boundaries_size (function) -ida_hexrays.boundaries_t (class) -ida_hexrays.boundaries_t.__init__ (method) -ida_hexrays.boundaries_t.at (method) -ida_hexrays.boundaries_t.size (method) -ida_hexrays.call_helper (function) -ida_hexrays.carg_t (class) -ida_hexrays.carg_t.__eq__ (method) -ida_hexrays.carg_t.__ge__ (method) -ida_hexrays.carg_t.__gt__ (method) -ida_hexrays.carg_t.__init__ (method) -ida_hexrays.carg_t.__le__ (method) -ida_hexrays.carg_t.__lt__ (method) -ida_hexrays.carg_t.__ne__ (method) -ida_hexrays.carg_t.compare (method) -ida_hexrays.carg_t.consume_cexpr (method) -ida_hexrays.carg_t.formal_type (variable) -ida_hexrays.carg_t.is_vararg (variable) -ida_hexrays.carglist_t (class) -ida_hexrays.carglist_t.__eq__ (method) -ida_hexrays.carglist_t.__ge__ (method) -ida_hexrays.carglist_t.__gt__ (method) -ida_hexrays.carglist_t.__init__ (method) -ida_hexrays.carglist_t.__le__ (method) -ida_hexrays.carglist_t.__lt__ (method) -ida_hexrays.carglist_t.__ne__ (method) -ida_hexrays.carglist_t.compare (method) -ida_hexrays.carglist_t.flags (variable) -ida_hexrays.carglist_t.functype (variable) -ida_hexrays.casm_t (class) -ida_hexrays.casm_t.__eq__ (method) -ida_hexrays.casm_t.__ge__ (method) -ida_hexrays.casm_t.__gt__ (method) -ida_hexrays.casm_t.__init__ (method) -ida_hexrays.casm_t.__le__ (method) -ida_hexrays.casm_t.__lt__ (method) -ida_hexrays.casm_t.__ne__ (method) -ida_hexrays.casm_t.compare (method) -ida_hexrays.casm_t.one_insn (method) -ida_hexrays.cblock_t (class) -ida_hexrays.cblock_t.__eq__ (method) -ida_hexrays.cblock_t.__ge__ (method) -ida_hexrays.cblock_t.__gt__ (method) -ida_hexrays.cblock_t.__init__ (method) -ida_hexrays.cblock_t.__le__ (method) -ida_hexrays.cblock_t.__lt__ (method) -ida_hexrays.cblock_t.__ne__ (method) -ida_hexrays.cblock_t._deregister (method) -ida_hexrays.cblock_t.compare (method) -ida_hexrays.ccase_t (class) -ida_hexrays.ccase_t.__eq__ (method) -ida_hexrays.ccase_t.__ge__ (method) -ida_hexrays.ccase_t.__gt__ (method) -ida_hexrays.ccase_t.__init__ (method) -ida_hexrays.ccase_t.__le__ (method) -ida_hexrays.ccase_t.__lt__ (method) -ida_hexrays.ccase_t.__ne__ (method) -ida_hexrays.ccase_t.compare (method) -ida_hexrays.ccase_t.size (method) -ida_hexrays.ccase_t.value (method) -ida_hexrays.ccase_t.values (variable) -ida_hexrays.ccases_t (class) -ida_hexrays.ccases_t.__eq__ (method) -ida_hexrays.ccases_t.__ge__ (method) -ida_hexrays.ccases_t.__gt__ (method) -ida_hexrays.ccases_t.__init__ (method) -ida_hexrays.ccases_t.__le__ (method) -ida_hexrays.ccases_t.__lt__ (method) -ida_hexrays.ccases_t.__ne__ (method) -ida_hexrays.ccases_t.compare (method) -ida_hexrays.cdg_insn_iterator_t (class) -ida_hexrays.cdg_insn_iterator_t.__init__ (method) -ida_hexrays.cdg_insn_iterator_t.dslot_with_xrefs (method) -ida_hexrays.cdg_insn_iterator_t.has_dslot (method) -ida_hexrays.cdg_insn_iterator_t.is_severed_dslot (method) -ida_hexrays.cdg_insn_iterator_t.next (method) -ida_hexrays.cdg_insn_iterator_t.ok (method) -ida_hexrays.cdg_insn_iterator_t.start (method) -ida_hexrays.cdo_t (class) -ida_hexrays.cdo_t.__eq__ (method) -ida_hexrays.cdo_t.__ge__ (method) -ida_hexrays.cdo_t.__gt__ (method) -ida_hexrays.cdo_t.__init__ (method) -ida_hexrays.cdo_t.__le__ (method) -ida_hexrays.cdo_t.__lt__ (method) -ida_hexrays.cdo_t.__ne__ (method) -ida_hexrays.cdo_t.compare (method) -ida_hexrays.ceinsn_t (class) -ida_hexrays.ceinsn_t.__init__ (method) -ida_hexrays.ceinsn_t.expr (variable) -ida_hexrays.cexpr_operands (function) -ida_hexrays.cexpr_t (class) -ida_hexrays.cexpr_t.__eq__ (method) -ida_hexrays.cexpr_t.__ge__ (method) -ida_hexrays.cexpr_t.__gt__ (method) -ida_hexrays.cexpr_t.__init__ (method) -ida_hexrays.cexpr_t.__le__ (method) -ida_hexrays.cexpr_t.__lt__ (method) -ida_hexrays.cexpr_t.__ne__ (method) -ida_hexrays.cexpr_t._deregister (method) -ida_hexrays.cexpr_t._get_a (method) -ida_hexrays.cexpr_t._get_fpc (method) -ida_hexrays.cexpr_t._get_helper (method) -ida_hexrays.cexpr_t._get_insn (method) -ida_hexrays.cexpr_t._get_m (method) -ida_hexrays.cexpr_t._get_n (method) -ida_hexrays.cexpr_t._get_obj_ea (method) -ida_hexrays.cexpr_t._get_ptrsize (method) -ida_hexrays.cexpr_t._get_refwidth (method) -ida_hexrays.cexpr_t._get_string (method) -ida_hexrays.cexpr_t._get_x (method) -ida_hexrays.cexpr_t._get_y (method) -ida_hexrays.cexpr_t._get_z (method) -ida_hexrays.cexpr_t._register (method) -ida_hexrays.cexpr_t._replace_by (method) -ida_hexrays.cexpr_t._set_a (method) -ida_hexrays.cexpr_t._set_fpc (method) -ida_hexrays.cexpr_t._set_helper (method) -ida_hexrays.cexpr_t._set_insn (method) -ida_hexrays.cexpr_t._set_m (method) -ida_hexrays.cexpr_t._set_n (method) -ida_hexrays.cexpr_t._set_obj_ea (method) -ida_hexrays.cexpr_t._set_ptrsize (method) -ida_hexrays.cexpr_t._set_refwidth (method) -ida_hexrays.cexpr_t._set_string (method) -ida_hexrays.cexpr_t._set_x (method) -ida_hexrays.cexpr_t._set_y (method) -ida_hexrays.cexpr_t._set_z (method) -ida_hexrays.cexpr_t.a (variable) -ida_hexrays.cexpr_t.assign (method) -ida_hexrays.cexpr_t.calc_type (method) -ida_hexrays.cexpr_t.cleanup (method) -ida_hexrays.cexpr_t.compare (method) -ida_hexrays.cexpr_t.contains_comma (method) -ida_hexrays.cexpr_t.contains_comma_or_insn_or_label (method) -ida_hexrays.cexpr_t.contains_insn (method) -ida_hexrays.cexpr_t.contains_insn_or_label (method) -ida_hexrays.cexpr_t.contains_operator (method) -ida_hexrays.cexpr_t.cpadone (method) -ida_hexrays.cexpr_t.dstr (method) -ida_hexrays.cexpr_t.equal_effect (method) -ida_hexrays.cexpr_t.exflags (variable) -ida_hexrays.cexpr_t.find_num_op (method) -ida_hexrays.cexpr_t.find_op (method) -ida_hexrays.cexpr_t.fpc (variable) -ida_hexrays.cexpr_t.get_1num_op (method) -ida_hexrays.cexpr_t.get_const_value (method) -ida_hexrays.cexpr_t.get_high_nbit_bound (method) -ida_hexrays.cexpr_t.get_low_nbit_bound (method) -ida_hexrays.cexpr_t.get_ptr_or_array (method) -ida_hexrays.cexpr_t.get_type_sign (method) -ida_hexrays.cexpr_t.get_v (method) -ida_hexrays.cexpr_t.has_side_effects (method) -ida_hexrays.cexpr_t.helper (variable) -ida_hexrays.cexpr_t.insn (variable) -ida_hexrays.cexpr_t.is_call_arg_of (method) -ida_hexrays.cexpr_t.is_call_object_of (method) -ida_hexrays.cexpr_t.is_child_of (method) -ida_hexrays.cexpr_t.is_const_value (method) -ida_hexrays.cexpr_t.is_cstr (method) -ida_hexrays.cexpr_t.is_fpop (method) -ida_hexrays.cexpr_t.is_jumpout (method) -ida_hexrays.cexpr_t.is_negative_const (method) -ida_hexrays.cexpr_t.is_nice_cond (method) -ida_hexrays.cexpr_t.is_nice_expr (method) -ida_hexrays.cexpr_t.is_non_negative_const (method) -ida_hexrays.cexpr_t.is_non_zero_const (method) -ida_hexrays.cexpr_t.is_odd_lvalue (method) -ida_hexrays.cexpr_t.is_type_signed (method) -ida_hexrays.cexpr_t.is_type_unsigned (method) -ida_hexrays.cexpr_t.is_undef_val (method) -ida_hexrays.cexpr_t.is_vftable (method) -ida_hexrays.cexpr_t.is_zero_const (method) -ida_hexrays.cexpr_t.m (variable) -ida_hexrays.cexpr_t.maybe_ptr (method) -ida_hexrays.cexpr_t.n (variable) -ida_hexrays.cexpr_t.numval (method) -ida_hexrays.cexpr_t.obj_ea (variable) -ida_hexrays.cexpr_t.print1 (method) -ida_hexrays.cexpr_t.ptrsize (variable) -ida_hexrays.cexpr_t.put_number (method) -ida_hexrays.cexpr_t.refwidth (variable) -ida_hexrays.cexpr_t.requires_lvalue (method) -ida_hexrays.cexpr_t.set_cpadone (method) -ida_hexrays.cexpr_t.set_v (method) -ida_hexrays.cexpr_t.set_vftable (method) -ida_hexrays.cexpr_t.string (variable) -ida_hexrays.cexpr_t.swap (method) -ida_hexrays.cexpr_t.theother (method) -ida_hexrays.cexpr_t.type (variable) -ida_hexrays.cexpr_t.v (variable) -ida_hexrays.cexpr_t.x (variable) -ida_hexrays.cexpr_t.y (variable) -ida_hexrays.cexpr_t.z (variable) -ida_hexrays.cfor_t (class) -ida_hexrays.cfor_t.__eq__ (method) -ida_hexrays.cfor_t.__ge__ (method) -ida_hexrays.cfor_t.__gt__ (method) -ida_hexrays.cfor_t.__init__ (method) -ida_hexrays.cfor_t.__le__ (method) -ida_hexrays.cfor_t.__lt__ (method) -ida_hexrays.cfor_t.__ne__ (method) -ida_hexrays.cfor_t.compare (method) -ida_hexrays.cfor_t.init (variable) -ida_hexrays.cfor_t.step (variable) -ida_hexrays.cfunc_parentee_t (class) -ida_hexrays.cfunc_parentee_t.__disown__ (method) -ida_hexrays.cfunc_parentee_t.__init__ (method) -ida_hexrays.cfunc_parentee_t.calc_rvalue_type (method) -ida_hexrays.cfunc_parentee_t.func (variable) -ida_hexrays.cfunc_t (class) -ida_hexrays.cfunc_t.__init__ (method) -ida_hexrays.cfunc_t.__str__ (method) -ida_hexrays.cfunc_t.argidx (variable) -ida_hexrays.cfunc_t.body (variable) -ida_hexrays.cfunc_t.build_c_tree (method) -ida_hexrays.cfunc_t.del_orphan_cmts (method) -ida_hexrays.cfunc_t.entry_ea (variable) -ida_hexrays.cfunc_t.find_item_coords (method) -ida_hexrays.cfunc_t.find_label (method) -ida_hexrays.cfunc_t.gather_derefs (method) -ida_hexrays.cfunc_t.get_boundaries (method) -ida_hexrays.cfunc_t.get_eamap (method) -ida_hexrays.cfunc_t.get_func_type (method) -ida_hexrays.cfunc_t.get_line_item (method) -ida_hexrays.cfunc_t.get_lvars (method) -ida_hexrays.cfunc_t.get_pseudocode (method) -ida_hexrays.cfunc_t.get_stkoff_delta (method) -ida_hexrays.cfunc_t.get_user_cmt (method) -ida_hexrays.cfunc_t.get_user_iflags (method) -ida_hexrays.cfunc_t.get_user_union_selection (method) -ida_hexrays.cfunc_t.get_warnings (method) -ida_hexrays.cfunc_t.has_orphan_cmts (method) -ida_hexrays.cfunc_t.hdrlines (variable) -ida_hexrays.cfunc_t.locked (method) -ida_hexrays.cfunc_t.maturity (variable) -ida_hexrays.cfunc_t.mba (variable) -ida_hexrays.cfunc_t.numforms (variable) -ida_hexrays.cfunc_t.print_dcl (method) -ida_hexrays.cfunc_t.print_func (method) -ida_hexrays.cfunc_t.refcnt (variable) -ida_hexrays.cfunc_t.refresh_func_ctext (method) -ida_hexrays.cfunc_t.release (method) -ida_hexrays.cfunc_t.remove_unused_labels (method) -ida_hexrays.cfunc_t.save_user_cmts (method) -ida_hexrays.cfunc_t.save_user_iflags (method) -ida_hexrays.cfunc_t.save_user_labels (method) -ida_hexrays.cfunc_t.save_user_numforms (method) -ida_hexrays.cfunc_t.save_user_unions (method) -ida_hexrays.cfunc_t.set_user_cmt (method) -ida_hexrays.cfunc_t.set_user_iflags (method) -ida_hexrays.cfunc_t.set_user_union_selection (method) -ida_hexrays.cfunc_t.statebits (variable) -ida_hexrays.cfunc_t.treeitems (variable) -ida_hexrays.cfunc_t.user_cmts (variable) -ida_hexrays.cfunc_t.user_iflags (variable) -ida_hexrays.cfunc_t.user_labels (variable) -ida_hexrays.cfunc_t.user_unions (variable) -ida_hexrays.cfunc_t.verify (method) -ida_hexrays.cfunc_type (function) -ida_hexrays.cfuncptr_t (class) -ida_hexrays.cfuncptr_t.__deref__ (method) -ida_hexrays.cfuncptr_t.__init__ (method) -ida_hexrays.cfuncptr_t.__ptrval__ (method) -ida_hexrays.cfuncptr_t.__ref__ (method) -ida_hexrays.cfuncptr_t.__str__ (method) -ida_hexrays.cfuncptr_t.build_c_tree (method) -ida_hexrays.cfuncptr_t.del_orphan_cmts (method) -ida_hexrays.cfuncptr_t.find_item_coords (method) -ida_hexrays.cfuncptr_t.find_label (method) -ida_hexrays.cfuncptr_t.gather_derefs (method) -ida_hexrays.cfuncptr_t.get_boundaries (method) -ida_hexrays.cfuncptr_t.get_eamap (method) -ida_hexrays.cfuncptr_t.get_func_type (method) -ida_hexrays.cfuncptr_t.get_line_item (method) -ida_hexrays.cfuncptr_t.get_lvars (method) -ida_hexrays.cfuncptr_t.get_pseudocode (method) -ida_hexrays.cfuncptr_t.get_stkoff_delta (method) -ida_hexrays.cfuncptr_t.get_user_cmt (method) -ida_hexrays.cfuncptr_t.get_user_iflags (method) -ida_hexrays.cfuncptr_t.get_user_union_selection (method) -ida_hexrays.cfuncptr_t.get_warnings (method) -ida_hexrays.cfuncptr_t.has_orphan_cmts (method) -ida_hexrays.cfuncptr_t.locked (method) -ida_hexrays.cfuncptr_t.print_dcl (method) -ida_hexrays.cfuncptr_t.print_func (method) -ida_hexrays.cfuncptr_t.refresh_func_ctext (method) -ida_hexrays.cfuncptr_t.release (method) -ida_hexrays.cfuncptr_t.remove_unused_labels (method) -ida_hexrays.cfuncptr_t.reset (method) -ida_hexrays.cfuncptr_t.save_user_cmts (method) -ida_hexrays.cfuncptr_t.save_user_iflags (method) -ida_hexrays.cfuncptr_t.save_user_labels (method) -ida_hexrays.cfuncptr_t.save_user_numforms (method) -ida_hexrays.cfuncptr_t.save_user_unions (method) -ida_hexrays.cfuncptr_t.set_user_cmt (method) -ida_hexrays.cfuncptr_t.set_user_iflags (method) -ida_hexrays.cfuncptr_t.set_user_union_selection (method) -ida_hexrays.cfuncptr_t.verify (method) -ida_hexrays.cgoto_t (class) -ida_hexrays.cgoto_t.__eq__ (method) -ida_hexrays.cgoto_t.__ge__ (method) -ida_hexrays.cgoto_t.__gt__ (method) -ida_hexrays.cgoto_t.__init__ (method) -ida_hexrays.cgoto_t.__le__ (method) -ida_hexrays.cgoto_t.__lt__ (method) -ida_hexrays.cgoto_t.__ne__ (method) -ida_hexrays.cgoto_t.compare (method) -ida_hexrays.cgoto_t.label_num (variable) -ida_hexrays.chain_keeper_t (class) -ida_hexrays.chain_keeper_t.__init__ (method) -ida_hexrays.chain_keeper_t.back (method) -ida_hexrays.chain_keeper_t.for_all_chains (method) -ida_hexrays.chain_keeper_t.front (method) -ida_hexrays.chain_t (class) -ida_hexrays.chain_t.__init__ (method) -ida_hexrays.chain_t.__lt__ (method) -ida_hexrays.chain_t._print (method) -ida_hexrays.chain_t.append_list (method) -ida_hexrays.chain_t.clear_varnum (method) -ida_hexrays.chain_t.dstr (method) -ida_hexrays.chain_t.endoff (method) -ida_hexrays.chain_t.flags (variable) -ida_hexrays.chain_t.get_reg (method) -ida_hexrays.chain_t.get_stkoff (method) -ida_hexrays.chain_t.includes (method) -ida_hexrays.chain_t.is_fake (method) -ida_hexrays.chain_t.is_inited (method) -ida_hexrays.chain_t.is_overlapped (method) -ida_hexrays.chain_t.is_passreg (method) -ida_hexrays.chain_t.is_reg (method) -ida_hexrays.chain_t.is_replaced (method) -ida_hexrays.chain_t.is_stkoff (method) -ida_hexrays.chain_t.is_term (method) -ida_hexrays.chain_t.key (method) -ida_hexrays.chain_t.overlap (method) -ida_hexrays.chain_t.set_inited (method) -ida_hexrays.chain_t.set_overlapped (method) -ida_hexrays.chain_t.set_replaced (method) -ida_hexrays.chain_t.set_term (method) -ida_hexrays.chain_t.set_value (method) -ida_hexrays.chain_t.varnum (variable) -ida_hexrays.chain_t.width (variable) -ida_hexrays.chain_visitor_t (class) -ida_hexrays.chain_visitor_t.__disown__ (method) -ida_hexrays.chain_visitor_t.__init__ (method) -ida_hexrays.chain_visitor_t.parent (variable) -ida_hexrays.chain_visitor_t.visit_chain (method) -ida_hexrays.change_hexrays_config (function) -ida_hexrays.checkout_hexrays_license (function) -ida_hexrays.cif_t (class) -ida_hexrays.cif_t.__eq__ (method) -ida_hexrays.cif_t.__ge__ (method) -ida_hexrays.cif_t.__gt__ (method) -ida_hexrays.cif_t.__init__ (method) -ida_hexrays.cif_t.__le__ (method) -ida_hexrays.cif_t.__lt__ (method) -ida_hexrays.cif_t.__ne__ (method) -ida_hexrays.cif_t.assign (method) -ida_hexrays.cif_t.cleanup (method) -ida_hexrays.cif_t.compare (method) -ida_hexrays.cif_t.ielse (variable) -ida_hexrays.cif_t.ithen (variable) -ida_hexrays.cinsn_details (function) -ida_hexrays.cinsn_list_t (class) -ida_hexrays.cinsn_list_t.__eq__ (method) -ida_hexrays.cinsn_list_t.__getitem__ (method) -ida_hexrays.cinsn_list_t.__init__ (method) -ida_hexrays.cinsn_list_t.__len__ (method) -ida_hexrays.cinsn_list_t.__ne__ (method) -ida_hexrays.cinsn_list_t.__setitem__ (method) -ida_hexrays.cinsn_list_t.at (method) -ida_hexrays.cinsn_list_t.back (method) -ida_hexrays.cinsn_list_t.begin (method) -ida_hexrays.cinsn_list_t.clear (method) -ida_hexrays.cinsn_list_t.empty (method) -ida_hexrays.cinsn_list_t.end (method) -ida_hexrays.cinsn_list_t.erase (method) -ida_hexrays.cinsn_list_t.find (method) -ida_hexrays.cinsn_list_t.front (method) -ida_hexrays.cinsn_list_t.index (method) -ida_hexrays.cinsn_list_t.insert (method) -ida_hexrays.cinsn_list_t.pop_back (method) -ida_hexrays.cinsn_list_t.pop_front (method) -ida_hexrays.cinsn_list_t.push_back (method) -ida_hexrays.cinsn_list_t.push_front (method) -ida_hexrays.cinsn_list_t.rbegin (method) -ida_hexrays.cinsn_list_t.remove (method) -ida_hexrays.cinsn_list_t.rend (method) -ida_hexrays.cinsn_list_t.size (method) -ida_hexrays.cinsn_list_t.swap (method) -ida_hexrays.cinsn_list_t_iterator (class) -ida_hexrays.cinsn_list_t_iterator.__eq__ (method) -ida_hexrays.cinsn_list_t_iterator.__init__ (method) -ida_hexrays.cinsn_list_t_iterator.__ne__ (method) -ida_hexrays.cinsn_list_t_iterator.__next__ (method) -ida_hexrays.cinsn_t (class) -ida_hexrays.cinsn_t.__eq__ (method) -ida_hexrays.cinsn_t.__ge__ (method) -ida_hexrays.cinsn_t.__gt__ (method) -ida_hexrays.cinsn_t.__init__ (method) -ida_hexrays.cinsn_t.__le__ (method) -ida_hexrays.cinsn_t.__lt__ (method) -ida_hexrays.cinsn_t.__ne__ (method) -ida_hexrays.cinsn_t._deregister (method) -ida_hexrays.cinsn_t._get_casm (method) -ida_hexrays.cinsn_t._get_cblock (method) -ida_hexrays.cinsn_t._get_cdo (method) -ida_hexrays.cinsn_t._get_cexpr (method) -ida_hexrays.cinsn_t._get_cfor (method) -ida_hexrays.cinsn_t._get_cgoto (method) -ida_hexrays.cinsn_t._get_cif (method) -ida_hexrays.cinsn_t._get_creturn (method) -ida_hexrays.cinsn_t._get_cswitch (method) -ida_hexrays.cinsn_t._get_cwhile (method) -ida_hexrays.cinsn_t._print (method) -ida_hexrays.cinsn_t._register (method) -ida_hexrays.cinsn_t._replace_by (method) -ida_hexrays.cinsn_t._set_casm (method) -ida_hexrays.cinsn_t._set_cblock (method) -ida_hexrays.cinsn_t._set_cdo (method) -ida_hexrays.cinsn_t._set_cexpr (method) -ida_hexrays.cinsn_t._set_cfor (method) -ida_hexrays.cinsn_t._set_cgoto (method) -ida_hexrays.cinsn_t._set_cif (method) -ida_hexrays.cinsn_t._set_creturn (method) -ida_hexrays.cinsn_t._set_cswitch (method) -ida_hexrays.cinsn_t._set_cwhile (method) -ida_hexrays.cinsn_t.assign (method) -ida_hexrays.cinsn_t.casm (variable) -ida_hexrays.cinsn_t.cblock (variable) -ida_hexrays.cinsn_t.cdo (variable) -ida_hexrays.cinsn_t.cexpr (variable) -ida_hexrays.cinsn_t.cfor (variable) -ida_hexrays.cinsn_t.cgoto (variable) -ida_hexrays.cinsn_t.cif (variable) -ida_hexrays.cinsn_t.cleanup (method) -ida_hexrays.cinsn_t.collect_free_breaks (method) -ida_hexrays.cinsn_t.collect_free_continues (method) -ida_hexrays.cinsn_t.compare (method) -ida_hexrays.cinsn_t.contains_free_break (method) -ida_hexrays.cinsn_t.contains_free_continue (method) -ida_hexrays.cinsn_t.contains_insn (method) -ida_hexrays.cinsn_t.create_if (method) -ida_hexrays.cinsn_t.creturn (variable) -ida_hexrays.cinsn_t.cswitch (variable) -ida_hexrays.cinsn_t.cwhile (variable) -ida_hexrays.cinsn_t.dstr (method) -ida_hexrays.cinsn_t.insn_is_epilog (method) -ida_hexrays.cinsn_t.is_epilog (method) -ida_hexrays.cinsn_t.is_ordinary_flow (method) -ida_hexrays.cinsn_t.new_insn (method) -ida_hexrays.cinsn_t.print1 (method) -ida_hexrays.cinsn_t.swap (method) -ida_hexrays.cinsn_t.zero (method) -ida_hexrays.cinsn_t_insn_is_epilog (function) -ida_hexrays.cinsnptrvec_t (class) -ida_hexrays.cinsnptrvec_t.__eq__ (method) -ida_hexrays.cinsnptrvec_t.__getitem__ (method) -ida_hexrays.cinsnptrvec_t.__init__ (method) -ida_hexrays.cinsnptrvec_t.__len__ (method) -ida_hexrays.cinsnptrvec_t.__ne__ (method) -ida_hexrays.cinsnptrvec_t.__setitem__ (method) -ida_hexrays.cinsnptrvec_t._del (method) -ida_hexrays.cinsnptrvec_t.add_unique (method) -ida_hexrays.cinsnptrvec_t.at (method) -ida_hexrays.cinsnptrvec_t.begin (method) -ida_hexrays.cinsnptrvec_t.capacity (method) -ida_hexrays.cinsnptrvec_t.clear (method) -ida_hexrays.cinsnptrvec_t.empty (method) -ida_hexrays.cinsnptrvec_t.end (method) -ida_hexrays.cinsnptrvec_t.erase (method) -ida_hexrays.cinsnptrvec_t.extract (method) -ida_hexrays.cinsnptrvec_t.find (method) -ida_hexrays.cinsnptrvec_t.has (method) -ida_hexrays.cinsnptrvec_t.inject (method) -ida_hexrays.cinsnptrvec_t.insert (method) -ida_hexrays.cinsnptrvec_t.pop_back (method) -ida_hexrays.cinsnptrvec_t.push_back (method) -ida_hexrays.cinsnptrvec_t.qclear (method) -ida_hexrays.cinsnptrvec_t.reserve (method) -ida_hexrays.cinsnptrvec_t.resize (method) -ida_hexrays.cinsnptrvec_t.size (method) -ida_hexrays.cinsnptrvec_t.swap (method) -ida_hexrays.cinsnptrvec_t.truncate (method) -ida_hexrays.cit_asm (variable) -ida_hexrays.cit_block (variable) -ida_hexrays.cit_break (variable) -ida_hexrays.cit_continue (variable) -ida_hexrays.cit_do (variable) -ida_hexrays.cit_empty (variable) -ida_hexrays.cit_expr (variable) -ida_hexrays.cit_for (variable) -ida_hexrays.cit_goto (variable) -ida_hexrays.cit_if (variable) -ida_hexrays.cit_return (variable) -ida_hexrays.cit_switch (variable) -ida_hexrays.cit_while (variable) -ida_hexrays.citem_cmt_t (class) -ida_hexrays.citem_cmt_t.__init__ (method) -ida_hexrays.citem_cmt_t.__str__ (method) -ida_hexrays.citem_cmt_t.c_str (method) -ida_hexrays.citem_cmt_t.used (variable) -ida_hexrays.citem_locator_t (class) -ida_hexrays.citem_locator_t.__eq__ (method) -ida_hexrays.citem_locator_t.__ge__ (method) -ida_hexrays.citem_locator_t.__gt__ (method) -ida_hexrays.citem_locator_t.__init__ (method) -ida_hexrays.citem_locator_t.__le__ (method) -ida_hexrays.citem_locator_t.__lt__ (method) -ida_hexrays.citem_locator_t.__ne__ (method) -ida_hexrays.citem_locator_t.compare (method) -ida_hexrays.citem_locator_t.ea (variable) -ida_hexrays.citem_locator_t.op (variable) -ida_hexrays.citem_t (class) -ida_hexrays.citem_t.__dbg_get_meminfo (method) -ida_hexrays.citem_t.__dbg_get_registered_kind (method) -ida_hexrays.citem_t.__init__ (method) -ida_hexrays.citem_t._acquire_ownership (method) -ida_hexrays.citem_t._ensure_cond (method) -ida_hexrays.citem_t._ensure_no_obj (method) -ida_hexrays.citem_t._ensure_no_op (method) -ida_hexrays.citem_t._ensure_ownership_transferrable (method) -ida_hexrays.citem_t._get_op (method) -ida_hexrays.citem_t._maybe_disown_and_deregister (method) -ida_hexrays.citem_t._meminfo (method) -ida_hexrays.citem_t._obj_id (method) -ida_hexrays.citem_t._own_and_register (method) -ida_hexrays.citem_t._set_op (method) -ida_hexrays.citem_t.contains_expr (method) -ida_hexrays.citem_t.contains_label (method) -ida_hexrays.citem_t.ea (variable) -ida_hexrays.citem_t.find_closest_addr (method) -ida_hexrays.citem_t.find_parent_of (method) -ida_hexrays.citem_t.index (variable) -ida_hexrays.citem_t.is_expr (method) -ida_hexrays.citem_t.label_num (variable) -ida_hexrays.citem_t.op (variable) -ida_hexrays.citem_t.print1 (method) -ida_hexrays.citem_t.replace_by (method) -ida_hexrays.citem_t.swap (method) -ida_hexrays.citem_to_specific_type (function) -ida_hexrays.clear_cached_cfuncs (function) -ida_hexrays.cloop_t (class) -ida_hexrays.cloop_t.__init__ (method) -ida_hexrays.cloop_t.assign (method) -ida_hexrays.cloop_t.cleanup (method) -ida_hexrays.close_hexrays_waitbox (function) -ida_hexrays.close_pseudocode (function) -ida_hexrays.cnumber_t (class) -ida_hexrays.cnumber_t.__eq__ (method) -ida_hexrays.cnumber_t.__ge__ (method) -ida_hexrays.cnumber_t.__gt__ (method) -ida_hexrays.cnumber_t.__init__ (method) -ida_hexrays.cnumber_t.__le__ (method) -ida_hexrays.cnumber_t.__lt__ (method) -ida_hexrays.cnumber_t.__ne__ (method) -ida_hexrays.cnumber_t._print (method) -ida_hexrays.cnumber_t._value (variable) -ida_hexrays.cnumber_t.assign (method) -ida_hexrays.cnumber_t.compare (method) -ida_hexrays.cnumber_t.nf (variable) -ida_hexrays.cnumber_t.value (method) -ida_hexrays.codegen_t (class) -ida_hexrays.codegen_t.__init__ (method) -ida_hexrays.codegen_t.analyze_prolog (method) -ida_hexrays.codegen_t.emit (method) -ida_hexrays.codegen_t.emit_micro_mvm (method) -ida_hexrays.codegen_t.gen_micro (method) -ida_hexrays.codegen_t.load_effective_address (method) -ida_hexrays.codegen_t.load_operand (method) -ida_hexrays.codegen_t.microgen_completed (method) -ida_hexrays.codegen_t.prepare_gen_micro (method) -ida_hexrays.codegen_t.store_operand (method) -ida_hexrays.convert_to_user_call (function) -ida_hexrays.cot_add (variable) -ida_hexrays.cot_asg (variable) -ida_hexrays.cot_asgadd (variable) -ida_hexrays.cot_asgband (variable) -ida_hexrays.cot_asgbor (variable) -ida_hexrays.cot_asgmul (variable) -ida_hexrays.cot_asgsdiv (variable) -ida_hexrays.cot_asgshl (variable) -ida_hexrays.cot_asgsmod (variable) -ida_hexrays.cot_asgsshr (variable) -ida_hexrays.cot_asgsub (variable) -ida_hexrays.cot_asgudiv (variable) -ida_hexrays.cot_asgumod (variable) -ida_hexrays.cot_asgushr (variable) -ida_hexrays.cot_asgxor (variable) -ida_hexrays.cot_band (variable) -ida_hexrays.cot_bnot (variable) -ida_hexrays.cot_bor (variable) -ida_hexrays.cot_call (variable) -ida_hexrays.cot_cast (variable) -ida_hexrays.cot_comma (variable) -ida_hexrays.cot_eq (variable) -ida_hexrays.cot_fadd (variable) -ida_hexrays.cot_fdiv (variable) -ida_hexrays.cot_fmul (variable) -ida_hexrays.cot_fneg (variable) -ida_hexrays.cot_fnum (variable) -ida_hexrays.cot_fsub (variable) -ida_hexrays.cot_helper (variable) -ida_hexrays.cot_idx (variable) -ida_hexrays.cot_insn (variable) -ida_hexrays.cot_land (variable) -ida_hexrays.cot_lnot (variable) -ida_hexrays.cot_lor (variable) -ida_hexrays.cot_memptr (variable) -ida_hexrays.cot_memref (variable) -ida_hexrays.cot_mul (variable) -ida_hexrays.cot_ne (variable) -ida_hexrays.cot_neg (variable) -ida_hexrays.cot_num (variable) -ida_hexrays.cot_obj (variable) -ida_hexrays.cot_postdec (variable) -ida_hexrays.cot_postinc (variable) -ida_hexrays.cot_predec (variable) -ida_hexrays.cot_preinc (variable) -ida_hexrays.cot_ptr (variable) -ida_hexrays.cot_ref (variable) -ida_hexrays.cot_sdiv (variable) -ida_hexrays.cot_sge (variable) -ida_hexrays.cot_sgt (variable) -ida_hexrays.cot_shl (variable) -ida_hexrays.cot_sizeof (variable) -ida_hexrays.cot_sle (variable) -ida_hexrays.cot_slt (variable) -ida_hexrays.cot_smod (variable) -ida_hexrays.cot_sshr (variable) -ida_hexrays.cot_str (variable) -ida_hexrays.cot_sub (variable) -ida_hexrays.cot_tern (variable) -ida_hexrays.cot_type (variable) -ida_hexrays.cot_udiv (variable) -ida_hexrays.cot_uge (variable) -ida_hexrays.cot_ugt (variable) -ida_hexrays.cot_ule (variable) -ida_hexrays.cot_ult (variable) -ida_hexrays.cot_umod (variable) -ida_hexrays.cot_ushr (variable) -ida_hexrays.cot_var (variable) -ida_hexrays.cot_xor (variable) -ida_hexrays.create_cfunc (function) -ida_hexrays.create_empty_mba (function) -ida_hexrays.create_field_name (function) -ida_hexrays.create_helper (function) -ida_hexrays.create_typedef (function) -ida_hexrays.creturn_t (class) -ida_hexrays.creturn_t.__eq__ (method) -ida_hexrays.creturn_t.__ge__ (method) -ida_hexrays.creturn_t.__gt__ (method) -ida_hexrays.creturn_t.__init__ (method) -ida_hexrays.creturn_t.__le__ (method) -ida_hexrays.creturn_t.__lt__ (method) -ida_hexrays.creturn_t.__ne__ (method) -ida_hexrays.creturn_t.compare (method) -ida_hexrays.cswitch_t (class) -ida_hexrays.cswitch_t.__eq__ (method) -ida_hexrays.cswitch_t.__ge__ (method) -ida_hexrays.cswitch_t.__gt__ (method) -ida_hexrays.cswitch_t.__init__ (method) -ida_hexrays.cswitch_t.__le__ (method) -ida_hexrays.cswitch_t.__lt__ (method) -ida_hexrays.cswitch_t.__ne__ (method) -ida_hexrays.cswitch_t.cases (variable) -ida_hexrays.cswitch_t.compare (method) -ida_hexrays.cswitch_t.mvnf (variable) -ida_hexrays.ctext_position_t (class) -ida_hexrays.ctext_position_t.__eq__ (method) -ida_hexrays.ctext_position_t.__ge__ (method) -ida_hexrays.ctext_position_t.__gt__ (method) -ida_hexrays.ctext_position_t.__init__ (method) -ida_hexrays.ctext_position_t.__le__ (method) -ida_hexrays.ctext_position_t.__lt__ (method) -ida_hexrays.ctext_position_t.__ne__ (method) -ida_hexrays.ctext_position_t.compare (method) -ida_hexrays.ctext_position_t.in_ctree (method) -ida_hexrays.ctext_position_t.lnnum (variable) -ida_hexrays.ctext_position_t.x (variable) -ida_hexrays.ctext_position_t.y (variable) -ida_hexrays.ctree_anchor_t (class) -ida_hexrays.ctree_anchor_t.__init__ (method) -ida_hexrays.ctree_anchor_t.get_index (method) -ida_hexrays.ctree_anchor_t.get_itp (method) -ida_hexrays.ctree_anchor_t.is_blkcmt_anchor (method) -ida_hexrays.ctree_anchor_t.is_citem_anchor (method) -ida_hexrays.ctree_anchor_t.is_itp_anchor (method) -ida_hexrays.ctree_anchor_t.is_lvar_anchor (method) -ida_hexrays.ctree_anchor_t.is_valid_anchor (method) -ida_hexrays.ctree_item_t (class) -ida_hexrays.ctree_item_t.__init__ (method) -ida_hexrays.ctree_item_t._get_e (method) -ida_hexrays.ctree_item_t._get_f (method) -ida_hexrays.ctree_item_t._get_i (method) -ida_hexrays.ctree_item_t._get_it (method) -ida_hexrays.ctree_item_t._get_l (method) -ida_hexrays.ctree_item_t._print (method) -ida_hexrays.ctree_item_t.citype (variable) -ida_hexrays.ctree_item_t.dstr (method) -ida_hexrays.ctree_item_t.get_ea (method) -ida_hexrays.ctree_item_t.get_label_num (method) -ida_hexrays.ctree_item_t.get_lvar (method) -ida_hexrays.ctree_item_t.get_memptr (method) -ida_hexrays.ctree_item_t.is_citem (method) -ida_hexrays.ctree_items_t (class) -ida_hexrays.ctree_items_t.__eq__ (method) -ida_hexrays.ctree_items_t.__getitem__ (method) -ida_hexrays.ctree_items_t.__init__ (method) -ida_hexrays.ctree_items_t.__len__ (method) -ida_hexrays.ctree_items_t.__ne__ (method) -ida_hexrays.ctree_items_t.__setitem__ (method) -ida_hexrays.ctree_items_t._del (method) -ida_hexrays.ctree_items_t.add_unique (method) -ida_hexrays.ctree_items_t.at (method) -ida_hexrays.ctree_items_t.begin (method) -ida_hexrays.ctree_items_t.capacity (method) -ida_hexrays.ctree_items_t.clear (method) -ida_hexrays.ctree_items_t.empty (method) -ida_hexrays.ctree_items_t.end (method) -ida_hexrays.ctree_items_t.erase (method) -ida_hexrays.ctree_items_t.extract (method) -ida_hexrays.ctree_items_t.find (method) -ida_hexrays.ctree_items_t.has (method) -ida_hexrays.ctree_items_t.inject (method) -ida_hexrays.ctree_items_t.insert (method) -ida_hexrays.ctree_items_t.pop_back (method) -ida_hexrays.ctree_items_t.push_back (method) -ida_hexrays.ctree_items_t.qclear (method) -ida_hexrays.ctree_items_t.reserve (method) -ida_hexrays.ctree_items_t.resize (method) -ida_hexrays.ctree_items_t.size (method) -ida_hexrays.ctree_items_t.swap (method) -ida_hexrays.ctree_items_t.truncate (method) -ida_hexrays.ctree_parentee_t (class) -ida_hexrays.ctree_parentee_t.__disown__ (method) -ida_hexrays.ctree_parentee_t.__init__ (method) -ida_hexrays.ctree_parentee_t.get_block (method) -ida_hexrays.ctree_parentee_t.recalc_parent_types (method) -ida_hexrays.ctree_visitor_t (class) -ida_hexrays.ctree_visitor_t.__disown__ (method) -ida_hexrays.ctree_visitor_t.__init__ (method) -ida_hexrays.ctree_visitor_t.apply_to (method) -ida_hexrays.ctree_visitor_t.apply_to_exprs (method) -ida_hexrays.ctree_visitor_t.clr_prune (method) -ida_hexrays.ctree_visitor_t.clr_restart (method) -ida_hexrays.ctree_visitor_t.cv_flags (variable) -ida_hexrays.ctree_visitor_t.is_postorder (method) -ida_hexrays.ctree_visitor_t.leave_expr (method) -ida_hexrays.ctree_visitor_t.leave_insn (method) -ida_hexrays.ctree_visitor_t.maintain_parents (method) -ida_hexrays.ctree_visitor_t.must_prune (method) -ida_hexrays.ctree_visitor_t.must_restart (method) -ida_hexrays.ctree_visitor_t.only_insns (method) -ida_hexrays.ctree_visitor_t.parent_expr (method) -ida_hexrays.ctree_visitor_t.parent_insn (method) -ida_hexrays.ctree_visitor_t.parents (variable) -ida_hexrays.ctree_visitor_t.prune_now (method) -ida_hexrays.ctree_visitor_t.set_restart (method) -ida_hexrays.ctree_visitor_t.visit_expr (method) -ida_hexrays.ctree_visitor_t.visit_insn (method) -ida_hexrays.cwhile_t (class) -ida_hexrays.cwhile_t.__eq__ (method) -ida_hexrays.cwhile_t.__ge__ (method) -ida_hexrays.cwhile_t.__gt__ (method) -ida_hexrays.cwhile_t.__init__ (method) -ida_hexrays.cwhile_t.__le__ (method) -ida_hexrays.cwhile_t.__lt__ (method) -ida_hexrays.cwhile_t.__ne__ (method) -ida_hexrays.cwhile_t.compare (method) -ida_hexrays.debug_hexrays_ctree (function) -ida_hexrays.decompile (function) -ida_hexrays.decompile (function) -ida_hexrays.decompile_func (function) -ida_hexrays.decompile_many (function) -ida_hexrays.dereference (function) -ida_hexrays.dstr (function) -ida_hexrays.dummy_ptrtype (function) -ida_hexrays.eamap_begin (function) -ida_hexrays.eamap_clear (function) -ida_hexrays.eamap_end (function) -ida_hexrays.eamap_erase (function) -ida_hexrays.eamap_find (function) -ida_hexrays.eamap_first (function) -ida_hexrays.eamap_free (function) -ida_hexrays.eamap_insert (function) -ida_hexrays.eamap_iterator_t (class) -ida_hexrays.eamap_iterator_t.__eq__ (method) -ida_hexrays.eamap_iterator_t.__init__ (method) -ida_hexrays.eamap_iterator_t.__ne__ (method) -ida_hexrays.eamap_new (function) -ida_hexrays.eamap_next (function) -ida_hexrays.eamap_prev (function) -ida_hexrays.eamap_second (function) -ida_hexrays.eamap_size (function) -ida_hexrays.eamap_t (class) -ida_hexrays.eamap_t.__init__ (method) -ida_hexrays.eamap_t.at (method) -ida_hexrays.eamap_t.size (method) -ida_hexrays.fnumber_t (class) -ida_hexrays.fnumber_t.__eq__ (method) -ida_hexrays.fnumber_t.__ge__ (method) -ida_hexrays.fnumber_t.__gt__ (method) -ida_hexrays.fnumber_t.__init__ (method) -ida_hexrays.fnumber_t.__le__ (method) -ida_hexrays.fnumber_t.__lt__ (method) -ida_hexrays.fnumber_t.__ne__ (method) -ida_hexrays.fnumber_t._print (method) -ida_hexrays.fnumber_t.compare (method) -ida_hexrays.fnumber_t.dereference_const_uint16 (method) -ida_hexrays.fnumber_t.dereference_uint16 (method) -ida_hexrays.fnumber_t.fnum (variable) -ida_hexrays.fnumber_t.nbytes (variable) -ida_hexrays.gco_info_t (class) -ida_hexrays.gco_info_t.__init__ (method) -ida_hexrays.gco_info_t.append_to_list (method) -ida_hexrays.gco_info_t.cvt_to_ivl (method) -ida_hexrays.gco_info_t.is_def (method) -ida_hexrays.gco_info_t.is_reg (method) -ida_hexrays.gco_info_t.is_use (method) -ida_hexrays.gco_info_t.name (variable) -ida_hexrays.gco_info_t.regnum (variable) -ida_hexrays.gco_info_t.size (variable) -ida_hexrays.gco_info_t.stkoff (variable) -ida_hexrays.gen_microcode (function) -ida_hexrays.get_ctype_name (function) -ida_hexrays.get_current_operand (function) -ida_hexrays.get_float_type (function) -ida_hexrays.get_hexrays_version (function) -ida_hexrays.get_int_type_by_width_and_sign (function) -ida_hexrays.get_member_type (function) -ida_hexrays.get_merror_desc (function) -ida_hexrays.get_mreg_name (function) -ida_hexrays.get_op_signness (function) -ida_hexrays.get_signed_mcode (function) -ida_hexrays.get_temp_regs (function) -ida_hexrays.get_type (function) -ida_hexrays.get_unk_type (function) -ida_hexrays.get_unsigned_mcode (function) -ida_hexrays.get_widget_vdui (function) -ida_hexrays.getb_reginsn (function) -ida_hexrays.getf_reginsn (function) -ida_hexrays.graph_chains_t (class) -ida_hexrays.graph_chains_t.__init__ (method) -ida_hexrays.graph_chains_t.acquire (method) -ida_hexrays.graph_chains_t.for_all_chains (method) -ida_hexrays.graph_chains_t.is_locked (method) -ida_hexrays.graph_chains_t.release (method) -ida_hexrays.graph_chains_t.swap (method) -ida_hexrays.has_cached_cfunc (function) -ida_hexrays.has_mcode_seloff (function) -ida_hexrays.hexrays_alloc (function) -ida_hexrays.hexrays_failure_t (class) -ida_hexrays.hexrays_failure_t.__init__ (method) -ida_hexrays.hexrays_failure_t.code (variable) -ida_hexrays.hexrays_failure_t.desc (method) -ida_hexrays.hexrays_failure_t.errea (variable) -ida_hexrays.hexrays_failure_t.str (variable) -ida_hexrays.hexrays_free (function) -ida_hexrays.hexwarn_t (class) -ida_hexrays.hexwarn_t.__eq__ (method) -ida_hexrays.hexwarn_t.__ge__ (method) -ida_hexrays.hexwarn_t.__gt__ (method) -ida_hexrays.hexwarn_t.__init__ (method) -ida_hexrays.hexwarn_t.__le__ (method) -ida_hexrays.hexwarn_t.__lt__ (method) -ida_hexrays.hexwarn_t.__ne__ (method) -ida_hexrays.hexwarn_t.compare (method) -ida_hexrays.hexwarn_t.ea (variable) -ida_hexrays.hexwarn_t.id (variable) -ida_hexrays.hexwarn_t.text (variable) -ida_hexrays.hexwarns_t (class) -ida_hexrays.hexwarns_t.__eq__ (method) -ida_hexrays.hexwarns_t.__getitem__ (method) -ida_hexrays.hexwarns_t.__init__ (method) -ida_hexrays.hexwarns_t.__len__ (method) -ida_hexrays.hexwarns_t.__ne__ (method) -ida_hexrays.hexwarns_t.__setitem__ (method) -ida_hexrays.hexwarns_t._del (method) -ida_hexrays.hexwarns_t.add_unique (method) -ida_hexrays.hexwarns_t.at (method) -ida_hexrays.hexwarns_t.begin (method) -ida_hexrays.hexwarns_t.capacity (method) -ida_hexrays.hexwarns_t.clear (method) -ida_hexrays.hexwarns_t.empty (method) -ida_hexrays.hexwarns_t.end (method) -ida_hexrays.hexwarns_t.erase (method) -ida_hexrays.hexwarns_t.extract (method) -ida_hexrays.hexwarns_t.find (method) -ida_hexrays.hexwarns_t.grow (method) -ida_hexrays.hexwarns_t.has (method) -ida_hexrays.hexwarns_t.inject (method) -ida_hexrays.hexwarns_t.insert (method) -ida_hexrays.hexwarns_t.pop_back (method) -ida_hexrays.hexwarns_t.push_back (method) -ida_hexrays.hexwarns_t.qclear (method) -ida_hexrays.hexwarns_t.reserve (method) -ida_hexrays.hexwarns_t.resize (method) -ida_hexrays.hexwarns_t.size (method) -ida_hexrays.hexwarns_t.swap (method) -ida_hexrays.hexwarns_t.truncate (method) -ida_hexrays.history_item_t (class) -ida_hexrays.history_item_t.__init__ (method) -ida_hexrays.history_item_t.ea (variable) -ida_hexrays.history_item_t.end (variable) -ida_hexrays.history_t (class) -ida_hexrays.history_t.__init__ (method) -ida_hexrays.history_t.pop (method) -ida_hexrays.history_t.push (method) -ida_hexrays.history_t.top (method) -ida_hexrays.hxe_build_callinfo (variable) -ida_hexrays.hxe_callinfo_built (variable) -ida_hexrays.hxe_calls_done (variable) -ida_hexrays.hxe_close_pseudocode (variable) -ida_hexrays.hxe_cmt_changed (variable) -ida_hexrays.hxe_combine (variable) -ida_hexrays.hxe_create_hint (variable) -ida_hexrays.hxe_curpos (variable) -ida_hexrays.hxe_double_click (variable) -ida_hexrays.hxe_flowchart (variable) -ida_hexrays.hxe_func_printed (variable) -ida_hexrays.hxe_glbopt (variable) -ida_hexrays.hxe_interr (variable) -ida_hexrays.hxe_keyboard (variable) -ida_hexrays.hxe_locopt (variable) -ida_hexrays.hxe_maturity (variable) -ida_hexrays.hxe_microcode (variable) -ida_hexrays.hxe_open_pseudocode (variable) -ida_hexrays.hxe_populating_popup (variable) -ida_hexrays.hxe_prealloc (variable) -ida_hexrays.hxe_preoptimized (variable) -ida_hexrays.hxe_print_func (variable) -ida_hexrays.hxe_prolog (variable) -ida_hexrays.hxe_refresh_pseudocode (variable) -ida_hexrays.hxe_resolve_stkaddrs (variable) -ida_hexrays.hxe_right_click (variable) -ida_hexrays.hxe_stkpnts (variable) -ida_hexrays.hxe_structural (variable) -ida_hexrays.hxe_switch_pseudocode (variable) -ida_hexrays.hxe_text_ready (variable) -ida_hexrays.init_hexrays_plugin (function) -ida_hexrays.install_hexrays_callback (function) -ida_hexrays.install_microcode_filter (function) -ida_hexrays.is_additive (function) -ida_hexrays.is_assignment (function) -ida_hexrays.is_binary (function) -ida_hexrays.is_bitop (function) -ida_hexrays.is_bool_type (function) -ida_hexrays.is_break_consumer (function) -ida_hexrays.is_commutative (function) -ida_hexrays.is_inplace_def (function) -ida_hexrays.is_kreg (function) -ida_hexrays.is_logical (function) -ida_hexrays.is_loop (function) -ida_hexrays.is_lvalue (function) -ida_hexrays.is_may_access (function) -ida_hexrays.is_mcode_addsub (function) -ida_hexrays.is_mcode_call (function) -ida_hexrays.is_mcode_commutative (function) -ida_hexrays.is_mcode_convertible_to_jmp (function) -ida_hexrays.is_mcode_convertible_to_set (function) -ida_hexrays.is_mcode_divmod (function) -ida_hexrays.is_mcode_fpu (function) -ida_hexrays.is_mcode_j1 (function) -ida_hexrays.is_mcode_jcond (function) -ida_hexrays.is_mcode_propagatable (function) -ida_hexrays.is_mcode_set (function) -ida_hexrays.is_mcode_set1 (function) -ida_hexrays.is_mcode_shift (function) -ida_hexrays.is_mcode_xdsu (function) -ida_hexrays.is_multiplicative (function) -ida_hexrays.is_nonbool_type (function) -ida_hexrays.is_paf (function) -ida_hexrays.is_prepost (function) -ida_hexrays.is_ptr_or_array (function) -ida_hexrays.is_relational (function) -ida_hexrays.is_signed_mcode (function) -ida_hexrays.is_small_udt (function) -ida_hexrays.is_type_correct (function) -ida_hexrays.is_unary (function) -ida_hexrays.is_unsigned_mcode (function) -ida_hexrays.iterator (class) -ida_hexrays.iterator.__eq__ (method) -ida_hexrays.iterator.__init__ (method) -ida_hexrays.iterator.__ne__ (method) -ida_hexrays.iterator.__ref__ (method) -ida_hexrays.ivl_t (class) -ida_hexrays.ivl_t.__eq__ (method) -ida_hexrays.ivl_t.__ge__ (method) -ida_hexrays.ivl_t.__gt__ (method) -ida_hexrays.ivl_t.__init__ (method) -ida_hexrays.ivl_t.__le__ (method) -ida_hexrays.ivl_t.__lt__ (method) -ida_hexrays.ivl_t.__ne__ (method) -ida_hexrays.ivl_t.clear (method) -ida_hexrays.ivl_t.compare (method) -ida_hexrays.ivl_t.contains (method) -ida_hexrays.ivl_t.dstr (method) -ida_hexrays.ivl_t.empty (method) -ida_hexrays.ivl_t.extend_to_cover (method) -ida_hexrays.ivl_t.includes (method) -ida_hexrays.ivl_t.intersect (method) -ida_hexrays.ivl_t.overlap (method) -ida_hexrays.ivl_with_name_t (class) -ida_hexrays.ivl_with_name_t.__init__ (method) -ida_hexrays.ivlset_t (class) -ida_hexrays.ivlset_t.__eq__ (method) -ida_hexrays.ivlset_t.__ge__ (method) -ida_hexrays.ivlset_t.__gt__ (method) -ida_hexrays.ivlset_t.__init__ (method) -ida_hexrays.ivlset_t.__le__ (method) -ida_hexrays.ivlset_t.__lt__ (method) -ida_hexrays.ivlset_t.__ne__ (method) -ida_hexrays.ivlset_t._print (method) -ida_hexrays.ivlset_t.add (method) -ida_hexrays.ivlset_t.addmasked (method) -ida_hexrays.ivlset_t.compare (method) -ida_hexrays.ivlset_t.contains (method) -ida_hexrays.ivlset_t.count (method) -ida_hexrays.ivlset_t.dstr (method) -ida_hexrays.ivlset_t.has_common (method) -ida_hexrays.ivlset_t.includes (method) -ida_hexrays.ivlset_t.intersect (method) -ida_hexrays.ivlset_t.sub (method) -ida_hexrays.jcnd2set (function) -ida_hexrays.lexcompare (function) -ida_hexrays.lnot (function) -ida_hexrays.locate_lvar (function) -ida_hexrays.lvar_locator_t (class) -ida_hexrays.lvar_locator_t.__eq__ (method) -ida_hexrays.lvar_locator_t.__ge__ (method) -ida_hexrays.lvar_locator_t.__gt__ (method) -ida_hexrays.lvar_locator_t.__init__ (method) -ida_hexrays.lvar_locator_t.__le__ (method) -ida_hexrays.lvar_locator_t.__lt__ (method) -ida_hexrays.lvar_locator_t.__ne__ (method) -ida_hexrays.lvar_locator_t.compare (method) -ida_hexrays.lvar_locator_t.defea (variable) -ida_hexrays.lvar_locator_t.get_reg1 (method) -ida_hexrays.lvar_locator_t.get_reg2 (method) -ida_hexrays.lvar_locator_t.get_scattered (method) -ida_hexrays.lvar_locator_t.get_stkoff (method) -ida_hexrays.lvar_locator_t.is_reg1 (method) -ida_hexrays.lvar_locator_t.is_reg2 (method) -ida_hexrays.lvar_locator_t.is_reg_var (method) -ida_hexrays.lvar_locator_t.is_scattered (method) -ida_hexrays.lvar_locator_t.is_stk_var (method) -ida_hexrays.lvar_locator_t.location (variable) -ida_hexrays.lvar_mapping_begin (function) -ida_hexrays.lvar_mapping_clear (function) -ida_hexrays.lvar_mapping_end (function) -ida_hexrays.lvar_mapping_erase (function) -ida_hexrays.lvar_mapping_find (function) -ida_hexrays.lvar_mapping_first (function) -ida_hexrays.lvar_mapping_free (function) -ida_hexrays.lvar_mapping_insert (function) -ida_hexrays.lvar_mapping_iterator_t (class) -ida_hexrays.lvar_mapping_iterator_t.__eq__ (method) -ida_hexrays.lvar_mapping_iterator_t.__init__ (method) -ida_hexrays.lvar_mapping_iterator_t.__ne__ (method) -ida_hexrays.lvar_mapping_new (function) -ida_hexrays.lvar_mapping_next (function) -ida_hexrays.lvar_mapping_prev (function) -ida_hexrays.lvar_mapping_second (function) -ida_hexrays.lvar_mapping_size (function) -ida_hexrays.lvar_mapping_t (class) -ida_hexrays.lvar_mapping_t.__init__ (method) -ida_hexrays.lvar_mapping_t.at (method) -ida_hexrays.lvar_mapping_t.size (method) -ida_hexrays.lvar_ref_t (class) -ida_hexrays.lvar_ref_t.__eq__ (method) -ida_hexrays.lvar_ref_t.__ge__ (method) -ida_hexrays.lvar_ref_t.__gt__ (method) -ida_hexrays.lvar_ref_t.__init__ (method) -ida_hexrays.lvar_ref_t.__le__ (method) -ida_hexrays.lvar_ref_t.__lt__ (method) -ida_hexrays.lvar_ref_t.__ne__ (method) -ida_hexrays.lvar_ref_t.compare (method) -ida_hexrays.lvar_ref_t.idx (variable) -ida_hexrays.lvar_ref_t.mba (variable) -ida_hexrays.lvar_ref_t.off (variable) -ida_hexrays.lvar_ref_t.swap (method) -ida_hexrays.lvar_ref_t.var (method) -ida_hexrays.lvar_saved_info_t (class) -ida_hexrays.lvar_saved_info_t.__eq__ (method) -ida_hexrays.lvar_saved_info_t.__init__ (method) -ida_hexrays.lvar_saved_info_t.__ne__ (method) -ida_hexrays.lvar_saved_info_t.clear_keep (method) -ida_hexrays.lvar_saved_info_t.clr_nomap_lvar (method) -ida_hexrays.lvar_saved_info_t.clr_noptr_lvar (method) -ida_hexrays.lvar_saved_info_t.clr_split_lvar (method) -ida_hexrays.lvar_saved_info_t.clr_unused_lvar (method) -ida_hexrays.lvar_saved_info_t.cmt (variable) -ida_hexrays.lvar_saved_info_t.flags (variable) -ida_hexrays.lvar_saved_info_t.has_info (method) -ida_hexrays.lvar_saved_info_t.is_kept (method) -ida_hexrays.lvar_saved_info_t.is_nomap_lvar (method) -ida_hexrays.lvar_saved_info_t.is_noptr_lvar (method) -ida_hexrays.lvar_saved_info_t.is_split_lvar (method) -ida_hexrays.lvar_saved_info_t.is_unused_lvar (method) -ida_hexrays.lvar_saved_info_t.ll (variable) -ida_hexrays.lvar_saved_info_t.name (variable) -ida_hexrays.lvar_saved_info_t.set_keep (method) -ida_hexrays.lvar_saved_info_t.set_nomap_lvar (method) -ida_hexrays.lvar_saved_info_t.set_noptr_lvar (method) -ida_hexrays.lvar_saved_info_t.set_split_lvar (method) -ida_hexrays.lvar_saved_info_t.set_unused_lvar (method) -ida_hexrays.lvar_saved_info_t.size (variable) -ida_hexrays.lvar_saved_info_t.type (variable) -ida_hexrays.lvar_saved_infos_t (class) -ida_hexrays.lvar_saved_infos_t.__eq__ (method) -ida_hexrays.lvar_saved_infos_t.__getitem__ (method) -ida_hexrays.lvar_saved_infos_t.__init__ (method) -ida_hexrays.lvar_saved_infos_t.__len__ (method) -ida_hexrays.lvar_saved_infos_t.__ne__ (method) -ida_hexrays.lvar_saved_infos_t.__setitem__ (method) -ida_hexrays.lvar_saved_infos_t._del (method) -ida_hexrays.lvar_saved_infos_t.add_unique (method) -ida_hexrays.lvar_saved_infos_t.at (method) -ida_hexrays.lvar_saved_infos_t.begin (method) -ida_hexrays.lvar_saved_infos_t.capacity (method) -ida_hexrays.lvar_saved_infos_t.clear (method) -ida_hexrays.lvar_saved_infos_t.empty (method) -ida_hexrays.lvar_saved_infos_t.end (method) -ida_hexrays.lvar_saved_infos_t.erase (method) -ida_hexrays.lvar_saved_infos_t.extract (method) -ida_hexrays.lvar_saved_infos_t.find (method) -ida_hexrays.lvar_saved_infos_t.grow (method) -ida_hexrays.lvar_saved_infos_t.has (method) -ida_hexrays.lvar_saved_infos_t.inject (method) -ida_hexrays.lvar_saved_infos_t.insert (method) -ida_hexrays.lvar_saved_infos_t.pop_back (method) -ida_hexrays.lvar_saved_infos_t.push_back (method) -ida_hexrays.lvar_saved_infos_t.qclear (method) -ida_hexrays.lvar_saved_infos_t.reserve (method) -ida_hexrays.lvar_saved_infos_t.resize (method) -ida_hexrays.lvar_saved_infos_t.size (method) -ida_hexrays.lvar_saved_infos_t.swap (method) -ida_hexrays.lvar_saved_infos_t.truncate (method) -ida_hexrays.lvar_t (class) -ida_hexrays.lvar_t.__init__ (method) -ida_hexrays.lvar_t.accepts_type (method) -ida_hexrays.lvar_t.append_list (method) -ida_hexrays.lvar_t.clear_used (method) -ida_hexrays.lvar_t.clr_arg_var (method) -ida_hexrays.lvar_t.clr_automapped (method) -ida_hexrays.lvar_t.clr_decl_unused (method) -ida_hexrays.lvar_t.clr_dummy_arg (method) -ida_hexrays.lvar_t.clr_fake_var (method) -ida_hexrays.lvar_t.clr_floating_var (method) -ida_hexrays.lvar_t.clr_mapdst_var (method) -ida_hexrays.lvar_t.clr_mreg_done (method) -ida_hexrays.lvar_t.clr_noptr_var (method) -ida_hexrays.lvar_t.clr_notarg (method) -ida_hexrays.lvar_t.clr_overlapped_var (method) -ida_hexrays.lvar_t.clr_shared (method) -ida_hexrays.lvar_t.clr_split_var (method) -ida_hexrays.lvar_t.clr_spoiled_var (method) -ida_hexrays.lvar_t.clr_thisarg (method) -ida_hexrays.lvar_t.clr_unknown_width (method) -ida_hexrays.lvar_t.clr_used_byref (method) -ida_hexrays.lvar_t.clr_user_info (method) -ida_hexrays.lvar_t.clr_user_name (method) -ida_hexrays.lvar_t.clr_user_type (method) -ida_hexrays.lvar_t.cmt (variable) -ida_hexrays.lvar_t.defblk (variable) -ida_hexrays.lvar_t.divisor (variable) -ida_hexrays.lvar_t.has_common (method) -ida_hexrays.lvar_t.has_common_bit (method) -ida_hexrays.lvar_t.has_nice_name (method) -ida_hexrays.lvar_t.has_regname (method) -ida_hexrays.lvar_t.has_user_info (method) -ida_hexrays.lvar_t.has_user_name (method) -ida_hexrays.lvar_t.has_user_type (method) -ida_hexrays.lvar_t.in_asm (method) -ida_hexrays.lvar_t.is_aliasable (method) -ida_hexrays.lvar_t.is_arg_var (method) -ida_hexrays.lvar_t.is_automapped (method) -ida_hexrays.lvar_t.is_decl_unused (method) -ida_hexrays.lvar_t.is_dummy_arg (method) -ida_hexrays.lvar_t.is_fake_var (method) -ida_hexrays.lvar_t.is_floating_var (method) -ida_hexrays.lvar_t.is_mapdst_var (method) -ida_hexrays.lvar_t.is_noptr_var (method) -ida_hexrays.lvar_t.is_notarg (method) -ida_hexrays.lvar_t.is_overlapped_var (method) -ida_hexrays.lvar_t.is_result_var (method) -ida_hexrays.lvar_t.is_shared (method) -ida_hexrays.lvar_t.is_split_var (method) -ida_hexrays.lvar_t.is_spoiled_var (method) -ida_hexrays.lvar_t.is_thisarg (method) -ida_hexrays.lvar_t.is_unknown_width (method) -ida_hexrays.lvar_t.is_used_byref (method) -ida_hexrays.lvar_t.mreg_done (method) -ida_hexrays.lvar_t.name (variable) -ida_hexrays.lvar_t.set_arg_var (method) -ida_hexrays.lvar_t.set_automapped (method) -ida_hexrays.lvar_t.set_decl_unused (method) -ida_hexrays.lvar_t.set_dummy_arg (method) -ida_hexrays.lvar_t.set_fake_var (method) -ida_hexrays.lvar_t.set_final_lvar_type (method) -ida_hexrays.lvar_t.set_floating_var (method) -ida_hexrays.lvar_t.set_lvar_type (method) -ida_hexrays.lvar_t.set_mapdst_var (method) -ida_hexrays.lvar_t.set_mreg_done (method) -ida_hexrays.lvar_t.set_non_typed (method) -ida_hexrays.lvar_t.set_noptr_var (method) -ida_hexrays.lvar_t.set_notarg (method) -ida_hexrays.lvar_t.set_overlapped_var (method) -ida_hexrays.lvar_t.set_shared (method) -ida_hexrays.lvar_t.set_split_var (method) -ida_hexrays.lvar_t.set_spoiled_var (method) -ida_hexrays.lvar_t.set_thisarg (method) -ida_hexrays.lvar_t.set_typed (method) -ida_hexrays.lvar_t.set_unknown_width (method) -ida_hexrays.lvar_t.set_used (method) -ida_hexrays.lvar_t.set_used_byref (method) -ida_hexrays.lvar_t.set_user_name (method) -ida_hexrays.lvar_t.set_user_type (method) -ida_hexrays.lvar_t.set_width (method) -ida_hexrays.lvar_t.tif (variable) -ida_hexrays.lvar_t.type (method) -ida_hexrays.lvar_t.typed (method) -ida_hexrays.lvar_t.used (method) -ida_hexrays.lvar_t.width (variable) -ida_hexrays.lvar_uservec_t (class) -ida_hexrays.lvar_uservec_t.__init__ (method) -ida_hexrays.lvar_uservec_t.clear (method) -ida_hexrays.lvar_uservec_t.empty (method) -ida_hexrays.lvar_uservec_t.find_info (method) -ida_hexrays.lvar_uservec_t.keep_info (method) -ida_hexrays.lvar_uservec_t.lmaps (variable) -ida_hexrays.lvar_uservec_t.lvvec (variable) -ida_hexrays.lvar_uservec_t.stkoff_delta (variable) -ida_hexrays.lvar_uservec_t.swap (method) -ida_hexrays.lvar_uservec_t.ulv_flags (variable) -ida_hexrays.lvars_t (class) -ida_hexrays.lvars_t.__init__ (method) -ida_hexrays.lvars_t.find (method) -ida_hexrays.lvars_t.find_input_lvar (method) -ida_hexrays.lvars_t.find_lvar (method) -ida_hexrays.lvars_t.find_stkvar (method) -ida_hexrays.lxe_lvar_cmt_changed (variable) -ida_hexrays.lxe_lvar_mapping_changed (variable) -ida_hexrays.lxe_lvar_name_changed (variable) -ida_hexrays.lxe_lvar_type_changed (variable) -ida_hexrays.make_num (function) -ida_hexrays.make_pointer (function) -ida_hexrays.make_ref (function) -ida_hexrays.mark_cfunc_dirty (function) -ida_hexrays.mba_range_iterator_t (class) -ida_hexrays.mba_range_iterator_t.__init__ (method) -ida_hexrays.mba_range_iterator_t.chunk (method) -ida_hexrays.mba_range_iterator_t.is_snippet (method) -ida_hexrays.mba_range_iterator_t.next (method) -ida_hexrays.mba_range_iterator_t.set (method) -ida_hexrays.mba_ranges_t (class) -ida_hexrays.mba_ranges_t.__init__ (method) -ida_hexrays.mba_ranges_t.clear (method) -ida_hexrays.mba_ranges_t.empty (method) -ida_hexrays.mba_ranges_t.is_fragmented (method) -ida_hexrays.mba_ranges_t.is_snippet (method) -ida_hexrays.mba_ranges_t.pfn (variable) -ida_hexrays.mba_ranges_t.ranges (variable) -ida_hexrays.mba_ranges_t.start (method) -ida_hexrays.mba_t (class) -ida_hexrays.mba_t.__init__ (method) -ida_hexrays.mba_t._deregister (method) -ida_hexrays.mba_t._print (method) -ida_hexrays.mba_t._register (method) -ida_hexrays.mba_t.aliased_args (variable) -ida_hexrays.mba_t.aliased_memory (variable) -ida_hexrays.mba_t.aliased_vars (variable) -ida_hexrays.mba_t.alloc_fict_ea (method) -ida_hexrays.mba_t.alloc_kreg (method) -ida_hexrays.mba_t.alloc_lvars (method) -ida_hexrays.mba_t.analyze_calls (method) -ida_hexrays.mba_t.arg (method) -ida_hexrays.mba_t.argbase (method) -ida_hexrays.mba_t.argidx (variable) -ida_hexrays.mba_t.argidx_ok (method) -ida_hexrays.mba_t.argidx_sorted (method) -ida_hexrays.mba_t.bad_call_sp_detected (method) -ida_hexrays.mba_t.blocks (variable) -ida_hexrays.mba_t.build_graph (method) -ida_hexrays.mba_t.calc_shins_flags (method) -ida_hexrays.mba_t.callinfo_built (method) -ida_hexrays.mba_t.cc (variable) -ida_hexrays.mba_t.chain_varnums_ok (method) -ida_hexrays.mba_t.clr_cdtr (method) -ida_hexrays.mba_t.clr_mba_flags (method) -ida_hexrays.mba_t.clr_mba_flags2 (method) -ida_hexrays.mba_t.code16_bit_removed (method) -ida_hexrays.mba_t.combine_blocks (method) -ida_hexrays.mba_t.common_stkvars_stkargs (method) -ida_hexrays.mba_t.consumed_argregs (variable) -ida_hexrays.mba_t.copy_block (method) -ida_hexrays.mba_t.create_helper_call (method) -ida_hexrays.mba_t.deleted_pairs (method) -ida_hexrays.mba_t.deprecated_idb_node (variable) -ida_hexrays.mba_t.deserialize (method) -ida_hexrays.mba_t.display_numaddrs (method) -ida_hexrays.mba_t.display_valnums (method) -ida_hexrays.mba_t.dump (method) -ida_hexrays.mba_t.dump_mba (method) -ida_hexrays.mba_t.error_ea (variable) -ida_hexrays.mba_t.final_type (variable) -ida_hexrays.mba_t.find_mop (method) -ida_hexrays.mba_t.for_all_insns (method) -ida_hexrays.mba_t.for_all_ops (method) -ida_hexrays.mba_t.for_all_topinsns (method) -ida_hexrays.mba_t.fpd (variable) -ida_hexrays.mba_t.free_kreg (method) -ida_hexrays.mba_t.frregs (variable) -ida_hexrays.mba_t.frsize (variable) -ida_hexrays.mba_t.fti_flags (variable) -ida_hexrays.mba_t.fullsize (variable) -ida_hexrays.mba_t.generated_asserts (method) -ida_hexrays.mba_t.get_args_region (method) -ida_hexrays.mba_t.get_curfunc (method) -ida_hexrays.mba_t.get_func_output_lists (method) -ida_hexrays.mba_t.get_graph (method) -ida_hexrays.mba_t.get_ida_argloc (method) -ida_hexrays.mba_t.get_lvars_region (method) -ida_hexrays.mba_t.get_mba_flags (method) -ida_hexrays.mba_t.get_mba_flags2 (method) -ida_hexrays.mba_t.get_mblock (method) -ida_hexrays.mba_t.get_shadow_region (method) -ida_hexrays.mba_t.get_stack_region (method) -ida_hexrays.mba_t.get_std_region (method) -ida_hexrays.mba_t.gotoff_stkvars (variable) -ida_hexrays.mba_t.graph_insns (method) -ida_hexrays.mba_t.has_bad_sp (method) -ida_hexrays.mba_t.has_outlines (method) -ida_hexrays.mba_t.has_over_chains (method) -ida_hexrays.mba_t.has_passregs (method) -ida_hexrays.mba_t.has_stack_retval (method) -ida_hexrays.mba_t.idaloc2vd (method) -ida_hexrays.mba_t.idb_spoiled (variable) -ida_hexrays.mba_t.idb_type (variable) -ida_hexrays.mba_t.inargoff (variable) -ida_hexrays.mba_t.insert_block (method) -ida_hexrays.mba_t.is_cdtr (method) -ida_hexrays.mba_t.is_ctr (method) -ida_hexrays.mba_t.is_dtr (method) -ida_hexrays.mba_t.is_pattern (method) -ida_hexrays.mba_t.is_snippet (method) -ida_hexrays.mba_t.is_stkarg (method) -ida_hexrays.mba_t.is_thunk (method) -ida_hexrays.mba_t.label (variable) -ida_hexrays.mba_t.loaded_gdl (method) -ida_hexrays.mba_t.lvar_names_ok (method) -ida_hexrays.mba_t.lvars_allocated (method) -ida_hexrays.mba_t.lvars_renamed (method) -ida_hexrays.mba_t.map_fict_ea (method) -ida_hexrays.mba_t.mark_chains_dirty (method) -ida_hexrays.mba_t.maturity (variable) -ida_hexrays.mba_t.may_refine_rettype (method) -ida_hexrays.mba_t.minargref (variable) -ida_hexrays.mba_t.minstkref (variable) -ida_hexrays.mba_t.minstkref_ea (variable) -ida_hexrays.mba_t.natural (variable) -ida_hexrays.mba_t.nodel_memory (variable) -ida_hexrays.mba_t.npurged (variable) -ida_hexrays.mba_t.optimize_global (method) -ida_hexrays.mba_t.optimize_local (method) -ida_hexrays.mba_t.optimized (method) -ida_hexrays.mba_t.pfn_flags (variable) -ida_hexrays.mba_t.precise_defeas (method) -ida_hexrays.mba_t.prop_complex (method) -ida_hexrays.mba_t.propagated_asserts (method) -ida_hexrays.mba_t.qty (variable) -ida_hexrays.mba_t.really_alloc (method) -ida_hexrays.mba_t.regargs_is_not_aligned (method) -ida_hexrays.mba_t.remove_block (method) -ida_hexrays.mba_t.remove_empty_and_unreachable_blocks (method) -ida_hexrays.mba_t.reqmat (variable) -ida_hexrays.mba_t.retsize (variable) -ida_hexrays.mba_t.returns_fpval (method) -ida_hexrays.mba_t.retvaridx (variable) -ida_hexrays.mba_t.rtype_refined (method) -ida_hexrays.mba_t.save_snapshot (method) -ida_hexrays.mba_t.saverest_done (method) -ida_hexrays.mba_t.serialize (method) -ida_hexrays.mba_t.set_lvar_name (method) -ida_hexrays.mba_t.set_maturity (method) -ida_hexrays.mba_t.set_mba_flags (method) -ida_hexrays.mba_t.set_mba_flags2 (method) -ida_hexrays.mba_t.set_nice_lvar_name (method) -ida_hexrays.mba_t.set_user_lvar_name (method) -ida_hexrays.mba_t.shadow_args (variable) -ida_hexrays.mba_t.short_display (method) -ida_hexrays.mba_t.should_beautify (method) -ida_hexrays.mba_t.show_reduction (method) -ida_hexrays.mba_t.spd_adjust (variable) -ida_hexrays.mba_t.spoiled_list (variable) -ida_hexrays.mba_t.stacksize (variable) -ida_hexrays.mba_t.std_ivls (variable) -ida_hexrays.mba_t.stkoff_ida2vd (method) -ida_hexrays.mba_t.stkoff_vd2ida (method) -ida_hexrays.mba_t.term (method) -ida_hexrays.mba_t.tmpstk_size (variable) -ida_hexrays.mba_t.use_frame (method) -ida_hexrays.mba_t.use_wingraph32 (method) -ida_hexrays.mba_t.valranges_done (method) -ida_hexrays.mba_t.vars (variable) -ida_hexrays.mba_t.vd2idaloc (method) -ida_hexrays.mba_t.verify (method) -ida_hexrays.mba_t.write_to_const_detected (method) -ida_hexrays.mba_t_deserialize (function) -ida_hexrays.mbl_graph_t (class) -ida_hexrays.mbl_graph_t.__init__ (method) -ida_hexrays.mbl_graph_t.get_chain_stamp (method) -ida_hexrays.mbl_graph_t.get_du (method) -ida_hexrays.mbl_graph_t.get_mblock (method) -ida_hexrays.mbl_graph_t.get_ud (method) -ida_hexrays.mbl_graph_t.is_du_chain_dirty (method) -ida_hexrays.mbl_graph_t.is_redefined_globally (method) -ida_hexrays.mbl_graph_t.is_ud_chain_dirty (method) -ida_hexrays.mbl_graph_t.is_used_globally (method) -ida_hexrays.mblock_t (class) -ida_hexrays.mblock_t.__init__ (method) -ida_hexrays.mblock_t._print (method) -ida_hexrays.mblock_t.append_def_list (method) -ida_hexrays.mblock_t.append_use_list (method) -ida_hexrays.mblock_t.build_def_list (method) -ida_hexrays.mblock_t.build_lists (method) -ida_hexrays.mblock_t.build_use_list (method) -ida_hexrays.mblock_t.dead_at_start (variable) -ida_hexrays.mblock_t.dnu (variable) -ida_hexrays.mblock_t.dump (method) -ida_hexrays.mblock_t.dump_block (method) -ida_hexrays.mblock_t.empty (method) -ida_hexrays.mblock_t.end (variable) -ida_hexrays.mblock_t.find_access (method) -ida_hexrays.mblock_t.find_def (method) -ida_hexrays.mblock_t.find_first_use (method) -ida_hexrays.mblock_t.find_redefinition (method) -ida_hexrays.mblock_t.find_use (method) -ida_hexrays.mblock_t.flags (variable) -ida_hexrays.mblock_t.for_all_insns (method) -ida_hexrays.mblock_t.for_all_ops (method) -ida_hexrays.mblock_t.for_all_uses (method) -ida_hexrays.mblock_t.get_reginsn_qty (method) -ida_hexrays.mblock_t.get_valranges (method) -ida_hexrays.mblock_t.head (variable) -ida_hexrays.mblock_t.insert_into_block (method) -ida_hexrays.mblock_t.is_branch (method) -ida_hexrays.mblock_t.is_call_block (method) -ida_hexrays.mblock_t.is_nway (method) -ida_hexrays.mblock_t.is_redefined (method) -ida_hexrays.mblock_t.is_rhs_redefined (method) -ida_hexrays.mblock_t.is_simple_goto_block (method) -ida_hexrays.mblock_t.is_simple_jcnd_block (method) -ida_hexrays.mblock_t.is_unknown_call (method) -ida_hexrays.mblock_t.is_used (method) -ida_hexrays.mblock_t.lists_dirty (method) -ida_hexrays.mblock_t.lists_ready (method) -ida_hexrays.mblock_t.make_lists_ready (method) -ida_hexrays.mblock_t.make_nop (method) -ida_hexrays.mblock_t.mark_lists_dirty (method) -ida_hexrays.mblock_t.maxbsp (variable) -ida_hexrays.mblock_t.maybdef (variable) -ida_hexrays.mblock_t.maybuse (variable) -ida_hexrays.mblock_t.mba (variable) -ida_hexrays.mblock_t.minbargref (variable) -ida_hexrays.mblock_t.minbstkref (variable) -ida_hexrays.mblock_t.mustbdef (variable) -ida_hexrays.mblock_t.mustbuse (variable) -ida_hexrays.mblock_t.needs_propagation (method) -ida_hexrays.mblock_t.nextb (variable) -ida_hexrays.mblock_t.npred (method) -ida_hexrays.mblock_t.nsucc (method) -ida_hexrays.mblock_t.optimize_block (method) -ida_hexrays.mblock_t.optimize_insn (method) -ida_hexrays.mblock_t.optimize_useless_jump (method) -ida_hexrays.mblock_t.pred (method) -ida_hexrays.mblock_t.preds (method) -ida_hexrays.mblock_t.predset (variable) -ida_hexrays.mblock_t.prevb (variable) -ida_hexrays.mblock_t.remove_from_block (method) -ida_hexrays.mblock_t.request_demote64 (method) -ida_hexrays.mblock_t.request_propagation (method) -ida_hexrays.mblock_t.serial (variable) -ida_hexrays.mblock_t.start (variable) -ida_hexrays.mblock_t.succ (method) -ida_hexrays.mblock_t.succs (method) -ida_hexrays.mblock_t.succset (variable) -ida_hexrays.mblock_t.tail (variable) -ida_hexrays.mblock_t.type (variable) -ida_hexrays.mcallarg_t (class) -ida_hexrays.mcallarg_t.__init__ (method) -ida_hexrays.mcallarg_t._print (method) -ida_hexrays.mcallarg_t.argloc (variable) -ida_hexrays.mcallarg_t.copy_mop (method) -ida_hexrays.mcallarg_t.dstr (method) -ida_hexrays.mcallarg_t.ea (variable) -ida_hexrays.mcallarg_t.flags (variable) -ida_hexrays.mcallarg_t.make_int (method) -ida_hexrays.mcallarg_t.make_uint (method) -ida_hexrays.mcallarg_t.name (variable) -ida_hexrays.mcallarg_t.set_regarg (method) -ida_hexrays.mcallarg_t.type (variable) -ida_hexrays.mcallargs_t (class) -ida_hexrays.mcallargs_t.__eq__ (method) -ida_hexrays.mcallargs_t.__getitem__ (method) -ida_hexrays.mcallargs_t.__init__ (method) -ida_hexrays.mcallargs_t.__len__ (method) -ida_hexrays.mcallargs_t.__ne__ (method) -ida_hexrays.mcallargs_t.__setitem__ (method) -ida_hexrays.mcallargs_t._del (method) -ida_hexrays.mcallargs_t.add_unique (method) -ida_hexrays.mcallargs_t.at (method) -ida_hexrays.mcallargs_t.begin (method) -ida_hexrays.mcallargs_t.capacity (method) -ida_hexrays.mcallargs_t.clear (method) -ida_hexrays.mcallargs_t.empty (method) -ida_hexrays.mcallargs_t.end (method) -ida_hexrays.mcallargs_t.erase (method) -ida_hexrays.mcallargs_t.extract (method) -ida_hexrays.mcallargs_t.find (method) -ida_hexrays.mcallargs_t.grow (method) -ida_hexrays.mcallargs_t.has (method) -ida_hexrays.mcallargs_t.inject (method) -ida_hexrays.mcallargs_t.insert (method) -ida_hexrays.mcallargs_t.pop_back (method) -ida_hexrays.mcallargs_t.push_back (method) -ida_hexrays.mcallargs_t.qclear (method) -ida_hexrays.mcallargs_t.reserve (method) -ida_hexrays.mcallargs_t.resize (method) -ida_hexrays.mcallargs_t.size (method) -ida_hexrays.mcallargs_t.swap (method) -ida_hexrays.mcallargs_t.truncate (method) -ida_hexrays.mcallinfo_t (class) -ida_hexrays.mcallinfo_t.__init__ (method) -ida_hexrays.mcallinfo_t._print (method) -ida_hexrays.mcallinfo_t.args (variable) -ida_hexrays.mcallinfo_t.call_spd (variable) -ida_hexrays.mcallinfo_t.callee (variable) -ida_hexrays.mcallinfo_t.cc (variable) -ida_hexrays.mcallinfo_t.dead_regs (variable) -ida_hexrays.mcallinfo_t.dstr (method) -ida_hexrays.mcallinfo_t.flags (variable) -ida_hexrays.mcallinfo_t.fti_attrs (variable) -ida_hexrays.mcallinfo_t.get_type (method) -ida_hexrays.mcallinfo_t.is_vararg (method) -ida_hexrays.mcallinfo_t.lexcompare (method) -ida_hexrays.mcallinfo_t.pass_regs (variable) -ida_hexrays.mcallinfo_t.retregs (variable) -ida_hexrays.mcallinfo_t.return_argloc (variable) -ida_hexrays.mcallinfo_t.return_regs (variable) -ida_hexrays.mcallinfo_t.return_type (variable) -ida_hexrays.mcallinfo_t.role (variable) -ida_hexrays.mcallinfo_t.set_type (method) -ida_hexrays.mcallinfo_t.solid_args (variable) -ida_hexrays.mcallinfo_t.spoiled (variable) -ida_hexrays.mcallinfo_t.stkargs_top (variable) -ida_hexrays.mcallinfo_t.visible_memory (variable) -ida_hexrays.mcases_t (class) -ida_hexrays.mcases_t.__eq__ (method) -ida_hexrays.mcases_t.__ge__ (method) -ida_hexrays.mcases_t.__gt__ (method) -ida_hexrays.mcases_t.__init__ (method) -ida_hexrays.mcases_t.__le__ (method) -ida_hexrays.mcases_t.__lt__ (method) -ida_hexrays.mcases_t.__ne__ (method) -ida_hexrays.mcases_t._print (method) -ida_hexrays.mcases_t.compare (method) -ida_hexrays.mcases_t.dstr (method) -ida_hexrays.mcases_t.empty (method) -ida_hexrays.mcases_t.resize (method) -ida_hexrays.mcases_t.size (method) -ida_hexrays.mcases_t.swap (method) -ida_hexrays.mcases_t.targets (variable) -ida_hexrays.mcases_t.values (variable) -ida_hexrays.mcode_modifies_d (function) -ida_hexrays.microcode_filter_t (class) -ida_hexrays.microcode_filter_t.__disown__ (method) -ida_hexrays.microcode_filter_t.__init__ (method) -ida_hexrays.microcode_filter_t.apply (method) -ida_hexrays.microcode_filter_t.match (method) -ida_hexrays.minsn_t (class) -ida_hexrays.minsn_t.__dbg_get_meminfo (method) -ida_hexrays.minsn_t.__dbg_get_registered_kind (method) -ida_hexrays.minsn_t.__init__ (method) -ida_hexrays.minsn_t.__lt__ (method) -ida_hexrays.minsn_t._acquire_ownership (method) -ida_hexrays.minsn_t._deregister (method) -ida_hexrays.minsn_t._ensure_cond (method) -ida_hexrays.minsn_t._ensure_no_obj (method) -ida_hexrays.minsn_t._ensure_ownership_transferrable (method) -ida_hexrays.minsn_t._make_nop (method) -ida_hexrays.minsn_t._maybe_disown_and_deregister (method) -ida_hexrays.minsn_t._meminfo (method) -ida_hexrays.minsn_t._obj_id (method) -ida_hexrays.minsn_t._own_and_register (method) -ida_hexrays.minsn_t._print (method) -ida_hexrays.minsn_t._register (method) -ida_hexrays.minsn_t.clr_assert (method) -ida_hexrays.minsn_t.clr_combinable (method) -ida_hexrays.minsn_t.clr_combined (method) -ida_hexrays.minsn_t.clr_fpinsn (method) -ida_hexrays.minsn_t.clr_ignlowsrc (method) -ida_hexrays.minsn_t.clr_multimov (method) -ida_hexrays.minsn_t.clr_noret_icall (method) -ida_hexrays.minsn_t.clr_propagatable (method) -ida_hexrays.minsn_t.clr_tailcall (method) -ida_hexrays.minsn_t.contains_call (method) -ida_hexrays.minsn_t.contains_opcode (method) -ida_hexrays.minsn_t.d (variable) -ida_hexrays.minsn_t.deserialize (method) -ida_hexrays.minsn_t.dstr (method) -ida_hexrays.minsn_t.ea (variable) -ida_hexrays.minsn_t.equal_insns (method) -ida_hexrays.minsn_t.find_call (method) -ida_hexrays.minsn_t.find_ins_op (method) -ida_hexrays.minsn_t.find_num_op (method) -ida_hexrays.minsn_t.find_opcode (method) -ida_hexrays.minsn_t.for_all_insns (method) -ida_hexrays.minsn_t.for_all_ops (method) -ida_hexrays.minsn_t.get_role (method) -ida_hexrays.minsn_t.get_split_size (method) -ida_hexrays.minsn_t.has_side_effects (method) -ida_hexrays.minsn_t.iprops (variable) -ida_hexrays.minsn_t.is_after (method) -ida_hexrays.minsn_t.is_alloca (method) -ida_hexrays.minsn_t.is_assert (method) -ida_hexrays.minsn_t.is_between (method) -ida_hexrays.minsn_t.is_bswap (method) -ida_hexrays.minsn_t.is_cleaning_pop (method) -ida_hexrays.minsn_t.is_combinable (method) -ida_hexrays.minsn_t.is_combined (method) -ida_hexrays.minsn_t.is_extstx (method) -ida_hexrays.minsn_t.is_farcall (method) -ida_hexrays.minsn_t.is_fpinsn (method) -ida_hexrays.minsn_t.is_helper (method) -ida_hexrays.minsn_t.is_ignlowsrc (method) -ida_hexrays.minsn_t.is_inverted_jx (method) -ida_hexrays.minsn_t.is_like_move (method) -ida_hexrays.minsn_t.is_mbarrier (method) -ida_hexrays.minsn_t.is_memcpy (method) -ida_hexrays.minsn_t.is_memset (method) -ida_hexrays.minsn_t.is_mov (method) -ida_hexrays.minsn_t.is_multimov (method) -ida_hexrays.minsn_t.is_noret_call (method) -ida_hexrays.minsn_t.is_optional (method) -ida_hexrays.minsn_t.is_persistent (method) -ida_hexrays.minsn_t.is_propagatable (method) -ida_hexrays.minsn_t.is_readflags (method) -ida_hexrays.minsn_t.is_tailcall (method) -ida_hexrays.minsn_t.is_unknown_call (method) -ida_hexrays.minsn_t.is_wild_match (method) -ida_hexrays.minsn_t.l (variable) -ida_hexrays.minsn_t.lexcompare (method) -ida_hexrays.minsn_t.may_use_aliased_memory (method) -ida_hexrays.minsn_t.modifies_d (method) -ida_hexrays.minsn_t.modifies_pair_mop (method) -ida_hexrays.minsn_t.next (variable) -ida_hexrays.minsn_t.opcode (variable) -ida_hexrays.minsn_t.optimize_solo (method) -ida_hexrays.minsn_t.optimize_subtree (method) -ida_hexrays.minsn_t.prev (variable) -ida_hexrays.minsn_t.r (variable) -ida_hexrays.minsn_t.replace_by (method) -ida_hexrays.minsn_t.serialize (method) -ida_hexrays.minsn_t.set_assert (method) -ida_hexrays.minsn_t.set_cleaning_pop (method) -ida_hexrays.minsn_t.set_combinable (method) -ida_hexrays.minsn_t.set_extstx (method) -ida_hexrays.minsn_t.set_farcall (method) -ida_hexrays.minsn_t.set_fpinsn (method) -ida_hexrays.minsn_t.set_ignlowsrc (method) -ida_hexrays.minsn_t.set_inverted_jx (method) -ida_hexrays.minsn_t.set_mbarrier (method) -ida_hexrays.minsn_t.set_multimov (method) -ida_hexrays.minsn_t.set_noret_icall (method) -ida_hexrays.minsn_t.set_optional (method) -ida_hexrays.minsn_t.set_persistent (method) -ida_hexrays.minsn_t.set_split_size (method) -ida_hexrays.minsn_t.set_tailcall (method) -ida_hexrays.minsn_t.set_unmerged (method) -ida_hexrays.minsn_t.set_wild_match (method) -ida_hexrays.minsn_t.setaddr (method) -ida_hexrays.minsn_t.swap (method) -ida_hexrays.minsn_t.was_noret_icall (method) -ida_hexrays.minsn_t.was_split (method) -ida_hexrays.minsn_t.was_unmerged (method) -ida_hexrays.minsn_visitor_t (class) -ida_hexrays.minsn_visitor_t.__disown__ (method) -ida_hexrays.minsn_visitor_t.__init__ (method) -ida_hexrays.minsn_visitor_t.visit_minsn (method) -ida_hexrays.mlist_mop_visitor_t (class) -ida_hexrays.mlist_mop_visitor_t.__disown__ (method) -ida_hexrays.mlist_mop_visitor_t.__init__ (method) -ida_hexrays.mlist_mop_visitor_t.visit_mop (method) -ida_hexrays.mlist_t (class) -ida_hexrays.mlist_t.__eq__ (method) -ida_hexrays.mlist_t.__ge__ (method) -ida_hexrays.mlist_t.__gt__ (method) -ida_hexrays.mlist_t.__init__ (method) -ida_hexrays.mlist_t.__le__ (method) -ida_hexrays.mlist_t.__lt__ (method) -ida_hexrays.mlist_t.__ne__ (method) -ida_hexrays.mlist_t._print (method) -ida_hexrays.mlist_t.add (method) -ida_hexrays.mlist_t.addmem (method) -ida_hexrays.mlist_t.clear (method) -ida_hexrays.mlist_t.compare (method) -ida_hexrays.mlist_t.count (method) -ida_hexrays.mlist_t.dstr (method) -ida_hexrays.mlist_t.empty (method) -ida_hexrays.mlist_t.has (method) -ida_hexrays.mlist_t.has_all (method) -ida_hexrays.mlist_t.has_any (method) -ida_hexrays.mlist_t.has_common (method) -ida_hexrays.mlist_t.has_memory (method) -ida_hexrays.mlist_t.includes (method) -ida_hexrays.mlist_t.intersect (method) -ida_hexrays.mlist_t.is_subset_of (method) -ida_hexrays.mlist_t.sub (method) -ida_hexrays.mlist_t.swap (method) -ida_hexrays.mnumber_t (class) -ida_hexrays.mnumber_t.__eq__ (method) -ida_hexrays.mnumber_t.__ge__ (method) -ida_hexrays.mnumber_t.__gt__ (method) -ida_hexrays.mnumber_t.__init__ (method) -ida_hexrays.mnumber_t.__le__ (method) -ida_hexrays.mnumber_t.__lt__ (method) -ida_hexrays.mnumber_t.__ne__ (method) -ida_hexrays.mnumber_t.compare (method) -ida_hexrays.mnumber_t.update_value (method) -ida_hexrays.modify_user_lvar_info (function) -ida_hexrays.modify_user_lvars (function) -ida_hexrays.mop_S (variable) -ida_hexrays.mop_addr_t (class) -ida_hexrays.mop_addr_t.__init__ (method) -ida_hexrays.mop_addr_t.lexcompare (method) -ida_hexrays.mop_b (variable) -ida_hexrays.mop_c (variable) -ida_hexrays.mop_d (variable) -ida_hexrays.mop_f (variable) -ida_hexrays.mop_fn (variable) -ida_hexrays.mop_h (variable) -ida_hexrays.mop_l (variable) -ida_hexrays.mop_n (variable) -ida_hexrays.mop_p (variable) -ida_hexrays.mop_pair_t (class) -ida_hexrays.mop_pair_t.__init__ (method) -ida_hexrays.mop_pair_t.hop (variable) -ida_hexrays.mop_pair_t.lop (variable) -ida_hexrays.mop_r (variable) -ida_hexrays.mop_sc (variable) -ida_hexrays.mop_str (variable) -ida_hexrays.mop_t (class) -ida_hexrays.mop_t.__dbg_get_meminfo (method) -ida_hexrays.mop_t.__dbg_get_registered_kind (method) -ida_hexrays.mop_t.__eq__ (method) -ida_hexrays.mop_t.__init__ (method) -ida_hexrays.mop_t.__lt__ (method) -ida_hexrays.mop_t.__ne__ (method) -ida_hexrays.mop_t._acquire_ownership (method) -ida_hexrays.mop_t._deregister (method) -ida_hexrays.mop_t._ensure_cond (method) -ida_hexrays.mop_t._ensure_no_obj (method) -ida_hexrays.mop_t._ensure_no_t (method) -ida_hexrays.mop_t._ensure_ownership_transferrable (method) -ida_hexrays.mop_t._get_a (method) -ida_hexrays.mop_t._get_b (method) -ida_hexrays.mop_t._get_c (method) -ida_hexrays.mop_t._get_cstr (method) -ida_hexrays.mop_t._get_d (method) -ida_hexrays.mop_t._get_f (method) -ida_hexrays.mop_t._get_fpc (method) -ida_hexrays.mop_t._get_g (method) -ida_hexrays.mop_t._get_helper (method) -ida_hexrays.mop_t._get_l (method) -ida_hexrays.mop_t._get_nnn (method) -ida_hexrays.mop_t._get_pair (method) -ida_hexrays.mop_t._get_r (method) -ida_hexrays.mop_t._get_s (method) -ida_hexrays.mop_t._get_scif (method) -ida_hexrays.mop_t._get_t (method) -ida_hexrays.mop_t._make_blkref (method) -ida_hexrays.mop_t._make_callinfo (method) -ida_hexrays.mop_t._make_cases (method) -ida_hexrays.mop_t._make_gvar (method) -ida_hexrays.mop_t._make_insn (method) -ida_hexrays.mop_t._make_lvar (method) -ida_hexrays.mop_t._make_pair (method) -ida_hexrays.mop_t._make_reg (method) -ida_hexrays.mop_t._make_stkvar (method) -ida_hexrays.mop_t._make_strlit (method) -ida_hexrays.mop_t._maybe_disown_and_deregister (method) -ida_hexrays.mop_t._meminfo (method) -ida_hexrays.mop_t._obj_id (method) -ida_hexrays.mop_t._own_and_register (method) -ida_hexrays.mop_t._print (method) -ida_hexrays.mop_t._register (method) -ida_hexrays.mop_t._set_a (method) -ida_hexrays.mop_t._set_b (method) -ida_hexrays.mop_t._set_c (method) -ida_hexrays.mop_t._set_cstr (method) -ida_hexrays.mop_t._set_d (method) -ida_hexrays.mop_t._set_f (method) -ida_hexrays.mop_t._set_fpc (method) -ida_hexrays.mop_t._set_g (method) -ida_hexrays.mop_t._set_helper (method) -ida_hexrays.mop_t._set_l (method) -ida_hexrays.mop_t._set_nnn (method) -ida_hexrays.mop_t._set_pair (method) -ida_hexrays.mop_t._set_r (method) -ida_hexrays.mop_t._set_s (method) -ida_hexrays.mop_t._set_scif (method) -ida_hexrays.mop_t._set_t (method) -ida_hexrays.mop_t.apply_ld_mcode (method) -ida_hexrays.mop_t.apply_xds (method) -ida_hexrays.mop_t.apply_xdu (method) -ida_hexrays.mop_t.assign (method) -ida_hexrays.mop_t.change_size (method) -ida_hexrays.mop_t.create_from_insn (method) -ida_hexrays.mop_t.create_from_ivlset (method) -ida_hexrays.mop_t.create_from_mlist (method) -ida_hexrays.mop_t.create_from_scattered_vdloc (method) -ida_hexrays.mop_t.create_from_vdloc (method) -ida_hexrays.mop_t.double_size (method) -ida_hexrays.mop_t.dstr (method) -ida_hexrays.mop_t.empty (method) -ida_hexrays.mop_t.equal_mops (method) -ida_hexrays.mop_t.erase (method) -ida_hexrays.mop_t.erase_but_keep_size (method) -ida_hexrays.mop_t.for_all_ops (method) -ida_hexrays.mop_t.for_all_scattered_submops (method) -ida_hexrays.mop_t.get_insn (method) -ida_hexrays.mop_t.get_stkoff (method) -ida_hexrays.mop_t.get_stkvar (method) -ida_hexrays.mop_t.has_side_effects (method) -ida_hexrays.mop_t.is01 (method) -ida_hexrays.mop_t.is_arglist (method) -ida_hexrays.mop_t.is_bit_reg (method) -ida_hexrays.mop_t.is_cc (method) -ida_hexrays.mop_t.is_ccflags (method) -ida_hexrays.mop_t.is_constant (method) -ida_hexrays.mop_t.is_equal_to (method) -ida_hexrays.mop_t.is_extended_from (method) -ida_hexrays.mop_t.is_glbaddr (method) -ida_hexrays.mop_t.is_glbaddr_from_fixup (method) -ida_hexrays.mop_t.is_impptr_done (method) -ida_hexrays.mop_t.is_insn (method) -ida_hexrays.mop_t.is_kreg (method) -ida_hexrays.mop_t.is_lowaddr (method) -ida_hexrays.mop_t.is_mob (method) -ida_hexrays.mop_t.is_negative_constant (method) -ida_hexrays.mop_t.is_one (method) -ida_hexrays.mop_t.is_pcval (method) -ida_hexrays.mop_t.is_positive_constant (method) -ida_hexrays.mop_t.is_reg (method) -ida_hexrays.mop_t.is_scattered (method) -ida_hexrays.mop_t.is_sign_extended_from (method) -ida_hexrays.mop_t.is_stkaddr (method) -ida_hexrays.mop_t.is_udt (method) -ida_hexrays.mop_t.is_undef_val (method) -ida_hexrays.mop_t.is_zero (method) -ida_hexrays.mop_t.is_zero_extended_from (method) -ida_hexrays.mop_t.lexcompare (method) -ida_hexrays.mop_t.make_blkref (method) -ida_hexrays.mop_t.make_first_half (method) -ida_hexrays.mop_t.make_fpnum (method) -ida_hexrays.mop_t.make_gvar (method) -ida_hexrays.mop_t.make_helper (method) -ida_hexrays.mop_t.make_high_half (method) -ida_hexrays.mop_t.make_insn (method) -ida_hexrays.mop_t.make_low_half (method) -ida_hexrays.mop_t.make_number (method) -ida_hexrays.mop_t.make_reg (method) -ida_hexrays.mop_t.make_reg_pair (method) -ida_hexrays.mop_t.make_second_half (method) -ida_hexrays.mop_t.make_stkvar (method) -ida_hexrays.mop_t.may_use_aliased_memory (method) -ida_hexrays.mop_t.oprops (variable) -ida_hexrays.mop_t.preserve_side_effects (method) -ida_hexrays.mop_t.probably_floating (method) -ida_hexrays.mop_t.replace_by (method) -ida_hexrays.mop_t.set_impptr_done (method) -ida_hexrays.mop_t.set_lowaddr (method) -ida_hexrays.mop_t.set_udt (method) -ida_hexrays.mop_t.set_undef_val (method) -ida_hexrays.mop_t.shift_mop (method) -ida_hexrays.mop_t.signed_value (method) -ida_hexrays.mop_t.size (variable) -ida_hexrays.mop_t.swap (method) -ida_hexrays.mop_t.t (variable) -ida_hexrays.mop_t.unsigned_value (method) -ida_hexrays.mop_t.update_numop_value (method) -ida_hexrays.mop_t.valnum (variable) -ida_hexrays.mop_t.value (method) -ida_hexrays.mop_t.zero (method) -ida_hexrays.mop_v (variable) -ida_hexrays.mop_visitor_t (class) -ida_hexrays.mop_visitor_t.__disown__ (method) -ida_hexrays.mop_visitor_t.__init__ (method) -ida_hexrays.mop_visitor_t.prune (variable) -ida_hexrays.mop_visitor_t.visit_mop (method) -ida_hexrays.mop_z (variable) -ida_hexrays.mopvec_t (class) -ida_hexrays.mopvec_t.__eq__ (method) -ida_hexrays.mopvec_t.__getitem__ (method) -ida_hexrays.mopvec_t.__init__ (method) -ida_hexrays.mopvec_t.__len__ (method) -ida_hexrays.mopvec_t.__ne__ (method) -ida_hexrays.mopvec_t.__setitem__ (method) -ida_hexrays.mopvec_t._del (method) -ida_hexrays.mopvec_t.add_unique (method) -ida_hexrays.mopvec_t.at (method) -ida_hexrays.mopvec_t.begin (method) -ida_hexrays.mopvec_t.capacity (method) -ida_hexrays.mopvec_t.clear (method) -ida_hexrays.mopvec_t.empty (method) -ida_hexrays.mopvec_t.end (method) -ida_hexrays.mopvec_t.erase (method) -ida_hexrays.mopvec_t.extract (method) -ida_hexrays.mopvec_t.find (method) -ida_hexrays.mopvec_t.grow (method) -ida_hexrays.mopvec_t.has (method) -ida_hexrays.mopvec_t.inject (method) -ida_hexrays.mopvec_t.insert (method) -ida_hexrays.mopvec_t.pop_back (method) -ida_hexrays.mopvec_t.push_back (method) -ida_hexrays.mopvec_t.qclear (method) -ida_hexrays.mopvec_t.reserve (method) -ida_hexrays.mopvec_t.resize (method) -ida_hexrays.mopvec_t.size (method) -ida_hexrays.mopvec_t.swap (method) -ida_hexrays.mopvec_t.truncate (method) -ida_hexrays.mreg2reg (function) -ida_hexrays.must_mcode_close_block (function) -ida_hexrays.negate_mcode_relation (function) -ida_hexrays.negated_relation (function) -ida_hexrays.new_block (function) -ida_hexrays.number_format_t (class) -ida_hexrays.number_format_t.__init__ (method) -ida_hexrays.number_format_t.flags (variable) -ida_hexrays.number_format_t.flags32 (variable) -ida_hexrays.number_format_t.get_radix (method) -ida_hexrays.number_format_t.has_unmutable_type (method) -ida_hexrays.number_format_t.is_char (method) -ida_hexrays.number_format_t.is_dec (method) -ida_hexrays.number_format_t.is_enum (method) -ida_hexrays.number_format_t.is_fixed (method) -ida_hexrays.number_format_t.is_hex (method) -ida_hexrays.number_format_t.is_numop (method) -ida_hexrays.number_format_t.is_oct (method) -ida_hexrays.number_format_t.is_stroff (method) -ida_hexrays.number_format_t.needs_to_be_inverted (method) -ida_hexrays.number_format_t.opnum (variable) -ida_hexrays.number_format_t.org_nbytes (variable) -ida_hexrays.number_format_t.serial (variable) -ida_hexrays.number_format_t.type_name (variable) -ida_hexrays.op_parent_info_t (class) -ida_hexrays.op_parent_info_t.__init__ (method) -ida_hexrays.op_uses_x (function) -ida_hexrays.op_uses_y (function) -ida_hexrays.op_uses_z (function) -ida_hexrays.open_pseudocode (function) -ida_hexrays.operand_locator_t (class) -ida_hexrays.operand_locator_t.__eq__ (method) -ida_hexrays.operand_locator_t.__ge__ (method) -ida_hexrays.operand_locator_t.__gt__ (method) -ida_hexrays.operand_locator_t.__init__ (method) -ida_hexrays.operand_locator_t.__le__ (method) -ida_hexrays.operand_locator_t.__lt__ (method) -ida_hexrays.operand_locator_t.__ne__ (method) -ida_hexrays.operand_locator_t.compare (method) -ida_hexrays.operand_locator_t.ea (variable) -ida_hexrays.operand_locator_t.opnum (variable) -ida_hexrays.optblock_t (class) -ida_hexrays.optblock_t.__disown__ (method) -ida_hexrays.optblock_t.__init__ (method) -ida_hexrays.optblock_t.func (method) -ida_hexrays.optblock_t.install (method) -ida_hexrays.optblock_t.remove (method) -ida_hexrays.optinsn_t (class) -ida_hexrays.optinsn_t.__disown__ (method) -ida_hexrays.optinsn_t.__init__ (method) -ida_hexrays.optinsn_t.func (method) -ida_hexrays.optinsn_t.install (method) -ida_hexrays.optinsn_t.remove (method) -ida_hexrays.parse_user_call (function) -ida_hexrays.partial_type_num (function) -ida_hexrays.print_vdloc (function) -ida_hexrays.property_op_to_typename (function) -ida_hexrays.qstring_printer_t (class) -ida_hexrays.qstring_printer_t.__init__ (method) -ida_hexrays.qstring_printer_t._print (method) -ida_hexrays.qstring_printer_t.get_s (method) -ida_hexrays.qstring_printer_t.s (variable) -ida_hexrays.qstring_printer_t.with_tags (variable) -ida_hexrays.qswap (function) -ida_hexrays.qvector_carg_t (class) -ida_hexrays.qvector_carg_t.__eq__ (method) -ida_hexrays.qvector_carg_t.__getitem__ (method) -ida_hexrays.qvector_carg_t.__init__ (method) -ida_hexrays.qvector_carg_t.__len__ (method) -ida_hexrays.qvector_carg_t.__ne__ (method) -ida_hexrays.qvector_carg_t.__setitem__ (method) -ida_hexrays.qvector_carg_t._del (method) -ida_hexrays.qvector_carg_t.add_unique (method) -ida_hexrays.qvector_carg_t.at (method) -ida_hexrays.qvector_carg_t.begin (method) -ida_hexrays.qvector_carg_t.capacity (method) -ida_hexrays.qvector_carg_t.clear (method) -ida_hexrays.qvector_carg_t.empty (method) -ida_hexrays.qvector_carg_t.end (method) -ida_hexrays.qvector_carg_t.erase (method) -ida_hexrays.qvector_carg_t.extract (method) -ida_hexrays.qvector_carg_t.find (method) -ida_hexrays.qvector_carg_t.grow (method) -ida_hexrays.qvector_carg_t.has (method) -ida_hexrays.qvector_carg_t.inject (method) -ida_hexrays.qvector_carg_t.insert (method) -ida_hexrays.qvector_carg_t.pop_back (method) -ida_hexrays.qvector_carg_t.push_back (method) -ida_hexrays.qvector_carg_t.qclear (method) -ida_hexrays.qvector_carg_t.reserve (method) -ida_hexrays.qvector_carg_t.resize (method) -ida_hexrays.qvector_carg_t.size (method) -ida_hexrays.qvector_carg_t.swap (method) -ida_hexrays.qvector_carg_t.truncate (method) -ida_hexrays.qvector_ccase_t (class) -ida_hexrays.qvector_ccase_t.__eq__ (method) -ida_hexrays.qvector_ccase_t.__getitem__ (method) -ida_hexrays.qvector_ccase_t.__init__ (method) -ida_hexrays.qvector_ccase_t.__len__ (method) -ida_hexrays.qvector_ccase_t.__ne__ (method) -ida_hexrays.qvector_ccase_t.__setitem__ (method) -ida_hexrays.qvector_ccase_t._del (method) -ida_hexrays.qvector_ccase_t.add_unique (method) -ida_hexrays.qvector_ccase_t.at (method) -ida_hexrays.qvector_ccase_t.begin (method) -ida_hexrays.qvector_ccase_t.capacity (method) -ida_hexrays.qvector_ccase_t.clear (method) -ida_hexrays.qvector_ccase_t.empty (method) -ida_hexrays.qvector_ccase_t.end (method) -ida_hexrays.qvector_ccase_t.erase (method) -ida_hexrays.qvector_ccase_t.extract (method) -ida_hexrays.qvector_ccase_t.find (method) -ida_hexrays.qvector_ccase_t.grow (method) -ida_hexrays.qvector_ccase_t.has (method) -ida_hexrays.qvector_ccase_t.inject (method) -ida_hexrays.qvector_ccase_t.insert (method) -ida_hexrays.qvector_ccase_t.pop_back (method) -ida_hexrays.qvector_ccase_t.push_back (method) -ida_hexrays.qvector_ccase_t.qclear (method) -ida_hexrays.qvector_ccase_t.reserve (method) -ida_hexrays.qvector_ccase_t.resize (method) -ida_hexrays.qvector_ccase_t.size (method) -ida_hexrays.qvector_ccase_t.swap (method) -ida_hexrays.qvector_ccase_t.truncate (method) -ida_hexrays.qvector_history_t (class) -ida_hexrays.qvector_history_t.__eq__ (method) -ida_hexrays.qvector_history_t.__getitem__ (method) -ida_hexrays.qvector_history_t.__init__ (method) -ida_hexrays.qvector_history_t.__len__ (method) -ida_hexrays.qvector_history_t.__ne__ (method) -ida_hexrays.qvector_history_t.__setitem__ (method) -ida_hexrays.qvector_history_t._del (method) -ida_hexrays.qvector_history_t.add_unique (method) -ida_hexrays.qvector_history_t.at (method) -ida_hexrays.qvector_history_t.begin (method) -ida_hexrays.qvector_history_t.capacity (method) -ida_hexrays.qvector_history_t.clear (method) -ida_hexrays.qvector_history_t.empty (method) -ida_hexrays.qvector_history_t.end (method) -ida_hexrays.qvector_history_t.erase (method) -ida_hexrays.qvector_history_t.extract (method) -ida_hexrays.qvector_history_t.find (method) -ida_hexrays.qvector_history_t.grow (method) -ida_hexrays.qvector_history_t.has (method) -ida_hexrays.qvector_history_t.inject (method) -ida_hexrays.qvector_history_t.insert (method) -ida_hexrays.qvector_history_t.pop_back (method) -ida_hexrays.qvector_history_t.push_back (method) -ida_hexrays.qvector_history_t.qclear (method) -ida_hexrays.qvector_history_t.reserve (method) -ida_hexrays.qvector_history_t.resize (method) -ida_hexrays.qvector_history_t.size (method) -ida_hexrays.qvector_history_t.swap (method) -ida_hexrays.qvector_history_t.truncate (method) -ida_hexrays.qvector_lvar_t (class) -ida_hexrays.qvector_lvar_t.__eq__ (method) -ida_hexrays.qvector_lvar_t.__getitem__ (method) -ida_hexrays.qvector_lvar_t.__init__ (method) -ida_hexrays.qvector_lvar_t.__len__ (method) -ida_hexrays.qvector_lvar_t.__ne__ (method) -ida_hexrays.qvector_lvar_t.__setitem__ (method) -ida_hexrays.qvector_lvar_t._del (method) -ida_hexrays.qvector_lvar_t.add_unique (method) -ida_hexrays.qvector_lvar_t.at (method) -ida_hexrays.qvector_lvar_t.begin (method) -ida_hexrays.qvector_lvar_t.capacity (method) -ida_hexrays.qvector_lvar_t.clear (method) -ida_hexrays.qvector_lvar_t.empty (method) -ida_hexrays.qvector_lvar_t.end (method) -ida_hexrays.qvector_lvar_t.erase (method) -ida_hexrays.qvector_lvar_t.extract (method) -ida_hexrays.qvector_lvar_t.find (method) -ida_hexrays.qvector_lvar_t.grow (method) -ida_hexrays.qvector_lvar_t.has (method) -ida_hexrays.qvector_lvar_t.inject (method) -ida_hexrays.qvector_lvar_t.insert (method) -ida_hexrays.qvector_lvar_t.pop_back (method) -ida_hexrays.qvector_lvar_t.push_back (method) -ida_hexrays.qvector_lvar_t.qclear (method) -ida_hexrays.qvector_lvar_t.reserve (method) -ida_hexrays.qvector_lvar_t.resize (method) -ida_hexrays.qvector_lvar_t.size (method) -ida_hexrays.qvector_lvar_t.swap (method) -ida_hexrays.qvector_lvar_t.truncate (method) -ida_hexrays.reg2mreg (function) -ida_hexrays.remitem (function) -ida_hexrays.remove_hexrays_callback (function) -ida_hexrays.rename_lvar (function) -ida_hexrays.restore_user_cmts (function) -ida_hexrays.restore_user_defined_calls (function) -ida_hexrays.restore_user_iflags (function) -ida_hexrays.restore_user_labels (function) -ida_hexrays.restore_user_labels2 (function) -ida_hexrays.restore_user_lvar_settings (function) -ida_hexrays.restore_user_numforms (function) -ida_hexrays.restore_user_unions (function) -ida_hexrays.rlist_t (class) -ida_hexrays.rlist_t.__init__ (method) -ida_hexrays.rlist_t.dstr (method) -ida_hexrays.save_user_cmts (function) -ida_hexrays.save_user_defined_calls (function) -ida_hexrays.save_user_iflags (function) -ida_hexrays.save_user_labels (function) -ida_hexrays.save_user_labels2 (function) -ida_hexrays.save_user_lvar_settings (function) -ida_hexrays.save_user_numforms (function) -ida_hexrays.save_user_unions (function) -ida_hexrays.scif_t (class) -ida_hexrays.scif_t.__init__ (method) -ida_hexrays.scif_t.mba (variable) -ida_hexrays.scif_t.name (variable) -ida_hexrays.scif_t.type (variable) -ida_hexrays.scif_visitor_t (class) -ida_hexrays.scif_visitor_t.__disown__ (method) -ida_hexrays.scif_visitor_t.__init__ (method) -ida_hexrays.scif_visitor_t.visit_scif_mop (method) -ida_hexrays.select_udt_by_offset (function) -ida_hexrays.send_database (function) -ida_hexrays.set2jcnd (function) -ida_hexrays.set_type (function) -ida_hexrays.simple_graph_t (class) -ida_hexrays.simple_graph_t.__init__ (method) -ida_hexrays.stkvar_ref_t (class) -ida_hexrays.stkvar_ref_t.__eq__ (method) -ida_hexrays.stkvar_ref_t.__ge__ (method) -ida_hexrays.stkvar_ref_t.__gt__ (method) -ida_hexrays.stkvar_ref_t.__init__ (method) -ida_hexrays.stkvar_ref_t.__le__ (method) -ida_hexrays.stkvar_ref_t.__lt__ (method) -ida_hexrays.stkvar_ref_t.__ne__ (method) -ida_hexrays.stkvar_ref_t.compare (method) -ida_hexrays.stkvar_ref_t.get_stkvar (method) -ida_hexrays.stkvar_ref_t.mba (variable) -ida_hexrays.stkvar_ref_t.off (variable) -ida_hexrays.stkvar_ref_t.swap (method) -ida_hexrays.swap_mcode_relation (function) -ida_hexrays.swapped_relation (function) -ida_hexrays.term_hexrays_plugin (function) -ida_hexrays.treeloc_t (class) -ida_hexrays.treeloc_t.__eq__ (method) -ida_hexrays.treeloc_t.__init__ (method) -ida_hexrays.treeloc_t.__lt__ (method) -ida_hexrays.udc_filter_t (class) -ida_hexrays.udc_filter_t.__disown__ (method) -ida_hexrays.udc_filter_t.__init__ (method) -ida_hexrays.udc_filter_t.apply (method) -ida_hexrays.udc_filter_t.cleanup (method) -ida_hexrays.udc_filter_t.empty (method) -ida_hexrays.udc_filter_t.init (method) -ida_hexrays.udc_filter_t.install (method) -ida_hexrays.udc_filter_t.match (method) -ida_hexrays.udc_filter_t.remove (method) -ida_hexrays.udcall_map_begin (function) -ida_hexrays.udcall_map_clear (function) -ida_hexrays.udcall_map_end (function) -ida_hexrays.udcall_map_erase (function) -ida_hexrays.udcall_map_find (function) -ida_hexrays.udcall_map_first (function) -ida_hexrays.udcall_map_free (function) -ida_hexrays.udcall_map_insert (function) -ida_hexrays.udcall_map_iterator_t (class) -ida_hexrays.udcall_map_iterator_t.__eq__ (method) -ida_hexrays.udcall_map_iterator_t.__init__ (method) -ida_hexrays.udcall_map_iterator_t.__ne__ (method) -ida_hexrays.udcall_map_new (function) -ida_hexrays.udcall_map_next (function) -ida_hexrays.udcall_map_prev (function) -ida_hexrays.udcall_map_second (function) -ida_hexrays.udcall_map_size (function) -ida_hexrays.udcall_t (class) -ida_hexrays.udcall_t.__eq__ (method) -ida_hexrays.udcall_t.__ge__ (method) -ida_hexrays.udcall_t.__gt__ (method) -ida_hexrays.udcall_t.__init__ (method) -ida_hexrays.udcall_t.__le__ (method) -ida_hexrays.udcall_t.__lt__ (method) -ida_hexrays.udcall_t.__ne__ (method) -ida_hexrays.udcall_t.compare (method) -ida_hexrays.udcall_t.empty (method) -ida_hexrays.ui_stroff_applicator_t (class) -ida_hexrays.ui_stroff_applicator_t.__disown__ (method) -ida_hexrays.ui_stroff_applicator_t.__init__ (method) -ida_hexrays.ui_stroff_applicator_t.apply (method) -ida_hexrays.ui_stroff_op_t (class) -ida_hexrays.ui_stroff_op_t.__eq__ (method) -ida_hexrays.ui_stroff_op_t.__init__ (method) -ida_hexrays.ui_stroff_op_t.__ne__ (method) -ida_hexrays.ui_stroff_op_t.offset (variable) -ida_hexrays.ui_stroff_op_t.text (variable) -ida_hexrays.ui_stroff_ops_t (class) -ida_hexrays.ui_stroff_ops_t.__eq__ (method) -ida_hexrays.ui_stroff_ops_t.__getitem__ (method) -ida_hexrays.ui_stroff_ops_t.__init__ (method) -ida_hexrays.ui_stroff_ops_t.__len__ (method) -ida_hexrays.ui_stroff_ops_t.__ne__ (method) -ida_hexrays.ui_stroff_ops_t.__setitem__ (method) -ida_hexrays.ui_stroff_ops_t._del (method) -ida_hexrays.ui_stroff_ops_t.add_unique (method) -ida_hexrays.ui_stroff_ops_t.at (method) -ida_hexrays.ui_stroff_ops_t.begin (method) -ida_hexrays.ui_stroff_ops_t.capacity (method) -ida_hexrays.ui_stroff_ops_t.clear (method) -ida_hexrays.ui_stroff_ops_t.empty (method) -ida_hexrays.ui_stroff_ops_t.end (method) -ida_hexrays.ui_stroff_ops_t.erase (method) -ida_hexrays.ui_stroff_ops_t.extract (method) -ida_hexrays.ui_stroff_ops_t.find (method) -ida_hexrays.ui_stroff_ops_t.grow (method) -ida_hexrays.ui_stroff_ops_t.has (method) -ida_hexrays.ui_stroff_ops_t.inject (method) -ida_hexrays.ui_stroff_ops_t.insert (method) -ida_hexrays.ui_stroff_ops_t.pop_back (method) -ida_hexrays.ui_stroff_ops_t.push_back (method) -ida_hexrays.ui_stroff_ops_t.qclear (method) -ida_hexrays.ui_stroff_ops_t.reserve (method) -ida_hexrays.ui_stroff_ops_t.resize (method) -ida_hexrays.ui_stroff_ops_t.size (method) -ida_hexrays.ui_stroff_ops_t.swap (method) -ida_hexrays.ui_stroff_ops_t.truncate (method) -ida_hexrays.user_cmts_begin (function) -ida_hexrays.user_cmts_clear (function) -ida_hexrays.user_cmts_end (function) -ida_hexrays.user_cmts_erase (function) -ida_hexrays.user_cmts_find (function) -ida_hexrays.user_cmts_first (function) -ida_hexrays.user_cmts_free (function) -ida_hexrays.user_cmts_insert (function) -ida_hexrays.user_cmts_iterator_t (class) -ida_hexrays.user_cmts_iterator_t.__eq__ (method) -ida_hexrays.user_cmts_iterator_t.__init__ (method) -ida_hexrays.user_cmts_iterator_t.__ne__ (method) -ida_hexrays.user_cmts_new (function) -ida_hexrays.user_cmts_next (function) -ida_hexrays.user_cmts_prev (function) -ida_hexrays.user_cmts_second (function) -ida_hexrays.user_cmts_size (function) -ida_hexrays.user_cmts_t (class) -ida_hexrays.user_cmts_t.__init__ (method) -ida_hexrays.user_cmts_t.at (method) -ida_hexrays.user_cmts_t.size (method) -ida_hexrays.user_iflags_begin (function) -ida_hexrays.user_iflags_clear (function) -ida_hexrays.user_iflags_end (function) -ida_hexrays.user_iflags_erase (function) -ida_hexrays.user_iflags_find (function) -ida_hexrays.user_iflags_first (function) -ida_hexrays.user_iflags_free (function) -ida_hexrays.user_iflags_insert (function) -ida_hexrays.user_iflags_iterator_t (class) -ida_hexrays.user_iflags_iterator_t.__eq__ (method) -ida_hexrays.user_iflags_iterator_t.__init__ (method) -ida_hexrays.user_iflags_iterator_t.__ne__ (method) -ida_hexrays.user_iflags_new (function) -ida_hexrays.user_iflags_next (function) -ida_hexrays.user_iflags_prev (function) -ida_hexrays.user_iflags_second (function) -ida_hexrays.user_iflags_size (function) -ida_hexrays.user_iflags_t (class) -ida_hexrays.user_iflags_t.__init__ (method) -ida_hexrays.user_iflags_t.at (method) -ida_hexrays.user_iflags_t.size (method) -ida_hexrays.user_labels_begin (function) -ida_hexrays.user_labels_clear (function) -ida_hexrays.user_labels_end (function) -ida_hexrays.user_labels_erase (function) -ida_hexrays.user_labels_find (function) -ida_hexrays.user_labels_first (function) -ida_hexrays.user_labels_free (function) -ida_hexrays.user_labels_insert (function) -ida_hexrays.user_labels_iterator_t (class) -ida_hexrays.user_labels_iterator_t.__eq__ (method) -ida_hexrays.user_labels_iterator_t.__init__ (method) -ida_hexrays.user_labels_iterator_t.__ne__ (method) -ida_hexrays.user_labels_new (function) -ida_hexrays.user_labels_next (function) -ida_hexrays.user_labels_prev (function) -ida_hexrays.user_labels_second (function) -ida_hexrays.user_labels_size (function) -ida_hexrays.user_labels_t (class) -ida_hexrays.user_labels_t.__init__ (method) -ida_hexrays.user_labels_t.at (method) -ida_hexrays.user_labels_t.size (method) -ida_hexrays.user_lvar_modifier_t (class) -ida_hexrays.user_lvar_modifier_t.__disown__ (method) -ida_hexrays.user_lvar_modifier_t.__init__ (method) -ida_hexrays.user_lvar_modifier_t.modify_lvars (method) -ida_hexrays.user_numforms_begin (function) -ida_hexrays.user_numforms_clear (function) -ida_hexrays.user_numforms_end (function) -ida_hexrays.user_numforms_erase (function) -ida_hexrays.user_numforms_find (function) -ida_hexrays.user_numforms_first (function) -ida_hexrays.user_numforms_free (function) -ida_hexrays.user_numforms_insert (function) -ida_hexrays.user_numforms_iterator_t (class) -ida_hexrays.user_numforms_iterator_t.__eq__ (method) -ida_hexrays.user_numforms_iterator_t.__init__ (method) -ida_hexrays.user_numforms_iterator_t.__ne__ (method) -ida_hexrays.user_numforms_new (function) -ida_hexrays.user_numforms_next (function) -ida_hexrays.user_numforms_prev (function) -ida_hexrays.user_numforms_second (function) -ida_hexrays.user_numforms_size (function) -ida_hexrays.user_numforms_t (class) -ida_hexrays.user_numforms_t.__init__ (method) -ida_hexrays.user_numforms_t.at (method) -ida_hexrays.user_numforms_t.size (method) -ida_hexrays.user_unions_begin (function) -ida_hexrays.user_unions_clear (function) -ida_hexrays.user_unions_end (function) -ida_hexrays.user_unions_erase (function) -ida_hexrays.user_unions_find (function) -ida_hexrays.user_unions_first (function) -ida_hexrays.user_unions_free (function) -ida_hexrays.user_unions_insert (function) -ida_hexrays.user_unions_iterator_t (class) -ida_hexrays.user_unions_iterator_t.__eq__ (method) -ida_hexrays.user_unions_iterator_t.__init__ (method) -ida_hexrays.user_unions_iterator_t.__ne__ (method) -ida_hexrays.user_unions_new (function) -ida_hexrays.user_unions_next (function) -ida_hexrays.user_unions_prev (function) -ida_hexrays.user_unions_second (function) -ida_hexrays.user_unions_size (function) -ida_hexrays.user_unions_t (class) -ida_hexrays.user_unions_t.__init__ (method) -ida_hexrays.user_unions_t.at (method) -ida_hexrays.user_unions_t.size (method) -ida_hexrays.uval_ivl_ivlset_t (class) -ida_hexrays.uval_ivl_ivlset_t.__eq__ (method) -ida_hexrays.uval_ivl_ivlset_t.__init__ (method) -ida_hexrays.uval_ivl_ivlset_t.__ne__ (method) -ida_hexrays.uval_ivl_ivlset_t.all_values (method) -ida_hexrays.uval_ivl_ivlset_t.begin (method) -ida_hexrays.uval_ivl_ivlset_t.clear (method) -ida_hexrays.uval_ivl_ivlset_t.empty (method) -ida_hexrays.uval_ivl_ivlset_t.end (method) -ida_hexrays.uval_ivl_ivlset_t.getivl (method) -ida_hexrays.uval_ivl_ivlset_t.lastivl (method) -ida_hexrays.uval_ivl_ivlset_t.nivls (method) -ida_hexrays.uval_ivl_ivlset_t.qclear (method) -ida_hexrays.uval_ivl_ivlset_t.set_all_values (method) -ida_hexrays.uval_ivl_ivlset_t.single_value (method) -ida_hexrays.uval_ivl_ivlset_t.swap (method) -ida_hexrays.uval_ivl_t (class) -ida_hexrays.uval_ivl_t.__init__ (method) -ida_hexrays.uval_ivl_t.end (method) -ida_hexrays.uval_ivl_t.last (method) -ida_hexrays.uval_ivl_t.valid (method) -ida_hexrays.valrng_t (class) -ida_hexrays.valrng_t.__eq__ (method) -ida_hexrays.valrng_t.__ge__ (method) -ida_hexrays.valrng_t.__gt__ (method) -ida_hexrays.valrng_t.__init__ (method) -ida_hexrays.valrng_t.__le__ (method) -ida_hexrays.valrng_t.__lt__ (method) -ida_hexrays.valrng_t.__ne__ (method) -ida_hexrays.valrng_t._deregister (method) -ida_hexrays.valrng_t._print (method) -ida_hexrays.valrng_t._register (method) -ida_hexrays.valrng_t.all_values (method) -ida_hexrays.valrng_t.compare (method) -ida_hexrays.valrng_t.cvt_to_cmp (method) -ida_hexrays.valrng_t.cvt_to_single_value (method) -ida_hexrays.valrng_t.dstr (method) -ida_hexrays.valrng_t.empty (method) -ida_hexrays.valrng_t.get_size (method) -ida_hexrays.valrng_t.has (method) -ida_hexrays.valrng_t.intersect_with (method) -ida_hexrays.valrng_t.inverse (method) -ida_hexrays.valrng_t.is_unknown (method) -ida_hexrays.valrng_t.max_svalue (method) -ida_hexrays.valrng_t.max_value (method) -ida_hexrays.valrng_t.min_svalue (method) -ida_hexrays.valrng_t.reduce_size (method) -ida_hexrays.valrng_t.set_all (method) -ida_hexrays.valrng_t.set_cmp (method) -ida_hexrays.valrng_t.set_eq (method) -ida_hexrays.valrng_t.set_none (method) -ida_hexrays.valrng_t.set_unk (method) -ida_hexrays.valrng_t.swap (method) -ida_hexrays.valrng_t.unite_with (method) -ida_hexrays.var_ref_t (class) -ida_hexrays.var_ref_t.__eq__ (method) -ida_hexrays.var_ref_t.__ge__ (method) -ida_hexrays.var_ref_t.__gt__ (method) -ida_hexrays.var_ref_t.__init__ (method) -ida_hexrays.var_ref_t.__le__ (method) -ida_hexrays.var_ref_t.__lt__ (method) -ida_hexrays.var_ref_t.__ne__ (method) -ida_hexrays.var_ref_t.compare (method) -ida_hexrays.var_ref_t.getv (method) -ida_hexrays.var_ref_t.idx (variable) -ida_hexrays.var_ref_t.mba (variable) -ida_hexrays.vc_printer_t (class) -ida_hexrays.vc_printer_t.__disown__ (method) -ida_hexrays.vc_printer_t.__init__ (method) -ida_hexrays.vc_printer_t.func (variable) -ida_hexrays.vc_printer_t.oneliner (method) -ida_hexrays.vd_failure_t (class) -ida_hexrays.vd_failure_t.__init__ (method) -ida_hexrays.vd_failure_t.desc (method) -ida_hexrays.vd_interr_t (class) -ida_hexrays.vd_interr_t.__init__ (method) -ida_hexrays.vd_printer_t (class) -ida_hexrays.vd_printer_t.__disown__ (method) -ida_hexrays.vd_printer_t.__init__ (method) -ida_hexrays.vd_printer_t._print (method) -ida_hexrays.vd_printer_t.hdrlines (variable) -ida_hexrays.vdloc_t (class) -ida_hexrays.vdloc_t.__eq__ (method) -ida_hexrays.vdloc_t.__ge__ (method) -ida_hexrays.vdloc_t.__gt__ (method) -ida_hexrays.vdloc_t.__init__ (method) -ida_hexrays.vdloc_t.__le__ (method) -ida_hexrays.vdloc_t.__lt__ (method) -ida_hexrays.vdloc_t.__ne__ (method) -ida_hexrays.vdloc_t._set_reg1 (method) -ida_hexrays.vdloc_t.compare (method) -ida_hexrays.vdloc_t.is_aliasable (method) -ida_hexrays.vdloc_t.reg1 (method) -ida_hexrays.vdloc_t.set_reg1 (method) -ida_hexrays.vdui_t (class) -ida_hexrays.vdui_t.__init__ (method) -ida_hexrays.vdui_t.calc_cmt_type (method) -ida_hexrays.vdui_t.cfunc (variable) -ida_hexrays.vdui_t.clear (method) -ida_hexrays.vdui_t.collapse_item (method) -ida_hexrays.vdui_t.collapse_lvars (method) -ida_hexrays.vdui_t.cpos (variable) -ida_hexrays.vdui_t.ct (variable) -ida_hexrays.vdui_t.ctree_to_disasm (method) -ida_hexrays.vdui_t.del_orphan_cmts (method) -ida_hexrays.vdui_t.edit_cmt (method) -ida_hexrays.vdui_t.edit_func_cmt (method) -ida_hexrays.vdui_t.flags (variable) -ida_hexrays.vdui_t.get_current_item (method) -ida_hexrays.vdui_t.get_current_label (method) -ida_hexrays.vdui_t.get_number (method) -ida_hexrays.vdui_t.head (variable) -ida_hexrays.vdui_t.in_ctree (method) -ida_hexrays.vdui_t.invert_bits (method) -ida_hexrays.vdui_t.invert_sign (method) -ida_hexrays.vdui_t.item (variable) -ida_hexrays.vdui_t.jump_enter (method) -ida_hexrays.vdui_t.last_code (variable) -ida_hexrays.vdui_t.locked (method) -ida_hexrays.vdui_t.map_lvar (method) -ida_hexrays.vdui_t.mba (variable) -ida_hexrays.vdui_t.refresh_cpos (method) -ida_hexrays.vdui_t.refresh_ctext (method) -ida_hexrays.vdui_t.refresh_view (method) -ida_hexrays.vdui_t.rename_global (method) -ida_hexrays.vdui_t.rename_label (method) -ida_hexrays.vdui_t.rename_lvar (method) -ida_hexrays.vdui_t.rename_strmem (method) -ida_hexrays.vdui_t.set_global_type (method) -ida_hexrays.vdui_t.set_locked (method) -ida_hexrays.vdui_t.set_lvar_cmt (method) -ida_hexrays.vdui_t.set_lvar_type (method) -ida_hexrays.vdui_t.set_noptr_lvar (method) -ida_hexrays.vdui_t.set_num_enum (method) -ida_hexrays.vdui_t.set_num_radix (method) -ida_hexrays.vdui_t.set_num_stroff (method) -ida_hexrays.vdui_t.set_strmem_type (method) -ida_hexrays.vdui_t.set_valid (method) -ida_hexrays.vdui_t.set_visible (method) -ida_hexrays.vdui_t.split_item (method) -ida_hexrays.vdui_t.switch_to (method) -ida_hexrays.vdui_t.tail (variable) -ida_hexrays.vdui_t.ui_edit_lvar_cmt (method) -ida_hexrays.vdui_t.ui_map_lvar (method) -ida_hexrays.vdui_t.ui_rename_lvar (method) -ida_hexrays.vdui_t.ui_set_call_type (method) -ida_hexrays.vdui_t.ui_set_lvar_type (method) -ida_hexrays.vdui_t.ui_unmap_lvar (method) -ida_hexrays.vdui_t.valid (method) -ida_hexrays.vdui_t.view_idx (variable) -ida_hexrays.vdui_t.visible (method) -ida_hexrays.vivl_t (class) -ida_hexrays.vivl_t.__eq__ (method) -ida_hexrays.vivl_t.__ge__ (method) -ida_hexrays.vivl_t.__gt__ (method) -ida_hexrays.vivl_t.__init__ (method) -ida_hexrays.vivl_t.__le__ (method) -ida_hexrays.vivl_t.__lt__ (method) -ida_hexrays.vivl_t.__ne__ (method) -ida_hexrays.vivl_t._print (method) -ida_hexrays.vivl_t.compare (method) -ida_hexrays.vivl_t.contains (method) -ida_hexrays.vivl_t.dstr (method) -ida_hexrays.vivl_t.extend_to_cover (method) -ida_hexrays.vivl_t.includes (method) -ida_hexrays.vivl_t.intersect (method) -ida_hexrays.vivl_t.overlap (method) -ida_hexrays.vivl_t.set (method) -ida_hexrays.vivl_t.set_reg (method) -ida_hexrays.vivl_t.set_stkoff (method) -ida_hexrays.vivl_t.size (variable) -ida_hexrays.voff_t (class) -ida_hexrays.voff_t.__eq__ (method) -ida_hexrays.voff_t.__ge__ (method) -ida_hexrays.voff_t.__gt__ (method) -ida_hexrays.voff_t.__init__ (method) -ida_hexrays.voff_t.__le__ (method) -ida_hexrays.voff_t.__lt__ (method) -ida_hexrays.voff_t.__ne__ (method) -ida_hexrays.voff_t.add (method) -ida_hexrays.voff_t.compare (method) -ida_hexrays.voff_t.defined (method) -ida_hexrays.voff_t.diff (method) -ida_hexrays.voff_t.get_reg (method) -ida_hexrays.voff_t.get_stkoff (method) -ida_hexrays.voff_t.inc (method) -ida_hexrays.voff_t.is_reg (method) -ida_hexrays.voff_t.is_stkoff (method) -ida_hexrays.voff_t.off (variable) -ida_hexrays.voff_t.set (method) -ida_hexrays.voff_t.set_reg (method) -ida_hexrays.voff_t.set_stkoff (method) -ida_hexrays.voff_t.type (variable) -ida_hexrays.voff_t.undef (method) -ida_allins (module) -ida_auto (module) -ida_auto.AU_CHLB (variable) -ida_auto.AU_CODE (variable) -ida_auto.AU_FCHUNK (variable) -ida_auto.AU_FINAL (variable) -ida_auto.AU_LBF2 (variable) -ida_auto.AU_LBF3 (variable) -ida_auto.AU_LIBF (variable) -ida_auto.AU_NONE (variable) -ida_auto.AU_PROC (variable) -ida_auto.AU_TAIL (variable) -ida_auto.AU_TYPE (variable) -ida_auto.AU_UNK (variable) -ida_auto.AU_USED (variable) -ida_auto.AU_WEAK (variable) -ida_auto.auto_apply_tail (function) -ida_auto.auto_apply_type (function) -ida_auto.auto_cancel (function) -ida_auto.auto_display_t (class) -ida_auto.auto_display_t.__init__ (method) -ida_auto.auto_get (function) -ida_auto.auto_is_ok (function) -ida_auto.auto_make_code (function) -ida_auto.auto_make_proc (function) -ida_auto.auto_make_step (function) -ida_auto.auto_mark (function) -ida_auto.auto_mark_range (function) -ida_auto.auto_recreate_insn (function) -ida_auto.auto_unmark (function) -ida_auto.auto_wait (function) -ida_auto.auto_wait_range (function) -ida_auto.enable_auto (function) -ida_auto.get_auto_display (function) -ida_auto.get_auto_state (function) -ida_auto.is_auto_enabled (function) -ida_auto.may_create_stkvars (function) -ida_auto.may_trace_sp (function) -ida_auto.peek_auto_queue (function) -ida_auto.plan_and_wait (function) -ida_auto.plan_ea (function) -ida_auto.plan_range (function) -ida_auto.reanalyze_callers (function) -ida_auto.revert_ida_decisions (function) -ida_auto.set_auto_state (function) -ida_auto.set_ida_state (function) -ida_auto.show_addr (function) -ida_auto.show_auto (function) -ida_bitrange (module) -ida_bitrange.bitrange_t (class) -ida_bitrange.bitrange_t.__eq__ (method) -ida_bitrange.bitrange_t.__ge__ (method) -ida_bitrange.bitrange_t.__gt__ (method) -ida_bitrange.bitrange_t.__init__ (method) -ida_bitrange.bitrange_t.__le__ (method) -ida_bitrange.bitrange_t.__lt__ (method) -ida_bitrange.bitrange_t.__ne__ (method) -ida_bitrange.bitrange_t.__str__ (method) -ida_bitrange.bitrange_t.apply_mask (method) -ida_bitrange.bitrange_t.bitoff (method) -ida_bitrange.bitrange_t.bitsize (method) -ida_bitrange.bitrange_t.bytesize (method) -ida_bitrange.bitrange_t.compare (method) -ida_bitrange.bitrange_t.create_union (method) -ida_bitrange.bitrange_t.empty (method) -ida_bitrange.bitrange_t.extract (method) -ida_bitrange.bitrange_t.has_common (method) -ida_bitrange.bitrange_t.init (method) -ida_bitrange.bitrange_t.inject (method) -ida_bitrange.bitrange_t.intersect (method) -ida_bitrange.bitrange_t.mask64 (method) -ida_bitrange.bitrange_t.reset (method) -ida_bitrange.bitrange_t.shift_down (method) -ida_bitrange.bitrange_t.shift_up (method) -ida_bitrange.bitrange_t.sub (method) -ida_bytes (module) -ida_bytes.ALOPT_IGNCLT (variable) -ida_bytes.ALOPT_IGNHEADS (variable) -ida_bytes.ALOPT_IGNPRINT (variable) -ida_bytes.ALOPT_MAX4K (variable) -ida_bytes.ALOPT_ONLYTERM (variable) -ida_bytes.BIN_SEARCH_BACKWARD (variable) -ida_bytes.BIN_SEARCH_BITMASK (variable) -ida_bytes.BIN_SEARCH_CASE (variable) -ida_bytes.BIN_SEARCH_FORWARD (variable) -ida_bytes.BIN_SEARCH_INITED (variable) -ida_bytes.BIN_SEARCH_NOBREAK (variable) -ida_bytes.BIN_SEARCH_NOCASE (variable) -ida_bytes.BIN_SEARCH_NOSHOW (variable) -ida_bytes.DELIT_DELNAMES (variable) -ida_bytes.DELIT_EXPAND (variable) -ida_bytes.DELIT_KEEPFUNC (variable) -ida_bytes.DELIT_NOCMT (variable) -ida_bytes.DELIT_NOTRUNC (variable) -ida_bytes.DELIT_NOUNAME (variable) -ida_bytes.DELIT_SIMPLE (variable) -ida_bytes.DTP_NODUP (variable) -ida_bytes.DT_TYPE (variable) -ida_bytes.FF_ALIGN (variable) -ida_bytes.FF_BNOT (variable) -ida_bytes.FF_BYTE (variable) -ida_bytes.FF_CODE (variable) -ida_bytes.FF_COMM (variable) -ida_bytes.FF_CUSTOM (variable) -ida_bytes.FF_DATA (variable) -ida_bytes.FF_DOUBLE (variable) -ida_bytes.FF_DWORD (variable) -ida_bytes.FF_FLOAT (variable) -ida_bytes.FF_FLOW (variable) -ida_bytes.FF_FUNC (variable) -ida_bytes.FF_IMMD (variable) -ida_bytes.FF_IVL (variable) -ida_bytes.FF_JUMP (variable) -ida_bytes.FF_LABL (variable) -ida_bytes.FF_LINE (variable) -ida_bytes.FF_NAME (variable) -ida_bytes.FF_N_CHAR (variable) -ida_bytes.FF_N_CUST (variable) -ida_bytes.FF_N_ENUM (variable) -ida_bytes.FF_N_FLT (variable) -ida_bytes.FF_N_FOP (variable) -ida_bytes.FF_N_NUMB (variable) -ida_bytes.FF_N_NUMD (variable) -ida_bytes.FF_N_NUMH (variable) -ida_bytes.FF_N_NUMO (variable) -ida_bytes.FF_N_OFF (variable) -ida_bytes.FF_N_SEG (variable) -ida_bytes.FF_N_STK (variable) -ida_bytes.FF_N_STRO (variable) -ida_bytes.FF_N_VOID (variable) -ida_bytes.FF_OWORD (variable) -ida_bytes.FF_PACKREAL (variable) -ida_bytes.FF_QWORD (variable) -ida_bytes.FF_REF (variable) -ida_bytes.FF_SIGN (variable) -ida_bytes.FF_STRLIT (variable) -ida_bytes.FF_STRUCT (variable) -ida_bytes.FF_TAIL (variable) -ida_bytes.FF_TBYTE (variable) -ida_bytes.FF_UNK (variable) -ida_bytes.FF_UNUSED (variable) -ida_bytes.FF_WORD (variable) -ida_bytes.FF_YWORD (variable) -ida_bytes.FF_ZWORD (variable) -ida_bytes.GFE_IDB_VALUE (variable) -ida_bytes.GFE_VALUE (variable) -ida_bytes.GMB_READALL (variable) -ida_bytes.GMB_WAITBOX (variable) -ida_bytes.ITEM_END_CANCEL (variable) -ida_bytes.ITEM_END_FIXUP (variable) -ida_bytes.ITEM_END_INITED (variable) -ida_bytes.ITEM_END_NAME (variable) -ida_bytes.ITEM_END_XREF (variable) -ida_bytes.MS_CLS (variable) -ida_bytes.MS_CODE (variable) -ida_bytes.MS_COMM (variable) -ida_bytes.MS_N_TYPE (variable) -ida_bytes.MS_VAL (variable) -ida_bytes.OPND_ALL (variable) -ida_bytes.OPND_MASK (variable) -ida_bytes.OPND_OUTER (variable) -ida_bytes.PSTF_ATTRIB (variable) -ida_bytes.PSTF_ENC (variable) -ida_bytes.PSTF_HOTKEY (variable) -ida_bytes.PSTF_ONLY_ENC (variable) -ida_bytes.PSTF_TBRIEF (variable) -ida_bytes.PSTF_TINLIN (variable) -ida_bytes.PSTF_TMASK (variable) -ida_bytes.PSTF_TNORM (variable) -ida_bytes.STRCONV_ESCAPE (variable) -ida_bytes.STRCONV_INCLLEN (variable) -ida_bytes.STRCONV_REPLCHAR (variable) -ida_bytes.__walk_types_and_formats (function) -ida_bytes.add_byte (function) -ida_bytes.add_dword (function) -ida_bytes.add_hidden_range (function) -ida_bytes.add_mapping (function) -ida_bytes.add_qword (function) -ida_bytes.add_word (function) -ida_bytes.align_flag (function) -ida_bytes.append_cmt (function) -ida_bytes.attach_custom_data_format (function) -ida_bytes.bin_flag (function) -ida_bytes.bin_search (function) -ida_bytes.bin_search3 (function) -ida_bytes.byte_flag (function) -ida_bytes.bytesize (function) -ida_bytes.calc_def_align (function) -ida_bytes.calc_dflags (function) -ida_bytes.calc_max_align (function) -ida_bytes.calc_max_item_end (function) -ida_bytes.calc_min_align (function) -ida_bytes.can_define_item (function) -ida_bytes.change_storage_type (function) -ida_bytes.char_flag (function) -ida_bytes.chunk_size (function) -ida_bytes.chunk_start (function) -ida_bytes.clr_lzero (function) -ida_bytes.clr_op_type (function) -ida_bytes.code_flag (function) -ida_bytes.combine_flags (function) -ida_bytes.compiled_binpat_t (class) -ida_bytes.compiled_binpat_t.__eq__ (method) -ida_bytes.compiled_binpat_t.__init__ (method) -ida_bytes.compiled_binpat_t.__ne__ (method) -ida_bytes.compiled_binpat_t.all_bytes_defined (method) -ida_bytes.compiled_binpat_t.qclear (method) -ida_bytes.compiled_binpat_vec_t (class) -ida_bytes.compiled_binpat_vec_t.__eq__ (method) -ida_bytes.compiled_binpat_vec_t.__getitem__ (method) -ida_bytes.compiled_binpat_vec_t.__init__ (method) -ida_bytes.compiled_binpat_vec_t.__len__ (method) -ida_bytes.compiled_binpat_vec_t.__ne__ (method) -ida_bytes.compiled_binpat_vec_t.__setitem__ (method) -ida_bytes.compiled_binpat_vec_t._del (method) -ida_bytes.compiled_binpat_vec_t.add_unique (method) -ida_bytes.compiled_binpat_vec_t.at (method) -ida_bytes.compiled_binpat_vec_t.begin (method) -ida_bytes.compiled_binpat_vec_t.capacity (method) -ida_bytes.compiled_binpat_vec_t.clear (method) -ida_bytes.compiled_binpat_vec_t.empty (method) -ida_bytes.compiled_binpat_vec_t.end (method) -ida_bytes.compiled_binpat_vec_t.erase (method) -ida_bytes.compiled_binpat_vec_t.extract (method) -ida_bytes.compiled_binpat_vec_t.find (method) -ida_bytes.compiled_binpat_vec_t.grow (method) -ida_bytes.compiled_binpat_vec_t.has (method) -ida_bytes.compiled_binpat_vec_t.inject (method) -ida_bytes.compiled_binpat_vec_t.insert (method) -ida_bytes.compiled_binpat_vec_t.pop_back (method) -ida_bytes.compiled_binpat_vec_t.push_back (method) -ida_bytes.compiled_binpat_vec_t.qclear (method) -ida_bytes.compiled_binpat_vec_t.reserve (method) -ida_bytes.compiled_binpat_vec_t.resize (method) -ida_bytes.compiled_binpat_vec_t.size (method) -ida_bytes.compiled_binpat_vec_t.swap (method) -ida_bytes.compiled_binpat_vec_t.truncate (method) -ida_bytes.create_16bit_data (function) -ida_bytes.create_32bit_data (function) -ida_bytes.create_align (function) -ida_bytes.create_byte (function) -ida_bytes.create_custdata (function) -ida_bytes.create_data (function) -ida_bytes.create_double (function) -ida_bytes.create_dword (function) -ida_bytes.create_float (function) -ida_bytes.create_oword (function) -ida_bytes.create_packed_real (function) -ida_bytes.create_qword (function) -ida_bytes.create_strlit (function) -ida_bytes.create_struct (function) -ida_bytes.create_tbyte (function) -ida_bytes.create_word (function) -ida_bytes.create_yword (function) -ida_bytes.create_zword (function) -ida_bytes.cust_flag (function) -ida_bytes.custfmt_flag (function) -ida_bytes.data_format_t (class) -ida_bytes.data_format_t.__get_id (method) -ida_bytes.data_format_t.__init__ (method) -ida_bytes.data_format_t.__init__ (method) -ida_bytes.data_format_t.hotkey (variable) -ida_bytes.data_format_t.is_present_in_menus (method) -ida_bytes.data_format_t.menu_name (variable) -ida_bytes.data_format_t.name (variable) -ida_bytes.data_format_t.props (variable) -ida_bytes.data_format_t.text_width (variable) -ida_bytes.data_format_t.value_size (variable) -ida_bytes.data_type_t (class) -ida_bytes.data_type_t.__get_id (method) -ida_bytes.data_type_t.__init__ (method) -ida_bytes.data_type_t.__init__ (method) -ida_bytes.data_type_t.asm_keyword (variable) -ida_bytes.data_type_t.hotkey (variable) -ida_bytes.data_type_t.is_present_in_menus (method) -ida_bytes.data_type_t.menu_name (variable) -ida_bytes.data_type_t.name (variable) -ida_bytes.data_type_t.props (variable) -ida_bytes.data_type_t.value_size (variable) -ida_bytes.dec_flag (function) -ida_bytes.del_hidden_range (function) -ida_bytes.del_items (function) -ida_bytes.del_mapping (function) -ida_bytes.del_value (function) -ida_bytes.detach_custom_data_format (function) -ida_bytes.disable_flags (function) -ida_bytes.double_flag (function) -ida_bytes.dword_flag (function) -ida_bytes.enable_flags (function) -ida_bytes.enum_flag (function) -ida_bytes.equal_bytes (function) -ida_bytes.f_has_cmt (function) -ida_bytes.f_has_dummy_name (function) -ida_bytes.f_has_extra_cmts (function) -ida_bytes.f_has_name (function) -ida_bytes.f_has_user_name (function) -ida_bytes.f_has_xref (function) -ida_bytes.f_is_align (function) -ida_bytes.f_is_byte (function) -ida_bytes.f_is_code (function) -ida_bytes.f_is_custom (function) -ida_bytes.f_is_data (function) -ida_bytes.f_is_double (function) -ida_bytes.f_is_dword (function) -ida_bytes.f_is_float (function) -ida_bytes.f_is_head (function) -ida_bytes.f_is_not_tail (function) -ida_bytes.f_is_oword (function) -ida_bytes.f_is_pack_real (function) -ida_bytes.f_is_qword (function) -ida_bytes.f_is_strlit (function) -ida_bytes.f_is_struct (function) -ida_bytes.f_is_tail (function) -ida_bytes.f_is_tbyte (function) -ida_bytes.f_is_word (function) -ida_bytes.f_is_yword (function) -ida_bytes.find_byte (function) -ida_bytes.find_byter (function) -ida_bytes.find_custom_data_format (function) -ida_bytes.find_custom_data_type (function) -ida_bytes.find_free_chunk (function) -ida_bytes.float_flag (function) -ida_bytes.flt_flag (function) -ida_bytes.free_chunk (function) -ida_bytes.get_16bit (function) -ida_bytes.get_32bit (function) -ida_bytes.get_64bit (function) -ida_bytes.get_8bit (function) -ida_bytes.get_byte (function) -ida_bytes.get_bytes (function) -ida_bytes.get_bytes_and_mask (function) -ida_bytes.get_cmt (function) -ida_bytes.get_custom_data_format (function) -ida_bytes.get_custom_data_formats (function) -ida_bytes.get_custom_data_type (function) -ida_bytes.get_custom_data_types (function) -ida_bytes.get_data_elsize (function) -ida_bytes.get_data_value (function) -ida_bytes.get_db_byte (function) -ida_bytes.get_default_radix (function) -ida_bytes.get_dword (function) -ida_bytes.get_enum_id (function) -ida_bytes.get_first_hidden_range (function) -ida_bytes.get_flags (function) -ida_bytes.get_flags_by_size (function) -ida_bytes.get_flags_ex (function) -ida_bytes.get_forced_operand (function) -ida_bytes.get_full_data_elsize (function) -ida_bytes.get_full_flags (function) -ida_bytes.get_hidden_range (function) -ida_bytes.get_hidden_range_num (function) -ida_bytes.get_hidden_range_qty (function) -ida_bytes.get_item_end (function) -ida_bytes.get_item_flag (function) -ida_bytes.get_item_head (function) -ida_bytes.get_item_refinfo (function) -ida_bytes.get_item_size (function) -ida_bytes.get_last_hidden_range (function) -ida_bytes.get_manual_insn (function) -ida_bytes.get_mapping (function) -ida_bytes.get_mappings_qty (function) -ida_bytes.get_max_strlit_length (function) -ida_bytes.get_next_hidden_range (function) -ida_bytes.get_octet (function) -ida_bytes.get_octet2 (function) -ida_bytes.get_operand_flag (function) -ida_bytes.get_operand_type_shift (function) -ida_bytes.get_opinfo (function) -ida_bytes.get_optype_flags0 (function) -ida_bytes.get_optype_flags1 (function) -ida_bytes.get_original_byte (function) -ida_bytes.get_original_dword (function) -ida_bytes.get_original_qword (function) -ida_bytes.get_original_word (function) -ida_bytes.get_predef_insn_cmt (function) -ida_bytes.get_prev_hidden_range (function) -ida_bytes.get_qword (function) -ida_bytes.get_radix (function) -ida_bytes.get_strlit_contents (function) -ida_bytes.get_stroff_path (function) -ida_bytes.get_wide_byte (function) -ida_bytes.get_wide_dword (function) -ida_bytes.get_wide_word (function) -ida_bytes.get_word (function) -ida_bytes.get_zero_ranges (function) -ida_bytes.getn_hidden_range (function) -ida_bytes.has_any_name (function) -ida_bytes.has_auto_name (function) -ida_bytes.has_cmt (function) -ida_bytes.has_dummy_name (function) -ida_bytes.has_extra_cmts (function) -ida_bytes.has_immd (function) -ida_bytes.has_name (function) -ida_bytes.has_user_name (function) -ida_bytes.has_value (function) -ida_bytes.has_xref (function) -ida_bytes.hex_flag (function) -ida_bytes.hidden_range_t (class) -ida_bytes.hidden_range_t.__init__ (method) -ida_bytes.hidden_range_t.color (variable) -ida_bytes.hidden_range_t.description (variable) -ida_bytes.hidden_range_t.footer (variable) -ida_bytes.hidden_range_t.header (variable) -ida_bytes.hidden_range_t.visible (variable) -ida_bytes.is_align (function) -ida_bytes.is_attached_custom_data_format (function) -ida_bytes.is_bnot (function) -ida_bytes.is_byte (function) -ida_bytes.is_char (function) -ida_bytes.is_char0 (function) -ida_bytes.is_char1 (function) -ida_bytes.is_code (function) -ida_bytes.is_custfmt (function) -ida_bytes.is_custfmt0 (function) -ida_bytes.is_custfmt1 (function) -ida_bytes.is_custom (function) -ida_bytes.is_data (function) -ida_bytes.is_defarg (function) -ida_bytes.is_defarg0 (function) -ida_bytes.is_defarg1 (function) -ida_bytes.is_double (function) -ida_bytes.is_dword (function) -ida_bytes.is_enum (function) -ida_bytes.is_enum0 (function) -ida_bytes.is_enum1 (function) -ida_bytes.is_flag_for_operand (function) -ida_bytes.is_float (function) -ida_bytes.is_float0 (function) -ida_bytes.is_float1 (function) -ida_bytes.is_flow (function) -ida_bytes.is_fltnum (function) -ida_bytes.is_forced_operand (function) -ida_bytes.is_func (function) -ida_bytes.is_head (function) -ida_bytes.is_invsign (function) -ida_bytes.is_loaded (function) -ida_bytes.is_lzero (function) -ida_bytes.is_manual (function) -ida_bytes.is_manual_insn (function) -ida_bytes.is_mapped (function) -ida_bytes.is_not_tail (function) -ida_bytes.is_numop (function) -ida_bytes.is_numop0 (function) -ida_bytes.is_numop1 (function) -ida_bytes.is_off (function) -ida_bytes.is_off0 (function) -ida_bytes.is_off1 (function) -ida_bytes.is_oword (function) -ida_bytes.is_pack_real (function) -ida_bytes.is_qword (function) -ida_bytes.is_same_data_type (function) -ida_bytes.is_seg (function) -ida_bytes.is_seg0 (function) -ida_bytes.is_seg1 (function) -ida_bytes.is_stkvar (function) -ida_bytes.is_stkvar0 (function) -ida_bytes.is_stkvar1 (function) -ida_bytes.is_strlit (function) -ida_bytes.is_stroff (function) -ida_bytes.is_stroff0 (function) -ida_bytes.is_stroff1 (function) -ida_bytes.is_struct (function) -ida_bytes.is_suspop (function) -ida_bytes.is_tail (function) -ida_bytes.is_tbyte (function) -ida_bytes.is_unknown (function) -ida_bytes.is_varsize_item (function) -ida_bytes.is_word (function) -ida_bytes.is_yword (function) -ida_bytes.is_zword (function) -ida_bytes.leading_zero_important (function) -ida_bytes.nbits (function) -ida_bytes.next_addr (function) -ida_bytes.next_chunk (function) -ida_bytes.next_head (function) -ida_bytes.next_inited (function) -ida_bytes.next_not_tail (function) -ida_bytes.next_that (function) -ida_bytes.next_unknown (function) -ida_bytes.next_visea (function) -ida_bytes.num_flag (function) -ida_bytes.oct_flag (function) -ida_bytes.octet_generator_t (class) -ida_bytes.octet_generator_t.__init__ (method) -ida_bytes.octet_generator_t.invert_byte_order (method) -ida_bytes.off_flag (function) -ida_bytes.op_adds_xrefs (function) -ida_bytes.op_based_stroff (function) -ida_bytes.op_bin (function) -ida_bytes.op_chr (function) -ida_bytes.op_custfmt (function) -ida_bytes.op_dec (function) -ida_bytes.op_enum (function) -ida_bytes.op_flt (function) -ida_bytes.op_hex (function) -ida_bytes.op_num (function) -ida_bytes.op_oct (function) -ida_bytes.op_seg (function) -ida_bytes.op_stkvar (function) -ida_bytes.op_stroff (function) -ida_bytes.oword_flag (function) -ida_bytes.packreal_flag (function) -ida_bytes.parse_binpat_str (function) -ida_bytes.patch_byte (function) -ida_bytes.patch_bytes (function) -ida_bytes.patch_dword (function) -ida_bytes.patch_qword (function) -ida_bytes.patch_word (function) -ida_bytes.prev_addr (function) -ida_bytes.prev_chunk (function) -ida_bytes.prev_head (function) -ida_bytes.prev_inited (function) -ida_bytes.prev_not_tail (function) -ida_bytes.prev_that (function) -ida_bytes.prev_unknown (function) -ida_bytes.prev_visea (function) -ida_bytes.print_strlit_type (function) -ida_bytes.put_byte (function) -ida_bytes.put_bytes (function) -ida_bytes.put_dword (function) -ida_bytes.put_qword (function) -ida_bytes.put_word (function) -ida_bytes.qword_flag (function) -ida_bytes.register_custom_data_format (function) -ida_bytes.register_custom_data_type (function) -ida_bytes.register_data_types_and_formats (function) -ida_bytes.register_data_types_and_formats.__reg_format (function) -ida_bytes.register_data_types_and_formats.__reg_type (function) -ida_bytes.revert_byte (function) -ida_bytes.seg_flag (function) -ida_bytes.set_cmt (function) -ida_bytes.set_forced_operand (function) -ida_bytes.set_immd (function) -ida_bytes.set_lzero (function) -ida_bytes.set_manual_insn (function) -ida_bytes.set_op_type (function) -ida_bytes.set_opinfo (function) -ida_bytes.stkvar_flag (function) -ida_bytes.strlit_flag (function) -ida_bytes.stroff_flag (function) -ida_bytes.stru_flag (function) -ida_bytes.tbyte_flag (function) -ida_bytes.toggle_bnot (function) -ida_bytes.toggle_lzero (function) -ida_bytes.toggle_sign (function) -ida_bytes.unregister_custom_data_format (function) -ida_bytes.unregister_custom_data_type (function) -ida_bytes.unregister_data_types_and_formats (function) -ida_bytes.unregister_data_types_and_formats.__unreg_format (function) -ida_bytes.unregister_data_types_and_formats.__unreg_type (function) -ida_bytes.update_hidden_range (function) -ida_bytes.use_mapping (function) -ida_bytes.visit_patched_bytes (function) -ida_bytes.word_flag (function) -ida_bytes.yword_flag (function) -ida_bytes.zword_flag (function) -ida_dbg (module) -ida_dbg.BKPT_ACTIVE (variable) -ida_dbg.BKPT_BADBPT (variable) -ida_dbg.BKPT_CNDREADY (variable) -ida_dbg.BKPT_FAKEPEND (variable) -ida_dbg.BKPT_LISTBPT (variable) -ida_dbg.BKPT_PAGE (variable) -ida_dbg.BKPT_PARTIAL (variable) -ida_dbg.BKPT_TRACE (variable) -ida_dbg.BPLT_ABS (variable) -ida_dbg.BPLT_REL (variable) -ida_dbg.BPLT_SRC (variable) -ida_dbg.BPTCK_ACT (variable) -ida_dbg.BPTCK_NO (variable) -ida_dbg.BPTCK_NONE (variable) -ida_dbg.BPTCK_YES (variable) -ida_dbg.BPTEV_ADDED (variable) -ida_dbg.BPTEV_CHANGED (variable) -ida_dbg.BPTEV_REMOVED (variable) -ida_dbg.BPT_BRK (variable) -ida_dbg.BPT_ELANG_SHIFT (variable) -ida_dbg.BPT_ENABLED (variable) -ida_dbg.BPT_LOWCND (variable) -ida_dbg.BPT_TRACE (variable) -ida_dbg.BPT_TRACEON (variable) -ida_dbg.BPT_TRACE_BBLK (variable) -ida_dbg.BPT_TRACE_FUNC (variable) -ida_dbg.BPT_TRACE_INSN (variable) -ida_dbg.BPT_TRACE_TYPES (variable) -ida_dbg.BPT_UPDMEM (variable) -ida_dbg.BT_LOG_INSTS (variable) -ida_dbg.DBGINV_ALL (variable) -ida_dbg.DBGINV_MEMCFG (variable) -ida_dbg.DBGINV_MEMORY (variable) -ida_dbg.DBGINV_NONE (variable) -ida_dbg.DBGINV_REDRAW (variable) -ida_dbg.DBGINV_REGS (variable) -ida_dbg.DBG_Hooks (class) -ida_dbg.DBG_Hooks.__disown__ (method) -ida_dbg.DBG_Hooks.__init__ (method) -ida_dbg.DBG_Hooks.dbg_bpt (method) -ida_dbg.DBG_Hooks.dbg_bpt_changed (method) -ida_dbg.DBG_Hooks.dbg_exception (method) -ida_dbg.DBG_Hooks.dbg_finished_loading_bpts (method) -ida_dbg.DBG_Hooks.dbg_information (method) -ida_dbg.DBG_Hooks.dbg_library_load (method) -ida_dbg.DBG_Hooks.dbg_library_unload (method) -ida_dbg.DBG_Hooks.dbg_process_attach (method) -ida_dbg.DBG_Hooks.dbg_process_detach (method) -ida_dbg.DBG_Hooks.dbg_process_exit (method) -ida_dbg.DBG_Hooks.dbg_process_start (method) -ida_dbg.DBG_Hooks.dbg_request_error (method) -ida_dbg.DBG_Hooks.dbg_run_to (method) -ida_dbg.DBG_Hooks.dbg_started_loading_bpts (method) -ida_dbg.DBG_Hooks.dbg_step_into (method) -ida_dbg.DBG_Hooks.dbg_step_over (method) -ida_dbg.DBG_Hooks.dbg_step_until_ret (method) -ida_dbg.DBG_Hooks.dbg_suspend_process (method) -ida_dbg.DBG_Hooks.dbg_thread_exit (method) -ida_dbg.DBG_Hooks.dbg_thread_start (method) -ida_dbg.DBG_Hooks.dbg_trace (method) -ida_dbg.DBG_Hooks.hook (method) -ida_dbg.DBG_Hooks.unhook (method) -ida_dbg.DEC_ERROR (variable) -ida_dbg.DEC_NOTASK (variable) -ida_dbg.DEC_TIMEOUT (variable) -ida_dbg.DOPT_BPT_MSGS (variable) -ida_dbg.DOPT_DISABLE_ASLR (variable) -ida_dbg.DOPT_END_BPT (variable) -ida_dbg.DOPT_ENTRY_BPT (variable) -ida_dbg.DOPT_EXCDLG (variable) -ida_dbg.DOPT_FAST_STEP (variable) -ida_dbg.DOPT_INFO_BPT (variable) -ida_dbg.DOPT_INFO_MSGS (variable) -ida_dbg.DOPT_LIB_BPT (variable) -ida_dbg.DOPT_LIB_MSGS (variable) -ida_dbg.DOPT_LOAD_DINFO (variable) -ida_dbg.DOPT_REAL_MEMORY (variable) -ida_dbg.DOPT_REDO_STACK (variable) -ida_dbg.DOPT_SEGM_MSGS (variable) -ida_dbg.DOPT_START_BPT (variable) -ida_dbg.DOPT_TEMP_HWBPT (variable) -ida_dbg.DOPT_THREAD_BPT (variable) -ida_dbg.DOPT_THREAD_MSGS (variable) -ida_dbg.DSTATE_NOTASK (variable) -ida_dbg.DSTATE_RUN (variable) -ida_dbg.DSTATE_SUSP (variable) -ida_dbg.EXCDLG_ALWAYS (variable) -ida_dbg.EXCDLG_NEVER (variable) -ida_dbg.EXCDLG_UNKNOWN (variable) -ida_dbg.FT_LOG_RET (variable) -ida_dbg.IT_LOG_SAME_IP (variable) -ida_dbg.SRCIT_EXPR (variable) -ida_dbg.SRCIT_FUNC (variable) -ida_dbg.SRCIT_LOCVAR (variable) -ida_dbg.SRCIT_MODULE (variable) -ida_dbg.SRCIT_NONE (variable) -ida_dbg.SRCIT_STMT (variable) -ida_dbg.SRCIT_STTVAR (variable) -ida_dbg.ST_ALREADY_LOGGED (variable) -ida_dbg.ST_OPTIONS_MASK (variable) -ida_dbg.ST_OVER_DEBUG_SEG (variable) -ida_dbg.ST_OVER_LIB_FUNC (variable) -ida_dbg.ST_SKIP_LOOPS (variable) -ida_dbg.WFNE_ANY (variable) -ida_dbg.WFNE_CONT (variable) -ida_dbg.WFNE_NOWAIT (variable) -ida_dbg.WFNE_SILENT (variable) -ida_dbg.WFNE_SUSP (variable) -ida_dbg.WFNE_USEC (variable) -ida_dbg.add_bpt (function) -ida_dbg.add_path_mapping (function) -ida_dbg.add_virt_module (function) -ida_dbg.attach_process (function) -ida_dbg.bpt_location_t (class) -ida_dbg.bpt_location_t.__eq__ (method) -ida_dbg.bpt_location_t.__ge__ (method) -ida_dbg.bpt_location_t.__gt__ (method) -ida_dbg.bpt_location_t.__init__ (method) -ida_dbg.bpt_location_t.__le__ (method) -ida_dbg.bpt_location_t.__lt__ (method) -ida_dbg.bpt_location_t.__ne__ (method) -ida_dbg.bpt_location_t.compare (method) -ida_dbg.bpt_location_t.ea (method) -ida_dbg.bpt_location_t.is_empty_path (method) -ida_dbg.bpt_location_t.lineno (method) -ida_dbg.bpt_location_t.offset (method) -ida_dbg.bpt_location_t.path (method) -ida_dbg.bpt_location_t.set_abs_bpt (method) -ida_dbg.bpt_location_t.set_rel_bpt (method) -ida_dbg.bpt_location_t.set_src_bpt (method) -ida_dbg.bpt_location_t.set_sym_bpt (method) -ida_dbg.bpt_location_t.symbol (method) -ida_dbg.bpt_location_t.type (method) -ida_dbg.bpt_t (class) -ida_dbg.bpt_t.__init__ (method) -ida_dbg.bpt_t.badbpt (method) -ida_dbg.bpt_t.bptid (variable) -ida_dbg.bpt_t.cb (variable) -ida_dbg.bpt_t.cndidx (variable) -ida_dbg.bpt_t.ea (variable) -ida_dbg.bpt_t.enabled (method) -ida_dbg.bpt_t.flags (variable) -ida_dbg.bpt_t.get_cnd_elang_idx (method) -ida_dbg.bpt_t.get_size (method) -ida_dbg.bpt_t.is_absbpt (method) -ida_dbg.bpt_t.is_active (method) -ida_dbg.bpt_t.is_compiled (method) -ida_dbg.bpt_t.is_hwbpt (method) -ida_dbg.bpt_t.is_inactive (method) -ida_dbg.bpt_t.is_low_level (method) -ida_dbg.bpt_t.is_page_bpt (method) -ida_dbg.bpt_t.is_partially_active (method) -ida_dbg.bpt_t.is_relbpt (method) -ida_dbg.bpt_t.is_srcbpt (method) -ida_dbg.bpt_t.is_symbpt (method) -ida_dbg.bpt_t.is_tracemodebpt (method) -ida_dbg.bpt_t.is_traceoffbpt (method) -ida_dbg.bpt_t.is_traceonbpt (method) -ida_dbg.bpt_t.listbpt (method) -ida_dbg.bpt_t.loc (variable) -ida_dbg.bpt_t.pass_count (variable) -ida_dbg.bpt_t.pid (variable) -ida_dbg.bpt_t.props (variable) -ida_dbg.bpt_t.set_abs_bpt (method) -ida_dbg.bpt_t.set_rel_bpt (method) -ida_dbg.bpt_t.set_src_bpt (method) -ida_dbg.bpt_t.set_sym_bpt (method) -ida_dbg.bpt_t.set_trace_action (method) -ida_dbg.bpt_t.size (variable) -ida_dbg.bpt_t.tid (variable) -ida_dbg.bpt_t.type (variable) -ida_dbg.bpt_vec_t (class) -ida_dbg.bpt_vec_t.__getitem__ (method) -ida_dbg.bpt_vec_t.__init__ (method) -ida_dbg.bpt_vec_t.__len__ (method) -ida_dbg.bpt_vec_t.__setitem__ (method) -ida_dbg.bpt_vec_t.at (method) -ida_dbg.bpt_vec_t.begin (method) -ida_dbg.bpt_vec_t.capacity (method) -ida_dbg.bpt_vec_t.clear (method) -ida_dbg.bpt_vec_t.empty (method) -ida_dbg.bpt_vec_t.end (method) -ida_dbg.bpt_vec_t.erase (method) -ida_dbg.bpt_vec_t.extract (method) -ida_dbg.bpt_vec_t.grow (method) -ida_dbg.bpt_vec_t.inject (method) -ida_dbg.bpt_vec_t.insert (method) -ida_dbg.bpt_vec_t.pop_back (method) -ida_dbg.bpt_vec_t.push_back (method) -ida_dbg.bpt_vec_t.qclear (method) -ida_dbg.bpt_vec_t.reserve (method) -ida_dbg.bpt_vec_t.resize (method) -ida_dbg.bpt_vec_t.size (method) -ida_dbg.bpt_vec_t.swap (method) -ida_dbg.bpt_vec_t.truncate (method) -ida_dbg.bptaddrs_t (class) -ida_dbg.bptaddrs_t.__init__ (method) -ida_dbg.bring_debugger_to_front (function) -ida_dbg.check_bpt (function) -ida_dbg.choose_trace_file (function) -ida_dbg.clear_requests_queue (function) -ida_dbg.clear_trace (function) -ida_dbg.collect_stack_trace (function) -ida_dbg.continue_process (function) -ida_dbg.create_source_viewer (function) -ida_dbg.dbg_add_bpt_tev (function) -ida_dbg.dbg_add_call_tev (function) -ida_dbg.dbg_add_debug_event (function) -ida_dbg.dbg_add_insn_tev (function) -ida_dbg.dbg_add_many_tevs (function) -ida_dbg.dbg_add_ret_tev (function) -ida_dbg.dbg_add_tev (function) -ida_dbg.dbg_add_thread (function) -ida_dbg.dbg_bin_search (function) -ida_dbg.dbg_bpt (variable) -ida_dbg.dbg_bpt_changed (variable) -ida_dbg.dbg_can_query (function) -ida_dbg.dbg_del_thread (function) -ida_dbg.dbg_finished_loading_bpts (variable) -ida_dbg.dbg_is_loaded (function) -ida_dbg.dbg_last (variable) -ida_dbg.dbg_process_attach (variable) -ida_dbg.dbg_process_detach (variable) -ida_dbg.dbg_process_exit (variable) -ida_dbg.dbg_process_start (variable) -ida_dbg.dbg_request_error (variable) -ida_dbg.dbg_started_loading_bpts (variable) -ida_dbg.dbg_suspend_process (variable) -ida_dbg.dbg_trace (variable) -ida_dbg.define_exception (function) -ida_dbg.del_bpt (function) -ida_dbg.del_bptgrp (function) -ida_dbg.del_virt_module (function) -ida_dbg.detach_process (function) -ida_dbg.diff_trace_file (function) -ida_dbg.disable_bblk_trace (function) -ida_dbg.disable_bpt (function) -ida_dbg.disable_func_trace (function) -ida_dbg.disable_insn_trace (function) -ida_dbg.disable_step_trace (function) -ida_dbg.edit_manual_regions (function) -ida_dbg.enable_bblk_trace (function) -ida_dbg.enable_bpt (function) -ida_dbg.enable_bptgrp (function) -ida_dbg.enable_func_trace (function) -ida_dbg.enable_insn_trace (function) -ida_dbg.enable_manual_regions (function) -ida_dbg.enable_step_trace (function) -ida_dbg.eval_ctx_t (class) -ida_dbg.eval_ctx_t.__init__ (method) -ida_dbg.exist_bpt (function) -ida_dbg.exit_process (function) -ida_dbg.find_bpt (function) -ida_dbg.get_bblk_trace_options (function) -ida_dbg.get_bpt (function) -ida_dbg.get_bpt_group (function) -ida_dbg.get_bpt_qty (function) -ida_dbg.get_bpt_tev_ea (function) -ida_dbg.get_bptloc_string (function) -ida_dbg.get_call_tev_callee (function) -ida_dbg.get_current_source_file (function) -ida_dbg.get_current_source_line (function) -ida_dbg.get_current_thread (function) -ida_dbg.get_dbg_byte (function) -ida_dbg.get_dbg_memory_info (function) -ida_dbg.get_dbg_reg_info (function) -ida_dbg.get_debug_event (function) -ida_dbg.get_debugger_event_cond (function) -ida_dbg.get_first_module (function) -ida_dbg.get_func_trace_options (function) -ida_dbg.get_global_var (function) -ida_dbg.get_grp_bpts (function) -ida_dbg.get_insn_tev_reg_mem (function) -ida_dbg.get_insn_tev_reg_result (function) -ida_dbg.get_insn_tev_reg_val (function) -ida_dbg.get_insn_trace_options (function) -ida_dbg.get_ip_val (function) -ida_dbg.get_local_var (function) -ida_dbg.get_local_vars (function) -ida_dbg.get_manual_regions (function) -ida_dbg.get_module_info (function) -ida_dbg.get_next_module (function) -ida_dbg.get_process_options (function) -ida_dbg.get_process_state (function) -ida_dbg.get_processes (function) -ida_dbg.get_reg_val (function) -ida_dbg.get_reg_vals (function) -ida_dbg.get_ret_tev_return (function) -ida_dbg.get_running_notification (function) -ida_dbg.get_running_request (function) -ida_dbg.get_sp_val (function) -ida_dbg.get_srcinfo_provider (function) -ida_dbg.get_step_trace_options (function) -ida_dbg.get_tev_ea (function) -ida_dbg.get_tev_event (function) -ida_dbg.get_tev_info (function) -ida_dbg.get_tev_memory_info (function) -ida_dbg.get_tev_qty (function) -ida_dbg.get_tev_reg_mem (function) -ida_dbg.get_tev_reg_mem_ea (function) -ida_dbg.get_tev_reg_mem_qty (function) -ida_dbg.get_tev_reg_val (function) -ida_dbg.get_tev_tid (function) -ida_dbg.get_tev_type (function) -ida_dbg.get_thread_qty (function) -ida_dbg.get_trace_base_address (function) -ida_dbg.get_trace_dynamic_register_set (function) -ida_dbg.get_trace_file_desc (function) -ida_dbg.get_trace_platform (function) -ida_dbg.getn_bpt (function) -ida_dbg.getn_thread (function) -ida_dbg.getn_thread_name (function) -ida_dbg.graph_trace (function) -ida_dbg.handle_debug_event (function) -ida_dbg.hide_all_bpts (function) -ida_dbg.internal_get_sreg_base (function) -ida_dbg.internal_ioctl (function) -ida_dbg.invalidate_dbg_state (function) -ida_dbg.invalidate_dbgmem_config (function) -ida_dbg.invalidate_dbgmem_contents (function) -ida_dbg.is_bblk_trace_enabled (function) -ida_dbg.is_debugger_busy (function) -ida_dbg.is_debugger_memory (function) -ida_dbg.is_debugger_on (function) -ida_dbg.is_func_trace_enabled (function) -ida_dbg.is_insn_trace_enabled (function) -ida_dbg.is_reg_custom (function) -ida_dbg.is_reg_float (function) -ida_dbg.is_reg_integer (function) -ida_dbg.is_request_running (function) -ida_dbg.is_step_trace_enabled (function) -ida_dbg.is_valid_dstate (function) -ida_dbg.is_valid_trace_file (function) -ida_dbg.list_bptgrps (function) -ida_dbg.load_debugger (function) -ida_dbg.load_trace_file (function) -ida_dbg.memreg_info_t (class) -ida_dbg.memreg_info_t.__init__ (method) -ida_dbg.memreg_info_t.get_bytes (method) -ida_dbg.memreg_infos_t (class) -ida_dbg.memreg_infos_t.__getitem__ (method) -ida_dbg.memreg_infos_t.__init__ (method) -ida_dbg.memreg_infos_t.__len__ (method) -ida_dbg.memreg_infos_t.__setitem__ (method) -ida_dbg.memreg_infos_t.at (method) -ida_dbg.memreg_infos_t.begin (method) -ida_dbg.memreg_infos_t.capacity (method) -ida_dbg.memreg_infos_t.clear (method) -ida_dbg.memreg_infos_t.empty (method) -ida_dbg.memreg_infos_t.end (method) -ida_dbg.memreg_infos_t.erase (method) -ida_dbg.memreg_infos_t.extract (method) -ida_dbg.memreg_infos_t.grow (method) -ida_dbg.memreg_infos_t.inject (method) -ida_dbg.memreg_infos_t.insert (method) -ida_dbg.memreg_infos_t.pop_back (method) -ida_dbg.memreg_infos_t.push_back (method) -ida_dbg.memreg_infos_t.qclear (method) -ida_dbg.memreg_infos_t.reserve (method) -ida_dbg.memreg_infos_t.resize (method) -ida_dbg.memreg_infos_t.size (method) -ida_dbg.memreg_infos_t.swap (method) -ida_dbg.memreg_infos_t.truncate (method) -ida_dbg.put_dbg_byte (function) -ida_dbg.read_dbg_memory (function) -ida_dbg.refresh_debugger_memory (function) -ida_dbg.rename_bptgrp (function) -ida_dbg.request_add_bpt (function) -ida_dbg.request_attach_process (function) -ida_dbg.request_clear_trace (function) -ida_dbg.request_continue_process (function) -ida_dbg.request_del_bpt (function) -ida_dbg.request_detach_process (function) -ida_dbg.request_disable_bblk_trace (function) -ida_dbg.request_disable_bpt (function) -ida_dbg.request_disable_func_trace (function) -ida_dbg.request_disable_insn_trace (function) -ida_dbg.request_disable_step_trace (function) -ida_dbg.request_enable_bblk_trace (function) -ida_dbg.request_enable_bpt (function) -ida_dbg.request_enable_func_trace (function) -ida_dbg.request_enable_insn_trace (function) -ida_dbg.request_enable_step_trace (function) -ida_dbg.request_exit_process (function) -ida_dbg.request_resume_thread (function) -ida_dbg.request_run_to (function) -ida_dbg.request_select_thread (function) -ida_dbg.request_set_bblk_trace_options (function) -ida_dbg.request_set_func_trace_options (function) -ida_dbg.request_set_insn_trace_options (function) -ida_dbg.request_set_reg_val (function) -ida_dbg.request_set_resume_mode (function) -ida_dbg.request_set_step_trace_options (function) -ida_dbg.request_start_process (function) -ida_dbg.request_step_into (function) -ida_dbg.request_step_over (function) -ida_dbg.request_step_until_ret (function) -ida_dbg.request_suspend_process (function) -ida_dbg.request_suspend_thread (function) -ida_dbg.resume_thread (function) -ida_dbg.retrieve_exceptions (function) -ida_dbg.run_requests (function) -ida_dbg.run_to (function) -ida_dbg.save_trace_file (function) -ida_dbg.select_thread (function) -ida_dbg.send_dbg_command (function) -ida_dbg.set_bblk_trace_options (function) -ida_dbg.set_bpt_group (function) -ida_dbg.set_bptloc_group (function) -ida_dbg.set_bptloc_string (function) -ida_dbg.set_debugger_event_cond (function) -ida_dbg.set_debugger_options (function) -ida_dbg.set_func_trace_options (function) -ida_dbg.set_highlight_trace_options (function) -ida_dbg.set_insn_trace_options (function) -ida_dbg.set_manual_regions (function) -ida_dbg.set_process_options (function) -ida_dbg.set_process_state (function) -ida_dbg.set_reg_val (function) -ida_dbg.set_remote_debugger (function) -ida_dbg.set_resume_mode (function) -ida_dbg.set_step_trace_options (function) -ida_dbg.set_trace_base_address (function) -ida_dbg.set_trace_dynamic_register_set (function) -ida_dbg.set_trace_file_desc (function) -ida_dbg.set_trace_platform (function) -ida_dbg.set_trace_size (function) -ida_dbg.srcdbg_request_step_into (function) -ida_dbg.srcdbg_request_step_over (function) -ida_dbg.srcdbg_request_step_until_ret (function) -ida_dbg.srcdbg_step_into (function) -ida_dbg.srcdbg_step_over (function) -ida_dbg.srcdbg_step_until_ret (function) -ida_dbg.start_process (function) -ida_dbg.step_into (function) -ida_dbg.step_over (function) -ida_dbg.step_until_ret (function) -ida_dbg.store_exceptions (function) -ida_dbg.suspend_process (function) -ida_dbg.suspend_thread (function) -ida_dbg.tev_bpt (variable) -ida_dbg.tev_call (variable) -ida_dbg.tev_event (variable) -ida_dbg.tev_info_reg_t (class) -ida_dbg.tev_info_reg_t.__init__ (method) -ida_dbg.tev_info_t (class) -ida_dbg.tev_info_t.__init__ (method) -ida_dbg.tev_info_t.ea (variable) -ida_dbg.tev_info_t.tid (variable) -ida_dbg.tev_info_t.type (variable) -ida_dbg.tev_insn (variable) -ida_dbg.tev_max (variable) -ida_dbg.tev_mem (variable) -ida_dbg.tev_none (variable) -ida_dbg.tev_reg_value_t (class) -ida_dbg.tev_reg_value_t.__init__ (method) -ida_dbg.tev_reg_values_t (class) -ida_dbg.tev_reg_values_t.__getitem__ (method) -ida_dbg.tev_reg_values_t.__init__ (method) -ida_dbg.tev_reg_values_t.__len__ (method) -ida_dbg.tev_reg_values_t.__setitem__ (method) -ida_dbg.tev_reg_values_t.at (method) -ida_dbg.tev_reg_values_t.begin (method) -ida_dbg.tev_reg_values_t.capacity (method) -ida_dbg.tev_reg_values_t.clear (method) -ida_dbg.tev_reg_values_t.empty (method) -ida_dbg.tev_reg_values_t.end (method) -ida_dbg.tev_reg_values_t.erase (method) -ida_dbg.tev_reg_values_t.extract (method) -ida_dbg.tev_reg_values_t.grow (method) -ida_dbg.tev_reg_values_t.inject (method) -ida_dbg.tev_reg_values_t.insert (method) -ida_dbg.tev_reg_values_t.pop_back (method) -ida_dbg.tev_reg_values_t.push_back (method) -ida_dbg.tev_reg_values_t.qclear (method) -ida_dbg.tev_reg_values_t.reserve (method) -ida_dbg.tev_reg_values_t.resize (method) -ida_dbg.tev_reg_values_t.size (method) -ida_dbg.tev_reg_values_t.swap (method) -ida_dbg.tev_reg_values_t.truncate (method) -ida_dbg.tev_ret (variable) -ida_dbg.tevinforeg_vec_t (class) -ida_dbg.tevinforeg_vec_t.__getitem__ (method) -ida_dbg.tevinforeg_vec_t.__init__ (method) -ida_dbg.tevinforeg_vec_t.__len__ (method) -ida_dbg.tevinforeg_vec_t.__setitem__ (method) -ida_dbg.tevinforeg_vec_t.at (method) -ida_dbg.tevinforeg_vec_t.begin (method) -ida_dbg.tevinforeg_vec_t.capacity (method) -ida_dbg.tevinforeg_vec_t.clear (method) -ida_dbg.tevinforeg_vec_t.empty (method) -ida_dbg.tevinforeg_vec_t.end (method) -ida_dbg.tevinforeg_vec_t.erase (method) -ida_dbg.tevinforeg_vec_t.extract (method) -ida_dbg.tevinforeg_vec_t.grow (method) -ida_dbg.tevinforeg_vec_t.inject (method) -ida_dbg.tevinforeg_vec_t.insert (method) -ida_dbg.tevinforeg_vec_t.pop_back (method) -ida_dbg.tevinforeg_vec_t.push_back (method) -ida_dbg.tevinforeg_vec_t.qclear (method) -ida_dbg.tevinforeg_vec_t.reserve (method) -ida_dbg.tevinforeg_vec_t.resize (method) -ida_dbg.tevinforeg_vec_t.size (method) -ida_dbg.tevinforeg_vec_t.swap (method) -ida_dbg.tevinforeg_vec_t.truncate (method) -ida_dbg.update_bpt (function) -ida_dbg.wait_for_next_event (function) -ida_dbg.write_dbg_memory (function) -ida_diskio (module) -ida_diskio.IDA_SUBDIR_IDADIR_FIRST (variable) -ida_diskio.IDA_SUBDIR_IDP (variable) -ida_diskio.IDA_SUBDIR_ONLY_EXISTING (variable) -ida_diskio.LINPUT_GENERIC (variable) -ida_diskio.LINPUT_LOCAL (variable) -ida_diskio.LINPUT_NONE (variable) -ida_diskio.LINPUT_PROCMEM (variable) -ida_diskio.LINPUT_RFILE (variable) -ida_diskio.choose_ioport_device2 (function) -ida_diskio.choose_ioport_parser_t (class) -ida_diskio.choose_ioport_parser_t.__disown__ (method) -ida_diskio.choose_ioport_parser_t.__init__ (method) -ida_diskio.choose_ioport_parser_t.parse (method) -ida_diskio.close_linput (function) -ida_diskio.create_bytearray_linput (function) -ida_diskio.create_generic_linput (function) -ida_diskio.create_memory_linput (function) -ida_diskio.eclose (function) -ida_diskio.enumerate_files (function) -ida_diskio.enumerate_files2 (function) -ida_diskio.file_enumerator_t (class) -ida_diskio.file_enumerator_t.__disown__ (method) -ida_diskio.file_enumerator_t.__init__ (method) -ida_diskio.file_enumerator_t.visit_file (method) -ida_diskio.fopenA (function) -ida_diskio.fopenM (function) -ida_diskio.fopenRB (function) -ida_diskio.fopenRT (function) -ida_diskio.fopenWB (function) -ida_diskio.fopenWT (function) -ida_diskio.generic_linput_t (class) -ida_diskio.generic_linput_t.__init__ (method) -ida_diskio.generic_linput_t.blocksize (variable) -ida_diskio.generic_linput_t.filesize (variable) -ida_diskio.generic_linput_t.read (method) -ida_diskio.get_ida_subdirs (function) -ida_diskio.get_linput_type (function) -ida_diskio.get_special_folder (function) -ida_diskio.get_user_idadir (function) -ida_diskio.getsysfile (function) -ida_diskio.idadir (function) -ida_diskio.ioports_fallback_t (class) -ida_diskio.ioports_fallback_t.__disown__ (method) -ida_diskio.ioports_fallback_t.__init__ (method) -ida_diskio.ioports_fallback_t.handle (method) -ida_diskio.open_linput (function) -ida_diskio.qlgetz (function) -ida_diskio.read_ioports2 (function) -ida_dirtree (module) -ida_dirtree.DTN_DISPLAY_NAME (variable) -ida_dirtree.DTN_FULL_NAME (variable) -ida_dirtree.direntry_t (class) -ida_dirtree.direntry_t.__eq__ (method) -ida_dirtree.direntry_t.__init__ (method) -ida_dirtree.direntry_t.__lt__ (method) -ida_dirtree.direntry_t.__ne__ (method) -ida_dirtree.direntry_t.idx (variable) -ida_dirtree.direntry_t.isdir (variable) -ida_dirtree.direntry_t.valid (method) -ida_dirtree.direntry_vec_t (class) -ida_dirtree.direntry_vec_t.__eq__ (method) -ida_dirtree.direntry_vec_t.__getitem__ (method) -ida_dirtree.direntry_vec_t.__init__ (method) -ida_dirtree.direntry_vec_t.__len__ (method) -ida_dirtree.direntry_vec_t.__ne__ (method) -ida_dirtree.direntry_vec_t.__setitem__ (method) -ida_dirtree.direntry_vec_t._del (method) -ida_dirtree.direntry_vec_t.add_unique (method) -ida_dirtree.direntry_vec_t.at (method) -ida_dirtree.direntry_vec_t.begin (method) -ida_dirtree.direntry_vec_t.capacity (method) -ida_dirtree.direntry_vec_t.clear (method) -ida_dirtree.direntry_vec_t.empty (method) -ida_dirtree.direntry_vec_t.end (method) -ida_dirtree.direntry_vec_t.erase (method) -ida_dirtree.direntry_vec_t.extract (method) -ida_dirtree.direntry_vec_t.find (method) -ida_dirtree.direntry_vec_t.grow (method) -ida_dirtree.direntry_vec_t.has (method) -ida_dirtree.direntry_vec_t.inject (method) -ida_dirtree.direntry_vec_t.insert (method) -ida_dirtree.direntry_vec_t.pop_back (method) -ida_dirtree.direntry_vec_t.push_back (method) -ida_dirtree.direntry_vec_t.qclear (method) -ida_dirtree.direntry_vec_t.reserve (method) -ida_dirtree.direntry_vec_t.resize (method) -ida_dirtree.direntry_vec_t.size (method) -ida_dirtree.direntry_vec_t.swap (method) -ida_dirtree.direntry_vec_t.truncate (method) -ida_dirtree.dirspec_t (class) -ida_dirtree.dirspec_t.__disown__ (method) -ida_dirtree.dirspec_t.__init__ (method) -ida_dirtree.dirspec_t.get_attrs (method) -ida_dirtree.dirspec_t.get_inode (method) -ida_dirtree.dirspec_t.get_name (method) -ida_dirtree.dirspec_t.is_orderable (method) -ida_dirtree.dirspec_t.rename_inode (method) -ida_dirtree.dirspec_t.unlink_inode (method) -ida_dirtree.dirtree_cursor_t (class) -ida_dirtree.dirtree_cursor_t.__eq__ (method) -ida_dirtree.dirtree_cursor_t.__ge__ (method) -ida_dirtree.dirtree_cursor_t.__gt__ (method) -ida_dirtree.dirtree_cursor_t.__init__ (method) -ida_dirtree.dirtree_cursor_t.__le__ (method) -ida_dirtree.dirtree_cursor_t.__lt__ (method) -ida_dirtree.dirtree_cursor_t.__ne__ (method) -ida_dirtree.dirtree_cursor_t.compare (method) -ida_dirtree.dirtree_cursor_t.is_root_cursor (method) -ida_dirtree.dirtree_cursor_t.parent (variable) -ida_dirtree.dirtree_cursor_t.rank (variable) -ida_dirtree.dirtree_cursor_t.root_cursor (method) -ida_dirtree.dirtree_cursor_t.set_root_cursor (method) -ida_dirtree.dirtree_cursor_t.valid (method) -ida_dirtree.dirtree_cursor_t_root_cursor (function) -ida_dirtree.dirtree_cursor_vec_t (class) -ida_dirtree.dirtree_cursor_vec_t.__eq__ (method) -ida_dirtree.dirtree_cursor_vec_t.__getitem__ (method) -ida_dirtree.dirtree_cursor_vec_t.__init__ (method) -ida_dirtree.dirtree_cursor_vec_t.__len__ (method) -ida_dirtree.dirtree_cursor_vec_t.__ne__ (method) -ida_dirtree.dirtree_cursor_vec_t.__setitem__ (method) -ida_dirtree.dirtree_cursor_vec_t._del (method) -ida_dirtree.dirtree_cursor_vec_t.add_unique (method) -ida_dirtree.dirtree_cursor_vec_t.at (method) -ida_dirtree.dirtree_cursor_vec_t.begin (method) -ida_dirtree.dirtree_cursor_vec_t.capacity (method) -ida_dirtree.dirtree_cursor_vec_t.clear (method) -ida_dirtree.dirtree_cursor_vec_t.empty (method) -ida_dirtree.dirtree_cursor_vec_t.end (method) -ida_dirtree.dirtree_cursor_vec_t.erase (method) -ida_dirtree.dirtree_cursor_vec_t.extract (method) -ida_dirtree.dirtree_cursor_vec_t.find (method) -ida_dirtree.dirtree_cursor_vec_t.grow (method) -ida_dirtree.dirtree_cursor_vec_t.has (method) -ida_dirtree.dirtree_cursor_vec_t.inject (method) -ida_dirtree.dirtree_cursor_vec_t.insert (method) -ida_dirtree.dirtree_cursor_vec_t.pop_back (method) -ida_dirtree.dirtree_cursor_vec_t.push_back (method) -ida_dirtree.dirtree_cursor_vec_t.qclear (method) -ida_dirtree.dirtree_cursor_vec_t.reserve (method) -ida_dirtree.dirtree_cursor_vec_t.resize (method) -ida_dirtree.dirtree_cursor_vec_t.size (method) -ida_dirtree.dirtree_cursor_vec_t.swap (method) -ida_dirtree.dirtree_cursor_vec_t.truncate (method) -ida_dirtree.dirtree_iterator_t (class) -ida_dirtree.dirtree_iterator_t.__init__ (method) -ida_dirtree.dirtree_selection_t (class) -ida_dirtree.dirtree_selection_t.__init__ (method) -ida_dirtree.dirtree_t (class) -ida_dirtree.dirtree_t.__init__ (method) -ida_dirtree.dirtree_t.change_rank (method) -ida_dirtree.dirtree_t.chdir (method) -ida_dirtree.dirtree_t.errstr (method) -ida_dirtree.dirtree_t.find_entry (method) -ida_dirtree.dirtree_t.findfirst (method) -ida_dirtree.dirtree_t.findnext (method) -ida_dirtree.dirtree_t.get_abspath (method) -ida_dirtree.dirtree_t.get_dir_size (method) -ida_dirtree.dirtree_t.get_entry_attrs (method) -ida_dirtree.dirtree_t.get_entry_name (method) -ida_dirtree.dirtree_t.get_id (method) -ida_dirtree.dirtree_t.get_parent_cursor (method) -ida_dirtree.dirtree_t.get_rank (method) -ida_dirtree.dirtree_t.getcwd (method) -ida_dirtree.dirtree_t.is_dir_ordered (method) -ida_dirtree.dirtree_t.is_orderable (method) -ida_dirtree.dirtree_t.isdir (method) -ida_dirtree.dirtree_t.isfile (method) -ida_dirtree.dirtree_t.link (method) -ida_dirtree.dirtree_t.load (method) -ida_dirtree.dirtree_t.mkdir (method) -ida_dirtree.dirtree_t.notify_dirtree (method) -ida_dirtree.dirtree_t.rename (method) -ida_dirtree.dirtree_t.resolve_cursor (method) -ida_dirtree.dirtree_t.resolve_path (method) -ida_dirtree.dirtree_t.rmdir (method) -ida_dirtree.dirtree_t.save (method) -ida_dirtree.dirtree_t.set_id (method) -ida_dirtree.dirtree_t.set_natural_order (method) -ida_dirtree.dirtree_t.traverse (method) -ida_dirtree.dirtree_t.unlink (method) -ida_dirtree.dirtree_t_errstr (function) -ida_dirtree.dirtree_visitor_t (class) -ida_dirtree.dirtree_visitor_t.__disown__ (method) -ida_dirtree.dirtree_visitor_t.__init__ (method) -ida_dirtree.dirtree_visitor_t.visit (method) -ida_dirtree.get_std_dirtree (function) -ida_entry (module) -ida_entry.AEF_IDBENC (variable) -ida_entry.AEF_NODUMMY (variable) -ida_entry.AEF_UTF8 (variable) -ida_entry.add_entry (function) -ida_entry.get_entry (function) -ida_entry.get_entry_forwarder (function) -ida_entry.get_entry_name (function) -ida_entry.get_entry_ordinal (function) -ida_entry.get_entry_qty (function) -ida_entry.rename_entry (function) -ida_entry.set_entry_forwarder (function) -ida_enum (module) -ida_enum.DEFMASK (variable) -ida_enum.ENFL_REGEX (variable) -ida_enum.ENUM_MEMBER_ERROR_ENUM (variable) -ida_enum.ENUM_MEMBER_ERROR_ILLV (variable) -ida_enum.ENUM_MEMBER_ERROR_MASK (variable) -ida_enum.ENUM_MEMBER_ERROR_NAME (variable) -ida_enum.ENUM_MEMBER_ERROR_VALUE (variable) -ida_enum.MAX_ENUM_SERIAL (variable) -ida_enum.add_enum (function) -ida_enum.add_enum_member (function) -ida_enum.del_enum (function) -ida_enum.del_enum_member (function) -ida_enum.enum_member_visitor_t (class) -ida_enum.enum_member_visitor_t.__disown__ (method) -ida_enum.enum_member_visitor_t.__init__ (method) -ida_enum.enum_member_visitor_t.visit_enum_member (method) -ida_enum.for_all_enum_members (function) -ida_enum.get_bmask_cmt (function) -ida_enum.get_bmask_name (function) -ida_enum.get_enum (function) -ida_enum.get_enum_cmt (function) -ida_enum.get_enum_flag (function) -ida_enum.get_enum_idx (function) -ida_enum.get_enum_member (function) -ida_enum.get_enum_member_bmask (function) -ida_enum.get_enum_member_by_name (function) -ida_enum.get_enum_member_cmt (function) -ida_enum.get_enum_member_enum (function) -ida_enum.get_enum_member_name (function) -ida_enum.get_enum_member_serial (function) -ida_enum.get_enum_member_value (function) -ida_enum.get_enum_name (function) -ida_enum.get_enum_name2 (function) -ida_enum.get_enum_qty (function) -ida_enum.get_enum_size (function) -ida_enum.get_enum_type_ordinal (function) -ida_enum.get_enum_width (function) -ida_enum.get_first_bmask (function) -ida_enum.get_first_enum_member (function) -ida_enum.get_first_serial_enum_member (function) -ida_enum.get_last_bmask (function) -ida_enum.get_last_enum_member (function) -ida_enum.get_last_serial_enum_member (function) -ida_enum.get_next_bmask (function) -ida_enum.get_next_enum_member (function) -ida_enum.get_next_serial_enum_member (function) -ida_enum.get_prev_bmask (function) -ida_enum.get_prev_enum_member (function) -ida_enum.get_prev_serial_enum_member (function) -ida_enum.getn_enum (function) -ida_enum.is_bf (function) -ida_enum.is_enum_fromtil (function) -ida_enum.is_enum_hidden (function) -ida_enum.is_ghost_enum (function) -ida_enum.is_one_bit_mask (function) -ida_enum.set_bmask_cmt (function) -ida_enum.set_bmask_name (function) -ida_enum.set_enum_bf (function) -ida_enum.set_enum_cmt (function) -ida_enum.set_enum_flag (function) -ida_enum.set_enum_fromtil (function) -ida_enum.set_enum_ghost (function) -ida_enum.set_enum_hidden (function) -ida_enum.set_enum_idx (function) -ida_enum.set_enum_member_cmt (function) -ida_enum.set_enum_member_name (function) -ida_enum.set_enum_name (function) -ida_enum.set_enum_type_ordinal (function) -ida_enum.set_enum_width (function) -ida_expr (module) -ida_expr.CPL_DEL_MACROS (variable) -ida_expr.CPL_ONLY_SAFE (variable) -ida_expr.CPL_USE_LABELS (variable) -ida_expr.EXTFUN_BASE (variable) -ida_expr.EXTFUN_NORET (variable) -ida_expr.EXTFUN_SAFE (variable) -ida_expr.IDC_LANG_EXT (variable) -ida_expr.VARSLICE_SINGLE (variable) -ida_expr.VREF_COPY (variable) -ida_expr.VREF_LOOP (variable) -ida_expr.VREF_ONCE (variable) -ida_expr.VT_FLOAT (variable) -ida_expr.VT_FUNC (variable) -ida_expr.VT_INT64 (variable) -ida_expr.VT_LONG (variable) -ida_expr.VT_OBJ (variable) -ida_expr.VT_PVOID (variable) -ida_expr.VT_REF (variable) -ida_expr.VT_STR (variable) -ida_expr.VT_WILD (variable) -ida_expr._IdcFunction (class) -ida_expr._IdcFunction.__call__ (method) -ida_expr._IdcFunction.__init__ (method) -ida_expr.add_idc_class (function) -ida_expr.add_idc_func (function) -ida_expr.add_idc_gvar (function) -ida_expr.call_idc_func__ (function) -ida_expr.compile_idc_file (function) -ida_expr.compile_idc_snippet (function) -ida_expr.compile_idc_text (function) -ida_expr.copy_idcv (function) -ida_expr.create_idcv_ref (function) -ida_expr.deep_copy_idcv (function) -ida_expr.del_idc_func (function) -ida_expr.del_idcv_attr (function) -ida_expr.deref_idcv (function) -ida_expr.eExecThrow (variable) -ida_expr.eval_expr (function) -ida_expr.eval_idc_expr (function) -ida_expr.exec_idc_script (function) -ida_expr.exec_system_script (function) -ida_expr.find_idc_class (function) -ida_expr.find_idc_func (function) -ida_expr.find_idc_gvar (function) -ida_expr.first_idcv_attr (function) -ida_expr.free_idcv (function) -ida_expr.get_idc_filename (function) -ida_expr.get_idcv_attr (function) -ida_expr.get_idcv_class_name (function) -ida_expr.get_idcv_slice (function) -ida_expr.highlighter_cbs_t (class) -ida_expr.highlighter_cbs_t.__disown__ (method) -ida_expr.highlighter_cbs_t.__init__ (method) -ida_expr.highlighter_cbs_t.cur_block_state (method) -ida_expr.highlighter_cbs_t.prev_block_state (method) -ida_expr.highlighter_cbs_t.set_block_state (method) -ida_expr.highlighter_cbs_t.set_style (method) -ida_expr.idc_global_t (class) -ida_expr.idc_global_t.__init__ (method) -ida_expr.idc_value_t (class) -ida_expr.idc_value_t.__init__ (method) -ida_expr.idc_value_t._create_empty_string (method) -ida_expr.idc_value_t.c_str (method) -ida_expr.idc_value_t.clear (method) -ida_expr.idc_value_t.create_empty_string (method) -ida_expr.idc_value_t.e (variable) -ida_expr.idc_value_t.funcidx (variable) -ida_expr.idc_value_t.i64 (variable) -ida_expr.idc_value_t.is_convertible (method) -ida_expr.idc_value_t.is_integral (method) -ida_expr.idc_value_t.is_zero (method) -ida_expr.idc_value_t.num (variable) -ida_expr.idc_value_t.pvoid (variable) -ida_expr.idc_value_t.qstr (method) -ida_expr.idc_value_t.reserve (variable) -ida_expr.idc_value_t.set_float (method) -ida_expr.idc_value_t.set_int64 (method) -ida_expr.idc_value_t.set_long (method) -ida_expr.idc_value_t.set_pvoid (method) -ida_expr.idc_value_t.set_string (method) -ida_expr.idc_value_t.swap (method) -ida_expr.idc_value_t.u_str (method) -ida_expr.idc_value_t.vtype (variable) -ida_expr.idc_values_t (class) -ida_expr.idc_values_t.__getitem__ (method) -ida_expr.idc_values_t.__init__ (method) -ida_expr.idc_values_t.__len__ (method) -ida_expr.idc_values_t.__setitem__ (method) -ida_expr.idc_values_t.at (method) -ida_expr.idc_values_t.begin (method) -ida_expr.idc_values_t.capacity (method) -ida_expr.idc_values_t.clear (method) -ida_expr.idc_values_t.empty (method) -ida_expr.idc_values_t.end (method) -ida_expr.idc_values_t.erase (method) -ida_expr.idc_values_t.extract (method) -ida_expr.idc_values_t.grow (method) -ida_expr.idc_values_t.inject (method) -ida_expr.idc_values_t.insert (method) -ida_expr.idc_values_t.pop_back (method) -ida_expr.idc_values_t.push_back (method) -ida_expr.idc_values_t.qclear (method) -ida_expr.idc_values_t.reserve (method) -ida_expr.idc_values_t.resize (method) -ida_expr.idc_values_t.size (method) -ida_expr.idc_values_t.swap (method) -ida_expr.idc_values_t.truncate (method) -ida_expr.idcv_float (function) -ida_expr.idcv_int64 (function) -ida_expr.idcv_long (function) -ida_expr.idcv_num (function) -ida_expr.idcv_object (function) -ida_expr.idcv_string (function) -ida_expr.last_idcv_attr (function) -ida_expr.move_idcv (function) -ida_expr.next_idcv_attr (function) -ida_expr.prev_idcv_attr (function) -ida_expr.print_idcv (function) -ida_expr.py_add_idc_func (function) -ida_expr.py_get_call_idc_func (function) -ida_expr.pyw_convert_defvals (function) -ida_expr.pyw_register_idc_func (function) -ida_expr.pyw_unregister_idc_func (function) -ida_expr.set_header_path (function) -ida_expr.set_idcv_attr (function) -ida_expr.set_idcv_slice (function) -ida_expr.swap_idcvs (function) -ida_expr.throw_idc_exception (function) -ida_fixup (module) -ida_fixup.FIXUPF_CREATED (variable) -ida_fixup.FIXUPF_EXTDEF (variable) -ida_fixup.FIXUPF_LOADER_MASK (variable) -ida_fixup.FIXUPF_REL (variable) -ida_fixup.FIXUPF_UNUSED (variable) -ida_fixup.FIXUP_CUSTOM (variable) -ida_fixup.FIXUP_HI16 (variable) -ida_fixup.FIXUP_HI8 (variable) -ida_fixup.FIXUP_LOW16 (variable) -ida_fixup.FIXUP_LOW8 (variable) -ida_fixup.FIXUP_OFF16 (variable) -ida_fixup.FIXUP_OFF16S (variable) -ida_fixup.FIXUP_OFF32 (variable) -ida_fixup.FIXUP_OFF32S (variable) -ida_fixup.FIXUP_OFF64 (variable) -ida_fixup.FIXUP_OFF8 (variable) -ida_fixup.FIXUP_OFF8S (variable) -ida_fixup.FIXUP_PTR16 (variable) -ida_fixup.FIXUP_PTR32 (variable) -ida_fixup.FIXUP_SEG16 (variable) -ida_fixup.V695_FIXUP_VHIGH (variable) -ida_fixup.V695_FIXUP_VLOW (variable) -ida_fixup.calc_fixup_size (function) -ida_fixup.contains_fixups (function) -ida_fixup.del_fixup (function) -ida_fixup.exists_fixup (function) -ida_fixup.find_custom_fixup (function) -ida_fixup.fixup_data_t (class) -ida_fixup.fixup_data_t.__init__ (method) -ida_fixup.fixup_data_t.calc_size (method) -ida_fixup.fixup_data_t.clr_extdef (method) -ida_fixup.fixup_data_t.clr_unused (method) -ida_fixup.fixup_data_t.displacement (variable) -ida_fixup.fixup_data_t.get (method) -ida_fixup.fixup_data_t.get_base (method) -ida_fixup.fixup_data_t.get_desc (method) -ida_fixup.fixup_data_t.get_flags (method) -ida_fixup.fixup_data_t.get_handler (method) -ida_fixup.fixup_data_t.get_type (method) -ida_fixup.fixup_data_t.get_value (method) -ida_fixup.fixup_data_t.has_base (method) -ida_fixup.fixup_data_t.is_custom (method) -ida_fixup.fixup_data_t.is_extdef (method) -ida_fixup.fixup_data_t.is_unused (method) -ida_fixup.fixup_data_t.off (variable) -ida_fixup.fixup_data_t.patch_value (method) -ida_fixup.fixup_data_t.sel (variable) -ida_fixup.fixup_data_t.set (method) -ida_fixup.fixup_data_t.set_base (method) -ida_fixup.fixup_data_t.set_extdef (method) -ida_fixup.fixup_data_t.set_sel (method) -ida_fixup.fixup_data_t.set_target_sel (method) -ida_fixup.fixup_data_t.set_type (method) -ida_fixup.fixup_data_t.set_type_and_flags (method) -ida_fixup.fixup_data_t.set_unused (method) -ida_fixup.fixup_data_t.was_created (method) -ida_fixup.fixup_info_t (class) -ida_fixup.fixup_info_t.__init__ (method) -ida_fixup.gen_fix_fixups (function) -ida_fixup.get_first_fixup_ea (function) -ida_fixup.get_fixup (function) -ida_fixup.get_fixup_desc (function) -ida_fixup.get_fixup_handler (function) -ida_fixup.get_fixup_value (function) -ida_fixup.get_fixups (function) -ida_fixup.get_next_fixup_ea (function) -ida_fixup.get_prev_fixup_ea (function) -ida_fixup.handle_fixups_in_macro (function) -ida_fixup.is_fixup_custom (function) -ida_fixup.patch_fixup_value (function) -ida_fixup.set_fixup (function) -ida_fpro (module) -ida_fpro.qfile_t (class) -ida_fpro.qfile_t.__init__ (method) -ida_fpro.qfile_t.close (method) -ida_fpro.qfile_t.filename (method) -ida_fpro.qfile_t.flush (method) -ida_fpro.qfile_t.from_capsule (method) -ida_fpro.qfile_t.from_fp (method) -ida_fpro.qfile_t.get_byte (method) -ida_fpro.qfile_t.get_fp (method) -ida_fpro.qfile_t.gets (method) -ida_fpro.qfile_t.open (method) -ida_fpro.qfile_t.opened (method) -ida_fpro.qfile_t.put_byte (method) -ida_fpro.qfile_t.puts (method) -ida_fpro.qfile_t.read (method) -ida_fpro.qfile_t.readbytes (method) -ida_fpro.qfile_t.seek (method) -ida_fpro.qfile_t.size (method) -ida_fpro.qfile_t.tell (method) -ida_fpro.qfile_t.tmpfile (method) -ida_fpro.qfile_t.write (method) -ida_fpro.qfile_t.writebytes (method) -ida_fpro.qfile_t_from_capsule (function) -ida_fpro.qfile_t_from_fp (function) -ida_fpro.qfile_t_tmpfile (function) -ida_frame (module) -ida_frame.REGVAR_ERROR_ARG (variable) -ida_frame.REGVAR_ERROR_NAME (variable) -ida_frame.REGVAR_ERROR_OK (variable) -ida_frame.REGVAR_ERROR_RANGE (variable) -ida_frame.STKVAR_VALID_SIZE (variable) -ida_frame.add_auto_stkpnt (function) -ida_frame.add_frame (function) -ida_frame.add_regvar (function) -ida_frame.add_user_stkpnt (function) -ida_frame.build_stkvar_name (function) -ida_frame.build_stkvar_xrefs (function) -ida_frame.calc_stkvar_struc_offset (function) -ida_frame.define_stkvar (function) -ida_frame.del_frame (function) -ida_frame.del_regvar (function) -ida_frame.del_stkpnt (function) -ida_frame.delete_unreferenced_stkvars (function) -ida_frame.delete_wrong_stkvar_ops (function) -ida_frame.find_regvar (function) -ida_frame.frame_off_args (function) -ida_frame.frame_off_lvars (function) -ida_frame.frame_off_retaddr (function) -ida_frame.frame_off_savregs (function) -ida_frame.free_regvar (function) -ida_frame.get_effective_spd (function) -ida_frame.get_frame (function) -ida_frame.get_frame_part (function) -ida_frame.get_frame_retsize (function) -ida_frame.get_frame_size (function) -ida_frame.get_func_by_frame (function) -ida_frame.get_min_spd_ea (function) -ida_frame.get_sp_delta (function) -ida_frame.get_spd (function) -ida_frame.get_stkvar (function) -ida_frame.has_regvar (function) -ida_frame.is_funcarg_off (function) -ida_frame.lvar_off (function) -ida_frame.recalc_spd (function) -ida_frame.recalc_spd_for_basic_block (function) -ida_frame.regvar_t (class) -ida_frame.regvar_t.__init__ (method) -ida_frame.regvar_t.canon (variable) -ida_frame.regvar_t.cmt (variable) -ida_frame.regvar_t.swap (method) -ida_frame.regvar_t.user (variable) -ida_frame.rename_regvar (function) -ida_frame.set_auto_spd (function) -ida_frame.set_frame_size (function) -ida_frame.set_purged (function) -ida_frame.set_regvar_cmt (function) -ida_frame.soff_to_fpoff (function) -ida_frame.stkpnt_t (class) -ida_frame.stkpnt_t.__eq__ (method) -ida_frame.stkpnt_t.__ge__ (method) -ida_frame.stkpnt_t.__gt__ (method) -ida_frame.stkpnt_t.__init__ (method) -ida_frame.stkpnt_t.__le__ (method) -ida_frame.stkpnt_t.__lt__ (method) -ida_frame.stkpnt_t.__ne__ (method) -ida_frame.stkpnt_t.compare (method) -ida_frame.stkpnts_t (class) -ida_frame.stkpnts_t.__eq__ (method) -ida_frame.stkpnts_t.__ge__ (method) -ida_frame.stkpnts_t.__gt__ (method) -ida_frame.stkpnts_t.__init__ (method) -ida_frame.stkpnts_t.__le__ (method) -ida_frame.stkpnts_t.__lt__ (method) -ida_frame.stkpnts_t.__ne__ (method) -ida_frame.stkpnts_t.compare (method) -ida_frame.update_fpd (function) -ida_frame.xreflist_entry_t (class) -ida_frame.xreflist_entry_t.__eq__ (method) -ida_frame.xreflist_entry_t.__ge__ (method) -ida_frame.xreflist_entry_t.__gt__ (method) -ida_frame.xreflist_entry_t.__init__ (method) -ida_frame.xreflist_entry_t.__le__ (method) -ida_frame.xreflist_entry_t.__lt__ (method) -ida_frame.xreflist_entry_t.__ne__ (method) -ida_frame.xreflist_entry_t.compare (method) -ida_frame.xreflist_entry_t.ea (variable) -ida_frame.xreflist_entry_t.opnum (variable) -ida_frame.xreflist_entry_t.type (variable) -ida_frame.xreflist_t (class) -ida_frame.xreflist_t.__eq__ (method) -ida_frame.xreflist_t.__getitem__ (method) -ida_frame.xreflist_t.__init__ (method) -ida_frame.xreflist_t.__len__ (method) -ida_frame.xreflist_t.__ne__ (method) -ida_frame.xreflist_t.__setitem__ (method) -ida_frame.xreflist_t._del (method) -ida_frame.xreflist_t.add_unique (method) -ida_frame.xreflist_t.at (method) -ida_frame.xreflist_t.begin (method) -ida_frame.xreflist_t.capacity (method) -ida_frame.xreflist_t.clear (method) -ida_frame.xreflist_t.empty (method) -ida_frame.xreflist_t.end (method) -ida_frame.xreflist_t.erase (method) -ida_frame.xreflist_t.extract (method) -ida_frame.xreflist_t.find (method) -ida_frame.xreflist_t.grow (method) -ida_frame.xreflist_t.has (method) -ida_frame.xreflist_t.inject (method) -ida_frame.xreflist_t.insert (method) -ida_frame.xreflist_t.pop_back (method) -ida_frame.xreflist_t.push_back (method) -ida_frame.xreflist_t.qclear (method) -ida_frame.xreflist_t.reserve (method) -ida_frame.xreflist_t.resize (method) -ida_frame.xreflist_t.size (method) -ida_frame.xreflist_t.swap (method) -ida_frame.xreflist_t.truncate (method) -ida_funcs (module) -ida_funcs.FIND_FUNC_DEFINE (variable) -ida_funcs.FIND_FUNC_EXIST (variable) -ida_funcs.FIND_FUNC_IGNOREFN (variable) -ida_funcs.FIND_FUNC_KEEPBD (variable) -ida_funcs.FIND_FUNC_NORMAL (variable) -ida_funcs.FIND_FUNC_OK (variable) -ida_funcs.FIND_FUNC_UNDEF (variable) -ida_funcs.FUNC_BOTTOMBP (variable) -ida_funcs.FUNC_FAR (variable) -ida_funcs.FUNC_FRAME (variable) -ida_funcs.FUNC_FUZZY_SP (variable) -ida_funcs.FUNC_HIDDEN (variable) -ida_funcs.FUNC_LIB (variable) -ida_funcs.FUNC_LUMINA (variable) -ida_funcs.FUNC_NORET (variable) -ida_funcs.FUNC_NORET_PENDING (variable) -ida_funcs.FUNC_OUTLINE (variable) -ida_funcs.FUNC_PROLOG_OK (variable) -ida_funcs.FUNC_PURGED_OK (variable) -ida_funcs.FUNC_REANALYZE (variable) -ida_funcs.FUNC_SP_READY (variable) -ida_funcs.FUNC_STATICDEF (variable) -ida_funcs.FUNC_TAIL (variable) -ida_funcs.FUNC_THUNK (variable) -ida_funcs.FUNC_USERFAR (variable) -ida_funcs.IDASGN_APPLIED (variable) -ida_funcs.IDASGN_BADARG (variable) -ida_funcs.IDASGN_CURRENT (variable) -ida_funcs.IDASGN_OK (variable) -ida_funcs.IDASGN_PLANNED (variable) -ida_funcs.LIBFUNC_DELAY (variable) -ida_funcs.LIBFUNC_FOUND (variable) -ida_funcs.LIBFUNC_NONE (variable) -ida_funcs.MOVE_FUNC_BADSTART (variable) -ida_funcs.MOVE_FUNC_NOCODE (variable) -ida_funcs.MOVE_FUNC_NOFUNC (variable) -ida_funcs.MOVE_FUNC_OK (variable) -ida_funcs.MOVE_FUNC_REFUSED (variable) -ida_funcs.add_func (function) -ida_funcs.add_func_ex (function) -ida_funcs.add_regarg (function) -ida_funcs.append_func_tail (function) -ida_funcs.apply_idasgn_to (function) -ida_funcs.apply_startup_sig (function) -ida_funcs.calc_func_size (function) -ida_funcs.calc_idasgn_state (function) -ida_funcs.calc_thunk_func_target (function) -ida_funcs.calc_thunk_func_target (function) -ida_funcs.del_func (function) -ida_funcs.del_idasgn (function) -ida_funcs.dyn_ea_array (class) -ida_funcs.dyn_ea_array.__getitem__ (method) -ida_funcs.dyn_ea_array.__init__ (method) -ida_funcs.dyn_ea_array.__len__ (method) -ida_funcs.dyn_ea_array.__setitem__ (method) -ida_funcs.dyn_range_array (class) -ida_funcs.dyn_range_array.__getitem__ (method) -ida_funcs.dyn_range_array.__init__ (method) -ida_funcs.dyn_range_array.__len__ (method) -ida_funcs.dyn_range_array.__setitem__ (method) -ida_funcs.dyn_regarg_array (class) -ida_funcs.dyn_regarg_array.__getitem__ (method) -ida_funcs.dyn_regarg_array.__init__ (method) -ida_funcs.dyn_regarg_array.__len__ (method) -ida_funcs.dyn_regarg_array.__setitem__ (method) -ida_funcs.dyn_regvar_array (class) -ida_funcs.dyn_regvar_array.__getitem__ (method) -ida_funcs.dyn_regvar_array.__init__ (method) -ida_funcs.dyn_regvar_array.__len__ (method) -ida_funcs.dyn_regvar_array.__setitem__ (method) -ida_funcs.dyn_stkpnt_array (class) -ida_funcs.dyn_stkpnt_array.__getitem__ (method) -ida_funcs.dyn_stkpnt_array.__init__ (method) -ida_funcs.dyn_stkpnt_array.__len__ (method) -ida_funcs.dyn_stkpnt_array.__setitem__ (method) -ida_funcs.f_any (function) -ida_funcs.find_func_bounds (function) -ida_funcs.free_regarg (function) -ida_funcs.func_contains (function) -ida_funcs.func_does_return (function) -ida_funcs.func_item_iterator_t (class) -ida_funcs.func_item_iterator_t.__init__ (method) -ida_funcs.func_item_iterator_t.__iter__ (method) -ida_funcs.func_item_iterator_t.__next__ (method) -ida_funcs.func_item_iterator_t.addresses (method) -ida_funcs.func_item_iterator_t.chunk (method) -ida_funcs.func_item_iterator_t.code_items (method) -ida_funcs.func_item_iterator_t.current (method) -ida_funcs.func_item_iterator_t.data_items (method) -ida_funcs.func_item_iterator_t.decode_preceding_insn (method) -ida_funcs.func_item_iterator_t.decode_prev_insn (method) -ida_funcs.func_item_iterator_t.first (method) -ida_funcs.func_item_iterator_t.head_items (method) -ida_funcs.func_item_iterator_t.last (method) -ida_funcs.func_item_iterator_t.next_addr (method) -ida_funcs.func_item_iterator_t.next_code (method) -ida_funcs.func_item_iterator_t.next_data (method) -ida_funcs.func_item_iterator_t.next_head (method) -ida_funcs.func_item_iterator_t.next_not_tail (method) -ida_funcs.func_item_iterator_t.not_tails (method) -ida_funcs.func_item_iterator_t.prev (method) -ida_funcs.func_item_iterator_t.prev_addr (method) -ida_funcs.func_item_iterator_t.prev_code (method) -ida_funcs.func_item_iterator_t.prev_data (method) -ida_funcs.func_item_iterator_t.prev_head (method) -ida_funcs.func_item_iterator_t.prev_not_tail (method) -ida_funcs.func_item_iterator_t.set (method) -ida_funcs.func_item_iterator_t.set_range (method) -ida_funcs.func_item_iterator_t.succ (method) -ida_funcs.func_item_iterator_t.succ_code (method) -ida_funcs.func_parent_iterator_set (function) -ida_funcs.func_parent_iterator_t (class) -ida_funcs.func_parent_iterator_t.__init__ (method) -ida_funcs.func_parent_iterator_t.__iter__ (method) -ida_funcs.func_parent_iterator_t.__next__ (method) -ida_funcs.func_parent_iterator_t.first (method) -ida_funcs.func_parent_iterator_t.last (method) -ida_funcs.func_parent_iterator_t.parent (method) -ida_funcs.func_parent_iterator_t.prev (method) -ida_funcs.func_parent_iterator_t.reset_fnt (method) -ida_funcs.func_parent_iterator_t.set (method) -ida_funcs.func_t (class) -ida_funcs.func_t.__get_points__ (method) -ida_funcs.func_t.__get_referers__ (method) -ida_funcs.func_t.__get_regargs__ (method) -ida_funcs.func_t.__get_regvars__ (method) -ida_funcs.func_t.__get_tails__ (method) -ida_funcs.func_t.__init__ (method) -ida_funcs.func_t.__iter__ (method) -ida_funcs.func_t.addresses (method) -ida_funcs.func_t.analyzed_sp (method) -ida_funcs.func_t.argsize (variable) -ida_funcs.func_t.code_items (method) -ida_funcs.func_t.color (variable) -ida_funcs.func_t.data_items (method) -ida_funcs.func_t.does_return (method) -ida_funcs.func_t.flags (variable) -ida_funcs.func_t.fpd (variable) -ida_funcs.func_t.frame (variable) -ida_funcs.func_t.frregs (variable) -ida_funcs.func_t.frsize (variable) -ida_funcs.func_t.head_items (method) -ida_funcs.func_t.is_far (method) -ida_funcs.func_t.need_prolog_analysis (method) -ida_funcs.func_t.not_tails (method) -ida_funcs.func_t.owner (variable) -ida_funcs.func_t.pntqty (variable) -ida_funcs.func_t.points (variable) -ida_funcs.func_t.referers (variable) -ida_funcs.func_t.refqty (variable) -ida_funcs.func_t.regargqty (variable) -ida_funcs.func_t.regargs (variable) -ida_funcs.func_t.regvarqty (variable) -ida_funcs.func_t.regvars (variable) -ida_funcs.func_t.tailqty (variable) -ida_funcs.func_t.tails (variable) -ida_funcs.func_t__from_ptrval__ (function) -ida_funcs.func_tail_iterator_set (function) -ida_funcs.func_tail_iterator_set_ea (function) -ida_funcs.func_tail_iterator_t (class) -ida_funcs.func_tail_iterator_t.__init__ (method) -ida_funcs.func_tail_iterator_t.__iter__ (method) -ida_funcs.func_tail_iterator_t.__next__ (method) -ida_funcs.func_tail_iterator_t.chunk (method) -ida_funcs.func_tail_iterator_t.first (method) -ida_funcs.func_tail_iterator_t.last (method) -ida_funcs.func_tail_iterator_t.main (method) -ida_funcs.func_tail_iterator_t.prev (method) -ida_funcs.func_tail_iterator_t.set (method) -ida_funcs.func_tail_iterator_t.set_ea (method) -ida_funcs.func_tail_iterator_t.set_range (method) -ida_funcs.get_current_idasgn (function) -ida_funcs.get_fchunk (function) -ida_funcs.get_fchunk_num (function) -ida_funcs.get_fchunk_qty (function) -ida_funcs.get_fchunk_referer (function) -ida_funcs.get_func (function) -ida_funcs.get_func_bitness (function) -ida_funcs.get_func_bits (function) -ida_funcs.get_func_bytes (function) -ida_funcs.get_func_chunknum (function) -ida_funcs.get_func_cmt (function) -ida_funcs.get_func_name (function) -ida_funcs.get_func_num (function) -ida_funcs.get_func_qty (function) -ida_funcs.get_func_ranges (function) -ida_funcs.get_idasgn_desc (function) -ida_funcs.get_idasgn_desc_with_matches (function) -ida_funcs.get_idasgn_qty (function) -ida_funcs.get_idasgn_title (function) -ida_funcs.get_next_fchunk (function) -ida_funcs.get_next_func (function) -ida_funcs.get_next_func_addr (function) -ida_funcs.get_prev_fchunk (function) -ida_funcs.get_prev_func (function) -ida_funcs.get_prev_func_addr (function) -ida_funcs.getn_fchunk (function) -ida_funcs.getn_func (function) -ida_funcs.is_finally_visible_func (function) -ida_funcs.is_func_entry (function) -ida_funcs.is_func_locked (function) -ida_funcs.is_func_tail (function) -ida_funcs.is_same_func (function) -ida_funcs.is_visible_func (function) -ida_funcs.lock_func (class) -ida_funcs.lock_func.__init__ (method) -ida_funcs.lock_func_range (function) -ida_funcs.lock_func_with_tails_t (class) -ida_funcs.lock_func_with_tails_t.__init__ (method) -ida_funcs.plan_to_apply_idasgn (function) -ida_funcs.read_regargs (function) -ida_funcs.reanalyze_function (function) -ida_funcs.reanalyze_noret_flag (function) -ida_funcs.regarg_t (class) -ida_funcs.regarg_t.__init__ (method) -ida_funcs.regarg_t.swap (method) -ida_funcs.remove_func_tail (function) -ida_funcs.set_func_cmt (function) -ida_funcs.set_func_end (function) -ida_funcs.set_func_name_if_jumpfunc (function) -ida_funcs.set_func_start (function) -ida_funcs.set_noret_insn (function) -ida_funcs.set_tail_owner (function) -ida_funcs.set_visible_func (function) -ida_funcs.try_to_add_libfunc (function) -ida_funcs.update_func (function) -ida_gdl (module) -ida_gdl.BasicBlock (class) -ida_gdl.BasicBlock.__init__ (method) -ida_gdl.BasicBlock.preds (method) -ida_gdl.BasicBlock.succs (method) -ida_gdl.CHART_FOLLOW_DIRECTION (variable) -ida_gdl.CHART_GEN_DOT (variable) -ida_gdl.CHART_GEN_GDL (variable) -ida_gdl.CHART_IGNORE_LIB_FROM (variable) -ida_gdl.CHART_IGNORE_LIB_TO (variable) -ida_gdl.CHART_NOLIBFUNCS (variable) -ida_gdl.CHART_PRINT_DOTS (variable) -ida_gdl.CHART_PRINT_NAMES (variable) -ida_gdl.CHART_RECURSIVE (variable) -ida_gdl.CHART_REFERENCED (variable) -ida_gdl.CHART_REFERENCING (variable) -ida_gdl.CHART_WINGRAPH (variable) -ida_gdl.FC_APPND (variable) -ida_gdl.FC_CALL_ENDS (variable) -ida_gdl.FC_CHKBREAK (variable) -ida_gdl.FC_NOEXT (variable) -ida_gdl.FC_NOPREDS (variable) -ida_gdl.FC_OUTLINES (variable) -ida_gdl.FC_PRINT (variable) -ida_gdl.FlowChart (class) -ida_gdl.FlowChart.__getitem__ (method) -ida_gdl.FlowChart.__init__ (method) -ida_gdl.FlowChart.__iter__ (method) -ida_gdl.FlowChart._getitem (method) -ida_gdl.FlowChart.refresh (method) -ida_gdl.FlowChart.size (variable) -ida_gdl.cancellable_graph_t (class) -ida_gdl.cancellable_graph_t.__disown__ (method) -ida_gdl.cancellable_graph_t.__init__ (method) -ida_gdl.display_gdl (function) -ida_gdl.fcb_cndret (variable) -ida_gdl.fcb_enoret (variable) -ida_gdl.fcb_error (variable) -ida_gdl.fcb_extern (variable) -ida_gdl.fcb_indjump (variable) -ida_gdl.fcb_noret (variable) -ida_gdl.fcb_normal (variable) -ida_gdl.fcb_ret (variable) -ida_gdl.gdl_graph_t (class) -ida_gdl.gdl_graph_t.__disown__ (method) -ida_gdl.gdl_graph_t.__init__ (method) -ida_gdl.gdl_graph_t.begin (method) -ida_gdl.gdl_graph_t.edge (method) -ida_gdl.gdl_graph_t.empty (method) -ida_gdl.gdl_graph_t.end (method) -ida_gdl.gdl_graph_t.entry (method) -ida_gdl.gdl_graph_t.exists (method) -ida_gdl.gdl_graph_t.exit (method) -ida_gdl.gdl_graph_t.front (method) -ida_gdl.gdl_graph_t.get_edge_color (method) -ida_gdl.gdl_graph_t.get_node_color (method) -ida_gdl.gdl_graph_t.get_node_label (method) -ida_gdl.gdl_graph_t.nedge (method) -ida_gdl.gdl_graph_t.node_qty (method) -ida_gdl.gdl_graph_t.npred (method) -ida_gdl.gdl_graph_t.nsucc (method) -ida_gdl.gdl_graph_t.pred (method) -ida_gdl.gdl_graph_t.print_edge (method) -ida_gdl.gdl_graph_t.print_graph_attributes (method) -ida_gdl.gdl_graph_t.print_node (method) -ida_gdl.gdl_graph_t.print_node_attributes (method) -ida_gdl.gdl_graph_t.size (method) -ida_gdl.gdl_graph_t.succ (method) -ida_gdl.gen_complex_call_chart (function) -ida_gdl.gen_flow_graph (function) -ida_gdl.gen_gdl (function) -ida_gdl.gen_simple_call_chart (function) -ida_gdl.is_noret_block (function) -ida_gdl.is_ret_block (function) -ida_gdl.node_iterator (class) -ida_gdl.node_iterator.__eq__ (method) -ida_gdl.node_iterator.__init__ (method) -ida_gdl.node_iterator.__ne__ (method) -ida_gdl.node_iterator.__ref__ (method) -ida_gdl.qbasic_block_t (class) -ida_gdl.qbasic_block_t.__init__ (method) -ida_gdl.qflow_chart_t (class) -ida_gdl.qflow_chart_t.__getitem__ (method) -ida_gdl.qflow_chart_t.__init__ (method) -ida_gdl.qflow_chart_t.append_to_flowchart (method) -ida_gdl.qflow_chart_t.bounds (variable) -ida_gdl.qflow_chart_t.calc_block_type (method) -ida_gdl.qflow_chart_t.create (method) -ida_gdl.qflow_chart_t.flags (variable) -ida_gdl.qflow_chart_t.get_node_label (method) -ida_gdl.qflow_chart_t.is_noret_block (method) -ida_gdl.qflow_chart_t.is_ret_block (method) -ida_gdl.qflow_chart_t.npred (method) -ida_gdl.qflow_chart_t.nproper (variable) -ida_gdl.qflow_chart_t.nsucc (method) -ida_gdl.qflow_chart_t.pfn (variable) -ida_gdl.qflow_chart_t.pred (method) -ida_gdl.qflow_chart_t.print_names (method) -ida_gdl.qflow_chart_t.print_node_attributes (method) -ida_gdl.qflow_chart_t.refresh (method) -ida_gdl.qflow_chart_t.size (method) -ida_gdl.qflow_chart_t.succ (method) -ida_graph (module) -ida_graph.GLICTL_CENTER (variable) -ida_graph.GraphViewer (class) -ida_graph.GraphViewer.AddCommand (method) -ida_graph.GraphViewer.AddEdge (method) -ida_graph.GraphViewer.AddNode (method) -ida_graph.GraphViewer.Clear (method) -ida_graph.GraphViewer.Close (method) -ida_graph.GraphViewer.Count (method) -ida_graph.GraphViewer.OnCommand (method) -ida_graph.GraphViewer.OnPopup (method) -ida_graph.GraphViewer.OnRefresh (method) -ida_graph.GraphViewer.Select (method) -ida_graph.GraphViewer.Show (method) -ida_graph.GraphViewer.UI_Hooks_Trampoline (class) -ida_graph.GraphViewer.UI_Hooks_Trampoline.__init__ (method) -ida_graph.GraphViewer.UI_Hooks_Trampoline.populating_widget_popup (method) -ida_graph.GraphViewer._OnBind (method) -ida_graph.GraphViewer.__getitem__ (method) -ida_graph.GraphViewer.__init__ (method) -ida_graph.GraphViewer.__init__._qccb (function) -ida_graph.GraphViewer.__iter__ (method) -ida_graph.MTG_DOT_NODE (variable) -ida_graph.MTG_GROUP_NODE (variable) -ida_graph.MTG_NON_DISPLAYABLE_NODE (variable) -ida_graph.NIF_BG_COLOR (variable) -ida_graph.NIF_EA (variable) -ida_graph.NIF_FLAGS (variable) -ida_graph.NIF_FRAME_COLOR (variable) -ida_graph.NIF_TEXT (variable) -ida_graph.TPointDouble (class) -ida_graph.TPointDouble.__eq__ (method) -ida_graph.TPointDouble.__init__ (method) -ida_graph.TPointDouble.__ne__ (method) -ida_graph.TPointDouble.add (method) -ida_graph.TPointDouble.negate (method) -ida_graph.TPointDouble.sub (method) -ida_graph.abstract_graph_t (class) -ida_graph.abstract_graph_t.__disown__ (method) -ida_graph.abstract_graph_t.__init__ (method) -ida_graph.abstract_graph_t.callback_ud (variable) -ida_graph.abstract_graph_t.circle_center (variable) -ida_graph.abstract_graph_t.circle_radius (variable) -ida_graph.abstract_graph_t.create_circle_layout (method) -ida_graph.abstract_graph_t.create_tree_layout (method) -ida_graph.abstract_graph_t.current_layout (variable) -ida_graph.abstract_graph_t.get_edge (method) -ida_graph.abstract_graph_t.grcall (method) -ida_graph.abstract_graph_t.nrect (method) -ida_graph.abstract_graph_t.rect_edges_made (variable) -ida_graph.abstract_graph_t.set_callback (method) -ida_graph.abstract_graph_t.title (variable) -ida_graph.calc_dist (function) -ida_graph.clr_node_info (function) -ida_graph.create_disasm_graph (function) -ida_graph.create_graph_viewer (function) -ida_graph.create_mutable_graph (function) -ida_graph.create_user_graph_place (function) -ida_graph.del_node_info (function) -ida_graph.delete_mutable_graph (function) -ida_graph.edge_info_t (class) -ida_graph.edge_info_t.__init__ (method) -ida_graph.edge_info_t.color (variable) -ida_graph.edge_info_t.layout (variable) -ida_graph.edge_info_t.reverse_layout (method) -ida_graph.edge_info_t.width (variable) -ida_graph.edge_infos_wrapper_t (class) -ida_graph.edge_infos_wrapper_t.__init__ (method) -ida_graph.edge_infos_wrapper_t.clear (method) -ida_graph.edge_layout_point_t (class) -ida_graph.edge_layout_point_t.__eq__ (method) -ida_graph.edge_layout_point_t.__init__ (method) -ida_graph.edge_layout_point_t.__ne__ (method) -ida_graph.edge_layout_point_t.compare (method) -ida_graph.edge_layout_point_t.e (variable) -ida_graph.edge_layout_point_t.pidx (variable) -ida_graph.edge_segment_t (class) -ida_graph.edge_segment_t.__init__ (method) -ida_graph.edge_segment_t.__lt__ (method) -ida_graph.edge_segment_t.length (method) -ida_graph.edge_segment_t.toright (method) -ida_graph.edge_t (class) -ida_graph.edge_t.__eq__ (method) -ida_graph.edge_t.__init__ (method) -ida_graph.edge_t.__lt__ (method) -ida_graph.edge_t.__ne__ (method) -ida_graph.edge_t.dst (variable) -ida_graph.edge_t.src (variable) -ida_graph.get_graph_viewer (function) -ida_graph.get_node_info (function) -ida_graph.get_viewer_graph (function) -ida_graph.git_edge (variable) -ida_graph.git_elp (variable) -ida_graph.git_node (variable) -ida_graph.git_none (variable) -ida_graph.git_text (variable) -ida_graph.git_tool (variable) -ida_graph.graph_item_t (class) -ida_graph.graph_item_t.__init__ (method) -ida_graph.graph_item_t.b (variable) -ida_graph.graph_item_t.e (variable) -ida_graph.graph_item_t.elp (variable) -ida_graph.graph_item_t.is_edge (method) -ida_graph.graph_item_t.is_node (method) -ida_graph.graph_item_t.n (variable) -ida_graph.graph_item_t.p (variable) -ida_graph.graph_item_t.type (variable) -ida_graph.graph_node_visitor_t (class) -ida_graph.graph_node_visitor_t.__disown__ (method) -ida_graph.graph_node_visitor_t.__init__ (method) -ida_graph.graph_node_visitor_t.is_forbidden_edge (method) -ida_graph.graph_node_visitor_t.is_visited (method) -ida_graph.graph_node_visitor_t.reinit (method) -ida_graph.graph_node_visitor_t.set_visited (method) -ida_graph.graph_node_visitor_t.visit_node (method) -ida_graph.graph_path_visitor_t (class) -ida_graph.graph_path_visitor_t.__disown__ (method) -ida_graph.graph_path_visitor_t.__init__ (method) -ida_graph.graph_path_visitor_t.path (variable) -ida_graph.graph_path_visitor_t.prune (variable) -ida_graph.graph_path_visitor_t.walk_backward (method) -ida_graph.graph_path_visitor_t.walk_forward (method) -ida_graph.graph_visitor_t (class) -ida_graph.graph_visitor_t.__disown__ (method) -ida_graph.graph_visitor_t.__init__ (method) -ida_graph.graph_visitor_t.visit_edge (method) -ida_graph.graph_visitor_t.visit_node (method) -ida_graph.grcode_calculating_layout (variable) -ida_graph.grcode_center_on (variable) -ida_graph.grcode_change_group_visibility (variable) -ida_graph.grcode_changed_graph (variable) -ida_graph.grcode_clear (variable) -ida_graph.grcode_clicked (variable) -ida_graph.grcode_create_circle_layout (variable) -ida_graph.grcode_create_digraph_layout (variable) -ida_graph.grcode_create_disasm_graph1 (variable) -ida_graph.grcode_create_disasm_graph2 (variable) -ida_graph.grcode_create_graph_viewer (variable) -ida_graph.grcode_create_group (variable) -ida_graph.grcode_create_mutable_graph (variable) -ida_graph.grcode_create_tree_layout (variable) -ida_graph.grcode_create_user_graph_place (variable) -ida_graph.grcode_creating_group (variable) -ida_graph.grcode_dblclicked (variable) -ida_graph.grcode_del_custom_layout (variable) -ida_graph.grcode_del_node_info (variable) -ida_graph.grcode_delete_group (variable) -ida_graph.grcode_delete_mutable_graph (variable) -ida_graph.grcode_deleting_group (variable) -ida_graph.grcode_destroyed (variable) -ida_graph.grcode_edge_infos_wrapper_clear (variable) -ida_graph.grcode_edge_infos_wrapper_copy (variable) -ida_graph.grcode_empty (variable) -ida_graph.grcode_find_subgraph_node (variable) -ida_graph.grcode_fit_window (variable) -ida_graph.grcode_get_curnode (variable) -ida_graph.grcode_get_custom_layout (variable) -ida_graph.grcode_get_gli (variable) -ida_graph.grcode_get_graph_groups (variable) -ida_graph.grcode_get_graph_viewer (variable) -ida_graph.grcode_get_node_info (variable) -ida_graph.grcode_get_node_representative (variable) -ida_graph.grcode_get_selection (variable) -ida_graph.grcode_get_viewer_graph (variable) -ida_graph.grcode_gotfocus (variable) -ida_graph.grcode_group_visibility (variable) -ida_graph.grcode_is_visible_node (variable) -ida_graph.grcode_layout_calculated (variable) -ida_graph.grcode_lostfocus (variable) -ida_graph.grcode_node_qty (variable) -ida_graph.grcode_nrect (variable) -ida_graph.grcode_refresh_viewer (variable) -ida_graph.grcode_set_custom_layout (variable) -ida_graph.grcode_set_edge (variable) -ida_graph.grcode_set_gli (variable) -ida_graph.grcode_set_graph_groups (variable) -ida_graph.grcode_set_node_info (variable) -ida_graph.grcode_set_titlebar_height (variable) -ida_graph.grcode_set_viewer_graph (variable) -ida_graph.grcode_user_draw (variable) -ida_graph.grcode_user_hint (variable) -ida_graph.grcode_user_refresh (variable) -ida_graph.grcode_user_size (variable) -ida_graph.grcode_user_text (variable) -ida_graph.grcode_user_title (variable) -ida_graph.grcode_viewer_create_groups_vec (variable) -ida_graph.grcode_viewer_delete_groups_vec (variable) -ida_graph.grcode_viewer_groups_visibility_vec (variable) -ida_graph.group_crinfo_t (class) -ida_graph.group_crinfo_t.__init__ (method) -ida_graph.interval_t (class) -ida_graph.interval_t.__eq__ (method) -ida_graph.interval_t.__init__ (method) -ida_graph.interval_t.__ne__ (method) -ida_graph.interval_t.contains (method) -ida_graph.interval_t.empty (method) -ida_graph.interval_t.intersect (method) -ida_graph.interval_t.length (method) -ida_graph.interval_t.make_union (method) -ida_graph.interval_t.move_by (method) -ida_graph.mutable_graph_t (class) -ida_graph.mutable_graph_t.__init__ (method) -ida_graph.mutable_graph_t.add_edge (method) -ida_graph.mutable_graph_t.add_node (method) -ida_graph.mutable_graph_t.belongs (variable) -ida_graph.mutable_graph_t.calc_group_ea (method) -ida_graph.mutable_graph_t.change_group_visibility (method) -ida_graph.mutable_graph_t.create_digraph_layout (method) -ida_graph.mutable_graph_t.create_group (method) -ida_graph.mutable_graph_t.del_custom_layout (method) -ida_graph.mutable_graph_t.del_edge (method) -ida_graph.mutable_graph_t.del_node (method) -ida_graph.mutable_graph_t.delete_group (method) -ida_graph.mutable_graph_t.empty (method) -ida_graph.mutable_graph_t.exists (method) -ida_graph.mutable_graph_t.get_custom_layout (method) -ida_graph.mutable_graph_t.get_first_subgraph_node (method) -ida_graph.mutable_graph_t.get_graph_groups (method) -ida_graph.mutable_graph_t.get_next_subgraph_node (method) -ida_graph.mutable_graph_t.get_node_group (method) -ida_graph.mutable_graph_t.get_node_representative (method) -ida_graph.mutable_graph_t.gid (variable) -ida_graph.mutable_graph_t.is_collapsed_node (method) -ida_graph.mutable_graph_t.is_deleted_node (method) -ida_graph.mutable_graph_t.is_displayable_node (method) -ida_graph.mutable_graph_t.is_dot_node (method) -ida_graph.mutable_graph_t.is_group_node (method) -ida_graph.mutable_graph_t.is_simple_node (method) -ida_graph.mutable_graph_t.is_subgraph_node (method) -ida_graph.mutable_graph_t.is_uncollapsed_node (method) -ida_graph.mutable_graph_t.is_user_graph (method) -ida_graph.mutable_graph_t.is_visible_node (method) -ida_graph.mutable_graph_t.node_flags (variable) -ida_graph.mutable_graph_t.node_qty (method) -ida_graph.mutable_graph_t.npred (method) -ida_graph.mutable_graph_t.nsucc (method) -ida_graph.mutable_graph_t.pred (method) -ida_graph.mutable_graph_t.predset (method) -ida_graph.mutable_graph_t.redo_layout (method) -ida_graph.mutable_graph_t.refresh (method) -ida_graph.mutable_graph_t.replace_edge (method) -ida_graph.mutable_graph_t.reset (method) -ida_graph.mutable_graph_t.resize (method) -ida_graph.mutable_graph_t.set_custom_layout (method) -ida_graph.mutable_graph_t.set_deleted_node (method) -ida_graph.mutable_graph_t.set_edge (method) -ida_graph.mutable_graph_t.set_graph_groups (method) -ida_graph.mutable_graph_t.set_node_group (method) -ida_graph.mutable_graph_t.set_nrect (method) -ida_graph.mutable_graph_t.size (method) -ida_graph.mutable_graph_t.succ (method) -ida_graph.mutable_graph_t.succset (method) -ida_graph.node_info_t (class) -ida_graph.node_info_t.__init__ (method) -ida_graph.node_info_t.bg_color (variable) -ida_graph.node_info_t.ea (variable) -ida_graph.node_info_t.flags (variable) -ida_graph.node_info_t.frame_color (variable) -ida_graph.node_info_t.get_flags_for_valid (method) -ida_graph.node_info_t.text (variable) -ida_graph.node_info_t.valid_bg_color (method) -ida_graph.node_info_t.valid_ea (method) -ida_graph.node_info_t.valid_flags (method) -ida_graph.node_info_t.valid_frame_color (method) -ida_graph.node_info_t.valid_text (method) -ida_graph.node_layout_t (class) -ida_graph.node_layout_t.__eq__ (method) -ida_graph.node_layout_t.__getitem__ (method) -ida_graph.node_layout_t.__init__ (method) -ida_graph.node_layout_t.__len__ (method) -ida_graph.node_layout_t.__ne__ (method) -ida_graph.node_layout_t.__setitem__ (method) -ida_graph.node_layout_t._del (method) -ida_graph.node_layout_t.add_unique (method) -ida_graph.node_layout_t.at (method) -ida_graph.node_layout_t.begin (method) -ida_graph.node_layout_t.capacity (method) -ida_graph.node_layout_t.clear (method) -ida_graph.node_layout_t.empty (method) -ida_graph.node_layout_t.end (method) -ida_graph.node_layout_t.erase (method) -ida_graph.node_layout_t.extract (method) -ida_graph.node_layout_t.find (method) -ida_graph.node_layout_t.grow (method) -ida_graph.node_layout_t.has (method) -ida_graph.node_layout_t.inject (method) -ida_graph.node_layout_t.insert (method) -ida_graph.node_layout_t.pop_back (method) -ida_graph.node_layout_t.push_back (method) -ida_graph.node_layout_t.qclear (method) -ida_graph.node_layout_t.reserve (method) -ida_graph.node_layout_t.resize (method) -ida_graph.node_layout_t.size (method) -ida_graph.node_layout_t.swap (method) -ida_graph.node_layout_t.truncate (method) -ida_graph.node_ordering_t (class) -ida_graph.node_ordering_t.__init__ (method) -ida_graph.node_ordering_t.clear (method) -ida_graph.node_ordering_t.clr (method) -ida_graph.node_ordering_t.node (method) -ida_graph.node_ordering_t.order (method) -ida_graph.node_ordering_t.resize (method) -ida_graph.node_ordering_t.set (method) -ida_graph.node_ordering_t.size (method) -ida_graph.point_t (class) -ida_graph.point_t.__eq__ (method) -ida_graph.point_t.__init__ (method) -ida_graph.point_t.__ne__ (method) -ida_graph.point_t.add (method) -ida_graph.point_t.negate (method) -ida_graph.point_t.sub (method) -ida_graph.pointseq_t (class) -ida_graph.pointseq_t.__init__ (method) -ida_graph.pointvec_t (class) -ida_graph.pointvec_t.__eq__ (method) -ida_graph.pointvec_t.__getitem__ (method) -ida_graph.pointvec_t.__init__ (method) -ida_graph.pointvec_t.__len__ (method) -ida_graph.pointvec_t.__ne__ (method) -ida_graph.pointvec_t.__setitem__ (method) -ida_graph.pointvec_t._del (method) -ida_graph.pointvec_t.add_unique (method) -ida_graph.pointvec_t.at (method) -ida_graph.pointvec_t.begin (method) -ida_graph.pointvec_t.capacity (method) -ida_graph.pointvec_t.clear (method) -ida_graph.pointvec_t.empty (method) -ida_graph.pointvec_t.end (method) -ida_graph.pointvec_t.erase (method) -ida_graph.pointvec_t.extract (method) -ida_graph.pointvec_t.find (method) -ida_graph.pointvec_t.grow (method) -ida_graph.pointvec_t.has (method) -ida_graph.pointvec_t.inject (method) -ida_graph.pointvec_t.insert (method) -ida_graph.pointvec_t.pop_back (method) -ida_graph.pointvec_t.push_back (method) -ida_graph.pointvec_t.qclear (method) -ida_graph.pointvec_t.reserve (method) -ida_graph.pointvec_t.resize (method) -ida_graph.pointvec_t.size (method) -ida_graph.pointvec_t.swap (method) -ida_graph.pointvec_t.truncate (method) -ida_graph.pyg_close (function) -ida_graph.pyg_select_node (function) -ida_graph.pyg_show (function) -ida_graph.rect_t (class) -ida_graph.rect_t.__eq__ (method) -ida_graph.rect_t.__init__ (method) -ida_graph.rect_t.__ne__ (method) -ida_graph.rect_t.area (method) -ida_graph.rect_t.bottomright (method) -ida_graph.rect_t.center (method) -ida_graph.rect_t.contains (method) -ida_graph.rect_t.empty (method) -ida_graph.rect_t.grow (method) -ida_graph.rect_t.height (method) -ida_graph.rect_t.intersect (method) -ida_graph.rect_t.is_intersection_empty (method) -ida_graph.rect_t.make_union (method) -ida_graph.rect_t.move_by (method) -ida_graph.rect_t.move_to (method) -ida_graph.rect_t.topleft (method) -ida_graph.rect_t.width (method) -ida_graph.refresh_viewer (function) -ida_graph.row_info_t (class) -ida_graph.row_info_t.__init__ (method) -ida_graph.row_info_t.bottom (variable) -ida_graph.row_info_t.height (method) -ida_graph.row_info_t.nodes (variable) -ida_graph.row_info_t.top (variable) -ida_graph.screen_graph_selection_base_t (class) -ida_graph.screen_graph_selection_base_t.__eq__ (method) -ida_graph.screen_graph_selection_base_t.__getitem__ (method) -ida_graph.screen_graph_selection_base_t.__init__ (method) -ida_graph.screen_graph_selection_base_t.__len__ (method) -ida_graph.screen_graph_selection_base_t.__ne__ (method) -ida_graph.screen_graph_selection_base_t.__setitem__ (method) -ida_graph.screen_graph_selection_base_t._del (method) -ida_graph.screen_graph_selection_base_t.add_unique (method) -ida_graph.screen_graph_selection_base_t.at (method) -ida_graph.screen_graph_selection_base_t.begin (method) -ida_graph.screen_graph_selection_base_t.capacity (method) -ida_graph.screen_graph_selection_base_t.clear (method) -ida_graph.screen_graph_selection_base_t.empty (method) -ida_graph.screen_graph_selection_base_t.end (method) -ida_graph.screen_graph_selection_base_t.erase (method) -ida_graph.screen_graph_selection_base_t.extract (method) -ida_graph.screen_graph_selection_base_t.find (method) -ida_graph.screen_graph_selection_base_t.grow (method) -ida_graph.screen_graph_selection_base_t.has (method) -ida_graph.screen_graph_selection_base_t.inject (method) -ida_graph.screen_graph_selection_base_t.insert (method) -ida_graph.screen_graph_selection_base_t.pop_back (method) -ida_graph.screen_graph_selection_base_t.push_back (method) -ida_graph.screen_graph_selection_base_t.qclear (method) -ida_graph.screen_graph_selection_base_t.reserve (method) -ida_graph.screen_graph_selection_base_t.resize (method) -ida_graph.screen_graph_selection_base_t.size (method) -ida_graph.screen_graph_selection_base_t.swap (method) -ida_graph.screen_graph_selection_base_t.truncate (method) -ida_graph.screen_graph_selection_t (class) -ida_graph.screen_graph_selection_t.__init__ (method) -ida_graph.screen_graph_selection_t.add (method) -ida_graph.screen_graph_selection_t.add_node (method) -ida_graph.screen_graph_selection_t.add_point (method) -ida_graph.screen_graph_selection_t.del_node (method) -ida_graph.screen_graph_selection_t.del_point (method) -ida_graph.screen_graph_selection_t.has (method) -ida_graph.screen_graph_selection_t.items_count (method) -ida_graph.screen_graph_selection_t.nodes_count (method) -ida_graph.screen_graph_selection_t.points_count (method) -ida_graph.screen_graph_selection_t.sub (method) -ida_graph.selection_item_t (class) -ida_graph.selection_item_t.__eq__ (method) -ida_graph.selection_item_t.__init__ (method) -ida_graph.selection_item_t.__lt__ (method) -ida_graph.selection_item_t.__ne__ (method) -ida_graph.selection_item_t.compare (method) -ida_graph.selection_item_t.elp (variable) -ida_graph.selection_item_t.is_node (variable) -ida_graph.selection_item_t.node (variable) -ida_graph.set_node_info (function) -ida_graph.set_viewer_graph (function) -ida_graph.user_graph_place_t (class) -ida_graph.user_graph_place_t.__init__ (method) -ida_graph.viewer_attach_menu_item (function) -ida_graph.viewer_center_on (function) -ida_graph.viewer_create_groups (function) -ida_graph.viewer_del_node_info (function) -ida_graph.viewer_delete_groups (function) -ida_graph.viewer_fit_window (function) -ida_graph.viewer_get_curnode (function) -ida_graph.viewer_get_gli (function) -ida_graph.viewer_get_node_info (function) -ida_graph.viewer_get_selection (function) -ida_graph.viewer_set_gli (function) -ida_graph.viewer_set_groups_visibility (function) -ida_graph.viewer_set_node_info (function) -ida_graph.viewer_set_titlebar_height (function) -ida_ida (module) -ida_ida.ABI_8ALIGN4 (variable) -ida_ida.ABI_BIGARG_ALIGN (variable) -ida_ida.ABI_GCC_LAYOUT (variable) -ida_ida.ABI_HARD_FLOAT (variable) -ida_ida.ABI_HUGEARG_ALIGN (variable) -ida_ida.ABI_MAP_STKARGS (variable) -ida_ida.ABI_PACK_STKARGS (variable) -ida_ida.ABI_SET_BY_USER (variable) -ida_ida.ABI_STACK_LDBL (variable) -ida_ida.ABI_STACK_VARARGS (variable) -ida_ida.AF2_DOEH (variable) -ida_ida.AF2_DORTTI (variable) -ida_ida.AF2_MACRO (variable) -ida_ida.AF_ANORET (variable) -ida_ida.AF_CHKUNI (variable) -ida_ida.AF_CODE (variable) -ida_ida.AF_DATOFF (variable) -ida_ida.AF_DOCODE (variable) -ida_ida.AF_DODATA (variable) -ida_ida.AF_DREFOFF (variable) -ida_ida.AF_FINAL (variable) -ida_ida.AF_FIXUP (variable) -ida_ida.AF_FLIRT (variable) -ida_ida.AF_FTAIL (variable) -ida_ida.AF_HFLIRT (variable) -ida_ida.AF_IMMOFF (variable) -ida_ida.AF_JFUNC (variable) -ida_ida.AF_JUMPTBL (variable) -ida_ida.AF_LVAR (variable) -ida_ida.AF_MARKCODE (variable) -ida_ida.AF_MEMFUNC (variable) -ida_ida.AF_NULLSUB (variable) -ida_ida.AF_PROC (variable) -ida_ida.AF_PROCPTR (variable) -ida_ida.AF_PURDAT (variable) -ida_ida.AF_REGARG (variable) -ida_ida.AF_SIGCMT (variable) -ida_ida.AF_SIGMLT (variable) -ida_ida.AF_STKARG (variable) -ida_ida.AF_STRLIT (variable) -ida_ida.AF_TRACE (variable) -ida_ida.AF_TRFUNC (variable) -ida_ida.AF_UNK (variable) -ida_ida.AF_USED (variable) -ida_ida.AF_VERSP (variable) -ida_ida.DEMNAM_CMNT (variable) -ida_ida.DEMNAM_FIRST (variable) -ida_ida.DEMNAM_GCC3 (variable) -ida_ida.DEMNAM_MASK (variable) -ida_ida.DEMNAM_NAME (variable) -ida_ida.DEMNAM_NONE (variable) -ida_ida.IDAINFO_TAG_SIZE (variable) -ida_ida.IDB_COMPRESSED (variable) -ida_ida.IDB_PACKED (variable) -ida_ida.IDB_UNPACKED (variable) -ida_ida.INFFL_ALLASM (variable) -ida_ida.INFFL_AUTO (variable) -ida_ida.INFFL_CHKOPS (variable) -ida_ida.INFFL_GRAPH_VIEW (variable) -ida_ida.INFFL_LOADIDC (variable) -ida_ida.INFFL_NMOPS (variable) -ida_ida.INFFL_NOUSER (variable) -ida_ida.INFFL_READONLY (variable) -ida_ida.INF_ABINAME (variable) -ida_ida.INF_ARCHIVE_PATH (variable) -ida_ida.INF_CRC32 (variable) -ida_ida.INF_CTIME (variable) -ida_ida.INF_C_MACROS (variable) -ida_ida.INF_DBG_BINPATHS (variable) -ida_ida.INF_DUALOP_GRAPH (variable) -ida_ida.INF_DUALOP_TEXT (variable) -ida_ida.INF_ELAPSED (variable) -ida_ida.INF_FILE_FORMAT_NAME (variable) -ida_ida.INF_FSIZE (variable) -ida_ida.INF_GROUPS (variable) -ida_ida.INF_H_PATH (variable) -ida_ida.INF_IDA_VERSION (variable) -ida_ida.INF_IDSNODE (variable) -ida_ida.INF_IMAGEBASE (variable) -ida_ida.INF_INCLUDE (variable) -ida_ida.INF_INITIAL_VERSION (variable) -ida_ida.INF_MD5 (variable) -ida_ida.INF_NOPENS (variable) -ida_ida.INF_NOTEPAD (variable) -ida_ida.INF_OUTFILEENC (variable) -ida_ida.INF_PROBLEMS (variable) -ida_ida.INF_SELECTORS (variable) -ida_ida.INF_SHA256 (variable) -ida_ida.INF_SRCDBG_PATHS (variable) -ida_ida.INF_SRCDBG_UNDESIRED (variable) -ida_ida.INF_STR_ENCODINGS (variable) -ida_ida.LFLG_64BIT (variable) -ida_ida.LFLG_COMPRESS (variable) -ida_ida.LFLG_DBG_NOPATH (variable) -ida_ida.LFLG_FLAT_OFF32 (variable) -ida_ida.LFLG_IS_DLL (variable) -ida_ida.LFLG_KERNMODE (variable) -ida_ida.LFLG_MSF (variable) -ida_ida.LFLG_PACK (variable) -ida_ida.LFLG_PC_FLAT (variable) -ida_ida.LFLG_PC_FPP (variable) -ida_ida.LFLG_SNAPSHOT (variable) -ida_ida.LFLG_WIDE_HBF (variable) -ida_ida.LMT_EMPTY (variable) -ida_ida.LMT_THICK (variable) -ida_ida.LMT_THIN (variable) -ida_ida.LN_AUTO (variable) -ida_ida.LN_NORMAL (variable) -ida_ida.LN_PUBLIC (variable) -ida_ida.LN_WEAK (variable) -ida_ida.OFLG_GEN_ASSUME (variable) -ida_ida.OFLG_GEN_NULL (variable) -ida_ida.OFLG_GEN_ORG (variable) -ida_ida.OFLG_GEN_TRYBLKS (variable) -ida_ida.OFLG_LZERO (variable) -ida_ida.OFLG_PREF_SEG (variable) -ida_ida.OFLG_SHOW_AUTO (variable) -ida_ida.OFLG_SHOW_PREF (variable) -ida_ida.OFLG_SHOW_VOID (variable) -ida_ida.PREF_FNCOFF (variable) -ida_ida.PREF_PFXTRUNC (variable) -ida_ida.PREF_SEGADR (variable) -ida_ida.PREF_STACK (variable) -ida_ida.SCF_ALLCMT (variable) -ida_ida.SCF_LINNUM (variable) -ida_ida.SCF_NOCMT (variable) -ida_ida.SCF_RPTCMT (variable) -ida_ida.SCF_SHHID_FUNC (variable) -ida_ida.SCF_SHHID_ITEM (variable) -ida_ida.SCF_SHHID_SEGM (variable) -ida_ida.SCF_TESTMODE (variable) -ida_ida.STRF_AUTO (variable) -ida_ida.STRF_COMMENT (variable) -ida_ida.STRF_GEN (variable) -ida_ida.STRF_SAVECASE (variable) -ida_ida.STRF_SERIAL (variable) -ida_ida.STRF_UNICODE (variable) -ida_ida.STT_CUR (variable) -ida_ida.STT_DBG (variable) -ida_ida.STT_MM (variable) -ida_ida.STT_VA (variable) -ida_ida.SW_SEGXRF (variable) -ida_ida.SW_XRFFNC (variable) -ida_ida.SW_XRFMRK (variable) -ida_ida.SW_XRFVAL (variable) -ida_ida.UA_MAXOP (variable) -ida_ida.VLD_AUTO_REPAIR (variable) -ida_ida.VLD_DIALOG (variable) -ida_ida.VLD_SILENT (variable) -ida_ida.__make_idainfo_accessors (function) -ida_ida.__make_idainfo_bound (function) -ida_ida.__make_idainfo_bound.__func (function) -ida_ida.__make_idainfo_getter (function) -ida_ida.__set_module_dynattrs (function) -ida_ida.__wrap_hooks_callback (function) -ida_ida.__wrap_hooks_callback.__wrapper (function) -ida_ida.calc_default_idaplace_flags (function) -ida_ida.compiler_info_t (class) -ida_ida.compiler_info_t.__init__ (method) -ida_ida.compiler_info_t.cm (variable) -ida_ida.compiler_info_t.defalign (variable) -ida_ida.compiler_info_t.id (variable) -ida_ida.compiler_info_t.size_b (variable) -ida_ida.compiler_info_t.size_e (variable) -ida_ida.compiler_info_t.size_i (variable) -ida_ida.compiler_info_t.size_l (variable) -ida_ida.compiler_info_t.size_ldbl (variable) -ida_ida.compiler_info_t.size_ll (variable) -ida_ida.compiler_info_t.size_s (variable) -ida_ida.delinf (function) -ida_ida.f_AIXAR (variable) -ida_ida.f_AOUT (variable) -ida_ida.f_AR (variable) -ida_ida.f_BIN (variable) -ida_ida.f_COFF (variable) -ida_ida.f_COM (variable) -ida_ida.f_COM_old (variable) -ida_ida.f_DRV (variable) -ida_ida.f_ELF (variable) -ida_ida.f_EXE (variable) -ida_ida.f_EXE_old (variable) -ida_ida.f_HEX (variable) -ida_ida.f_LE (variable) -ida_ida.f_LOADER (variable) -ida_ida.f_LX (variable) -ida_ida.f_MACHO (variable) -ida_ida.f_MEX (variable) -ida_ida.f_NLM (variable) -ida_ida.f_OMF (variable) -ida_ida.f_OMFLIB (variable) -ida_ida.f_PE (variable) -ida_ida.f_PRC (variable) -ida_ida.f_PSXOBJ (variable) -ida_ida.f_SREC (variable) -ida_ida.f_W32RUN (variable) -ida_ida.f_WIN (variable) -ida_ida.f_ZIP (variable) -ida_ida.get_dbctx_id (function) -ida_ida.get_dbctx_qty (function) -ida_ida.getinf_str (function) -ida_ida.idainfo (class) -ida_ida.idainfo.__init__ (method) -ida_ida.idainfo._get_lflags (method) -ida_ida.idainfo._set_lflags (method) -ida_ida.idainfo.abibits (variable) -ida_ida.idainfo.af (variable) -ida_ida.idainfo.af2 (variable) -ida_ida.idainfo.appcall_options (variable) -ida_ida.idainfo.apptype (variable) -ida_ida.idainfo.asmtype (variable) -ida_ida.idainfo.baseaddr (variable) -ida_ida.idainfo.bin_prefix_size (variable) -ida_ida.idainfo.cc (variable) -ida_ida.idainfo.cmt_indent (variable) -ida_ida.idainfo.database_change_count (variable) -ida_ida.idainfo.datatypes (variable) -ida_ida.idainfo.demnames (variable) -ida_ida.idainfo.filetype (variable) -ida_ida.idainfo.get_abiname (method) -ida_ida.idainfo.highoff (variable) -ida_ida.idainfo.indent (variable) -ida_ida.idainfo.lenxref (variable) -ida_ida.idainfo.lflags (variable) -ida_ida.idainfo.listnames (variable) -ida_ida.idainfo.long_demnames (variable) -ida_ida.idainfo.lowoff (variable) -ida_ida.idainfo.main (variable) -ida_ida.idainfo.margin (variable) -ida_ida.idainfo.max_autoname_len (variable) -ida_ida.idainfo.max_ea (variable) -ida_ida.idainfo.maxref (variable) -ida_ida.idainfo.min_ea (variable) -ida_ida.idainfo.nametype (variable) -ida_ida.idainfo.omax_ea (variable) -ida_ida.idainfo.omin_ea (variable) -ida_ida.idainfo.ostype (variable) -ida_ida.idainfo.outflags (variable) -ida_ida.idainfo.procname (variable) -ida_ida.idainfo.refcmtnum (variable) -ida_ida.idainfo.s_cmtflg (variable) -ida_ida.idainfo.s_genflags (variable) -ida_ida.idainfo.s_limiter (variable) -ida_ida.idainfo.s_prefflag (variable) -ida_ida.idainfo.s_xrefflag (variable) -ida_ida.idainfo.short_demnames (variable) -ida_ida.idainfo.specsegs (variable) -ida_ida.idainfo.start_cs (variable) -ida_ida.idainfo.start_ea (variable) -ida_ida.idainfo.start_ip (variable) -ida_ida.idainfo.start_sp (variable) -ida_ida.idainfo.start_ss (variable) -ida_ida.idainfo.strlit_break (variable) -ida_ida.idainfo.strlit_flags (variable) -ida_ida.idainfo.strlit_pref (variable) -ida_ida.idainfo.strlit_sernum (variable) -ida_ida.idainfo.strlit_zeroes (variable) -ida_ida.idainfo.strtype (variable) -ida_ida.idainfo.tag (variable) -ida_ida.idainfo.type_xrefnum (variable) -ida_ida.idainfo.version (variable) -ida_ida.idainfo.xrefnum (variable) -ida_ida.idainfo_is_32bit (function) -ida_ida.inf_abi_set_by_user (function) -ida_ida.inf_allow_non_matched_ops (function) -ida_ida.inf_allow_sigmulti (function) -ida_ida.inf_append_sigcmt (function) -ida_ida.inf_big_arg_align (function) -ida_ida.inf_check_manual_ops (function) -ida_ida.inf_check_unicode_strlits (function) -ida_ida.inf_coagulate_code (function) -ida_ida.inf_coagulate_data (function) -ida_ida.inf_compress_idb (function) -ida_ida.inf_create_all_xrefs (function) -ida_ida.inf_create_func_from_call (function) -ida_ida.inf_create_func_from_ptr (function) -ida_ida.inf_create_func_tails (function) -ida_ida.inf_create_jump_tables (function) -ida_ida.inf_create_off_on_dref (function) -ida_ida.inf_create_off_using_fixup (function) -ida_ida.inf_create_strlit_on_xref (function) -ida_ida.inf_data_offset (function) -ida_ida.inf_dbg_no_store_path (function) -ida_ida.inf_decode_fpp (function) -ida_ida.inf_del_no_xref_insns (function) -ida_ida.inf_final_pass (function) -ida_ida.inf_full_sp_ana (function) -ida_ida.inf_gen_assume (function) -ida_ida.inf_gen_lzero (function) -ida_ida.inf_gen_null (function) -ida_ida.inf_gen_org (function) -ida_ida.inf_gen_tryblks (function) -ida_ida.inf_get_abibits (function) -ida_ida.inf_get_af (function) -ida_ida.inf_get_af2 (function) -ida_ida.inf_get_af2_low (function) -ida_ida.inf_get_af_high (function) -ida_ida.inf_get_af_low (function) -ida_ida.inf_get_app_bitness (function) -ida_ida.inf_get_appcall_options (function) -ida_ida.inf_get_apptype (function) -ida_ida.inf_get_asmtype (function) -ida_ida.inf_get_baseaddr (function) -ida_ida.inf_get_bin_prefix_size (function) -ida_ida.inf_get_cc (function) -ida_ida.inf_get_cc_cm (function) -ida_ida.inf_get_cc_defalign (function) -ida_ida.inf_get_cc_id (function) -ida_ida.inf_get_cc_size_b (function) -ida_ida.inf_get_cc_size_e (function) -ida_ida.inf_get_cc_size_i (function) -ida_ida.inf_get_cc_size_l (function) -ida_ida.inf_get_cc_size_ldbl (function) -ida_ida.inf_get_cc_size_ll (function) -ida_ida.inf_get_cc_size_s (function) -ida_ida.inf_get_cmt_indent (function) -ida_ida.inf_get_cmtflg (function) -ida_ida.inf_get_database_change_count (function) -ida_ida.inf_get_datatypes (function) -ida_ida.inf_get_demname_form (function) -ida_ida.inf_get_demnames (function) -ida_ida.inf_get_filetype (function) -ida_ida.inf_get_genflags (function) -ida_ida.inf_get_highoff (function) -ida_ida.inf_get_indent (function) -ida_ida.inf_get_lenxref (function) -ida_ida.inf_get_lflags (function) -ida_ida.inf_get_limiter (function) -ida_ida.inf_get_listnames (function) -ida_ida.inf_get_long_demnames (function) -ida_ida.inf_get_lowoff (function) -ida_ida.inf_get_main (function) -ida_ida.inf_get_margin (function) -ida_ida.inf_get_max_autoname_len (function) -ida_ida.inf_get_max_ea (function) -ida_ida.inf_get_maxref (function) -ida_ida.inf_get_min_ea (function) -ida_ida.inf_get_nametype (function) -ida_ida.inf_get_netdelta (function) -ida_ida.inf_get_omax_ea (function) -ida_ida.inf_get_omin_ea (function) -ida_ida.inf_get_ostype (function) -ida_ida.inf_get_outflags (function) -ida_ida.inf_get_pack_mode (function) -ida_ida.inf_get_prefflag (function) -ida_ida.inf_get_privrange (function) -ida_ida.inf_get_privrange_end_ea (function) -ida_ida.inf_get_privrange_start_ea (function) -ida_ida.inf_get_procname (function) -ida_ida.inf_get_refcmtnum (function) -ida_ida.inf_get_short_demnames (function) -ida_ida.inf_get_specsegs (function) -ida_ida.inf_get_start_cs (function) -ida_ida.inf_get_start_ea (function) -ida_ida.inf_get_start_ip (function) -ida_ida.inf_get_start_sp (function) -ida_ida.inf_get_start_ss (function) -ida_ida.inf_get_strlit_break (function) -ida_ida.inf_get_strlit_flags (function) -ida_ida.inf_get_strlit_pref (function) -ida_ida.inf_get_strlit_sernum (function) -ida_ida.inf_get_strlit_zeroes (function) -ida_ida.inf_get_strtype (function) -ida_ida.inf_get_type_xrefnum (function) -ida_ida.inf_get_version (function) -ida_ida.inf_get_xrefflag (function) -ida_ida.inf_get_xrefnum (function) -ida_ida.inf_guess_func_type (function) -ida_ida.inf_handle_eh (function) -ida_ida.inf_handle_rtti (function) -ida_ida.inf_hide_comments (function) -ida_ida.inf_hide_libfuncs (function) -ida_ida.inf_huge_arg_align (function) -ida_ida.inf_inc_database_change_count (function) -ida_ida.inf_is_16bit (function) -ida_ida.inf_is_32bit_exactly (function) -ida_ida.inf_is_32bit_or_higher (function) -ida_ida.inf_is_64bit (function) -ida_ida.inf_is_auto_enabled (function) -ida_ida.inf_is_be (function) -ida_ida.inf_is_dll (function) -ida_ida.inf_is_flat_off32 (function) -ida_ida.inf_is_graph_view (function) -ida_ida.inf_is_hard_float (function) -ida_ida.inf_is_kernel_mode (function) -ida_ida.inf_is_limiter_empty (function) -ida_ida.inf_is_limiter_thick (function) -ida_ida.inf_is_limiter_thin (function) -ida_ida.inf_is_mem_aligned4 (function) -ida_ida.inf_is_snapshot (function) -ida_ida.inf_is_wide_high_byte_first (function) -ida_ida.inf_like_binary (function) -ida_ida.inf_line_pref_with_seg (function) -ida_ida.inf_loading_idc (function) -ida_ida.inf_macros_enabled (function) -ida_ida.inf_map_stkargs (function) -ida_ida.inf_mark_code (function) -ida_ida.inf_no_store_user_info (function) -ida_ida.inf_noflow_to_data (function) -ida_ida.inf_noret_ana (function) -ida_ida.inf_op_offset (function) -ida_ida.inf_pack_idb (function) -ida_ida.inf_pack_stkargs (function) -ida_ida.inf_postinc_strlit_sernum (function) -ida_ida.inf_prefix_show_funcoff (function) -ida_ida.inf_prefix_show_segaddr (function) -ida_ida.inf_prefix_show_stack (function) -ida_ida.inf_prefix_truncate_opcode_bytes (function) -ida_ida.inf_propagate_regargs (function) -ida_ida.inf_propagate_stkargs (function) -ida_ida.inf_readonly_idb (function) -ida_ida.inf_rename_jumpfunc (function) -ida_ida.inf_rename_nullsub (function) -ida_ida.inf_set_32bit (function) -ida_ida.inf_set_64bit (function) -ida_ida.inf_set_abi_set_by_user (function) -ida_ida.inf_set_abibits (function) -ida_ida.inf_set_af (function) -ida_ida.inf_set_af2 (function) -ida_ida.inf_set_af2_low (function) -ida_ida.inf_set_af_high (function) -ida_ida.inf_set_af_low (function) -ida_ida.inf_set_allow_non_matched_ops (function) -ida_ida.inf_set_allow_sigmulti (function) -ida_ida.inf_set_app_bitness (function) -ida_ida.inf_set_appcall_options (function) -ida_ida.inf_set_append_sigcmt (function) -ida_ida.inf_set_apptype (function) -ida_ida.inf_set_asmtype (function) -ida_ida.inf_set_auto_enabled (function) -ida_ida.inf_set_baseaddr (function) -ida_ida.inf_set_be (function) -ida_ida.inf_set_big_arg_align (function) -ida_ida.inf_set_bin_prefix_size (function) -ida_ida.inf_set_cc (function) -ida_ida.inf_set_cc_cm (function) -ida_ida.inf_set_cc_defalign (function) -ida_ida.inf_set_cc_id (function) -ida_ida.inf_set_cc_size_b (function) -ida_ida.inf_set_cc_size_e (function) -ida_ida.inf_set_cc_size_i (function) -ida_ida.inf_set_cc_size_l (function) -ida_ida.inf_set_cc_size_ldbl (function) -ida_ida.inf_set_cc_size_ll (function) -ida_ida.inf_set_cc_size_s (function) -ida_ida.inf_set_check_manual_ops (function) -ida_ida.inf_set_check_unicode_strlits (function) -ida_ida.inf_set_cmt_indent (function) -ida_ida.inf_set_cmtflg (function) -ida_ida.inf_set_coagulate_code (function) -ida_ida.inf_set_coagulate_data (function) -ida_ida.inf_set_compress_idb (function) -ida_ida.inf_set_create_all_xrefs (function) -ida_ida.inf_set_create_func_from_call (function) -ida_ida.inf_set_create_func_from_ptr (function) -ida_ida.inf_set_create_func_tails (function) -ida_ida.inf_set_create_jump_tables (function) -ida_ida.inf_set_create_off_on_dref (function) -ida_ida.inf_set_create_off_using_fixup (function) -ida_ida.inf_set_create_strlit_on_xref (function) -ida_ida.inf_set_data_offset (function) -ida_ida.inf_set_database_change_count (function) -ida_ida.inf_set_datatypes (function) -ida_ida.inf_set_dbg_no_store_path (function) -ida_ida.inf_set_decode_fpp (function) -ida_ida.inf_set_del_no_xref_insns (function) -ida_ida.inf_set_demnames (function) -ida_ida.inf_set_dll (function) -ida_ida.inf_set_filetype (function) -ida_ida.inf_set_final_pass (function) -ida_ida.inf_set_flat_off32 (function) -ida_ida.inf_set_full_sp_ana (function) -ida_ida.inf_set_gen_assume (function) -ida_ida.inf_set_gen_lzero (function) -ida_ida.inf_set_gen_null (function) -ida_ida.inf_set_gen_org (function) -ida_ida.inf_set_gen_tryblks (function) -ida_ida.inf_set_genflags (function) -ida_ida.inf_set_graph_view (function) -ida_ida.inf_set_guess_func_type (function) -ida_ida.inf_set_handle_eh (function) -ida_ida.inf_set_handle_rtti (function) -ida_ida.inf_set_hard_float (function) -ida_ida.inf_set_hide_comments (function) -ida_ida.inf_set_hide_libfuncs (function) -ida_ida.inf_set_highoff (function) -ida_ida.inf_set_huge_arg_align (function) -ida_ida.inf_set_indent (function) -ida_ida.inf_set_kernel_mode (function) -ida_ida.inf_set_lenxref (function) -ida_ida.inf_set_lflags (function) -ida_ida.inf_set_limiter (function) -ida_ida.inf_set_limiter_empty (function) -ida_ida.inf_set_limiter_thick (function) -ida_ida.inf_set_limiter_thin (function) -ida_ida.inf_set_line_pref_with_seg (function) -ida_ida.inf_set_listnames (function) -ida_ida.inf_set_loading_idc (function) -ida_ida.inf_set_long_demnames (function) -ida_ida.inf_set_lowoff (function) -ida_ida.inf_set_macros_enabled (function) -ida_ida.inf_set_main (function) -ida_ida.inf_set_map_stkargs (function) -ida_ida.inf_set_margin (function) -ida_ida.inf_set_mark_code (function) -ida_ida.inf_set_max_autoname_len (function) -ida_ida.inf_set_max_ea (function) -ida_ida.inf_set_maxref (function) -ida_ida.inf_set_mem_aligned4 (function) -ida_ida.inf_set_min_ea (function) -ida_ida.inf_set_nametype (function) -ida_ida.inf_set_netdelta (function) -ida_ida.inf_set_no_store_user_info (function) -ida_ida.inf_set_noflow_to_data (function) -ida_ida.inf_set_noret_ana (function) -ida_ida.inf_set_omax_ea (function) -ida_ida.inf_set_omin_ea (function) -ida_ida.inf_set_op_offset (function) -ida_ida.inf_set_ostype (function) -ida_ida.inf_set_outflags (function) -ida_ida.inf_set_pack_idb (function) -ida_ida.inf_set_pack_mode (function) -ida_ida.inf_set_pack_stkargs (function) -ida_ida.inf_set_prefflag (function) -ida_ida.inf_set_prefix_show_funcoff (function) -ida_ida.inf_set_prefix_show_segaddr (function) -ida_ida.inf_set_prefix_show_stack (function) -ida_ida.inf_set_prefix_truncate_opcode_bytes (function) -ida_ida.inf_set_privrange (function) -ida_ida.inf_set_privrange_end_ea (function) -ida_ida.inf_set_privrange_start_ea (function) -ida_ida.inf_set_procname (function) -ida_ida.inf_set_propagate_regargs (function) -ida_ida.inf_set_propagate_stkargs (function) -ida_ida.inf_set_readonly_idb (function) -ida_ida.inf_set_refcmtnum (function) -ida_ida.inf_set_rename_jumpfunc (function) -ida_ida.inf_set_rename_nullsub (function) -ida_ida.inf_set_short_demnames (function) -ida_ida.inf_set_should_create_stkvars (function) -ida_ida.inf_set_should_trace_sp (function) -ida_ida.inf_set_show_all_comments (function) -ida_ida.inf_set_show_auto (function) -ida_ida.inf_set_show_hidden_funcs (function) -ida_ida.inf_set_show_hidden_insns (function) -ida_ida.inf_set_show_hidden_segms (function) -ida_ida.inf_set_show_line_pref (function) -ida_ida.inf_set_show_repeatables (function) -ida_ida.inf_set_show_src_linnum (function) -ida_ida.inf_set_show_void (function) -ida_ida.inf_set_show_xref_fncoff (function) -ida_ida.inf_set_show_xref_seg (function) -ida_ida.inf_set_show_xref_tmarks (function) -ida_ida.inf_set_show_xref_val (function) -ida_ida.inf_set_snapshot (function) -ida_ida.inf_set_specsegs (function) -ida_ida.inf_set_stack_ldbl (function) -ida_ida.inf_set_stack_varargs (function) -ida_ida.inf_set_start_cs (function) -ida_ida.inf_set_start_ea (function) -ida_ida.inf_set_start_ip (function) -ida_ida.inf_set_start_sp (function) -ida_ida.inf_set_start_ss (function) -ida_ida.inf_set_strlit_autocmt (function) -ida_ida.inf_set_strlit_break (function) -ida_ida.inf_set_strlit_flags (function) -ida_ida.inf_set_strlit_name_bit (function) -ida_ida.inf_set_strlit_names (function) -ida_ida.inf_set_strlit_pref (function) -ida_ida.inf_set_strlit_savecase (function) -ida_ida.inf_set_strlit_serial_names (function) -ida_ida.inf_set_strlit_sernum (function) -ida_ida.inf_set_strlit_zeroes (function) -ida_ida.inf_set_strtype (function) -ida_ida.inf_set_trace_flow (function) -ida_ida.inf_set_truncate_on_del (function) -ida_ida.inf_set_type_xrefnum (function) -ida_ida.inf_set_unicode_strlits (function) -ida_ida.inf_set_use_allasm (function) -ida_ida.inf_set_use_flirt (function) -ida_ida.inf_set_use_gcc_layout (function) -ida_ida.inf_set_version (function) -ida_ida.inf_set_wide_high_byte_first (function) -ida_ida.inf_set_xrefflag (function) -ida_ida.inf_set_xrefnum (function) -ida_ida.inf_should_create_stkvars (function) -ida_ida.inf_should_trace_sp (function) -ida_ida.inf_show_all_comments (function) -ida_ida.inf_show_auto (function) -ida_ida.inf_show_hidden_funcs (function) -ida_ida.inf_show_hidden_insns (function) -ida_ida.inf_show_hidden_segms (function) -ida_ida.inf_show_line_pref (function) -ida_ida.inf_show_repeatables (function) -ida_ida.inf_show_src_linnum (function) -ida_ida.inf_show_void (function) -ida_ida.inf_show_xref_fncoff (function) -ida_ida.inf_show_xref_seg (function) -ida_ida.inf_show_xref_tmarks (function) -ida_ida.inf_show_xref_val (function) -ida_ida.inf_stack_ldbl (function) -ida_ida.inf_stack_varargs (function) -ida_ida.inf_strlit_autocmt (function) -ida_ida.inf_strlit_name_bit (function) -ida_ida.inf_strlit_names (function) -ida_ida.inf_strlit_savecase (function) -ida_ida.inf_strlit_serial_names (function) -ida_ida.inf_test_mode (function) -ida_ida.inf_trace_flow (function) -ida_ida.inf_truncate_on_del (function) -ida_ida.inf_unicode_strlits (function) -ida_ida.inf_use_allasm (function) -ida_ida.inf_use_flirt (function) -ida_ida.inf_use_gcc_layout (function) -ida_ida.is_database_busy (function) -ida_ida.is_filetype_like_binary (function) -ida_ida.move_privrange (function) -ida_ida.switch_dbctx (function) -ida_ida.to_ea (function) -ida_ida.validate_idb (function) -ida_idaapi (module) -ida_idaapi.IDAPython_ExecScript (function) -ida_idaapi.IDAPython_ExecSystem (function) -ida_idaapi.IDAPython_FormatExc (function) -ida_idaapi.IDAPython_LoadProcMod (function) -ida_idaapi.IDAPython_UnLoadProcMod (function) -ida_idaapi.IDAPython_displayhook (class) -ida_idaapi.IDAPython_displayhook.__init__ (method) -ida_idaapi.IDAPython_displayhook._print_hex (method) -ida_idaapi.IDAPython_displayhook.displayhook (method) -ida_idaapi.IDAPython_displayhook.format_item (method) -ida_idaapi.IDAPython_displayhook.format_seq (method) -ida_idaapi.NW_CLOSEIDB (variable) -ida_idaapi.NW_INITIDA (variable) -ida_idaapi.NW_OPENIDB (variable) -ida_idaapi.NW_REMOVE (variable) -ida_idaapi.NW_TERMIDA (variable) -ida_idaapi.PY_ICID_BYREF (variable) -ida_idaapi.PY_ICID_INT64 (variable) -ida_idaapi.PY_ICID_OPAQUE (variable) -ida_idaapi.PyIdc_cvt_int64__ (class) -ida_idaapi.PyIdc_cvt_int64__.__add__ (method) -ida_idaapi.PyIdc_cvt_int64__.__div__ (method) -ida_idaapi.PyIdc_cvt_int64__.__init__ (method) -ida_idaapi.PyIdc_cvt_int64__.__mul__ (method) -ida_idaapi.PyIdc_cvt_int64__.__op (method) -ida_idaapi.PyIdc_cvt_int64__.__radd__ (method) -ida_idaapi.PyIdc_cvt_int64__.__rdiv__ (method) -ida_idaapi.PyIdc_cvt_int64__.__rmul__ (method) -ida_idaapi.PyIdc_cvt_int64__.__rsub__ (method) -ida_idaapi.PyIdc_cvt_int64__.__sub__ (method) -ida_idaapi.PyIdc_cvt_refclass__ (class) -ida_idaapi.PyIdc_cvt_refclass__.__init__ (method) -ida_idaapi.PyIdc_cvt_refclass__.cstr (method) -ida_idaapi.ST_OVER_DEBUG_SEG (variable) -ida_idaapi.ST_OVER_LIB_FUNC (variable) -ida_idaapi.TRUNC (function) -ida_idaapi.__IDAPython_Completion_Util (class) -ida_idaapi.__IDAPython_Completion_Util.__call__ (method) -ida_idaapi.__IDAPython_Completion_Util.__init__ (method) -ida_idaapi.__IDAPython_Completion_Util.debug (method) -ida_idaapi.__IDAPython_Completion_Util.dir_namespace (method) -ida_idaapi.__IDAPython_Completion_Util.get_candidates (method) -ida_idaapi.__IDAPython_Completion_Util.maybe_extend_syntactically (method) -ida_idaapi.__install_excepthook (function) -ida_idaapi._bounded_getitem_iterator (function) -ida_idaapi._listify_types (function) -ida_idaapi._make_missed_695bwcompat_property (function) -ida_idaapi._make_missed_695bwcompat_property._getter (function) -ida_idaapi._make_missed_695bwcompat_property._setter (function) -ida_idaapi._make_one_time_warning_message (function) -ida_idaapi._make_one_time_warning_message.f (function) -ida_idaapi._qvector_back (function) -ida_idaapi._qvector_front (function) -ida_idaapi._replace_module_function (function) -ida_idaapi.as_UTF16 (function) -ida_idaapi.as_cstr (function) -ida_idaapi.as_int32 (function) -ida_idaapi.as_signed (function) -ida_idaapi.as_uint32 (function) -ida_idaapi.copy_bits (function) -ida_idaapi.disable_script_timeout (function) -ida_idaapi.enable_extlang_python (function) -ida_idaapi.enable_python_cli (function) -ida_idaapi.format_basestring (function) -ida_idaapi.get_inf_structure (function) -ida_idaapi.loader_input_t (class) -ida_idaapi.loader_input_t.__init__ (method) -ida_idaapi.loader_input_t.close (method) -ida_idaapi.loader_input_t.file2base (method) -ida_idaapi.loader_input_t.filename (method) -ida_idaapi.loader_input_t.from_capsule (method) -ida_idaapi.loader_input_t.from_fp (method) -ida_idaapi.loader_input_t.from_linput (method) -ida_idaapi.loader_input_t.get_byte (method) -ida_idaapi.loader_input_t.get_linput (method) -ida_idaapi.loader_input_t.gets (method) -ida_idaapi.loader_input_t.getz (method) -ida_idaapi.loader_input_t.open (method) -ida_idaapi.loader_input_t.open_memory (method) -ida_idaapi.loader_input_t.opened (method) -ida_idaapi.loader_input_t.read (method) -ida_idaapi.loader_input_t.readbytes (method) -ida_idaapi.loader_input_t.seek (method) -ida_idaapi.loader_input_t.set_linput (method) -ida_idaapi.loader_input_t.size (method) -ida_idaapi.loader_input_t.tell (method) -ida_idaapi.loader_input_t_from_capsule (function) -ida_idaapi.loader_input_t_from_fp (function) -ida_idaapi.loader_input_t_from_linput (function) -ida_idaapi.notify_when (function) -ida_idaapi.object_t (class) -ida_idaapi.object_t.__getitem__ (method) -ida_idaapi.object_t.__init__ (method) -ida_idaapi.parse_command_line3 (function) -ida_idaapi.plugin_t (class) -ida_idaapi.plugin_t.run (method) -ida_idaapi.plugin_t.term (method) -ida_idaapi.plugmod_t (class) -ida_idaapi.py_clinked_object_t (class) -ida_idaapi.py_clinked_object_t.__del__ (method) -ida_idaapi.py_clinked_object_t.__init__ (method) -ida_idaapi.py_clinked_object_t._create_clink (method) -ida_idaapi.py_clinked_object_t._del_clink (method) -ida_idaapi.py_clinked_object_t._free (method) -ida_idaapi.py_clinked_object_t._get_clink_ptr (method) -ida_idaapi.py_clinked_object_t.assign (method) -ida_idaapi.py_clinked_object_t.clink (variable) -ida_idaapi.py_clinked_object_t.clink_ptr (variable) -ida_idaapi.py_clinked_object_t.copy (method) -ida_idaapi.pycim_get_widget (function) -ida_idaapi.pycim_view_close (function) -ida_idaapi.pygc_create_groups (function) -ida_idaapi.pygc_delete_groups (function) -ida_idaapi.pygc_refresh (function) -ida_idaapi.pygc_set_groups_visibility (function) -ida_idaapi.pyidc_cvt_helper__ (class) -ida_idaapi.pyidc_cvt_helper__.__get_value (method) -ida_idaapi.pyidc_cvt_helper__.__init__ (method) -ida_idaapi.pyidc_cvt_helper__.__set_value (method) -ida_idaapi.pyidc_opaque_object_t (class) -ida_idaapi.replfun (function) -ida_idaapi.require (function) -ida_idaapi.set_script_timeout (function) -ida_idaapi.struct_unpack (function) -ida_idc (module) -ida_idc.get_mark_comment (function) -ida_idc.get_marked_pos (function) -ida_idc.mark_position (function) -ida_idd (module) -ida_idd.APPCALL_DEBEV (variable) -ida_idd.APPCALL_MANUAL (variable) -ida_idd.APPCALL_TIMEOUT (variable) -ida_idd.Appcall__ (class) -ida_idd.Appcall__.APPCALL_DEBEV (variable) -ida_idd.Appcall__.APPCALL_MANUAL (variable) -ida_idd.Appcall__.APPCALL_TIMEOUT (variable) -ida_idd.Appcall__.Consts (variable) -ida_idd.Appcall__.UTF16 (method) -ida_idd.Appcall__.__get_consts (method) -ida_idd.Appcall__.__getattr__ (method) -ida_idd.Appcall__.__getitem__ (method) -ida_idd.Appcall__.__init__ (method) -ida_idd.Appcall__.__name_or_ea (method) -ida_idd.Appcall__.__typedecl_or_tinfo (method) -ida_idd.Appcall__.array (method) -ida_idd.Appcall__.buffer (method) -ida_idd.Appcall__.byref (method) -ida_idd.Appcall__.cleanup_appcall (method) -ida_idd.Appcall__.cstr (method) -ida_idd.Appcall__.get_appcall_options (method) -ida_idd.Appcall__.int64 (method) -ida_idd.Appcall__.obj (method) -ida_idd.Appcall__.proto (method) -ida_idd.Appcall__.set_appcall_options (method) -ida_idd.Appcall__.typedobj (method) -ida_idd.Appcall__.valueof (method) -ida_idd.Appcall_array__ (class) -ida_idd.Appcall_array__.__init__ (method) -ida_idd.Appcall_array__.pack (method) -ida_idd.Appcall_array__.try_to_convert_to_list (method) -ida_idd.Appcall_array__.unpack (method) -ida_idd.Appcall_callable__ (class) -ida_idd.Appcall_callable__.__call__ (method) -ida_idd.Appcall_callable__.__get_ea (method) -ida_idd.Appcall_callable__.__get_fields (method) -ida_idd.Appcall_callable__.__get_options (method) -ida_idd.Appcall_callable__.__get_size (method) -ida_idd.Appcall_callable__.__get_tif (method) -ida_idd.Appcall_callable__.__get_timeout (method) -ida_idd.Appcall_callable__.__get_type (method) -ida_idd.Appcall_callable__.__init__ (method) -ida_idd.Appcall_callable__.__set_ea (method) -ida_idd.Appcall_callable__.__set_options (method) -ida_idd.Appcall_callable__.__set_timeout (method) -ida_idd.Appcall_callable__.ea (variable) -ida_idd.Appcall_callable__.fields (variable) -ida_idd.Appcall_callable__.options (variable) -ida_idd.Appcall_callable__.retrieve (method) -ida_idd.Appcall_callable__.size (variable) -ida_idd.Appcall_callable__.store (method) -ida_idd.Appcall_callable__.tif (variable) -ida_idd.Appcall_callable__.timeout (variable) -ida_idd.Appcall_callable__.type (variable) -ida_idd.Appcall_consts__ (class) -ida_idd.Appcall_consts__.__getattr__ (method) -ida_idd.Appcall_consts__.__init__ (method) -ida_idd.BPT_BAD_ADDR (variable) -ida_idd.BPT_BAD_ALIGN (variable) -ida_idd.BPT_BAD_LEN (variable) -ida_idd.BPT_BAD_TYPE (variable) -ida_idd.BPT_DEFAULT (variable) -ida_idd.BPT_EXEC (variable) -ida_idd.BPT_INTERNAL_ERR (variable) -ida_idd.BPT_OK (variable) -ida_idd.BPT_PAGE_OK (variable) -ida_idd.BPT_RDWR (variable) -ida_idd.BPT_READ (variable) -ida_idd.BPT_READ_ERROR (variable) -ida_idd.BPT_SKIP (variable) -ida_idd.BPT_SOFT (variable) -ida_idd.BPT_TOO_MANY (variable) -ida_idd.BPT_WRITE (variable) -ida_idd.BPT_WRITE_ERROR (variable) -ida_idd.BREAKPOINT (variable) -ida_idd.DBG_FLAG_ADD_ENVS (variable) -ida_idd.DBG_FLAG_ANYSIZE_HWBPT (variable) -ida_idd.DBG_FLAG_CAN_CONT_BPT (variable) -ida_idd.DBG_FLAG_CLEAN_EXIT (variable) -ida_idd.DBG_FLAG_CONNSTRING (variable) -ida_idd.DBG_FLAG_DEBTHREAD (variable) -ida_idd.DBG_FLAG_DEBUG_DLL (variable) -ida_idd.DBG_FLAG_DONT_DISTURB (variable) -ida_idd.DBG_FLAG_EXITSHOTOK (variable) -ida_idd.DBG_FLAG_FAKE_ATTACH (variable) -ida_idd.DBG_FLAG_FAKE_MEMORY (variable) -ida_idd.DBG_FLAG_FAST_STEP (variable) -ida_idd.DBG_FLAG_HWDATBPT_ONE (variable) -ida_idd.DBG_FLAG_LAZY_WATCHPTS (variable) -ida_idd.DBG_FLAG_LOWCNDS (variable) -ida_idd.DBG_FLAG_MANMEMINFO (variable) -ida_idd.DBG_FLAG_MERGE_ENVS (variable) -ida_idd.DBG_FLAG_NEEDPORT (variable) -ida_idd.DBG_FLAG_NOHOST (variable) -ida_idd.DBG_FLAG_NOPARAMETERS (variable) -ida_idd.DBG_FLAG_NOPASSWORD (variable) -ida_idd.DBG_FLAG_NOSTARTDIR (variable) -ida_idd.DBG_FLAG_PREFER_SWBPTS (variable) -ida_idd.DBG_FLAG_REMOTE (variable) -ida_idd.DBG_FLAG_SAFE (variable) -ida_idd.DBG_FLAG_SMALLBLKS (variable) -ida_idd.DBG_FLAG_TRACER_MODULE (variable) -ida_idd.DBG_FLAG_USE_SREGS (variable) -ida_idd.DBG_FLAG_VIRTHREADS (variable) -ida_idd.DBG_HAS_APPCALL (variable) -ida_idd.DBG_HAS_ATTACH_PROCESS (variable) -ida_idd.DBG_HAS_CHECK_BPT (variable) -ida_idd.DBG_HAS_DETACH_PROCESS (variable) -ida_idd.DBG_HAS_GET_PROCESSES (variable) -ida_idd.DBG_HAS_MAP_ADDRESS (variable) -ida_idd.DBG_HAS_OPEN_FILE (variable) -ida_idd.DBG_HAS_REQUEST_PAUSE (variable) -ida_idd.DBG_HAS_REXEC (variable) -ida_idd.DBG_HAS_SET_EXCEPTION_INFO (variable) -ida_idd.DBG_HAS_SET_RESUME_MODE (variable) -ida_idd.DBG_HAS_THREAD_CONTINUE (variable) -ida_idd.DBG_HAS_THREAD_GET_SREG_BASE (variable) -ida_idd.DBG_HAS_THREAD_SUSPEND (variable) -ida_idd.DBG_HAS_UPDATE_CALL_STACK (variable) -ida_idd.DBG_HIDE_WINDOW (variable) -ida_idd.DBG_NO_ASLR (variable) -ida_idd.DBG_NO_TRACE (variable) -ida_idd.DBG_PROC_32BIT (variable) -ida_idd.DBG_PROC_64BIT (variable) -ida_idd.DBG_PROC_IS_DLL (variable) -ida_idd.DBG_PROC_IS_GUI (variable) -ida_idd.DBG_RESMOD_STEP_HANDLE (variable) -ida_idd.DBG_RESMOD_STEP_INTO (variable) -ida_idd.DBG_RESMOD_STEP_OUT (variable) -ida_idd.DBG_RESMOD_STEP_OVER (variable) -ida_idd.DBG_RESMOD_STEP_SRCINTO (variable) -ida_idd.DBG_RESMOD_STEP_SRCOUT (variable) -ida_idd.DBG_RESMOD_STEP_SRCOVER (variable) -ida_idd.DBG_RESMOD_STEP_USER (variable) -ida_idd.DBG_SUSPENDED (variable) -ida_idd.DEBUGGER_ID_6811_EMULATOR (variable) -ida_idd.DEBUGGER_ID_ARM_IPHONE_USER (variable) -ida_idd.DEBUGGER_ID_ARM_LINUX_USER (variable) -ida_idd.DEBUGGER_ID_ARM_MACOS_USER (variable) -ida_idd.DEBUGGER_ID_DALVIK_USER (variable) -ida_idd.DEBUGGER_ID_GDB_USER (variable) -ida_idd.DEBUGGER_ID_TRACE_REPLAYER (variable) -ida_idd.DEBUGGER_ID_WINDBG (variable) -ida_idd.DEBUGGER_ID_X86_DOSBOX_EMULATOR (variable) -ida_idd.DEBUGGER_ID_X86_IA32_BOCHS (variable) -ida_idd.DEBUGGER_ID_X86_IA32_LINUX_USER (variable) -ida_idd.DEBUGGER_ID_X86_IA32_MACOSX_USER (variable) -ida_idd.DEBUGGER_ID_X86_IA32_WIN32_USER (variable) -ida_idd.DEBUGGER_ID_X86_PIN_TRACER (variable) -ida_idd.DEBUGGER_ID_XNU_USER (variable) -ida_idd.DRC_CRC (variable) -ida_idd.DRC_ERROR (variable) -ida_idd.DRC_EVENTS (variable) -ida_idd.DRC_FAILED (variable) -ida_idd.DRC_IDBSEG (variable) -ida_idd.DRC_NETERR (variable) -ida_idd.DRC_NOCHG (variable) -ida_idd.DRC_NOFILE (variable) -ida_idd.DRC_NONE (variable) -ida_idd.DRC_NOPROC (variable) -ida_idd.DRC_OK (variable) -ida_idd.EXCEPTION (variable) -ida_idd.EXC_BREAK (variable) -ida_idd.EXC_HANDLE (variable) -ida_idd.EXC_MSG (variable) -ida_idd.EXC_SILENT (variable) -ida_idd.IDD_INTERFACE_VERSION (variable) -ida_idd.INFORMATION (variable) -ida_idd.LIB_LOADED (variable) -ida_idd.LIB_UNLOADED (variable) -ida_idd.NO_EVENT (variable) -ida_idd.NO_PROCESS (variable) -ida_idd.NO_THREAD (variable) -ida_idd.PROCESS_ATTACHED (variable) -ida_idd.PROCESS_DETACHED (variable) -ida_idd.PROCESS_EXITED (variable) -ida_idd.PROCESS_STARTED (variable) -ida_idd.PROCESS_SUSPENDED (variable) -ida_idd.REGISTER_ADDRESS (variable) -ida_idd.REGISTER_CS (variable) -ida_idd.REGISTER_CUSTFMT (variable) -ida_idd.REGISTER_FP (variable) -ida_idd.REGISTER_IP (variable) -ida_idd.REGISTER_NOLF (variable) -ida_idd.REGISTER_READONLY (variable) -ida_idd.REGISTER_SP (variable) -ida_idd.REGISTER_SS (variable) -ida_idd.RESMOD_HANDLE (variable) -ida_idd.RESMOD_INTO (variable) -ida_idd.RESMOD_NONE (variable) -ida_idd.RESMOD_OUT (variable) -ida_idd.RESMOD_OVER (variable) -ida_idd.RESMOD_SRCINTO (variable) -ida_idd.RESMOD_SRCOUT (variable) -ida_idd.RESMOD_SRCOVER (variable) -ida_idd.RESMOD_USER (variable) -ida_idd.RVT_FLOAT (variable) -ida_idd.RVT_INT (variable) -ida_idd.RVT_UNAVAILABLE (variable) -ida_idd.STEP (variable) -ida_idd.THREAD_EXITED (variable) -ida_idd.THREAD_STARTED (variable) -ida_idd.TRACE_FULL (variable) -ida_idd.appcall (function) -ida_idd.bptaddr_t (class) -ida_idd.bptaddr_t.__init__ (method) -ida_idd.bptaddr_t.hea (variable) -ida_idd.bptaddr_t.kea (variable) -ida_idd.call_stack_info_t (class) -ida_idd.call_stack_info_t.__eq__ (method) -ida_idd.call_stack_info_t.__init__ (method) -ida_idd.call_stack_info_t.__ne__ (method) -ida_idd.call_stack_info_t.callea (variable) -ida_idd.call_stack_info_t.fp (variable) -ida_idd.call_stack_info_t.funcea (variable) -ida_idd.call_stack_info_t.funcok (variable) -ida_idd.call_stack_info_vec_t (class) -ida_idd.call_stack_info_vec_t.__eq__ (method) -ida_idd.call_stack_info_vec_t.__getitem__ (method) -ida_idd.call_stack_info_vec_t.__init__ (method) -ida_idd.call_stack_info_vec_t.__len__ (method) -ida_idd.call_stack_info_vec_t.__ne__ (method) -ida_idd.call_stack_info_vec_t.__setitem__ (method) -ida_idd.call_stack_info_vec_t._del (method) -ida_idd.call_stack_info_vec_t.add_unique (method) -ida_idd.call_stack_info_vec_t.at (method) -ida_idd.call_stack_info_vec_t.begin (method) -ida_idd.call_stack_info_vec_t.capacity (method) -ida_idd.call_stack_info_vec_t.clear (method) -ida_idd.call_stack_info_vec_t.empty (method) -ida_idd.call_stack_info_vec_t.end (method) -ida_idd.call_stack_info_vec_t.erase (method) -ida_idd.call_stack_info_vec_t.extract (method) -ida_idd.call_stack_info_vec_t.find (method) -ida_idd.call_stack_info_vec_t.grow (method) -ida_idd.call_stack_info_vec_t.has (method) -ida_idd.call_stack_info_vec_t.inject (method) -ida_idd.call_stack_info_vec_t.insert (method) -ida_idd.call_stack_info_vec_t.pop_back (method) -ida_idd.call_stack_info_vec_t.push_back (method) -ida_idd.call_stack_info_vec_t.qclear (method) -ida_idd.call_stack_info_vec_t.reserve (method) -ida_idd.call_stack_info_vec_t.resize (method) -ida_idd.call_stack_info_vec_t.size (method) -ida_idd.call_stack_info_vec_t.swap (method) -ida_idd.call_stack_info_vec_t.truncate (method) -ida_idd.call_stack_t (class) -ida_idd.call_stack_t.__init__ (method) -ida_idd.can_exc_continue (function) -ida_idd.cleanup_appcall (function) -ida_idd.dbg_appcall (function) -ida_idd.dbg_get_memory_info (function) -ida_idd.dbg_get_name (function) -ida_idd.dbg_get_registers (function) -ida_idd.dbg_get_thread_sreg_base (function) -ida_idd.dbg_read_memory (function) -ida_idd.dbg_write_memory (function) -ida_idd.debapp_attrs_t (class) -ida_idd.debapp_attrs_t.__init__ (method) -ida_idd.debapp_attrs_t.addrsize (variable) -ida_idd.debapp_attrs_t.cbsize (variable) -ida_idd.debapp_attrs_t.platform (variable) -ida_idd.debug_event_t (class) -ida_idd.debug_event_t.__init__ (method) -ida_idd.debug_event_t.bpt (method) -ida_idd.debug_event_t.bpt_ea (method) -ida_idd.debug_event_t.clear (method) -ida_idd.debug_event_t.clear_all (method) -ida_idd.debug_event_t.copy (method) -ida_idd.debug_event_t.ea (variable) -ida_idd.debug_event_t.eid (method) -ida_idd.debug_event_t.exc (method) -ida_idd.debug_event_t.exit_code (method) -ida_idd.debug_event_t.handled (variable) -ida_idd.debug_event_t.info (method) -ida_idd.debug_event_t.modinfo (method) -ida_idd.debug_event_t.pid (variable) -ida_idd.debug_event_t.set_bpt (method) -ida_idd.debug_event_t.set_eid (method) -ida_idd.debug_event_t.set_exception (method) -ida_idd.debug_event_t.set_exit_code (method) -ida_idd.debug_event_t.set_info (method) -ida_idd.debug_event_t.set_modinfo (method) -ida_idd.debug_event_t.tid (variable) -ida_idd.debugger_t (class) -ida_idd.debugger_t.__get_bpt_bytes (method) -ida_idd.debugger_t.__get_nregs (method) -ida_idd.debugger_t.__get_regclasses (method) -ida_idd.debugger_t.__get_registers (method) -ida_idd.debugger_t.__init__ (method) -ida_idd.debugger_t.attach_process (method) -ida_idd.debugger_t.bin_search (method) -ida_idd.debugger_t.bpt_bytes (variable) -ida_idd.debugger_t.bpt_size (variable) -ida_idd.debugger_t.cache_block_size (method) -ida_idd.debugger_t.can_continue_from_bpt (method) -ida_idd.debugger_t.can_debug_standalone_dlls (method) -ida_idd.debugger_t.check_bpt (method) -ida_idd.debugger_t.cleanup_appcall (method) -ida_idd.debugger_t.close_file (method) -ida_idd.debugger_t.dbg_enable_trace (method) -ida_idd.debugger_t.default_regclasses (variable) -ida_idd.debugger_t.detach_process (method) -ida_idd.debugger_t.ev_appcall (variable) -ida_idd.debugger_t.ev_attach_process (variable) -ida_idd.debugger_t.ev_bin_search (variable) -ida_idd.debugger_t.ev_check_bpt (variable) -ida_idd.debugger_t.ev_cleanup_appcall (variable) -ida_idd.debugger_t.ev_close_file (variable) -ida_idd.debugger_t.ev_dbg_enable_trace (variable) -ida_idd.debugger_t.ev_detach_process (variable) -ida_idd.debugger_t.ev_eval_lowcnd (variable) -ida_idd.debugger_t.ev_exit_process (variable) -ida_idd.debugger_t.ev_get_debapp_attrs (variable) -ida_idd.debugger_t.ev_get_debmod_extensions (variable) -ida_idd.debugger_t.ev_get_debug_event (variable) -ida_idd.debugger_t.ev_get_memory_info (variable) -ida_idd.debugger_t.ev_get_processes (variable) -ida_idd.debugger_t.ev_get_srcinfo_path (variable) -ida_idd.debugger_t.ev_init_debugger (variable) -ida_idd.debugger_t.ev_is_tracing_enabled (variable) -ida_idd.debugger_t.ev_map_address (variable) -ida_idd.debugger_t.ev_open_file (variable) -ida_idd.debugger_t.ev_read_file (variable) -ida_idd.debugger_t.ev_read_memory (variable) -ida_idd.debugger_t.ev_read_registers (variable) -ida_idd.debugger_t.ev_rebase_if_required_to (variable) -ida_idd.debugger_t.ev_request_pause (variable) -ida_idd.debugger_t.ev_resume (variable) -ida_idd.debugger_t.ev_rexec (variable) -ida_idd.debugger_t.ev_send_ioctl (variable) -ida_idd.debugger_t.ev_set_exception_info (variable) -ida_idd.debugger_t.ev_set_resume_mode (variable) -ida_idd.debugger_t.ev_start_process (variable) -ida_idd.debugger_t.ev_suspended (variable) -ida_idd.debugger_t.ev_term_debugger (variable) -ida_idd.debugger_t.ev_thread_continue (variable) -ida_idd.debugger_t.ev_thread_get_sreg_base (variable) -ida_idd.debugger_t.ev_thread_suspend (variable) -ida_idd.debugger_t.ev_update_bpts (variable) -ida_idd.debugger_t.ev_update_call_stack (variable) -ida_idd.debugger_t.ev_update_lowcnds (variable) -ida_idd.debugger_t.ev_write_file (variable) -ida_idd.debugger_t.ev_write_memory (variable) -ida_idd.debugger_t.ev_write_register (variable) -ida_idd.debugger_t.eval_lowcnd (method) -ida_idd.debugger_t.exit_process (method) -ida_idd.debugger_t.fake_memory (method) -ida_idd.debugger_t.filetype (variable) -ida_idd.debugger_t.flags2 (variable) -ida_idd.debugger_t.get_debapp_attrs (method) -ida_idd.debugger_t.get_debmod_extensions (method) -ida_idd.debugger_t.get_debug_event (method) -ida_idd.debugger_t.get_memory_info (method) -ida_idd.debugger_t.get_processes (method) -ida_idd.debugger_t.get_srcinfo_path (method) -ida_idd.debugger_t.has_appcall (method) -ida_idd.debugger_t.has_attach_process (method) -ida_idd.debugger_t.has_check_bpt (method) -ida_idd.debugger_t.has_detach_process (method) -ida_idd.debugger_t.has_get_processes (method) -ida_idd.debugger_t.has_map_address (method) -ida_idd.debugger_t.has_open_file (method) -ida_idd.debugger_t.has_request_pause (method) -ida_idd.debugger_t.has_rexec (method) -ida_idd.debugger_t.has_set_exception_info (method) -ida_idd.debugger_t.has_set_resume_mode (method) -ida_idd.debugger_t.has_soft_bpt (method) -ida_idd.debugger_t.has_thread_continue (method) -ida_idd.debugger_t.has_thread_get_sreg_base (method) -ida_idd.debugger_t.has_thread_suspend (method) -ida_idd.debugger_t.has_update_call_stack (method) -ida_idd.debugger_t.id (variable) -ida_idd.debugger_t.init_debugger (method) -ida_idd.debugger_t.is_remote (method) -ida_idd.debugger_t.is_resmod_avail (method) -ida_idd.debugger_t.is_safe (method) -ida_idd.debugger_t.is_tracing_enabled (method) -ida_idd.debugger_t.map_address (method) -ida_idd.debugger_t.may_disturb (method) -ida_idd.debugger_t.may_take_exit_snapshot (method) -ida_idd.debugger_t.memory_page_size (variable) -ida_idd.debugger_t.must_have_hostname (method) -ida_idd.debugger_t.name (variable) -ida_idd.debugger_t.nregs (variable) -ida_idd.debugger_t.open_file (method) -ida_idd.debugger_t.processor (variable) -ida_idd.debugger_t.read_file (method) -ida_idd.debugger_t.read_memory (method) -ida_idd.debugger_t.read_registers (method) -ida_idd.debugger_t.rebase_if_required_to (method) -ida_idd.debugger_t.regclasses (variable) -ida_idd.debugger_t.registers (variable) -ida_idd.debugger_t.regs (method) -ida_idd.debugger_t.request_pause (method) -ida_idd.debugger_t.resume (method) -ida_idd.debugger_t.resume_modes (variable) -ida_idd.debugger_t.rexec (method) -ida_idd.debugger_t.send_ioctl (method) -ida_idd.debugger_t.set_exception_info (method) -ida_idd.debugger_t.set_resume_mode (method) -ida_idd.debugger_t.start_process (method) -ida_idd.debugger_t.supports_debthread (method) -ida_idd.debugger_t.supports_lowcnds (method) -ida_idd.debugger_t.suspended (method) -ida_idd.debugger_t.term_debugger (method) -ida_idd.debugger_t.thread_continue (method) -ida_idd.debugger_t.thread_get_sreg_base (method) -ida_idd.debugger_t.thread_suspend (method) -ida_idd.debugger_t.update_bpts (method) -ida_idd.debugger_t.update_call_stack (method) -ida_idd.debugger_t.update_lowcnds (method) -ida_idd.debugger_t.use_memregs (method) -ida_idd.debugger_t.use_sregs (method) -ida_idd.debugger_t.version (variable) -ida_idd.debugger_t.virtual_threads (method) -ida_idd.debugger_t.write_file (method) -ida_idd.debugger_t.write_memory (method) -ida_idd.debugger_t.write_register (method) -ida_idd.dyn_register_info_array (class) -ida_idd.dyn_register_info_array.__getitem__ (method) -ida_idd.dyn_register_info_array.__init__ (method) -ida_idd.dyn_register_info_array.__len__ (method) -ida_idd.dyn_register_info_array.__setitem__ (method) -ida_idd.exception_info_t (class) -ida_idd.exception_info_t.__init__ (method) -ida_idd.exception_info_t.break_on (method) -ida_idd.exception_info_t.code (variable) -ida_idd.exception_info_t.desc (variable) -ida_idd.exception_info_t.flags (variable) -ida_idd.exception_info_t.handle (method) -ida_idd.exception_info_t.name (variable) -ida_idd.excinfo_t (class) -ida_idd.excinfo_t.__init__ (method) -ida_idd.excinfo_t.can_cont (variable) -ida_idd.excinfo_t.code (variable) -ida_idd.excinfo_t.ea (variable) -ida_idd.excinfo_t.info (variable) -ida_idd.excvec_t (class) -ida_idd.excvec_t.__getitem__ (method) -ida_idd.excvec_t.__init__ (method) -ida_idd.excvec_t.__len__ (method) -ida_idd.excvec_t.__setitem__ (method) -ida_idd.excvec_t.at (method) -ida_idd.excvec_t.begin (method) -ida_idd.excvec_t.capacity (method) -ida_idd.excvec_t.clear (method) -ida_idd.excvec_t.empty (method) -ida_idd.excvec_t.end (method) -ida_idd.excvec_t.erase (method) -ida_idd.excvec_t.extract (method) -ida_idd.excvec_t.grow (method) -ida_idd.excvec_t.inject (method) -ida_idd.excvec_t.insert (method) -ida_idd.excvec_t.pop_back (method) -ida_idd.excvec_t.push_back (method) -ida_idd.excvec_t.qclear (method) -ida_idd.excvec_t.reserve (method) -ida_idd.excvec_t.resize (method) -ida_idd.excvec_t.size (method) -ida_idd.excvec_t.swap (method) -ida_idd.excvec_t.truncate (method) -ida_idd.get_dbg (function) -ida_idd.get_event_bpt_hea (function) -ida_idd.get_event_exc_code (function) -ida_idd.get_event_exc_ea (function) -ida_idd.get_event_exc_info (function) -ida_idd.get_event_info (function) -ida_idd.get_event_module_base (function) -ida_idd.get_event_module_name (function) -ida_idd.get_event_module_size (function) -ida_idd.launch_env_t (class) -ida_idd.launch_env_t.__init__ (method) -ida_idd.meminfo_vec_t (class) -ida_idd.meminfo_vec_t.__init__ (method) -ida_idd.meminfo_vec_template_t (class) -ida_idd.meminfo_vec_template_t.__eq__ (method) -ida_idd.meminfo_vec_template_t.__getitem__ (method) -ida_idd.meminfo_vec_template_t.__init__ (method) -ida_idd.meminfo_vec_template_t.__len__ (method) -ida_idd.meminfo_vec_template_t.__ne__ (method) -ida_idd.meminfo_vec_template_t.__setitem__ (method) -ida_idd.meminfo_vec_template_t._del (method) -ida_idd.meminfo_vec_template_t.add_unique (method) -ida_idd.meminfo_vec_template_t.at (method) -ida_idd.meminfo_vec_template_t.begin (method) -ida_idd.meminfo_vec_template_t.capacity (method) -ida_idd.meminfo_vec_template_t.clear (method) -ida_idd.meminfo_vec_template_t.empty (method) -ida_idd.meminfo_vec_template_t.end (method) -ida_idd.meminfo_vec_template_t.erase (method) -ida_idd.meminfo_vec_template_t.extract (method) -ida_idd.meminfo_vec_template_t.find (method) -ida_idd.meminfo_vec_template_t.grow (method) -ida_idd.meminfo_vec_template_t.has (method) -ida_idd.meminfo_vec_template_t.inject (method) -ida_idd.meminfo_vec_template_t.insert (method) -ida_idd.meminfo_vec_template_t.pop_back (method) -ida_idd.meminfo_vec_template_t.push_back (method) -ida_idd.meminfo_vec_template_t.qclear (method) -ida_idd.meminfo_vec_template_t.reserve (method) -ida_idd.meminfo_vec_template_t.resize (method) -ida_idd.meminfo_vec_template_t.size (method) -ida_idd.meminfo_vec_template_t.swap (method) -ida_idd.meminfo_vec_template_t.truncate (method) -ida_idd.memory_info_t (class) -ida_idd.memory_info_t.__eq__ (method) -ida_idd.memory_info_t.__init__ (method) -ida_idd.memory_info_t.__ne__ (method) -ida_idd.memory_info_t.bitness (variable) -ida_idd.memory_info_t.name (variable) -ida_idd.memory_info_t.perm (variable) -ida_idd.memory_info_t.sbase (variable) -ida_idd.memory_info_t.sclass (variable) -ida_idd.modinfo_t (class) -ida_idd.modinfo_t.__init__ (method) -ida_idd.modinfo_t.base (variable) -ida_idd.modinfo_t.name (variable) -ida_idd.modinfo_t.rebase_to (variable) -ida_idd.modinfo_t.size (variable) -ida_idd.process_info_t (class) -ida_idd.process_info_t.__init__ (method) -ida_idd.process_info_t.name (variable) -ida_idd.process_info_t.pid (variable) -ida_idd.procinfo_vec_t (class) -ida_idd.procinfo_vec_t.__getitem__ (method) -ida_idd.procinfo_vec_t.__init__ (method) -ida_idd.procinfo_vec_t.__len__ (method) -ida_idd.procinfo_vec_t.__setitem__ (method) -ida_idd.procinfo_vec_t.at (method) -ida_idd.procinfo_vec_t.begin (method) -ida_idd.procinfo_vec_t.capacity (method) -ida_idd.procinfo_vec_t.clear (method) -ida_idd.procinfo_vec_t.empty (method) -ida_idd.procinfo_vec_t.end (method) -ida_idd.procinfo_vec_t.erase (method) -ida_idd.procinfo_vec_t.extract (method) -ida_idd.procinfo_vec_t.grow (method) -ida_idd.procinfo_vec_t.inject (method) -ida_idd.procinfo_vec_t.insert (method) -ida_idd.procinfo_vec_t.pop_back (method) -ida_idd.procinfo_vec_t.push_back (method) -ida_idd.procinfo_vec_t.qclear (method) -ida_idd.procinfo_vec_t.reserve (method) -ida_idd.procinfo_vec_t.resize (method) -ida_idd.procinfo_vec_t.size (method) -ida_idd.procinfo_vec_t.swap (method) -ida_idd.procinfo_vec_t.truncate (method) -ida_idd.register_info_t (class) -ida_idd.register_info_t.__get_bit_strings (method) -ida_idd.register_info_t.__init__ (method) -ida_idd.register_info_t.bit_strings (variable) -ida_idd.register_info_t.default_bit_strings_mask (variable) -ida_idd.register_info_t.dtype (variable) -ida_idd.register_info_t.flags (variable) -ida_idd.register_info_t.name (variable) -ida_idd.register_info_t.register_class (variable) -ida_idd.regval_t (class) -ida_idd.regval_t.__eq__ (method) -ida_idd.regval_t.__init__ (method) -ida_idd.regval_t.__ne__ (method) -ida_idd.regval_t.bytes (method) -ida_idd.regval_t.clear (method) -ida_idd.regval_t.fval (variable) -ida_idd.regval_t.get_data (method) -ida_idd.regval_t.get_data_size (method) -ida_idd.regval_t.ival (variable) -ida_idd.regval_t.pyval (method) -ida_idd.regval_t.rvtype (variable) -ida_idd.regval_t.set_bytes (method) -ida_idd.regval_t.set_float (method) -ida_idd.regval_t.set_int (method) -ida_idd.regval_t.set_pyval (method) -ida_idd.regval_t.set_unavailable (method) -ida_idd.regval_t.swap (method) -ida_idd.regvals_t (class) -ida_idd.regvals_t.__eq__ (method) -ida_idd.regvals_t.__getitem__ (method) -ida_idd.regvals_t.__init__ (method) -ida_idd.regvals_t.__len__ (method) -ida_idd.regvals_t.__ne__ (method) -ida_idd.regvals_t.__setitem__ (method) -ida_idd.regvals_t._del (method) -ida_idd.regvals_t.add_unique (method) -ida_idd.regvals_t.at (method) -ida_idd.regvals_t.begin (method) -ida_idd.regvals_t.capacity (method) -ida_idd.regvals_t.clear (method) -ida_idd.regvals_t.empty (method) -ida_idd.regvals_t.end (method) -ida_idd.regvals_t.erase (method) -ida_idd.regvals_t.extract (method) -ida_idd.regvals_t.find (method) -ida_idd.regvals_t.grow (method) -ida_idd.regvals_t.has (method) -ida_idd.regvals_t.inject (method) -ida_idd.regvals_t.insert (method) -ida_idd.regvals_t.pop_back (method) -ida_idd.regvals_t.push_back (method) -ida_idd.regvals_t.qclear (method) -ida_idd.regvals_t.reserve (method) -ida_idd.regvals_t.resize (method) -ida_idd.regvals_t.size (method) -ida_idd.regvals_t.swap (method) -ida_idd.regvals_t.truncate (method) -ida_idd.scattered_segm_t (class) -ida_idd.scattered_segm_t.__init__ (method) -ida_idd.scattered_segm_t.name (variable) -ida_idd.set_debug_event_code (function) -ida_idd.thread_name_t (class) -ida_idd.thread_name_t.__init__ (method) -ida_idd.thread_name_t.name (variable) -ida_idd.thread_name_t.tid (variable) -ida_idp (module) -ida_idp.AS2_BRACE (variable) -ida_idp.AS2_BYTE1CHAR (variable) -ida_idp.AS2_COLONSUF (variable) -ida_idp.AS2_IDEALDSCR (variable) -ida_idp.AS2_STRINV (variable) -ida_idp.AS2_TERSESTR (variable) -ida_idp.AS2_YWORD (variable) -ida_idp.AS2_ZWORD (variable) -ida_idp.ASB_BINF0 (variable) -ida_idp.ASB_BINF1 (variable) -ida_idp.ASB_BINF2 (variable) -ida_idp.ASB_BINF3 (variable) -ida_idp.ASB_BINF4 (variable) -ida_idp.ASB_BINF5 (variable) -ida_idp.ASD_DECF0 (variable) -ida_idp.ASD_DECF1 (variable) -ida_idp.ASD_DECF2 (variable) -ida_idp.ASD_DECF3 (variable) -ida_idp.ASH_HEXF0 (variable) -ida_idp.ASH_HEXF1 (variable) -ida_idp.ASH_HEXF2 (variable) -ida_idp.ASH_HEXF3 (variable) -ida_idp.ASH_HEXF4 (variable) -ida_idp.ASH_HEXF5 (variable) -ida_idp.ASO_OCTF0 (variable) -ida_idp.ASO_OCTF1 (variable) -ida_idp.ASO_OCTF2 (variable) -ida_idp.ASO_OCTF3 (variable) -ida_idp.ASO_OCTF4 (variable) -ida_idp.ASO_OCTF5 (variable) -ida_idp.ASO_OCTF6 (variable) -ida_idp.ASO_OCTF7 (variable) -ida_idp.AS_1TEXT (variable) -ida_idp.AS_2CHRE (variable) -ida_idp.AS_ALIGN2 (variable) -ida_idp.AS_ASCIIC (variable) -ida_idp.AS_ASCIIZ (variable) -ida_idp.AS_BINFM (variable) -ida_idp.AS_COLON (variable) -ida_idp.AS_DECFM (variable) -ida_idp.AS_HEXFM (variable) -ida_idp.AS_LALIGN (variable) -ida_idp.AS_N2CHR (variable) -ida_idp.AS_NCHRE (variable) -ida_idp.AS_NCMAS (variable) -ida_idp.AS_NHIAS (variable) -ida_idp.AS_NOCODECLN (variable) -ida_idp.AS_NOSPACE (variable) -ida_idp.AS_NOXRF (variable) -ida_idp.AS_OCTFM (variable) -ida_idp.AS_OFFST (variable) -ida_idp.AS_ONEDUP (variable) -ida_idp.AS_RELSUP (variable) -ida_idp.AS_UDATA (variable) -ida_idp.AS_UNEQU (variable) -ida_idp.AS_XTRNTYPE (variable) -ida_idp.AssembleLine (function) -ida_idp.CF_CALL (variable) -ida_idp.CF_CHG1 (variable) -ida_idp.CF_CHG2 (variable) -ida_idp.CF_CHG3 (variable) -ida_idp.CF_CHG4 (variable) -ida_idp.CF_CHG5 (variable) -ida_idp.CF_CHG6 (variable) -ida_idp.CF_CHG7 (variable) -ida_idp.CF_CHG8 (variable) -ida_idp.CF_HLL (variable) -ida_idp.CF_JUMP (variable) -ida_idp.CF_SHFT (variable) -ida_idp.CF_STOP (variable) -ida_idp.CF_USE1 (variable) -ida_idp.CF_USE2 (variable) -ida_idp.CF_USE3 (variable) -ida_idp.CF_USE4 (variable) -ida_idp.CF_USE5 (variable) -ida_idp.CF_USE6 (variable) -ida_idp.CF_USE7 (variable) -ida_idp.CF_USE8 (variable) -ida_idp.CUSTOM_INSN_ITYPE (variable) -ida_idp.HKCB_GLOBAL (variable) -ida_idp.IDB_Hooks (class) -ida_idp.IDB_Hooks.__disown__ (method) -ida_idp.IDB_Hooks.__init__ (method) -ida_idp.IDB_Hooks.adding_segm (method) -ida_idp.IDB_Hooks.allsegs_moved (method) -ida_idp.IDB_Hooks.auto_empty (method) -ida_idp.IDB_Hooks.auto_empty_finally (method) -ida_idp.IDB_Hooks.bookmark_changed (method) -ida_idp.IDB_Hooks.byte_patched (method) -ida_idp.IDB_Hooks.callee_addr_changed (method) -ida_idp.IDB_Hooks.changing_cmt (method) -ida_idp.IDB_Hooks.changing_enum_bf (method) -ida_idp.IDB_Hooks.changing_enum_cmt (method) -ida_idp.IDB_Hooks.changing_op_ti (method) -ida_idp.IDB_Hooks.changing_op_type (method) -ida_idp.IDB_Hooks.changing_range_cmt (method) -ida_idp.IDB_Hooks.changing_segm_class (method) -ida_idp.IDB_Hooks.changing_segm_end (method) -ida_idp.IDB_Hooks.changing_segm_name (method) -ida_idp.IDB_Hooks.changing_segm_start (method) -ida_idp.IDB_Hooks.changing_struc_align (method) -ida_idp.IDB_Hooks.changing_struc_cmt (method) -ida_idp.IDB_Hooks.changing_struc_member (method) -ida_idp.IDB_Hooks.changing_ti (method) -ida_idp.IDB_Hooks.closebase (method) -ida_idp.IDB_Hooks.cmt_changed (method) -ida_idp.IDB_Hooks.compiler_changed (method) -ida_idp.IDB_Hooks.deleting_enum (method) -ida_idp.IDB_Hooks.deleting_enum_member (method) -ida_idp.IDB_Hooks.deleting_func (method) -ida_idp.IDB_Hooks.deleting_func_tail (method) -ida_idp.IDB_Hooks.deleting_segm (method) -ida_idp.IDB_Hooks.deleting_struc (method) -ida_idp.IDB_Hooks.deleting_struc_member (method) -ida_idp.IDB_Hooks.deleting_tryblks (method) -ida_idp.IDB_Hooks.destroyed_items (method) -ida_idp.IDB_Hooks.determined_main (method) -ida_idp.IDB_Hooks.dirtree_link (method) -ida_idp.IDB_Hooks.dirtree_mkdir (method) -ida_idp.IDB_Hooks.dirtree_move (method) -ida_idp.IDB_Hooks.dirtree_rank (method) -ida_idp.IDB_Hooks.dirtree_rmdir (method) -ida_idp.IDB_Hooks.dirtree_rminode (method) -ida_idp.IDB_Hooks.dirtree_segm_moved (method) -ida_idp.IDB_Hooks.enum_bf_changed (method) -ida_idp.IDB_Hooks.enum_cmt_changed (method) -ida_idp.IDB_Hooks.enum_created (method) -ida_idp.IDB_Hooks.enum_deleted (method) -ida_idp.IDB_Hooks.enum_flag_changed (method) -ida_idp.IDB_Hooks.enum_member_created (method) -ida_idp.IDB_Hooks.enum_member_deleted (method) -ida_idp.IDB_Hooks.enum_ordinal_changed (method) -ida_idp.IDB_Hooks.enum_renamed (method) -ida_idp.IDB_Hooks.enum_width_changed (method) -ida_idp.IDB_Hooks.expanding_struc (method) -ida_idp.IDB_Hooks.extlang_changed (method) -ida_idp.IDB_Hooks.extra_cmt_changed (method) -ida_idp.IDB_Hooks.flow_chart_created (method) -ida_idp.IDB_Hooks.frame_deleted (method) -ida_idp.IDB_Hooks.func_added (method) -ida_idp.IDB_Hooks.func_deleted (method) -ida_idp.IDB_Hooks.func_noret_changed (method) -ida_idp.IDB_Hooks.func_tail_appended (method) -ida_idp.IDB_Hooks.func_tail_deleted (method) -ida_idp.IDB_Hooks.func_updated (method) -ida_idp.IDB_Hooks.hook (method) -ida_idp.IDB_Hooks.idasgn_loaded (method) -ida_idp.IDB_Hooks.item_color_changed (method) -ida_idp.IDB_Hooks.kernel_config_loaded (method) -ida_idp.IDB_Hooks.loader_finished (method) -ida_idp.IDB_Hooks.local_types_changed (method) -ida_idp.IDB_Hooks.make_code (method) -ida_idp.IDB_Hooks.make_data (method) -ida_idp.IDB_Hooks.op_ti_changed (method) -ida_idp.IDB_Hooks.op_type_changed (method) -ida_idp.IDB_Hooks.range_cmt_changed (method) -ida_idp.IDB_Hooks.renamed (method) -ida_idp.IDB_Hooks.renaming_enum (method) -ida_idp.IDB_Hooks.renaming_struc (method) -ida_idp.IDB_Hooks.renaming_struc_member (method) -ida_idp.IDB_Hooks.savebase (method) -ida_idp.IDB_Hooks.segm_added (method) -ida_idp.IDB_Hooks.segm_attrs_updated (method) -ida_idp.IDB_Hooks.segm_class_changed (method) -ida_idp.IDB_Hooks.segm_deleted (method) -ida_idp.IDB_Hooks.segm_end_changed (method) -ida_idp.IDB_Hooks.segm_moved (method) -ida_idp.IDB_Hooks.segm_name_changed (method) -ida_idp.IDB_Hooks.segm_start_changed (method) -ida_idp.IDB_Hooks.set_func_end (method) -ida_idp.IDB_Hooks.set_func_start (method) -ida_idp.IDB_Hooks.sgr_changed (method) -ida_idp.IDB_Hooks.sgr_deleted (method) -ida_idp.IDB_Hooks.stkpnts_changed (method) -ida_idp.IDB_Hooks.struc_align_changed (method) -ida_idp.IDB_Hooks.struc_cmt_changed (method) -ida_idp.IDB_Hooks.struc_created (method) -ida_idp.IDB_Hooks.struc_deleted (method) -ida_idp.IDB_Hooks.struc_expanded (method) -ida_idp.IDB_Hooks.struc_member_changed (method) -ida_idp.IDB_Hooks.struc_member_created (method) -ida_idp.IDB_Hooks.struc_member_deleted (method) -ida_idp.IDB_Hooks.struc_member_renamed (method) -ida_idp.IDB_Hooks.struc_renamed (method) -ida_idp.IDB_Hooks.tail_owner_changed (method) -ida_idp.IDB_Hooks.thunk_func_created (method) -ida_idp.IDB_Hooks.ti_changed (method) -ida_idp.IDB_Hooks.tryblks_updated (method) -ida_idp.IDB_Hooks.unhook (method) -ida_idp.IDB_Hooks.updating_tryblks (method) -ida_idp.IDB_Hooks.upgraded (method) -ida_idp.IDP_Hooks (class) -ida_idp.IDP_Hooks.__disown__ (method) -ida_idp.IDP_Hooks.__init__ (method) -ida_idp.IDP_Hooks.ev_add_cref (method) -ida_idp.IDP_Hooks.ev_add_dref (method) -ida_idp.IDP_Hooks.ev_adjust_argloc (method) -ida_idp.IDP_Hooks.ev_adjust_libfunc_ea (method) -ida_idp.IDP_Hooks.ev_adjust_refinfo (method) -ida_idp.IDP_Hooks.ev_ana_insn (method) -ida_idp.IDP_Hooks.ev_analyze_prolog (method) -ida_idp.IDP_Hooks.ev_arch_changed (method) -ida_idp.IDP_Hooks.ev_arg_addrs_ready (method) -ida_idp.IDP_Hooks.ev_asm_installed (method) -ida_idp.IDP_Hooks.ev_assemble (method) -ida_idp.IDP_Hooks.ev_auto_queue_empty (method) -ida_idp.IDP_Hooks.ev_calc_arglocs (method) -ida_idp.IDP_Hooks.ev_calc_cdecl_purged_bytes (method) -ida_idp.IDP_Hooks.ev_calc_next_eas (method) -ida_idp.IDP_Hooks.ev_calc_purged_bytes (method) -ida_idp.IDP_Hooks.ev_calc_retloc (method) -ida_idp.IDP_Hooks.ev_calc_spdelta (method) -ida_idp.IDP_Hooks.ev_calc_step_over (method) -ida_idp.IDP_Hooks.ev_calc_switch_cases (method) -ida_idp.IDP_Hooks.ev_calc_varglocs (method) -ida_idp.IDP_Hooks.ev_calcrel (method) -ida_idp.IDP_Hooks.ev_can_have_type (method) -ida_idp.IDP_Hooks.ev_clean_tbit (method) -ida_idp.IDP_Hooks.ev_cmp_operands (method) -ida_idp.IDP_Hooks.ev_coagulate (method) -ida_idp.IDP_Hooks.ev_coagulate_dref (method) -ida_idp.IDP_Hooks.ev_create_flat_group (method) -ida_idp.IDP_Hooks.ev_create_func_frame (method) -ida_idp.IDP_Hooks.ev_create_merge_handlers (method) -ida_idp.IDP_Hooks.ev_create_switch_xrefs (method) -ida_idp.IDP_Hooks.ev_creating_segm (method) -ida_idp.IDP_Hooks.ev_cvt64_hashval (method) -ida_idp.IDP_Hooks.ev_cvt64_supval (method) -ida_idp.IDP_Hooks.ev_decorate_name (method) -ida_idp.IDP_Hooks.ev_del_cref (method) -ida_idp.IDP_Hooks.ev_del_dref (method) -ida_idp.IDP_Hooks.ev_delay_slot_insn (method) -ida_idp.IDP_Hooks.ev_demangle_name (method) -ida_idp.IDP_Hooks.ev_emu_insn (method) -ida_idp.IDP_Hooks.ev_endbinary (method) -ida_idp.IDP_Hooks.ev_ending_undo (method) -ida_idp.IDP_Hooks.ev_equal_reglocs (method) -ida_idp.IDP_Hooks.ev_extract_address (method) -ida_idp.IDP_Hooks.ev_find_op_value (method) -ida_idp.IDP_Hooks.ev_find_reg_value (method) -ida_idp.IDP_Hooks.ev_func_bounds (method) -ida_idp.IDP_Hooks.ev_gen_asm_or_lst (method) -ida_idp.IDP_Hooks.ev_gen_map_file (method) -ida_idp.IDP_Hooks.ev_gen_regvar_def (method) -ida_idp.IDP_Hooks.ev_gen_src_file_lnnum (method) -ida_idp.IDP_Hooks.ev_gen_stkvar_def (method) -ida_idp.IDP_Hooks.ev_get_abi_info (method) -ida_idp.IDP_Hooks.ev_get_autocmt (method) -ida_idp.IDP_Hooks.ev_get_bg_color (method) -ida_idp.IDP_Hooks.ev_get_cc_regs (method) -ida_idp.IDP_Hooks.ev_get_code16_mode (method) -ida_idp.IDP_Hooks.ev_get_dbr_opnum (method) -ida_idp.IDP_Hooks.ev_get_default_enum_size (method) -ida_idp.IDP_Hooks.ev_get_frame_retsize (method) -ida_idp.IDP_Hooks.ev_get_macro_insn_head (method) -ida_idp.IDP_Hooks.ev_get_operand_string (method) -ida_idp.IDP_Hooks.ev_get_procmod (method) -ida_idp.IDP_Hooks.ev_get_reg_accesses (method) -ida_idp.IDP_Hooks.ev_get_reg_info (method) -ida_idp.IDP_Hooks.ev_get_reg_name (method) -ida_idp.IDP_Hooks.ev_get_simd_types (method) -ida_idp.IDP_Hooks.ev_get_stkarg_area_info (method) -ida_idp.IDP_Hooks.ev_get_stkvar_scale_factor (method) -ida_idp.IDP_Hooks.ev_getreg (method) -ida_idp.IDP_Hooks.ev_init (method) -ida_idp.IDP_Hooks.ev_insn_reads_tbit (method) -ida_idp.IDP_Hooks.ev_is_align_insn (method) -ida_idp.IDP_Hooks.ev_is_alloca_probe (method) -ida_idp.IDP_Hooks.ev_is_basic_block_end (method) -ida_idp.IDP_Hooks.ev_is_call_insn (method) -ida_idp.IDP_Hooks.ev_is_cond_insn (method) -ida_idp.IDP_Hooks.ev_is_control_flow_guard (method) -ida_idp.IDP_Hooks.ev_is_far_jump (method) -ida_idp.IDP_Hooks.ev_is_indirect_jump (method) -ida_idp.IDP_Hooks.ev_is_insn_table_jump (method) -ida_idp.IDP_Hooks.ev_is_jump_func (method) -ida_idp.IDP_Hooks.ev_is_ret_insn (method) -ida_idp.IDP_Hooks.ev_is_sane_insn (method) -ida_idp.IDP_Hooks.ev_is_sp_based (method) -ida_idp.IDP_Hooks.ev_is_switch (method) -ida_idp.IDP_Hooks.ev_last_cb_before_loader (method) -ida_idp.IDP_Hooks.ev_loader (method) -ida_idp.IDP_Hooks.ev_lower_func_type (method) -ida_idp.IDP_Hooks.ev_max_ptr_size (method) -ida_idp.IDP_Hooks.ev_may_be_func (method) -ida_idp.IDP_Hooks.ev_may_show_sreg (method) -ida_idp.IDP_Hooks.ev_moving_segm (method) -ida_idp.IDP_Hooks.ev_newasm (method) -ida_idp.IDP_Hooks.ev_newbinary (method) -ida_idp.IDP_Hooks.ev_newfile (method) -ida_idp.IDP_Hooks.ev_newprc (method) -ida_idp.IDP_Hooks.ev_next_exec_insn (method) -ida_idp.IDP_Hooks.ev_oldfile (method) -ida_idp.IDP_Hooks.ev_out_assumes (method) -ida_idp.IDP_Hooks.ev_out_data (method) -ida_idp.IDP_Hooks.ev_out_footer (method) -ida_idp.IDP_Hooks.ev_out_header (method) -ida_idp.IDP_Hooks.ev_out_insn (method) -ida_idp.IDP_Hooks.ev_out_label (method) -ida_idp.IDP_Hooks.ev_out_mnem (method) -ida_idp.IDP_Hooks.ev_out_operand (method) -ida_idp.IDP_Hooks.ev_out_segend (method) -ida_idp.IDP_Hooks.ev_out_segstart (method) -ida_idp.IDP_Hooks.ev_out_special_item (method) -ida_idp.IDP_Hooks.ev_privrange_changed (method) -ida_idp.IDP_Hooks.ev_realcvt (method) -ida_idp.IDP_Hooks.ev_rename (method) -ida_idp.IDP_Hooks.ev_replaying_undo (method) -ida_idp.IDP_Hooks.ev_set_code16_mode (method) -ida_idp.IDP_Hooks.ev_set_idp_options (method) -ida_idp.IDP_Hooks.ev_set_proc_options (method) -ida_idp.IDP_Hooks.ev_setup_til (method) -ida_idp.IDP_Hooks.ev_str2reg (method) -ida_idp.IDP_Hooks.ev_term (method) -ida_idp.IDP_Hooks.ev_treat_hindering_item (method) -ida_idp.IDP_Hooks.ev_undefine (method) -ida_idp.IDP_Hooks.ev_update_call_stack (method) -ida_idp.IDP_Hooks.ev_use_arg_types (method) -ida_idp.IDP_Hooks.ev_use_regarg_type (method) -ida_idp.IDP_Hooks.ev_use_stkarg_type (method) -ida_idp.IDP_Hooks.ev_validate_flirt_func (method) -ida_idp.IDP_Hooks.ev_verify_noreturn (method) -ida_idp.IDP_Hooks.ev_verify_sp (method) -ida_idp.IDP_Hooks.hook (method) -ida_idp.IDP_Hooks.unhook (method) -ida_idp.IDP_INTERFACE_VERSION (variable) -ida_idp.OP_FP_BASED (variable) -ida_idp.OP_SP_ADD (variable) -ida_idp.OP_SP_BASED (variable) -ida_idp.OP_SP_SUB (variable) -ida_idp.PLFM_386 (variable) -ida_idp.PLFM_6502 (variable) -ida_idp.PLFM_65C816 (variable) -ida_idp.PLFM_6800 (variable) -ida_idp.PLFM_68K (variable) -ida_idp.PLFM_80196 (variable) -ida_idp.PLFM_8051 (variable) -ida_idp.PLFM_AD2106X (variable) -ida_idp.PLFM_AD218X (variable) -ida_idp.PLFM_ALPHA (variable) -ida_idp.PLFM_ARC (variable) -ida_idp.PLFM_ARM (variable) -ida_idp.PLFM_AVR (variable) -ida_idp.PLFM_C166 (variable) -ida_idp.PLFM_C39 (variable) -ida_idp.PLFM_CR16 (variable) -ida_idp.PLFM_DALVIK (variable) -ida_idp.PLFM_DSP56K (variable) -ida_idp.PLFM_DSP96K (variable) -ida_idp.PLFM_EBC (variable) -ida_idp.PLFM_F2MC (variable) -ida_idp.PLFM_FR (variable) -ida_idp.PLFM_H8 (variable) -ida_idp.PLFM_H8500 (variable) -ida_idp.PLFM_HPPA (variable) -ida_idp.PLFM_I860 (variable) -ida_idp.PLFM_I960 (variable) -ida_idp.PLFM_IA64 (variable) -ida_idp.PLFM_JAVA (variable) -ida_idp.PLFM_KR1878 (variable) -ida_idp.PLFM_M16C (variable) -ida_idp.PLFM_M32R (variable) -ida_idp.PLFM_M740 (variable) -ida_idp.PLFM_M7700 (variable) -ida_idp.PLFM_M7900 (variable) -ida_idp.PLFM_MC6812 (variable) -ida_idp.PLFM_MC6816 (variable) -ida_idp.PLFM_MIPS (variable) -ida_idp.PLFM_MN102L00 (variable) -ida_idp.PLFM_MSP430 (variable) -ida_idp.PLFM_NEC_78K0 (variable) -ida_idp.PLFM_NEC_78K0S (variable) -ida_idp.PLFM_NEC_V850X (variable) -ida_idp.PLFM_NET (variable) -ida_idp.PLFM_OAKDSP (variable) -ida_idp.PLFM_PDP (variable) -ida_idp.PLFM_PIC (variable) -ida_idp.PLFM_PIC16 (variable) -ida_idp.PLFM_PPC (variable) -ida_idp.PLFM_RISCV (variable) -ida_idp.PLFM_RL78 (variable) -ida_idp.PLFM_RX (variable) -ida_idp.PLFM_S390 (variable) -ida_idp.PLFM_SCR_ADPT (variable) -ida_idp.PLFM_SH (variable) -ida_idp.PLFM_SPARC (variable) -ida_idp.PLFM_SPC700 (variable) -ida_idp.PLFM_SPU (variable) -ida_idp.PLFM_ST20 (variable) -ida_idp.PLFM_ST7 (variable) -ida_idp.PLFM_ST9 (variable) -ida_idp.PLFM_TLCS900 (variable) -ida_idp.PLFM_TMS (variable) -ida_idp.PLFM_TMS320C1X (variable) -ida_idp.PLFM_TMS320C28 (variable) -ida_idp.PLFM_TMS320C3 (variable) -ida_idp.PLFM_TMS320C54 (variable) -ida_idp.PLFM_TMS320C55 (variable) -ida_idp.PLFM_TMSC6 (variable) -ida_idp.PLFM_TRICORE (variable) -ida_idp.PLFM_TRIMEDIA (variable) -ida_idp.PLFM_UNSP (variable) -ida_idp.PLFM_XTENSA (variable) -ida_idp.PLFM_Z8 (variable) -ida_idp.PLFM_Z80 (variable) -ida_idp.PR2_CODE16_BIT (variable) -ida_idp.PR2_FORCE_16BIT (variable) -ida_idp.PR2_IDP_OPTS (variable) -ida_idp.PR2_MACRO (variable) -ida_idp.PR2_MAPPINGS (variable) -ida_idp.PR2_REALCVT (variable) -ida_idp.PR2_REL_BITS (variable) -ida_idp.PR2_USE_CALCREL (variable) -ida_idp.PRN_BIN (variable) -ida_idp.PRN_DEC (variable) -ida_idp.PRN_HEX (variable) -ida_idp.PRN_OCT (variable) -ida_idp.PR_ADJSEGS (variable) -ida_idp.PR_ALIGN (variable) -ida_idp.PR_ALIGN_INSN (variable) -ida_idp.PR_ASSEMBLE (variable) -ida_idp.PR_BINMEM (variable) -ida_idp.PR_CHK_XREF (variable) -ida_idp.PR_CNDINSNS (variable) -ida_idp.PR_DEFNUM (variable) -ida_idp.PR_DEFSEG32 (variable) -ida_idp.PR_DEFSEG64 (variable) -ida_idp.PR_DELAYED (variable) -ida_idp.PR_NOCHANGE (variable) -ida_idp.PR_NO_SEGMOVE (variable) -ida_idp.PR_OUTER (variable) -ida_idp.PR_PURGING (variable) -ida_idp.PR_RNAMESOK (variable) -ida_idp.PR_SCALE_STKVARS (variable) -ida_idp.PR_SEGS (variable) -ida_idp.PR_SEGTRANS (variable) -ida_idp.PR_SGROTHER (variable) -ida_idp.PR_STACK_UP (variable) -ida_idp.PR_TYPEINFO (variable) -ida_idp.PR_USE32 (variable) -ida_idp.PR_USE64 (variable) -ida_idp.PR_USE_ARG_TYPES (variable) -ida_idp.PR_USE_TBYTE (variable) -ida_idp.PR_WORD_INS (variable) -ida_idp.REG_SPOIL (variable) -ida_idp.SETPROC_IDB (variable) -ida_idp.SETPROC_LOADER (variable) -ida_idp.SETPROC_LOADER_NON_FATAL (variable) -ida_idp.SETPROC_USER (variable) -ida_idp.__ph (class) -ida_idp._idp_cvar_t (class) -ida_idp._notify_when_dispatcher_t (class) -ida_idp._notify_when_dispatcher_t._IDB_Hooks (class) -ida_idp._notify_when_dispatcher_t._IDB_Hooks.__init__ (method) -ida_idp._notify_when_dispatcher_t._IDB_Hooks.closebase (method) -ida_idp._notify_when_dispatcher_t._IDP_Hooks (class) -ida_idp._notify_when_dispatcher_t._IDP_Hooks.__init__ (method) -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_newfile (method) -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_oldfile (method) -ida_idp._notify_when_dispatcher_t.__init__ (method) -ida_idp._notify_when_dispatcher_t._callback_t (class) -ida_idp._notify_when_dispatcher_t._callback_t.__init__ (method) -ida_idp._notify_when_dispatcher_t._find (method) -ida_idp._notify_when_dispatcher_t.dispatch (method) -ida_idp._notify_when_dispatcher_t.notify_when (method) -ida_idp._processor_t (class) -ida_idp._processor_t.__init__ (method) -ida_idp._processor_t.add_cref (method) -ida_idp._processor_t.add_dref (method) -ida_idp._processor_t.adjust_argloc (method) -ida_idp._processor_t.adjust_libfunc_ea (method) -ida_idp._processor_t.adjust_refinfo (method) -ida_idp._processor_t.ana_insn (method) -ida_idp._processor_t.analyze_prolog (method) -ida_idp._processor_t.arch_changed (method) -ida_idp._processor_t.arg_addrs_ready (method) -ida_idp._processor_t.asm_installed (method) -ida_idp._processor_t.assemble (method) -ida_idp._processor_t.auto_queue_empty (method) -ida_idp._processor_t.calc_arglocs (method) -ida_idp._processor_t.calc_cdecl_purged_bytes (method) -ida_idp._processor_t.calc_next_eas (method) -ida_idp._processor_t.calc_purged_bytes (method) -ida_idp._processor_t.calc_retloc (method) -ida_idp._processor_t.calc_spdelta (method) -ida_idp._processor_t.calc_step_over (method) -ida_idp._processor_t.calc_switch_cases (method) -ida_idp._processor_t.calc_varglocs (method) -ida_idp._processor_t.calcrel (method) -ida_idp._processor_t.calcrel_in_bits (method) -ida_idp._processor_t.can_have_type (method) -ida_idp._processor_t.cbsize (method) -ida_idp._processor_t.clean_tbit (method) -ida_idp._processor_t.cmp_operands (method) -ida_idp._processor_t.coagulate (method) -ida_idp._processor_t.coagulate_dref (method) -ida_idp._processor_t.create_flat_group (method) -ida_idp._processor_t.create_func_frame (method) -ida_idp._processor_t.create_merge_handlers (method) -ida_idp._processor_t.create_switch_xrefs (method) -ida_idp._processor_t.creating_segm (method) -ida_idp._processor_t.cvt64_hashval (method) -ida_idp._processor_t.cvt64_supval (method) -ida_idp._processor_t.dbsize (method) -ida_idp._processor_t.decorate_name (method) -ida_idp._processor_t.del_cref (method) -ida_idp._processor_t.del_dref (method) -ida_idp._processor_t.delay_slot_insn (method) -ida_idp._processor_t.demangle_name (method) -ida_idp._processor_t.emu_insn (method) -ida_idp._processor_t.endbinary (method) -ida_idp._processor_t.equal_reglocs (method) -ida_idp._processor_t.extract_address (method) -ida_idp._processor_t.find_op_value (method) -ida_idp._processor_t.find_reg_value (method) -ida_idp._processor_t.func_bounds (method) -ida_idp._processor_t.gen_asm_or_lst (method) -ida_idp._processor_t.gen_map_file (method) -ida_idp._processor_t.gen_regvar_def (method) -ida_idp._processor_t.gen_src_file_lnnum (method) -ida_idp._processor_t.gen_stkvar_def (method) -ida_idp._processor_t.get_abi_info (method) -ida_idp._processor_t.get_autocmt (method) -ida_idp._processor_t.get_bg_color (method) -ida_idp._processor_t.get_canon_feature (method) -ida_idp._processor_t.get_canon_mnem (method) -ida_idp._processor_t.get_cc_regs (method) -ida_idp._processor_t.get_code16_mode (method) -ida_idp._processor_t.get_dbr_opnum (method) -ida_idp._processor_t.get_default_segm_bitness (method) -ida_idp._processor_t.get_frame_retsize (method) -ida_idp._processor_t.get_idd_opinfo (method) -ida_idp._processor_t.get_macro_insn_head (method) -ida_idp._processor_t.get_operand_string (method) -ida_idp._processor_t.get_proc_index (method) -ida_idp._processor_t.get_reg_accesses (method) -ida_idp._processor_t.get_reg_info (method) -ida_idp._processor_t.get_reg_name (method) -ida_idp._processor_t.get_simd_types (method) -ida_idp._processor_t.get_stkarg_area_info (method) -ida_idp._processor_t.get_stkvar_scale (method) -ida_idp._processor_t.get_stkvar_scale_factor (method) -ida_idp._processor_t.getreg (method) -ida_idp._processor_t.has_code16_bit (method) -ida_idp._processor_t.has_idp_opts (method) -ida_idp._processor_t.has_realcvt (method) -ida_idp._processor_t.has_segregs (method) -ida_idp._processor_t.init (method) -ida_idp._processor_t.insn_reads_tbit (method) -ida_idp._processor_t.is_align_insn (method) -ida_idp._processor_t.is_alloca_probe (method) -ida_idp._processor_t.is_basic_block_end (method) -ida_idp._processor_t.is_call_insn (method) -ida_idp._processor_t.is_cond_insn (method) -ida_idp._processor_t.is_control_flow_guard (method) -ida_idp._processor_t.is_far_jump (method) -ida_idp._processor_t.is_indirect_jump (method) -ida_idp._processor_t.is_jump_func (method) -ida_idp._processor_t.is_ret_insn (method) -ida_idp._processor_t.is_sane_insn (method) -ida_idp._processor_t.is_sp_based (method) -ida_idp._processor_t.is_switch (method) -ida_idp._processor_t.loader_elf_machine (method) -ida_idp._processor_t.lower_func_type (method) -ida_idp._processor_t.max_ptr_size (method) -ida_idp._processor_t.may_be_func (method) -ida_idp._processor_t.may_show_sreg (method) -ida_idp._processor_t.moving_segm (method) -ida_idp._processor_t.newasm (method) -ida_idp._processor_t.newbinary (method) -ida_idp._processor_t.newfile (method) -ida_idp._processor_t.newprc (method) -ida_idp._processor_t.next_exec_insn (method) -ida_idp._processor_t.notify (method) -ida_idp._processor_t.oldfile (method) -ida_idp._processor_t.out_assumes (method) -ida_idp._processor_t.out_data (method) -ida_idp._processor_t.out_footer (method) -ida_idp._processor_t.out_header (method) -ida_idp._processor_t.out_insn (method) -ida_idp._processor_t.out_label (method) -ida_idp._processor_t.out_mnem (method) -ida_idp._processor_t.out_operand (method) -ida_idp._processor_t.out_segend (method) -ida_idp._processor_t.out_segstart (method) -ida_idp._processor_t.out_special_item (method) -ida_idp._processor_t.privrange_changed (method) -ida_idp._processor_t.realcvt (method) -ida_idp._processor_t.rename (method) -ida_idp._processor_t.set_code16_mode (method) -ida_idp._processor_t.set_idp_options (method) -ida_idp._processor_t.set_proc_options (method) -ida_idp._processor_t.setup_til (method) -ida_idp._processor_t.sizeof_ldbl (method) -ida_idp._processor_t.stkup (method) -ida_idp._processor_t.str2reg (method) -ida_idp._processor_t.supports_calcrel (method) -ida_idp._processor_t.supports_macros (method) -ida_idp._processor_t.term (method) -ida_idp._processor_t.ti (method) -ida_idp._processor_t.treat_hindering_item (method) -ida_idp._processor_t.undefine (method) -ida_idp._processor_t.update_call_stack (method) -ida_idp._processor_t.use32 (method) -ida_idp._processor_t.use64 (method) -ida_idp._processor_t.use_arg_types (method) -ida_idp._processor_t.use_mappings (method) -ida_idp._processor_t.use_regarg_type (method) -ida_idp._processor_t.use_stkarg_type (method) -ida_idp._processor_t.use_tbyte (method) -ida_idp._processor_t.validate_flirt_func (method) -ida_idp._processor_t.verify_noreturn (method) -ida_idp._processor_t.verify_sp (method) -ida_idp._processor_t_Trampoline_IDB_Hooks (class) -ida_idp._processor_t_Trampoline_IDB_Hooks.__dummy (method) -ida_idp._processor_t_Trampoline_IDB_Hooks.__init__ (method) -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller (method) -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller.call_parent (function) -ida_idp._processor_t_add_cref (function) -ida_idp._processor_t_add_dref (function) -ida_idp._processor_t_adjust_argloc (function) -ida_idp._processor_t_adjust_libfunc_ea (function) -ida_idp._processor_t_adjust_refinfo (function) -ida_idp._processor_t_ana_insn (function) -ida_idp._processor_t_analyze_prolog (function) -ida_idp._processor_t_arch_changed (function) -ida_idp._processor_t_arg_addrs_ready (function) -ida_idp._processor_t_asm_installed (function) -ida_idp._processor_t_assemble (function) -ida_idp._processor_t_auto_queue_empty (function) -ida_idp._processor_t_calc_arglocs (function) -ida_idp._processor_t_calc_cdecl_purged_bytes (function) -ida_idp._processor_t_calc_next_eas (function) -ida_idp._processor_t_calc_purged_bytes (function) -ida_idp._processor_t_calc_retloc (function) -ida_idp._processor_t_calc_spdelta (function) -ida_idp._processor_t_calc_step_over (function) -ida_idp._processor_t_calc_switch_cases (function) -ida_idp._processor_t_calc_varglocs (function) -ida_idp._processor_t_calcrel (function) -ida_idp._processor_t_can_have_type (function) -ida_idp._processor_t_clean_tbit (function) -ida_idp._processor_t_cmp_operands (function) -ida_idp._processor_t_coagulate (function) -ida_idp._processor_t_coagulate_dref (function) -ida_idp._processor_t_create_flat_group (function) -ida_idp._processor_t_create_func_frame (function) -ida_idp._processor_t_create_merge_handlers (function) -ida_idp._processor_t_create_switch_xrefs (function) -ida_idp._processor_t_creating_segm (function) -ida_idp._processor_t_decorate_name (function) -ida_idp._processor_t_del_cref (function) -ida_idp._processor_t_del_dref (function) -ida_idp._processor_t_demangle_name (function) -ida_idp._processor_t_emu_insn (function) -ida_idp._processor_t_endbinary (function) -ida_idp._processor_t_equal_reglocs (function) -ida_idp._processor_t_extract_address (function) -ida_idp._processor_t_find_op_value (function) -ida_idp._processor_t_find_reg_value (function) -ida_idp._processor_t_func_bounds (function) -ida_idp._processor_t_gen_asm_or_lst (function) -ida_idp._processor_t_gen_map_file (function) -ida_idp._processor_t_gen_regvar_def (function) -ida_idp._processor_t_gen_src_file_lnnum (function) -ida_idp._processor_t_gen_stkvar_def (function) -ida_idp._processor_t_get_abi_info (function) -ida_idp._processor_t_get_autocmt (function) -ida_idp._processor_t_get_bg_color (function) -ida_idp._processor_t_get_cc_regs (function) -ida_idp._processor_t_get_code16_mode (function) -ida_idp._processor_t_get_dbr_opnum (function) -ida_idp._processor_t_get_frame_retsize (function) -ida_idp._processor_t_get_idd_opinfo (function) -ida_idp._processor_t_get_macro_insn_head (function) -ida_idp._processor_t_get_operand_string (function) -ida_idp._processor_t_get_reg_accesses (function) -ida_idp._processor_t_get_reg_info (function) -ida_idp._processor_t_get_reg_name (function) -ida_idp._processor_t_get_simd_types (function) -ida_idp._processor_t_get_stkarg_area_info (function) -ida_idp._processor_t_get_stkvar_scale_factor (function) -ida_idp._processor_t_getreg (function) -ida_idp._processor_t_init (function) -ida_idp._processor_t_insn_reads_tbit (function) -ida_idp._processor_t_is_align_insn (function) -ida_idp._processor_t_is_alloca_probe (function) -ida_idp._processor_t_is_basic_block_end (function) -ida_idp._processor_t_is_call_insn (function) -ida_idp._processor_t_is_cond_insn (function) -ida_idp._processor_t_is_control_flow_guard (function) -ida_idp._processor_t_is_far_jump (function) -ida_idp._processor_t_is_indirect_jump (function) -ida_idp._processor_t_is_jump_func (function) -ida_idp._processor_t_is_ret_insn (function) -ida_idp._processor_t_is_sane_insn (function) -ida_idp._processor_t_is_sp_based (function) -ida_idp._processor_t_is_switch (function) -ida_idp._processor_t_loader_elf_machine (function) -ida_idp._processor_t_lower_func_type (function) -ida_idp._processor_t_max_ptr_size (function) -ida_idp._processor_t_may_be_func (function) -ida_idp._processor_t_may_show_sreg (function) -ida_idp._processor_t_moving_segm (function) -ida_idp._processor_t_newasm (function) -ida_idp._processor_t_newbinary (function) -ida_idp._processor_t_newfile (function) -ida_idp._processor_t_newprc (function) -ida_idp._processor_t_next_exec_insn (function) -ida_idp._processor_t_notify (function) -ida_idp._processor_t_oldfile (function) -ida_idp._processor_t_out_assumes (function) -ida_idp._processor_t_out_data (function) -ida_idp._processor_t_out_footer (function) -ida_idp._processor_t_out_header (function) -ida_idp._processor_t_out_insn (function) -ida_idp._processor_t_out_label (function) -ida_idp._processor_t_out_mnem (function) -ida_idp._processor_t_out_operand (function) -ida_idp._processor_t_out_segend (function) -ida_idp._processor_t_out_segstart (function) -ida_idp._processor_t_out_special_item (function) -ida_idp._processor_t_realcvt (function) -ida_idp._processor_t_rename (function) -ida_idp._processor_t_set_code16_mode (function) -ida_idp._processor_t_set_idp_options (function) -ida_idp._processor_t_set_proc_options (function) -ida_idp._processor_t_setup_til (function) -ida_idp._processor_t_str2reg (function) -ida_idp._processor_t_term (function) -ida_idp._processor_t_treat_hindering_item (function) -ida_idp._processor_t_undefine (function) -ida_idp._processor_t_update_call_stack (function) -ida_idp._processor_t_use_arg_types (function) -ida_idp._processor_t_use_regarg_type (function) -ida_idp._processor_t_use_stkarg_type (function) -ida_idp._processor_t_validate_flirt_func (function) -ida_idp._processor_t_verify_noreturn (function) -ida_idp._processor_t_verify_sp (function) -ida_idp.asm_t (class) -ida_idp.asm_t.__init__ (method) -ida_idp.asm_t.a_align (variable) -ida_idp.asm_t.a_ascii (variable) -ida_idp.asm_t.a_band (variable) -ida_idp.asm_t.a_bnot (variable) -ida_idp.asm_t.a_bor (variable) -ida_idp.asm_t.a_bss (variable) -ida_idp.asm_t.a_byte (variable) -ida_idp.asm_t.a_comdef (variable) -ida_idp.asm_t.a_curip (variable) -ida_idp.asm_t.a_double (variable) -ida_idp.asm_t.a_dups (variable) -ida_idp.asm_t.a_dword (variable) -ida_idp.asm_t.a_equ (variable) -ida_idp.asm_t.a_extrn (variable) -ida_idp.asm_t.a_float (variable) -ida_idp.asm_t.a_include_fmt (variable) -ida_idp.asm_t.a_mod (variable) -ida_idp.asm_t.a_oword (variable) -ida_idp.asm_t.a_packreal (variable) -ida_idp.asm_t.a_public (variable) -ida_idp.asm_t.a_qword (variable) -ida_idp.asm_t.a_rva (variable) -ida_idp.asm_t.a_seg (variable) -ida_idp.asm_t.a_shl (variable) -ida_idp.asm_t.a_shr (variable) -ida_idp.asm_t.a_sizeof_fmt (variable) -ida_idp.asm_t.a_tbyte (variable) -ida_idp.asm_t.a_vstruc_fmt (variable) -ida_idp.asm_t.a_weak (variable) -ida_idp.asm_t.a_word (variable) -ida_idp.asm_t.a_xor (variable) -ida_idp.asm_t.a_yword (variable) -ida_idp.asm_t.a_zword (variable) -ida_idp.asm_t.accsep (variable) -ida_idp.asm_t.ascsep (variable) -ida_idp.asm_t.cmnt (variable) -ida_idp.asm_t.cmnt2 (variable) -ida_idp.asm_t.end (variable) -ida_idp.asm_t.esccodes (variable) -ida_idp.asm_t.flag (variable) -ida_idp.asm_t.flag2 (variable) -ida_idp.asm_t.header (variable) -ida_idp.asm_t.help (variable) -ida_idp.asm_t.high16 (variable) -ida_idp.asm_t.high8 (variable) -ida_idp.asm_t.lbrace (variable) -ida_idp.asm_t.low16 (variable) -ida_idp.asm_t.low8 (variable) -ida_idp.asm_t.name (variable) -ida_idp.asm_t.origin (variable) -ida_idp.asm_t.rbrace (variable) -ida_idp.asm_t.uflag (variable) -ida_idp.assemble (function) -ida_idp.cfg_get_cc_header_path (function) -ida_idp.cfg_get_cc_parm (function) -ida_idp.cfg_get_cc_predefined_macros (function) -ida_idp.delay_slot_insn (function) -ida_idp.gen_idb_event (function) -ida_idp.get_ash (function) -ida_idp.get_config_value (function) -ida_idp.get_idb_notifier_addr (function) -ida_idp.get_idb_notifier_ud_addr (function) -ida_idp.get_idp_name (function) -ida_idp.get_idp_notifier_addr (function) -ida_idp.get_idp_notifier_ud_addr (function) -ida_idp.get_ph (function) -ida_idp.get_reg_info (function) -ida_idp.get_reg_name (function) -ida_idp.has_cf_chg (function) -ida_idp.has_cf_use (function) -ida_idp.has_insn_feature (function) -ida_idp.is_align_insn (function) -ida_idp.is_basic_block_end (function) -ida_idp.is_call_insn (function) -ida_idp.is_indirect_jump_insn (function) -ida_idp.is_ret_insn (function) -ida_idp.num_range_t (class) -ida_idp.num_range_t.__init__ (method) -ida_idp.params_t (class) -ida_idp.params_t.__init__ (method) -ida_idp.parse_reg_name (function) -ida_idp.ph_calcrel (function) -ida_idp.ph_find_op_value (function) -ida_idp.ph_find_reg_value (function) -ida_idp.ph_get_cnbits (function) -ida_idp.ph_get_dnbits (function) -ida_idp.ph_get_flag (function) -ida_idp.ph_get_icode_return (function) -ida_idp.ph_get_id (function) -ida_idp.ph_get_instruc (function) -ida_idp.ph_get_instruc_end (function) -ida_idp.ph_get_instruc_start (function) -ida_idp.ph_get_operand_info (function) -ida_idp.ph_get_reg_accesses (function) -ida_idp.ph_get_reg_code_sreg (function) -ida_idp.ph_get_reg_data_sreg (function) -ida_idp.ph_get_reg_first_sreg (function) -ida_idp.ph_get_reg_last_sreg (function) -ida_idp.ph_get_regnames (function) -ida_idp.ph_get_segreg_size (function) -ida_idp.ph_get_tbyte_size (function) -ida_idp.ph_get_version (function) -ida_idp.process_config_directive (function) -ida_idp.processor_t (class) -ida_idp.processor_t.__init__ (method) -ida_idp.processor_t._get_idb_notifier_addr (method) -ida_idp.processor_t._get_idb_notifier_ud_addr (method) -ida_idp.processor_t._get_idp_notifier_addr (method) -ida_idp.processor_t._get_idp_notifier_ud_addr (method) -ida_idp.processor_t._get_notify (method) -ida_idp.processor_t._make_forced_value_wrapper (method) -ida_idp.processor_t._make_forced_value_wrapper.f (function) -ida_idp.processor_t._make_int_returning_wrapper (method) -ida_idp.processor_t._make_int_returning_wrapper.f (function) -ida_idp.processor_t.auto_empty (method) -ida_idp.processor_t.auto_empty_finally (method) -ida_idp.processor_t.closebase (method) -ida_idp.processor_t.compiler_changed (method) -ida_idp.processor_t.deleting_func (method) -ida_idp.processor_t.determined_main (method) -ida_idp.processor_t.ev_ana_insn (method) -ida_idp.processor_t.ev_assemble (method) -ida_idp.processor_t.ev_auto_queue_empty (method) -ida_idp.processor_t.ev_calc_step_over (method) -ida_idp.processor_t.ev_can_have_type (method) -ida_idp.processor_t.ev_cmp_operands (method) -ida_idp.processor_t.ev_coagulate (method) -ida_idp.processor_t.ev_coagulate_dref (method) -ida_idp.processor_t.ev_create_func_frame (method) -ida_idp.processor_t.ev_create_switch_xrefs (method) -ida_idp.processor_t.ev_creating_segm (method) -ida_idp.processor_t.ev_emu_insn (method) -ida_idp.processor_t.ev_endbinary (method) -ida_idp.processor_t.ev_func_bounds (method) -ida_idp.processor_t.ev_gen_map_file (method) -ida_idp.processor_t.ev_gen_regvar_def (method) -ida_idp.processor_t.ev_gen_src_file_lnnum (method) -ida_idp.processor_t.ev_get_autocmt (method) -ida_idp.processor_t.ev_get_frame_retsize (method) -ida_idp.processor_t.ev_get_operand_string (method) -ida_idp.processor_t.ev_is_align_insn (method) -ida_idp.processor_t.ev_is_alloca_probe (method) -ida_idp.processor_t.ev_is_basic_block_end (method) -ida_idp.processor_t.ev_is_call_insn (method) -ida_idp.processor_t.ev_is_far_jump (method) -ida_idp.processor_t.ev_is_indirect_jump (method) -ida_idp.processor_t.ev_is_insn_table_jump (method) -ida_idp.processor_t.ev_is_ret_insn (method) -ida_idp.processor_t.ev_is_sane_insn (method) -ida_idp.processor_t.ev_is_sp_based (method) -ida_idp.processor_t.ev_is_switch (method) -ida_idp.processor_t.ev_may_be_func (method) -ida_idp.processor_t.ev_may_show_sreg (method) -ida_idp.processor_t.ev_moving_segm (method) -ida_idp.processor_t.ev_newbinary (method) -ida_idp.processor_t.ev_newfile (method) -ida_idp.processor_t.ev_newprc (method) -ida_idp.processor_t.ev_oldfile (method) -ida_idp.processor_t.ev_out_assumes (method) -ida_idp.processor_t.ev_out_data (method) -ida_idp.processor_t.ev_out_footer (method) -ida_idp.processor_t.ev_out_header (method) -ida_idp.processor_t.ev_out_insn (method) -ida_idp.processor_t.ev_out_label (method) -ida_idp.processor_t.ev_out_mnem (method) -ida_idp.processor_t.ev_out_operand (method) -ida_idp.processor_t.ev_out_segend (method) -ida_idp.processor_t.ev_out_segstart (method) -ida_idp.processor_t.ev_out_special_item (method) -ida_idp.processor_t.ev_rename (method) -ida_idp.processor_t.ev_set_idp_options (method) -ida_idp.processor_t.ev_set_proc_options (method) -ida_idp.processor_t.ev_str2reg (method) -ida_idp.processor_t.ev_treat_hindering_item (method) -ida_idp.processor_t.ev_undefine (method) -ida_idp.processor_t.ev_validate_flirt_func (method) -ida_idp.processor_t.ev_verify_noreturn (method) -ida_idp.processor_t.ev_verify_sp (method) -ida_idp.processor_t.func_added (method) -ida_idp.processor_t.get_auxpref (method) -ida_idp.processor_t.get_idpdesc (method) -ida_idp.processor_t.get_uFlag (method) -ida_idp.processor_t.idasgn_loaded (method) -ida_idp.processor_t.kernel_config_loaded (method) -ida_idp.processor_t.make_code (method) -ida_idp.processor_t.make_data (method) -ida_idp.processor_t.renamed (method) -ida_idp.processor_t.savebase (method) -ida_idp.processor_t.segm_moved (method) -ida_idp.processor_t.set_func_end (method) -ida_idp.processor_t.set_func_start (method) -ida_idp.processor_t.sgr_changed (method) -ida_idp.reg_access_t (class) -ida_idp.reg_access_t.__eq__ (method) -ida_idp.reg_access_t.__init__ (method) -ida_idp.reg_access_t.__ne__ (method) -ida_idp.reg_access_t.have_common_bits (method) -ida_idp.reg_access_t.opnum (variable) -ida_idp.reg_access_t.range (variable) -ida_idp.reg_access_t.regnum (variable) -ida_idp.reg_access_vec_t (class) -ida_idp.reg_access_vec_t.__eq__ (method) -ida_idp.reg_access_vec_t.__getitem__ (method) -ida_idp.reg_access_vec_t.__init__ (method) -ida_idp.reg_access_vec_t.__len__ (method) -ida_idp.reg_access_vec_t.__ne__ (method) -ida_idp.reg_access_vec_t.__setitem__ (method) -ida_idp.reg_access_vec_t._del (method) -ida_idp.reg_access_vec_t.add_unique (method) -ida_idp.reg_access_vec_t.at (method) -ida_idp.reg_access_vec_t.begin (method) -ida_idp.reg_access_vec_t.capacity (method) -ida_idp.reg_access_vec_t.clear (method) -ida_idp.reg_access_vec_t.empty (method) -ida_idp.reg_access_vec_t.end (method) -ida_idp.reg_access_vec_t.erase (method) -ida_idp.reg_access_vec_t.extract (method) -ida_idp.reg_access_vec_t.find (method) -ida_idp.reg_access_vec_t.grow (method) -ida_idp.reg_access_vec_t.has (method) -ida_idp.reg_access_vec_t.inject (method) -ida_idp.reg_access_vec_t.insert (method) -ida_idp.reg_access_vec_t.pop_back (method) -ida_idp.reg_access_vec_t.push_back (method) -ida_idp.reg_access_vec_t.qclear (method) -ida_idp.reg_access_vec_t.reserve (method) -ida_idp.reg_access_vec_t.resize (method) -ida_idp.reg_access_vec_t.size (method) -ida_idp.reg_access_vec_t.swap (method) -ida_idp.reg_access_vec_t.truncate (method) -ida_idp.reg_accesses_t (class) -ida_idp.reg_accesses_t.__init__ (method) -ida_idp.reg_info_t (class) -ida_idp.reg_info_t.__eq__ (method) -ida_idp.reg_info_t.__ge__ (method) -ida_idp.reg_info_t.__gt__ (method) -ida_idp.reg_info_t.__init__ (method) -ida_idp.reg_info_t.__le__ (method) -ida_idp.reg_info_t.__lt__ (method) -ida_idp.reg_info_t.__ne__ (method) -ida_idp.reg_info_t.compare (method) -ida_idp.reg_info_t.reg (variable) -ida_idp.reg_info_t.size (variable) -ida_idp.register_cfgopts (function) -ida_idp.set_processor_type (function) -ida_idp.set_target_assembler (function) -ida_idp.sizeof_ldbl (function) -ida_idp.str2reg (function) -ida_ieee (module) -ida_ieee.E_SPECIAL_EXP (variable) -ida_ieee.FPV_BADARG (variable) -ida_ieee.FPV_NAN (variable) -ida_ieee.FPV_NINF (variable) -ida_ieee.FPV_NORM (variable) -ida_ieee.FPV_PINF (variable) -ida_ieee.IEEE_EXONE (variable) -ida_ieee.REAL_ERROR_FPOVER (variable) -ida_ieee.REAL_ERROR_INTOVER (variable) -ida_ieee.REAL_ERROR_OK (variable) -ida_ieee.ecleaz (function) -ida_ieee.fpvalue_shorts_array_t (class) -ida_ieee.fpvalue_shorts_array_t.__getitem__ (method) -ida_ieee.fpvalue_shorts_array_t.__init__ (method) -ida_ieee.fpvalue_shorts_array_t.__len__ (method) -ida_ieee.fpvalue_shorts_array_t.__setitem__ (method) -ida_ieee.fpvalue_shorts_array_t._get_bytes (method) -ida_ieee.fpvalue_shorts_array_t._set_bytes (method) -ida_ieee.fpvalue_t (class) -ida_ieee.fpvalue_t.__add__ (method) -ida_ieee.fpvalue_t.__eq__ (method) -ida_ieee.fpvalue_t.__ge__ (method) -ida_ieee.fpvalue_t.__getitem__ (method) -ida_ieee.fpvalue_t.__gt__ (method) -ida_ieee.fpvalue_t.__init__ (method) -ida_ieee.fpvalue_t.__iter__ (method) -ida_ieee.fpvalue_t.__le__ (method) -ida_ieee.fpvalue_t.__lt__ (method) -ida_ieee.fpvalue_t.__mul__ (method) -ida_ieee.fpvalue_t.__ne__ (method) -ida_ieee.fpvalue_t.__setitem__ (method) -ida_ieee.fpvalue_t.__str__ (method) -ida_ieee.fpvalue_t.__sub__ (method) -ida_ieee.fpvalue_t.__truediv__ (method) -ida_ieee.fpvalue_t._get_10bytes (method) -ida_ieee.fpvalue_t._get_bytes (method) -ida_ieee.fpvalue_t._get_float (method) -ida_ieee.fpvalue_t._get_shorts (method) -ida_ieee.fpvalue_t._set_10bytes (method) -ida_ieee.fpvalue_t._set_bytes (method) -ida_ieee.fpvalue_t._set_float (method) -ida_ieee.fpvalue_t.assign (method) -ida_ieee.fpvalue_t.clear (method) -ida_ieee.fpvalue_t.compare (method) -ida_ieee.fpvalue_t.eabs (method) -ida_ieee.fpvalue_t.fadd (method) -ida_ieee.fpvalue_t.fdiv (method) -ida_ieee.fpvalue_t.fmul (method) -ida_ieee.fpvalue_t.from_10bytes (method) -ida_ieee.fpvalue_t.from_12bytes (method) -ida_ieee.fpvalue_t.from_int64 (method) -ida_ieee.fpvalue_t.from_str (method) -ida_ieee.fpvalue_t.from_sval (method) -ida_ieee.fpvalue_t.from_uint64 (method) -ida_ieee.fpvalue_t.fsub (method) -ida_ieee.fpvalue_t.get_kind (method) -ida_ieee.fpvalue_t.is_negative (method) -ida_ieee.fpvalue_t.mul_pow2 (method) -ida_ieee.fpvalue_t.negate (method) -ida_ieee.fpvalue_t.to_10bytes (method) -ida_ieee.fpvalue_t.to_12bytes (method) -ida_ieee.fpvalue_t.to_int64 (method) -ida_ieee.fpvalue_t.to_str (method) -ida_ieee.fpvalue_t.to_sval (method) -ida_ieee.fpvalue_t.to_uint64 (method) -ida_kernwin (module) -ida_kernwin.AA_CHECKABLE (variable) -ida_kernwin.AA_CHECKED (variable) -ida_kernwin.AA_ICON (variable) -ida_kernwin.AA_LABEL (variable) -ida_kernwin.AA_NONE (variable) -ida_kernwin.AA_SHORTCUT (variable) -ida_kernwin.AA_STATE (variable) -ida_kernwin.AA_TOOLTIP (variable) -ida_kernwin.AA_VISIBILITY (variable) -ida_kernwin.ACF_HAS_FIELD_DIRTREE_SELECTION (variable) -ida_kernwin.ACF_HAS_SELECTION (variable) -ida_kernwin.ACF_HAS_SOURCE (variable) -ida_kernwin.ACF_HAS_TYPE_REF (variable) -ida_kernwin.ACF_XTRN_EA (variable) -ida_kernwin.ADF_CHECKABLE (variable) -ida_kernwin.ADF_CHECKED (variable) -ida_kernwin.ADF_GLOBAL (variable) -ida_kernwin.ADF_NO_HIGHLIGHT (variable) -ida_kernwin.ADF_NO_UNDO (variable) -ida_kernwin.ADF_OT_MASK (variable) -ida_kernwin.ADF_OT_PLUGIN (variable) -ida_kernwin.ADF_OT_PLUGMOD (variable) -ida_kernwin.ADF_OT_PROCMOD (variable) -ida_kernwin.ADF_OWN_HANDLER (variable) -ida_kernwin.AHF_VERSION (variable) -ida_kernwin.AHF_VERSION_MASK (variable) -ida_kernwin.ASKBTN_BTN1 (variable) -ida_kernwin.ASKBTN_BTN2 (variable) -ida_kernwin.ASKBTN_BTN3 (variable) -ida_kernwin.ASKBTN_CANCEL (variable) -ida_kernwin.ASKBTN_NO (variable) -ida_kernwin.ASKBTN_YES (variable) -ida_kernwin.AST_DISABLE (variable) -ida_kernwin.AST_DISABLE_ALWAYS (variable) -ida_kernwin.AST_DISABLE_FOR_IDB (variable) -ida_kernwin.AST_DISABLE_FOR_WIDGET (variable) -ida_kernwin.AST_ENABLE (variable) -ida_kernwin.AST_ENABLE_ALWAYS (variable) -ida_kernwin.AST_ENABLE_FOR_IDB (variable) -ida_kernwin.AST_ENABLE_FOR_WIDGET (variable) -ida_kernwin.BWN_ADDRWATCH (variable) -ida_kernwin.BWN_BOOKMARKS (variable) -ida_kernwin.BWN_BPTS (variable) -ida_kernwin.BWN_CALLS (variable) -ida_kernwin.BWN_CALLS_CALLEES (variable) -ida_kernwin.BWN_CALLS_CALLERS (variable) -ida_kernwin.BWN_CALL_STACK (variable) -ida_kernwin.BWN_CHOOSER (variable) -ida_kernwin.BWN_CLI (variable) -ida_kernwin.BWN_CMDPALCSR (variable) -ida_kernwin.BWN_CMDPALWIN (variable) -ida_kernwin.BWN_CPUREGS (variable) -ida_kernwin.BWN_CUSTVIEW (variable) -ida_kernwin.BWN_CV_LINE_INFOS (variable) -ida_kernwin.BWN_DISASM (variable) -ida_kernwin.BWN_DISASMS (variable) -ida_kernwin.BWN_DISASM_ARROWS (variable) -ida_kernwin.BWN_DUMP (variable) -ida_kernwin.BWN_DUMPS (variable) -ida_kernwin.BWN_ENUMS (variable) -ida_kernwin.BWN_EXPORTS (variable) -ida_kernwin.BWN_FRAME (variable) -ida_kernwin.BWN_FUNCS (variable) -ida_kernwin.BWN_IMPORTS (variable) -ida_kernwin.BWN_LOCALS (variable) -ida_kernwin.BWN_LOCTYPS (variable) -ida_kernwin.BWN_MDVIEWCSR (variable) -ida_kernwin.BWN_MODULES (variable) -ida_kernwin.BWN_NAMES (variable) -ida_kernwin.BWN_NAVBAND (variable) -ida_kernwin.BWN_NOTEPAD (variable) -ida_kernwin.BWN_OUTPUT (variable) -ida_kernwin.BWN_PROBS (variable) -ida_kernwin.BWN_PSEUDOCODE (variable) -ida_kernwin.BWN_SCRIPTS_CSR (variable) -ida_kernwin.BWN_SEARCH (variable) -ida_kernwin.BWN_SEARCHS (variable) -ida_kernwin.BWN_SEGREGS (variable) -ida_kernwin.BWN_SEGS (variable) -ida_kernwin.BWN_SELS (variable) -ida_kernwin.BWN_SHORTCUTCSR (variable) -ida_kernwin.BWN_SHORTCUTWIN (variable) -ida_kernwin.BWN_SIGNS (variable) -ida_kernwin.BWN_SNIPPETS (variable) -ida_kernwin.BWN_SNIPPETS_CSR (variable) -ida_kernwin.BWN_SO_OFFSETS (variable) -ida_kernwin.BWN_SO_STRUCTS (variable) -ida_kernwin.BWN_SRCPTHMAP_CSR (variable) -ida_kernwin.BWN_SRCPTHUND_CSR (variable) -ida_kernwin.BWN_STACK (variable) -ida_kernwin.BWN_STKVIEW (variable) -ida_kernwin.BWN_STRINGS (variable) -ida_kernwin.BWN_STRUCTS (variable) -ida_kernwin.BWN_THREADS (variable) -ida_kernwin.BWN_TILIST (variable) -ida_kernwin.BWN_TILS (variable) -ida_kernwin.BWN_TRACE (variable) -ida_kernwin.BWN_UNDOHIST (variable) -ida_kernwin.BWN_UNKNOWN (variable) -ida_kernwin.BWN_WATCH (variable) -ida_kernwin.BWN_XREFS (variable) -ida_kernwin.CDVF_LINEICONS (variable) -ida_kernwin.CDVF_NOLINES (variable) -ida_kernwin.CDVF_STATUSBAR (variable) -ida_kernwin.CDVH_LINES_ALIGNMENT (variable) -ida_kernwin.CDVH_LINES_CLICK (variable) -ida_kernwin.CDVH_LINES_DBLCLICK (variable) -ida_kernwin.CDVH_LINES_DRAWICON (variable) -ida_kernwin.CDVH_LINES_ICONMARGIN (variable) -ida_kernwin.CDVH_LINES_LINENUM (variable) -ida_kernwin.CDVH_LINES_POPUP (variable) -ida_kernwin.CDVH_LINES_RADIX (variable) -ida_kernwin.CDVH_SRCVIEW (variable) -ida_kernwin.CDVH_USERDATA (variable) -ida_kernwin.CH2_LAZY_LOADED (variable) -ida_kernwin.CHCOL_DEC (variable) -ida_kernwin.CHCOL_DEFHIDDEN (variable) -ida_kernwin.CHCOL_DRAGHINT (variable) -ida_kernwin.CHCOL_EA (variable) -ida_kernwin.CHCOL_FNAME (variable) -ida_kernwin.CHCOL_FORMAT (variable) -ida_kernwin.CHCOL_HEX (variable) -ida_kernwin.CHCOL_INODENAME (variable) -ida_kernwin.CHCOL_PATH (variable) -ida_kernwin.CHCOL_PLAIN (variable) -ida_kernwin.CHITEM_BOLD (variable) -ida_kernwin.CHITEM_GRAY (variable) -ida_kernwin.CHITEM_ITALIC (variable) -ida_kernwin.CHITEM_STRIKE (variable) -ida_kernwin.CHITEM_UNDER (variable) -ida_kernwin.CHOOSER_NOMAINMENU (variable) -ida_kernwin.CHOOSER_NOSTATUSBAR (variable) -ida_kernwin.CH_ATTRS (variable) -ida_kernwin.CH_BUILTIN_MASK (variable) -ida_kernwin.CH_CAN_DEL (variable) -ida_kernwin.CH_CAN_EDIT (variable) -ida_kernwin.CH_CAN_INS (variable) -ida_kernwin.CH_CAN_REFRESH (variable) -ida_kernwin.CH_FORCE_DEFAULT (variable) -ida_kernwin.CH_HAS_DIFF (variable) -ida_kernwin.CH_HAS_DIRTREE (variable) -ida_kernwin.CH_KEEP (variable) -ida_kernwin.CH_MODAL (variable) -ida_kernwin.CH_MULTI (variable) -ida_kernwin.CH_MULTI_EDIT (variable) -ida_kernwin.CH_NOBTNS (variable) -ida_kernwin.CH_NON_PERSISTED_TREE (variable) -ida_kernwin.CH_NO_FILTER (variable) -ida_kernwin.CH_NO_SORT (variable) -ida_kernwin.CH_NO_STATUS_BAR (variable) -ida_kernwin.CH_QFLT (variable) -ida_kernwin.CH_QFTYP_DEFAULT (variable) -ida_kernwin.CH_QFTYP_FUZZY (variable) -ida_kernwin.CH_QFTYP_NORMAL (variable) -ida_kernwin.CH_QFTYP_REGEX (variable) -ida_kernwin.CH_QFTYP_WHOLE_WORDS (variable) -ida_kernwin.CH_RENAME_IS_EDIT (variable) -ida_kernwin.CH_RESTORE (variable) -ida_kernwin.CH_TM_FOLDERS_ONLY (variable) -ida_kernwin.CH_TM_FULL_TREE (variable) -ida_kernwin.CH_TM_NO_TREE (variable) -ida_kernwin.CK_EXTRA1 (variable) -ida_kernwin.CK_EXTRA10 (variable) -ida_kernwin.CK_EXTRA11 (variable) -ida_kernwin.CK_EXTRA12 (variable) -ida_kernwin.CK_EXTRA13 (variable) -ida_kernwin.CK_EXTRA14 (variable) -ida_kernwin.CK_EXTRA15 (variable) -ida_kernwin.CK_EXTRA16 (variable) -ida_kernwin.CK_EXTRA2 (variable) -ida_kernwin.CK_EXTRA3 (variable) -ida_kernwin.CK_EXTRA4 (variable) -ida_kernwin.CK_EXTRA5 (variable) -ida_kernwin.CK_EXTRA6 (variable) -ida_kernwin.CK_EXTRA7 (variable) -ida_kernwin.CK_EXTRA8 (variable) -ida_kernwin.CK_EXTRA9 (variable) -ida_kernwin.CK_TRACE (variable) -ida_kernwin.CK_TRACE_OVL (variable) -ida_kernwin.CLNL_FINDCMT (variable) -ida_kernwin.CLNL_LTRIM (variable) -ida_kernwin.CLNL_RTRIM (variable) -ida_kernwin.CREATETB_ADV (variable) -ida_kernwin.CVH_CLICK (variable) -ida_kernwin.CVH_CLOSE (variable) -ida_kernwin.CVH_CURPOS (variable) -ida_kernwin.CVH_DBLCLICK (variable) -ida_kernwin.CVH_HELP (variable) -ida_kernwin.CVH_KEYDOWN (variable) -ida_kernwin.CVH_MOUSEMOVE (variable) -ida_kernwin.CVH_POPUP (variable) -ida_kernwin.CVH_QT_AWARE (variable) -ida_kernwin.CVLF_USE_MOUSE (variable) -ida_kernwin.CVNF_ACT (variable) -ida_kernwin.CVNF_JUMP (variable) -ida_kernwin.CVNF_LAZY (variable) -ida_kernwin.Choose (class) -ida_kernwin.Choose.ALREADY_EXISTS (variable) -ida_kernwin.Choose.Activate (method) -ida_kernwin.Choose.AddCommand (method) -ida_kernwin.Choose.CH_CAN_DEL (variable) -ida_kernwin.Choose.CH_CAN_EDIT (variable) -ida_kernwin.Choose.CH_CAN_INS (variable) -ida_kernwin.Choose.CH_CAN_REFRESH (variable) -ida_kernwin.Choose.CH_FORCE_DEFAULT (variable) -ida_kernwin.Choose.CH_MODAL (variable) -ida_kernwin.Choose.CH_MULTI (variable) -ida_kernwin.Choose.CH_NOIDB (variable) -ida_kernwin.Choose.CH_NO_STATUS_BAR (variable) -ida_kernwin.Choose.CH_QFLT (variable) -ida_kernwin.Choose.CH_RENAME_IS_EDIT (variable) -ida_kernwin.Choose.CH_RESTORE (variable) -ida_kernwin.Choose.Close (method) -ida_kernwin.Choose.EMPTY_CHOOSER (variable) -ida_kernwin.Choose.Embedded (method) -ida_kernwin.Choose.GetEmbSelection (method) -ida_kernwin.Choose.GetWidget (method) -ida_kernwin.Choose.NO_ATTR (variable) -ida_kernwin.Choose.NO_SELECTION (variable) -ida_kernwin.Choose.OnClose (method) -ida_kernwin.Choose.OnDeleteLine (method) -ida_kernwin.Choose.OnEditLine (method) -ida_kernwin.Choose.OnGetDirTree (method) -ida_kernwin.Choose.OnGetEA (method) -ida_kernwin.Choose.OnGetIcon (method) -ida_kernwin.Choose.OnGetLine (method) -ida_kernwin.Choose.OnGetLineAttr (method) -ida_kernwin.Choose.OnGetSize (method) -ida_kernwin.Choose.OnIndexToDiffpos (method) -ida_kernwin.Choose.OnIndexToInode (method) -ida_kernwin.Choose.OnInit (method) -ida_kernwin.Choose.OnInsertLine (method) -ida_kernwin.Choose.OnLazyLoadDir (method) -ida_kernwin.Choose.OnPopup (method) -ida_kernwin.Choose.OnRefresh (method) -ida_kernwin.Choose.OnSelectLine (method) -ida_kernwin.Choose.OnSelectionChange (method) -ida_kernwin.Choose.Refresh (method) -ida_kernwin.Choose.Show (method) -ida_kernwin.Choose.UI_Hooks_Trampoline (class) -ida_kernwin.Choose.UI_Hooks_Trampoline.__init__ (method) -ida_kernwin.Choose.UI_Hooks_Trampoline.populating_widget_popup (method) -ida_kernwin.Choose.__init__ (method) -ida_kernwin.Choose.__init__._qccb (function) -ida_kernwin.Choose.adjust_last_item (method) -ida_kernwin.CustomIDAMemo (class) -ida_kernwin.CustomIDAMemo.CreateGroups (method) -ida_kernwin.CustomIDAMemo.DelNodesInfos (method) -ida_kernwin.CustomIDAMemo.DeleteGroups (method) -ida_kernwin.CustomIDAMemo.GetCurrentRendererType (method) -ida_kernwin.CustomIDAMemo.GetNodeInfo (method) -ida_kernwin.CustomIDAMemo.GetWidget (method) -ida_kernwin.CustomIDAMemo.GetWidgetAsGraphViewer (method) -ida_kernwin.CustomIDAMemo.Refresh (method) -ida_kernwin.CustomIDAMemo.SetCurrentRendererType (method) -ida_kernwin.CustomIDAMemo.SetGroupsVisibility (method) -ida_kernwin.CustomIDAMemo.SetNodeInfo (method) -ida_kernwin.CustomIDAMemo.SetNodesInfos (method) -ida_kernwin.CustomIDAMemo._OnBind (method) -ida_kernwin.CustomIDAMemo.__init__ (method) -ida_kernwin.CustomIDAMemo._dummy_cb (method) -ida_kernwin.CustomIDAMemo._get_cb (method) -ida_kernwin.CustomIDAMemo._get_cb_arity (method) -ida_kernwin.CustomIDAMemo._graph_item_tuple (method) -ida_kernwin.CustomIDAMemo.view_activated (method) -ida_kernwin.CustomIDAMemo.view_click (method) -ida_kernwin.CustomIDAMemo.view_close (method) -ida_kernwin.CustomIDAMemo.view_curpos (method) -ida_kernwin.CustomIDAMemo.view_dblclick (method) -ida_kernwin.CustomIDAMemo.view_deactivated (method) -ida_kernwin.CustomIDAMemo.view_keydown (method) -ida_kernwin.CustomIDAMemo.view_loc_changed (method) -ida_kernwin.CustomIDAMemo.view_mouse_moved (method) -ida_kernwin.CustomIDAMemo.view_mouse_over (method) -ida_kernwin.CustomIDAMemo.view_switched (method) -ida_kernwin.DP_BEFORE (variable) -ida_kernwin.DP_BOTTOM (variable) -ida_kernwin.DP_FLOATING (variable) -ida_kernwin.DP_INSIDE (variable) -ida_kernwin.DP_LEFT (variable) -ida_kernwin.DP_RIGHT (variable) -ida_kernwin.DP_SZHINT (variable) -ida_kernwin.DP_TAB (variable) -ida_kernwin.DP_TOP (variable) -ida_kernwin.Form (class) -ida_kernwin.Form.Add (method) -ida_kernwin.Form.AddControls (method) -ida_kernwin.Form.ButtonInput (class) -ida_kernwin.Form.ButtonInput.__init__ (method) -ida_kernwin.Form.ButtonInput.helper_cb (method) -ida_kernwin.Form.ButtonInput.is_input_field (method) -ida_kernwin.Form.ChkGroupControl (class) -ida_kernwin.Form.ChkGroupControl.ItemClass (variable) -ida_kernwin.Form.ChkGroupControl.__init__ (method) -ida_kernwin.Form.ChkGroupItemControl (class) -ida_kernwin.Form.ChkGroupItemControl.__get_value (method) -ida_kernwin.Form.ChkGroupItemControl.__init__ (method) -ida_kernwin.Form.ChkGroupItemControl.__set_value (method) -ida_kernwin.Form.ChkGroupItemControl.checked (variable) -ida_kernwin.Form.Close (method) -ida_kernwin.Form.ColorInput (class) -ida_kernwin.Form.ColorInput.__init__ (method) -ida_kernwin.Form.Compile (method) -ida_kernwin.Form.CompileEx (method) -ida_kernwin.Form.CompileEx.next_control (function) -ida_kernwin.Form.Compiled (method) -ida_kernwin.Form.Control (class) -ida_kernwin.Form.Control.__init__ (method) -ida_kernwin.Form.Control.free (method) -ida_kernwin.Form.Control.get_arg (method) -ida_kernwin.Form.Control.get_tag (method) -ida_kernwin.Form.Control.is_input_field (method) -ida_kernwin.Form.ControlToFieldTypeIdAndSize (method) -ida_kernwin.Form.DirInput (class) -ida_kernwin.Form.DirInput.__init__ (method) -ida_kernwin.Form.DropdownListControl (class) -ida_kernwin.Form.DropdownListControl.__get_selval (method) -ida_kernwin.Form.DropdownListControl.__init__ (method) -ida_kernwin.Form.DropdownListControl.__set_selval (method) -ida_kernwin.Form.DropdownListControl.free (method) -ida_kernwin.Form.DropdownListControl.selval (variable) -ida_kernwin.Form.DropdownListControl.set_items (method) -ida_kernwin.Form.EmbeddedChooserControl (class) -ida_kernwin.Form.EmbeddedChooserControl.__get_selection__ (method) -ida_kernwin.Form.EmbeddedChooserControl.__init__ (method) -ida_kernwin.Form.EmbeddedChooserControl.free (method) -ida_kernwin.Form.EmbeddedChooserControl.selection (variable) -ida_kernwin.Form.EmbeddedChooserControl.value (variable) -ida_kernwin.Form.EnableField (method) -ida_kernwin.Form.Execute (method) -ida_kernwin.Form.FT_ADDR (variable) -ida_kernwin.Form.FT_ASCII (variable) -ida_kernwin.Form.FT_BIN (variable) -ida_kernwin.Form.FT_BUTTON (variable) -ida_kernwin.Form.FT_CHAR (variable) -ida_kernwin.Form.FT_COLOR (variable) -ida_kernwin.Form.FT_DEC (variable) -ida_kernwin.Form.FT_DIR (variable) -ida_kernwin.Form.FT_DROPDOWN_LIST (variable) -ida_kernwin.Form.FT_ECHOOSER (variable) -ida_kernwin.Form.FT_FILE (variable) -ida_kernwin.Form.FT_FORMCHG (variable) -ida_kernwin.Form.FT_HEX (variable) -ida_kernwin.Form.FT_HTML_LABEL (variable) -ida_kernwin.Form.FT_IDENT (variable) -ida_kernwin.Form.FT_INT64 (variable) -ida_kernwin.Form.FT_MULTI_LINE_TEXT (variable) -ida_kernwin.Form.FT_OCT (variable) -ida_kernwin.Form.FT_RAWHEX (variable) -ida_kernwin.Form.FT_SEG (variable) -ida_kernwin.Form.FT_SHEX (variable) -ida_kernwin.Form.FT_TYPE (variable) -ida_kernwin.Form.FT_UINT64 (variable) -ida_kernwin.Form.FileInput (class) -ida_kernwin.Form.FileInput.__init__ (method) -ida_kernwin.Form.FindControlById (method) -ida_kernwin.Form.FormChangeCb (class) -ida_kernwin.Form.FormChangeCb.__init__ (method) -ida_kernwin.Form.FormChangeCb.free (method) -ida_kernwin.Form.FormChangeCb.get_tag (method) -ida_kernwin.Form.FormChangeCb.helper_cb (method) -ida_kernwin.Form.Free (method) -ida_kernwin.Form.GetControlValue (method) -ida_kernwin.Form.GetFocusedField (method) -ida_kernwin.Form.GroupControl (class) -ida_kernwin.Form.GroupControl.__init__ (method) -ida_kernwin.Form.GroupControl._reset (method) -ida_kernwin.Form.GroupControl.get_tag (method) -ida_kernwin.Form.GroupControl.next_child_pos (method) -ida_kernwin.Form.GroupItemControl (class) -ida_kernwin.Form.GroupItemControl.__init__ (method) -ida_kernwin.Form.GroupItemControl.assign_pos (method) -ida_kernwin.Form.GroupItemControl.get_tag (method) -ida_kernwin.Form.GroupItemControl.is_input_field (method) -ida_kernwin.Form.InputControl (class) -ida_kernwin.Form.InputControl.__init__ (method) -ida_kernwin.Form.InputControl.get_tag (method) -ida_kernwin.Form.InputControl.is_input_field (method) -ida_kernwin.Form.LabelControl (class) -ida_kernwin.Form.LabelControl.__init__ (method) -ida_kernwin.Form.LabelControl.get_tag (method) -ida_kernwin.Form.MoveField (method) -ida_kernwin.Form.MultiLineTextControl (class) -ida_kernwin.Form.MultiLineTextControl.__init__ (method) -ida_kernwin.Form.MultiLineTextControl.free (method) -ida_kernwin.Form.NumericArgument (class) -ida_kernwin.Form.NumericArgument.__init__ (method) -ida_kernwin.Form.NumericArgument.__set_value (method) -ida_kernwin.Form.NumericInput (class) -ida_kernwin.Form.NumericInput.__init__ (method) -ida_kernwin.Form.NumericLabel (class) -ida_kernwin.Form.NumericLabel.__init__ (method) -ida_kernwin.Form.Open (method) -ida_kernwin.Form.RadGroupControl (class) -ida_kernwin.Form.RadGroupControl.__init__ (method) -ida_kernwin.Form.RadGroupItemControl (class) -ida_kernwin.Form.RadGroupItemControl.__get_value (method) -ida_kernwin.Form.RadGroupItemControl.__init__ (method) -ida_kernwin.Form.RadGroupItemControl.__set_value (method) -ida_kernwin.Form.RadGroupItemControl.selected (variable) -ida_kernwin.Form.RefreshField (method) -ida_kernwin.Form.SetControlValue (method) -ida_kernwin.Form.SetFocusedField (method) -ida_kernwin.Form.ShowField (method) -ida_kernwin.Form.StringArgument (class) -ida_kernwin.Form.StringArgument.__get_value (method) -ida_kernwin.Form.StringArgument.__init__ (method) -ida_kernwin.Form.StringArgument.__set_value (method) -ida_kernwin.Form.StringInput (class) -ida_kernwin.Form.StringInput.__init__ (method) -ida_kernwin.Form.StringLabel (class) -ida_kernwin.Form.StringLabel.__init__ (method) -ida_kernwin.Form._AddGroup (method) -ida_kernwin.Form._ChkCompiled (method) -ida_kernwin.Form._FT_USHORT (variable) -ida_kernwin.Form._ParseFormTitle (method) -ida_kernwin.Form.__getitem__ (method) -ida_kernwin.Form.__init__ (method) -ida_kernwin.Form._reset (method) -ida_kernwin.Form.create_string_buffer (method) -ida_kernwin.Form.fieldtype_to_ctype (method) -ida_kernwin.GCRF_ALL (variable) -ida_kernwin.GCRF_CURRENT (variable) -ida_kernwin.GCRF_HEADER (variable) -ida_kernwin.GCRF_SELECTION (variable) -ida_kernwin.HIF_IDENTIFIER (variable) -ida_kernwin.HIF_LOCKED (variable) -ida_kernwin.HIF_NOCASE (variable) -ida_kernwin.HIF_REGISTER (variable) -ida_kernwin.HIF_SLOT_0 (variable) -ida_kernwin.HIF_SLOT_1 (variable) -ida_kernwin.HIF_SLOT_2 (variable) -ida_kernwin.HIF_SLOT_3 (variable) -ida_kernwin.HIF_SLOT_4 (variable) -ida_kernwin.HIF_SLOT_5 (variable) -ida_kernwin.HIF_SLOT_6 (variable) -ida_kernwin.HIF_SLOT_7 (variable) -ida_kernwin.HIF_SLOT_SHIFT (variable) -ida_kernwin.HIF_USE_SLOT (variable) -ida_kernwin.HIST_CMD (variable) -ida_kernwin.HIST_CMT (variable) -ida_kernwin.HIST_DIR (variable) -ida_kernwin.HIST_FILE (variable) -ida_kernwin.HIST_IDENT (variable) -ida_kernwin.HIST_SEG (variable) -ida_kernwin.HIST_SRCH (variable) -ida_kernwin.HIST_TYPE (variable) -ida_kernwin.IDAViewWrapper (class) -ida_kernwin.IDAViewWrapper.Bind (method) -ida_kernwin.IDAViewWrapper.Unbind (method) -ida_kernwin.IDAViewWrapper.__init__ (method) -ida_kernwin.IDA_DEBUG_ACCESSIBILITY (variable) -ida_kernwin.IDA_DEBUG_ALREADY (variable) -ida_kernwin.IDA_DEBUG_ALWAYS (variable) -ida_kernwin.IDA_DEBUG_APPCALL (variable) -ida_kernwin.IDA_DEBUG_CHECKMEM (variable) -ida_kernwin.IDA_DEBUG_CONFIG (variable) -ida_kernwin.IDA_DEBUG_DBGINFO (variable) -ida_kernwin.IDA_DEBUG_DEBUGGER (variable) -ida_kernwin.IDA_DEBUG_DEMANGLE (variable) -ida_kernwin.IDA_DEBUG_DREFS (variable) -ida_kernwin.IDA_DEBUG_FLIRT (variable) -ida_kernwin.IDA_DEBUG_IDP (variable) -ida_kernwin.IDA_DEBUG_IDS (variable) -ida_kernwin.IDA_DEBUG_INTERNET (variable) -ida_kernwin.IDA_DEBUG_LDR (variable) -ida_kernwin.IDA_DEBUG_LICENSE (variable) -ida_kernwin.IDA_DEBUG_LUMINA (variable) -ida_kernwin.IDA_DEBUG_NETWORK (variable) -ida_kernwin.IDA_DEBUG_NOTIFY (variable) -ida_kernwin.IDA_DEBUG_OFFSET (variable) -ida_kernwin.IDA_DEBUG_PLUGIN (variable) -ida_kernwin.IDA_DEBUG_QUEUE (variable) -ida_kernwin.IDA_DEBUG_REGEX (variable) -ida_kernwin.IDA_DEBUG_ROLLBACK (variable) -ida_kernwin.IDA_DEBUG_SIMPLEX (variable) -ida_kernwin.IDA_DEBUG_SRCDBG (variable) -ida_kernwin.IDA_DEBUG_SUBPROC (variable) -ida_kernwin.IDA_DEBUG_THEMES (variable) -ida_kernwin.IDA_DEBUG_TIL (variable) -ida_kernwin.IDCHK_ARG (variable) -ida_kernwin.IDCHK_KEY (variable) -ida_kernwin.IDCHK_MAX (variable) -ida_kernwin.IDCHK_OK (variable) -ida_kernwin.IWID_ADDRWATCH (variable) -ida_kernwin.IWID_ALL (variable) -ida_kernwin.IWID_BOOKMARKS (variable) -ida_kernwin.IWID_BPTS (variable) -ida_kernwin.IWID_CALLS (variable) -ida_kernwin.IWID_CALLS_CALLEES (variable) -ida_kernwin.IWID_CALLS_CALLERS (variable) -ida_kernwin.IWID_CALL_STACK (variable) -ida_kernwin.IWID_CHOOSER (variable) -ida_kernwin.IWID_CLI (variable) -ida_kernwin.IWID_CMDPALCSR (variable) -ida_kernwin.IWID_CMDPALWIN (variable) -ida_kernwin.IWID_CPUREGS (variable) -ida_kernwin.IWID_CUSTVIEW (variable) -ida_kernwin.IWID_CV_LINE_INFOS (variable) -ida_kernwin.IWID_DISASM (variable) -ida_kernwin.IWID_DISASM_ARROWS (variable) -ida_kernwin.IWID_DUMP (variable) -ida_kernwin.IWID_ENUMS (variable) -ida_kernwin.IWID_EXPORTS (variable) -ida_kernwin.IWID_FRAME (variable) -ida_kernwin.IWID_FUNCS (variable) -ida_kernwin.IWID_IMPORTS (variable) -ida_kernwin.IWID_LOCALS (variable) -ida_kernwin.IWID_LOCTYPS (variable) -ida_kernwin.IWID_MDVIEWCSR (variable) -ida_kernwin.IWID_MODULES (variable) -ida_kernwin.IWID_NAMES (variable) -ida_kernwin.IWID_NAVBAND (variable) -ida_kernwin.IWID_NOTEPAD (variable) -ida_kernwin.IWID_OUTPUT (variable) -ida_kernwin.IWID_PROBS (variable) -ida_kernwin.IWID_PSEUDOCODE (variable) -ida_kernwin.IWID_SCRIPTS_CSR (variable) -ida_kernwin.IWID_SEARCH (variable) -ida_kernwin.IWID_SEGREGS (variable) -ida_kernwin.IWID_SEGS (variable) -ida_kernwin.IWID_SELS (variable) -ida_kernwin.IWID_SHORTCUTCSR (variable) -ida_kernwin.IWID_SHORTCUTWIN (variable) -ida_kernwin.IWID_SIGNS (variable) -ida_kernwin.IWID_SNIPPETS (variable) -ida_kernwin.IWID_SNIPPETS_CSR (variable) -ida_kernwin.IWID_SO_OFFSETS (variable) -ida_kernwin.IWID_SO_STRUCTS (variable) -ida_kernwin.IWID_SRCPTHMAP_CSR (variable) -ida_kernwin.IWID_SRCPTHUND_CSR (variable) -ida_kernwin.IWID_STACK (variable) -ida_kernwin.IWID_STKVIEW (variable) -ida_kernwin.IWID_STRINGS (variable) -ida_kernwin.IWID_STRUCTS (variable) -ida_kernwin.IWID_THREADS (variable) -ida_kernwin.IWID_TILIST (variable) -ida_kernwin.IWID_TILS (variable) -ida_kernwin.IWID_TRACE (variable) -ida_kernwin.IWID_UNDOHIST (variable) -ida_kernwin.IWID_WATCH (variable) -ida_kernwin.IWID_XREFS (variable) -ida_kernwin.LROEF_CPS_RANGE (variable) -ida_kernwin.LROEF_FULL_LINE (variable) -ida_kernwin.MFF_FAST (variable) -ida_kernwin.MFF_NOWAIT (variable) -ida_kernwin.MFF_READ (variable) -ida_kernwin.MFF_WRITE (variable) -ida_kernwin.PCF_EA_CAPABLE (variable) -ida_kernwin.PCF_MAKEPLACE_ALLOCATES (variable) -ida_kernwin.PluginForm (class) -ida_kernwin.PluginForm.Close (method) -ida_kernwin.PluginForm.GetWidget (method) -ida_kernwin.PluginForm.OnClose (method) -ida_kernwin.PluginForm.OnCreate (method) -ida_kernwin.PluginForm.QtWidgetToTWidget (method) -ida_kernwin.PluginForm.Show (method) -ida_kernwin.PluginForm.TWidgetToPyQtWidget (method) -ida_kernwin.PluginForm.TWidgetToPySideWidget (method) -ida_kernwin.PluginForm.WCLS_DELETE_LATER (variable) -ida_kernwin.PluginForm.WCLS_DONT_SAVE_SIZE (variable) -ida_kernwin.PluginForm.WCLS_NO_CONTEXT (variable) -ida_kernwin.PluginForm.WCLS_SAVE (variable) -ida_kernwin.PluginForm.WOPN_DP_BEFORE (variable) -ida_kernwin.PluginForm.WOPN_DP_BOTTOM (variable) -ida_kernwin.PluginForm.WOPN_DP_FLOATING (variable) -ida_kernwin.PluginForm.WOPN_DP_INSIDE (variable) -ida_kernwin.PluginForm.WOPN_DP_LEFT (variable) -ida_kernwin.PluginForm.WOPN_DP_RIGHT (variable) -ida_kernwin.PluginForm.WOPN_DP_SZHINT (variable) -ida_kernwin.PluginForm.WOPN_DP_TAB (variable) -ida_kernwin.PluginForm.WOPN_DP_TOP (variable) -ida_kernwin.PluginForm.WOPN_PERSIST (variable) -ida_kernwin.PluginForm.WOPN_RESTORE (variable) -ida_kernwin.PluginForm.__init__ (method) -ida_kernwin.PluginForm._ensure_widget_deps (method) -ida_kernwin.RENADDR_HR (variable) -ida_kernwin.RENADDR_IDA (variable) -ida_kernwin.S2EAOPT_NOCALC (variable) -ida_kernwin.SETMENU_APP (variable) -ida_kernwin.SETMENU_ENSURE_SEP (variable) -ida_kernwin.SETMENU_FIRST (variable) -ida_kernwin.SETMENU_INS (variable) -ida_kernwin.SVF_COPY_LINES (variable) -ida_kernwin.SVF_LINES_BYPTR (variable) -ida_kernwin.TCCPT_ENUMPLACE (variable) -ida_kernwin.TCCPT_IDAPLACE (variable) -ida_kernwin.TCCPT_INVALID (variable) -ida_kernwin.TCCPT_PLACE (variable) -ida_kernwin.TCCPT_SIMPLELINE_PLACE (variable) -ida_kernwin.TCCPT_STRUCTPLACE (variable) -ida_kernwin.TCCPT_TIPLACE (variable) -ida_kernwin.TCCRT_FLAT (variable) -ida_kernwin.TCCRT_GRAPH (variable) -ida_kernwin.TCCRT_INVALID (variable) -ida_kernwin.TCCRT_PROXIMITY (variable) -ida_kernwin.TWidget__from_ptrval__ (function) -ida_kernwin.UIJMP_ACTIVATE (variable) -ida_kernwin.UIJMP_ANYVIEW (variable) -ida_kernwin.UIJMP_DONTPUSH (variable) -ida_kernwin.UIJMP_IDAVIEW (variable) -ida_kernwin.UIJMP_IDAVIEW_NEW (variable) -ida_kernwin.UI_Hooks (class) -ida_kernwin.UI_Hooks.__disown__ (method) -ida_kernwin.UI_Hooks.__init__ (method) -ida_kernwin.UI_Hooks.create_desktop_widget (method) -ida_kernwin.UI_Hooks.current_widget_changed (method) -ida_kernwin.UI_Hooks.database_closed (method) -ida_kernwin.UI_Hooks.database_inited (method) -ida_kernwin.UI_Hooks.debugger_menu_change (method) -ida_kernwin.UI_Hooks.desktop_applied (method) -ida_kernwin.UI_Hooks.destroying_plugmod (method) -ida_kernwin.UI_Hooks.destroying_procmod (method) -ida_kernwin.UI_Hooks.finish_populating_widget_popup (method) -ida_kernwin.UI_Hooks.get_chooser_item_attrs (method) -ida_kernwin.UI_Hooks.get_custom_viewer_hint (method) -ida_kernwin.UI_Hooks.get_ea_hint (method) -ida_kernwin.UI_Hooks.get_item_hint (method) -ida_kernwin.UI_Hooks.get_lines_rendering_info (method) -ida_kernwin.UI_Hooks.get_widget_config (method) -ida_kernwin.UI_Hooks.hook (method) -ida_kernwin.UI_Hooks.idcstart (method) -ida_kernwin.UI_Hooks.idcstop (method) -ida_kernwin.UI_Hooks.initing_database (method) -ida_kernwin.UI_Hooks.plugin_loaded (method) -ida_kernwin.UI_Hooks.plugin_unloading (method) -ida_kernwin.UI_Hooks.populating_widget_popup (method) -ida_kernwin.UI_Hooks.postprocess_action (method) -ida_kernwin.UI_Hooks.preprocess_action (method) -ida_kernwin.UI_Hooks.range (method) -ida_kernwin.UI_Hooks.ready_to_run (method) -ida_kernwin.UI_Hooks.resume (method) -ida_kernwin.UI_Hooks.saved (method) -ida_kernwin.UI_Hooks.saving (method) -ida_kernwin.UI_Hooks.screen_ea_changed (method) -ida_kernwin.UI_Hooks.set_widget_config (method) -ida_kernwin.UI_Hooks.suspend (method) -ida_kernwin.UI_Hooks.unhook (method) -ida_kernwin.UI_Hooks.updated_actions (method) -ida_kernwin.UI_Hooks.updating_actions (method) -ida_kernwin.UI_Hooks.widget_closing (method) -ida_kernwin.UI_Hooks.widget_invisible (method) -ida_kernwin.UI_Hooks.widget_visible (method) -ida_kernwin.VES_SHIFT (variable) -ida_kernwin.VME_LEFT_BUTTON (variable) -ida_kernwin.VME_MID_BUTTON (variable) -ida_kernwin.VME_RIGHT_BUTTON (variable) -ida_kernwin.VME_UNKNOWN (variable) -ida_kernwin.View_Hooks (class) -ida_kernwin.View_Hooks.__disown__ (method) -ida_kernwin.View_Hooks.__init__ (method) -ida_kernwin.View_Hooks.hook (method) -ida_kernwin.View_Hooks.unhook (method) -ida_kernwin.View_Hooks.view_activated (method) -ida_kernwin.View_Hooks.view_click (method) -ida_kernwin.View_Hooks.view_close (method) -ida_kernwin.View_Hooks.view_created (method) -ida_kernwin.View_Hooks.view_curpos (method) -ida_kernwin.View_Hooks.view_dblclick (method) -ida_kernwin.View_Hooks.view_deactivated (method) -ida_kernwin.View_Hooks.view_keydown (method) -ida_kernwin.View_Hooks.view_loc_changed (method) -ida_kernwin.View_Hooks.view_mouse_moved (method) -ida_kernwin.View_Hooks.view_mouse_over (method) -ida_kernwin.View_Hooks.view_switched (method) -ida_kernwin.WCLS_DELETE_LATER (variable) -ida_kernwin.WCLS_DONT_SAVE_SIZE (variable) -ida_kernwin.WCLS_NO_CONTEXT (variable) -ida_kernwin.WCLS_SAVE (variable) -ida_kernwin.WOPN_CLOSED_BY_ESC (variable) -ida_kernwin.WOPN_DP_BEFORE (variable) -ida_kernwin.WOPN_DP_BOTTOM (variable) -ida_kernwin.WOPN_DP_FLOATING (variable) -ida_kernwin.WOPN_DP_INSIDE (variable) -ida_kernwin.WOPN_DP_LEFT (variable) -ida_kernwin.WOPN_DP_RIGHT (variable) -ida_kernwin.WOPN_DP_SZHINT (variable) -ida_kernwin.WOPN_DP_TAB (variable) -ida_kernwin.WOPN_DP_TOP (variable) -ida_kernwin.WOPN_NOT_CLOSED_BY_ESC (variable) -ida_kernwin.WOPN_PERSIST (variable) -ida_kernwin.WOPN_RESTORE (variable) -ida_kernwin.__qtimer_t (class) -ida_kernwin.__qtimer_t.__init__ (method) -ida_kernwin._ask_addr (function) -ida_kernwin._ask_long (function) -ida_kernwin._ask_seg (function) -ida_kernwin._kludge_force_declare_dirspec_t (function) -ida_kernwin._kludge_force_declare_dirtree_t (function) -ida_kernwin.action_ctx_base_cur_sel_t (class) -ida_kernwin.action_ctx_base_cur_sel_t.__init__ (method) -ida_kernwin.action_ctx_base_cur_sel_t.reset (method) -ida_kernwin.action_ctx_base_cur_sel_t.to (variable) -ida_kernwin.action_ctx_base_source_t (class) -ida_kernwin.action_ctx_base_source_t.__init__ (method) -ida_kernwin.action_ctx_base_source_t.reset (method) -ida_kernwin.action_ctx_base_t (class) -ida_kernwin.action_ctx_base_t.__init__ (method) -ida_kernwin.action_ctx_base_t.action (variable) -ida_kernwin.action_ctx_base_t.chooser_selection (variable) -ida_kernwin.action_ctx_base_t.cur_ea (variable) -ida_kernwin.action_ctx_base_t.cur_enum (variable) -ida_kernwin.action_ctx_base_t.cur_fchunk (variable) -ida_kernwin.action_ctx_base_t.cur_flags (variable) -ida_kernwin.action_ctx_base_t.cur_func (variable) -ida_kernwin.action_ctx_base_t.cur_seg (variable) -ida_kernwin.action_ctx_base_t.cur_sel (variable) -ida_kernwin.action_ctx_base_t.cur_strmem (variable) -ida_kernwin.action_ctx_base_t.cur_struc (variable) -ida_kernwin.action_ctx_base_t.cur_value (variable) -ida_kernwin.action_ctx_base_t.dirtree_selection (variable) -ida_kernwin.action_ctx_base_t.focus (variable) -ida_kernwin.action_ctx_base_t.graph_selection (variable) -ida_kernwin.action_ctx_base_t.has_flag (method) -ida_kernwin.action_ctx_base_t.regname (variable) -ida_kernwin.action_ctx_base_t.reset (method) -ida_kernwin.action_ctx_base_t.source (variable) -ida_kernwin.action_ctx_base_t.type_ref (variable) -ida_kernwin.action_ctx_base_t.widget_title (variable) -ida_kernwin.action_ctx_base_t.widget_type (variable) -ida_kernwin.action_desc_t (class) -ida_kernwin.action_desc_t.__init__ (method) -ida_kernwin.action_desc_t.cb (variable) -ida_kernwin.action_desc_t.flags (variable) -ida_kernwin.action_desc_t.icon (variable) -ida_kernwin.action_desc_t.label (variable) -ida_kernwin.action_desc_t.name (variable) -ida_kernwin.action_desc_t.owner (variable) -ida_kernwin.action_desc_t.shortcut (variable) -ida_kernwin.action_desc_t.tooltip (variable) -ida_kernwin.action_handler_t (class) -ida_kernwin.action_handler_t.__init__ (method) -ida_kernwin.action_handler_t.activate (method) -ida_kernwin.action_handler_t.update (method) -ida_kernwin.activate_widget (function) -ida_kernwin.add_hotkey (function) -ida_kernwin.add_idc_hotkey (function) -ida_kernwin.add_spaces (function) -ida_kernwin.addon_count (function) -ida_kernwin.addon_info_t (class) -ida_kernwin.addon_info_t.__init__ (method) -ida_kernwin.analyzer_options (function) -ida_kernwin.ask_addr (function) -ida_kernwin.ask_buttons (function) -ida_kernwin.ask_file (function) -ida_kernwin.ask_for_feedback (function) -ida_kernwin.ask_form (function) -ida_kernwin.ask_ident (function) -ida_kernwin.ask_long (function) -ida_kernwin.ask_seg (function) -ida_kernwin.ask_str (function) -ida_kernwin.ask_text (function) -ida_kernwin.ask_yn (function) -ida_kernwin.atoea (function) -ida_kernwin.attach_action_to_menu (function) -ida_kernwin.attach_action_to_popup (function) -ida_kernwin.attach_action_to_toolbar (function) -ida_kernwin.attach_dynamic_action_to_popup (function) -ida_kernwin.banner (function) -ida_kernwin.beep (function) -ida_kernwin.call_nav_colorizer (function) -ida_kernwin.cancel_exec_request (function) -ida_kernwin.cancel_thread_exec_requests (function) -ida_kernwin.choose_activate (function) -ida_kernwin.choose_choose (function) -ida_kernwin.choose_close (function) -ida_kernwin.choose_create_embedded_chobj (function) -ida_kernwin.choose_entry (function) -ida_kernwin.choose_enum (function) -ida_kernwin.choose_enum_by_value (function) -ida_kernwin.choose_find (function) -ida_kernwin.choose_func (function) -ida_kernwin.choose_get_widget (function) -ida_kernwin.choose_idasgn (function) -ida_kernwin.choose_name (function) -ida_kernwin.choose_refresh (function) -ida_kernwin.choose_segm (function) -ida_kernwin.choose_srcp (function) -ida_kernwin.choose_stkvar_xref (function) -ida_kernwin.choose_struc (function) -ida_kernwin.choose_til (function) -ida_kernwin.choose_xref (function) -ida_kernwin.chooser_base_t (class) -ida_kernwin.chooser_base_t.__init__ (method) -ida_kernwin.chooser_base_t.ask_item_attrs (method) -ida_kernwin.chooser_base_t.can_del (method) -ida_kernwin.chooser_base_t.can_edit (method) -ida_kernwin.chooser_base_t.can_filter (method) -ida_kernwin.chooser_base_t.can_ins (method) -ida_kernwin.chooser_base_t.can_refresh (method) -ida_kernwin.chooser_base_t.can_sort (method) -ida_kernwin.chooser_base_t.columns (variable) -ida_kernwin.chooser_base_t.deflt_col (variable) -ida_kernwin.chooser_base_t.get_builtin_number (method) -ida_kernwin.chooser_base_t.get_count (method) -ida_kernwin.chooser_base_t.get_ea (method) -ida_kernwin.chooser_base_t.get_quick_filter_initial_mode (method) -ida_kernwin.chooser_base_t.get_row (method) -ida_kernwin.chooser_base_t.has_diff_capability (method) -ida_kernwin.chooser_base_t.has_dirtree (method) -ida_kernwin.chooser_base_t.header (variable) -ida_kernwin.chooser_base_t.height (variable) -ida_kernwin.chooser_base_t.icon (variable) -ida_kernwin.chooser_base_t.is_dirtree_persisted (method) -ida_kernwin.chooser_base_t.is_force_default (method) -ida_kernwin.chooser_base_t.is_lazy_loaded (method) -ida_kernwin.chooser_base_t.is_modal (method) -ida_kernwin.chooser_base_t.is_multi (method) -ida_kernwin.chooser_base_t.is_quick_filter_visible_initially (method) -ida_kernwin.chooser_base_t.is_same (method) -ida_kernwin.chooser_base_t.is_status_bar_hidden (method) -ida_kernwin.chooser_base_t.popup_allowed (method) -ida_kernwin.chooser_base_t.popup_names (variable) -ida_kernwin.chooser_base_t.should_rename_trigger_edit (method) -ida_kernwin.chooser_base_t.should_restore_geometry (method) -ida_kernwin.chooser_base_t.title (variable) -ida_kernwin.chooser_base_t.width (variable) -ida_kernwin.chooser_base_t.widths (variable) -ida_kernwin.chooser_base_t.x0 (variable) -ida_kernwin.chooser_item_attrs_t (class) -ida_kernwin.chooser_item_attrs_t.__eq__ (method) -ida_kernwin.chooser_item_attrs_t.__init__ (method) -ida_kernwin.chooser_item_attrs_t.color (variable) -ida_kernwin.chooser_item_attrs_t.flags (variable) -ida_kernwin.chooser_item_attrs_t.reset (method) -ida_kernwin.chooser_row_info_t (class) -ida_kernwin.chooser_row_info_t.__eq__ (method) -ida_kernwin.chooser_row_info_t.__init__ (method) -ida_kernwin.chooser_row_info_t.__ne__ (method) -ida_kernwin.chooser_row_info_t.attrs (variable) -ida_kernwin.chooser_row_info_t.icon (variable) -ida_kernwin.chooser_row_info_t.texts (variable) -ida_kernwin.chooser_row_info_vec_t (class) -ida_kernwin.chooser_row_info_vec_t.__eq__ (method) -ida_kernwin.chooser_row_info_vec_t.__getitem__ (method) -ida_kernwin.chooser_row_info_vec_t.__init__ (method) -ida_kernwin.chooser_row_info_vec_t.__len__ (method) -ida_kernwin.chooser_row_info_vec_t.__ne__ (method) -ida_kernwin.chooser_row_info_vec_t.__setitem__ (method) -ida_kernwin.chooser_row_info_vec_t._del (method) -ida_kernwin.chooser_row_info_vec_t.add_unique (method) -ida_kernwin.chooser_row_info_vec_t.at (method) -ida_kernwin.chooser_row_info_vec_t.begin (method) -ida_kernwin.chooser_row_info_vec_t.capacity (method) -ida_kernwin.chooser_row_info_vec_t.clear (method) -ida_kernwin.chooser_row_info_vec_t.empty (method) -ida_kernwin.chooser_row_info_vec_t.end (method) -ida_kernwin.chooser_row_info_vec_t.erase (method) -ida_kernwin.chooser_row_info_vec_t.extract (method) -ida_kernwin.chooser_row_info_vec_t.find (method) -ida_kernwin.chooser_row_info_vec_t.grow (method) -ida_kernwin.chooser_row_info_vec_t.has (method) -ida_kernwin.chooser_row_info_vec_t.inject (method) -ida_kernwin.chooser_row_info_vec_t.insert (method) -ida_kernwin.chooser_row_info_vec_t.pop_back (method) -ida_kernwin.chooser_row_info_vec_t.push_back (method) -ida_kernwin.chooser_row_info_vec_t.qclear (method) -ida_kernwin.chooser_row_info_vec_t.reserve (method) -ida_kernwin.chooser_row_info_vec_t.resize (method) -ida_kernwin.chooser_row_info_vec_t.size (method) -ida_kernwin.chooser_row_info_vec_t.swap (method) -ida_kernwin.chooser_row_info_vec_t.truncate (method) -ida_kernwin.chooser_stdact_desc_t (class) -ida_kernwin.chooser_stdact_desc_t.__disown__ (method) -ida_kernwin.chooser_stdact_desc_t.__init__ (method) -ida_kernwin.chooser_stdact_desc_t.label (variable) -ida_kernwin.chooser_stdact_desc_t.ucb (method) -ida_kernwin.chooser_stdact_desc_t.version (variable) -ida_kernwin.chtype_entry (variable) -ida_kernwin.chtype_enum (variable) -ida_kernwin.chtype_enum_by_value (variable) -ida_kernwin.chtype_enum_by_value_and_size (variable) -ida_kernwin.chtype_func (variable) -ida_kernwin.chtype_generic (variable) -ida_kernwin.chtype_idasgn (variable) -ida_kernwin.chtype_idatil (variable) -ida_kernwin.chtype_name (variable) -ida_kernwin.chtype_segm (variable) -ida_kernwin.chtype_srcp (variable) -ida_kernwin.chtype_stkvar_xref (variable) -ida_kernwin.chtype_strpath (variable) -ida_kernwin.chtype_struc (variable) -ida_kernwin.chtype_xref (variable) -ida_kernwin.clear_refresh_request (function) -ida_kernwin.cli_t (class) -ida_kernwin.cli_t.OnCompleteLine (method) -ida_kernwin.cli_t.OnExecuteLine (method) -ida_kernwin.cli_t.OnKeydown (method) -ida_kernwin.cli_t.__del__ (method) -ida_kernwin.cli_t.__init__ (method) -ida_kernwin.cli_t.register (method) -ida_kernwin.cli_t.unregister (method) -ida_kernwin.close_chooser (function) -ida_kernwin.close_widget (function) -ida_kernwin.clr_cancelled (function) -ida_kernwin.create_code_viewer (function) -ida_kernwin.create_empty_widget (function) -ida_kernwin.create_menu (function) -ida_kernwin.create_toolbar (function) -ida_kernwin.custom_viewer_jump (function) -ida_kernwin.del_hotkey (function) -ida_kernwin.del_idc_hotkey (function) -ida_kernwin.delete_menu (function) -ida_kernwin.delete_toolbar (function) -ida_kernwin.detach_action_from_menu (function) -ida_kernwin.detach_action_from_popup (function) -ida_kernwin.detach_action_from_toolbar (function) -ida_kernwin.disabled_script_timeout_t (class) -ida_kernwin.disabled_script_timeout_t.__enter__ (method) -ida_kernwin.disabled_script_timeout_t.__exit__ (method) -ida_kernwin.disasm_line_t (class) -ida_kernwin.disasm_line_t.__init__ (method) -ida_kernwin.disasm_text_t (class) -ida_kernwin.disasm_text_t.__getitem__ (method) -ida_kernwin.disasm_text_t.__init__ (method) -ida_kernwin.disasm_text_t.__len__ (method) -ida_kernwin.disasm_text_t.__setitem__ (method) -ida_kernwin.disasm_text_t.at (method) -ida_kernwin.disasm_text_t.begin (method) -ida_kernwin.disasm_text_t.capacity (method) -ida_kernwin.disasm_text_t.clear (method) -ida_kernwin.disasm_text_t.empty (method) -ida_kernwin.disasm_text_t.end (method) -ida_kernwin.disasm_text_t.erase (method) -ida_kernwin.disasm_text_t.extract (method) -ida_kernwin.disasm_text_t.grow (method) -ida_kernwin.disasm_text_t.inject (method) -ida_kernwin.disasm_text_t.insert (method) -ida_kernwin.disasm_text_t.pop_back (method) -ida_kernwin.disasm_text_t.push_back (method) -ida_kernwin.disasm_text_t.qclear (method) -ida_kernwin.disasm_text_t.reserve (method) -ida_kernwin.disasm_text_t.resize (method) -ida_kernwin.disasm_text_t.size (method) -ida_kernwin.disasm_text_t.swap (method) -ida_kernwin.disasm_text_t.truncate (method) -ida_kernwin.display_copyright_warning (function) -ida_kernwin.display_widget (function) -ida_kernwin.ea2str (function) -ida_kernwin.ea_viewer_history_push_and_jump (function) -ida_kernwin.enable_chooser_item_attrs (function) -ida_kernwin.enumplace_t (class) -ida_kernwin.enumplace_t.__init__ (method) -ida_kernwin.enumplace_t.bmask (variable) -ida_kernwin.enumplace_t.idx (variable) -ida_kernwin.enumplace_t.serial (variable) -ida_kernwin.enumplace_t.value (variable) -ida_kernwin.error (function) -ida_kernwin.execute_sync (function) -ida_kernwin.execute_ui_requests (function) -ida_kernwin.find_widget (function) -ida_kernwin.formchgcbfa_close (function) -ida_kernwin.formchgcbfa_enable_field (function) -ida_kernwin.formchgcbfa_get_field_value (function) -ida_kernwin.formchgcbfa_get_focused_field (function) -ida_kernwin.formchgcbfa_move_field (function) -ida_kernwin.formchgcbfa_refresh_field (function) -ida_kernwin.formchgcbfa_set_field_value (function) -ida_kernwin.formchgcbfa_set_focused_field (function) -ida_kernwin.formchgcbfa_show_field (function) -ida_kernwin.free_custom_icon (function) -ida_kernwin.gen_disasm_text (function) -ida_kernwin.get_action_checkable (function) -ida_kernwin.get_action_checked (function) -ida_kernwin.get_action_icon (function) -ida_kernwin.get_action_label (function) -ida_kernwin.get_action_shortcut (function) -ida_kernwin.get_action_state (function) -ida_kernwin.get_action_tooltip (function) -ida_kernwin.get_action_visibility (function) -ida_kernwin.get_active_modal_widget (function) -ida_kernwin.get_addon_info (function) -ida_kernwin.get_addon_info_idx (function) -ida_kernwin.get_chooser_data (function) -ida_kernwin.get_chooser_obj (function) -ida_kernwin.get_chooser_rows (function) -ida_kernwin.get_curline (function) -ida_kernwin.get_current_viewer (function) -ida_kernwin.get_current_widget (function) -ida_kernwin.get_cursor (function) -ida_kernwin.get_custom_viewer_curline (function) -ida_kernwin.get_custom_viewer_location (function) -ida_kernwin.get_custom_viewer_place (function) -ida_kernwin.get_custom_viewer_place_xcoord (function) -ida_kernwin.get_ea_viewer_history_info (function) -ida_kernwin.get_hexdump_ea (function) -ida_kernwin.get_highlight (function) -ida_kernwin.get_icon_id_by_name (function) -ida_kernwin.get_kernel_version (function) -ida_kernwin.get_key_code (function) -ida_kernwin.get_navband_ea (function) -ida_kernwin.get_navband_pixel (function) -ida_kernwin.get_opnum (function) -ida_kernwin.get_output_curline (function) -ida_kernwin.get_output_cursor (function) -ida_kernwin.get_output_selected_text (function) -ida_kernwin.get_place_class (function) -ida_kernwin.get_place_class_id (function) -ida_kernwin.get_place_class_template (function) -ida_kernwin.get_registered_actions (function) -ida_kernwin.get_screen_ea (function) -ida_kernwin.get_synced_group (function) -ida_kernwin.get_tab_size (function) -ida_kernwin.get_user_input_event (function) -ida_kernwin.get_user_strlist_options (function) -ida_kernwin.get_view_renderer_type (function) -ida_kernwin.get_viewer_place_type (function) -ida_kernwin.get_viewer_user_data (function) -ida_kernwin.get_widget_title (function) -ida_kernwin.get_widget_type (function) -ida_kernwin.get_window_id (function) -ida_kernwin.hide_wait_box (function) -ida_kernwin.idaplace_t (class) -ida_kernwin.idaplace_t.__init__ (method) -ida_kernwin.idaplace_t.ea (variable) -ida_kernwin.info (function) -ida_kernwin.input_event_keyboard_data_t (class) -ida_kernwin.input_event_keyboard_data_t.__init__ (method) -ida_kernwin.input_event_mouse_data_t (class) -ida_kernwin.input_event_mouse_data_t.__init__ (method) -ida_kernwin.input_event_shortcut_data_t (class) -ida_kernwin.input_event_shortcut_data_t.__init__ (method) -ida_kernwin.input_event_t (class) -ida_kernwin.input_event_t.__init__ (method) -ida_kernwin.input_event_t._source_as_size (method) -ida_kernwin.input_event_t._target_as_size (method) -ida_kernwin.input_event_t.cb (variable) -ida_kernwin.input_event_t.get_source_QEvent (method) -ida_kernwin.input_event_t.get_target_QWidget (method) -ida_kernwin.input_event_t.kind (variable) -ida_kernwin.input_event_t.modifiers (variable) -ida_kernwin.input_event_t.source (variable) -ida_kernwin.input_event_t.target (variable) -ida_kernwin.install_command_interpreter (function) -ida_kernwin.internal_register_place_class (function) -ida_kernwin.is_action_enabled (function) -ida_kernwin.is_chooser_widget (function) -ida_kernwin.is_idaq (function) -ida_kernwin.is_idaview (function) -ida_kernwin.is_msg_inited (function) -ida_kernwin.is_place_class_ea_capable (function) -ida_kernwin.is_refresh_requested (function) -ida_kernwin.jobj_wrapper_t (class) -ida_kernwin.jobj_wrapper_t.__init__ (method) -ida_kernwin.jobj_wrapper_t.get_dict (method) -ida_kernwin.jumpto (function) -ida_kernwin.l_compare2 (function) -ida_kernwin.line_rendering_output_entries_refs_t (class) -ida_kernwin.line_rendering_output_entries_refs_t.__eq__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__getitem__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__init__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__len__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__ne__ (method) -ida_kernwin.line_rendering_output_entries_refs_t.__setitem__ (method) -ida_kernwin.line_rendering_output_entries_refs_t._del (method) -ida_kernwin.line_rendering_output_entries_refs_t._internal_push_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.add_unique (method) -ida_kernwin.line_rendering_output_entries_refs_t.at (method) -ida_kernwin.line_rendering_output_entries_refs_t.begin (method) -ida_kernwin.line_rendering_output_entries_refs_t.capacity (method) -ida_kernwin.line_rendering_output_entries_refs_t.clear (method) -ida_kernwin.line_rendering_output_entries_refs_t.empty (method) -ida_kernwin.line_rendering_output_entries_refs_t.end (method) -ida_kernwin.line_rendering_output_entries_refs_t.erase (method) -ida_kernwin.line_rendering_output_entries_refs_t.extract (method) -ida_kernwin.line_rendering_output_entries_refs_t.find (method) -ida_kernwin.line_rendering_output_entries_refs_t.has (method) -ida_kernwin.line_rendering_output_entries_refs_t.inject (method) -ida_kernwin.line_rendering_output_entries_refs_t.insert (method) -ida_kernwin.line_rendering_output_entries_refs_t.pop_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) -ida_kernwin.line_rendering_output_entries_refs_t.qclear (method) -ida_kernwin.line_rendering_output_entries_refs_t.reserve (method) -ida_kernwin.line_rendering_output_entries_refs_t.resize (method) -ida_kernwin.line_rendering_output_entries_refs_t.size (method) -ida_kernwin.line_rendering_output_entries_refs_t.swap (method) -ida_kernwin.line_rendering_output_entries_refs_t.truncate (method) -ida_kernwin.line_rendering_output_entry_t (class) -ida_kernwin.line_rendering_output_entry_t.__eq__ (method) -ida_kernwin.line_rendering_output_entry_t.__init__ (method) -ida_kernwin.line_rendering_output_entry_t.__ne__ (method) -ida_kernwin.line_rendering_output_entry_t.cpx (variable) -ida_kernwin.line_rendering_output_entry_t.flags (variable) -ida_kernwin.line_rendering_output_entry_t.is_bg_color_direct (method) -ida_kernwin.line_rendering_output_entry_t.is_bg_color_empty (method) -ida_kernwin.line_rendering_output_entry_t.is_bg_color_key (method) -ida_kernwin.line_rendering_output_entry_t.nchars (variable) -ida_kernwin.line_section_t (class) -ida_kernwin.line_section_t.__init__ (method) -ida_kernwin.line_section_t.contains (method) -ida_kernwin.line_section_t.is_closed (method) -ida_kernwin.line_section_t.is_open (method) -ida_kernwin.line_section_t.valid (method) -ida_kernwin.linearray_t (class) -ida_kernwin.linearray_t.__init__ (method) -ida_kernwin.linearray_t.beginning (method) -ida_kernwin.linearray_t.down (method) -ida_kernwin.linearray_t.ending (method) -ida_kernwin.linearray_t.get_bg_color (method) -ida_kernwin.linearray_t.get_dlnnum (method) -ida_kernwin.linearray_t.get_linecnt (method) -ida_kernwin.linearray_t.get_pfx_color (method) -ida_kernwin.linearray_t.get_place (method) -ida_kernwin.linearray_t.set_place (method) -ida_kernwin.linearray_t.set_userdata (method) -ida_kernwin.linearray_t.up (method) -ida_kernwin.linearray_t.userdata (method) -ida_kernwin.lines_rendering_input_t (class) -ida_kernwin.lines_rendering_input_t.__init__ (method) -ida_kernwin.lines_rendering_input_t.sections_lines (variable) -ida_kernwin.lines_rendering_input_t.sync_group (variable) -ida_kernwin.lines_rendering_output_t (class) -ida_kernwin.lines_rendering_output_t.__eq__ (method) -ida_kernwin.lines_rendering_output_t.__init__ (method) -ida_kernwin.lines_rendering_output_t.__ne__ (method) -ida_kernwin.lines_rendering_output_t.clear (method) -ida_kernwin.lines_rendering_output_t.swap (method) -ida_kernwin.listing_location_t (class) -ida_kernwin.listing_location_t.__init__ (method) -ida_kernwin.load_custom_icon (function) -ida_kernwin.load_dbg_dbginfo (function) -ida_kernwin.lookup_key_code (function) -ida_kernwin.mbox_internal (variable) -ida_kernwin.msg (function) -ida_kernwin.msg_activated (variable) -ida_kernwin.msg_clear (function) -ida_kernwin.msg_click (variable) -ida_kernwin.msg_closed (variable) -ida_kernwin.msg_dblclick (variable) -ida_kernwin.msg_deactivated (variable) -ida_kernwin.msg_get_lines (function) -ida_kernwin.msg_keydown (variable) -ida_kernwin.msg_save (function) -ida_kernwin.nomem (function) -ida_kernwin.open_bookmarks_window (function) -ida_kernwin.open_bpts_window (function) -ida_kernwin.open_calls_window (function) -ida_kernwin.open_disasm_window (function) -ida_kernwin.open_enums_window (function) -ida_kernwin.open_exports_window (function) -ida_kernwin.open_form (function) -ida_kernwin.open_frame_window (function) -ida_kernwin.open_funcs_window (function) -ida_kernwin.open_hexdump_window (function) -ida_kernwin.open_imports_window (function) -ida_kernwin.open_loctypes_window (function) -ida_kernwin.open_modules_window (function) -ida_kernwin.open_names_window (function) -ida_kernwin.open_navband_window (function) -ida_kernwin.open_notepad_window (function) -ida_kernwin.open_problems_window (function) -ida_kernwin.open_segments_window (function) -ida_kernwin.open_segregs_window (function) -ida_kernwin.open_selectors_window (function) -ida_kernwin.open_signatures_window (function) -ida_kernwin.open_stack_window (function) -ida_kernwin.open_strings_window (function) -ida_kernwin.open_structs_window (function) -ida_kernwin.open_threads_window (function) -ida_kernwin.open_tils_window (function) -ida_kernwin.open_trace_window (function) -ida_kernwin.open_url (function) -ida_kernwin.open_xrefs_window (function) -ida_kernwin.place_t (class) -ida_kernwin.place_t.__init__ (method) -ida_kernwin.place_t._print (method) -ida_kernwin.place_t.adjust (method) -ida_kernwin.place_t.as_enumplace_t (method) -ida_kernwin.place_t.as_idaplace_t (method) -ida_kernwin.place_t.as_simpleline_place_t (method) -ida_kernwin.place_t.as_structplace_t (method) -ida_kernwin.place_t.as_tiplace_t (method) -ida_kernwin.place_t.beginning (method) -ida_kernwin.place_t.clone (method) -ida_kernwin.place_t.compare (method) -ida_kernwin.place_t.compare2 (method) -ida_kernwin.place_t.copyfrom (method) -ida_kernwin.place_t.deserialize (method) -ida_kernwin.place_t.ending (method) -ida_kernwin.place_t.enter (method) -ida_kernwin.place_t.generate (method) -ida_kernwin.place_t.id (method) -ida_kernwin.place_t.leave (method) -ida_kernwin.place_t.lnnum (variable) -ida_kernwin.place_t.makeplace (method) -ida_kernwin.place_t.name (method) -ida_kernwin.place_t.next (method) -ida_kernwin.place_t.prev (method) -ida_kernwin.place_t.rebase (method) -ida_kernwin.place_t.serialize (method) -ida_kernwin.place_t.toea (method) -ida_kernwin.place_t.touval (method) -ida_kernwin.place_t_as_enumplace_t (function) -ida_kernwin.place_t_as_idaplace_t (function) -ida_kernwin.place_t_as_simpleline_place_t (function) -ida_kernwin.place_t_as_structplace_t (function) -ida_kernwin.place_t_as_tiplace_t (function) -ida_kernwin.plgform_close (function) -ida_kernwin.plgform_get_widget (function) -ida_kernwin.plgform_new (function) -ida_kernwin.plgform_show (function) -ida_kernwin.process_ui_action (function) -ida_kernwin.py_chooser_base_t_get_row (function) -ida_kernwin.py_get_ask_form (function) -ida_kernwin.py_get_open_form (function) -ida_kernwin.py_load_custom_icon_data (function) -ida_kernwin.py_load_custom_icon_fn (function) -ida_kernwin.py_register_compiled_form (function) -ida_kernwin.py_unregister_compiled_form (function) -ida_kernwin.pyidag_bind (function) -ida_kernwin.pyidag_unbind (function) -ida_kernwin.pyscv_add_line (function) -ida_kernwin.pyscv_clear_lines (function) -ida_kernwin.pyscv_close (function) -ida_kernwin.pyscv_count (function) -ida_kernwin.pyscv_del_line (function) -ida_kernwin.pyscv_edit_line (function) -ida_kernwin.pyscv_get_current_line (function) -ida_kernwin.pyscv_get_current_word (function) -ida_kernwin.pyscv_get_line (function) -ida_kernwin.pyscv_get_pos (function) -ida_kernwin.pyscv_get_selection (function) -ida_kernwin.pyscv_get_widget (function) -ida_kernwin.pyscv_init (function) -ida_kernwin.pyscv_insert_line (function) -ida_kernwin.pyscv_is_focused (function) -ida_kernwin.pyscv_jumpto (function) -ida_kernwin.pyscv_patch_line (function) -ida_kernwin.pyscv_refresh (function) -ida_kernwin.pyscv_show (function) -ida_kernwin.qcleanline (function) -ida_kernwin.quick_widget_commands_t (class) -ida_kernwin.quick_widget_commands_t.__init__ (method) -ida_kernwin.quick_widget_commands_t._ah_t (class) -ida_kernwin.quick_widget_commands_t._ah_t.__init__ (method) -ida_kernwin.quick_widget_commands_t._ah_t.activate (method) -ida_kernwin.quick_widget_commands_t._ah_t.update (method) -ida_kernwin.quick_widget_commands_t._cmd_t (class) -ida_kernwin.quick_widget_commands_t._cmd_t.__init__ (method) -ida_kernwin.quick_widget_commands_t.add (method) -ida_kernwin.quick_widget_commands_t.populate_popup (method) -ida_kernwin.read_range_selection (function) -ida_kernwin.read_selection (function) -ida_kernwin.refresh_chooser (function) -ida_kernwin.refresh_choosers (function) -ida_kernwin.refresh_custom_viewer (function) -ida_kernwin.refresh_idaview (function) -ida_kernwin.refresh_idaview_anyway (function) -ida_kernwin.refresh_navband (function) -ida_kernwin.register_action (function) -ida_kernwin.register_addon (function) -ida_kernwin.register_and_attach_to_menu (function) -ida_kernwin.register_timer (function) -ida_kernwin.remove_command_interpreter (function) -ida_kernwin.renderer_pos_info_t (class) -ida_kernwin.renderer_pos_info_t.__eq__ (method) -ida_kernwin.renderer_pos_info_t.__init__ (method) -ida_kernwin.renderer_pos_info_t.__ne__ (method) -ida_kernwin.renderer_pos_info_t.cx (variable) -ida_kernwin.renderer_pos_info_t.cy (variable) -ida_kernwin.renderer_pos_info_t.node (variable) -ida_kernwin.renderer_pos_info_t.sx (variable) -ida_kernwin.repaint_custom_viewer (function) -ida_kernwin.replace_wait_box (function) -ida_kernwin.request_refresh (function) -ida_kernwin.restore_database_snapshot (function) -ida_kernwin.section_lines_refs_t (class) -ida_kernwin.section_lines_refs_t.__eq__ (method) -ida_kernwin.section_lines_refs_t.__getitem__ (method) -ida_kernwin.section_lines_refs_t.__init__ (method) -ida_kernwin.section_lines_refs_t.__len__ (method) -ida_kernwin.section_lines_refs_t.__ne__ (method) -ida_kernwin.section_lines_refs_t.__setitem__ (method) -ida_kernwin.section_lines_refs_t._del (method) -ida_kernwin.section_lines_refs_t.add_unique (method) -ida_kernwin.section_lines_refs_t.at (method) -ida_kernwin.section_lines_refs_t.begin (method) -ida_kernwin.section_lines_refs_t.capacity (method) -ida_kernwin.section_lines_refs_t.clear (method) -ida_kernwin.section_lines_refs_t.empty (method) -ida_kernwin.section_lines_refs_t.end (method) -ida_kernwin.section_lines_refs_t.erase (method) -ida_kernwin.section_lines_refs_t.extract (method) -ida_kernwin.section_lines_refs_t.find (method) -ida_kernwin.section_lines_refs_t.has (method) -ida_kernwin.section_lines_refs_t.inject (method) -ida_kernwin.section_lines_refs_t.insert (method) -ida_kernwin.section_lines_refs_t.pop_back (method) -ida_kernwin.section_lines_refs_t.push_back (method) -ida_kernwin.section_lines_refs_t.qclear (method) -ida_kernwin.section_lines_refs_t.reserve (method) -ida_kernwin.section_lines_refs_t.resize (method) -ida_kernwin.section_lines_refs_t.size (method) -ida_kernwin.section_lines_refs_t.swap (method) -ida_kernwin.section_lines_refs_t.truncate (method) -ida_kernwin.sections_lines_refs_t (class) -ida_kernwin.sections_lines_refs_t.__eq__ (method) -ida_kernwin.sections_lines_refs_t.__getitem__ (method) -ida_kernwin.sections_lines_refs_t.__init__ (method) -ida_kernwin.sections_lines_refs_t.__len__ (method) -ida_kernwin.sections_lines_refs_t.__ne__ (method) -ida_kernwin.sections_lines_refs_t.__setitem__ (method) -ida_kernwin.sections_lines_refs_t._del (method) -ida_kernwin.sections_lines_refs_t.add_unique (method) -ida_kernwin.sections_lines_refs_t.at (method) -ida_kernwin.sections_lines_refs_t.begin (method) -ida_kernwin.sections_lines_refs_t.capacity (method) -ida_kernwin.sections_lines_refs_t.clear (method) -ida_kernwin.sections_lines_refs_t.empty (method) -ida_kernwin.sections_lines_refs_t.end (method) -ida_kernwin.sections_lines_refs_t.erase (method) -ida_kernwin.sections_lines_refs_t.extract (method) -ida_kernwin.sections_lines_refs_t.find (method) -ida_kernwin.sections_lines_refs_t.grow (method) -ida_kernwin.sections_lines_refs_t.has (method) -ida_kernwin.sections_lines_refs_t.inject (method) -ida_kernwin.sections_lines_refs_t.insert (method) -ida_kernwin.sections_lines_refs_t.pop_back (method) -ida_kernwin.sections_lines_refs_t.push_back (method) -ida_kernwin.sections_lines_refs_t.qclear (method) -ida_kernwin.sections_lines_refs_t.reserve (method) -ida_kernwin.sections_lines_refs_t.resize (method) -ida_kernwin.sections_lines_refs_t.size (method) -ida_kernwin.sections_lines_refs_t.swap (method) -ida_kernwin.sections_lines_refs_t.truncate (method) -ida_kernwin.set_cancelled (function) -ida_kernwin.set_code_viewer_handler (function) -ida_kernwin.set_code_viewer_is_source (function) -ida_kernwin.set_code_viewer_line_handlers (function) -ida_kernwin.set_code_viewer_lines_alignment (function) -ida_kernwin.set_code_viewer_lines_icon_margin (function) -ida_kernwin.set_code_viewer_lines_radix (function) -ida_kernwin.set_code_viewer_user_data (function) -ida_kernwin.set_custom_viewer_qt_aware (function) -ida_kernwin.set_dock_pos (function) -ida_kernwin.set_highlight (function) -ida_kernwin.set_nav_colorizer (function) -ida_kernwin.set_view_renderer_type (function) -ida_kernwin.show_wait_box (function) -ida_kernwin.simplecustviewer_t (class) -ida_kernwin.simplecustviewer_t.AddLine (method) -ida_kernwin.simplecustviewer_t.ClearLines (method) -ida_kernwin.simplecustviewer_t.Close (method) -ida_kernwin.simplecustviewer_t.Count (method) -ida_kernwin.simplecustviewer_t.Create (method) -ida_kernwin.simplecustviewer_t.DelLine (method) -ida_kernwin.simplecustviewer_t.EditLine (method) -ida_kernwin.simplecustviewer_t.GetCurrentLine (method) -ida_kernwin.simplecustviewer_t.GetCurrentWord (method) -ida_kernwin.simplecustviewer_t.GetLine (method) -ida_kernwin.simplecustviewer_t.GetLineNo (method) -ida_kernwin.simplecustviewer_t.GetPos (method) -ida_kernwin.simplecustviewer_t.GetSelection (method) -ida_kernwin.simplecustviewer_t.GetWidget (method) -ida_kernwin.simplecustviewer_t.InsertLine (method) -ida_kernwin.simplecustviewer_t.IsFocused (method) -ida_kernwin.simplecustviewer_t.Jump (method) -ida_kernwin.simplecustviewer_t.OnPopup (method) -ida_kernwin.simplecustviewer_t.PatchLine (method) -ida_kernwin.simplecustviewer_t.Refresh (method) -ida_kernwin.simplecustviewer_t.RefreshCurrent (method) -ida_kernwin.simplecustviewer_t.Show (method) -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline (class) -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.__init__ (method) -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.populating_widget_popup (method) -ida_kernwin.simplecustviewer_t.__init__ (method) -ida_kernwin.simplecustviewer_t.__make_sl_arg (method) -ida_kernwin.simpleline_place_t (class) -ida_kernwin.simpleline_place_t.__init__ (method) -ida_kernwin.simpleline_place_t.n (variable) -ida_kernwin.simpleline_t (class) -ida_kernwin.simpleline_t.__init__ (method) -ida_kernwin.simpleline_t.bgcolor (variable) -ida_kernwin.simpleline_t.color (variable) -ida_kernwin.simpleline_t.line (variable) -ida_kernwin.str2ea (function) -ida_kernwin.str2ea_ex (function) -ida_kernwin.strarray (function) -ida_kernwin.strarray_t (class) -ida_kernwin.strarray_t.__init__ (method) -ida_kernwin.structplace_t (class) -ida_kernwin.structplace_t.__init__ (method) -ida_kernwin.structplace_t.idx (variable) -ida_kernwin.structplace_t.offset (variable) -ida_kernwin.sync_source_t (class) -ida_kernwin.sync_source_t.__eq__ (method) -ida_kernwin.sync_source_t.__init__ (method) -ida_kernwin.sync_source_t.__ne__ (method) -ida_kernwin.sync_source_t.get_register (method) -ida_kernwin.sync_source_t.get_widget (method) -ida_kernwin.sync_source_t.is_register (method) -ida_kernwin.sync_source_t.is_widget (method) -ida_kernwin.sync_source_vec_t (class) -ida_kernwin.sync_source_vec_t.__eq__ (method) -ida_kernwin.sync_source_vec_t.__getitem__ (method) -ida_kernwin.sync_source_vec_t.__init__ (method) -ida_kernwin.sync_source_vec_t.__len__ (method) -ida_kernwin.sync_source_vec_t.__ne__ (method) -ida_kernwin.sync_source_vec_t.__setitem__ (method) -ida_kernwin.sync_source_vec_t._del (method) -ida_kernwin.sync_source_vec_t.add_unique (method) -ida_kernwin.sync_source_vec_t.at (method) -ida_kernwin.sync_source_vec_t.begin (method) -ida_kernwin.sync_source_vec_t.capacity (method) -ida_kernwin.sync_source_vec_t.clear (method) -ida_kernwin.sync_source_vec_t.empty (method) -ida_kernwin.sync_source_vec_t.end (method) -ida_kernwin.sync_source_vec_t.erase (method) -ida_kernwin.sync_source_vec_t.extract (method) -ida_kernwin.sync_source_vec_t.find (method) -ida_kernwin.sync_source_vec_t.has (method) -ida_kernwin.sync_source_vec_t.inject (method) -ida_kernwin.sync_source_vec_t.insert (method) -ida_kernwin.sync_source_vec_t.pop_back (method) -ida_kernwin.sync_source_vec_t.push_back (method) -ida_kernwin.sync_source_vec_t.qclear (method) -ida_kernwin.sync_source_vec_t.reserve (method) -ida_kernwin.sync_source_vec_t.size (method) -ida_kernwin.sync_source_vec_t.swap (method) -ida_kernwin.sync_source_vec_t.truncate (method) -ida_kernwin.sync_sources (function) -ida_kernwin.synced_group_t (class) -ida_kernwin.synced_group_t.__init__ (method) -ida_kernwin.synced_group_t.has (method) -ida_kernwin.synced_group_t.has_register (method) -ida_kernwin.synced_group_t.has_widget (method) -ida_kernwin.tagged_line_section_t (class) -ida_kernwin.tagged_line_section_t.__init__ (method) -ida_kernwin.tagged_line_section_t.substr (method) -ida_kernwin.tagged_line_section_t.valid (method) -ida_kernwin.tagged_line_sections_t (class) -ida_kernwin.tagged_line_sections_t.__init__ (method) -ida_kernwin.tagged_line_sections_t.nearest_at (method) -ida_kernwin.tagged_line_sections_t.sections_at (method) -ida_kernwin.take_database_snapshot (function) -ida_kernwin.text_t (class) -ida_kernwin.text_t.__getitem__ (method) -ida_kernwin.text_t.__init__ (method) -ida_kernwin.text_t.__len__ (method) -ida_kernwin.text_t.__setitem__ (method) -ida_kernwin.text_t.at (method) -ida_kernwin.text_t.begin (method) -ida_kernwin.text_t.capacity (method) -ida_kernwin.text_t.clear (method) -ida_kernwin.text_t.empty (method) -ida_kernwin.text_t.end (method) -ida_kernwin.text_t.erase (method) -ida_kernwin.text_t.extract (method) -ida_kernwin.text_t.grow (method) -ida_kernwin.text_t.inject (method) -ida_kernwin.text_t.insert (method) -ida_kernwin.text_t.pop_back (method) -ida_kernwin.text_t.push_back (method) -ida_kernwin.text_t.qclear (method) -ida_kernwin.text_t.reserve (method) -ida_kernwin.text_t.resize (method) -ida_kernwin.text_t.size (method) -ida_kernwin.text_t.swap (method) -ida_kernwin.text_t.truncate (method) -ida_kernwin.textctrl_info_t (class) -ida_kernwin.textctrl_info_t.TXTF_ACCEPTTABS (variable) -ida_kernwin.textctrl_info_t.TXTF_AUTOINDENT (variable) -ida_kernwin.textctrl_info_t.TXTF_FIXEDFONT (variable) -ida_kernwin.textctrl_info_t.TXTF_MODIFIED (variable) -ida_kernwin.textctrl_info_t.TXTF_READONLY (variable) -ida_kernwin.textctrl_info_t.TXTF_SELECTED (variable) -ida_kernwin.textctrl_info_t.__get_flags__ (method) -ida_kernwin.textctrl_info_t.__get_tabsize__ (method) -ida_kernwin.textctrl_info_t.__get_text (method) -ida_kernwin.textctrl_info_t.__init__ (method) -ida_kernwin.textctrl_info_t.__set_flags__ (method) -ida_kernwin.textctrl_info_t.__set_tabsize__ (method) -ida_kernwin.textctrl_info_t.__set_text (method) -ida_kernwin.textctrl_info_t._create_clink (method) -ida_kernwin.textctrl_info_t._del_clink (method) -ida_kernwin.textctrl_info_t._get_clink_ptr (method) -ida_kernwin.textctrl_info_t.assign (method) -ida_kernwin.textctrl_info_t.flags (variable) -ida_kernwin.textctrl_info_t.tabsize (variable) -ida_kernwin.textctrl_info_t.text (variable) -ida_kernwin.textctrl_info_t.value (variable) -ida_kernwin.textctrl_info_t_assign (function) -ida_kernwin.textctrl_info_t_create (function) -ida_kernwin.textctrl_info_t_destroy (function) -ida_kernwin.textctrl_info_t_get_clink (function) -ida_kernwin.textctrl_info_t_get_clink_ptr (function) -ida_kernwin.textctrl_info_t_get_flags (function) -ida_kernwin.textctrl_info_t_get_tabsize (function) -ida_kernwin.textctrl_info_t_get_text (function) -ida_kernwin.textctrl_info_t_set_flags (function) -ida_kernwin.textctrl_info_t_set_tabsize (function) -ida_kernwin.textctrl_info_t_set_text (function) -ida_kernwin.tif_path_t (class) -ida_kernwin.tif_path_t.__init__ (method) -ida_kernwin.tif_path_t.get_index (method) -ida_kernwin.tif_path_t.get_path (method) -ida_kernwin.tif_path_t.is_footer (method) -ida_kernwin.tif_path_t.is_header (method) -ida_kernwin.tif_path_t.is_index (method) -ida_kernwin.tif_path_t.reset (method) -ida_kernwin.tif_path_t.set_footer (method) -ida_kernwin.tif_path_t.set_header (method) -ida_kernwin.tif_path_t.set_index (method) -ida_kernwin.tif_path_t.set_path (method) -ida_kernwin.til_type_ref_t (class) -ida_kernwin.til_type_ref_t.__init__ (method) -ida_kernwin.til_type_ref_t.reset (method) -ida_kernwin.tiplace_t (class) -ida_kernwin.tiplace_t.__init__ (method) -ida_kernwin.tiplace_t.calc_udm_index (method) -ida_kernwin.tiplace_t.calc_udm_offset (method) -ida_kernwin.tiplace_t.get_index (method) -ida_kernwin.tiplace_t.get_path (method) -ida_kernwin.tiplace_t.is_footer (method) -ida_kernwin.tiplace_t.is_header (method) -ida_kernwin.tiplace_t.is_index (method) -ida_kernwin.tiplace_t.reset (method) -ida_kernwin.tiplace_t.set_footer (method) -ida_kernwin.tiplace_t.set_header (method) -ida_kernwin.tiplace_t.set_index (method) -ida_kernwin.tiplace_t.set_path (method) -ida_kernwin.tiplace_t.valid_ord (method) -ida_kernwin.twinline_t (class) -ida_kernwin.twinline_t.__init__ (method) -ida_kernwin.twinline_t.at (variable) -ida_kernwin.twinline_t.bg_color (variable) -ida_kernwin.twinline_t.is_default (variable) -ida_kernwin.twinline_t.line (variable) -ida_kernwin.twinline_t.prefix_color (variable) -ida_kernwin.twinpos_t (class) -ida_kernwin.twinpos_t.__init__ (method) -ida_kernwin.twinpos_t.at (variable) -ida_kernwin.twinpos_t.place (method) -ida_kernwin.twinpos_t.place_as_enumplace_t (method) -ida_kernwin.twinpos_t.place_as_idaplace_t (method) -ida_kernwin.twinpos_t.place_as_simpleline_place_t (method) -ida_kernwin.twinpos_t.place_as_structplace_t (method) -ida_kernwin.twinpos_t.place_as_tiplace_t (method) -ida_kernwin.twinpos_t.x (variable) -ida_kernwin.ui_load_new_file (function) -ida_kernwin.ui_requests_t (class) -ida_kernwin.ui_requests_t.__init__ (method) -ida_kernwin.ui_run_debugger (function) -ida_kernwin.unmark_selection (function) -ida_kernwin.unregister_action (function) -ida_kernwin.unregister_timer (function) -ida_kernwin.update_action_checkable (function) -ida_kernwin.update_action_checked (function) -ida_kernwin.update_action_icon (function) -ida_kernwin.update_action_label (function) -ida_kernwin.update_action_shortcut (function) -ida_kernwin.update_action_state (function) -ida_kernwin.update_action_tooltip (function) -ida_kernwin.update_action_visibility (function) -ida_kernwin.user_cancelled (function) -ida_kernwin.view_activated (variable) -ida_kernwin.view_click (variable) -ida_kernwin.view_close (variable) -ida_kernwin.view_created (variable) -ida_kernwin.view_curpos (variable) -ida_kernwin.view_dblclick (variable) -ida_kernwin.view_deactivated (variable) -ida_kernwin.view_keydown (variable) -ida_kernwin.view_loc_changed (variable) -ida_kernwin.view_mouse_event_location_t (class) -ida_kernwin.view_mouse_event_location_t.__init__ (method) -ida_kernwin.view_mouse_event_location_t.ea (variable) -ida_kernwin.view_mouse_event_location_t.item (variable) -ida_kernwin.view_mouse_event_t (class) -ida_kernwin.view_mouse_event_t.__init__ (method) -ida_kernwin.view_mouse_event_t.button (variable) -ida_kernwin.view_mouse_event_t.location (variable) -ida_kernwin.view_mouse_event_t.renderer_pos (variable) -ida_kernwin.view_mouse_event_t.rtype (variable) -ida_kernwin.view_mouse_event_t.state (variable) -ida_kernwin.view_mouse_event_t.x (variable) -ida_kernwin.view_mouse_event_t.y (variable) -ida_kernwin.view_mouse_moved (variable) -ida_kernwin.view_mouse_over (variable) -ida_kernwin.view_switched (variable) -ida_kernwin.warning (function) -ida_lines (module) -ida_lines.COLOR_ADDR (variable) -ida_lines.COLOR_ADDR_SIZE (variable) -ida_lines.COLOR_ALTOP (variable) -ida_lines.COLOR_ASMDIR (variable) -ida_lines.COLOR_AUTOCMT (variable) -ida_lines.COLOR_BG_MAX (variable) -ida_lines.COLOR_BINPREF (variable) -ida_lines.COLOR_CHAR (variable) -ida_lines.COLOR_CNAME (variable) -ida_lines.COLOR_CODE (variable) -ida_lines.COLOR_CODNAME (variable) -ida_lines.COLOR_COLLAPSED (variable) -ida_lines.COLOR_CREF (variable) -ida_lines.COLOR_CREFTAIL (variable) -ida_lines.COLOR_CURITEM (variable) -ida_lines.COLOR_CURLINE (variable) -ida_lines.COLOR_DATA (variable) -ida_lines.COLOR_DATNAME (variable) -ida_lines.COLOR_DCHAR (variable) -ida_lines.COLOR_DEFAULT (variable) -ida_lines.COLOR_DEMNAME (variable) -ida_lines.COLOR_DNAME (variable) -ida_lines.COLOR_DNUM (variable) -ida_lines.COLOR_DREF (variable) -ida_lines.COLOR_DREFTAIL (variable) -ida_lines.COLOR_DSTR (variable) -ida_lines.COLOR_ERROR (variable) -ida_lines.COLOR_ESC (variable) -ida_lines.COLOR_EXTERN (variable) -ida_lines.COLOR_EXTRA (variable) -ida_lines.COLOR_FG_MAX (variable) -ida_lines.COLOR_HIDLINE (variable) -ida_lines.COLOR_HIDNAME (variable) -ida_lines.COLOR_IMPNAME (variable) -ida_lines.COLOR_INSN (variable) -ida_lines.COLOR_INV (variable) -ida_lines.COLOR_KEYWORD (variable) -ida_lines.COLOR_LIBFUNC (variable) -ida_lines.COLOR_LIBNAME (variable) -ida_lines.COLOR_LOCNAME (variable) -ida_lines.COLOR_LUMFUNC (variable) -ida_lines.COLOR_LUMINA (variable) -ida_lines.COLOR_MACRO (variable) -ida_lines.COLOR_NUMBER (variable) -ida_lines.COLOR_OFF (variable) -ida_lines.COLOR_ON (variable) -ida_lines.COLOR_OPND1 (variable) -ida_lines.COLOR_OPND2 (variable) -ida_lines.COLOR_OPND3 (variable) -ida_lines.COLOR_OPND4 (variable) -ida_lines.COLOR_OPND5 (variable) -ida_lines.COLOR_OPND6 (variable) -ida_lines.COLOR_OPND7 (variable) -ida_lines.COLOR_OPND8 (variable) -ida_lines.COLOR_PREFIX (variable) -ida_lines.COLOR_REG (variable) -ida_lines.COLOR_REGCMT (variable) -ida_lines.COLOR_REGFUNC (variable) -ida_lines.COLOR_RESERVED1 (variable) -ida_lines.COLOR_RPTCMT (variable) -ida_lines.COLOR_SEGNAME (variable) -ida_lines.COLOR_SELECTED (variable) -ida_lines.COLOR_STRING (variable) -ida_lines.COLOR_SYMBOL (variable) -ida_lines.COLOR_UNAME (variable) -ida_lines.COLOR_UNKNAME (variable) -ida_lines.COLOR_UNKNOWN (variable) -ida_lines.COLOR_VOIDOP (variable) -ida_lines.COLSTR (function) -ida_lines.SCOLOR_ADDR (variable) -ida_lines.SCOLOR_ALTOP (variable) -ida_lines.SCOLOR_ASMDIR (variable) -ida_lines.SCOLOR_AUTOCMT (variable) -ida_lines.SCOLOR_BINPREF (variable) -ida_lines.SCOLOR_CHAR (variable) -ida_lines.SCOLOR_CNAME (variable) -ida_lines.SCOLOR_CODNAME (variable) -ida_lines.SCOLOR_COLLAPSED (variable) -ida_lines.SCOLOR_CREF (variable) -ida_lines.SCOLOR_CREFTAIL (variable) -ida_lines.SCOLOR_DATNAME (variable) -ida_lines.SCOLOR_DCHAR (variable) -ida_lines.SCOLOR_DEFAULT (variable) -ida_lines.SCOLOR_DEMNAME (variable) -ida_lines.SCOLOR_DNAME (variable) -ida_lines.SCOLOR_DNUM (variable) -ida_lines.SCOLOR_DREF (variable) -ida_lines.SCOLOR_DREFTAIL (variable) -ida_lines.SCOLOR_DSTR (variable) -ida_lines.SCOLOR_ERROR (variable) -ida_lines.SCOLOR_ESC (variable) -ida_lines.SCOLOR_EXTRA (variable) -ida_lines.SCOLOR_HIDNAME (variable) -ida_lines.SCOLOR_IMPNAME (variable) -ida_lines.SCOLOR_INSN (variable) -ida_lines.SCOLOR_INV (variable) -ida_lines.SCOLOR_KEYWORD (variable) -ida_lines.SCOLOR_LIBNAME (variable) -ida_lines.SCOLOR_LOCNAME (variable) -ida_lines.SCOLOR_MACRO (variable) -ida_lines.SCOLOR_NUMBER (variable) -ida_lines.SCOLOR_OFF (variable) -ida_lines.SCOLOR_ON (variable) -ida_lines.SCOLOR_PREFIX (variable) -ida_lines.SCOLOR_REG (variable) -ida_lines.SCOLOR_REGCMT (variable) -ida_lines.SCOLOR_RPTCMT (variable) -ida_lines.SCOLOR_SEGNAME (variable) -ida_lines.SCOLOR_STRING (variable) -ida_lines.SCOLOR_SYMBOL (variable) -ida_lines.SCOLOR_UNAME (variable) -ida_lines.SCOLOR_UNKNAME (variable) -ida_lines.SCOLOR_VOIDOP (variable) -ida_lines.add_extra_cmt (function) -ida_lines.add_extra_line (function) -ida_lines.add_pgm_cmt (function) -ida_lines.add_sourcefile (function) -ida_lines.calc_bg_color (function) -ida_lines.calc_prefix_color (function) -ida_lines.create_encoding_helper (function) -ida_lines.del_extra_cmt (function) -ida_lines.del_sourcefile (function) -ida_lines.delete_extra_cmts (function) -ida_lines.generate_disasm_line (function) -ida_lines.generate_disassembly (function) -ida_lines.get_extra_cmt (function) -ida_lines.get_first_free_extra_cmtidx (function) -ida_lines.get_sourcefile (function) -ida_lines.install_user_defined_prefix (function) -ida_lines.requires_color_esc (function) -ida_lines.set_user_defined_prefix (function) -ida_lines.tag_addr (function) -ida_lines.tag_advance (function) -ida_lines.tag_remove (function) -ida_lines.tag_skipcode (function) -ida_lines.tag_skipcodes (function) -ida_lines.tag_strlen (function) -ida_lines.update_extra_cmt (function) -ida_lines.user_defined_prefix_t (class) -ida_lines.user_defined_prefix_t.__disown__ (method) -ida_lines.user_defined_prefix_t.__init__ (method) -ida_lines.user_defined_prefix_t.get_user_defined_prefix (method) -ida_loader (module) -ida_loader.ACCEPT_ARCHIVE (variable) -ida_loader.ACCEPT_CONTINUE (variable) -ida_loader.ACCEPT_FIRST (variable) -ida_loader.DBFL_BAK (variable) -ida_loader.DBFL_COMP (variable) -ida_loader.DBFL_KILL (variable) -ida_loader.DBFL_TEMP (variable) -ida_loader.FILEREG_NOTPATCHABLE (variable) -ida_loader.FILEREG_PATCHABLE (variable) -ida_loader.GENFLG_ASMINC (variable) -ida_loader.GENFLG_ASMTYPE (variable) -ida_loader.GENFLG_GENHTML (variable) -ida_loader.LDRF_RELOAD (variable) -ida_loader.LDRF_REQ_PROC (variable) -ida_loader.MAX_DATABASE_DESCRIPTION (variable) -ida_loader.NEF_CODE (variable) -ida_loader.NEF_FILL (variable) -ida_loader.NEF_FIRST (variable) -ida_loader.NEF_FLAT (variable) -ida_loader.NEF_IMPS (variable) -ida_loader.NEF_LALL (variable) -ida_loader.NEF_LOPT (variable) -ida_loader.NEF_MAN (variable) -ida_loader.NEF_MINI (variable) -ida_loader.NEF_NAME (variable) -ida_loader.NEF_RELOAD (variable) -ida_loader.NEF_RSCS (variable) -ida_loader.NEF_SEGS (variable) -ida_loader.OFILE_ASM (variable) -ida_loader.OFILE_DIF (variable) -ida_loader.OFILE_EXE (variable) -ida_loader.OFILE_IDC (variable) -ida_loader.OFILE_LST (variable) -ida_loader.OFILE_MAP (variable) -ida_loader.PATH_TYPE_CMD (variable) -ida_loader.PATH_TYPE_ID0 (variable) -ida_loader.PATH_TYPE_IDB (variable) -ida_loader.PLUGIN_DLL (variable) -ida_loader.SSF_AUTOMATIC (variable) -ida_loader.SSUF_DESC (variable) -ida_loader.SSUF_FLAGS (variable) -ida_loader.SSUF_PATH (variable) -ida_loader.base2file (function) -ida_loader.build_snapshot_tree (function) -ida_loader.clr_database_flag (function) -ida_loader.extract_module_from_archive (function) -ida_loader.file2base (function) -ida_loader.find_plugin (function) -ida_loader.flush_buffers (function) -ida_loader.gen_exe_file (function) -ida_loader.gen_file (function) -ida_loader.get_basic_file_type (function) -ida_loader.get_elf_debug_file_directory (function) -ida_loader.get_file_type_name (function) -ida_loader.get_fileregion_ea (function) -ida_loader.get_fileregion_offset (function) -ida_loader.get_path (function) -ida_loader.get_plugin_options (function) -ida_loader.idp_desc_t (class) -ida_loader.idp_desc_t.__init__ (method) -ida_loader.idp_desc_t.checked (variable) -ida_loader.idp_desc_t.family (variable) -ida_loader.idp_desc_t.is_script (variable) -ida_loader.idp_desc_t.mtime (variable) -ida_loader.idp_desc_t.names (variable) -ida_loader.idp_desc_t.path (variable) -ida_loader.idp_name_t (class) -ida_loader.idp_name_t.__init__ (method) -ida_loader.idp_name_t.hidden (variable) -ida_loader.idp_name_t.lname (variable) -ida_loader.idp_name_t.sname (variable) -ida_loader.is_database_flag (function) -ida_loader.is_trusted_idb (function) -ida_loader.load_and_run_plugin (function) -ida_loader.load_binary_file (function) -ida_loader.load_ids_module (function) -ida_loader.load_plugin (function) -ida_loader.loader_t (class) -ida_loader.loader_t.__init__ (method) -ida_loader.loader_t.flags (variable) -ida_loader.loader_t.version (variable) -ida_loader.mem2base (function) -ida_loader.plugin_info_t (class) -ida_loader.plugin_info_t.__init__ (method) -ida_loader.plugin_info_t.arg (variable) -ida_loader.plugin_info_t.comment (variable) -ida_loader.plugin_info_t.entry (variable) -ida_loader.plugin_info_t.flags (variable) -ida_loader.plugin_info_t.hotkey (variable) -ida_loader.plugin_info_t.name (variable) -ida_loader.plugin_info_t.next (variable) -ida_loader.plugin_info_t.org_hotkey (variable) -ida_loader.plugin_info_t.org_name (variable) -ida_loader.plugin_info_t.path (variable) -ida_loader.process_archive (function) -ida_loader.qvector_snapshotvec_t (class) -ida_loader.qvector_snapshotvec_t.__eq__ (method) -ida_loader.qvector_snapshotvec_t.__getitem__ (method) -ida_loader.qvector_snapshotvec_t.__init__ (method) -ida_loader.qvector_snapshotvec_t.__len__ (method) -ida_loader.qvector_snapshotvec_t.__ne__ (method) -ida_loader.qvector_snapshotvec_t.__setitem__ (method) -ida_loader.qvector_snapshotvec_t._del (method) -ida_loader.qvector_snapshotvec_t.add_unique (method) -ida_loader.qvector_snapshotvec_t.at (method) -ida_loader.qvector_snapshotvec_t.begin (method) -ida_loader.qvector_snapshotvec_t.capacity (method) -ida_loader.qvector_snapshotvec_t.clear (method) -ida_loader.qvector_snapshotvec_t.empty (method) -ida_loader.qvector_snapshotvec_t.end (method) -ida_loader.qvector_snapshotvec_t.erase (method) -ida_loader.qvector_snapshotvec_t.extract (method) -ida_loader.qvector_snapshotvec_t.find (method) -ida_loader.qvector_snapshotvec_t.has (method) -ida_loader.qvector_snapshotvec_t.inject (method) -ida_loader.qvector_snapshotvec_t.insert (method) -ida_loader.qvector_snapshotvec_t.pop_back (method) -ida_loader.qvector_snapshotvec_t.push_back (method) -ida_loader.qvector_snapshotvec_t.qclear (method) -ida_loader.qvector_snapshotvec_t.reserve (method) -ida_loader.qvector_snapshotvec_t.resize (method) -ida_loader.qvector_snapshotvec_t.size (method) -ida_loader.qvector_snapshotvec_t.swap (method) -ida_loader.qvector_snapshotvec_t.truncate (method) -ida_loader.reload_file (function) -ida_loader.run_plugin (function) -ida_loader.save_database (function) -ida_loader.set_database_flag (function) -ida_loader.set_import_name (function) -ida_loader.set_import_ordinal (function) -ida_loader.set_path (function) -ida_loader.snapshot_t (class) -ida_loader.snapshot_t.__eq__ (method) -ida_loader.snapshot_t.__ge__ (method) -ida_loader.snapshot_t.__gt__ (method) -ida_loader.snapshot_t.__init__ (method) -ida_loader.snapshot_t.__le__ (method) -ida_loader.snapshot_t.__lt__ (method) -ida_loader.snapshot_t.__ne__ (method) -ida_loader.snapshot_t.children (variable) -ida_loader.snapshot_t.clear (method) -ida_loader.snapshot_t.desc (variable) -ida_loader.snapshot_t.filename (variable) -ida_loader.snapshot_t.flags (variable) -ida_loader.snapshot_t.id (variable) -ida_lumina (module) -ida_lumina.AMDF_FORCE (variable) -ida_lumina.AMDF_UPGRADE (variable) -ida_lumina.apply_metadata (function) -ida_lumina.backup_metadata (function) -ida_lumina.calc_func_metadata (function) -ida_lumina.diff_metadata (function) -ida_lumina.extra_cmt_t (class) -ida_lumina.extra_cmt_t.__init__ (method) -ida_lumina.extra_cmts_t (class) -ida_lumina.extra_cmts_t.__getitem__ (method) -ida_lumina.extra_cmts_t.__init__ (method) -ida_lumina.extra_cmts_t.__len__ (method) -ida_lumina.extra_cmts_t.__setitem__ (method) -ida_lumina.extra_cmts_t.at (method) -ida_lumina.extra_cmts_t.begin (method) -ida_lumina.extra_cmts_t.capacity (method) -ida_lumina.extra_cmts_t.clear (method) -ida_lumina.extra_cmts_t.empty (method) -ida_lumina.extra_cmts_t.end (method) -ida_lumina.extra_cmts_t.erase (method) -ida_lumina.extra_cmts_t.extract (method) -ida_lumina.extra_cmts_t.grow (method) -ida_lumina.extra_cmts_t.inject (method) -ida_lumina.extra_cmts_t.insert (method) -ida_lumina.extra_cmts_t.pop_back (method) -ida_lumina.extra_cmts_t.push_back (method) -ida_lumina.extra_cmts_t.qclear (method) -ida_lumina.extra_cmts_t.reserve (method) -ida_lumina.extra_cmts_t.resize (method) -ida_lumina.extra_cmts_t.size (method) -ida_lumina.extra_cmts_t.swap (method) -ida_lumina.extra_cmts_t.truncate (method) -ida_lumina.extract_extra_cmts_from_metadata (function) -ida_lumina.extract_frame_desc_from_metadata (function) -ida_lumina.extract_insn_cmts_from_metadata (function) -ida_lumina.extract_insn_opreprs_from_metadata (function) -ida_lumina.extract_insn_opreprs_from_metadata_ex (function) -ida_lumina.extract_type_from_metadata (function) -ida_lumina.extract_user_stkpnts_from_metadata (function) -ida_lumina.frame_desc_t (class) -ida_lumina.frame_desc_t.__init__ (method) -ida_lumina.frame_mem_t (class) -ida_lumina.frame_mem_t.__init__ (method) -ida_lumina.frame_mems_t (class) -ida_lumina.frame_mems_t.__getitem__ (method) -ida_lumina.frame_mems_t.__init__ (method) -ida_lumina.frame_mems_t.__len__ (method) -ida_lumina.frame_mems_t.__setitem__ (method) -ida_lumina.frame_mems_t.at (method) -ida_lumina.frame_mems_t.begin (method) -ida_lumina.frame_mems_t.capacity (method) -ida_lumina.frame_mems_t.clear (method) -ida_lumina.frame_mems_t.empty (method) -ida_lumina.frame_mems_t.end (method) -ida_lumina.frame_mems_t.erase (method) -ida_lumina.frame_mems_t.extract (method) -ida_lumina.frame_mems_t.grow (method) -ida_lumina.frame_mems_t.inject (method) -ida_lumina.frame_mems_t.insert (method) -ida_lumina.frame_mems_t.pop_back (method) -ida_lumina.frame_mems_t.push_back (method) -ida_lumina.frame_mems_t.qclear (method) -ida_lumina.frame_mems_t.reserve (method) -ida_lumina.frame_mems_t.resize (method) -ida_lumina.frame_mems_t.size (method) -ida_lumina.frame_mems_t.swap (method) -ida_lumina.frame_mems_t.truncate (method) -ida_lumina.func_info_and_frequency_t (class) -ida_lumina.func_info_and_frequency_t.__init__ (method) -ida_lumina.func_info_and_frequency_vec_t (class) -ida_lumina.func_info_and_frequency_vec_t.__getitem__ (method) -ida_lumina.func_info_and_frequency_vec_t.__init__ (method) -ida_lumina.func_info_and_frequency_vec_t.__len__ (method) -ida_lumina.func_info_and_frequency_vec_t.__setitem__ (method) -ida_lumina.func_info_and_frequency_vec_t.at (method) -ida_lumina.func_info_and_frequency_vec_t.begin (method) -ida_lumina.func_info_and_frequency_vec_t.capacity (method) -ida_lumina.func_info_and_frequency_vec_t.clear (method) -ida_lumina.func_info_and_frequency_vec_t.empty (method) -ida_lumina.func_info_and_frequency_vec_t.end (method) -ida_lumina.func_info_and_frequency_vec_t.erase (method) -ida_lumina.func_info_and_frequency_vec_t.extract (method) -ida_lumina.func_info_and_frequency_vec_t.grow (method) -ida_lumina.func_info_and_frequency_vec_t.inject (method) -ida_lumina.func_info_and_frequency_vec_t.insert (method) -ida_lumina.func_info_and_frequency_vec_t.pop_back (method) -ida_lumina.func_info_and_frequency_vec_t.push_back (method) -ida_lumina.func_info_and_frequency_vec_t.qclear (method) -ida_lumina.func_info_and_frequency_vec_t.reserve (method) -ida_lumina.func_info_and_frequency_vec_t.resize (method) -ida_lumina.func_info_and_frequency_vec_t.size (method) -ida_lumina.func_info_and_frequency_vec_t.swap (method) -ida_lumina.func_info_and_frequency_vec_t.truncate (method) -ida_lumina.func_info_and_pattern_t (class) -ida_lumina.func_info_and_pattern_t.__init__ (method) -ida_lumina.func_info_and_pattern_vec_t (class) -ida_lumina.func_info_and_pattern_vec_t.__getitem__ (method) -ida_lumina.func_info_and_pattern_vec_t.__init__ (method) -ida_lumina.func_info_and_pattern_vec_t.__len__ (method) -ida_lumina.func_info_and_pattern_vec_t.__setitem__ (method) -ida_lumina.func_info_and_pattern_vec_t.at (method) -ida_lumina.func_info_and_pattern_vec_t.begin (method) -ida_lumina.func_info_and_pattern_vec_t.capacity (method) -ida_lumina.func_info_and_pattern_vec_t.clear (method) -ida_lumina.func_info_and_pattern_vec_t.empty (method) -ida_lumina.func_info_and_pattern_vec_t.end (method) -ida_lumina.func_info_and_pattern_vec_t.erase (method) -ida_lumina.func_info_and_pattern_vec_t.extract (method) -ida_lumina.func_info_and_pattern_vec_t.grow (method) -ida_lumina.func_info_and_pattern_vec_t.inject (method) -ida_lumina.func_info_and_pattern_vec_t.insert (method) -ida_lumina.func_info_and_pattern_vec_t.pop_back (method) -ida_lumina.func_info_and_pattern_vec_t.push_back (method) -ida_lumina.func_info_and_pattern_vec_t.qclear (method) -ida_lumina.func_info_and_pattern_vec_t.reserve (method) -ida_lumina.func_info_and_pattern_vec_t.resize (method) -ida_lumina.func_info_and_pattern_vec_t.size (method) -ida_lumina.func_info_and_pattern_vec_t.swap (method) -ida_lumina.func_info_and_pattern_vec_t.truncate (method) -ida_lumina.func_info_base_t (class) -ida_lumina.func_info_base_t.__init__ (method) -ida_lumina.func_info_pattern_and_frequency_t (class) -ida_lumina.func_info_pattern_and_frequency_t.__init__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t (class) -ida_lumina.func_info_pattern_and_frequency_vec_t.__getitem__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.__init__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.__len__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.__setitem__ (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.at (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.begin (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.capacity (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.clear (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.empty (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.end (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.erase (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.extract (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.grow (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.inject (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.insert (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.pop_back (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.push_back (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.qclear (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.reserve (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.resize (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.size (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.swap (method) -ida_lumina.func_info_pattern_and_frequency_vec_t.truncate (method) -ida_lumina.func_info_t (class) -ida_lumina.func_info_t.__init__ (method) -ida_lumina.func_info_vec_t (class) -ida_lumina.func_info_vec_t.__getitem__ (method) -ida_lumina.func_info_vec_t.__init__ (method) -ida_lumina.func_info_vec_t.__len__ (method) -ida_lumina.func_info_vec_t.__setitem__ (method) -ida_lumina.func_info_vec_t.at (method) -ida_lumina.func_info_vec_t.begin (method) -ida_lumina.func_info_vec_t.capacity (method) -ida_lumina.func_info_vec_t.clear (method) -ida_lumina.func_info_vec_t.empty (method) -ida_lumina.func_info_vec_t.end (method) -ida_lumina.func_info_vec_t.erase (method) -ida_lumina.func_info_vec_t.extract (method) -ida_lumina.func_info_vec_t.grow (method) -ida_lumina.func_info_vec_t.inject (method) -ida_lumina.func_info_vec_t.insert (method) -ida_lumina.func_info_vec_t.pop_back (method) -ida_lumina.func_info_vec_t.push_back (method) -ida_lumina.func_info_vec_t.qclear (method) -ida_lumina.func_info_vec_t.reserve (method) -ida_lumina.func_info_vec_t.resize (method) -ida_lumina.func_info_vec_t.size (method) -ida_lumina.func_info_vec_t.swap (method) -ida_lumina.func_info_vec_t.truncate (method) -ida_lumina.func_md_diff_handler_t (class) -ida_lumina.func_md_diff_handler_t.__disown__ (method) -ida_lumina.func_md_diff_handler_t.__init__ (method) -ida_lumina.func_md_diff_handler_t.on_comment_changed (method) -ida_lumina.func_md_diff_handler_t.on_extra_comment_changed (method) -ida_lumina.func_md_diff_handler_t.on_frame_member_changed (method) -ida_lumina.func_md_diff_handler_t.on_function_comment_changed (method) -ida_lumina.func_md_diff_handler_t.on_insn_ops_repr_changed (method) -ida_lumina.func_md_diff_handler_t.on_name_changed (method) -ida_lumina.func_md_diff_handler_t.on_proto_changed (method) -ida_lumina.func_md_diff_handler_t.on_score_changed (method) -ida_lumina.func_md_diff_handler_t.on_user_stkpnt_changed (method) -ida_lumina.get_lumina_rpc_packet_t_index_from_base (function) -ida_lumina.get_server_connection (function) -ida_lumina.get_server_connection2 (function) -ida_lumina.has_backup_metadata (function) -ida_lumina.input_file_t (class) -ida_lumina.input_file_t.__init__ (method) -ida_lumina.insn_cmt_t (class) -ida_lumina.insn_cmt_t.__init__ (method) -ida_lumina.insn_cmts_t (class) -ida_lumina.insn_cmts_t.__getitem__ (method) -ida_lumina.insn_cmts_t.__init__ (method) -ida_lumina.insn_cmts_t.__len__ (method) -ida_lumina.insn_cmts_t.__setitem__ (method) -ida_lumina.insn_cmts_t.at (method) -ida_lumina.insn_cmts_t.begin (method) -ida_lumina.insn_cmts_t.capacity (method) -ida_lumina.insn_cmts_t.clear (method) -ida_lumina.insn_cmts_t.empty (method) -ida_lumina.insn_cmts_t.end (method) -ida_lumina.insn_cmts_t.erase (method) -ida_lumina.insn_cmts_t.extract (method) -ida_lumina.insn_cmts_t.grow (method) -ida_lumina.insn_cmts_t.inject (method) -ida_lumina.insn_cmts_t.insert (method) -ida_lumina.insn_cmts_t.pop_back (method) -ida_lumina.insn_cmts_t.push_back (method) -ida_lumina.insn_cmts_t.qclear (method) -ida_lumina.insn_cmts_t.reserve (method) -ida_lumina.insn_cmts_t.resize (method) -ida_lumina.insn_cmts_t.size (method) -ida_lumina.insn_cmts_t.swap (method) -ida_lumina.insn_cmts_t.truncate (method) -ida_lumina.insn_ops_repr_t (class) -ida_lumina.insn_ops_repr_t.__init__ (method) -ida_lumina.insn_ops_reprs_t (class) -ida_lumina.insn_ops_reprs_t.__getitem__ (method) -ida_lumina.insn_ops_reprs_t.__init__ (method) -ida_lumina.insn_ops_reprs_t.__len__ (method) -ida_lumina.insn_ops_reprs_t.__setitem__ (method) -ida_lumina.insn_ops_reprs_t.at (method) -ida_lumina.insn_ops_reprs_t.begin (method) -ida_lumina.insn_ops_reprs_t.capacity (method) -ida_lumina.insn_ops_reprs_t.clear (method) -ida_lumina.insn_ops_reprs_t.empty (method) -ida_lumina.insn_ops_reprs_t.end (method) -ida_lumina.insn_ops_reprs_t.erase (method) -ida_lumina.insn_ops_reprs_t.extract (method) -ida_lumina.insn_ops_reprs_t.grow (method) -ida_lumina.insn_ops_reprs_t.inject (method) -ida_lumina.insn_ops_reprs_t.insert (method) -ida_lumina.insn_ops_reprs_t.pop_back (method) -ida_lumina.insn_ops_reprs_t.push_back (method) -ida_lumina.insn_ops_reprs_t.qclear (method) -ida_lumina.insn_ops_reprs_t.reserve (method) -ida_lumina.insn_ops_reprs_t.resize (method) -ida_lumina.insn_ops_reprs_t.size (method) -ida_lumina.insn_ops_reprs_t.swap (method) -ida_lumina.insn_ops_reprs_t.truncate (method) -ida_lumina.insn_site_t (class) -ida_lumina.insn_site_t.__init__ (method) -ida_lumina.insn_site_t.toea (method) -ida_lumina.lumina_client_t (class) -ida_lumina.lumina_client_t.__init__ (method) -ida_lumina.lumina_client_t.del_history (method) -ida_lumina.lumina_client_t.get_pop (method) -ida_lumina.lumina_client_t.is_pattern_id (method) -ida_lumina.lumina_client_t.pull_md (method) -ida_lumina.lumina_client_t.push_md (method) -ida_lumina.lumina_client_t.set_pattern_id_md5 (method) -ida_lumina.lumina_info_t (class) -ida_lumina.lumina_info_t.__init__ (method) -ida_lumina.lumina_op_res_vec_t (class) -ida_lumina.lumina_op_res_vec_t.__eq__ (method) -ida_lumina.lumina_op_res_vec_t.__getitem__ (method) -ida_lumina.lumina_op_res_vec_t.__init__ (method) -ida_lumina.lumina_op_res_vec_t.__len__ (method) -ida_lumina.lumina_op_res_vec_t.__ne__ (method) -ida_lumina.lumina_op_res_vec_t.__setitem__ (method) -ida_lumina.lumina_op_res_vec_t._del (method) -ida_lumina.lumina_op_res_vec_t.add_unique (method) -ida_lumina.lumina_op_res_vec_t.at (method) -ida_lumina.lumina_op_res_vec_t.begin (method) -ida_lumina.lumina_op_res_vec_t.capacity (method) -ida_lumina.lumina_op_res_vec_t.clear (method) -ida_lumina.lumina_op_res_vec_t.empty (method) -ida_lumina.lumina_op_res_vec_t.end (method) -ida_lumina.lumina_op_res_vec_t.erase (method) -ida_lumina.lumina_op_res_vec_t.extract (method) -ida_lumina.lumina_op_res_vec_t.find (method) -ida_lumina.lumina_op_res_vec_t.grow (method) -ida_lumina.lumina_op_res_vec_t.has (method) -ida_lumina.lumina_op_res_vec_t.inject (method) -ida_lumina.lumina_op_res_vec_t.insert (method) -ida_lumina.lumina_op_res_vec_t.pop_back (method) -ida_lumina.lumina_op_res_vec_t.push_back (method) -ida_lumina.lumina_op_res_vec_t.qclear (method) -ida_lumina.lumina_op_res_vec_t.reserve (method) -ida_lumina.lumina_op_res_vec_t.resize (method) -ida_lumina.lumina_op_res_vec_t.size (method) -ida_lumina.lumina_op_res_vec_t.swap (method) -ida_lumina.lumina_op_res_vec_t.truncate (method) -ida_lumina.lumina_server_info_t (class) -ida_lumina.lumina_server_info_t.__init__ (method) -ida_lumina.lumina_user_t (class) -ida_lumina.lumina_user_t.__init__ (method) -ida_lumina.lumina_user_t.can_del_history (method) -ida_lumina.lumina_user_t.is_admin (method) -ida_lumina.lumina_user_t.set_can_del_history (method) -ida_lumina.lumina_user_t.set_is_admin (method) -ida_lumina.md_type_parts_t (class) -ida_lumina.md_type_parts_t.__eq__ (method) -ida_lumina.md_type_parts_t.__init__ (method) -ida_lumina.md_type_parts_t.__ne__ (method) -ida_lumina.metadata_iterator_t (class) -ida_lumina.metadata_iterator_t.__init__ (method) -ida_lumina.metadata_iterator_t.data_end (method) -ida_lumina.metadata_iterator_t.next (method) -ida_lumina.new_packet (function) -ida_lumina.oprepr_t (class) -ida_lumina.oprepr_t.__init__ (method) -ida_lumina.pattern_id_t (class) -ida_lumina.pattern_id_t.__init__ (method) -ida_lumina.peer_conn_t (class) -ida_lumina.peer_conn_t.__init__ (method) -ida_lumina.pkt_get_lumina_info_result_t (class) -ida_lumina.pkt_get_lumina_info_result_t.__init__ (method) -ida_lumina.pkt_get_lumina_info_t (class) -ida_lumina.pkt_get_lumina_info_t.__init__ (method) -ida_lumina.pkt_get_pop_result_t (class) -ida_lumina.pkt_get_pop_result_t.__init__ (method) -ida_lumina.pkt_get_pop_t (class) -ida_lumina.pkt_get_pop_t.__init__ (method) -ida_lumina.pkt_helo_result_t (class) -ida_lumina.pkt_helo_result_t.__init__ (method) -ida_lumina.pkt_helo_t (class) -ida_lumina.pkt_helo_t.__init__ (method) -ida_lumina.pkt_pull_md_result_t (class) -ida_lumina.pkt_pull_md_result_t.__init__ (method) -ida_lumina.pkt_pull_md_t (class) -ida_lumina.pkt_pull_md_t.__init__ (method) -ida_lumina.pkt_push_md_result_t (class) -ida_lumina.pkt_push_md_result_t.__init__ (method) -ida_lumina.pkt_push_md_t (class) -ida_lumina.pkt_push_md_t.__init__ (method) -ida_lumina.pkt_rpc_fail_t (class) -ida_lumina.pkt_rpc_fail_t.__init__ (method) -ida_lumina.pkt_rpc_notify_t (class) -ida_lumina.pkt_rpc_notify_t.__init__ (method) -ida_lumina.pkt_rpc_ok_t (class) -ida_lumina.pkt_rpc_ok_t.__init__ (method) -ida_lumina.pop_fun_t (class) -ida_lumina.pop_fun_t.__init__ (method) -ida_lumina.push_md_opts_t (class) -ida_lumina.push_md_opts_t.__init__ (method) -ida_lumina.push_md_result_t (class) -ida_lumina.push_md_result_t.__init__ (method) -ida_lumina.revert_metadata (function) -ida_lumina.score_metadata (function) -ida_lumina.serialized_tinfo (class) -ida_lumina.serialized_tinfo.__init__ (method) -ida_lumina.simple_idb_diff_handler_t (class) -ida_lumina.simple_idb_diff_handler_t.__init__ (method) -ida_lumina.simple_idb_diff_handler_t.ensure_header_generated (method) -ida_lumina.simple_idb_diff_handler_t.format_extra_cmt (method) -ida_lumina.simple_idb_diff_handler_t.format_frame_member (method) -ida_lumina.simple_idb_diff_handler_t.format_insn_ops (method) -ida_lumina.simple_idb_diff_handler_t.format_stkpnt (method) -ida_lumina.simple_idb_diff_handler_t.format_type (method) -ida_lumina.simple_idb_diff_handler_t.indenter_t (class) -ida_lumina.simple_idb_diff_handler_t.indenter_t.__del__ (method) -ida_lumina.simple_idb_diff_handler_t.indenter_t.__init__ (method) -ida_lumina.simple_idb_diff_handler_t.on_comment_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_extra_comment_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_frame_member_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_function_comment_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_insn_ops_repr_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_name_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_proto_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_score_changed (method) -ida_lumina.simple_idb_diff_handler_t.on_user_stkpnt_changed (method) -ida_lumina.simple_idb_diff_handler_t.put (method) -ida_lumina.simple_idb_diff_handler_t.put2 (method) -ida_lumina.simple_idb_diff_handler_t.where (method) -ida_lumina.skipped_func_t (class) -ida_lumina.skipped_func_t.__init__ (method) -ida_lumina.skipped_funcs_t (class) -ida_lumina.skipped_funcs_t.__getitem__ (method) -ida_lumina.skipped_funcs_t.__init__ (method) -ida_lumina.skipped_funcs_t.__len__ (method) -ida_lumina.skipped_funcs_t.__setitem__ (method) -ida_lumina.skipped_funcs_t.at (method) -ida_lumina.skipped_funcs_t.begin (method) -ida_lumina.skipped_funcs_t.capacity (method) -ida_lumina.skipped_funcs_t.clear (method) -ida_lumina.skipped_funcs_t.empty (method) -ida_lumina.skipped_funcs_t.end (method) -ida_lumina.skipped_funcs_t.erase (method) -ida_lumina.skipped_funcs_t.extract (method) -ida_lumina.skipped_funcs_t.grow (method) -ida_lumina.skipped_funcs_t.inject (method) -ida_lumina.skipped_funcs_t.insert (method) -ida_lumina.skipped_funcs_t.pop_back (method) -ida_lumina.skipped_funcs_t.push_back (method) -ida_lumina.skipped_funcs_t.qclear (method) -ida_lumina.skipped_funcs_t.reserve (method) -ida_lumina.skipped_funcs_t.resize (method) -ida_lumina.skipped_funcs_t.size (method) -ida_lumina.skipped_funcs_t.swap (method) -ida_lumina.skipped_funcs_t.truncate (method) -ida_lumina.split_metadata (function) -ida_lumina.user_license_info_t (class) -ida_lumina.user_license_info_t.__init__ (method) -ida_lumina.user_stkpnt_t (class) -ida_lumina.user_stkpnt_t.__init__ (method) -ida_lumina.user_stkpnts_t (class) -ida_lumina.user_stkpnts_t.__getitem__ (method) -ida_lumina.user_stkpnts_t.__init__ (method) -ida_lumina.user_stkpnts_t.__len__ (method) -ida_lumina.user_stkpnts_t.__setitem__ (method) -ida_lumina.user_stkpnts_t.at (method) -ida_lumina.user_stkpnts_t.begin (method) -ida_lumina.user_stkpnts_t.capacity (method) -ida_lumina.user_stkpnts_t.clear (method) -ida_lumina.user_stkpnts_t.empty (method) -ida_lumina.user_stkpnts_t.end (method) -ida_lumina.user_stkpnts_t.erase (method) -ida_lumina.user_stkpnts_t.extract (method) -ida_lumina.user_stkpnts_t.grow (method) -ida_lumina.user_stkpnts_t.inject (method) -ida_lumina.user_stkpnts_t.insert (method) -ida_lumina.user_stkpnts_t.pop_back (method) -ida_lumina.user_stkpnts_t.push_back (method) -ida_lumina.user_stkpnts_t.qclear (method) -ida_lumina.user_stkpnts_t.reserve (method) -ida_lumina.user_stkpnts_t.resize (method) -ida_lumina.user_stkpnts_t.size (method) -ida_lumina.user_stkpnts_t.swap (method) -ida_lumina.user_stkpnts_t.truncate (method) -ida_moves (module) -ida_moves.bookmarks_t (class) -ida_moves.bookmarks_t.__getitem__ (method) -ida_moves.bookmarks_t.__init__ (method) -ida_moves.bookmarks_t.__init__ (method) -ida_moves.bookmarks_t.__iter__ (method) -ida_moves.bookmarks_t.__len__ (method) -ida_moves.bookmarks_t.erase (method) -ida_moves.bookmarks_t.find_index (method) -ida_moves.bookmarks_t.get (method) -ida_moves.bookmarks_t.get_desc (method) -ida_moves.bookmarks_t.get_dirtree_id (method) -ida_moves.bookmarks_t.mark (method) -ida_moves.bookmarks_t.size (method) -ida_moves.bookmarks_t_erase (function) -ida_moves.bookmarks_t_find_index (function) -ida_moves.bookmarks_t_get (function) -ida_moves.bookmarks_t_get_desc (function) -ida_moves.bookmarks_t_get_dirtree_id (function) -ida_moves.bookmarks_t_mark (function) -ida_moves.bookmarks_t_size (function) -ida_moves.graph_location_info_t (class) -ida_moves.graph_location_info_t.__eq__ (method) -ida_moves.graph_location_info_t.__init__ (method) -ida_moves.graph_location_info_t.__ne__ (method) -ida_moves.lochist_entry_t (class) -ida_moves.lochist_entry_t.__init__ (method) -ida_moves.lochist_entry_t.acquire_place (method) -ida_moves.lochist_entry_t.is_valid (method) -ida_moves.lochist_entry_t.place (method) -ida_moves.lochist_entry_t.renderer_info (method) -ida_moves.lochist_entry_t.set_place (method) -ida_moves.lochist_t (class) -ida_moves.lochist_t.__init__ (method) -ida_moves.lochist_t.back (method) -ida_moves.lochist_t.clear (method) -ida_moves.lochist_t.current_index (method) -ida_moves.lochist_t.fwd (method) -ida_moves.lochist_t.get (method) -ida_moves.lochist_t.get_current (method) -ida_moves.lochist_t.get_place_id (method) -ida_moves.lochist_t.get_template_place (method) -ida_moves.lochist_t.init (method) -ida_moves.lochist_t.is_history_enabled (method) -ida_moves.lochist_t.jump (method) -ida_moves.lochist_t.netcode (method) -ida_moves.lochist_t.save (method) -ida_moves.lochist_t.seek (method) -ida_moves.lochist_t.set (method) -ida_moves.lochist_t.set_current (method) -ida_moves.lochist_t.size (method) -ida_moves.renderer_info_pos_t (class) -ida_moves.renderer_info_pos_t.__eq__ (method) -ida_moves.renderer_info_pos_t.__init__ (method) -ida_moves.renderer_info_pos_t.__ne__ (method) -ida_moves.renderer_info_t (class) -ida_moves.renderer_info_t.__eq__ (method) -ida_moves.renderer_info_t.__init__ (method) -ida_moves.renderer_info_t.__ne__ (method) -ida_moves.segm_move_info_t (class) -ida_moves.segm_move_info_t.__eq__ (method) -ida_moves.segm_move_info_t.__init__ (method) -ida_moves.segm_move_info_t.__ne__ (method) -ida_moves.segm_move_info_vec_t (class) -ida_moves.segm_move_info_vec_t.__eq__ (method) -ida_moves.segm_move_info_vec_t.__getitem__ (method) -ida_moves.segm_move_info_vec_t.__init__ (method) -ida_moves.segm_move_info_vec_t.__len__ (method) -ida_moves.segm_move_info_vec_t.__ne__ (method) -ida_moves.segm_move_info_vec_t.__setitem__ (method) -ida_moves.segm_move_info_vec_t._del (method) -ida_moves.segm_move_info_vec_t.add_unique (method) -ida_moves.segm_move_info_vec_t.at (method) -ida_moves.segm_move_info_vec_t.begin (method) -ida_moves.segm_move_info_vec_t.capacity (method) -ida_moves.segm_move_info_vec_t.clear (method) -ida_moves.segm_move_info_vec_t.empty (method) -ida_moves.segm_move_info_vec_t.end (method) -ida_moves.segm_move_info_vec_t.erase (method) -ida_moves.segm_move_info_vec_t.extract (method) -ida_moves.segm_move_info_vec_t.find (method) -ida_moves.segm_move_info_vec_t.grow (method) -ida_moves.segm_move_info_vec_t.has (method) -ida_moves.segm_move_info_vec_t.inject (method) -ida_moves.segm_move_info_vec_t.insert (method) -ida_moves.segm_move_info_vec_t.pop_back (method) -ida_moves.segm_move_info_vec_t.push_back (method) -ida_moves.segm_move_info_vec_t.qclear (method) -ida_moves.segm_move_info_vec_t.reserve (method) -ida_moves.segm_move_info_vec_t.resize (method) -ida_moves.segm_move_info_vec_t.size (method) -ida_moves.segm_move_info_vec_t.swap (method) -ida_moves.segm_move_info_vec_t.truncate (method) -ida_moves.segm_move_infos_t (class) -ida_moves.segm_move_infos_t.__init__ (method) -ida_moves.segm_move_infos_t.find (method) -ida_nalt (module) -ida_nalt.AFL_ALIGNFLOW (variable) -ida_nalt.AFL_BNOT0 (variable) -ida_nalt.AFL_BNOT1 (variable) -ida_nalt.AFL_COLORED (variable) -ida_nalt.AFL_FIXEDSPD (variable) -ida_nalt.AFL_HIDDEN (variable) -ida_nalt.AFL_HR_DETERMINED (variable) -ida_nalt.AFL_HR_GUESSED_DATA (variable) -ida_nalt.AFL_HR_GUESSED_FUNC (variable) -ida_nalt.AFL_IDA_GUESSED (variable) -ida_nalt.AFL_LIB (variable) -ida_nalt.AFL_LINNUM (variable) -ida_nalt.AFL_LNAME (variable) -ida_nalt.AFL_LZERO0 (variable) -ida_nalt.AFL_LZERO1 (variable) -ida_nalt.AFL_MANUAL (variable) -ida_nalt.AFL_NOBRD (variable) -ida_nalt.AFL_NORET (variable) -ida_nalt.AFL_NOTCODE (variable) -ida_nalt.AFL_NOTPROC (variable) -ida_nalt.AFL_PUBNAM (variable) -ida_nalt.AFL_RETFP (variable) -ida_nalt.AFL_TERSESTR (variable) -ida_nalt.AFL_TI (variable) -ida_nalt.AFL_TI0 (variable) -ida_nalt.AFL_TI1 (variable) -ida_nalt.AFL_TILCMT (variable) -ida_nalt.AFL_TYPE_GUESSED (variable) -ida_nalt.AFL_USEMODSP (variable) -ida_nalt.AFL_USERSP (variable) -ida_nalt.AFL_USERTI (variable) -ida_nalt.AFL_WEAKNAM (variable) -ida_nalt.AFL_ZSTROFF (variable) -ida_nalt.AP_ALLOWDUPS (variable) -ida_nalt.AP_ARRAY (variable) -ida_nalt.AP_IDXBASEMASK (variable) -ida_nalt.AP_IDXBIN (variable) -ida_nalt.AP_IDXDEC (variable) -ida_nalt.AP_IDXHEX (variable) -ida_nalt.AP_IDXOCT (variable) -ida_nalt.AP_INDEX (variable) -ida_nalt.AP_SIGNED (variable) -ida_nalt.IDB_DESKTOPS_NODE_NAME (variable) -ida_nalt.IDB_DESKTOPS_TAG (variable) -ida_nalt.MAXSTRUCPATH (variable) -ida_nalt.NALT_ABSBASE (variable) -ida_nalt.NALT_AFLAGS (variable) -ida_nalt.NALT_ALIGN (variable) -ida_nalt.NALT_COLOR (variable) -ida_nalt.NALT_CREF_FROM (variable) -ida_nalt.NALT_CREF_TO (variable) -ida_nalt.NALT_DREF_FROM (variable) -ida_nalt.NALT_DREF_TO (variable) -ida_nalt.NALT_ENUM0 (variable) -ida_nalt.NALT_ENUM1 (variable) -ida_nalt.NALT_GR_LAYX (variable) -ida_nalt.NALT_LINNUM (variable) -ida_nalt.NALT_PURGE (variable) -ida_nalt.NALT_STRTYPE (variable) -ida_nalt.NALT_STRUCT (variable) -ida_nalt.NALT_SWITCH (variable) -ida_nalt.NSUP_ARGEAS (variable) -ida_nalt.NSUP_ARRAY (variable) -ida_nalt.NSUP_CMT (variable) -ida_nalt.NSUP_CUSTDT (variable) -ida_nalt.NSUP_EX_FLAGS (variable) -ida_nalt.NSUP_FOP1 (variable) -ida_nalt.NSUP_FOP2 (variable) -ida_nalt.NSUP_FOP3 (variable) -ida_nalt.NSUP_FOP4 (variable) -ida_nalt.NSUP_FOP5 (variable) -ida_nalt.NSUP_FOP6 (variable) -ida_nalt.NSUP_FOP7 (variable) -ida_nalt.NSUP_FOP8 (variable) -ida_nalt.NSUP_FTAILS (variable) -ida_nalt.NSUP_GROUP (variable) -ida_nalt.NSUP_GR_INFO (variable) -ida_nalt.NSUP_GR_LAYT (variable) -ida_nalt.NSUP_JINFO (variable) -ida_nalt.NSUP_LLABEL (variable) -ida_nalt.NSUP_MANUAL (variable) -ida_nalt.NSUP_OPTYPES (variable) -ida_nalt.NSUP_OREF0 (variable) -ida_nalt.NSUP_OREF1 (variable) -ida_nalt.NSUP_OREF2 (variable) -ida_nalt.NSUP_OREF3 (variable) -ida_nalt.NSUP_OREF4 (variable) -ida_nalt.NSUP_OREF5 (variable) -ida_nalt.NSUP_OREF6 (variable) -ida_nalt.NSUP_OREF7 (variable) -ida_nalt.NSUP_ORIGFMD (variable) -ida_nalt.NSUP_POINTS (variable) -ida_nalt.NSUP_REF0 (variable) -ida_nalt.NSUP_REF1 (variable) -ida_nalt.NSUP_REF2 (variable) -ida_nalt.NSUP_REF3 (variable) -ida_nalt.NSUP_REF4 (variable) -ida_nalt.NSUP_REF5 (variable) -ida_nalt.NSUP_REF6 (variable) -ida_nalt.NSUP_REF7 (variable) -ida_nalt.NSUP_REGARG (variable) -ida_nalt.NSUP_REGVAR (variable) -ida_nalt.NSUP_REPCMT (variable) -ida_nalt.NSUP_SEGTRANS (variable) -ida_nalt.NSUP_SWITCH (variable) -ida_nalt.NSUP_TYPEINFO (variable) -ida_nalt.NSUP_XREFPOS (variable) -ida_nalt.PATCH_TAG (variable) -ida_nalt.REFINFO_CUSTOM (variable) -ida_nalt.REFINFO_NOBASE (variable) -ida_nalt.REFINFO_NO_ONES (variable) -ida_nalt.REFINFO_NO_ZEROS (variable) -ida_nalt.REFINFO_PASTEND (variable) -ida_nalt.REFINFO_RVAOFF (variable) -ida_nalt.REFINFO_SELFREF (variable) -ida_nalt.REFINFO_SIGNEDOP (variable) -ida_nalt.REFINFO_SUBTRACT (variable) -ida_nalt.REFINFO_TYPE (variable) -ida_nalt.REF_HIGH16 (variable) -ida_nalt.REF_HIGH8 (variable) -ida_nalt.REF_LOW16 (variable) -ida_nalt.REF_LOW8 (variable) -ida_nalt.REF_OFF16 (variable) -ida_nalt.REF_OFF32 (variable) -ida_nalt.REF_OFF64 (variable) -ida_nalt.REF_OFF8 (variable) -ida_nalt.RIDX_ABINAME (variable) -ida_nalt.RIDX_ARCHIVE_PATH (variable) -ida_nalt.RIDX_C_MACROS (variable) -ida_nalt.RIDX_DBG_BINPATHS (variable) -ida_nalt.RIDX_DUALOP_GRAPH (variable) -ida_nalt.RIDX_DUALOP_TEXT (variable) -ida_nalt.RIDX_FILE_FORMAT_NAME (variable) -ida_nalt.RIDX_GROUPS (variable) -ida_nalt.RIDX_H_PATH (variable) -ida_nalt.RIDX_IDA_VERSION (variable) -ida_nalt.RIDX_INCLUDE (variable) -ida_nalt.RIDX_MD5 (variable) -ida_nalt.RIDX_NOTEPAD (variable) -ida_nalt.RIDX_PROBLEMS (variable) -ida_nalt.RIDX_SELECTORS (variable) -ida_nalt.RIDX_SHA256 (variable) -ida_nalt.RIDX_SMALL_IDC (variable) -ida_nalt.RIDX_SMALL_IDC_OLD (variable) -ida_nalt.RIDX_SRCDBG_PATHS (variable) -ida_nalt.RIDX_SRCDBG_UNDESIRED (variable) -ida_nalt.RIDX_STR_ENCODINGS (variable) -ida_nalt.STRENC_DEFAULT (variable) -ida_nalt.STRENC_NONE (variable) -ida_nalt.STRTYPE_C (variable) -ida_nalt.STRTYPE_C_16 (variable) -ida_nalt.STRTYPE_C_32 (variable) -ida_nalt.STRTYPE_LEN2 (variable) -ida_nalt.STRTYPE_LEN2_16 (variable) -ida_nalt.STRTYPE_LEN4 (variable) -ida_nalt.STRTYPE_PASCAL (variable) -ida_nalt.STRTYPE_PASCAL_16 (variable) -ida_nalt.STRTYPE_TERMCHR (variable) -ida_nalt.SWI_CUSTOM (variable) -ida_nalt.SWI_DEFRET (variable) -ida_nalt.SWI_DEF_IN_TBL (variable) -ida_nalt.SWI_ELBASE (variable) -ida_nalt.SWI_HXNOLOWCASE (variable) -ida_nalt.SWI_INDIRECT (variable) -ida_nalt.SWI_J32 (variable) -ida_nalt.SWI_JMPINSN (variable) -ida_nalt.SWI_JMP_INV (variable) -ida_nalt.SWI_JSIZE (variable) -ida_nalt.SWI_SELFREL (variable) -ida_nalt.SWI_SEPARATE (variable) -ida_nalt.SWI_SHIFT_MASK (variable) -ida_nalt.SWI_SIGNED (variable) -ida_nalt.SWI_SPARSE (variable) -ida_nalt.SWI_STDTBL (variable) -ida_nalt.SWI_SUBTRACT (variable) -ida_nalt.SWI_USER (variable) -ida_nalt.SWI_V32 (variable) -ida_nalt.SWI_VERSION (variable) -ida_nalt.SWI_VSIZE (variable) -ida_nalt.SWI_VSPLIT (variable) -ida_nalt.V695_REF_OFF8 (variable) -ida_nalt.V695_REF_VHIGH (variable) -ida_nalt.V695_REF_VLOW (variable) -ida_nalt.add_encoding (function) -ida_nalt.array_parameters_t (class) -ida_nalt.array_parameters_t.__init__ (method) -ida_nalt.array_parameters_t.alignment (variable) -ida_nalt.array_parameters_t.lineitems (variable) -ida_nalt.clr__bnot0 (function) -ida_nalt.clr__bnot1 (function) -ida_nalt.clr__invsign0 (function) -ida_nalt.clr__invsign1 (function) -ida_nalt.clr_abits (function) -ida_nalt.clr_align_flow (function) -ida_nalt.clr_colored_item (function) -ida_nalt.clr_fixed_spd (function) -ida_nalt.clr_has_lname (function) -ida_nalt.clr_has_ti (function) -ida_nalt.clr_has_ti0 (function) -ida_nalt.clr_has_ti1 (function) -ida_nalt.clr_libitem (function) -ida_nalt.clr_lzero0 (function) -ida_nalt.clr_lzero1 (function) -ida_nalt.clr_noret (function) -ida_nalt.clr_notcode (function) -ida_nalt.clr_notproc (function) -ida_nalt.clr_retfp (function) -ida_nalt.clr_terse_struc (function) -ida_nalt.clr_tilcmt (function) -ida_nalt.clr_usemodsp (function) -ida_nalt.clr_usersp (function) -ida_nalt.clr_userti (function) -ida_nalt.clr_zstroff (function) -ida_nalt.custom_data_type_ids_fids_array (class) -ida_nalt.custom_data_type_ids_fids_array.__getitem__ (method) -ida_nalt.custom_data_type_ids_fids_array.__init__ (method) -ida_nalt.custom_data_type_ids_fids_array.__len__ (method) -ida_nalt.custom_data_type_ids_fids_array.__setitem__ (method) -ida_nalt.custom_data_type_ids_fids_array._get_bytes (method) -ida_nalt.custom_data_type_ids_fids_array._set_bytes (method) -ida_nalt.custom_data_type_ids_t (class) -ida_nalt.custom_data_type_ids_t.__getFids (method) -ida_nalt.custom_data_type_ids_t.__init__ (method) -ida_nalt.custom_data_type_ids_t.dtid (variable) -ida_nalt.custom_data_type_ids_t.fids (variable) -ida_nalt.custom_data_type_ids_t.get_dtid (method) -ida_nalt.custom_data_type_ids_t.set (method) -ida_nalt.dbg_get_input_path (function) -ida_nalt.del_absbase (function) -ida_nalt.del_aflags (function) -ida_nalt.del_alignment (function) -ida_nalt.del_array_parameters (function) -ida_nalt.del_custom_data_type_ids (function) -ida_nalt.del_encoding (function) -ida_nalt.del_ind_purged (function) -ida_nalt.del_item_color (function) -ida_nalt.del_op_tinfo (function) -ida_nalt.del_refinfo (function) -ida_nalt.del_source_linnum (function) -ida_nalt.del_str_type (function) -ida_nalt.del_switch_info (function) -ida_nalt.del_switch_parent (function) -ida_nalt.del_tinfo (function) -ida_nalt.delete_imports (function) -ida_nalt.ea2node (function) -ida_nalt.encoding_from_strtype (function) -ida_nalt.enum_const_t (class) -ida_nalt.enum_const_t.__init__ (method) -ida_nalt.enum_import_names (function) -ida_nalt.find_custom_refinfo (function) -ida_nalt.get_abi_name (function) -ida_nalt.get_absbase (function) -ida_nalt.get_aflags (function) -ida_nalt.get_alignment (function) -ida_nalt.get_archive_path (function) -ida_nalt.get_array_parameters (function) -ida_nalt.get_asm_inc_file (function) -ida_nalt.get_custom_data_type_ids (function) -ida_nalt.get_custom_refinfo (function) -ida_nalt.get_default_encoding_idx (function) -ida_nalt.get_elapsed_secs (function) -ida_nalt.get_encoding_bpu (function) -ida_nalt.get_encoding_bpu_by_name (function) -ida_nalt.get_encoding_name (function) -ida_nalt.get_encoding_qty (function) -ida_nalt.get_gotea (function) -ida_nalt.get_ida_notepad_text (function) -ida_nalt.get_idb_ctime (function) -ida_nalt.get_idb_nopens (function) -ida_nalt.get_ids_modnode (function) -ida_nalt.get_imagebase (function) -ida_nalt.get_import_module_name (function) -ida_nalt.get_import_module_qty (function) -ida_nalt.get_ind_purged (function) -ida_nalt.get_initial_ida_version (function) -ida_nalt.get_initial_idb_version (function) -ida_nalt.get_input_file_path (function) -ida_nalt.get_item_color (function) -ida_nalt.get_loader_format_name (function) -ida_nalt.get_op_tinfo (function) -ida_nalt.get_outfile_encoding_idx (function) -ida_nalt.get_refinfo (function) -ida_nalt.get_reftype_by_size (function) -ida_nalt.get_root_filename (function) -ida_nalt.get_source_linnum (function) -ida_nalt.get_srcdbg_paths (function) -ida_nalt.get_srcdbg_undesired_paths (function) -ida_nalt.get_str_encoding_idx (function) -ida_nalt.get_str_term1 (function) -ida_nalt.get_str_term2 (function) -ida_nalt.get_str_type (function) -ida_nalt.get_str_type_code (function) -ida_nalt.get_str_type_prefix_length (function) -ida_nalt.get_strid (function) -ida_nalt.get_strtype_bpu (function) -ida_nalt.get_switch_info (function) -ida_nalt.get_switch_info (function) -ida_nalt.get_switch_parent (function) -ida_nalt.get_tinfo (function) -ida_nalt.getnode (function) -ida_nalt.has_aflag_linnum (function) -ida_nalt.has_aflag_lname (function) -ida_nalt.has_aflag_ti (function) -ida_nalt.has_aflag_ti0 (function) -ida_nalt.has_aflag_ti1 (function) -ida_nalt.has_lname (function) -ida_nalt.has_ti (function) -ida_nalt.has_ti0 (function) -ida_nalt.has_ti1 (function) -ida_nalt.hide_border (function) -ida_nalt.hide_item (function) -ida_nalt.is__bnot0 (function) -ida_nalt.is__bnot1 (function) -ida_nalt.is__invsign0 (function) -ida_nalt.is__invsign1 (function) -ida_nalt.is_aflag__bnot0 (function) -ida_nalt.is_aflag__bnot1 (function) -ida_nalt.is_aflag__invsign0 (function) -ida_nalt.is_aflag__invsign1 (function) -ida_nalt.is_aflag_align_flow (function) -ida_nalt.is_aflag_colored_item (function) -ida_nalt.is_aflag_data_guessed_by_hexrays (function) -ida_nalt.is_aflag_fixed_spd (function) -ida_nalt.is_aflag_func_guessed_by_hexrays (function) -ida_nalt.is_aflag_hidden_border (function) -ida_nalt.is_aflag_hidden_item (function) -ida_nalt.is_aflag_libitem (function) -ida_nalt.is_aflag_lzero0 (function) -ida_nalt.is_aflag_lzero1 (function) -ida_nalt.is_aflag_manual_insn (function) -ida_nalt.is_aflag_noret (function) -ida_nalt.is_aflag_notcode (function) -ida_nalt.is_aflag_notproc (function) -ida_nalt.is_aflag_public_name (function) -ida_nalt.is_aflag_retfp (function) -ida_nalt.is_aflag_terse_struc (function) -ida_nalt.is_aflag_tilcmt (function) -ida_nalt.is_aflag_type_determined_by_hexrays (function) -ida_nalt.is_aflag_type_guessed_by_hexrays (function) -ida_nalt.is_aflag_type_guessed_by_ida (function) -ida_nalt.is_aflag_usersp (function) -ida_nalt.is_aflag_userti (function) -ida_nalt.is_aflag_weak_name (function) -ida_nalt.is_aflag_zstroff (function) -ida_nalt.is_align_flow (function) -ida_nalt.is_colored_item (function) -ida_nalt.is_data_guessed_by_hexrays (function) -ida_nalt.is_finally_visible_item (function) -ida_nalt.is_fixed_spd (function) -ida_nalt.is_func_guessed_by_hexrays (function) -ida_nalt.is_hidden_border (function) -ida_nalt.is_hidden_item (function) -ida_nalt.is_libitem (function) -ida_nalt.is_lzero0 (function) -ida_nalt.is_lzero1 (function) -ida_nalt.is_noret (function) -ida_nalt.is_notcode (function) -ida_nalt.is_notproc (function) -ida_nalt.is_pascal (function) -ida_nalt.is_reftype_target_optional (function) -ida_nalt.is_retfp (function) -ida_nalt.is_terse_struc (function) -ida_nalt.is_tilcmt (function) -ida_nalt.is_type_determined_by_hexrays (function) -ida_nalt.is_type_guessed_by_hexrays (function) -ida_nalt.is_type_guessed_by_ida (function) -ida_nalt.is_usersp (function) -ida_nalt.is_userti (function) -ida_nalt.is_visible_item (function) -ida_nalt.is_zstroff (function) -ida_nalt.make_str_type (function) -ida_nalt.node2ea (function) -ida_nalt.opinfo_t (class) -ida_nalt.opinfo_t.__init__ (method) -ida_nalt.opinfo_t.cd (variable) -ida_nalt.opinfo_t.ec (variable) -ida_nalt.opinfo_t.path (variable) -ida_nalt.opinfo_t.ri (variable) -ida_nalt.opinfo_t.strtype (variable) -ida_nalt.opinfo_t.tid (variable) -ida_nalt.printop_t (class) -ida_nalt.printop_t.__init__ (method) -ida_nalt.printop_t.get_ti (method) -ida_nalt.printop_t.is_aflags_initialized (method) -ida_nalt.printop_t.is_f64 (method) -ida_nalt.printop_t.is_ti_initialized (method) -ida_nalt.printop_t.set_aflags_initialized (method) -ida_nalt.printop_t.set_ti_initialized (method) -ida_nalt.refinfo_t (class) -ida_nalt.refinfo_t.__init__ (method) -ida_nalt.refinfo_t.base (variable) -ida_nalt.refinfo_t.flags (variable) -ida_nalt.refinfo_t.init (method) -ida_nalt.refinfo_t.is_custom (method) -ida_nalt.refinfo_t.is_no_ones (method) -ida_nalt.refinfo_t.is_no_zeros (method) -ida_nalt.refinfo_t.is_pastend (method) -ida_nalt.refinfo_t.is_rvaoff (method) -ida_nalt.refinfo_t.is_selfref (method) -ida_nalt.refinfo_t.is_signed (method) -ida_nalt.refinfo_t.is_subtract (method) -ida_nalt.refinfo_t.is_target_optional (method) -ida_nalt.refinfo_t.no_base_xref (method) -ida_nalt.refinfo_t.set_type (method) -ida_nalt.refinfo_t.target (variable) -ida_nalt.refinfo_t.tdelta (variable) -ida_nalt.refinfo_t.type (method) -ida_nalt.rename_encoding (function) -ida_nalt.retrieve_input_file_crc32 (function) -ida_nalt.retrieve_input_file_md5 (function) -ida_nalt.retrieve_input_file_sha256 (function) -ida_nalt.retrieve_input_file_size (function) -ida_nalt.set__bnot0 (function) -ida_nalt.set__bnot1 (function) -ida_nalt.set__invsign0 (function) -ida_nalt.set__invsign1 (function) -ida_nalt.set_abits (function) -ida_nalt.set_absbase (function) -ida_nalt.set_aflags (function) -ida_nalt.set_align_flow (function) -ida_nalt.set_alignment (function) -ida_nalt.set_archive_path (function) -ida_nalt.set_array_parameters (function) -ida_nalt.set_asm_inc_file (function) -ida_nalt.set_colored_item (function) -ida_nalt.set_custom_data_type_ids (function) -ida_nalt.set_data_guessed_by_hexrays (function) -ida_nalt.set_default_encoding_idx (function) -ida_nalt.set_fixed_spd (function) -ida_nalt.set_func_guessed_by_hexrays (function) -ida_nalt.set_gotea (function) -ida_nalt.set_has_lname (function) -ida_nalt.set_has_ti (function) -ida_nalt.set_has_ti0 (function) -ida_nalt.set_has_ti1 (function) -ida_nalt.set_ida_notepad_text (function) -ida_nalt.set_ids_modnode (function) -ida_nalt.set_imagebase (function) -ida_nalt.set_item_color (function) -ida_nalt.set_libitem (function) -ida_nalt.set_loader_format_name (function) -ida_nalt.set_lzero0 (function) -ida_nalt.set_lzero1 (function) -ida_nalt.set_noret (function) -ida_nalt.set_notcode (function) -ida_nalt.set_notproc (function) -ida_nalt.set_op_tinfo (function) -ida_nalt.set_outfile_encoding_idx (function) -ida_nalt.set_refinfo (function) -ida_nalt.set_refinfo_ex (function) -ida_nalt.set_retfp (function) -ida_nalt.set_root_filename (function) -ida_nalt.set_source_linnum (function) -ida_nalt.set_srcdbg_paths (function) -ida_nalt.set_srcdbg_undesired_paths (function) -ida_nalt.set_str_encoding_idx (function) -ida_nalt.set_str_type (function) -ida_nalt.set_switch_info (function) -ida_nalt.set_switch_parent (function) -ida_nalt.set_terse_struc (function) -ida_nalt.set_tilcmt (function) -ida_nalt.set_tinfo (function) -ida_nalt.set_type_determined_by_hexrays (function) -ida_nalt.set_type_guessed_by_ida (function) -ida_nalt.set_usemodsp (function) -ida_nalt.set_usersp (function) -ida_nalt.set_userti (function) -ida_nalt.set_visible_item (function) -ida_nalt.set_zstroff (function) -ida_nalt.strpath_ids_array (class) -ida_nalt.strpath_ids_array.__getitem__ (method) -ida_nalt.strpath_ids_array.__init__ (method) -ida_nalt.strpath_ids_array.__len__ (method) -ida_nalt.strpath_ids_array.__setitem__ (method) -ida_nalt.strpath_ids_array._get_bytes (method) -ida_nalt.strpath_ids_array._set_bytes (method) -ida_nalt.strpath_t (class) -ida_nalt.strpath_t.__getIds (method) -ida_nalt.strpath_t.__init__ (method) -ida_nalt.switch_info_t (class) -ida_nalt.switch_info_t.__init__ (method) -ida_nalt.switch_info_t._get_values_lowcase (method) -ida_nalt.switch_info_t._set_values_lowcase (method) -ida_nalt.switch_info_t.assign (method) -ida_nalt.switch_info_t.clear (method) -ida_nalt.switch_info_t.custom (variable) -ida_nalt.switch_info_t.defjump (variable) -ida_nalt.switch_info_t.elbase (variable) -ida_nalt.switch_info_t.expr_ea (variable) -ida_nalt.switch_info_t.flags (variable) -ida_nalt.switch_info_t.get_jrange_vrange (method) -ida_nalt.switch_info_t.get_jtable_element_size (method) -ida_nalt.switch_info_t.get_jtable_size (method) -ida_nalt.switch_info_t.get_lowcase (method) -ida_nalt.switch_info_t.get_shift (method) -ida_nalt.switch_info_t.get_version (method) -ida_nalt.switch_info_t.get_vtable_element_size (method) -ida_nalt.switch_info_t.has_default (method) -ida_nalt.switch_info_t.has_elbase (method) -ida_nalt.switch_info_t.is_custom (method) -ida_nalt.switch_info_t.is_indirect (method) -ida_nalt.switch_info_t.is_nolowcase (method) -ida_nalt.switch_info_t.is_sparse (method) -ida_nalt.switch_info_t.is_subtract (method) -ida_nalt.switch_info_t.is_user_defined (method) -ida_nalt.switch_info_t.jcases (variable) -ida_nalt.switch_info_t.jumps (variable) -ida_nalt.switch_info_t.lowcase (variable) -ida_nalt.switch_info_t.marks (variable) -ida_nalt.switch_info_t.ncases (variable) -ida_nalt.switch_info_t.regdtype (variable) -ida_nalt.switch_info_t.regnum (variable) -ida_nalt.switch_info_t.set_elbase (method) -ida_nalt.switch_info_t.set_expr (method) -ida_nalt.switch_info_t.set_jtable_element_size (method) -ida_nalt.switch_info_t.set_jtable_size (method) -ida_nalt.switch_info_t.set_shift (method) -ida_nalt.switch_info_t.set_vtable_element_size (method) -ida_nalt.switch_info_t.startea (variable) -ida_nalt.switch_info_t.use_std_table (method) -ida_nalt.switch_info_t.values (variable) -ida_nalt.switch_info_t__from_ptrval__ (function) -ida_nalt.unhide_border (function) -ida_nalt.unhide_item (function) -ida_nalt.upd_abits (function) -ida_nalt.uses_aflag_modsp (function) -ida_nalt.uses_modsp (function) -ida_nalt.validate_idb_names (function) -ida_name (module) -ida_name.DEBNAME_EXACT (variable) -ida_name.DEBNAME_LOWER (variable) -ida_name.DEBNAME_NICE (variable) -ida_name.DEBNAME_UPPER (variable) -ida_name.FUNC_IMPORT_PREFIX (variable) -ida_name.GETN_APPZERO (variable) -ida_name.GETN_NODUMMY (variable) -ida_name.GETN_NOFIXUP (variable) -ida_name.GNCN_NOCOLOR (variable) -ida_name.GNCN_NODBGNM (variable) -ida_name.GNCN_NOFUNC (variable) -ida_name.GNCN_NOLABEL (variable) -ida_name.GNCN_NOSEG (variable) -ida_name.GNCN_PREFDBG (variable) -ida_name.GNCN_REQFUNC (variable) -ida_name.GNCN_REQNAME (variable) -ida_name.GNCN_SEGNUM (variable) -ida_name.GNCN_SEG_FUNC (variable) -ida_name.GN_COLORED (variable) -ida_name.GN_DEMANGLED (variable) -ida_name.GN_ISRET (variable) -ida_name.GN_LOCAL (variable) -ida_name.GN_LONG (variable) -ida_name.GN_NOT_DUMMY (variable) -ida_name.GN_NOT_ISRET (variable) -ida_name.GN_SHORT (variable) -ida_name.GN_STRICT (variable) -ida_name.GN_VISIBLE (variable) -ida_name.MAXNAMELEN (variable) -ida_name.NT_ABS (variable) -ida_name.NT_BMASK (variable) -ida_name.NT_BYTE (variable) -ida_name.NT_ENUM (variable) -ida_name.NT_LOCAL (variable) -ida_name.NT_NONE (variable) -ida_name.NT_REGVAR (variable) -ida_name.NT_SEG (variable) -ida_name.NT_STKVAR (variable) -ida_name.NT_STROFF (variable) -ida_name.NearestName (class) -ida_name.NearestName.__getitem__ (method) -ida_name.NearestName.__init__ (method) -ida_name.NearestName.__iter__ (method) -ida_name.NearestName._get_item (method) -ida_name.NearestName.find (method) -ida_name.NearestName.update (method) -ida_name.SN_AUTO (variable) -ida_name.SN_CHECK (variable) -ida_name.SN_DELTAIL (variable) -ida_name.SN_FORCE (variable) -ida_name.SN_IDBENC (variable) -ida_name.SN_LOCAL (variable) -ida_name.SN_NOCHECK (variable) -ida_name.SN_NODUMMY (variable) -ida_name.SN_NOLIST (variable) -ida_name.SN_NON_AUTO (variable) -ida_name.SN_NON_PUBLIC (variable) -ida_name.SN_NON_WEAK (variable) -ida_name.SN_NOWARN (variable) -ida_name.SN_PUBLIC (variable) -ida_name.SN_WEAK (variable) -ida_name.append_struct_fields (function) -ida_name.calc_gtn_flags (function) -ida_name.cleanup_name (function) -ida_name.del_debug_names (function) -ida_name.del_global_name (function) -ida_name.del_local_name (function) -ida_name.demangle_name (function) -ida_name.ea_name_t (class) -ida_name.ea_name_t.__init__ (method) -ida_name.ea_name_vec_t (class) -ida_name.ea_name_vec_t.__getitem__ (method) -ida_name.ea_name_vec_t.__init__ (method) -ida_name.ea_name_vec_t.__len__ (method) -ida_name.ea_name_vec_t.__setitem__ (method) -ida_name.ea_name_vec_t.at (method) -ida_name.ea_name_vec_t.begin (method) -ida_name.ea_name_vec_t.capacity (method) -ida_name.ea_name_vec_t.clear (method) -ida_name.ea_name_vec_t.empty (method) -ida_name.ea_name_vec_t.end (method) -ida_name.ea_name_vec_t.erase (method) -ida_name.ea_name_vec_t.extract (method) -ida_name.ea_name_vec_t.grow (method) -ida_name.ea_name_vec_t.inject (method) -ida_name.ea_name_vec_t.insert (method) -ida_name.ea_name_vec_t.pop_back (method) -ida_name.ea_name_vec_t.push_back (method) -ida_name.ea_name_vec_t.qclear (method) -ida_name.ea_name_vec_t.reserve (method) -ida_name.ea_name_vec_t.resize (method) -ida_name.ea_name_vec_t.size (method) -ida_name.ea_name_vec_t.swap (method) -ida_name.ea_name_vec_t.truncate (method) -ida_name.extract_name (function) -ida_name.force_name (function) -ida_name.get_colored_demangled_name (function) -ida_name.get_colored_long_name (function) -ida_name.get_colored_name (function) -ida_name.get_colored_short_name (function) -ida_name.get_cp_validity (function) -ida_name.get_debug_name (function) -ida_name.get_debug_name_ea (function) -ida_name.get_debug_names (function) -ida_name.get_demangled_name (function) -ida_name.get_ea_name (function) -ida_name.get_long_name (function) -ida_name.get_mangled_name_type (function) -ida_name.get_name (function) -ida_name.get_name_base_ea (function) -ida_name.get_name_color (function) -ida_name.get_name_ea (function) -ida_name.get_name_expr (function) -ida_name.get_name_value (function) -ida_name.get_nice_colored_name (function) -ida_name.get_nlist_ea (function) -ida_name.get_nlist_idx (function) -ida_name.get_nlist_name (function) -ida_name.get_nlist_size (function) -ida_name.get_short_name (function) -ida_name.get_visible_name (function) -ida_name.hide_name (function) -ida_name.is_ident (function) -ida_name.is_ident_cp (function) -ida_name.is_in_nlist (function) -ida_name.is_name_defined_locally (function) -ida_name.is_public_name (function) -ida_name.is_strlit_cp (function) -ida_name.is_uname (function) -ida_name.is_valid_cp (function) -ida_name.is_valid_typename (function) -ida_name.is_visible_cp (function) -ida_name.is_weak_name (function) -ida_name.make_name_auto (function) -ida_name.make_name_non_public (function) -ida_name.make_name_non_weak (function) -ida_name.make_name_public (function) -ida_name.make_name_user (function) -ida_name.make_name_weak (function) -ida_name.rebuild_nlist (function) -ida_name.reorder_dummy_names (function) -ida_name.set_cp_validity (function) -ida_name.set_debug_name (function) -ida_name.set_dummy_name (function) -ida_name.set_name (function) -ida_name.show_name (function) -ida_name.validate_name (function) -ida_netnode (module) -ida_netnode.BADNODE (variable) -ida_netnode.MAXNAMESIZE (variable) -ida_netnode.MAXSPECSIZE (variable) -ida_netnode.MAX_NODENAME_SIZE (variable) -ida_netnode.atag (variable) -ida_netnode.exist (function) -ida_netnode.htag (variable) -ida_netnode.ltag (variable) -ida_netnode.netnode (class) -ida_netnode.netnode.__eq__ (method) -ida_netnode.netnode.__init__ (method) -ida_netnode.netnode.__ne__ (method) -ida_netnode.netnode.altdel (method) -ida_netnode.netnode.altdel_all (method) -ida_netnode.netnode.altdel_ea (method) -ida_netnode.netnode.altdel_idx8 (method) -ida_netnode.netnode.altfirst (method) -ida_netnode.netnode.altfirst_idx8 (method) -ida_netnode.netnode.altlast (method) -ida_netnode.netnode.altlast_idx8 (method) -ida_netnode.netnode.altnext (method) -ida_netnode.netnode.altnext_idx8 (method) -ida_netnode.netnode.altprev (method) -ida_netnode.netnode.altprev_idx8 (method) -ida_netnode.netnode.altset (method) -ida_netnode.netnode.altset_ea (method) -ida_netnode.netnode.altset_idx8 (method) -ida_netnode.netnode.altshift (method) -ida_netnode.netnode.altval (method) -ida_netnode.netnode.altval_ea (method) -ida_netnode.netnode.altval_idx8 (method) -ida_netnode.netnode.blobshift (method) -ida_netnode.netnode.blobsize (method) -ida_netnode.netnode.blobsize_ea (method) -ida_netnode.netnode.chardel (method) -ida_netnode.netnode.chardel_ea (method) -ida_netnode.netnode.chardel_idx8 (method) -ida_netnode.netnode.charfirst (method) -ida_netnode.netnode.charfirst_idx8 (method) -ida_netnode.netnode.charlast (method) -ida_netnode.netnode.charlast_idx8 (method) -ida_netnode.netnode.charnext (method) -ida_netnode.netnode.charnext_idx8 (method) -ida_netnode.netnode.charprev (method) -ida_netnode.netnode.charprev_idx8 (method) -ida_netnode.netnode.charset (method) -ida_netnode.netnode.charset_ea (method) -ida_netnode.netnode.charset_idx8 (method) -ida_netnode.netnode.charshift (method) -ida_netnode.netnode.charval (method) -ida_netnode.netnode.charval_ea (method) -ida_netnode.netnode.charval_idx8 (method) -ida_netnode.netnode.copyto (method) -ida_netnode.netnode.create (method) -ida_netnode.netnode.delblob (method) -ida_netnode.netnode.delblob_ea (method) -ida_netnode.netnode.delvalue (method) -ida_netnode.netnode.eadel (method) -ida_netnode.netnode.eadel_idx8 (method) -ida_netnode.netnode.eaget (method) -ida_netnode.netnode.eaget_idx (method) -ida_netnode.netnode.eaget_idx8 (method) -ida_netnode.netnode.easet (method) -ida_netnode.netnode.easet_idx (method) -ida_netnode.netnode.easet_idx8 (method) -ida_netnode.netnode.end (method) -ida_netnode.netnode.exist (method) -ida_netnode.netnode.get_name (method) -ida_netnode.netnode.getblob (method) -ida_netnode.netnode.getblob_ea (method) -ida_netnode.netnode.getclob (method) -ida_netnode.netnode.hashdel (method) -ida_netnode.netnode.hashdel_all (method) -ida_netnode.netnode.hashfirst (method) -ida_netnode.netnode.hashlast (method) -ida_netnode.netnode.hashnext (method) -ida_netnode.netnode.hashprev (method) -ida_netnode.netnode.hashset (method) -ida_netnode.netnode.hashset_buf (method) -ida_netnode.netnode.hashset_idx (method) -ida_netnode.netnode.hashstr (method) -ida_netnode.netnode.hashstr_buf (method) -ida_netnode.netnode.hashval (method) -ida_netnode.netnode.hashval_long (method) -ida_netnode.netnode.index (method) -ida_netnode.netnode.kill (method) -ida_netnode.netnode.long_value (method) -ida_netnode.netnode.lower_bound (method) -ida_netnode.netnode.lower_bound_ea (method) -ida_netnode.netnode.lower_bound_idx8 (method) -ida_netnode.netnode.moveto (method) -ida_netnode.netnode.next (method) -ida_netnode.netnode.prev (method) -ida_netnode.netnode.rename (method) -ida_netnode.netnode.set (method) -ida_netnode.netnode.set_long (method) -ida_netnode.netnode.setblob (method) -ida_netnode.netnode.setblob_ea (method) -ida_netnode.netnode.start (method) -ida_netnode.netnode.supdel (method) -ida_netnode.netnode.supdel_all (method) -ida_netnode.netnode.supdel_ea (method) -ida_netnode.netnode.supdel_idx8 (method) -ida_netnode.netnode.supdel_range (method) -ida_netnode.netnode.supdel_range_idx8 (method) -ida_netnode.netnode.supfirst (method) -ida_netnode.netnode.supfirst_idx8 (method) -ida_netnode.netnode.suplast (method) -ida_netnode.netnode.suplast_idx8 (method) -ida_netnode.netnode.supnext (method) -ida_netnode.netnode.supnext_idx8 (method) -ida_netnode.netnode.supprev (method) -ida_netnode.netnode.supprev_idx8 (method) -ida_netnode.netnode.supset (method) -ida_netnode.netnode.supset_ea (method) -ida_netnode.netnode.supset_idx8 (method) -ida_netnode.netnode.supshift (method) -ida_netnode.netnode.supstr (method) -ida_netnode.netnode.supstr_ea (method) -ida_netnode.netnode.supstr_idx8 (method) -ida_netnode.netnode.supval (method) -ida_netnode.netnode.supval_ea (method) -ida_netnode.netnode.supval_idx8 (method) -ida_netnode.netnode.valobj (method) -ida_netnode.netnode.valstr (method) -ida_netnode.netnode.value_exists (method) -ida_netnode.netnode_exist (function) -ida_netnode.ntag (variable) -ida_netnode.stag (variable) -ida_netnode.vtag (variable) -ida_offset (module) -ida_offset.add_refinfo_dref (function) -ida_offset.calc_basevalue (function) -ida_offset.calc_offset_base (function) -ida_offset.calc_probable_base_by_value (function) -ida_offset.calc_reference_data (function) -ida_offset.calc_target (function) -ida_offset.can_be_off32 (function) -ida_offset.get_default_reftype (function) -ida_offset.get_offbase (function) -ida_offset.get_offset_expr (function) -ida_offset.get_offset_expression (function) -ida_offset.op_offset (function) -ida_offset.op_offset_ex (function) -ida_offset.op_plain_offset (function) -ida_pro (module) -ida_pro.CP_UTF16 (variable) -ida_pro.IDA_SDK_VERSION (variable) -ida_pro.IDBDEC_ESCAPE (variable) -ida_pro.IOREDIR_APPEND (variable) -ida_pro.IOREDIR_INPUT (variable) -ida_pro.IOREDIR_OUTPUT (variable) -ida_pro.IOREDIR_QUOTED (variable) -ida_pro.MAXSTR (variable) -ida_pro.SUBSTCHAR (variable) -ida_pro.__MF__ (variable) -ida_pro.__qmutex_t (class) -ida_pro.__qmutex_t.__init__ (method) -ida_pro.__qsemaphore_t (class) -ida_pro.__qsemaphore_t.__init__ (method) -ida_pro.__qthread_t (class) -ida_pro.__qthread_t.__init__ (method) -ida_pro._qstrvec_t (class) -ida_pro._qstrvec_t.__get_size (method) -ida_pro._qstrvec_t.__getitem__ (method) -ida_pro._qstrvec_t.__init__ (method) -ida_pro._qstrvec_t.__setitem__ (method) -ida_pro._qstrvec_t._create_clink (method) -ida_pro._qstrvec_t._del_clink (method) -ida_pro._qstrvec_t._get_clink_ptr (method) -ida_pro._qstrvec_t.add (method) -ida_pro._qstrvec_t.addressof (method) -ida_pro._qstrvec_t.assign (method) -ida_pro._qstrvec_t.clear (method) -ida_pro._qstrvec_t.from_list (method) -ida_pro._qstrvec_t.insert (method) -ida_pro._qstrvec_t.remove (method) -ida_pro._qstrvec_t.size (variable) -ida_pro.boolvec_t (class) -ida_pro.boolvec_t.__eq__ (method) -ida_pro.boolvec_t.__getitem__ (method) -ida_pro.boolvec_t.__init__ (method) -ida_pro.boolvec_t.__len__ (method) -ida_pro.boolvec_t.__ne__ (method) -ida_pro.boolvec_t.__setitem__ (method) -ida_pro.boolvec_t._del (method) -ida_pro.boolvec_t.add_unique (method) -ida_pro.boolvec_t.at (method) -ida_pro.boolvec_t.begin (method) -ida_pro.boolvec_t.capacity (method) -ida_pro.boolvec_t.clear (method) -ida_pro.boolvec_t.empty (method) -ida_pro.boolvec_t.end (method) -ida_pro.boolvec_t.erase (method) -ida_pro.boolvec_t.extract (method) -ida_pro.boolvec_t.find (method) -ida_pro.boolvec_t.grow (method) -ida_pro.boolvec_t.has (method) -ida_pro.boolvec_t.inject (method) -ida_pro.boolvec_t.insert (method) -ida_pro.boolvec_t.pop_back (method) -ida_pro.boolvec_t.push_back (method) -ida_pro.boolvec_t.qclear (method) -ida_pro.boolvec_t.reserve (method) -ida_pro.boolvec_t.resize (method) -ida_pro.boolvec_t.size (method) -ida_pro.boolvec_t.swap (method) -ida_pro.boolvec_t.truncate (method) -ida_pro.channel_redir_t (class) -ida_pro.channel_redir_t.__init__ (method) -ida_pro.channel_redir_t.fd (variable) -ida_pro.channel_redir_t.file (variable) -ida_pro.channel_redir_t.flags (variable) -ida_pro.channel_redir_t.is_append (method) -ida_pro.channel_redir_t.is_input (method) -ida_pro.channel_redir_t.is_output (method) -ida_pro.channel_redir_t.is_quoted (method) -ida_pro.channel_redir_t.length (variable) -ida_pro.channel_redir_t.start (variable) -ida_pro.check_process_exit (function) -ida_pro.ea_array (class) -ida_pro.ea_array.__getitem__ (method) -ida_pro.ea_array.__init__ (method) -ida_pro.ea_array.__setitem__ (method) -ida_pro.ea_array.cast (method) -ida_pro.ea_array.frompointer (method) -ida_pro.ea_array_frompointer (function) -ida_pro.ea_pointer (class) -ida_pro.ea_pointer.__init__ (method) -ida_pro.ea_pointer.assign (method) -ida_pro.ea_pointer.cast (method) -ida_pro.ea_pointer.frompointer (method) -ida_pro.ea_pointer.value (method) -ida_pro.ea_pointer_frompointer (function) -ida_pro.extend_sign (function) -ida_pro.instant_dbgopts_t (class) -ida_pro.instant_dbgopts_t.__init__ (method) -ida_pro.instant_dbgopts_t.attach (variable) -ida_pro.instant_dbgopts_t.debmod (variable) -ida_pro.instant_dbgopts_t.env (variable) -ida_pro.instant_dbgopts_t.event_id (variable) -ida_pro.instant_dbgopts_t.host (variable) -ida_pro.instant_dbgopts_t.pid (variable) -ida_pro.instant_dbgopts_t.port (variable) -ida_pro.int64vec_t (class) -ida_pro.int64vec_t.__eq__ (method) -ida_pro.int64vec_t.__getitem__ (method) -ida_pro.int64vec_t.__init__ (method) -ida_pro.int64vec_t.__len__ (method) -ida_pro.int64vec_t.__ne__ (method) -ida_pro.int64vec_t.__setitem__ (method) -ida_pro.int64vec_t._del (method) -ida_pro.int64vec_t.add_unique (method) -ida_pro.int64vec_t.at (method) -ida_pro.int64vec_t.begin (method) -ida_pro.int64vec_t.capacity (method) -ida_pro.int64vec_t.clear (method) -ida_pro.int64vec_t.empty (method) -ida_pro.int64vec_t.end (method) -ida_pro.int64vec_t.erase (method) -ida_pro.int64vec_t.extract (method) -ida_pro.int64vec_t.find (method) -ida_pro.int64vec_t.has (method) -ida_pro.int64vec_t.inject (method) -ida_pro.int64vec_t.insert (method) -ida_pro.int64vec_t.pop_back (method) -ida_pro.int64vec_t.push_back (method) -ida_pro.int64vec_t.qclear (method) -ida_pro.int64vec_t.reserve (method) -ida_pro.int64vec_t.resize (method) -ida_pro.int64vec_t.size (method) -ida_pro.int64vec_t.swap (method) -ida_pro.int64vec_t.truncate (method) -ida_pro.int_pointer (class) -ida_pro.int_pointer.__init__ (method) -ida_pro.int_pointer.assign (method) -ida_pro.int_pointer.cast (method) -ida_pro.int_pointer.frompointer (method) -ida_pro.int_pointer.value (method) -ida_pro.int_pointer_frompointer (function) -ida_pro.intvec_t (class) -ida_pro.intvec_t.__eq__ (method) -ida_pro.intvec_t.__getitem__ (method) -ida_pro.intvec_t.__init__ (method) -ida_pro.intvec_t.__len__ (method) -ida_pro.intvec_t.__ne__ (method) -ida_pro.intvec_t.__setitem__ (method) -ida_pro.intvec_t._del (method) -ida_pro.intvec_t.add_unique (method) -ida_pro.intvec_t.at (method) -ida_pro.intvec_t.begin (method) -ida_pro.intvec_t.capacity (method) -ida_pro.intvec_t.clear (method) -ida_pro.intvec_t.empty (method) -ida_pro.intvec_t.end (method) -ida_pro.intvec_t.erase (method) -ida_pro.intvec_t.extract (method) -ida_pro.intvec_t.find (method) -ida_pro.intvec_t.has (method) -ida_pro.intvec_t.inject (method) -ida_pro.intvec_t.insert (method) -ida_pro.intvec_t.pop_back (method) -ida_pro.intvec_t.push_back (method) -ida_pro.intvec_t.qclear (method) -ida_pro.intvec_t.reserve (method) -ida_pro.intvec_t.resize (method) -ida_pro.intvec_t.size (method) -ida_pro.intvec_t.swap (method) -ida_pro.intvec_t.truncate (method) -ida_pro.is_control_tty (function) -ida_pro.is_cvt64 (function) -ida_pro.is_main_thread (function) -ida_pro.log2ceil (function) -ida_pro.log2floor (function) -ida_pro.parse_dbgopts (function) -ida_pro.qatoll (function) -ida_pro.qcontrol_tty (function) -ida_pro.qdetach_tty (function) -ida_pro.qexit (function) -ida_pro.qmutex_locker_t (class) -ida_pro.qmutex_locker_t.__init__ (method) -ida_pro.qrefcnt_obj_t (class) -ida_pro.qrefcnt_obj_t.__init__ (method) -ida_pro.qrefcnt_obj_t.refcnt (variable) -ida_pro.qrefcnt_obj_t.release (method) -ida_pro.qstrvec_t_add (function) -ida_pro.qstrvec_t_addressof (function) -ida_pro.qstrvec_t_assign (function) -ida_pro.qstrvec_t_clear (function) -ida_pro.qstrvec_t_create (function) -ida_pro.qstrvec_t_destroy (function) -ida_pro.qstrvec_t_from_list (function) -ida_pro.qstrvec_t_get (function) -ida_pro.qstrvec_t_get_clink (function) -ida_pro.qstrvec_t_get_clink_ptr (function) -ida_pro.qstrvec_t_insert (function) -ida_pro.qstrvec_t_remove (function) -ida_pro.qstrvec_t_set (function) -ida_pro.qstrvec_t_size (function) -ida_pro.qthread_equal (function) -ida_pro.quote_cmdline_arg (function) -ida_pro.qvector_reserve (function) -ida_pro.readbytes (function) -ida_pro.reloc_value (function) -ida_pro.relocate_relobj (function) -ida_pro.sel_array (class) -ida_pro.sel_array.__getitem__ (method) -ida_pro.sel_array.__init__ (method) -ida_pro.sel_array.__setitem__ (method) -ida_pro.sel_array.cast (method) -ida_pro.sel_array.frompointer (method) -ida_pro.sel_array_frompointer (function) -ida_pro.sel_pointer (class) -ida_pro.sel_pointer.__init__ (method) -ida_pro.sel_pointer.assign (method) -ida_pro.sel_pointer.cast (method) -ida_pro.sel_pointer.frompointer (method) -ida_pro.sel_pointer.value (method) -ida_pro.sel_pointer_frompointer (function) -ida_pro.sizevec_t (class) -ida_pro.sizevec_t.__eq__ (method) -ida_pro.sizevec_t.__getitem__ (method) -ida_pro.sizevec_t.__init__ (method) -ida_pro.sizevec_t.__len__ (method) -ida_pro.sizevec_t.__ne__ (method) -ida_pro.sizevec_t.__setitem__ (method) -ida_pro.sizevec_t._del (method) -ida_pro.sizevec_t.add_unique (method) -ida_pro.sizevec_t.at (method) -ida_pro.sizevec_t.begin (method) -ida_pro.sizevec_t.capacity (method) -ida_pro.sizevec_t.clear (method) -ida_pro.sizevec_t.empty (method) -ida_pro.sizevec_t.end (method) -ida_pro.sizevec_t.erase (method) -ida_pro.sizevec_t.extract (method) -ida_pro.sizevec_t.find (method) -ida_pro.sizevec_t.grow (method) -ida_pro.sizevec_t.has (method) -ida_pro.sizevec_t.inject (method) -ida_pro.sizevec_t.insert (method) -ida_pro.sizevec_t.pop_back (method) -ida_pro.sizevec_t.push_back (method) -ida_pro.sizevec_t.qclear (method) -ida_pro.sizevec_t.reserve (method) -ida_pro.sizevec_t.resize (method) -ida_pro.sizevec_t.size (method) -ida_pro.sizevec_t.swap (method) -ida_pro.sizevec_t.truncate (method) -ida_pro.str2user (function) -ida_pro.strvec_t (class) -ida_pro.strvec_t.__getitem__ (method) -ida_pro.strvec_t.__init__ (method) -ida_pro.strvec_t.__len__ (method) -ida_pro.strvec_t.__setitem__ (method) -ida_pro.strvec_t.at (method) -ida_pro.strvec_t.begin (method) -ida_pro.strvec_t.capacity (method) -ida_pro.strvec_t.clear (method) -ida_pro.strvec_t.empty (method) -ida_pro.strvec_t.end (method) -ida_pro.strvec_t.erase (method) -ida_pro.strvec_t.extract (method) -ida_pro.strvec_t.grow (method) -ida_pro.strvec_t.inject (method) -ida_pro.strvec_t.insert (method) -ida_pro.strvec_t.pop_back (method) -ida_pro.strvec_t.push_back (method) -ida_pro.strvec_t.qclear (method) -ida_pro.strvec_t.reserve (method) -ida_pro.strvec_t.resize (method) -ida_pro.strvec_t.size (method) -ida_pro.strvec_t.swap (method) -ida_pro.strvec_t.truncate (method) -ida_pro.sval_pointer (class) -ida_pro.sval_pointer.__init__ (method) -ida_pro.sval_pointer.assign (method) -ida_pro.sval_pointer.cast (method) -ida_pro.sval_pointer.frompointer (method) -ida_pro.sval_pointer.value (method) -ida_pro.sval_pointer_frompointer (function) -ida_pro.tid_array (class) -ida_pro.tid_array.__getitem__ (method) -ida_pro.tid_array.__init__ (method) -ida_pro.tid_array.__setitem__ (method) -ida_pro.tid_array.cast (method) -ida_pro.tid_array.frompointer (method) -ida_pro.tid_array_frompointer (function) -ida_pro.uchar_array (class) -ida_pro.uchar_array.__getitem__ (method) -ida_pro.uchar_array.__init__ (method) -ida_pro.uchar_array.__setitem__ (method) -ida_pro.uchar_array.cast (method) -ida_pro.uchar_array.frompointer (method) -ida_pro.uchar_array_frompointer (function) -ida_pro.uint64vec_t (class) -ida_pro.uint64vec_t.__eq__ (method) -ida_pro.uint64vec_t.__getitem__ (method) -ida_pro.uint64vec_t.__init__ (method) -ida_pro.uint64vec_t.__len__ (method) -ida_pro.uint64vec_t.__ne__ (method) -ida_pro.uint64vec_t.__setitem__ (method) -ida_pro.uint64vec_t._del (method) -ida_pro.uint64vec_t.add_unique (method) -ida_pro.uint64vec_t.at (method) -ida_pro.uint64vec_t.begin (method) -ida_pro.uint64vec_t.capacity (method) -ida_pro.uint64vec_t.clear (method) -ida_pro.uint64vec_t.empty (method) -ida_pro.uint64vec_t.end (method) -ida_pro.uint64vec_t.erase (method) -ida_pro.uint64vec_t.extract (method) -ida_pro.uint64vec_t.find (method) -ida_pro.uint64vec_t.has (method) -ida_pro.uint64vec_t.inject (method) -ida_pro.uint64vec_t.insert (method) -ida_pro.uint64vec_t.pop_back (method) -ida_pro.uint64vec_t.push_back (method) -ida_pro.uint64vec_t.qclear (method) -ida_pro.uint64vec_t.reserve (method) -ida_pro.uint64vec_t.resize (method) -ida_pro.uint64vec_t.size (method) -ida_pro.uint64vec_t.swap (method) -ida_pro.uint64vec_t.truncate (method) -ida_pro.uintvec_t (class) -ida_pro.uintvec_t.__eq__ (method) -ida_pro.uintvec_t.__getitem__ (method) -ida_pro.uintvec_t.__init__ (method) -ida_pro.uintvec_t.__len__ (method) -ida_pro.uintvec_t.__ne__ (method) -ida_pro.uintvec_t.__setitem__ (method) -ida_pro.uintvec_t._del (method) -ida_pro.uintvec_t.add_unique (method) -ida_pro.uintvec_t.at (method) -ida_pro.uintvec_t.begin (method) -ida_pro.uintvec_t.capacity (method) -ida_pro.uintvec_t.clear (method) -ida_pro.uintvec_t.empty (method) -ida_pro.uintvec_t.end (method) -ida_pro.uintvec_t.erase (method) -ida_pro.uintvec_t.extract (method) -ida_pro.uintvec_t.find (method) -ida_pro.uintvec_t.has (method) -ida_pro.uintvec_t.inject (method) -ida_pro.uintvec_t.insert (method) -ida_pro.uintvec_t.pop_back (method) -ida_pro.uintvec_t.push_back (method) -ida_pro.uintvec_t.qclear (method) -ida_pro.uintvec_t.reserve (method) -ida_pro.uintvec_t.resize (method) -ida_pro.uintvec_t.size (method) -ida_pro.uintvec_t.swap (method) -ida_pro.uintvec_t.truncate (method) -ida_pro.uval_array (class) -ida_pro.uval_array.__getitem__ (method) -ida_pro.uval_array.__init__ (method) -ida_pro.uval_array.__setitem__ (method) -ida_pro.uval_array.cast (method) -ida_pro.uval_array.frompointer (method) -ida_pro.uval_array_frompointer (function) -ida_pro.writebytes (function) -ida_problems (module) -ida_problems.PR_ATTN (variable) -ida_problems.PR_BADSTACK (variable) -ida_problems.PR_COLLISION (variable) -ida_problems.PR_DECIMP (variable) -ida_problems.PR_DISASM (variable) -ida_problems.PR_END (variable) -ida_problems.PR_FINAL (variable) -ida_problems.PR_HEAD (variable) -ida_problems.PR_ILLADDR (variable) -ida_problems.PR_JUMP (variable) -ida_problems.PR_MANYLINES (variable) -ida_problems.PR_NOBASE (variable) -ida_problems.PR_NOCMT (variable) -ida_problems.PR_NOFOP (variable) -ida_problems.PR_NONAME (variable) -ida_problems.PR_NOXREFS (variable) -ida_problems.PR_ROLLED (variable) -ida_problems.forget_problem (function) -ida_problems.get_problem (function) -ida_problems.get_problem_desc (function) -ida_problems.get_problem_name (function) -ida_problems.is_problem_present (function) -ida_problems.remember_problem (function) -ida_problems.was_ida_decision (function) -ida_range (module) -ida_range.RANGE_KIND_FUNC (variable) -ida_range.RANGE_KIND_HIDDEN_RANGE (variable) -ida_range.RANGE_KIND_SEGMENT (variable) -ida_range.array_of_rangesets (class) -ida_range.array_of_rangesets.__eq__ (method) -ida_range.array_of_rangesets.__getitem__ (method) -ida_range.array_of_rangesets.__init__ (method) -ida_range.array_of_rangesets.__len__ (method) -ida_range.array_of_rangesets.__ne__ (method) -ida_range.array_of_rangesets.__setitem__ (method) -ida_range.array_of_rangesets._del (method) -ida_range.array_of_rangesets.add_unique (method) -ida_range.array_of_rangesets.at (method) -ida_range.array_of_rangesets.begin (method) -ida_range.array_of_rangesets.capacity (method) -ida_range.array_of_rangesets.clear (method) -ida_range.array_of_rangesets.empty (method) -ida_range.array_of_rangesets.end (method) -ida_range.array_of_rangesets.erase (method) -ida_range.array_of_rangesets.extract (method) -ida_range.array_of_rangesets.find (method) -ida_range.array_of_rangesets.grow (method) -ida_range.array_of_rangesets.has (method) -ida_range.array_of_rangesets.inject (method) -ida_range.array_of_rangesets.insert (method) -ida_range.array_of_rangesets.pop_back (method) -ida_range.array_of_rangesets.push_back (method) -ida_range.array_of_rangesets.qclear (method) -ida_range.array_of_rangesets.reserve (method) -ida_range.array_of_rangesets.resize (method) -ida_range.array_of_rangesets.size (method) -ida_range.array_of_rangesets.swap (method) -ida_range.array_of_rangesets.truncate (method) -ida_range.range_t (class) -ida_range.range_t.__eq__ (method) -ida_range.range_t.__gt__ (method) -ida_range.range_t.__init__ (method) -ida_range.range_t.__lt__ (method) -ida_range.range_t.__ne__ (method) -ida_range.range_t._print (method) -ida_range.range_t.clear (method) -ida_range.range_t.compare (method) -ida_range.range_t.contains (method) -ida_range.range_t.empty (method) -ida_range.range_t.end_ea (variable) -ida_range.range_t.extend (method) -ida_range.range_t.intersect (method) -ida_range.range_t.overlaps (method) -ida_range.range_t.size (method) -ida_range.range_t.start_ea (variable) -ida_range.range_t_print (function) -ida_range.rangeset_t (class) -ida_range.rangeset_t.__eq__ (method) -ida_range.rangeset_t.__getitem__ (method) -ida_range.rangeset_t.__init__ (method) -ida_range.rangeset_t.__ne__ (method) -ida_range.rangeset_t._print (method) -ida_range.rangeset_t.add (method) -ida_range.rangeset_t.begin (method) -ida_range.rangeset_t.cached_range (method) -ida_range.rangeset_t.clear (method) -ida_range.rangeset_t.contains (method) -ida_range.rangeset_t.empty (method) -ida_range.rangeset_t.end (method) -ida_range.rangeset_t.find_range (method) -ida_range.rangeset_t.getrange (method) -ida_range.rangeset_t.has_common (method) -ida_range.rangeset_t.includes (method) -ida_range.rangeset_t.intersect (method) -ida_range.rangeset_t.is_equal (method) -ida_range.rangeset_t.is_subset_of (method) -ida_range.rangeset_t.lastrange (method) -ida_range.rangeset_t.next_addr (method) -ida_range.rangeset_t.next_range (method) -ida_range.rangeset_t.nranges (method) -ida_range.rangeset_t.prev_addr (method) -ida_range.rangeset_t.prev_range (method) -ida_range.rangeset_t.sub (method) -ida_range.rangeset_t.swap (method) -ida_range.rangevec_base_t (class) -ida_range.rangevec_base_t.__eq__ (method) -ida_range.rangevec_base_t.__getitem__ (method) -ida_range.rangevec_base_t.__init__ (method) -ida_range.rangevec_base_t.__len__ (method) -ida_range.rangevec_base_t.__ne__ (method) -ida_range.rangevec_base_t.__setitem__ (method) -ida_range.rangevec_base_t._del (method) -ida_range.rangevec_base_t.add_unique (method) -ida_range.rangevec_base_t.at (method) -ida_range.rangevec_base_t.begin (method) -ida_range.rangevec_base_t.capacity (method) -ida_range.rangevec_base_t.clear (method) -ida_range.rangevec_base_t.empty (method) -ida_range.rangevec_base_t.end (method) -ida_range.rangevec_base_t.erase (method) -ida_range.rangevec_base_t.extract (method) -ida_range.rangevec_base_t.find (method) -ida_range.rangevec_base_t.grow (method) -ida_range.rangevec_base_t.has (method) -ida_range.rangevec_base_t.inject (method) -ida_range.rangevec_base_t.insert (method) -ida_range.rangevec_base_t.pop_back (method) -ida_range.rangevec_base_t.push_back (method) -ida_range.rangevec_base_t.qclear (method) -ida_range.rangevec_base_t.reserve (method) -ida_range.rangevec_base_t.resize (method) -ida_range.rangevec_base_t.size (method) -ida_range.rangevec_base_t.swap (method) -ida_range.rangevec_base_t.truncate (method) -ida_range.rangevec_t (class) -ida_range.rangevec_t.__init__ (method) -ida_registry (module) -ida_registry.ROOT_KEY_NAME (variable) -ida_registry.reg_binary (variable) -ida_registry.reg_data_type (function) -ida_registry.reg_delete (function) -ida_registry.reg_delete_subkey (function) -ida_registry.reg_delete_tree (function) -ida_registry.reg_dword (variable) -ida_registry.reg_exists (function) -ida_registry.reg_flush (function) -ida_registry.reg_load (function) -ida_registry.reg_read_binary (function) -ida_registry.reg_read_bool (function) -ida_registry.reg_read_int (function) -ida_registry.reg_read_string (function) -ida_registry.reg_read_strlist (function) -ida_registry.reg_subkey_exists (function) -ida_registry.reg_subkey_subkeys (function) -ida_registry.reg_subkey_values (function) -ida_registry.reg_sz (variable) -ida_registry.reg_unknown (variable) -ida_registry.reg_update_filestrlist (function) -ida_registry.reg_update_strlist (function) -ida_registry.reg_write_binary (function) -ida_registry.reg_write_bool (function) -ida_registry.reg_write_int (function) -ida_registry.reg_write_string (function) -ida_registry.set_registry_root (function) -ida_regfinder (module) -ida_regfinder.find_nearest_rvi (function) -ida_regfinder.find_reg_value (function) -ida_regfinder.find_reg_value_info (function) -ida_regfinder.find_sp_value (function) -ida_regfinder.invalidate_regfinder_cache (function) -ida_regfinder.reg_value_def_t (class) -ida_regfinder.reg_value_def_t.LIKE_GOT (variable) -ida_regfinder.reg_value_def_t.NOVAL (variable) -ida_regfinder.reg_value_def_t.PC_BASED (variable) -ida_regfinder.reg_value_def_t.SHORT_INSN (variable) -ida_regfinder.reg_value_def_t.SPVAL (variable) -ida_regfinder.reg_value_def_t.UVAL (variable) -ida_regfinder.reg_value_def_t.__eq__ (method) -ida_regfinder.reg_value_def_t.__init__ (method) -ida_regfinder.reg_value_def_t.__lt__ (method) -ida_regfinder.reg_value_def_t.def_ea (variable) -ida_regfinder.reg_value_def_t.def_itype (variable) -ida_regfinder.reg_value_def_t.dstr (method) -ida_regfinder.reg_value_def_t.flags (variable) -ida_regfinder.reg_value_def_t.is_like_got (method) -ida_regfinder.reg_value_def_t.is_pc_based (method) -ida_regfinder.reg_value_def_t.is_short_insn (method) -ida_regfinder.reg_value_def_t.val (variable) -ida_regfinder.reg_value_info_t (class) -ida_regfinder.reg_value_info_t.CONTAINED (variable) -ida_regfinder.reg_value_info_t.CONTAINS (variable) -ida_regfinder.reg_value_info_t.EQUAL (variable) -ida_regfinder.reg_value_info_t.NOT_COMPARABLE (variable) -ida_regfinder.reg_value_info_t.__getitem__ (method) -ida_regfinder.reg_value_info_t.__init__ (method) -ida_regfinder.reg_value_info_t.__len__ (method) -ida_regfinder.reg_value_info_t.__str__ (method) -ida_regfinder.reg_value_info_t.aborted (method) -ida_regfinder.reg_value_info_t.add (method) -ida_regfinder.reg_value_info_t.add_num (method) -ida_regfinder.reg_value_info_t.band (method) -ida_regfinder.reg_value_info_t.bandnot (method) -ida_regfinder.reg_value_info_t.bnot (method) -ida_regfinder.reg_value_info_t.bor (method) -ida_regfinder.reg_value_info_t.bxor (method) -ida_regfinder.reg_value_info_t.clear (method) -ida_regfinder.reg_value_info_t.empty (method) -ida_regfinder.reg_value_info_t.extend (method) -ida_regfinder.reg_value_info_t.get_def_ea (method) -ida_regfinder.reg_value_info_t.get_def_itype (method) -ida_regfinder.reg_value_info_t.get_num (method) -ida_regfinder.reg_value_info_t.get_spd (method) -ida_regfinder.reg_value_info_t.have_all_vals_flag (method) -ida_regfinder.reg_value_info_t.is_all_vals_like_got (method) -ida_regfinder.reg_value_info_t.is_all_vals_pc_based (method) -ida_regfinder.reg_value_info_t.is_badinsn (method) -ida_regfinder.reg_value_info_t.is_dead_end (method) -ida_regfinder.reg_value_info_t.is_known (method) -ida_regfinder.reg_value_info_t.is_num (method) -ida_regfinder.reg_value_info_t.is_spd (method) -ida_regfinder.reg_value_info_t.is_special (method) -ida_regfinder.reg_value_info_t.is_unkfunc (method) -ida_regfinder.reg_value_info_t.is_unkinsn (method) -ida_regfinder.reg_value_info_t.is_unkloop (method) -ida_regfinder.reg_value_info_t.is_unkmult (method) -ida_regfinder.reg_value_info_t.is_unknown (method) -ida_regfinder.reg_value_info_t.is_value_unique (method) -ida_regfinder.reg_value_info_t.make_aborted (method) -ida_regfinder.reg_value_info_t.make_badinsn (method) -ida_regfinder.reg_value_info_t.make_dead_end (method) -ida_regfinder.reg_value_info_t.make_initial_sp (method) -ida_regfinder.reg_value_info_t.make_num (method) -ida_regfinder.reg_value_info_t.make_unkfunc (method) -ida_regfinder.reg_value_info_t.make_unkinsn (method) -ida_regfinder.reg_value_info_t.make_unkloop (method) -ida_regfinder.reg_value_info_t.make_unkmult (method) -ida_regfinder.reg_value_info_t.neg (method) -ida_regfinder.reg_value_info_t.set_aborted (method) -ida_regfinder.reg_value_info_t.set_badinsn (method) -ida_regfinder.reg_value_info_t.set_dead_end (method) -ida_regfinder.reg_value_info_t.set_num (method) -ida_regfinder.reg_value_info_t.set_unkfunc (method) -ida_regfinder.reg_value_info_t.set_unkinsn (method) -ida_regfinder.reg_value_info_t.set_unkloop (method) -ida_regfinder.reg_value_info_t.set_unkmult (method) -ida_regfinder.reg_value_info_t.shift_left (method) -ida_regfinder.reg_value_info_t.shift_right (method) -ida_regfinder.reg_value_info_t.sll (method) -ida_regfinder.reg_value_info_t.slr (method) -ida_regfinder.reg_value_info_t.sub (method) -ida_regfinder.reg_value_info_t.vals_union (method) -ida_regfinder.reg_value_info_t_make_aborted (function) -ida_regfinder.reg_value_info_t_make_badinsn (function) -ida_regfinder.reg_value_info_t_make_dead_end (function) -ida_regfinder.reg_value_info_t_make_initial_sp (function) -ida_regfinder.reg_value_info_t_make_num (function) -ida_regfinder.reg_value_info_t_make_unkfunc (function) -ida_regfinder.reg_value_info_t_make_unkinsn (function) -ida_regfinder.reg_value_info_t_make_unkloop (function) -ida_regfinder.reg_value_info_t_make_unkmult (function) -ida_search (module) -ida_search.SEARCH_BRK (variable) -ida_search.SEARCH_CASE (variable) -ida_search.SEARCH_DOWN (variable) -ida_search.SEARCH_IDENT (variable) -ida_search.SEARCH_NEXT (variable) -ida_search.SEARCH_NOBRK (variable) -ida_search.SEARCH_NOSHOW (variable) -ida_search.SEARCH_REGEX (variable) -ida_search.SEARCH_UP (variable) -ida_search.SEARCH_USESEL (variable) -ida_search.find_binary (function) -ida_search.find_code (function) -ida_search.find_data (function) -ida_search.find_defined (function) -ida_search.find_error (function) -ida_search.find_imm (function) -ida_search.find_not_func (function) -ida_search.find_notype (function) -ida_search.find_reg_access (function) -ida_search.find_suspop (function) -ida_search.find_text (function) -ida_search.find_unknown (function) -ida_search.search_down (function) -ida_segment (module) -ida_segment.ADDSEG_FILLGAP (variable) -ida_segment.ADDSEG_IDBENC (variable) -ida_segment.ADDSEG_NOAA (variable) -ida_segment.ADDSEG_NOSREG (variable) -ida_segment.ADDSEG_NOTRUNC (variable) -ida_segment.ADDSEG_OR_DIE (variable) -ida_segment.ADDSEG_QUIET (variable) -ida_segment.ADDSEG_SPARSE (variable) -ida_segment.CSS_BREAK (variable) -ida_segment.CSS_NODBG (variable) -ida_segment.CSS_NOMEM (variable) -ida_segment.CSS_NORANGE (variable) -ida_segment.CSS_OK (variable) -ida_segment.MAX_GROUPS (variable) -ida_segment.MAX_SEGM_TRANSLATIONS (variable) -ida_segment.MOVE_SEGM_CHUNK (variable) -ida_segment.MOVE_SEGM_DEBUG (variable) -ida_segment.MOVE_SEGM_IDP (variable) -ida_segment.MOVE_SEGM_INVAL (variable) -ida_segment.MOVE_SEGM_LOADER (variable) -ida_segment.MOVE_SEGM_MAPPING (variable) -ida_segment.MOVE_SEGM_ODD (variable) -ida_segment.MOVE_SEGM_OK (variable) -ida_segment.MOVE_SEGM_ORPHAN (variable) -ida_segment.MOVE_SEGM_PARAM (variable) -ida_segment.MOVE_SEGM_ROOM (variable) -ida_segment.MOVE_SEGM_SOURCEFILES (variable) -ida_segment.MSF_FIXONCE (variable) -ida_segment.MSF_LDKEEP (variable) -ida_segment.MSF_NETNODES (variable) -ida_segment.MSF_NOFIX (variable) -ida_segment.MSF_PRIORITY (variable) -ida_segment.MSF_SILENT (variable) -ida_segment.SEGMOD_KEEP (variable) -ida_segment.SEGMOD_KEEP0 (variable) -ida_segment.SEGMOD_KEEPSEL (variable) -ida_segment.SEGMOD_KILL (variable) -ida_segment.SEGMOD_NOMOVE (variable) -ida_segment.SEGMOD_SILENT (variable) -ida_segment.SEGMOD_SPARSE (variable) -ida_segment.SEGPERM_EXEC (variable) -ida_segment.SEGPERM_READ (variable) -ida_segment.SEGPERM_WRITE (variable) -ida_segment.SEG_ABSSYM (variable) -ida_segment.SEG_BSS (variable) -ida_segment.SEG_CODE (variable) -ida_segment.SEG_COMM (variable) -ida_segment.SEG_DATA (variable) -ida_segment.SEG_GRP (variable) -ida_segment.SEG_IMEM (variable) -ida_segment.SEG_NORM (variable) -ida_segment.SEG_NULL (variable) -ida_segment.SEG_UNDF (variable) -ida_segment.SEG_XTRN (variable) -ida_segment.SFL_COMORG (variable) -ida_segment.SFL_DEBUG (variable) -ida_segment.SFL_HEADER (variable) -ida_segment.SFL_HIDDEN (variable) -ida_segment.SFL_HIDETYPE (variable) -ida_segment.SFL_LOADER (variable) -ida_segment.SFL_OBOK (variable) -ida_segment.SNAP_ALL_SEG (variable) -ida_segment.SNAP_CUR_SEG (variable) -ida_segment.SNAP_LOAD_SEG (variable) -ida_segment.SREG_NUM (variable) -ida_segment.add_segm (function) -ida_segment.add_segm_ex (function) -ida_segment.add_segment_translation (function) -ida_segment.allocate_selector (function) -ida_segment.change_segment_status (function) -ida_segment.del_segm (function) -ida_segment.del_segment_translations (function) -ida_segment.del_selector (function) -ida_segment.find_free_selector (function) -ida_segment.find_selector (function) -ida_segment.get_defsr (function) -ida_segment.get_first_seg (function) -ida_segment.get_group_selector (function) -ida_segment.get_last_seg (function) -ida_segment.get_next_seg (function) -ida_segment.get_prev_seg (function) -ida_segment.get_segm_base (function) -ida_segment.get_segm_by_name (function) -ida_segment.get_segm_by_sel (function) -ida_segment.get_segm_class (function) -ida_segment.get_segm_name (function) -ida_segment.get_segm_num (function) -ida_segment.get_segm_para (function) -ida_segment.get_segm_qty (function) -ida_segment.get_segment_alignment (function) -ida_segment.get_segment_cmt (function) -ida_segment.get_segment_combination (function) -ida_segment.get_segment_translations (function) -ida_segment.get_selector_qty (function) -ida_segment.get_visible_segm_name (function) -ida_segment.getn_selector (function) -ida_segment.getnseg (function) -ida_segment.getseg (function) -ida_segment.is_finally_visible_segm (function) -ida_segment.is_miniidb (function) -ida_segment.is_segm_locked (function) -ida_segment.is_spec_ea (function) -ida_segment.is_spec_segm (function) -ida_segment.is_visible_segm (function) -ida_segment.lock_segm (function) -ida_segment.lock_segment (class) -ida_segment.lock_segment.__init__ (method) -ida_segment.move_segm (function) -ida_segment.move_segm_start (function) -ida_segment.move_segm_strerror (function) -ida_segment.rebase_program (function) -ida_segment.saAbs (variable) -ida_segment.saGroup (variable) -ida_segment.saRel1024Bytes (variable) -ida_segment.saRel128Bytes (variable) -ida_segment.saRel2048Bytes (variable) -ida_segment.saRel32Bytes (variable) -ida_segment.saRel4K (variable) -ida_segment.saRel512Bytes (variable) -ida_segment.saRel64Bytes (variable) -ida_segment.saRelByte (variable) -ida_segment.saRelDble (variable) -ida_segment.saRelPage (variable) -ida_segment.saRelPara (variable) -ida_segment.saRelQword (variable) -ida_segment.saRelWord (variable) -ida_segment.scCommon (variable) -ida_segment.scGroup (variable) -ida_segment.scPriv (variable) -ida_segment.scPub (variable) -ida_segment.scPub2 (variable) -ida_segment.scPub3 (variable) -ida_segment.scStack (variable) -ida_segment.segm_adjust_diff (function) -ida_segment.segm_adjust_ea (function) -ida_segment.segment_defsr_array (class) -ida_segment.segment_defsr_array.__getitem__ (method) -ida_segment.segment_defsr_array.__init__ (method) -ida_segment.segment_defsr_array.__len__ (method) -ida_segment.segment_defsr_array.__setitem__ (method) -ida_segment.segment_defsr_array._get_bytes (method) -ida_segment.segment_defsr_array._set_bytes (method) -ida_segment.segment_t (class) -ida_segment.segment_t.__getDefsr (method) -ida_segment.segment_t.__init__ (method) -ida_segment.segment_t.abits (method) -ida_segment.segment_t.abytes (method) -ida_segment.segment_t.align (variable) -ida_segment.segment_t.bitness (variable) -ida_segment.segment_t.clr_comorg (method) -ida_segment.segment_t.clr_ob_ok (method) -ida_segment.segment_t.color (variable) -ida_segment.segment_t.comb (variable) -ida_segment.segment_t.comorg (method) -ida_segment.segment_t.defsr (variable) -ida_segment.segment_t.flags (variable) -ida_segment.segment_t.is_16bit (method) -ida_segment.segment_t.is_32bit (method) -ida_segment.segment_t.is_64bit (method) -ida_segment.segment_t.is_header_segm (method) -ida_segment.segment_t.is_hidden_segtype (method) -ida_segment.segment_t.is_loader_segm (method) -ida_segment.segment_t.is_visible_segm (method) -ida_segment.segment_t.name (variable) -ida_segment.segment_t.ob_ok (method) -ida_segment.segment_t.orgbase (variable) -ida_segment.segment_t.perm (variable) -ida_segment.segment_t.sclass (variable) -ida_segment.segment_t.sel (variable) -ida_segment.segment_t.set_comorg (method) -ida_segment.segment_t.set_debugger_segm (method) -ida_segment.segment_t.set_header_segm (method) -ida_segment.segment_t.set_hidden_segtype (method) -ida_segment.segment_t.set_loader_segm (method) -ida_segment.segment_t.set_ob_ok (method) -ida_segment.segment_t.set_visible_segm (method) -ida_segment.segment_t.type (variable) -ida_segment.segment_t.update (method) -ida_segment.segtype (function) -ida_segment.sel2ea (function) -ida_segment.sel2para (function) -ida_segment.set_defsr (function) -ida_segment.set_group_selector (function) -ida_segment.set_segm_addressing (function) -ida_segment.set_segm_base (function) -ida_segment.set_segm_class (function) -ida_segment.set_segm_end (function) -ida_segment.set_segm_name (function) -ida_segment.set_segm_start (function) -ida_segment.set_segment_cmt (function) -ida_segment.set_segment_translations (function) -ida_segment.set_selector (function) -ida_segment.set_visible_segm (function) -ida_segment.setup_selector (function) -ida_segment.std_out_segm_footer (function) -ida_segment.take_memory_snapshot (function) -ida_segment.update_segm (function) -ida_segregs (module) -ida_segregs.SR_auto (variable) -ida_segregs.SR_autostart (variable) -ida_segregs.SR_inherit (variable) -ida_segregs.SR_user (variable) -ida_segregs.copy_sreg_ranges (function) -ida_segregs.del_sreg_range (function) -ida_segregs.get_prev_sreg_range (function) -ida_segregs.get_sreg (function) -ida_segregs.get_sreg_range (function) -ida_segregs.get_sreg_range_num (function) -ida_segregs.get_sreg_ranges_qty (function) -ida_segregs.getn_sreg_range (function) -ida_segregs.set_default_dataseg (function) -ida_segregs.set_default_sreg_value (function) -ida_segregs.set_sreg_at_next_code (function) -ida_segregs.split_sreg_range (function) -ida_segregs.sreg_range_t (class) -ida_segregs.sreg_range_t.__init__ (method) -ida_segregs.sreg_range_t.tag (variable) -ida_segregs.sreg_range_t.val (variable) -ida_srclang (module) -ida_srclang.SRCLANG_C (variable) -ida_srclang.SRCLANG_CPP (variable) -ida_srclang.SRCLANG_GO (variable) -ida_srclang.SRCLANG_OBJC (variable) -ida_srclang.SRCLANG_SWIFT (variable) -ida_srclang.parse_decls_for_srclang (function) -ida_srclang.parse_decls_with_parser (function) -ida_srclang.select_parser_by_name (function) -ida_srclang.select_parser_by_srclang (function) -ida_srclang.set_parser_argv (function) -ida_strlist (module) -ida_strlist.build_strlist (function) -ida_strlist.clear_strlist (function) -ida_strlist.get_strlist_item (function) -ida_strlist.get_strlist_options (function) -ida_strlist.get_strlist_qty (function) -ida_strlist.string_info_t (class) -ida_strlist.string_info_t.__init__ (method) -ida_strlist.string_info_t.__lt__ (method) -ida_strlist.strwinsetup_t (class) -ida_strlist.strwinsetup_t.__init__ (method) -ida_strlist.strwinsetup_t._get_strtypes (method) -ida_strlist.strwinsetup_t._set_strtypes (method) -ida_struct (module) -ida_struct.MF_BASECLASS (variable) -ida_struct.MF_BYTIL (variable) -ida_struct.MF_DTOR (variable) -ida_struct.MF_DUPNAME (variable) -ida_struct.MF_HASTI (variable) -ida_struct.MF_HASUNI (variable) -ida_struct.MF_OK (variable) -ida_struct.MF_UNIMEM (variable) -ida_struct.SET_MEMTI_BYTIL (variable) -ida_struct.SET_MEMTI_COMPATIBLE (variable) -ida_struct.SET_MEMTI_FUNCARG (variable) -ida_struct.SET_MEMTI_MAY_DESTROY (variable) -ida_struct.SET_MEMTI_USERTI (variable) -ida_struct.SF_ALIGN (variable) -ida_struct.SF_FRAME (variable) -ida_struct.SF_GHOST (variable) -ida_struct.SF_HASUNI (variable) -ida_struct.SF_HIDDEN (variable) -ida_struct.SF_NOLIST (variable) -ida_struct.SF_TYPLIB (variable) -ida_struct.SF_UNION (variable) -ida_struct.SF_VAR (variable) -ida_struct.SMT_ARRAY (variable) -ida_struct.SMT_BADARG (variable) -ida_struct.SMT_FAILED (variable) -ida_struct.SMT_KEEP (variable) -ida_struct.SMT_NOCOMPAT (variable) -ida_struct.SMT_OVERLAP (variable) -ida_struct.SMT_SIZE (variable) -ida_struct.SMT_WORSE (variable) -ida_struct.STRNFL_REGEX (variable) -ida_struct.STRUC_ERROR_MEMBER_LTUDT (variable) -ida_struct.STRUC_ERROR_MEMBER_NAME (variable) -ida_struct.STRUC_ERROR_MEMBER_NESTED (variable) -ida_struct.STRUC_ERROR_MEMBER_OFFSET (variable) -ida_struct.STRUC_ERROR_MEMBER_OK (variable) -ida_struct.STRUC_ERROR_MEMBER_SIZE (variable) -ida_struct.STRUC_ERROR_MEMBER_STRUCT (variable) -ida_struct.STRUC_ERROR_MEMBER_TINFO (variable) -ida_struct.STRUC_ERROR_MEMBER_UNIVAR (variable) -ida_struct.STRUC_ERROR_MEMBER_VARLAST (variable) -ida_struct.STRUC_SEPARATOR (variable) -ida_struct.add_struc (function) -ida_struct.add_struc_member (function) -ida_struct.del_member_tinfo (function) -ida_struct.del_struc (function) -ida_struct.del_struc_member (function) -ida_struct.del_struc_members (function) -ida_struct.dyn_member_ref_array (class) -ida_struct.dyn_member_ref_array.__getitem__ (method) -ida_struct.dyn_member_ref_array.__init__ (method) -ida_struct.dyn_member_ref_array.__len__ (method) -ida_struct.dyn_member_ref_array.__setitem__ (method) -ida_struct.expand_struc (function) -ida_struct.get_best_fit_member (function) -ida_struct.get_first_struc_idx (function) -ida_struct.get_innermost_member (function) -ida_struct.get_last_struc_idx (function) -ida_struct.get_max_offset (function) -ida_struct.get_member (function) -ida_struct.get_member_by_fullname (function) -ida_struct.get_member_by_id (function) -ida_struct.get_member_by_name (function) -ida_struct.get_member_cmt (function) -ida_struct.get_member_fullname (function) -ida_struct.get_member_id (function) -ida_struct.get_member_name (function) -ida_struct.get_member_size (function) -ida_struct.get_member_struc (function) -ida_struct.get_member_tinfo (function) -ida_struct.get_next_member_idx (function) -ida_struct.get_next_struc_idx (function) -ida_struct.get_or_guess_member_tinfo (function) -ida_struct.get_prev_member_idx (function) -ida_struct.get_prev_struc_idx (function) -ida_struct.get_sptr (function) -ida_struct.get_struc (function) -ida_struct.get_struc_by_idx (function) -ida_struct.get_struc_cmt (function) -ida_struct.get_struc_first_offset (function) -ida_struct.get_struc_id (function) -ida_struct.get_struc_idx (function) -ida_struct.get_struc_last_offset (function) -ida_struct.get_struc_name (function) -ida_struct.get_struc_next_offset (function) -ida_struct.get_struc_prev_offset (function) -ida_struct.get_struc_qty (function) -ida_struct.get_struc_size (function) -ida_struct.is_anonymous_member_name (function) -ida_struct.is_dummy_member_name (function) -ida_struct.is_member_id (function) -ida_struct.is_special_member (function) -ida_struct.is_union (function) -ida_struct.is_varmember (function) -ida_struct.is_varstr (function) -ida_struct.member_t (class) -ida_struct.member_t.__init__ (method) -ida_struct.member_t.by_til (method) -ida_struct.member_t.eoff (variable) -ida_struct.member_t.flag (variable) -ida_struct.member_t.get_size (method) -ida_struct.member_t.get_soff (method) -ida_struct.member_t.has_ti (method) -ida_struct.member_t.has_union (method) -ida_struct.member_t.id (variable) -ida_struct.member_t.is_baseclass (method) -ida_struct.member_t.is_destructor (method) -ida_struct.member_t.is_dupname (method) -ida_struct.member_t.props (variable) -ida_struct.member_t.soff (variable) -ida_struct.member_t.unimem (method) -ida_struct.retrieve_member_info (function) -ida_struct.save_struc (function) -ida_struct.set_member_cmt (function) -ida_struct.set_member_name (function) -ida_struct.set_member_tinfo (function) -ida_struct.set_member_type (function) -ida_struct.set_struc_align (function) -ida_struct.set_struc_cmt (function) -ida_struct.set_struc_hidden (function) -ida_struct.set_struc_idx (function) -ida_struct.set_struc_listed (function) -ida_struct.set_struc_name (function) -ida_struct.stroff_as_size (function) -ida_struct.struc_t (class) -ida_struct.struc_t.__get_members__ (method) -ida_struct.struc_t.__init__ (method) -ida_struct.struc_t.age (variable) -ida_struct.struc_t.from_til (method) -ida_struct.struc_t.get_alignment (method) -ida_struct.struc_t.get_last_member (method) -ida_struct.struc_t.get_member (method) -ida_struct.struc_t.has_union (method) -ida_struct.struc_t.id (variable) -ida_struct.struc_t.is_choosable (method) -ida_struct.struc_t.is_copyof (method) -ida_struct.struc_t.is_frame (method) -ida_struct.struc_t.is_ghost (method) -ida_struct.struc_t.is_hidden (method) -ida_struct.struc_t.is_mappedto (method) -ida_struct.struc_t.is_synced (method) -ida_struct.struc_t.is_union (method) -ida_struct.struc_t.is_varstr (method) -ida_struct.struc_t.like_union (method) -ida_struct.struc_t.members (variable) -ida_struct.struc_t.memqty (variable) -ida_struct.struc_t.ordinal (variable) -ida_struct.struc_t.props (variable) -ida_struct.struc_t.set_alignment (method) -ida_struct.struc_t.set_ghost (method) -ida_struct.struc_t.unsync (method) -ida_struct.struct_field_visitor_t (class) -ida_struct.struct_field_visitor_t.__disown__ (method) -ida_struct.struct_field_visitor_t.__init__ (method) -ida_struct.struct_field_visitor_t.visit_field (method) -ida_struct.udt_member_visitor_t (class) -ida_struct.udt_member_visitor_t.__disown__ (method) -ida_struct.udt_member_visitor_t.__init__ (method) -ida_struct.udt_member_visitor_t.visit_member (method) -ida_struct.visit_stroff_fields (function) -ida_struct.visit_stroff_members (function) -ida_tryblks (module) -ida_tryblks.TBERR_EMPTY (variable) -ida_tryblks.TBERR_END (variable) -ida_tryblks.TBERR_INTERSECT (variable) -ida_tryblks.TBERR_KIND (variable) -ida_tryblks.TBERR_NO_CATCHES (variable) -ida_tryblks.TBERR_OK (variable) -ida_tryblks.TBERR_ORDER (variable) -ida_tryblks.TBERR_START (variable) -ida_tryblks.add_tryblk (function) -ida_tryblks.catch_t (class) -ida_tryblks.catch_t.__init__ (method) -ida_tryblks.catchvec_t (class) -ida_tryblks.catchvec_t.__eq__ (method) -ida_tryblks.catchvec_t.__getitem__ (method) -ida_tryblks.catchvec_t.__init__ (method) -ida_tryblks.catchvec_t.__len__ (method) -ida_tryblks.catchvec_t.__ne__ (method) -ida_tryblks.catchvec_t.__setitem__ (method) -ida_tryblks.catchvec_t._del (method) -ida_tryblks.catchvec_t.add_unique (method) -ida_tryblks.catchvec_t.at (method) -ida_tryblks.catchvec_t.begin (method) -ida_tryblks.catchvec_t.capacity (method) -ida_tryblks.catchvec_t.clear (method) -ida_tryblks.catchvec_t.empty (method) -ida_tryblks.catchvec_t.end (method) -ida_tryblks.catchvec_t.erase (method) -ida_tryblks.catchvec_t.extract (method) -ida_tryblks.catchvec_t.find (method) -ida_tryblks.catchvec_t.grow (method) -ida_tryblks.catchvec_t.has (method) -ida_tryblks.catchvec_t.inject (method) -ida_tryblks.catchvec_t.insert (method) -ida_tryblks.catchvec_t.pop_back (method) -ida_tryblks.catchvec_t.push_back (method) -ida_tryblks.catchvec_t.qclear (method) -ida_tryblks.catchvec_t.reserve (method) -ida_tryblks.catchvec_t.resize (method) -ida_tryblks.catchvec_t.size (method) -ida_tryblks.catchvec_t.swap (method) -ida_tryblks.catchvec_t.truncate (method) -ida_tryblks.del_tryblks (function) -ida_tryblks.find_syseh (function) -ida_tryblks.get_tryblks (function) -ida_tryblks.is_ea_tryblks (function) -ida_tryblks.seh_t (class) -ida_tryblks.seh_t.__init__ (method) -ida_tryblks.seh_t.clear (method) -ida_tryblks.try_handler_t (class) -ida_tryblks.try_handler_t.__init__ (method) -ida_tryblks.try_handler_t.clear (method) -ida_tryblks.tryblk_t (class) -ida_tryblks.tryblk_t.__init__ (method) -ida_tryblks.tryblk_t.clear (method) -ida_tryblks.tryblk_t.cpp (method) -ida_tryblks.tryblk_t.empty (method) -ida_tryblks.tryblk_t.get_kind (method) -ida_tryblks.tryblk_t.is_cpp (method) -ida_tryblks.tryblk_t.is_seh (method) -ida_tryblks.tryblk_t.seh (method) -ida_tryblks.tryblk_t.set_cpp (method) -ida_tryblks.tryblk_t.set_seh (method) -ida_tryblks.tryblks_t (class) -ida_tryblks.tryblks_t.__eq__ (method) -ida_tryblks.tryblks_t.__getitem__ (method) -ida_tryblks.tryblks_t.__init__ (method) -ida_tryblks.tryblks_t.__len__ (method) -ida_tryblks.tryblks_t.__ne__ (method) -ida_tryblks.tryblks_t.__setitem__ (method) -ida_tryblks.tryblks_t._del (method) -ida_tryblks.tryblks_t.add_unique (method) -ida_tryblks.tryblks_t.at (method) -ida_tryblks.tryblks_t.begin (method) -ida_tryblks.tryblks_t.capacity (method) -ida_tryblks.tryblks_t.clear (method) -ida_tryblks.tryblks_t.empty (method) -ida_tryblks.tryblks_t.end (method) -ida_tryblks.tryblks_t.erase (method) -ida_tryblks.tryblks_t.extract (method) -ida_tryblks.tryblks_t.find (method) -ida_tryblks.tryblks_t.grow (method) -ida_tryblks.tryblks_t.has (method) -ida_tryblks.tryblks_t.inject (method) -ida_tryblks.tryblks_t.insert (method) -ida_tryblks.tryblks_t.pop_back (method) -ida_tryblks.tryblks_t.push_back (method) -ida_tryblks.tryblks_t.qclear (method) -ida_tryblks.tryblks_t.reserve (method) -ida_tryblks.tryblks_t.resize (method) -ida_tryblks.tryblks_t.size (method) -ida_tryblks.tryblks_t.swap (method) -ida_tryblks.tryblks_t.truncate (method) -ida_typeinf (module) -ida_typeinf.ADDTIL_ABORTED (variable) -ida_typeinf.ADDTIL_COMP (variable) -ida_typeinf.ADDTIL_DEFAULT (variable) -ida_typeinf.ADDTIL_FAILED (variable) -ida_typeinf.ADDTIL_INCOMP (variable) -ida_typeinf.ADDTIL_OK (variable) -ida_typeinf.ADDTIL_SILENT (variable) -ida_typeinf.ALOC_CUSTOM (variable) -ida_typeinf.ALOC_DIST (variable) -ida_typeinf.ALOC_NONE (variable) -ida_typeinf.ALOC_REG1 (variable) -ida_typeinf.ALOC_REG2 (variable) -ida_typeinf.ALOC_RREL (variable) -ida_typeinf.ALOC_STACK (variable) -ida_typeinf.ALOC_STATIC (variable) -ida_typeinf.ARGREGS_BY_SLOTS (variable) -ida_typeinf.ARGREGS_FP_CONSUME_GP (variable) -ida_typeinf.ARGREGS_GP_ONLY (variable) -ida_typeinf.ARGREGS_INDEPENDENT (variable) -ida_typeinf.ARGREGS_MIPS_O32 (variable) -ida_typeinf.BADORD (variable) -ida_typeinf.BADSIZE (variable) -ida_typeinf.BFA_FUNC_EXT_FORMAT (variable) -ida_typeinf.BFA_FUNC_MARKER (variable) -ida_typeinf.BFA_HIGH (variable) -ida_typeinf.BFA_NORET (variable) -ida_typeinf.BFA_PURE (variable) -ida_typeinf.BFA_STATIC (variable) -ida_typeinf.BFA_VIRTUAL (variable) -ida_typeinf.BTE_ALWAYS (variable) -ida_typeinf.BTE_BITFIELD (variable) -ida_typeinf.BTE_CHAR (variable) -ida_typeinf.BTE_HEX (variable) -ida_typeinf.BTE_OUT_MASK (variable) -ida_typeinf.BTE_RESERVED (variable) -ida_typeinf.BTE_SDEC (variable) -ida_typeinf.BTE_SIZE_MASK (variable) -ida_typeinf.BTE_UDEC (variable) -ida_typeinf.BTF_BOOL (variable) -ida_typeinf.BTF_BYTE (variable) -ida_typeinf.BTF_CHAR (variable) -ida_typeinf.BTF_DOUBLE (variable) -ida_typeinf.BTF_ENUM (variable) -ida_typeinf.BTF_FLOAT (variable) -ida_typeinf.BTF_INT (variable) -ida_typeinf.BTF_INT128 (variable) -ida_typeinf.BTF_INT16 (variable) -ida_typeinf.BTF_INT32 (variable) -ida_typeinf.BTF_INT64 (variable) -ida_typeinf.BTF_INT8 (variable) -ida_typeinf.BTF_LDOUBLE (variable) -ida_typeinf.BTF_SINT (variable) -ida_typeinf.BTF_STRUCT (variable) -ida_typeinf.BTF_TBYTE (variable) -ida_typeinf.BTF_TYPEDEF (variable) -ida_typeinf.BTF_UCHAR (variable) -ida_typeinf.BTF_UINT (variable) -ida_typeinf.BTF_UINT128 (variable) -ida_typeinf.BTF_UINT16 (variable) -ida_typeinf.BTF_UINT32 (variable) -ida_typeinf.BTF_UINT64 (variable) -ida_typeinf.BTF_UINT8 (variable) -ida_typeinf.BTF_UNION (variable) -ida_typeinf.BTF_UNK (variable) -ida_typeinf.BTF_VOID (variable) -ida_typeinf.BTMT_ARRESERV (variable) -ida_typeinf.BTMT_BFLDI16 (variable) -ida_typeinf.BTMT_BFLDI32 (variable) -ida_typeinf.BTMT_BFLDI64 (variable) -ida_typeinf.BTMT_BFLDI8 (variable) -ida_typeinf.BTMT_BOOL1 (variable) -ida_typeinf.BTMT_BOOL2 (variable) -ida_typeinf.BTMT_BOOL4 (variable) -ida_typeinf.BTMT_BOOL8 (variable) -ida_typeinf.BTMT_CHAR (variable) -ida_typeinf.BTMT_CLOSURE (variable) -ida_typeinf.BTMT_DEFBOOL (variable) -ida_typeinf.BTMT_DEFCALL (variable) -ida_typeinf.BTMT_DEFPTR (variable) -ida_typeinf.BTMT_DOUBLE (variable) -ida_typeinf.BTMT_FAR (variable) -ida_typeinf.BTMT_FARCALL (variable) -ida_typeinf.BTMT_FLOAT (variable) -ida_typeinf.BTMT_INTCALL (variable) -ida_typeinf.BTMT_LNGDBL (variable) -ida_typeinf.BTMT_NEAR (variable) -ida_typeinf.BTMT_NEARCALL (variable) -ida_typeinf.BTMT_NONBASED (variable) -ida_typeinf.BTMT_SIGNED (variable) -ida_typeinf.BTMT_SIZE0 (variable) -ida_typeinf.BTMT_SIZE12 (variable) -ida_typeinf.BTMT_SIZE128 (variable) -ida_typeinf.BTMT_SIZE48 (variable) -ida_typeinf.BTMT_SPECFLT (variable) -ida_typeinf.BTMT_TYPEDEF (variable) -ida_typeinf.BTMT_UNKSIGN (variable) -ida_typeinf.BTMT_USIGNED (variable) -ida_typeinf.BTM_CONST (variable) -ida_typeinf.BTM_VOLATILE (variable) -ida_typeinf.BT_ARRAY (variable) -ida_typeinf.BT_BITFIELD (variable) -ida_typeinf.BT_BOOL (variable) -ida_typeinf.BT_COMPLEX (variable) -ida_typeinf.BT_FLOAT (variable) -ida_typeinf.BT_FUNC (variable) -ida_typeinf.BT_INT (variable) -ida_typeinf.BT_INT128 (variable) -ida_typeinf.BT_INT16 (variable) -ida_typeinf.BT_INT32 (variable) -ida_typeinf.BT_INT64 (variable) -ida_typeinf.BT_INT8 (variable) -ida_typeinf.BT_PTR (variable) -ida_typeinf.BT_RESERVED (variable) -ida_typeinf.BT_SEGREG (variable) -ida_typeinf.BT_UNK (variable) -ida_typeinf.BT_UNKNOWN (variable) -ida_typeinf.BT_UNK_BYTE (variable) -ida_typeinf.BT_UNK_DWORD (variable) -ida_typeinf.BT_UNK_OWORD (variable) -ida_typeinf.BT_UNK_QWORD (variable) -ida_typeinf.BT_UNK_WORD (variable) -ida_typeinf.BT_VOID (variable) -ida_typeinf.CC_ALLOW_ARGPERM (variable) -ida_typeinf.CC_ALLOW_REGHOLES (variable) -ida_typeinf.CC_CDECL_OK (variable) -ida_typeinf.CC_GOLANG_OK (variable) -ida_typeinf.CC_HAS_ELLIPSIS (variable) -ida_typeinf.CM_CC_CDECL (variable) -ida_typeinf.CM_CC_ELLIPSIS (variable) -ida_typeinf.CM_CC_FASTCALL (variable) -ida_typeinf.CM_CC_GOLANG (variable) -ida_typeinf.CM_CC_INVALID (variable) -ida_typeinf.CM_CC_PASCAL (variable) -ida_typeinf.CM_CC_SPECIALE (variable) -ida_typeinf.CM_CC_SPECIALP (variable) -ida_typeinf.CM_CC_SPOILED (variable) -ida_typeinf.CM_CC_STDCALL (variable) -ida_typeinf.CM_CC_SWIFT (variable) -ida_typeinf.CM_CC_THISCALL (variable) -ida_typeinf.CM_CC_UNKNOWN (variable) -ida_typeinf.CM_CC_VOIDARG (variable) -ida_typeinf.CM_N16_F32 (variable) -ida_typeinf.CM_N32_F48 (variable) -ida_typeinf.CM_N64 (variable) -ida_typeinf.CM_N8_F16 (variable) -ida_typeinf.CM_UNKNOWN (variable) -ida_typeinf.COMP_BC (variable) -ida_typeinf.COMP_BP (variable) -ida_typeinf.COMP_GNU (variable) -ida_typeinf.COMP_MS (variable) -ida_typeinf.COMP_UNK (variable) -ida_typeinf.COMP_UNSURE (variable) -ida_typeinf.COMP_VISAGE (variable) -ida_typeinf.COMP_WATCOM (variable) -ida_typeinf.FAH_BYTE (variable) -ida_typeinf.FAI_ARRAY (variable) -ida_typeinf.FAI_HIDDEN (variable) -ida_typeinf.FAI_RETPTR (variable) -ida_typeinf.FAI_STRUCT (variable) -ida_typeinf.FAI_UNUSED (variable) -ida_typeinf.FIRST_NONTRIVIAL_TYPID (variable) -ida_typeinf.FRB_CHAR (variable) -ida_typeinf.FRB_CUSTOM (variable) -ida_typeinf.FRB_ENUM (variable) -ida_typeinf.FRB_FLOAT (variable) -ida_typeinf.FRB_INVBITS (variable) -ida_typeinf.FRB_INVSIGN (variable) -ida_typeinf.FRB_LZERO (variable) -ida_typeinf.FRB_MASK (variable) -ida_typeinf.FRB_NUMB (variable) -ida_typeinf.FRB_NUMD (variable) -ida_typeinf.FRB_NUMH (variable) -ida_typeinf.FRB_NUMO (variable) -ida_typeinf.FRB_OFFSET (variable) -ida_typeinf.FRB_SEG (variable) -ida_typeinf.FRB_SIGNED (variable) -ida_typeinf.FRB_STRLIT (variable) -ida_typeinf.FRB_STROFF (variable) -ida_typeinf.FRB_UNK (variable) -ida_typeinf.FTI_ALL (variable) -ida_typeinf.FTI_ARGLOCS (variable) -ida_typeinf.FTI_CALLTYPE (variable) -ida_typeinf.FTI_CONST (variable) -ida_typeinf.FTI_CTOR (variable) -ida_typeinf.FTI_DEFCALL (variable) -ida_typeinf.FTI_DTOR (variable) -ida_typeinf.FTI_EXPLOCS (variable) -ida_typeinf.FTI_FARCALL (variable) -ida_typeinf.FTI_HIGH (variable) -ida_typeinf.FTI_INTCALL (variable) -ida_typeinf.FTI_NEARCALL (variable) -ida_typeinf.FTI_NORET (variable) -ida_typeinf.FTI_PURE (variable) -ida_typeinf.FTI_SPOILED (variable) -ida_typeinf.FTI_STATIC (variable) -ida_typeinf.FTI_VIRTUAL (variable) -ida_typeinf.GTD_CALC_ARGLOCS (variable) -ida_typeinf.GTD_CALC_LAYOUT (variable) -ida_typeinf.GTD_DEL_BITFLDS (variable) -ida_typeinf.GTD_NO_ARGLOCS (variable) -ida_typeinf.GTD_NO_LAYOUT (variable) -ida_typeinf.GTE_IDBSYNC (variable) -ida_typeinf.GTE_SAVE (variable) -ida_typeinf.GTS_BASECLASS (variable) -ida_typeinf.GTS_NESTED (variable) -ida_typeinf.GUESS_FUNC_FAILED (variable) -ida_typeinf.GUESS_FUNC_OK (variable) -ida_typeinf.GUESS_FUNC_TRIVIAL (variable) -ida_typeinf.HTI_CPP (variable) -ida_typeinf.HTI_DCL (variable) -ida_typeinf.HTI_FIL (variable) -ida_typeinf.HTI_HIGH (variable) -ida_typeinf.HTI_LOWER (variable) -ida_typeinf.HTI_MAC (variable) -ida_typeinf.HTI_NDC (variable) -ida_typeinf.HTI_NER (variable) -ida_typeinf.HTI_NWR (variable) -ida_typeinf.HTI_PAK (variable) -ida_typeinf.HTI_PAK1 (variable) -ida_typeinf.HTI_PAK16 (variable) -ida_typeinf.HTI_PAK2 (variable) -ida_typeinf.HTI_PAK4 (variable) -ida_typeinf.HTI_PAK8 (variable) -ida_typeinf.HTI_PAKDEF (variable) -ida_typeinf.HTI_PAK_SHIFT (variable) -ida_typeinf.HTI_RAWARGS (variable) -ida_typeinf.HTI_TST (variable) -ida_typeinf.IMPTYPE_LOCAL (variable) -ida_typeinf.IMPTYPE_OVERRIDE (variable) -ida_typeinf.IMPTYPE_VERBOSE (variable) -ida_typeinf.MAX_FUNC_ARGS (variable) -ida_typeinf.NTF_64BIT (variable) -ida_typeinf.NTF_CHKSYNC (variable) -ida_typeinf.NTF_FIXNAME (variable) -ida_typeinf.NTF_IDBENC (variable) -ida_typeinf.NTF_NOBASE (variable) -ida_typeinf.NTF_NOCUR (variable) -ida_typeinf.NTF_NO_NAMECHK (variable) -ida_typeinf.NTF_REPLACE (variable) -ida_typeinf.NTF_SYMM (variable) -ida_typeinf.NTF_SYMU (variable) -ida_typeinf.NTF_TYPE (variable) -ida_typeinf.NTF_UMANGLED (variable) -ida_typeinf.PDF_DEF_BASE (variable) -ida_typeinf.PDF_DEF_FWD (variable) -ida_typeinf.PDF_HEADER_CMT (variable) -ida_typeinf.PDF_INCL_DEPS (variable) -ida_typeinf.PIO_IGNORE_PTRS (variable) -ida_typeinf.PIO_NOATTR_FAIL (variable) -ida_typeinf.PRALOC_STKOFF (variable) -ida_typeinf.PRALOC_VERIFY (variable) -ida_typeinf.PRTYPE_1LINCMT (variable) -ida_typeinf.PRTYPE_1LINE (variable) -ida_typeinf.PRTYPE_COLORED (variable) -ida_typeinf.PRTYPE_CPP (variable) -ida_typeinf.PRTYPE_HEADER (variable) -ida_typeinf.PRTYPE_MULTI (variable) -ida_typeinf.PRTYPE_NOREGEX (variable) -ida_typeinf.PRTYPE_PRAGMA (variable) -ida_typeinf.PRTYPE_SEMI (variable) -ida_typeinf.PRTYPE_TYPE (variable) -ida_typeinf.PT_HIGH (variable) -ida_typeinf.PT_LOWER (variable) -ida_typeinf.PT_NDC (variable) -ida_typeinf.PT_PACKMASK (variable) -ida_typeinf.PT_RAWARGS (variable) -ida_typeinf.PT_REPLACE (variable) -ida_typeinf.PT_SIL (variable) -ida_typeinf.PT_TYP (variable) -ida_typeinf.PT_VAR (variable) -ida_typeinf.RESERVED_BYTE (variable) -ida_typeinf.SC_AUTO (variable) -ida_typeinf.SC_EXT (variable) -ida_typeinf.SC_FRIEND (variable) -ida_typeinf.SC_REG (variable) -ida_typeinf.SC_STAT (variable) -ida_typeinf.SC_TYPE (variable) -ida_typeinf.SC_UNK (variable) -ida_typeinf.SC_VIRT (variable) -ida_typeinf.SETCOMP_BY_USER (variable) -ida_typeinf.SETCOMP_ONLY_ABI (variable) -ida_typeinf.SETCOMP_ONLY_ID (variable) -ida_typeinf.SETCOMP_OVERRIDE (variable) -ida_typeinf.STI_ACCHAR (variable) -ida_typeinf.STI_ACHAR (variable) -ida_typeinf.STI_ACUCHAR (variable) -ida_typeinf.STI_AEABI_LCMP (variable) -ida_typeinf.STI_AEABI_MEMCLR (variable) -ida_typeinf.STI_AEABI_MEMCPY (variable) -ida_typeinf.STI_AEABI_MEMSET (variable) -ida_typeinf.STI_AEABI_ULCMP (variable) -ida_typeinf.STI_AUCHAR (variable) -ida_typeinf.STI_COMPLEX128 (variable) -ida_typeinf.STI_COMPLEX64 (variable) -ida_typeinf.STI_DONT_USE (variable) -ida_typeinf.STI_FDELOP (variable) -ida_typeinf.STI_FPURGING (variable) -ida_typeinf.STI_MSGSEND (variable) -ida_typeinf.STI_PBYTE (variable) -ida_typeinf.STI_PCCHAR (variable) -ida_typeinf.STI_PCHAR (variable) -ida_typeinf.STI_PCUCHAR (variable) -ida_typeinf.STI_PCVOID (variable) -ida_typeinf.STI_PINT (variable) -ida_typeinf.STI_PPVOID (variable) -ida_typeinf.STI_PUCHAR (variable) -ida_typeinf.STI_PUINT (variable) -ida_typeinf.STI_PVOID (variable) -ida_typeinf.STI_RTC_CHECK_2 (variable) -ida_typeinf.STI_RTC_CHECK_4 (variable) -ida_typeinf.STI_RTC_CHECK_8 (variable) -ida_typeinf.STI_SIZE_T (variable) -ida_typeinf.STI_SSIZE_T (variable) -ida_typeinf.STRMEM_ANON (variable) -ida_typeinf.STRMEM_AUTO (variable) -ida_typeinf.STRMEM_CASTABLE_TO (variable) -ida_typeinf.STRMEM_INDEX (variable) -ida_typeinf.STRMEM_MAXS (variable) -ida_typeinf.STRMEM_MINS (variable) -ida_typeinf.STRMEM_NAME (variable) -ida_typeinf.STRMEM_OFFSET (variable) -ida_typeinf.STRMEM_SIZE (variable) -ida_typeinf.STRMEM_SKIP_EMPTY (variable) -ida_typeinf.STRMEM_TYPE (variable) -ida_typeinf.STRMEM_VFTABLE (variable) -ida_typeinf.SUDT_ALIGN (variable) -ida_typeinf.SUDT_CONST (variable) -ida_typeinf.SUDT_FAST (variable) -ida_typeinf.SUDT_GAPS (variable) -ida_typeinf.SUDT_SORT (variable) -ida_typeinf.SUDT_UNEX (variable) -ida_typeinf.SUDT_VOLATILE (variable) -ida_typeinf.TAFLD_METHOD (variable) -ida_typeinf.TAH_ALL (variable) -ida_typeinf.TAH_BYTE (variable) -ida_typeinf.TAH_HASATTRS (variable) -ida_typeinf.TA_FORMAT (variable) -ida_typeinf.TA_ORG_ARRDIM (variable) -ida_typeinf.TA_ORG_TYPEDEF (variable) -ida_typeinf.TCMP_ANYBASE (variable) -ida_typeinf.TCMP_AUTOCAST (variable) -ida_typeinf.TCMP_CALL (variable) -ida_typeinf.TCMP_DECL (variable) -ida_typeinf.TCMP_DELPTR (variable) -ida_typeinf.TCMP_EQUAL (variable) -ida_typeinf.TCMP_IGNMODS (variable) -ida_typeinf.TCMP_MANCAST (variable) -ida_typeinf.TCMP_SKIPTHIS (variable) -ida_typeinf.TERR_BADSYNC (variable) -ida_typeinf.TERR_OK (variable) -ida_typeinf.TERR_SAVE (variable) -ida_typeinf.TERR_SERIALIZE (variable) -ida_typeinf.TERR_WRONGNAME (variable) -ida_typeinf.TIL_ADD_ALREADY (variable) -ida_typeinf.TIL_ADD_FAILED (variable) -ida_typeinf.TIL_ADD_OK (variable) -ida_typeinf.TIL_ALI (variable) -ida_typeinf.TIL_ESI (variable) -ida_typeinf.TIL_MAC (variable) -ida_typeinf.TIL_MOD (variable) -ida_typeinf.TIL_ORD (variable) -ida_typeinf.TIL_SLD (variable) -ida_typeinf.TIL_STM (variable) -ida_typeinf.TIL_UNI (variable) -ida_typeinf.TIL_ZIP (variable) -ida_typeinf.TINFO_DEFINITE (variable) -ida_typeinf.TINFO_DELAYFUNC (variable) -ida_typeinf.TINFO_GUESSED (variable) -ida_typeinf.TINFO_STRICT (variable) -ida_typeinf.TVIS_CMT (variable) -ida_typeinf.TVIS_NAME (variable) -ida_typeinf.TVIS_TYPE (variable) -ida_typeinf.TVST_DEF (variable) -ida_typeinf.TVST_PRUNE (variable) -ida_typeinf.TYPE_BASE_MASK (variable) -ida_typeinf.TYPE_FLAGS_MASK (variable) -ida_typeinf.TYPE_FULL_MASK (variable) -ida_typeinf.TYPE_MODIF_MASK (variable) -ida_typeinf.TYPID_ISREF (variable) -ida_typeinf.TYPID_SHIFT (variable) -ida_typeinf.VALSTR_OPEN (variable) -ida_typeinf._BT_LAST_BASIC (variable) -ida_typeinf._wrap_cvar (class) -ida_typeinf._wrap_cvar.__getattr__ (method) -ida_typeinf._wrap_cvar.__setattr__ (method) -ida_typeinf.add_til (function) -ida_typeinf.alloc_type_ordinal (function) -ida_typeinf.alloc_type_ordinals (function) -ida_typeinf.aloc_visitor_t (class) -ida_typeinf.aloc_visitor_t.__disown__ (method) -ida_typeinf.aloc_visitor_t.__init__ (method) -ida_typeinf.aloc_visitor_t.visit_location (method) -ida_typeinf.append_abi_opts (function) -ida_typeinf.append_argloc (function) -ida_typeinf.append_tinfo_covered (function) -ida_typeinf.apply_callee_tinfo (function) -ida_typeinf.apply_cdecl (function) -ida_typeinf.apply_named_type (function) -ida_typeinf.apply_once_tinfo_and_name (function) -ida_typeinf.apply_tinfo (function) -ida_typeinf.apply_tinfo_to_stkarg (function) -ida_typeinf.apply_type (function) -ida_typeinf.argloc_t (class) -ida_typeinf.argloc_t.__eq__ (method) -ida_typeinf.argloc_t.__ge__ (method) -ida_typeinf.argloc_t.__gt__ (method) -ida_typeinf.argloc_t.__init__ (method) -ida_typeinf.argloc_t.__le__ (method) -ida_typeinf.argloc_t.__lt__ (method) -ida_typeinf.argloc_t.__ne__ (method) -ida_typeinf.argloc_t._consume_rrel (method) -ida_typeinf.argloc_t._consume_scattered (method) -ida_typeinf.argloc_t._set_badloc (method) -ida_typeinf.argloc_t._set_biggest (method) -ida_typeinf.argloc_t._set_custom (method) -ida_typeinf.argloc_t._set_ea (method) -ida_typeinf.argloc_t._set_reg1 (method) -ida_typeinf.argloc_t._set_reg2 (method) -ida_typeinf.argloc_t._set_stkoff (method) -ida_typeinf.argloc_t.advance (method) -ida_typeinf.argloc_t.align_reg_high (method) -ida_typeinf.argloc_t.align_stkoff_high (method) -ida_typeinf.argloc_t.atype (method) -ida_typeinf.argloc_t.calc_offset (method) -ida_typeinf.argloc_t.compare (method) -ida_typeinf.argloc_t.consume_rrel (method) -ida_typeinf.argloc_t.consume_scattered (method) -ida_typeinf.argloc_t.get_biggest (method) -ida_typeinf.argloc_t.get_custom (method) -ida_typeinf.argloc_t.get_ea (method) -ida_typeinf.argloc_t.get_reginfo (method) -ida_typeinf.argloc_t.get_rrel (method) -ida_typeinf.argloc_t.has_reg (method) -ida_typeinf.argloc_t.has_stkoff (method) -ida_typeinf.argloc_t.in_stack (method) -ida_typeinf.argloc_t.is_badloc (method) -ida_typeinf.argloc_t.is_custom (method) -ida_typeinf.argloc_t.is_ea (method) -ida_typeinf.argloc_t.is_fragmented (method) -ida_typeinf.argloc_t.is_mixed_scattered (method) -ida_typeinf.argloc_t.is_reg (method) -ida_typeinf.argloc_t.is_reg1 (method) -ida_typeinf.argloc_t.is_reg2 (method) -ida_typeinf.argloc_t.is_rrel (method) -ida_typeinf.argloc_t.is_scattered (method) -ida_typeinf.argloc_t.is_stkoff (method) -ida_typeinf.argloc_t.reg1 (method) -ida_typeinf.argloc_t.reg2 (method) -ida_typeinf.argloc_t.regoff (method) -ida_typeinf.argloc_t.scattered (method) -ida_typeinf.argloc_t.set_badloc (method) -ida_typeinf.argloc_t.set_ea (method) -ida_typeinf.argloc_t.set_reg1 (method) -ida_typeinf.argloc_t.set_reg2 (method) -ida_typeinf.argloc_t.set_stkoff (method) -ida_typeinf.argloc_t.stkoff (method) -ida_typeinf.argloc_t.swap (method) -ida_typeinf.argpart_t (class) -ida_typeinf.argpart_t.__init__ (method) -ida_typeinf.argpart_t.__lt__ (method) -ida_typeinf.argpart_t.bad_offset (method) -ida_typeinf.argpart_t.bad_size (method) -ida_typeinf.argpart_t.off (variable) -ida_typeinf.argpart_t.size (variable) -ida_typeinf.argpart_t.swap (method) -ida_typeinf.argpartvec_t (class) -ida_typeinf.argpartvec_t.__eq__ (method) -ida_typeinf.argpartvec_t.__getitem__ (method) -ida_typeinf.argpartvec_t.__init__ (method) -ida_typeinf.argpartvec_t.__len__ (method) -ida_typeinf.argpartvec_t.__ne__ (method) -ida_typeinf.argpartvec_t.__setitem__ (method) -ida_typeinf.argpartvec_t._del (method) -ida_typeinf.argpartvec_t.add_unique (method) -ida_typeinf.argpartvec_t.at (method) -ida_typeinf.argpartvec_t.begin (method) -ida_typeinf.argpartvec_t.capacity (method) -ida_typeinf.argpartvec_t.clear (method) -ida_typeinf.argpartvec_t.empty (method) -ida_typeinf.argpartvec_t.end (method) -ida_typeinf.argpartvec_t.erase (method) -ida_typeinf.argpartvec_t.extract (method) -ida_typeinf.argpartvec_t.find (method) -ida_typeinf.argpartvec_t.grow (method) -ida_typeinf.argpartvec_t.has (method) -ida_typeinf.argpartvec_t.inject (method) -ida_typeinf.argpartvec_t.insert (method) -ida_typeinf.argpartvec_t.pop_back (method) -ida_typeinf.argpartvec_t.push_back (method) -ida_typeinf.argpartvec_t.qclear (method) -ida_typeinf.argpartvec_t.reserve (method) -ida_typeinf.argpartvec_t.resize (method) -ida_typeinf.argpartvec_t.size (method) -ida_typeinf.argpartvec_t.swap (method) -ida_typeinf.argpartvec_t.truncate (method) -ida_typeinf.argtinfo_helper_t (class) -ida_typeinf.argtinfo_helper_t.__disown__ (method) -ida_typeinf.argtinfo_helper_t.__init__ (method) -ida_typeinf.argtinfo_helper_t.has_delay_slot (method) -ida_typeinf.argtinfo_helper_t.is_stkarg_load (method) -ida_typeinf.argtinfo_helper_t.set_op_tinfo (method) -ida_typeinf.argtinfo_helper_t.use_arg_tinfos (method) -ida_typeinf.array_type_data_t (class) -ida_typeinf.array_type_data_t.__init__ (method) -ida_typeinf.array_type_data_t.base (variable) -ida_typeinf.array_type_data_t.elem_type (variable) -ida_typeinf.array_type_data_t.nelems (variable) -ida_typeinf.array_type_data_t.swap (method) -ida_typeinf.begin_type_updating (function) -ida_typeinf.bitfield_type_data_t (class) -ida_typeinf.bitfield_type_data_t.__eq__ (method) -ida_typeinf.bitfield_type_data_t.__ge__ (method) -ida_typeinf.bitfield_type_data_t.__gt__ (method) -ida_typeinf.bitfield_type_data_t.__init__ (method) -ida_typeinf.bitfield_type_data_t.__le__ (method) -ida_typeinf.bitfield_type_data_t.__lt__ (method) -ida_typeinf.bitfield_type_data_t.__ne__ (method) -ida_typeinf.bitfield_type_data_t.compare (method) -ida_typeinf.bitfield_type_data_t.is_unsigned (variable) -ida_typeinf.bitfield_type_data_t.nbytes (variable) -ida_typeinf.bitfield_type_data_t.swap (method) -ida_typeinf.bitfield_type_data_t.width (variable) -ida_typeinf.calc_c_cpp_name (function) -ida_typeinf.calc_number_of_children (function) -ida_typeinf.calc_tinfo_gaps (function) -ida_typeinf.calc_type_size (function) -ida_typeinf.callregs_t (class) -ida_typeinf.callregs_t.__init__ (method) -ida_typeinf.callregs_t.by_slots (method) -ida_typeinf.callregs_t.fpregs (variable) -ida_typeinf.callregs_t.gpregs (variable) -ida_typeinf.callregs_t.init_regs (method) -ida_typeinf.callregs_t.nregs (variable) -ida_typeinf.callregs_t.policy (variable) -ida_typeinf.callregs_t.regcount (method) -ida_typeinf.callregs_t.reginds (method) -ida_typeinf.callregs_t.reset (method) -ida_typeinf.callregs_t.set (method) -ida_typeinf.callregs_t.swap (method) -ida_typeinf.callregs_t_regcount (function) -ida_typeinf.choose_local_tinfo (function) -ida_typeinf.choose_local_tinfo_and_delta (function) -ida_typeinf.choose_named_type (function) -ida_typeinf.clear_tinfo_t (function) -ida_typeinf.compact_til (function) -ida_typeinf.compare_tinfo (function) -ida_typeinf.const_aloc_visitor_t (class) -ida_typeinf.const_aloc_visitor_t.__disown__ (method) -ida_typeinf.const_aloc_visitor_t.__init__ (method) -ida_typeinf.const_aloc_visitor_t.visit_location (method) -ida_typeinf.convert_pt_flags_to_hti (function) -ida_typeinf.copy_named_type (function) -ida_typeinf.copy_tinfo_t (function) -ida_typeinf.create_enum_type (function) -ida_typeinf.create_numbered_type_name (function) -ida_typeinf.create_tinfo (function) -ida_typeinf.create_tinfo2 (function) -ida_typeinf.custom_data_type_info_t (class) -ida_typeinf.custom_data_type_info_t.__init__ (method) -ida_typeinf.custom_data_type_info_t.dtid (variable) -ida_typeinf.custom_data_type_info_t.fid (variable) -ida_typeinf.default_compiler (function) -ida_typeinf.del_named_type (function) -ida_typeinf.del_numbered_type (function) -ida_typeinf.del_til (function) -ida_typeinf.del_tinfo_attr (function) -ida_typeinf.del_vftable_ea (function) -ida_typeinf.deref_ptr (function) -ida_typeinf.deserialize_tinfo (function) -ida_typeinf.dstr_tinfo (function) -ida_typeinf.dump_func_type_data (function) -ida_typeinf.end_type_updating (function) -ida_typeinf.enum_member_t (class) -ida_typeinf.enum_member_t.__eq__ (method) -ida_typeinf.enum_member_t.__init__ (method) -ida_typeinf.enum_member_t.__ne__ (method) -ida_typeinf.enum_member_t.swap (method) -ida_typeinf.enum_member_vec_t (class) -ida_typeinf.enum_member_vec_t.__eq__ (method) -ida_typeinf.enum_member_vec_t.__getitem__ (method) -ida_typeinf.enum_member_vec_t.__init__ (method) -ida_typeinf.enum_member_vec_t.__len__ (method) -ida_typeinf.enum_member_vec_t.__ne__ (method) -ida_typeinf.enum_member_vec_t.__setitem__ (method) -ida_typeinf.enum_member_vec_t._del (method) -ida_typeinf.enum_member_vec_t.add_unique (method) -ida_typeinf.enum_member_vec_t.at (method) -ida_typeinf.enum_member_vec_t.begin (method) -ida_typeinf.enum_member_vec_t.capacity (method) -ida_typeinf.enum_member_vec_t.clear (method) -ida_typeinf.enum_member_vec_t.empty (method) -ida_typeinf.enum_member_vec_t.end (method) -ida_typeinf.enum_member_vec_t.erase (method) -ida_typeinf.enum_member_vec_t.extract (method) -ida_typeinf.enum_member_vec_t.find (method) -ida_typeinf.enum_member_vec_t.grow (method) -ida_typeinf.enum_member_vec_t.has (method) -ida_typeinf.enum_member_vec_t.inject (method) -ida_typeinf.enum_member_vec_t.insert (method) -ida_typeinf.enum_member_vec_t.pop_back (method) -ida_typeinf.enum_member_vec_t.push_back (method) -ida_typeinf.enum_member_vec_t.qclear (method) -ida_typeinf.enum_member_vec_t.reserve (method) -ida_typeinf.enum_member_vec_t.resize (method) -ida_typeinf.enum_member_vec_t.size (method) -ida_typeinf.enum_member_vec_t.swap (method) -ida_typeinf.enum_member_vec_t.truncate (method) -ida_typeinf.enum_type_data_t (class) -ida_typeinf.enum_type_data_t.__init__ (method) -ida_typeinf.enum_type_data_t.add_constant (method) -ida_typeinf.enum_type_data_t.bte (variable) -ida_typeinf.enum_type_data_t.calc_mask (method) -ida_typeinf.enum_type_data_t.calc_nbytes (method) -ida_typeinf.enum_type_data_t.del_constant (method) -ida_typeinf.enum_type_data_t.find_member (method) -ida_typeinf.enum_type_data_t.get_enum_radix (method) -ida_typeinf.enum_type_data_t.group_sizes (variable) -ida_typeinf.enum_type_data_t.has_lzero (method) -ida_typeinf.enum_type_data_t.is_bf (method) -ida_typeinf.enum_type_data_t.is_bin (method) -ida_typeinf.enum_type_data_t.is_char (method) -ida_typeinf.enum_type_data_t.is_dec (method) -ida_typeinf.enum_type_data_t.is_group_mask_at (method) -ida_typeinf.enum_type_data_t.is_hex (method) -ida_typeinf.enum_type_data_t.is_number_signed (method) -ida_typeinf.enum_type_data_t.is_oct (method) -ida_typeinf.enum_type_data_t.is_sbin (method) -ida_typeinf.enum_type_data_t.is_shex (method) -ida_typeinf.enum_type_data_t.is_soct (method) -ida_typeinf.enum_type_data_t.is_udec (method) -ida_typeinf.enum_type_data_t.is_valid_group_sizes (method) -ida_typeinf.enum_type_data_t.npos (variable) -ida_typeinf.enum_type_data_t.set_bf (method) -ida_typeinf.enum_type_data_t.set_enum_radix (method) -ida_typeinf.enum_type_data_t.set_lzero (method) -ida_typeinf.enum_type_data_t.set_nbytes (method) -ida_typeinf.enum_type_data_t.store_64bit_values (method) -ida_typeinf.enum_type_data_t.swap (method) -ida_typeinf.enum_type_data_t.taenum_bits (variable) -ida_typeinf.enum_type_data_t.validate (method) -ida_typeinf.enum_type_data_t__add_constant (function) -ida_typeinf.enum_type_data_t__del_constant (function) -ida_typeinf.enum_type_data_t__set_bf (function) -ida_typeinf.enum_type_data_t__validate (function) -ida_typeinf.extract_argloc (function) -ida_typeinf.field_repr_t (class) -ida_typeinf.field_repr_t.__init__ (method) -ida_typeinf.field_repr_t.__str__ (method) -ida_typeinf.field_repr_t._print (method) -ida_typeinf.field_repr_t.cd (variable) -ida_typeinf.field_repr_t.clear (method) -ida_typeinf.field_repr_t.deserialize (method) -ida_typeinf.field_repr_t.empty (method) -ida_typeinf.field_repr_t.from_opinfo (method) -ida_typeinf.field_repr_t.get_flags (method) -ida_typeinf.field_repr_t.get_tinfo (method) -ida_typeinf.field_repr_t.is_custom (method) -ida_typeinf.field_repr_t.is_enum (method) -ida_typeinf.field_repr_t.is_offset (method) -ida_typeinf.field_repr_t.is_signed (method) -ida_typeinf.field_repr_t.is_strlit (method) -ida_typeinf.field_repr_t.is_stroff (method) -ida_typeinf.field_repr_t.is_typref (method) -ida_typeinf.field_repr_t.ri (variable) -ida_typeinf.field_repr_t.serialize (method) -ida_typeinf.field_repr_t.strtype (variable) -ida_typeinf.field_repr_t.swap (method) -ida_typeinf.field_repr_t.to_opinfo (method) -ida_typeinf.field_repr_t.type_ordinal (variable) -ida_typeinf.field_repr_t__deserialize (function) -ida_typeinf.field_repr_t__from_opinfo (function) -ida_typeinf.field_repr_t__get_flags (function) -ida_typeinf.field_repr_t__print_ (function) -ida_typeinf.field_repr_t__serialize (function) -ida_typeinf.field_repr_t__to_opinfo (function) -ida_typeinf.find_tinfo_udt_member (function) -ida_typeinf.first_named_type (function) -ida_typeinf.for_all_arglocs (function) -ida_typeinf.for_all_const_arglocs (function) -ida_typeinf.free_til (function) -ida_typeinf.func_has_stkframe_hole (function) -ida_typeinf.func_type_data_t (class) -ida_typeinf.func_type_data_t.__init__ (method) -ida_typeinf.func_type_data_t.cc (variable) -ida_typeinf.func_type_data_t.dump (method) -ida_typeinf.func_type_data_t.flags (variable) -ida_typeinf.func_type_data_t.get_call_method (method) -ida_typeinf.func_type_data_t.guess_cc (method) -ida_typeinf.func_type_data_t.is_const (method) -ida_typeinf.func_type_data_t.is_ctor (method) -ida_typeinf.func_type_data_t.is_dtor (method) -ida_typeinf.func_type_data_t.is_golang_cc (method) -ida_typeinf.func_type_data_t.is_high (method) -ida_typeinf.func_type_data_t.is_noret (method) -ida_typeinf.func_type_data_t.is_pure (method) -ida_typeinf.func_type_data_t.is_static (method) -ida_typeinf.func_type_data_t.is_swift_cc (method) -ida_typeinf.func_type_data_t.is_vararg_cc (method) -ida_typeinf.func_type_data_t.is_virtual (method) -ida_typeinf.func_type_data_t.retloc (variable) -ida_typeinf.func_type_data_t.rettype (variable) -ida_typeinf.func_type_data_t.spoiled (variable) -ida_typeinf.func_type_data_t.stkargs (variable) -ida_typeinf.func_type_data_t.swap (method) -ida_typeinf.funcarg_t (class) -ida_typeinf.funcarg_t.__eq__ (method) -ida_typeinf.funcarg_t.__init__ (method) -ida_typeinf.funcarg_t.__ne__ (method) -ida_typeinf.funcarg_t.argloc (variable) -ida_typeinf.funcarg_t.cmt (variable) -ida_typeinf.funcarg_t.flags (variable) -ida_typeinf.funcarg_t.name (variable) -ida_typeinf.funcarg_t.type (variable) -ida_typeinf.funcargvec_t (class) -ida_typeinf.funcargvec_t.__eq__ (method) -ida_typeinf.funcargvec_t.__getitem__ (method) -ida_typeinf.funcargvec_t.__init__ (method) -ida_typeinf.funcargvec_t.__len__ (method) -ida_typeinf.funcargvec_t.__ne__ (method) -ida_typeinf.funcargvec_t.__setitem__ (method) -ida_typeinf.funcargvec_t._del (method) -ida_typeinf.funcargvec_t.add_unique (method) -ida_typeinf.funcargvec_t.at (method) -ida_typeinf.funcargvec_t.begin (method) -ida_typeinf.funcargvec_t.capacity (method) -ida_typeinf.funcargvec_t.clear (method) -ida_typeinf.funcargvec_t.empty (method) -ida_typeinf.funcargvec_t.end (method) -ida_typeinf.funcargvec_t.erase (method) -ida_typeinf.funcargvec_t.extract (method) -ida_typeinf.funcargvec_t.find (method) -ida_typeinf.funcargvec_t.grow (method) -ida_typeinf.funcargvec_t.has (method) -ida_typeinf.funcargvec_t.inject (method) -ida_typeinf.funcargvec_t.insert (method) -ida_typeinf.funcargvec_t.pop_back (method) -ida_typeinf.funcargvec_t.push_back (method) -ida_typeinf.funcargvec_t.qclear (method) -ida_typeinf.funcargvec_t.reserve (method) -ida_typeinf.funcargvec_t.resize (method) -ida_typeinf.funcargvec_t.size (method) -ida_typeinf.funcargvec_t.swap (method) -ida_typeinf.funcargvec_t.truncate (method) -ida_typeinf.gcc_layout (function) -ida_typeinf.gen_decorate_name (function) -ida_typeinf.gen_use_arg_tinfos (function) -ida_typeinf.gen_use_arg_tinfos2 (function) -ida_typeinf.get_abi_name (function) -ida_typeinf.get_alias_target (function) -ida_typeinf.get_arg_addrs (function) -ida_typeinf.get_base_type (function) -ida_typeinf.get_c_header_path (function) -ida_typeinf.get_c_macros (function) -ida_typeinf.get_comp (function) -ida_typeinf.get_compiler_abbr (function) -ida_typeinf.get_compiler_name (function) -ida_typeinf.get_compilers (function) -ida_typeinf.get_enum_details_by_name (function) -ida_typeinf.get_enum_details_by_tid (function) -ida_typeinf.get_enum_member_expr (function) -ida_typeinf.get_full_type (function) -ida_typeinf.get_idainfo64_by_type (function) -ida_typeinf.get_idainfo_by_type (function) -ida_typeinf.get_idati (function) -ida_typeinf.get_named_type (function) -ida_typeinf.get_named_type64 (function) -ida_typeinf.get_named_type_tid (function) -ida_typeinf.get_numbered_type (function) -ida_typeinf.get_numbered_type_name (function) -ida_typeinf.get_numbered_type_tid (function) -ida_typeinf.get_ordinal_from_idb_type (function) -ida_typeinf.get_ordinal_qty (function) -ida_typeinf.get_scalar_bt (function) -ida_typeinf.get_stock_tinfo (function) -ida_typeinf.get_tid_from_tinfo (function) -ida_typeinf.get_tid_name (function) -ida_typeinf.get_tid_ordinal (function) -ida_typeinf.get_tinfo_attr (function) -ida_typeinf.get_tinfo_attrs (function) -ida_typeinf.get_tinfo_by_tid (function) -ida_typeinf.get_tinfo_details (function) -ida_typeinf.get_tinfo_details2 (function) -ida_typeinf.get_tinfo_pdata (function) -ida_typeinf.get_tinfo_property (function) -ida_typeinf.get_tinfo_size (function) -ida_typeinf.get_type_flags (function) -ida_typeinf.get_type_ordinal (function) -ida_typeinf.get_udm_tid (function) -ida_typeinf.get_udt_member_tid (function) -ida_typeinf.get_vftable_ea (function) -ida_typeinf.get_vftable_ordinal (function) -ida_typeinf.guess_func_cc (function) -ida_typeinf.guess_tinfo (function) -ida_typeinf.ida_lowertype_helper_t (class) -ida_typeinf.ida_lowertype_helper_t.__init__ (method) -ida_typeinf.ida_lowertype_helper_t.func_has_stkframe_hole (method) -ida_typeinf.ida_lowertype_helper_t.get_func_purged_bytes (method) -ida_typeinf.idc_get_local_type (function) -ida_typeinf.idc_get_local_type_name (function) -ida_typeinf.idc_get_local_type_raw (function) -ida_typeinf.idc_get_type (function) -ida_typeinf.idc_get_type_raw (function) -ida_typeinf.idc_guess_type (function) -ida_typeinf.idc_parse_decl (function) -ida_typeinf.idc_parse_types (function) -ida_typeinf.idc_print_type (function) -ida_typeinf.idc_set_local_type (function) -ida_typeinf.import_type (function) -ida_typeinf.inf_big_arg_align (function) -ida_typeinf.inf_huge_arg_align (function) -ida_typeinf.inf_pack_stkargs (function) -ida_typeinf.is_autosync (function) -ida_typeinf.is_code_far (function) -ida_typeinf.is_comp_unsure (function) -ida_typeinf.is_data_far (function) -ida_typeinf.is_gcc (function) -ida_typeinf.is_gcc32 (function) -ida_typeinf.is_gcc64 (function) -ida_typeinf.is_golang_cc (function) -ida_typeinf.is_ordinal_name (function) -ida_typeinf.is_purging_cc (function) -ida_typeinf.is_restype_enum (function) -ida_typeinf.is_restype_struct (function) -ida_typeinf.is_restype_struni (function) -ida_typeinf.is_restype_void (function) -ida_typeinf.is_sdacl_byte (function) -ida_typeinf.is_swift_cc (function) -ida_typeinf.is_tah_byte (function) -ida_typeinf.is_type_arithmetic (function) -ida_typeinf.is_type_array (function) -ida_typeinf.is_type_bitfld (function) -ida_typeinf.is_type_bool (function) -ida_typeinf.is_type_char (function) -ida_typeinf.is_type_complex (function) -ida_typeinf.is_type_const (function) -ida_typeinf.is_type_double (function) -ida_typeinf.is_type_enum (function) -ida_typeinf.is_type_ext_arithmetic (function) -ida_typeinf.is_type_ext_integral (function) -ida_typeinf.is_type_float (function) -ida_typeinf.is_type_floating (function) -ida_typeinf.is_type_func (function) -ida_typeinf.is_type_int (function) -ida_typeinf.is_type_int128 (function) -ida_typeinf.is_type_int16 (function) -ida_typeinf.is_type_int32 (function) -ida_typeinf.is_type_int64 (function) -ida_typeinf.is_type_integral (function) -ida_typeinf.is_type_ldouble (function) -ida_typeinf.is_type_paf (function) -ida_typeinf.is_type_partial (function) -ida_typeinf.is_type_ptr (function) -ida_typeinf.is_type_ptr_or_array (function) -ida_typeinf.is_type_struct (function) -ida_typeinf.is_type_struni (function) -ida_typeinf.is_type_sue (function) -ida_typeinf.is_type_tbyte (function) -ida_typeinf.is_type_typedef (function) -ida_typeinf.is_type_uchar (function) -ida_typeinf.is_type_uint (function) -ida_typeinf.is_type_uint128 (function) -ida_typeinf.is_type_uint16 (function) -ida_typeinf.is_type_uint32 (function) -ida_typeinf.is_type_uint64 (function) -ida_typeinf.is_type_union (function) -ida_typeinf.is_type_unknown (function) -ida_typeinf.is_type_void (function) -ida_typeinf.is_type_volatile (function) -ida_typeinf.is_typeid_last (function) -ida_typeinf.is_user_cc (function) -ida_typeinf.is_vararg_cc (function) -ida_typeinf.lexcompare_tinfo (function) -ida_typeinf.load_til (function) -ida_typeinf.load_til_header (function) -ida_typeinf.lower_type (function) -ida_typeinf.lowertype_helper_t (class) -ida_typeinf.lowertype_helper_t.__init__ (method) -ida_typeinf.lowertype_helper_t.func_has_stkframe_hole (method) -ida_typeinf.lowertype_helper_t.get_func_purged_bytes (method) -ida_typeinf.new_til (function) -ida_typeinf.next_named_type (function) -ida_typeinf.no_sign (variable) -ida_typeinf.optimize_argloc (function) -ida_typeinf.pack_idcobj_to_bv (function) -ida_typeinf.pack_idcobj_to_idb (function) -ida_typeinf.pack_object_to_bv (function) -ida_typeinf.pack_object_to_idb (function) -ida_typeinf.parse_decl (function) -ida_typeinf.parse_decls (function) -ida_typeinf.predicate_t (class) -ida_typeinf.predicate_t.__disown__ (method) -ida_typeinf.predicate_t.__init__ (method) -ida_typeinf.predicate_t.should_display (method) -ida_typeinf.print_argloc (function) -ida_typeinf.print_decls (function) -ida_typeinf.print_tinfo (function) -ida_typeinf.print_type (function) -ida_typeinf.ptr_type_data_t (class) -ida_typeinf.ptr_type_data_t.__eq__ (method) -ida_typeinf.ptr_type_data_t.__init__ (method) -ida_typeinf.ptr_type_data_t.__ne__ (method) -ida_typeinf.ptr_type_data_t.closure (variable) -ida_typeinf.ptr_type_data_t.delta (variable) -ida_typeinf.ptr_type_data_t.is_code_ptr (method) -ida_typeinf.ptr_type_data_t.is_shifted (method) -ida_typeinf.ptr_type_data_t.obj_type (variable) -ida_typeinf.ptr_type_data_t.parent (variable) -ida_typeinf.ptr_type_data_t.swap (method) -ida_typeinf.ptr_type_data_t.taptr_bits (variable) -ida_typeinf.read_tinfo_bitfield_value (function) -ida_typeinf.reginfovec_t (class) -ida_typeinf.reginfovec_t.__eq__ (method) -ida_typeinf.reginfovec_t.__getitem__ (method) -ida_typeinf.reginfovec_t.__init__ (method) -ida_typeinf.reginfovec_t.__len__ (method) -ida_typeinf.reginfovec_t.__ne__ (method) -ida_typeinf.reginfovec_t.__setitem__ (method) -ida_typeinf.reginfovec_t._del (method) -ida_typeinf.reginfovec_t.add_unique (method) -ida_typeinf.reginfovec_t.at (method) -ida_typeinf.reginfovec_t.begin (method) -ida_typeinf.reginfovec_t.capacity (method) -ida_typeinf.reginfovec_t.clear (method) -ida_typeinf.reginfovec_t.empty (method) -ida_typeinf.reginfovec_t.end (method) -ida_typeinf.reginfovec_t.erase (method) -ida_typeinf.reginfovec_t.extract (method) -ida_typeinf.reginfovec_t.find (method) -ida_typeinf.reginfovec_t.grow (method) -ida_typeinf.reginfovec_t.has (method) -ida_typeinf.reginfovec_t.inject (method) -ida_typeinf.reginfovec_t.insert (method) -ida_typeinf.reginfovec_t.pop_back (method) -ida_typeinf.reginfovec_t.push_back (method) -ida_typeinf.reginfovec_t.qclear (method) -ida_typeinf.reginfovec_t.reserve (method) -ida_typeinf.reginfovec_t.resize (method) -ida_typeinf.reginfovec_t.size (method) -ida_typeinf.reginfovec_t.swap (method) -ida_typeinf.reginfovec_t.truncate (method) -ida_typeinf.regobj_t (class) -ida_typeinf.regobj_t.__init__ (method) -ida_typeinf.regobj_t.regidx (variable) -ida_typeinf.regobj_t.relocate (variable) -ida_typeinf.regobj_t.size (method) -ida_typeinf.regobjs_t (class) -ida_typeinf.regobjs_t.__init__ (method) -ida_typeinf.regobjvec_t (class) -ida_typeinf.regobjvec_t.__getitem__ (method) -ida_typeinf.regobjvec_t.__init__ (method) -ida_typeinf.regobjvec_t.__len__ (method) -ida_typeinf.regobjvec_t.__setitem__ (method) -ida_typeinf.regobjvec_t.at (method) -ida_typeinf.regobjvec_t.begin (method) -ida_typeinf.regobjvec_t.capacity (method) -ida_typeinf.regobjvec_t.clear (method) -ida_typeinf.regobjvec_t.empty (method) -ida_typeinf.regobjvec_t.end (method) -ida_typeinf.regobjvec_t.erase (method) -ida_typeinf.regobjvec_t.extract (method) -ida_typeinf.regobjvec_t.grow (method) -ida_typeinf.regobjvec_t.inject (method) -ida_typeinf.regobjvec_t.insert (method) -ida_typeinf.regobjvec_t.pop_back (method) -ida_typeinf.regobjvec_t.push_back (method) -ida_typeinf.regobjvec_t.qclear (method) -ida_typeinf.regobjvec_t.reserve (method) -ida_typeinf.regobjvec_t.resize (method) -ida_typeinf.regobjvec_t.size (method) -ida_typeinf.regobjvec_t.swap (method) -ida_typeinf.regobjvec_t.truncate (method) -ida_typeinf.remove_abi_opts (function) -ida_typeinf.remove_pointer (function) -ida_typeinf.remove_tinfo_pointer (function) -ida_typeinf.replace_ordinal_typerefs (function) -ida_typeinf.resolve_typedef (function) -ida_typeinf.rrel_t (class) -ida_typeinf.rrel_t.__init__ (method) -ida_typeinf.rrel_t.off (variable) -ida_typeinf.rrel_t.reg (variable) -ida_typeinf.save_tinfo (function) -ida_typeinf.scattered_aloc_t (class) -ida_typeinf.scattered_aloc_t.__init__ (method) -ida_typeinf.score_tinfo (function) -ida_typeinf.serialize_tinfo (function) -ida_typeinf.set_abi_name (function) -ida_typeinf.set_c_header_path (function) -ida_typeinf.set_c_macros (function) -ida_typeinf.set_compiler (function) -ida_typeinf.set_compiler_id (function) -ida_typeinf.set_compiler_string (function) -ida_typeinf.set_numbered_type (function) -ida_typeinf.set_tinfo_attr (function) -ida_typeinf.set_tinfo_attrs (function) -ida_typeinf.set_tinfo_property (function) -ida_typeinf.set_tinfo_property3 (function) -ida_typeinf.set_type_alias (function) -ida_typeinf.set_vftable_ea (function) -ida_typeinf.simd_info_t (class) -ida_typeinf.simd_info_t.__init__ (method) -ida_typeinf.simd_info_t.match_pattern (method) -ida_typeinf.simd_info_t.memtype (variable) -ida_typeinf.simd_info_t.name (variable) -ida_typeinf.simd_info_t.size (variable) -ida_typeinf.simd_info_t.tif (variable) -ida_typeinf.stkarg_area_info_t (class) -ida_typeinf.stkarg_area_info_t.__init__ (method) -ida_typeinf.stkarg_area_info_t.linkage_area (variable) -ida_typeinf.stkarg_area_info_t.shadow_size (variable) -ida_typeinf.stkarg_area_info_t.stkarg_offset (variable) -ida_typeinf.store_til (function) -ida_typeinf.switch_to_golang (function) -ida_typeinf.text_sink_t (class) -ida_typeinf.text_sink_t.__disown__ (method) -ida_typeinf.text_sink_t.__init__ (method) -ida_typeinf.text_sink_t._print (method) -ida_typeinf.til_symbol_t (class) -ida_typeinf.til_symbol_t.__init__ (method) -ida_typeinf.til_symbol_t.name (variable) -ida_typeinf.til_symbol_t.til (variable) -ida_typeinf.til_t (class) -ida_typeinf.til_t.__init__ (method) -ida_typeinf.til_t.base (method) -ida_typeinf.til_t.cc (variable) -ida_typeinf.til_t.desc (variable) -ida_typeinf.til_t.flags (variable) -ida_typeinf.til_t.is_dirty (method) -ida_typeinf.til_t.name (variable) -ida_typeinf.til_t.nbases (variable) -ida_typeinf.til_t.nrefs (variable) -ida_typeinf.til_t.nstreams (variable) -ida_typeinf.til_t.set_dirty (method) -ida_typeinf.til_t.streams (variable) -ida_typeinf.tinfo_t (class) -ida_typeinf.tinfo_t.__eq__ (method) -ida_typeinf.tinfo_t.__ge__ (method) -ida_typeinf.tinfo_t.__gt__ (method) -ida_typeinf.tinfo_t.__init__ (method) -ida_typeinf.tinfo_t.__le__ (method) -ida_typeinf.tinfo_t.__lt__ (method) -ida_typeinf.tinfo_t.__ne__ (method) -ida_typeinf.tinfo_t.__str__ (method) -ida_typeinf.tinfo_t._print (method) -ida_typeinf.tinfo_t.append_covered (method) -ida_typeinf.tinfo_t.calc_gaps (method) -ida_typeinf.tinfo_t.calc_purged_bytes (method) -ida_typeinf.tinfo_t.calc_score (method) -ida_typeinf.tinfo_t.calc_udt_aligns (method) -ida_typeinf.tinfo_t.change_sign (method) -ida_typeinf.tinfo_t.clear (method) -ida_typeinf.tinfo_t.clr_const (method) -ida_typeinf.tinfo_t.clr_const_volatile (method) -ida_typeinf.tinfo_t.clr_decl_const_volatile (method) -ida_typeinf.tinfo_t.clr_volatile (method) -ida_typeinf.tinfo_t.compare (method) -ida_typeinf.tinfo_t.compare_with (method) -ida_typeinf.tinfo_t.convert_array_to_ptr (method) -ida_typeinf.tinfo_t.copy (method) -ida_typeinf.tinfo_t.create_array (method) -ida_typeinf.tinfo_t.create_bitfield (method) -ida_typeinf.tinfo_t.create_enum (method) -ida_typeinf.tinfo_t.create_forward_decl (method) -ida_typeinf.tinfo_t.create_func (method) -ida_typeinf.tinfo_t.create_ptr (method) -ida_typeinf.tinfo_t.create_simple_type (method) -ida_typeinf.tinfo_t.create_typedef (method) -ida_typeinf.tinfo_t.create_udt (method) -ida_typeinf.tinfo_t.del_attr (method) -ida_typeinf.tinfo_t.del_attrs (method) -ida_typeinf.tinfo_t.deserialize (method) -ida_typeinf.tinfo_t.dstr (method) -ida_typeinf.tinfo_t.edit_array (method) -ida_typeinf.tinfo_t.edit_bitfield (method) -ida_typeinf.tinfo_t.edit_enum (method) -ida_typeinf.tinfo_t.edit_func (method) -ida_typeinf.tinfo_t.edit_ptr (method) -ida_typeinf.tinfo_t.edit_udt (method) -ida_typeinf.tinfo_t.empty (method) -ida_typeinf.tinfo_t.equals_to (method) -ida_typeinf.tinfo_t.find_udt_member (method) -ida_typeinf.tinfo_t.get_array_details (method) -ida_typeinf.tinfo_t.get_array_element (method) -ida_typeinf.tinfo_t.get_array_nelems (method) -ida_typeinf.tinfo_t.get_attr (method) -ida_typeinf.tinfo_t.get_attrs (method) -ida_typeinf.tinfo_t.get_bitfield_details (method) -ida_typeinf.tinfo_t.get_declalign (method) -ida_typeinf.tinfo_t.get_decltype (method) -ida_typeinf.tinfo_t.get_enum_base_type (method) -ida_typeinf.tinfo_t.get_enum_details (method) -ida_typeinf.tinfo_t.get_final_ordinal (method) -ida_typeinf.tinfo_t.get_final_type_name (method) -ida_typeinf.tinfo_t.get_func_details (method) -ida_typeinf.tinfo_t.get_methods (method) -ida_typeinf.tinfo_t.get_modifiers (method) -ida_typeinf.tinfo_t.get_named_type (method) -ida_typeinf.tinfo_t.get_nargs (method) -ida_typeinf.tinfo_t.get_next_type_name (method) -ida_typeinf.tinfo_t.get_nth_arg (method) -ida_typeinf.tinfo_t.get_numbered_type (method) -ida_typeinf.tinfo_t.get_onemember_type (method) -ida_typeinf.tinfo_t.get_ordinal (method) -ida_typeinf.tinfo_t.get_pointed_object (method) -ida_typeinf.tinfo_t.get_ptr_details (method) -ida_typeinf.tinfo_t.get_ptrarr_object (method) -ida_typeinf.tinfo_t.get_ptrarr_objsize (method) -ida_typeinf.tinfo_t.get_realtype (method) -ida_typeinf.tinfo_t.get_rettype (method) -ida_typeinf.tinfo_t.get_sign (method) -ida_typeinf.tinfo_t.get_size (method) -ida_typeinf.tinfo_t.get_stock (method) -ida_typeinf.tinfo_t.get_til (method) -ida_typeinf.tinfo_t.get_type_cmt (method) -ida_typeinf.tinfo_t.get_type_name (method) -ida_typeinf.tinfo_t.get_type_rptcmt (method) -ida_typeinf.tinfo_t.get_udt_details (method) -ida_typeinf.tinfo_t.get_udt_nmembers (method) -ida_typeinf.tinfo_t.get_unpadded_size (method) -ida_typeinf.tinfo_t.has_details (method) -ida_typeinf.tinfo_t.has_vftable (method) -ida_typeinf.tinfo_t.is_anonymous_udt (method) -ida_typeinf.tinfo_t.is_arithmetic (method) -ida_typeinf.tinfo_t.is_array (method) -ida_typeinf.tinfo_t.is_bitfield (method) -ida_typeinf.tinfo_t.is_bool (method) -ida_typeinf.tinfo_t.is_castable_to (method) -ida_typeinf.tinfo_t.is_char (method) -ida_typeinf.tinfo_t.is_complex (method) -ida_typeinf.tinfo_t.is_const (method) -ida_typeinf.tinfo_t.is_correct (method) -ida_typeinf.tinfo_t.is_decl_array (method) -ida_typeinf.tinfo_t.is_decl_bitfield (method) -ida_typeinf.tinfo_t.is_decl_bool (method) -ida_typeinf.tinfo_t.is_decl_char (method) -ida_typeinf.tinfo_t.is_decl_complex (method) -ida_typeinf.tinfo_t.is_decl_const (method) -ida_typeinf.tinfo_t.is_decl_double (method) -ida_typeinf.tinfo_t.is_decl_enum (method) -ida_typeinf.tinfo_t.is_decl_float (method) -ida_typeinf.tinfo_t.is_decl_floating (method) -ida_typeinf.tinfo_t.is_decl_func (method) -ida_typeinf.tinfo_t.is_decl_int (method) -ida_typeinf.tinfo_t.is_decl_int128 (method) -ida_typeinf.tinfo_t.is_decl_int16 (method) -ida_typeinf.tinfo_t.is_decl_int32 (method) -ida_typeinf.tinfo_t.is_decl_int64 (method) -ida_typeinf.tinfo_t.is_decl_last (method) -ida_typeinf.tinfo_t.is_decl_ldouble (method) -ida_typeinf.tinfo_t.is_decl_paf (method) -ida_typeinf.tinfo_t.is_decl_partial (method) -ida_typeinf.tinfo_t.is_decl_ptr (method) -ida_typeinf.tinfo_t.is_decl_struct (method) -ida_typeinf.tinfo_t.is_decl_sue (method) -ida_typeinf.tinfo_t.is_decl_tbyte (method) -ida_typeinf.tinfo_t.is_decl_typedef (method) -ida_typeinf.tinfo_t.is_decl_uchar (method) -ida_typeinf.tinfo_t.is_decl_udt (method) -ida_typeinf.tinfo_t.is_decl_uint (method) -ida_typeinf.tinfo_t.is_decl_uint128 (method) -ida_typeinf.tinfo_t.is_decl_uint16 (method) -ida_typeinf.tinfo_t.is_decl_uint32 (method) -ida_typeinf.tinfo_t.is_decl_uint64 (method) -ida_typeinf.tinfo_t.is_decl_union (method) -ida_typeinf.tinfo_t.is_decl_unknown (method) -ida_typeinf.tinfo_t.is_decl_void (method) -ida_typeinf.tinfo_t.is_decl_volatile (method) -ida_typeinf.tinfo_t.is_double (method) -ida_typeinf.tinfo_t.is_empty_udt (method) -ida_typeinf.tinfo_t.is_enum (method) -ida_typeinf.tinfo_t.is_ext_arithmetic (method) -ida_typeinf.tinfo_t.is_ext_integral (method) -ida_typeinf.tinfo_t.is_float (method) -ida_typeinf.tinfo_t.is_floating (method) -ida_typeinf.tinfo_t.is_forward_decl (method) -ida_typeinf.tinfo_t.is_from_subtil (method) -ida_typeinf.tinfo_t.is_func (method) -ida_typeinf.tinfo_t.is_funcptr (method) -ida_typeinf.tinfo_t.is_high_func (method) -ida_typeinf.tinfo_t.is_int (method) -ida_typeinf.tinfo_t.is_int128 (method) -ida_typeinf.tinfo_t.is_int16 (method) -ida_typeinf.tinfo_t.is_int32 (method) -ida_typeinf.tinfo_t.is_int64 (method) -ida_typeinf.tinfo_t.is_integral (method) -ida_typeinf.tinfo_t.is_ldouble (method) -ida_typeinf.tinfo_t.is_manually_castable_to (method) -ida_typeinf.tinfo_t.is_one_fpval (method) -ida_typeinf.tinfo_t.is_paf (method) -ida_typeinf.tinfo_t.is_partial (method) -ida_typeinf.tinfo_t.is_ptr (method) -ida_typeinf.tinfo_t.is_ptr_or_array (method) -ida_typeinf.tinfo_t.is_purging_cc (method) -ida_typeinf.tinfo_t.is_pvoid (method) -ida_typeinf.tinfo_t.is_scalar (method) -ida_typeinf.tinfo_t.is_shifted_ptr (method) -ida_typeinf.tinfo_t.is_signed (method) -ida_typeinf.tinfo_t.is_small_udt (method) -ida_typeinf.tinfo_t.is_sse_type (method) -ida_typeinf.tinfo_t.is_struct (method) -ida_typeinf.tinfo_t.is_sue (method) -ida_typeinf.tinfo_t.is_tbyte (method) -ida_typeinf.tinfo_t.is_typedef (method) -ida_typeinf.tinfo_t.is_typeref (method) -ida_typeinf.tinfo_t.is_uchar (method) -ida_typeinf.tinfo_t.is_udt (method) -ida_typeinf.tinfo_t.is_uint (method) -ida_typeinf.tinfo_t.is_uint128 (method) -ida_typeinf.tinfo_t.is_uint16 (method) -ida_typeinf.tinfo_t.is_uint32 (method) -ida_typeinf.tinfo_t.is_uint64 (method) -ida_typeinf.tinfo_t.is_union (method) -ida_typeinf.tinfo_t.is_unknown (method) -ida_typeinf.tinfo_t.is_unsigned (method) -ida_typeinf.tinfo_t.is_user_cc (method) -ida_typeinf.tinfo_t.is_vararg_cc (method) -ida_typeinf.tinfo_t.is_varstruct (method) -ida_typeinf.tinfo_t.is_vftable (method) -ida_typeinf.tinfo_t.is_void (method) -ida_typeinf.tinfo_t.is_volatile (method) -ida_typeinf.tinfo_t.is_well_defined (method) -ida_typeinf.tinfo_t.present (method) -ida_typeinf.tinfo_t.read_bitfield_value (method) -ida_typeinf.tinfo_t.remove_ptr_or_array (method) -ida_typeinf.tinfo_t.requires_qualifier (method) -ida_typeinf.tinfo_t.serialize (method) -ida_typeinf.tinfo_t.set_attr (method) -ida_typeinf.tinfo_t.set_attrs (method) -ida_typeinf.tinfo_t.set_const (method) -ida_typeinf.tinfo_t.set_declalign (method) -ida_typeinf.tinfo_t.set_methods (method) -ida_typeinf.tinfo_t.set_modifiers (method) -ida_typeinf.tinfo_t.set_named_type (method) -ida_typeinf.tinfo_t.set_numbered_type (method) -ida_typeinf.tinfo_t.set_symbol_type (method) -ida_typeinf.tinfo_t.set_type_cmt (method) -ida_typeinf.tinfo_t.set_volatile (method) -ida_typeinf.tinfo_t.swap (method) -ida_typeinf.tinfo_t.write_bitfield_value (method) -ida_typeinf.tinfo_t_get_stock (function) -ida_typeinf.tinfo_visitor_t (class) -ida_typeinf.tinfo_visitor_t.__disown__ (method) -ida_typeinf.tinfo_visitor_t.__init__ (method) -ida_typeinf.tinfo_visitor_t.apply_to (method) -ida_typeinf.tinfo_visitor_t.prune_now (method) -ida_typeinf.tinfo_visitor_t.state (variable) -ida_typeinf.tinfo_visitor_t.visit_type (method) -ida_typeinf.type_attr_t (class) -ida_typeinf.type_attr_t.__ge__ (method) -ida_typeinf.type_attr_t.__init__ (method) -ida_typeinf.type_attr_t.__lt__ (method) -ida_typeinf.type_attr_t.key (variable) -ida_typeinf.type_attr_t.value (variable) -ida_typeinf.type_attrs_t (class) -ida_typeinf.type_attrs_t.__getitem__ (method) -ida_typeinf.type_attrs_t.__init__ (method) -ida_typeinf.type_attrs_t.__len__ (method) -ida_typeinf.type_attrs_t.__setitem__ (method) -ida_typeinf.type_attrs_t.at (method) -ida_typeinf.type_attrs_t.begin (method) -ida_typeinf.type_attrs_t.capacity (method) -ida_typeinf.type_attrs_t.clear (method) -ida_typeinf.type_attrs_t.empty (method) -ida_typeinf.type_attrs_t.end (method) -ida_typeinf.type_attrs_t.erase (method) -ida_typeinf.type_attrs_t.extract (method) -ida_typeinf.type_attrs_t.grow (method) -ida_typeinf.type_attrs_t.inject (method) -ida_typeinf.type_attrs_t.insert (method) -ida_typeinf.type_attrs_t.pop_back (method) -ida_typeinf.type_attrs_t.push_back (method) -ida_typeinf.type_attrs_t.qclear (method) -ida_typeinf.type_attrs_t.reserve (method) -ida_typeinf.type_attrs_t.resize (method) -ida_typeinf.type_attrs_t.size (method) -ida_typeinf.type_attrs_t.swap (method) -ida_typeinf.type_attrs_t.truncate (method) -ida_typeinf.type_mods_t (class) -ida_typeinf.type_mods_t.__init__ (method) -ida_typeinf.type_mods_t.clear (method) -ida_typeinf.type_mods_t.cmt (variable) -ida_typeinf.type_mods_t.flags (variable) -ida_typeinf.type_mods_t.has_cmt (method) -ida_typeinf.type_mods_t.has_info (method) -ida_typeinf.type_mods_t.has_name (method) -ida_typeinf.type_mods_t.has_type (method) -ida_typeinf.type_mods_t.name (variable) -ida_typeinf.type_mods_t.set_new_cmt (method) -ida_typeinf.type_mods_t.set_new_name (method) -ida_typeinf.type_mods_t.set_new_type (method) -ida_typeinf.type_mods_t.type (variable) -ida_typeinf.type_signed (variable) -ida_typeinf.type_unsigned (variable) -ida_typeinf.typedef_type_data_t (class) -ida_typeinf.typedef_type_data_t.__init__ (method) -ida_typeinf.typedef_type_data_t.is_ordref (variable) -ida_typeinf.typedef_type_data_t.name (variable) -ida_typeinf.typedef_type_data_t.ordinal (variable) -ida_typeinf.typedef_type_data_t.resolve (variable) -ida_typeinf.typedef_type_data_t.swap (method) -ida_typeinf.typedef_type_data_t.til (variable) -ida_typeinf.udt_member_t (class) -ida_typeinf.udt_member_t.__eq__ (method) -ida_typeinf.udt_member_t.__init__ (method) -ida_typeinf.udt_member_t.__lt__ (method) -ida_typeinf.udt_member_t.__ne__ (method) -ida_typeinf.udt_member_t.begin (method) -ida_typeinf.udt_member_t.clr_baseclass (method) -ida_typeinf.udt_member_t.clr_method (method) -ida_typeinf.udt_member_t.clr_unaligned (method) -ida_typeinf.udt_member_t.clr_vftable (method) -ida_typeinf.udt_member_t.clr_virtbase (method) -ida_typeinf.udt_member_t.cmt (variable) -ida_typeinf.udt_member_t.effalign (variable) -ida_typeinf.udt_member_t.end (method) -ida_typeinf.udt_member_t.fda (variable) -ida_typeinf.udt_member_t.is_anonymous_udm (method) -ida_typeinf.udt_member_t.is_baseclass (method) -ida_typeinf.udt_member_t.is_bitfield (method) -ida_typeinf.udt_member_t.is_gap (method) -ida_typeinf.udt_member_t.is_method (method) -ida_typeinf.udt_member_t.is_rptcmt (method) -ida_typeinf.udt_member_t.is_unaligned (method) -ida_typeinf.udt_member_t.is_vftable (method) -ida_typeinf.udt_member_t.is_virtbase (method) -ida_typeinf.udt_member_t.is_zero_bitfield (method) -ida_typeinf.udt_member_t.make_gap (method) -ida_typeinf.udt_member_t.name (variable) -ida_typeinf.udt_member_t.offset (variable) -ida_typeinf.udt_member_t.repr (variable) -ida_typeinf.udt_member_t.set_baseclass (method) -ida_typeinf.udt_member_t.set_method (method) -ida_typeinf.udt_member_t.set_unaligned (method) -ida_typeinf.udt_member_t.set_vftable (method) -ida_typeinf.udt_member_t.set_virtbase (method) -ida_typeinf.udt_member_t.size (variable) -ida_typeinf.udt_member_t.swap (method) -ida_typeinf.udt_member_t.tafld_bits (variable) -ida_typeinf.udt_member_t.type (variable) -ida_typeinf.udt_member_t__make_gap (function) -ida_typeinf.udt_type_data_t (class) -ida_typeinf.udt_type_data_t.__init__ (method) -ida_typeinf.udt_type_data_t.effalign (variable) -ida_typeinf.udt_type_data_t.find_member (method) -ida_typeinf.udt_type_data_t.get_best_fit_member (method) -ida_typeinf.udt_type_data_t.is_cppobj (method) -ida_typeinf.udt_type_data_t.is_last_baseclass (method) -ida_typeinf.udt_type_data_t.is_msstruct (method) -ida_typeinf.udt_type_data_t.is_unaligned (method) -ida_typeinf.udt_type_data_t.is_union (variable) -ida_typeinf.udt_type_data_t.is_vftable (method) -ida_typeinf.udt_type_data_t.npos (variable) -ida_typeinf.udt_type_data_t.pack (variable) -ida_typeinf.udt_type_data_t.sda (variable) -ida_typeinf.udt_type_data_t.set_vftable (method) -ida_typeinf.udt_type_data_t.swap (method) -ida_typeinf.udt_type_data_t.taudt_bits (variable) -ida_typeinf.udt_type_data_t.total_size (variable) -ida_typeinf.udt_type_data_t.unpadded_size (variable) -ida_typeinf.udt_type_data_t.version (variable) -ida_typeinf.udt_type_data_t__find_member (function) -ida_typeinf.udt_type_data_t__get_best_fit_member (function) -ida_typeinf.udtmembervec_t (class) -ida_typeinf.udtmembervec_t.__init__ (method) -ida_typeinf.udtmembervec_template_t (class) -ida_typeinf.udtmembervec_template_t.__eq__ (method) -ida_typeinf.udtmembervec_template_t.__getitem__ (method) -ida_typeinf.udtmembervec_template_t.__init__ (method) -ida_typeinf.udtmembervec_template_t.__len__ (method) -ida_typeinf.udtmembervec_template_t.__ne__ (method) -ida_typeinf.udtmembervec_template_t.__setitem__ (method) -ida_typeinf.udtmembervec_template_t._del (method) -ida_typeinf.udtmembervec_template_t.add_unique (method) -ida_typeinf.udtmembervec_template_t.at (method) -ida_typeinf.udtmembervec_template_t.begin (method) -ida_typeinf.udtmembervec_template_t.capacity (method) -ida_typeinf.udtmembervec_template_t.clear (method) -ida_typeinf.udtmembervec_template_t.empty (method) -ida_typeinf.udtmembervec_template_t.end (method) -ida_typeinf.udtmembervec_template_t.erase (method) -ida_typeinf.udtmembervec_template_t.extract (method) -ida_typeinf.udtmembervec_template_t.find (method) -ida_typeinf.udtmembervec_template_t.grow (method) -ida_typeinf.udtmembervec_template_t.has (method) -ida_typeinf.udtmembervec_template_t.inject (method) -ida_typeinf.udtmembervec_template_t.insert (method) -ida_typeinf.udtmembervec_template_t.pop_back (method) -ida_typeinf.udtmembervec_template_t.push_back (method) -ida_typeinf.udtmembervec_template_t.qclear (method) -ida_typeinf.udtmembervec_template_t.reserve (method) -ida_typeinf.udtmembervec_template_t.resize (method) -ida_typeinf.udtmembervec_template_t.size (method) -ida_typeinf.udtmembervec_template_t.swap (method) -ida_typeinf.udtmembervec_template_t.truncate (method) -ida_typeinf.unpack_idcobj_from_bv (function) -ida_typeinf.unpack_idcobj_from_idb (function) -ida_typeinf.unpack_object_from_bv (function) -ida_typeinf.unpack_object_from_idb (function) -ida_typeinf.use_golang_cc (function) -ida_typeinf.valstr_t (class) -ida_typeinf.valstr_t.__init__ (method) -ida_typeinf.valstr_t.info (variable) -ida_typeinf.valstr_t.length (variable) -ida_typeinf.valstr_t.members (variable) -ida_typeinf.valstr_t.oneline (variable) -ida_typeinf.valstr_t.props (variable) -ida_typeinf.valstrs_t (class) -ida_typeinf.valstrs_t.__init__ (method) -ida_typeinf.valstrvec_t (class) -ida_typeinf.valstrvec_t.__getitem__ (method) -ida_typeinf.valstrvec_t.__init__ (method) -ida_typeinf.valstrvec_t.__len__ (method) -ida_typeinf.valstrvec_t.__setitem__ (method) -ida_typeinf.valstrvec_t.at (method) -ida_typeinf.valstrvec_t.begin (method) -ida_typeinf.valstrvec_t.capacity (method) -ida_typeinf.valstrvec_t.clear (method) -ida_typeinf.valstrvec_t.empty (method) -ida_typeinf.valstrvec_t.end (method) -ida_typeinf.valstrvec_t.erase (method) -ida_typeinf.valstrvec_t.extract (method) -ida_typeinf.valstrvec_t.grow (method) -ida_typeinf.valstrvec_t.inject (method) -ida_typeinf.valstrvec_t.insert (method) -ida_typeinf.valstrvec_t.pop_back (method) -ida_typeinf.valstrvec_t.push_back (method) -ida_typeinf.valstrvec_t.qclear (method) -ida_typeinf.valstrvec_t.reserve (method) -ida_typeinf.valstrvec_t.resize (method) -ida_typeinf.valstrvec_t.size (method) -ida_typeinf.valstrvec_t.swap (method) -ida_typeinf.valstrvec_t.truncate (method) -ida_typeinf.verify_argloc (function) -ida_typeinf.verify_tinfo (function) -ida_typeinf.visit_subtypes (function) -ida_typeinf.write_tinfo_bitfield_value (function) -ida_ua (module) -ida_ua.FCBF_CONT (variable) -ida_ua.FCBF_DELIM (variable) -ida_ua.FCBF_ERR_REPL (variable) -ida_ua.FCBF_FF_LIT (variable) -ida_ua.INSN_64BIT (variable) -ida_ua.INSN_MACRO (variable) -ida_ua.INSN_MODMAC (variable) -ida_ua.OF_NO_BASE_DISP (variable) -ida_ua.OF_NUMBER (variable) -ida_ua.OF_OUTER_DISP (variable) -ida_ua.OF_SHOW (variable) -ida_ua.OOFS_IFSIGN (variable) -ida_ua.OOFS_NEEDSIGN (variable) -ida_ua.OOFS_NOSIGN (variable) -ida_ua.OOFW_16 (variable) -ida_ua.OOFW_24 (variable) -ida_ua.OOFW_32 (variable) -ida_ua.OOFW_64 (variable) -ida_ua.OOFW_8 (variable) -ida_ua.OOFW_IMM (variable) -ida_ua.OOF_ADDR (variable) -ida_ua.OOF_ANYSERIAL (variable) -ida_ua.OOF_NOBNOT (variable) -ida_ua.OOF_NUMBER (variable) -ida_ua.OOF_OUTER (variable) -ida_ua.OOF_SIGNED (variable) -ida_ua.OOF_SIGNMASK (variable) -ida_ua.OOF_SPACES (variable) -ida_ua.OOF_WIDTHMASK (variable) -ida_ua.OOF_ZSTROFF (variable) -ida_ua.PACK_FORM_DEF (variable) -ida_ua.STKVAR_VALID_SIZE (variable) -ida_ua.calc_dataseg (function) -ida_ua.can_decode (function) -ida_ua.construct_macro (function) -ida_ua.construct_macro2 (function) -ida_ua.create_insn (function) -ida_ua.create_outctx (function) -ida_ua.decode_insn (function) -ida_ua.decode_preceding_insn (function) -ida_ua.decode_prev_insn (function) -ida_ua.dt_bitfild (variable) -ida_ua.dt_byte (variable) -ida_ua.dt_byte16 (variable) -ida_ua.dt_byte32 (variable) -ida_ua.dt_byte64 (variable) -ida_ua.dt_code (variable) -ida_ua.dt_double (variable) -ida_ua.dt_dword (variable) -ida_ua.dt_float (variable) -ida_ua.dt_fword (variable) -ida_ua.dt_half (variable) -ida_ua.dt_ldbl (variable) -ida_ua.dt_packreal (variable) -ida_ua.dt_qword (variable) -ida_ua.dt_string (variable) -ida_ua.dt_tbyte (variable) -ida_ua.dt_unicode (variable) -ida_ua.dt_void (variable) -ida_ua.dt_word (variable) -ida_ua.get_dtype_by_size (function) -ida_ua.get_dtype_flag (function) -ida_ua.get_dtype_size (function) -ida_ua.get_immvals (function) -ida_ua.get_lookback (function) -ida_ua.get_printable_immvals (function) -ida_ua.insn_add_cref (function) -ida_ua.insn_add_dref (function) -ida_ua.insn_add_off_drefs (function) -ida_ua.insn_create_stkvar (function) -ida_ua.insn_t (class) -ida_ua.insn_t.__get_auxpref__ (method) -ida_ua.insn_t.__get_operand__ (method) -ida_ua.insn_t.__get_ops__ (method) -ida_ua.insn_t.__getitem__ (method) -ida_ua.insn_t.__init__ (method) -ida_ua.insn_t.__iter__ (method) -ida_ua.insn_t.__set_auxpref__ (method) -ida_ua.insn_t.add_cref (method) -ida_ua.insn_t.add_dref (method) -ida_ua.insn_t.add_off_drefs (method) -ida_ua.insn_t.assign (method) -ida_ua.insn_t.auxpref (variable) -ida_ua.insn_t.create_op_data (method) -ida_ua.insn_t.create_stkvar (method) -ida_ua.insn_t.cs (variable) -ida_ua.insn_t.ea (variable) -ida_ua.insn_t.flags (variable) -ida_ua.insn_t.get_canon_feature (method) -ida_ua.insn_t.get_canon_mnem (method) -ida_ua.insn_t.get_next_byte (method) -ida_ua.insn_t.get_next_dword (method) -ida_ua.insn_t.get_next_qword (method) -ida_ua.insn_t.get_next_word (method) -ida_ua.insn_t.insnpref (variable) -ida_ua.insn_t.ip (variable) -ida_ua.insn_t.is_64bit (method) -ida_ua.insn_t.is_canon_insn (method) -ida_ua.insn_t.is_macro (method) -ida_ua.insn_t.itype (variable) -ida_ua.insn_t.ops (variable) -ida_ua.insn_t.segpref (variable) -ida_ua.insn_t.size (variable) -ida_ua.insn_t__from_ptrval__ (function) -ida_ua.is_floating_dtype (function) -ida_ua.macro_constructor_t (class) -ida_ua.macro_constructor_t.__disown__ (method) -ida_ua.macro_constructor_t.__init__ (method) -ida_ua.macro_constructor_t.build_macro (method) -ida_ua.map_code_ea (function) -ida_ua.map_data_ea (function) -ida_ua.map_ea (function) -ida_ua.o_displ (variable) -ida_ua.o_far (variable) -ida_ua.o_idpspec0 (variable) -ida_ua.o_idpspec1 (variable) -ida_ua.o_idpspec2 (variable) -ida_ua.o_idpspec3 (variable) -ida_ua.o_idpspec4 (variable) -ida_ua.o_idpspec5 (variable) -ida_ua.o_imm (variable) -ida_ua.o_mem (variable) -ida_ua.o_near (variable) -ida_ua.o_phrase (variable) -ida_ua.o_reg (variable) -ida_ua.o_void (variable) -ida_ua.op_t (class) -ida_ua.op_t.__get_addr__ (method) -ida_ua.op_t.__get_reg_phrase__ (method) -ida_ua.op_t.__get_specval__ (method) -ida_ua.op_t.__get_value64__ (method) -ida_ua.op_t.__get_value__ (method) -ida_ua.op_t.__init__ (method) -ida_ua.op_t.__set_addr__ (method) -ida_ua.op_t.__set_reg_phrase__ (method) -ida_ua.op_t.__set_specval__ (method) -ida_ua.op_t.__set_value64__ (method) -ida_ua.op_t.__set_value__ (method) -ida_ua.op_t.addr (variable) -ida_ua.op_t.assign (method) -ida_ua.op_t.clr_shown (method) -ida_ua.op_t.dtype (variable) -ida_ua.op_t.flags (variable) -ida_ua.op_t.has_reg (method) -ida_ua.op_t.is_imm (method) -ida_ua.op_t.is_reg (method) -ida_ua.op_t.n (variable) -ida_ua.op_t.offb (variable) -ida_ua.op_t.offo (variable) -ida_ua.op_t.phrase (variable) -ida_ua.op_t.reg (variable) -ida_ua.op_t.set_shown (method) -ida_ua.op_t.shown (method) -ida_ua.op_t.specval (variable) -ida_ua.op_t.type (variable) -ida_ua.op_t.value (variable) -ida_ua.op_t__from_ptrval__ (function) -ida_ua.operands_array (class) -ida_ua.operands_array.__getitem__ (method) -ida_ua.operands_array.__init__ (method) -ida_ua.operands_array.__len__ (method) -ida_ua.operands_array.__setitem__ (method) -ida_ua.operands_array._get_bytes (method) -ida_ua.operands_array._set_bytes (method) -ida_ua.outctx_base_t (class) -ida_ua.outctx_base_t.__init__ (method) -ida_ua.outctx_base_t.close_comment (method) -ida_ua.outctx_base_t.clr_gen_label (method) -ida_ua.outctx_base_t.display_voids (method) -ida_ua.outctx_base_t.flush_buf (method) -ida_ua.outctx_base_t.flush_outbuf (method) -ida_ua.outctx_base_t.forbid_annotations (method) -ida_ua.outctx_base_t.force_code (method) -ida_ua.outctx_base_t.gen_block_cmt (method) -ida_ua.outctx_base_t.gen_border_line (method) -ida_ua.outctx_base_t.gen_cmt_line (method) -ida_ua.outctx_base_t.gen_collapsed_line (method) -ida_ua.outctx_base_t.gen_empty_line (method) -ida_ua.outctx_base_t.gen_empty_line_without_annotations (method) -ida_ua.outctx_base_t.gen_printf (method) -ida_ua.outctx_base_t.gen_xref_lines (method) -ida_ua.outctx_base_t.getF (method) -ida_ua.outctx_base_t.get_stkvar (method) -ida_ua.outctx_base_t.init_lines_array (method) -ida_ua.outctx_base_t.multiline (method) -ida_ua.outctx_base_t.only_main_line (method) -ida_ua.outctx_base_t.out_addr_tag (method) -ida_ua.outctx_base_t.out_btoa (method) -ida_ua.outctx_base_t.out_char (method) -ida_ua.outctx_base_t.out_chars (method) -ida_ua.outctx_base_t.out_colored_register_line (method) -ida_ua.outctx_base_t.out_keyword (method) -ida_ua.outctx_base_t.out_line (method) -ida_ua.outctx_base_t.out_long (method) -ida_ua.outctx_base_t.out_name_expr (method) -ida_ua.outctx_base_t.out_printf (method) -ida_ua.outctx_base_t.out_register (method) -ida_ua.outctx_base_t.out_spaces (method) -ida_ua.outctx_base_t.out_symbol (method) -ida_ua.outctx_base_t.out_tagoff (method) -ida_ua.outctx_base_t.out_tagon (method) -ida_ua.outctx_base_t.out_value (method) -ida_ua.outctx_base_t.print_label_now (method) -ida_ua.outctx_base_t.restore_ctxflags (method) -ida_ua.outctx_base_t.retrieve_cmt (method) -ida_ua.outctx_base_t.retrieve_name (method) -ida_ua.outctx_base_t.set_comment_addr (method) -ida_ua.outctx_base_t.set_dlbind_opnd (method) -ida_ua.outctx_base_t.set_gen_cmt (method) -ida_ua.outctx_base_t.set_gen_demangled_label (method) -ida_ua.outctx_base_t.set_gen_label (method) -ida_ua.outctx_base_t.set_gen_xrefs (method) -ida_ua.outctx_base_t.setup_outctx (method) -ida_ua.outctx_base_t.stack_view (method) -ida_ua.outctx_base_t.term_outctx (method) -ida_ua.outctx_base_t__from_ptrval__ (function) -ida_ua.outctx_t (class) -ida_ua.outctx_t.__init__ (method) -ida_ua.outctx_t.gen_func_footer (method) -ida_ua.outctx_t.gen_func_header (method) -ida_ua.outctx_t.gen_header (method) -ida_ua.outctx_t.gen_header_extra (method) -ida_ua.outctx_t.gen_xref_lines (method) -ida_ua.outctx_t.out_btoa (method) -ida_ua.outctx_t.out_custom_mnem (method) -ida_ua.outctx_t.out_data (method) -ida_ua.outctx_t.out_fcref_names (method) -ida_ua.outctx_t.out_immchar_cmts (method) -ida_ua.outctx_t.out_mnem (method) -ida_ua.outctx_t.out_mnemonic (method) -ida_ua.outctx_t.out_one_operand (method) -ida_ua.outctx_t.out_specea (method) -ida_ua.outctx_t.retrieve_cmt (method) -ida_ua.outctx_t.retrieve_name (method) -ida_ua.outctx_t.set_bin_state (method) -ida_ua.outctx_t.setup_outctx (method) -ida_ua.outctx_t.term_outctx (method) -ida_ua.outctx_t__from_ptrval__ (function) -ida_ua.print_insn_mnem (function) -ida_ua.print_operand (function) -ida_xref (module) -ida_xref.XREF_ALL (variable) -ida_xref.XREF_BASE (variable) -ida_xref.XREF_DATA (variable) -ida_xref.XREF_FAR (variable) -ida_xref.XREF_MASK (variable) -ida_xref.XREF_PASTEND (variable) -ida_xref.XREF_TAIL (variable) -ida_xref.XREF_USER (variable) -ida_xref.add_cref (function) -ida_xref.add_dref (function) -ida_xref.calc_switch_cases (function) -ida_xref.cases_and_targets_t (class) -ida_xref.cases_and_targets_t.__init__ (method) -ida_xref.casevec_t (class) -ida_xref.casevec_t.__eq__ (method) -ida_xref.casevec_t.__getitem__ (method) -ida_xref.casevec_t.__init__ (method) -ida_xref.casevec_t.__len__ (method) -ida_xref.casevec_t.__ne__ (method) -ida_xref.casevec_t.__setitem__ (method) -ida_xref.casevec_t._del (method) -ida_xref.casevec_t.add_unique (method) -ida_xref.casevec_t.at (method) -ida_xref.casevec_t.begin (method) -ida_xref.casevec_t.capacity (method) -ida_xref.casevec_t.clear (method) -ida_xref.casevec_t.empty (method) -ida_xref.casevec_t.end (method) -ida_xref.casevec_t.erase (method) -ida_xref.casevec_t.extract (method) -ida_xref.casevec_t.find (method) -ida_xref.casevec_t.grow (method) -ida_xref.casevec_t.has (method) -ida_xref.casevec_t.inject (method) -ida_xref.casevec_t.insert (method) -ida_xref.casevec_t.pop_back (method) -ida_xref.casevec_t.push_back (method) -ida_xref.casevec_t.qclear (method) -ida_xref.casevec_t.reserve (method) -ida_xref.casevec_t.resize (method) -ida_xref.casevec_t.size (method) -ida_xref.casevec_t.swap (method) -ida_xref.casevec_t.truncate (method) -ida_xref.create_switch_table (function) -ida_xref.create_switch_xrefs (function) -ida_xref.del_cref (function) -ida_xref.del_dref (function) -ida_xref.delete_switch_table (function) -ida_xref.dr_I (variable) -ida_xref.dr_O (variable) -ida_xref.dr_R (variable) -ida_xref.dr_S (variable) -ida_xref.dr_T (variable) -ida_xref.dr_U (variable) -ida_xref.dr_W (variable) -ida_xref.fl_CF (variable) -ida_xref.fl_CN (variable) -ida_xref.fl_F (variable) -ida_xref.fl_JF (variable) -ida_xref.fl_JN (variable) -ida_xref.fl_U (variable) -ida_xref.fl_USobsolete (variable) -ida_xref.get_first_cref_from (function) -ida_xref.get_first_cref_to (function) -ida_xref.get_first_dref_from (function) -ida_xref.get_first_dref_to (function) -ida_xref.get_first_fcref_from (function) -ida_xref.get_first_fcref_to (function) -ida_xref.get_next_cref_from (function) -ida_xref.get_next_cref_to (function) -ida_xref.get_next_dref_from (function) -ida_xref.get_next_dref_to (function) -ida_xref.get_next_fcref_from (function) -ida_xref.get_next_fcref_to (function) -ida_xref.has_external_refs (function) -ida_xref.xrefblk_t (class) -ida_xref.xrefblk_t.__init__ (method) -ida_xref.xrefblk_t.crefs_from (method) -ida_xref.xrefblk_t.crefs_to (method) -ida_xref.xrefblk_t.drefs_from (method) -ida_xref.xrefblk_t.drefs_to (method) -ida_xref.xrefblk_t.fcrefs_from (method) -ida_xref.xrefblk_t.fcrefs_to (method) -ida_xref.xrefblk_t.first_from (method) -ida_xref.xrefblk_t.first_to (method) -ida_xref.xrefblk_t.iscode (variable) -ida_xref.xrefblk_t.next_from (method) -ida_xref.xrefblk_t.next_to (method) -ida_xref.xrefblk_t.refs_from (method) -ida_xref.xrefblk_t.refs_from._copy_xref (function) -ida_xref.xrefblk_t.refs_to (method) -ida_xref.xrefblk_t.refs_to._copy_xref (function) -ida_xref.xrefblk_t.to (variable) -ida_xref.xrefblk_t.type (variable) -ida_xref.xrefblk_t.user (variable) -ida_xref.xrefchar (function) diff --git a/api_contents_pro.full b/api_contents_pro.full deleted file mode 100644 index 00e5545..0000000 --- a/api_contents_pro.full +++ /dev/null @@ -1,67968 +0,0 @@ -ida_hexrays (module) - array used for translating cexpr_t->op type to their names. - -ida_hexrays.ACFL_BLKOPT (variable) - perform interblock transformations - -ida_hexrays.ACFL_GLBDEL (variable) - perform dead code eliminition - -ida_hexrays.ACFL_GLBPROP (variable) - perform global propagation - -ida_hexrays.ACFL_GUESS (variable) - may guess calling conventions - -ida_hexrays.ACFL_LOCOPT (variable) - perform local propagation (requires ACFL_BLKOPT) - -ida_hexrays.ALLOW_UNUSED_LABELS (variable) - Unused labels are permitted. - -ida_hexrays.ANCHOR_BLKCMT (variable) - block comment (for ctree items) - -ida_hexrays.ANCHOR_CITEM (variable) - c-tree item - -ida_hexrays.ANCHOR_ITP (variable) - item type preciser - -ida_hexrays.ANCHOR_LVAR (variable) - declaration of local variable - -ida_hexrays.ANY_FPSIZE (variable) - any size of floating operand is permitted - -ida_hexrays.ANY_REGSIZE (variable) - any register size is permitted - -ida_hexrays.BLT_0WAY (variable) - does not have successors (tail is a noret function) - -ida_hexrays.BLT_1WAY (variable) - passes execution to one block (regular or goto block) - -ida_hexrays.BLT_2WAY (variable) - passes execution to two blocks (conditional jump) - -ida_hexrays.BLT_NONE (variable) - unknown block type - -ida_hexrays.BLT_NWAY (variable) - passes execution to many blocks (switch idiom) - -ida_hexrays.BLT_STOP (variable) - stops execution regularly (must be the last block) - -ida_hexrays.BLT_XTRN (variable) - external block (out of function address) - -ida_hexrays.CALC_CURLY_BRACES (variable) - print curly braces if necessary - -ida_hexrays.CFL_FINAL (variable) - call type is final, should not be changed - -ida_hexrays.CFL_HELPER (variable) - created from a decompiler helper function - -ida_hexrays.CFL_NORET (variable) - call does not return - -ida_hexrays.CFS_BOUNDS (variable) - 'eamap' and 'boundaries' are ready - -ida_hexrays.CFS_LOCKED (variable) - cfunc is temporarily locked - -ida_hexrays.CFS_LVARS_HIDDEN (variable) - local variable definitions are collapsed - -ida_hexrays.CFS_TEXT (variable) - 'sv' is ready (and hdrlines) - -ida_hexrays.CHF_FAKE (variable) - fake chain created by widen_chains() - -ida_hexrays.CHF_INITED (variable) - is chain initialized? (valid only after lvar allocation) - -ida_hexrays.CHF_OVER (variable) - overlapped chain - -ida_hexrays.CHF_PASSTHRU (variable) - pass-thru chain, must use the input variable to the block - -ida_hexrays.CHF_REPLACED (variable) - chain operands have been replaced? - -ida_hexrays.CHF_TERM (variable) - terminating chain; the variable does not survive across the block - -ida_hexrays.CIT_COLLAPSED (variable) - display ctree item in collapsed form - -ida_hexrays.CMAT_BUILT (variable) - just generated - -ida_hexrays.CMAT_CASTED (variable) - added necessary casts - -ida_hexrays.CMAT_CPA (variable) - corrected pointer arithmetic - -ida_hexrays.CMAT_FINAL (variable) - ready-to-use - -ida_hexrays.CMAT_NICE (variable) - nicefied expressions - -ida_hexrays.CMAT_TRANS1 (variable) - applied first wave of transformations - -ida_hexrays.CMAT_TRANS2 (variable) - applied second wave of transformations - -ida_hexrays.CMAT_TRANS3 (variable) - applied third wave of transformations - -ida_hexrays.CMAT_ZERO (variable) - does not exist - -ida_hexrays.CMT_ALL (variable) - All comments. - -ida_hexrays.CMT_BLOCK1 (variable) - Anterioir block comment. - -ida_hexrays.CMT_BLOCK2 (variable) - Posterior block comment. - -ida_hexrays.CMT_FUNC (variable) - Function comment. - -ida_hexrays.CMT_LVAR (variable) - Local variable comment. - -ida_hexrays.CMT_NONE (variable) - No comment is possible. - -ida_hexrays.CMT_TAIL (variable) - Indented comment. - -ida_hexrays.CPBLK_FAST (variable) - do not update minbstkref and minbargref - -ida_hexrays.CPBLK_MINREF (variable) - update minbstkref and minbargref - -ida_hexrays.CPBLK_OPTJMP (variable) - del the jump insn at the end of the block if it becomes useless - -ida_hexrays.CV_FAST (variable) - do not maintain parent information - -ida_hexrays.CV_INSNS (variable) - visit only statements, prune all expressions do not use before the final ctree - maturity because expressions may contain statements at intermediate stages (see - cot_insn). Otherwise you risk missing statements embedded into expressions. - -ida_hexrays.CV_PARENTS (variable) - maintain parent information - -ida_hexrays.CV_POST (variable) - call the leave...() functions - -ida_hexrays.CV_PRUNE (variable) - this bit is set by visit...() to prune the walk - -ida_hexrays.CV_RESTART (variable) - restart enumeration at the top expr (apply_to_exprs) - -ida_hexrays.DECOMP_ALL_BLKS (variable) - generate microcode for unreachable blocks - -ida_hexrays.DECOMP_GXREFS_DEFLT (variable) - the default behavior: do not update the global xrefs cache upon decompile() - call, but when the pseudocode text is generated (e.g., through - cfunc_t.get_pseudocode()) - -ida_hexrays.DECOMP_GXREFS_FORCE (variable) - update the global xrefs cache immediately - -ida_hexrays.DECOMP_GXREFS_NOUPD (variable) - do not update the global xrefs cache - -ida_hexrays.DECOMP_NO_CACHE (variable) - do not use decompilation cache (snippets are never cached) - -ida_hexrays.DECOMP_NO_FRAME (variable) - do not use function frame info (only snippet mode) - -ida_hexrays.DECOMP_NO_HIDE (variable) - do not close display waitbox. see close_hexrays_waitboxes() - -ida_hexrays.DECOMP_NO_WAIT (variable) - do not display waitbox - -ida_hexrays.DECOMP_NO_XREFS (variable) - Obsolete. Use DECOMP_GXREFS_NOUPD. - -ida_hexrays.DECOMP_VOID_MBA (variable) - return empty mba object (to be used with gen_microcode) - -ida_hexrays.DECOMP_WARNINGS (variable) - display warnings in the output window - -ida_hexrays.DecompilationFailure (class) - -ida_hexrays.EQ_CMPDEST (variable) - compare instruction destinations - -ida_hexrays.EQ_IGNCODE (variable) - ignore instruction opcodes - -ida_hexrays.EQ_IGNSIZE (variable) - ignore source operand sizes - -ida_hexrays.EQ_OPTINSN (variable) - optimize mop_d operands - -ida_hexrays.EXFL_ALL (variable) - all currently defined bits - -ida_hexrays.EXFL_ALONE (variable) - standalone helper - -ida_hexrays.EXFL_CPADONE (variable) - pointer arithmetic correction done - -ida_hexrays.EXFL_CSTR (variable) - string literal - -ida_hexrays.EXFL_FPOP (variable) - floating point operation - -ida_hexrays.EXFL_JUMPOUT (variable) - jump out-of-function - -ida_hexrays.EXFL_LVALUE (variable) - expression is lvalue even if it doesn't look like it - -ida_hexrays.EXFL_PARTIAL (variable) - type of the expression is considered partial - -ida_hexrays.EXFL_UNDEF (variable) - expression uses undefined value - -ida_hexrays.EXFL_VFTABLE (variable) - is ptr to vftable (used for cot_memptr, cot_memref) - -ida_hexrays.FCI_DEAD (variable) - some return registers were determined dead - -ida_hexrays.FCI_EXPLOCS (variable) - all arglocs are specified explicitly - -ida_hexrays.FCI_FINAL (variable) - call type is final, should not be changed - -ida_hexrays.FCI_HASCALL (variable) - A function is an synthetic helper combined from several instructions and at - least one of them was a call to a real functions - -ida_hexrays.FCI_HASFMT (variable) - A variadic function with recognized printf- or scanf-style format string - -ida_hexrays.FCI_NORET (variable) - call does not return - -ida_hexrays.FCI_NOSIDE (variable) - call does not have side effects - -ida_hexrays.FCI_PROP (variable) - call has been propagated - -ida_hexrays.FCI_PURE (variable) - pure function - -ida_hexrays.FCI_SPLOK (variable) - spoiled/visible_memory lists have been optimized. for some functions we can - reduce them as soon as information about the arguments becomes available. in - order not to try optimize them again we use this bit. - -ida_hexrays.FD_BACKWARD (variable) - search direction - -ida_hexrays.FD_DEF (variable) - look for definition - -ida_hexrays.FD_DIRTY (variable) - ignore possible implicit definitions by function calls and indirect memory - access - -ida_hexrays.FD_FORWARD (variable) - search direction - -ida_hexrays.FD_USE (variable) - look for use - -ida_hexrays.FORBID_UNUSED_LABELS (variable) - Unused labels cause interr. - -ida_hexrays.GCA_ALLOC (variable) - enumerate only allocated chains - -ida_hexrays.GCA_EMPTY (variable) - include empty chains - -ida_hexrays.GCA_NALLOC (variable) - enumerate only non-allocated chains - -ida_hexrays.GCA_OFIRST (variable) - consider only chains of the first block - -ida_hexrays.GCA_OLAST (variable) - consider only chains of the last block - -ida_hexrays.GCA_SPEC (variable) - include chains for special registers - -ida_hexrays.GCO_DEF (variable) - is destination operand? - -ida_hexrays.GCO_REG (variable) - is register? otherwise a stack variable - -ida_hexrays.GCO_STK (variable) - a stack variable - -ida_hexrays.GCO_USE (variable) - is source operand? - -ida_hexrays.GC_ASR (variable) - all the above and assertions - -ida_hexrays.GC_DIRTY_ALL (variable) - bitmask to represent all chains - -ida_hexrays.GC_END (variable) - number of chain types - -ida_hexrays.GC_REGS_AND_STKVARS (variable) - registers and stkvars (restricted memory only) - -ida_hexrays.GC_XDSU (variable) - only registers calculated with FULL_XDSU - -ida_hexrays.GLN_ALL (variable) - get both - -ida_hexrays.GLN_CURRENT (variable) - get label of the current item - -ida_hexrays.GLN_GOTO_TARGET (variable) - get goto target - -ida_hexrays.Hexrays_Hooks (class) - Proxy of C++ Hexrays_Hooks class. - -ida_hexrays.Hexrays_Hooks.__disown__ (method) - -ida_hexrays.Hexrays_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> Hexrays_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 - -ida_hexrays.Hexrays_Hooks.build_callinfo (method) - build_callinfo(self, blk, type) -> PyObject * - Analyzing a call instruction. - - @param blk: (mblock_t *) blk->tail is the call. - @param type: (tinfo_t *) buffer for the output type. - -ida_hexrays.Hexrays_Hooks.callinfo_built (method) - callinfo_built(self, blk) -> int - A call instruction has been anallyzed. - - @param blk: (mblock_t *) blk->tail is the call. - -ida_hexrays.Hexrays_Hooks.calls_done (method) - calls_done(self, mba) -> int - All calls have been analyzed. - - @param mba: (mba_t *) This event is generated immediately after analyzing all - calls, before any optimizitions, call unmerging and block merging. - -ida_hexrays.Hexrays_Hooks.close_pseudocode (method) - close_pseudocode(self, vu) -> int - Pseudocode view is being closed. - - @param vu: (vdui_t *) - -ida_hexrays.Hexrays_Hooks.cmt_changed (method) - cmt_changed(self, cfunc, loc, cmt) -> int - Comment got changed. - - @param cfunc: (cfunc_t *) - @param loc: (const treeloc_t *) - @param cmt: (const char *) - -ida_hexrays.Hexrays_Hooks.combine (method) - combine(self, blk, insn) -> int - Trying to combine instructions of basic block. - - @param blk: (mblock_t *) - @param insn: (minsn_t *) Should return: 1 if combined the current instruction - with a preceding one -1 if the instruction should not be combined 0 - else - -ida_hexrays.Hexrays_Hooks.create_hint (method) - create_hint(self, vu) -> PyObject * - Create a hint for the current item. - @see: ui_get_custom_viewer_hint - - @param vu: (vdui_t *) - @retval 0: continue collecting hints with other subscribers - @retval 1: stop collecting hints - -ida_hexrays.Hexrays_Hooks.curpos (method) - curpos(self, vu) -> int - Current cursor position has been changed. (for example, by left-clicking or - using keyboard) - - @param vu: (vdui_t *) - -ida_hexrays.Hexrays_Hooks.double_click (method) - double_click(self, vu, shift_state) -> int - Mouse double click. - - @param vu: (vdui_t *) - @param shift_state: (int) Should return: 1 if the event has been handled - -ida_hexrays.Hexrays_Hooks.flowchart (method) - flowchart(self, fc) -> int - Flowchart has been generated. - - @param fc: (qflow_chart_t *) - -ida_hexrays.Hexrays_Hooks.func_printed (method) - func_printed(self, cfunc) -> int - Function text has been generated. Plugins may modify the text in cfunc_t::sv. - The text uses regular color codes (see lines.hpp) COLOR_ADDR is used to store - pointers to ctree items. - - @param cfunc: (cfunc_t *) - -ida_hexrays.Hexrays_Hooks.glbopt (method) - glbopt(self, mba) -> int - Global optimization has been finished. If microcode is modified, MERR_LOOP must - be returned. It will cause a complete restart of the optimization. - - @param mba: (mba_t *) return Microcode error codes code - -ida_hexrays.Hexrays_Hooks.hook (method) - hook(self) -> bool - -ida_hexrays.Hexrays_Hooks.interr (method) - interr(self, errcode) -> int - Internal error has occurred. - - @param errcode: (int ) - -ida_hexrays.Hexrays_Hooks.keyboard (method) - keyboard(self, vu, key_code, shift_state) -> int - Keyboard has been hit. - - @param vu: (vdui_t *) - @param key_code: (int) VK_... - @param shift_state: (int) Should return: 1 if the event has been handled - -ida_hexrays.Hexrays_Hooks.locopt (method) - locopt(self, mba) -> int - Basic block level optimization has been finished. - - @param mba: (mba_t *) return Microcode error codes code - -ida_hexrays.Hexrays_Hooks.lvar_cmt_changed (method) - lvar_cmt_changed(self, vu, v, cmt) -> int - Local variable comment got changed. - - @param vu: (vdui_t *) - @param v: (lvar_t *) - @param cmt: (const char *) Please note that it is possible to read/write user - settings for lvars directly from the idb. - -ida_hexrays.Hexrays_Hooks.lvar_mapping_changed (method) - lvar_mapping_changed(self, vu, frm, to) -> int - Local variable mapping got changed. - - @param vu: (vdui_t *) - @param from: lvar_t * - @param to: (lvar_t *) Please note that it is possible to read/write user - settings for lvars directly from the idb. - -ida_hexrays.Hexrays_Hooks.lvar_name_changed (method) - lvar_name_changed(self, vu, v, name, is_user_name) -> int - Local variable got renamed. - - @param vu: (vdui_t *) - @param v: (lvar_t *) - @param name: (const char *) - @param is_user_name: (bool) Please note that it is possible to read/write user - settings for lvars directly from the idb. - -ida_hexrays.Hexrays_Hooks.lvar_type_changed (method) - lvar_type_changed(self, vu, v, tinfo) -> int - Local variable type got changed. - - @param vu: (vdui_t *) - @param v: (lvar_t *) - @param tinfo: (const tinfo_t *) Please note that it is possible to read/write - user settings for lvars directly from the idb. - -ida_hexrays.Hexrays_Hooks.maturity (method) - maturity(self, cfunc, new_maturity) -> int - Ctree maturity level is being changed. - - @param cfunc: (cfunc_t *) - @param new_maturity: (ctree_maturity_t) - -ida_hexrays.Hexrays_Hooks.microcode (method) - microcode(self, mba) -> int - Microcode has been generated. - - @param mba: (mba_t *) return Microcode error codes code - -ida_hexrays.Hexrays_Hooks.open_pseudocode (method) - open_pseudocode(self, vu) -> int - New pseudocode view has been opened. - - @param vu: (vdui_t *) - -ida_hexrays.Hexrays_Hooks.populating_popup (method) - populating_popup(self, widget, popup_handle, vu) -> int - Populating popup menu. We can add menu items now. - - @param widget: (TWidget *) - @param popup_handle: (TPopupMenu *) - @param vu: (vdui_t *) - -ida_hexrays.Hexrays_Hooks.prealloc (method) - prealloc(self, mba) -> int - Local variables: preallocation step begins. - - @param mba: (mba_t *) This event may occur several times. Should return: 1 if - modified microcode Negative values are Microcode error codes error - codes - -ida_hexrays.Hexrays_Hooks.preoptimized (method) - preoptimized(self, mba) -> int - Microcode has been preoptimized. - - @param mba: (mba_t *) return Microcode error codes code - -ida_hexrays.Hexrays_Hooks.print_func (method) - print_func(self, cfunc, vp) -> int - Printing ctree and generating text. - - @param cfunc: (cfunc_t *) - @param vp: (vc_printer_t *) Returns: 1 if text has been generated by the plugin - It is forbidden to modify ctree at this event. - -ida_hexrays.Hexrays_Hooks.prolog (method) - prolog(self, mba, fc, reachable_blocks, decomp_flags) -> int - Prolog analysis has been finished. - - @param mba: (mba_t *) - @param fc: (qflow_chart_t *) - @param reachable_blocks: (bitset_t *) - @param decomp_flags: (int) return Microcode error codes code - -ida_hexrays.Hexrays_Hooks.refresh_pseudocode (method) - refresh_pseudocode(self, vu) -> int - Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is - forbidden in this event. - - @param vu: (vdui_t *) See also hxe_text_ready, which happens earlier - -ida_hexrays.Hexrays_Hooks.resolve_stkaddrs (method) - resolve_stkaddrs(self, mba) -> int - The optimizer is about to resolve stack addresses. - - @param mba: (mba_t *) - -ida_hexrays.Hexrays_Hooks.right_click (method) - right_click(self, vu) -> int - Mouse right click. Use hxe_populating_popup instead, in case you want to add - items in the popup menu. - - @param vu: (vdui_t *) - -ida_hexrays.Hexrays_Hooks.stkpnts (method) - stkpnts(self, mba, _sps) -> int - SP change points have been calculated. - - @param mba: (mba_t *) - @param stkpnts: (stkpnts_t *) return Microcode error codes code - -ida_hexrays.Hexrays_Hooks.structural (method) - structural(self, ct) -> int - Structural analysis has been finished. - - @param ct: (control_graph_t *) - -ida_hexrays.Hexrays_Hooks.switch_pseudocode (method) - switch_pseudocode(self, vu) -> int - Existing pseudocode view has been reloaded with a new function. Its text has not - been refreshed yet, only cfunc and mba pointers are ready. - - @param vu: (vdui_t *) - -ida_hexrays.Hexrays_Hooks.text_ready (method) - text_ready(self, vu) -> int - Decompiled text is ready. - - @param vu: (vdui_t *) This event can be used to modify the output text (sv). - Obsolete. Please use hxe_func_printed instead. - -ida_hexrays.Hexrays_Hooks.unhook (method) - unhook(self) -> bool - -ida_hexrays.IPROP_CLNPOP (variable) - the purpose of the instruction is to clean stack (e.g. "pop ecx" is often used - for that) - -ida_hexrays.IPROP_COMBINED (variable) - insn has been modified because of a partial reference - -ida_hexrays.IPROP_DONT_COMB (variable) - may not combine this instruction with others - -ida_hexrays.IPROP_DONT_PROP (variable) - may not propagate - -ida_hexrays.IPROP_EXTSTX (variable) - this is m_ext propagated into m_stx - -ida_hexrays.IPROP_FARCALL (variable) - call of a far function using push cs/call sequence - -ida_hexrays.IPROP_FPINSN (variable) - floating point insn - -ida_hexrays.IPROP_IGNLOWSRC (variable) - low part of the instruction source operand has been created artificially (this - bit is used only for 'and x, 80...') - -ida_hexrays.IPROP_INV_JX (variable) - inverted conditional jump - -ida_hexrays.IPROP_MBARRIER (variable) - this instruction acts as a memory barrier (instructions accessing memory may not - be reordered past it) - -ida_hexrays.IPROP_MULTI_MOV (variable) - bits that can be set by plugins: - - the minsn was generated as part of insn that moves multiple registers (example: - STM on ARM may transfer multiple registers) - -ida_hexrays.IPROP_OPTIONAL (variable) - optional instruction - -ida_hexrays.IPROP_PERSIST (variable) - persistent insn; they are not destroyed - -ida_hexrays.IPROP_SPLIT (variable) - the instruction has been split: - -ida_hexrays.IPROP_SPLIT1 (variable) - into 1 byte - -ida_hexrays.IPROP_SPLIT2 (variable) - into 2 bytes - -ida_hexrays.IPROP_SPLIT4 (variable) - into 4 bytes - -ida_hexrays.IPROP_SPLIT8 (variable) - into 8 bytes - -ida_hexrays.IPROP_TAILCALL (variable) - tail call - -ida_hexrays.IPROP_UNMERGED (variable) - 'goto' instruction was transformed info 'call' - -ida_hexrays.IPROP_WAS_NORET (variable) - was noret icall - -ida_hexrays.IPROP_WILDMATCH (variable) - match multiple insns - -ida_hexrays.ITP_ARG1 (variable) - , (64 entries are reserved for 64 call arguments) - -ida_hexrays.ITP_ASM (variable) - __asm-line - -ida_hexrays.ITP_BLOCK1 (variable) - opening block comment. this comment is printed before the item (other comments - are indented and printed after the item) - -ida_hexrays.ITP_BLOCK2 (variable) - closing block comment. - -ida_hexrays.ITP_BRACE2 (variable) - ) - -ida_hexrays.ITP_CASE (variable) - bit for switch cases - -ida_hexrays.ITP_COLON (variable) - : (label) - -ida_hexrays.ITP_CURLY1 (variable) - { - -ida_hexrays.ITP_CURLY2 (variable) - } - -ida_hexrays.ITP_DO (variable) - do-line - -ida_hexrays.ITP_ELSE (variable) - else-line - -ida_hexrays.ITP_EMPTY (variable) - nothing - -ida_hexrays.ITP_SEMI (variable) - semicolon - -ida_hexrays.ITP_SIGN (variable) - if this bit is set too, then we have a negative case value - -ida_hexrays.LOCOPT_ALL (variable) - redo optimization for all blocks. if this bit is not set, only dirty blocks will - be optimized - -ida_hexrays.LOCOPT_REFINE (variable) - refine return type, ok to fail - -ida_hexrays.LOCOPT_REFINE2 (variable) - refine return type, try harder - -ida_hexrays.LVINF_KEEP (variable) - preserve saved user settings regardless of vars for example, if a var loses all - its user-defined attributes or even gets destroyed, keep its lvar_saved_info_t. - this is used for ephemeral variables that get destroyed by macro recognition. - -ida_hexrays.LVINF_NOMAP (variable) - forbid automatic mapping of the variable - -ida_hexrays.LVINF_NOPTR (variable) - variable type should not be a pointer - -ida_hexrays.LVINF_SPLIT (variable) - split allocation of a new variable. forces the decompiler to create a new - variable at ll.defea - -ida_hexrays.LVINF_UNUSED (variable) - unused argument, corresponds to CVAR_UNUSED - -ida_hexrays.MBA2_ARGIDX_OK (variable) - may verify input argument list? - -ida_hexrays.MBA2_ARGIDX_SORTED (variable) - args finally sorted according to ABI (e.g. reverse stkarg order in Borland) - -ida_hexrays.MBA2_CODE16_BIT (variable) - the code16 bit removed - -ida_hexrays.MBA2_DONT_VERIFY (variable) - Do not verify microcode. This flag is recomended to be set only when debugging - decompiler plugins - -ida_hexrays.MBA2_HAS_OUTLINES (variable) - calls to outlined code have been inlined - -ida_hexrays.MBA2_IS_CTR (variable) - is constructor? - -ida_hexrays.MBA2_IS_DTR (variable) - is destructor? - -ida_hexrays.MBA2_LVARNAMES_OK (variable) - may verify lvar_names? - -ida_hexrays.MBA2_LVARS_RENAMED (variable) - accept empty names now? - -ida_hexrays.MBA2_NO_DUP_CALLS (variable) - forbid multiple calls with the same ea - -ida_hexrays.MBA2_NO_DUP_LVARS (variable) - forbid multiple lvars with the same ea - -ida_hexrays.MBA2_NO_FRAME (variable) - do not use function frame info (only snippet mode) - -ida_hexrays.MBA2_OVER_CHAINS (variable) - has overlapped chains? - -ida_hexrays.MBA2_PROP_COMPLEX (variable) - allow propagation of more complex variable definitions - -ida_hexrays.MBA2_STACK_RETVAL (variable) - the return value is on the stack - -ida_hexrays.MBA2_UNDEF_RETVAR (variable) - return value is undefined - -ida_hexrays.MBA2_VALRNG_DONE (variable) - calculated valranges? - -ida_hexrays.MBA_ASRPROP (variable) - assertion have been propagated - -ida_hexrays.MBA_ASRTOK (variable) - assertions have been generated - -ida_hexrays.MBA_CALLS (variable) - callinfo has been built - -ida_hexrays.MBA_CHVARS (variable) - can verify chain varnums - -ida_hexrays.MBA_CMBBLK (variable) - request to combine blocks - -ida_hexrays.MBA_CMNSTK (variable) - stkvars+stkargs should be considered as one area - -ida_hexrays.MBA_COLGDL (variable) - display graph after each reduction - -ida_hexrays.MBA_DELPAIRS (variable) - pairs have been deleted once - -ida_hexrays.MBA_GLBOPT (variable) - microcode has been optimized globally - -ida_hexrays.MBA_INSGDL (variable) - display instruction in graphs - -ida_hexrays.MBA_LOADED (variable) - loaded gdl, no instructions (debugging) - -ida_hexrays.MBA_LVARS0 (variable) - lvar pre-allocation has been performed - -ida_hexrays.MBA_LVARS1 (variable) - lvar real allocation has been performed - -ida_hexrays.MBA_NICE (variable) - apply transformations to c code - -ida_hexrays.MBA_NOFUNC (variable) - function is not present, addresses might be wrong - -ida_hexrays.MBA_NUMADDR (variable) - display definition addresses for numbers - -ida_hexrays.MBA_PASSREGS (variable) - has mcallinfo_t::pass_regs - -ida_hexrays.MBA_PATTERN (variable) - microcode pattern, callinfo is present - -ida_hexrays.MBA_PRCDEFS (variable) - use precise defeas for chain-allocated lvars - -ida_hexrays.MBA_PREOPT (variable) - preoptimization stage complete - -ida_hexrays.MBA_REFINE (variable) - may refine return value size - -ida_hexrays.MBA_RETFP (variable) - function returns floating point value - -ida_hexrays.MBA_RETREF (variable) - return type has been refined - -ida_hexrays.MBA_SAVRST (variable) - save-restore analysis has been performed - -ida_hexrays.MBA_SHORT (variable) - use short display - -ida_hexrays.MBA_SPLINFO (variable) - (final_type ? idb_spoiled : spoiled_regs) is valid - -ida_hexrays.MBA_THUNK (variable) - thunk function - -ida_hexrays.MBA_VALNUM (variable) - display value numbers - -ida_hexrays.MBA_WINGR32 (variable) - use wingraph32 - -ida_hexrays.MBL_BACKPROP (variable) - performed backprop_cc - -ida_hexrays.MBL_CALL (variable) - call information has been built - -ida_hexrays.MBL_COMB (variable) - needs "combine" pass - -ida_hexrays.MBL_DEAD (variable) - needs "eliminate deads" pass - -ida_hexrays.MBL_DMT64 (variable) - needs "demote 64bits" - -ida_hexrays.MBL_DSLOT (variable) - block for delay slot - -ida_hexrays.MBL_FAKE (variable) - fake block - -ida_hexrays.MBL_GOTO (variable) - this block is a goto target - -ida_hexrays.MBL_INCONST (variable) - inconsistent lists: we are building them - -ida_hexrays.MBL_KEEP (variable) - do not remove even if unreachable - -ida_hexrays.MBL_LIST (variable) - use/def lists are ready (not dirty) - -ida_hexrays.MBL_NONFAKE (variable) - regular block - -ida_hexrays.MBL_NORET (variable) - dead end block: doesn't return execution control - -ida_hexrays.MBL_PRIV (variable) - private block - no instructions except the specified are accepted (used in - patterns) - -ida_hexrays.MBL_PROP (variable) - needs 'propagation' pass - -ida_hexrays.MBL_PUSH (variable) - needs "convert push/pop instructions" - -ida_hexrays.MBL_TCAL (variable) - aritifical call block for tail calls - -ida_hexrays.MBL_VALRANGES (variable) - should optimize using value ranges - -ida_hexrays.MERR_BADARCH (variable) - current architecture is not supported - -ida_hexrays.MERR_BADBLK (variable) - bad block found - -ida_hexrays.MERR_BADCALL (variable) - could not determine call arguments - -ida_hexrays.MERR_BADFRAME (variable) - function frame is wrong - -ida_hexrays.MERR_BADIDB (variable) - inconsistent database information - -ida_hexrays.MERR_BADRANGES (variable) - bad input ranges - -ida_hexrays.MERR_BADSP (variable) - positive sp value has been found - -ida_hexrays.MERR_BITNESS (variable) - 16-bit functions cannot be decompiled - -ida_hexrays.MERR_BLOCK (variable) - no error, switch to new block - -ida_hexrays.MERR_BUSY (variable) - already decompiling a function - -ida_hexrays.MERR_CANCELED (variable) - decompilation has been cancelled - -ida_hexrays.MERR_COMPLEX (variable) - too complex function - -ida_hexrays.MERR_DSLOT (variable) - bad instruction in the delay slot - -ida_hexrays.MERR_EXCEPTION (variable) - exception analysis failed - -ida_hexrays.MERR_EXTERN (variable) - special segments cannot be decompiled - -ida_hexrays.MERR_FARPTR (variable) - far memory model is supported only for pc - -ida_hexrays.MERR_FUNCSIZE (variable) - too big function - -ida_hexrays.MERR_HUGESTACK (variable) - stack frame is too big - -ida_hexrays.MERR_INSN (variable) - cannot convert to microcode - -ida_hexrays.MERR_INTERR (variable) - internal error - -ida_hexrays.MERR_LICENSE (variable) - no license available - -ida_hexrays.MERR_LOOP (variable) - internal code: redo last loop (never reported) - -ida_hexrays.MERR_LVARS (variable) - local variable allocation failed - -ida_hexrays.MERR_MEM (variable) - not enough memory - -ida_hexrays.MERR_OK (variable) - ok - -ida_hexrays.MERR_ONLY32 (variable) - only 32-bit functions can be decompiled for the current database - -ida_hexrays.MERR_ONLY64 (variable) - only 64-bit functions can be decompiled for the current database - -ida_hexrays.MERR_OVERLAP (variable) - variables would overlap: s - -ida_hexrays.MERR_PARTINIT (variable) - partially initialized variable s - -ida_hexrays.MERR_PROLOG (variable) - prolog analysis failed - -ida_hexrays.MERR_RECDEPTH (variable) - max recursion depth reached during lvar allocation - -ida_hexrays.MERR_REDO (variable) - redecompilation has been requested - -ida_hexrays.MERR_SIZEOF (variable) - wrong basic type sizes in compiler settings - -ida_hexrays.MERR_STOP (variable) - no error, stop the analysis - -ida_hexrays.MERR_SWITCH (variable) - wrong switch idiom - -ida_hexrays.MERR_UNKTYPE (variable) - undefined type s (currently unused error code) - -ida_hexrays.MLI_CLR_FLAGS (variable) - clear LVINF_... bits - -ida_hexrays.MLI_CMT (variable) - apply lvar comment - -ida_hexrays.MLI_NAME (variable) - apply lvar name - -ida_hexrays.MLI_SET_FLAGS (variable) - set LVINF_... bits - -ida_hexrays.MLI_TYPE (variable) - apply lvar type - -ida_hexrays.MMAT_CALLS (variable) - detected call arguments. see also hxe_calls_done - -ida_hexrays.MMAT_GENERATED (variable) - generated microcode - -ida_hexrays.MMAT_GLBOPT1 (variable) - performed the first pass of global optimization - -ida_hexrays.MMAT_GLBOPT2 (variable) - most global optimization passes are done - -ida_hexrays.MMAT_GLBOPT3 (variable) - completed all global optimization. microcode is fixed now. - -ida_hexrays.MMAT_LOCOPT (variable) - local optimization of each basic block is complete. control flow graph is ready - too. - -ida_hexrays.MMAT_LVARS (variable) - allocated local variables - -ida_hexrays.MMAT_PREOPTIMIZED (variable) - preoptimized pass is complete - -ida_hexrays.MMAT_ZERO (variable) - microcode does not exist - -ida_hexrays.MMIDX_GLBHIGH (variable) - global memory: high part - -ida_hexrays.MMIDX_GLBLOW (variable) - global memory: low part - -ida_hexrays.NALT_VD (variable) - this index is not used by ida - -ida_hexrays.NF_BINVDONE (variable) - temporary internal bit: inverting bits is done - -ida_hexrays.NF_BITNOT (variable) - The user asked to invert bits of the constant. - -ida_hexrays.NF_FIXED (variable) - number format has been defined by the user - -ida_hexrays.NF_NEGATE (variable) - The user asked to negate the constant. - -ida_hexrays.NF_NEGDONE (variable) - temporary internal bit: negation has been performed - -ida_hexrays.NF_VALID (variable) - internal bit: stroff or enum is valid for enums: this bit is set immediately for - stroffs: this bit is set at the end of decompilation - -ida_hexrays.NOSIZE (variable) - wrong or unexisting operand size - -ida_hexrays.NO_CURLY_BRACES (variable) - don't print curly braces - -ida_hexrays.NO_SIDEFF (variable) - change operand size but ignore side effects if you decide to keep the changed - operand, handle_new_size() must be called - -ida_hexrays.ONLY_SIDEFF (variable) - only handle side effects - -ida_hexrays.OPF_NEW_WINDOW (variable) - open new window - -ida_hexrays.OPF_NO_WAIT (variable) - do not display waitbox if decompilation happens - -ida_hexrays.OPF_REUSE (variable) - reuse existing window - -ida_hexrays.OPF_REUSE_ACTIVE (variable) - reuse existing window, only if the currently active widget is a pseudocode view - -ida_hexrays.OPROP_FLOAT (variable) - possibly floating value - -ida_hexrays.OPROP_IMPDONE (variable) - imported operand (a pointer) has been dereferenced - -ida_hexrays.OPROP_LOWADDR (variable) - a low address offset - -ida_hexrays.OPROP_UDEFVAL (variable) - uses undefined value - -ida_hexrays.OPROP_UDT (variable) - a struct or union - -ida_hexrays.OPTI_ADDREXPRS (variable) - optimize all address expressions (&x+N; &x-&y) - -ida_hexrays.OPTI_COMBINSNS (variable) - may combine insns (only for optimize_insn) - -ida_hexrays.OPTI_MINSTKREF (variable) - may update minstkref - -ida_hexrays.OPTI_NO_LDXOPT (variable) - the function is called after the propagation attempt, we do not optimize - low/high(ldx) in this case - -ida_hexrays.RETRIEVE_ALWAYS (variable) - Retrieve comment even if it has been used. - -ida_hexrays.RETRIEVE_ONCE (variable) - Retrieve comment if it has not been used yet. - -ida_hexrays.ROLE_3WAYCMP0 (variable) - 3-way compare helper, returns -1/0/1 - -ida_hexrays.ROLE_3WAYCMP1 (variable) - 3-way compare helper, returns 0/1/2 - -ida_hexrays.ROLE_ABS (variable) - integer absolute value - -ida_hexrays.ROLE_ALLOCA (variable) - alloca() function - -ida_hexrays.ROLE_BITTEST (variable) - [lock] bt - -ida_hexrays.ROLE_BITTESTANDCOMPLEMENT (variable) - [lock] btc - -ida_hexrays.ROLE_BITTESTANDRESET (variable) - [lock] btr - -ida_hexrays.ROLE_BITTESTANDSET (variable) - [lock] bts - -ida_hexrays.ROLE_BSWAP (variable) - bswap() function (any size) - -ida_hexrays.ROLE_BUG (variable) - BUG() helper macro: never returns, causes exception. - -ida_hexrays.ROLE_CFSUB3 (variable) - carry flag after subtract with carry - -ida_hexrays.ROLE_CONTAINING_RECORD (variable) - CONTAINING_RECORD() macro. - -ida_hexrays.ROLE_EMPTY (variable) - empty, does not do anything (maybe spoils regs) - -ida_hexrays.ROLE_FASTFAIL (variable) - __fastfail() - -ida_hexrays.ROLE_IS_MUL_OK (variable) - is_mul_ok - -ida_hexrays.ROLE_MEMCPY (variable) - memcpy(void *dst, const void *src, size_t count); - -ida_hexrays.ROLE_MEMSET (variable) - memset(void *dst, uchar value, size_t count); - -ida_hexrays.ROLE_MEMSET32 (variable) - memset32(void *dst, uint32 value, size_t count); - -ida_hexrays.ROLE_MEMSET64 (variable) - memset64(void *dst, uint64 value, size_t count); - -ida_hexrays.ROLE_OFSUB3 (variable) - overflow flag after subtract with carry - -ida_hexrays.ROLE_PRESENT (variable) - present() function (used in patterns) - -ida_hexrays.ROLE_READFLAGS (variable) - __readeflags, __readcallersflags - -ida_hexrays.ROLE_ROL (variable) - rotate left - -ida_hexrays.ROLE_ROR (variable) - rotate right - -ida_hexrays.ROLE_SATURATED_MUL (variable) - saturated_mul - -ida_hexrays.ROLE_SSE_CMP4 (variable) - e.g. _mm_cmpgt_ss - -ida_hexrays.ROLE_SSE_CMP8 (variable) - e.g. _mm_cmpgt_sd - -ida_hexrays.ROLE_STRCAT (variable) - strcat(char *dst, const char *src); - -ida_hexrays.ROLE_STRCPY (variable) - strcpy(char *dst, const char *src); - -ida_hexrays.ROLE_STRLEN (variable) - strlen(const char *src); - -ida_hexrays.ROLE_TAIL (variable) - char *tail(const char *str); - -ida_hexrays.ROLE_UNK (variable) - unknown function role - -ida_hexrays.ROLE_VA_ARG (variable) - va_arg() macro - -ida_hexrays.ROLE_VA_COPY (variable) - va_copy() function - -ida_hexrays.ROLE_VA_END (variable) - va_end() function - -ida_hexrays.ROLE_VA_START (variable) - va_start() function - -ida_hexrays.ROLE_WCSCAT (variable) - wchar_t *wcscat(wchar_t *dst, const wchar_t *src) - -ida_hexrays.ROLE_WCSCPY (variable) - wchar_t *wcscpy(wchar_t *dst, const wchar_t *src); - -ida_hexrays.ROLE_WCSLEN (variable) - size_t wcslen(const wchar_t *s) - -ida_hexrays.ROLE_WMEMCPY (variable) - wchar_t *wmemcpy(wchar_t *dst, const wchar_t *src, size_t n) - -ida_hexrays.ROLE_WMEMSET (variable) - wchar_t *wmemset(wchar_t *dst, wchar_t wc, size_t n) - -ida_hexrays.SHINS_LDXEA (variable) - display address of ldx expressions (not used) - -ida_hexrays.SHINS_NUMADDR (variable) - display definition addresses for numbers - -ida_hexrays.SHINS_SHORT (variable) - do not display use-def chains and other attrs - -ida_hexrays.SHINS_VALNUM (variable) - display value numbers - -ida_hexrays.ULV_PRECISE_DEFEA (variable) - Use precise defea's for lvar locations. - -ida_hexrays.USE_CURLY_BRACES (variable) - print curly braces without any checks - -ida_hexrays.USE_KEYBOARD (variable) - Keyboard. - -ida_hexrays.USE_MOUSE (variable) - Mouse. - -ida_hexrays.VDI_EXPR (variable) - c-tree item - -ida_hexrays.VDI_FUNC (variable) - the function itself (the very first line with the function prototype) - -ida_hexrays.VDI_LVAR (variable) - declaration of local variable - -ida_hexrays.VDI_NONE (variable) - undefined - -ida_hexrays.VDI_TAIL (variable) - cursor is at (beyond) the line end (commentable line) - -ida_hexrays.VDRUN_APPEND (variable) - Create a new file or append to existing file. - -ida_hexrays.VDRUN_CMDLINE (variable) - Called from ida's command line. - -ida_hexrays.VDRUN_LUMINA (variable) - Use lumina server. - -ida_hexrays.VDRUN_MAYSTOP (variable) - The user can cancel decompilation. - -ida_hexrays.VDRUN_NEWFILE (variable) - Create a new file or overwrite existing file. - -ida_hexrays.VDRUN_ONLYNEW (variable) - Fail if output file already exists. - -ida_hexrays.VDRUN_SENDIDB (variable) - Send problematic databases to hex-rays.com. - -ida_hexrays.VDRUN_SILENT (variable) - Silent decompilation. - -ida_hexrays.VDRUN_STATS (variable) - Print statistics into vd_stats.txt. - -ida_hexrays.VDUI_VALID (variable) - is valid? - -ida_hexrays.VDUI_VISIBLE (variable) - is visible? - -ida_hexrays.VR_AT_END (variable) - get value ranges after the instruction or at the block end, just after the last - instruction (if M is nullptr) - -ida_hexrays.VR_AT_START (variable) - get value ranges before the instruction or at the block start (if M is nullptr) - -ida_hexrays.VR_EXACT (variable) - find exact match. if not set, the returned valrng size will be >= vivl.size - -ida_hexrays.WARN_ADDR_OUTARGS (variable) - 6 cannot handle address arithmetics in outgoing argument area of stack frame - - unused - -ida_hexrays.WARN_ARRAY_INARG (variable) - 21 array has been used for an input argument - -ida_hexrays.WARN_BAD_CALL_SP (variable) - 38 bad sp value at call - -ida_hexrays.WARN_BAD_FIELD_TYPE (variable) - 23 incorrect structure member type for s::s, ignored - -ida_hexrays.WARN_BAD_INSN (variable) - 49 bad instruction - -ida_hexrays.WARN_BAD_MAPDST (variable) - 48 too short map destination 's' for variable 's' - -ida_hexrays.WARN_BAD_PURGED (variable) - 12 inconsistent function type and number of purged bytes - -ida_hexrays.WARN_BAD_RETVAR (variable) - 25 wrong return variable - -ida_hexrays.WARN_BAD_SHADOW (variable) - 45 ignored the value written to the shadow area of the succeeding call - -ida_hexrays.WARN_BAD_SP (variable) - 40 positive sp value a has been found - -ida_hexrays.WARN_BAD_STD_TYPE (variable) - 37 corrupted or unexisting local type 's' - -ida_hexrays.WARN_BAD_STKPNT (variable) - 41 wrong sp change point - -ida_hexrays.WARN_BAD_STROFF (variable) - 33 user specified stroff has not been processed: s - -ida_hexrays.WARN_BAD_VALRNG (variable) - 44 values range analysis failed - -ida_hexrays.WARN_BAD_VARSIZE (variable) - 34 inconsistent variable size for 's' - -ida_hexrays.WARN_CBUILD_LOOPS (variable) - 13 too many cbuild loops - -ida_hexrays.WARN_CR_BADOFF (variable) - 32 CONTAINING_RECORD: too small offset d for struct 's' - -ida_hexrays.WARN_CR_NOFIELD (variable) - 31 CONTAINING_RECORD: no field 's' in struct 's' at d - -ida_hexrays.WARN_DEP_UNK_CALLS (variable) - 7 found interdependent unknown calls - -ida_hexrays.WARN_EXP_LINVAR (variable) - 10 failed to expand a linear variable - -ida_hexrays.WARN_FIXED_MACRO (variable) - 29 fixed broken macro-insn - -ida_hexrays.WARN_FRAG_LVAR (variable) - 26 fragmented variable at s may be wrong - -ida_hexrays.WARN_GUESSED_TYPE (variable) - 9 using guessed type s; - -ida_hexrays.WARN_HUGE_STKOFF (variable) - 27 exceedingly huge offset into the stack frame - -ida_hexrays.WARN_ILL_ELLIPSIS (variable) - 8 erroneously detected ellipsis type has been ignored - -ida_hexrays.WARN_ILL_FPU_STACK (variable) - 18 inconsistent fpu stack - -ida_hexrays.WARN_ILL_FUNCTYPE (variable) - 2 invalid function type 's' has been ignored - -ida_hexrays.WARN_ILL_PURGED (variable) - 1 odd caller purged bytes d, correcting - -ida_hexrays.WARN_JUMPOUT (variable) - 43 control flows out of bounds - -ida_hexrays.WARN_MAX (variable) - may be used in notes as a placeholder when the warning id is not available - -ida_hexrays.WARN_MAX_ARGS (variable) - 22 too many input arguments, some ignored - -ida_hexrays.WARN_MISSED_SWITCH (variable) - 39 wrong markup of switch jump, skipped it - -ida_hexrays.WARN_MUST_RET_FP (variable) - 17 function return type is incorrect (must be floating point) - -ida_hexrays.WARN_NO_SAVE_REST (variable) - 14 could not find valid save-restore pair for s - -ida_hexrays.WARN_ODD_ABI (variable) - 50 encountered odd instruction for the current ABI - -ida_hexrays.WARN_ODD_ADDR_USE (variable) - 16 odd use of a variable address - -ida_hexrays.WARN_ODD_INPUT_REG (variable) - 15 odd input register s - -ida_hexrays.WARN_OPT_USELESS_JCND (variable) - 54 simplified comparisons for 's': s became s - -ida_hexrays.WARN_OPT_VALRNG (variable) - 46 conditional instruction was optimized away because s - -ida_hexrays.WARN_OPT_VALRNG2 (variable) - 52 mask 0xX is shortened because s <= 0xX" - -ida_hexrays.WARN_OPT_VALRNG3 (variable) - 53 masking with 0XX was optimized away because s <= 0xX - -ida_hexrays.WARN_RET_LOCREF (variable) - 47 returning address of temporary local variable 's' - -ida_hexrays.WARN_SELFREF_PROP (variable) - 19 self-referencing variable has been detected - -ida_hexrays.WARN_UNALIGNED_ARG (variable) - 36 unaligned function argument 's' - -ida_hexrays.WARN_UNBALANCED_STACK (variable) - 51 unbalanced stack, ignored a potential tail call - -ida_hexrays.WARN_UNDEF_LVAR (variable) - 42 variable 's' is possibly undefined - -ida_hexrays.WARN_UNINITED_REG (variable) - 28 reference to an uninitialized register has been removed: s - -ida_hexrays.WARN_UNSUPP_REG (variable) - 35 unsupported processor register 's' - -ida_hexrays.WARN_VARARG_MANY (variable) - 5 too many varargs, some ignored - -ida_hexrays.WARN_VARARG_NOSTK (variable) - 4 call vararg without local stack - -ida_hexrays.WARN_VARARG_REGS (variable) - 0 cannot handle register arguments in vararg function, discarded them - -ida_hexrays.WARN_VARARG_TCAL (variable) - 3 cannot handle tail call to vararg - -ida_hexrays.WARN_WIDEN_CHAINS (variable) - 11 failed to widen chains - -ida_hexrays.WARN_WOULD_OVERLAP (variable) - 20 variables would overlap: s - -ida_hexrays.WARN_WRITE_CONST (variable) - 24 write access to const memory at a has been detected - -ida_hexrays.WARN_WRONG_VA_OFF (variable) - 30 wrong offset of va_list variable - -ida_hexrays.WITH_SIDEFF (variable) - change operand size and handle side effects - -ida_hexrays.__cbhooks_t (class) - -ida_hexrays.__cbhooks_t.__init__ (method) - -ida_hexrays.__cbhooks_t.close_pseudocode (method) - -ida_hexrays.__cbhooks_t.create_hint (method) - -ida_hexrays.__cbhooks_t.curpos (method) - -ida_hexrays.__cbhooks_t.double_click (method) - -ida_hexrays.__cbhooks_t.func_printed (method) - -ida_hexrays.__cbhooks_t.interr (method) - -ida_hexrays.__cbhooks_t.keyboard (method) - -ida_hexrays.__cbhooks_t.maturity (method) - -ida_hexrays.__cbhooks_t.open_pseudocode (method) - -ida_hexrays.__cbhooks_t.populating_popup (method) - -ida_hexrays.__cbhooks_t.print_func (method) - -ida_hexrays.__cbhooks_t.refresh_pseudocode (method) - -ida_hexrays.__cbhooks_t.right_click (method) - -ida_hexrays.__cbhooks_t.switch_pseudocode (method) - -ida_hexrays.__cbhooks_t.text_ready (method) - -ida_hexrays._call_with_transferrable_ownership (function) - -ida_hexrays._kludge_force_declare_TPopupMenu (function) - _kludge_force_declare_TPopupMenu(arg1) - - Parameters - ---------- - arg1: TPopupMenu const * - -ida_hexrays._ll_call_helper (function) - _ll_call_helper(rettype, args, format) -> cexpr_t - - Parameters - ---------- - rettype: tinfo_t const & - args: carglist_t * - format: char const * - -ida_hexrays._ll_create_helper (function) - _ll_create_helper(standalone, type, format) -> cexpr_t - - Parameters - ---------- - standalone: bool - type: tinfo_t const & - format: char const * - -ida_hexrays._ll_dereference (function) - _ll_dereference(e, ptrsize, is_flt=False) -> cexpr_t - - Parameters - ---------- - e: cexpr_t * - ptrsize: int - is_flt: bool - -ida_hexrays._ll_lnot (function) - _ll_lnot(e) -> cexpr_t - - Parameters - ---------- - e: cexpr_t * - -ida_hexrays._ll_make_num (function) - _ll_make_num(n, func=None, ea=BADADDR, opnum=0, sign=no_sign, size=0) -> cexpr_t - - Parameters - ---------- - n: uint64 - func: cfunc_t * - ea: ea_t - opnum: int - sign: type_sign_t - size: int - -ida_hexrays._ll_make_ref (function) - _ll_make_ref(e) -> cexpr_t - - Parameters - ---------- - e: cexpr_t * - -ida_hexrays._ll_new_block (function) - _ll_new_block() -> cinsn_t - -ida_hexrays._map_as_dict (function) - -ida_hexrays._map_as_dict._map___contains__ (function) - Returns true if the specified key exists in the . - -ida_hexrays._map_as_dict._map___delitem__ (function) - Removes the value associated with the provided key. - -ida_hexrays._map_as_dict._map___getitem__ (function) - Returns the value associated with the provided key. - -ida_hexrays._map_as_dict._map___iter__ (function) - Iterate over dictionary keys. - -ida_hexrays._map_as_dict._map___setitem__ (function) - Returns the value associated with the provided key. - -ida_hexrays._map_as_dict._map_clear (function) - -ida_hexrays._map_as_dict._map_copy (function) - -ida_hexrays._map_as_dict._map_get (function) - -ida_hexrays._map_as_dict._map_has_key (function) - -ida_hexrays._map_as_dict._map_items (function) - -ida_hexrays._map_as_dict._map_iteritems (function) - -ida_hexrays._map_as_dict._map_iterkeys (function) - -ida_hexrays._map_as_dict._map_itervalues (function) - -ida_hexrays._map_as_dict._map_keys (function) - -ida_hexrays._map_as_dict._map_pop (function) - Sets the value associated with the provided key. - -ida_hexrays._map_as_dict._map_popitem (function) - Sets the value associated with the provided key. - -ida_hexrays._map_as_dict._map_setdefault (function) - Sets the value associated with the provided key. - -ida_hexrays._map_as_dict._map_values (function) - -ida_hexrays.accepts_small_udts (function) - accepts_small_udts(op) -> bool - Is the operator allowed on small structure or union? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.accepts_udts (function) - accepts_udts(op) -> bool - - @param op: enum ctype_t - -ida_hexrays.arglocs_overlap (function) - arglocs_overlap(loc1, w1, loc2, w2) -> bool - Do two arglocs overlap? - - @param loc1: (C++: const vdloc_t &) vdloc_t const & - @param w1: (C++: size_t) - @param loc2: (C++: const vdloc_t &) vdloc_t const & - @param w2: (C++: size_t) - -ida_hexrays.array_of_bitsets (class) - Proxy of C++ qvector< bitset_t > class. - -ida_hexrays.array_of_bitsets.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< bitset_t > const & - -ida_hexrays.array_of_bitsets.__getitem__ (method) - __getitem__(self, i) -> bitset_t - - @param i: size_t - -ida_hexrays.array_of_bitsets.__init__ (method) - __init__(self) -> array_of_bitsets - __init__(self, x) -> array_of_bitsets - - @param x: qvector< bitset_t > const & - -ida_hexrays.array_of_bitsets.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.array_of_bitsets.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< bitset_t > const & - -ida_hexrays.array_of_bitsets.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: bitset_t const & - -ida_hexrays.array_of_bitsets._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: bitset_t const & - -ida_hexrays.array_of_bitsets.add_unique (method) - add_unique(self, x) -> bool - - @param x: bitset_t const & - -ida_hexrays.array_of_bitsets.at (method) - at(self, _idx) -> bitset_t - - @param _idx: size_t - -ida_hexrays.array_of_bitsets.begin (method) - begin(self) -> bitset_t - -ida_hexrays.array_of_bitsets.capacity (method) - capacity(self) -> size_t - -ida_hexrays.array_of_bitsets.clear (method) - clear(self) - -ida_hexrays.array_of_bitsets.empty (method) - empty(self) -> bool - -ida_hexrays.array_of_bitsets.end (method) - end(self) -> bitset_t - -ida_hexrays.array_of_bitsets.erase (method) - erase(self, it) -> bitset_t - - @param it: qvector< bitset_t >::iterator - - erase(self, first, last) -> bitset_t - - @param first: qvector< bitset_t >::iterator - @param last: qvector< bitset_t >::iterator - -ida_hexrays.array_of_bitsets.extract (method) - extract(self) -> bitset_t - -ida_hexrays.array_of_bitsets.find (method) - find(self, x) -> bitset_t - - @param x: bitset_t const & - -ida_hexrays.array_of_bitsets.grow (method) - grow(self, x=bitset_t()) - - @param x: bitset_t const & - -ida_hexrays.array_of_bitsets.has (method) - has(self, x) -> bool - - @param x: bitset_t const & - -ida_hexrays.array_of_bitsets.inject (method) - inject(self, s, len) - - @param s: bitset_t * - @param len: size_t - -ida_hexrays.array_of_bitsets.insert (method) - insert(self, it, x) -> bitset_t - - @param it: qvector< bitset_t >::iterator - @param x: bitset_t const & - -ida_hexrays.array_of_bitsets.pop_back (method) - pop_back(self) - -ida_hexrays.array_of_bitsets.push_back (method) - push_back(self, x) - - @param x: bitset_t const & - - push_back(self) -> bitset_t - -ida_hexrays.array_of_bitsets.qclear (method) - qclear(self) - -ida_hexrays.array_of_bitsets.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.array_of_bitsets.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: bitset_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.array_of_bitsets.size (method) - size(self) -> size_t - -ida_hexrays.array_of_bitsets.swap (method) - swap(self, r) - - @param r: qvector< bitset_t > & - -ida_hexrays.array_of_bitsets.truncate (method) - truncate(self) - -ida_hexrays.array_of_ivlsets (class) - Proxy of C++ qvector< ivlset_t > class. - -ida_hexrays.array_of_ivlsets.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< ivlset_t > const & - -ida_hexrays.array_of_ivlsets.__getitem__ (method) - __getitem__(self, i) -> ivlset_t - - @param i: size_t - -ida_hexrays.array_of_ivlsets.__init__ (method) - __init__(self) -> array_of_ivlsets - __init__(self, x) -> array_of_ivlsets - - @param x: qvector< ivlset_t > const & - -ida_hexrays.array_of_ivlsets.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.array_of_ivlsets.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< ivlset_t > const & - -ida_hexrays.array_of_ivlsets.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ivlset_t const & - -ida_hexrays.array_of_ivlsets._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: ivlset_t const & - -ida_hexrays.array_of_ivlsets.add_unique (method) - add_unique(self, x) -> bool - - @param x: ivlset_t const & - -ida_hexrays.array_of_ivlsets.at (method) - at(self, _idx) -> ivlset_t - - @param _idx: size_t - -ida_hexrays.array_of_ivlsets.begin (method) - begin(self) -> ivlset_t - -ida_hexrays.array_of_ivlsets.capacity (method) - capacity(self) -> size_t - -ida_hexrays.array_of_ivlsets.clear (method) - clear(self) - -ida_hexrays.array_of_ivlsets.empty (method) - empty(self) -> bool - -ida_hexrays.array_of_ivlsets.end (method) - end(self) -> ivlset_t - -ida_hexrays.array_of_ivlsets.erase (method) - erase(self, it) -> ivlset_t - - @param it: qvector< ivlset_t >::iterator - - erase(self, first, last) -> ivlset_t - - @param first: qvector< ivlset_t >::iterator - @param last: qvector< ivlset_t >::iterator - -ida_hexrays.array_of_ivlsets.extract (method) - extract(self) -> ivlset_t - -ida_hexrays.array_of_ivlsets.find (method) - find(self, x) -> ivlset_t - - @param x: ivlset_t const & - -ida_hexrays.array_of_ivlsets.grow (method) - grow(self, x=ivlset_t()) - - @param x: ivlset_t const & - -ida_hexrays.array_of_ivlsets.has (method) - has(self, x) -> bool - - @param x: ivlset_t const & - -ida_hexrays.array_of_ivlsets.inject (method) - inject(self, s, len) - - @param s: ivlset_t * - @param len: size_t - -ida_hexrays.array_of_ivlsets.insert (method) - insert(self, it, x) -> ivlset_t - - @param it: qvector< ivlset_t >::iterator - @param x: ivlset_t const & - -ida_hexrays.array_of_ivlsets.pop_back (method) - pop_back(self) - -ida_hexrays.array_of_ivlsets.push_back (method) - push_back(self, x) - - @param x: ivlset_t const & - - push_back(self) -> ivlset_t - -ida_hexrays.array_of_ivlsets.qclear (method) - qclear(self) - -ida_hexrays.array_of_ivlsets.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.array_of_ivlsets.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ivlset_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.array_of_ivlsets.size (method) - size(self) -> size_t - -ida_hexrays.array_of_ivlsets.swap (method) - swap(self, r) - - @param r: qvector< ivlset_t > & - -ida_hexrays.array_of_ivlsets.truncate (method) - truncate(self) - -ida_hexrays.asgop (function) - asgop(cop) -> ctype_t - Convert plain operator into assignment operator. For example, cot_add returns - cot_asgadd. - - @param cop: (C++: ctype_t) enum ctype_t - -ida_hexrays.asgop_revert (function) - asgop_revert(cop) -> ctype_t - Convert assignment operator into plain operator. For example, cot_asgadd returns - cot_add - - @param cop: (C++: ctype_t) enum ctype_t - @return: cot_empty is the input operator is not an assignment operator. - -ida_hexrays.bit_bound_t (class) - Proxy of C++ bit_bound_t class. - -ida_hexrays.bit_bound_t.__init__ (method) - __init__(self, n=0, s=0) -> bit_bound_t - - @param n: int - @param s: int - -ida_hexrays.bitset_t (class) - Proxy of C++ bitset_t class. - -ida_hexrays.bitset_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bitset_t const & - -ida_hexrays.bitset_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bitset_t const & - -ida_hexrays.bitset_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bitset_t const & - -ida_hexrays.bitset_t.__init__ (method) - __init__(self) -> bitset_t - __init__(self, m) -> bitset_t - - @param m: bitset_t const & - -ida_hexrays.bitset_t.__iter__ (method) - -ida_hexrays.bitset_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bitset_t const & - -ida_hexrays.bitset_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bitset_t const & - -ida_hexrays.bitset_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bitset_t const & - -ida_hexrays.bitset_t.add (method) - add(self, bit) -> bool - - @param bit: int - - add(self, bit, width) -> bool - - @param bit: int - @param width: int - - add(self, ml) -> bool - - @param ml: bitset_t const & - -ida_hexrays.bitset_t.back (method) - back(self) -> int - -ida_hexrays.bitset_t.begin (method) - begin(self) -> iterator - -ida_hexrays.bitset_t.clear (method) - clear(self) - -ida_hexrays.bitset_t.compare (method) - compare(self, r) -> int - - @param r: bitset_t const & - -ida_hexrays.bitset_t.copy (method) - copy(self, m) -> bitset_t - - @param m: bitset_t const & - -ida_hexrays.bitset_t.count (method) - count(self) -> int - count(self, bit) -> int - - @param bit: int - -ida_hexrays.bitset_t.cut_at (method) - cut_at(self, maxbit) -> bool - - @param maxbit: int - -ida_hexrays.bitset_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.bitset_t.empty (method) - empty(self) -> bool - -ida_hexrays.bitset_t.end (method) - end(self) -> iterator - -ida_hexrays.bitset_t.fill_with_ones (method) - fill_with_ones(self, maxbit) - - @param maxbit: int - -ida_hexrays.bitset_t.front (method) - front(self) -> int - -ida_hexrays.bitset_t.has (method) - has(self, bit) -> bool - - @param bit: int - -ida_hexrays.bitset_t.has_all (method) - has_all(self, bit, width) -> bool - - @param bit: int - @param width: int - -ida_hexrays.bitset_t.has_any (method) - has_any(self, bit, width) -> bool - - @param bit: int - @param width: int - -ida_hexrays.bitset_t.has_common (method) - has_common(self, ml) -> bool - - @param ml: bitset_t const & - -ida_hexrays.bitset_t.inc (method) - inc(self, p, n=1) - - @param p: bitset_t::iterator & - @param n: int - -ida_hexrays.bitset_t.includes (method) - includes(self, ml) -> bool - - @param ml: bitset_t const & - -ida_hexrays.bitset_t.intersect (method) - intersect(self, ml) -> bool - - @param ml: bitset_t const & - -ida_hexrays.bitset_t.is_subset_of (method) - is_subset_of(self, ml) -> bool - - @param ml: bitset_t const & - -ida_hexrays.bitset_t.itat (method) - itat(self, n) -> iterator - - @param n: int - -ida_hexrays.bitset_t.itv (method) - itv(self, it) -> int - - @param it: bitset_t::const_iterator - -ida_hexrays.bitset_t.last (method) - last(self) -> int - -ida_hexrays.bitset_t.shift_down (method) - shift_down(self, shift) - - @param shift: int - -ida_hexrays.bitset_t.sub (method) - sub(self, bit) -> bool - - @param bit: int - - sub(self, bit, width) -> bool - - @param bit: int - @param width: int - - sub(self, ml) -> bool - - @param ml: bitset_t const & - -ida_hexrays.bitset_t.swap (method) - swap(self, r) - - @param r: bitset_t & - -ida_hexrays.block_chains_begin (function) - block_chains_begin(set) -> block_chains_iterator_t - Get iterator pointing to the beginning of block_chains_t. - - @param set: (C++: const block_chains_t *) block_chains_t const * - -ida_hexrays.block_chains_clear (function) - block_chains_clear(set) - Clear block_chains_t. - - @param set: (C++: block_chains_t *) - -ida_hexrays.block_chains_end (function) - block_chains_end(set) -> block_chains_iterator_t - Get iterator pointing to the end of block_chains_t. - - @param set: (C++: const block_chains_t *) block_chains_t const * - -ida_hexrays.block_chains_erase (function) - block_chains_erase(set, p) - Erase current element from block_chains_t. - - @param set: (C++: block_chains_t *) - @param p: (C++: block_chains_iterator_t) - -ida_hexrays.block_chains_find (function) - block_chains_find(set, val) -> block_chains_iterator_t - Find the specified key in set block_chains_t. - - @param set: (C++: const block_chains_t *) block_chains_t const * - @param val: (C++: const chain_t &) chain_t const & - -ida_hexrays.block_chains_free (function) - block_chains_free(set) - Delete block_chains_t instance. - - @param set: (C++: block_chains_t *) - -ida_hexrays.block_chains_get (function) - block_chains_get(p) -> chain_t - Get reference to the current set value. - - @param p: (C++: block_chains_iterator_t) - -ida_hexrays.block_chains_insert (function) - block_chains_insert(set, val) -> block_chains_iterator_t - Insert new (chain_t) into set block_chains_t. - - @param set: (C++: block_chains_t *) - @param val: (C++: const chain_t &) chain_t const & - -ida_hexrays.block_chains_iterator_t (class) - Proxy of C++ block_chains_iterator_t class. - -ida_hexrays.block_chains_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: block_chains_iterator_t const & - -ida_hexrays.block_chains_iterator_t.__init__ (method) - __init__(self) -> block_chains_iterator_t - -ida_hexrays.block_chains_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: block_chains_iterator_t const & - -ida_hexrays.block_chains_new (function) - block_chains_new() -> block_chains_t - Create a new block_chains_t instance. - -ida_hexrays.block_chains_next (function) - block_chains_next(p) -> block_chains_iterator_t - Move to the next element. - - @param p: (C++: block_chains_iterator_t) - -ida_hexrays.block_chains_prev (function) - block_chains_prev(p) -> block_chains_iterator_t - Move to the previous element. - - @param p: (C++: block_chains_iterator_t) - -ida_hexrays.block_chains_size (function) - block_chains_size(set) -> size_t - Get size of block_chains_t. - - @param set: (C++: block_chains_t *) - -ida_hexrays.block_chains_t (class) - Proxy of C++ block_chains_t class. - -ida_hexrays.block_chains_t.__init__ (method) - __init__(self) -> block_chains_t - -ida_hexrays.block_chains_t._print (method) - _print(self) - -ida_hexrays.block_chains_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.block_chains_t.get_chain (method) - get_chain(self, k, width=1) -> chain_t - - @param k: voff_t const & - @param width: int - - get_chain(self, ch) -> chain_t - - @param ch: chain_t const & - -ida_hexrays.block_chains_t.get_reg_chain (method) - get_reg_chain(self, reg, width=1) -> chain_t - - @param reg: mreg_t - @param width: int - -ida_hexrays.block_chains_t.get_stk_chain (method) - get_stk_chain(self, off, width=1) -> chain_t - - @param off: sval_t - @param width: int - -ida_hexrays.block_chains_vec_t (class) - Proxy of C++ qvector< block_chains_t > class. - -ida_hexrays.block_chains_vec_t.__getitem__ (method) - __getitem__(self, i) -> block_chains_t - - @param i: size_t - -ida_hexrays.block_chains_vec_t.__init__ (method) - __init__(self) -> block_chains_vec_t - __init__(self, x) -> block_chains_vec_t - - @param x: qvector< block_chains_t > const & - -ida_hexrays.block_chains_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.block_chains_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: block_chains_t const & - -ida_hexrays.block_chains_vec_t.at (method) - at(self, _idx) -> block_chains_t - - @param _idx: size_t - -ida_hexrays.block_chains_vec_t.begin (method) - begin(self) -> block_chains_t - -ida_hexrays.block_chains_vec_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.block_chains_vec_t.clear (method) - clear(self) - -ida_hexrays.block_chains_vec_t.empty (method) - empty(self) -> bool - -ida_hexrays.block_chains_vec_t.end (method) - end(self) -> block_chains_t - -ida_hexrays.block_chains_vec_t.erase (method) - erase(self, it) -> block_chains_t - - @param it: qvector< block_chains_t >::iterator - - erase(self, first, last) -> block_chains_t - - @param first: qvector< block_chains_t >::iterator - @param last: qvector< block_chains_t >::iterator - -ida_hexrays.block_chains_vec_t.extract (method) - extract(self) -> block_chains_t - -ida_hexrays.block_chains_vec_t.grow (method) - grow(self, x=block_chains_t()) - - @param x: block_chains_t const & - -ida_hexrays.block_chains_vec_t.inject (method) - inject(self, s, len) - - @param s: block_chains_t * - @param len: size_t - -ida_hexrays.block_chains_vec_t.insert (method) - insert(self, it, x) -> block_chains_t - - @param it: qvector< block_chains_t >::iterator - @param x: block_chains_t const & - -ida_hexrays.block_chains_vec_t.pop_back (method) - pop_back(self) - -ida_hexrays.block_chains_vec_t.push_back (method) - push_back(self, x) - - @param x: block_chains_t const & - - push_back(self) -> block_chains_t - -ida_hexrays.block_chains_vec_t.qclear (method) - qclear(self) - -ida_hexrays.block_chains_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.block_chains_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: block_chains_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.block_chains_vec_t.size (method) - size(self) -> size_t - -ida_hexrays.block_chains_vec_t.swap (method) - swap(self, r) - - @param r: qvector< block_chains_t > & - -ida_hexrays.block_chains_vec_t.truncate (method) - truncate(self) - -ida_hexrays.boundaries_begin (function) - boundaries_begin(map) -> boundaries_iterator_t - Get iterator pointing to the beginning of boundaries_t. - - @param map: (C++: const boundaries_t *) boundaries_t const * - -ida_hexrays.boundaries_clear (function) - boundaries_clear(map) - Clear boundaries_t. - - @param map: (C++: boundaries_t *) - -ida_hexrays.boundaries_end (function) - boundaries_end(map) -> boundaries_iterator_t - Get iterator pointing to the end of boundaries_t. - - @param map: (C++: const boundaries_t *) boundaries_t const * - -ida_hexrays.boundaries_erase (function) - boundaries_erase(map, p) - Erase current element from boundaries_t. - - @param map: (C++: boundaries_t *) - @param p: (C++: boundaries_iterator_t) - -ida_hexrays.boundaries_find (function) - boundaries_find(map, key) -> boundaries_iterator_t - Find the specified key in boundaries_t. - - @param map: (C++: const boundaries_t *) boundaries_t const * - @param key: (C++: const cinsn_t *&) cinsn_t const * - -ida_hexrays.boundaries_first (function) - boundaries_first(p) -> cinsn_t - Get reference to the current map key. - - @param p: (C++: boundaries_iterator_t) - -ida_hexrays.boundaries_free (function) - boundaries_free(map) - Delete boundaries_t instance. - - @param map: (C++: boundaries_t *) - -ida_hexrays.boundaries_insert (function) - boundaries_insert(map, key, val) -> boundaries_iterator_t - Insert new (cinsn_t *, rangeset_t) pair into boundaries_t. - - @param map: (C++: boundaries_t *) - @param key: (C++: const cinsn_t *&) cinsn_t const * - @param val: (C++: const rangeset_t &) rangeset_t const & - -ida_hexrays.boundaries_iterator_t (class) - Proxy of C++ boundaries_iterator_t class. - -ida_hexrays.boundaries_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: boundaries_iterator_t const & - -ida_hexrays.boundaries_iterator_t.__init__ (method) - __init__(self) -> boundaries_iterator_t - -ida_hexrays.boundaries_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: boundaries_iterator_t const & - -ida_hexrays.boundaries_new (function) - boundaries_new() -> boundaries_t - Create a new boundaries_t instance. - -ida_hexrays.boundaries_next (function) - boundaries_next(p) -> boundaries_iterator_t - Move to the next element. - - @param p: (C++: boundaries_iterator_t) - -ida_hexrays.boundaries_prev (function) - boundaries_prev(p) -> boundaries_iterator_t - Move to the previous element. - - @param p: (C++: boundaries_iterator_t) - -ida_hexrays.boundaries_second (function) - boundaries_second(p) -> rangeset_t - Get reference to the current map value. - - @param p: (C++: boundaries_iterator_t) - -ida_hexrays.boundaries_size (function) - boundaries_size(map) -> size_t - Get size of boundaries_t. - - @param map: (C++: boundaries_t *) - -ida_hexrays.boundaries_t (class) - Proxy of C++ std::map< cinsn_t *,rangeset_t > class. - -ida_hexrays.boundaries_t.__init__ (method) - __init__(self) -> boundaries_t - -ida_hexrays.boundaries_t.at (method) - at(self, _Keyval) -> rangeset_t - - @param _Keyval: cinsn_t *const & - -ida_hexrays.boundaries_t.size (method) - size(self) -> size_t - -ida_hexrays.call_helper (function) - Create a helper call. - -ida_hexrays.carg_t (class) - Proxy of C++ carg_t class. - -ida_hexrays.carg_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: carg_t const & - -ida_hexrays.carg_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: carg_t const & - -ida_hexrays.carg_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: carg_t const & - -ida_hexrays.carg_t.__init__ (method) - __init__(self) -> carg_t - -ida_hexrays.carg_t.__le__ (method) - __le__(self, r) -> bool - - @param r: carg_t const & - -ida_hexrays.carg_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: carg_t const & - -ida_hexrays.carg_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: carg_t const & - -ida_hexrays.carg_t.compare (method) - compare(self, r) -> int - - @param r: carg_t const & - -ida_hexrays.carg_t.consume_cexpr (method) - consume_cexpr(self, e) - - @param e: cexpr_t * - -ida_hexrays.carg_t.formal_type (variable) - formal parameter type (if known) - -ida_hexrays.carg_t.is_vararg (variable) - is a vararg (matches ...) - -ida_hexrays.carglist_t (class) - Proxy of C++ carglist_t class. - -ida_hexrays.carglist_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: carglist_t const & - -ida_hexrays.carglist_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: carglist_t const & - -ida_hexrays.carglist_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: carglist_t const & - -ida_hexrays.carglist_t.__init__ (method) - __init__(self) -> carglist_t - __init__(self, ftype, fl=0) -> carglist_t - - @param ftype: tinfo_t const & - @param fl: int - -ida_hexrays.carglist_t.__le__ (method) - __le__(self, r) -> bool - - @param r: carglist_t const & - -ida_hexrays.carglist_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: carglist_t const & - -ida_hexrays.carglist_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: carglist_t const & - -ida_hexrays.carglist_t.compare (method) - compare(self, r) -> int - - @param r: carglist_t const & - -ida_hexrays.carglist_t.flags (variable) - call flags - -ida_hexrays.carglist_t.functype (variable) - function object type - -ida_hexrays.casm_t (class) - Proxy of C++ casm_t class. - -ida_hexrays.casm_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: casm_t const & - -ida_hexrays.casm_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: casm_t const & - -ida_hexrays.casm_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: casm_t const & - -ida_hexrays.casm_t.__init__ (method) - __init__(self, ea) -> casm_t - - @param ea: ea_t - - __init__(self, r) -> casm_t - - @param r: casm_t const & - -ida_hexrays.casm_t.__le__ (method) - __le__(self, r) -> bool - - @param r: casm_t const & - -ida_hexrays.casm_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: casm_t const & - -ida_hexrays.casm_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: casm_t const & - -ida_hexrays.casm_t.compare (method) - compare(self, r) -> int - - @param r: casm_t const & - -ida_hexrays.casm_t.one_insn (method) - one_insn(self) -> bool - -ida_hexrays.cblock_t (class) - Proxy of C++ cblock_t class. - -ida_hexrays.cblock_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cblock_t const & - -ida_hexrays.cblock_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cblock_t const & - -ida_hexrays.cblock_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cblock_t const & - -ida_hexrays.cblock_t.__init__ (method) - __init__(self) -> cblock_t - -ida_hexrays.cblock_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cblock_t const & - -ida_hexrays.cblock_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cblock_t const & - -ida_hexrays.cblock_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cblock_t const & - -ida_hexrays.cblock_t._deregister (method) - _deregister(self) - -ida_hexrays.cblock_t.compare (method) - compare(self, r) -> int - - @param r: cblock_t const & - -ida_hexrays.ccase_t (class) - Proxy of C++ ccase_t class. - -ida_hexrays.ccase_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ccase_t const & - -ida_hexrays.ccase_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ccase_t const & - -ida_hexrays.ccase_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ccase_t const & - -ida_hexrays.ccase_t.__init__ (method) - __init__(self) -> ccase_t - -ida_hexrays.ccase_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ccase_t const & - -ida_hexrays.ccase_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ccase_t const & - -ida_hexrays.ccase_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ccase_t const & - -ida_hexrays.ccase_t.compare (method) - compare(self, r) -> int - - @param r: ccase_t const & - -ida_hexrays.ccase_t.size (method) - size(self) -> size_t - -ida_hexrays.ccase_t.value (method) - value(self, i) -> uint64 const & - - @param i: int - -ida_hexrays.ccase_t.values (variable) - List of case values. if empty, then 'default' case - -ida_hexrays.ccases_t (class) - Proxy of C++ ccases_t class. - -ida_hexrays.ccases_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ccases_t const & - -ida_hexrays.ccases_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ccases_t const & - -ida_hexrays.ccases_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ccases_t const & - -ida_hexrays.ccases_t.__init__ (method) - __init__(self) -> ccases_t - -ida_hexrays.ccases_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ccases_t const & - -ida_hexrays.ccases_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ccases_t const & - -ida_hexrays.ccases_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ccases_t const & - -ida_hexrays.ccases_t.compare (method) - compare(self, r) -> int - - @param r: ccases_t const & - -ida_hexrays.cdg_insn_iterator_t (class) - Proxy of C++ cdg_insn_iterator_t class. - -ida_hexrays.cdg_insn_iterator_t.__init__ (method) - __init__(self, mba_) -> cdg_insn_iterator_t - - @param mba_: mba_t const * - - __init__(self, r) -> cdg_insn_iterator_t - - @param r: cdg_insn_iterator_t const & - -ida_hexrays.cdg_insn_iterator_t.dslot_with_xrefs (method) - dslot_with_xrefs(self) -> bool - -ida_hexrays.cdg_insn_iterator_t.has_dslot (method) - has_dslot(self) -> bool - -ida_hexrays.cdg_insn_iterator_t.is_severed_dslot (method) - is_severed_dslot(self) -> bool - -ida_hexrays.cdg_insn_iterator_t.next (method) - next(self, ins) -> merror_t - - @param ins: insn_t * - -ida_hexrays.cdg_insn_iterator_t.ok (method) - ok(self) -> bool - -ida_hexrays.cdg_insn_iterator_t.start (method) - start(self, rng) - - @param rng: range_t const & - -ida_hexrays.cdo_t (class) - Proxy of C++ cdo_t class. - -ida_hexrays.cdo_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cdo_t const & - -ida_hexrays.cdo_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cdo_t const & - -ida_hexrays.cdo_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cdo_t const & - -ida_hexrays.cdo_t.__init__ (method) - __init__(self) -> cdo_t - -ida_hexrays.cdo_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cdo_t const & - -ida_hexrays.cdo_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cdo_t const & - -ida_hexrays.cdo_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cdo_t const & - -ida_hexrays.cdo_t.compare (method) - compare(self, r) -> int - - @param r: cdo_t const & - -ida_hexrays.ceinsn_t (class) - Proxy of C++ ceinsn_t class. - -ida_hexrays.ceinsn_t.__init__ (method) - __init__(self) -> ceinsn_t - -ida_hexrays.ceinsn_t.expr (variable) - Expression of the statement. - -ida_hexrays.cexpr_operands (function) - return a dictionary with the operands of a cexpr_t. - -ida_hexrays.cexpr_t (class) - Proxy of C++ cexpr_t class. - -ida_hexrays.cexpr_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.__init__ (method) - __init__(self) -> cexpr_t - __init__(self, cexpr_op, _x, _y=None, _z=None) -> cexpr_t - - @param cexpr_op: enum ctype_t - @param _x: cexpr_t * - @param _y: cexpr_t * - @param _z: cexpr_t * - - __init__(self, r) -> cexpr_t - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t._deregister (method) - _deregister(self) - -ida_hexrays.cexpr_t._get_a (method) - _get_a(self) -> carglist_t - -ida_hexrays.cexpr_t._get_fpc (method) - _get_fpc(self) -> fnumber_t - -ida_hexrays.cexpr_t._get_helper (method) - _get_helper(self) -> char const * - -ida_hexrays.cexpr_t._get_insn (method) - _get_insn(self) -> cinsn_t - -ida_hexrays.cexpr_t._get_m (method) - _get_m(self) -> int - -ida_hexrays.cexpr_t._get_n (method) - _get_n(self) -> cnumber_t - -ida_hexrays.cexpr_t._get_obj_ea (method) - _get_obj_ea(self) -> ea_t - -ida_hexrays.cexpr_t._get_ptrsize (method) - _get_ptrsize(self) -> int - -ida_hexrays.cexpr_t._get_refwidth (method) - _get_refwidth(self) -> int - -ida_hexrays.cexpr_t._get_string (method) - _get_string(self) -> char const * - -ida_hexrays.cexpr_t._get_x (method) - _get_x(self) -> cexpr_t - -ida_hexrays.cexpr_t._get_y (method) - _get_y(self) -> cexpr_t - -ida_hexrays.cexpr_t._get_z (method) - _get_z(self) -> cexpr_t - -ida_hexrays.cexpr_t._register (method) - _register(self) - -ida_hexrays.cexpr_t._replace_by (method) - _replace_by(self, r) - - Parameters - ---------- - r: cexpr_t * - -ida_hexrays.cexpr_t._set_a (method) - _set_a(self, _v) - - Parameters - ---------- - _v: carglist_t * - -ida_hexrays.cexpr_t._set_fpc (method) - _set_fpc(self, _v) - - Parameters - ---------- - _v: fnumber_t * - -ida_hexrays.cexpr_t._set_helper (method) - _set_helper(self, _v) - - Parameters - ---------- - _v: char const * - -ida_hexrays.cexpr_t._set_insn (method) - _set_insn(self, _v) - - Parameters - ---------- - _v: cinsn_t * - -ida_hexrays.cexpr_t._set_m (method) - _set_m(self, _v) - - Parameters - ---------- - _v: int - -ida_hexrays.cexpr_t._set_n (method) - _set_n(self, _v) - - Parameters - ---------- - _v: cnumber_t * - -ida_hexrays.cexpr_t._set_obj_ea (method) - _set_obj_ea(self, _v) - - Parameters - ---------- - _v: ea_t - -ida_hexrays.cexpr_t._set_ptrsize (method) - _set_ptrsize(self, _v) - - Parameters - ---------- - _v: int - -ida_hexrays.cexpr_t._set_refwidth (method) - _set_refwidth(self, _v) - - Parameters - ---------- - _v: int - -ida_hexrays.cexpr_t._set_string (method) - _set_string(self, _v) - - Parameters - ---------- - _v: char const * - -ida_hexrays.cexpr_t._set_x (method) - _set_x(self, _v) - - Parameters - ---------- - _v: cexpr_t * - -ida_hexrays.cexpr_t._set_y (method) - _set_y(self, _v) - - Parameters - ---------- - _v: cexpr_t * - -ida_hexrays.cexpr_t._set_z (method) - _set_z(self, _v) - - Parameters - ---------- - _v: cexpr_t * - -ida_hexrays.cexpr_t.a (variable) - argument list (used for cot_call) - -ida_hexrays.cexpr_t.assign (method) - assign(self, r) -> cexpr_t - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.calc_type (method) - calc_type(self, recursive) - Calculate the type of the expression. Use this function to calculate the - expression type when a new expression is built - - @param recursive: (C++: bool) if true, types of all children expression will be calculated - before calculating our type - -ida_hexrays.cexpr_t.cleanup (method) - cleanup(self) - Cleanup the expression. This function properly deletes all children and sets the - item type to cot_empty. - -ida_hexrays.cexpr_t.compare (method) - compare(self, r) -> int - - @param r: cexpr_t const & - -ida_hexrays.cexpr_t.contains_comma (method) - contains_comma(self, times=1) -> bool - Does the expression contain a comma operator? - - @param times: (C++: int) - -ida_hexrays.cexpr_t.contains_comma_or_insn_or_label (method) - contains_comma_or_insn_or_label(self, maxcommas=1) -> bool - Does the expression contain a comma operator or an embedded statement operator - or a label? - - @param maxcommas: (C++: int) - -ida_hexrays.cexpr_t.contains_insn (method) - contains_insn(self, times=1) -> bool - Does the expression contain an embedded statement operator? - - @param times: (C++: int) - -ida_hexrays.cexpr_t.contains_insn_or_label (method) - contains_insn_or_label(self) -> bool - Does the expression contain an embedded statement operator or a label? - -ida_hexrays.cexpr_t.contains_operator (method) - contains_operator(self, needed_op, times=1) -> bool - Check if the expression contains the specified operator. - - @param needed_op: (C++: ctype_t) operator code to search for - @param times: (C++: int) how many times the operator code should be present - @return: true if the expression has at least TIMES children with NEEDED_OP - -ida_hexrays.cexpr_t.cpadone (method) - cpadone(self) -> bool - Pointer arithmetic correction done for this expression? - -ida_hexrays.cexpr_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.cexpr_t.equal_effect (method) - equal_effect(self, r) -> bool - Compare two expressions. This function tries to compare two expressions in an - 'intelligent' manner. For example, it knows about commutitive operators and can - ignore useless casts. - - @param r: (C++: const cexpr_t &) the expression to compare against the current expression - @return: true expressions can be considered equal - -ida_hexrays.cexpr_t.exflags (variable) - Expression attributes - -ida_hexrays.cexpr_t.find_num_op (method) - find_num_op(self) -> cexpr_t - -ida_hexrays.cexpr_t.find_op (method) - find_op(self, _op) -> cexpr_t - - @param _op: enum ctype_t - -ida_hexrays.cexpr_t.fpc (variable) - used for cot_fnum - -ida_hexrays.cexpr_t.get_1num_op (method) - get_1num_op(self, o1, o2) -> bool - - @param o1: cexpr_t ** - @param o2: cexpr_t ** - -ida_hexrays.cexpr_t.get_const_value (method) - get_const_value(self) -> bool - Get expression value. - - @return: true if the expression is a number. - -ida_hexrays.cexpr_t.get_high_nbit_bound (method) - get_high_nbit_bound(self) -> bit_bound_t - Get max number of bits that can really be used by the expression. For example, x - % 16 can yield only 4 non-zero bits, higher bits are zero - -ida_hexrays.cexpr_t.get_low_nbit_bound (method) - get_low_nbit_bound(self) -> int - Get min number of bits that are certainly required to represent the expression. - For example, constant 16 always uses 5 bits: 10000. - -ida_hexrays.cexpr_t.get_ptr_or_array (method) - get_ptr_or_array(self) -> cexpr_t - Find pointer or array child. - -ida_hexrays.cexpr_t.get_type_sign (method) - get_type_sign(self) -> type_sign_t - Get expression sign. - -ida_hexrays.cexpr_t.get_v (method) - get_v(self) -> var_ref_t - -ida_hexrays.cexpr_t.has_side_effects (method) - has_side_effects(self) -> bool - Check if the expression has side effects. Calls, pre/post inc/dec, and - assignments have side effects. - -ida_hexrays.cexpr_t.helper (variable) - helper name (used for cot_helper) - -ida_hexrays.cexpr_t.insn (variable) - an embedded statement, they are prohibited at the final maturity stage - (CMAT_FINAL) - -ida_hexrays.cexpr_t.is_call_arg_of (method) - is_call_arg_of(self, parent) -> bool - Is call argument? - - @param parent: (C++: const citem_t *) citem_t const * - @return: true if our expression is a call argument of the specified parent - expression. - -ida_hexrays.cexpr_t.is_call_object_of (method) - is_call_object_of(self, parent) -> bool - Is call object? - - @param parent: (C++: const citem_t *) citem_t const * - @return: true if our expression is the call object of the specified parent - expression. - -ida_hexrays.cexpr_t.is_child_of (method) - is_child_of(self, parent) -> bool - Verify if the specified item is our parent. - - @param parent: (C++: const citem_t *) possible parent item - @return: true if the specified item is our parent - -ida_hexrays.cexpr_t.is_const_value (method) - is_const_value(self, _v) -> bool - Check if the expression is a number with the specified value. - - @param _v: (C++: uint64) - -ida_hexrays.cexpr_t.is_cstr (method) - is_cstr(self) -> bool - -ida_hexrays.cexpr_t.is_fpop (method) - is_fpop(self) -> bool - -ida_hexrays.cexpr_t.is_jumpout (method) - is_jumpout(self) -> bool - -ida_hexrays.cexpr_t.is_negative_const (method) - is_negative_const(self) -> bool - Check if the expression is a negative number. - -ida_hexrays.cexpr_t.is_nice_cond (method) - is_nice_cond(self) -> bool - Is nice condition?. Nice condition is a nice expression of the boolean type. - -ida_hexrays.cexpr_t.is_nice_expr (method) - is_nice_expr(self) -> bool - Is nice expression? Nice expressions do not contain comma operators, embedded - statements, or labels. - -ida_hexrays.cexpr_t.is_non_negative_const (method) - is_non_negative_const(self) -> bool - Check if the expression is a non-negative number. - -ida_hexrays.cexpr_t.is_non_zero_const (method) - is_non_zero_const(self) -> bool - Check if the expression is a non-zero number. - -ida_hexrays.cexpr_t.is_odd_lvalue (method) - is_odd_lvalue(self) -> bool - -ida_hexrays.cexpr_t.is_type_signed (method) - is_type_signed(self) -> bool - Is expression signed? - -ida_hexrays.cexpr_t.is_type_unsigned (method) - is_type_unsigned(self) -> bool - Is expression unsigned? - -ida_hexrays.cexpr_t.is_undef_val (method) - is_undef_val(self) -> bool - -ida_hexrays.cexpr_t.is_vftable (method) - is_vftable(self) -> bool - -ida_hexrays.cexpr_t.is_zero_const (method) - is_zero_const(self) -> bool - Check if the expression is a zero. - -ida_hexrays.cexpr_t.m (variable) - member offset (used for cot_memptr, cot_memref) for unions, the member number - -ida_hexrays.cexpr_t.maybe_ptr (method) - maybe_ptr(self) -> bool - May the expression be a pointer? - -ida_hexrays.cexpr_t.n (variable) - used for cot_num - -ida_hexrays.cexpr_t.numval (method) - numval(self) -> uint64 - Get numeric value of the expression. This function can be called only on cot_num - expressions! - -ida_hexrays.cexpr_t.obj_ea (variable) - used for cot_obj - -ida_hexrays.cexpr_t.print1 (method) - print1(self, func) - Print expression into one line. - - @param func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced - variable names. - -ida_hexrays.cexpr_t.ptrsize (variable) - memory access size (used for cot_ptr, cot_memptr) - -ida_hexrays.cexpr_t.put_number (method) - put_number(self, func, value, nbytes, sign=no_sign) - Assign a number to the expression. - - @param func: (C++: cfunc_t *) current function - @param value: (C++: uint64) number value - @param nbytes: (C++: int) size of the number in bytes - @param sign: (C++: type_sign_t) number sign - -ida_hexrays.cexpr_t.refwidth (variable) - how many bytes are accessed? (-1: none) - -ida_hexrays.cexpr_t.requires_lvalue (method) - requires_lvalue(self, child) -> bool - Check if the expression requires an lvalue. - - @param child: (C++: const cexpr_t *) The function will check if this child of our expression must be an - lvalue. - @return: true if child must be an lvalue. - -ida_hexrays.cexpr_t.set_cpadone (method) - set_cpadone(self) - -ida_hexrays.cexpr_t.set_v (method) - set_v(self, v) - - @param v: var_ref_t const * - -ida_hexrays.cexpr_t.set_vftable (method) - set_vftable(self) - -ida_hexrays.cexpr_t.string (variable) - utf8 string constant, user representation (used for cot_str) - -ida_hexrays.cexpr_t.swap (method) - swap(self, r) - - @param r: cexpr_t & - -ida_hexrays.cexpr_t.theother (method) - theother(self, what) -> cexpr_t - - @param what: cexpr_t const * - -ida_hexrays.cexpr_t.type (variable) - expression type. must be carefully maintained - -ida_hexrays.cexpr_t.v (variable) - used for cot_var - -ida_hexrays.cexpr_t.x (variable) - the first operand of the expression - -ida_hexrays.cexpr_t.y (variable) - the second operand of the expression - -ida_hexrays.cexpr_t.z (variable) - the third operand of the expression - -ida_hexrays.cfor_t (class) - Proxy of C++ cfor_t class. - -ida_hexrays.cfor_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cfor_t const & - -ida_hexrays.cfor_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cfor_t const & - -ida_hexrays.cfor_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cfor_t const & - -ida_hexrays.cfor_t.__init__ (method) - __init__(self) -> cfor_t - -ida_hexrays.cfor_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cfor_t const & - -ida_hexrays.cfor_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cfor_t const & - -ida_hexrays.cfor_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cfor_t const & - -ida_hexrays.cfor_t.compare (method) - compare(self, r) -> int - - @param r: cfor_t const & - -ida_hexrays.cfor_t.init (variable) - Initialization expression. - -ida_hexrays.cfor_t.step (variable) - Step expression. - -ida_hexrays.cfunc_parentee_t (class) - Proxy of C++ cfunc_parentee_t class. - -ida_hexrays.cfunc_parentee_t.__disown__ (method) - -ida_hexrays.cfunc_parentee_t.__init__ (method) - __init__(self, f, post=False) -> cfunc_parentee_t - - @param f: cfunc_t * - @param post: bool - -ida_hexrays.cfunc_parentee_t.calc_rvalue_type (method) - calc_rvalue_type(self, target, e) -> bool - Calculate rvalue type. This function tries to determine the type of the - specified item based on its context. For example, if the current expression is - the right side of an assignment operator, the type of its left side will be - returned. This function can be used to determine the 'best' type of the - specified expression. - - @param target: (C++: tinfo_t *) 'best' type of the expression will be returned here - @param e: (C++: const cexpr_t *) expression to determine the desired type - @return: false if failed - -ida_hexrays.cfunc_parentee_t.func (variable) - Pointer to current function. - -ida_hexrays.cfunc_t (class) - Proxy of C++ cfunc_t class. - -ida_hexrays.cfunc_t.__init__ (method) - -ida_hexrays.cfunc_t.__str__ (method) - __str__(self) -> qstring - -ida_hexrays.cfunc_t.argidx (variable) - list of arguments (indexes into vars) - -ida_hexrays.cfunc_t.body (variable) - function body, must be a block - -ida_hexrays.cfunc_t.build_c_tree (method) - build_c_tree(self) - Generate the function body. This function (re)generates the function body from - the underlying microcode. - -ida_hexrays.cfunc_t.del_orphan_cmts (method) - del_orphan_cmts(self) -> int - Delete all orphan comments. The save_user_cmts() function must be called after - this call. - -ida_hexrays.cfunc_t.entry_ea (variable) - function entry address - -ida_hexrays.cfunc_t.find_item_coords (method) - find_item_coords(self, item, px, py) -> bool - - @param item: citem_t const * - @param px: int * - @param py: int * - - find_item_coords(self, item) -> PyObject * - - @param item: citem_t const * - -ida_hexrays.cfunc_t.find_label (method) - find_label(self, label) -> citem_t - Find the label. - - @param label: (C++: int) - @return: pointer to the ctree item with the specified label number. - -ida_hexrays.cfunc_t.gather_derefs (method) - gather_derefs(self, ci, udm=None) -> bool - - @param ci: ctree_item_t const & - @param udm: udt_type_data_t * - -ida_hexrays.cfunc_t.get_boundaries (method) - get_boundaries(self) -> boundaries_t - Get pointer to map of instruction boundaries. This function initializes the - boundary map if not done yet. - -ida_hexrays.cfunc_t.get_eamap (method) - get_eamap(self) -> eamap_t - Get pointer to ea->insn map. This function initializes eamap if not done yet. - -ida_hexrays.cfunc_t.get_func_type (method) - get_func_type(self, type) -> bool - Get the function type. - - @param type: (C++: tinfo_t *) variable where the function type is returned - @return: false if failure - -ida_hexrays.cfunc_t.get_line_item (method) - get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool - Get ctree item for the specified cursor position. - - @param line: (C++: const char *) line of decompilation text (element of sv) - @param x: (C++: int) x cursor coordinate in the line - @param is_ctree_line: (C++: bool) does the line belong to statement area? (if not, it is - assumed to belong to the declaration area) - @param phead: (C++: ctree_item_t *) ptr to the first item on the line (used to attach block comments). - May be nullptr - @param pitem: (C++: ctree_item_t *) ptr to the current item. May be nullptr - @param ptail: (C++: ctree_item_t *) ptr to the last item on the line (used to attach indented - comments). May be nullptr - @see: vdui_t::get_current_item() - @return: false if failed to get the current item - -ida_hexrays.cfunc_t.get_lvars (method) - get_lvars(self) -> lvars_t - Get vector of local variables. - - @return: pointer to the vector of local variables. If you modify this vector, - the ctree must be regenerated in order to have correct cast operators. - Use build_c_tree() for that. Removing lvars should be done carefully: - all references in ctree and microcode must be corrected after that. - -ida_hexrays.cfunc_t.get_pseudocode (method) - get_pseudocode(self) -> strvec_t - Get pointer to decompilation output: the pseudocode. This function generates - pseudocode if not done yet. - -ida_hexrays.cfunc_t.get_stkoff_delta (method) - get_stkoff_delta(self) -> sval_t - Get stack offset delta. The local variable stack offsets retrieved by - v.location.stkoff() should be adjusted before being used as stack frame offsets - in IDA. - - @return: the delta to apply. example: ida_stkoff = v.location.stkoff() - - f->get_stkoff_delta() - -ida_hexrays.cfunc_t.get_user_cmt (method) - get_user_cmt(self, loc, rt) -> char const * - Retrieve a user defined comment. - - @param loc: (C++: const treeloc_t &) ctree location - @param rt: (C++: cmt_retrieval_type_t) should already retrieved comments retrieved again? - @return: pointer to the comment string or nullptr - -ida_hexrays.cfunc_t.get_user_iflags (method) - get_user_iflags(self, loc) -> int32 - Retrieve citem iflags. - - @param loc: (C++: const citem_locator_t &) citem locator - @return: ctree item iflags bits or 0 - -ida_hexrays.cfunc_t.get_user_union_selection (method) - get_user_union_selection(self, ea, path) -> bool - Retrieve a user defined union field selection. - - @param ea: (C++: ea_t) address - @param path: (C++: intvec_t *) out: path describing the union selection. - @return: pointer to the path or nullptr - -ida_hexrays.cfunc_t.get_warnings (method) - get_warnings(self) -> hexwarns_t - Get information about decompilation warnings. - - @return: reference to the vector of warnings - -ida_hexrays.cfunc_t.has_orphan_cmts (method) - has_orphan_cmts(self) -> bool - Check if there are orphan comments. - -ida_hexrays.cfunc_t.hdrlines (variable) - number of lines in the declaration area - -ida_hexrays.cfunc_t.locked (method) - locked(self) -> bool - -ida_hexrays.cfunc_t.maturity (variable) - maturity level - -ida_hexrays.cfunc_t.mba (variable) - underlying microcode - -ida_hexrays.cfunc_t.numforms (variable) - user-defined number formats. - -ida_hexrays.cfunc_t.print_dcl (method) - print_dcl(self) - Print function prototype. - -ida_hexrays.cfunc_t.print_func (method) - print_func(self, vp) - Print function text. - - @param vp: (C++: vc_printer_t &) printer helper class to receive the generated text. - -ida_hexrays.cfunc_t.refcnt (variable) - reference count to this object. use cfuncptr_t - -ida_hexrays.cfunc_t.refresh_func_ctext (method) - refresh_func_ctext(self) - Refresh ctext after a ctree modification. This function informs the decompiler - that ctree (body) have been modified and ctext (sv) does not correspond to it - anymore. It also refreshes the pseudocode windows if there is any. - -ida_hexrays.cfunc_t.release (method) - release(self) - -ida_hexrays.cfunc_t.remove_unused_labels (method) - remove_unused_labels(self) - Remove unused labels. This function checks what labels are really used by the - function and removes the unused ones. You must call it after deleting a goto - statement. - -ida_hexrays.cfunc_t.save_user_cmts (method) - save_user_cmts(self) - Save user-defined comments into the database. - -ida_hexrays.cfunc_t.save_user_iflags (method) - save_user_iflags(self) - Save user-defined iflags into the database. - -ida_hexrays.cfunc_t.save_user_labels (method) - save_user_labels(self) - Save user-defined labels into the database. - -ida_hexrays.cfunc_t.save_user_numforms (method) - save_user_numforms(self) - Save user-defined number formats into the database. - -ida_hexrays.cfunc_t.save_user_unions (method) - save_user_unions(self) - Save user-defined union field selections into the database. - -ida_hexrays.cfunc_t.set_user_cmt (method) - set_user_cmt(self, loc, cmt) - Set a user defined comment. This function stores the specified comment in the - cfunc_t structure. The save_user_cmts() function must be called after it. - - @param loc: (C++: const treeloc_t &) ctree location - @param cmt: (C++: const char *) new comment. if empty or nullptr, then an existing comment is - deleted. - -ida_hexrays.cfunc_t.set_user_iflags (method) - set_user_iflags(self, loc, iflags) - Set citem iflags. - - @param loc: (C++: const citem_locator_t &) citem locator - @param iflags: (C++: int32) new iflags - -ida_hexrays.cfunc_t.set_user_union_selection (method) - set_user_union_selection(self, ea, path) - Set a union field selection. The save_user_unions() function must be called - after calling this function. - - @param ea: (C++: ea_t) address - @param path: (C++: const intvec_t &) in: path describing the union selection. - -ida_hexrays.cfunc_t.statebits (variable) - current cfunc_t state. see cfunc state bits - -ida_hexrays.cfunc_t.treeitems (variable) - vector of ctree items - -ida_hexrays.cfunc_t.user_cmts (variable) - user-defined comments. - -ida_hexrays.cfunc_t.user_iflags (variable) - user-defined item flags ctree item iflags bits - -ida_hexrays.cfunc_t.user_labels (variable) - user-defined labels. - -ida_hexrays.cfunc_t.user_unions (variable) - user-defined union field selections. - -ida_hexrays.cfunc_t.verify (method) - verify(self, aul, even_without_debugger) - Verify the ctree. This function verifies the ctree. If the ctree is malformed, - an internal error is generated. Use it to verify the ctree after your - modifications. - - @param aul: (C++: allow_unused_labels_t) Are unused labels acceptable? - @param even_without_debugger: (C++: bool) if false and there is no debugger, the - verification will be skipped - -ida_hexrays.cfunc_type (function) - Get the function's return type tinfo_t object. - -ida_hexrays.cfuncptr_t (class) - Proxy of C++ qrefcnt_t< cfunc_t > class. - -ida_hexrays.cfuncptr_t.__deref__ (method) - __deref__(self) -> cfunc_t - -ida_hexrays.cfuncptr_t.__init__ (method) - __init__(self, p) -> cfuncptr_t - - @param p: cfunc_t * - - __init__(self, r) -> cfuncptr_t - - @param r: qrefcnt_t< cfunc_t > const & - -ida_hexrays.cfuncptr_t.__ptrval__ (method) - __ptrval__(self) -> size_t - -ida_hexrays.cfuncptr_t.__ref__ (method) - __ref__(self) -> cfunc_t - -ida_hexrays.cfuncptr_t.__str__ (method) - __str__(self) -> qstring - -ida_hexrays.cfuncptr_t.build_c_tree (method) - build_c_tree(self) - -ida_hexrays.cfuncptr_t.del_orphan_cmts (method) - del_orphan_cmts(self) -> int - -ida_hexrays.cfuncptr_t.find_item_coords (method) - find_item_coords(self, item, px, py) -> bool - - @param item: citem_t const * - @param px: int * - @param py: int * - - find_item_coords(self, item) -> (int, int), bool - - @param item: citem_t const * - -ida_hexrays.cfuncptr_t.find_label (method) - find_label(self, label) -> citem_t - - @param label: int - -ida_hexrays.cfuncptr_t.gather_derefs (method) - gather_derefs(self, ci, udm=None) -> bool - - @param ci: ctree_item_t const & - @param udm: udt_type_data_t * - -ida_hexrays.cfuncptr_t.get_boundaries (method) - get_boundaries(self) -> boundaries_t - -ida_hexrays.cfuncptr_t.get_eamap (method) - get_eamap(self) -> eamap_t - -ida_hexrays.cfuncptr_t.get_func_type (method) - get_func_type(self, type) -> bool - - @param type: tinfo_t * - -ida_hexrays.cfuncptr_t.get_line_item (method) - get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool - - @param line: char const * - @param x: int - @param is_ctree_line: bool - @param phead: ctree_item_t * - @param pitem: ctree_item_t * - @param ptail: ctree_item_t * - -ida_hexrays.cfuncptr_t.get_lvars (method) - get_lvars(self) -> lvars_t - -ida_hexrays.cfuncptr_t.get_pseudocode (method) - get_pseudocode(self) -> strvec_t - -ida_hexrays.cfuncptr_t.get_stkoff_delta (method) - get_stkoff_delta(self) -> sval_t - -ida_hexrays.cfuncptr_t.get_user_cmt (method) - get_user_cmt(self, loc, rt) -> char const * - - @param loc: treeloc_t const & - @param rt: enum cmt_retrieval_type_t - -ida_hexrays.cfuncptr_t.get_user_iflags (method) - get_user_iflags(self, loc) -> int32 - - @param loc: citem_locator_t const & - -ida_hexrays.cfuncptr_t.get_user_union_selection (method) - get_user_union_selection(self, ea, path) -> bool - - @param ea: ea_t - @param path: intvec_t * - -ida_hexrays.cfuncptr_t.get_warnings (method) - get_warnings(self) -> hexwarns_t - -ida_hexrays.cfuncptr_t.has_orphan_cmts (method) - has_orphan_cmts(self) -> bool - -ida_hexrays.cfuncptr_t.locked (method) - locked(self) -> bool - -ida_hexrays.cfuncptr_t.print_dcl (method) - print_dcl(self) - -ida_hexrays.cfuncptr_t.print_func (method) - print_func(self, vp) - - @param vp: vc_printer_t & - -ida_hexrays.cfuncptr_t.refresh_func_ctext (method) - refresh_func_ctext(self) - -ida_hexrays.cfuncptr_t.release (method) - release(self) - -ida_hexrays.cfuncptr_t.remove_unused_labels (method) - remove_unused_labels(self) - -ida_hexrays.cfuncptr_t.reset (method) - reset(self) - -ida_hexrays.cfuncptr_t.save_user_cmts (method) - save_user_cmts(self) - -ida_hexrays.cfuncptr_t.save_user_iflags (method) - save_user_iflags(self) - -ida_hexrays.cfuncptr_t.save_user_labels (method) - save_user_labels(self) - -ida_hexrays.cfuncptr_t.save_user_numforms (method) - save_user_numforms(self) - -ida_hexrays.cfuncptr_t.save_user_unions (method) - save_user_unions(self) - -ida_hexrays.cfuncptr_t.set_user_cmt (method) - set_user_cmt(self, loc, cmt) - - @param loc: treeloc_t const & - @param cmt: char const * - -ida_hexrays.cfuncptr_t.set_user_iflags (method) - set_user_iflags(self, loc, iflags) - - @param loc: citem_locator_t const & - @param iflags: int32 - -ida_hexrays.cfuncptr_t.set_user_union_selection (method) - set_user_union_selection(self, ea, path) - - @param ea: ea_t - @param path: intvec_t const & - -ida_hexrays.cfuncptr_t.verify (method) - verify(self, aul, even_without_debugger) - - @param aul: enum allow_unused_labels_t - @param even_without_debugger: bool - -ida_hexrays.cgoto_t (class) - Proxy of C++ cgoto_t class. - -ida_hexrays.cgoto_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__init__ (method) - __init__(self) -> cgoto_t - -ida_hexrays.cgoto_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.compare (method) - compare(self, r) -> int - - @param r: cgoto_t const & - -ida_hexrays.cgoto_t.label_num (variable) - Target label number. - -ida_hexrays.chain_keeper_t (class) - Proxy of C++ chain_keeper_t class. - -ida_hexrays.chain_keeper_t.__init__ (method) - __init__(self, _gc) -> chain_keeper_t - - @param _gc: graph_chains_t * - -ida_hexrays.chain_keeper_t.back (method) - back(self) -> block_chains_t - -ida_hexrays.chain_keeper_t.for_all_chains (method) - for_all_chains(self, cv, gca) -> int - - @param cv: chain_visitor_t & - @param gca: int - -ida_hexrays.chain_keeper_t.front (method) - front(self) -> block_chains_t - -ida_hexrays.chain_t (class) - Proxy of C++ chain_t class. - -ida_hexrays.chain_t.__init__ (method) - __init__(self) -> chain_t - __init__(self, t, off, w=1, v=-1) -> chain_t - - @param t: mopt_t - @param off: sval_t - @param w: int - @param v: int - - __init__(self, _k, w=1) -> chain_t - - @param _k: voff_t const & - @param w: int - -ida_hexrays.chain_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: chain_t const & - -ida_hexrays.chain_t._print (method) - _print(self) - -ida_hexrays.chain_t.append_list (method) - append_list(self, mba, list) - Append the contents of the chain to the specified list of locations. - - @param mba: (C++: const mba_t *) mba_t const * - @param list: (C++: mlist_t *) - -ida_hexrays.chain_t.clear_varnum (method) - clear_varnum(self) - -ida_hexrays.chain_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.chain_t.endoff (method) - endoff(self) -> voff_t - -ida_hexrays.chain_t.flags (variable) - combination Chain properties bits - -ida_hexrays.chain_t.get_reg (method) - get_reg(self) -> mreg_t - -ida_hexrays.chain_t.get_stkoff (method) - get_stkoff(self) -> sval_t - -ida_hexrays.chain_t.includes (method) - includes(self, r) -> bool - - @param r: chain_t const & - -ida_hexrays.chain_t.is_fake (method) - is_fake(self) -> bool - -ida_hexrays.chain_t.is_inited (method) - is_inited(self) -> bool - -ida_hexrays.chain_t.is_overlapped (method) - is_overlapped(self) -> bool - -ida_hexrays.chain_t.is_passreg (method) - is_passreg(self) -> bool - -ida_hexrays.chain_t.is_reg (method) - is_reg(self) -> bool - -ida_hexrays.chain_t.is_replaced (method) - is_replaced(self) -> bool - -ida_hexrays.chain_t.is_stkoff (method) - is_stkoff(self) -> bool - -ida_hexrays.chain_t.is_term (method) - is_term(self) -> bool - -ida_hexrays.chain_t.key (method) - key(self) -> voff_t - -ida_hexrays.chain_t.overlap (method) - overlap(self, r) -> bool - - @param r: chain_t const & - -ida_hexrays.chain_t.set_inited (method) - set_inited(self, b) - - @param b: bool - -ida_hexrays.chain_t.set_overlapped (method) - set_overlapped(self, b) - - @param b: bool - -ida_hexrays.chain_t.set_replaced (method) - set_replaced(self, b) - - @param b: bool - -ida_hexrays.chain_t.set_term (method) - set_term(self, b) - - @param b: bool - -ida_hexrays.chain_t.set_value (method) - set_value(self, r) - - @param r: chain_t const & - -ida_hexrays.chain_t.varnum (variable) - allocated variable index (-1 - not allocated yet) - -ida_hexrays.chain_t.width (variable) - size of the value in bytes - -ida_hexrays.chain_visitor_t (class) - Proxy of C++ chain_visitor_t class. - -ida_hexrays.chain_visitor_t.__disown__ (method) - -ida_hexrays.chain_visitor_t.__init__ (method) - __init__(self) -> chain_visitor_t - - @param self: PyObject * - -ida_hexrays.chain_visitor_t.parent (variable) - parent of the current chain - -ida_hexrays.chain_visitor_t.visit_chain (method) - visit_chain(self, nblock, ch) -> int - - @param nblock: int - @param ch: chain_t & - -ida_hexrays.change_hexrays_config (function) - change_hexrays_config(directive) -> bool - Parse DIRECTIVE and update the current configuration variables. For the syntax - see hexrays.cfg - - @param directive: (C++: const char *) char const * - -ida_hexrays.checkout_hexrays_license (function) - checkout_hexrays_license(silent) -> bool - Check out a floating decompiler license. This function will display a dialog box - if the license is not available. For non-floating licenses this function is - effectively no-op. It is not necessary to call this function before decompiling. - If the license was not checked out, the decompiler will automatically do it. - This function can be used to check out a license in advance and ensure that a - license is available. - - @param silent: (C++: bool) silently fail if the license cannot be checked out. - @return: false if failed - -ida_hexrays.cif_t (class) - Proxy of C++ cif_t class. - -ida_hexrays.cif_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cif_t const & - -ida_hexrays.cif_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cif_t const & - -ida_hexrays.cif_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cif_t const & - -ida_hexrays.cif_t.__init__ (method) - __init__(self) -> cif_t - __init__(self, r) -> cif_t - - @param r: cif_t const & - -ida_hexrays.cif_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cif_t const & - -ida_hexrays.cif_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cif_t const & - -ida_hexrays.cif_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cif_t const & - -ida_hexrays.cif_t.assign (method) - assign(self, r) -> cif_t - - @param r: cif_t const & - -ida_hexrays.cif_t.cleanup (method) - cleanup(self) - -ida_hexrays.cif_t.compare (method) - compare(self, r) -> int - - @param r: cif_t const & - -ida_hexrays.cif_t.ielse (variable) - Else-branch of the if-statement. May be nullptr. - -ida_hexrays.cif_t.ithen (variable) - Then-branch of the if-statement. - -ida_hexrays.cinsn_details (function) - 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. - -ida_hexrays.cinsn_list_t (class) - Proxy of C++ qlist< cinsn_t > class. - -ida_hexrays.cinsn_list_t.__eq__ (method) - __eq__(self, x) -> bool - - @param x: qlist< cinsn_t > const & - -ida_hexrays.cinsn_list_t.__getitem__ (method) - __getitem__(self, i) -> cinsn_t - - @param i: size_t - -ida_hexrays.cinsn_list_t.__init__ (method) - __init__(self) -> cinsn_list_t - __init__(self, x) -> cinsn_list_t - - @param x: qlist< cinsn_t > const & - -ida_hexrays.cinsn_list_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.cinsn_list_t.__ne__ (method) - __ne__(self, x) -> bool - - @param x: qlist< cinsn_t > const & - -ida_hexrays.cinsn_list_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: cinsn_t const & - -ida_hexrays.cinsn_list_t.at (method) - -ida_hexrays.cinsn_list_t.back (method) - back(self) -> cinsn_t - -ida_hexrays.cinsn_list_t.begin (method) - begin(self) -> cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t.clear (method) - clear(self) - -ida_hexrays.cinsn_list_t.empty (method) - empty(self) -> bool - -ida_hexrays.cinsn_list_t.end (method) - end(self) -> cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t.erase (method) - erase(self, p) - - @param p: cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t.find (method) - -ida_hexrays.cinsn_list_t.front (method) - front(self) -> cinsn_t - -ida_hexrays.cinsn_list_t.index (method) - -ida_hexrays.cinsn_list_t.insert (method) - insert(self, i, v) - - @param i: size_t - @param v: cinsn_t const & - - insert(self, p, x) -> cinsn_list_t_iterator - - @param p: cinsn_list_t_iterator - @param x: cinsn_t const & - -ida_hexrays.cinsn_list_t.pop_back (method) - pop_back(self) - -ida_hexrays.cinsn_list_t.pop_front (method) - pop_front(self) - -ida_hexrays.cinsn_list_t.push_back (method) - push_back(self, x) - - @param x: cinsn_t const & - - push_back(self) -> cinsn_t - -ida_hexrays.cinsn_list_t.push_front (method) - push_front(self, x) - - @param x: cinsn_t const & - -ida_hexrays.cinsn_list_t.rbegin (method) - rbegin(self) -> qlist< cinsn_t >::reverse_iterator - rbegin(self) -> qlist< cinsn_t >::const_reverse_iterator - -ida_hexrays.cinsn_list_t.remove (method) - remove(self, v) -> bool - - @param v: cinsn_t const & - -ida_hexrays.cinsn_list_t.rend (method) - rend(self) -> qlist< cinsn_t >::reverse_iterator - rend(self) -> qlist< cinsn_t >::const_reverse_iterator - -ida_hexrays.cinsn_list_t.size (method) - size(self) -> size_t - -ida_hexrays.cinsn_list_t.swap (method) - swap(self, x) - - @param x: qlist< cinsn_t > & - -ida_hexrays.cinsn_list_t_iterator (class) - Proxy of C++ cinsn_list_t_iterator class. - -ida_hexrays.cinsn_list_t_iterator.__eq__ (method) - __eq__(self, x) -> bool - - @param x: cinsn_list_t_iterator const * - -ida_hexrays.cinsn_list_t_iterator.__init__ (method) - __init__(self) -> cinsn_list_t_iterator - -ida_hexrays.cinsn_list_t_iterator.__ne__ (method) - __ne__(self, x) -> bool - - @param x: cinsn_list_t_iterator const * - -ida_hexrays.cinsn_list_t_iterator.__next__ (method) - __next__(self) - -ida_hexrays.cinsn_t (class) - Proxy of C++ cinsn_t class. - -ida_hexrays.cinsn_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__init__ (method) - __init__(self) -> cinsn_t - __init__(self, r) -> cinsn_t - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t._deregister (method) - _deregister(self) - -ida_hexrays.cinsn_t._get_casm (method) - _get_casm(self) -> casm_t - -ida_hexrays.cinsn_t._get_cblock (method) - _get_cblock(self) -> cblock_t - -ida_hexrays.cinsn_t._get_cdo (method) - _get_cdo(self) -> cdo_t - -ida_hexrays.cinsn_t._get_cexpr (method) - _get_cexpr(self) -> cexpr_t - -ida_hexrays.cinsn_t._get_cfor (method) - _get_cfor(self) -> cfor_t - -ida_hexrays.cinsn_t._get_cgoto (method) - _get_cgoto(self) -> cgoto_t - -ida_hexrays.cinsn_t._get_cif (method) - _get_cif(self) -> cif_t - -ida_hexrays.cinsn_t._get_creturn (method) - _get_creturn(self) -> creturn_t - -ida_hexrays.cinsn_t._get_cswitch (method) - _get_cswitch(self) -> cswitch_t - -ida_hexrays.cinsn_t._get_cwhile (method) - _get_cwhile(self) -> cwhile_t - -ida_hexrays.cinsn_t._print (method) - _print(self, indent, vp, use_curly=CALC_CURLY_BRACES) - - Parameters - ---------- - indent: int - vp: vc_printer_t & - use_curly: enum use_curly_t - -ida_hexrays.cinsn_t._register (method) - _register(self) - -ida_hexrays.cinsn_t._replace_by (method) - _replace_by(self, r) - - Parameters - ---------- - r: cinsn_t * - -ida_hexrays.cinsn_t._set_casm (method) - _set_casm(self, _v) - - Parameters - ---------- - _v: casm_t * - -ida_hexrays.cinsn_t._set_cblock (method) - _set_cblock(self, _v) - - Parameters - ---------- - _v: cblock_t * - -ida_hexrays.cinsn_t._set_cdo (method) - _set_cdo(self, _v) - - Parameters - ---------- - _v: cdo_t * - -ida_hexrays.cinsn_t._set_cexpr (method) - _set_cexpr(self, _v) - - Parameters - ---------- - _v: cexpr_t * - -ida_hexrays.cinsn_t._set_cfor (method) - _set_cfor(self, _v) - - Parameters - ---------- - _v: cfor_t * - -ida_hexrays.cinsn_t._set_cgoto (method) - _set_cgoto(self, _v) - - Parameters - ---------- - _v: cgoto_t * - -ida_hexrays.cinsn_t._set_cif (method) - _set_cif(self, _v) - - Parameters - ---------- - _v: cif_t * - -ida_hexrays.cinsn_t._set_creturn (method) - _set_creturn(self, _v) - - Parameters - ---------- - _v: creturn_t * - -ida_hexrays.cinsn_t._set_cswitch (method) - _set_cswitch(self, _v) - - Parameters - ---------- - _v: cswitch_t * - -ida_hexrays.cinsn_t._set_cwhile (method) - _set_cwhile(self, _v) - - Parameters - ---------- - _v: cwhile_t * - -ida_hexrays.cinsn_t.assign (method) - assign(self, r) -> cinsn_t - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.casm (variable) - details of asm-statement - -ida_hexrays.cinsn_t.cblock (variable) - details of block-statement - -ida_hexrays.cinsn_t.cdo (variable) - details of do-statement - -ida_hexrays.cinsn_t.cexpr (variable) - details of expression-statement - -ida_hexrays.cinsn_t.cfor (variable) - details of for-statement - -ida_hexrays.cinsn_t.cgoto (variable) - details of goto-statement - -ida_hexrays.cinsn_t.cif (variable) - details of if-statement - -ida_hexrays.cinsn_t.cleanup (method) - cleanup(self) - Cleanup the statement. This function properly deletes all children and sets the - item type to cit_empty. - -ida_hexrays.cinsn_t.collect_free_breaks (method) - collect_free_breaks(self, breaks) -> bool - Collect free break statements. This function finds all free break statements - within the current statement. A break statement is free if it does not have a - loop or switch parent that that is also within the current statement. - - @param breaks: (C++: cinsnptrvec_t *) pointer to the variable where the vector of all found free break - statements is returned. This argument can be nullptr. - @return: true if some free break statements have been found - -ida_hexrays.cinsn_t.collect_free_continues (method) - collect_free_continues(self, continues) -> bool - Collect free continue statements. This function finds all free continue - statements within the current statement. A continue statement is free if it does - not have a loop parent that that is also within the current statement. - - @param continues: (C++: cinsnptrvec_t *) pointer to the variable where the vector of all found free - continue statements is returned. This argument can be nullptr. - @return: true if some free continue statements have been found - -ida_hexrays.cinsn_t.compare (method) - compare(self, r) -> int - - @param r: cinsn_t const & - -ida_hexrays.cinsn_t.contains_free_break (method) - contains_free_break(self) -> bool - Check if the statement has free break statements. - -ida_hexrays.cinsn_t.contains_free_continue (method) - contains_free_continue(self) -> bool - Check if the statement has free continue statements. - -ida_hexrays.cinsn_t.contains_insn (method) - contains_insn(self, type, times=1) -> bool - Check if the statement contains a statement of the specified type. - - @param type: (C++: ctype_t) statement opcode to look for - @param times: (C++: int) how many times TYPE should be present - @return: true if the statement has at least TIMES children with opcode == TYPE - -ida_hexrays.cinsn_t.create_if (method) - create_if(self, cnd) -> cif_t - Create a new if-statement. The current statement must be a block. The new - statement will be appended to it. - - @param cnd: (C++: cexpr_t *) if condition. It will be deleted after being copied. - -ida_hexrays.cinsn_t.creturn (variable) - details of return-statement - -ida_hexrays.cinsn_t.cswitch (variable) - details of switch-statement - -ida_hexrays.cinsn_t.cwhile (variable) - details of while-statement - -ida_hexrays.cinsn_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.cinsn_t.insn_is_epilog (method) - insn_is_epilog(insn) -> bool - - @param insn: cinsn_t const * - -ida_hexrays.cinsn_t.is_epilog (method) - -ida_hexrays.cinsn_t.is_ordinary_flow (method) - is_ordinary_flow(self) -> bool - Check if the statement passes execution to the next statement. - - @return: false if the statement breaks the control flow (like goto, return, etc) - -ida_hexrays.cinsn_t.new_insn (method) - new_insn(self, insn_ea) -> cinsn_t - Create a new statement. The current statement must be a block. The new statement - will be appended to it. - - @param insn_ea: (C++: ea_t) statement address - -ida_hexrays.cinsn_t.print1 (method) - print1(self, func) - Print the statement into one line. Currently this function is not available. - - @param func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced - variable names. - -ida_hexrays.cinsn_t.swap (method) - swap(self, r) - - @param r: cinsn_t & - -ida_hexrays.cinsn_t.zero (method) - zero(self) - Overwrite with zeroes without cleaning memory or deleting children. - -ida_hexrays.cinsn_t_insn_is_epilog (function) - cinsn_t_insn_is_epilog(insn) -> bool - - @param insn: cinsn_t const * - -ida_hexrays.cinsnptrvec_t (class) - Proxy of C++ qvector< cinsn_t * > class. - -ida_hexrays.cinsnptrvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< cinsn_t * > const & - -ida_hexrays.cinsnptrvec_t.__getitem__ (method) - __getitem__(self, i) -> cinsn_t - - @param i: size_t - -ida_hexrays.cinsnptrvec_t.__init__ (method) - __init__(self) -> cinsnptrvec_t - __init__(self, x) -> cinsnptrvec_t - - @param x: qvector< cinsn_t * > const & - -ida_hexrays.cinsnptrvec_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.cinsnptrvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< cinsn_t * > const & - -ida_hexrays.cinsnptrvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: cinsn_t *const & - -ida_hexrays.cinsnptrvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: cinsn_t *const & - -ida_hexrays.cinsnptrvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: cinsn_t *const & - -ida_hexrays.cinsnptrvec_t.at (method) - at(self, _idx) -> cinsn_t - - @param _idx: size_t - -ida_hexrays.cinsnptrvec_t.begin (method) - begin(self) -> qvector< cinsn_t * >::iterator - begin(self) -> qvector< cinsn_t * >::const_iterator - -ida_hexrays.cinsnptrvec_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.cinsnptrvec_t.clear (method) - clear(self) - -ida_hexrays.cinsnptrvec_t.empty (method) - empty(self) -> bool - -ida_hexrays.cinsnptrvec_t.end (method) - end(self) -> qvector< cinsn_t * >::iterator - end(self) -> qvector< cinsn_t * >::const_iterator - -ida_hexrays.cinsnptrvec_t.erase (method) - erase(self, it) -> qvector< cinsn_t * >::iterator - - @param it: qvector< cinsn_t * >::iterator - - erase(self, first, last) -> qvector< cinsn_t * >::iterator - - @param first: qvector< cinsn_t * >::iterator - @param last: qvector< cinsn_t * >::iterator - -ida_hexrays.cinsnptrvec_t.extract (method) - extract(self) -> cinsn_t ** - -ida_hexrays.cinsnptrvec_t.find (method) - find(self, x) -> qvector< cinsn_t * >::iterator - - @param x: cinsn_t *const & - - find(self, x) -> qvector< cinsn_t * >::const_iterator - - @param x: cinsn_t *const & - -ida_hexrays.cinsnptrvec_t.has (method) - has(self, x) -> bool - - @param x: cinsn_t *const & - -ida_hexrays.cinsnptrvec_t.inject (method) - inject(self, s, len) - - @param s: cinsn_t ** - @param len: size_t - -ida_hexrays.cinsnptrvec_t.insert (method) - insert(self, it, x) -> qvector< cinsn_t * >::iterator - - @param it: qvector< cinsn_t * >::iterator - @param x: cinsn_t *const & - -ida_hexrays.cinsnptrvec_t.pop_back (method) - pop_back(self) - -ida_hexrays.cinsnptrvec_t.push_back (method) - push_back(self, x) - - @param x: cinsn_t *const & - - push_back(self) -> cinsn_t *& - -ida_hexrays.cinsnptrvec_t.qclear (method) - qclear(self) - -ida_hexrays.cinsnptrvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.cinsnptrvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: cinsn_t *const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.cinsnptrvec_t.size (method) - size(self) -> size_t - -ida_hexrays.cinsnptrvec_t.swap (method) - swap(self, r) - - @param r: qvector< cinsn_t * > & - -ida_hexrays.cinsnptrvec_t.truncate (method) - truncate(self) - -ida_hexrays.cit_asm (variable) - asm-statement - -ida_hexrays.cit_block (variable) - block-statement: { ... } - -ida_hexrays.cit_break (variable) - break-statement - -ida_hexrays.cit_continue (variable) - continue-statement - -ida_hexrays.cit_do (variable) - do-statement - -ida_hexrays.cit_empty (variable) - instruction types start here - -ida_hexrays.cit_expr (variable) - expression-statement: expr; - -ida_hexrays.cit_for (variable) - for-statement - -ida_hexrays.cit_goto (variable) - goto-statement - -ida_hexrays.cit_if (variable) - if-statement - -ida_hexrays.cit_return (variable) - return-statement - -ida_hexrays.cit_switch (variable) - switch-statement - -ida_hexrays.cit_while (variable) - while-statement - -ida_hexrays.citem_cmt_t (class) - Proxy of C++ citem_cmt_t class. - -ida_hexrays.citem_cmt_t.__init__ (method) - __init__(self) -> citem_cmt_t - __init__(self, s) -> citem_cmt_t - - @param s: char const * - -ida_hexrays.citem_cmt_t.__str__ (method) - __str__(self) -> char const * - -ida_hexrays.citem_cmt_t.c_str (method) - c_str(self) -> char const * - -ida_hexrays.citem_cmt_t.used (variable) - the comment has been retrieved? - -ida_hexrays.citem_locator_t (class) - Proxy of C++ citem_locator_t class. - -ida_hexrays.citem_locator_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: citem_locator_t const & - -ida_hexrays.citem_locator_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: citem_locator_t const & - -ida_hexrays.citem_locator_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: citem_locator_t const & - -ida_hexrays.citem_locator_t.__init__ (method) - __init__(self, _ea, _op) -> citem_locator_t - - @param _ea: ea_t - @param _op: enum ctype_t - - __init__(self, i) -> citem_locator_t - - @param i: citem_t const * - -ida_hexrays.citem_locator_t.__le__ (method) - __le__(self, r) -> bool - - @param r: citem_locator_t const & - -ida_hexrays.citem_locator_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: citem_locator_t const & - -ida_hexrays.citem_locator_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: citem_locator_t const & - -ida_hexrays.citem_locator_t.compare (method) - compare(self, r) -> int - - @param r: citem_locator_t const & - -ida_hexrays.citem_locator_t.ea (variable) - citem address - -ida_hexrays.citem_locator_t.op (variable) - citem operation - -ida_hexrays.citem_t (class) - Proxy of C++ citem_t class. - -ida_hexrays.citem_t.__dbg_get_meminfo (method) - __dbg_get_meminfo(self) -> qstring - -ida_hexrays.citem_t.__dbg_get_registered_kind (method) - __dbg_get_registered_kind(self) -> int - -ida_hexrays.citem_t.__init__ (method) - __init__(self, o=cot_empty) -> citem_t - - @param o: enum ctype_t - -ida_hexrays.citem_t._acquire_ownership (method) - -ida_hexrays.citem_t._ensure_cond (method) - -ida_hexrays.citem_t._ensure_no_obj (method) - -ida_hexrays.citem_t._ensure_no_op (method) - -ida_hexrays.citem_t._ensure_ownership_transferrable (method) - -ida_hexrays.citem_t._get_op (method) - _get_op(self) -> ctype_t - -ida_hexrays.citem_t._maybe_disown_and_deregister (method) - -ida_hexrays.citem_t._meminfo (method) - -ida_hexrays.citem_t._obj_id (method) - _obj_id(self) -> PyObject * - -ida_hexrays.citem_t._own_and_register (method) - -ida_hexrays.citem_t._set_op (method) - _set_op(self, v) - - Parameters - ---------- - v: enum ctype_t - -ida_hexrays.citem_t.contains_expr (method) - contains_expr(self, e) -> bool - Does the item contain an expression? - - @param e: (C++: const cexpr_t *) cexpr_t const * - -ida_hexrays.citem_t.contains_label (method) - contains_label(self) -> bool - Does the item contain a label? - -ida_hexrays.citem_t.ea (variable) - address that corresponds to the item. may be BADADDR - -ida_hexrays.citem_t.find_closest_addr (method) - find_closest_addr(self, _ea) -> citem_t - - @param _ea: ea_t - -ida_hexrays.citem_t.find_parent_of (method) - find_parent_of(self, sitem) -> citem_t - - @param sitem: citem_t const * - - find_parent_of(self, item) -> citem_t - - @param item: citem_t const * - -ida_hexrays.citem_t.index (variable) - an index in cfunc_t::treeitems. meaningful only after print_func() - -ida_hexrays.citem_t.is_expr (method) - is_expr(self) -> bool - Is an expression? - -ida_hexrays.citem_t.label_num (variable) - label number. -1 means no label. items of the expression types (cot_...) should - not have labels at the final maturity level, but at the intermediate levels any - ctree item may have a label. Labels must be unique. Usually they correspond to - the basic block numbers. - -ida_hexrays.citem_t.op (variable) - item type - -ida_hexrays.citem_t.print1 (method) - print1(self, func) - Print item into one line. - - @param func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced - variable names. - @return: length of the generated text. - -ida_hexrays.citem_t.replace_by (method) - -ida_hexrays.citem_t.swap (method) - swap(self, r) - Swap two citem_t. - - @param r: (C++: citem_t &) - -ida_hexrays.citem_to_specific_type (function) - cast the citem_t object to its more specific type, either cexpr_t or cinsn_t. - -ida_hexrays.clear_cached_cfuncs (function) - clear_cached_cfuncs() - Flush all cached decompilation results. - -ida_hexrays.cloop_t (class) - Proxy of C++ cloop_t class. - -ida_hexrays.cloop_t.__init__ (method) - __init__(self, b=None) -> cloop_t - - @param b: cinsn_t * - - __init__(self, r) -> cloop_t - - @param r: cloop_t const & - -ida_hexrays.cloop_t.assign (method) - assign(self, r) -> cloop_t - - @param r: cloop_t const & - -ida_hexrays.cloop_t.cleanup (method) - cleanup(self) - -ida_hexrays.close_hexrays_waitbox (function) - close_hexrays_waitbox() - Close the waitbox displayed by the decompiler. Useful if DECOMP_NO_HIDE was used - during decompilation. - -ida_hexrays.close_pseudocode (function) - close_pseudocode(f) -> bool - Close pseudocode window. - - @param f: (C++: TWidget *) pointer to window - @return: false if failed - -ida_hexrays.cnumber_t (class) - Proxy of C++ cnumber_t class. - -ida_hexrays.cnumber_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cnumber_t const & - -ida_hexrays.cnumber_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cnumber_t const & - -ida_hexrays.cnumber_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cnumber_t const & - -ida_hexrays.cnumber_t.__init__ (method) - __init__(self, _opnum=0) -> cnumber_t - - @param _opnum: int - -ida_hexrays.cnumber_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cnumber_t const & - -ida_hexrays.cnumber_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cnumber_t const & - -ida_hexrays.cnumber_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cnumber_t const & - -ida_hexrays.cnumber_t._print (method) - _print(self, type, parent=None, nice_stroff=None) - - Parameters - ---------- - type: tinfo_t const & - parent: citem_t const * - nice_stroff: bool * - -ida_hexrays.cnumber_t._value (variable) - its value - -ida_hexrays.cnumber_t.assign (method) - assign(self, v, nbytes, sign) - Assign new value - - @param v: (C++: uint64) new value - @param nbytes: (C++: int) size of the new value in bytes - @param sign: (C++: type_sign_t) sign of the value - -ida_hexrays.cnumber_t.compare (method) - compare(self, r) -> int - - @param r: cnumber_t const & - -ida_hexrays.cnumber_t.nf (variable) - how to represent it - -ida_hexrays.cnumber_t.value (method) - value(self, type) -> uint64 - Get value. This function will properly extend the number sign to 64bits - depending on the type sign. - - @param type: (C++: const tinfo_t &) tinfo_t const & - -ida_hexrays.codegen_t (class) - Proxy of C++ codegen_t class. - -ida_hexrays.codegen_t.__init__ (method) - -ida_hexrays.codegen_t.analyze_prolog (method) - analyze_prolog(self, fc, reachable) -> merror_t - Analyze prolog/epilog of the function to decompile. If prolog is found, allocate - and fill 'mba->pi' structure. - - @param fc: (C++: const class qflow_chart_t &) flow chart - @param reachable: (C++: const class bitset_t &) bitmap of reachable blocks - @return: error code - -ida_hexrays.codegen_t.emit (method) - emit(self, code, width, l, r, d, offsize) -> minsn_t - Emit one microinstruction. This variant accepts pointers to operands. It is more - difficult to use but permits to create virtually any instruction. Operands may - be nullptr when it makes sense. - - @param code: (C++: mcode_t) enum mcode_t - @param width: int - @param l: (C++: const mop_t *) uval_t - @param r: (C++: const mop_t *) uval_t - @param d: (C++: const mop_t *) uval_t - @param offsize: int - - emit(self, code, l, r, d) -> minsn_t - - @param code: enum mcode_t - @param l: mop_t const * - @param r: mop_t const * - @param d: mop_t const * - -ida_hexrays.codegen_t.emit_micro_mvm (method) - emit_micro_mvm(self, code, dtype, l, r, d, offsize) -> minsn_t - Emit one microinstruction. This variant takes a data type not a size. - - @param code: (C++: mcode_t) enum mcode_t - @param dtype: (C++: op_dtype_t) - @param l: (C++: uval_t) - @param r: (C++: uval_t) - @param d: (C++: uval_t) - @param offsize: (C++: int) - -ida_hexrays.codegen_t.gen_micro (method) - gen_micro(self) -> merror_t - Generate microcode for one instruction. The instruction is in INSN - - @return: MERR_OK - all ok MERR_BLOCK - all ok, need to switch to new block - MERR_BADBLK - delete current block and continue other error codes are - fatal - -ida_hexrays.codegen_t.load_effective_address (method) - load_effective_address(self, n, flags=0) -> mreg_t - Generate microcode to calculate the address of a memory operand. - - @param n: (C++: int) - number of INSN operand - @param flags: (C++: int) - reserved for future use - @return: register containing the operand address. mr_none - failed (not a memory - operand) - -ida_hexrays.codegen_t.load_operand (method) - load_operand(self, opnum, flags=0) -> mreg_t - Generate microcode to load one operand. - - @param opnum: (C++: int) number of INSN operand - @param flags: (C++: int) reserved for future use - @return: register containing the operand. - -ida_hexrays.codegen_t.microgen_completed (method) - microgen_completed(self) - This method is called when the microcode generation is done. - -ida_hexrays.codegen_t.prepare_gen_micro (method) - prepare_gen_micro(self) -> merror_t - Setup internal data to handle new instruction. This method should be called - before calling gen_micro(). Usually gen_micro() is called by the decompiler. You - have to call this function explicitly only if you yourself call gen_micro(). The - instruction is in INSN - - @return: MERR_OK - all ok other error codes are fatal - -ida_hexrays.codegen_t.store_operand (method) - store_operand(self, n, mop, flags=0, outins=None) -> bool - Generate microcode to store an operand. In case of success an arbitrary number - of instructions can be generated (and even no instruction if the source and - target are the same) - - @param n: (C++: int) - number of target INSN operand - @param mop: (C++: const mop_t &) - operand to be stored - @param flags: (C++: int) - reserved for future use - @param outins: (C++: minsn_t **) - (OUT) the last generated instruction - @return: success - -ida_hexrays.convert_to_user_call (function) - convert_to_user_call(udc, cdg) -> merror_t - try to generate user-defined call for an instruction - - @param udc: (C++: const udcall_t &) udcall_t const & - @param cdg: (C++: codegen_t &) - @return: Microcode error codes code: MERR_OK - user-defined call generated else - - error (MERR_INSN == inacceptable udc.tif) - -ida_hexrays.cot_add (variable) - x + y - -ida_hexrays.cot_asg (variable) - x = y - -ida_hexrays.cot_asgadd (variable) - x += y - -ida_hexrays.cot_asgband (variable) - x &= y - -ida_hexrays.cot_asgbor (variable) - x |= y - -ida_hexrays.cot_asgmul (variable) - x *= y - -ida_hexrays.cot_asgsdiv (variable) - x /= y signed - -ida_hexrays.cot_asgshl (variable) - x <<= y - -ida_hexrays.cot_asgsmod (variable) - x %= y signed - -ida_hexrays.cot_asgsshr (variable) - x >>= y signed - -ida_hexrays.cot_asgsub (variable) - x -= y - -ida_hexrays.cot_asgudiv (variable) - x /= y unsigned - -ida_hexrays.cot_asgumod (variable) - x %= y unsigned - -ida_hexrays.cot_asgushr (variable) - x >>= y unsigned - -ida_hexrays.cot_asgxor (variable) - x ^= y - -ida_hexrays.cot_band (variable) - x & y - -ida_hexrays.cot_bnot (variable) - ~x - -ida_hexrays.cot_bor (variable) - x | y - -ida_hexrays.cot_call (variable) - x(...) - -ida_hexrays.cot_cast (variable) - (type)x - -ida_hexrays.cot_comma (variable) - x, y - -ida_hexrays.cot_eq (variable) - x == y int or fpu (see EXFL_FPOP) - -ida_hexrays.cot_fadd (variable) - x + y fp - -ida_hexrays.cot_fdiv (variable) - x / y fp - -ida_hexrays.cot_fmul (variable) - x * y fp - -ida_hexrays.cot_fneg (variable) - -x fp - -ida_hexrays.cot_fnum (variable) - fpc - -ida_hexrays.cot_fsub (variable) - x - y fp - -ida_hexrays.cot_helper (variable) - arbitrary name - -ida_hexrays.cot_idx (variable) - x[y] - -ida_hexrays.cot_insn (variable) - instruction in expression, internal representation only - -ida_hexrays.cot_land (variable) - x && y - -ida_hexrays.cot_lnot (variable) - !x - -ida_hexrays.cot_lor (variable) - x || y - -ida_hexrays.cot_memptr (variable) - x->m, access size in 'ptrsize' - -ida_hexrays.cot_memref (variable) - x.m - -ida_hexrays.cot_mul (variable) - x * y - -ida_hexrays.cot_ne (variable) - x != y int or fpu (see EXFL_FPOP) - -ida_hexrays.cot_neg (variable) - -x - -ida_hexrays.cot_num (variable) - n - -ida_hexrays.cot_obj (variable) - obj_ea - -ida_hexrays.cot_postdec (variable) - x- - -ida_hexrays.cot_postinc (variable) - x++ - -ida_hexrays.cot_predec (variable) - -x - -ida_hexrays.cot_preinc (variable) - ++x - -ida_hexrays.cot_ptr (variable) - *x, access size in 'ptrsize' - -ida_hexrays.cot_ref (variable) - &x - -ida_hexrays.cot_sdiv (variable) - x / y signed - -ida_hexrays.cot_sge (variable) - x >= y signed or fpu (see EXFL_FPOP) - -ida_hexrays.cot_sgt (variable) - x > y signed or fpu (see EXFL_FPOP) - -ida_hexrays.cot_shl (variable) - x << y - -ida_hexrays.cot_sizeof (variable) - sizeof(x) - -ida_hexrays.cot_sle (variable) - x <= y signed or fpu (see EXFL_FPOP) - -ida_hexrays.cot_slt (variable) - x < y signed or fpu (see EXFL_FPOP) - -ida_hexrays.cot_smod (variable) - x % y signed - -ida_hexrays.cot_sshr (variable) - x >> y signed - -ida_hexrays.cot_str (variable) - string constant (user representation) - -ida_hexrays.cot_sub (variable) - x - y - -ida_hexrays.cot_tern (variable) - x ? y : z - -ida_hexrays.cot_type (variable) - arbitrary type - -ida_hexrays.cot_udiv (variable) - x / y unsigned - -ida_hexrays.cot_uge (variable) - x >= y unsigned - -ida_hexrays.cot_ugt (variable) - x > y unsigned - -ida_hexrays.cot_ule (variable) - x <= y unsigned - -ida_hexrays.cot_ult (variable) - x < y unsigned - -ida_hexrays.cot_umod (variable) - x % y unsigned - -ida_hexrays.cot_ushr (variable) - x >> y unsigned - -ida_hexrays.cot_var (variable) - v - -ida_hexrays.cot_xor (variable) - x ^ y - -ida_hexrays.create_cfunc (function) - create_cfunc(mba) -> cfuncptr_t - Create a new cfunc_t object. - - @param mba: (C++: mba_t *) microcode object. After creating the cfunc object it takes the - ownership of MBA. - -ida_hexrays.create_empty_mba (function) - create_empty_mba(mbr, hf=None) -> mba_t - Create an empty microcode object. - - @param mbr: (C++: const mba_ranges_t &) mba_ranges_t const & - @param hf: (C++: hexrays_failure_t *) - -ida_hexrays.create_field_name (function) - create_field_name(type, offset=BADADDR) -> qstring - - @param type: tinfo_t const & - @param offset: uval_t - -ida_hexrays.create_helper (function) - Create a helper object.. - -ida_hexrays.create_typedef (function) - create_typedef(name) -> tinfo_t - Create a reference to an ordinal type. - - @param name: char const * - - @return: type which refers to the specified ordinal. For example, if n is 1, the - type info which refers to ordinal type 1 is created. - create_typedef(n) -> tinfo_t - - @param n: int - -ida_hexrays.creturn_t (class) - Proxy of C++ creturn_t class. - -ida_hexrays.creturn_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: creturn_t const & - -ida_hexrays.creturn_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: creturn_t const & - -ida_hexrays.creturn_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: creturn_t const & - -ida_hexrays.creturn_t.__init__ (method) - __init__(self) -> creturn_t - -ida_hexrays.creturn_t.__le__ (method) - __le__(self, r) -> bool - - @param r: creturn_t const & - -ida_hexrays.creturn_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: creturn_t const & - -ida_hexrays.creturn_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: creturn_t const & - -ida_hexrays.creturn_t.compare (method) - compare(self, r) -> int - - @param r: creturn_t const & - -ida_hexrays.cswitch_t (class) - Proxy of C++ cswitch_t class. - -ida_hexrays.cswitch_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cswitch_t const & - -ida_hexrays.cswitch_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cswitch_t const & - -ida_hexrays.cswitch_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cswitch_t const & - -ida_hexrays.cswitch_t.__init__ (method) - __init__(self) -> cswitch_t - -ida_hexrays.cswitch_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cswitch_t const & - -ida_hexrays.cswitch_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cswitch_t const & - -ida_hexrays.cswitch_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cswitch_t const & - -ida_hexrays.cswitch_t.cases (variable) - Switch cases: values and instructions. - -ida_hexrays.cswitch_t.compare (method) - compare(self, r) -> int - - @param r: cswitch_t const & - -ida_hexrays.cswitch_t.mvnf (variable) - Maximal switch value and number format. - -ida_hexrays.ctext_position_t (class) - Proxy of C++ ctext_position_t class. - -ida_hexrays.ctext_position_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ctext_position_t const & - -ida_hexrays.ctext_position_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ctext_position_t const & - -ida_hexrays.ctext_position_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ctext_position_t const & - -ida_hexrays.ctext_position_t.__init__ (method) - __init__(self, _lnnum=-1, _x=0, _y=0) -> ctext_position_t - - @param _lnnum: int - @param _x: int - @param _y: int - -ida_hexrays.ctext_position_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ctext_position_t const & - -ida_hexrays.ctext_position_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ctext_position_t const & - -ida_hexrays.ctext_position_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ctext_position_t const & - -ida_hexrays.ctext_position_t.compare (method) - compare(self, r) -> int - - @param r: ctext_position_t const & - -ida_hexrays.ctext_position_t.in_ctree (method) - in_ctree(self, hdrlines) -> bool - Is the cursor in the variable/type declaration area? - - @param hdrlines: (C++: int) Number of lines of the declaration area - -ida_hexrays.ctext_position_t.lnnum (variable) - Line number. - -ida_hexrays.ctext_position_t.x (variable) - x coordinate of the cursor within the window - -ida_hexrays.ctext_position_t.y (variable) - y coordinate of the cursor within the window - -ida_hexrays.ctree_anchor_t (class) - Proxy of C++ ctree_anchor_t class. - -ida_hexrays.ctree_anchor_t.__init__ (method) - __init__(self) -> ctree_anchor_t - -ida_hexrays.ctree_anchor_t.get_index (method) - get_index(self) -> int - -ida_hexrays.ctree_anchor_t.get_itp (method) - get_itp(self) -> item_preciser_t - -ida_hexrays.ctree_anchor_t.is_blkcmt_anchor (method) - is_blkcmt_anchor(self) -> bool - -ida_hexrays.ctree_anchor_t.is_citem_anchor (method) - is_citem_anchor(self) -> bool - -ida_hexrays.ctree_anchor_t.is_itp_anchor (method) - is_itp_anchor(self) -> bool - -ida_hexrays.ctree_anchor_t.is_lvar_anchor (method) - is_lvar_anchor(self) -> bool - -ida_hexrays.ctree_anchor_t.is_valid_anchor (method) - is_valid_anchor(self) -> bool - -ida_hexrays.ctree_item_t (class) - Proxy of C++ ctree_item_t class. - -ida_hexrays.ctree_item_t.__init__ (method) - __init__(self) -> ctree_item_t - -ida_hexrays.ctree_item_t._get_e (method) - _get_e(self) -> cexpr_t - -ida_hexrays.ctree_item_t._get_f (method) - _get_f(self) -> cfunc_t - -ida_hexrays.ctree_item_t._get_i (method) - _get_i(self) -> cinsn_t - -ida_hexrays.ctree_item_t._get_it (method) - _get_it(self) -> citem_t - -ida_hexrays.ctree_item_t._get_l (method) - _get_l(self) -> lvar_t - -ida_hexrays.ctree_item_t._print (method) - _print(self) - -ida_hexrays.ctree_item_t.citype (variable) - Item type. - -ida_hexrays.ctree_item_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.ctree_item_t.get_ea (method) - get_ea(self) -> ea_t - Get address of the current item. Each ctree item has an address. - - @return: BADADDR if failed - -ida_hexrays.ctree_item_t.get_edm (method) - get_edm(self, parent) -> int - Get type of an enum member. If the current item is a symbolic constant, this - function will return information about it. - - @param parent: (C++: tinfo_t *) pointer to buffer for the enum type. - @return: member index or -1 if failed - -ida_hexrays.ctree_item_t.get_label_num (method) - get_label_num(self, gln_flags) -> int - Get label number of the current item. - - @param gln_flags: (C++: int) Combination of get_label_num control bits - @return: -1 if failed or no label - -ida_hexrays.ctree_item_t.get_lvar (method) - get_lvar(self) -> lvar_t - Get pointer to local variable. If the current item is a local variable, this - function will return pointer to its definition. - - @return: nullptr if failed - -ida_hexrays.ctree_item_t.get_memptr (method) - get_memptr(self, p_sptr=None) -> member_t * - Get pointer to structure member. If the current item is a structure field, this - function will return pointer to its definition. - - @param p_sptr: (C++: struc_t **) pointer to the variable where the pointer to the parent structure - is returned. This parameter can be nullptr. - @return: nullptr if failed OBSOLETE FUNCTION, do not use! - -ida_hexrays.ctree_item_t.get_udm (method) - get_udm(self, udm=None, parent=None, p_offset=None) -> int - Get type of a structure field. If the current item is a structure/union field, - this function will return information about it. - - @param udm: (C++: udm_t *) pointer to buffer for the udt member info. - @param parent: (C++: tinfo_t *) pointer to buffer for the struct/union type. - @param p_offset: (C++: uint64 *) pointer to the offset in bits inside udt. - @return: member index or -1 if failed Both output parameters can be nullptr. - -ida_hexrays.ctree_item_t.is_citem (method) - is_citem(self) -> bool - Is the current item is a ctree item? - -ida_hexrays.ctree_items_t (class) - Proxy of C++ qvector< citem_t * > class. - -ida_hexrays.ctree_items_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< citem_t * > const & - -ida_hexrays.ctree_items_t.__getitem__ (method) - __getitem__(self, i) -> citem_t - - @param i: size_t - -ida_hexrays.ctree_items_t.__init__ (method) - __init__(self) -> ctree_items_t - __init__(self, x) -> ctree_items_t - - @param x: qvector< citem_t * > const & - -ida_hexrays.ctree_items_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.ctree_items_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< citem_t * > const & - -ida_hexrays.ctree_items_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: citem_t *const & - -ida_hexrays.ctree_items_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: citem_t *const & - -ida_hexrays.ctree_items_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: citem_t *const & - -ida_hexrays.ctree_items_t.at (method) - at(self, _idx) -> citem_t - - @param _idx: size_t - -ida_hexrays.ctree_items_t.begin (method) - begin(self) -> qvector< citem_t * >::iterator - begin(self) -> qvector< citem_t * >::const_iterator - -ida_hexrays.ctree_items_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.ctree_items_t.clear (method) - clear(self) - -ida_hexrays.ctree_items_t.empty (method) - empty(self) -> bool - -ida_hexrays.ctree_items_t.end (method) - end(self) -> qvector< citem_t * >::iterator - end(self) -> qvector< citem_t * >::const_iterator - -ida_hexrays.ctree_items_t.erase (method) - erase(self, it) -> qvector< citem_t * >::iterator - - @param it: qvector< citem_t * >::iterator - - erase(self, first, last) -> qvector< citem_t * >::iterator - - @param first: qvector< citem_t * >::iterator - @param last: qvector< citem_t * >::iterator - -ida_hexrays.ctree_items_t.extract (method) - extract(self) -> citem_t ** - -ida_hexrays.ctree_items_t.find (method) - find(self, x) -> qvector< citem_t * >::iterator - - @param x: citem_t *const & - - find(self, x) -> qvector< citem_t * >::const_iterator - - @param x: citem_t *const & - -ida_hexrays.ctree_items_t.has (method) - has(self, x) -> bool - - @param x: citem_t *const & - -ida_hexrays.ctree_items_t.inject (method) - inject(self, s, len) - - @param s: citem_t ** - @param len: size_t - -ida_hexrays.ctree_items_t.insert (method) - insert(self, it, x) -> qvector< citem_t * >::iterator - - @param it: qvector< citem_t * >::iterator - @param x: citem_t *const & - -ida_hexrays.ctree_items_t.pop_back (method) - pop_back(self) - -ida_hexrays.ctree_items_t.push_back (method) - push_back(self, x) - - @param x: citem_t *const & - - push_back(self) -> citem_t *& - -ida_hexrays.ctree_items_t.qclear (method) - qclear(self) - -ida_hexrays.ctree_items_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.ctree_items_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: citem_t *const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.ctree_items_t.size (method) - size(self) -> size_t - -ida_hexrays.ctree_items_t.swap (method) - swap(self, r) - - @param r: qvector< citem_t * > & - -ida_hexrays.ctree_items_t.truncate (method) - truncate(self) - -ida_hexrays.ctree_parentee_t (class) - Proxy of C++ ctree_parentee_t class. - -ida_hexrays.ctree_parentee_t.__disown__ (method) - -ida_hexrays.ctree_parentee_t.__init__ (method) - __init__(self, post=False) -> ctree_parentee_t - - @param post: bool - -ida_hexrays.ctree_parentee_t.get_block (method) - get_block(self) -> cblock_t - Get pointer to the parent block of the currently visited item. This function - should be called only when the parent is a block. - -ida_hexrays.ctree_parentee_t.recalc_parent_types (method) - recalc_parent_types(self) -> bool - Recalculate type of parent nodes. If a node type has been changed, the visitor - must recalculate all parent types, otherwise the ctree becomes inconsistent. If - during this recalculation a parent node is added/deleted, this function returns - true. In this case the traversal must be stopped because the information about - parent nodes is stale. - - @return: false-ok to continue the traversal, true-must stop. - -ida_hexrays.ctree_visitor_t (class) - Proxy of C++ ctree_visitor_t class. - -ida_hexrays.ctree_visitor_t.__disown__ (method) - -ida_hexrays.ctree_visitor_t.__init__ (method) - __init__(self, _flags) -> ctree_visitor_t - - @param _flags: int - -ida_hexrays.ctree_visitor_t.apply_to (method) - apply_to(self, item, parent) -> int - Traverse ctree. The traversal will start at the specified item and continue - until of one the visit_...() functions return a non-zero value. - - @param item: (C++: citem_t *) root of the ctree to traverse - @param parent: (C++: citem_t *) parent of the specified item. can be specified as nullptr. - @return: 0 or a non-zero value returned by a visit_...() function - -ida_hexrays.ctree_visitor_t.apply_to_exprs (method) - apply_to_exprs(self, item, parent) -> int - Traverse only expressions. The traversal will start at the specified item and - continue until of one the visit_...() functions return a non-zero value. - - @param item: (C++: citem_t *) root of the ctree to traverse - @param parent: (C++: citem_t *) parent of the specified item. can be specified as nullptr. - @return: 0 or a non-zero value returned by a visit_...() function - -ida_hexrays.ctree_visitor_t.clr_prune (method) - clr_prune(self) - Do not prune children. This is an internal function, no need to call it. - -ida_hexrays.ctree_visitor_t.clr_restart (method) - clr_restart(self) - Do not restart. This is an internal function, no need to call it. - -ida_hexrays.ctree_visitor_t.cv_flags (variable) - Ctree visitor property bits - -ida_hexrays.ctree_visitor_t.is_postorder (method) - is_postorder(self) -> bool - Should the leave...() functions be called? - -ida_hexrays.ctree_visitor_t.leave_expr (method) - leave_expr(self, arg0) -> int - Visit an expression after having visited its children. This is a visitor - function which should be overridden by a derived class to do some useful work. - This visitor performs post-order traserval, i.e. an item is visited after its - children. - - @param arg0: cexpr_t * - @return: 0 to continue the traversal, nonzero to stop. - -ida_hexrays.ctree_visitor_t.leave_insn (method) - leave_insn(self, arg0) -> int - Visit a statement after having visited its children. This is a visitor function - which should be overridden by a derived class to do some useful work. This - visitor performs post-order traserval, i.e. an item is visited after its - children. - - @param arg0: cinsn_t * - @return: 0 to continue the traversal, nonzero to stop. - -ida_hexrays.ctree_visitor_t.maintain_parents (method) - maintain_parents(self) -> bool - Should the parent information by maintained? - -ida_hexrays.ctree_visitor_t.must_prune (method) - must_prune(self) -> bool - Should the traversal skip the children of the current item? - -ida_hexrays.ctree_visitor_t.must_restart (method) - must_restart(self) -> bool - Should the traversal restart? - -ida_hexrays.ctree_visitor_t.only_insns (method) - only_insns(self) -> bool - Should all expressions be automatically pruned? - -ida_hexrays.ctree_visitor_t.parent_expr (method) - parent_expr(self) -> cexpr_t - Get parent of the current item as an expression. - -ida_hexrays.ctree_visitor_t.parent_insn (method) - parent_insn(self) -> cinsn_t - Get parent of the current item as a statement. - -ida_hexrays.ctree_visitor_t.parents (variable) - Vector of parents of the current item. - -ida_hexrays.ctree_visitor_t.prune_now (method) - prune_now(self) - Prune children. This function may be called by a visitor() to skip all children - of the current item. - -ida_hexrays.ctree_visitor_t.set_restart (method) - set_restart(self) - Restart the travesal. Meaningful only in apply_to_exprs() - -ida_hexrays.ctree_visitor_t.visit_expr (method) - visit_expr(self, arg0) -> int - Visit an expression. This is a visitor function which should be overridden by a - derived class to do some useful work. This visitor performs pre-order traserval, - i.e. an item is visited before its children. - - @param arg0: cexpr_t * - @return: 0 to continue the traversal, nonzero to stop. - -ida_hexrays.ctree_visitor_t.visit_insn (method) - visit_insn(self, arg0) -> int - Visit a statement. This is a visitor function which should be overridden by a - derived class to do some useful work. This visitor performs pre-order traserval, - i.e. an item is visited before its children. - - @param arg0: cinsn_t * - @return: 0 to continue the traversal, nonzero to stop. - -ida_hexrays.cwhile_t (class) - Proxy of C++ cwhile_t class. - -ida_hexrays.cwhile_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: cwhile_t const & - -ida_hexrays.cwhile_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: cwhile_t const & - -ida_hexrays.cwhile_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: cwhile_t const & - -ida_hexrays.cwhile_t.__init__ (method) - __init__(self) -> cwhile_t - -ida_hexrays.cwhile_t.__le__ (method) - __le__(self, r) -> bool - - @param r: cwhile_t const & - -ida_hexrays.cwhile_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: cwhile_t const & - -ida_hexrays.cwhile_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: cwhile_t const & - -ida_hexrays.cwhile_t.compare (method) - compare(self, r) -> int - - @param r: cwhile_t const & - -ida_hexrays.debug_hexrays_ctree (function) - debug_hexrays_ctree(level, msg) - - @param level: int - @param msg: char const * - -ida_hexrays.decompile (function) - decompile(mbr, hf=None, decomp_flags=0) -> cfuncptr_t - Decompile a snippet or a function. - - @param mbr: (C++: const mba_ranges_t &) what to decompile - @param hf: (C++: hexrays_failure_t *) extended error information (if failed) - @param decomp_flags: (C++: int) bitwise combination of decompile() flags... bits - @return: pointer to the decompilation result (a reference counted pointer). - nullptr if failed. - -ida_hexrays.decompile (function) - Decompile a function. - - @param ea an address belonging to the function, or an ida_funcs.func_t object - @param hf extended error information (if failed) - @param flags decomp_flags bitwise combination of `DECOMP_...` bits - @return the decompilation result (a `ida_hexrays.cfunc_t` wrapper), or None - -ida_hexrays.decompile_func (function) - decompile_func(pfn, hf=None, decomp_flags=0) -> cfuncptr_t - Decompile a function. Multiple decompilations of the same function return the - same object. - - @param pfn: (C++: func_t *) pointer to function to decompile - @param hf: (C++: hexrays_failure_t *) extended error information (if failed) - @param decomp_flags: (C++: int) bitwise combination of decompile() flags... bits - @return: pointer to the decompilation result (a reference counted pointer). - nullptr if failed. - -ida_hexrays.decompile_many (function) - decompile_many(outfile, funcaddrs, flags) -> bool - Batch decompilation. Decompile all or the specified functions - - @param outfile: (C++: const char *) name of the output file - @param funcaddrs: (C++: const eavec_t *) list of functions to decompile. If nullptr or empty, then - decompile all nonlib functions - @param flags: (C++: int) Batch decompilation bits - @return: true if no internal error occurred and the user has not cancelled - decompilation - -ida_hexrays.dereference (function) - Dereference a pointer. This function dereferences a pointer expression. It - performs the following conversion: "ptr" => "*ptr" It can handle discrepancies - in the pointer type and the access size. - - @return: dereferenced expression - -ida_hexrays.dstr (function) - dstr(tif) -> char const * - Print the specified type info. This function can be used from a debugger by - typing "tif->dstr()" - - @param tif: (C++: const tinfo_t *) tinfo_t const * - -ida_hexrays.dummy_ptrtype (function) - dummy_ptrtype(ptrsize, isfp) -> tinfo_t - Generate a dummy pointer type - - @param ptrsize: (C++: int) size of pointed object - @param isfp: (C++: bool) is floating point object? - -ida_hexrays.eamap_begin (function) - eamap_begin(map) -> eamap_iterator_t - Get iterator pointing to the beginning of eamap_t. - - @param map: (C++: const eamap_t *) eamap_t const * - -ida_hexrays.eamap_clear (function) - eamap_clear(map) - Clear eamap_t. - - @param map: (C++: eamap_t *) - -ida_hexrays.eamap_end (function) - eamap_end(map) -> eamap_iterator_t - Get iterator pointing to the end of eamap_t. - - @param map: (C++: const eamap_t *) eamap_t const * - -ida_hexrays.eamap_erase (function) - eamap_erase(map, p) - Erase current element from eamap_t. - - @param map: (C++: eamap_t *) - @param p: (C++: eamap_iterator_t) - -ida_hexrays.eamap_find (function) - eamap_find(map, key) -> eamap_iterator_t - Find the specified key in eamap_t. - - @param map: (C++: const eamap_t *) eamap_t const * - @param key: (C++: const ea_t &) ea_t const & - -ida_hexrays.eamap_first (function) - eamap_first(p) -> ea_t const & - Get reference to the current map key. - - @param p: (C++: eamap_iterator_t) - -ida_hexrays.eamap_free (function) - eamap_free(map) - Delete eamap_t instance. - - @param map: (C++: eamap_t *) - -ida_hexrays.eamap_insert (function) - eamap_insert(map, key, val) -> eamap_iterator_t - Insert new (ea_t, cinsnptrvec_t) pair into eamap_t. - - @param map: (C++: eamap_t *) - @param key: (C++: const ea_t &) ea_t const & - @param val: (C++: const cinsnptrvec_t &) cinsnptrvec_t const & - -ida_hexrays.eamap_iterator_t (class) - Proxy of C++ eamap_iterator_t class. - -ida_hexrays.eamap_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: eamap_iterator_t const & - -ida_hexrays.eamap_iterator_t.__init__ (method) - __init__(self) -> eamap_iterator_t - -ida_hexrays.eamap_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: eamap_iterator_t const & - -ida_hexrays.eamap_new (function) - eamap_new() -> eamap_t - Create a new eamap_t instance. - -ida_hexrays.eamap_next (function) - eamap_next(p) -> eamap_iterator_t - Move to the next element. - - @param p: (C++: eamap_iterator_t) - -ida_hexrays.eamap_prev (function) - eamap_prev(p) -> eamap_iterator_t - Move to the previous element. - - @param p: (C++: eamap_iterator_t) - -ida_hexrays.eamap_second (function) - eamap_second(p) -> cinsnptrvec_t - Get reference to the current map value. - - @param p: (C++: eamap_iterator_t) - -ida_hexrays.eamap_size (function) - eamap_size(map) -> size_t - Get size of eamap_t. - - @param map: (C++: eamap_t *) - -ida_hexrays.eamap_t (class) - Proxy of C++ std::map< ea_t,cinsnptrvec_t > class. - -ida_hexrays.eamap_t.__init__ (method) - __init__(self) -> eamap_t - -ida_hexrays.eamap_t.at (method) - at(self, _Keyval) -> cinsnptrvec_t - - @param _Keyval: unsigned-ea-like-numeric-type const & - -ida_hexrays.eamap_t.size (method) - size(self) -> size_t - -ida_hexrays.fnumber_t (class) - Proxy of C++ fnumber_t class. - -ida_hexrays.fnumber_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: fnumber_t const & - -ida_hexrays.fnumber_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: fnumber_t const & - -ida_hexrays.fnumber_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: fnumber_t const & - -ida_hexrays.fnumber_t.__init__ (method) - __init__(self) -> fnumber_t - -ida_hexrays.fnumber_t.__le__ (method) - __le__(self, r) -> bool - - @param r: fnumber_t const & - -ida_hexrays.fnumber_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: fnumber_t const & - -ida_hexrays.fnumber_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: fnumber_t const & - -ida_hexrays.fnumber_t._print (method) - _print(self) - -ida_hexrays.fnumber_t.compare (method) - compare(self, r) -> int - - @param r: fnumber_t const & - -ida_hexrays.fnumber_t.dereference_const_uint16 (method) - dereference_const_uint16(self) -> uint16 const * - -ida_hexrays.fnumber_t.dereference_uint16 (method) - dereference_uint16(self) -> uint16 * - -ida_hexrays.fnumber_t.fnum (variable) - Internal representation of the number. - -ida_hexrays.fnumber_t.nbytes (variable) - Original size of the constant in bytes. - -ida_hexrays.gco_info_t (class) - Proxy of C++ gco_info_t class. - -ida_hexrays.gco_info_t.__init__ (method) - __init__(self) -> gco_info_t - -ida_hexrays.gco_info_t.append_to_list (method) - append_to_list(self, list, mba) -> bool - Append operand info to LIST. This function converts IDA register number or stack - offset to a decompiler list. - - @param list: (C++: mlist_t *) list to append to - @param mba: (C++: const mba_t *) microcode object - -ida_hexrays.gco_info_t.cvt_to_ivl (method) - cvt_to_ivl(self) -> vivl_t - Convert operand info to VIVL. The returned VIVL can be used, for example, in a - call of get_valranges(). - -ida_hexrays.gco_info_t.is_def (method) - is_def(self) -> bool - -ida_hexrays.gco_info_t.is_reg (method) - is_reg(self) -> bool - -ida_hexrays.gco_info_t.is_use (method) - is_use(self) -> bool - -ida_hexrays.gco_info_t.name (variable) - register or stkvar name - -ida_hexrays.gco_info_t.regnum (variable) - if register, the register id - -ida_hexrays.gco_info_t.size (variable) - operand size - -ida_hexrays.gco_info_t.stkoff (variable) - if stkvar, stack offset - -ida_hexrays.gen_microcode (function) - gen_microcode(mbr, hf=None, retlist=None, decomp_flags=0, reqmat=MMAT_GLBOPT3) -> mba_t - Generate microcode of an arbitrary code snippet - - @param mbr: (C++: const mba_ranges_t &) snippet ranges - @param hf: (C++: hexrays_failure_t *) extended error information (if failed) - @param retlist: (C++: const mlist_t *) list of registers the snippet returns - @param decomp_flags: (C++: int) bitwise combination of decompile() flags... bits - @param reqmat: (C++: mba_maturity_t) required microcode maturity - @return: pointer to the microcode, nullptr if failed. - -ida_hexrays.get_ctype_name (function) - get_ctype_name(op) -> char const * - - @param op: enum ctype_t - -ida_hexrays.get_current_operand (function) - get_current_operand(out) -> bool - Get the instruction operand under the cursor. This function determines the - operand that is under the cursor in the active disassembly listing. If the - operand refers to a register or stack variable, it returns true. - - @param out: (C++: gco_info_t *) [out]: output buffer - -ida_hexrays.get_float_type (function) - get_float_type(width) -> tinfo_t - Get a type of a floating point value with the specified width - - @param width: (C++: int) width of the desired type - @return: type info object - -ida_hexrays.get_hexrays_version (function) - get_hexrays_version() -> char const * - Get decompiler version. The returned string is of the form - <major>.<minor>.<revision>.<build-date> - - @return: pointer to version string. For example: "2.0.0.140605" - -ida_hexrays.get_int_type_by_width_and_sign (function) - get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t - Create a type info by width and sign. Returns a simple type (examples: int, - short) with the given width and sign. - - @param srcwidth: (C++: int) size of the type in bytes - @param sign: (C++: type_sign_t) sign of the type - -ida_hexrays.get_member_type (function) - get_member_type(mptr, type) -> bool - Get type of a structure field. This function performs validity checks of the - field type. Wrong types are rejected. - - @param mptr: (C++: const member_t *) structure field - @param type: (C++: tinfo_t *) pointer to the variable where the type is returned. This parameter - can be nullptr. - @return: false if failed - -ida_hexrays.get_merror_desc (function) - get_merror_desc(code, mba) -> str - Get textual description of an error code - - @param code: (C++: merror_t) Microcode error codes - @param mba: (C++: mba_t *) the microcode array - @return: the error address - -ida_hexrays.get_mreg_name (function) - get_mreg_name(reg, width, ud=None) -> str - Get the microregister name. - - @param reg: (C++: mreg_t) microregister number - @param width: (C++: int) size of microregister in bytes. may be bigger than the real - register size. - @param ud: (C++: void *) reserved, must be nullptr - @return: width of the printed register. this value may be less than the WIDTH - argument. - -ida_hexrays.get_op_signness (function) - get_op_signness(op) -> type_sign_t - Get operator sign. Meaningful for sign-dependent operators, like cot_sdiv. - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.get_signed_mcode (function) - get_signed_mcode(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.get_temp_regs (function) - get_temp_regs() -> mlist_t - Get list of temporary registers. Tempregs are temporary registers that are used - during code generation. They do not map to regular processor registers. They are - used only to store temporary values during execution of one instruction. - Tempregs may not be used to pass a value from one block to another. In other - words, at the end of a block all tempregs must be dead. - -ida_hexrays.get_type (function) - get_type(id, tif, guess) -> bool - Get a global type. Global types are types of addressable objects and - struct/union/enum types - - @param id: (C++: uval_t) address or id of the object - @param tif: (C++: tinfo_t *) buffer for the answer - @param guess: (C++: type_source_t) what kind of types to consider - @return: success - -ida_hexrays.get_unk_type (function) - get_unk_type(size) -> tinfo_t - Create a partial type info by width. Returns a partially defined type (examples: - _DWORD, _BYTE) with the given width. - - @param size: (C++: int) size of the type in bytes - -ida_hexrays.get_unsigned_mcode (function) - get_unsigned_mcode(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.get_widget_vdui (function) - get_widget_vdui(f) -> vdui_t - Get the vdui_t instance associated to the TWidget - - @param f: (C++: TWidget *) pointer to window - @return: a vdui_t *, or nullptr - -ida_hexrays.getb_reginsn (function) - getb_reginsn(ins) -> minsn_t - - @param ins: minsn_t * - -ida_hexrays.getf_reginsn (function) - getf_reginsn(ins) -> minsn_t - - @param ins: minsn_t * - -ida_hexrays.graph_chains_t (class) - Proxy of C++ graph_chains_t class. - -ida_hexrays.graph_chains_t.__init__ (method) - __init__(self) -> graph_chains_t - -ida_hexrays.graph_chains_t.acquire (method) - acquire(self) - Lock the chains. - -ida_hexrays.graph_chains_t.for_all_chains (method) - for_all_chains(self, cv, gca_flags) -> int - Visit all chains - - @param cv: (C++: chain_visitor_t &) chain visitor - @param gca_flags: (C++: int) combination of GCA_ bits - -ida_hexrays.graph_chains_t.is_locked (method) - is_locked(self) -> bool - Are the chains locked? It is a good idea to lock the chains before using them. - This ensures that they won't be recalculated and reallocated during the use. See - the chain_keeper_t class for that. - -ida_hexrays.graph_chains_t.release (method) - release(self) - Unlock the chains. - -ida_hexrays.graph_chains_t.swap (method) - swap(self, r) - - @param r: graph_chains_t & - -ida_hexrays.has_cached_cfunc (function) - has_cached_cfunc(ea) -> bool - Do we have a cached decompilation result for 'ea'? - - @param ea: (C++: ea_t) - -ida_hexrays.has_mcode_seloff (function) - has_mcode_seloff(op) -> bool - - @param op: enum mcode_t - -ida_hexrays.hexrays_alloc (function) - hexrays_alloc(size) -> void * - - @param size: size_t - -ida_hexrays.hexrays_failure_t (class) - Proxy of C++ hexrays_failure_t class. - -ida_hexrays.hexrays_failure_t.__init__ (method) - __init__(self) -> hexrays_failure_t - __init__(self, c, ea, buf=None) -> hexrays_failure_t - - @param c: enum merror_t - @param ea: ea_t - @param buf: char const * - - __init__(self, c, ea, buf) -> hexrays_failure_t - - @param c: enum merror_t - @param ea: ea_t - @param buf: qstring const & - -ida_hexrays.hexrays_failure_t.code (variable) - Microcode error codes - -ida_hexrays.hexrays_failure_t.desc (method) - desc(self) -> qstring - -ida_hexrays.hexrays_failure_t.errea (variable) - associated address - -ida_hexrays.hexrays_failure_t.str (variable) - string information - -ida_hexrays.hexrays_free (function) - hexrays_free(ptr) - - @param ptr: void * - -ida_hexrays.hexwarn_t (class) - Proxy of C++ hexwarn_t class. - -ida_hexrays.hexwarn_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: hexwarn_t const & - -ida_hexrays.hexwarn_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: hexwarn_t const & - -ida_hexrays.hexwarn_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: hexwarn_t const & - -ida_hexrays.hexwarn_t.__init__ (method) - __init__(self) -> hexwarn_t - -ida_hexrays.hexwarn_t.__le__ (method) - __le__(self, r) -> bool - - @param r: hexwarn_t const & - -ida_hexrays.hexwarn_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: hexwarn_t const & - -ida_hexrays.hexwarn_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: hexwarn_t const & - -ida_hexrays.hexwarn_t.compare (method) - compare(self, r) -> int - - @param r: hexwarn_t const & - -ida_hexrays.hexwarn_t.ea (variable) - Address where the warning occurred. - -ida_hexrays.hexwarn_t.id (variable) - Warning id. - -ida_hexrays.hexwarn_t.text (variable) - Fully formatted text of the warning. - -ida_hexrays.hexwarns_t (class) - Proxy of C++ qvector< hexwarn_t > class. - -ida_hexrays.hexwarns_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< hexwarn_t > const & - -ida_hexrays.hexwarns_t.__getitem__ (method) - __getitem__(self, i) -> hexwarn_t - - @param i: size_t - -ida_hexrays.hexwarns_t.__init__ (method) - __init__(self) -> hexwarns_t - __init__(self, x) -> hexwarns_t - - @param x: qvector< hexwarn_t > const & - -ida_hexrays.hexwarns_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.hexwarns_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< hexwarn_t > const & - -ida_hexrays.hexwarns_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: hexwarn_t const & - -ida_hexrays.hexwarns_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: hexwarn_t const & - -ida_hexrays.hexwarns_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: hexwarn_t const & - -ida_hexrays.hexwarns_t.at (method) - at(self, _idx) -> hexwarn_t - - @param _idx: size_t - -ida_hexrays.hexwarns_t.begin (method) - begin(self) -> hexwarn_t - -ida_hexrays.hexwarns_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.hexwarns_t.clear (method) - clear(self) - -ida_hexrays.hexwarns_t.empty (method) - empty(self) -> bool - -ida_hexrays.hexwarns_t.end (method) - end(self) -> hexwarn_t - -ida_hexrays.hexwarns_t.erase (method) - erase(self, it) -> hexwarn_t - - @param it: qvector< hexwarn_t >::iterator - - erase(self, first, last) -> hexwarn_t - - @param first: qvector< hexwarn_t >::iterator - @param last: qvector< hexwarn_t >::iterator - -ida_hexrays.hexwarns_t.extract (method) - extract(self) -> hexwarn_t - -ida_hexrays.hexwarns_t.find (method) - find(self, x) -> hexwarn_t - - @param x: hexwarn_t const & - -ida_hexrays.hexwarns_t.grow (method) - grow(self, x=hexwarn_t()) - - @param x: hexwarn_t const & - -ida_hexrays.hexwarns_t.has (method) - has(self, x) -> bool - - @param x: hexwarn_t const & - -ida_hexrays.hexwarns_t.inject (method) - inject(self, s, len) - - @param s: hexwarn_t * - @param len: size_t - -ida_hexrays.hexwarns_t.insert (method) - insert(self, it, x) -> hexwarn_t - - @param it: qvector< hexwarn_t >::iterator - @param x: hexwarn_t const & - -ida_hexrays.hexwarns_t.pop_back (method) - pop_back(self) - -ida_hexrays.hexwarns_t.push_back (method) - push_back(self, x) - - @param x: hexwarn_t const & - - push_back(self) -> hexwarn_t - -ida_hexrays.hexwarns_t.qclear (method) - qclear(self) - -ida_hexrays.hexwarns_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.hexwarns_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: hexwarn_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.hexwarns_t.size (method) - size(self) -> size_t - -ida_hexrays.hexwarns_t.swap (method) - swap(self, r) - - @param r: qvector< hexwarn_t > & - -ida_hexrays.hexwarns_t.truncate (method) - truncate(self) - -ida_hexrays.history_item_t (class) - Proxy of C++ history_item_t class. - -ida_hexrays.history_item_t.__init__ (method) - __init__(self, _ea=BADADDR, _lnnum=-1, _x=0, _y=0) -> history_item_t - - @param _ea: ea_t - @param _lnnum: int - @param _x: int - @param _y: int - - __init__(self, _ea, p) -> history_item_t - - @param _ea: ea_t - @param p: ctext_position_t const & - -ida_hexrays.history_item_t.ea (variable) - The entry address of the decompiled function. - -ida_hexrays.history_item_t.end (variable) - BADADDR-decompile function; otherwise end of the range. - -ida_hexrays.history_t (class) - Proxy of C++ qstack< history_item_t > class. - -ida_hexrays.history_t.__init__ (method) - __init__(self) -> history_t - -ida_hexrays.history_t.pop (method) - pop(self) -> history_item_t - -ida_hexrays.history_t.push (method) - push(self, v) - - @param v: history_item_t const & - -ida_hexrays.history_t.top (method) - top(self) -> history_item_t - -ida_hexrays.hxe_build_callinfo (variable) - Analyzing a call instruction. - -ida_hexrays.hxe_callinfo_built (variable) - A call instruction has been anallyzed. - -ida_hexrays.hxe_calls_done (variable) - All calls have been analyzed. - -ida_hexrays.hxe_close_pseudocode (variable) - Pseudocode view is being closed. - -ida_hexrays.hxe_cmt_changed (variable) - Comment got changed. - -ida_hexrays.hxe_combine (variable) - Trying to combine instructions of basic block. - -ida_hexrays.hxe_create_hint (variable) - Create a hint for the current item. - @see: ui_get_custom_viewer_hint - - @retval 0: continue collecting hints with other subscribers - @retval 1: stop collecting hints - -ida_hexrays.hxe_curpos (variable) - Current cursor position has been changed. (for example, by left-clicking or - using keyboard) - -ida_hexrays.hxe_double_click (variable) - Mouse double click. - -ida_hexrays.hxe_flowchart (variable) - Flowchart has been generated. - -ida_hexrays.hxe_func_printed (variable) - Function text has been generated. Plugins may modify the text in cfunc_t::sv. - The text uses regular color codes (see lines.hpp) COLOR_ADDR is used to store - pointers to ctree items. - -ida_hexrays.hxe_glbopt (variable) - Global optimization has been finished. If microcode is modified, MERR_LOOP must - be returned. It will cause a complete restart of the optimization. - -ida_hexrays.hxe_interr (variable) - Internal error has occurred. - -ida_hexrays.hxe_keyboard (variable) - Keyboard has been hit. - -ida_hexrays.hxe_locopt (variable) - Basic block level optimization has been finished. - -ida_hexrays.hxe_maturity (variable) - Ctree maturity level is being changed. - -ida_hexrays.hxe_microcode (variable) - Microcode has been generated. - -ida_hexrays.hxe_open_pseudocode (variable) - New pseudocode view has been opened. - -ida_hexrays.hxe_populating_popup (variable) - Populating popup menu. We can add menu items now. - -ida_hexrays.hxe_prealloc (variable) - Local variables: preallocation step begins. - -ida_hexrays.hxe_preoptimized (variable) - Microcode has been preoptimized. - -ida_hexrays.hxe_print_func (variable) - Printing ctree and generating text. - -ida_hexrays.hxe_prolog (variable) - Prolog analysis has been finished. - -ida_hexrays.hxe_refresh_pseudocode (variable) - Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is - forbidden in this event. - -ida_hexrays.hxe_resolve_stkaddrs (variable) - The optimizer is about to resolve stack addresses. - -ida_hexrays.hxe_right_click (variable) - Mouse right click. Use hxe_populating_popup instead, in case you want to add - items in the popup menu. - -ida_hexrays.hxe_stkpnts (variable) - SP change points have been calculated. - -ida_hexrays.hxe_structural (variable) - Structural analysis has been finished. - -ida_hexrays.hxe_switch_pseudocode (variable) - Existing pseudocode view has been reloaded with a new function. Its text has not - been refreshed yet, only cfunc and mba pointers are ready. - -ida_hexrays.hxe_text_ready (variable) - Decompiled text is ready. - -ida_hexrays.init_hexrays_plugin (function) - init_hexrays_plugin(flags=0) -> bool - Check that your plugin is compatible with hex-rays decompiler. This function - must be called before calling any other decompiler function. - - @param flags: (C++: int) reserved, must be 0 - @return: true if the decompiler exists and is compatible with your plugin - -ida_hexrays.install_hexrays_callback (function) - Deprecated. Please use Hexrays_Hooks instead - Install handler for decompiler events. - - @return: false if failed - -ida_hexrays.install_microcode_filter (function) - install_microcode_filter(filter, install=True) -> bool - register/unregister non-standard microcode generator - - @param filter: (C++: microcode_filter_t *) - microcode generator object - @param install: (C++: bool) - TRUE - register the object, FALSE - unregister - @return: success - -ida_hexrays.is_additive (function) - is_additive(op) -> bool - Is additive operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_assignment (function) - is_assignment(op) -> bool - Is assignment operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_binary (function) - is_binary(op) -> bool - Is binary operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_bitop (function) - is_bitop(op) -> bool - Is bit related operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_bool_type (function) - is_bool_type(type) -> bool - Is a boolean type? - - @param type: (C++: const tinfo_t &) tinfo_t const & - @return: true if the type is a boolean type - -ida_hexrays.is_break_consumer (function) - is_break_consumer(op) -> bool - Does a break statement influence the specified statement code? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_commutative (function) - is_commutative(op) -> bool - Is commutative operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_inplace_def (function) - is_inplace_def(type) -> bool - Is struct/union/enum definition (not declaration)? - - @param type: (C++: const tinfo_t &) tinfo_t const & - -ida_hexrays.is_kreg (function) - is_kreg(r) -> bool - Is a kernel register? Kernel registers are temporary registers that can be used - freely. They may be used to store values that cross instruction or basic block - boundaries. Kernel registers do not map to regular processor registers. See also - mba_t::alloc_kreg() - - @param r: (C++: mreg_t) - -ida_hexrays.is_logical (function) - is_logical(op) -> bool - Is logical operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_loop (function) - is_loop(op) -> bool - Is loop statement code? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_lvalue (function) - is_lvalue(op) -> bool - Is Lvalue operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_may_access (function) - is_may_access(maymust) -> bool - - @param maymust: maymust_t - -ida_hexrays.is_mcode_addsub (function) - is_mcode_addsub(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_call (function) - is_mcode_call(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_commutative (function) - is_mcode_commutative(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_convertible_to_jmp (function) - is_mcode_convertible_to_jmp(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_convertible_to_set (function) - is_mcode_convertible_to_set(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_divmod (function) - is_mcode_divmod(op) -> bool - - @param op: enum mcode_t - -ida_hexrays.is_mcode_fpu (function) - is_mcode_fpu(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_j1 (function) - is_mcode_j1(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_jcond (function) - is_mcode_jcond(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_propagatable (function) - is_mcode_propagatable(mcode) -> bool - May opcode be propagated? Such opcodes can be used in sub-instructions (nested - instructions) There is a handful of non-propagatable opcodes, like jumps, ret, - nop, etc All other regular opcodes are propagatable and may appear in a nested - instruction. - - @param mcode: (C++: mcode_t) enum mcode_t - -ida_hexrays.is_mcode_set (function) - is_mcode_set(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_set1 (function) - is_mcode_set1(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_shift (function) - is_mcode_shift(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_mcode_xdsu (function) - is_mcode_xdsu(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.is_multiplicative (function) - is_multiplicative(op) -> bool - Is multiplicative operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_nonbool_type (function) - is_nonbool_type(type) -> bool - Is definitely a non-boolean type? - - @param type: (C++: const tinfo_t &) tinfo_t const & - @return: true if the type is a non-boolean type (non bool and well defined) - -ida_hexrays.is_paf (function) - is_paf(t) -> bool - Is a pointer, array, or function type? - - @param t: (C++: type_t) - -ida_hexrays.is_prepost (function) - is_prepost(op) -> bool - Is pre/post increment/decrement operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_ptr_or_array (function) - is_ptr_or_array(t) -> bool - Is a pointer or array type? - - @param t: (C++: type_t) - -ida_hexrays.is_relational (function) - is_relational(op) -> bool - Is comparison operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_signed_mcode (function) - is_signed_mcode(code) -> bool - - @param code: enum mcode_t - -ida_hexrays.is_small_udt (function) - is_small_udt(tif) -> bool - Is a small structure or union? - - @param tif: (C++: const tinfo_t &) tinfo_t const & - @return: true if the type is a small UDT (user defined type). Small UDTs fit - into a register (or pair or registers) as a rule. - -ida_hexrays.is_type_correct (function) - is_type_correct(ptr) -> bool - Verify a type string. - - @param ptr: (C++: const type_t *) type_t const * - @return: true if type string is correct - -ida_hexrays.is_unary (function) - is_unary(op) -> bool - Is unary operator? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.is_unsigned_mcode (function) - is_unsigned_mcode(code) -> bool - - @param code: enum mcode_t - -ida_hexrays.iterator (class) - Proxy of C++ bitset_t::iterator class. - -ida_hexrays.iterator.__eq__ (method) - __eq__(self, n) -> bool - - @param n: bitset_t::iterator const & - -ida_hexrays.iterator.__init__ (method) - __init__(self, n=-1) -> iterator - - @param n: int - -ida_hexrays.iterator.__ne__ (method) - __ne__(self, n) -> bool - - @param n: bitset_t::iterator const & - -ida_hexrays.iterator.__ref__ (method) - __ref__(self) -> int - -ida_hexrays.ivl_t (class) - Proxy of C++ ivl_t class. - -ida_hexrays.ivl_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ivl_t const & - -ida_hexrays.ivl_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ivl_t const & - -ida_hexrays.ivl_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ivl_t const & - -ida_hexrays.ivl_t.__init__ (method) - __init__(self, _off=0, _size=0) -> ivl_t - - @param _off: uval_t - @param _size: uval_t - -ida_hexrays.ivl_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ivl_t const & - -ida_hexrays.ivl_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ivl_t const & - -ida_hexrays.ivl_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ivl_t const & - -ida_hexrays.ivl_t.clear (method) - clear(self) - -ida_hexrays.ivl_t.compare (method) - compare(self, r) -> int - - @param r: ivl_t const & - -ida_hexrays.ivl_t.contains (method) - contains(self, off2) -> bool - - @param off2: uval_t - -ida_hexrays.ivl_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.ivl_t.empty (method) - empty(self) -> bool - -ida_hexrays.ivl_t.extend_to_cover (method) - extend_to_cover(self, r) -> bool - - @param r: ivl_t const & - -ida_hexrays.ivl_t.includes (method) - includes(self, ivl) -> bool - - @param ivl: ivl_t const & - -ida_hexrays.ivl_t.intersect (method) - intersect(self, r) - - @param r: ivl_t const & - -ida_hexrays.ivl_t.overlap (method) - overlap(self, ivl) -> bool - - @param ivl: ivl_t const & - -ida_hexrays.ivl_with_name_t (class) - Proxy of C++ ivl_with_name_t class. - -ida_hexrays.ivl_with_name_t.__init__ (method) - __init__(self) -> ivl_with_name_t - -ida_hexrays.ivlset_t (class) - Proxy of C++ ivlset_t class. - -ida_hexrays.ivlset_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t.__init__ (method) - __init__(self) -> ivlset_t - __init__(self, ivl) -> ivlset_t - - @param ivl: ivl_t const & - -ida_hexrays.ivlset_t.__le__ (method) - __le__(self, r) -> bool - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t._print (method) - _print(self) - -ida_hexrays.ivlset_t.add (method) - add(self, ivl) -> bool - - @param ivl: ivl_t const & - - add(self, ea, size) -> bool - - @param ea: ea_t - @param size: asize_t - - add(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.addmasked (method) - addmasked(self, ivs, mask) -> bool - - @param ivs: ivlset_t const & - @param mask: ivl_t const & - -ida_hexrays.ivlset_t.compare (method) - compare(self, r) -> int - - @param r: ivlset_t const & - -ida_hexrays.ivlset_t.contains (method) - contains(self, off) -> bool - - @param off: uval_t - -ida_hexrays.ivlset_t.count (method) - count(self) -> asize_t - -ida_hexrays.ivlset_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.ivlset_t.has_common (method) - has_common(self, ivl, strict=False) -> bool - - @param ivl: ivl_t const & - @param strict: bool - - has_common(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.includes (method) - includes(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.intersect (method) - intersect(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.ivlset_t.sub (method) - sub(self, ivl) -> bool - - @param ivl: ivl_t const & - - sub(self, ea, size) -> bool - - @param ea: ea_t - @param size: asize_t - - sub(self, ivs) -> bool - - @param ivs: ivlset_t const & - -ida_hexrays.jcnd2set (function) - jcnd2set(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.lexcompare (function) - lexcompare(a, b) -> int - - @param a: mop_t const & - @param b: mop_t const & - -ida_hexrays.lnot (function) - Logically negate the specified expression. The specified expression will be - logically negated. For example, "x == y" is converted into "x != y" by this - function. - - @return: logically negated expression. - -ida_hexrays.locate_lvar (function) - locate_lvar(out, func_ea, varname) -> bool - Find a variable by name. - - @param out: (C++: lvar_locator_t *) output buffer for the variable locator - @param func_ea: (C++: ea_t) function start address - @param varname: (C++: const char *) variable name - @return: success Since VARNAME is not always enough to find the variable, it may - decompile the function. - -ida_hexrays.lvar_locator_t (class) - Proxy of C++ lvar_locator_t class. - -ida_hexrays.lvar_locator_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__init__ (method) - __init__(self) -> lvar_locator_t - __init__(self, loc, ea) -> lvar_locator_t - - @param loc: vdloc_t const & - @param ea: ea_t - -ida_hexrays.lvar_locator_t.__le__ (method) - __le__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.compare (method) - compare(self, r) -> int - - @param r: lvar_locator_t const & - -ida_hexrays.lvar_locator_t.defea (variable) - Definition address. Usually, this is the address of the instruction that - initializes the variable. In some cases it can be a fictional address. - -ida_hexrays.lvar_locator_t.get_reg1 (method) - get_reg1(self) -> mreg_t - Get the register number of the variable. - -ida_hexrays.lvar_locator_t.get_reg2 (method) - get_reg2(self) -> mreg_t - Get the number of the second register (works only for ALOC_REG2 lvars) - -ida_hexrays.lvar_locator_t.get_scattered (method) - get_scattered(self) -> scattered_aloc_t - -ida_hexrays.lvar_locator_t.get_stkoff (method) - get_stkoff(self) -> sval_t - Get offset of the varialbe in the stack frame. - - @return: a non-negative value for stack variables. The value is an offset from - the bottom of the stack frame in terms of vd-offsets. negative values - mean error (not a stack variable) - -ida_hexrays.lvar_locator_t.is_reg1 (method) - is_reg1(self) -> bool - Is variable located on one register? - -ida_hexrays.lvar_locator_t.is_reg2 (method) - is_reg2(self) -> bool - Is variable located on two registers? - -ida_hexrays.lvar_locator_t.is_reg_var (method) - is_reg_var(self) -> bool - Is variable located on register(s)? - -ida_hexrays.lvar_locator_t.is_scattered (method) - is_scattered(self) -> bool - Is variable scattered? - -ida_hexrays.lvar_locator_t.is_stk_var (method) - is_stk_var(self) -> bool - Is variable located on the stack? - -ida_hexrays.lvar_locator_t.location (variable) - Variable location. - -ida_hexrays.lvar_mapping_begin (function) - lvar_mapping_begin(map) -> lvar_mapping_iterator_t - Get iterator pointing to the beginning of lvar_mapping_t. - - @param map: (C++: const lvar_mapping_t *) lvar_mapping_t const * - -ida_hexrays.lvar_mapping_clear (function) - lvar_mapping_clear(map) - Clear lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) - -ida_hexrays.lvar_mapping_end (function) - lvar_mapping_end(map) -> lvar_mapping_iterator_t - Get iterator pointing to the end of lvar_mapping_t. - - @param map: (C++: const lvar_mapping_t *) lvar_mapping_t const * - -ida_hexrays.lvar_mapping_erase (function) - lvar_mapping_erase(map, p) - Erase current element from lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) - @param p: (C++: lvar_mapping_iterator_t) - -ida_hexrays.lvar_mapping_find (function) - lvar_mapping_find(map, key) -> lvar_mapping_iterator_t - Find the specified key in lvar_mapping_t. - - @param map: (C++: const lvar_mapping_t *) lvar_mapping_t const * - @param key: (C++: const lvar_locator_t &) lvar_locator_t const & - -ida_hexrays.lvar_mapping_first (function) - lvar_mapping_first(p) -> lvar_locator_t - Get reference to the current map key. - - @param p: (C++: lvar_mapping_iterator_t) - -ida_hexrays.lvar_mapping_free (function) - lvar_mapping_free(map) - Delete lvar_mapping_t instance. - - @param map: (C++: lvar_mapping_t *) - -ida_hexrays.lvar_mapping_insert (function) - lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t - Insert new (lvar_locator_t, lvar_locator_t) pair into lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) - @param key: (C++: const lvar_locator_t &) lvar_locator_t const & - @param val: (C++: const lvar_locator_t &) lvar_locator_t const & - -ida_hexrays.lvar_mapping_iterator_t (class) - Proxy of C++ lvar_mapping_iterator_t class. - -ida_hexrays.lvar_mapping_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: lvar_mapping_iterator_t const & - -ida_hexrays.lvar_mapping_iterator_t.__init__ (method) - __init__(self) -> lvar_mapping_iterator_t - -ida_hexrays.lvar_mapping_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: lvar_mapping_iterator_t const & - -ida_hexrays.lvar_mapping_new (function) - lvar_mapping_new() -> lvar_mapping_t - Create a new lvar_mapping_t instance. - -ida_hexrays.lvar_mapping_next (function) - lvar_mapping_next(p) -> lvar_mapping_iterator_t - Move to the next element. - - @param p: (C++: lvar_mapping_iterator_t) - -ida_hexrays.lvar_mapping_prev (function) - lvar_mapping_prev(p) -> lvar_mapping_iterator_t - Move to the previous element. - - @param p: (C++: lvar_mapping_iterator_t) - -ida_hexrays.lvar_mapping_second (function) - lvar_mapping_second(p) -> lvar_locator_t - Get reference to the current map value. - - @param p: (C++: lvar_mapping_iterator_t) - -ida_hexrays.lvar_mapping_size (function) - lvar_mapping_size(map) -> size_t - Get size of lvar_mapping_t. - - @param map: (C++: lvar_mapping_t *) - -ida_hexrays.lvar_mapping_t (class) - Proxy of C++ std::map< lvar_locator_t,lvar_locator_t > class. - -ida_hexrays.lvar_mapping_t.__init__ (method) - __init__(self) -> lvar_mapping_t - -ida_hexrays.lvar_mapping_t.at (method) - at(self, _Keyval) -> lvar_locator_t - - @param _Keyval: lvar_locator_t const & - -ida_hexrays.lvar_mapping_t.size (method) - size(self) -> size_t - -ida_hexrays.lvar_ref_t (class) - Proxy of C++ lvar_ref_t class. - -ida_hexrays.lvar_ref_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.__init__ (method) - __init__(self, m, i, o=0) -> lvar_ref_t - - @param m: mba_t * - @param i: int - @param o: sval_t - - __init__(self, r) -> lvar_ref_t - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.__le__ (method) - __le__(self, r) -> bool - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.compare (method) - compare(self, r) -> int - - @param r: lvar_ref_t const & - -ida_hexrays.lvar_ref_t.idx (variable) - index into mba->vars - -ida_hexrays.lvar_ref_t.mba (variable) - Pointer to the parent mba_t object. Since we need to access the 'mba->vars' - array in order to retrieve the referenced variable, we keep a pointer to mba_t - here. Note: this means this class and consequently mop_t, minsn_t, mblock_t are - specific to a mba_t object and cannot migrate between them. fortunately this is - not something we need to do. second, lvar_ref_t's appear only after MMAT_LVARS. - -ida_hexrays.lvar_ref_t.off (variable) - offset from the beginning of the variable - -ida_hexrays.lvar_ref_t.swap (method) - swap(self, r) - - @param r: lvar_ref_t & - -ida_hexrays.lvar_ref_t.var (method) - var(self) -> lvar_t - Retrieve the referenced variable. - -ida_hexrays.lvar_saved_info_t (class) - Proxy of C++ lvar_saved_info_t class. - -ida_hexrays.lvar_saved_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_info_t.__init__ (method) - __init__(self) -> lvar_saved_info_t - -ida_hexrays.lvar_saved_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_info_t.clear_keep (method) - clear_keep(self) - -ida_hexrays.lvar_saved_info_t.clr_nomap_lvar (method) - clr_nomap_lvar(self) - -ida_hexrays.lvar_saved_info_t.clr_noptr_lvar (method) - clr_noptr_lvar(self) - -ida_hexrays.lvar_saved_info_t.clr_split_lvar (method) - clr_split_lvar(self) - -ida_hexrays.lvar_saved_info_t.clr_unused_lvar (method) - clr_unused_lvar(self) - -ida_hexrays.lvar_saved_info_t.cmt (variable) - Comment. - -ida_hexrays.lvar_saved_info_t.flags (variable) - saved user lvar info property bits - -ida_hexrays.lvar_saved_info_t.has_info (method) - has_info(self) -> bool - -ida_hexrays.lvar_saved_info_t.is_kept (method) - is_kept(self) -> bool - -ida_hexrays.lvar_saved_info_t.is_nomap_lvar (method) - is_nomap_lvar(self) -> bool - -ida_hexrays.lvar_saved_info_t.is_noptr_lvar (method) - is_noptr_lvar(self) -> bool - -ida_hexrays.lvar_saved_info_t.is_split_lvar (method) - is_split_lvar(self) -> bool - -ida_hexrays.lvar_saved_info_t.is_unused_lvar (method) - is_unused_lvar(self) -> bool - -ida_hexrays.lvar_saved_info_t.ll (variable) - Variable locator. - -ida_hexrays.lvar_saved_info_t.name (variable) - Name. - -ida_hexrays.lvar_saved_info_t.set_keep (method) - set_keep(self) - -ida_hexrays.lvar_saved_info_t.set_nomap_lvar (method) - set_nomap_lvar(self) - -ida_hexrays.lvar_saved_info_t.set_noptr_lvar (method) - set_noptr_lvar(self) - -ida_hexrays.lvar_saved_info_t.set_split_lvar (method) - set_split_lvar(self) - -ida_hexrays.lvar_saved_info_t.set_unused_lvar (method) - set_unused_lvar(self) - -ida_hexrays.lvar_saved_info_t.size (variable) - Type size (if not initialized then -1) - -ida_hexrays.lvar_saved_info_t.type (variable) - Type. - -ida_hexrays.lvar_saved_infos_t (class) - Proxy of C++ qvector< lvar_saved_info_t > class. - -ida_hexrays.lvar_saved_infos_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< lvar_saved_info_t > const & - -ida_hexrays.lvar_saved_infos_t.__getitem__ (method) - __getitem__(self, i) -> lvar_saved_info_t - - @param i: size_t - -ida_hexrays.lvar_saved_infos_t.__init__ (method) - __init__(self) -> lvar_saved_infos_t - __init__(self, x) -> lvar_saved_infos_t - - @param x: qvector< lvar_saved_info_t > const & - -ida_hexrays.lvar_saved_infos_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.lvar_saved_infos_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< lvar_saved_info_t > const & - -ida_hexrays.lvar_saved_infos_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_infos_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_infos_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_infos_t.at (method) - at(self, _idx) -> lvar_saved_info_t - - @param _idx: size_t - -ida_hexrays.lvar_saved_infos_t.begin (method) - begin(self) -> lvar_saved_info_t - -ida_hexrays.lvar_saved_infos_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.lvar_saved_infos_t.clear (method) - clear(self) - -ida_hexrays.lvar_saved_infos_t.empty (method) - empty(self) -> bool - -ida_hexrays.lvar_saved_infos_t.end (method) - end(self) -> lvar_saved_info_t - -ida_hexrays.lvar_saved_infos_t.erase (method) - erase(self, it) -> lvar_saved_info_t - - @param it: qvector< lvar_saved_info_t >::iterator - - erase(self, first, last) -> lvar_saved_info_t - - @param first: qvector< lvar_saved_info_t >::iterator - @param last: qvector< lvar_saved_info_t >::iterator - -ida_hexrays.lvar_saved_infos_t.extract (method) - extract(self) -> lvar_saved_info_t - -ida_hexrays.lvar_saved_infos_t.find (method) - find(self, x) -> lvar_saved_info_t - - @param x: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_infos_t.grow (method) - grow(self, x=lvar_saved_info_t()) - - @param x: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_infos_t.has (method) - has(self, x) -> bool - - @param x: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_infos_t.inject (method) - inject(self, s, len) - - @param s: lvar_saved_info_t * - @param len: size_t - -ida_hexrays.lvar_saved_infos_t.insert (method) - insert(self, it, x) -> lvar_saved_info_t - - @param it: qvector< lvar_saved_info_t >::iterator - @param x: lvar_saved_info_t const & - -ida_hexrays.lvar_saved_infos_t.pop_back (method) - pop_back(self) - -ida_hexrays.lvar_saved_infos_t.push_back (method) - push_back(self, x) - - @param x: lvar_saved_info_t const & - - push_back(self) -> lvar_saved_info_t - -ida_hexrays.lvar_saved_infos_t.qclear (method) - qclear(self) - -ida_hexrays.lvar_saved_infos_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.lvar_saved_infos_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: lvar_saved_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.lvar_saved_infos_t.size (method) - size(self) -> size_t - -ida_hexrays.lvar_saved_infos_t.swap (method) - swap(self, r) - - @param r: qvector< lvar_saved_info_t > & - -ida_hexrays.lvar_saved_infos_t.truncate (method) - truncate(self) - -ida_hexrays.lvar_t (class) - Proxy of C++ lvar_t class. - -ida_hexrays.lvar_t.__init__ (method) - -ida_hexrays.lvar_t.accepts_type (method) - accepts_type(self, t, may_change_thisarg=False) -> bool - Check if the variable accept the specified type. Some types are forbidden (void, - function types, wrong arrays, etc) - - @param t: (C++: const tinfo_t &) tinfo_t const & - @param may_change_thisarg: (C++: bool) - -ida_hexrays.lvar_t.append_list (method) - append_list(self, mba, lst, pad_if_scattered=False) - Append local variable to mlist. - - @param mba: (C++: const mba_t *) ptr to the current mba_t - @param lst: (C++: mlist_t *) list to append to - @param pad_if_scattered: (C++: bool) if true, append padding bytes in case of scattered lvar - -ida_hexrays.lvar_t.clear_used (method) - clear_used(self) - -ida_hexrays.lvar_t.clr_arg_var (method) - clr_arg_var(self) - -ida_hexrays.lvar_t.clr_automapped (method) - clr_automapped(self) - -ida_hexrays.lvar_t.clr_decl_unused (method) - clr_decl_unused(self) - -ida_hexrays.lvar_t.clr_dummy_arg (method) - clr_dummy_arg(self) - -ida_hexrays.lvar_t.clr_fake_var (method) - clr_fake_var(self) - -ida_hexrays.lvar_t.clr_floating_var (method) - clr_floating_var(self) - -ida_hexrays.lvar_t.clr_mapdst_var (method) - clr_mapdst_var(self) - -ida_hexrays.lvar_t.clr_mreg_done (method) - clr_mreg_done(self) - -ida_hexrays.lvar_t.clr_noptr_var (method) - clr_noptr_var(self) - -ida_hexrays.lvar_t.clr_notarg (method) - clr_notarg(self) - -ida_hexrays.lvar_t.clr_overlapped_var (method) - clr_overlapped_var(self) - -ida_hexrays.lvar_t.clr_shared (method) - clr_shared(self) - -ida_hexrays.lvar_t.clr_split_var (method) - clr_split_var(self) - -ida_hexrays.lvar_t.clr_spoiled_var (method) - clr_spoiled_var(self) - -ida_hexrays.lvar_t.clr_thisarg (method) - clr_thisarg(self) - -ida_hexrays.lvar_t.clr_unknown_width (method) - clr_unknown_width(self) - -ida_hexrays.lvar_t.clr_used_byref (method) - clr_used_byref(self) - -ida_hexrays.lvar_t.clr_user_info (method) - clr_user_info(self) - -ida_hexrays.lvar_t.clr_user_name (method) - clr_user_name(self) - -ida_hexrays.lvar_t.clr_user_type (method) - clr_user_type(self) - -ida_hexrays.lvar_t.cmt (variable) - variable comment string - -ida_hexrays.lvar_t.defblk (variable) - first block defining the variable. 0 for args, -1 if unknown - -ida_hexrays.lvar_t.divisor (variable) - max known divisor of the variable - -ida_hexrays.lvar_t.has_common (method) - has_common(self, v) -> bool - Do variables overlap? - - @param v: (C++: const lvar_t &) lvar_t const & - -ida_hexrays.lvar_t.has_common_bit (method) - has_common_bit(self, loc, width2) -> bool - Does the variable overlap with the specified location? - - @param loc: (C++: const vdloc_t &) vdloc_t const & - @param width2: (C++: asize_t) - -ida_hexrays.lvar_t.has_nice_name (method) - has_nice_name(self) -> bool - Does the variable have a nice name? - -ida_hexrays.lvar_t.has_regname (method) - has_regname(self) -> bool - Has a register name? (like _RAX) - -ida_hexrays.lvar_t.has_user_info (method) - has_user_info(self) -> bool - Has any user-defined information? - -ida_hexrays.lvar_t.has_user_name (method) - has_user_name(self) -> bool - Has user-defined name? - -ida_hexrays.lvar_t.has_user_type (method) - has_user_type(self) -> bool - Has user-defined type? - -ida_hexrays.lvar_t.in_asm (method) - in_asm(self) -> bool - Is variable used in an instruction translated into __asm? - -ida_hexrays.lvar_t.is_aliasable (method) - is_aliasable(self, mba) -> bool - Is the variable aliasable? - - @param mba: (C++: const mba_t *) ptr to the current mba_t Aliasable variables may be modified - indirectly (through a pointer) - -ida_hexrays.lvar_t.is_arg_var (method) - is_arg_var(self) -> bool - Is the function argument? - -ida_hexrays.lvar_t.is_automapped (method) - is_automapped(self) -> bool - Was the variable automatically mapped to another variable? - -ida_hexrays.lvar_t.is_decl_unused (method) - is_decl_unused(self) -> bool - Was declared as __unused by the user? See CVAR_UNUSED. - -ida_hexrays.lvar_t.is_dummy_arg (method) - is_dummy_arg(self) -> bool - Is a dummy argument (added to fill a hole in the argument list) - -ida_hexrays.lvar_t.is_fake_var (method) - is_fake_var(self) -> bool - Is fake return variable? - -ida_hexrays.lvar_t.is_floating_var (method) - is_floating_var(self) -> bool - Used by a fpu insn? - -ida_hexrays.lvar_t.is_mapdst_var (method) - is_mapdst_var(self) -> bool - Other variable(s) map to this var? - -ida_hexrays.lvar_t.is_noptr_var (method) - is_noptr_var(self) -> bool - Variable type should not be a pointer. - -ida_hexrays.lvar_t.is_notarg (method) - is_notarg(self) -> bool - Is a local variable? (local variable cannot be an input argument) - -ida_hexrays.lvar_t.is_overlapped_var (method) - is_overlapped_var(self) -> bool - Is overlapped variable? - -ida_hexrays.lvar_t.is_result_var (method) - is_result_var(self) -> bool - Is the function result? - -ida_hexrays.lvar_t.is_shared (method) - is_shared(self) -> bool - Is lvar mapped to several chains. - -ida_hexrays.lvar_t.is_split_var (method) - is_split_var(self) -> bool - Is a split variable? - -ida_hexrays.lvar_t.is_spoiled_var (method) - is_spoiled_var(self) -> bool - Is spoiled var? (meaningful only during lvar allocation) - -ida_hexrays.lvar_t.is_thisarg (method) - is_thisarg(self) -> bool - Is 'this' argument of a C++ member function? - -ida_hexrays.lvar_t.is_unknown_width (method) - is_unknown_width(self) -> bool - Do we know the width of the variable? - -ida_hexrays.lvar_t.is_used_byref (method) - is_used_byref(self) -> bool - Was the address of the variable taken? - -ida_hexrays.lvar_t.mreg_done (method) - mreg_done(self) -> bool - Have corresponding microregs been replaced by references to this variable? - -ida_hexrays.lvar_t.name (variable) - variable name. use mba_t::set_nice_lvar_name() and mba_t::set_user_lvar_name() - to modify it - -ida_hexrays.lvar_t.set_arg_var (method) - set_arg_var(self) - -ida_hexrays.lvar_t.set_automapped (method) - set_automapped(self) - -ida_hexrays.lvar_t.set_decl_unused (method) - set_decl_unused(self) - -ida_hexrays.lvar_t.set_dummy_arg (method) - set_dummy_arg(self) - -ida_hexrays.lvar_t.set_fake_var (method) - set_fake_var(self) - -ida_hexrays.lvar_t.set_final_lvar_type (method) - set_final_lvar_type(self, t) - Set final variable type. - - @param t: (C++: const tinfo_t &) tinfo_t const & - -ida_hexrays.lvar_t.set_floating_var (method) - set_floating_var(self) - -ida_hexrays.lvar_t.set_lvar_type (method) - set_lvar_type(self, t, may_fail=False) -> bool - Set variable type Note: this function does not modify the idb, only the lvar - instance in the memory. For permanent changes see modify_user_lvars() Also, the - variable type is not considered as final by the decompiler and may be modified - later by the type derivation. In some cases set_final_var_type() may work - better, but it does not do persistent changes to the database neither. - - @param t: (C++: const tinfo_t &) new type - @param may_fail: (C++: bool) if false and type is bad, interr - @return: success - -ida_hexrays.lvar_t.set_mapdst_var (method) - set_mapdst_var(self) - -ida_hexrays.lvar_t.set_mreg_done (method) - set_mreg_done(self) - -ida_hexrays.lvar_t.set_non_typed (method) - set_non_typed(self) - -ida_hexrays.lvar_t.set_noptr_var (method) - set_noptr_var(self) - -ida_hexrays.lvar_t.set_notarg (method) - set_notarg(self) - -ida_hexrays.lvar_t.set_overlapped_var (method) - set_overlapped_var(self) - -ida_hexrays.lvar_t.set_shared (method) - set_shared(self) - -ida_hexrays.lvar_t.set_split_var (method) - set_split_var(self) - -ida_hexrays.lvar_t.set_spoiled_var (method) - set_spoiled_var(self) - -ida_hexrays.lvar_t.set_thisarg (method) - set_thisarg(self) - -ida_hexrays.lvar_t.set_typed (method) - set_typed(self) - -ida_hexrays.lvar_t.set_unknown_width (method) - set_unknown_width(self) - -ida_hexrays.lvar_t.set_used (method) - set_used(self) - -ida_hexrays.lvar_t.set_used_byref (method) - set_used_byref(self) - -ida_hexrays.lvar_t.set_user_name (method) - set_user_name(self) - -ida_hexrays.lvar_t.set_user_type (method) - set_user_type(self) - -ida_hexrays.lvar_t.set_width (method) - set_width(self, w, svw_flags=0) -> bool - Change the variable width. We call the variable size 'width', it is represents - the number of bytes. This function may change the variable type using - set_lvar_type(). - - @param w: (C++: int) new width - @param svw_flags: (C++: int) combination of SVW_... bits - @return: success - -ida_hexrays.lvar_t.tif (variable) - variable type - -ida_hexrays.lvar_t.type (method) - type(self) -> tinfo_t - -ida_hexrays.lvar_t.typed (method) - typed(self) -> bool - Has the variable a type? - -ida_hexrays.lvar_t.used (method) - used(self) -> bool - Is the variable used in the code? - -ida_hexrays.lvar_t.width (variable) - variable size in bytes - -ida_hexrays.lvar_uservec_t (class) - Proxy of C++ lvar_uservec_t class. - -ida_hexrays.lvar_uservec_t.__init__ (method) - __init__(self) -> lvar_uservec_t - -ida_hexrays.lvar_uservec_t.clear (method) - clear(self) - -ida_hexrays.lvar_uservec_t.empty (method) - empty(self) -> bool - -ida_hexrays.lvar_uservec_t.find_info (method) - find_info(self, vloc) -> lvar_saved_info_t - find saved user settings for given var - - @param vloc: (C++: const lvar_locator_t &) lvar_locator_t const & - -ida_hexrays.lvar_uservec_t.keep_info (method) - keep_info(self, v) - Preserve user settings for given var. - - @param v: (C++: const lvar_t &) lvar_t const & - -ida_hexrays.lvar_uservec_t.lmaps (variable) - Local variable mapping (used for merging variables) - -ida_hexrays.lvar_uservec_t.lvvec (variable) - User-specified names, types, comments for lvars. Variables without user- - specified info are not present in this vector. - -ida_hexrays.lvar_uservec_t.stkoff_delta (variable) - Delta to add to IDA stack offset to calculate Hex-Rays stack offsets. Should be - set by the caller before calling save_user_lvar_settings(); - -ida_hexrays.lvar_uservec_t.swap (method) - swap(self, r) - - @param r: lvar_uservec_t & - -ida_hexrays.lvar_uservec_t.ulv_flags (variable) - Various flags. Possible values are from lvar_uservec_t property bits. - -ida_hexrays.lvars_t (class) - Proxy of C++ lvars_t class. - -ida_hexrays.lvars_t.__init__ (method) - __init__(self) -> lvars_t - -ida_hexrays.lvars_t.find (method) - find(self, ll) -> lvar_t - Find variable at the specified location. - - @param ll: (C++: const lvar_locator_t &) variable location - @return: pointer to variable or nullptr - -ida_hexrays.lvars_t.find_input_lvar (method) - find_input_lvar(self, argloc, _size) -> int - Find input variable at the specified location. - - @param argloc: (C++: const vdloc_t &) variable location - @param _size: (C++: int) variable size - @return: -1 if failed, otherwise the index into the variables vector. - -ida_hexrays.lvars_t.find_lvar (method) - find_lvar(self, location, width, defblk=-1) -> int - Find variable at the specified location. - - @param location: (C++: const vdloc_t &) variable location - @param width: (C++: int) variable size - @param defblk: (C++: int) definition block of the lvar. -1 means any block - @return: -1 if failed, otherwise the index into the variables vector. - -ida_hexrays.lvars_t.find_stkvar (method) - find_stkvar(self, spoff, width) -> int - Find stack variable at the specified location. - - @param spoff: (C++: sval_t) offset from the minimal sp - @param width: (C++: int) variable size - @return: -1 if failed, otherwise the index into the variables vector. - -ida_hexrays.lxe_lvar_cmt_changed (variable) - Local variable comment got changed. - -ida_hexrays.lxe_lvar_mapping_changed (variable) - Local variable mapping got changed. - -ida_hexrays.lxe_lvar_name_changed (variable) - Local variable got renamed. - -ida_hexrays.lxe_lvar_type_changed (variable) - Local variable type got changed. - -ida_hexrays.make_num (function) - Create a number expression - -ida_hexrays.make_pointer (function) - make_pointer(type) -> tinfo_t - Create a pointer type. This function performs the following conversion: "type" - -> "type*" - - @param type: (C++: const tinfo_t &) object type. - @return: "type*". for example, if 'char' is passed as the argument, - -ida_hexrays.make_ref (function) - Create a reference. This function performs the following conversion: "obj" => - "&obj". It can handle casts, annihilate "&*", and process other special cases. - -ida_hexrays.mark_cfunc_dirty (function) - mark_cfunc_dirty(ea, close_views=False) -> bool - Flush the cached decompilation results. Erases a cache entry for the specified - function. - - @param ea: (C++: ea_t) function to erase from the cache - @param close_views: (C++: bool) close pseudocode windows that show the function - @return: if a cache entry existed. - -ida_hexrays.mba_range_iterator_t (class) - Proxy of C++ mba_range_iterator_t class. - -ida_hexrays.mba_range_iterator_t.__init__ (method) - __init__(self) -> mba_range_iterator_t - -ida_hexrays.mba_range_iterator_t.chunk (method) - chunk(self) -> range_t - -ida_hexrays.mba_range_iterator_t.is_snippet (method) - is_snippet(self) -> bool - -ida_hexrays.mba_range_iterator_t.next (method) - next(self) -> bool - -ida_hexrays.mba_range_iterator_t.set (method) - set(self, mbr) -> bool - - @param mbr: mba_ranges_t const & - -ida_hexrays.mba_ranges_t (class) - Proxy of C++ mba_ranges_t class. - -ida_hexrays.mba_ranges_t.__init__ (method) - __init__(self, _pfn=None) -> mba_ranges_t - - @param _pfn: func_t * - - __init__(self, r) -> mba_ranges_t - - @param r: rangevec_t const & - -ida_hexrays.mba_ranges_t.clear (method) - clear(self) - -ida_hexrays.mba_ranges_t.empty (method) - empty(self) -> bool - -ida_hexrays.mba_ranges_t.is_fragmented (method) - is_fragmented(self) -> bool - -ida_hexrays.mba_ranges_t.is_snippet (method) - is_snippet(self) -> bool - -ida_hexrays.mba_ranges_t.pfn (variable) - function to decompile. if not null, then function mode. - -ida_hexrays.mba_ranges_t.ranges (variable) - snippet mode: ranges to decompile. function mode: list of outlined ranges - -ida_hexrays.mba_ranges_t.start (method) - start(self) -> ea_t - -ida_hexrays.mba_t (class) - Deprecated. Please do not use. - -ida_hexrays.mba_t.__init__ (method) - -ida_hexrays.mba_t._deregister (method) - _deregister(self) - -ida_hexrays.mba_t._print (method) - _print(self, vp) - - Parameters - ---------- - vp: vd_printer_t & - -ida_hexrays.mba_t._register (method) - _register(self) - -ida_hexrays.mba_t.aliased_args (variable) - Aliased stkarg locations. - -ida_hexrays.mba_t.aliased_memory (variable) - aliased_memory+restricted_memory=ALLMEM - -ida_hexrays.mba_t.aliased_vars (variable) - Aliased stkvar locations. - -ida_hexrays.mba_t.alloc_fict_ea (method) - alloc_fict_ea(self, real_ea) -> ea_t - Allocate a fictional address. This function can be used to allocate a new unique - address for a new instruction, if re-using any existing address leads to - conflicts. For example, if the last instruction of the function modifies R0 and - falls through to the next function, it will be a tail call: LDM R0!, {R4,R7} end - of the function start of another function In this case R0 generates two - different lvars at the same address: - * one modified by LDM - * another that represents the return value from the tail call Another example: a - third-party plugin makes a copy of an instruction. This may lead to the - generation of two variables at the same address. Example 3: fictional addresses - can be used for new instructions created while modifying the microcode. This - function can be used to allocate a new unique address for a new instruction or a - variable. The fictional address is selected from an unallocated address range. - - @param real_ea: (C++: ea_t) real instruction address (BADADDR is ok too) - @return: a unique fictional address - -ida_hexrays.mba_t.alloc_kreg (method) - alloc_kreg(self, size, check_size=True) -> mreg_t - Allocate a kernel register. - - @param size: (C++: size_t) size of the register in bytes - @param check_size: (C++: bool) if true, only the sizes that correspond to a size of a basic - type will be accepted. - @return: allocated register. mr_none means failure. - -ida_hexrays.mba_t.alloc_lvars (method) - alloc_lvars(self) - Allocate local variables. Must be called only immediately after - optimize_global(), with no modifications to the microcode. Converts registers, - stack variables, and similar operands into mop_l. This call will not fail - because all necessary checks were performed in optimize_global(). After this - call the microcode reaches its final state. - -ida_hexrays.mba_t.analyze_calls (method) - analyze_calls(self, acflags) -> int - Analyze calls and determine calling conventions. - - @param acflags: (C++: int) permitted actions that are necessary for successful detection of - calling conventions. See Bits for analyze_calls() - @return: number of calls. -1 means error. - -ida_hexrays.mba_t.arg (method) - arg(self, n) -> lvar_t - - @param n: int - -ida_hexrays.mba_t.argbase (method) - argbase(self) -> sval_t - -ida_hexrays.mba_t.argidx (variable) - input arguments (indexes into 'vars') - -ida_hexrays.mba_t.argidx_ok (method) - argidx_ok(self) -> bool - -ida_hexrays.mba_t.argidx_sorted (method) - argidx_sorted(self) -> bool - -ida_hexrays.mba_t.bad_call_sp_detected (method) - bad_call_sp_detected(self) -> bool - -ida_hexrays.mba_t.blocks (variable) - double linked list of blocks - -ida_hexrays.mba_t.build_graph (method) - build_graph(self) -> merror_t - Build control flow graph. This function may be called only once. It calculates - the type of each basic block and the adjacency list. optimize_local() calls this - function if necessary. You need to call this function only before MMAT_LOCOPT. - - @return: error code - -ida_hexrays.mba_t.calc_shins_flags (method) - calc_shins_flags(self) -> int - -ida_hexrays.mba_t.callinfo_built (method) - callinfo_built(self) -> bool - -ida_hexrays.mba_t.cc (variable) - calling convention - -ida_hexrays.mba_t.chain_varnums_ok (method) - chain_varnums_ok(self) -> bool - -ida_hexrays.mba_t.clr_cdtr (method) - clr_cdtr(self) - -ida_hexrays.mba_t.clr_mba_flags (method) - clr_mba_flags(self, f) - - @param f: int - -ida_hexrays.mba_t.clr_mba_flags2 (method) - clr_mba_flags2(self, f) - - @param f: int - -ida_hexrays.mba_t.code16_bit_removed (method) - code16_bit_removed(self) -> bool - -ida_hexrays.mba_t.combine_blocks (method) - combine_blocks(self) -> bool - Combine blocks. This function merges blocks constituting linear flow. It calls - remove_empty_and_unreachable_blocks() as well. - - @return: true if changed any blocks - -ida_hexrays.mba_t.common_stkvars_stkargs (method) - common_stkvars_stkargs(self) -> bool - -ida_hexrays.mba_t.consumed_argregs (variable) - registers converted into stack arguments, should not be used as arguments - -ida_hexrays.mba_t.copy_block (method) - copy_block(self, blk, new_serial, cpblk_flags=3) -> mblock_t - Make a copy of a block. This function makes a simple copy of the block. It does - not fix the predecessor and successor lists, they must be fixed if necessary. - - @param blk: (C++: mblock_t *) block to copy - @param new_serial: (C++: int) position of the copied block - @param cpblk_flags: (C++: int) combination of Batch decompilation bits... bits - @return: pointer to the new copy - -ida_hexrays.mba_t.create_helper_call (method) - create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t - Create a call of a helper function. - - @param ea: (C++: ea_t) The desired address of the instruction - @param helper: (C++: const char *) The helper name - @param rettype: (C++: const tinfo_t *) The return type (nullptr or empty type means 'void') - @param callargs: (C++: const mcallargs_t *) The helper arguments (nullptr-no arguments) - @param out: (C++: const mop_t *) The operand where the call result should be stored. If this argument - is not nullptr, "mov helper_call(), out" will be generated. - Otherwise "call helper()" will be generated. Note: the size of this - operand must be equal to the RETTYPE size - @return: pointer to the created instruction or nullptr if error - -ida_hexrays.mba_t.deleted_pairs (method) - deleted_pairs(self) -> bool - -ida_hexrays.mba_t.deprecated_idb_node (variable) - netnode with additional decompiler info. deprecated, do not use it anymore. it - may get stale after undo. - -ida_hexrays.mba_t.deserialize (method) - deserialize(bytes) -> mba_t - Deserialize a byte sequence into mbl array. - - @param bytes: (C++: const uchar *) pointer to the beginning of the byte sequence. - @return: new mbl array - -ida_hexrays.mba_t.display_numaddrs (method) - display_numaddrs(self) -> bool - -ida_hexrays.mba_t.display_valnums (method) - display_valnums(self) -> bool - -ida_hexrays.mba_t.dump (method) - dump(self) - Dump microcode to a file. The file will be created in the directory pointed by - IDA_DUMPDIR envvar. Dump will be created only if IDA is run under debugger. - -ida_hexrays.mba_t.dump_mba (method) - dump_mba(self, _verify, title) - - @param _verify: bool - @param title: char const * - -ida_hexrays.mba_t.error_ea (variable) - during microcode generation holds ins.ea - -ida_hexrays.mba_t.final_type (variable) - is the function type final? (specified by the user) - -ida_hexrays.mba_t.find_mop (method) - find_mop(self, ctx, ea, is_dest, list) -> mop_t - Find an operand in the microcode. This function tries to find the operand that - matches LIST. Any operand that overlaps with LIST is considered as a match. - - @param ctx: (C++: op_parent_info_t *) context information for the result - @param ea: (C++: ea_t) desired address of the operand. BADADDR means to accept any address. - @param is_dest: (C++: bool) search for destination operand? this argument may be ignored if - the exact match could not be found - @param list: (C++: const mlist_t &) list of locations the correspond to the operand - @return: pointer to the operand or nullptr. - -ida_hexrays.mba_t.for_all_insns (method) - for_all_insns(self, mv) -> int - Visit all instructions. This function visits all instruction and - subinstructions. - - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: non-zero value returned by mv.visit_mop() or zero - -ida_hexrays.mba_t.for_all_ops (method) - for_all_ops(self, mv) -> int - Visit all operands of all instructions. - - @param mv: (C++: mop_visitor_t &) operand visitor - @return: non-zero value returned by mv.visit_mop() or zero - -ida_hexrays.mba_t.for_all_topinsns (method) - for_all_topinsns(self, mv) -> int - Visit all top level instructions. - - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: non-zero value returned by mv.visit_mop() or zero - -ida_hexrays.mba_t.fpd (variable) - frame pointer delta - -ida_hexrays.mba_t.free_kreg (method) - free_kreg(self, reg, size) - Free a kernel register. If wrong arguments are passed, this function will - generate an internal error. - - @param reg: (C++: mreg_t) a previously allocated kernel register - @param size: (C++: size_t) size of the register in bytes - -ida_hexrays.mba_t.frregs (variable) - size of saved registers range in the stack frame - -ida_hexrays.mba_t.frsize (variable) - size of local stkvars range in the stack frame - -ida_hexrays.mba_t.fti_flags (variable) - FTI_... constants for the current function. - -ida_hexrays.mba_t.fullsize (variable) - Full stack size including incoming args. - -ida_hexrays.mba_t.generated_asserts (method) - generated_asserts(self) -> bool - -ida_hexrays.mba_t.get_args_region (method) - get_args_region(self) -> ivl_t - -ida_hexrays.mba_t.get_curfunc (method) - get_curfunc(self) -> func_t * - -ida_hexrays.mba_t.get_func_output_lists (method) - get_func_output_lists(self, return_regs, spoiled, type, call_ea=BADADDR, tail_call=False) - Prepare the lists of registers & memory that are defined/killed by a function - - @param return_regs: (C++: mlist_t *) defined regs to return (eax,edx) - @param spoiled: (C++: mlist_t *) spoiled regs (flags,ecx,mem) - @param type: (C++: const tinfo_t &) the function type - @param call_ea: (C++: ea_t) the call insn address (if known) - @param tail_call: (C++: bool) is it the tail call? - -ida_hexrays.mba_t.get_graph (method) - get_graph(self) -> mbl_graph_t - Get control graph. Call build_graph() if you need the graph before MMAT_LOCOPT. - -ida_hexrays.mba_t.get_ida_argloc (method) - get_ida_argloc(self, v) -> argloc_t - - @param v: lvar_t const & - -ida_hexrays.mba_t.get_lvars_region (method) - get_lvars_region(self) -> ivl_t - -ida_hexrays.mba_t.get_mba_flags (method) - get_mba_flags(self) -> int - -ida_hexrays.mba_t.get_mba_flags2 (method) - get_mba_flags2(self) -> int - -ida_hexrays.mba_t.get_mblock (method) - get_mblock(self, n) -> mblock_t - - @param n: int - -ida_hexrays.mba_t.get_shadow_region (method) - get_shadow_region(self) -> ivl_t - -ida_hexrays.mba_t.get_stack_region (method) - get_stack_region(self) -> ivl_t - -ida_hexrays.mba_t.get_std_region (method) - get_std_region(self, idx) -> ivl_t - Get information about various memory regions. We map the stack frame to the - global memory, to some unused range. - - @param idx: (C++: memreg_index_t) enum memreg_index_t - -ida_hexrays.mba_t.gotoff_stkvars (variable) - stkvars that hold .got offsets. considered to be unaliasable - -ida_hexrays.mba_t.graph_insns (method) - graph_insns(self) -> bool - -ida_hexrays.mba_t.has_bad_sp (method) - has_bad_sp(self) -> bool - -ida_hexrays.mba_t.has_outlines (method) - has_outlines(self) -> bool - -ida_hexrays.mba_t.has_over_chains (method) - has_over_chains(self) -> bool - -ida_hexrays.mba_t.has_passregs (method) - has_passregs(self) -> bool - -ida_hexrays.mba_t.has_stack_retval (method) - has_stack_retval(self) -> bool - -ida_hexrays.mba_t.idaloc2vd (method) - idaloc2vd(self, loc, width) -> vdloc_t - - @param loc: argloc_t const & - @param width: int - -ida_hexrays.mba_t.idb_spoiled (variable) - MBA_SPLINFO && final_type: info in ida format. - -ida_hexrays.mba_t.idb_type (variable) - function type as retrieved from the database - -ida_hexrays.mba_t.inargoff (variable) - offset of the first stack argument; after fix_scattered_movs() INARGOFF may be - less than STACKSIZE - -ida_hexrays.mba_t.insert_block (method) - insert_block(self, bblk) -> mblock_t - Insert a block in the middle of the mbl array. The very first block of microcode - must be empty, it is the entry block. The very last block of microcode must be - BLT_STOP, it is the exit block. Therefore inserting a new block before the entry - point or after the exit block is not a good idea. - - @param bblk: (C++: int) the new block will be inserted before BBLK - @return: ptr to the new block - -ida_hexrays.mba_t.is_cdtr (method) - is_cdtr(self) -> bool - -ida_hexrays.mba_t.is_ctr (method) - is_ctr(self) -> bool - -ida_hexrays.mba_t.is_dtr (method) - is_dtr(self) -> bool - -ida_hexrays.mba_t.is_pattern (method) - is_pattern(self) -> bool - -ida_hexrays.mba_t.is_snippet (method) - is_snippet(self) -> bool - -ida_hexrays.mba_t.is_stkarg (method) - is_stkarg(self, v) -> bool - - @param v: lvar_t const & - -ida_hexrays.mba_t.is_thunk (method) - is_thunk(self) -> bool - -ida_hexrays.mba_t.label (variable) - name of the function or pattern (colored) - -ida_hexrays.mba_t.loaded_gdl (method) - loaded_gdl(self) -> bool - -ida_hexrays.mba_t.lvar_names_ok (method) - lvar_names_ok(self) -> bool - -ida_hexrays.mba_t.lvars_allocated (method) - lvars_allocated(self) -> bool - -ida_hexrays.mba_t.lvars_renamed (method) - lvars_renamed(self) -> bool - -ida_hexrays.mba_t.map_fict_ea (method) - map_fict_ea(self, fict_ea) -> ea_t - Resolve a fictional address. This function provides a reverse of the mapping - made by alloc_fict_ea(). - - @param fict_ea: (C++: ea_t) fictional definition address - @return: the real instruction address - -ida_hexrays.mba_t.mark_chains_dirty (method) - mark_chains_dirty(self) - Mark the microcode use-def chains dirty. Call this function is any inter-block - data dependencies got changed because of your modifications to the microcode. - Failing to do so may cause an internal error. - -ida_hexrays.mba_t.maturity (variable) - current maturity level - -ida_hexrays.mba_t.may_refine_rettype (method) - may_refine_rettype(self) -> bool - -ida_hexrays.mba_t.minargref (variable) - The lowest stack argument location whose address was taken This location and - locations above it can be aliased It controls locations >= inargoff-shadow_args - -ida_hexrays.mba_t.minstkref (variable) - The lowest stack location whose address was taken. - -ida_hexrays.mba_t.minstkref_ea (variable) - address with lowest minstkref (for debugging) - -ida_hexrays.mba_t.natural (variable) - natural order of blocks - -ida_hexrays.mba_t.nodel_memory (variable) - global dead elimination may not delete references to this area - -ida_hexrays.mba_t.npurged (variable) - -1 - unknown - -ida_hexrays.mba_t.optimize_global (method) - optimize_global(self) -> merror_t - Optimize microcode globally. This function applies various optimization methods - until we reach the fixed point. After that it preallocates lvars unless reqmat - forbids it. - - @return: error code - -ida_hexrays.mba_t.optimize_local (method) - optimize_local(self, locopt_bits) -> int - Optimize each basic block locally - - @param locopt_bits: (C++: int) combination of Bits for optimize_local() bits - @return: number of changes. 0 means nothing changed This function is called by - the decompiler, usually there is no need to call it explicitly. - -ida_hexrays.mba_t.optimized (method) - optimized(self) -> bool - -ida_hexrays.mba_t.pfn_flags (variable) - copy of func_t::flags - -ida_hexrays.mba_t.precise_defeas (method) - precise_defeas(self) -> bool - -ida_hexrays.mba_t.prop_complex (method) - prop_complex(self) -> bool - -ida_hexrays.mba_t.propagated_asserts (method) - propagated_asserts(self) -> bool - -ida_hexrays.mba_t.qty (variable) - number of basic blocks - -ida_hexrays.mba_t.really_alloc (method) - really_alloc(self) -> bool - -ida_hexrays.mba_t.regargs_is_not_aligned (method) - regargs_is_not_aligned(self) -> bool - -ida_hexrays.mba_t.remove_block (method) - remove_block(self, blk) -> bool - Delete a block. - - @param blk: (C++: mblock_t *) block to delete - @return: true if at least one of the other blocks became empty or unreachable - -ida_hexrays.mba_t.remove_empty_and_unreachable_blocks (method) - remove_empty_and_unreachable_blocks(self) -> bool - Delete all empty and unreachable blocks. Blocks marked with MBL_KEEP won't be - deleted. - -ida_hexrays.mba_t.reqmat (variable) - required maturity level - -ida_hexrays.mba_t.retsize (variable) - size of return address in the stack frame - -ida_hexrays.mba_t.returns_fpval (method) - returns_fpval(self) -> bool - -ida_hexrays.mba_t.retvaridx (variable) - index of variable holding the return value -1 means none - -ida_hexrays.mba_t.rtype_refined (method) - rtype_refined(self) -> bool - -ida_hexrays.mba_t.save_snapshot (method) - save_snapshot(self, description) - Create and save microcode snapshot. - - @param description: (C++: const char *) char const * - -ida_hexrays.mba_t.saverest_done (method) - saverest_done(self) -> bool - -ida_hexrays.mba_t.serialize (method) - serialize(self) - Serialize mbl array into a sequence of bytes. - -ida_hexrays.mba_t.set_lvar_name (method) - set_lvar_name(self, v, name, flagbits) -> bool - - @param v: lvar_t & - @param name: char const * - @param flagbits: int - -ida_hexrays.mba_t.set_maturity (method) - set_maturity(self, mat) -> bool - Set maturity level. - - @param mat: (C++: mba_maturity_t) new maturity level - @return: true if it is time to stop analysis Plugins may use this function to - skip some parts of the analysis. The maturity level cannot be - decreased. - -ida_hexrays.mba_t.set_mba_flags (method) - set_mba_flags(self, f) - - @param f: int - -ida_hexrays.mba_t.set_mba_flags2 (method) - set_mba_flags2(self, f) - - @param f: int - -ida_hexrays.mba_t.set_nice_lvar_name (method) - set_nice_lvar_name(self, v, name) -> bool - - @param v: lvar_t & - @param name: char const * - -ida_hexrays.mba_t.set_user_lvar_name (method) - set_user_lvar_name(self, v, name) -> bool - - @param v: lvar_t & - @param name: char const * - -ida_hexrays.mba_t.shadow_args (variable) - size of shadow argument area - -ida_hexrays.mba_t.short_display (method) - short_display(self) -> bool - -ida_hexrays.mba_t.should_beautify (method) - should_beautify(self) -> bool - -ida_hexrays.mba_t.show_reduction (method) - show_reduction(self) -> bool - -ida_hexrays.mba_t.spd_adjust (variable) - If sp>0, the max positive sp value. - -ida_hexrays.mba_t.spoiled_list (variable) - MBA_SPLINFO && !final_type: info in vd format. - -ida_hexrays.mba_t.stacksize (variable) - The maximal size of the function stack including bytes allocated for outgoing - call arguments (up to retaddr) - -ida_hexrays.mba_t.std_ivls (variable) - we treat memory as consisting of 6 parts see memreg_index_t - -ida_hexrays.mba_t.stkoff_ida2vd (method) - stkoff_ida2vd(self, off) -> sval_t - - @param off: sval_t - -ida_hexrays.mba_t.stkoff_vd2ida (method) - stkoff_vd2ida(self, off) -> sval_t - - @param off: sval_t - -ida_hexrays.mba_t.term (method) - term(self) - -ida_hexrays.mba_t.tmpstk_size (variable) - size of the temporary stack part (which dynamically changes with push/pops) - -ida_hexrays.mba_t.use_frame (method) - use_frame(self) -> bool - -ida_hexrays.mba_t.use_wingraph32 (method) - use_wingraph32(self) -> bool - -ida_hexrays.mba_t.valranges_done (method) - valranges_done(self) -> bool - -ida_hexrays.mba_t.vars (variable) - local variables - -ida_hexrays.mba_t.vd2idaloc (method) - vd2idaloc(self, loc, width, spd) -> argloc_t - - @param loc: vdloc_t const & - @param width: int - @param spd: sval_t - - vd2idaloc(self, loc, width) -> argloc_t - - @param loc: vdloc_t const & - @param width: int - -ida_hexrays.mba_t.verify (method) - verify(self, always) - Verify microcode consistency. - - @param always: (C++: bool) if false, the check will be performed only if ida runs under - debugger If any inconsistency is discovered, an internal error - will be generated. We strongly recommend you to call this - function before returing control to the decompiler from your - callbacks, in the case if you modified the microcode. If the - microcode is inconsistent, this function will generate an - internal error. We provide the source code of this function in - the plugins/hexrays_sdk/verifier directory for your reference. - -ida_hexrays.mba_t.write_to_const_detected (method) - write_to_const_detected(self) -> bool - -ida_hexrays.mba_t_deserialize (function) - mba_t_deserialize(bytes) -> mba_t - - @param bytes: uchar const * - -ida_hexrays.mbl_graph_t (class) - Proxy of C++ mbl_graph_t class. - -ida_hexrays.mbl_graph_t.__init__ (method) - -ida_hexrays.mbl_graph_t.get_chain_stamp (method) - get_chain_stamp(self) -> int - -ida_hexrays.mbl_graph_t.get_du (method) - get_du(self, gctype) -> graph_chains_t - Get def-use chains. - - @param gctype: (C++: gctype_t) enum gctype_t - -ida_hexrays.mbl_graph_t.get_mblock (method) - get_mblock(self, n) -> mblock_t - - @param n: int - -ida_hexrays.mbl_graph_t.get_ud (method) - get_ud(self, gctype) -> graph_chains_t - Get use-def chains. - - @param gctype: (C++: gctype_t) enum gctype_t - -ida_hexrays.mbl_graph_t.is_du_chain_dirty (method) - is_du_chain_dirty(self, gctype) -> bool - Is the def-use chain of the specified kind dirty? - - @param gctype: (C++: gctype_t) enum gctype_t - -ida_hexrays.mbl_graph_t.is_redefined_globally (method) - is_redefined_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool - Is LIST redefined in the graph? - - @param list: (C++: const mlist_t &) mlist_t const & - @param b1: (C++: int) - @param b2: (C++: int) - @param m1: (C++: const minsn_t *) minsn_t const * - @param m2: (C++: const minsn_t *) minsn_t const * - @param maymust: (C++: maymust_t) - -ida_hexrays.mbl_graph_t.is_ud_chain_dirty (method) - is_ud_chain_dirty(self, gctype) -> bool - Is the use-def chain of the specified kind dirty? - - @param gctype: (C++: gctype_t) enum gctype_t - -ida_hexrays.mbl_graph_t.is_used_globally (method) - is_used_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool - Is LIST used in the graph? - - @param list: (C++: const mlist_t &) mlist_t const & - @param b1: (C++: int) - @param b2: (C++: int) - @param m1: (C++: const minsn_t *) minsn_t const * - @param m2: (C++: const minsn_t *) minsn_t const * - @param maymust: (C++: maymust_t) - -ida_hexrays.mblock_t (class) - Proxy of C++ mblock_t class. - -ida_hexrays.mblock_t.__init__ (method) - -ida_hexrays.mblock_t._print (method) - _print(self, vp) - - Parameters - ---------- - vp: vd_printer_t & - -ida_hexrays.mblock_t.append_def_list (method) - append_def_list(self, list, op, maymust) - Append def-list of an operand. This function calculates list of locations that - may or must be modified by the operand and appends it to LIST. - - @param list: (C++: mlist_t *) ptr to the output buffer. we will append to it. - @param op: (C++: const mop_t &) operand to calculate the def list of - @param maymust: (C++: maymust_t) should we calculate 'may-def' or 'must-def' list? see maymust_t - for more details. - -ida_hexrays.mblock_t.append_use_list (method) - append_use_list(self, list, op, maymust, mask=bitrange_t(0, USHRT_MAX)) - Append use-list of an operand. This function calculates list of locations that - may or must be used by the operand and appends it to LIST. - - @param list: (C++: mlist_t *) ptr to the output buffer. we will append to it. - @param op: (C++: const mop_t &) operand to calculate the use list of - @param maymust: (C++: maymust_t) should we calculate 'may-use' or 'must-use' list? see maymust_t - for more details. - @param mask: (C++: bitrange_t) if only part of the operand should be considered, a bitmask can be - used to specify which part. example: op=AX,mask=0xFF means that we - will consider only AL. - -ida_hexrays.mblock_t.build_def_list (method) - build_def_list(self, ins, maymust) -> mlist_t - Build def-list of an instruction. This function calculates list of locations - that may or must be modified by the instruction. Examples: "stx ebx.4, ds.2, - eax.4", may-list: all aliasable memory "stx ebx.4, ds.2, eax.4", must-list: - empty Since STX uses EAX for indirect access, it may modify any aliasable - memory. On the other hand, we cannot tell for sure which memory cells will be - modified, this is why the must-list is empty. - - @param ins: (C++: const minsn_t &) instruction to calculate the def list of - @param maymust: (C++: maymust_t) should we calculate 'may-def' or 'must-def' list? see maymust_t - for more details. - @return: the calculated def-list - -ida_hexrays.mblock_t.build_lists (method) - build_lists(self, kill_deads) -> int - Build def-use lists and eliminate deads. - - @param kill_deads: (C++: bool) do delete dead instructions? - @return: the number of eliminated instructions Better mblock_t::call - make_lists_ready() rather than this function. - -ida_hexrays.mblock_t.build_use_list (method) - build_use_list(self, ins, maymust) -> mlist_t - Build use-list of an instruction. This function calculates list of locations - that may or must be used by the instruction. Examples: "ldx ds.2, eax.4, ebx.4", - may-list: all aliasable memory "ldx ds.2, eax.4, ebx.4", must-list: empty Since - LDX uses EAX for indirect access, it may access any aliasable memory. On the - other hand, we cannot tell for sure which memory cells will be accessed, this is - why the must-list is empty. - - @param ins: (C++: const minsn_t &) instruction to calculate the use list of - @param maymust: (C++: maymust_t) should we calculate 'may-use' or 'must-use' list? see maymust_t - for more details. - @return: the calculated use-list - -ida_hexrays.mblock_t.dead_at_start (variable) - data that is dead at the block entry - -ida_hexrays.mblock_t.dnu (variable) - data that is defined but not used in the block - -ida_hexrays.mblock_t.dump (method) - dump(self) - Dump block info. This function is useful for debugging, see mba_t::dump for info - -ida_hexrays.mblock_t.dump_block (method) - dump_block(self, title) - - @param title: char const * - -ida_hexrays.mblock_t.empty (method) - empty(self) -> bool - -ida_hexrays.mblock_t.end (variable) - end address note: we cannot rely on start/end addresses very much because - instructions are propagated between blocks - -ida_hexrays.mblock_t.find_access (method) - find_access(self, op, parent, mend, fdflags) -> minsn_t - Find the instruction that accesses the specified operand. This function search - inside one block. - - @param op: (C++: const mop_t &) operand to search for - @param parent: (C++: minsn_t **) ptr to ptr to a top level instruction. denotes the beginning of - the search range. - @param mend: (C++: const minsn_t *) end instruction of the range (must be a top level insn) mend is - excluded from the range. it can be specified as nullptr. parent and - mend must belong to the same block. - @param fdflags: (C++: int) combination of bits for mblock_t::find_access bits - @return: the instruction that accesses the operand. this instruction may be a - sub-instruction. to find out the top level instruction, check out - *p_i1. nullptr means 'not found'. - -ida_hexrays.mblock_t.find_def (method) - find_def(self, op, p_i1, i2, fdflags) -> minsn_t - - @param op: mop_t const & - @param p_i1: minsn_t ** - @param i2: minsn_t const * - @param fdflags: int - -ida_hexrays.mblock_t.find_first_use (method) - find_first_use(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t - - @param list: mlist_t * - @param i1: minsn_t * - @param i2: minsn_t const * - @param maymust: maymust_t - -ida_hexrays.mblock_t.find_redefinition (method) - find_redefinition(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t - - @param list: mlist_t const & - @param i1: minsn_t * - @param i2: minsn_t const * - @param maymust: maymust_t - -ida_hexrays.mblock_t.find_use (method) - find_use(self, op, p_i1, i2, fdflags) -> minsn_t - - @param op: mop_t const & - @param p_i1: minsn_t ** - @param i2: minsn_t const * - @param fdflags: int - -ida_hexrays.mblock_t.flags (variable) - combination of Basic block properties bits - -ida_hexrays.mblock_t.for_all_insns (method) - for_all_insns(self, mv) -> int - Visit all instructions. This function visits subinstructions too. - - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: zero or the value returned by mv.visit_insn() See also - mba_t::for_all_topinsns() - -ida_hexrays.mblock_t.for_all_ops (method) - for_all_ops(self, mv) -> int - Visit all operands. This function visit subinstruction operands too. - - @param mv: (C++: mop_visitor_t &) operand visitor - @return: zero or the value returned by mv.visit_mop() - -ida_hexrays.mblock_t.for_all_uses (method) - for_all_uses(self, list, i1, i2, mmv) -> int - Visit all operands that use LIST. - - @param list: (C++: mlist_t *) ptr to the list of locations. it may be modified: parts that get - redefined by the instructions in [i1,i2) will be deleted. - @param i1: (C++: minsn_t *) starting instruction. must be a top level insn. - @param i2: (C++: minsn_t *) ending instruction (excluded). must be a top level insn. - @param mmv: (C++: mlist_mop_visitor_t &) operand visitor - @return: zero or the value returned by mmv.visit_mop() - -ida_hexrays.mblock_t.get_reginsn_qty (method) - get_reginsn_qty(self) -> size_t - Calculate number of regular instructions in the block. Assertions are skipped by - this function. - - @return: Number of non-assertion instructions in the block. - -ida_hexrays.mblock_t.get_valranges (method) - get_valranges(self, res, vivl, vrflags) -> bool - Find possible values for an instruction. - - @param res: (C++: valrng_t *) set of value ranges - @param vivl: (C++: const vivl_t &) what to search for - @param vrflags: (C++: int) combination of bits for get_valranges bits - get_valranges(self, res, vivl, m, vrflags) -> bool - - @param res: valrng_t * - @param vivl: vivl_t const & - @param m: minsn_t const * - @param vrflags: int - -ida_hexrays.mblock_t.head (variable) - pointer to the first instruction of the block - -ida_hexrays.mblock_t.insert_into_block (method) - insert_into_block(self, nm, om) -> minsn_t - Insert instruction into the doubly linked list - - @param nm: (C++: minsn_t *) new instruction - @param om: (C++: minsn_t *) existing instruction, part of the doubly linked list if nullptr, then - the instruction will be inserted at the beginning of the list NM will - be inserted immediately after OM - @return: pointer to NM - -ida_hexrays.mblock_t.is_branch (method) - is_branch(self) -> bool - -ida_hexrays.mblock_t.is_call_block (method) - is_call_block(self) -> bool - -ida_hexrays.mblock_t.is_nway (method) - is_nway(self) -> bool - -ida_hexrays.mblock_t.is_redefined (method) - is_redefined(self, list, i1, i2, maymust=MAY_ACCESS) -> bool - Is the list redefined by the specified instructions? - - @param list: (C++: const mlist_t &) list of locations to check. - @param i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn) - @param i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is - excluded from the range. it can be specified as nullptr. i1 and i2 - must belong to the same block. - @param maymust: (C++: maymust_t) should we search in 'may-access' or 'must-access' mode? - -ida_hexrays.mblock_t.is_rhs_redefined (method) - is_rhs_redefined(self, ins, i1, i2) -> bool - Is the right hand side of the instruction redefined the insn range? "right hand - side" corresponds to the source operands of the instruction. - - @param ins: (C++: const minsn_t *) instruction to consider - @param i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn) - @param i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is - excluded from the range. it can be specified as nullptr. i1 and i2 - must belong to the same block. - -ida_hexrays.mblock_t.is_simple_goto_block (method) - is_simple_goto_block(self) -> bool - -ida_hexrays.mblock_t.is_simple_jcnd_block (method) - is_simple_jcnd_block(self) -> bool - -ida_hexrays.mblock_t.is_unknown_call (method) - is_unknown_call(self) -> bool - -ida_hexrays.mblock_t.is_used (method) - is_used(self, list, i1, i2, maymust=MAY_ACCESS) -> bool - Is the list used by the specified instruction range? - - @param list: (C++: mlist_t *) list of locations. LIST may be modified by the function: redefined - locations will be removed from it. - @param i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn) - @param i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is - excluded from the range. it can be specified as nullptr. i1 and i2 - must belong to the same block. - @param maymust: (C++: maymust_t) should we search in 'may-access' or 'must-access' mode? - -ida_hexrays.mblock_t.lists_dirty (method) - lists_dirty(self) -> bool - -ida_hexrays.mblock_t.lists_ready (method) - lists_ready(self) -> bool - -ida_hexrays.mblock_t.make_lists_ready (method) - make_lists_ready(self) -> int - -ida_hexrays.mblock_t.make_nop (method) - make_nop(self, m) - Erase the instruction (convert it to nop) and mark the lists dirty. This is the - recommended function to use because it also marks the block use-def lists dirty. - - @param m: (C++: minsn_t *) - -ida_hexrays.mblock_t.mark_lists_dirty (method) - mark_lists_dirty(self) - -ida_hexrays.mblock_t.maxbsp (variable) - maximal sp value in the block (0...stacksize) - -ida_hexrays.mblock_t.maybdef (variable) - data that may be defined by the block - -ida_hexrays.mblock_t.maybuse (variable) - data that may be used by the block - -ida_hexrays.mblock_t.mba (variable) - the parent micro block array - -ida_hexrays.mblock_t.minbargref (variable) - the same for arguments - -ida_hexrays.mblock_t.minbstkref (variable) - lowest stack location accessible with indirect addressing (offset from the stack - bottom) initially it is 0 (not computed) - -ida_hexrays.mblock_t.mustbdef (variable) - data that must be defined by the block - -ida_hexrays.mblock_t.mustbuse (variable) - data that must be used by the block - -ida_hexrays.mblock_t.needs_propagation (method) - needs_propagation(self) -> bool - -ida_hexrays.mblock_t.nextb (variable) - next block in the doubly linked list - -ida_hexrays.mblock_t.npred (method) - npred(self) -> int - Get number of block predecessors. - -ida_hexrays.mblock_t.nsucc (method) - nsucc(self) -> int - Get number of block successors. - -ida_hexrays.mblock_t.optimize_block (method) - optimize_block(self) -> int - Optimize a basic block. Usually there is no need to call this function - explicitly because the decompiler will call it itself if optinsn_t::func or - optblock_t::func return non-zero. - - @return: number of changes made to the block - -ida_hexrays.mblock_t.optimize_insn (method) - optimize_insn(self, m, optflags=0x0002|0x0004) -> int - Optimize one instruction in the context of the block. - - @param m: (C++: minsn_t *) pointer to a top level instruction - @param optflags: (C++: int) combination of optimization flags bits - @return: number of changes made to the block This function may change other - instructions in the block too. However, it will not destroy top level - instructions (it may convert them to nop's). This function performs - only intrablock modifications. See also minsn_t::optimize_solo() - -ida_hexrays.mblock_t.optimize_useless_jump (method) - optimize_useless_jump(self) -> int - Remove a jump at the end of the block if it is useless. This function preserves - any side effects when removing a useless jump. Both conditional and - unconditional jumps are handled (and jtbl too). This function deletes useless - jumps, not only replaces them with a nop. (please note that \optimize_insn does - not handle useless jumps). - - @return: number of changes made to the block - -ida_hexrays.mblock_t.pred (method) - pred(self, n) -> int - - @param n: int - -ida_hexrays.mblock_t.preds (method) - Iterates the list of predecessor blocks - -ida_hexrays.mblock_t.predset (variable) - control flow graph: list of our predecessors use npred() and pred() to access it - -ida_hexrays.mblock_t.prevb (variable) - previous block in the doubly linked list - -ida_hexrays.mblock_t.remove_from_block (method) - remove_from_block(self, m) -> minsn_t - Remove instruction from the doubly linked list - - @param m: (C++: minsn_t *) instruction to remove The removed instruction is not deleted, the - caller gets its ownership - @return: pointer to the next instruction - -ida_hexrays.mblock_t.request_demote64 (method) - request_demote64(self) - -ida_hexrays.mblock_t.request_propagation (method) - request_propagation(self) - -ida_hexrays.mblock_t.serial (variable) - block number - -ida_hexrays.mblock_t.start (variable) - start address - -ida_hexrays.mblock_t.succ (method) - succ(self, n) -> int - - @param n: int - -ida_hexrays.mblock_t.succs (method) - Iterates the list of successor blocks - -ida_hexrays.mblock_t.succset (variable) - control flow graph: list of our successors use nsucc() and succ() to access it - -ida_hexrays.mblock_t.tail (variable) - pointer to the last instruction of the block - -ida_hexrays.mblock_t.type (variable) - block type (BLT_NONE - not computed yet) - -ida_hexrays.mcallarg_t (class) - Proxy of C++ mcallarg_t class. - -ida_hexrays.mcallarg_t.__init__ (method) - __init__(self) -> mcallarg_t - __init__(self, rarg) -> mcallarg_t - - @param rarg: mop_t const & - -ida_hexrays.mcallarg_t._print (method) - _print(self, shins_flags=0x04|0x02) - - Parameters - ---------- - shins_flags: int - -ida_hexrays.mcallarg_t.argloc (variable) - ida argloc - -ida_hexrays.mcallarg_t.copy_mop (method) - copy_mop(self, op) - - @param op: mop_t const & - -ida_hexrays.mcallarg_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.mcallarg_t.ea (variable) - address where the argument was initialized. BADADDR means unknown. - -ida_hexrays.mcallarg_t.flags (variable) - FAI_... - -ida_hexrays.mcallarg_t.make_int (method) - make_int(self, val, val_ea, opno=0) - - @param val: int - @param val_ea: ea_t - @param opno: int - -ida_hexrays.mcallarg_t.make_uint (method) - make_uint(self, val, val_ea, opno=0) - - @param val: int - @param val_ea: ea_t - @param opno: int - -ida_hexrays.mcallarg_t.name (variable) - formal argument name - -ida_hexrays.mcallarg_t.set_regarg (method) - set_regarg(self, mr, sz, tif) - - @param mr: mreg_t - @param sz: int - @param tif: tinfo_t const & - - set_regarg(self, mr, tif) - - @param mr: mreg_t - @param tif: tinfo_t const & - - set_regarg(self, mr, dt, sign=type_unsigned) - - @param mr: mreg_t - @param dt: char - @param sign: type_sign_t - -ida_hexrays.mcallarg_t.type (variable) - formal argument type - -ida_hexrays.mcallargs_t (class) - Proxy of C++ qvector< mcallarg_t > class. - -ida_hexrays.mcallargs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< mcallarg_t > const & - -ida_hexrays.mcallargs_t.__getitem__ (method) - __getitem__(self, i) -> mcallarg_t - - @param i: size_t - -ida_hexrays.mcallargs_t.__init__ (method) - __init__(self) -> mcallargs_t - __init__(self, x) -> mcallargs_t - - @param x: qvector< mcallarg_t > const & - -ida_hexrays.mcallargs_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.mcallargs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< mcallarg_t > const & - -ida_hexrays.mcallargs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: mcallarg_t const & - -ida_hexrays.mcallargs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: mcallarg_t const & - -ida_hexrays.mcallargs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: mcallarg_t const & - -ida_hexrays.mcallargs_t.at (method) - at(self, _idx) -> mcallarg_t - - @param _idx: size_t - -ida_hexrays.mcallargs_t.begin (method) - begin(self) -> mcallarg_t - -ida_hexrays.mcallargs_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.mcallargs_t.clear (method) - clear(self) - -ida_hexrays.mcallargs_t.empty (method) - empty(self) -> bool - -ida_hexrays.mcallargs_t.end (method) - end(self) -> mcallarg_t - -ida_hexrays.mcallargs_t.erase (method) - erase(self, it) -> mcallarg_t - - @param it: qvector< mcallarg_t >::iterator - - erase(self, first, last) -> mcallarg_t - - @param first: qvector< mcallarg_t >::iterator - @param last: qvector< mcallarg_t >::iterator - -ida_hexrays.mcallargs_t.extract (method) - extract(self) -> mcallarg_t - -ida_hexrays.mcallargs_t.find (method) - find(self, x) -> mcallarg_t - - @param x: mcallarg_t const & - -ida_hexrays.mcallargs_t.grow (method) - grow(self, x=mcallarg_t()) - - @param x: mcallarg_t const & - -ida_hexrays.mcallargs_t.has (method) - has(self, x) -> bool - - @param x: mcallarg_t const & - -ida_hexrays.mcallargs_t.inject (method) - inject(self, s, len) - - @param s: mcallarg_t * - @param len: size_t - -ida_hexrays.mcallargs_t.insert (method) - insert(self, it, x) -> mcallarg_t - - @param it: qvector< mcallarg_t >::iterator - @param x: mcallarg_t const & - -ida_hexrays.mcallargs_t.pop_back (method) - pop_back(self) - -ida_hexrays.mcallargs_t.push_back (method) - push_back(self, x) - - @param x: mcallarg_t const & - - push_back(self) -> mcallarg_t - -ida_hexrays.mcallargs_t.qclear (method) - qclear(self) - -ida_hexrays.mcallargs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.mcallargs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: mcallarg_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.mcallargs_t.size (method) - size(self) -> size_t - -ida_hexrays.mcallargs_t.swap (method) - swap(self, r) - - @param r: qvector< mcallarg_t > & - -ida_hexrays.mcallargs_t.truncate (method) - truncate(self) - -ida_hexrays.mcallinfo_t (class) - Proxy of C++ mcallinfo_t class. - -ida_hexrays.mcallinfo_t.__init__ (method) - __init__(self, _callee=BADADDR, _sargs=0) -> mcallinfo_t - - @param _callee: ea_t - @param _sargs: int - -ida_hexrays.mcallinfo_t._print (method) - _print(self, size=-1, shins_flags=0x04|0x02) - - Parameters - ---------- - size: int - shins_flags: int - -ida_hexrays.mcallinfo_t.args (variable) - call arguments - -ida_hexrays.mcallinfo_t.call_spd (variable) - sp value at call insn - -ida_hexrays.mcallinfo_t.callee (variable) - address of the called function, if known - -ida_hexrays.mcallinfo_t.cc (variable) - calling convention - -ida_hexrays.mcallinfo_t.dead_regs (variable) - registers defined by the function but never used. upon propagation we do the - following: - * dead_regs += return_regs - * retregs.clear() since the call is propagated - -ida_hexrays.mcallinfo_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.mcallinfo_t.flags (variable) - combination of Call properties... bits - -ida_hexrays.mcallinfo_t.fti_attrs (variable) - extended function attributes - -ida_hexrays.mcallinfo_t.get_type (method) - get_type(self) -> tinfo_t - -ida_hexrays.mcallinfo_t.is_vararg (method) - is_vararg(self) -> bool - -ida_hexrays.mcallinfo_t.lexcompare (method) - lexcompare(self, f) -> int - - @param f: mcallinfo_t const & - -ida_hexrays.mcallinfo_t.pass_regs (variable) - passthrough registers: registers that depend on input values (subset of spoiled) - -ida_hexrays.mcallinfo_t.retregs (variable) - return register(s) (e.g., AX, AX:DX, etc.) this vector is built from return_regs - -ida_hexrays.mcallinfo_t.return_argloc (variable) - location of the returned value - -ida_hexrays.mcallinfo_t.return_regs (variable) - list of values returned by the function - -ida_hexrays.mcallinfo_t.return_type (variable) - type of the returned value - -ida_hexrays.mcallinfo_t.role (variable) - function role - -ida_hexrays.mcallinfo_t.set_type (method) - set_type(self, type) -> bool - - @param type: tinfo_t const & - -ida_hexrays.mcallinfo_t.solid_args (variable) - number of solid args. there may be variadic args in addtion - -ida_hexrays.mcallinfo_t.spoiled (variable) - list of spoiled locations (includes return_regs) - -ida_hexrays.mcallinfo_t.stkargs_top (variable) - first offset past stack arguments - -ida_hexrays.mcallinfo_t.visible_memory (variable) - what memory is visible to the call? - -ida_hexrays.mcases_t (class) - Proxy of C++ mcases_t class. - -ida_hexrays.mcases_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: mcases_t const & - -ida_hexrays.mcases_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: mcases_t const & - -ida_hexrays.mcases_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: mcases_t const & - -ida_hexrays.mcases_t.__init__ (method) - __init__(self) -> mcases_t - -ida_hexrays.mcases_t.__le__ (method) - __le__(self, r) -> bool - - @param r: mcases_t const & - -ida_hexrays.mcases_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: mcases_t const & - -ida_hexrays.mcases_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: mcases_t const & - -ida_hexrays.mcases_t._print (method) - _print(self) - -ida_hexrays.mcases_t.compare (method) - compare(self, r) -> int - - @param r: mcases_t const & - -ida_hexrays.mcases_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.mcases_t.empty (method) - empty(self) -> bool - -ida_hexrays.mcases_t.resize (method) - resize(self, s) - - @param s: int - -ida_hexrays.mcases_t.size (method) - size(self) -> size_t - -ida_hexrays.mcases_t.swap (method) - swap(self, r) - - @param r: mcases_t & - -ida_hexrays.mcases_t.targets (variable) - target block numbers - -ida_hexrays.mcases_t.values (variable) - expression values for each target - -ida_hexrays.mcode_modifies_d (function) - mcode_modifies_d(mcode) -> bool - - @param mcode: enum mcode_t - -ida_hexrays.microcode_filter_t (class) - Proxy of C++ microcode_filter_t class. - -ida_hexrays.microcode_filter_t.__disown__ (method) - -ida_hexrays.microcode_filter_t.__init__ (method) - __init__(self) -> microcode_filter_t - - @param self: PyObject * - -ida_hexrays.microcode_filter_t.apply (method) - apply(self, cdg) -> merror_t - generate microcode for an instruction - - @param cdg: (C++: codegen_t &) - @return: MERR_... code: MERR_OK - user-defined microcode generated, go to the - next instruction MERR_INSN - not generated - the caller should try the - standard way else - error - -ida_hexrays.microcode_filter_t.match (method) - match(self, cdg) -> bool - check if the filter object is to be applied - - @param cdg: (C++: codegen_t &) - @return: success - -ida_hexrays.minsn_t (class) - Proxy of C++ minsn_t class. - -ida_hexrays.minsn_t.__dbg_get_meminfo (method) - __dbg_get_meminfo(self) -> qstring - -ida_hexrays.minsn_t.__dbg_get_registered_kind (method) - __dbg_get_registered_kind(self) -> int - -ida_hexrays.minsn_t.__init__ (method) - __init__(self, _ea) -> minsn_t - - @param _ea: ea_t - - __init__(self, m) -> minsn_t - - @param m: minsn_t const & - -ida_hexrays.minsn_t.__lt__ (method) - __lt__(self, ri) -> bool - - @param ri: minsn_t const & - -ida_hexrays.minsn_t._acquire_ownership (method) - -ida_hexrays.minsn_t._deregister (method) - _deregister(self) - -ida_hexrays.minsn_t._ensure_cond (method) - -ida_hexrays.minsn_t._ensure_no_obj (method) - -ida_hexrays.minsn_t._ensure_ownership_transferrable (method) - -ida_hexrays.minsn_t._make_nop (method) - _make_nop(self) - -ida_hexrays.minsn_t._maybe_disown_and_deregister (method) - -ida_hexrays.minsn_t._meminfo (method) - -ida_hexrays.minsn_t._obj_id (method) - _obj_id(self) -> PyObject * - -ida_hexrays.minsn_t._own_and_register (method) - -ida_hexrays.minsn_t._print (method) - _print(self, shins_flags=0x04|0x02) - - Parameters - ---------- - shins_flags: int - -ida_hexrays.minsn_t._register (method) - _register(self) - -ida_hexrays.minsn_t.clr_assert (method) - clr_assert(self) - -ida_hexrays.minsn_t.clr_combinable (method) - clr_combinable(self) - -ida_hexrays.minsn_t.clr_combined (method) - clr_combined(self) - -ida_hexrays.minsn_t.clr_fpinsn (method) - clr_fpinsn(self) - -ida_hexrays.minsn_t.clr_ignlowsrc (method) - clr_ignlowsrc(self) - -ida_hexrays.minsn_t.clr_multimov (method) - clr_multimov(self) - -ida_hexrays.minsn_t.clr_noret_icall (method) - clr_noret_icall(self) - -ida_hexrays.minsn_t.clr_propagatable (method) - clr_propagatable(self) - -ida_hexrays.minsn_t.clr_tailcall (method) - clr_tailcall(self) - -ida_hexrays.minsn_t.contains_call (method) - contains_call(self, with_helpers=False) -> bool - Does the instruction contain a call? - - @param with_helpers: (C++: bool) - -ida_hexrays.minsn_t.contains_opcode (method) - contains_opcode(self, mcode) -> bool - Does the instruction have the specified opcode? This function searches - subinstructions as well. - - @param mcode: (C++: mcode_t) opcode to search for. - -ida_hexrays.minsn_t.d (variable) - destination operand - -ida_hexrays.minsn_t.deserialize (method) - deserialize(self, bytes, format_version) -> bool - Deserialize an instruction - - @param bytes: (C++: const uchar *) pointer to serialized data - @param format_version: (C++: int) serialization format version. this value is returned by - minsn_t::serialize() - @return: success - -ida_hexrays.minsn_t.dstr (method) - dstr(self) -> char const * - Get displayable text without tags in a static buffer. - -ida_hexrays.minsn_t.ea (variable) - instruction address - -ida_hexrays.minsn_t.equal_insns (method) - equal_insns(self, m, eqflags) -> bool - Compare instructions. This is the main comparison function for instructions. - - @param m: (C++: const minsn_t &) instruction to compare with - @param eqflags: (C++: int) combination of comparison bits bits - -ida_hexrays.minsn_t.find_call (method) - find_call(self, with_helpers=False) -> minsn_t - Find a call instruction. Check for the current instruction and its - subinstructions. - - @param with_helpers: (C++: bool) consider helper calls as well? - -ida_hexrays.minsn_t.find_ins_op (method) - find_ins_op(self, op=m_nop) -> minsn_t - - @param op: enum mcode_t - -ida_hexrays.minsn_t.find_num_op (method) - find_num_op(self) -> mop_t - -ida_hexrays.minsn_t.find_opcode (method) - find_opcode(self, mcode) -> minsn_t - - @param mcode: enum mcode_t - -ida_hexrays.minsn_t.for_all_insns (method) - for_all_insns(self, mv) -> int - Visit all instructions. This function visits the instruction itself and all its - subinstructions. - - @param mv: (C++: minsn_visitor_t &) instruction visitor - @return: non-zero value returned by mv.visit_mop() or zero - -ida_hexrays.minsn_t.for_all_ops (method) - for_all_ops(self, mv) -> int - Visit all instruction operands. This function visits subinstruction operands as - well. - - @param mv: (C++: mop_visitor_t &) operand visitor - @return: non-zero value returned by mv.visit_mop() or zero - -ida_hexrays.minsn_t.get_role (method) - get_role(self) -> funcrole_t - Get the function role of a call. - -ida_hexrays.minsn_t.get_split_size (method) - get_split_size(self) -> int - -ida_hexrays.minsn_t.has_side_effects (method) - has_side_effects(self, include_ldx_and_divs=False) -> bool - Does the instruction have a side effect? - - @param include_ldx_and_divs: (C++: bool) consider ldx/div/mod as having side effects? stx is - always considered as having side effects. Apart - from ldx/std only call may have side effects. - -ida_hexrays.minsn_t.iprops (variable) - combination of instruction property bits bits - -ida_hexrays.minsn_t.is_after (method) - is_after(self, m) -> bool - Is the instruction after the specified one? - - @param m: (C++: const minsn_t *) the instruction to compare against in the list - -ida_hexrays.minsn_t.is_alloca (method) - is_alloca(self) -> bool - -ida_hexrays.minsn_t.is_assert (method) - is_assert(self) -> bool - -ida_hexrays.minsn_t.is_between (method) - is_between(self, m1, m2) -> bool - Is the instruction in the specified range of instructions? - - @param m1: (C++: const minsn_t *) beginning of the range in the doubly linked list - @param m2: (C++: const minsn_t *) end of the range in the doubly linked list (excluded, may be nullptr) - This function assumes that m1 and m2 belong to the same basic block - and they are top level instructions. - -ida_hexrays.minsn_t.is_bswap (method) - is_bswap(self) -> bool - -ida_hexrays.minsn_t.is_cleaning_pop (method) - is_cleaning_pop(self) -> bool - -ida_hexrays.minsn_t.is_combinable (method) - is_combinable(self) -> bool - -ida_hexrays.minsn_t.is_combined (method) - is_combined(self) -> bool - -ida_hexrays.minsn_t.is_extstx (method) - is_extstx(self) -> bool - -ida_hexrays.minsn_t.is_farcall (method) - is_farcall(self) -> bool - -ida_hexrays.minsn_t.is_fpinsn (method) - is_fpinsn(self) -> bool - -ida_hexrays.minsn_t.is_helper (method) - is_helper(self, name) -> bool - Is a helper call with the specified name? Helper calls usually have well-known - function names (see Well known function names) but they may have any other name. - The decompiler does not assume any special meaning for non-well-known names. - - @param name: (C++: const char *) char const * - -ida_hexrays.minsn_t.is_ignlowsrc (method) - is_ignlowsrc(self) -> bool - -ida_hexrays.minsn_t.is_inverted_jx (method) - is_inverted_jx(self) -> bool - -ida_hexrays.minsn_t.is_like_move (method) - is_like_move(self) -> bool - -ida_hexrays.minsn_t.is_mbarrier (method) - is_mbarrier(self) -> bool - -ida_hexrays.minsn_t.is_memcpy (method) - is_memcpy(self) -> bool - -ida_hexrays.minsn_t.is_memset (method) - is_memset(self) -> bool - -ida_hexrays.minsn_t.is_mov (method) - is_mov(self) -> bool - -ida_hexrays.minsn_t.is_multimov (method) - is_multimov(self) -> bool - -ida_hexrays.minsn_t.is_noret_call (method) - is_noret_call(self, flags=0) -> bool - Is a non-returing call? - - @param flags: (C++: int) combination of NORET_... bits - -ida_hexrays.minsn_t.is_optional (method) - is_optional(self) -> bool - -ida_hexrays.minsn_t.is_persistent (method) - is_persistent(self) -> bool - -ida_hexrays.minsn_t.is_propagatable (method) - is_propagatable(self) -> bool - -ida_hexrays.minsn_t.is_readflags (method) - is_readflags(self) -> bool - -ida_hexrays.minsn_t.is_tailcall (method) - is_tailcall(self) -> bool - -ida_hexrays.minsn_t.is_unknown_call (method) - is_unknown_call(self) -> bool - Is an unknown call? Unknown calls are calls without the argument list - (mcallinfo_t). Usually the argument lists are determined by - mba_t::analyze_calls(). Unknown calls exist until the MMAT_CALLS maturity level. - See also mblock_t::is_call_block - -ida_hexrays.minsn_t.is_wild_match (method) - is_wild_match(self) -> bool - -ida_hexrays.minsn_t.l (variable) - left operand - -ida_hexrays.minsn_t.lexcompare (method) - lexcompare(self, ri) -> int - - @param ri: minsn_t const & - -ida_hexrays.minsn_t.may_use_aliased_memory (method) - may_use_aliased_memory(self) -> bool - Is it possible for the instruction to use aliased memory? - -ida_hexrays.minsn_t.modifies_d (method) - modifies_d(self) -> bool - Does the instruction modify its 'd' operand? Some instructions (e.g. m_stx) do - not modify the 'd' operand. - -ida_hexrays.minsn_t.modifies_pair_mop (method) - modifies_pair_mop(self) -> bool - -ida_hexrays.minsn_t.next (variable) - next insn in doubly linked list. check also nexti() - -ida_hexrays.minsn_t.opcode (variable) - instruction opcode - -ida_hexrays.minsn_t.optimize_solo (method) - optimize_solo(self, optflags=0) -> int - Optimize one instruction without context. This function does not have access to - the instruction context (the previous and next instructions in the list, the - block number, etc). It performs only basic optimizations that are available - without this info. - - @param optflags: (C++: int) combination of optimization flags bits - @return: number of changes, 0-unchanged See also mblock_t::optimize_insn() - -ida_hexrays.minsn_t.optimize_subtree (method) - optimize_subtree(self, blk, top, parent, converted_call, optflags=0x0002) -> int - Optimize instruction in its context. Do not use this function, use - mblock_t::optimize() - - @param blk: (C++: mblock_t *) - @param top: (C++: minsn_t *) - @param parent: (C++: minsn_t *) - @param converted_call: (C++: ea_t *) - @param optflags: (C++: int) - -ida_hexrays.minsn_t.prev (variable) - prev insn in doubly linked list. check also previ() - -ida_hexrays.minsn_t.r (variable) - right operand - -ida_hexrays.minsn_t.replace_by (method) - -ida_hexrays.minsn_t.serialize (method) - serialize(self, b) -> int - Serialize an instruction - - @param b: (C++: bytevec_t *) the output buffer - @return: the serialization format that was used to store info - -ida_hexrays.minsn_t.set_assert (method) - set_assert(self) - -ida_hexrays.minsn_t.set_cleaning_pop (method) - set_cleaning_pop(self) - -ida_hexrays.minsn_t.set_combinable (method) - set_combinable(self) - -ida_hexrays.minsn_t.set_extstx (method) - set_extstx(self) - -ida_hexrays.minsn_t.set_farcall (method) - set_farcall(self) - -ida_hexrays.minsn_t.set_fpinsn (method) - set_fpinsn(self) - -ida_hexrays.minsn_t.set_ignlowsrc (method) - set_ignlowsrc(self) - -ida_hexrays.minsn_t.set_inverted_jx (method) - set_inverted_jx(self) - -ida_hexrays.minsn_t.set_mbarrier (method) - set_mbarrier(self) - -ida_hexrays.minsn_t.set_multimov (method) - set_multimov(self) - -ida_hexrays.minsn_t.set_noret_icall (method) - set_noret_icall(self) - -ida_hexrays.minsn_t.set_optional (method) - set_optional(self) - -ida_hexrays.minsn_t.set_persistent (method) - set_persistent(self) - -ida_hexrays.minsn_t.set_split_size (method) - set_split_size(self, s) - - @param s: int - -ida_hexrays.minsn_t.set_tailcall (method) - set_tailcall(self) - -ida_hexrays.minsn_t.set_unmerged (method) - set_unmerged(self) - -ida_hexrays.minsn_t.set_wild_match (method) - set_wild_match(self) - -ida_hexrays.minsn_t.setaddr (method) - setaddr(self, new_ea) - Change the instruction address. This function modifies subinstructions as well. - - @param new_ea: (C++: ea_t) - -ida_hexrays.minsn_t.swap (method) - swap(self, m) - Swap two instructions. The prev/next fields are not modified by this function - because it would corrupt the doubly linked list. - - @param m: (C++: minsn_t &) - -ida_hexrays.minsn_t.was_noret_icall (method) - was_noret_icall(self) -> bool - -ida_hexrays.minsn_t.was_split (method) - was_split(self) -> bool - -ida_hexrays.minsn_t.was_unmerged (method) - was_unmerged(self) -> bool - -ida_hexrays.minsn_visitor_t (class) - Proxy of C++ minsn_visitor_t class. - -ida_hexrays.minsn_visitor_t.__disown__ (method) - -ida_hexrays.minsn_visitor_t.__init__ (method) - __init__(self, _mba=None, _blk=None, _topins=None) -> minsn_visitor_t - - @param _mba: mba_t * - @param _blk: mblock_t * - @param _topins: minsn_t * - -ida_hexrays.minsn_visitor_t.visit_minsn (method) - visit_minsn(self) -> int - -ida_hexrays.mlist_mop_visitor_t (class) - Proxy of C++ mlist_mop_visitor_t class. - -ida_hexrays.mlist_mop_visitor_t.__disown__ (method) - -ida_hexrays.mlist_mop_visitor_t.__init__ (method) - __init__(self) -> mlist_mop_visitor_t - - @param self: PyObject * - -ida_hexrays.mlist_mop_visitor_t.visit_mop (method) - visit_mop(self, op) -> int - - @param op: mop_t * - -ida_hexrays.mlist_t (class) - Proxy of C++ mlist_t class. - -ida_hexrays.mlist_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: mlist_t const & - -ida_hexrays.mlist_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: mlist_t const & - -ida_hexrays.mlist_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: mlist_t const & - -ida_hexrays.mlist_t.__init__ (method) - __init__(self) -> mlist_t - __init__(self, ivl) -> mlist_t - - @param ivl: ivl_t const & - - __init__(self, r, size) -> mlist_t - - @param r: mreg_t - @param size: int - -ida_hexrays.mlist_t.__le__ (method) - __le__(self, r) -> bool - - @param r: mlist_t const & - -ida_hexrays.mlist_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: mlist_t const & - -ida_hexrays.mlist_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: mlist_t const & - -ida_hexrays.mlist_t._print (method) - _print(self) - -ida_hexrays.mlist_t.add (method) - add(self, r, size) -> bool - - @param r: mreg_t - @param size: int - - add(self, r) -> bool - - @param r: rlist_t const & - - add(self, ivl) -> bool - - @param ivl: ivl_t const & - - add(self, lst) -> bool - - @param lst: mlist_t const & - -ida_hexrays.mlist_t.addmem (method) - addmem(self, ea, size) -> bool - - @param ea: ea_t - @param size: asize_t - -ida_hexrays.mlist_t.clear (method) - clear(self) - -ida_hexrays.mlist_t.compare (method) - compare(self, r) -> int - - @param r: mlist_t const & - -ida_hexrays.mlist_t.count (method) - count(self) -> asize_t - -ida_hexrays.mlist_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.mlist_t.empty (method) - empty(self) -> bool - -ida_hexrays.mlist_t.has (method) - has(self, r) -> bool - - @param r: mreg_t - -ida_hexrays.mlist_t.has_all (method) - has_all(self, r, size) -> bool - - @param r: mreg_t - @param size: int - -ida_hexrays.mlist_t.has_any (method) - has_any(self, r, size) -> bool - - @param r: mreg_t - @param size: int - -ida_hexrays.mlist_t.has_common (method) - has_common(self, lst) -> bool - - @param lst: mlist_t const & - -ida_hexrays.mlist_t.has_memory (method) - has_memory(self) -> bool - -ida_hexrays.mlist_t.includes (method) - includes(self, lst) -> bool - - @param lst: mlist_t const & - -ida_hexrays.mlist_t.intersect (method) - intersect(self, lst) -> bool - - @param lst: mlist_t const & - -ida_hexrays.mlist_t.is_subset_of (method) - is_subset_of(self, lst) -> bool - - @param lst: mlist_t const & - -ida_hexrays.mlist_t.sub (method) - sub(self, r, size) -> bool - - @param r: mreg_t - @param size: int - - sub(self, ivl) -> bool - - @param ivl: ivl_t const & - - sub(self, lst) -> bool - - @param lst: mlist_t const & - -ida_hexrays.mlist_t.swap (method) - swap(self, r) - - @param r: mlist_t & - -ida_hexrays.mnumber_t (class) - Proxy of C++ mnumber_t class. - -ida_hexrays.mnumber_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.__init__ (method) - __init__(self, v, _ea=BADADDR, n=0) -> mnumber_t - - @param v: uint64 - @param _ea: ea_t - @param n: int - -ida_hexrays.mnumber_t.__le__ (method) - __le__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.compare (method) - compare(self, r) -> int - - @param r: mnumber_t const & - -ida_hexrays.mnumber_t.update_value (method) - update_value(self, val64) - - @param val64: uint64 - -ida_hexrays.modify_user_lvar_info (function) - modify_user_lvar_info(func_ea, mli_flags, info) -> bool - Modify saved local variable settings of one variable. - - @param func_ea: (C++: ea_t) function start address - @param mli_flags: (C++: uint) bits that specify which attrs defined by INFO are to be set - @param info: (C++: const lvar_saved_info_t &) local variable info attrs - @return: true if modified, false if invalid MLI_FLAGS passed - -ida_hexrays.modify_user_lvars (function) - modify_user_lvars(entry_ea, mlv) -> bool - Modify saved local variable settings. - - @param entry_ea: (C++: ea_t) function start address - @param mlv: (C++: user_lvar_modifier_t &) local variable modifier - @return: true if modified variables - -ida_hexrays.mop_S (variable) - local stack variable (they exist until MMAT_LVARS) - -ida_hexrays.mop_addr_t (class) - Proxy of C++ mop_addr_t class. - -ida_hexrays.mop_addr_t.__init__ (method) - __init__(self) -> mop_addr_t - __init__(self, ra) -> mop_addr_t - - @param ra: mop_addr_t const & - - __init__(self, ra, isz, osz) -> mop_addr_t - - @param ra: mop_t const & - @param isz: int - @param osz: int - -ida_hexrays.mop_addr_t.lexcompare (method) - lexcompare(self, ra) -> int - - @param ra: mop_addr_t const & - -ida_hexrays.mop_b (variable) - micro basic block (mblock_t) - -ida_hexrays.mop_c (variable) - mcases - -ida_hexrays.mop_d (variable) - result of another instruction - -ida_hexrays.mop_f (variable) - list of arguments - -ida_hexrays.mop_fn (variable) - floating point constant - -ida_hexrays.mop_h (variable) - helper function - -ida_hexrays.mop_l (variable) - local variable - -ida_hexrays.mop_n (variable) - immediate number constant - -ida_hexrays.mop_p (variable) - operand pair - -ida_hexrays.mop_pair_t (class) - Proxy of C++ mop_pair_t class. - -ida_hexrays.mop_pair_t.__init__ (method) - __init__(self) -> mop_pair_t - -ida_hexrays.mop_pair_t.hop (variable) - high operand - -ida_hexrays.mop_pair_t.lop (variable) - low operand - -ida_hexrays.mop_r (variable) - register (they exist until MMAT_LVARS) - -ida_hexrays.mop_sc (variable) - scattered - -ida_hexrays.mop_str (variable) - immediate string constant (user representation) - -ida_hexrays.mop_t (class) - Proxy of C++ mop_t class. - -ida_hexrays.mop_t.__dbg_get_meminfo (method) - __dbg_get_meminfo(self) -> qstring - -ida_hexrays.mop_t.__dbg_get_registered_kind (method) - __dbg_get_registered_kind(self) -> int - -ida_hexrays.mop_t.__eq__ (method) - __eq__(self, rop) -> bool - - @param rop: mop_t const & - -ida_hexrays.mop_t.__init__ (method) - __init__(self) -> mop_t - __init__(self, rop) -> mop_t - - @param rop: mop_t const & - - __init__(self, _r, _s) -> mop_t - - @param _r: mreg_t - @param _s: int - -ida_hexrays.mop_t.__lt__ (method) - __lt__(self, rop) -> bool - - @param rop: mop_t const & - -ida_hexrays.mop_t.__ne__ (method) - __ne__(self, rop) -> bool - - @param rop: mop_t const & - -ida_hexrays.mop_t._acquire_ownership (method) - -ida_hexrays.mop_t._deregister (method) - _deregister(self) - -ida_hexrays.mop_t._ensure_cond (method) - -ida_hexrays.mop_t._ensure_no_obj (method) - -ida_hexrays.mop_t._ensure_no_t (method) - -ida_hexrays.mop_t._ensure_ownership_transferrable (method) - -ida_hexrays.mop_t._get_a (method) - _get_a(self) -> mop_addr_t - -ida_hexrays.mop_t._get_b (method) - _get_b(self) -> int - -ida_hexrays.mop_t._get_c (method) - _get_c(self) -> mcases_t - -ida_hexrays.mop_t._get_cstr (method) - _get_cstr(self) -> char const * - -ida_hexrays.mop_t._get_d (method) - _get_d(self) -> minsn_t - -ida_hexrays.mop_t._get_f (method) - _get_f(self) -> mcallinfo_t - -ida_hexrays.mop_t._get_fpc (method) - _get_fpc(self) -> fnumber_t - -ida_hexrays.mop_t._get_g (method) - _get_g(self) -> ea_t - -ida_hexrays.mop_t._get_helper (method) - _get_helper(self) -> char const * - -ida_hexrays.mop_t._get_l (method) - _get_l(self) -> lvar_ref_t - -ida_hexrays.mop_t._get_nnn (method) - _get_nnn(self) -> mnumber_t - -ida_hexrays.mop_t._get_pair (method) - _get_pair(self) -> mop_pair_t - -ida_hexrays.mop_t._get_r (method) - _get_r(self) -> mreg_t - -ida_hexrays.mop_t._get_s (method) - _get_s(self) -> stkvar_ref_t - -ida_hexrays.mop_t._get_scif (method) - _get_scif(self) -> scif_t - -ida_hexrays.mop_t._get_t (method) - _get_t(self) -> mopt_t - -ida_hexrays.mop_t._make_blkref (method) - _make_blkref(self, blknum) - - Parameters - ---------- - blknum: int - -ida_hexrays.mop_t._make_callinfo (method) - _make_callinfo(self, fi) - - Parameters - ---------- - fi: mcallinfo_t * - -ida_hexrays.mop_t._make_cases (method) - _make_cases(self, _cases) - - Parameters - ---------- - _cases: mcases_t * - -ida_hexrays.mop_t._make_gvar (method) - _make_gvar(self, ea) - - Parameters - ---------- - ea: ea_t - -ida_hexrays.mop_t._make_insn (method) - _make_insn(self, ins) - - Parameters - ---------- - ins: minsn_t * - -ida_hexrays.mop_t._make_lvar (method) - _make_lvar(self, mba, idx, off=0) - - Parameters - ---------- - mba: mba_t * - idx: int - off: sval_t - -ida_hexrays.mop_t._make_pair (method) - _make_pair(self, _pair) - - Parameters - ---------- - _pair: mop_pair_t * - -ida_hexrays.mop_t._make_reg (method) - _make_reg(self, reg) - - Parameters - ---------- - reg: mreg_t - - _make_reg(self, reg, _size) - - Parameters - ---------- - reg: mreg_t - _size: int - -ida_hexrays.mop_t._make_stkvar (method) - _make_stkvar(self, mba, off) - - Parameters - ---------- - mba: mba_t * - off: sval_t - -ida_hexrays.mop_t._make_strlit (method) - _make_strlit(self, str) - - Parameters - ---------- - str: char const * - -ida_hexrays.mop_t._maybe_disown_and_deregister (method) - -ida_hexrays.mop_t._meminfo (method) - -ida_hexrays.mop_t._obj_id (method) - _obj_id(self) -> PyObject * - -ida_hexrays.mop_t._own_and_register (method) - -ida_hexrays.mop_t._print (method) - _print(self, shins_flags=0x04|0x02) - - Parameters - ---------- - shins_flags: int - -ida_hexrays.mop_t._register (method) - _register(self) - -ida_hexrays.mop_t._set_a (method) - _set_a(self, _v) - - Parameters - ---------- - _v: mop_addr_t * - -ida_hexrays.mop_t._set_b (method) - _set_b(self, _v) - - Parameters - ---------- - _v: int - -ida_hexrays.mop_t._set_c (method) - _set_c(self, _v) - - Parameters - ---------- - _v: mcases_t * - -ida_hexrays.mop_t._set_cstr (method) - _set_cstr(self, _v) - - Parameters - ---------- - _v: char const * - -ida_hexrays.mop_t._set_d (method) - _set_d(self, _v) - - Parameters - ---------- - _v: minsn_t * - -ida_hexrays.mop_t._set_f (method) - _set_f(self, _v) - - Parameters - ---------- - _v: mcallinfo_t * - -ida_hexrays.mop_t._set_fpc (method) - _set_fpc(self, _v) - - Parameters - ---------- - _v: fnumber_t * - -ida_hexrays.mop_t._set_g (method) - _set_g(self, _v) - - Parameters - ---------- - _v: ea_t - -ida_hexrays.mop_t._set_helper (method) - _set_helper(self, _v) - - Parameters - ---------- - _v: char const * - -ida_hexrays.mop_t._set_l (method) - _set_l(self, _v) - - Parameters - ---------- - _v: lvar_ref_t * - -ida_hexrays.mop_t._set_nnn (method) - _set_nnn(self, _v) - - Parameters - ---------- - _v: mnumber_t * - -ida_hexrays.mop_t._set_pair (method) - _set_pair(self, _v) - - Parameters - ---------- - _v: mop_pair_t * - -ida_hexrays.mop_t._set_r (method) - _set_r(self, _v) - - Parameters - ---------- - _v: mreg_t - -ida_hexrays.mop_t._set_s (method) - _set_s(self, _v) - - Parameters - ---------- - _v: stkvar_ref_t * - -ida_hexrays.mop_t._set_scif (method) - _set_scif(self, _v) - - Parameters - ---------- - _v: scif_t * - -ida_hexrays.mop_t._set_t (method) - _set_t(self, v) - - Parameters - ---------- - v: mopt_t - -ida_hexrays.mop_t.apply_ld_mcode (method) - apply_ld_mcode(self, mcode, ea, newsize) - Apply a unary opcode to the operand. - - @param mcode: (C++: mcode_t) opcode to apply. it must accept 'l' and 'd' operands but not 'r'. - @param ea: (C++: ea_t) value of minsn_t::ea for the newly created insruction - @param newsize: (C++: int) new operand size Example: apply_ld_mcode(m_low) will convert op - => low(op) - -ida_hexrays.mop_t.apply_xds (method) - apply_xds(self, ea, newsize) - - @param ea: ea_t - @param newsize: int - -ida_hexrays.mop_t.apply_xdu (method) - apply_xdu(self, ea, newsize) - - @param ea: ea_t - @param newsize: int - -ida_hexrays.mop_t.assign (method) - assign(self, rop) -> mop_t - - @param rop: mop_t const & - -ida_hexrays.mop_t.change_size (method) - change_size(self, nsize, sideff=WITH_SIDEFF) -> bool - Change the operand size. Examples: change_size(AL.1, 2) -> AX.2 - change_size(qword_00000008.8, 4) -> dword_00000008.4 change_size(xdu.8(op.4), 4) - -> op.4 change_size(#0x12345678.4, 1) -> #0x78.1 - - @param nsize: (C++: int) new operand size - @param sideff: (C++: side_effect_t) may modify the database because of the size change? - @return: success - -ida_hexrays.mop_t.create_from_insn (method) - create_from_insn(self, m) - Create operand from an instruction. This function creates a nested instruction - that can be used as an operand. Example: if m="add x,y,z", our operand will be - (t=mop_d,d=m). The destination operand of 'add' (z) is lost. - - @param m: (C++: const minsn_t *) instruction to embed into operand. may not be nullptr. - -ida_hexrays.mop_t.create_from_ivlset (method) - create_from_ivlset(self, mba, ivs, fullsize) -> bool - Create operand from ivlset_t. Example: if IVS contains [glbvar..glbvar+4), our - operand will be (t=mop_v, g=&glbvar, size=4) - - @param mba: (C++: mba_t *) pointer to microcode - @param ivs: (C++: const ivlset_t &) set of memory intervals - @param fullsize: (C++: sval_t) mba->fullsize - @return: success - -ida_hexrays.mop_t.create_from_mlist (method) - create_from_mlist(self, mba, lst, fullsize) -> bool - Create operand from mlist_t. Example: if LST contains 4 bits for R0.4, our - operand will be (t=mop_r, r=R0, size=4) - - @param mba: (C++: mba_t *) pointer to microcode - @param lst: (C++: const mlist_t &) list of locations - @param fullsize: (C++: sval_t) mba->fullsize - @return: success - -ida_hexrays.mop_t.create_from_scattered_vdloc (method) - create_from_scattered_vdloc(self, mba, name, type, loc) - Create operand from scattered vdloc_t. Example: if LOC is (ALOC_DIST, {EAX.4, - EDX.4}) and TYPE is _LARGE_INTEGER, our operand will be (t=mop_sc, scif={EAX.4, - EDX.4}) - - @param mba: (C++: mba_t *) pointer to microcode - @param name: (C++: const char *) name of the operand, if available - @param type: (C++: tinfo_t) type of the operand, must be present - @param loc: (C++: const vdloc_t &) a scattered location - @return: success - -ida_hexrays.mop_t.create_from_vdloc (method) - create_from_vdloc(self, mba, loc, _size) - Create operand from vdloc_t. Example: if LOC contains (type=ALOC_REG1, r=R0), - our operand will be (t=mop_r, r=R0, size=_SIZE) - - @param mba: (C++: mba_t *) pointer to microcode - @param loc: (C++: const vdloc_t &) location - @param _size: (C++: int) operand size Note: this function cannot handle scattered - locations. - @return: success - -ida_hexrays.mop_t.double_size (method) - double_size(self, sideff=WITH_SIDEFF) -> bool - - @param sideff: enum side_effect_t - -ida_hexrays.mop_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.mop_t.empty (method) - empty(self) -> bool - -ida_hexrays.mop_t.equal_mops (method) - equal_mops(self, rop, eqflags) -> bool - Compare operands. This is the main comparison function for operands. - - @param rop: (C++: const mop_t &) operand to compare with - @param eqflags: (C++: int) combination of comparison bits bits - -ida_hexrays.mop_t.erase (method) - erase(self) - -ida_hexrays.mop_t.erase_but_keep_size (method) - erase_but_keep_size(self) - -ida_hexrays.mop_t.for_all_ops (method) - for_all_ops(self, mv, type=None, is_target=False) -> int - Visit the operand and all its sub-operands. This function visits the current - operand as well. - - @param mv: (C++: mop_visitor_t &) visitor object - @param type: (C++: const tinfo_t *) operand type - @param is_target: (C++: bool) is a destination operand? - -ida_hexrays.mop_t.for_all_scattered_submops (method) - for_all_scattered_submops(self, sv) -> int - Visit all sub-operands of a scattered operand. This function does not visit the - current operand, only its sub-operands. All sub-operands are synthetic and are - destroyed after the visitor. This function works only with scattered operands. - - @param sv: (C++: scif_visitor_t &) visitor object - -ida_hexrays.mop_t.get_insn (method) - get_insn(self, code) -> minsn_t - - @param code: enum mcode_t - -ida_hexrays.mop_t.get_stkoff (method) - get_stkoff(self, p_off) -> bool - Get the referenced stack offset. This function can also handle mop_sc if it is - entirely mapped into a continuous stack region. - - @param p_off: (C++: sval_t *) the output buffer - @return: success - -ida_hexrays.mop_t.get_stkvar (method) - get_stkvar(self, p_off) -> member_t * - Retrieve the referenced stack variable. - - @param p_off: (C++: uval_t *) if specified, will hold IDA stkoff after the call. - @return: pointer to the stack variable - -ida_hexrays.mop_t.has_side_effects (method) - has_side_effects(self, include_ldx_and_divs=False) -> bool - Has any side effects? - - @param include_ldx_and_divs: (C++: bool) consider ldx/div/mod as having side effects? - -ida_hexrays.mop_t.is01 (method) - is01(self) -> bool - Are the possible values of the operand only 0 and 1? This function returns true - for 0/1 constants, bit registers, the result of 'set' insns, etc. - -ida_hexrays.mop_t.is_arglist (method) - is_arglist(self) -> bool - Is a list of arguments? - -ida_hexrays.mop_t.is_bit_reg (method) - is_bit_reg(self, reg) -> bool - Is a bit register? This includes condition codes and eventually other bit - registers - - @param reg: (C++: mreg_t) - - is_bit_reg(self) -> bool - -ida_hexrays.mop_t.is_cc (method) - is_cc(self) -> bool - Is a condition code? - -ida_hexrays.mop_t.is_ccflags (method) - is_ccflags(self) -> bool - -ida_hexrays.mop_t.is_constant (method) - is_constant(self, is_signed=True) -> bool - Retrieve value of a constant integer operand. - - @param is_signed: (C++: bool) should treat the value as signed - @return: true if the operand is mop_n - -ida_hexrays.mop_t.is_equal_to (method) - is_equal_to(self, n, is_signed=True) -> bool - - @param n: uint64 - @param is_signed: bool - -ida_hexrays.mop_t.is_extended_from (method) - is_extended_from(self, nbytes, is_signed) -> bool - Does the high part of the operand consist of zero or sign bytes? - - @param nbytes: (C++: int) - @param is_signed: (C++: bool) - -ida_hexrays.mop_t.is_glbaddr (method) - is_glbaddr(self) -> bool - Is address of the specified global memory cell? - is_glbaddr(self, ea) -> bool - - @param ea: ea_t - -ida_hexrays.mop_t.is_glbaddr_from_fixup (method) - is_glbaddr_from_fixup(self) -> bool - -ida_hexrays.mop_t.is_impptr_done (method) - is_impptr_done(self) -> bool - -ida_hexrays.mop_t.is_insn (method) - is_insn(self) -> bool - Is a sub-instruction with the specified opcode? - is_insn(self, code) -> bool - - @param code: enum mcode_t - -ida_hexrays.mop_t.is_kreg (method) - is_kreg(self) -> bool - Is a kernel register? - -ida_hexrays.mop_t.is_lowaddr (method) - is_lowaddr(self) -> bool - -ida_hexrays.mop_t.is_mob (method) - is_mob(self, serial) -> bool - Is a block reference to the specified block? - - @param serial: (C++: int) - -ida_hexrays.mop_t.is_negative_constant (method) - is_negative_constant(self) -> bool - -ida_hexrays.mop_t.is_one (method) - is_one(self) -> bool - -ida_hexrays.mop_t.is_pcval (method) - is_pcval(self) -> bool - -ida_hexrays.mop_t.is_positive_constant (method) - is_positive_constant(self) -> bool - -ida_hexrays.mop_t.is_reg (method) - is_reg(self) -> bool - Is the specified register of the specified size? - is_reg(self, _r) -> bool - - @param _r: mreg_t - - is_reg(self, _r, _size) -> bool - - @param _r: mreg_t - @param _size: int - -ida_hexrays.mop_t.is_scattered (method) - is_scattered(self) -> bool - Is a scattered operand? - -ida_hexrays.mop_t.is_sign_extended_from (method) - is_sign_extended_from(self, nbytes) -> bool - Does the high part of the operand consist of the sign bytes? - - @param nbytes: (C++: int) number of bytes that were sign extended. the remaining size- - nbytes high bytes must be sign bytes Example: - is_sign_extended_from(xds.4(op.1), 1) -> true because the high 3 - bytes are certainly sign bits - -ida_hexrays.mop_t.is_stkaddr (method) - is_stkaddr(self) -> bool - Is address of a stack variable? - -ida_hexrays.mop_t.is_udt (method) - is_udt(self) -> bool - -ida_hexrays.mop_t.is_undef_val (method) - is_undef_val(self) -> bool - -ida_hexrays.mop_t.is_zero (method) - is_zero(self) -> bool - -ida_hexrays.mop_t.is_zero_extended_from (method) - is_zero_extended_from(self, nbytes) -> bool - Does the high part of the operand consist of zero bytes? - - @param nbytes: (C++: int) number of bytes that were zero extended. the remaining size- - nbytes high bytes must be zero Example: - is_zero_extended_from(xdu.8(op.1), 2) -> true because the high 6 - bytes are certainly zero - -ida_hexrays.mop_t.lexcompare (method) - lexcompare(self, rop) -> int - - @param rop: mop_t const & - -ida_hexrays.mop_t.make_blkref (method) - make_blkref(self, blknum) - Create a global variable operand. - - @param blknum: (C++: int) - -ida_hexrays.mop_t.make_first_half (method) - make_first_half(self, width) -> bool - Make the first part of the operand. This function does not care about the memory - endianness - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success - -ida_hexrays.mop_t.make_fpnum (method) - make_fpnum(self, bytes) -> bool - Create a floating point constant operand. - - @param bytes: (C++: const void *) pointer to the floating point value as used by the current - processor (e.g. for x86 it must be in IEEE 754) - @return: success - -ida_hexrays.mop_t.make_gvar (method) - make_gvar(self, ea) - Create a global variable operand. - - @param ea: (C++: ea_t) - -ida_hexrays.mop_t.make_helper (method) - make_helper(self, name) - Create a helper operand. A helper operand usually keeps a built-in function name - like "va_start" It is essentially just an arbitrary identifier without any - additional info. - - @param name: (C++: const char *) char const * - -ida_hexrays.mop_t.make_high_half (method) - make_high_half(self, width) -> bool - Make the high part of the operand. This function takes into account the memory - endianness (byte sex) - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success - -ida_hexrays.mop_t.make_insn (method) - make_insn(self, ins) - Create a nested instruction. - - @param ins: (C++: minsn_t *) - -ida_hexrays.mop_t.make_low_half (method) - make_low_half(self, width) -> bool - Make the low part of the operand. This function takes into account the memory - endianness (byte sex) - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success - -ida_hexrays.mop_t.make_number (method) - make_number(self, _value, _size, _ea=BADADDR, opnum=0) - Create an integer constant operand. - - @param _value: (C++: uint64) value to store in the operand - @param _size: (C++: int) size of the value in bytes (1,2,4,8) - @param _ea: (C++: ea_t) address of the processor instruction that made the value - @param opnum: (C++: int) operand number of the processor instruction - -ida_hexrays.mop_t.make_reg (method) - make_reg(self, reg) - - @param reg: mreg_t - - make_reg(self, reg, _size) - - @param reg: mreg_t - @param _size: int - -ida_hexrays.mop_t.make_reg_pair (method) - make_reg_pair(self, loreg, hireg, halfsize) - Create pair of registers. - - @param loreg: (C++: int) register holding the low part of the value - @param hireg: (C++: int) register holding the high part of the value - @param halfsize: (C++: int) the size of each of loreg/hireg - -ida_hexrays.mop_t.make_second_half (method) - make_second_half(self, width) -> bool - Make the second part of the operand. This function does not care about the - memory endianness - - @param width: (C++: int) the desired size of the operand part in bytes - @return: success - -ida_hexrays.mop_t.make_stkvar (method) - make_stkvar(self, mba, off) - - @param mba: mba_t * - @param off: sval_t - -ida_hexrays.mop_t.may_use_aliased_memory (method) - may_use_aliased_memory(self) -> bool - Is it possible for the operand to use aliased memory? - -ida_hexrays.mop_t.oprops (variable) - Operand properties. - -ida_hexrays.mop_t.preserve_side_effects (method) - preserve_side_effects(self, blk, top, moved_calls=None) -> bool - Move subinstructions with side effects out of the operand. If we decide to - delete an instruction operand, it is a good idea to call this function. - Alternatively we should skip such operands by calling mop_t::has_side_effects() - For example, if we transform: jnz x, x, @blk => goto @blk then we must call this - function before deleting the X operands. - - @param blk: (C++: mblock_t *) current block - @param top: (C++: minsn_t *) top level instruction that contains our operand - @param moved_calls: (C++: bool *) pointer to the boolean that will track if all side effects - get handled correctly. must be false initially. - @return: false failed to preserve a side effect, it is not safe to delete the - operand true no side effects or successfully preserved them - -ida_hexrays.mop_t.probably_floating (method) - probably_floating(self) -> bool - -ida_hexrays.mop_t.replace_by (method) - -ida_hexrays.mop_t.set_impptr_done (method) - set_impptr_done(self) - -ida_hexrays.mop_t.set_lowaddr (method) - set_lowaddr(self) - -ida_hexrays.mop_t.set_udt (method) - set_udt(self) - -ida_hexrays.mop_t.set_undef_val (method) - set_undef_val(self) - -ida_hexrays.mop_t.shift_mop (method) - shift_mop(self, offset) -> bool - Shift the operand. This function shifts only the beginning of the operand. The - operand size will be changed. Examples: shift_mop(AH.1, -1) -> AX.2 - shift_mop(qword_00000008.8, 4) -> dword_0000000C.4 shift_mop(xdu.8(op.4), 4) -> - #0.4 shift_mop(#0x12345678.4, 3) -> #12.1 - - @param offset: (C++: int) shift count (the number of bytes to shift) - @return: success - -ida_hexrays.mop_t.signed_value (method) - signed_value(self) -> int64 - -ida_hexrays.mop_t.size (variable) - Operand size. Usually it is 1,2,4,8 or NOSIZE but for UDTs other sizes are - permitted - -ida_hexrays.mop_t.swap (method) - swap(self, rop) - - @param rop: mop_t & - -ida_hexrays.mop_t.t (variable) - Operand type. - -ida_hexrays.mop_t.unsigned_value (method) - unsigned_value(self) -> uint64 - -ida_hexrays.mop_t.update_numop_value (method) - update_numop_value(self, val) - - @param val: uint64 - -ida_hexrays.mop_t.valnum (variable) - Value number. Zero means unknown. Operands with the same value number are equal. - -ida_hexrays.mop_t.value (method) - value(self, is_signed) -> uint64 - Retrieve value of a constant integer operand. These functions can be called only - for mop_n operands. See is_constant() that can be called on any operand. - - @param is_signed: (C++: bool) - -ida_hexrays.mop_t.zero (method) - zero(self) - -ida_hexrays.mop_v (variable) - global variable - -ida_hexrays.mop_visitor_t (class) - Proxy of C++ mop_visitor_t class. - -ida_hexrays.mop_visitor_t.__disown__ (method) - -ida_hexrays.mop_visitor_t.__init__ (method) - __init__(self, _mba=None, _blk=None, _topins=None) -> mop_visitor_t - - @param _mba: mba_t * - @param _blk: mblock_t * - @param _topins: minsn_t * - -ida_hexrays.mop_visitor_t.prune (variable) - Should skip sub-operands of the current operand? visit_mop() may set - 'prune=true' for that. - -ida_hexrays.mop_visitor_t.visit_mop (method) - visit_mop(self, op, type, is_target) -> int - - @param op: mop_t * - @param type: tinfo_t const * - @param is_target: bool - -ida_hexrays.mop_z (variable) - none - -ida_hexrays.mopvec_t (class) - Proxy of C++ qvector< mop_t > class. - -ida_hexrays.mopvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< mop_t > const & - -ida_hexrays.mopvec_t.__getitem__ (method) - __getitem__(self, i) -> mop_t - - @param i: size_t - -ida_hexrays.mopvec_t.__init__ (method) - __init__(self) -> mopvec_t - __init__(self, x) -> mopvec_t - - @param x: qvector< mop_t > const & - -ida_hexrays.mopvec_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.mopvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< mop_t > const & - -ida_hexrays.mopvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: mop_t const & - -ida_hexrays.mopvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: mop_t const & - -ida_hexrays.mopvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: mop_t const & - -ida_hexrays.mopvec_t.at (method) - at(self, _idx) -> mop_t - - @param _idx: size_t - -ida_hexrays.mopvec_t.begin (method) - begin(self) -> mop_t - -ida_hexrays.mopvec_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.mopvec_t.clear (method) - clear(self) - -ida_hexrays.mopvec_t.empty (method) - empty(self) -> bool - -ida_hexrays.mopvec_t.end (method) - end(self) -> mop_t - -ida_hexrays.mopvec_t.erase (method) - erase(self, it) -> mop_t - - @param it: qvector< mop_t >::iterator - - erase(self, first, last) -> mop_t - - @param first: qvector< mop_t >::iterator - @param last: qvector< mop_t >::iterator - -ida_hexrays.mopvec_t.extract (method) - extract(self) -> mop_t - -ida_hexrays.mopvec_t.find (method) - find(self, x) -> mop_t - - @param x: mop_t const & - -ida_hexrays.mopvec_t.grow (method) - grow(self, x=mop_t()) - - @param x: mop_t const & - -ida_hexrays.mopvec_t.has (method) - has(self, x) -> bool - - @param x: mop_t const & - -ida_hexrays.mopvec_t.inject (method) - inject(self, s, len) - - @param s: mop_t * - @param len: size_t - -ida_hexrays.mopvec_t.insert (method) - insert(self, it, x) -> mop_t - - @param it: qvector< mop_t >::iterator - @param x: mop_t const & - -ida_hexrays.mopvec_t.pop_back (method) - pop_back(self) - -ida_hexrays.mopvec_t.push_back (method) - push_back(self, x) - - @param x: mop_t const & - - push_back(self) -> mop_t - -ida_hexrays.mopvec_t.qclear (method) - qclear(self) - -ida_hexrays.mopvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.mopvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: mop_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.mopvec_t.size (method) - size(self) -> size_t - -ida_hexrays.mopvec_t.swap (method) - swap(self, r) - - @param r: qvector< mop_t > & - -ida_hexrays.mopvec_t.truncate (method) - truncate(self) - -ida_hexrays.mreg2reg (function) - mreg2reg(reg, width) -> int - Map a microregister to a processor register. - - @param reg: (C++: mreg_t) microregister number - @param width: (C++: int) size of microregister in bytes - @return: processor register id or -1 - -ida_hexrays.must_mcode_close_block (function) - must_mcode_close_block(mcode, including_calls) -> bool - Must an instruction with the given opcode be the last one in a block? Such - opcodes are called closing opcodes. - - @param mcode: (C++: mcode_t) instruction opcode - @param including_calls: (C++: bool) should m_call/m_icall be considered as the closing - opcodes? If this function returns true, the opcode - cannot appear in the middle of a block. Calls are a - special case: unknown calls (is_unknown_call) are - considered as closing opcodes. - -ida_hexrays.negate_mcode_relation (function) - negate_mcode_relation(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.negated_relation (function) - negated_relation(op) -> ctype_t - Negate a comparison operator. For example, cot_sge becomes cot_slt. - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.new_block (function) - Create a new block-statement. - -ida_hexrays.number_format_t (class) - Proxy of C++ number_format_t class. - -ida_hexrays.number_format_t.__init__ (method) - __init__(self, _opnum=0) -> number_format_t - - @param _opnum: int - -ida_hexrays.number_format_t.flags (variable) - ida flags, which describe number radix, enum, etc - -ida_hexrays.number_format_t.flags32 (variable) - low 32bit of flags (for compatibility) - -ida_hexrays.number_format_t.get_radix (method) - get_radix(self) -> int - Get number radix - - @return: 2,8,10, or 16 - -ida_hexrays.number_format_t.has_unmutable_type (method) - has_unmutable_type(self) -> bool - -ida_hexrays.number_format_t.is_char (method) - is_char(self) -> bool - Is a character constant? - -ida_hexrays.number_format_t.is_dec (method) - is_dec(self) -> bool - Is a decimal number? - -ida_hexrays.number_format_t.is_enum (method) - is_enum(self) -> bool - Is a symbolic constant? - -ida_hexrays.number_format_t.is_fixed (method) - is_fixed(self) -> bool - Is number representation fixed? Fixed representation cannot be modified by the - decompiler - -ida_hexrays.number_format_t.is_hex (method) - is_hex(self) -> bool - Is a hexadecimal number? - -ida_hexrays.number_format_t.is_numop (method) - is_numop(self) -> bool - Is a number? - -ida_hexrays.number_format_t.is_oct (method) - is_oct(self) -> bool - Is a octal number? - -ida_hexrays.number_format_t.is_stroff (method) - is_stroff(self) -> bool - Is a structure field offset? - -ida_hexrays.number_format_t.needs_to_be_inverted (method) - needs_to_be_inverted(self) -> bool - Does the number need to be negated or bitwise negated? Returns true if the user - requested a negation but it is not done yet - -ida_hexrays.number_format_t.opnum (variable) - operand number: 0..UA_MAXOP - -ida_hexrays.number_format_t.org_nbytes (variable) - original number size in bytes - -ida_hexrays.number_format_t.serial (variable) - for enums: constant serial number - -ida_hexrays.number_format_t.type_name (variable) - for stroffs: structure for offsetof() - for enums: enum name - -ida_hexrays.op_parent_info_t (class) - Proxy of C++ op_parent_info_t class. - -ida_hexrays.op_parent_info_t.__init__ (method) - __init__(self, _mba=None, _blk=None, _topins=None) -> op_parent_info_t - - @param _mba: mba_t * - @param _blk: mblock_t * - @param _topins: minsn_t * - -ida_hexrays.op_uses_x (function) - op_uses_x(op) -> bool - Does operator use the 'x' field of cexpr_t? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.op_uses_y (function) - op_uses_y(op) -> bool - Does operator use the 'y' field of cexpr_t? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.op_uses_z (function) - op_uses_z(op) -> bool - Does operator use the 'z' field of cexpr_t? - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.open_pseudocode (function) - open_pseudocode(ea, flags) -> vdui_t - Open pseudocode window. The specified function is decompiled and the pseudocode - window is opened. - - @param ea: (C++: ea_t) function to decompile - @param flags: (C++: int) a combination of OPF_ flags - @return: false if failed - -ida_hexrays.operand_locator_t (class) - Proxy of C++ operand_locator_t class. - -ida_hexrays.operand_locator_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: operand_locator_t const & - -ida_hexrays.operand_locator_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: operand_locator_t const & - -ida_hexrays.operand_locator_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: operand_locator_t const & - -ida_hexrays.operand_locator_t.__init__ (method) - __init__(self, _ea, _opnum) -> operand_locator_t - - @param _ea: ea_t - @param _opnum: int - -ida_hexrays.operand_locator_t.__le__ (method) - __le__(self, r) -> bool - - @param r: operand_locator_t const & - -ida_hexrays.operand_locator_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: operand_locator_t const & - -ida_hexrays.operand_locator_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: operand_locator_t const & - -ida_hexrays.operand_locator_t.compare (method) - compare(self, r) -> int - - @param r: operand_locator_t const & - -ida_hexrays.operand_locator_t.ea (variable) - address of the original processor instruction - -ida_hexrays.operand_locator_t.opnum (variable) - operand number in the instruction - -ida_hexrays.optblock_t (class) - Proxy of C++ optblock_t class. - -ida_hexrays.optblock_t.__disown__ (method) - -ida_hexrays.optblock_t.__init__ (method) - __init__(self) -> optblock_t - - @param self: PyObject * - -ida_hexrays.optblock_t.func (method) - func(self, blk) -> int - Optimize a block. This function usually performs the optimizations that require - analyzing the entire block and/or its neighbors. For example it can recognize - patterns and perform conversions like: b0: b0: ... ... jnz x, 0, @b2 => jnz x, - 0, @b2 b1: b1: add x, 0, y mov x, y ... ... - - @param blk: (C++: mblock_t *) Basic block to optimize as a whole. - @return: number of changes made to the block. See also mark_lists_dirty. - -ida_hexrays.optblock_t.install (method) - install(self) - -ida_hexrays.optblock_t.remove (method) - remove(self) -> bool - -ida_hexrays.optinsn_t (class) - Proxy of C++ optinsn_t class. - -ida_hexrays.optinsn_t.__disown__ (method) - -ida_hexrays.optinsn_t.__init__ (method) - __init__(self) -> optinsn_t - - @param self: PyObject * - -ida_hexrays.optinsn_t.func (method) - func(self, blk, ins, optflags) -> int - Optimize an instruction. - - @param blk: (C++: mblock_t *) current basic block. maybe nullptr, which means that the instruction - must be optimized without context - @param ins: (C++: minsn_t *) instruction to optimize; it is always a top-level instruction. the - callback may not delete the instruction but may convert it into nop - (see mblock_t::make_nop). to optimize sub-instructions, visit them - using minsn_visitor_t. sub-instructions may not be converted into - nop but can be converted to "mov x,x". for example: add x,0,x => mov - x,x this callback may change other instructions in the block, but - should do this with care, e.g. to no break the propagation algorithm - if called with OPTI_NO_LDXOPT. - @param optflags: (C++: int) combination of optimization flags bits - @return: number of changes made to the instruction. if after this call the - instruction's use/def lists have changed, you must mark the block level - lists as dirty (see mark_lists_dirty) - -ida_hexrays.optinsn_t.install (method) - install(self) - -ida_hexrays.optinsn_t.remove (method) - remove(self) -> bool - -ida_hexrays.parse_user_call (function) - parse_user_call(udc, decl, silent) -> bool - Convert function type declaration into internal structure - - @param udc: (C++: udcall_t *) - pointer to output structure - @param decl: (C++: const char *) - function type declaration - @param silent: (C++: bool) - if TRUE: do not show warning in case of incorrect type - @return: success - -ida_hexrays.partial_type_num (function) - partial_type_num(type) -> int - Calculate number of partial subtypes. - - @param type: (C++: const tinfo_t &) tinfo_t const & - @return: number of partial subtypes. The bigger is this number, the uglier is - the type. - -ida_hexrays.print_vdloc (function) - print_vdloc(loc, nbytes) -> str - Print vdloc. Since vdloc does not always carry the size info, we pass it as - NBYTES.. - - @param loc: (C++: const vdloc_t &) vdloc_t const & - @param nbytes: (C++: int) - -ida_hexrays.property_op_to_typename (function) - -ida_hexrays.qstring_printer_t (class) - Proxy of C++ qstring_printer_t class. - -ida_hexrays.qstring_printer_t.__init__ (method) - __init__(self, f, tags) -> qstring_printer_t - - @param f: cfunc_t const * - @param tags: bool - -ida_hexrays.qstring_printer_t._print (method) - _print(self, indent, format) -> int - - Parameters - ---------- - indent: int - format: char const * - -ida_hexrays.qstring_printer_t.get_s (method) - get_s(self) -> qstring - -ida_hexrays.qstring_printer_t.s (variable) - Reference to the output string - -ida_hexrays.qstring_printer_t.with_tags (variable) - Generate output with color tags. - -ida_hexrays.qswap (function) - qswap(a, b) - - @param a: cinsn_t & - @param b: cinsn_t & - -ida_hexrays.qvector_carg_t (class) - Proxy of C++ qvector< carg_t > class. - -ida_hexrays.qvector_carg_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< carg_t > const & - -ida_hexrays.qvector_carg_t.__getitem__ (method) - __getitem__(self, i) -> carg_t - - @param i: size_t - -ida_hexrays.qvector_carg_t.__init__ (method) - __init__(self) -> qvector_carg_t - __init__(self, x) -> qvector_carg_t - - @param x: qvector< carg_t > const & - -ida_hexrays.qvector_carg_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_carg_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< carg_t > const & - -ida_hexrays.qvector_carg_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: carg_t const & - -ida_hexrays.qvector_carg_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: carg_t const & - -ida_hexrays.qvector_carg_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.at (method) - at(self, _idx) -> carg_t - - @param _idx: size_t - -ida_hexrays.qvector_carg_t.begin (method) - begin(self) -> carg_t - -ida_hexrays.qvector_carg_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_carg_t.clear (method) - clear(self) - -ida_hexrays.qvector_carg_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_carg_t.end (method) - end(self) -> carg_t - -ida_hexrays.qvector_carg_t.erase (method) - erase(self, it) -> carg_t - - @param it: qvector< carg_t >::iterator - - erase(self, first, last) -> carg_t - - @param first: qvector< carg_t >::iterator - @param last: qvector< carg_t >::iterator - -ida_hexrays.qvector_carg_t.extract (method) - extract(self) -> carg_t - -ida_hexrays.qvector_carg_t.find (method) - find(self, x) -> carg_t - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.grow (method) - grow(self, x=carg_t()) - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.has (method) - has(self, x) -> bool - - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.inject (method) - inject(self, s, len) - - @param s: carg_t * - @param len: size_t - -ida_hexrays.qvector_carg_t.insert (method) - insert(self, it, x) -> carg_t - - @param it: qvector< carg_t >::iterator - @param x: carg_t const & - -ida_hexrays.qvector_carg_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_carg_t.push_back (method) - push_back(self, x) - - @param x: carg_t const & - - push_back(self) -> carg_t - -ida_hexrays.qvector_carg_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_carg_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_carg_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: carg_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_carg_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_carg_t.swap (method) - swap(self, r) - - @param r: qvector< carg_t > & - -ida_hexrays.qvector_carg_t.truncate (method) - truncate(self) - -ida_hexrays.qvector_ccase_t (class) - Proxy of C++ qvector< ccase_t > class. - -ida_hexrays.qvector_ccase_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< ccase_t > const & - -ida_hexrays.qvector_ccase_t.__getitem__ (method) - __getitem__(self, i) -> ccase_t - - @param i: size_t - -ida_hexrays.qvector_ccase_t.__init__ (method) - __init__(self) -> qvector_ccase_t - __init__(self, x) -> qvector_ccase_t - - @param x: qvector< ccase_t > const & - -ida_hexrays.qvector_ccase_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_ccase_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< ccase_t > const & - -ida_hexrays.qvector_ccase_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ccase_t const & - -ida_hexrays.qvector_ccase_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: ccase_t const & - -ida_hexrays.qvector_ccase_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.at (method) - at(self, _idx) -> ccase_t - - @param _idx: size_t - -ida_hexrays.qvector_ccase_t.begin (method) - begin(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_ccase_t.clear (method) - clear(self) - -ida_hexrays.qvector_ccase_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_ccase_t.end (method) - end(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.erase (method) - erase(self, it) -> ccase_t - - @param it: qvector< ccase_t >::iterator - - erase(self, first, last) -> ccase_t - - @param first: qvector< ccase_t >::iterator - @param last: qvector< ccase_t >::iterator - -ida_hexrays.qvector_ccase_t.extract (method) - extract(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.find (method) - find(self, x) -> ccase_t - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.grow (method) - grow(self, x=ccase_t()) - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.has (method) - has(self, x) -> bool - - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.inject (method) - inject(self, s, len) - - @param s: ccase_t * - @param len: size_t - -ida_hexrays.qvector_ccase_t.insert (method) - insert(self, it, x) -> ccase_t - - @param it: qvector< ccase_t >::iterator - @param x: ccase_t const & - -ida_hexrays.qvector_ccase_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_ccase_t.push_back (method) - push_back(self, x) - - @param x: ccase_t const & - - push_back(self) -> ccase_t - -ida_hexrays.qvector_ccase_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_ccase_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_ccase_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ccase_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_ccase_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_ccase_t.swap (method) - swap(self, r) - - @param r: qvector< ccase_t > & - -ida_hexrays.qvector_ccase_t.truncate (method) - truncate(self) - -ida_hexrays.qvector_history_t (class) - Proxy of C++ qvector< history_item_t > class. - -ida_hexrays.qvector_history_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< history_item_t > const & - -ida_hexrays.qvector_history_t.__getitem__ (method) - __getitem__(self, i) -> history_item_t - - @param i: size_t - -ida_hexrays.qvector_history_t.__init__ (method) - __init__(self) -> qvector_history_t - __init__(self, x) -> qvector_history_t - - @param x: qvector< history_item_t > const & - -ida_hexrays.qvector_history_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_history_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< history_item_t > const & - -ida_hexrays.qvector_history_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: history_item_t const & - -ida_hexrays.qvector_history_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: history_item_t const & - -ida_hexrays.qvector_history_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.at (method) - at(self, _idx) -> history_item_t - - @param _idx: size_t - -ida_hexrays.qvector_history_t.begin (method) - begin(self) -> history_item_t - -ida_hexrays.qvector_history_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_history_t.clear (method) - clear(self) - -ida_hexrays.qvector_history_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_history_t.end (method) - end(self) -> history_item_t - -ida_hexrays.qvector_history_t.erase (method) - erase(self, it) -> history_item_t - - @param it: qvector< history_item_t >::iterator - - erase(self, first, last) -> history_item_t - - @param first: qvector< history_item_t >::iterator - @param last: qvector< history_item_t >::iterator - -ida_hexrays.qvector_history_t.extract (method) - extract(self) -> history_item_t - -ida_hexrays.qvector_history_t.find (method) - find(self, x) -> history_item_t - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.grow (method) - grow(self, x=history_item_t()) - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.has (method) - has(self, x) -> bool - - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.inject (method) - inject(self, s, len) - - @param s: history_item_t * - @param len: size_t - -ida_hexrays.qvector_history_t.insert (method) - insert(self, it, x) -> history_item_t - - @param it: qvector< history_item_t >::iterator - @param x: history_item_t const & - -ida_hexrays.qvector_history_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_history_t.push_back (method) - push_back(self, x) - - @param x: history_item_t const & - - push_back(self) -> history_item_t - -ida_hexrays.qvector_history_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_history_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_history_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: history_item_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_history_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_history_t.swap (method) - swap(self, r) - - @param r: qvector< history_item_t > & - -ida_hexrays.qvector_history_t.truncate (method) - truncate(self) - -ida_hexrays.qvector_lvar_t (class) - Proxy of C++ qvector< lvar_t > class. - -ida_hexrays.qvector_lvar_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< lvar_t > const & - -ida_hexrays.qvector_lvar_t.__getitem__ (method) - __getitem__(self, i) -> lvar_t - - @param i: size_t - -ida_hexrays.qvector_lvar_t.__init__ (method) - __init__(self) -> qvector_lvar_t - __init__(self, x) -> qvector_lvar_t - - @param x: qvector< lvar_t > const & - -ida_hexrays.qvector_lvar_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.qvector_lvar_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< lvar_t > const & - -ida_hexrays.qvector_lvar_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: lvar_t const & - -ida_hexrays.qvector_lvar_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: lvar_t const & - -ida_hexrays.qvector_lvar_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.at (method) - at(self, _idx) -> lvar_t - - @param _idx: size_t - -ida_hexrays.qvector_lvar_t.begin (method) - begin(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.qvector_lvar_t.clear (method) - clear(self) - -ida_hexrays.qvector_lvar_t.empty (method) - empty(self) -> bool - -ida_hexrays.qvector_lvar_t.end (method) - end(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.erase (method) - erase(self, it) -> lvar_t - - @param it: qvector< lvar_t >::iterator - - erase(self, first, last) -> lvar_t - - @param first: qvector< lvar_t >::iterator - @param last: qvector< lvar_t >::iterator - -ida_hexrays.qvector_lvar_t.extract (method) - extract(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.find (method) - find(self, x) -> lvar_t - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.grow (method) - grow(self, x=lvar_t()) - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.has (method) - has(self, x) -> bool - - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.inject (method) - inject(self, s, len) - - @param s: lvar_t * - @param len: size_t - -ida_hexrays.qvector_lvar_t.insert (method) - insert(self, it, x) -> lvar_t - - @param it: qvector< lvar_t >::iterator - @param x: lvar_t const & - -ida_hexrays.qvector_lvar_t.pop_back (method) - pop_back(self) - -ida_hexrays.qvector_lvar_t.push_back (method) - push_back(self, x) - - @param x: lvar_t const & - - push_back(self) -> lvar_t - -ida_hexrays.qvector_lvar_t.qclear (method) - qclear(self) - -ida_hexrays.qvector_lvar_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.qvector_lvar_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: lvar_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.qvector_lvar_t.size (method) - size(self) -> size_t - -ida_hexrays.qvector_lvar_t.swap (method) - swap(self, r) - - @param r: qvector< lvar_t > & - -ida_hexrays.qvector_lvar_t.truncate (method) - truncate(self) - -ida_hexrays.reg2mreg (function) - reg2mreg(reg) -> mreg_t - Map a processor register to a microregister. - - @param reg: (C++: int) processor register number - @return: microregister register id or mr_none - -ida_hexrays.remitem (function) - remitem(e) - - @param e: citem_t const * - -ida_hexrays.remove_hexrays_callback (function) - Deprecated. Please use Hexrays_Hooks instead - Uninstall handler for decompiler events. - - @return: number of uninstalled handlers. - -ida_hexrays.rename_lvar (function) - rename_lvar(func_ea, oldname, newname) -> bool - Rename a local variable. - - @param func_ea: (C++: ea_t) function start address - @param oldname: (C++: const char *) old name of the variable - @param newname: (C++: const char *) new name of the variable - @return: success This is a convenience function. For bulk renaming consider - using modify_user_lvars. - -ida_hexrays.restore_user_cmts (function) - restore_user_cmts(func_ea) -> user_cmts_t - Restore user defined comments from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of user defined comments. The returned object must be - deleted by the caller using delete_user_cmts() - -ida_hexrays.restore_user_defined_calls (function) - restore_user_defined_calls(udcalls, func_ea) -> bool - Restore user defined function calls from the database. - - @param udcalls: (C++: udcall_map_t *) ptr to output buffer - @param func_ea: (C++: ea_t) entry address of the function - @return: success - -ida_hexrays.restore_user_iflags (function) - restore_user_iflags(func_ea) -> user_iflags_t - Restore user defined citem iflags from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of user defined iflags. The returned object must be deleted - by the caller using delete_user_iflags() - -ida_hexrays.restore_user_labels (function) - restore_user_labels(func_ea) -> user_labels_t - Restore user defined labels from the database. - - @param func_ea: (C++: ea_t) the entry address of the function, ignored if FUNC != nullptr - @return: collection of user defined labels. The returned object must be deleted - by the caller using delete_user_labels() - -ida_hexrays.restore_user_labels2 (function) - restore_user_labels2(func_ea, func=None) -> user_labels_t - - @param func_ea: ea_t - @param func: cfunc_t const * - -ida_hexrays.restore_user_lvar_settings (function) - restore_user_lvar_settings(lvinf, func_ea) -> bool - Restore user defined local variable settings in the database. - - @param lvinf: (C++: lvar_uservec_t *) ptr to output buffer - @param func_ea: (C++: ea_t) entry address of the function - @return: success - -ida_hexrays.restore_user_numforms (function) - restore_user_numforms(func_ea) -> user_numforms_t - Restore user defined number formats from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of user defined number formats. The returned object must be - deleted by the caller using delete_user_numforms() - -ida_hexrays.restore_user_unions (function) - restore_user_unions(func_ea) -> user_unions_t - Restore user defined union field selections from the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @return: collection of union field selections The returned object must be - deleted by the caller using delete_user_unions() - -ida_hexrays.rlist_t (class) - Proxy of C++ rlist_t class. - -ida_hexrays.rlist_t.__init__ (method) - __init__(self) -> rlist_t - __init__(self, m) -> rlist_t - - @param m: rlist_t const & - - __init__(self, reg, width) -> rlist_t - - @param reg: mreg_t - @param width: int - -ida_hexrays.rlist_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.save_user_cmts (function) - save_user_cmts(func_ea, user_cmts) - Save user defined comments into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param user_cmts: (C++: const user_cmts_t *) collection of user defined comments - -ida_hexrays.save_user_defined_calls (function) - save_user_defined_calls(func_ea, udcalls) - Save user defined local function calls into the database. - - @param func_ea: (C++: ea_t) entry address of the function - @param udcalls: (C++: const udcall_map_t &) user-specified info about user defined function calls - -ida_hexrays.save_user_iflags (function) - save_user_iflags(func_ea, iflags) - Save user defined citem iflags into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param iflags: (C++: const user_iflags_t *) collection of user defined citem iflags - -ida_hexrays.save_user_labels (function) - save_user_labels(func_ea, user_labels) - Save user defined labels into the database. - - @param func_ea: (C++: ea_t) the entry address of the function, ignored if FUNC != nullptr - @param user_labels: (C++: const user_labels_t *) collection of user defined labels - -ida_hexrays.save_user_labels2 (function) - save_user_labels2(func_ea, user_labels, func=None) - - @param func_ea: ea_t - @param user_labels: user_labels_t const * - @param func: cfunc_t const * - -ida_hexrays.save_user_lvar_settings (function) - save_user_lvar_settings(func_ea, lvinf) - Save user defined local variable settings into the database. - - @param func_ea: (C++: ea_t) entry address of the function - @param lvinf: (C++: const lvar_uservec_t &) user-specified info about local variables - -ida_hexrays.save_user_numforms (function) - save_user_numforms(func_ea, numforms) - Save user defined number formats into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param numforms: (C++: const user_numforms_t *) collection of user defined comments - -ida_hexrays.save_user_unions (function) - save_user_unions(func_ea, unions) - Save user defined union field selections into the database. - - @param func_ea: (C++: ea_t) the entry address of the function - @param unions: (C++: const user_unions_t *) collection of union field selections - -ida_hexrays.scif_t (class) - Proxy of C++ scif_t class. - -ida_hexrays.scif_t.__init__ (method) - __init__(self, _mba, tif, n=None) -> scif_t - - @param _mba: mba_t * - @param tif: tinfo_t * - @param n: qstring * - -ida_hexrays.scif_t.mba (variable) - Pointer to the parent mba_t object. Some operations may convert a scattered - operand into something simpler, (a stack operand, for example). We will need to - create stkvar_ref_t at that moment, this is why we need this pointer. See notes - for lvar_ref_t::mba. - -ida_hexrays.scif_t.name (variable) - Usually scattered operands are created from a function prototype, which has the - name information. We preserve it and use it to name the corresponding local - variable. - -ida_hexrays.scif_t.type (variable) - Scattered operands always have type info assigned to them because without it we - won't be able to manipulte them. - -ida_hexrays.scif_visitor_t (class) - Proxy of C++ scif_visitor_t class. - -ida_hexrays.scif_visitor_t.__disown__ (method) - -ida_hexrays.scif_visitor_t.__init__ (method) - __init__(self) -> scif_visitor_t - - @param self: PyObject * - -ida_hexrays.scif_visitor_t.visit_scif_mop (method) - visit_scif_mop(self, r, off) -> int - - @param r: mop_t const & - @param off: int - -ida_hexrays.select_udt_by_offset (function) - select_udt_by_offset(udts, ops, applicator) -> int - Select UDT - - @param udts: (C++: const qvector< tinfo_t > *) list of UDT tinfo_t for the selection, if nullptr or empty then - UDTs from the "Local types" will be used - @param ops: (C++: const ui_stroff_ops_t &) operands - @param applicator: (C++: ui_stroff_applicator_t &) callback will be called to apply the selection for every - operand - -ida_hexrays.send_database (function) - send_database(err, silent) - Send the database to Hex-Rays. This function sends the current database to the - Hex-Rays server. The database is sent in the compressed form over an encrypted - (SSL) connection. - - @param err: (C++: const hexrays_failure_t &) failure description object. Empty hexrays_failure_t object can be - used if error information is not available. - @param silent: (C++: bool) if false, a dialog box will be displayed before sending the - database. - -ida_hexrays.set2jcnd (function) - set2jcnd(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.set_type (function) - set_type(id, tif, source, force=False) -> bool - Set a global type. - - @param id: (C++: uval_t) address or id of the object - @param tif: (C++: const tinfo_t &) new type info - @param source: (C++: type_source_t) where the type comes from - @param force: (C++: bool) true means to set the type as is, false means to merge the new - type with the possibly existing old type info. - @return: success - -ida_hexrays.simple_graph_t (class) - Proxy of C++ simple_graph_t class. - -ida_hexrays.simple_graph_t.__init__ (method) - -ida_hexrays.stkvar_ref_t (class) - Proxy of C++ stkvar_ref_t class. - -ida_hexrays.stkvar_ref_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__init__ (method) - __init__(self, m, o) -> stkvar_ref_t - - @param m: mba_t * - @param o: sval_t - -ida_hexrays.stkvar_ref_t.__le__ (method) - __le__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.compare (method) - compare(self, r) -> int - - @param r: stkvar_ref_t const & - -ida_hexrays.stkvar_ref_t.get_stkvar (method) - get_stkvar(self, p_off=None) -> member_t * - Retrieve the referenced stack variable. - - @param p_off: (C++: uval_t *) if specified, will hold IDA stkoff after the call. - @return: pointer to the stack variable - -ida_hexrays.stkvar_ref_t.mba (variable) - Pointer to the parent mba_t object. We need it in order to retrieve the - referenced stack variable. See notes for lvar_ref_t::mba. - -ida_hexrays.stkvar_ref_t.off (variable) - Offset to the stack variable from the bottom of the stack frame. It is called - 'decompiler stkoff' and it is different from IDA stkoff. See a note and a - picture about 'decompiler stkoff' below. - -ida_hexrays.stkvar_ref_t.swap (method) - swap(self, r) - - @param r: stkvar_ref_t & - -ida_hexrays.swap_mcode_relation (function) - swap_mcode_relation(code) -> mcode_t - - @param code: enum mcode_t - -ida_hexrays.swapped_relation (function) - swapped_relation(op) -> ctype_t - Swap a comparison operator. For example, cot_sge becomes cot_sle. - - @param op: (C++: ctype_t) enum ctype_t - -ida_hexrays.term_hexrays_plugin (function) - term_hexrays_plugin() - Stop working with hex-rays decompiler. - -ida_hexrays.treeloc_t (class) - Proxy of C++ treeloc_t class. - -ida_hexrays.treeloc_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: treeloc_t const & - -ida_hexrays.treeloc_t.__init__ (method) - __init__(self) -> treeloc_t - -ida_hexrays.treeloc_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: treeloc_t const & - -ida_hexrays.udc_filter_t (class) - Proxy of C++ udc_filter_t class. - -ida_hexrays.udc_filter_t.__disown__ (method) - -ida_hexrays.udc_filter_t.__init__ (method) - __init__(self) -> udc_filter_t - - @param self: PyObject * - -ida_hexrays.udc_filter_t.apply (method) - apply(self, cdg) -> merror_t - generate microcode for an instruction - - @param cdg: (C++: codegen_t &) - @return: MERR_... code: MERR_OK - user-defined microcode generated, go to the - next instruction MERR_INSN - not generated - the caller should try the - standard way else - error - -ida_hexrays.udc_filter_t.cleanup (method) - cleanup(self) - Cleanup the filter This function properly clears type information associated to - this filter. - -ida_hexrays.udc_filter_t.empty (method) - empty(self) -> bool - -ida_hexrays.udc_filter_t.init (method) - init(self, decl) -> bool - - @param decl: char const * - -ida_hexrays.udc_filter_t.install (method) - install(self) - -ida_hexrays.udc_filter_t.match (method) - match(self, cdg) -> bool - return true if the filter object should be applied to given instruction - - @param cdg: (C++: codegen_t &) - -ida_hexrays.udc_filter_t.remove (method) - remove(self) -> bool - -ida_hexrays.udcall_map_begin (function) - udcall_map_begin(map) -> udcall_map_iterator_t - Get iterator pointing to the beginning of udcall_map_t. - - @param map: (C++: const udcall_map_t *) udcall_map_t const * - -ida_hexrays.udcall_map_clear (function) - udcall_map_clear(map) - Clear udcall_map_t. - - @param map: (C++: udcall_map_t *) - -ida_hexrays.udcall_map_end (function) - udcall_map_end(map) -> udcall_map_iterator_t - Get iterator pointing to the end of udcall_map_t. - - @param map: (C++: const udcall_map_t *) udcall_map_t const * - -ida_hexrays.udcall_map_erase (function) - udcall_map_erase(map, p) - Erase current element from udcall_map_t. - - @param map: (C++: udcall_map_t *) - @param p: (C++: udcall_map_iterator_t) - -ida_hexrays.udcall_map_find (function) - udcall_map_find(map, key) -> udcall_map_iterator_t - Find the specified key in udcall_map_t. - - @param map: (C++: const udcall_map_t *) udcall_map_t const * - @param key: (C++: const ea_t &) ea_t const & - -ida_hexrays.udcall_map_first (function) - udcall_map_first(p) -> ea_t const & - Get reference to the current map key. - - @param p: (C++: udcall_map_iterator_t) - -ida_hexrays.udcall_map_free (function) - udcall_map_free(map) - Delete udcall_map_t instance. - - @param map: (C++: udcall_map_t *) - -ida_hexrays.udcall_map_insert (function) - udcall_map_insert(map, key, val) -> udcall_map_iterator_t - Insert new (ea_t, udcall_t) pair into udcall_map_t. - - @param map: (C++: udcall_map_t *) - @param key: (C++: const ea_t &) ea_t const & - @param val: (C++: const udcall_t &) udcall_t const & - -ida_hexrays.udcall_map_iterator_t (class) - Proxy of C++ udcall_map_iterator_t class. - -ida_hexrays.udcall_map_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: udcall_map_iterator_t const & - -ida_hexrays.udcall_map_iterator_t.__init__ (method) - __init__(self) -> udcall_map_iterator_t - -ida_hexrays.udcall_map_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: udcall_map_iterator_t const & - -ida_hexrays.udcall_map_new (function) - udcall_map_new() -> udcall_map_t * - Create a new udcall_map_t instance. - -ida_hexrays.udcall_map_next (function) - udcall_map_next(p) -> udcall_map_iterator_t - Move to the next element. - - @param p: (C++: udcall_map_iterator_t) - -ida_hexrays.udcall_map_prev (function) - udcall_map_prev(p) -> udcall_map_iterator_t - Move to the previous element. - - @param p: (C++: udcall_map_iterator_t) - -ida_hexrays.udcall_map_second (function) - udcall_map_second(p) -> udcall_t - Get reference to the current map value. - - @param p: (C++: udcall_map_iterator_t) - -ida_hexrays.udcall_map_size (function) - udcall_map_size(map) -> size_t - Get size of udcall_map_t. - - @param map: (C++: udcall_map_t *) - -ida_hexrays.udcall_t (class) - Proxy of C++ udcall_t class. - -ida_hexrays.udcall_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: udcall_t const & - -ida_hexrays.udcall_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: udcall_t const & - -ida_hexrays.udcall_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: udcall_t const & - -ida_hexrays.udcall_t.__init__ (method) - __init__(self) -> udcall_t - -ida_hexrays.udcall_t.__le__ (method) - __le__(self, r) -> bool - - @param r: udcall_t const & - -ida_hexrays.udcall_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: udcall_t const & - -ida_hexrays.udcall_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: udcall_t const & - -ida_hexrays.udcall_t.compare (method) - compare(self, r) -> int - - @param r: udcall_t const & - -ida_hexrays.udcall_t.empty (method) - empty(self) -> bool - -ida_hexrays.ui_stroff_applicator_t (class) - Proxy of C++ ui_stroff_applicator_t class. - -ida_hexrays.ui_stroff_applicator_t.__disown__ (method) - -ida_hexrays.ui_stroff_applicator_t.__init__ (method) - __init__(self) -> ui_stroff_applicator_t - - @param self: PyObject * - -ida_hexrays.ui_stroff_applicator_t.apply (method) - apply(self, opnum, path, top_tif, spath) -> bool - - @param opnum: (C++: size_t) operand ordinal number, see below - @param path: (C++: const intvec_t &) path describing the union selection, maybe empty - @param top_tif: (C++: const tinfo_t &) tinfo_t of the selected toplevel UDT - @param spath: (C++: const char *) selected path - -ida_hexrays.ui_stroff_op_t (class) - Proxy of C++ ui_stroff_op_t class. - -ida_hexrays.ui_stroff_op_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_op_t.__init__ (method) - __init__(self) -> ui_stroff_op_t - -ida_hexrays.ui_stroff_op_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_op_t.offset (variable) - operand offset, will be used when calculating the UDT path - -ida_hexrays.ui_stroff_op_t.text (variable) - any text for the column "Operand" of widget - -ida_hexrays.ui_stroff_ops_t (class) - Proxy of C++ qvector< ui_stroff_op_t > class. - -ida_hexrays.ui_stroff_ops_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< ui_stroff_op_t > const & - -ida_hexrays.ui_stroff_ops_t.__getitem__ (method) - __getitem__(self, i) -> ui_stroff_op_t - - @param i: size_t - -ida_hexrays.ui_stroff_ops_t.__init__ (method) - __init__(self) -> ui_stroff_ops_t - __init__(self, x) -> ui_stroff_ops_t - - @param x: qvector< ui_stroff_op_t > const & - -ida_hexrays.ui_stroff_ops_t.__len__ (method) - __len__(self) -> size_t - -ida_hexrays.ui_stroff_ops_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< ui_stroff_op_t > const & - -ida_hexrays.ui_stroff_ops_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_ops_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_ops_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_ops_t.at (method) - at(self, _idx) -> ui_stroff_op_t - - @param _idx: size_t - -ida_hexrays.ui_stroff_ops_t.begin (method) - begin(self) -> ui_stroff_op_t - -ida_hexrays.ui_stroff_ops_t.capacity (method) - capacity(self) -> size_t - -ida_hexrays.ui_stroff_ops_t.clear (method) - clear(self) - -ida_hexrays.ui_stroff_ops_t.empty (method) - empty(self) -> bool - -ida_hexrays.ui_stroff_ops_t.end (method) - end(self) -> ui_stroff_op_t - -ida_hexrays.ui_stroff_ops_t.erase (method) - erase(self, it) -> ui_stroff_op_t - - @param it: qvector< ui_stroff_op_t >::iterator - - erase(self, first, last) -> ui_stroff_op_t - - @param first: qvector< ui_stroff_op_t >::iterator - @param last: qvector< ui_stroff_op_t >::iterator - -ida_hexrays.ui_stroff_ops_t.extract (method) - extract(self) -> ui_stroff_op_t - -ida_hexrays.ui_stroff_ops_t.find (method) - find(self, x) -> ui_stroff_op_t - - @param x: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_ops_t.grow (method) - grow(self, x=ui_stroff_op_t()) - - @param x: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_ops_t.has (method) - has(self, x) -> bool - - @param x: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_ops_t.inject (method) - inject(self, s, len) - - @param s: ui_stroff_op_t * - @param len: size_t - -ida_hexrays.ui_stroff_ops_t.insert (method) - insert(self, it, x) -> ui_stroff_op_t - - @param it: qvector< ui_stroff_op_t >::iterator - @param x: ui_stroff_op_t const & - -ida_hexrays.ui_stroff_ops_t.pop_back (method) - pop_back(self) - -ida_hexrays.ui_stroff_ops_t.push_back (method) - push_back(self, x) - - @param x: ui_stroff_op_t const & - - push_back(self) -> ui_stroff_op_t - -ida_hexrays.ui_stroff_ops_t.qclear (method) - qclear(self) - -ida_hexrays.ui_stroff_ops_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_hexrays.ui_stroff_ops_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ui_stroff_op_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_hexrays.ui_stroff_ops_t.size (method) - size(self) -> size_t - -ida_hexrays.ui_stroff_ops_t.swap (method) - swap(self, r) - - @param r: qvector< ui_stroff_op_t > & - -ida_hexrays.ui_stroff_ops_t.truncate (method) - truncate(self) - -ida_hexrays.user_cmts_begin (function) - user_cmts_begin(map) -> user_cmts_iterator_t - Get iterator pointing to the beginning of user_cmts_t. - - @param map: (C++: const user_cmts_t *) user_cmts_t const * - -ida_hexrays.user_cmts_clear (function) - user_cmts_clear(map) - Clear user_cmts_t. - - @param map: (C++: user_cmts_t *) - -ida_hexrays.user_cmts_end (function) - user_cmts_end(map) -> user_cmts_iterator_t - Get iterator pointing to the end of user_cmts_t. - - @param map: (C++: const user_cmts_t *) user_cmts_t const * - -ida_hexrays.user_cmts_erase (function) - user_cmts_erase(map, p) - Erase current element from user_cmts_t. - - @param map: (C++: user_cmts_t *) - @param p: (C++: user_cmts_iterator_t) - -ida_hexrays.user_cmts_find (function) - user_cmts_find(map, key) -> user_cmts_iterator_t - Find the specified key in user_cmts_t. - - @param map: (C++: const user_cmts_t *) user_cmts_t const * - @param key: (C++: const treeloc_t &) treeloc_t const & - -ida_hexrays.user_cmts_first (function) - user_cmts_first(p) -> treeloc_t - Get reference to the current map key. - - @param p: (C++: user_cmts_iterator_t) - -ida_hexrays.user_cmts_free (function) - user_cmts_free(map) - Delete user_cmts_t instance. - - @param map: (C++: user_cmts_t *) - -ida_hexrays.user_cmts_insert (function) - user_cmts_insert(map, key, val) -> user_cmts_iterator_t - Insert new (treeloc_t, citem_cmt_t) pair into user_cmts_t. - - @param map: (C++: user_cmts_t *) - @param key: (C++: const treeloc_t &) treeloc_t const & - @param val: (C++: const citem_cmt_t &) citem_cmt_t const & - -ida_hexrays.user_cmts_iterator_t (class) - Proxy of C++ user_cmts_iterator_t class. - -ida_hexrays.user_cmts_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_cmts_iterator_t const & - -ida_hexrays.user_cmts_iterator_t.__init__ (method) - __init__(self) -> user_cmts_iterator_t - -ida_hexrays.user_cmts_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_cmts_iterator_t const & - -ida_hexrays.user_cmts_new (function) - user_cmts_new() -> user_cmts_t - Create a new user_cmts_t instance. - -ida_hexrays.user_cmts_next (function) - user_cmts_next(p) -> user_cmts_iterator_t - Move to the next element. - - @param p: (C++: user_cmts_iterator_t) - -ida_hexrays.user_cmts_prev (function) - user_cmts_prev(p) -> user_cmts_iterator_t - Move to the previous element. - - @param p: (C++: user_cmts_iterator_t) - -ida_hexrays.user_cmts_second (function) - user_cmts_second(p) -> citem_cmt_t - Get reference to the current map value. - - @param p: (C++: user_cmts_iterator_t) - -ida_hexrays.user_cmts_size (function) - user_cmts_size(map) -> size_t - Get size of user_cmts_t. - - @param map: (C++: user_cmts_t *) - -ida_hexrays.user_cmts_t (class) - Proxy of C++ std::map< treeloc_t,citem_cmt_t > class. - -ida_hexrays.user_cmts_t.__init__ (method) - __init__(self) -> user_cmts_t - -ida_hexrays.user_cmts_t.at (method) - at(self, _Keyval) -> citem_cmt_t - - @param _Keyval: treeloc_t const & - -ida_hexrays.user_cmts_t.size (method) - size(self) -> size_t - -ida_hexrays.user_iflags_begin (function) - user_iflags_begin(map) -> user_iflags_iterator_t - Get iterator pointing to the beginning of user_iflags_t. - - @param map: (C++: const user_iflags_t *) user_iflags_t const * - -ida_hexrays.user_iflags_clear (function) - user_iflags_clear(map) - Clear user_iflags_t. - - @param map: (C++: user_iflags_t *) - -ida_hexrays.user_iflags_end (function) - user_iflags_end(map) -> user_iflags_iterator_t - Get iterator pointing to the end of user_iflags_t. - - @param map: (C++: const user_iflags_t *) user_iflags_t const * - -ida_hexrays.user_iflags_erase (function) - user_iflags_erase(map, p) - Erase current element from user_iflags_t. - - @param map: (C++: user_iflags_t *) - @param p: (C++: user_iflags_iterator_t) - -ida_hexrays.user_iflags_find (function) - user_iflags_find(map, key) -> user_iflags_iterator_t - Find the specified key in user_iflags_t. - - @param map: (C++: const user_iflags_t *) user_iflags_t const * - @param key: (C++: const citem_locator_t &) citem_locator_t const & - -ida_hexrays.user_iflags_first (function) - user_iflags_first(p) -> citem_locator_t - Get reference to the current map key. - - @param p: (C++: user_iflags_iterator_t) - -ida_hexrays.user_iflags_free (function) - user_iflags_free(map) - Delete user_iflags_t instance. - - @param map: (C++: user_iflags_t *) - -ida_hexrays.user_iflags_insert (function) - user_iflags_insert(map, key, val) -> user_iflags_iterator_t - Insert new (citem_locator_t, int32) pair into user_iflags_t. - - @param map: (C++: user_iflags_t *) - @param key: (C++: const citem_locator_t &) citem_locator_t const & - @param val: (C++: const int32 &) int32 const & - -ida_hexrays.user_iflags_iterator_t (class) - Proxy of C++ user_iflags_iterator_t class. - -ida_hexrays.user_iflags_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_iflags_iterator_t const & - -ida_hexrays.user_iflags_iterator_t.__init__ (method) - __init__(self) -> user_iflags_iterator_t - -ida_hexrays.user_iflags_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_iflags_iterator_t const & - -ida_hexrays.user_iflags_new (function) - user_iflags_new() -> user_iflags_t - Create a new user_iflags_t instance. - -ida_hexrays.user_iflags_next (function) - user_iflags_next(p) -> user_iflags_iterator_t - Move to the next element. - - @param p: (C++: user_iflags_iterator_t) - -ida_hexrays.user_iflags_prev (function) - user_iflags_prev(p) -> user_iflags_iterator_t - Move to the previous element. - - @param p: (C++: user_iflags_iterator_t) - -ida_hexrays.user_iflags_second (function) - user_iflags_second(p) -> int32 const & - Get reference to the current map value. - - @param p: (C++: user_iflags_iterator_t) - -ida_hexrays.user_iflags_size (function) - user_iflags_size(map) -> size_t - Get size of user_iflags_t. - - @param map: (C++: user_iflags_t *) - -ida_hexrays.user_iflags_t (class) - Proxy of C++ std::map< citem_locator_t,int32 > class. - -ida_hexrays.user_iflags_t.__init__ (method) - __init__(self) -> user_iflags_t - -ida_hexrays.user_iflags_t.at (method) - at(self, _Keyval) -> int & - - @param _Keyval: citem_locator_t const & - -ida_hexrays.user_iflags_t.size (method) - size(self) -> size_t - -ida_hexrays.user_labels_begin (function) - user_labels_begin(map) -> user_labels_iterator_t - Get iterator pointing to the beginning of user_labels_t. - - @param map: (C++: const user_labels_t *) user_labels_t const * - -ida_hexrays.user_labels_clear (function) - user_labels_clear(map) - Clear user_labels_t. - - @param map: (C++: user_labels_t *) - -ida_hexrays.user_labels_end (function) - user_labels_end(map) -> user_labels_iterator_t - Get iterator pointing to the end of user_labels_t. - - @param map: (C++: const user_labels_t *) user_labels_t const * - -ida_hexrays.user_labels_erase (function) - user_labels_erase(map, p) - Erase current element from user_labels_t. - - @param map: (C++: user_labels_t *) - @param p: (C++: user_labels_iterator_t) - -ida_hexrays.user_labels_find (function) - user_labels_find(map, key) -> user_labels_iterator_t - Find the specified key in user_labels_t. - - @param map: (C++: const user_labels_t *) user_labels_t const * - @param key: (C++: const int &) int const & - -ida_hexrays.user_labels_first (function) - user_labels_first(p) -> int const & - Get reference to the current map key. - - @param p: (C++: user_labels_iterator_t) - -ida_hexrays.user_labels_free (function) - user_labels_free(map) - Delete user_labels_t instance. - - @param map: (C++: user_labels_t *) - -ida_hexrays.user_labels_insert (function) - user_labels_insert(map, key, val) -> user_labels_iterator_t - Insert new (int, qstring) pair into user_labels_t. - - @param map: (C++: user_labels_t *) - @param key: (C++: const int &) int const & - @param val: (C++: const qstring &) qstring const & - -ida_hexrays.user_labels_iterator_t (class) - Proxy of C++ user_labels_iterator_t class. - -ida_hexrays.user_labels_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_labels_iterator_t const & - -ida_hexrays.user_labels_iterator_t.__init__ (method) - __init__(self) -> user_labels_iterator_t - -ida_hexrays.user_labels_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_labels_iterator_t const & - -ida_hexrays.user_labels_new (function) - user_labels_new() -> user_labels_t - Create a new user_labels_t instance. - -ida_hexrays.user_labels_next (function) - user_labels_next(p) -> user_labels_iterator_t - Move to the next element. - - @param p: (C++: user_labels_iterator_t) - -ida_hexrays.user_labels_prev (function) - user_labels_prev(p) -> user_labels_iterator_t - Move to the previous element. - - @param p: (C++: user_labels_iterator_t) - -ida_hexrays.user_labels_second (function) - user_labels_second(p) -> qstring & - Get reference to the current map value. - - @param p: (C++: user_labels_iterator_t) - -ida_hexrays.user_labels_size (function) - user_labels_size(map) -> size_t - Get size of user_labels_t. - - @param map: (C++: user_labels_t *) - -ida_hexrays.user_labels_t (class) - Proxy of C++ std::map< int,qstring > class. - -ida_hexrays.user_labels_t.__init__ (method) - __init__(self) -> user_labels_t - -ida_hexrays.user_labels_t.at (method) - at(self, _Keyval) -> _qstring< char > & - - @param _Keyval: int const & - -ida_hexrays.user_labels_t.size (method) - size(self) -> size_t - -ida_hexrays.user_lvar_modifier_t (class) - Proxy of C++ user_lvar_modifier_t class. - -ida_hexrays.user_lvar_modifier_t.__disown__ (method) - -ida_hexrays.user_lvar_modifier_t.__init__ (method) - __init__(self) -> user_lvar_modifier_t - - @param self: PyObject * - -ida_hexrays.user_lvar_modifier_t.modify_lvars (method) - modify_lvars(self, lvinf) -> bool - Modify lvar settings. Returns: true-modified - - @param lvinf: (C++: lvar_uservec_t *) - -ida_hexrays.user_numforms_begin (function) - user_numforms_begin(map) -> user_numforms_iterator_t - Get iterator pointing to the beginning of user_numforms_t. - - @param map: (C++: const user_numforms_t *) user_numforms_t const * - -ida_hexrays.user_numforms_clear (function) - user_numforms_clear(map) - Clear user_numforms_t. - - @param map: (C++: user_numforms_t *) - -ida_hexrays.user_numforms_end (function) - user_numforms_end(map) -> user_numforms_iterator_t - Get iterator pointing to the end of user_numforms_t. - - @param map: (C++: const user_numforms_t *) user_numforms_t const * - -ida_hexrays.user_numforms_erase (function) - user_numforms_erase(map, p) - Erase current element from user_numforms_t. - - @param map: (C++: user_numforms_t *) - @param p: (C++: user_numforms_iterator_t) - -ida_hexrays.user_numforms_find (function) - user_numforms_find(map, key) -> user_numforms_iterator_t - Find the specified key in user_numforms_t. - - @param map: (C++: const user_numforms_t *) user_numforms_t const * - @param key: (C++: const operand_locator_t &) operand_locator_t const & - -ida_hexrays.user_numforms_first (function) - user_numforms_first(p) -> operand_locator_t - Get reference to the current map key. - - @param p: (C++: user_numforms_iterator_t) - -ida_hexrays.user_numforms_free (function) - user_numforms_free(map) - Delete user_numforms_t instance. - - @param map: (C++: user_numforms_t *) - -ida_hexrays.user_numforms_insert (function) - user_numforms_insert(map, key, val) -> user_numforms_iterator_t - Insert new (operand_locator_t, number_format_t) pair into user_numforms_t. - - @param map: (C++: user_numforms_t *) - @param key: (C++: const operand_locator_t &) operand_locator_t const & - @param val: (C++: const number_format_t &) number_format_t const & - -ida_hexrays.user_numforms_iterator_t (class) - Proxy of C++ user_numforms_iterator_t class. - -ida_hexrays.user_numforms_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_numforms_iterator_t const & - -ida_hexrays.user_numforms_iterator_t.__init__ (method) - __init__(self) -> user_numforms_iterator_t - -ida_hexrays.user_numforms_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_numforms_iterator_t const & - -ida_hexrays.user_numforms_new (function) - user_numforms_new() -> user_numforms_t - Create a new user_numforms_t instance. - -ida_hexrays.user_numforms_next (function) - user_numforms_next(p) -> user_numforms_iterator_t - Move to the next element. - - @param p: (C++: user_numforms_iterator_t) - -ida_hexrays.user_numforms_prev (function) - user_numforms_prev(p) -> user_numforms_iterator_t - Move to the previous element. - - @param p: (C++: user_numforms_iterator_t) - -ida_hexrays.user_numforms_second (function) - user_numforms_second(p) -> number_format_t - Get reference to the current map value. - - @param p: (C++: user_numforms_iterator_t) - -ida_hexrays.user_numforms_size (function) - user_numforms_size(map) -> size_t - Get size of user_numforms_t. - - @param map: (C++: user_numforms_t *) - -ida_hexrays.user_numforms_t (class) - Proxy of C++ std::map< operand_locator_t,number_format_t > class. - -ida_hexrays.user_numforms_t.__init__ (method) - __init__(self) -> user_numforms_t - -ida_hexrays.user_numforms_t.at (method) - at(self, _Keyval) -> number_format_t - - @param _Keyval: operand_locator_t const & - -ida_hexrays.user_numforms_t.size (method) - size(self) -> size_t - -ida_hexrays.user_unions_begin (function) - user_unions_begin(map) -> user_unions_iterator_t - Get iterator pointing to the beginning of user_unions_t. - - @param map: (C++: const user_unions_t *) user_unions_t const * - -ida_hexrays.user_unions_clear (function) - user_unions_clear(map) - Clear user_unions_t. - - @param map: (C++: user_unions_t *) - -ida_hexrays.user_unions_end (function) - user_unions_end(map) -> user_unions_iterator_t - Get iterator pointing to the end of user_unions_t. - - @param map: (C++: const user_unions_t *) user_unions_t const * - -ida_hexrays.user_unions_erase (function) - user_unions_erase(map, p) - Erase current element from user_unions_t. - - @param map: (C++: user_unions_t *) - @param p: (C++: user_unions_iterator_t) - -ida_hexrays.user_unions_find (function) - user_unions_find(map, key) -> user_unions_iterator_t - Find the specified key in user_unions_t. - - @param map: (C++: const user_unions_t *) user_unions_t const * - @param key: (C++: const ea_t &) ea_t const & - -ida_hexrays.user_unions_first (function) - user_unions_first(p) -> ea_t const & - Get reference to the current map key. - - @param p: (C++: user_unions_iterator_t) - -ida_hexrays.user_unions_free (function) - user_unions_free(map) - Delete user_unions_t instance. - - @param map: (C++: user_unions_t *) - -ida_hexrays.user_unions_insert (function) - user_unions_insert(map, key, val) -> user_unions_iterator_t - Insert new (ea_t, intvec_t) pair into user_unions_t. - - @param map: (C++: user_unions_t *) - @param key: (C++: const ea_t &) ea_t const & - @param val: (C++: const intvec_t &) intvec_t const & - -ida_hexrays.user_unions_iterator_t (class) - Proxy of C++ user_unions_iterator_t class. - -ida_hexrays.user_unions_iterator_t.__eq__ (method) - __eq__(self, p) -> bool - - @param p: user_unions_iterator_t const & - -ida_hexrays.user_unions_iterator_t.__init__ (method) - __init__(self) -> user_unions_iterator_t - -ida_hexrays.user_unions_iterator_t.__ne__ (method) - __ne__(self, p) -> bool - - @param p: user_unions_iterator_t const & - -ida_hexrays.user_unions_new (function) - user_unions_new() -> user_unions_t - Create a new user_unions_t instance. - -ida_hexrays.user_unions_next (function) - user_unions_next(p) -> user_unions_iterator_t - Move to the next element. - - @param p: (C++: user_unions_iterator_t) - -ida_hexrays.user_unions_prev (function) - user_unions_prev(p) -> user_unions_iterator_t - Move to the previous element. - - @param p: (C++: user_unions_iterator_t) - -ida_hexrays.user_unions_second (function) - user_unions_second(p) -> intvec_t - Get reference to the current map value. - - @param p: (C++: user_unions_iterator_t) - -ida_hexrays.user_unions_size (function) - user_unions_size(map) -> size_t - Get size of user_unions_t. - - @param map: (C++: user_unions_t *) - -ida_hexrays.user_unions_t (class) - Proxy of C++ std::map< ea_t,intvec_t > class. - -ida_hexrays.user_unions_t.__init__ (method) - __init__(self) -> user_unions_t - -ida_hexrays.user_unions_t.at (method) - at(self, _Keyval) -> intvec_t - - @param _Keyval: unsigned-ea-like-numeric-type const & - -ida_hexrays.user_unions_t.size (method) - size(self) -> size_t - -ida_hexrays.uval_ivl_ivlset_t (class) - Proxy of C++ ivlset_tpl< ivl_t,uval_t > class. - -ida_hexrays.uval_ivl_ivlset_t.__eq__ (method) - __eq__(self, v) -> bool - - @param v: ivl_t const & - -ida_hexrays.uval_ivl_ivlset_t.__init__ (method) - __init__(self) -> uval_ivl_ivlset_t - __init__(self, ivl) -> uval_ivl_ivlset_t - - @param ivl: ivl_t const & - -ida_hexrays.uval_ivl_ivlset_t.__ne__ (method) - __ne__(self, v) -> bool - - @param v: ivl_t const & - -ida_hexrays.uval_ivl_ivlset_t.all_values (method) - all_values(self) -> bool - -ida_hexrays.uval_ivl_ivlset_t.begin (method) - begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator - begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator - -ida_hexrays.uval_ivl_ivlset_t.clear (method) - clear(self) - -ida_hexrays.uval_ivl_ivlset_t.empty (method) - empty(self) -> bool - -ida_hexrays.uval_ivl_ivlset_t.end (method) - end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator - end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator - -ida_hexrays.uval_ivl_ivlset_t.getivl (method) - getivl(self, idx) -> ivl_t - - @param idx: int - -ida_hexrays.uval_ivl_ivlset_t.lastivl (method) - lastivl(self) -> ivl_t - -ida_hexrays.uval_ivl_ivlset_t.nivls (method) - nivls(self) -> size_t - -ida_hexrays.uval_ivl_ivlset_t.qclear (method) - qclear(self) - -ida_hexrays.uval_ivl_ivlset_t.set_all_values (method) - set_all_values(self) - -ida_hexrays.uval_ivl_ivlset_t.single_value (method) - single_value(self) -> bool - single_value(self, v) -> bool - - @param v: unsigned-ea-like-numeric-type - -ida_hexrays.uval_ivl_ivlset_t.swap (method) - swap(self, r) - - @param r: ivlset_tpl< ivl_t,uval_t > & - -ida_hexrays.uval_ivl_t (class) - Proxy of C++ ivl_tpl< uval_t > class. - -ida_hexrays.uval_ivl_t.__init__ (method) - __init__(self, _off, _size) -> uval_ivl_t - - @param _off: unsigned-ea-like-numeric-type - @param _size: unsigned-ea-like-numeric-type - -ida_hexrays.uval_ivl_t.end (method) - end(self) -> unsigned-ea-like-numeric-type - -ida_hexrays.uval_ivl_t.last (method) - last(self) -> unsigned-ea-like-numeric-type - -ida_hexrays.uval_ivl_t.valid (method) - valid(self) -> bool - -ida_hexrays.valrng_t (class) - Proxy of C++ valrng_t class. - -ida_hexrays.valrng_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__init__ (method) - __init__(self, size_=MAX_VLR_SIZE) -> valrng_t - - @param size_: int - - __init__(self, r) -> valrng_t - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__le__ (method) - __le__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t._deregister (method) - _deregister(self) - -ida_hexrays.valrng_t._print (method) - _print(self) - -ida_hexrays.valrng_t._register (method) - _register(self) - -ida_hexrays.valrng_t.all_values (method) - all_values(self) -> bool - -ida_hexrays.valrng_t.compare (method) - compare(self, r) -> int - - @param r: valrng_t const & - -ida_hexrays.valrng_t.cvt_to_cmp (method) - cvt_to_cmp(self, strict) -> bool - - @param strict: bool - -ida_hexrays.valrng_t.cvt_to_single_value (method) - cvt_to_single_value(self) -> bool - -ida_hexrays.valrng_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.valrng_t.empty (method) - empty(self) -> bool - -ida_hexrays.valrng_t.get_size (method) - get_size(self) -> int - -ida_hexrays.valrng_t.has (method) - has(self, v) -> bool - - @param v: uvlr_t - -ida_hexrays.valrng_t.intersect_with (method) - intersect_with(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.valrng_t.inverse (method) - inverse(self) - -ida_hexrays.valrng_t.is_unknown (method) - is_unknown(self) -> bool - -ida_hexrays.valrng_t.max_svalue (method) - max_svalue(self, size_) -> uvlr_t - - @param size_: int - - max_svalue(self) -> uvlr_t - -ida_hexrays.valrng_t.max_value (method) - max_value(self, size_) -> uvlr_t - - @param size_: int - - max_value(self) -> uvlr_t - -ida_hexrays.valrng_t.min_svalue (method) - min_svalue(self, size_) -> uvlr_t - - @param size_: int - - min_svalue(self) -> uvlr_t - -ida_hexrays.valrng_t.reduce_size (method) - reduce_size(self, new_size) -> bool - - @param new_size: int - -ida_hexrays.valrng_t.set_all (method) - set_all(self) - -ida_hexrays.valrng_t.set_cmp (method) - set_cmp(self, cmp, _value) - - @param cmp: enum cmpop_t - @param _value: uvlr_t - -ida_hexrays.valrng_t.set_eq (method) - set_eq(self, v) - - @param v: uvlr_t - -ida_hexrays.valrng_t.set_none (method) - set_none(self) - -ida_hexrays.valrng_t.set_unk (method) - set_unk(self) - -ida_hexrays.valrng_t.swap (method) - swap(self, r) - - @param r: valrng_t & - -ida_hexrays.valrng_t.unite_with (method) - unite_with(self, r) -> bool - - @param r: valrng_t const & - -ida_hexrays.var_ref_t (class) - Proxy of C++ var_ref_t class. - -ida_hexrays.var_ref_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__init__ (method) - __init__(self) -> var_ref_t - -ida_hexrays.var_ref_t.__le__ (method) - __le__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.compare (method) - compare(self, r) -> int - - @param r: var_ref_t const & - -ida_hexrays.var_ref_t.getv (method) - getv(self) -> lvar_t - -ida_hexrays.var_ref_t.idx (variable) - index into lvars_t - -ida_hexrays.var_ref_t.mba (variable) - pointer to the underlying micro array - -ida_hexrays.vc_printer_t (class) - Proxy of C++ vc_printer_t class. - -ida_hexrays.vc_printer_t.__disown__ (method) - -ida_hexrays.vc_printer_t.__init__ (method) - __init__(self, f) -> vc_printer_t - - @param f: cfunc_t const * - -ida_hexrays.vc_printer_t.func (variable) - cfunc_t to generate text for - -ida_hexrays.vc_printer_t.oneliner (method) - oneliner(self) -> bool - Are we generating one-line text representation? - - @return: true if the output will occupy one line without line breaks - -ida_hexrays.vd_failure_t (class) - Proxy of C++ vd_failure_t class. - -ida_hexrays.vd_failure_t.__init__ (method) - __init__(self) -> vd_failure_t - __init__(self, code, ea, buf=None) -> vd_failure_t - - @param code: enum merror_t - @param ea: ea_t - @param buf: char const * - - __init__(self, code, ea, buf) -> vd_failure_t - - @param code: enum merror_t - @param ea: ea_t - @param buf: qstring const & - - __init__(self, _hf) -> vd_failure_t - - @param _hf: hexrays_failure_t const & - -ida_hexrays.vd_failure_t.desc (method) - desc(self) -> qstring - -ida_hexrays.vd_interr_t (class) - Proxy of C++ vd_interr_t class. - -ida_hexrays.vd_interr_t.__init__ (method) - __init__(self, ea, buf) -> vd_interr_t - - @param ea: ea_t - @param buf: char const * - -ida_hexrays.vd_printer_t (class) - Proxy of C++ vd_printer_t class. - -ida_hexrays.vd_printer_t.__disown__ (method) - -ida_hexrays.vd_printer_t.__init__ (method) - __init__(self) -> vd_printer_t - - @param self: PyObject * - -ida_hexrays.vd_printer_t._print (method) - _print(self, indent, format) -> int - - Parameters - ---------- - indent: int - format: char const * - -ida_hexrays.vd_printer_t.hdrlines (variable) - number of header lines (prototype+typedef+lvars) valid at the end of print - process - -ida_hexrays.vdloc_t (class) - Proxy of C++ vdloc_t class. - -ida_hexrays.vdloc_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: vdloc_t const & - -ida_hexrays.vdloc_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: vdloc_t const & - -ida_hexrays.vdloc_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: vdloc_t const & - -ida_hexrays.vdloc_t.__init__ (method) - __init__(self) -> vdloc_t - -ida_hexrays.vdloc_t.__le__ (method) - __le__(self, r) -> bool - - @param r: vdloc_t const & - -ida_hexrays.vdloc_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: vdloc_t const & - -ida_hexrays.vdloc_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: vdloc_t const & - -ida_hexrays.vdloc_t._set_reg1 (method) - _set_reg1(self, r1) - - Parameters - ---------- - r1: int - -ida_hexrays.vdloc_t.compare (method) - compare(self, r) -> int - - @param r: vdloc_t const & - -ida_hexrays.vdloc_t.is_aliasable (method) - is_aliasable(self, mb, size) -> bool - - @param mb: mba_t const * - @param size: int - -ida_hexrays.vdloc_t.reg1 (method) - reg1(self) -> int - -ida_hexrays.vdloc_t.set_reg1 (method) - set_reg1(self, r1) - - @param r1: int - -ida_hexrays.vdui_t (class) - Proxy of C++ vdui_t class. - -ida_hexrays.vdui_t.__init__ (method) - -ida_hexrays.vdui_t.calc_cmt_type (method) - calc_cmt_type(self, lnnum, cmttype) -> cmt_type_t - Check if the specified line can have a comment. Due to the coordinate system for - comments: (\link{https://www.hex-rays.com/blog/coordinate-system-for-hex-rays}) - some function lines cannot have comments. This function checks if a comment can - be attached to the specified line. - - @param lnnum: (C++: size_t) line number (0 based) - @param cmttype: (C++: cmt_type_t) comment types to check - @return: possible comment types - -ida_hexrays.vdui_t.cfunc (variable) - pointer to function object - -ida_hexrays.vdui_t.clear (method) - clear(self) - Clear the pseudocode window. It deletes the current function and microcode. - -ida_hexrays.vdui_t.collapse_item (method) - collapse_item(self, hide) -> bool - Collapse/uncollapse item. This function collapses the current item. - - @param hide: (C++: bool) - @return: false if failed. - -ida_hexrays.vdui_t.collapse_lvars (method) - collapse_lvars(self, hide) -> bool - Collapse/uncollapse local variable declarations. - - @param hide: (C++: bool) - @return: false if failed. - -ida_hexrays.vdui_t.cpos (variable) - Current ctext position. - -ida_hexrays.vdui_t.ct (variable) - pseudocode view - -ida_hexrays.vdui_t.ctree_to_disasm (method) - ctree_to_disasm(self) -> bool - Jump to disassembly. This function jumps to the address in the disassembly - window which corresponds to the current item. The current item is determined - based on the current keyboard cursor position. - - @return: false if failed - -ida_hexrays.vdui_t.del_orphan_cmts (method) - del_orphan_cmts(self) -> bool - Delete all orphan comments. Delete all orphan comments and refresh the screen. - - @return: true - -ida_hexrays.vdui_t.edit_cmt (method) - edit_cmt(self, loc) -> bool - Edit an indented comment. This function displays a dialog box and allows the - user to edit the comment for the specified ctree location. - - @param loc: (C++: const treeloc_t &) comment location - @return: false if failed or cancelled - -ida_hexrays.vdui_t.edit_func_cmt (method) - edit_func_cmt(self) -> bool - Edit a function comment. This function displays a dialog box and allows the user - to edit the function comment. - - @return: false if failed or cancelled - -ida_hexrays.vdui_t.flags (variable) - Properties of pseudocode window - -ida_hexrays.vdui_t.get_current_item (method) - get_current_item(self, idv) -> bool - Get current item. This function refreshes the cpos, item, tail fields. - - @param idv: (C++: input_device_t) keyboard or mouse - @see: cfunc_t::get_line_item() - @return: false if failed - -ida_hexrays.vdui_t.get_current_label (method) - get_current_label(self) -> int - Get current label. If there is a label under the cursor, return its number. - - @return: -1 if there is no label under the cursor. prereq: get_current_item() - has been called - -ida_hexrays.vdui_t.get_number (method) - get_number(self) -> cnumber_t - Get current number. If the current item is a number, return pointer to it. - - @return: nullptr if the current item is not a number This function returns non- - null for the cases of a 'switch' statement Also, if the current item is - a casted number, then this function will succeed. - -ida_hexrays.vdui_t.head (variable) - First ctree item on the current line (for block comments) - -ida_hexrays.vdui_t.in_ctree (method) - in_ctree(self) -> bool - Is the current item a statement? - - @return: false if the cursor is in the local variable/type declaration area - true if the cursor is in the statement area - -ida_hexrays.vdui_t.invert_bits (method) - invert_bits(self) -> bool - Bitwise negate a number. This function inverts all bits of the current number. - - @return: false if failed. - -ida_hexrays.vdui_t.invert_sign (method) - invert_sign(self) -> bool - Negate a number. This function negates the current number. - - @return: false if failed. - -ida_hexrays.vdui_t.item (variable) - Current ctree item. - -ida_hexrays.vdui_t.jump_enter (method) - jump_enter(self, idv, omflags) -> bool - Process the Enter key. This function jumps to the definition of the item under - the cursor. If the current item is a function, it will be decompiled. If the - current item is a global data, its disassemly text will be displayed. - - @param idv: (C++: input_device_t) what cursor must be used, the keyboard or the mouse - @param omflags: (C++: int) OM_NEWWIN: new pseudocode window will open, 0: reuse the - existing window - @return: false if failed - -ida_hexrays.vdui_t.last_code (variable) - result of the last user action. See Microcode error codes - -ida_hexrays.vdui_t.locked (method) - locked(self) -> bool - Does the pseudocode window contain valid code? We lock windows before modifying - them, to avoid recursion due to the events generated by the IDA kernel. - @retval true: The window is locked and may have stale info - -ida_hexrays.vdui_t.map_lvar (method) - map_lvar(self, frm, to) -> bool - Map a local variable to another. This function permanently maps one lvar to - another. All occurrences of the mapped variable are replaced by the new variable - - @param from: (C++: lvar_t *) the variable being mapped - @param to: (C++: lvar_t *) the variable to map to. if nullptr, unmaps the variable - @return: false if failed - -ida_hexrays.vdui_t.mba (variable) - pointer to underlying microcode - -ida_hexrays.vdui_t.refresh_cpos (method) - refresh_cpos(self, idv) -> bool - Refresh the current position. This function refreshes the cpos field. - - @param idv: (C++: input_device_t) keyboard or mouse - @return: false if failed - -ida_hexrays.vdui_t.refresh_ctext (method) - refresh_ctext(self, activate=True) - Refresh pseudocode window. This function refreshes the pseudocode window by - regenerating its text from cfunc_t. Instead of this function use - refresh_func_ctext(), which refreshes all pseudocode windows for the function. - @see: refresh_view(), refresh_func_ctext() - - @param activate: (C++: bool) - -ida_hexrays.vdui_t.refresh_view (method) - refresh_view(self, redo_mba) - Refresh pseudocode window. This is the highest level refresh function. It causes - the most profound refresh possible and can lead to redecompilation of the - current function. Please consider using refresh_ctext() if you need a more - superficial refresh. - - @param redo_mba: (C++: bool) true means to redecompile the current function - false means to rebuild ctree without regenerating microcode - @see: refresh_ctext() - -ida_hexrays.vdui_t.rename_global (method) - rename_global(self, ea) -> bool - Rename global item. This function displays a dialog box and allows the user to - rename a global item (data or function). - - @param ea: (C++: ea_t) address of the global item - @return: false if failed or cancelled - -ida_hexrays.vdui_t.rename_label (method) - rename_label(self, label) -> bool - Rename a label. This function displays a dialog box and allows the user to - rename a statement label. - - @param label: (C++: int) label number - @return: false if failed or cancelled - -ida_hexrays.vdui_t.rename_lvar (method) - rename_lvar(self, v, name, is_user_name) -> bool - Rename local variable. This function permanently renames a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @param name: (C++: const char *) new variable name - @param is_user_name: (C++: bool) use true to save the new name into the database. use false - to delete the saved name. - @see: ::rename_lvar() - @return: false if failed - -ida_hexrays.vdui_t.rename_strmem (method) - rename_strmem(self, sptr, mptr) -> bool - Rename structure field. This function displays a dialog box and allows the user - to rename a structure field. - - @param sptr: (C++: struc_t *) pointer to structure - @param mptr: (C++: member_t *) pointer to structure member OBSOLETE FUNCTION, do not use! - @return: false if failed or cancelled - -ida_hexrays.vdui_t.rename_udm (method) - rename_udm(self, udt_type, udm_idx) -> bool - Rename structure field. This function displays a dialog box and allows the user - to rename a structure field. - - @param udt_type: (C++: tinfo_t &) structure/union type - @param udm_idx: (C++: int) index of the structure/union member - @return: false if failed or cancelled - -ida_hexrays.vdui_t.set_global_type (method) - set_global_type(self, ea) -> bool - Set global item type. This function displays a dialog box and allows the user to - change the type of a global item (data or function). - - @param ea: (C++: ea_t) address of the global item - @return: false if failed or cancelled - -ida_hexrays.vdui_t.set_locked (method) - set_locked(self, v) -> bool - - @param v: bool - -ida_hexrays.vdui_t.set_lvar_cmt (method) - set_lvar_cmt(self, v, cmt) -> bool - Set local variable comment. This function permanently sets a variable comment. - - @param v: (C++: lvar_t *) pointer to local variable - @param cmt: (C++: const char *) new comment - @return: false if failed - -ida_hexrays.vdui_t.set_lvar_type (method) - set_lvar_type(self, v, type) -> bool - Set local variable type. This function permanently sets a local variable type - and clears NOPTR flag if it was set before by function 'set_noptr_lvar' - - @param v: (C++: lvar_t *) pointer to local variable - @param type: (C++: const tinfo_t &) new variable type - @return: false if failed - -ida_hexrays.vdui_t.set_noptr_lvar (method) - set_noptr_lvar(self, v) -> bool - Inform that local variable should have a non-pointer type This function - permanently sets a corresponding variable flag (NOPTR) and removes type if it - was set before by function 'set_lvar_type' - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed - -ida_hexrays.vdui_t.set_num_enum (method) - set_num_enum(self) -> bool - Convert number to symbolic constant. This function displays a dialog box and - allows the user to select a symbolic constant to represent the number. - - @return: false if failed or cancelled - -ida_hexrays.vdui_t.set_num_radix (method) - set_num_radix(self, base) -> bool - Change number base. This function changes the current number representation. - - @param base: (C++: int) number radix (10 or 16) - 0 means a character constant - @return: false if failed - -ida_hexrays.vdui_t.set_num_stroff (method) - set_num_stroff(self) -> bool - Convert number to structure field offset. Currently not implemented. - - @return: false if failed or cancelled - -ida_hexrays.vdui_t.set_strmem_type (method) - set_strmem_type(self, sptr, mptr) -> bool - Set structure field type. This function displays a dialog box and allows the - user to change the type of a structure field. - - @param sptr: (C++: struc_t *) pointer to structure - @param mptr: (C++: member_t *) pointer to structure member OBSOLETE FUNCTION, do not use! - @return: false if failed or cancelled - -ida_hexrays.vdui_t.set_udm_type (method) - set_udm_type(self, udt_type, udm_idx) -> bool - Set structure field type. This function displays a dialog box and allows the - user to change the type of a structure field. - - @param udt_type: (C++: tinfo_t &) structure/union type - @param udm_idx: (C++: int) index of the structure/union member - @return: false if failed or cancelled - -ida_hexrays.vdui_t.set_valid (method) - set_valid(self, v) - - @param v: bool - -ida_hexrays.vdui_t.set_visible (method) - set_visible(self, v) - - @param v: bool - -ida_hexrays.vdui_t.split_item (method) - split_item(self, split) -> bool - Split/unsplit item. This function splits the current assignment expression. - - @param split: (C++: bool) - @return: false if failed. - -ida_hexrays.vdui_t.switch_to (method) - switch_to(self, f, activate) - Display the specified pseudocode. This function replaces the pseudocode window - contents with the specified cfunc_t. - - @param f: (C++: cfuncptr_t) pointer to the function to display. - @param activate: (C++: bool) should the pseudocode window get focus? - -ida_hexrays.vdui_t.tail (variable) - Tail ctree item on the current line (for indented comments) - -ida_hexrays.vdui_t.ui_edit_lvar_cmt (method) - ui_edit_lvar_cmt(self, v) -> bool - Set local variable comment. This function displays a dialog box and allows the - user to edit the comment of a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled - -ida_hexrays.vdui_t.ui_map_lvar (method) - ui_map_lvar(self, v) -> bool - Map a local variable to another. This function displays a variable list and - allows the user to select mapping. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled - -ida_hexrays.vdui_t.ui_rename_lvar (method) - ui_rename_lvar(self, v) -> bool - Rename local variable. This function displays a dialog box and allows the user - to rename a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled - -ida_hexrays.vdui_t.ui_set_call_type (method) - ui_set_call_type(self, e) -> bool - Set type of a function call This function displays a dialog box and allows the - user to change the type of a function call - - @param e: (C++: const cexpr_t *) pointer to call expression - @return: false if failed or cancelled - -ida_hexrays.vdui_t.ui_set_lvar_type (method) - ui_set_lvar_type(self, v) -> bool - Set local variable type. This function displays a dialog box and allows the user - to change the type of a local variable. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled - -ida_hexrays.vdui_t.ui_unmap_lvar (method) - ui_unmap_lvar(self, v) -> bool - Unmap a local variable. This function displays list of variables mapped to the - specified variable and allows the user to select a variable to unmap. - - @param v: (C++: lvar_t *) pointer to local variable - @return: false if failed or cancelled - -ida_hexrays.vdui_t.valid (method) - valid(self) -> bool - Does the pseudocode window contain valid code? It can become invalid if the - function type gets changed in IDA. - -ida_hexrays.vdui_t.view_idx (variable) - pseudocode window index (0..) - -ida_hexrays.vdui_t.visible (method) - visible(self) -> bool - Is the pseudocode window visible? if not, it might be invisible or destroyed - -ida_hexrays.vivl_t (class) - Proxy of C++ vivl_t class. - -ida_hexrays.vivl_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: vivl_t const & - - __eq__(self, mop) -> bool - - @param mop: mop_t const & - -ida_hexrays.vivl_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: vivl_t const & - -ida_hexrays.vivl_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: vivl_t const & - -ida_hexrays.vivl_t.__init__ (method) - __init__(self, _type=mop_z, _off=-1, _size=0) -> vivl_t - - @param _type: mopt_t - @param _off: sval_t - @param _size: int - - __init__(self, ch) -> vivl_t - - @param ch: chain_t const & - - __init__(self, op) -> vivl_t - - @param op: mop_t const & - -ida_hexrays.vivl_t.__le__ (method) - __le__(self, r) -> bool - - @param r: vivl_t const & - -ida_hexrays.vivl_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: vivl_t const & - -ida_hexrays.vivl_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: vivl_t const & - -ida_hexrays.vivl_t._print (method) - _print(self) - -ida_hexrays.vivl_t.compare (method) - compare(self, r) -> int - - @param r: vivl_t const & - -ida_hexrays.vivl_t.contains (method) - contains(self, voff2) -> bool - Does our value interval contain the specified value offset? - - @param voff2: (C++: const voff_t &) voff_t const & - -ida_hexrays.vivl_t.dstr (method) - dstr(self) -> char const * - -ida_hexrays.vivl_t.extend_to_cover (method) - extend_to_cover(self, r) -> bool - Extend a value interval using another value interval of the same type - - @param r: (C++: const vivl_t &) vivl_t const & - @return: success - -ida_hexrays.vivl_t.includes (method) - includes(self, r) -> bool - Does our value interval include another? - - @param r: (C++: const vivl_t &) vivl_t const & - -ida_hexrays.vivl_t.intersect (method) - intersect(self, r) -> uval_t - Intersect value intervals the same type - - @param r: (C++: const vivl_t &) vivl_t const & - @return: size of the resulting intersection - -ida_hexrays.vivl_t.overlap (method) - overlap(self, r) -> bool - Do two value intervals overlap? - - @param r: (C++: const vivl_t &) vivl_t const & - -ida_hexrays.vivl_t.set (method) - set(self, _type, _off, _size=0) - - @param _type: mopt_t - @param _off: sval_t - @param _size: int - - set(self, voff, _size) - - @param voff: voff_t const & - @param _size: int - -ida_hexrays.vivl_t.set_reg (method) - set_reg(self, mreg, sz=0) - - @param mreg: mreg_t - @param sz: int - -ida_hexrays.vivl_t.set_stkoff (method) - set_stkoff(self, stkoff, sz=0) - - @param stkoff: sval_t - @param sz: int - -ida_hexrays.vivl_t.size (variable) - Interval size in bytes. - -ida_hexrays.voff_t (class) - Proxy of C++ voff_t class. - -ida_hexrays.voff_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: voff_t const & - -ida_hexrays.voff_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: voff_t const & - -ida_hexrays.voff_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: voff_t const & - -ida_hexrays.voff_t.__init__ (method) - __init__(self) -> voff_t - __init__(self, _type, _off) -> voff_t - - @param _type: mopt_t - @param _off: sval_t - - __init__(self, op) -> voff_t - - @param op: mop_t const & - -ida_hexrays.voff_t.__le__ (method) - __le__(self, r) -> bool - - @param r: voff_t const & - -ida_hexrays.voff_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: voff_t const & - -ida_hexrays.voff_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: voff_t const & - -ida_hexrays.voff_t.add (method) - add(self, width) -> voff_t - - @param width: int - -ida_hexrays.voff_t.compare (method) - compare(self, r) -> int - - @param r: voff_t const & - -ida_hexrays.voff_t.defined (method) - defined(self) -> bool - -ida_hexrays.voff_t.diff (method) - diff(self, r) -> sval_t - - @param r: voff_t const & - -ida_hexrays.voff_t.get_reg (method) - get_reg(self) -> mreg_t - -ida_hexrays.voff_t.get_stkoff (method) - get_stkoff(self) -> sval_t - -ida_hexrays.voff_t.inc (method) - inc(self, delta) - - @param delta: sval_t - -ida_hexrays.voff_t.is_reg (method) - is_reg(self) -> bool - -ida_hexrays.voff_t.is_stkoff (method) - is_stkoff(self) -> bool - -ida_hexrays.voff_t.off (variable) - register number or stack offset - -ida_hexrays.voff_t.set (method) - set(self, _type, _off) - - @param _type: mopt_t - @param _off: sval_t - -ida_hexrays.voff_t.set_reg (method) - set_reg(self, mreg) - - @param mreg: mreg_t - -ida_hexrays.voff_t.set_stkoff (method) - set_stkoff(self, stkoff) - - @param stkoff: sval_t - -ida_hexrays.voff_t.type (variable) - mop_r - register, mop_S - stack, mop_z - undefined - -ida_hexrays.voff_t.undef (method) - undef(self) - -ida_allins (module) - - -ida_auto (module) - Functions that work with the autoanalyzer queue. - - The autoanalyzer works when IDA is not busy processing the user keystrokes. It - has several queues, each queue having its own priority. The analyzer stops when - all queues are empty. - - A queue contains addresses or address ranges. The addresses are kept sorted by - their values. The analyzer will process all addresses from the first queue, then - switch to the second queue and so on. There are no limitations on the size of - the queues. - - This file also contains functions that deal with the IDA status indicator and - the autoanalysis indicator. You may use these functions to change the indicator - value. - -ida_auto.AU_CHLB (variable) - 12: load signature file (file name is kept separately) - -ida_auto.AU_CODE (variable) - 1: convert to instruction - -ida_auto.AU_FCHUNK (variable) - 5: find func chunks - -ida_auto.AU_FINAL (variable) - 13: final pass - -ida_auto.AU_LBF2 (variable) - 10: the same, second pass - -ida_auto.AU_LBF3 (variable) - 11: the same, third pass - -ida_auto.AU_LIBF (variable) - 9: apply signature to address - -ida_auto.AU_NONE (variable) - placeholder, not used - -ida_auto.AU_PROC (variable) - 3: convert to procedure start - -ida_auto.AU_TAIL (variable) - 4: add a procedure tail - -ida_auto.AU_TYPE (variable) - 8: apply type information - -ida_auto.AU_UNK (variable) - 0: convert to unexplored - -ida_auto.AU_USD2 (variable) - 7: reanalyze, second pass - -ida_auto.AU_USED (variable) - 6: reanalyze - -ida_auto.AU_WEAK (variable) - 2: convert to instruction (ida decision) - -ida_auto.auto_apply_tail (function) - auto_apply_tail(tail_ea, parent_ea) - Plan to apply the tail_ea chunk to the parent - - @param tail_ea: (C++: ea_t) linear address of start of tail - @param parent_ea: (C++: ea_t) linear address within parent. If BADADDR, automatically try to - find parent via xrefs. - -ida_auto.auto_apply_type (function) - auto_apply_type(caller, callee) - Plan to apply the callee's type to the calling point. - - @param caller: (C++: ea_t) - @param callee: (C++: ea_t) - -ida_auto.auto_cancel (function) - auto_cancel(ea1, ea2) - Remove an address range (ea1..ea2) from queues AU_CODE, AU_PROC, AU_USED. To - remove an address range from other queues use auto_unmark() function. 'ea1' may - be higher than 'ea2', the kernel will swap them in this case. 'ea2' doesn't - belong to the range. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - -ida_auto.auto_display_t (class) - Proxy of C++ auto_display_t class. - -ida_auto.auto_display_t.__init__ (method) - __init__(self) -> auto_display_t - -ida_auto.auto_get (function) - auto_get(type, lowEA, highEA) -> ea_t - Retrieve an address from queues regarding their priority. Returns BADADDR if no - addresses not lower than 'lowEA' and less than 'highEA' are found in the queues. - Otherwise *type will have queue type. - - @param type: (C++: atype_t *) - @param lowEA: (C++: ea_t) - @param highEA: (C++: ea_t) - -ida_auto.auto_is_ok (function) - auto_is_ok() -> bool - Are all queues empty? (i.e. has autoanalysis finished?). - -ida_auto.auto_make_code (function) - auto_make_code(ea) - Plan to make code. - - @param ea: (C++: ea_t) - -ida_auto.auto_make_proc (function) - auto_make_proc(ea) - Plan to make code&function. - - @param ea: (C++: ea_t) - -ida_auto.auto_make_step (function) - auto_make_step(ea1, ea2) -> bool - Analyze one address in the specified range and return true. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - @return: if processed anything. false means that there is nothing to process in - the specified range. - -ida_auto.auto_mark (function) - auto_mark(ea, type) - Put single address into a queue. Queues keep addresses sorted. - - @param ea: (C++: ea_t) - @param type: (C++: atype_t) - -ida_auto.auto_mark_range (function) - auto_mark_range(start, end, type) - Put range of addresses into a queue. 'start' may be higher than 'end', the - kernel will swap them in this case. 'end' doesn't belong to the range. - - @param start: (C++: ea_t) - @param end: (C++: ea_t) - @param type: (C++: atype_t) - -ida_auto.auto_postpone_analysis (function) - auto_postpone_analysis(ea) -> bool - Plan to reanalyze on the second pass The typical usage of this function in - emu.cpp is: if ( !auto_postpone_analysis(ea) ) op_offset(ea, 0, ...); (we make - an offset only on the second pass) - - @param ea: (C++: ea_t) - -ida_auto.auto_recreate_insn (function) - auto_recreate_insn(ea) -> int - Try to create instruction - - @param ea: (C++: ea_t) linear address of callee - @return: the length of the instruction or 0 - -ida_auto.auto_unmark (function) - auto_unmark(start, end, type) - Remove range of addresses from a queue. 'start' may be higher than 'end', the - kernel will swap them in this case. 'end' doesn't belong to the range. - - @param start: (C++: ea_t) - @param end: (C++: ea_t) - @param type: (C++: atype_t) - -ida_auto.auto_wait (function) - auto_wait() -> bool - Process everything in the queues and return true. - - @return: false if the user clicked cancel. (the wait box must be displayed by - the caller if desired) - -ida_auto.auto_wait_range (function) - auto_wait_range(ea1, ea2) -> ssize_t - Process everything in the specified range and return true. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - @return: number of autoanalysis steps made. -1 if the user clicked cancel. (the - wait box must be displayed by the caller if desired) - -ida_auto.enable_auto (function) - enable_auto(enable) -> bool - Temporarily enable/disable autoanalyzer. Not user-facing, but rather because IDA - sometimes need to turn AA on/off regardless of inf.s_genflags:INFFL_AUTO - - @param enable: (C++: bool) - @return: old state - -ida_auto.get_auto_display (function) - get_auto_display(auto_display) -> bool - Get structure which holds the autoanalysis indicator contents. - - @param auto_display: (C++: auto_display_t *) - -ida_auto.get_auto_state (function) - get_auto_state() -> atype_t - Get current state of autoanalyzer. If auto_state == AU_NONE, IDA is currently - not running the analysis (it could be temporarily interrupted to perform the - user's requests, for example). - -ida_auto.is_auto_enabled (function) - is_auto_enabled() -> bool - Get autoanalyzer state. - -ida_auto.may_create_stkvars (function) - may_create_stkvars() -> bool - Is it allowed to create stack variables automatically?. This function should be - used by IDP modules before creating stack vars. - -ida_auto.may_trace_sp (function) - may_trace_sp() -> bool - Is it allowed to trace stack pointer automatically?. This function should be - used by IDP modules before tracing sp. - -ida_auto.peek_auto_queue (function) - peek_auto_queue(low_ea, type) -> ea_t - Peek into a queue 'type' for an address not lower than 'low_ea'. Do not remove - address from the queue. - - @param low_ea: (C++: ea_t) - @param type: (C++: atype_t) - @return: the address or BADADDR - -ida_auto.plan_and_wait (function) - plan_and_wait(ea1, ea2, final_pass=True) -> int - Analyze the specified range. Try to create instructions where possible. Make the - final pass over the specified range if specified. This function doesn't return - until the range is analyzed. - @retval 1: ok - @retval 0: Ctrl-Break was pressed - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - @param final_pass: (C++: bool) - -ida_auto.plan_ea (function) - plan_ea(ea) - Plan to perform reanalysis. - - @param ea: (C++: ea_t) - -ida_auto.plan_range (function) - plan_range(sEA, eEA) - Plan to perform reanalysis. - - @param sEA: (C++: ea_t) - @param eEA: (C++: ea_t) - -ida_auto.reanalyze_callers (function) - reanalyze_callers(ea, noret) - Plan to reanalyze callers of the specified address. This function will add to - AU_USED queue all instructions that call (not jump to) the specified address. - - @param ea: (C++: ea_t) linear address of callee - @param noret: (C++: bool) !=0: the callee doesn't return, mark to undefine subsequent - instructions in the caller. 0: do nothing. - -ida_auto.revert_ida_decisions (function) - revert_ida_decisions(ea1, ea2) - Delete all analysis info that IDA generated for for the given range. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - -ida_auto.set_auto_state (function) - set_auto_state(new_state) -> atype_t - Set current state of autoanalyzer. - - @param new_state: (C++: atype_t) new state of autoanalyzer - @return: previous state - -ida_auto.set_ida_state (function) - set_ida_state(st) -> idastate_t - Change IDA status indicator value - - @param st: (C++: idastate_t) - new indicator status - @return: old indicator status - -ida_auto.show_addr (function) - show_addr(ea) - Show an address on the autoanalysis indicator. The address is displayed in the - form " @:12345678". - - @param ea: (C++: ea_t) - linear address to display - -ida_auto.show_auto (function) - show_auto(ea, type=AU_NONE) - Change autoanalysis indicator value. - - @param ea: (C++: ea_t) linear address being analyzed - @param type: (C++: atype_t) autoanalysis type (see Autoanalysis queues) - -ida_bitrange (module) - Definition of the bitrange_t class. - -ida_bitrange.bitrange_t (class) - Proxy of C++ bitrange_t class. - -ida_bitrange.bitrange_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bitrange_t const & - -ida_bitrange.bitrange_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bitrange_t const & - -ida_bitrange.bitrange_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bitrange_t const & - -ida_bitrange.bitrange_t.__init__ (method) - __init__(self, bit_ofs=0, size_in_bits=0) -> bitrange_t - - @param bit_ofs: uint16 - @param size_in_bits: uint16 - -ida_bitrange.bitrange_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bitrange_t const & - -ida_bitrange.bitrange_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bitrange_t const & - -ida_bitrange.bitrange_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bitrange_t const & - -ida_bitrange.bitrange_t.__str__ (method) - __str__(self) -> qstring - -ida_bitrange.bitrange_t.apply_mask (method) - apply_mask(self, subrange) -> bool - Apply mask to a bitrange - - @param subrange: (C++: const bitrange_t &) range *inside* the main bitrange to keep After this operation - the main bitrange will be truncated to have only the bits that - are specified by subrange. Example: [off=8,nbits=4], - subrange[off=1,nbits=2] => [off=9,nbits=2] - @return: success - -ida_bitrange.bitrange_t.bitoff (method) - bitoff(self) -> uint - Get offset of 1st bit. - -ida_bitrange.bitrange_t.bitsize (method) - bitsize(self) -> uint - Get size of the value in bits. - -ida_bitrange.bitrange_t.bytesize (method) - bytesize(self) -> uint - Size of the value in bytes. - -ida_bitrange.bitrange_t.compare (method) - compare(self, r) -> int - - @param r: bitrange_t const & - -ida_bitrange.bitrange_t.create_union (method) - create_union(self, r) - Create union of 2 ranges including the hole between them. - - @param r: (C++: const bitrange_t &) bitrange_t const & - -ida_bitrange.bitrange_t.empty (method) - empty(self) -> bool - Is the bitrange empty? - -ida_bitrange.bitrange_t.extract (method) - extract(self, src, is_mf) -> bool - - @param src: void const * - @param is_mf: bool - -ida_bitrange.bitrange_t.has_common (method) - has_common(self, r) -> bool - Does have common bits with another bitrange? - - @param r: (C++: const bitrange_t &) bitrange_t const & - -ida_bitrange.bitrange_t.init (method) - init(self, bit_ofs, size_in_bits) - Initialize offset and size to given values. - - @param bit_ofs: (C++: uint16) - @param size_in_bits: (C++: uint16) - -ida_bitrange.bitrange_t.inject (method) - inject(self, dst, src, is_mf) -> bool - - @param dst: void * - @param src: bytevec_t const & - @param is_mf: bool - -ida_bitrange.bitrange_t.intersect (method) - intersect(self, r) - Intersect two ranges. - - @param r: (C++: const bitrange_t &) bitrange_t const & - -ida_bitrange.bitrange_t.mask64 (method) - mask64(self) -> uint64 - Convert to mask of 64 bits. - -ida_bitrange.bitrange_t.reset (method) - reset(self) - Make the bitrange empty. - -ida_bitrange.bitrange_t.shift_down (method) - shift_down(self, cnt) - Shift range down (left) - - @param cnt: (C++: uint) - -ida_bitrange.bitrange_t.shift_up (method) - shift_up(self, cnt) - Shift range up (right) - - @param cnt: (C++: uint) - -ida_bitrange.bitrange_t.sub (method) - sub(self, r) -> bool - Subtract a bitrange. - - @param r: (C++: const bitrange_t &) bitrange_t const & - -ida_bytes (module) - Contains functions that deal with individual byte characteristics. - - Each byte of the disassembled program is represented by a 32-bit value. We will - call this value 'flags'. The structure of the flags is here. - - You are not allowed to inspect individual bits of flags and modify them - directly. Use special functions to inspect and/or modify flags. - - Flags are kept in a virtual array file (*.id1). Addresses (ea) are all 32-bit - (or 64-bit) quantities. - -ida_bytes.ALOPT_APPEND (variable) - if an existing strlit is encountered, then append it to the string. - -ida_bytes.ALOPT_IGNCLT (variable) - if set, don't stop at codepoints that are not part of the current 'culture'; - accept all those that are graphical (this is typically used used by user- - initiated actions creating string literals.) - -ida_bytes.ALOPT_IGNHEADS (variable) - don't stop if another data item is encountered. only the byte values will be - used to determine the string length. if not set, a defined data item or - instruction will truncate the string - -ida_bytes.ALOPT_IGNPRINT (variable) - if set, don't stop at non-printable codepoints, but only at the terminating - character (or not unicode-mapped character (e.g., 0x8f in CP1252)) - -ida_bytes.ALOPT_MAX4K (variable) - if string length is more than 4K, return the accumulated length - -ida_bytes.ALOPT_ONLYTERM (variable) - only the termination characters can be at the string end. Without this option - illegal characters also terminate the string. - -ida_bytes.BIN_SEARCH_BACKWARD (variable) - search backward for bytes - -ida_bytes.BIN_SEARCH_BITMASK (variable) - searching using strict bit mask - -ida_bytes.BIN_SEARCH_CASE (variable) - case sensitive - -ida_bytes.BIN_SEARCH_FORWARD (variable) - search forward for bytes - -ida_bytes.BIN_SEARCH_INITED (variable) - find_byte, find_byter: any initilized value - -ida_bytes.BIN_SEARCH_NOBREAK (variable) - don't check for Ctrl-Break - -ida_bytes.BIN_SEARCH_NOCASE (variable) - case insensitive - -ida_bytes.BIN_SEARCH_NOSHOW (variable) - don't show search progress or update screen - -ida_bytes.DELIT_DELNAMES (variable) - delete any names at the specified address range (except for the starting - address). this bit is valid if nbytes > 1 - -ida_bytes.DELIT_EXPAND (variable) - propagate undefined items; for example if removing an instruction removes all - references to the next instruction, then plan to convert to unexplored the next - instruction too. - -ida_bytes.DELIT_KEEPFUNC (variable) - do not undefine the function start. Just delete xrefs, ops e.t.c. - -ida_bytes.DELIT_NOCMT (variable) - reject to delete if a comment is in address range (except for the starting - address). this bit is valid if nbytes > 1 - -ida_bytes.DELIT_NOTRUNC (variable) - don't truncate the current function even if AF_TRFUNC is set - -ida_bytes.DELIT_NOUNAME (variable) - reject to delete if a user name is in address range (except for the starting - address). this bit is valid if nbytes > 1 - -ida_bytes.DELIT_SIMPLE (variable) - simply undefine the specified item(s) - -ida_bytes.DTP_NODUP (variable) - do not use dup construct - -ida_bytes.DT_TYPE (variable) - Mask for DATA typing. - -ida_bytes.FF_ALIGN (variable) - alignment directive - -ida_bytes.FF_BNOT (variable) - Bitwise negation of operands. - -ida_bytes.FF_BYTE (variable) - byte - -ida_bytes.FF_CODE (variable) - Code ? - -ida_bytes.FF_COMM (variable) - Has comment ? - -ida_bytes.FF_CUSTOM (variable) - custom data type - -ida_bytes.FF_DATA (variable) - Data ? - -ida_bytes.FF_DOUBLE (variable) - double - -ida_bytes.FF_DWORD (variable) - double word - -ida_bytes.FF_FLOAT (variable) - float - -ida_bytes.FF_FLOW (variable) - Exec flow from prev instruction. - -ida_bytes.FF_FUNC (variable) - function start? - -ida_bytes.FF_IMMD (variable) - Has Immediate value ? - -ida_bytes.FF_IVL (variable) - Byte has value ? - -ida_bytes.FF_JUMP (variable) - Has jump table or switch_info? - -ida_bytes.FF_LABL (variable) - Has dummy name? - -ida_bytes.FF_LINE (variable) - Has next or prev lines ? - -ida_bytes.FF_NAME (variable) - Has name ? - -ida_bytes.FF_N_CHAR (variable) - Char ('x')? - -ida_bytes.FF_N_CUST (variable) - Custom representation? - -ida_bytes.FF_N_ENUM (variable) - Enumeration? - -ida_bytes.FF_N_FLT (variable) - Floating point number? - -ida_bytes.FF_N_FOP (variable) - Forced operand? - -ida_bytes.FF_N_NUMB (variable) - Binary number? - -ida_bytes.FF_N_NUMD (variable) - Decimal number? - -ida_bytes.FF_N_NUMH (variable) - Hexadecimal number? - -ida_bytes.FF_N_NUMO (variable) - Octal number? - -ida_bytes.FF_N_OFF (variable) - Offset? - -ida_bytes.FF_N_SEG (variable) - Segment? - -ida_bytes.FF_N_STK (variable) - Stack variable? - -ida_bytes.FF_N_STRO (variable) - Struct offset? - -ida_bytes.FF_N_VOID (variable) - Void (unknown)? - -ida_bytes.FF_OWORD (variable) - octaword/xmm word (16 bytes/128 bits) - -ida_bytes.FF_PACKREAL (variable) - packed decimal real - -ida_bytes.FF_QWORD (variable) - quadro word - -ida_bytes.FF_REF (variable) - has references - -ida_bytes.FF_SIGN (variable) - Inverted sign of operands. - -ida_bytes.FF_STRLIT (variable) - string literal - -ida_bytes.FF_STRUCT (variable) - struct variable - -ida_bytes.FF_TAIL (variable) - Tail ? - -ida_bytes.FF_TBYTE (variable) - tbyte - -ida_bytes.FF_UNK (variable) - Unknown ? - -ida_bytes.FF_UNUSED (variable) - unused bit (was used for variable bytes) - -ida_bytes.FF_WORD (variable) - word - -ida_bytes.FF_YWORD (variable) - ymm word (32 bytes/256 bits) - -ida_bytes.FF_ZWORD (variable) - zmm word (64 bytes/512 bits) - -ida_bytes.GFE_IDB_VALUE (variable) - get flags with FF_IVL & MS_VAL. but never use the debugger memory. - -ida_bytes.GFE_VALUE (variable) - get flags with FF_IVL & MS_VAL. It is much slower under remote debugging because - the kernel needs to read the process memory. - -ida_bytes.GMB_READALL (variable) - try to read all bytes; if this bit is not set, fail at first uninited byte - -ida_bytes.GMB_WAITBOX (variable) - show wait box (may return -1 in this case) - -ida_bytes.ITEM_END_CANCEL (variable) - stop when operation cancelled, it is the responsibility of the caller to show - the wait dialog - -ida_bytes.ITEM_END_FIXUP (variable) - stop at the first fixup - -ida_bytes.ITEM_END_INITED (variable) - stop when initialization changes i.e. - * if is_loaded(ea): stop if uninitialized byte is encountered - * if !is_loaded(ea): stop if initialized byte is encountered - -ida_bytes.ITEM_END_NAME (variable) - stop at the first named location - -ida_bytes.ITEM_END_XREF (variable) - stop at the first referenced location - -ida_bytes.MS_CLS (variable) - Mask for typing. - -ida_bytes.MS_CODE (variable) - Mask for code bits. - -ida_bytes.MS_COMM (variable) - Mask of common bits. - -ida_bytes.MS_N_TYPE (variable) - Mask for nth arg (a 64-bit constant) - -ida_bytes.MS_VAL (variable) - Mask for byte value. - -ida_bytes.OPND_ALL (variable) - all operands - -ida_bytes.OPND_MASK (variable) - mask for operand number - -ida_bytes.OPND_OUTER (variable) - outer offset base (combined with operand number). used only in set, get, - del_offset() functions - -ida_bytes.PSTF_ATTRIB (variable) - generate for type attribute usage - -ida_bytes.PSTF_ENC (variable) - if encoding is specified, append it - -ida_bytes.PSTF_HOTKEY (variable) - have hotkey markers part of the name - -ida_bytes.PSTF_ONLY_ENC (variable) - generate only the encoding name - -ida_bytes.PSTF_TBRIEF (variable) - use brief name (e.g., in the 'Strings' window) - -ida_bytes.PSTF_TINLIN (variable) - use 'inline' name (e.g., in the structures comments) - -ida_bytes.PSTF_TMASK (variable) - type mask - -ida_bytes.PSTF_TNORM (variable) - use normal name - -ida_bytes.STRCONV_ESCAPE (variable) - convert non-printable characters to C escapes ( - , \xNN, \uNNNN) - -ida_bytes.STRCONV_INCLLEN (variable) - for Pascal-style strings, include the prefixing length byte(s) as C-escaped - sequence - -ida_bytes.STRCONV_REPLCHAR (variable) - convert non-printable characters to the Unicode replacement character (U+FFFD) - -ida_bytes.__walk_types_and_formats (function) - -ida_bytes.add_byte (function) - add_byte(ea, value) - Add a value to one byte of the program. This function works for wide byte - processors too. - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint32) byte value - -ida_bytes.add_dword (function) - add_dword(ea, value) - Add a value to one dword of the program. This function works for wide byte - processors too. This function takes into account order of bytes specified in - idainfo::is_be() - @note: this function works incorrectly if processor_t::nbits > 16 - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint64) byte value - -ida_bytes.add_hidden_range (function) - add_hidden_range(ea1, ea2, description, header, footer, color=bgcolor_t(-1)) -> bool - Mark a range of addresses as hidden. The range will be created in the invisible - state with the default color - - @param ea1: (C++: ea_t) linear address of start of the address range - @param ea2: (C++: ea_t) linear address of end of the address range - @param description: (C++: const char *) ,header,footer: range parameters - @param header: (C++: const char *) char const * - @param footer: (C++: const char *) char const * - @param color: (C++: bgcolor_t) the range color - @return: success - -ida_bytes.add_mapping (function) - add_mapping(_from, to, size) -> bool - IDA supports memory mapping. References to the addresses from the mapped range - use data and meta-data from the mapping range. - @note: You should set flag PR2_MAPPING in ph.flag2 to use memory mapping Add - memory mapping range. - - @param from: (C++: ea_t) start of the mapped range (nonexistent address) - @param to: (C++: ea_t) start of the mapping range (existent address) - @param size: (C++: asize_t) size of the range - @return: success - -ida_bytes.add_qword (function) - add_qword(ea, value) - Add a value to one qword of the program. This function does not work for wide - byte processors. This function takes into account order of bytes specified in - idainfo::is_be() - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint64) byte value - -ida_bytes.add_word (function) - add_word(ea, value) - Add a value to one word of the program. This function works for wide byte - processors too. This function takes into account order of bytes specified in - idainfo::is_be() - - @param ea: (C++: ea_t) linear address - @param value: (C++: uint64) byte value - -ida_bytes.align_flag (function) - align_flag() -> flags64_t - Get a flags64_t representing an alignment directive. - -ida_bytes.append_cmt (function) - append_cmt(ea, str, rptble) -> bool - Append to an indented comment. Creates a new comment if none exists. Appends a - newline character and the specified string otherwise. - - @param ea: (C++: ea_t) linear address - @param str: (C++: const char *) comment string to append - @param rptble: (C++: bool) append to repeatable comment? - @return: success - -ida_bytes.attach_custom_data_format (function) - attach_custom_data_format(dtid, dfid) -> bool - Attach the data format to the data type. - - @param dtid: (C++: int) data type id that can use the data format. 0 means all standard - data types. Such data formats can be applied to any data item or - instruction operands. For instruction operands, the - data_format_t::value_size check is not performed by the kernel. - @param dfid: (C++: int) data format id - @retval true: ok - @retval false: no such `dtid', or no such `dfid', or the data format has already - been attached to the data type - -ida_bytes.bin_flag (function) - bin_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() - -ida_bytes.bin_search (function) - bin_search(start_ea, end_ea, data, flags) -> ea_t - Search for a set of bytes in the program - - @param start_ea: linear address, start of range to search - @param end_ea: linear address, end of range to search (exclusive) - @param data: the prepared data to search for (see parse_binpat_str()) - @param flags: combination of BIN_SEARCH_* flags - @return: the address of a match, or ida_idaapi.BADADDR if not found - bin_search(start_ea, end_ea, image, imask, step, flags) -> ea_t - - @param start_ea: ea_t - @param end_ea: ea_t - @param image: bytevec_t const & - @param imask: bytevec_t const & - @param step: int - @param flags: int - -ida_bytes.bin_search3 (function) - bin_search3(start_ea, end_ea, data, flags) -> ea_t - Search for a patter in the program. - - @param start_ea: (C++: ea_t) linear address, start of range to search - @param end_ea: (C++: ea_t) linear address, end of range to search (exclusive) - @param data: (C++: const compiled_binpat_vec_t &) the prepared data to search for (see parse_binpat_str()) - @param flags: (C++: int) combination of Search flags - @return: BADADDR (if pressed Ctrl-Break or not found) or pattern address. - -ida_bytes.byte_flag (function) - byte_flag() -> flags64_t - Get a flags64_t representing a byte. - -ida_bytes.bytesize (function) - bytesize(ea) -> int - Get number of bytes required to store a byte at the given address. - - @param ea: (C++: ea_t) - -ida_bytes.calc_def_align (function) - calc_def_align(ea, mina, maxa) -> int - Calculate the default alignment exponent. - - @param ea: (C++: ea_t) linear address - @param mina: (C++: int) minimal possible alignment exponent. - @param maxa: (C++: int) minimal possible alignment exponent. - -ida_bytes.calc_dflags (function) - calc_dflags(f, force) -> flags64_t - - @param f: flags64_t - @param force: bool - -ida_bytes.calc_max_align (function) - calc_max_align(endea) -> int - Calculate the maximal possible alignment exponent. - - @param endea: (C++: ea_t) end address of the alignment item. - @return: a value in the 0..32 range - -ida_bytes.calc_max_item_end (function) - calc_max_item_end(ea, how=15) -> ea_t - Calculate maximal reasonable end address of a new item. This function will limit - the item with the current segment bounds. - - @param ea: (C++: ea_t) linear address - @param how: (C++: int) when to stop the search. A combination of Item end search flags - @return: end of new item. If it is not possible to create an item, it will - return 'ea'. If operation was cancelled by user, it will return 'ea' - -ida_bytes.calc_min_align (function) - calc_min_align(length) -> int - Calculate the minimal possible alignment exponent. - - @param length: (C++: asize_t) size of the item in bytes. - @return: a value in the 1..32 range - -ida_bytes.can_define_item (function) - can_define_item(ea, length, flags) -> bool - Can define item (instruction/data) of the specified 'length', starting at 'ea'? - @note: if there is an item starting at 'ea', this function ignores it - @note: this function converts to unexplored all encountered data items with - fixup information. Should be fixed in the future. - - @param ea: (C++: ea_t) start of the range for the new item - @param length: (C++: asize_t) length of the new item in bytes - @param flags: (C++: flags64_t) if not 0, then the kernel will ignore the data types specified by - the flags and destroy them. For example: - 1000 dw 5 - 1002 db 5 ; undef - 1003 db 5 ; undef - 1004 dw 5 - 1006 dd 5 - can_define_item(1000, 6, 0) - false because of dw at 1004 - can_define_item(1000, 6, word_flag()) - true, word at 1004 is destroyed - @return: 1-yes, 0-no - * a new item would cross segment boundaries - * a new item would overlap with existing items (except items specified by - 'flags') - -ida_bytes.change_storage_type (function) - change_storage_type(start_ea, end_ea, stt) -> error_t - Change flag storage type for address range. - - @param start_ea: (C++: ea_t) should be lower than end_ea. - @param end_ea: (C++: ea_t) does not belong to the range. - @param stt: (C++: storage_type_t) - @return: error code - -ida_bytes.char_flag (function) - char_flag() -> flags64_t - see FF_opbits - -ida_bytes.chunk_size (function) - chunk_size(ea) -> asize_t - Get size of the contiguous address block containing 'ea'. - - @param ea: (C++: ea_t) - @return: 0 if 'ea' doesn't belong to the program. - -ida_bytes.chunk_start (function) - chunk_start(ea) -> ea_t - Get start of the contiguous address block containing 'ea'. - - @param ea: (C++: ea_t) - @return: BADADDR if 'ea' doesn't belong to the program. - -ida_bytes.clr_lzero (function) - clr_lzero(ea, n) -> bool - Clear toggle lzero bit. This function reset the display of leading zeroes for - the specified operand to the default. If the default is not to display leading - zeroes, leading zeroes will not be displayed, as vice versa. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success - -ida_bytes.clr_op_type (function) - clr_op_type(ea, n) -> bool - Remove operand representation information. (set operand representation to be - 'undefined') - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @return: success - -ida_bytes.code_flag (function) - code_flag() -> flags64_t - FF_CODE - -ida_bytes.combine_flags (function) - combine_flags(F) -> flags64_t - - @param F: flags64_t - -ida_bytes.compiled_binpat_t (class) - Proxy of C++ compiled_binpat_t class. - -ida_bytes.compiled_binpat_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: compiled_binpat_t const & - -ida_bytes.compiled_binpat_t.__init__ (method) - __init__(self) -> compiled_binpat_t - -ida_bytes.compiled_binpat_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: compiled_binpat_t const & - -ida_bytes.compiled_binpat_t.all_bytes_defined (method) - all_bytes_defined(self) -> bool - -ida_bytes.compiled_binpat_t.qclear (method) - qclear(self) - -ida_bytes.compiled_binpat_vec_t (class) - Proxy of C++ qvector< compiled_binpat_t > class. - -ida_bytes.compiled_binpat_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< compiled_binpat_t > const & - -ida_bytes.compiled_binpat_vec_t.__getitem__ (method) - __getitem__(self, i) -> compiled_binpat_t - - @param i: size_t - -ida_bytes.compiled_binpat_vec_t.__init__ (method) - __init__(self) -> compiled_binpat_vec_t - __init__(self, x) -> compiled_binpat_vec_t - - @param x: qvector< compiled_binpat_t > const & - -ida_bytes.compiled_binpat_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_bytes.compiled_binpat_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< compiled_binpat_t > const & - -ida_bytes.compiled_binpat_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: compiled_binpat_t const & - -ida_bytes.compiled_binpat_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: compiled_binpat_t const & - -ida_bytes.compiled_binpat_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: compiled_binpat_t const & - -ida_bytes.compiled_binpat_vec_t.at (method) - at(self, _idx) -> compiled_binpat_t - - @param _idx: size_t - -ida_bytes.compiled_binpat_vec_t.begin (method) - begin(self) -> compiled_binpat_t - -ida_bytes.compiled_binpat_vec_t.capacity (method) - capacity(self) -> size_t - -ida_bytes.compiled_binpat_vec_t.clear (method) - clear(self) - -ida_bytes.compiled_binpat_vec_t.empty (method) - empty(self) -> bool - -ida_bytes.compiled_binpat_vec_t.end (method) - end(self) -> compiled_binpat_t - -ida_bytes.compiled_binpat_vec_t.erase (method) - erase(self, it) -> compiled_binpat_t - - @param it: qvector< compiled_binpat_t >::iterator - - erase(self, first, last) -> compiled_binpat_t - - @param first: qvector< compiled_binpat_t >::iterator - @param last: qvector< compiled_binpat_t >::iterator - -ida_bytes.compiled_binpat_vec_t.extract (method) - extract(self) -> compiled_binpat_t - -ida_bytes.compiled_binpat_vec_t.find (method) - find(self, x) -> compiled_binpat_t - - @param x: compiled_binpat_t const & - -ida_bytes.compiled_binpat_vec_t.grow (method) - grow(self, x=compiled_binpat_t()) - - @param x: compiled_binpat_t const & - -ida_bytes.compiled_binpat_vec_t.has (method) - has(self, x) -> bool - - @param x: compiled_binpat_t const & - -ida_bytes.compiled_binpat_vec_t.inject (method) - inject(self, s, len) - - @param s: compiled_binpat_t * - @param len: size_t - -ida_bytes.compiled_binpat_vec_t.insert (method) - insert(self, it, x) -> compiled_binpat_t - - @param it: qvector< compiled_binpat_t >::iterator - @param x: compiled_binpat_t const & - -ida_bytes.compiled_binpat_vec_t.pop_back (method) - pop_back(self) - -ida_bytes.compiled_binpat_vec_t.push_back (method) - push_back(self, x) - - @param x: compiled_binpat_t const & - - push_back(self) -> compiled_binpat_t - -ida_bytes.compiled_binpat_vec_t.qclear (method) - qclear(self) - -ida_bytes.compiled_binpat_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_bytes.compiled_binpat_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: compiled_binpat_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_bytes.compiled_binpat_vec_t.size (method) - size(self) -> size_t - -ida_bytes.compiled_binpat_vec_t.swap (method) - swap(self, r) - - @param r: qvector< compiled_binpat_t > & - -ida_bytes.compiled_binpat_vec_t.truncate (method) - truncate(self) - -ida_bytes.create_16bit_data (function) - create_16bit_data(ea, length) -> bool - Convert to 16-bit quantity (take the byte size into account) - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - -ida_bytes.create_32bit_data (function) - create_32bit_data(ea, length) -> bool - Convert to 32-bit quantity (take the byte size into account) - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - -ida_bytes.create_align (function) - create_align(ea, length, alignment) -> bool - Create an alignment item. - - @param ea: (C++: ea_t) linear address - @param length: (C++: asize_t) size of the item in bytes. 0 means to infer from ALIGNMENT - @param alignment: (C++: int) alignment exponent. Example: 3 means align to 8 bytes. 0 means - to infer from LENGTH It is forbidden to specify both LENGTH - and ALIGNMENT as 0. - @return: success - -ida_bytes.create_byte (function) - create_byte(ea, length, force=False) -> bool - Convert to byte. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_custdata (function) - create_custdata(ea, length, dtid, fid, force=False) -> bool - Convert to custom data type. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param dtid: (C++: int) - @param fid: (C++: int) - @param force: (C++: bool) - -ida_bytes.create_data (function) - create_data(ea, dataflag, size, tid) -> bool - Convert to data (byte, word, dword, etc). This function may be used to create - arrays. - - @param ea: (C++: ea_t) linear address - @param dataflag: (C++: flags64_t) type of data. Value of function byte_flag(), word_flag(), etc. - @param size: (C++: asize_t) size of array in bytes. should be divisible by the size of one item - of the specified type. for variable sized items it can be specified - as 0, and the kernel will try to calculate the size. - @param tid: (C++: tid_t) type id. If the specified type is a structure, then tid is structure - id. Otherwise should be BADNODE. - @return: success - -ida_bytes.create_double (function) - create_double(ea, length, force=False) -> bool - Convert to double. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_dword (function) - create_dword(ea, length, force=False) -> bool - Convert to dword. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_float (function) - create_float(ea, length, force=False) -> bool - Convert to float. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_oword (function) - create_oword(ea, length, force=False) -> bool - Convert to octaword/xmm word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_packed_real (function) - create_packed_real(ea, length, force=False) -> bool - Convert to packed decimal real. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_qword (function) - create_qword(ea, length, force=False) -> bool - Convert to quadword. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_strlit (function) - create_strlit(start, len, strtype) -> bool - Convert to string literal and give a meaningful name. 'start' may be higher than - 'end', the kernel will swap them in this case - - @param start: (C++: ea_t) starting address - @param len: (C++: size_t) length of the string in bytes. if 0, then get_max_strlit_length() - will be used to determine the length - @param strtype: (C++: int32) string type. one of String type codes - @return: success - -ida_bytes.create_struct (function) - create_struct(ea, length, tid, force=False) -> bool - Convert to struct. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param tid: (C++: tid_t) - @param force: (C++: bool) - -ida_bytes.create_tbyte (function) - create_tbyte(ea, length, force=False) -> bool - Convert to tbyte. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_word (function) - create_word(ea, length, force=False) -> bool - Convert to word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_yword (function) - create_yword(ea, length, force=False) -> bool - Convert to ymm word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.create_zword (function) - create_zword(ea, length, force=False) -> bool - Convert to zmm word. - - @param ea: (C++: ea_t) - @param length: (C++: asize_t) - @param force: (C++: bool) - -ida_bytes.cust_flag (function) - cust_flag() -> flags64_t - Get a flags64_t representing custom type data. - -ida_bytes.custfmt_flag (function) - custfmt_flag() -> flags64_t - see FF_opbits - -ida_bytes.data_format_t (class) - Proxy of C++ data_format_t class. - -ida_bytes.data_format_t.__get_id (method) - __get_id(self) -> int - -ida_bytes.data_format_t.__init__ (method) - __init__(self, _self, name, value_size=0, menu_name=None, props=0, hotkey=None, text_width=0) -> data_format_t - - @param self: PyObject * - @param name: char const * - @param value_size: asize_t - @param menu_name: char const * - @param props: int - @param hotkey: char const * - @param text_width: int32 - -ida_bytes.data_format_t.__init__ (method) - -ida_bytes.data_format_t.hotkey (variable) - Hotkey for the corresponding menu item if nullptr, no hotkey will be associated - with the menu item - -ida_bytes.data_format_t.is_present_in_menus (method) - is_present_in_menus(self) -> bool - Should this format be shown in UI menus - - @return: success - -ida_bytes.data_format_t.menu_name (variable) - Visible format name to use in menus if nullptr, no menu item will be created - -ida_bytes.data_format_t.name (variable) - Format name, must be unique. - -ida_bytes.data_format_t.props (variable) - properties (currently 0) - -ida_bytes.data_format_t.text_width (variable) - Usual width of the text representation This value is used to calculate the width - of the control to display values of this type - -ida_bytes.data_format_t.value_size (variable) - size of the value in bytes 0 means any size is ok data formats that are - registered for standard types (dtid 0) may be called with any value_size - (instruction operands only) - -ida_bytes.data_type_t (class) - Proxy of C++ data_type_t class. - -ida_bytes.data_type_t.__get_id (method) - __get_id(self) -> int - -ida_bytes.data_type_t.__init__ (method) - __init__(self, _self, name, value_size=0, menu_name=None, hotkey=None, asm_keyword=None, props=0) -> data_type_t - - @param self: PyObject * - @param name: char const * - @param value_size: asize_t - @param menu_name: char const * - @param hotkey: char const * - @param asm_keyword: char const * - @param props: int - -ida_bytes.data_type_t.__init__ (method) - -ida_bytes.data_type_t.asm_keyword (variable) - keyword to use for this type in the assembly if nullptr, the data type cannot be - used in the listing it can still be used in cpuregs window - -ida_bytes.data_type_t.hotkey (variable) - Hotkey for the corresponding menu item if nullptr, no hotkey will be associated - with the menu item - -ida_bytes.data_type_t.is_present_in_menus (method) - is_present_in_menus(self) -> bool - Should this type be shown in UI menus - - @return: success - -ida_bytes.data_type_t.menu_name (variable) - Visible data type name to use in menus if nullptr, no menu item will be created - -ida_bytes.data_type_t.name (variable) - name of the data type. must be unique - -ida_bytes.data_type_t.props (variable) - properties - -ida_bytes.data_type_t.value_size (variable) - size of the value in bytes - -ida_bytes.dec_flag (function) - dec_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() - -ida_bytes.del_hidden_range (function) - del_hidden_range(ea) -> bool - Delete hidden range. - - @param ea: (C++: ea_t) any address in the hidden range - @return: success - -ida_bytes.del_items (function) - del_items(ea, flags=0, nbytes=1, may_destroy=None) -> bool - Convert item (instruction/data) to unexplored bytes. The whole item (including - the head and tail bytes) will be destroyed. It is allowed to pass any address in - the item to this function - - @param ea: (C++: ea_t) any address within the first item to delete - @param flags: (C++: int) combination of Unexplored byte conversion flags - @param nbytes: (C++: asize_t) number of bytes in the range to be undefined - @param may_destroy: (C++: may_destroy_cb_t *) optional routine invoked before deleting a head item. If - callback returns false then item is not to be deleted and - operation fails - @return: true on sucessful operation, otherwise false - -ida_bytes.del_mapping (function) - del_mapping(ea) - Delete memory mapping range. - - @param ea: (C++: ea_t) any address in the mapped range - -ida_bytes.del_value (function) - del_value(ea) - Delete byte value from flags. The corresponding byte becomes uninitialized. - - @param ea: (C++: ea_t) - -ida_bytes.detach_custom_data_format (function) - detach_custom_data_format(dtid, dfid) -> bool - Detach the data format from the data type. Unregistering a custom data type - detaches all attached data formats, no need to detach them explicitly. You still - need unregister them. Unregistering a custom data format detaches it from all - attached data types. - - @param dtid: (C++: int) data type id to detach data format from - @param dfid: (C++: int) data format id to detach - @retval true: ok - @retval false: no such `dtid', or no such `dfid', or the data format was not - attached to the data type - -ida_bytes.disable_flags (function) - disable_flags(start_ea, end_ea) -> error_t - Deallocate flags for address range. Exit with an error message if not enough - disk space (this may occur too). - - @param start_ea: (C++: ea_t) should be lower than end_ea. - @param end_ea: (C++: ea_t) does not belong to the range. - @return: 0 if ok, otherwise return error code - -ida_bytes.double_flag (function) - double_flag() -> flags64_t - Get a flags64_t representing a double. - -ida_bytes.dword_flag (function) - dword_flag() -> flags64_t - Get a flags64_t representing a double word. - -ida_bytes.enable_flags (function) - enable_flags(start_ea, end_ea, stt) -> error_t - Allocate flags for address range. This function does not change the storage type - of existing ranges. Exit with an error message if not enough disk space. - - @param start_ea: (C++: ea_t) should be lower than end_ea. - @param end_ea: (C++: ea_t) does not belong to the range. - @param stt: (C++: storage_type_t) - @return: 0 if ok, otherwise an error code - -ida_bytes.enum_flag (function) - enum_flag() -> flags64_t - see FF_opbits - -ida_bytes.equal_bytes (function) - equal_bytes(ea, image, mask, len, bin_search_flags) -> bool - Compare 'len' bytes of the program starting from 'ea' with 'image'. - - @param ea: (C++: ea_t) linear address - @param image: (C++: const uchar *) bytes to compare with - @param mask: (C++: const uchar *) array of mask bytes, it's length is 'len'. if the flag - BIN_SEARCH_BITMASK is passsed, 'bitwise AND' is used to compare. if - not; 1 means to perform the comparison of the corresponding byte. 0 - means not to perform. if mask == nullptr, then all bytes of 'image' - will be compared. if mask == SKIP_FF_MASK then 0xFF bytes will be - skipped - @param len: (C++: size_t) length of block to compare in bytes. - @param bin_search_flags: (C++: int) combination of Search flags - @retval 1: equal - @retval 0: not equal - -ida_bytes.f_has_cmt (function) - f_has_cmt(f, arg2) -> bool - - @param f: flags64_t - @param arg2: void * - -ida_bytes.f_has_dummy_name (function) - f_has_dummy_name(f, arg2) -> bool - Does the current byte have dummy (auto-generated, with special prefix) name? - - @param f: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_has_extra_cmts (function) - f_has_extra_cmts(f, arg2) -> bool - - @param f: flags64_t - @param arg2: void * - -ida_bytes.f_has_name (function) - f_has_name(f, arg2) -> bool - Does the current byte have non-trivial (non-dummy) name? - - @param f: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_has_user_name (function) - f_has_user_name(F, arg2) -> bool - Does the current byte have user-specified name? - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_has_xref (function) - f_has_xref(f, arg2) -> bool - Does the current byte have cross-references to it? - - @param f: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_align (function) - f_is_align(F, arg2) -> bool - See is_align() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_byte (function) - f_is_byte(F, arg2) -> bool - See is_byte() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_code (function) - f_is_code(F, arg2) -> bool - Does flag denote start of an instruction? - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_custom (function) - f_is_custom(F, arg2) -> bool - See is_custom() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_data (function) - f_is_data(F, arg2) -> bool - Does flag denote start of data? - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_double (function) - f_is_double(F, arg2) -> bool - See is_double() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_dword (function) - f_is_dword(F, arg2) -> bool - See is_dword() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_float (function) - f_is_float(F, arg2) -> bool - See is_float() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_head (function) - f_is_head(F, arg2) -> bool - Does flag denote start of instruction OR data? - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_not_tail (function) - f_is_not_tail(F, arg2) -> bool - Does flag denote tail byte? - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_oword (function) - f_is_oword(F, arg2) -> bool - See is_oword() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_pack_real (function) - f_is_pack_real(F, arg2) -> bool - See is_pack_real() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_qword (function) - f_is_qword(F, arg2) -> bool - See is_qword() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_strlit (function) - f_is_strlit(F, arg2) -> bool - See is_strlit() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_struct (function) - f_is_struct(F, arg2) -> bool - See is_struct() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_tail (function) - f_is_tail(F, arg2) -> bool - Does flag denote tail byte? - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_tbyte (function) - f_is_tbyte(F, arg2) -> bool - See is_tbyte() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_word (function) - f_is_word(F, arg2) -> bool - See is_word() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.f_is_yword (function) - f_is_yword(F, arg2) -> bool - See is_yword() - - @param F: (C++: flags64_t) - @param arg2: void * - -ida_bytes.find_byte (function) - find_byte(sEA, size, value, bin_search_flags) -> ea_t - Find forward a byte with the specified value (only 8-bit value from the - database). example: ea=4 size=3 will inspect addresses 4, 5, and 6 - - @param sEA: (C++: ea_t) linear address - @param size: (C++: asize_t) number of bytes to inspect - @param value: (C++: uchar) value to find - @param bin_search_flags: (C++: int) combination of Search flags - @return: address of byte or BADADDR - -ida_bytes.find_byter (function) - find_byter(sEA, size, value, bin_search_flags) -> ea_t - Find reverse a byte with the specified value (only 8-bit value from the - database). example: ea=4 size=3 will inspect addresses 6, 5, and 4 - - @param sEA: (C++: ea_t) the lower address of the search range - @param size: (C++: asize_t) number of bytes to inspect - @param value: (C++: uchar) value to find - @param bin_search_flags: (C++: int) combination of Search flags - @return: address of byte or BADADDR - -ida_bytes.find_custom_data_format (function) - find_custom_data_format(name) -> int - Get id of a custom data format. - - @param name: (C++: const char *) name of the custom data format - @return: id or -1 - -ida_bytes.find_custom_data_type (function) - find_custom_data_type(name) -> int - Get id of a custom data type. - - @param name: (C++: const char *) name of the custom data type - @return: id or -1 - -ida_bytes.find_free_chunk (function) - find_free_chunk(start, size, alignment) -> ea_t - Search for a hole in the addressing space of the program. - - @param start: (C++: ea_t) Address to start searching from - @param size: (C++: asize_t) Size of the desired empty range - @param alignment: (C++: asize_t) Alignment bitmask, must be a pow2-1. (for example, 0xF would - align the returned range to 16 bytes). - @return: Start of the found empty range or BADADDR - -ida_bytes.float_flag (function) - float_flag() -> flags64_t - Get a flags64_t representing a float. - -ida_bytes.flt_flag (function) - flt_flag() -> flags64_t - see FF_opbits - -ida_bytes.free_chunk (function) - free_chunk(bottom, size, step) -> ea_t - - @param bottom: ea_t - @param size: asize_t - @param step: int32 - -ida_bytes.get_16bit (function) - get_16bit(ea) -> uint32 - Get 16bits of the program at 'ea'. - - @param ea: (C++: ea_t) - @return: 1 byte (getFullByte()) if the current processor has 16-bit byte, - otherwise return get_word() - -ida_bytes.get_32bit (function) - get_32bit(ea) -> uint32 - Get not more than 32bits of the program at 'ea'. - - @param ea: (C++: ea_t) - @return: 32 bit value, depending on processor_t::nbits: - * if ( nbits <= 8 ) return get_dword(ea); - * if ( nbits <= 16) return get_wide_word(ea); - * return get_wide_byte(ea); - -ida_bytes.get_64bit (function) - get_64bit(ea) -> uint64 - Get not more than 64bits of the program at 'ea'. - - @param ea: (C++: ea_t) - @return: 64 bit value, depending on processor_t::nbits: - * if ( nbits <= 8 ) return get_qword(ea); - * if ( nbits <= 16) return get_wide_dword(ea); - * return get_wide_byte(ea); - -ida_bytes.get_8bit (function) - get_8bit(ea, v, nbit) -> PyObject * - - @param ea: ea_t - @param v: uint32 - @param nbit: int - -ida_bytes.get_byte (function) - get_byte(ea) -> uchar - Get one byte (8-bit) of the program at 'ea'. This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) - -ida_bytes.get_bytes (function) - get_bytes(ea, size, gmb_flags=0x01) -> bytes or None - Get the specified number of bytes of the program. - - @param ea: program address - @param size: number of bytes to return - @param gmb_flags: int - @return: the bytes (as a str), or None in case of failure - -ida_bytes.get_bytes_and_mask (function) - get_bytes_and_mask(ea, size, gmb_flags=0x01) -> PyObject * - Get the specified number of bytes of the program, and a bitmask - specifying what bytes are defined and what bytes are not. - - @param ea: program address - @param size: number of bytes to return - @param gmb_flags: int - @return: a tuple (bytes, mask), or None in case of failure. - Both 'bytes' and 'mask' are 'str' instances. - -ida_bytes.get_cmt (function) - get_cmt(ea, rptble) -> str - Get an indented comment. - - @param ea: (C++: ea_t) linear address. may point to tail byte, the function will find start - of the item - @param rptble: (C++: bool) get repeatable comment? - @return: size of comment or -1 - -ida_bytes.get_custom_data_format (function) - get_custom_data_format(dfid) -> data_format_t - Get definition of a registered custom data format. - - @param dfid: (C++: int) data format id - @return: data format definition or nullptr - -ida_bytes.get_custom_data_formats (function) - get_custom_data_formats(out, dtid) -> int - Get list of attached custom data formats for the specified data type. - - @param out: (C++: intvec_t *) buffer for the output. may be nullptr - @param dtid: (C++: int) data type id - @return: number of returned custom data formats. if error, returns -1 - -ida_bytes.get_custom_data_type (function) - get_custom_data_type(dtid) -> data_type_t - Get definition of a registered custom data type. - - @param dtid: (C++: int) data type id - @return: data type definition or nullptr - -ida_bytes.get_custom_data_types (function) - get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int - Get list of registered custom data type ids. - - @param out: (C++: intvec_t *) buffer for the output. may be nullptr - @param min_size: (C++: asize_t) minimum value size - @param max_size: (C++: asize_t) maximum value size - @return: number of custom data types with the specified size limits - -ida_bytes.get_data_elsize (function) - get_data_elsize(ea, F, ti=None) -> asize_t - Get size of data type specified in flags 'F'. - - @param ea: (C++: ea_t) linear address of the item - @param F: (C++: flags64_t) flags - @param ti: (C++: const opinfo_t *) additional information about the data type. For example, if the - current item is a structure instance, then ti->tid is structure id. - Otherwise is ignored (may be nullptr). If specified as nullptr, will - be automatically retrieved from the database - @return: * byte : 1 - * word : 2 - * etc... - -ida_bytes.get_data_value (function) - get_data_value(v, ea, size) -> bool - Get the value at of the item at 'ea'. This function works with entities up to - sizeof(ea_t) (bytes, word, etc) - - @param v: (C++: uval_t *) pointer to the result. may be nullptr - @param ea: (C++: ea_t) linear address - @param size: (C++: asize_t) size of data to read. If 0, then the item type at 'ea' will be used - @return: success - -ida_bytes.get_db_byte (function) - get_db_byte(ea) -> uchar - Get one byte (8-bit) of the program at 'ea' from the database. Works even if the - debugger is active. See also get_dbg_byte() to read the process memory directly. - This function works only for 8bit byte processors. - - @param ea: (C++: ea_t) - -ida_bytes.get_default_radix (function) - get_default_radix() -> int - Get default base of number for the current processor. - - @return: 2, 8, 10, 16 - -ida_bytes.get_dword (function) - get_dword(ea) -> uint32 - Get one dword (32-bit) of the program at 'ea'. This function takes into account - order of bytes specified in idainfo::is_be() This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) - -ida_bytes.get_enum_id (function) - get_enum_id(ea, n) -> enum_t - Get enum id of 'enum' operand. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands - @return: id of enum or BADNODE - -ida_bytes.get_first_hidden_range (function) - get_first_hidden_range() -> hidden_range_t - Get pointer to the first hidden range. - - @return: ptr to hidden range or nullptr - -ida_bytes.get_flags (function) - get_flags(ea) -> flags64_t - get flags with FF_IVL & MS_VAL. It is much slower under remote debugging because - the kernel needs to read the process memory. - - @param ea: (C++: ea_t) - -ida_bytes.get_flags_by_size (function) - get_flags_by_size(size) -> flags64_t - Get flags from size (in bytes). Supported sizes: 1, 2, 4, 8, 16, 32. For other - sizes returns 0 - - @param size: (C++: size_t) - -ida_bytes.get_flags_ex (function) - get_flags_ex(ea, how) -> flags64_t - Get flags for the specified address, extended form. - - @param ea: (C++: ea_t) - @param how: (C++: int) - -ida_bytes.get_forced_operand (function) - get_forced_operand(ea, n) -> str - Get forced operand. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number - @return: size of forced operand or -1 - -ida_bytes.get_full_data_elsize (function) - get_full_data_elsize(ea, F, ti=None) -> asize_t - Get full size of data type specified in flags 'F'. takes into account processors - with wide bytes e.g. returns 2 for a byte element with 16-bit bytes - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param ti: (C++: const opinfo_t *) opinfo_t const * - -ida_bytes.get_full_flags (function) - get_full_flags(ea) -> flags64_t - Get flags value for address 'ea'. - - @param ea: (C++: ea_t) - @return: 0 if address is not present in the program - -ida_bytes.get_hidden_range (function) - get_hidden_range(ea) -> hidden_range_t - Get pointer to hidden range structure, in: linear address. - - @param ea: (C++: ea_t) any address in the hidden range - -ida_bytes.get_hidden_range_num (function) - get_hidden_range_num(ea) -> int - Get number of a hidden range. - - @param ea: (C++: ea_t) any address in the hidden range - @return: number of hidden range (0..get_hidden_range_qty()-1) - -ida_bytes.get_hidden_range_qty (function) - get_hidden_range_qty() -> int - Get number of hidden ranges. - -ida_bytes.get_item_end (function) - get_item_end(ea) -> ea_t - Get the end address of the item at 'ea'. The returned address doesn't belong to - the current item. Unexplored bytes are counted as 1 byte entities. - - @param ea: (C++: ea_t) - -ida_bytes.get_item_flag (function) - get_item_flag(_from, n, ea, appzero) -> flags64_t - Get flag of the item at 'ea' even if it is a tail byte of some array or - structure. This function is used to get flags of structure members or array - elements. - - @param from: (C++: ea_t) linear address of the instruction which refers to 'ea' - @param n: (C++: int) operand number which refers to 'ea' or OPND_ALL for one of the - operands - @param ea: (C++: ea_t) the referenced address - @param appzero: (C++: bool) append a struct field name if the field offset is zero? - meaningful only if the name refers to a structure. - @return: flags or 0 (if failed) - -ida_bytes.get_item_head (function) - get_item_head(ea) -> ea_t - Get the start address of the item at 'ea'. If there is no current item, then - 'ea' will be returned (see definition at the end of bytes.hpp source) - - @param ea: (C++: ea_t) - -ida_bytes.get_item_refinfo (function) - get_item_refinfo(ri, ea, n) -> bool - Get refinfo of the item at 'ea'. This function works for a regular offset - operand as well as for a tail byte of a structure variable (in this case refinfo - to corresponding structure member will be returned) - - @param ri: (C++: refinfo_t *) refinfo holder - @param ea: (C++: ea_t) the item address - @param n: (C++: int) operand number which refers to 'ea' or OPND_ALL for one of the - operands - @return: success - -ida_bytes.get_item_size (function) - get_item_size(ea) -> asize_t - Get size of item (instruction/data) in bytes. Unexplored bytes have length of 1 - byte. This function returns 0 only for BADADDR. - - @param ea: (C++: ea_t) - -ida_bytes.get_last_hidden_range (function) - get_last_hidden_range() -> hidden_range_t - Get pointer to the last hidden range. - - @return: ptr to hidden range or nullptr - -ida_bytes.get_manual_insn (function) - get_manual_insn(ea) -> str - Retrieve the user-specified string for the manual instruction. - - @param ea: (C++: ea_t) linear address of the instruction or data item - @return: size of manual instruction or -1 - -ida_bytes.get_mapping (function) - get_mapping(n) -> bool - Get memory mapping range by its number. - - @param n: (C++: size_t) number of mapping range (0..get_mappings_qty()-1) - @return: false if the specified range doesn't exist, otherwise returns `from', - `to', `size' - -ida_bytes.get_mappings_qty (function) - get_mappings_qty() -> size_t - Get number of mappings. - -ida_bytes.get_max_strlit_length (function) - get_max_strlit_length(ea, strtype, options=0) -> size_t - Determine maximum length of string literal. - - If the string literal has a length prefix (e.g., STRTYPE_LEN2 has a two-byte - length prefix), the length of that prefix (i.e., 2) will be part of the returned - value. - - @param ea: (C++: ea_t) starting address - @param strtype: (C++: int32) string type. one of String type codes - @param options: (C++: int) combination of string literal length options - @return: length of the string in octets (octet==8bit) - -ida_bytes.get_next_hidden_range (function) - get_next_hidden_range(ea) -> hidden_range_t - Get pointer to next hidden range. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to hidden range or nullptr if next hidden range doesn't exist - -ida_bytes.get_octet (function) - get_octet(ea, v, nbit) -> (int, int, int, int) - - @param ea: ea_t - @param v: uint64 - @param nbit: int - -ida_bytes.get_octet2 (function) - get_octet2(ogen) -> bool - - @param ogen: octet_generator_t * - -ida_bytes.get_operand_flag (function) - get_operand_flag(typebits, n) -> flags64_t - Place operand `n`'s type flag in the right nibble of a 64-bit flags set. - - @param typebits: (C++: uint8) the type bits (one of `FF_N_`) - @param n: (C++: int) the operand number - @return: the shift to the nibble - -ida_bytes.get_operand_type_shift (function) - get_operand_type_shift(n) -> int - Get the shift in `flags64_t` for the nibble representing operand `n`'s type - - Note: n must be < UA_MAXOP, and is not checked - - @param n: (C++: uint32) the operand number - @return: the shift to the nibble - -ida_bytes.get_opinfo (function) - get_opinfo(buf, ea, n, flags) -> opinfo_t - Get additional information about an operand representation. - - @param buf: (C++: opinfo_t *) buffer to receive the result. may not be nullptr - @param ea: (C++: ea_t) linear address of item - @param n: (C++: int) number of operand, 0 or 1 - @param flags: (C++: flags64_t) flags of the item - @return: nullptr if no additional representation information - -ida_bytes.get_optype_flags0 (function) - get_optype_flags0(F) -> flags64_t - Get flags for first operand. - - @param F: (C++: flags64_t) - -ida_bytes.get_optype_flags1 (function) - get_optype_flags1(F) -> flags64_t - Get flags for second operand. - - @param F: (C++: flags64_t) - -ida_bytes.get_original_byte (function) - get_original_byte(ea) -> uint64 - Get original byte value (that was before patching). This function works for wide - byte processors too. - - @param ea: (C++: ea_t) - -ida_bytes.get_original_dword (function) - get_original_dword(ea) -> uint64 - Get original dword (that was before patching) This function works for wide byte - processors too. This function takes into account order of bytes specified in - idainfo::is_be() - - @param ea: (C++: ea_t) - -ida_bytes.get_original_qword (function) - get_original_qword(ea) -> uint64 - Get original qword value (that was before patching) This function DOESN'T work - for wide byte processors too. This function takes into account order of bytes - specified in idainfo::is_be() - - @param ea: (C++: ea_t) - -ida_bytes.get_original_word (function) - get_original_word(ea) -> uint64 - Get original word value (that was before patching). This function works for wide - byte processors too. This function takes into account order of bytes specified - in idainfo::is_be() - - @param ea: (C++: ea_t) - -ida_bytes.get_possible_item_varsize (function) - get_possible_item_varsize(ea, tif) -> asize_t - Return the possible size of the item at EA of type TIF if TIF is the variable - structure. - - @param ea: (C++: ea_t) the linear address of the item - @param tif: (C++: const tinfo_t &) the item type - @return: the possible size - @retval asize_t(-1): TIF is not a variable structure - -ida_bytes.get_predef_insn_cmt (function) - get_predef_insn_cmt(ins) -> str - Get predefined comment. - - @param ins: (C++: const insn_t &) current instruction information - @return: size of comment or -1 - -ida_bytes.get_prev_hidden_range (function) - get_prev_hidden_range(ea) -> hidden_range_t - Get pointer to previous hidden range. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to hidden range or nullptr if previous hidden range doesn't exist - -ida_bytes.get_qword (function) - get_qword(ea) -> uint64 - Get one qword (64-bit) of the program at 'ea'. This function takes into account - order of bytes specified in idainfo::is_be() This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) - -ida_bytes.get_radix (function) - get_radix(F, n) -> int - Get radix of the operand, in: flags. If the operand is not a number, returns - get_default_radix() - - @param F: (C++: flags64_t) flags - @param n: (C++: int) number of operand (0, 1, -1) - @return: 2, 8, 10, 16 - -ida_bytes.get_strlit_contents (function) - get_strlit_contents(ea, py_len, type, flags=0) -> bytes or None - Get contents of string literal, as UTF-8-encoded codepoints. - It works even if the string has not been created in the database yet. - - Note that the returned value will be of type 'bytes'; if - you want auto-conversion to unicode strings (that is: real Python - strings), you should probably be using the idautils.Strings class. - - @param ea: linear address of the string - @param py_len: length of the string in bytes (including terminating 0) - @param type: type of the string. Represents both the character encoding, - <u>and</u> the 'type' of string at the given location. - @param flags: combination of STRCONV_..., to perform output conversion. - @return: a bytes-filled str object. - -ida_bytes.get_stroff_path (function) - get_stroff_path(path, delta, ea, n) -> int - Get struct path of operand. - - @param path: (C++: tid_t *) buffer for structure path (strpath). see nalt.hpp for more info. - @param delta: (C++: adiff_t *) struct offset delta - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands - @return: length of strpath - -ida_bytes.get_wide_byte (function) - get_wide_byte(ea) -> uint64 - Get one wide byte of the program at 'ea'. Some processors may access more than - 8bit quantity at an address. These processors have 32-bit byte organization from - the IDA's point of view. - - @param ea: (C++: ea_t) - -ida_bytes.get_wide_dword (function) - get_wide_dword(ea) -> uint64 - Get two wide words (4 'bytes') of the program at 'ea'. Some processors may - access more than 8bit quantity at an address. These processors have 32-bit byte - organization from the IDA's point of view. This function takes into account - order of bytes specified in idainfo::is_be() - @note: this function works incorrectly if processor_t::nbits > 16 - - @param ea: (C++: ea_t) - -ida_bytes.get_wide_word (function) - get_wide_word(ea) -> uint64 - Get one wide word (2 'byte') of the program at 'ea'. Some processors may access - more than 8bit quantity at an address. These processors have 32-bit byte - organization from the IDA's point of view. This function takes into account - order of bytes specified in idainfo::is_be() - - @param ea: (C++: ea_t) - -ida_bytes.get_word (function) - get_word(ea) -> ushort - Get one word (16-bit) of the program at 'ea'. This function takes into account - order of bytes specified in idainfo::is_be() This function works only for 8bit - byte processors. - - @param ea: (C++: ea_t) - -ida_bytes.get_zero_ranges (function) - get_zero_ranges(zranges, range) -> bool - Return set of ranges with zero initialized bytes. The returned set includes only - big zero initialized ranges (at least >1KB). Some zero initialized byte ranges - may be not included. Only zero bytes that use the sparse storage method (STT_MM) - are reported. - - @param zranges: (C++: rangeset_t *) pointer to the return value. cannot be nullptr - @param range: (C++: const range_t *) the range of addresses to verify. can be nullptr - means all - ranges - @return: true if the result is a non-empty set - -ida_bytes.getn_hidden_range (function) - getn_hidden_range(n) -> hidden_range_t - Get pointer to hidden range structure, in: number of hidden range. - - @param n: (C++: int) number of hidden range, is in range 0..get_hidden_range_qty()-1 - -ida_bytes.has_any_name (function) - has_any_name(F) -> bool - Does the current byte have any name? - - @param F: (C++: flags64_t) - -ida_bytes.has_auto_name (function) - has_auto_name(F) -> bool - Does the current byte have auto-generated (no special prefix) name? - - @param F: (C++: flags64_t) - -ida_bytes.has_cmt (function) - has_cmt(F) -> bool - Does the current byte have an indented comment? - - @param F: (C++: flags64_t) - -ida_bytes.has_dummy_name (function) - has_dummy_name(F) -> bool - Does the current byte have dummy (auto-generated, with special prefix) name? - - @param F: (C++: flags64_t) - -ida_bytes.has_extra_cmts (function) - has_extra_cmts(F) -> bool - Does the current byte have additional anterior or posterior lines? - - @param F: (C++: flags64_t) - -ida_bytes.has_immd (function) - has_immd(F) -> bool - Has immediate value? - - @param F: (C++: flags64_t) - -ida_bytes.has_name (function) - has_name(F) -> bool - Does the current byte have non-trivial (non-dummy) name? - - @param F: (C++: flags64_t) - -ida_bytes.has_user_name (function) - has_user_name(F) -> bool - Does the current byte have user-specified name? - - @param F: (C++: flags64_t) - -ida_bytes.has_value (function) - has_value(F) -> bool - Do flags contain byte value? - - @param F: (C++: flags64_t) - -ida_bytes.has_xref (function) - has_xref(F) -> bool - Does the current byte have cross-references to it? - - @param F: (C++: flags64_t) - -ida_bytes.hex_flag (function) - hex_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() - -ida_bytes.hidden_range_t (class) - Proxy of C++ hidden_range_t class. - -ida_bytes.hidden_range_t.__init__ (method) - __init__(self) -> hidden_range_t - -ida_bytes.hidden_range_t.color (variable) - range color - -ida_bytes.hidden_range_t.description (variable) - description to display if the range is collapsed - -ida_bytes.hidden_range_t.footer (variable) - footer lines to display if the range is expanded - -ida_bytes.hidden_range_t.header (variable) - header lines to display if the range is expanded - -ida_bytes.hidden_range_t.visible (variable) - the range state - -ida_bytes.is_align (function) - is_align(F) -> bool - FF_ALIGN - - @param F: (C++: flags64_t) - -ida_bytes.is_attached_custom_data_format (function) - is_attached_custom_data_format(dtid, dfid) -> bool - Is the custom data format attached to the custom data type? - - @param dtid: (C++: int) data type id - @param dfid: (C++: int) data format id - @return: true or false - -ida_bytes.is_bnot (function) - is_bnot(ea, F, n) -> bool - Should we negate the operand?. asm_t::a_bnot should be defined in the idp module - in order to work with this function - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_byte (function) - is_byte(F) -> bool - FF_BYTE - - @param F: (C++: flags64_t) - -ida_bytes.is_char (function) - is_char(F, n) -> bool - is character constant? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_char0 (function) - is_char0(F) -> bool - Is the first operand character constant? (example: push 'a') - - @param F: (C++: flags64_t) - -ida_bytes.is_char1 (function) - is_char1(F) -> bool - Is the second operand character constant? (example: mov al, 'a') - - @param F: (C++: flags64_t) - -ida_bytes.is_code (function) - is_code(F) -> bool - Does flag denote start of an instruction? - - @param F: (C++: flags64_t) - -ida_bytes.is_custfmt (function) - is_custfmt(F, n) -> bool - is custom data format? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_custfmt0 (function) - is_custfmt0(F) -> bool - Does the first operand use a custom data representation? - - @param F: (C++: flags64_t) - -ida_bytes.is_custfmt1 (function) - is_custfmt1(F) -> bool - Does the second operand use a custom data representation? - - @param F: (C++: flags64_t) - -ida_bytes.is_custom (function) - is_custom(F) -> bool - FF_CUSTOM - - @param F: (C++: flags64_t) - -ida_bytes.is_data (function) - is_data(F) -> bool - Does flag denote start of data? - - @param F: (C++: flags64_t) - -ida_bytes.is_defarg (function) - is_defarg(F, n) -> bool - is defined? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_defarg0 (function) - is_defarg0(F) -> bool - Is the first operand defined? Initially operand has no defined representation. - - @param F: (C++: flags64_t) - -ida_bytes.is_defarg1 (function) - is_defarg1(F) -> bool - Is the second operand defined? Initially operand has no defined representation. - - @param F: (C++: flags64_t) - -ida_bytes.is_double (function) - is_double(F) -> bool - FF_DOUBLE - - @param F: (C++: flags64_t) - -ida_bytes.is_dword (function) - is_dword(F) -> bool - FF_DWORD - - @param F: (C++: flags64_t) - -ida_bytes.is_enum (function) - is_enum(F, n) -> bool - is enum? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_enum0 (function) - is_enum0(F) -> bool - Is the first operand a symbolic constant (enum member)? - - @param F: (C++: flags64_t) - -ida_bytes.is_enum1 (function) - is_enum1(F) -> bool - Is the second operand a symbolic constant (enum member)? - - @param F: (C++: flags64_t) - -ida_bytes.is_flag_for_operand (function) - is_flag_for_operand(F, typebits, n) -> bool - Check that the 64-bit flags set has the expected type for operand `n`. - - @param F: (C++: flags64_t) the flags - @param typebits: (C++: uint8) the type bits (one of `FF_N_`) - @param n: (C++: int) the operand number - @return: success - -ida_bytes.is_float (function) - is_float(F) -> bool - FF_FLOAT - - @param F: (C++: flags64_t) - -ida_bytes.is_float0 (function) - is_float0(F) -> bool - Is the first operand a floating point number? - - @param F: (C++: flags64_t) - -ida_bytes.is_float1 (function) - is_float1(F) -> bool - Is the second operand a floating point number? - - @param F: (C++: flags64_t) - -ida_bytes.is_flow (function) - is_flow(F) -> bool - Does the previous instruction exist and pass execution flow to the current byte? - - @param F: (C++: flags64_t) - -ida_bytes.is_fltnum (function) - is_fltnum(F, n) -> bool - is floating point number? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_forced_operand (function) - is_forced_operand(ea, n) -> bool - Is operand manually defined?. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number - -ida_bytes.is_func (function) - is_func(F) -> bool - Is function start? - - @param F: (C++: flags64_t) - -ida_bytes.is_head (function) - is_head(F) -> bool - Does flag denote start of instruction OR data? - - @param F: (C++: flags64_t) - -ida_bytes.is_invsign (function) - is_invsign(ea, F, n) -> bool - Should sign of n-th operand inverted during output?. allowed values of n: - 0-first operand, 1-other operands - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_loaded (function) - is_loaded(ea) -> bool - Does the specified address have a byte value (is initialized?) - - @param ea: (C++: ea_t) - -ida_bytes.is_lzero (function) - is_lzero(ea, n) -> bool - Display leading zeroes? Display leading zeroes in operands. The global switch - for the leading zeroes is in idainfo::s_genflags Note: the leading zeroes - doesn't work if for the target assembler octal numbers start with 0. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success - -ida_bytes.is_manual (function) - is_manual(F, n) -> bool - is forced operand? (use is_forced_operand()) - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_manual_insn (function) - is_manual_insn(ea) -> bool - Is the instruction overridden? - - @param ea: (C++: ea_t) linear address of the instruction or data item - -ida_bytes.is_mapped (function) - is_mapped(ea) -> bool - Is the specified address 'ea' present in the program? - - @param ea: (C++: ea_t) - -ida_bytes.is_not_tail (function) - is_not_tail(F) -> bool - Does flag denote tail byte? - - @param F: (C++: flags64_t) - -ida_bytes.is_numop (function) - is_numop(F, n) -> bool - is number (bin, oct, dec, hex)? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_numop0 (function) - is_numop0(F) -> bool - Is the first operand a number (i.e. binary, octal, decimal or hex?) - - @param F: (C++: flags64_t) - -ida_bytes.is_numop1 (function) - is_numop1(F) -> bool - Is the second operand a number (i.e. binary, octal, decimal or hex?) - - @param F: (C++: flags64_t) - -ida_bytes.is_off (function) - is_off(F, n) -> bool - is offset? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_off0 (function) - is_off0(F) -> bool - Is the first operand offset? (example: push offset xxx) - - @param F: (C++: flags64_t) - -ida_bytes.is_off1 (function) - is_off1(F) -> bool - Is the second operand offset? (example: mov ax, offset xxx) - - @param F: (C++: flags64_t) - -ida_bytes.is_oword (function) - is_oword(F) -> bool - FF_OWORD - - @param F: (C++: flags64_t) - -ida_bytes.is_pack_real (function) - is_pack_real(F) -> bool - FF_PACKREAL - - @param F: (C++: flags64_t) - -ida_bytes.is_qword (function) - is_qword(F) -> bool - FF_QWORD - - @param F: (C++: flags64_t) - -ida_bytes.is_same_data_type (function) - is_same_data_type(F1, F2) -> bool - Do the given flags specify the same data type? - - @param F1: (C++: flags64_t) - @param F2: (C++: flags64_t) - -ida_bytes.is_seg (function) - is_seg(F, n) -> bool - is segment? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_seg0 (function) - is_seg0(F) -> bool - Is the first operand segment selector? (example: push seg seg001) - - @param F: (C++: flags64_t) - -ida_bytes.is_seg1 (function) - is_seg1(F) -> bool - Is the second operand segment selector? (example: mov dx, seg dseg) - - @param F: (C++: flags64_t) - -ida_bytes.is_stkvar (function) - is_stkvar(F, n) -> bool - is stack variable? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_stkvar0 (function) - is_stkvar0(F) -> bool - Is the first operand a stack variable? - - @param F: (C++: flags64_t) - -ida_bytes.is_stkvar1 (function) - is_stkvar1(F) -> bool - Is the second operand a stack variable? - - @param F: (C++: flags64_t) - -ida_bytes.is_strlit (function) - is_strlit(F) -> bool - FF_STRLIT - - @param F: (C++: flags64_t) - -ida_bytes.is_stroff (function) - is_stroff(F, n) -> bool - is struct offset? - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_stroff0 (function) - is_stroff0(F) -> bool - Is the first operand an offset within a struct? - - @param F: (C++: flags64_t) - -ida_bytes.is_stroff1 (function) - is_stroff1(F) -> bool - Is the second operand an offset within a struct? - - @param F: (C++: flags64_t) - -ida_bytes.is_struct (function) - is_struct(F) -> bool - FF_STRUCT - - @param F: (C++: flags64_t) - -ida_bytes.is_suspop (function) - is_suspop(ea, F, n) -> bool - is suspicious operand? - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.is_tail (function) - is_tail(F) -> bool - Does flag denote tail byte? - - @param F: (C++: flags64_t) - -ida_bytes.is_tbyte (function) - is_tbyte(F) -> bool - FF_TBYTE - - @param F: (C++: flags64_t) - -ida_bytes.is_unknown (function) - is_unknown(F) -> bool - Does flag denote unexplored byte? - - @param F: (C++: flags64_t) - -ida_bytes.is_varsize_item (function) - is_varsize_item(ea, F, ti=None, itemsize=None) -> int - Is the item at 'ea' variable size?. - - @param ea: (C++: ea_t) linear address of the item - @param F: (C++: flags64_t) flags - @param ti: (C++: const opinfo_t *) additional information about the data type. For example, if the - current item is a structure instance, then ti->tid is structure id. - Otherwise is ignored (may be nullptr). If specified as nullptr, will - be automatically retrieved from the database - @param itemsize: (C++: asize_t *) if not nullptr and the item is varsize, itemsize will contain - the calculated item size (for struct types, the minimal size is - returned) - @retval 1: varsize item - @retval 0: fixed item - @retval -1: error (bad data definition) - -ida_bytes.is_word (function) - is_word(F) -> bool - FF_WORD - - @param F: (C++: flags64_t) - -ida_bytes.is_yword (function) - is_yword(F) -> bool - FF_YWORD - - @param F: (C++: flags64_t) - -ida_bytes.is_zword (function) - is_zword(F) -> bool - FF_ZWORD - - @param F: (C++: flags64_t) - -ida_bytes.leading_zero_important (function) - leading_zero_important(ea, n) -> bool - Check if leading zeroes are important. - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.nbits (function) - nbits(ea) -> int - Get number of bits in a byte at the given address. - - @param ea: (C++: ea_t) - @return: processor_t::dnbits() if the address doesn't belong to a segment, - otherwise the result depends on the segment type - -ida_bytes.next_addr (function) - next_addr(ea) -> ea_t - Get next address in the program (i.e. next address which has flags). - - @param ea: (C++: ea_t) - @return: BADADDR if no such address exist. - -ida_bytes.next_chunk (function) - next_chunk(ea) -> ea_t - Get the first address of next contiguous chunk in the program. - - @param ea: (C++: ea_t) - @return: BADADDR if next chunk doesn't exist. - -ida_bytes.next_head (function) - next_head(ea, maxea) -> ea_t - Get start of next defined item. - - @param ea: (C++: ea_t) begin search at this address - @param maxea: (C++: ea_t) not included in the search range - @return: BADADDR if none exists. - -ida_bytes.next_inited (function) - next_inited(ea, maxea) -> ea_t - Find the next initialized address. - - @param ea: (C++: ea_t) - @param maxea: (C++: ea_t) - -ida_bytes.next_not_tail (function) - next_not_tail(ea) -> ea_t - Get address of next non-tail byte. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. - -ida_bytes.next_that (function) - next_that(ea, maxea, testf) -> ea_t - Find next address with a flag satisfying the function 'testf'. - @note: do not pass is_unknown() to this function to find unexplored bytes. It - will fail under the debugger. To find unexplored bytes, use - next_unknown(). - - @param ea: (C++: ea_t) start searching at this address + 1 - @param maxea: (C++: ea_t) not included in the search range. - @param testf: (C++: testf_t *) test function to find next address - @return: the found address or BADADDR. - -ida_bytes.next_unknown (function) - next_unknown(ea, maxea) -> ea_t - Similar to next_that(), but will find the next address that is unexplored. - - @param ea: (C++: ea_t) - @param maxea: (C++: ea_t) - -ida_bytes.next_visea (function) - next_visea(ea) -> ea_t - Get next visible address. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. - -ida_bytes.num_flag (function) - num_flag() -> flags64_t - Get number of default base (bin, oct, dec, hex) - -ida_bytes.oct_flag (function) - oct_flag() -> flags64_t - Get number flag of the base, regardless of current processor - better to use - num_flag() - -ida_bytes.octet_generator_t (class) - Proxy of C++ octet_generator_t class. - -ida_bytes.octet_generator_t.__init__ (method) - __init__(self, _ea) -> octet_generator_t - - @param _ea: ea_t - -ida_bytes.octet_generator_t.invert_byte_order (method) - invert_byte_order(self) - -ida_bytes.off_flag (function) - off_flag() -> flags64_t - see FF_opbits - -ida_bytes.op_adds_xrefs (function) - op_adds_xrefs(F, n) -> bool - Should processor module create xrefs from the operand?. Currently 'offset' and - 'structure offset' operands create xrefs - - @param F: (C++: flags64_t) - @param n: (C++: int) - -ida_bytes.op_based_stroff (function) - op_based_stroff(insn, n, opval, base) -> bool - Set operand representation to be 'struct offset' if the operand likely points to - a structure member. For example, let's there is a structure at 1000 1000 - stru_1000 Elf32_Sym <...> the operand #8 will be represented as - '#Elf32_Sym.st_size' after the call of 'op_based_stroff(..., 8, 0x1000)' By the - way, after the call of 'op_plain_offset(..., 0x1000)' it will be represented as - '#(stru_1000.st_size - 0x1000)' - - @param insn: (C++: const insn_t &) the instruction - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @param opval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr) - @param base: (C++: ea_t) base reference - @return: success - -ida_bytes.op_bin (function) - op_bin(ea, n) -> bool - set op type to bin_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.op_chr (function) - op_chr(ea, n) -> bool - set op type to char_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.op_custfmt (function) - op_custfmt(ea, n, fid) -> bool - Set custom data format for operand (fid-custom data format id) - - @param ea: (C++: ea_t) - @param n: (C++: int) - @param fid: (C++: int) - -ida_bytes.op_dec (function) - op_dec(ea, n) -> bool - set op type to dec_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.op_enum (function) - op_enum(ea, n, id, serial=0) -> bool - Set operand representation to be 'enum_t'. If applied to unexplored bytes, - converts them to 16/32bit word data - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @param id: (C++: enum_t) id of enum - @param serial: (C++: uchar) the serial number of the constant in the enumeration, usually 0. - the serial numbers are used if the enumeration contains several - constants with the same value - @return: success - -ida_bytes.op_flt (function) - op_flt(ea, n) -> bool - set op type to flt_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.op_hex (function) - op_hex(ea, n) -> bool - set op type to hex_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.op_num (function) - op_num(ea, n) -> bool - set op type to num_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.op_oct (function) - op_oct(ea, n) -> bool - set op type to oct_flag() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.op_seg (function) - op_seg(ea, n) -> bool - Set operand representation to be 'segment'. If applied to unexplored bytes, - converts them to 16/32bit word data - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @return: success - -ida_bytes.op_stkvar (function) - op_stkvar(ea, n) -> bool - Set operand representation to be 'stack variable'. Should be applied to an - instruction within a function. Should be applied after creating a stack var - using insn_t::create_stkvar(). - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @return: success - -ida_bytes.op_stroff (function) - op_stroff(insn, n, path, path_len, delta) -> bool - Set operand representation to be 'struct offset'. - - @param insn: (C++: const insn_t &) the instruction - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @param path: (C++: const tid_t *) structure path (strpath). see nalt.hpp for more info. - @param path_len: (C++: int) length of the structure path - @param delta: (C++: adiff_t) struct offset delta. usually 0. denotes the difference between the - structure base and the pointer into the structure. - @return: success - op_stroff(insn, n, path, delta) -> bool - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param n: int - @param path: qvector< tid_t > const & - @param delta: adiff_t - -ida_bytes.oword_flag (function) - oword_flag() -> flags64_t - Get a flags64_t representing a octaword. - -ida_bytes.packreal_flag (function) - packreal_flag() -> flags64_t - Get a flags64_t representing a packed decimal real. - -ida_bytes.parse_binpat_str (function) - parse_binpat_str(out, ea, _in, radix, strlits_encoding=0) -> str - Convert user-specified binary string to internal representation. The 'in' - parameter contains space-separated tokens: - - numbers (numeric base is determined by 'radix') - - if value of number fits a byte, it is considered as a byte - - if value of number fits a word, it is considered as 2 bytes - - if value of number fits a dword,it is considered as 4 bytes - - "..." string constants - - 'x' single-character constants - - ? variable bytes - - Note that string constants are surrounded with double quotes. - - Here are a few examples (assuming base 16): - CD 21 - bytes 0xCD, 0x21 - 21CD - bytes 0xCD, 0x21 (little endian ) or 0x21, 0xCD (big-endian) - "Hello", 0 - the null terminated string "Hello" - L"Hello" - 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0 - B8 ? ? ? ? 90 - byte 0xB8, 4 bytes with any value, byte 0x90 - - @param out: (C++: compiled_binpat_vec_t *) a vector of compiled binary patterns, for use with bin_search2() - @param ea: (C++: ea_t) linear address to convert for (the conversion depends on the address, - because the number of bits in a byte depend on the segment type) - @param in: (C++: const char *) input text string - @param radix: (C++: int) numeric base of numbers (8,10,16) - @param strlits_encoding: (C++: int) the target encoding into which the string literals - present in 'in', should be encoded. Can be any from [1, - get_encoding_qty()), or the special values PBSENC_* - @return: false either in case of parsing error, or if at least one requested - target encoding couldn't encode the string literals present in "in". - -ida_bytes.patch_byte (function) - patch_byte(ea, x) -> bool - Patch a byte of the program. The original value of the byte is saved and can be - obtained by get_original_byte(). This function works for wide byte processors - too. - @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) - -ida_bytes.patch_bytes (function) - patch_bytes(ea, buf) - Patch the specified number of bytes of the program. Original values of bytes are - saved and are available with get_original...() functions. See also put_bytes(). - - @param ea: (C++: ea_t) linear address - @param buf: (C++: const void *) buffer with new values of bytes - -ida_bytes.patch_dword (function) - patch_dword(ea, x) -> bool - Patch a dword of the program. The original value of the dword is saved and can - be obtained by get_original_dword(). This function DOESN'T work for wide byte - processors. This function takes into account order of bytes specified in - idainfo::is_be() - @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) - -ida_bytes.patch_qword (function) - patch_qword(ea, x) -> bool - Patch a qword of the program. The original value of the qword is saved and can - be obtained by get_original_qword(). This function DOESN'T work for wide byte - processors. This function takes into account order of bytes specified in - idainfo::is_be() - @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) - -ida_bytes.patch_word (function) - patch_word(ea, x) -> bool - Patch a word of the program. The original value of the word is saved and can be - obtained by get_original_word(). This function works for wide byte processors - too. This function takes into account order of bytes specified in - idainfo::is_be() - @retval true: the database has been modified, - @retval false: the debugger is running and the process' memory has value 'x' at - address 'ea', or the debugger is not running, and the IDB has - value 'x' at address 'ea already. - - @param ea: (C++: ea_t) - @param x: (C++: uint64) - -ida_bytes.prev_addr (function) - prev_addr(ea) -> ea_t - Get previous address in the program. - - @param ea: (C++: ea_t) - @return: BADADDR if no such address exist. - -ida_bytes.prev_chunk (function) - prev_chunk(ea) -> ea_t - Get the last address of previous contiguous chunk in the program. - - @param ea: (C++: ea_t) - @return: BADADDR if previous chunk doesn't exist. - -ida_bytes.prev_head (function) - prev_head(ea, minea) -> ea_t - Get start of previous defined item. - - @param ea: (C++: ea_t) begin search at this address - @param minea: (C++: ea_t) included in the search range - @return: BADADDR if none exists. - -ida_bytes.prev_inited (function) - prev_inited(ea, minea) -> ea_t - Find the previous initialized address. - - @param ea: (C++: ea_t) - @param minea: (C++: ea_t) - -ida_bytes.prev_not_tail (function) - prev_not_tail(ea) -> ea_t - Get address of previous non-tail byte. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. - -ida_bytes.prev_that (function) - prev_that(ea, minea, testf) -> ea_t - Find previous address with a flag satisfying the function 'testf'. - @note: do not pass is_unknown() to this function to find unexplored bytes It - will fail under the debugger. To find unexplored bytes, use - prev_unknown(). - - @param ea: (C++: ea_t) start searching from this address - 1. - @param minea: (C++: ea_t) included in the search range. - @param testf: (C++: testf_t *) test function to find previous address - @return: the found address or BADADDR. - -ida_bytes.prev_unknown (function) - prev_unknown(ea, minea) -> ea_t - Similar to prev_that(), but will find the previous address that is unexplored. - - @param ea: (C++: ea_t) - @param minea: (C++: ea_t) - -ida_bytes.prev_visea (function) - prev_visea(ea) -> ea_t - Get previous visible address. - - @param ea: (C++: ea_t) - @return: BADADDR if none exists. - -ida_bytes.print_strlit_type (function) - print_strlit_type(strtype, flags=0) -> (str, str) - Get string type information: the string type name (possibly decorated with - hotkey markers), and the tooltip. - - @param strtype: (C++: int32) the string type - @param flags: (C++: int) or'ed PSTF_* constants - @return: length of generated text - -ida_bytes.put_byte (function) - put_byte(ea, x) -> bool - Set value of one byte of the program. This function modifies the database. If - the debugger is active then the debugged process memory is patched too. - @note: The original value of the byte is completely lost and can't be recovered - by the get_original_byte() function. See also put_dbg_byte() to write to - the process memory directly when the debugger is active. This function - can handle wide byte processors. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint64) byte value - @return: true if the database has been modified - -ida_bytes.put_bytes (function) - put_bytes(ea, buf) - Modify the specified number of bytes of the program. This function does not save - the original values of bytes. See also patch_bytes(). - - @param ea: (C++: ea_t) linear address - @param buf: (C++: const void *) buffer with new values of bytes - -ida_bytes.put_dword (function) - put_dword(ea, x) - Set value of one dword of the program. This function takes into account order of - bytes specified in idainfo::is_be() This function works for wide byte processors - too. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint64) dword value - @note: the original value of the dword is completely lost and can't be recovered - by the get_original_dword() function. - -ida_bytes.put_qword (function) - put_qword(ea, x) - Set value of one qword (8 bytes) of the program. This function takes into - account order of bytes specified in idainfo::is_be() This function DOESN'T works - for wide byte processors. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint64) qword value - -ida_bytes.put_word (function) - put_word(ea, x) - Set value of one word of the program. This function takes into account order of - bytes specified in idainfo::is_be() This function works for wide byte processors - too. - @note: The original value of the word is completely lost and can't be recovered - by the get_original_word() function. ea - linear address x - word value - - @param ea: (C++: ea_t) - @param x: (C++: uint64) - -ida_bytes.qword_flag (function) - qword_flag() -> flags64_t - Get a flags64_t representing a quad word. - -ida_bytes.register_custom_data_format (function) - register_custom_data_format(py_df) -> int - Registers a custom data format with a given data type. - - @param py_df: an instance of data_format_t - @return: < 0 if failed to register - > 0 data format id - -ida_bytes.register_custom_data_type (function) - register_custom_data_type(py_dt) -> int - Registers a custom data type. - - @param py_dt: an instance of the data_type_t class - @return: < 0 if failed to register - > 0 data type id - -ida_bytes.register_data_types_and_formats (function) - Registers multiple data types and formats at once. - To register one type/format at a time use register_custom_data_type/register_custom_data_format - - It employs a special table of types and formats described below: - - The 'formats' is a list of tuples. If a tuple has one element then it is the format to be registered with dtid=0 - If the tuple has more than one element, then tuple[0] is the data type and tuple[1:] are the data formats. For example: - many_formats = [ - (pascal_data_type(), pascal_data_format()), - (simplevm_data_type(), simplevm_data_format()), - (makedword_data_format(),), - (simplevm_data_format(),) - ] - The first two tuples describe data types and their associated formats. - The last two tuples describe two data formats to be used with built-in data types. - The data format may be attached to several data types. The id of the - data format is stored in the first data_format_t object. For example: - assert many_formats[1][1] != -1 - assert many_formats[2][0] != -1 - assert many_formats[3][0] == -1 - -ida_bytes.register_data_types_and_formats.__reg_format (function) - -ida_bytes.register_data_types_and_formats.__reg_type (function) - -ida_bytes.revert_byte (function) - revert_byte(ea) -> bool - Revert patched byte - @retval true: byte was patched before and reverted now - - @param ea: (C++: ea_t) - -ida_bytes.seg_flag (function) - seg_flag() -> flags64_t - see FF_opbits - -ida_bytes.set_cmt (function) - set_cmt(ea, comm, rptble) -> bool - Set an indented comment. - - @param ea: (C++: ea_t) linear address - @param comm: (C++: const char *) comment string - * nullptr: do nothing (return 0) - * "" : delete comment - @param rptble: (C++: bool) is repeatable? - @return: success - -ida_bytes.set_forced_operand (function) - set_forced_operand(ea, n, op) -> bool - Set forced operand. - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number - @param op: (C++: const char *) text of operand - * nullptr: do nothing (return 0) - * "" : delete forced operand - @return: success - -ida_bytes.set_immd (function) - set_immd(ea) -> bool - Set 'has immediate operand' flag. Returns true if the FF_IMMD bit was not set - and now is set - - @param ea: (C++: ea_t) - -ida_bytes.set_lzero (function) - set_lzero(ea, n) -> bool - Set toggle lzero bit. This function changes the display of leading zeroes for - the specified operand. If the default is not to display leading zeroes, this - function will display them and vice versa. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success - -ida_bytes.set_manual_insn (function) - set_manual_insn(ea, manual_insn) - Set manual instruction string. - - @param ea: (C++: ea_t) linear address of the instruction or data item - @param manual_insn: (C++: const char *) "" - delete manual string. nullptr - do nothing - -ida_bytes.set_op_type (function) - set_op_type(ea, type, n) -> bool - (internal function) change representation of operand(s). - - @param ea: (C++: ea_t) linear address - @param type: (C++: flags64_t) new flag value (should be obtained from char_flag(), num_flag() and - similar functions) - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands - @retval 1: ok - @retval 0: failed (applied to a tail byte) - -ida_bytes.set_opinfo (function) - set_opinfo(ea, n, flag, ti, suppress_events=False) -> bool - Set additional information about an operand representation. This function is a - low level one. Only the kernel should use it. - - @param ea: (C++: ea_t) linear address of the item - @param n: (C++: int) number of operand, 0 or 1 (see the note below) - @param flag: (C++: flags64_t) flags of the item - @param ti: (C++: const opinfo_t *) additional representation information - @param suppress_events: (C++: bool) do not generate changing_op_type and op_type_changed - events - @return: success - @note: for custom formats (if is_custfmt(flag, n) is true) or for offsets (if - is_off(flag, n) is true) N can be in range 0..UA_MAXOP-1 or equal to - OPND_ALL. In the case of OPND_ALL the additional information about all - operands will be set. - -ida_bytes.stkvar_flag (function) - stkvar_flag() -> flags64_t - see FF_opbits - -ida_bytes.strlit_flag (function) - strlit_flag() -> flags64_t - Get a flags64_t representing a string literal. - -ida_bytes.stroff_flag (function) - stroff_flag() -> flags64_t - see FF_opbits - -ida_bytes.stru_flag (function) - stru_flag() -> flags64_t - Get a flags64_t representing a struct. - -ida_bytes.tbyte_flag (function) - tbyte_flag() -> flags64_t - Get a flags64_t representing a tbyte. - -ida_bytes.toggle_bnot (function) - toggle_bnot(ea, n) -> bool - Toggle binary negation of operand. also see is_bnot() - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.toggle_lzero (function) - toggle_lzero(ea, n) -> bool - Toggle lzero bit. - - @param ea: (C++: ea_t) the item (insn/data) address - @param n: (C++: int) the operand number (0-first operand, 1-other operands) - @return: success - -ida_bytes.toggle_sign (function) - toggle_sign(ea, n) -> bool - Toggle sign of n-th operand. allowed values of n: 0-first operand, 1-other - operands - - @param ea: (C++: ea_t) - @param n: (C++: int) - -ida_bytes.unregister_custom_data_format (function) - unregister_custom_data_format(dfid) -> bool - Unregisters a custom data format - - @param dfid: data format id - @return: Boolean - -ida_bytes.unregister_custom_data_type (function) - unregister_custom_data_type(dtid) -> bool - Unregisters a custom data type. - - @param dtid: the data type id - @return: Boolean - -ida_bytes.unregister_data_types_and_formats (function) - As opposed to register_data_types_and_formats(), this function - unregisters multiple data types and formats at once. - -ida_bytes.unregister_data_types_and_formats.__unreg_format (function) - -ida_bytes.unregister_data_types_and_formats.__unreg_type (function) - -ida_bytes.update_hidden_range (function) - update_hidden_range(ha) -> bool - Update hidden range information in the database. You cannot use this function to - change the range boundaries - - @param ha: (C++: const hidden_range_t *) range to update - @return: success - -ida_bytes.use_mapping (function) - use_mapping(ea) -> ea_t - Translate address according to current mappings. - - @param ea: (C++: ea_t) address to translate - @return: translated address - -ida_bytes.visit_patched_bytes (function) - 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 py_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. - -ida_bytes.word_flag (function) - word_flag() -> flags64_t - Get a flags64_t representing a word. - -ida_bytes.yword_flag (function) - yword_flag() -> flags64_t - Get a flags64_t representing a ymm word. - -ida_bytes.zword_flag (function) - zword_flag() -> flags64_t - Get a flags64_t representing a zmm word. - -ida_dbg (module) - Contains functions to control the debugging of a process. - - See Debugger functions for a complete explanation of these functions. - - These functions are inlined for the kernel. They are not inlined for the user- - interfaces. - -ida_dbg.BKPT_ACTIVE (variable) - active? - -ida_dbg.BKPT_BADBPT (variable) - failed to write the bpt to the process memory (at least one location) - -ida_dbg.BKPT_CNDREADY (variable) - condition has been compiled - -ida_dbg.BKPT_FAKEPEND (variable) - fake pending bpt: it is inactive but another bpt of the same type is active at - the same address(es) - -ida_dbg.BKPT_LISTBPT (variable) - include in bpt list (user-defined bpt) - -ida_dbg.BKPT_PAGE (variable) - written to the process as a page bpt. Available only after writing the bpt to - the process. - -ida_dbg.BKPT_PARTIAL (variable) - partially active? (some locations were not written yet) - -ida_dbg.BKPT_TRACE (variable) - trace bpt; should not be deleted when the process gets suspended - -ida_dbg.BPLT_ABS (variable) - absolute address: ea - -ida_dbg.BPLT_REL (variable) - relative address: module_path, offset - -ida_dbg.BPLT_SRC (variable) - source level: filename, lineno - -ida_dbg.BPTCK_ACT (variable) - breakpoint is active (written to the process) - -ida_dbg.BPTCK_NO (variable) - breakpoint is disabled - -ida_dbg.BPTCK_NONE (variable) - breakpoint does not exist - -ida_dbg.BPTCK_YES (variable) - breakpoint is enabled - -ida_dbg.BPTEV_ADDED (variable) - Breakpoint has been added. - -ida_dbg.BPTEV_CHANGED (variable) - Breakpoint has been modified. - -ida_dbg.BPTEV_REMOVED (variable) - Breakpoint has been removed. - -ida_dbg.BPT_BRK (variable) - suspend execution upon hit - -ida_dbg.BPT_ELANG_SHIFT (variable) - index of the extlang (scripting language) of the condition - -ida_dbg.BPT_ENABLED (variable) - enabled? - -ida_dbg.BPT_LOWCND (variable) - condition is calculated at low level (on the server side) - -ida_dbg.BPT_TRACE (variable) - add trace information upon hit - -ida_dbg.BPT_TRACEON (variable) - enable tracing when the breakpoint is reached - -ida_dbg.BPT_TRACE_BBLK (variable) - basic block tracing - -ida_dbg.BPT_TRACE_FUNC (variable) - function tracing - -ida_dbg.BPT_TRACE_INSN (variable) - instruction tracing - -ida_dbg.BPT_TRACE_TYPES (variable) - trace insns, functions, and basic blocks. if any of BPT_TRACE_TYPES bits are set - but BPT_TRACEON is clear, then turn off tracing for the specified trace types - -ida_dbg.BPT_UPDMEM (variable) - refresh the memory layout and contents before evaluating bpt condition - -ida_dbg.BT_LOG_INSTS (variable) - specific options for basic block tracing (see set_bblk_trace_options()) - - log all instructions in the current basic block - -ida_dbg.DBGINV_ALL (variable) - invalidate everything - -ida_dbg.DBGINV_MEMCFG (variable) - invalidate cached process segmentation - -ida_dbg.DBGINV_MEMORY (variable) - invalidate cached memory contents - -ida_dbg.DBGINV_NONE (variable) - invalidate nothing - -ida_dbg.DBGINV_REDRAW (variable) - refresh the screen - -ida_dbg.DBGINV_REGS (variable) - invalidate cached register values - -ida_dbg.DBG_Hooks (class) - Proxy of C++ DBG_Hooks class. - -ida_dbg.DBG_Hooks.__disown__ (method) - -ida_dbg.DBG_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> DBG_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 - -ida_dbg.DBG_Hooks.dbg_bpt (method) - dbg_bpt(self, tid, bptea) -> int - A user defined breakpoint was reached. - - @param tid: (thid_t) - @param bptea: (::ea_t) - -ida_dbg.DBG_Hooks.dbg_bpt_changed (method) - dbg_bpt_changed(self, bptev_code, bpt) - Breakpoint has been changed. - - @param bptev_code: (int) Breakpoint modification events - @param bpt: (bpt_t *) - -ida_dbg.DBG_Hooks.dbg_exception (method) - dbg_exception(self, pid, tid, ea, exc_code, exc_can_cont, exc_ea, exc_info) -> int - - @param event: (const debug_event_t *) - @param warn: (int *) filled with: - * -1: display an exception warning dialog if the process is suspended. - * 0: never display an exception warning dialog. - * 1: always display an exception warning dialog. - @param ea: ea_t - @param exc_code: int - @param exc_can_cont: bool - @param exc_ea: ea_t - @param exc_info: char const * - -ida_dbg.DBG_Hooks.dbg_finished_loading_bpts (method) - dbg_finished_loading_bpts(self) - Finished loading breakpoint info from idb. - -ida_dbg.DBG_Hooks.dbg_information (method) - dbg_information(self, pid, tid, ea, info) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param info: char const * - -ida_dbg.DBG_Hooks.dbg_library_load (method) - dbg_library_load(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param modinfo_name: char const * - @param modinfo_base: ea_t - @param modinfo_size: asize_t - -ida_dbg.DBG_Hooks.dbg_library_unload (method) - dbg_library_unload(self, pid, tid, ea, info) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param info: char const * - -ida_dbg.DBG_Hooks.dbg_process_attach (method) - dbg_process_attach(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t - @param modinfo_name: char const * - @param modinfo_base: ea_t - @param modinfo_size: asize_t - -ida_dbg.DBG_Hooks.dbg_process_detach (method) - dbg_process_detach(self, pid, tid, ea) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t - -ida_dbg.DBG_Hooks.dbg_process_exit (method) - dbg_process_exit(self, pid, tid, ea, exit_code) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t - @param exit_code: int - -ida_dbg.DBG_Hooks.dbg_process_start (method) - dbg_process_start(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size) - - @param event: (const debug_event_t *) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - @param tid: thid_t - @param ea: ea_t - @param modinfo_name: char const * - @param modinfo_base: ea_t - @param modinfo_size: asize_t - -ida_dbg.DBG_Hooks.dbg_request_error (method) - dbg_request_error(self, failed_command, failed_dbg_notification) - An error occurred during the processing of a request. - - @param failed_command: (ui_notification_t) - @param failed_dbg_notification: (dbg_notification_t) - -ida_dbg.DBG_Hooks.dbg_run_to (method) - dbg_run_to(self, pid, tid, ea) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - -ida_dbg.DBG_Hooks.dbg_started_loading_bpts (method) - dbg_started_loading_bpts(self) - Started loading breakpoint info from idb. - -ida_dbg.DBG_Hooks.dbg_step_into (method) - dbg_step_into(self) - -ida_dbg.DBG_Hooks.dbg_step_over (method) - dbg_step_over(self) - -ida_dbg.DBG_Hooks.dbg_step_until_ret (method) - dbg_step_until_ret(self) - -ida_dbg.DBG_Hooks.dbg_suspend_process (method) - dbg_suspend_process(self) - The process is now suspended. - -ida_dbg.DBG_Hooks.dbg_thread_exit (method) - dbg_thread_exit(self, pid, tid, ea, exit_code) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - @param exit_code: int - -ida_dbg.DBG_Hooks.dbg_thread_start (method) - dbg_thread_start(self, pid, tid, ea) - - @param event: (const debug_event_t *) - @param tid: thid_t - @param ea: ea_t - -ida_dbg.DBG_Hooks.dbg_trace (method) - dbg_trace(self, tid, ip) -> int - A step occurred (one instruction was executed). This event notification is only - generated if step tracing is enabled. - - @param tid: (thid_t) thread ID - @param ip: (::ea_t) current instruction pointer. usually points after the - executed instruction - @retval 1: do not log this trace event - @retval 0: log it - -ida_dbg.DBG_Hooks.hook (method) - hook(self) -> bool - -ida_dbg.DBG_Hooks.unhook (method) - unhook(self) -> bool - -ida_dbg.DEC_ERROR (variable) - error - -ida_dbg.DEC_NOTASK (variable) - process does not exist - -ida_dbg.DEC_TIMEOUT (variable) - timeout - -ida_dbg.DOPT_BPT_MSGS (variable) - log breakpoints - -ida_dbg.DOPT_DISABLE_ASLR (variable) - disable ASLR - -ida_dbg.DOPT_END_BPT (variable) - evaluate event condition on process end - -ida_dbg.DOPT_ENTRY_BPT (variable) - break on program entry point - -ida_dbg.DOPT_EXCDLG (variable) - exception dialogs: - -ida_dbg.DOPT_FAST_STEP (variable) - prevent debugger memory refreshes when single-stepping - -ida_dbg.DOPT_INFO_BPT (variable) - break on debugging information - -ida_dbg.DOPT_INFO_MSGS (variable) - log debugging info events - -ida_dbg.DOPT_LIB_BPT (variable) - break on library load/unload - -ida_dbg.DOPT_LIB_MSGS (variable) - log library loads/unloads - -ida_dbg.DOPT_LOAD_DINFO (variable) - automatically load debug files (pdb) - -ida_dbg.DOPT_REAL_MEMORY (variable) - do not hide breakpoint instructions - -ida_dbg.DOPT_REDO_STACK (variable) - reconstruct the stack - -ida_dbg.DOPT_SEGM_MSGS (variable) - log debugger segments modifications - -ida_dbg.DOPT_START_BPT (variable) - break on process start - -ida_dbg.DOPT_TEMP_HWBPT (variable) - when possible use hardware bpts for temp bpts - -ida_dbg.DOPT_THREAD_BPT (variable) - break on thread start/exit - -ida_dbg.DOPT_THREAD_MSGS (variable) - log thread starts/exits - -ida_dbg.DSTATE_NOTASK (variable) - no process is currently debugged - -ida_dbg.DSTATE_RUN (variable) - process is running - -ida_dbg.DSTATE_SUSP (variable) - process is suspended and will not continue - -ida_dbg.EXCDLG_ALWAYS (variable) - always display - -ida_dbg.EXCDLG_NEVER (variable) - never display exception dialogs - -ida_dbg.EXCDLG_UNKNOWN (variable) - display for unknown exceptions - -ida_dbg.FT_LOG_RET (variable) - specific options for function tracing (see set_func_trace_options()) - - function tracing will log returning instructions - -ida_dbg.IT_LOG_SAME_IP (variable) - specific options for instruction tracing (see set_insn_trace_options()) - - instruction tracing will log new instructions even when IP doesn't change - -ida_dbg.SRCIT_EXPR (variable) - an expression (a+b*c) - -ida_dbg.SRCIT_FUNC (variable) - function - -ida_dbg.SRCIT_LOCVAR (variable) - a stack, register, or register-relative local variable or parameter - -ida_dbg.SRCIT_MODULE (variable) - module - -ida_dbg.SRCIT_NONE (variable) - unknown - -ida_dbg.SRCIT_STMT (variable) - a statement (if/while/for...) - -ida_dbg.SRCIT_STTVAR (variable) - static variable/code - -ida_dbg.ST_ALREADY_LOGGED (variable) - step tracing will be disabled when IP is already logged - -ida_dbg.ST_OPTIONS_MASK (variable) - mask of available options, to ensure compatibility with newer IDA versions - -ida_dbg.ST_OVER_DEBUG_SEG (variable) - step tracing will be disabled when IP is in a debugger segment - -ida_dbg.ST_OVER_LIB_FUNC (variable) - step tracing will be disabled when IP is in a library function - -ida_dbg.ST_SKIP_LOOPS (variable) - step tracing will try to skip loops already recorded - -ida_dbg.WFNE_ANY (variable) - return the first event (even if it doesn't suspend the process) - -ida_dbg.WFNE_CONT (variable) - continue from the suspended state - -ida_dbg.WFNE_NOWAIT (variable) - do not wait for any event, immediately return DEC_TIMEOUT (to be used with - WFNE_CONT) - -ida_dbg.WFNE_SILENT (variable) - 1: be silent, 0:display modal boxes if necessary - -ida_dbg.WFNE_SUSP (variable) - wait until the process gets suspended - -ida_dbg.WFNE_USEC (variable) - timeout is specified in microseconds (minimum non-zero timeout is 40000us) - -ida_dbg.add_bpt (function) - add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool - Add a new breakpoint in the debugged process. \sq{Type, Synchronous function - - available as request, Notification, none (synchronous function)} - - @param bpt: (C++: const bpt_t &) Breakpoint to add. It describes the break condition, type, flags, - location (module relative, source breakpoint or absolute) and other - attributes. - @param size: asize_t - @param type: bpttype_t - - add_bpt(bpt) -> bool - - @param bpt: bpt_t const & - -ida_dbg.add_path_mapping (function) - add_path_mapping(src, dst) - - @param src: char const * - @param dst: char const * - -ida_dbg.add_virt_module (function) - add_virt_module(mod) -> bool - - @param mod: modinfo_t const * - -ida_dbg.attach_process (function) - attach_process(pid=pid_t(-1), event_id=-1) -> int - Attach the debugger to a running process. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_process_attach} - @note: This function shouldn't be called as a request if NO_PROCESS is used. - - @param pid: (C++: pid_t) PID of the process to attach to. If NO_PROCESS, a dialog box will - interactively ask the user for the process to attach to. - @retval -4: debugger was not inited - @retval -3: the attaching is not supported - @retval -2: impossible to find a compatible process - @retval -1: impossible to attach to the given process (process died, privilege - needed, not supported by the debugger plugin, ...) - @retval 0: the user cancelled the attaching to the process - @retval 1: the debugger properly attached to the process - -ida_dbg.bpt_location_t (class) - Proxy of C++ bpt_location_t class. - -ida_dbg.bpt_location_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bpt_location_t const & - -ida_dbg.bpt_location_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bpt_location_t const & - -ida_dbg.bpt_location_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bpt_location_t const & - -ida_dbg.bpt_location_t.__init__ (method) - __init__(self) -> bpt_location_t - -ida_dbg.bpt_location_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bpt_location_t const & - -ida_dbg.bpt_location_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bpt_location_t const & - -ida_dbg.bpt_location_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bpt_location_t const & - -ida_dbg.bpt_location_t.compare (method) - compare(self, r) -> int - Lexically compare two breakpoint locations. Bpt locations are first compared - based on type (i.e. BPLT_ABS < BPLT_REL). BPLT_ABS locations are compared based - on their ea values. For all other location types, locations are first compared - based on their string (path/filename/symbol), then their offset/lineno. - - @param r: (C++: const bpt_location_t &) bpt_location_t const & - -ida_dbg.bpt_location_t.ea (method) - ea(self) -> ea_t - Get address (BPLT_ABS) - -ida_dbg.bpt_location_t.is_empty_path (method) - is_empty_path(self) -> bool - No path/filename specified? (BPLT_REL, BPLT_SRC) - -ida_dbg.bpt_location_t.lineno (method) - lineno(self) -> int - Get line number (BPLT_SRC) - -ida_dbg.bpt_location_t.offset (method) - offset(self) -> uval_t - Get offset (BPLT_REL, BPLT_SYM) - -ida_dbg.bpt_location_t.path (method) - path(self) -> char const * - Get path/filename (BPLT_REL, BPLT_SRC) - -ida_dbg.bpt_location_t.set_abs_bpt (method) - set_abs_bpt(self, a) - Specify an absolute address location. - - @param a: (C++: ea_t) - -ida_dbg.bpt_location_t.set_rel_bpt (method) - set_rel_bpt(self, mod, _offset) - Specify a relative address location. - - @param mod: (C++: const char *) char const * - @param _offset: (C++: uval_t) - -ida_dbg.bpt_location_t.set_src_bpt (method) - set_src_bpt(self, fn, _lineno) - Specify a source level location. - - @param fn: (C++: const char *) char const * - @param _lineno: (C++: int) - -ida_dbg.bpt_location_t.set_sym_bpt (method) - set_sym_bpt(self, _symbol, _offset=0) - Specify a symbolic location. - - @param _symbol: (C++: const char *) char const * - @param _offset: (C++: uval_t) - -ida_dbg.bpt_location_t.symbol (method) - symbol(self) -> char const * - Get symbol name (BPLT_SYM) - -ida_dbg.bpt_location_t.type (method) - type(self) -> bpt_loctype_t - Get bpt type. - -ida_dbg.bpt_t (class) - Proxy of C++ bpt_t class. - -ida_dbg.bpt_t.__init__ (method) - __init__(self) -> bpt_t - -ida_dbg.bpt_t.badbpt (method) - badbpt(self) -> bool - Failed to write bpt to process memory? - -ida_dbg.bpt_t.bptid (variable) - Internal breakpoint id. - -ida_dbg.bpt_t.cb (variable) - size of this structure - -ida_dbg.bpt_t.cndidx (variable) - Internal number of the condition (<0-none) - -ida_dbg.bpt_t.ea (variable) - Address, if known. For BPLT_SRC, index into an internal data struct. - -ida_dbg.bpt_t.enabled (method) - enabled(self) -> bool - Is breakpoint enabled? - -ida_dbg.bpt_t.flags (variable) - Breakpoint property bits - -ida_dbg.bpt_t.get_cnd_elang_idx (method) - get_cnd_elang_idx(self) -> size_t - -ida_dbg.bpt_t.get_size (method) - get_size(self) -> int - Get bpt size. - -ida_dbg.bpt_t.is_absbpt (method) - is_absbpt(self) -> bool - Is absolute address breakpoint? - -ida_dbg.bpt_t.is_active (method) - is_active(self) -> bool - Written completely to process? - -ida_dbg.bpt_t.is_compiled (method) - is_compiled(self) -> bool - Condition has been compiled? - -ida_dbg.bpt_t.is_hwbpt (method) - is_hwbpt(self) -> bool - Is hardware breakpoint? - -ida_dbg.bpt_t.is_inactive (method) - is_inactive(self) -> bool - Not written to process at all? - -ida_dbg.bpt_t.is_low_level (method) - is_low_level(self) -> bool - Is bpt condition calculated at low level? - -ida_dbg.bpt_t.is_page_bpt (method) - is_page_bpt(self) -> bool - Page breakpoint? - -ida_dbg.bpt_t.is_partially_active (method) - is_partially_active(self) -> bool - Written partially to process? - -ida_dbg.bpt_t.is_relbpt (method) - is_relbpt(self) -> bool - Is relative address breakpoint? - -ida_dbg.bpt_t.is_srcbpt (method) - is_srcbpt(self) -> bool - Is source level breakpoint? - -ida_dbg.bpt_t.is_symbpt (method) - is_symbpt(self) -> bool - Is symbolic breakpoint? - -ida_dbg.bpt_t.is_tracemodebpt (method) - is_tracemodebpt(self) -> bool - Does breakpoint trace anything? - -ida_dbg.bpt_t.is_traceoffbpt (method) - is_traceoffbpt(self) -> bool - Is this a tracing breakpoint, and is tracing disabled? - -ida_dbg.bpt_t.is_traceonbpt (method) - is_traceonbpt(self) -> bool - Is this a tracing breakpoint, and is tracing enabled? - -ida_dbg.bpt_t.listbpt (method) - listbpt(self) -> bool - Include in the bpt list? - -ida_dbg.bpt_t.loc (variable) - Location. - -ida_dbg.bpt_t.pass_count (variable) - Number of times the breakpoint is hit before stopping (default is 0: stop - always) - -ida_dbg.bpt_t.pid (variable) - breakpoint process id - -ida_dbg.bpt_t.props (variable) - Internal breakpoint properties - -ida_dbg.bpt_t.set_abs_bpt (method) - set_abs_bpt(self, a) - Set bpt location to an absolute address. - - @param a: (C++: ea_t) - -ida_dbg.bpt_t.set_rel_bpt (method) - set_rel_bpt(self, mod, o) - Set bpt location to a relative address. - - @param mod: (C++: const char *) char const * - @param o: (C++: uval_t) - -ida_dbg.bpt_t.set_src_bpt (method) - set_src_bpt(self, fn, lineno) - Set bpt location to a source line. - - @param fn: (C++: const char *) char const * - @param lineno: (C++: int) - -ida_dbg.bpt_t.set_sym_bpt (method) - set_sym_bpt(self, sym, o) - Set bpt location to a symbol. - - @param sym: (C++: const char *) char const * - @param o: (C++: uval_t) - -ida_dbg.bpt_t.set_trace_action (method) - set_trace_action(self, enable, trace_types) -> bool - Configure tracing options. - - @param enable: (C++: bool) - @param trace_types: (C++: int) - -ida_dbg.bpt_t.size (variable) - Size of the breakpoint (0 for software breakpoints) - -ida_dbg.bpt_t.tid (variable) - breakpoint thread id - -ida_dbg.bpt_t.type (variable) - Breakpoint type. - -ida_dbg.bpt_vec_t (class) - Proxy of C++ qvector< bpt_t > class. - -ida_dbg.bpt_vec_t.__getitem__ (method) - __getitem__(self, i) -> bpt_t - - @param i: size_t - -ida_dbg.bpt_vec_t.__init__ (method) - __init__(self) -> bpt_vec_t - __init__(self, x) -> bpt_vec_t - - @param x: qvector< bpt_t > const & - -ida_dbg.bpt_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_dbg.bpt_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: bpt_t const & - -ida_dbg.bpt_vec_t.at (method) - at(self, _idx) -> bpt_t - - @param _idx: size_t - -ida_dbg.bpt_vec_t.begin (method) - begin(self) -> bpt_t - -ida_dbg.bpt_vec_t.capacity (method) - capacity(self) -> size_t - -ida_dbg.bpt_vec_t.clear (method) - clear(self) - -ida_dbg.bpt_vec_t.empty (method) - empty(self) -> bool - -ida_dbg.bpt_vec_t.end (method) - end(self) -> bpt_t - -ida_dbg.bpt_vec_t.erase (method) - erase(self, it) -> bpt_t - - @param it: qvector< bpt_t >::iterator - - erase(self, first, last) -> bpt_t - - @param first: qvector< bpt_t >::iterator - @param last: qvector< bpt_t >::iterator - -ida_dbg.bpt_vec_t.extract (method) - extract(self) -> bpt_t - -ida_dbg.bpt_vec_t.grow (method) - grow(self, x=bpt_t()) - - @param x: bpt_t const & - -ida_dbg.bpt_vec_t.inject (method) - inject(self, s, len) - - @param s: bpt_t * - @param len: size_t - -ida_dbg.bpt_vec_t.insert (method) - insert(self, it, x) -> bpt_t - - @param it: qvector< bpt_t >::iterator - @param x: bpt_t const & - -ida_dbg.bpt_vec_t.pop_back (method) - pop_back(self) - -ida_dbg.bpt_vec_t.push_back (method) - push_back(self, x) - - @param x: bpt_t const & - - push_back(self) -> bpt_t - -ida_dbg.bpt_vec_t.qclear (method) - qclear(self) - -ida_dbg.bpt_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_dbg.bpt_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: bpt_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_dbg.bpt_vec_t.size (method) - size(self) -> size_t - -ida_dbg.bpt_vec_t.swap (method) - swap(self, r) - - @param r: qvector< bpt_t > & - -ida_dbg.bpt_vec_t.truncate (method) - truncate(self) - -ida_dbg.bptaddrs_t (class) - Proxy of C++ bptaddrs_t class. - -ida_dbg.bptaddrs_t.__init__ (method) - __init__(self) -> bptaddrs_t - -ida_dbg.bring_debugger_to_front (function) - bring_debugger_to_front() - -ida_dbg.check_bpt (function) - check_bpt(ea) -> int - Check the breakpoint at the specified address. - - @param ea: (C++: ea_t) - @return: one of Breakpoint status codes - -ida_dbg.choose_trace_file (function) - choose_trace_file() -> str - Show the choose trace dialog. - -ida_dbg.clear_requests_queue (function) - clear_requests_queue() - Clear the queue of waiting requests. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - @note: If a request is currently running, this one isn't stopped. - -ida_dbg.clear_trace (function) - clear_trace() - Clear all events in the trace buffer. \sq{Type, Synchronous function - available - as request, Notification, none (synchronous function)} - -ida_dbg.collect_stack_trace (function) - collect_stack_trace(tid, trace) -> bool - - @param tid: thid_t - @param trace: call_stack_t * - -ida_dbg.continue_process (function) - continue_process() -> bool - Continue the execution of the process in the debugger. \sq{Type, Synchronous - function - available as Request, Notification, none (synchronous function)} - @note: The continue_process() function can be called from a notification handler - to force the continuation of the process. In this case the request queue - will not be examined, IDA will simply resume execution. Usually it makes - sense to call request_continue_process() followed by run_requests(), so - that IDA will first start a queued request (if any) and then resume the - application. - -ida_dbg.create_source_viewer (function) - create_source_viewer(out_ccv, parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t * - Create a source code view. - - @param out_ccv: (C++: TWidget **) - @param parent: (C++: TWidget *) - @param custview: (C++: TWidget *) - @param sf: (C++: source_file_ptr) - @param lines: (C++: strvec_t *) - @param lnnum: (C++: int) - @param colnum: (C++: int) - @param flags: (C++: int) - -ida_dbg.dbg_add_bpt_tev (function) - dbg_add_bpt_tev(tid, ea, bp) -> bool - Add a new breakpoint trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param ea: (C++: ea_t) - @param bp: (C++: ea_t) - @return: false if the operation failed, true otherwise - -ida_dbg.dbg_add_call_tev (function) - dbg_add_call_tev(tid, caller, callee) - Add a new call trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param caller: (C++: ea_t) - @param callee: (C++: ea_t) - -ida_dbg.dbg_add_debug_event (function) - dbg_add_debug_event(event) - Add a new debug event to the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param event: (C++: debug_event_t *) - -ida_dbg.dbg_add_insn_tev (function) - dbg_add_insn_tev(tid, ea, save=SAVE_DIFF) -> bool - Add a new instruction trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param ea: (C++: ea_t) - @param save: (C++: save_reg_values_t) enum save_reg_values_t - @return: false if the operation failed, true otherwise - -ida_dbg.dbg_add_many_tevs (function) - dbg_add_many_tevs(new_tevs) -> bool - Add many new trace elements to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param new_tevs: (C++: tevinforeg_vec_t *) - @return: false if the operation failed for any tev_info_t object - -ida_dbg.dbg_add_ret_tev (function) - dbg_add_ret_tev(tid, ret_insn, return_to) - Add a new return trace element to the current trace. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - @param ret_insn: (C++: ea_t) - @param return_to: (C++: ea_t) - -ida_dbg.dbg_add_tev (function) - dbg_add_tev(type, tid, address) - Add a new trace element to the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param type: (C++: tev_type_t) enum tev_type_t - @param tid: (C++: thid_t) - @param address: (C++: ea_t) - -ida_dbg.dbg_add_thread (function) - dbg_add_thread(tid) - Add a thread to the current trace. \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @param tid: (C++: thid_t) - -ida_dbg.dbg_bin_search (function) - dbg_bin_search(start_ea, end_ea, data, srch_flags) -> str - - @param start_ea: ea_t - @param end_ea: ea_t - @param data: compiled_binpat_vec_t const & - @param srch_flags: int - -ida_dbg.dbg_bpt (variable) - A user defined breakpoint was reached. - -ida_dbg.dbg_bpt_changed (variable) - Breakpoint has been changed. - -ida_dbg.dbg_can_query (function) - 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 - -ida_dbg.dbg_del_thread (function) - dbg_del_thread(tid) - Delete a thread from the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param tid: (C++: thid_t) - -ida_dbg.dbg_finished_loading_bpts (variable) - Finished loading breakpoint info from idb. - -ida_dbg.dbg_is_loaded (function) - dbg_is_loaded() -> bool - Checks if a debugger is loaded - - @return: Boolean - -ida_dbg.dbg_last (variable) - The last debugger notification code. - -ida_dbg.dbg_process_attach (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - -ida_dbg.dbg_process_detach (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - -ida_dbg.dbg_process_exit (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - -ida_dbg.dbg_process_start (variable) - @note: This event notification is also an asynchronous function result - notification for start_process() ! - -ida_dbg.dbg_request_error (variable) - An error occurred during the processing of a request. - -ida_dbg.dbg_started_loading_bpts (variable) - Started loading breakpoint info from idb. - -ida_dbg.dbg_suspend_process (variable) - The process is now suspended. - - @note: This event notification is also an asynchronous function result - notification for suspend_process() ! - -ida_dbg.dbg_trace (variable) - A step occurred (one instruction was executed). This event notification is only - generated if step tracing is enabled. - - @retval 1: do not log this trace event - @retval 0: log it - -ida_dbg.define_exception (function) - define_exception(code, name, desc, flags) -> char const * - Convenience function: define new exception code. - - @param code: (C++: uint) exception code (cannot be 0) - @param name: (C++: const char *) exception name (cannot be empty or nullptr) - @param desc: (C++: const char *) exception description (maybe nullptr) - @param flags: (C++: int) combination of Exception info flags - @return: failure message or nullptr. You must call store_exceptions() if this - function succeeds - -ida_dbg.del_bpt (function) - del_bpt(ea) -> bool - Delete an existing breakpoint in the debugged process. \sq{Type, Synchronous - function - available as request, Notification, none (synchronous function)} - - @param bptloc: (C++: const bpt_location_t &) Breakpoint location - del_bpt(bptloc) -> bool - - @param bptloc: bpt_location_t const & - -ida_dbg.del_bptgrp (function) - del_bptgrp(name) -> bool - Delete a folder, bpt that were part of this folder are moved to the root folder - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @param name: (C++: const char *) full path to the folder to be deleted - @return: success - -ida_dbg.del_virt_module (function) - del_virt_module(base) -> bool - - @param base: ea_t const - -ida_dbg.detach_process (function) - detach_process() -> bool - Detach the debugger from the debugged process. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_process_detach} - -ida_dbg.diff_trace_file (function) - diff_trace_file(NONNULL_filename) -> bool - Show difference between the current trace and the one from 'filename'. - - @param NONNULL_filename: (C++: const char *) char const * - -ida_dbg.disable_bblk_trace (function) - disable_bblk_trace() -> bool - -ida_dbg.disable_bpt (function) - disable_bpt(ea) -> bool - - @param ea: ea_t - - disable_bpt(bptloc) -> bool - - @param bptloc: bpt_location_t const & - -ida_dbg.disable_func_trace (function) - disable_func_trace() -> bool - -ida_dbg.disable_insn_trace (function) - disable_insn_trace() -> bool - -ida_dbg.disable_step_trace (function) - disable_step_trace() -> bool - -ida_dbg.edit_manual_regions (function) - edit_manual_regions() - -ida_dbg.enable_bblk_trace (function) - enable_bblk_trace(enable=True) -> bool - - @param enable: bool - -ida_dbg.enable_bpt (function) - enable_bpt(ea, enable=True) -> bool - - @param ea: ea_t - @param enable: bool - - enable_bpt(bptloc, enable=True) -> bool - - @param bptloc: bpt_location_t const & - @param enable: bool - -ida_dbg.enable_bptgrp (function) - enable_bptgrp(bptgrp_name, enable=True) -> int - Enable (or disable) all bpts in a folder \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param bptgrp_name: (C++: const char *) absolute path to the folder - @param enable: (C++: bool) by default true, enable bpts, false disable bpts - @return: -1 an error occured 0 no changes >0 nubmers of bpts udpated - -ida_dbg.enable_func_trace (function) - enable_func_trace(enable=True) -> bool - - @param enable: bool - -ida_dbg.enable_insn_trace (function) - enable_insn_trace(enable=True) -> bool - - @param enable: bool - -ida_dbg.enable_manual_regions (function) - enable_manual_regions(enable) - - @param enable: bool - -ida_dbg.enable_step_trace (function) - enable_step_trace(enable=1) -> bool - - @param enable: int - -ida_dbg.eval_ctx_t (class) - Proxy of C++ eval_ctx_t class. - -ida_dbg.eval_ctx_t.__init__ (method) - __init__(self, _ea) -> eval_ctx_t - - @param _ea: ea_t - -ida_dbg.exist_bpt (function) - exist_bpt(ea) -> bool - Does a breakpoint exist at the given location? - - @param ea: (C++: ea_t) - -ida_dbg.exit_process (function) - exit_process() -> bool - Terminate the debugging of the current process. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_process_exit} - -ida_dbg.find_bpt (function) - find_bpt(bptloc, bpt) -> bool - Find a breakpoint by location. \sq{Type, Synchronous function - available as - request, Notification, none (synchronous function)} - - @param bptloc: (C++: const bpt_location_t &) Breakpoint location - @param bpt: (C++: bpt_t *) bpt is filled if the breakpoint was found - -ida_dbg.get_bblk_trace_options (function) - get_bblk_trace_options() -> int - Get current basic block tracing options. Also see BT_LOG_INSTS \sq{Type, - Synchronous function, Notification, none (synchronous function)} - -ida_dbg.get_bpt (function) - get_bpt(ea, bpt) -> bool - Get the characteristics of a breakpoint. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param ea: (C++: ea_t) any address in the breakpoint range - @param bpt: (C++: bpt_t *) if not nullptr, is filled with the characteristics. - @return: false if no breakpoint exists - -ida_dbg.get_bpt_group (function) - get_bpt_group(bptloc) -> str - Retrieve the absolute path to the folder of the bpt based on the bpt_location - find_bpt is called to retrieve the bpt \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param bptloc: (C++: const bpt_location_t &) bptlocation of the bpt - @return: breakpoint correclty moved to the directory - success - -ida_dbg.get_bpt_qty (function) - get_bpt_qty() -> int - Get number of breakpoints. \sq{Type, Synchronous function, Notification, none - (synchronous function)} - -ida_dbg.get_bpt_tev_ea (function) - get_bpt_tev_ea(n) -> ea_t - Get the address associated to a read, read/write or execution trace event. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @return: BADADDR if not a read, read/write or execution trace event. - @note: Usually, a breakpoint is associated with a read, read/write or execution - trace event. However, the returned address could be any address in the - range of this breakpoint. If the breakpoint was deleted after the trace - event, the address no longer corresponds to a valid breakpoint. - -ida_dbg.get_bptloc_string (function) - get_bptloc_string(i) -> char const * - - @param i: int - -ida_dbg.get_call_tev_callee (function) - get_call_tev_callee(n) -> ea_t - Get the called function from a function call trace event. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @return: BADADDR if not a function call event. - -ida_dbg.get_current_source_file (function) - get_current_source_file() -> str - -ida_dbg.get_current_source_line (function) - get_current_source_line() -> int - -ida_dbg.get_current_thread (function) - get_current_thread() -> thid_t - Get current thread ID. \sq{Type, Synchronous function, Notification, none - (synchronous function)} - -ida_dbg.get_dbg_byte (function) - get_dbg_byte(ea) -> bool - Get one byte of the debugged process memory. - - @param ea: (C++: ea_t) linear address - @return: true success - false address inaccessible or debugger not running - -ida_dbg.get_dbg_memory_info (function) - get_dbg_memory_info(ranges) -> int - - @param ranges: meminfo_vec_t * - -ida_dbg.get_dbg_reg_info (function) - get_dbg_reg_info(regname, ri) -> bool - Get register information \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param regname: (C++: const char *) char const * - @param ri: (C++: register_info_t *) - -ida_dbg.get_debug_event (function) - get_debug_event() -> debug_event_t - Get the current debugger event. - -ida_dbg.get_debugger_event_cond (function) - get_debugger_event_cond() -> char const * - -ida_dbg.get_first_module (function) - get_first_module(modinfo) -> bool - - @param modinfo: modinfo_t * - -ida_dbg.get_func_trace_options (function) - get_func_trace_options() -> int - Get current function tracing options. Also see FT_LOG_RET \sq{Type, Synchronous - function, Notification, none (synchronous function)} - -ida_dbg.get_global_var (function) - get_global_var(prov, ea, name, out) -> bool - - @param prov: srcinfo_provider_t * - @param ea: ea_t - @param name: char const * - @param out: source_item_ptr * - -ida_dbg.get_grp_bpts (function) - get_grp_bpts(bpts, grp_name) -> ssize_t - Retrieve a copy the bpts stored in a folder \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param bpts: (C++: bpt_vec_t *) : pointer to a vector where the copy of bpts are stored - @param grp_name: (C++: const char *) absolute path to the folder - @return: number of bpts present in the vector - -ida_dbg.get_insn_tev_reg_mem (function) - get_insn_tev_reg_mem(n, memmap) -> bool - Read the memory pointed by register values from an instruction trace event. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param memmap: (C++: memreg_infos_t *) result - @return: false if not an instruction event or no memory is available - -ida_dbg.get_insn_tev_reg_result (function) - get_insn_tev_reg_result(n, regname, regval) -> bool - - @param n: int - @param regname: char const * - @param regval: regval_t * - -ida_dbg.get_insn_tev_reg_val (function) - get_insn_tev_reg_val(n, regname, regval) -> bool - - @param n: int - @param regname: char const * - @param regval: regval_t * - -ida_dbg.get_insn_trace_options (function) - get_insn_trace_options() -> int - Get current instruction tracing options. Also see IT_LOG_SAME_IP \sq{Type, - Synchronous function, Notification, none (synchronous function)} - -ida_dbg.get_ip_val (function) - get_ip_val() -> bool - Get value of the IP (program counter) register for the current thread. Requires - a suspended debugger. - -ida_dbg.get_local_var (function) - get_local_var(prov, ea, name, out) -> bool - - @param prov: srcinfo_provider_t * - @param ea: ea_t - @param name: char const * - @param out: source_item_ptr * - -ida_dbg.get_local_vars (function) - get_local_vars(prov, ea, out) -> bool - - @param prov: srcinfo_provider_t * - @param ea: ea_t - @param out: source_items_t * - -ida_dbg.get_manual_regions (function) - get_manual_regions(ranges) - Returns the manual memory regions - - @param ranges: meminfo_vec_t * - - @return: list(start_ea, end_ea, name, sclass, sbase, bitness, perm) - get_manual_regions() -> [(int, int, str, str, int, int, int), ...] or None - -ida_dbg.get_module_info (function) - get_module_info(ea, modinfo) -> bool - - @param ea: ea_t - @param modinfo: modinfo_t * - -ida_dbg.get_next_module (function) - get_next_module(modinfo) -> bool - - @param modinfo: modinfo_t * - -ida_dbg.get_process_options (function) - get_process_options() - Get process options. Any of the arguments may be nullptr - -ida_dbg.get_process_state (function) - get_process_state() -> int - Return the state of the currently debugged process. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @return: one of Debugged process states - -ida_dbg.get_processes (function) - get_processes(proclist) -> ssize_t - Take a snapshot of running processes and return their description. \sq{Type, - Synchronous function, Notification, none (synchronous function)} - - @param proclist: (C++: procinfo_vec_t *) array with information about each running process - @return: number of processes or -1 on error - -ida_dbg.get_reg_val (function) - get_reg_val(regname, regval) -> bool - Get register value as an unsigned 64-bit int. - - @param regname: (C++: const char *) char const * - @param regval: regval_t * - - get_reg_val(regname, ival) -> bool - - @param regname: char const * - @param ival: uint64 * - - get_reg_val(regname) -> bool, float, int - - @param regname: char const * - -ida_dbg.get_reg_vals (function) - get_reg_vals(tid, clsmask=-1) -> regvals_t - Fetch live registers values for the thread - - @param tid: The ID of the thread to read registers for - @param clsmask: An OR'ed mask of register classes to - read values for (can be used to speed up the - retrieval process) - - @return: a regvals_t instance (empty if an error occurs) - -ida_dbg.get_ret_tev_return (function) - get_ret_tev_return(n) -> ea_t - Get the return address from a function return trace event. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @return: BADADDR if not a function return event. - -ida_dbg.get_running_notification (function) - get_running_notification() -> dbg_notification_t - Get the notification associated (if any) with the current running request. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @return: dbg_null if no running request - -ida_dbg.get_running_request (function) - get_running_request() -> ui_notification_t - Get the current running request. \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @return: ui_null if no running request - -ida_dbg.get_sp_val (function) - get_sp_val() -> bool - Get value of the SP register for the current thread. Requires a suspended - debugger. - -ida_dbg.get_srcinfo_provider (function) - get_srcinfo_provider(name) -> srcinfo_provider_t * - - @param name: char const * - -ida_dbg.get_step_trace_options (function) - get_step_trace_options() -> int - Get current step tracing options. \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @return: Step trace options - -ida_dbg.get_tev_ea (function) - get_tev_ea(n) -> ea_t - - @param n: int - -ida_dbg.get_tev_event (function) - get_tev_event(n, d) -> bool - Get the corresponding debug event, if any, for the specified tev object. - \sq{Type, Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param d: (C++: debug_event_t *) result - @return: false if the tev_t object doesn't have any associated debug event, true - otherwise, with the debug event in "d". - -ida_dbg.get_tev_info (function) - get_tev_info(n, tev_info) -> bool - Get main information about a trace event. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param tev_info: (C++: tev_info_t *) result - @return: success - -ida_dbg.get_tev_memory_info (function) - get_tev_memory_info(n, mi) -> bool - Get the memory layout, if any, for the specified tev object. \sq{Type, - Synchronous function, Notification, none (synchronous function)} - - @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents - the latest added trace event. - @param mi: (C++: meminfo_vec_t *) result - @return: false if the tev_t object is not of type tev_mem, true otherwise, with - the new memory layout in "mi". - -ida_dbg.get_tev_qty (function) - get_tev_qty() -> int - Get number of trace events available in trace buffer. \sq{Type, Synchronous - function, Notification, none (synchronous function)} - -ida_dbg.get_tev_reg_mem (function) - -ida_dbg.get_tev_reg_mem_ea (function) - -ida_dbg.get_tev_reg_mem_qty (function) - -ida_dbg.get_tev_reg_val (function) - -ida_dbg.get_tev_tid (function) - get_tev_tid(n) -> int - - @param n: int - -ida_dbg.get_tev_type (function) - get_tev_type(n) -> int - - @param n: int - -ida_dbg.get_thread_qty (function) - get_thread_qty() -> int - Get number of threads. \sq{Type, Synchronous function, Notification, none - (synchronous function)} - -ida_dbg.get_trace_base_address (function) - get_trace_base_address() -> ea_t - Get the base address of the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @return: the base address of the currently loaded trace - -ida_dbg.get_trace_dynamic_register_set (function) - get_trace_dynamic_register_set(idaregs) - Get dynamic register set of current trace. - - @param idaregs: (C++: dynamic_register_set_t *) - -ida_dbg.get_trace_file_desc (function) - get_trace_file_desc(filename) -> str - Get the file header of the specified trace file. - - @param filename: (C++: const char *) char const * - -ida_dbg.get_trace_platform (function) - get_trace_platform() -> char const * - Get platform name of current trace. - -ida_dbg.getn_bpt (function) - getn_bpt(n, bpt) -> bool - Get the characteristics of a breakpoint. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param n: (C++: int) number of breakpoint, is in range 0..get_bpt_qty()-1 - @param bpt: (C++: bpt_t *) filled with the characteristics. - @return: false if no breakpoint exists - -ida_dbg.getn_thread (function) - getn_thread(n) -> thid_t - Get the ID of a thread. \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param n: (C++: int) number of thread, is in range 0..get_thread_qty()-1 - @return: NO_THREAD if the thread doesn't exist. - -ida_dbg.getn_thread_name (function) - getn_thread_name(n) -> char const * - Get the NAME of a thread \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param n: (C++: int) number of thread, is in range 0..get_thread_qty()-1 or -1 for the - current thread - @return: thread name or nullptr if the thread doesn't exist. - -ida_dbg.graph_trace (function) - graph_trace() -> bool - Show the trace callgraph. - -ida_dbg.handle_debug_event (function) - handle_debug_event(ev, rqflags) -> int - - @param ev: debug_event_t const * - @param rqflags: int - -ida_dbg.hide_all_bpts (function) - hide_all_bpts() -> int - -ida_dbg.internal_get_sreg_base (function) - internal_get_sreg_base(tid, sreg_value) -> ea_t - Get the sreg base, for the given thread. - - @param tid: thid_t - @param sreg_value: int - @return: The sreg base, or BADADDR on failure. - -ida_dbg.internal_ioctl (function) - internal_ioctl(fn, buf, poutbuf, poutsize) -> int - - @param fn: int - @param buf: void const * - @param poutbuf: void ** - @param poutsize: ssize_t * - -ida_dbg.invalidate_dbg_state (function) - invalidate_dbg_state(dbginv) -> int - Invalidate cached debugger information. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param dbginv: (C++: int) Debugged process invalidation options - @return: current debugger state (one of Debugged process states) - -ida_dbg.invalidate_dbgmem_config (function) - invalidate_dbgmem_config() - Invalidate the debugged process memory configuration. Call this function if the - debugged process might have changed its memory layout (allocated more memory, - for example) - -ida_dbg.invalidate_dbgmem_contents (function) - invalidate_dbgmem_contents(ea, size) - Invalidate the debugged process memory contents. Call this function each time - the process has been stopped or the process memory is modified. If ea == - BADADDR, then the whole memory contents will be invalidated - - @param ea: (C++: ea_t) - @param size: (C++: asize_t) - -ida_dbg.is_bblk_trace_enabled (function) - is_bblk_trace_enabled() -> bool - -ida_dbg.is_debugger_busy (function) - is_debugger_busy() -> bool - Is the debugger busy?. Some debuggers do not accept any commands while the - debugged application is running. For such a debugger, it is unsafe to do - anything with the database (even simple queries like get_byte may lead to - undesired consequences). Returns: true if the debugged application is running - under such a debugger - -ida_dbg.is_debugger_memory (function) - is_debugger_memory(ea) -> bool - Is the address mapped to debugger memory? - - @param ea: (C++: ea_t) - -ida_dbg.is_debugger_on (function) - is_debugger_on() -> bool - Is the debugger currently running? - -ida_dbg.is_func_trace_enabled (function) - is_func_trace_enabled() -> bool - Get current state of functions tracing. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - -ida_dbg.is_insn_trace_enabled (function) - is_insn_trace_enabled() -> bool - Get current state of instruction tracing. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - -ida_dbg.is_reg_custom (function) - is_reg_custom(regname) -> bool - Does a register contain a value of a custom data type? \sq{Type, Synchronous - function, Notification, none (synchronous function)} - - @param regname: (C++: const char *) char const * - -ida_dbg.is_reg_float (function) - is_reg_float(regname) -> bool - Does a register contain a floating point value? \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param regname: (C++: const char *) char const * - -ida_dbg.is_reg_integer (function) - is_reg_integer(regname) -> bool - Does a register contain an integer value? \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param regname: (C++: const char *) char const * - -ida_dbg.is_request_running (function) - is_request_running() -> bool - Is a request currently running? - -ida_dbg.is_step_trace_enabled (function) - is_step_trace_enabled() -> bool - Get current state of step tracing. \sq{Type, Synchronous function, Notification, - none (synchronous function)} - -ida_dbg.is_valid_dstate (function) - is_valid_dstate(state) -> bool - - @param state: int - -ida_dbg.is_valid_trace_file (function) - is_valid_trace_file(filename) -> bool - Is the specified file a valid trace file for the current database? - - @param filename: (C++: const char *) char const * - -ida_dbg.list_bptgrps (function) - list_bptgrps(bptgrps) -> size_t - Retrieve the list of absolute path of all folders of bpt dirtree \sq{Type, - Synchronous function, Notification, none (synchronous function)} - - @param bptgrps: (C++: qstrvec_t *) list of absolute path in the bpt dirtree - @return: number of folders returned - list_bptgrps() -> [str, ...] - -ida_dbg.load_debugger (function) - load_debugger(dbgname, use_remote) -> bool - - @param dbgname: char const * - @param use_remote: bool - -ida_dbg.load_trace_file (function) - load_trace_file(filename) -> str - Load a recorded trace file in the 'Tracing' window. If the call succeeds and - 'buf' is not null, the description of the trace stored in the binary trace file - will be returned in 'buf' - - @param filename: (C++: const char *) char const * - -ida_dbg.memreg_info_t (class) - Proxy of C++ memreg_info_t class. - -ida_dbg.memreg_info_t.__init__ (method) - __init__(self) -> memreg_info_t - -ida_dbg.memreg_info_t.get_bytes (method) - get_bytes(self) -> PyObject * - -ida_dbg.memreg_infos_t (class) - Proxy of C++ qvector< memreg_info_t > class. - -ida_dbg.memreg_infos_t.__getitem__ (method) - __getitem__(self, i) -> memreg_info_t - - @param i: size_t - -ida_dbg.memreg_infos_t.__init__ (method) - __init__(self) -> memreg_infos_t - __init__(self, x) -> memreg_infos_t - - @param x: qvector< memreg_info_t > const & - -ida_dbg.memreg_infos_t.__len__ (method) - __len__(self) -> size_t - -ida_dbg.memreg_infos_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: memreg_info_t const & - -ida_dbg.memreg_infos_t.at (method) - at(self, _idx) -> memreg_info_t - - @param _idx: size_t - -ida_dbg.memreg_infos_t.begin (method) - begin(self) -> memreg_info_t - -ida_dbg.memreg_infos_t.capacity (method) - capacity(self) -> size_t - -ida_dbg.memreg_infos_t.clear (method) - clear(self) - -ida_dbg.memreg_infos_t.empty (method) - empty(self) -> bool - -ida_dbg.memreg_infos_t.end (method) - end(self) -> memreg_info_t - -ida_dbg.memreg_infos_t.erase (method) - erase(self, it) -> memreg_info_t - - @param it: qvector< memreg_info_t >::iterator - - erase(self, first, last) -> memreg_info_t - - @param first: qvector< memreg_info_t >::iterator - @param last: qvector< memreg_info_t >::iterator - -ida_dbg.memreg_infos_t.extract (method) - extract(self) -> memreg_info_t - -ida_dbg.memreg_infos_t.grow (method) - grow(self, x=memreg_info_t()) - - @param x: memreg_info_t const & - -ida_dbg.memreg_infos_t.inject (method) - inject(self, s, len) - - @param s: memreg_info_t * - @param len: size_t - -ida_dbg.memreg_infos_t.insert (method) - insert(self, it, x) -> memreg_info_t - - @param it: qvector< memreg_info_t >::iterator - @param x: memreg_info_t const & - -ida_dbg.memreg_infos_t.pop_back (method) - pop_back(self) - -ida_dbg.memreg_infos_t.push_back (method) - push_back(self, x) - - @param x: memreg_info_t const & - - push_back(self) -> memreg_info_t - -ida_dbg.memreg_infos_t.qclear (method) - qclear(self) - -ida_dbg.memreg_infos_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_dbg.memreg_infos_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: memreg_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_dbg.memreg_infos_t.size (method) - size(self) -> size_t - -ida_dbg.memreg_infos_t.swap (method) - swap(self, r) - - @param r: qvector< memreg_info_t > & - -ida_dbg.memreg_infos_t.truncate (method) - truncate(self) - -ida_dbg.put_dbg_byte (function) - put_dbg_byte(ea, x) -> bool - Change one byte of the debugged process memory. - - @param ea: (C++: ea_t) linear address - @param x: (C++: uint32) byte value - @return: true if the process memory has been modified - -ida_dbg.read_dbg_memory (function) - read_dbg_memory(ea, buffer, size) -> ssize_t - - @param ea: ea_t - @param buffer: void * - @param size: size_t - -ida_dbg.refresh_debugger_memory (function) - refresh_debugger_memory() -> PyObject * - Refreshes the debugger memory - - @return: Nothing - -ida_dbg.rename_bptgrp (function) - rename_bptgrp(old_name, new_name) -> bool - Rename a folder of bpt dirtree \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @param old_name: (C++: const char *) absolute path to the folder to be renamed - @param new_name: (C++: const char *) absolute path of the new folder name - @return: success - -ida_dbg.request_add_bpt (function) - request_add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool - Post an add_bpt(const bpt_t &) request. - - @param ea: ea_t - @param size: asize_t - @param type: bpttype_t - - request_add_bpt(bpt) -> bool - - @param bpt: bpt_t const & - -ida_dbg.request_attach_process (function) - request_attach_process(pid, event_id) -> int - Post an attach_process() request. - - @param pid: (C++: pid_t) - @param event_id: (C++: int) - -ida_dbg.request_clear_trace (function) - request_clear_trace() - Post a clear_trace() request. - -ida_dbg.request_continue_process (function) - request_continue_process() -> bool - Post a continue_process() request. - @note: This requires an explicit call to run_requests() - -ida_dbg.request_del_bpt (function) - request_del_bpt(ea) -> bool - Post a del_bpt(const bpt_location_t &) request. - - @param ea: ea_t - - request_del_bpt(bptloc) -> bool - - @param bptloc: bpt_location_t const & - -ida_dbg.request_detach_process (function) - request_detach_process() -> bool - Post a detach_process() request. - -ida_dbg.request_disable_bblk_trace (function) - request_disable_bblk_trace() -> bool - -ida_dbg.request_disable_bpt (function) - request_disable_bpt(ea) -> bool - - @param ea: ea_t - - request_disable_bpt(bptloc) -> bool - - @param bptloc: bpt_location_t const & - -ida_dbg.request_disable_func_trace (function) - request_disable_func_trace() -> bool - -ida_dbg.request_disable_insn_trace (function) - request_disable_insn_trace() -> bool - -ida_dbg.request_disable_step_trace (function) - request_disable_step_trace() -> bool - -ida_dbg.request_enable_bblk_trace (function) - request_enable_bblk_trace(enable=True) -> bool - - @param enable: bool - -ida_dbg.request_enable_bpt (function) - request_enable_bpt(ea, enable=True) -> bool - - @param ea: ea_t - @param enable: bool - - request_enable_bpt(bptloc, enable=True) -> bool - - @param bptloc: bpt_location_t const & - @param enable: bool - -ida_dbg.request_enable_func_trace (function) - request_enable_func_trace(enable=True) -> bool - - @param enable: bool - -ida_dbg.request_enable_insn_trace (function) - request_enable_insn_trace(enable=True) -> bool - - @param enable: bool - -ida_dbg.request_enable_step_trace (function) - request_enable_step_trace(enable=1) -> bool - - @param enable: int - -ida_dbg.request_exit_process (function) - request_exit_process() -> bool - Post an exit_process() request. - -ida_dbg.request_resume_thread (function) - request_resume_thread(tid) -> int - Post a resume_thread() request. - - @param tid: (C++: thid_t) - -ida_dbg.request_run_to (function) - request_run_to(ea, pid=pid_t(-1), tid=0) -> bool - Post a run_to() request. - - @param ea: (C++: ea_t) - @param pid: (C++: pid_t) - -ida_dbg.request_select_thread (function) - request_select_thread(tid) -> bool - Post a select_thread() request. - - @param tid: (C++: thid_t) - -ida_dbg.request_set_bblk_trace_options (function) - request_set_bblk_trace_options(options) - Post a set_bblk_trace_options() request. - - @param options: (C++: int) - -ida_dbg.request_set_func_trace_options (function) - request_set_func_trace_options(options) - Post a set_func_trace_options() request. - - @param options: (C++: int) - -ida_dbg.request_set_insn_trace_options (function) - request_set_insn_trace_options(options) - Post a set_insn_trace_options() request. - - @param options: (C++: int) - -ida_dbg.request_set_reg_val (function) - request_set_reg_val(regname, o) -> PyObject * - Post a set_reg_val() request. - - @param regname: (C++: const char *) char const * - @param o: PyObject * - -ida_dbg.request_set_resume_mode (function) - request_set_resume_mode(tid, mode) -> bool - Post a set_resume_mode() request. - - @param tid: (C++: thid_t) - @param mode: (C++: resume_mode_t) enum resume_mode_t - -ida_dbg.request_set_step_trace_options (function) - request_set_step_trace_options(options) - Post a set_step_trace_options() request. - - @param options: (C++: int) - -ida_dbg.request_start_process (function) - request_start_process(path=None, args=None, sdir=None) -> int - Post a start_process() request. - - @param path: (C++: const char *) char const * - @param args: (C++: const char *) char const * - @param sdir: (C++: const char *) char const * - -ida_dbg.request_step_into (function) - request_step_into() -> bool - Post a step_into() request. - -ida_dbg.request_step_over (function) - request_step_over() -> bool - Post a step_over() request. - -ida_dbg.request_step_until_ret (function) - request_step_until_ret() -> bool - Post a step_until_ret() request. - -ida_dbg.request_suspend_process (function) - request_suspend_process() -> bool - Post a suspend_process() request. - -ida_dbg.request_suspend_thread (function) - request_suspend_thread(tid) -> int - Post a suspend_thread() request. - - @param tid: (C++: thid_t) - -ida_dbg.resume_thread (function) - resume_thread(tid) -> int - Resume thread. \sq{Type, Synchronous function - available as request, - Notification, none (synchronous function)} - - @param tid: (C++: thid_t) thread id - @retval -1: network error - @retval 0: failed - @retval 1: ok - -ida_dbg.retrieve_exceptions (function) - retrieve_exceptions() -> excvec_t - Retrieve the exception information. You may freely modify the returned vector - and add/edit/delete exceptions You must call store_exceptions() after any - modifications Note: exceptions with code zero, multiple exception codes or names - are prohibited - -ida_dbg.run_requests (function) - run_requests() -> bool - Execute requests until all requests are processed or an asynchronous function is - called. \sq{Type, Synchronous function, Notification, none (synchronous - function)} - - @return: false if not all requests could be processed (indicates an asynchronous - function was started) - @note: If called from a notification handler, the execution of requests will be - postponed to the end of the execution of all notification handlers. - -ida_dbg.run_to (function) - run_to(ea, pid=pid_t(-1), tid=0) -> bool - Execute the process until the given address is reached. If no process is active, - a new process is started. Technically, the debugger sets up a temporary - breakpoint at the given address, and continues (or starts) the execution of the - whole process. So, all threads continue their execution! \sq{Type, Asynchronous - function - available as Request, Notification, dbg_run_to} - - @param ea: (C++: ea_t) target address - @param pid: (C++: pid_t) not used yet. please do not specify this parameter. - -ida_dbg.save_trace_file (function) - save_trace_file(filename, description) -> bool - Save the current trace in the specified file. - - @param filename: (C++: const char *) char const * - @param description: (C++: const char *) char const * - -ida_dbg.select_thread (function) - select_thread(tid) -> bool - Select the given thread as the current debugged thread. All thread related - execution functions will work on this thread. The process must be suspended to - select a new thread. \sq{Type, Synchronous function - available as request, - Notification, none (synchronous function)} - - @param tid: (C++: thid_t) ID of the thread to select - @return: false if the thread doesn't exist. - -ida_dbg.send_dbg_command (function) - Send a direct command to the debugger backend, and - retrieve the result as a string. - - Note: any double-quotes in 'command' must be backslash-escaped. - Note: this only works with some debugger backends: Bochs, WinDbg, GDB. - - Returns: (True, <result string>) on success, or (False, <Error message string>) on failure - -ida_dbg.set_bblk_trace_options (function) - set_bblk_trace_options(options) - Modify basic block tracing options (see BT_LOG_INSTS) - - @param options: (C++: int) - -ida_dbg.set_bpt_group (function) - set_bpt_group(bpt, grp_name) -> bool - Move a bpt into a folder in the breakpoint dirtree if the folder didn't exists, - it will be created \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param bpt: (C++: bpt_t &) bpt that will be moved - @param grp_name: (C++: const char *) absolute path to the breakpoint dirtree folder - @return: success - -ida_dbg.set_bptloc_group (function) - set_bptloc_group(bptloc, grp_name) -> bool - Move a bpt into a folder in the breakpoint dirtree based on the bpt_location - find_bpt is called to retrieve the bpt and then set_bpt_group if the folder - didn't exists, it will be created \sq{Type, Synchronous function, Notification, - none (synchronous function)} - - @param bptloc: (C++: const bpt_location_t &) bptlocation of the bpt that will be moved - @param grp_name: (C++: const char *) absolute path to the breakpoint dirtree folder - @return: success - -ida_dbg.set_bptloc_string (function) - set_bptloc_string(s) -> int - - @param s: char const * - -ida_dbg.set_debugger_event_cond (function) - set_debugger_event_cond(NONNULL_evcond) - - @param NONNULL_evcond: char const * - -ida_dbg.set_debugger_options (function) - set_debugger_options(options) -> uint - Set debugger options. Replaces debugger options with the specification - combination Debugger options - - @param options: (C++: uint) - @return: the old debugger options - -ida_dbg.set_func_trace_options (function) - set_func_trace_options(options) - Modify function tracing options. \sq{Type, Synchronous function - available as - request, Notification, none (synchronous function)} - - @param options: (C++: int) - -ida_dbg.set_highlight_trace_options (function) - set_highlight_trace_options(hilight, color, diff) - Set highlight trace parameters. - - @param hilight: (C++: bool) - @param color: (C++: bgcolor_t) - @param diff: (C++: bgcolor_t) - -ida_dbg.set_insn_trace_options (function) - set_insn_trace_options(options) - Modify instruction tracing options. \sq{Type, Synchronous function - available - as request, Notification, none (synchronous function)} - - @param options: (C++: int) - -ida_dbg.set_manual_regions (function) - set_manual_regions(ranges) - - @param ranges: meminfo_vec_t const * - -ida_dbg.set_process_options (function) - set_process_options(path, args, sdir, host, _pass, port) - Set process options. Any of the arguments may be nullptr, which means 'do not - modify' - - @param path: (C++: const char *) char const * - @param args: (C++: const char *) char const * - @param sdir: (C++: const char *) char const * - @param host: (C++: const char *) char const * - @param pass: (C++: const char *) char const * - @param port: (C++: int) - -ida_dbg.set_process_state (function) - set_process_state(newstate, p_thid, dbginv) -> int - Set new state for the debugged process. Notifies the IDA kernel about the change - of the debugged process state. For example, a debugger module could call this - function when it knows that the process is suspended for a short period of time. - Some IDA API calls can be made only when the process is suspended. The process - state is usually restored before returning control to the caller. You must know - that it is ok to change the process state, doing it at arbitrary moments may - crash the application or IDA. \sq{Type, Synchronous function, Notification, none - (synchronous function)} - - @param newstate: (C++: int) new process state (one of Debugged process states) if - DSTATE_NOTASK is passed then the state is not changed - @param p_thid: (C++: thid_t *) ptr to new thread id. may be nullptr or pointer to NO_THREAD. the - pointed variable will contain the old thread id upon return - @param dbginv: (C++: int) Debugged process invalidation options - @return: old debugger state (one of Debugged process states) - -ida_dbg.set_reg_val (function) - set_reg_val(regname, o) -> PyObject - - @param regname: char const * - @param o: PyObject * - - set_reg_val(tid, regidx, o) -> bool, int - - @param tid: thid_t - @param regidx: int - @param o: PyObject * - -ida_dbg.set_remote_debugger (function) - set_remote_debugger(host, _pass, port=-1) - Set remote debugging options. Should be used before starting the debugger. - - @param host: (C++: const char *) If empty, IDA will use local debugger. If nullptr, the host will - not be set. - @param pass: (C++: const char *) If nullptr, the password will not be set - @param port: (C++: int) If -1, the default port number will be used - -ida_dbg.set_resume_mode (function) - set_resume_mode(tid, mode) -> bool - How to resume the application. Set resume mode but do not resume process. - - @param tid: (C++: thid_t) - @param mode: (C++: resume_mode_t) enum resume_mode_t - -ida_dbg.set_step_trace_options (function) - set_step_trace_options(options) - Modify step tracing options. \sq{Type, Synchronous function - available as - request, Notification, none (synchronous function)} - - @param options: (C++: int) - -ida_dbg.set_trace_base_address (function) - set_trace_base_address(ea) - Set the base address of the current trace. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param ea: (C++: ea_t) - -ida_dbg.set_trace_dynamic_register_set (function) - set_trace_dynamic_register_set(idaregs) - Set dynamic register set of current trace. - - @param idaregs: (C++: dynamic_register_set_t &) - -ida_dbg.set_trace_file_desc (function) - set_trace_file_desc(filename, description) -> bool - Change the description of the specified trace file. - - @param filename: (C++: const char *) char const * - @param description: (C++: const char *) char const * - -ida_dbg.set_trace_platform (function) - set_trace_platform(platform) - Set platform name of current trace. - - @param platform: (C++: const char *) char const * - -ida_dbg.set_trace_size (function) - set_trace_size(size) -> bool - Specify the new size of the circular buffer. \sq{Type, Synchronous function, - Notification, none (synchronous function)} - - @param size: (C++: int) if 0, buffer isn't circular and events are never removed. If the - new size is smaller than the existing number of trace events, a - corresponding number of trace events are removed. - @note: If you specify 0, all available memory can be quickly used !!! - -ida_dbg.srcdbg_request_step_into (function) - srcdbg_request_step_into() -> bool - -ida_dbg.srcdbg_request_step_over (function) - srcdbg_request_step_over() -> bool - -ida_dbg.srcdbg_request_step_until_ret (function) - srcdbg_request_step_until_ret() -> bool - -ida_dbg.srcdbg_step_into (function) - srcdbg_step_into() -> bool - -ida_dbg.srcdbg_step_over (function) - srcdbg_step_over() -> bool - -ida_dbg.srcdbg_step_until_ret (function) - srcdbg_step_until_ret() -> bool - -ida_dbg.start_process (function) - start_process(path=None, args=None, sdir=None) -> int - Start a process in the debugger. \sq{Type, Asynchronous function - available as - Request, Notification, dbg_process_start} - @note: You can also use the run_to() function to easily start the execution of a - process until a given address is reached. - @note: For all parameters, a nullptr value indicates the debugger will take the - value from the defined Process Options. - - @param path: (C++: const char *) path to the executable to start - @param args: (C++: const char *) arguments to pass to process - @param sdir: (C++: const char *) starting directory for the process - @retval -1: impossible to create the process - @retval 0: the starting of the process was cancelled by the user - @retval 1: the process was properly started - -ida_dbg.step_into (function) - step_into() -> bool - Execute one instruction in the current thread. Other threads are kept suspended. - \sq{Type, Asynchronous function - available as Request, Notification, - dbg_step_into} - -ida_dbg.step_over (function) - step_over() -> bool - Execute one instruction in the current thread, but without entering into - functions. Others threads keep suspended. \sq{Type, Asynchronous function - - available as Request, Notification, dbg_step_over} - -ida_dbg.step_until_ret (function) - step_until_ret() -> bool - Execute instructions in the current thread until a function return instruction - is executed (aka "step out"). Other threads are kept suspended. \sq{Type, - Asynchronous function - available as Request, Notification, dbg_step_until_ret} - -ida_dbg.store_exceptions (function) - store_exceptions() -> bool - Update the exception information stored in the debugger module by invoking its - dbg->set_exception_info callback - -ida_dbg.suspend_process (function) - suspend_process() -> bool - Suspend the process in the debugger. \sq{ Type, - * Synchronous function (if in a notification handler) - * Asynchronous function (everywhere else) - * available as Request, Notification, - * none (if in a notification handler) - * dbg_suspend_process (everywhere else) } - @note: The suspend_process() function can be called from a notification handler - to force the stopping of the process. In this case, no notification will - be generated. When you suspend a process, the running command is always - aborted. - -ida_dbg.suspend_thread (function) - suspend_thread(tid) -> int - Suspend thread. Suspending a thread may deadlock the whole application if the - suspended was owning some synchronization objects. \sq{Type, Synchronous - function - available as request, Notification, none (synchronous function)} - - @param tid: (C++: thid_t) thread id - @retval -1: network error - @retval 0: failed - @retval 1: ok - -ida_dbg.tev_bpt (variable) - write, read/write, execution trace - -ida_dbg.tev_call (variable) - a function call trace - -ida_dbg.tev_event (variable) - debug event occurred - -ida_dbg.tev_info_reg_t (class) - Proxy of C++ tev_info_reg_t class. - -ida_dbg.tev_info_reg_t.__init__ (method) - __init__(self) -> tev_info_reg_t - -ida_dbg.tev_info_t (class) - Proxy of C++ tev_info_t class. - -ida_dbg.tev_info_t.__init__ (method) - __init__(self) -> tev_info_t - -ida_dbg.tev_info_t.ea (variable) - address where the event occurred - -ida_dbg.tev_info_t.tid (variable) - thread where the event was recorded - -ida_dbg.tev_info_t.type (variable) - trace event type - -ida_dbg.tev_insn (variable) - an instruction trace - -ida_dbg.tev_max (variable) - first unused event type - -ida_dbg.tev_mem (variable) - memory layout changed - -ida_dbg.tev_none (variable) - no event - -ida_dbg.tev_reg_value_t (class) - Proxy of C++ tev_reg_value_t class. - -ida_dbg.tev_reg_value_t.__init__ (method) - __init__(self, _reg_idx=-1, _value=uint64(-1)) -> tev_reg_value_t - - @param _reg_idx: int - @param _value: uint64 - -ida_dbg.tev_reg_values_t (class) - Proxy of C++ qvector< tev_reg_value_t > class. - -ida_dbg.tev_reg_values_t.__getitem__ (method) - __getitem__(self, i) -> tev_reg_value_t - - @param i: size_t - -ida_dbg.tev_reg_values_t.__init__ (method) - __init__(self) -> tev_reg_values_t - __init__(self, x) -> tev_reg_values_t - - @param x: qvector< tev_reg_value_t > const & - -ida_dbg.tev_reg_values_t.__len__ (method) - __len__(self) -> size_t - -ida_dbg.tev_reg_values_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: tev_reg_value_t const & - -ida_dbg.tev_reg_values_t.at (method) - at(self, _idx) -> tev_reg_value_t - - @param _idx: size_t - -ida_dbg.tev_reg_values_t.begin (method) - begin(self) -> tev_reg_value_t - -ida_dbg.tev_reg_values_t.capacity (method) - capacity(self) -> size_t - -ida_dbg.tev_reg_values_t.clear (method) - clear(self) - -ida_dbg.tev_reg_values_t.empty (method) - empty(self) -> bool - -ida_dbg.tev_reg_values_t.end (method) - end(self) -> tev_reg_value_t - -ida_dbg.tev_reg_values_t.erase (method) - erase(self, it) -> tev_reg_value_t - - @param it: qvector< tev_reg_value_t >::iterator - - erase(self, first, last) -> tev_reg_value_t - - @param first: qvector< tev_reg_value_t >::iterator - @param last: qvector< tev_reg_value_t >::iterator - -ida_dbg.tev_reg_values_t.extract (method) - extract(self) -> tev_reg_value_t - -ida_dbg.tev_reg_values_t.grow (method) - grow(self, x=tev_reg_value_t()) - - @param x: tev_reg_value_t const & - -ida_dbg.tev_reg_values_t.inject (method) - inject(self, s, len) - - @param s: tev_reg_value_t * - @param len: size_t - -ida_dbg.tev_reg_values_t.insert (method) - insert(self, it, x) -> tev_reg_value_t - - @param it: qvector< tev_reg_value_t >::iterator - @param x: tev_reg_value_t const & - -ida_dbg.tev_reg_values_t.pop_back (method) - pop_back(self) - -ida_dbg.tev_reg_values_t.push_back (method) - push_back(self, x) - - @param x: tev_reg_value_t const & - - push_back(self) -> tev_reg_value_t - -ida_dbg.tev_reg_values_t.qclear (method) - qclear(self) - -ida_dbg.tev_reg_values_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_dbg.tev_reg_values_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: tev_reg_value_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_dbg.tev_reg_values_t.size (method) - size(self) -> size_t - -ida_dbg.tev_reg_values_t.swap (method) - swap(self, r) - - @param r: qvector< tev_reg_value_t > & - -ida_dbg.tev_reg_values_t.truncate (method) - truncate(self) - -ida_dbg.tev_ret (variable) - a function return trace - -ida_dbg.tevinforeg_vec_t (class) - Proxy of C++ qvector< tev_info_reg_t > class. - -ida_dbg.tevinforeg_vec_t.__getitem__ (method) - __getitem__(self, i) -> tev_info_reg_t - - @param i: size_t - -ida_dbg.tevinforeg_vec_t.__init__ (method) - __init__(self) -> tevinforeg_vec_t - __init__(self, x) -> tevinforeg_vec_t - - @param x: qvector< tev_info_reg_t > const & - -ida_dbg.tevinforeg_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_dbg.tevinforeg_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: tev_info_reg_t const & - -ida_dbg.tevinforeg_vec_t.at (method) - at(self, _idx) -> tev_info_reg_t - - @param _idx: size_t - -ida_dbg.tevinforeg_vec_t.begin (method) - begin(self) -> tev_info_reg_t - -ida_dbg.tevinforeg_vec_t.capacity (method) - capacity(self) -> size_t - -ida_dbg.tevinforeg_vec_t.clear (method) - clear(self) - -ida_dbg.tevinforeg_vec_t.empty (method) - empty(self) -> bool - -ida_dbg.tevinforeg_vec_t.end (method) - end(self) -> tev_info_reg_t - -ida_dbg.tevinforeg_vec_t.erase (method) - erase(self, it) -> tev_info_reg_t - - @param it: qvector< tev_info_reg_t >::iterator - - erase(self, first, last) -> tev_info_reg_t - - @param first: qvector< tev_info_reg_t >::iterator - @param last: qvector< tev_info_reg_t >::iterator - -ida_dbg.tevinforeg_vec_t.extract (method) - extract(self) -> tev_info_reg_t - -ida_dbg.tevinforeg_vec_t.grow (method) - grow(self, x=tev_info_reg_t()) - - @param x: tev_info_reg_t const & - -ida_dbg.tevinforeg_vec_t.inject (method) - inject(self, s, len) - - @param s: tev_info_reg_t * - @param len: size_t - -ida_dbg.tevinforeg_vec_t.insert (method) - insert(self, it, x) -> tev_info_reg_t - - @param it: qvector< tev_info_reg_t >::iterator - @param x: tev_info_reg_t const & - -ida_dbg.tevinforeg_vec_t.pop_back (method) - pop_back(self) - -ida_dbg.tevinforeg_vec_t.push_back (method) - push_back(self, x) - - @param x: tev_info_reg_t const & - - push_back(self) -> tev_info_reg_t - -ida_dbg.tevinforeg_vec_t.qclear (method) - qclear(self) - -ida_dbg.tevinforeg_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_dbg.tevinforeg_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: tev_info_reg_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_dbg.tevinforeg_vec_t.size (method) - size(self) -> size_t - -ida_dbg.tevinforeg_vec_t.swap (method) - swap(self, r) - - @param r: qvector< tev_info_reg_t > & - -ida_dbg.tevinforeg_vec_t.truncate (method) - truncate(self) - -ida_dbg.update_bpt (function) - update_bpt(bpt) -> bool - Update modifiable characteristics of an existing breakpoint. To update the - breakpoint location, use change_bptlocs() \sq{Type, Synchronous function, - Notification, none (synchronous function)} - @note: Only the following fields can be modified: - * bpt_t::cndbody - * bpt_t::pass_count - * bpt_t::flags - * bpt_t::size - * bpt_t::type - @note: Changing some properties will require removing and then re-adding the - breakpoint to the process memory (or the debugger backend), which can - lead to race conditions (i.e., breakpoint(s) can be missed) in case the - process is not suspended. Here are a list of scenarios that will require - the breakpoint to be removed & then re-added: - * bpt_t::size is modified - * bpt_t::type is modified - * bpt_t::flags's BPT_ENABLED is modified - * bpt_t::flags's BPT_LOWCND is changed - * bpt_t::flags's BPT_LOWCND remains set, but cndbody changed - - @param bpt: (C++: const bpt_t *) bpt_t const * - -ida_dbg.wait_for_next_event (function) - wait_for_next_event(wfne, timeout) -> dbg_event_code_t - Wait for the next event. - - This function (optionally) resumes the process execution, and waits for a - debugger event until a possible timeout occurs. - - @param wfne: (C++: int) combination of Wait for debugger event flags constants - @param timeout: (C++: int) number of seconds to wait, -1-infinity - @return: either an event_id_t (if > 0), or a dbg_event_code_t (if <= 0) - -ida_dbg.write_dbg_memory (function) - write_dbg_memory(ea, py_buf, size=size_t(-1)) -> ssize_t - - @param ea: ea_t - @param py_buf: PyObject * - @param size: size_t - -ida_diskio (module) - File I/O functions for IDA. - - You should not use standard C file I/O functions in modules. Use functions from - this header, pro.h and fpro.h instead. - - This file also declares a call_system() function. - -ida_diskio.IDA_SUBDIR_IDADIR_FIRST (variable) - $IDADIR/subdir will be first, not last - -ida_diskio.IDA_SUBDIR_IDP (variable) - append the processor name as a subdirectory - -ida_diskio.IDA_SUBDIR_ONLY_EXISTING (variable) - only existing directories will be present - -ida_diskio.LINPUT_GENERIC (variable) - generic linput - -ida_diskio.LINPUT_LOCAL (variable) - local file - -ida_diskio.LINPUT_NONE (variable) - invalid linput - -ida_diskio.LINPUT_PROCMEM (variable) - debugged process memory (read_dbg_memory()) - -ida_diskio.LINPUT_RFILE (variable) - remote file ( debugger_t::open_file, debugger_t::read_file) - -ida_diskio.choose_ioport_device2 (function) - choose_ioport_device2(_device, file, parse_params) -> bool - - @param _device: qstring * - @param file: char const * - @param parse_params: choose_ioport_parser_t * - -ida_diskio.choose_ioport_parser_t (class) - Proxy of C++ choose_ioport_parser_t class. - -ida_diskio.choose_ioport_parser_t.__disown__ (method) - -ida_diskio.choose_ioport_parser_t.__init__ (method) - __init__(self) -> choose_ioport_parser_t - - @param self: PyObject * - -ida_diskio.choose_ioport_parser_t.parse (method) - parse(self, param, line) -> bool - @retval true: and fill PARAM with a displayed string - @retval false: and empty PARAM to skip the current device - @retval false: and fill PARAM with an error message - - @param param: (C++: qstring *) - @param line: (C++: const char *) char const * - -ida_diskio.close_linput (function) - close_linput(li) - Close loader input. - - @param li: (C++: linput_t *) - -ida_diskio.create_bytearray_linput (function) - create_bytearray_linput(s) -> linput_t * - Trivial memory linput. - - @param s: qstring const & - -ida_diskio.create_generic_linput (function) - create_generic_linput(gl) -> linput_t * - Create a generic linput - - @param gl: (C++: generic_linput_t *) linput description. this object will be destroyed by close_linput() - using "delete gl;" - -ida_diskio.create_memory_linput (function) - create_memory_linput(start, size) -> linput_t * - Create a linput for process memory. This linput will use read_dbg_memory() to - read data. - - @param start: (C++: ea_t) starting address of the input - @param size: (C++: asize_t) size of the memory area to represent as linput if unknown, may be - passed as 0 - -ida_diskio.eclose (function) - eclose(fp) - - @param fp: FILE * - -ida_diskio.enumerate_files (function) - 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 - -ida_diskio.enumerate_files2 (function) - enumerate_files2(answer, answer_size, path, fname, fv) -> int - - @param answer: char * - @param answer_size: size_t - @param path: char const * - @param fname: char const * - @param fv: file_enumerator_t & - -ida_diskio.file_enumerator_t (class) - Proxy of C++ file_enumerator_t class. - -ida_diskio.file_enumerator_t.__disown__ (method) - -ida_diskio.file_enumerator_t.__init__ (method) - __init__(self) -> file_enumerator_t - - @param self: PyObject * - -ida_diskio.file_enumerator_t.visit_file (method) - visit_file(self, file) -> int - - @param file: char const * - -ida_diskio.fopenA (function) - fopenA(file) -> FILE * - Open a file for append in text mode, deny none. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenM (function) - fopenM(file) -> FILE * - Open a file for read/write in binary mode, deny write. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenRB (function) - fopenRB(file) -> FILE * - Open a file for read in binary mode, deny none. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenRT (function) - fopenRT(file) -> FILE * - Open a file for read in text mode, deny none. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenWB (function) - fopenWB(file) -> FILE * - Open a new file for write in binary mode, deny read/write. If a file exists, it - will be removed. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.fopenWT (function) - fopenWT(file) -> FILE * - Open a new file for write in text mode, deny write. If a file exists, it will be - removed. - - @param file: (C++: const char *) char const * - @return: nullptr if failure - -ida_diskio.generic_linput_t (class) - Proxy of C++ generic_linput_t class. - -ida_diskio.generic_linput_t.__init__ (method) - -ida_diskio.generic_linput_t.blocksize (variable) - preferred block size to work with read/write sizes will be in multiples of this - number. for example, 4096 is a nice value blocksize 0 means that the filesize is - unknown. the internal cache will be disabled in this case. also, seeks from the - file end will fail. blocksize=-1 means error. - -ida_diskio.generic_linput_t.filesize (variable) - input file size - -ida_diskio.generic_linput_t.read (method) - read(self, off, buffer, nbytes) -> ssize_t - - @param off: qoff64_t - @param buffer: void * - @param nbytes: size_t - -ida_diskio.get_ida_subdirs (function) - get_ida_subdirs(subdir, flags=0) -> int - Get list of directories in which to find a specific IDA resource (see IDA - subdirectories). The order of the resulting list is as follows: - - [$IDAUSR/subdir (0..N entries)] - - $IDADIR/subdir - - @param subdir: (C++: const char *) name of the resource to list - @param flags: (C++: int) Subdirectory modification flags bits - @return: number of directories appended to 'dirs' - -ida_diskio.get_linput_type (function) - get_linput_type(li) -> linput_type_t - Get linput type. - - @param li: (C++: linput_t *) - -ida_diskio.get_special_folder (function) - get_special_folder(csidl) -> str - Get a folder location by CSIDL (see Common CSIDLs). Path should be of at least - MAX_PATH size - - @param csidl: (C++: int) - -ida_diskio.get_user_idadir (function) - get_user_idadir() -> char const * - Get user ida related directory. - - if $IDAUSR is defined: - - the first element in $IDAUSR - - else - - default user directory ($HOME/.idapro or %APPDATA%Hex-Rays/IDA Pro) - -ida_diskio.getsysfile (function) - getsysfile(filename, subdir) -> str - Search for IDA system file. This function searches for a file in: - 1. each directory specified by IDAUSR% - 2. ida directory [+ subdir] and returns the first match. - - @param filename: (C++: const char *) name of file to search - @param subdir: (C++: const char *) if specified, the file is looked for in the specified - subdirectory of the ida directory first (see IDA subdirectories) - @return: nullptr if not found, otherwise a pointer to full file name. - -ida_diskio.idadir (function) - idadir(subdir) -> char const * - Get IDA directory (if subdir==nullptr) or the specified subdirectory (see IDA - subdirectories) - - @param subdir: (C++: const char *) char const * - -ida_diskio.ioports_fallback_t (class) - Proxy of C++ ioports_fallback_t class. - -ida_diskio.ioports_fallback_t.__disown__ (method) - -ida_diskio.ioports_fallback_t.__init__ (method) - __init__(self) -> ioports_fallback_t - - @param self: PyObject * - -ida_diskio.ioports_fallback_t.handle (method) - handle(self, ports, line) -> bool - - @param ports: ioports_t const & - @param line: char const * - -ida_diskio.open_linput (function) - open_linput(file, remote) -> linput_t * - Open loader input. - - @param file: (C++: const char *) char const * - @param remote: (C++: bool) - -ida_diskio.qlgetz (function) - qlgetz(li, fpos) -> str - Read a zero-terminated string from the input. If fpos == -1 then no seek will be - performed. - - @param li: (C++: linput_t *) - @param fpos: (C++: int64) - -ida_diskio.read_ioports2 (function) - read_ioports2(ports, device, file, callback=None) -> ssize_t - - @param ports: ioports_t * - @param device: qstring * - @param file: char const * - @param callback: ioports_fallback_t * - -ida_dirtree (module) - Types involved in grouping of item into folders. - - The dirtree_t class is used to organize a directory tree on top of any - collection that allows for accessing its elements by an id (inode). - - No requirements are imposed on the inodes apart from the forbidden value -1 (it - is used ot denote a bad inode). - - The dirspec_t class is used to specialize the dirtree. It can be used to - introduce a directory structure for: - * local types - * structs - * enums - * functions - * names - * etc - - @note: you should be manipulating dirtree_t (and, if implementing a new tree - backend, dirspec_t) instances, not calling top-level functions in this - file directly. - -ida_dirtree.DTN_DISPLAY_NAME (variable) - use short, displayable form of the entry name. for example, 'std::string' - instead of 'std::basic_string<char, ...>'. Note that more than one "full name" - can have the same displayable name. - -ida_dirtree.DTN_FULL_NAME (variable) - use long form of the entry name. That name is unique. - -ida_dirtree.direntry_t (class) - Proxy of C++ direntry_t class. - -ida_dirtree.direntry_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: direntry_t const & - -ida_dirtree.direntry_t.__init__ (method) - __init__(self, i=BADIDX, d=False) -> direntry_t - - @param i: uval_t - @param d: bool - -ida_dirtree.direntry_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: direntry_t const & - -ida_dirtree.direntry_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: direntry_t const & - -ida_dirtree.direntry_t.idx (variable) - diridx_t or inode_t - -ida_dirtree.direntry_t.isdir (variable) - is 'idx' a diridx_t, or an inode_t - -ida_dirtree.direntry_t.valid (method) - valid(self) -> bool - -ida_dirtree.direntry_vec_t (class) - Proxy of C++ qvector< direntry_t > class. - -ida_dirtree.direntry_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< direntry_t > const & - -ida_dirtree.direntry_vec_t.__getitem__ (method) - __getitem__(self, i) -> direntry_t - - @param i: size_t - -ida_dirtree.direntry_vec_t.__init__ (method) - __init__(self) -> direntry_vec_t - __init__(self, x) -> direntry_vec_t - - @param x: qvector< direntry_t > const & - -ida_dirtree.direntry_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_dirtree.direntry_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< direntry_t > const & - -ida_dirtree.direntry_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: direntry_t const & - -ida_dirtree.direntry_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: direntry_t const & - -ida_dirtree.direntry_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: direntry_t const & - -ida_dirtree.direntry_vec_t.at (method) - at(self, _idx) -> direntry_t - - @param _idx: size_t - -ida_dirtree.direntry_vec_t.begin (method) - begin(self) -> direntry_t - -ida_dirtree.direntry_vec_t.capacity (method) - capacity(self) -> size_t - -ida_dirtree.direntry_vec_t.clear (method) - clear(self) - -ida_dirtree.direntry_vec_t.empty (method) - empty(self) -> bool - -ida_dirtree.direntry_vec_t.end (method) - end(self) -> direntry_t - -ida_dirtree.direntry_vec_t.erase (method) - erase(self, it) -> direntry_t - - @param it: qvector< direntry_t >::iterator - - erase(self, first, last) -> direntry_t - - @param first: qvector< direntry_t >::iterator - @param last: qvector< direntry_t >::iterator - -ida_dirtree.direntry_vec_t.extract (method) - extract(self) -> direntry_t - -ida_dirtree.direntry_vec_t.find (method) - find(self, x) -> direntry_t - - @param x: direntry_t const & - -ida_dirtree.direntry_vec_t.grow (method) - grow(self, x=direntry_t()) - - @param x: direntry_t const & - -ida_dirtree.direntry_vec_t.has (method) - has(self, x) -> bool - - @param x: direntry_t const & - -ida_dirtree.direntry_vec_t.inject (method) - inject(self, s, len) - - @param s: direntry_t * - @param len: size_t - -ida_dirtree.direntry_vec_t.insert (method) - insert(self, it, x) -> direntry_t - - @param it: qvector< direntry_t >::iterator - @param x: direntry_t const & - -ida_dirtree.direntry_vec_t.pop_back (method) - pop_back(self) - -ida_dirtree.direntry_vec_t.push_back (method) - push_back(self, x) - - @param x: direntry_t const & - - push_back(self) -> direntry_t - -ida_dirtree.direntry_vec_t.qclear (method) - qclear(self) - -ida_dirtree.direntry_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_dirtree.direntry_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: direntry_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_dirtree.direntry_vec_t.size (method) - size(self) -> size_t - -ida_dirtree.direntry_vec_t.swap (method) - swap(self, r) - - @param r: qvector< direntry_t > & - -ida_dirtree.direntry_vec_t.truncate (method) - truncate(self) - -ida_dirtree.dirspec_t (class) - Proxy of C++ dirspec_t class. - -ida_dirtree.dirspec_t.__disown__ (method) - -ida_dirtree.dirspec_t.__init__ (method) - __init__(self, nm=None, f=0) -> dirspec_t - - @param nm: char const * - @param f: uint32 - -ida_dirtree.dirspec_t.get_attrs (method) - get_attrs(self, inode) -> qstring - - @param inode: inode_t - -ida_dirtree.dirspec_t.get_inode (method) - get_inode(self, dirpath, name) -> inode_t - get the entry inode in the specified directory - - @param dirpath: (C++: const char *) the absolute directory path with trailing slash - @param name: (C++: const char *) the entry name in the directory - @return: the entry inode - -ida_dirtree.dirspec_t.get_name (method) - get_name(self, inode, name_flags=DTN_FULL_NAME) -> bool - get the entry name. for example, the structure name - - @param inode: (C++: inode_t) inode number of the entry - @param name_flags: (C++: uint32) how exactly the name should be retrieved. combination of bits - for get_...name() methods bits - @return: false if the entry does not exist. - -ida_dirtree.dirspec_t.is_orderable (method) - is_orderable(self) -> bool - -ida_dirtree.dirspec_t.rename_inode (method) - rename_inode(self, inode, newname) -> bool - rename the entry - - @param inode: (C++: inode_t) - @param newname: (C++: const char *) - @return: success - -ida_dirtree.dirspec_t.unlink_inode (method) - unlink_inode(self, inode) - - @param inode: (C++: inode_t) - -ida_dirtree.dirtree_cursor_t (class) - Proxy of C++ dirtree_cursor_t class. - -ida_dirtree.dirtree_cursor_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_t.__init__ (method) - __init__(self, _parent=BADIDX, _rank=size_t(-1)) -> dirtree_cursor_t - - @param _parent: diridx_t - @param _rank: size_t - -ida_dirtree.dirtree_cursor_t.__le__ (method) - __le__(self, r) -> bool - - @param r: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_t.compare (method) - compare(self, r) -> int - - @param r: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_t.is_root_cursor (method) - is_root_cursor(self) -> bool - -ida_dirtree.dirtree_cursor_t.parent (variable) - the parent directory - -ida_dirtree.dirtree_cursor_t.rank (variable) - the index into the parent directory - -ida_dirtree.dirtree_cursor_t.root_cursor (method) - root_cursor() -> dirtree_cursor_t - -ida_dirtree.dirtree_cursor_t.set_root_cursor (method) - set_root_cursor(self) - -ida_dirtree.dirtree_cursor_t.valid (method) - valid(self) -> bool - -ida_dirtree.dirtree_cursor_t_root_cursor (function) - dirtree_cursor_t_root_cursor() -> dirtree_cursor_t - -ida_dirtree.dirtree_cursor_vec_t (class) - Proxy of C++ qvector< dirtree_cursor_t > class. - -ida_dirtree.dirtree_cursor_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< dirtree_cursor_t > const & - -ida_dirtree.dirtree_cursor_vec_t.__getitem__ (method) - __getitem__(self, i) -> dirtree_cursor_t - - @param i: size_t - -ida_dirtree.dirtree_cursor_vec_t.__init__ (method) - __init__(self) -> dirtree_cursor_vec_t - __init__(self, x) -> dirtree_cursor_vec_t - - @param x: qvector< dirtree_cursor_t > const & - -ida_dirtree.dirtree_cursor_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_dirtree.dirtree_cursor_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< dirtree_cursor_t > const & - -ida_dirtree.dirtree_cursor_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_vec_t.at (method) - at(self, _idx) -> dirtree_cursor_t - - @param _idx: size_t - -ida_dirtree.dirtree_cursor_vec_t.begin (method) - begin(self) -> dirtree_cursor_t - -ida_dirtree.dirtree_cursor_vec_t.capacity (method) - capacity(self) -> size_t - -ida_dirtree.dirtree_cursor_vec_t.clear (method) - clear(self) - -ida_dirtree.dirtree_cursor_vec_t.empty (method) - empty(self) -> bool - -ida_dirtree.dirtree_cursor_vec_t.end (method) - end(self) -> dirtree_cursor_t - -ida_dirtree.dirtree_cursor_vec_t.erase (method) - erase(self, it) -> dirtree_cursor_t - - @param it: qvector< dirtree_cursor_t >::iterator - - erase(self, first, last) -> dirtree_cursor_t - - @param first: qvector< dirtree_cursor_t >::iterator - @param last: qvector< dirtree_cursor_t >::iterator - -ida_dirtree.dirtree_cursor_vec_t.extract (method) - extract(self) -> dirtree_cursor_t - -ida_dirtree.dirtree_cursor_vec_t.find (method) - find(self, x) -> dirtree_cursor_t - - @param x: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_vec_t.grow (method) - grow(self, x=dirtree_cursor_t()) - - @param x: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_vec_t.has (method) - has(self, x) -> bool - - @param x: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_vec_t.inject (method) - inject(self, s, len) - - @param s: dirtree_cursor_t * - @param len: size_t - -ida_dirtree.dirtree_cursor_vec_t.insert (method) - insert(self, it, x) -> dirtree_cursor_t - - @param it: qvector< dirtree_cursor_t >::iterator - @param x: dirtree_cursor_t const & - -ida_dirtree.dirtree_cursor_vec_t.pop_back (method) - pop_back(self) - -ida_dirtree.dirtree_cursor_vec_t.push_back (method) - push_back(self, x) - - @param x: dirtree_cursor_t const & - - push_back(self) -> dirtree_cursor_t - -ida_dirtree.dirtree_cursor_vec_t.qclear (method) - qclear(self) - -ida_dirtree.dirtree_cursor_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_dirtree.dirtree_cursor_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: dirtree_cursor_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_dirtree.dirtree_cursor_vec_t.size (method) - size(self) -> size_t - -ida_dirtree.dirtree_cursor_vec_t.swap (method) - swap(self, r) - - @param r: qvector< dirtree_cursor_t > & - -ida_dirtree.dirtree_cursor_vec_t.truncate (method) - truncate(self) - -ida_dirtree.dirtree_iterator_t (class) - Proxy of C++ dirtree_iterator_t class. - -ida_dirtree.dirtree_iterator_t.__init__ (method) - __init__(self) -> dirtree_iterator_t - -ida_dirtree.dirtree_selection_t (class) - Proxy of C++ dirtree_selection_t class. - -ida_dirtree.dirtree_selection_t.__init__ (method) - __init__(self) -> dirtree_selection_t - -ida_dirtree.dirtree_t (class) - Proxy of C++ dirtree_t class. - -ida_dirtree.dirtree_t.__init__ (method) - __init__(self, ds) -> dirtree_t - - @param ds: dirspec_t * - -ida_dirtree.dirtree_t.change_rank (method) - change_rank(self, path, rank_delta) -> dterr_t - Change ordering rank of an item. - - @param path: (C++: const char *) path to the item - @param rank_delta: (C++: ssize_t) the amount of the change. positive numbers mean to move down - in the list; negative numbers mean to move up. - @return: dterr_t error code - @note: this function may disable natural ordering of the parent folder - @see: set_natural_order() - -ida_dirtree.dirtree_t.chdir (method) - chdir(self, path) -> dterr_t - Change current directory - - @param path: (C++: const char *) new current directory - @return: dterr_t error code - -ida_dirtree.dirtree_t.errstr (method) - errstr(err) -> char const * - Get textual representation of the error code. - - @param err: (C++: dterr_t) enum dterr_t - -ida_dirtree.dirtree_t.find_entry (method) - find_entry(self, de) -> dirtree_cursor_t - Find the cursor corresponding to an entry of a directory - - @param de: (C++: const direntry_t &) directory entry - @return: cursor corresponding to the directory entry - -ida_dirtree.dirtree_t.findfirst (method) - findfirst(self, ff, pattern) -> bool - Start iterating over files in a directory - - @param ff: (C++: dirtree_iterator_t *) directory iterator. it will be initialized by the function - @param pattern: (C++: const char *) pattern to search for - @return: success - -ida_dirtree.dirtree_t.findnext (method) - findnext(self, ff) -> bool - Continue iterating over files in a directory - - @param ff: (C++: dirtree_iterator_t *) directory iterator - @return: success - -ida_dirtree.dirtree_t.get_abspath (method) - get_abspath(self, cursor, name_flags=DTN_FULL_NAME) -> qstring - Construct an absolute path from the specified relative path. This function - verifies the directory part of the specified path. The last component of the - specified path is not verified. - - @param cursor: dirtree_cursor_t const & - @param name_flags: uint32 - - @return: path. empty path means wrong directory part of RELPATH - get_abspath(self, relpath) -> qstring - - @param relpath: char const * - -ida_dirtree.dirtree_t.get_dir_size (method) - get_dir_size(self, diridx) -> ssize_t - Get dir size - - @param diridx: (C++: diridx_t) directory index - @return: number of entries under this directory; if error, return -1 - -ida_dirtree.dirtree_t.get_entry_attrs (method) - get_entry_attrs(self, de) -> qstring - Get entry attributes - - @param de: (C++: const direntry_t &) directory entry - @return: name - -ida_dirtree.dirtree_t.get_entry_name (method) - get_entry_name(self, de, name_flags=DTN_FULL_NAME) -> qstring - Get entry name - - @param de: (C++: const direntry_t &) directory entry - @param name_flags: (C++: uint32) how exactly the name should be retrieved. combination of bits - for get_...name() methods bits - @return: name - -ida_dirtree.dirtree_t.get_id (method) - get_id(self) -> char const * - netnode name - -ida_dirtree.dirtree_t.get_parent_cursor (method) - get_parent_cursor(self, cursor) -> dirtree_cursor_t - Get parent cursor. - - @param cursor: (C++: const dirtree_cursor_t &) a valid ditree cursor - @return: cursor's parent - -ida_dirtree.dirtree_t.get_rank (method) - get_rank(self, diridx, de) -> ssize_t - Get ordering rank of an item. - - @param diridx: (C++: diridx_t) index of the parent directory - @param de: (C++: const direntry_t &) directory entry - @return: number in a range of [0..n) where n is the number of entries in the - parent directory. -1 if error - -ida_dirtree.dirtree_t.getcwd (method) - getcwd(self) -> qstring - Get current directory - - @return: the current working directory - -ida_dirtree.dirtree_t.is_dir_ordered (method) - is_dir_ordered(self, diridx) -> bool - Is dir ordered? - - @param diridx: (C++: diridx_t) - @return: true if the dirtree has natural ordering - -ida_dirtree.dirtree_t.is_orderable (method) - is_orderable(self) -> bool - Is dirtree orderable? - - @return: true if the dirtree is orderable - -ida_dirtree.dirtree_t.isdir (method) - isdir(self, de) -> bool - - @param de: direntry_t const & - - isdir(self, path) -> bool - - @param path: char const * - -ida_dirtree.dirtree_t.isfile (method) - isfile(self, de) -> bool - - @param de: direntry_t const & - - isfile(self, path) -> bool - - @param path: char const * - -ida_dirtree.dirtree_t.link (method) - link(self, path) -> dterr_t - Add an inode into the current directory - - @param path: char const * - - @return: dterr_t error code - link(self, inode) -> dterr_t - - @param inode: inode_t - -ida_dirtree.dirtree_t.load (method) - load(self) -> bool - Load the tree structure from the netnode. If dirspec_t::id is empty, the - operation will be considered a success. In addition, calling load() more than - once will not do anything, and will be considered a success. - - @return: success - @see: dirspec_t::id. - -ida_dirtree.dirtree_t.mkdir (method) - mkdir(self, path) -> dterr_t - Create a directory. - - @param path: (C++: const char *) directory to create - @return: dterr_t error code - -ida_dirtree.dirtree_t.notify_dirtree (method) - notify_dirtree(self, added, inode) - Notify dirtree about a change of an inode. - - @param added: (C++: bool) are we adding or deleting an inode? - @param inode: (C++: inode_t) inode in question - -ida_dirtree.dirtree_t.rename (method) - rename(self, _from, to) -> dterr_t - Rename a directory entry. - - @param from: (C++: const char *) source path - @param to: (C++: const char *) destination path - @return: dterr_t error code - @note: This function can also rename the item - -ida_dirtree.dirtree_t.resolve_cursor (method) - resolve_cursor(self, cursor) -> direntry_t - Resolve cursor - - @param cursor: (C++: const dirtree_cursor_t &) to analyze - @return: directory entry; if the cursor is bad, the resolved entry will be - invalid. - @note: see also get_abspath() - -ida_dirtree.dirtree_t.resolve_path (method) - resolve_path(self, path) -> direntry_t - Resolve path - - @param path: (C++: const char *) to analyze - @return: directory entry - -ida_dirtree.dirtree_t.rmdir (method) - rmdir(self, path) -> dterr_t - Remove a directory. - - @param path: (C++: const char *) directory to delete - @return: dterr_t error code - -ida_dirtree.dirtree_t.save (method) - save(self) -> bool - Save the tree structure to the netnode. - - @return: success - @see: dirspec_t::id. - -ida_dirtree.dirtree_t.set_id (method) - set_id(self, nm) - - @param nm: char const * - -ida_dirtree.dirtree_t.set_natural_order (method) - set_natural_order(self, diridx, enable) -> bool - Enable/disable natural inode order in a directory. - - @param diridx: (C++: diridx_t) directory index - @param enable: (C++: bool) action to do TRUE - enable ordering: re-order existing entries so - that all subdirs are at the to beginning of the list, file - entries are sorted and placed after the subdirs FALSE - disable - ordering, no changes to existing entries - @return: SUCCESS - -ida_dirtree.dirtree_t.traverse (method) - traverse(self, v) -> ssize_t - Traverse dirtree, and be notified at each entry If the the visitor returns - anything other than 0, iteration will stop, and that value returned. The tree is - traversed using a depth-first algorithm. It is forbidden to modify the dirtree_t - during traversal; doing so will result in undefined behavior. - - @param v: (C++: dirtree_visitor_t &) the callback - @return: 0, or whatever the visitor returned - -ida_dirtree.dirtree_t.unlink (method) - unlink(self, path) -> dterr_t - Remove an inode from the current directory - - @param path: char const * - - @return: dterr_t error code - unlink(self, inode) -> dterr_t - - @param inode: inode_t - -ida_dirtree.dirtree_t_errstr (function) - dirtree_t_errstr(err) -> char const * - - @param err: enum dterr_t - -ida_dirtree.dirtree_visitor_t (class) - Proxy of C++ dirtree_visitor_t class. - -ida_dirtree.dirtree_visitor_t.__disown__ (method) - -ida_dirtree.dirtree_visitor_t.__init__ (method) - __init__(self) -> dirtree_visitor_t - - @param self: PyObject * - -ida_dirtree.dirtree_visitor_t.visit (method) - visit(self, c, de) -> ssize_t - Will be called for each entry in the dirtree_t If something other than 0 is - returned, iteration will stop. - - @param c: (C++: const dirtree_cursor_t &) the current cursor - @param de: (C++: const direntry_t &) the current entry - @return: 0 to keep iterating, or anything else to stop - -ida_dirtree.get_std_dirtree (function) - get_std_dirtree(id) -> dirtree_t - - @param id: enum dirtree_id_t - -ida_entry (module) - Functions that deal with entry points. - - Exported functions are considered as entry points as well. - - IDA maintains list of entry points to the program. Each entry point: - * has an address - * has a name - * may have an ordinal number - -ida_entry.AEF_IDBENC (variable) - the name is given in the IDB encoding; non-ASCII bytes will be decoded - accordingly. Specifying AEF_IDBENC also implies AEF_NODUMMY - -ida_entry.AEF_NODUMMY (variable) - automatically prepend the name with '_' if it begins with a dummy suffix. See - also AEF_IDBENC - -ida_entry.AEF_UTF8 (variable) - the name is given in UTF-8 (default) - -ida_entry.add_entry (function) - add_entry(ord, ea, name, makecode, flags=0) -> bool - Add an entry point to the list of entry points. - - @param ord: (C++: uval_t) ordinal number if ordinal number is equal to 'ea' then ordinal is - not used - @param ea: (C++: ea_t) linear address - @param name: (C++: const char *) name of entry point. If the specified location already has a name, - the old name will be appended to the regular comment. If name == - nullptr, then the old name will be retained. - @param makecode: (C++: bool) should the kernel convert bytes at the entry point to - instruction(s) - @param flags: (C++: int) See AEF_* - @return: success (currently always true) - -ida_entry.get_entry (function) - get_entry(ord) -> ea_t - Get entry point address by its ordinal - - @param ord: (C++: uval_t) ordinal number of entry point - @return: address or BADADDR - -ida_entry.get_entry_forwarder (function) - get_entry_forwarder(ord) -> str - Get forwarder name for the entry point by its ordinal. - - @param ord: (C++: uval_t) ordinal number of entry point - @return: size of entry forwarder name or -1 - -ida_entry.get_entry_name (function) - get_entry_name(ord) -> str - Get name of the entry point by its ordinal. - - @param ord: (C++: uval_t) ordinal number of entry point - @return: size of entry name or -1 - -ida_entry.get_entry_ordinal (function) - get_entry_ordinal(idx) -> uval_t - Get ordinal number of an entry point. - - @param idx: (C++: size_t) internal number of entry point. Should be in the range - 0..get_entry_qty()-1 - @return: ordinal number or 0. - -ida_entry.get_entry_qty (function) - get_entry_qty() -> size_t - Get number of entry points. - -ida_entry.rename_entry (function) - rename_entry(ord, name, flags=0) -> bool - Rename entry point. - - @param ord: (C++: uval_t) ordinal number of the entry point - @param name: (C++: const char *) name of entry point. If the specified location already has a name, - the old name will be appended to a repeatable comment. - @param flags: (C++: int) See AEF_* - @return: success - -ida_entry.set_entry_forwarder (function) - set_entry_forwarder(ord, name, flags=0) -> bool - Set forwarder name for ordinal. - - @param ord: (C++: uval_t) ordinal number of the entry point - @param name: (C++: const char *) forwarder name for entry point. - @param flags: (C++: int) See AEF_* - @return: success - -ida_enum (module) - Assembly level enum management. - - Enums and bitfields are represented as enum_t. - -ida_enum.DEFMASK (variable) - default bitmask - -ida_enum.ENFL_REGEX (variable) - apply regular expressions to beautify the name - -ida_enum.ENUM_MEMBER_ERROR_ENUM (variable) - bad enum id - -ida_enum.ENUM_MEMBER_ERROR_ILLV (variable) - bad bmask and value combination (~bmask & value != 0) - -ida_enum.ENUM_MEMBER_ERROR_MASK (variable) - bad bmask - -ida_enum.ENUM_MEMBER_ERROR_NAME (variable) - already have member with this name (bad name) - -ida_enum.ENUM_MEMBER_ERROR_VALUE (variable) - already have 256 members with this value - -ida_enum.MAX_ENUM_SERIAL (variable) - Max number of identical constants allowed for one enum type. - -ida_enum.add_enum (function) - add_enum(idx, name, flag) -> enum_t - Add new enum type. - * if idx==BADADDR then add as the last idx - * if name==nullptr then generate a unique name "enum_%d" - - @param idx: (C++: size_t) - @param name: (C++: const char *) char const * - @param flag: (C++: flags64_t) - -ida_enum.add_enum_member (function) - add_enum_member(id, name, value, bmask=(bmask_t(-1))) -> int - Add member to enum type. - - @param id: (C++: enum_t) - @param name: (C++: const char *) char const * - @param value: (C++: uval_t) - @param bmask: (C++: bmask_t) - @return: 0 if ok, otherwise one of Add enum member result codes - -ida_enum.del_enum (function) - del_enum(id) - Delete an enum type. - - @param id: (C++: enum_t) - -ida_enum.del_enum_member (function) - del_enum_member(id, value, serial, bmask) -> bool - Delete member of enum type. - - @param id: (C++: enum_t) - @param value: (C++: uval_t) - @param serial: (C++: uchar) - @param bmask: (C++: bmask_t) - -ida_enum.enum_member_visitor_t (class) - Proxy of C++ enum_member_visitor_t class. - -ida_enum.enum_member_visitor_t.__disown__ (method) - -ida_enum.enum_member_visitor_t.__init__ (method) - __init__(self) -> enum_member_visitor_t - - @param self: PyObject * - -ida_enum.enum_member_visitor_t.visit_enum_member (method) - visit_enum_member(self, cid, value) -> int - Implements action to take when enum member is visited. - - @param cid: (C++: const_t) - @param value: (C++: uval_t) - @return: nonzero to stop the iteration - -ida_enum.for_all_enum_members (function) - for_all_enum_members(id, cv) -> int - Visit all members of a given enum. - - @param id: (C++: enum_t) - @param cv: (C++: enum_member_visitor_t &) - -ida_enum.get_bmask_cmt (function) - get_bmask_cmt(id, bmask, repeatable) -> str - - @param id: enum_t - @param bmask: bmask_t - @param repeatable: bool - -ida_enum.get_bmask_name (function) - get_bmask_name(id, bmask) -> str - - @param id: enum_t - @param bmask: bmask_t - -ida_enum.get_enum (function) - get_enum(name) -> enum_t - Get enum by name. - - @param name: (C++: const char *) char const * - -ida_enum.get_enum_cmt (function) - get_enum_cmt(id, repeatable) -> str - Get enum comment. - - @param id: (C++: enum_t) - @param repeatable: (C++: bool) - -ida_enum.get_enum_flag (function) - get_enum_flag(id) -> flags64_t - Get flags determining the representation of the enum. (currently they define the - numeric base: octal, decimal, hex, bin) and signness. - - @param id: (C++: enum_t) - -ida_enum.get_enum_idx (function) - get_enum_idx(id) -> uval_t - Get the index in the list of enums. - - @param id: (C++: enum_t) - -ida_enum.get_enum_member (function) - get_enum_member(id, value, serial, mask) -> const_t - Find an enum member by enum, value and bitmask - @note: if serial -1, return a member with any serial - - @param id: (C++: enum_t) - @param value: (C++: uval_t) - @param serial: (C++: int) - @param mask: (C++: bmask_t) - -ida_enum.get_enum_member_bmask (function) - get_enum_member_bmask(id) -> bmask_t - Get bitmask of an enum member. - - @param id: (C++: const_t) - -ida_enum.get_enum_member_by_name (function) - get_enum_member_by_name(name) -> const_t - Get a reference to an enum member by its name. - - @param name: (C++: const char *) char const * - -ida_enum.get_enum_member_cmt (function) - get_enum_member_cmt(id, repeatable) -> str - Get enum member's comment. - - @param id: (C++: const_t) - @param repeatable: (C++: bool) - -ida_enum.get_enum_member_enum (function) - get_enum_member_enum(id) -> enum_t - Get the parent enum of an enum member. - - @param id: (C++: const_t) - -ida_enum.get_enum_member_name (function) - get_enum_member_name(id) -> str - Get name of an enum member by const_t. - - @param id: (C++: const_t) - -ida_enum.get_enum_member_serial (function) - get_enum_member_serial(cid) -> uchar - Get serial number of an enum member. - - @param cid: (C++: const_t) - -ida_enum.get_enum_member_value (function) - get_enum_member_value(id) -> uval_t - Get value of an enum member. - - @param id: (C++: const_t) - -ida_enum.get_enum_name (function) - get_enum_name(id) -> str - - @param id: enum_t - -ida_enum.get_enum_name2 (function) - get_enum_name2(id, flags=0) -> str - Get name of enum - - @param id: (C++: enum_t) enum id - @param flags: (C++: int) Enum name flags - -ida_enum.get_enum_qty (function) - get_enum_qty() -> size_t - Get number of declared enum_t types. - -ida_enum.get_enum_size (function) - get_enum_size(id) -> size_t - Get the number of the members of the enum. - - @param id: (C++: enum_t) - -ida_enum.get_enum_type_ordinal (function) - get_enum_type_ordinal(id) -> int32 - Get corresponding type ordinal number. - - @param id: (C++: enum_t) - -ida_enum.get_enum_width (function) - get_enum_width(id) -> size_t - Get the width of a enum element allowed values: 0 (unspecified),1,2,4,8,16,32,64 - - @param id: (C++: enum_t) - -ida_enum.get_first_bmask (function) - get_first_bmask(enum_id) -> bmask_t - Get first bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum (bitfield) - @return: the smallest bitmask for enum, or DEFMASK - -ida_enum.get_first_enum_member (function) - get_first_enum_member(id, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param bmask: bmask_t - -ida_enum.get_first_serial_enum_member (function) - get_first_serial_enum_member(id, value, bmask) -> const_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_last_bmask (function) - get_last_bmask(enum_id) -> bmask_t - Get last bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum - @return: the biggest bitmask for enum, or DEFMASK - -ida_enum.get_last_enum_member (function) - get_last_enum_member(id, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param bmask: bmask_t - -ida_enum.get_last_serial_enum_member (function) - get_last_serial_enum_member(id, value, bmask) -> const_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_next_bmask (function) - get_next_bmask(enum_id, bmask) -> bmask_t - Get next bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum - @param bmask: (C++: bmask_t) the current bitmask - @return: value of a bitmask with value higher than the specified value, or - DEFMASK - -ida_enum.get_next_enum_member (function) - get_next_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_next_serial_enum_member (function) - get_next_serial_enum_member(in_out_serial, first_cid) -> const_t - - @param in_out_serial: uchar * - @param first_cid: const_t - -ida_enum.get_prev_bmask (function) - get_prev_bmask(enum_id, bmask) -> bmask_t - Get prev bitmask in the enum (bitfield) - - @param enum_id: (C++: enum_t) id of enum - @param bmask: (C++: bmask_t) the current bitmask - @return: value of a bitmask with value lower than the specified value, or - DEFMASK - -ida_enum.get_prev_enum_member (function) - get_prev_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t - - @param id: enum_t - @param value: uval_t - @param bmask: bmask_t - -ida_enum.get_prev_serial_enum_member (function) - get_prev_serial_enum_member(in_out_serial, first_cid) -> const_t - - @param in_out_serial: uchar * - @param first_cid: const_t - -ida_enum.getn_enum (function) - getn_enum(idx) -> enum_t - Get enum by its index in the list of enums (0..get_enum_qty()-1). - - @param idx: (C++: size_t) - -ida_enum.is_bf (function) - is_bf(id) -> bool - Is enum a bitfield? (otherwise - plain enum, no bitmasks except for DEFMASK are - allowed) - - @param id: (C++: enum_t) - -ida_enum.is_enum_fromtil (function) - is_enum_fromtil(id) -> bool - Does enum come from type library? - - @param id: (C++: enum_t) - -ida_enum.is_enum_hidden (function) - is_enum_hidden(id) -> bool - Is enum collapsed? - - @param id: (C++: enum_t) - -ida_enum.is_ghost_enum (function) - is_ghost_enum(id) -> bool - Is a ghost copy of a local type? - - @param id: (C++: enum_t) - -ida_enum.is_one_bit_mask (function) - is_one_bit_mask(mask) -> bool - Is bitmask one bit? - - @param mask: (C++: bmask_t) - -ida_enum.set_bmask_cmt (function) - set_bmask_cmt(id, bmask, cmt, repeatable) -> bool - - @param id: enum_t - @param bmask: bmask_t - @param cmt: char const * - @param repeatable: bool - -ida_enum.set_bmask_name (function) - set_bmask_name(id, bmask, name) -> bool - - @param id: enum_t - @param bmask: bmask_t - @param name: char const * - -ida_enum.set_enum_bf (function) - set_enum_bf(id, bf) -> bool - Set 'bitfield' bit of enum (i.e. convert it to a bitfield) - - @param id: (C++: enum_t) - @param bf: (C++: bool) - -ida_enum.set_enum_cmt (function) - set_enum_cmt(id, cmt, repeatable) -> bool - Set comment for enum type. - - @param id: (C++: enum_t) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_enum.set_enum_flag (function) - set_enum_flag(id, flag) -> bool - Set data representation flags. - - @param id: (C++: enum_t) - @param flag: (C++: flags64_t) - -ida_enum.set_enum_fromtil (function) - set_enum_fromtil(id, fromtil) -> bool - Specify that enum comes from a type library. - - @param id: (C++: enum_t) - @param fromtil: (C++: bool) - -ida_enum.set_enum_ghost (function) - set_enum_ghost(id, ghost) -> bool - Specify that enum is a ghost copy of a local type. - - @param id: (C++: enum_t) - @param ghost: (C++: bool) - -ida_enum.set_enum_hidden (function) - set_enum_hidden(id, hidden) -> bool - Collapse enum. - - @param id: (C++: enum_t) - @param hidden: (C++: bool) - -ida_enum.set_enum_idx (function) - set_enum_idx(id, idx) -> bool - Set serial number of enum. Also see get_enum_idx(). - - @param id: (C++: enum_t) - @param idx: (C++: size_t) - -ida_enum.set_enum_member_cmt (function) - set_enum_member_cmt(id, cmt, repeatable) -> bool - Set comment for enum member. - - @param id: (C++: const_t) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_enum.set_enum_member_name (function) - set_enum_member_name(id, name) -> bool - Set name of enum member. - - @param id: (C++: const_t) - @param name: (C++: const char *) char const * - -ida_enum.set_enum_name (function) - set_enum_name(id, name) -> bool - Set name of enum type. - - @param id: (C++: enum_t) - @param name: (C++: const char *) char const * - -ida_enum.set_enum_type_ordinal (function) - set_enum_type_ordinal(id, ord) - Set corresponding type ordinal number. - - @param id: (C++: enum_t) - @param ord: (C++: int32) - -ida_enum.set_enum_width (function) - set_enum_width(id, width) -> bool - See comment for get_enum_width() - - @param id: (C++: enum_t) - @param width: (C++: int) - -ida_expr (module) - Functions that deal with C-like expressions and built-in IDC language. - - Functions marked THREAD_SAFE may be called from any thread. No simultaneous - calls should be made for the same variable. We protect only global structures, - individual variables must be protected manually. - -ida_expr.CPL_DEL_MACROS (variable) - delete macros at the end of compilation - -ida_expr.CPL_ONLY_SAFE (variable) - allow calls of only thread-safe functions - -ida_expr.CPL_USE_LABELS (variable) - allow program labels in the script - -ida_expr.EXTFUN_BASE (variable) - requires open database. - -ida_expr.EXTFUN_NORET (variable) - does not return. the interpreter may clean up its state before calling it. - -ida_expr.EXTFUN_SAFE (variable) - thread safe function. may be called from any thread. - -ida_expr.IDC_LANG_EXT (variable) - IDC script extension. - -ida_expr.VARSLICE_SINGLE (variable) - return single index (i2 is ignored) - -ida_expr.VREF_COPY (variable) - copy the result to the input var (v) - -ida_expr.VREF_LOOP (variable) - dereference until we get a non VT_REF - -ida_expr.VREF_ONCE (variable) - dereference only once, do not loop - -ida_expr.VT_FLOAT (variable) - Floating point (see idc_value_t::e) - -ida_expr.VT_FUNC (variable) - Function (see idc_value_t::funcidx) - -ida_expr.VT_INT64 (variable) - i64 - -ida_expr.VT_LONG (variable) - Integer (see idc_value_t::num) - -ida_expr.VT_OBJ (variable) - Object (see idc_value_t::obj) - -ida_expr.VT_PVOID (variable) - void * - -ida_expr.VT_REF (variable) - Reference. - -ida_expr.VT_STR (variable) - String (see qstr() and similar functions) - -ida_expr.VT_WILD (variable) - Function with arbitrary number of arguments. The actual number of arguments will - be passed in idc_value_t::num. This value should not be used for idc_value_t. - -ida_expr._IdcFunction (class) - Internal class that calls pyw_call_idc_func() with a context - -ida_expr._IdcFunction.__call__ (method) - -ida_expr._IdcFunction.__init__ (method) - -ida_expr.add_idc_class (function) - add_idc_class(name, super=None) -> idc_class_t * - Create a new IDC class. - - @param name: (C++: const char *) name of the new class - @param super: (C++: const idc_class_t *) the base class for the new class. if the new class is not based on - any other class, pass nullptr - @return: pointer to the created class. If such a class already exists, a pointer - to it will be returned. Pointers to other existing classes may be - invalidated by this call. - -ida_expr.add_idc_func (function) - Extends the IDC language by exposing a new IDC function that is backed up by a Python function - - Add an IDC function. This function does not modify the predefined kernel - functions. Example: - static error_t idaapi myfunc5(idc_value_t *argv, idc_value_t *res) - { - msg("myfunc is called with arg0=%a and arg1=%s\n", argv[0].num, argv[1].str); - res->num = 5; // let's return 5 - return eOk; - } - static const char myfunc5_args[] = { VT_LONG, VT_STR, 0 }; - static const ext_idcfunc_t myfunc_desc = { "MyFunc5", myfunc5, myfunc5_args, - nullptr, 0, EXTFUN_BASE }; - // after this: - add_idc_func(myfunc_desc); - // there is a new IDC function which can be called like this: - MyFunc5(0x123, "test"); - - @note: If the function already exists, it will be replaced by the new function - @return: success - -ida_expr.add_idc_gvar (function) - add_idc_gvar(name) -> idc_value_t - Add global IDC variable. - - @param name: (C++: const char *) name of the global variable - @return: pointer to the created variable or existing variable. NB: the returned - pointer is valid until a new global var is added. - -ida_expr.call_idc_func__ (function) - -ida_expr.compile_idc_file (function) - compile_idc_file(nonnul_line) -> str - - @param nonnul_line: char const * - -ida_expr.compile_idc_snippet (function) - compile_idc_snippet(func, text, resolver=None, only_safe_funcs=False) -> str - Compile text with IDC statements. - - @param func: (C++: const char *) name of the function to create out of the snippet - @param text: (C++: const char *) text to compile - @param resolver: (C++: idc_resolver_t *) callback object to get values of undefined variables This - object will be called if IDC function contains references to - undefined variables. May be nullptr. - @param only_safe_funcs: (C++: bool) if true, any calls to functions without EXTFUN_SAFE flag - will lead to a compilation error. - @retval true: ok - @retval false: error, see errbuf - -ida_expr.compile_idc_text (function) - compile_idc_text(nonnul_line) -> str - - @param nonnul_line: char const * - -ida_expr.copy_idcv (function) - copy_idcv(dst, src) -> error_t - Copy 'src' to 'dst'. For idc objects only a reference is copied. - - @param dst: (C++: idc_value_t *) - @param src: (C++: const idc_value_t &) idc_value_t const & - -ida_expr.create_idcv_ref (function) - create_idcv_ref(ref, v) -> bool - Create a variable reference. Currently only references to global variables can - be created. - - @param ref: (C++: idc_value_t *) ptr to the result - @param v: (C++: const idc_value_t *) variable to reference - @return: success - -ida_expr.deep_copy_idcv (function) - deep_copy_idcv(dst, src) -> error_t - Deep copy an IDC object. This function performs deep copy of idc objects. If - 'src' is not an object, copy_idcv() will be called - - @param dst: (C++: idc_value_t *) - @param src: (C++: const idc_value_t &) idc_value_t const & - -ida_expr.del_idc_func (function) - Unregisters the specified IDC function - - Delete an IDC function - -ida_expr.del_idcv_attr (function) - del_idcv_attr(obj, attr) -> error_t - Delete an object attribute. - - @param obj: (C++: idc_value_t *) variable that holds an object reference - @param attr: (C++: const char *) attribute name - @return: error code, eOk on success - -ida_expr.deref_idcv (function) - deref_idcv(v, vref_flags) -> idc_value_t - Dereference a VT_REF variable. - - @param v: (C++: idc_value_t *) variable to dereference - @param vref_flags: (C++: int) Dereference IDC variable flags - @return: pointer to the dereference result or nullptr. If returns nullptr, - qerrno is set to eExecBadRef "Illegal variable reference" - -ida_expr.eExecThrow (variable) - See return value of idc_func_t. - -ida_expr.eval_expr (function) - eval_expr(rv, where, line) -> str - Compile and calculate an expression. - - @param rv: (C++: idc_value_t *) pointer to the result - @param where: (C++: ea_t) the current linear address in the addressing space of the program - being disassembled. If will be used to resolve names of local - variables etc. if not applicable, then should be BADADDR. - @param line: (C++: const char *) the expression to evaluate - @retval true: ok - @retval false: error, see errbuf - -ida_expr.eval_idc_expr (function) - eval_idc_expr(rv, where, line) -> str - Same as eval_expr(), but will always use the IDC interpreter regardless of the - currently installed extlang. - - @param rv: (C++: idc_value_t *) - @param where: (C++: ea_t) - @param line: char const * - -ida_expr.exec_idc_script (function) - exec_idc_script(result, path, func, args, argsnum) -> str - Compile and execute IDC function(s) from file. - - @param result: (C++: idc_value_t *) ptr to idc_value_t to hold result of the function. If execution - fails, this variable will contain the exception information. You - may pass nullptr if you are not interested in the returned value. - @param path: (C++: const char *) text file containing text of IDC functions - @param func: (C++: const char *) function name to execute - @param args: (C++: const idc_value_t) array of parameters - @param argsnum: (C++: size_t) number of parameters to pass to 'fname' This number should be - equal to number of parameters the function expects. - @retval true: ok - @retval false: error, see errbuf - -ida_expr.exec_system_script (function) - exec_system_script(file, complain_if_no_file=True) -> bool - Compile and execute "main" function from system file. - - @param file: (C++: const char *) file name with IDC function(s). The file will be searched using - get_idc_filename(). - @param complain_if_no_file: (C++: bool) * 1: display warning if the file is not found - * 0: don't complain if file doesn't exist - @retval 1: ok, file is compiled and executed - @retval 0: failure, compilation or execution error, warning is displayed - -ida_expr.find_idc_class (function) - find_idc_class(name) -> idc_class_t * - Find an existing IDC class by its name. - - @param name: (C++: const char *) name of the class - @return: pointer to the class or nullptr. The returned pointer is valid until a - new call to add_idc_class() - -ida_expr.find_idc_func (function) - find_idc_func(prefix, n=0) -> str - - @param prefix: char const * - @param n: int - -ida_expr.find_idc_gvar (function) - find_idc_gvar(name) -> idc_value_t - Find an existing global IDC variable by its name. - - @param name: (C++: const char *) name of the global variable - @return: pointer to the variable or nullptr. NB: the returned pointer is valid - until a new global var is added. FIXME: it is difficult to use this - function in a thread safe manner - -ida_expr.first_idcv_attr (function) - first_idcv_attr(obj) -> char const * - - @param obj: idc_value_t const * - -ida_expr.free_idcv (function) - free_idcv(v) - Free storage used by VT_STR/VT_OBJ IDC variables. After this call the variable - has a numeric value 0 - - @param v: (C++: idc_value_t *) - -ida_expr.get_idc_filename (function) - get_idc_filename(file) -> str - Get full name of IDC file name. Search for file in list of include directories, - IDCPATH directory and system directories. - - @param file: (C++: const char *) file name without full path - @return: nullptr is file not found. otherwise returns pointer to buf - -ida_expr.get_idcv_attr (function) - get_idcv_attr(res, obj, attr, may_use_getattr=False) -> error_t - Get an object attribute. - - @param res: (C++: idc_value_t *) buffer for the attribute value - @param obj: (C++: const idc_value_t *) variable that holds an object reference. if obj is nullptr it - searches global variables, then user functions - @param attr: (C++: const char *) attribute name - @param may_use_getattr: (C++: bool) may call getattr functions to calculate the attribute if - it does not exist - @return: error code, eOk on success - -ida_expr.get_idcv_class_name (function) - get_idcv_class_name(obj) -> str - Retrieves the IDC object class name. - - @param obj: (C++: const idc_value_t *) class instance variable - @return: error code, eOk on success - -ida_expr.get_idcv_slice (function) - get_idcv_slice(res, v, i1, i2, flags=0) -> error_t - Get slice. - - @param res: (C++: idc_value_t *) output variable that will contain the slice - @param v: (C++: const idc_value_t *) input variable (string or object) - @param i1: (C++: uval_t) slice start index - @param i2: (C++: uval_t) slice end index (excluded) - @param flags: (C++: int) IDC variable slice flags or 0 - @return: eOk if success - -ida_expr.highlighter_cbs_t (class) - Proxy of C++ highlighter_cbs_t class. - -ida_expr.highlighter_cbs_t.__disown__ (method) - -ida_expr.highlighter_cbs_t.__init__ (method) - __init__(self) -> highlighter_cbs_t - - @param self: PyObject * - -ida_expr.highlighter_cbs_t.cur_block_state (method) - cur_block_state(self) -> int32 - -ida_expr.highlighter_cbs_t.prev_block_state (method) - prev_block_state(self) -> int32 - -ida_expr.highlighter_cbs_t.set_block_state (method) - set_block_state(self, arg0) - - @param arg0: int32 - -ida_expr.highlighter_cbs_t.set_style (method) - set_style(self, arg0, arg1, arg2) - - @param arg0: int32 - @param arg1: int32 - @param arg2: enum syntax_highlight_style - -ida_expr.idc_global_t (class) - Proxy of C++ idc_global_t class. - -ida_expr.idc_global_t.__init__ (method) - __init__(self) -> idc_global_t - __init__(self, n) -> idc_global_t - - @param n: char const * - -ida_expr.idc_value_t (class) - Proxy of C++ idc_value_t class. - -ida_expr.idc_value_t.__init__ (method) - __init__(self, n=0) -> idc_value_t - - @param n: sval_t - - __init__(self, r) -> idc_value_t - - @param r: idc_value_t const & - - __init__(self, _str) -> idc_value_t - - @param _str: char const * - -ida_expr.idc_value_t._create_empty_string (method) - _create_empty_string(self) - -ida_expr.idc_value_t.c_str (method) - c_str(self) -> char const * - VT_STR - -ida_expr.idc_value_t.clear (method) - clear(self) - See free_idcv() - -ida_expr.idc_value_t.create_empty_string (method) - create_empty_string(self) - -ida_expr.idc_value_t.e (variable) - VT_FLOAT - -ida_expr.idc_value_t.funcidx (variable) - VT_FUNC - -ida_expr.idc_value_t.i64 (variable) - VT_INT64 - -ida_expr.idc_value_t.is_convertible (method) - is_convertible(self) -> bool - Convertible types are VT_LONG, VT_FLOAT, VT_INT64, and VT_STR. - -ida_expr.idc_value_t.is_integral (method) - is_integral(self) -> bool - Does value represent a whole number? - -ida_expr.idc_value_t.is_zero (method) - is_zero(self) -> bool - Does value represent the integer 0? - -ida_expr.idc_value_t.num (variable) - VT_LONG - -ida_expr.idc_value_t.pvoid (variable) - VT_PVOID - -ida_expr.idc_value_t.qstr (method) - qstr(self) -> qstring - VT_STR - qstr(self) -> qstring const & - -ida_expr.idc_value_t.reserve (variable) - internal housekeeping: 64-bit qstring is bigger than 12 bytes - -ida_expr.idc_value_t.set_float (method) - set_float(self, f) - - @param f: fpvalue_t const & - -ida_expr.idc_value_t.set_int64 (method) - set_int64(self, v) - - @param v: int64 - -ida_expr.idc_value_t.set_long (method) - set_long(self, v) - - @param v: sval_t - -ida_expr.idc_value_t.set_pvoid (method) - set_pvoid(self, p) - - @param p: void * - -ida_expr.idc_value_t.set_string (method) - set_string(self, _str, len) - - @param _str: char const * - @param len: size_t - - set_string(self, _str) - - @param _str: char const * - -ida_expr.idc_value_t.swap (method) - swap(self, v) - Set this = r and v = this. - - @param v: (C++: idc_value_t &) - -ida_expr.idc_value_t.u_str (method) - u_str(self) -> uchar const * - VT_STR - -ida_expr.idc_value_t.vtype (variable) - IDC value types - -ida_expr.idc_values_t (class) - Proxy of C++ qvector< idc_value_t > class. - -ida_expr.idc_values_t.__getitem__ (method) - __getitem__(self, i) -> idc_value_t - - @param i: size_t - -ida_expr.idc_values_t.__init__ (method) - __init__(self) -> idc_values_t - __init__(self, x) -> idc_values_t - - @param x: qvector< idc_value_t > const & - -ida_expr.idc_values_t.__len__ (method) - __len__(self) -> size_t - -ida_expr.idc_values_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: idc_value_t const & - -ida_expr.idc_values_t.at (method) - at(self, _idx) -> idc_value_t - - @param _idx: size_t - -ida_expr.idc_values_t.begin (method) - begin(self) -> idc_value_t - -ida_expr.idc_values_t.capacity (method) - capacity(self) -> size_t - -ida_expr.idc_values_t.clear (method) - clear(self) - -ida_expr.idc_values_t.empty (method) - empty(self) -> bool - -ida_expr.idc_values_t.end (method) - end(self) -> idc_value_t - -ida_expr.idc_values_t.erase (method) - erase(self, it) -> idc_value_t - - @param it: qvector< idc_value_t >::iterator - - erase(self, first, last) -> idc_value_t - - @param first: qvector< idc_value_t >::iterator - @param last: qvector< idc_value_t >::iterator - -ida_expr.idc_values_t.extract (method) - extract(self) -> idc_value_t - -ida_expr.idc_values_t.grow (method) - grow(self, x=idc_value_t()) - - @param x: idc_value_t const & - -ida_expr.idc_values_t.inject (method) - inject(self, s, len) - - @param s: idc_value_t * - @param len: size_t - -ida_expr.idc_values_t.insert (method) - insert(self, it, x) -> idc_value_t - - @param it: qvector< idc_value_t >::iterator - @param x: idc_value_t const & - -ida_expr.idc_values_t.pop_back (method) - pop_back(self) - -ida_expr.idc_values_t.push_back (method) - push_back(self, x) - - @param x: idc_value_t const & - - push_back(self) -> idc_value_t - -ida_expr.idc_values_t.qclear (method) - qclear(self) - -ida_expr.idc_values_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_expr.idc_values_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: idc_value_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_expr.idc_values_t.size (method) - size(self) -> size_t - -ida_expr.idc_values_t.swap (method) - swap(self, r) - - @param r: qvector< idc_value_t > & - -ida_expr.idc_values_t.truncate (method) - truncate(self) - -ida_expr.idcv_float (function) - idcv_float(v) -> error_t - Convert IDC variable to a floating point. - - @param v: (C++: idc_value_t *) - -ida_expr.idcv_int64 (function) - idcv_int64(v) -> error_t - Convert IDC variable to a 64bit number. - - @param v: (C++: idc_value_t *) - @return: v = 0 if impossible to convert to int64 - -ida_expr.idcv_long (function) - idcv_long(v) -> error_t - Convert IDC variable to a long (32/64bit) number. - - @param v: (C++: idc_value_t *) - @return: v = 0 if impossible to convert to long - -ida_expr.idcv_num (function) - idcv_num(v) -> error_t - Convert IDC variable to a long number. - - @param v: (C++: idc_value_t *) - @return: * v = 0 if IDC variable = "false" string - * v = 1 if IDC variable = "true" string - * v = number if IDC variable is number or string containing a number - * eTypeConflict if IDC variable = empty string - -ida_expr.idcv_object (function) - idcv_object(v, icls=None) -> error_t - Create an IDC object. The original value of 'v' is discarded (freed). - - @param v: (C++: idc_value_t *) variable to hold the object. any previous value will be cleaned - @param icls: (C++: const idc_class_t *) ptr to the desired class. nullptr means "object" class this ptr - must be returned by add_idc_class() or find_idc_class() - @return: always eOk - -ida_expr.idcv_string (function) - idcv_string(v) -> error_t - Convert IDC variable to a text string. - - @param v: (C++: idc_value_t *) - -ida_expr.last_idcv_attr (function) - last_idcv_attr(obj) -> char const * - - @param obj: idc_value_t const * - -ida_expr.move_idcv (function) - move_idcv(dst, src) -> error_t - Move 'src' to 'dst'. This function is more effective than copy_idcv since it - never copies big amounts of data. - - @param dst: (C++: idc_value_t *) - @param src: (C++: idc_value_t *) - -ida_expr.next_idcv_attr (function) - next_idcv_attr(obj, attr) -> char const * - - @param obj: idc_value_t const * - @param attr: char const * - -ida_expr.prev_idcv_attr (function) - prev_idcv_attr(obj, attr) -> char const * - - @param obj: idc_value_t const * - @param attr: char const * - -ida_expr.print_idcv (function) - print_idcv(v, name=None, indent=0) -> str - Get text representation of idc_value_t. - - @param v: (C++: const idc_value_t &) idc_value_t const & - @param name: (C++: const char *) char const * - @param indent: (C++: int) - -ida_expr.py_add_idc_func (function) - py_add_idc_func(name, fp_ptr, args, defvals, flags) -> bool - - @param name: char const * - @param fp_ptr: size_t - @param args: char const * - @param defvals: idc_values_t const & - @param flags: int - -ida_expr.py_get_call_idc_func (function) - py_get_call_idc_func() -> size_t - -ida_expr.pyw_convert_defvals (function) - pyw_convert_defvals(out, py_seq) -> bool - - @param out: idc_values_t * - @param py_seq: PyObject * - -ida_expr.pyw_register_idc_func (function) - pyw_register_idc_func(name, args, py_fp) -> size_t - - @param name: char const * - @param args: char const * - @param py_fp: PyObject * - -ida_expr.pyw_unregister_idc_func (function) - pyw_unregister_idc_func(ctxptr) -> bool - - @param ctxptr: size_t - -ida_expr.set_header_path (function) - set_header_path(path, add) -> bool - Set or append a header path. IDA looks for the include files in the appended - header paths, then in the ida executable directory. - - @param path: (C++: const char *) list of directories to add (separated by ';') may be nullptr, in - this case nothing is added - @param add: (C++: bool) true: append. false: remove old paths. - @retval true: success - @retval false: no memory - -ida_expr.set_idcv_attr (function) - set_idcv_attr(obj, attr, value, may_use_setattr=False) -> error_t - Set an object attribute. - - @param obj: (C++: idc_value_t *) variable that holds an object reference. if obj is nullptr then it - tries to modify a global variable with the attribute name - @param attr: (C++: const char *) attribute name - @param value: (C++: const idc_value_t &) new attribute value - @param may_use_setattr: (C++: bool) may call setattr functions for the class - @return: error code, eOk on success - -ida_expr.set_idcv_slice (function) - set_idcv_slice(v, i1, i2, _in, flags=0) -> error_t - Set slice. - - @param v: (C++: idc_value_t *) variable to modify (string or object) - @param i1: (C++: uval_t) slice start index - @param i2: (C++: uval_t) slice end index (excluded) - @param in: (C++: const idc_value_t &) new value for the slice - @param flags: (C++: int) IDC variable slice flags or 0 - @return: eOk on success - -ida_expr.swap_idcvs (function) - swap_idcvs(v1, v2) - Swap 2 variables. - - @param v1: (C++: idc_value_t *) - @param v2: (C++: idc_value_t *) - -ida_expr.throw_idc_exception (function) - throw_idc_exception(r, desc) -> error_t - Create an idc execution exception object. This helper function can be used to - return an exception from C++ code to IDC. In other words this function can be - called from idc_func_t() callbacks. Sample usage: if ( !ok ) return - throw_idc_exception(r, "detailed error msg"); - - @param r: (C++: idc_value_t *) object to hold the exception object - @param desc: (C++: const char *) exception description - @return: eExecThrow - -ida_fixup (module) - Functions that deal with fixup information. - - A loader should setup fixup information using set_fixup(). - -ida_fixup.FIXUPF_CREATED (variable) - fixup was not present in the input file - -ida_fixup.FIXUPF_EXTDEF (variable) - target is a location (otherwise - segment). Use this bit if the target is a - symbol rather than an offset from the beginning of a segment. - -ida_fixup.FIXUPF_LOADER_MASK (variable) - additional flags. The bits from this mask are not stored in the database and can - be used by the loader at its discretion. - -ida_fixup.FIXUPF_REL (variable) - fixup is relative to the linear address `base'. Otherwise fixup is relative to - the start of the segment with `sel' selector. - -ida_fixup.FIXUPF_UNUSED (variable) - fixup is ignored by IDA - * disallows the kernel to convert operands - * this fixup is not used during output - -ida_fixup.FIXUP_CUSTOM (variable) - start of the custom types range - -ida_fixup.FIXUP_HI16 (variable) - high 16 bits of 32bit offset - -ida_fixup.FIXUP_HI8 (variable) - high 8 bits of 16bit offset - -ida_fixup.FIXUP_LOW16 (variable) - low 16 bits of 32bit offset - -ida_fixup.FIXUP_LOW8 (variable) - low 8 bits of 16bit offset - -ida_fixup.FIXUP_OFF16 (variable) - 16-bit offset - -ida_fixup.FIXUP_OFF16S (variable) - 16-bit signed offset - -ida_fixup.FIXUP_OFF32 (variable) - 32-bit offset - -ida_fixup.FIXUP_OFF32S (variable) - 32-bit signed offset - -ida_fixup.FIXUP_OFF64 (variable) - 64-bit offset - -ida_fixup.FIXUP_OFF8 (variable) - 8-bit offset - -ida_fixup.FIXUP_OFF8S (variable) - 8-bit signed offset - -ida_fixup.FIXUP_PTR16 (variable) - 32-bit long pointer (16-bit base:16-bit offset) - -ida_fixup.FIXUP_PTR32 (variable) - 48-bit pointer (16-bit base:32-bit offset) - -ida_fixup.FIXUP_SEG16 (variable) - 16-bit base-logical segment base (selector) - -ida_fixup.V695_FIXUP_VHIGH (variable) - obsolete - -ida_fixup.V695_FIXUP_VLOW (variable) - obsolete - -ida_fixup.calc_fixup_size (function) - calc_fixup_size(type) -> int - Calculate size of fixup in bytes (the number of bytes the fixup patches) - @retval -1: means error - - @param type: (C++: fixup_type_t) - -ida_fixup.contains_fixups (function) - contains_fixups(ea, size) -> bool - Does the specified address range contain any fixup information? - - @param ea: (C++: ea_t) - @param size: (C++: asize_t) - -ida_fixup.del_fixup (function) - del_fixup(source) - Delete fixup information. - - @param source: (C++: ea_t) - -ida_fixup.exists_fixup (function) - exists_fixup(source) -> bool - Check that a fixup exists at the given address. - - @param source: (C++: ea_t) - -ida_fixup.find_custom_fixup (function) - find_custom_fixup(name) -> fixup_type_t - Get id of a custom fixup handler. - - @param name: (C++: const char *) name of the custom fixup handler - @return: id with FIXUP_CUSTOM bit set or 0 - -ida_fixup.fixup_data_t (class) - Proxy of C++ fixup_data_t class. - -ida_fixup.fixup_data_t.__init__ (method) - __init__(self) -> fixup_data_t - __init__(self, type_, flags_=0) -> fixup_data_t - - @param type_: fixup_type_t - @param flags_: uint32 - -ida_fixup.fixup_data_t.calc_size (method) - calc_size(self) -> int - calc_fixup_size() - -ida_fixup.fixup_data_t.clr_extdef (method) - clr_extdef(self) - -ida_fixup.fixup_data_t.clr_unused (method) - clr_unused(self) - -ida_fixup.fixup_data_t.displacement (variable) - displacement (offset from the target) - -ida_fixup.fixup_data_t.get (method) - get(self, source) -> bool - get_fixup() - - @param source: (C++: ea_t) - -ida_fixup.fixup_data_t.get_base (method) - get_base(self) -> ea_t - Get base of fixup. - @note: The target is calculated as `get_base() + off`. - @see: FIXUPF_REL - -ida_fixup.fixup_data_t.get_desc (method) - get_desc(self, source) -> char const * - get_fixup_desc() - - @param source: (C++: ea_t) - -ida_fixup.fixup_data_t.get_flags (method) - get_flags(self) -> uint32 - Fixup flags Fixup flags. - -ida_fixup.fixup_data_t.get_handler (method) - get_handler(self) -> fixup_handler_t const * - get_fixup_handler() - -ida_fixup.fixup_data_t.get_type (method) - get_type(self) -> fixup_type_t - Fixup type Types of fixups. - -ida_fixup.fixup_data_t.get_value (method) - get_value(self, ea) -> uval_t - get_fixup_value() - - @param ea: (C++: ea_t) - -ida_fixup.fixup_data_t.has_base (method) - has_base(self) -> bool - Is fixup relative? - -ida_fixup.fixup_data_t.is_custom (method) - is_custom(self) -> bool - is_fixup_custom() - -ida_fixup.fixup_data_t.is_extdef (method) - is_extdef(self) -> bool - -ida_fixup.fixup_data_t.is_unused (method) - is_unused(self) -> bool - -ida_fixup.fixup_data_t.off (variable) - target offset - @note: The target is calculated as `get_base() + off`. - -ida_fixup.fixup_data_t.patch_value (method) - patch_value(self, ea) -> bool - patch_fixup_value() - - @param ea: (C++: ea_t) - -ida_fixup.fixup_data_t.sel (variable) - selector of the target segment. BADSEL means an absolute (zero based) target. - @see: FIXUPF_REL - -ida_fixup.fixup_data_t.set (method) - set(self, source) - set_fixup() - - @param source: (C++: ea_t) - -ida_fixup.fixup_data_t.set_base (method) - set_base(self, new_base) - Set base of fixup. The target should be set before a call of this function. - - @param new_base: (C++: ea_t) - -ida_fixup.fixup_data_t.set_extdef (method) - set_extdef(self) - -ida_fixup.fixup_data_t.set_sel (method) - set_sel(self, seg) - - @param seg: segment_t const * - -ida_fixup.fixup_data_t.set_target_sel (method) - set_target_sel(self) - Set selector of fixup to the target. The target should be set before a call of - this function. - -ida_fixup.fixup_data_t.set_type (method) - set_type(self, type_) - - @param type_: fixup_type_t - -ida_fixup.fixup_data_t.set_type_and_flags (method) - set_type_and_flags(self, type_, flags_=0) - - @param type_: fixup_type_t - @param flags_: uint32 - -ida_fixup.fixup_data_t.set_unused (method) - set_unused(self) - -ida_fixup.fixup_data_t.was_created (method) - was_created(self) -> bool - Is fixup artificial? - -ida_fixup.fixup_info_t (class) - Proxy of C++ fixup_info_t class. - -ida_fixup.fixup_info_t.__init__ (method) - __init__(self) -> fixup_info_t - -ida_fixup.gen_fix_fixups (function) - gen_fix_fixups(_from, to, size) - Relocate the bytes with fixup information once more (generic function). This - function may be called from loader_t::move_segm() if it suits the goal. If - loader_t::move_segm is not defined then this function will be called - automatically when moving segments or rebasing the entire program. Special - parameter values (from = BADADDR, size = 0, to = delta) are used when the - function is called from rebase_program(delta). - - @param from: (C++: ea_t) - @param to: (C++: ea_t) - @param size: (C++: asize_t) - -ida_fixup.get_first_fixup_ea (function) - get_first_fixup_ea() -> ea_t - -ida_fixup.get_fixup (function) - get_fixup(fd, source) -> bool - Get fixup information. - - @param fd: (C++: fixup_data_t *) - @param source: (C++: ea_t) - -ida_fixup.get_fixup_desc (function) - get_fixup_desc(source, fd) -> str - Get FIXUP description comment. - - @param source: (C++: ea_t) - @param fd: (C++: const fixup_data_t &) fixup_data_t const & - -ida_fixup.get_fixup_handler (function) - get_fixup_handler(type) -> fixup_handler_t const * - Get handler of standard or custom fixup. - - @param type: (C++: fixup_type_t) - -ida_fixup.get_fixup_value (function) - get_fixup_value(ea, type) -> uval_t - Get the operand value. This function get fixup bytes from data or an instruction - at `ea' and convert them to the operand value (maybe partially). It is opposite - in meaning to the `patch_fixup_value()`. For example, FIXUP_HI8 read a byte at - `ea' and shifts it left by 8 bits, or AArch64's custom fixup BRANCH26 get low 26 - bits of the insn at `ea' and shifts it left by 2 bits. This function is mainly - used to get a relocation addend. - - @param ea: (C++: ea_t) address to get fixup bytes from, the size of the fixup bytes depends - on the fixup type. - @see: fixup_handler_t::size - @param type: (C++: fixup_type_t) fixup type - @retval operand: value - -ida_fixup.get_fixups (function) - get_fixups(out, ea, size) -> bool - - @param out: fixups_t * - @param ea: ea_t - @param size: asize_t - -ida_fixup.get_next_fixup_ea (function) - get_next_fixup_ea(ea) -> ea_t - Find next address with fixup information - - @param ea: (C++: ea_t) current address - @return: the next address with fixup information, or BADADDR - -ida_fixup.get_prev_fixup_ea (function) - get_prev_fixup_ea(ea) -> ea_t - Find previous address with fixup information - - @param ea: (C++: ea_t) current address - @return: the previous address with fixup information, or BADADDR - -ida_fixup.handle_fixups_in_macro (function) - handle_fixups_in_macro(ri, ea, other, macro_reft_and_flags) -> bool - Handle two fixups in a macro. We often combine two instruction that load parts - of a value into one macro instruction. For example: - ARM: ADRP X0, #var@PAGE - ADD X0, X0, #var@PAGEOFF --> ADRL X0, var - MIPS: lui $v0, %hi(var) - addiu $v0, $v0, %lo(var) --> la $v0, var - When applying the fixups that fall inside such a macro, we should convert them - to one refinfo. This function does exactly that. It should be called from the - apply() callback of a custom fixup. - - @param ri: (C++: refinfo_t *) - @param ea: (C++: ea_t) - @param other: (C++: fixup_type_t) - @param macro_reft_and_flags: (C++: uint32) - @return: success ('false' means that RI was not changed) - -ida_fixup.is_fixup_custom (function) - is_fixup_custom(type) -> bool - Is fixup processed by processor module? - - @param type: (C++: fixup_type_t) - -ida_fixup.patch_fixup_value (function) - patch_fixup_value(ea, fd) -> bool - Patch the fixup bytes. This function updates data or an instruction at `ea' to - the fixup bytes. For example, FIXUP_HI8 updates a byte at `ea' to the high byte - of `fd->off', or AArch64's custom fixup BRANCH26 updates low 26 bits of the insn - at `ea' to the value of `fd->off' shifted right by 2. - - @param ea: (C++: ea_t) address where data are changed, the size of the changed data depends - on the fixup type. - @see: fixup_handler_t::size - @param fd: (C++: const fixup_data_t &) fixup data - @retval false: the fixup bytes do not fit (e.g. `fd->off' is greater than - 0xFFFFFFC for BRANCH26). The database is changed even in this - case. - -ida_fixup.set_fixup (function) - set_fixup(source, fd) - Set fixup information. You should fill fixup_data_t and call this function and - the kernel will remember information in the database. - - @param source: (C++: ea_t) the fixup source address, i.e. the address modified by the fixup - @param fd: (C++: const fixup_data_t &) fixup data - -ida_fpro (module) - System independent counterparts of FILE* related functions from Clib. - - You should not use C standard I/O functions in your modules. The reason: Each - module compiled with Borland (and statically linked to Borland's library) will - host a copy of the FILE * information. - - So, if you open a file in the plugin and pass the handle to the kernel, the - kernel will not be able to use it. - - If you really need to use the standard functions, define - USE_STANDARD_FILE_FUNCTIONS. In this case do not mix them with q... functions. - -ida_fpro.qfile_t (class) - A helper class to work with FILE related functions. - -ida_fpro.qfile_t.__init__ (method) - __init__(self, rhs) -> qfile_t - - @param rhs: qfile_t const & - - __init__(self, pycapsule=None) -> qfile_t - - @param pycapsule: PyObject * - -ida_fpro.qfile_t.close (method) - close(self) - Closes the file - -ida_fpro.qfile_t.filename (method) - filename(self) -> PyObject * - -ida_fpro.qfile_t.flush (method) - flush(self) -> int - -ida_fpro.qfile_t.from_capsule (method) - from_capsule(pycapsule) -> qfile_t - - @param pycapsule: PyObject * - -ida_fpro.qfile_t.from_fp (method) - from_fp(fp) -> qfile_t - - @param fp: FILE * - -ida_fpro.qfile_t.get_byte (method) - get_byte(self) -> PyObject * - Reads a single byte from the file. Returns None if EOF or the read byte - -ida_fpro.qfile_t.get_fp (method) - get_fp(self) -> FILE * - -ida_fpro.qfile_t.gets (method) - gets(self, size) -> PyObject * - Reads a line from the input file. Returns the read line or None - - @param size: int - -ida_fpro.qfile_t.open (method) - open(self, filename, mode) -> bool - Opens a file - - @param filename: the file name - @param mode: The mode string, ala fopen() style - @return: Boolean - -ida_fpro.qfile_t.opened (method) - opened(self) -> bool - Checks if the file is opened or not - -ida_fpro.qfile_t.put_byte (method) - put_byte(self, chr) -> int - Writes a single byte to the file - - @param chr: int - -ida_fpro.qfile_t.puts (method) - puts(self, str) -> int - - @param str: char const * - -ida_fpro.qfile_t.read (method) - read(self, size) -> PyObject * - Reads from the file. Returns the buffer or None - - @param size: int - -ida_fpro.qfile_t.readbytes (method) - readbytes(self, size, big_endian) -> PyObject * - Similar to read() but it respect the endianness - - @param size: int - @param big_endian: bool - -ida_fpro.qfile_t.seek (method) - seek(self, offset, whence=SEEK_SET) -> int - Set input source position - - @param offset: int64 - @param whence: int - @return: the new position (not 0 as fseek!) - -ida_fpro.qfile_t.size (method) - size(self) -> int64 - -ida_fpro.qfile_t.tell (method) - tell(self) -> int64 - Returns the current position - -ida_fpro.qfile_t.tmpfile (method) - tmpfile() -> qfile_t - A static method to construct an instance using a temporary file - -ida_fpro.qfile_t.write (method) - write(self, py_buf) -> int - Writes to the file. Returns 0 or the number of bytes written - - @param py_buf: PyObject * - -ida_fpro.qfile_t.writebytes (method) - writebytes(self, py_buf, big_endian) -> int - Similar to write() but it respect the endianness - - @param py_buf: PyObject * - @param big_endian: bool - -ida_fpro.qfile_t_from_capsule (function) - qfile_t_from_capsule(pycapsule) -> qfile_t - - @param pycapsule: PyObject * - -ida_fpro.qfile_t_from_fp (function) - qfile_t_from_fp(fp) -> qfile_t - - @param fp: FILE * - -ida_fpro.qfile_t_tmpfile (function) - qfile_t_tmpfile() -> qfile_t - -ida_frame (module) - Routines to manipulate function stack frames, stack variables, register - variables and local labels. - - The frame is represented as a structure: - +------------------------------------------------+ - | function arguments | - +------------------------------------------------+ - | return address (isn't stored in func_t) | - +------------------------------------------------+ - | saved registers (SI, DI, etc - func_t::frregs) | - +------------------------------------------------+ <- typical BP - | | | - | | | func_t::fpd - | | | - | | <- real BP - | local variables (func_t::frsize) | - | | - | | - +------------------------------------------------+ <- SP - - To access the structure of a function frame, use: - * get_struc() (use func_t::frame as structure ID) - * get_frame(const func_t *pfn) - * get_frame(ea_t ea) - -ida_frame.REGVAR_ERROR_ARG (variable) - function arguments are bad - -ida_frame.REGVAR_ERROR_NAME (variable) - the provided name(s) can't be accepted - -ida_frame.REGVAR_ERROR_OK (variable) - all ok - -ida_frame.REGVAR_ERROR_RANGE (variable) - the definition range is bad - -ida_frame.STKVAR_VALID_SIZE (variable) - x.dtyp contains correct variable type (for insns like 'lea' this bit must be - off). In general, dr_O references do not allow to determine the variable size - -ida_frame.add_auto_stkpnt (function) - add_auto_stkpnt(pfn, ea, delta) -> bool - Add automatic SP register change point. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address where SP changes. usually this is the end of the - instruction which modifies the stack pointer ( insn_t::ea+ - insn_t::size) - @param delta: (C++: sval_t) difference between old and new values of SP - @return: success - -ida_frame.add_frame (function) - add_frame(pfn, frsize, frregs, argsize) -> bool - Add function frame. - - @param pfn: (C++: func_t *) pointer to function structure - @param frsize: (C++: sval_t) size of function local variables - @param frregs: (C++: ushort) size of saved registers - @param argsize: (C++: asize_t) size of function arguments range which will be purged upon - return. this parameter is used for __stdcall and __pascal - calling conventions. for other calling conventions please pass - 0. - @retval 1: ok - @retval 0: failed (no function, frame already exists) - -ida_frame.add_regvar (function) - add_regvar(pfn, ea1, ea2, canon, user, cmt) -> int - Define a register variable. - - @param pfn: (C++: func_t *) function in which the definition will be created - @param ea1: (C++: ea_t) ,ea2: range of addresses within the function where the definition will - be used - @param canon: (C++: const char *) name of a general register - @param canon: (C++: const char *) name of a general register - @param user: (C++: const char *) user-defined name for the register - @param cmt: (C++: const char *) comment for the definition - @return: Register variable error codes - -ida_frame.add_user_stkpnt (function) - add_user_stkpnt(ea, delta) -> bool - Add user-defined SP register change point. - - @param ea: (C++: ea_t) linear address where SP changes - @param delta: (C++: sval_t) difference between old and new values of SP - @return: success - -ida_frame.build_stkvar_name (function) - build_stkvar_name(pfn, v) -> str - Build automatic stack variable name. - - @param pfn: (C++: const func_t *) pointer to function (can't be nullptr!) - @param v: (C++: sval_t) value of variable offset - @return: length of stack variable name or -1 - -ida_frame.build_stkvar_xrefs (function) - build_stkvar_xrefs(out, pfn, mptr) - Fill 'out' with a list of all the xrefs made from function 'pfn', to the - argument or variable 'mptr' in 'pfn's stack frame. - - @param out: (C++: xreflist_t *) the list of xrefs to fill. - @param pfn: (C++: func_t *) the function to scan. - @param mptr: (C++: const member_t *) the argument/variable in pfn's stack frame. - -ida_frame.calc_stkvar_struc_offset (function) - calc_stkvar_struc_offset(pfn, insn, n) -> ea_t - Calculate offset of stack variable in the frame structure. - - @param pfn: (C++: func_t *) pointer to function (can't be nullptr!) - @param insn: (C++: const insn_t &) the instruction - @param n: (C++: int) 0..UA_MAXOP-1 operand number -1 if error, return BADADDR - @return: BADADDR if some error (issue a warning if stack frame is bad) - -ida_frame.define_stkvar (function) - define_stkvar(pfn, name, off, flags, ti, nbytes) -> bool - Define/redefine a stack variable. - - @param pfn: (C++: func_t *) pointer to function - @param name: (C++: const char *) variable name, nullptr means autogenerate a name - @param off: (C++: sval_t) offset of the stack variable in the frame. negative values denote - local variables, positive - function arguments. - @param flags: (C++: flags64_t) variable type flags (byte_flag() for a byte variable, for example) - @param ti: (C++: const opinfo_t *) additional type information (like offsets, structs, etc) - @param nbytes: (C++: asize_t) number of bytes occupied by the variable - @return: success - -ida_frame.del_frame (function) - del_frame(pfn) -> bool - Delete a function frame. - - @param pfn: (C++: func_t *) pointer to function structure - @return: success - -ida_frame.del_regvar (function) - del_regvar(pfn, ea1, ea2, canon) -> int - Delete a register variable definition. - - @param pfn: (C++: func_t *) function in question - @param ea1: (C++: ea_t) ,ea2: range of addresses within the function where the definition - holds - @param canon: (C++: const char *) name of a general register - @param canon: (C++: const char *) name of a general register - @return: Register variable error codes - -ida_frame.del_stkpnt (function) - del_stkpnt(pfn, ea) -> bool - Delete SP register change point. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address - @return: success - -ida_frame.delete_unreferenced_stkvars (function) - delete_unreferenced_stkvars(pfn) -> int - - @param pfn: func_t * - -ida_frame.delete_wrong_stkvar_ops (function) - delete_wrong_stkvar_ops(pfn) -> int - - @param pfn: func_t * - -ida_frame.find_regvar (function) - find_regvar(pfn, ea1, ea2, canon, user) -> regvar_t - Find a register variable definition. - - @param pfn: (C++: func_t *) function in question - @param ea1: ea_t - @param canon: (C++: const char *) name of a general register - @param canon: (C++: const char *) name of a general register - @param user: char const * - - @return: nullptr-not found, otherwise ptr to regvar_t - find_regvar(pfn, ea, canon) -> regvar_t - - @param pfn: func_t * - @param ea: ea_t - @param canon: char const * - -ida_frame.frame_off_args (function) - frame_off_args(pfn) -> ea_t - Get starting address of arguments section. - - @param pfn: (C++: const func_t *) func_t const * - -ida_frame.frame_off_lvars (function) - frame_off_lvars(pfn) -> ea_t - Get start address of local variables section. - - @param pfn: (C++: const func_t *) func_t const * - -ida_frame.frame_off_retaddr (function) - frame_off_retaddr(pfn) -> ea_t - Get starting address of return address section. - - @param pfn: (C++: const func_t *) func_t const * - -ida_frame.frame_off_savregs (function) - frame_off_savregs(pfn) -> ea_t - Get starting address of saved registers section. - - @param pfn: (C++: const func_t *) func_t const * - -ida_frame.free_regvar (function) - free_regvar(v) - - @param v: regvar_t * - -ida_frame.get_effective_spd (function) - get_effective_spd(pfn, ea) -> sval_t - Get effective difference between the initial and current values of ESP. This - function returns the sp-diff used by the instruction. The difference between - get_spd() and get_effective_spd() is present only for instructions like "pop - [esp+N]": they modify sp and use the modified value. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address - @return: 0 or the difference, usually a negative number - -ida_frame.get_frame (function) - get_frame(pfn) -> struc_t * - Get pointer to function frame. - - @param pfn: func_t const * - -ida_frame.get_frame_member_by_id (function) - get_frame_member_by_id(out_mname, out_fptr, mid) -> member_t * - Check if the specified member id points to a frame member. - - @param out_mname: (C++: qstring *) - @param out_fptr: (C++: struc_t **) - @param mid: (C++: tid_t) - -ida_frame.get_frame_part (function) - get_frame_part(range, pfn, part) - Get offsets of the frame part in the frame. - - @param range: (C++: range_t *) pointer to the output buffer with the frame part - start/end(exclusive) offsets, can't be nullptr - @param pfn: (C++: const func_t *) pointer to function structure, can't be nullptr - @param part: (C++: frame_part_t) frame part - -ida_frame.get_frame_retsize (function) - get_frame_retsize(pfn) -> int - Get size of function return address. - - @param pfn: (C++: const func_t *) pointer to function structure, can't be nullptr - -ida_frame.get_frame_size (function) - get_frame_size(pfn) -> asize_t - Get full size of a function frame. This function takes into account size of - local variables + size of saved registers + size of return address + number of - purged bytes. The purged bytes correspond to the arguments of the functions with - __stdcall and __fastcall calling conventions. - - @param pfn: (C++: const func_t *) pointer to function structure, may be nullptr - @return: size of frame in bytes or zero - -ida_frame.get_func_by_frame (function) - get_func_by_frame(frame_id) -> ea_t - Get function by its frame id. - @warning: this function works only with databases created by IDA > 5.6 - - @param frame_id: (C++: tid_t) id of the function frame - @return: start address of the function or BADADDR - -ida_frame.get_min_spd_ea (function) - get_min_spd_ea(pfn) -> ea_t - - @param pfn: func_t * - -ida_frame.get_sp_delta (function) - get_sp_delta(pfn, ea) -> sval_t - Get modification of SP made at the specified location - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address - @return: 0 if the specified location doesn't contain a SP change point. - otherwise return delta of SP modification. - -ida_frame.get_spd (function) - get_spd(pfn, ea) -> sval_t - Get difference between the initial and current values of ESP. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address of the instruction - @return: 0 or the difference, usually a negative number. returns the sp-diff - before executing the instruction. - -ida_frame.get_stkvar (function) - get_stkvar(insn, op, v) -> (member_t, int) or None - Get pointer to stack variable - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @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 - -ida_frame.has_regvar (function) - has_regvar(pfn, ea) -> bool - Is there a register variable definition? - - @param pfn: (C++: func_t *) function in question - @param ea: (C++: ea_t) current address - -ida_frame.is_funcarg_off (function) - is_funcarg_off(pfn, frameoff) -> bool - - @param pfn: func_t const * - @param frameoff: uval_t - -ida_frame.lvar_off (function) - lvar_off(pfn, frameoff) -> sval_t - - @param pfn: func_t const * - @param frameoff: uval_t - -ida_frame.recalc_spd (function) - recalc_spd(cur_ea) -> bool - Recalculate SP delta for an instruction that stops execution. The next - instruction is not reached from the current instruction. We need to recalculate - SP for the next instruction. - - This function will create a new automatic SP register change point if necessary. - It should be called from the emulator (emu.cpp) when auto_state == AU_USED if - the current instruction doesn't pass the execution flow to the next instruction. - - @param cur_ea: (C++: ea_t) linear address of the current instruction - @retval 1: new stkpnt is added - @retval 0: nothing is changed - -ida_frame.recalc_spd_for_basic_block (function) - recalc_spd_for_basic_block(pfn, cur_ea) -> bool - Recalculate SP delta for the current instruction. The typical code snippet to - calculate SP delta in a proc module is: - - if ( may_trace_sp() && pfn != nullptr ) - if ( !recalc_spd_for_basic_block(pfn, insn.ea) ) - trace_sp(pfn, insn); - - where trace_sp() is a typical name for a function that emulates the SP change of - an instruction. - - @param pfn: (C++: func_t *) pointer to the function - @param cur_ea: (C++: ea_t) linear address of the current instruction - @retval true: the cumulative SP delta is set - @retval false: the instruction at CUR_EA passes flow to the next instruction. SP - delta must be set as a result of emulating the current - instruction. - -ida_frame.regvar_t (class) - Proxy of C++ regvar_t class. - -ida_frame.regvar_t.__init__ (method) - __init__(self) -> regvar_t - __init__(self, r) -> regvar_t - - @param r: regvar_t const & - -ida_frame.regvar_t.canon (variable) - canonical register name (case-insensitive) - -ida_frame.regvar_t.cmt (variable) - comment to appear near definition - -ida_frame.regvar_t.swap (method) - swap(self, r) - - @param r: regvar_t & - -ida_frame.regvar_t.user (variable) - user-defined register name - -ida_frame.rename_regvar (function) - rename_regvar(pfn, v, user) -> int - Rename a register variable. - - @param pfn: (C++: func_t *) function in question - @param v: (C++: regvar_t *) variable to rename - @param user: (C++: const char *) new user-defined name for the register - @return: Register variable error codes - -ida_frame.set_auto_spd (function) - set_auto_spd(pfn, ea, new_spd) -> bool - Add such an automatic SP register change point so that at EA the new cumulative - SP delta (that is, the difference between the initial and current values of SP) - would be equal to NEW_SPD. - - @param pfn: (C++: func_t *) pointer to the function. may be nullptr. - @param ea: (C++: ea_t) linear address of the instruction - @param new_spd: (C++: sval_t) new value of the cumulative SP delta - @return: success - -ida_frame.set_frame_size (function) - set_frame_size(pfn, frsize, frregs, argsize) -> bool - Set size of function frame. Note: The returned size may not include all stack - arguments. It does so only for __stdcall and __fastcall calling conventions. To - get the entire frame size for all cases use get_struc_size(get_frame(pfn)). - - @param pfn: (C++: func_t *) pointer to function structure - @param frsize: (C++: asize_t) size of function local variables - @param frregs: (C++: ushort) size of saved registers - @param argsize: (C++: asize_t) size of function arguments that will be purged from the stack - upon return - @return: success - -ida_frame.set_purged (function) - set_purged(ea, nbytes, override_old_value) -> bool - Set the number of purged bytes for a function or data item (funcptr). This - function will update the database and plan to reanalyze items referencing the - specified address. It works only for processors with PR_PURGING bit in 16 and 32 - bit modes. - - @param ea: (C++: ea_t) address of the function of item - @param nbytes: (C++: int) number of purged bytes - @param override_old_value: (C++: bool) may overwrite old information about purged bytes - @return: success - -ida_frame.set_regvar_cmt (function) - set_regvar_cmt(pfn, v, cmt) -> int - Set comment for a register variable. - - @param pfn: (C++: func_t *) function in question - @param v: (C++: regvar_t *) variable to rename - @param cmt: (C++: const char *) new comment - @return: Register variable error codes - -ida_frame.soff_to_fpoff (function) - soff_to_fpoff(pfn, soff) -> sval_t - Convert struct offsets into fp-relative offsets. This function converts the - offsets inside the struc_t object into the frame pointer offsets (for example, - EBP-relative). - - @param pfn: (C++: func_t *) - @param soff: (C++: uval_t) - -ida_frame.stkpnt_t (class) - Proxy of C++ stkpnt_t class. - -ida_frame.stkpnt_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: stkpnt_t const & - -ida_frame.stkpnt_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: stkpnt_t const & - -ida_frame.stkpnt_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: stkpnt_t const & - -ida_frame.stkpnt_t.__init__ (method) - __init__(self) -> stkpnt_t - -ida_frame.stkpnt_t.__le__ (method) - __le__(self, r) -> bool - - @param r: stkpnt_t const & - -ida_frame.stkpnt_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: stkpnt_t const & - -ida_frame.stkpnt_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: stkpnt_t const & - -ida_frame.stkpnt_t.compare (method) - compare(self, r) -> int - - @param r: stkpnt_t const & - -ida_frame.stkpnts_t (class) - Proxy of C++ stkpnts_t class. - -ida_frame.stkpnts_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: stkpnts_t const & - -ida_frame.stkpnts_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: stkpnts_t const & - -ida_frame.stkpnts_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: stkpnts_t const & - -ida_frame.stkpnts_t.__init__ (method) - __init__(self) -> stkpnts_t - -ida_frame.stkpnts_t.__le__ (method) - __le__(self, r) -> bool - - @param r: stkpnts_t const & - -ida_frame.stkpnts_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: stkpnts_t const & - -ida_frame.stkpnts_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: stkpnts_t const & - -ida_frame.stkpnts_t.compare (method) - compare(self, r) -> int - - @param r: stkpnts_t const & - -ida_frame.update_fpd (function) - update_fpd(pfn, fpd) -> bool - Update frame pointer delta. - - @param pfn: (C++: func_t *) pointer to function structure - @param fpd: (C++: asize_t) new fpd value. cannot be bigger than the local variable range size. - @return: success - -ida_frame.xreflist_entry_t (class) - Proxy of C++ xreflist_entry_t class. - -ida_frame.xreflist_entry_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: xreflist_entry_t const & - -ida_frame.xreflist_entry_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: xreflist_entry_t const & - -ida_frame.xreflist_entry_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: xreflist_entry_t const & - -ida_frame.xreflist_entry_t.__init__ (method) - __init__(self) -> xreflist_entry_t - -ida_frame.xreflist_entry_t.__le__ (method) - __le__(self, r) -> bool - - @param r: xreflist_entry_t const & - -ida_frame.xreflist_entry_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: xreflist_entry_t const & - -ida_frame.xreflist_entry_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: xreflist_entry_t const & - -ida_frame.xreflist_entry_t.compare (method) - compare(self, r) -> int - - @param r: xreflist_entry_t const & - -ida_frame.xreflist_entry_t.ea (variable) - Location of the insn referencing the stack frame member. - -ida_frame.xreflist_entry_t.opnum (variable) - Number of the operand of that instruction. - -ida_frame.xreflist_entry_t.type (variable) - The type of xref (cref_t & dref_t) - -ida_frame.xreflist_t (class) - Proxy of C++ qvector< xreflist_entry_t > class. - -ida_frame.xreflist_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< xreflist_entry_t > const & - -ida_frame.xreflist_t.__getitem__ (method) - __getitem__(self, i) -> xreflist_entry_t - - @param i: size_t - -ida_frame.xreflist_t.__init__ (method) - __init__(self) -> xreflist_t - __init__(self, x) -> xreflist_t - - @param x: qvector< xreflist_entry_t > const & - -ida_frame.xreflist_t.__len__ (method) - __len__(self) -> size_t - -ida_frame.xreflist_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< xreflist_entry_t > const & - -ida_frame.xreflist_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: xreflist_entry_t const & - -ida_frame.xreflist_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: xreflist_entry_t const & - -ida_frame.xreflist_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: xreflist_entry_t const & - -ida_frame.xreflist_t.at (method) - at(self, _idx) -> xreflist_entry_t - - @param _idx: size_t - -ida_frame.xreflist_t.begin (method) - begin(self) -> xreflist_entry_t - -ida_frame.xreflist_t.capacity (method) - capacity(self) -> size_t - -ida_frame.xreflist_t.clear (method) - clear(self) - -ida_frame.xreflist_t.empty (method) - empty(self) -> bool - -ida_frame.xreflist_t.end (method) - end(self) -> xreflist_entry_t - -ida_frame.xreflist_t.erase (method) - erase(self, it) -> xreflist_entry_t - - @param it: qvector< xreflist_entry_t >::iterator - - erase(self, first, last) -> xreflist_entry_t - - @param first: qvector< xreflist_entry_t >::iterator - @param last: qvector< xreflist_entry_t >::iterator - -ida_frame.xreflist_t.extract (method) - extract(self) -> xreflist_entry_t - -ida_frame.xreflist_t.find (method) - find(self, x) -> xreflist_entry_t - - @param x: xreflist_entry_t const & - -ida_frame.xreflist_t.grow (method) - grow(self, x=xreflist_entry_t()) - - @param x: xreflist_entry_t const & - -ida_frame.xreflist_t.has (method) - has(self, x) -> bool - - @param x: xreflist_entry_t const & - -ida_frame.xreflist_t.inject (method) - inject(self, s, len) - - @param s: xreflist_entry_t * - @param len: size_t - -ida_frame.xreflist_t.insert (method) - insert(self, it, x) -> xreflist_entry_t - - @param it: qvector< xreflist_entry_t >::iterator - @param x: xreflist_entry_t const & - -ida_frame.xreflist_t.pop_back (method) - pop_back(self) - -ida_frame.xreflist_t.push_back (method) - push_back(self, x) - - @param x: xreflist_entry_t const & - - push_back(self) -> xreflist_entry_t - -ida_frame.xreflist_t.qclear (method) - qclear(self) - -ida_frame.xreflist_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_frame.xreflist_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: xreflist_entry_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_frame.xreflist_t.size (method) - size(self) -> size_t - -ida_frame.xreflist_t.swap (method) - swap(self, r) - - @param r: qvector< xreflist_entry_t > & - -ida_frame.xreflist_t.truncate (method) - truncate(self) - -ida_funcs (module) - Routines for working with functions within the disassembled program. - - This file also contains routines for working with library signatures (e.g. - FLIRT). - - Each function consists of function chunks. At least one function chunk must be - present in the function definition - the function entry chunk. Other chunks are - called function tails. There may be several of them for a function. - - A function tail is a continuous range of addresses. It can be used in the - definition of one or more functions. One function using the tail is singled out - and called the tail owner. This function is considered as 'possessing' the tail. - get_func() on a tail address will return the function possessing the tail. You - can enumerate the functions using the tail by using func_parent_iterator_t. - - Each function chunk in the disassembly is represented as an "range" (a range of - addresses, see range.hpp for details) with characteristics. - - A function entry must start with an instruction (code) byte. - -ida_funcs.FIND_FUNC_DEFINE (variable) - create instruction if undefined byte is encountered - -ida_funcs.FIND_FUNC_EXIST (variable) - function exists already. its bounds are returned in 'nfn'. - -ida_funcs.FIND_FUNC_IGNOREFN (variable) - ignore existing function boundaries. by default the function returns function - boundaries if ea belongs to a function. - -ida_funcs.FIND_FUNC_KEEPBD (variable) - do not modify incoming function boundaries, just create instructions inside the - boundaries. - -ida_funcs.FIND_FUNC_NORMAL (variable) - stop processing if undefined byte is encountered - -ida_funcs.FIND_FUNC_OK (variable) - ok, 'nfn' is ready for add_func() - -ida_funcs.FIND_FUNC_UNDEF (variable) - function has instructions that pass execution flow to unexplored bytes. - nfn->end_ea will have the address of the unexplored byte. - -ida_funcs.FUNC_BOTTOMBP (variable) - BP points to the bottom of the stack frame. - -ida_funcs.FUNC_FAR (variable) - Far function. - -ida_funcs.FUNC_FRAME (variable) - Function uses frame pointer (BP) - -ida_funcs.FUNC_FUZZY_SP (variable) - Function changes SP in untraceable way, for example: and esp, 0FFFFFFF0h - -ida_funcs.FUNC_HIDDEN (variable) - A hidden function chunk. - -ida_funcs.FUNC_LIB (variable) - Library function. - -ida_funcs.FUNC_LUMINA (variable) - Function info is provided by Lumina. - -ida_funcs.FUNC_NORET (variable) - Function doesn't return. - -ida_funcs.FUNC_NORET_PENDING (variable) - Function 'non-return' analysis must be performed. This flag is verified upon - func_does_return() - -ida_funcs.FUNC_OUTLINE (variable) - Outlined code, not a real function. - -ida_funcs.FUNC_PROLOG_OK (variable) - Prolog analysis has been performed by last SP-analysis - -ida_funcs.FUNC_PURGED_OK (variable) - 'argsize' field has been validated. If this bit is clear and 'argsize' is 0, - then we do not known the real number of bytes removed from the stack. This bit - is handled by the processor module. - -ida_funcs.FUNC_REANALYZE (variable) - Function frame changed, request to reanalyze the function after the last insn is - analyzed. - -ida_funcs.FUNC_SP_READY (variable) - SP-analysis has been performed. If this flag is on, the stack change points - should not be not modified anymore. Currently this analysis is performed only - for PC - -ida_funcs.FUNC_STATICDEF (variable) - Static function. - -ida_funcs.FUNC_TAIL (variable) - This is a function tail. Other bits must be clear (except FUNC_HIDDEN). - -ida_funcs.FUNC_THUNK (variable) - Thunk (jump) function. - -ida_funcs.FUNC_USERFAR (variable) - User has specified far-ness of the function - -ida_funcs.IDASGN_APPLIED (variable) - signature is already applied - -ida_funcs.IDASGN_BADARG (variable) - bad number of signature - -ida_funcs.IDASGN_CURRENT (variable) - signature is currently being applied - -ida_funcs.IDASGN_OK (variable) - ok - -ida_funcs.IDASGN_PLANNED (variable) - signature is planned to be applied - -ida_funcs.LIBFUNC_DELAY (variable) - no decision because of lack of information - -ida_funcs.LIBFUNC_FOUND (variable) - ok, library function is found - -ida_funcs.LIBFUNC_NONE (variable) - no, this is not a library function - -ida_funcs.MOVE_FUNC_BADSTART (variable) - bad new start address - -ida_funcs.MOVE_FUNC_NOCODE (variable) - no instruction at 'newstart' - -ida_funcs.MOVE_FUNC_NOFUNC (variable) - no function at 'ea' - -ida_funcs.MOVE_FUNC_OK (variable) - ok - -ida_funcs.MOVE_FUNC_REFUSED (variable) - a plugin refused the action - -ida_funcs.add_func (function) - add_func(ea1, ea2=BADADDR) -> bool - Add a new function. If the function end address is BADADDR, then IDA will try to - determine the function bounds by calling find_func_bounds(..., - FIND_FUNC_DEFINE). - - @param ea1: (C++: ea_t) start address - @param ea2: (C++: ea_t) end address - @return: success - -ida_funcs.add_func_ex (function) - add_func_ex(pfn) -> bool - Add a new function. If the fn->end_ea is BADADDR, then IDA will try to determine - the function bounds by calling find_func_bounds(..., FIND_FUNC_DEFINE). - - @param pfn: (C++: func_t *) ptr to filled function structure - @return: success - -ida_funcs.add_regarg (function) - add_regarg(pfn, reg, tif, name) - - @param pfn: func_t * - @param reg: int - @param tif: tinfo_t const & - @param name: char const * - -ida_funcs.append_func_tail (function) - append_func_tail(pfn, ea1, ea2) -> bool - Append a new tail chunk to the function definition. If the tail already exists, - then it will simply be added to the function tail list Otherwise a new tail will - be created and its owner will be set to be our function If a new tail cannot be - created, then this function will fail. - - @param pfn: (C++: func_t *) pointer to the function - @param ea1: (C++: ea_t) start of the tail. If a tail already exists at the specified address - it must start at 'ea1' - @param ea2: (C++: ea_t) end of the tail. If a tail already exists at the specified address - it must end at 'ea2'. If specified as BADADDR, IDA will determine - the end address itself. - -ida_funcs.apply_idasgn_to (function) - apply_idasgn_to(signame, ea, is_startup) -> int - Apply a signature file to the specified address. - - @param signame: (C++: const char *) short name of signature file (the file name without path) - @param ea: (C++: ea_t) address to apply the signature - @param is_startup: (C++: bool) if set, then the signature is treated as a startup one for - startup signature ida doesn't rename the first function of - the applied module. - @return: Library function codes - -ida_funcs.apply_startup_sig (function) - apply_startup_sig(ea, startup) -> bool - Apply a startup signature file to the specified address. - - @param ea: (C++: ea_t) address to apply the signature to; usually idainfo::start_ea - @param startup: (C++: const char *) the name of the signature file without path and extension - @return: true if successfully applied the signature - -ida_funcs.calc_func_size (function) - calc_func_size(pfn) -> asize_t - Calculate function size. This function takes into account all fragments of the - function. - - @param pfn: (C++: func_t *) ptr to function structure - -ida_funcs.calc_idasgn_state (function) - calc_idasgn_state(n) -> int - Get state of a signature in the list of planned signatures - - @param n: (C++: int) number of signature in the list (0..get_idasgn_qty()-1) - @return: state of signature or IDASGN_BADARG - -ida_funcs.calc_thunk_func_target (function) - calc_thunk_func_target(pfn) -> ea_t - Calculate target of a thunk function. - - @param pfn: (C++: func_t *) pointer to function (may not be nullptr) - @return: the target function or BADADDR - -ida_funcs.calc_thunk_func_target (function) - -ida_funcs.del_func (function) - del_func(ea) -> bool - Delete a function. - - @param ea: (C++: ea_t) any address in the function entry chunk - @return: success - -ida_funcs.del_idasgn (function) - del_idasgn(n) -> int - Remove signature from the list of planned signatures. - - @param n: (C++: int) number of signature in the list (0..get_idasgn_qty()-1) - @return: IDASGN_OK, IDASGN_BADARG, IDASGN_APPLIED - -ida_funcs.dyn_ea_array (class) - Proxy of C++ dynamic_wrapped_array_t< ea_t > class. - -ida_funcs.dyn_ea_array.__getitem__ (method) - __getitem__(self, i) -> unsigned-ea-like-numeric-type const & - - @param i: size_t - -ida_funcs.dyn_ea_array.__init__ (method) - __init__(self, _data, _count) -> dyn_ea_array - - @param _data: unsigned-ea-like-numeric-type * - @param _count: size_t - -ida_funcs.dyn_ea_array.__len__ (method) - __len__(self) -> size_t - -ida_funcs.dyn_ea_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned-ea-like-numeric-type const & - -ida_funcs.dyn_range_array (class) - Proxy of C++ dynamic_wrapped_array_t< range_t > class. - -ida_funcs.dyn_range_array.__getitem__ (method) - __getitem__(self, i) -> range_t - - @param i: size_t - -ida_funcs.dyn_range_array.__init__ (method) - __init__(self, _data, _count) -> dyn_range_array - - @param _data: range_t * - @param _count: size_t - -ida_funcs.dyn_range_array.__len__ (method) - __len__(self) -> size_t - -ida_funcs.dyn_range_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: range_t const & - -ida_funcs.dyn_regarg_array (class) - Proxy of C++ dynamic_wrapped_array_t< regarg_t > class. - -ida_funcs.dyn_regarg_array.__getitem__ (method) - __getitem__(self, i) -> regarg_t - - @param i: size_t - -ida_funcs.dyn_regarg_array.__init__ (method) - __init__(self, _data, _count) -> dyn_regarg_array - - @param _data: regarg_t * - @param _count: size_t - -ida_funcs.dyn_regarg_array.__len__ (method) - __len__(self) -> size_t - -ida_funcs.dyn_regarg_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regarg_t const & - -ida_funcs.dyn_regvar_array (class) - Proxy of C++ dynamic_wrapped_array_t< regvar_t > class. - -ida_funcs.dyn_regvar_array.__getitem__ (method) - __getitem__(self, i) -> regvar_t const & - - @param i: size_t - -ida_funcs.dyn_regvar_array.__init__ (method) - __init__(self, _data, _count) -> dyn_regvar_array - - @param _data: regvar_t * - @param _count: size_t - -ida_funcs.dyn_regvar_array.__len__ (method) - __len__(self) -> size_t - -ida_funcs.dyn_regvar_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regvar_t const & - -ida_funcs.dyn_stkpnt_array (class) - Proxy of C++ dynamic_wrapped_array_t< stkpnt_t > class. - -ida_funcs.dyn_stkpnt_array.__getitem__ (method) - __getitem__(self, i) -> stkpnt_t const & - - @param i: size_t - -ida_funcs.dyn_stkpnt_array.__init__ (method) - __init__(self, _data, _count) -> dyn_stkpnt_array - - @param _data: stkpnt_t * - @param _count: size_t - -ida_funcs.dyn_stkpnt_array.__len__ (method) - __len__(self) -> size_t - -ida_funcs.dyn_stkpnt_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: stkpnt_t const & - -ida_funcs.f_any (function) - f_any(arg1, arg2) -> bool - Helper function to accept any address. - - @param arg1: flags64_t - @param arg2: void * - -ida_funcs.find_func_bounds (function) - find_func_bounds(nfn, flags) -> int - Determine the boundaries of a new function. This function tries to find the - start and end addresses of a new function. It calls the module with - processor_t::func_bounds in order to fine tune the function boundaries. - - @param nfn: (C++: func_t *) structure to fill with information \ nfn->start_ea points to the - start address of the new function. - @param flags: (C++: int) Find function bounds flags - @return: Find function bounds result codes - -ida_funcs.free_regarg (function) - free_regarg(v) - - @param v: regarg_t * - -ida_funcs.func_contains (function) - func_contains(pfn, ea) -> bool - Does the given function contain the given address? - - @param pfn: (C++: func_t *) - @param ea: (C++: ea_t) - -ida_funcs.func_does_return (function) - func_does_return(callee) -> bool - Does the function return?. To calculate the answer, FUNC_NORET flag and - is_noret() are consulted The latter is required for imported functions in the - .idata section. Since in .idata we have only function pointers but not - functions, we have to introduce a special flag for them. - - @param callee: (C++: ea_t) - -ida_funcs.func_item_iterator_t (class) - Proxy of C++ func_item_iterator_t class. - -ida_funcs.func_item_iterator_t.__init__ (method) - __init__(self) -> func_item_iterator_t - __init__(self, pfn, _ea=BADADDR) -> func_item_iterator_t - - @param pfn: func_t * - @param _ea: ea_t - -ida_funcs.func_item_iterator_t.__iter__ (method) - Provide an iterator on code items - -ida_funcs.func_item_iterator_t.__next__ (method) - __next__(self, func) -> bool - - @param func: testf_t * - -ida_funcs.func_item_iterator_t.addresses (method) - Provide an iterator on addresses contained within the function - -ida_funcs.func_item_iterator_t.chunk (method) - chunk(self) -> range_t - -ida_funcs.func_item_iterator_t.code_items (method) - Provide an iterator on code items contained within the function - -ida_funcs.func_item_iterator_t.current (method) - current(self) -> ea_t - -ida_funcs.func_item_iterator_t.data_items (method) - Provide an iterator on data items contained within the function - -ida_funcs.func_item_iterator_t.decode_preceding_insn (method) - decode_preceding_insn(self, visited, p_farref, out) -> bool - - @param visited: eavec_t * - @param p_farref: bool * - @param out: insn_t * - -ida_funcs.func_item_iterator_t.decode_prev_insn (method) - decode_prev_insn(self, out) -> bool - - @param out: insn_t * - -ida_funcs.func_item_iterator_t.first (method) - first(self) -> bool - -ida_funcs.func_item_iterator_t.head_items (method) - Provide an iterator on item heads contained within the function - -ida_funcs.func_item_iterator_t.last (method) - last(self) -> bool - -ida_funcs.func_item_iterator_t.next_addr (method) - next_addr(self) -> bool - -ida_funcs.func_item_iterator_t.next_code (method) - next_code(self) -> bool - -ida_funcs.func_item_iterator_t.next_data (method) - next_data(self) -> bool - -ida_funcs.func_item_iterator_t.next_head (method) - next_head(self) -> bool - -ida_funcs.func_item_iterator_t.next_not_tail (method) - next_not_tail(self) -> bool - -ida_funcs.func_item_iterator_t.not_tails (method) - Provide an iterator on non-tail addresses contained within the function - -ida_funcs.func_item_iterator_t.prev (method) - prev(self, func) -> bool - - @param func: testf_t * - -ida_funcs.func_item_iterator_t.prev_addr (method) - prev_addr(self) -> bool - -ida_funcs.func_item_iterator_t.prev_code (method) - prev_code(self) -> bool - -ida_funcs.func_item_iterator_t.prev_data (method) - prev_data(self) -> bool - -ida_funcs.func_item_iterator_t.prev_head (method) - prev_head(self) -> bool - -ida_funcs.func_item_iterator_t.prev_not_tail (method) - prev_not_tail(self) -> bool - -ida_funcs.func_item_iterator_t.set (method) - set(self, pfn, _ea=BADADDR) -> bool - Set a function range. if pfn == nullptr then a segment range will be set. - - @param pfn: (C++: func_t *) - @param _ea: (C++: ea_t) - -ida_funcs.func_item_iterator_t.set_range (method) - set_range(self, ea1, ea2) -> bool - Set an arbitrary range. - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - -ida_funcs.func_item_iterator_t.succ (method) - succ(self, func) -> bool - Similar to next(), but succ() iterates the chunks from low to high addresses, - while next() iterates through chunks starting at the function entry chunk - - @param func: (C++: testf_t *) - -ida_funcs.func_item_iterator_t.succ_code (method) - succ_code(self) -> bool - -ida_funcs.func_parent_iterator_set (function) - func_parent_iterator_set(fpi, pfn) -> bool - - @param fpi: func_parent_iterator_t * - @param pfn: func_t * - -ida_funcs.func_parent_iterator_t (class) - Proxy of C++ func_parent_iterator_t class. - -ida_funcs.func_parent_iterator_t.__init__ (method) - __init__(self) -> func_parent_iterator_t - __init__(self, _fnt) -> func_parent_iterator_t - - @param _fnt: func_t * - -ida_funcs.func_parent_iterator_t.__iter__ (method) - Provide an iterator on function parents - -ida_funcs.func_parent_iterator_t.__next__ (method) - __next__(self) -> bool - -ida_funcs.func_parent_iterator_t.first (method) - first(self) -> bool - -ida_funcs.func_parent_iterator_t.last (method) - last(self) -> bool - -ida_funcs.func_parent_iterator_t.parent (method) - parent(self) -> ea_t - -ida_funcs.func_parent_iterator_t.prev (method) - prev(self) -> bool - -ida_funcs.func_parent_iterator_t.reset_fnt (method) - reset_fnt(self, _fnt) - - @param _fnt: func_t * - -ida_funcs.func_parent_iterator_t.set (method) - set(self, _fnt) -> bool - - @param _fnt: func_t * - -ida_funcs.func_t (class) - Proxy of C++ func_t class. - -ida_funcs.func_t.__get_points__ (method) - __get_points__(self) -> dyn_stkpnt_array - -ida_funcs.func_t.__get_referers__ (method) - __get_referers__(self) -> dyn_ea_array - -ida_funcs.func_t.__get_regargs__ (method) - __get_regargs__(self) -> dyn_regarg_array - -ida_funcs.func_t.__get_regvars__ (method) - __get_regvars__(self) -> dyn_regvar_array - -ida_funcs.func_t.__get_tails__ (method) - __get_tails__(self) -> dyn_range_array - -ida_funcs.func_t.__init__ (method) - __init__(self, start=0, end=0, f=0) -> func_t - - @param start: ea_t - @param end: ea_t - @param f: flags64_t - -ida_funcs.func_t.__iter__ (method) - Alias for func_item_iterator_t(self).__iter__() - -ida_funcs.func_t.addresses (method) - Alias for func_item_iterator_t(self).addresses() - -ida_funcs.func_t.analyzed_sp (method) - analyzed_sp(self) -> bool - Has SP-analysis been performed? - -ida_funcs.func_t.argsize (variable) - number of bytes purged from the stack upon returning - -ida_funcs.func_t.code_items (method) - Alias for func_item_iterator_t(self).code_items() - -ida_funcs.func_t.color (variable) - user defined function color - -ida_funcs.func_t.data_items (method) - Alias for func_item_iterator_t(self).data_items() - -ida_funcs.func_t.does_return (method) - does_return(self) -> bool - Does function return? - -ida_funcs.func_t.flags (variable) - Function flags - -ida_funcs.func_t.fpd (variable) - frame pointer delta. (usually 0, i.e. realBP==typicalBP) use update_fpd() to - modify it. - -ida_funcs.func_t.frame (variable) - netnode id of frame structure - see frame.hpp - -ida_funcs.func_t.frregs (variable) - size of saved registers in frame. This range is immediately above the local - variables range. - -ida_funcs.func_t.frsize (variable) - size of local variables part of frame in bytes. If FUNC_FRAME is set and fpd==0, - the frame pointer (EBP) is assumed to point to the top of the local variables - range. - -ida_funcs.func_t.head_items (method) - Alias for func_item_iterator_t(self).head_items() - -ida_funcs.func_t.is_far (method) - is_far(self) -> bool - Is a far function? - -ida_funcs.func_t.need_prolog_analysis (method) - need_prolog_analysis(self) -> bool - Needs prolog analysis? - -ida_funcs.func_t.not_tails (method) - Alias for func_item_iterator_t(self).not_tails() - -ida_funcs.func_t.owner (variable) - the address of the main function possessing this tail - -ida_funcs.func_t.pntqty (variable) - number of SP change points - -ida_funcs.func_t.points (variable) - array of SP change points. use ...stkpnt...() functions to access this array. - -ida_funcs.func_t.referers (variable) - array of referers (function start addresses). use func_parent_iterator_t to - access the referers. - -ida_funcs.func_t.refqty (variable) - number of referers - -ida_funcs.func_t.regargqty (variable) - number of register arguments. During analysis IDA tries to guess the register - arguments. It stores store the guessing outcome in this field. As soon as it - determines the final function prototype, regargqty is set to zero. - -ida_funcs.func_t.regargs (variable) - unsorted array of register arguments. use ...regarg...() functions to access - this array. regargs are destroyed when the full function type is determined. - -ida_funcs.func_t.regvarqty (variable) - number of register variables (-1-not read in yet) use find_regvar() to read - register variables - -ida_funcs.func_t.regvars (variable) - array of register variables. this array is sorted by: start_ea. use - ...regvar...() functions to access this array. - -ida_funcs.func_t.tailqty (variable) - number of function tails - -ida_funcs.func_t.tails (variable) - array of tails, sorted by ea. use func_tail_iterator_t to access function tails. - -ida_funcs.func_t__from_ptrval__ (function) - func_t__from_ptrval__(ptrval) -> func_t - - @param ptrval: size_t - -ida_funcs.func_tail_iterator_set (function) - func_tail_iterator_set(fti, pfn, ea) -> bool - - @param fti: func_tail_iterator_t * - @param pfn: func_t * - @param ea: ea_t - -ida_funcs.func_tail_iterator_set_ea (function) - func_tail_iterator_set_ea(fti, ea) -> bool - - @param fti: func_tail_iterator_t * - @param ea: ea_t - -ida_funcs.func_tail_iterator_t (class) - Proxy of C++ func_tail_iterator_t class. - -ida_funcs.func_tail_iterator_t.__init__ (method) - __init__(self) -> func_tail_iterator_t - __init__(self, _pfn, ea=BADADDR) -> func_tail_iterator_t - - @param _pfn: func_t * - @param ea: ea_t - -ida_funcs.func_tail_iterator_t.__iter__ (method) - Provide an iterator on function tails - -ida_funcs.func_tail_iterator_t.__next__ (method) - __next__(self) -> bool - -ida_funcs.func_tail_iterator_t.chunk (method) - chunk(self) -> range_t - -ida_funcs.func_tail_iterator_t.first (method) - first(self) -> bool - -ida_funcs.func_tail_iterator_t.last (method) - last(self) -> bool - -ida_funcs.func_tail_iterator_t.main (method) - main(self) -> bool - -ida_funcs.func_tail_iterator_t.prev (method) - prev(self) -> bool - -ida_funcs.func_tail_iterator_t.set (method) - set(self, _pfn, ea=BADADDR) -> bool - - @param _pfn: func_t * - @param ea: ea_t - -ida_funcs.func_tail_iterator_t.set_ea (method) - set_ea(self, ea) -> bool - - @param ea: ea_t - -ida_funcs.func_tail_iterator_t.set_range (method) - set_range(self, ea1, ea2) -> bool - - @param ea1: ea_t - @param ea2: ea_t - -ida_funcs.get_current_idasgn (function) - get_current_idasgn() -> int - Get number of the the current signature. - - @return: 0..n-1 - -ida_funcs.get_fchunk (function) - get_fchunk(ea) -> func_t - Get pointer to function chunk structure by address. - - @param ea: (C++: ea_t) any address in a function chunk - @return: ptr to a function chunk or nullptr. This function may return a function - entry as well as a function tail. - -ida_funcs.get_fchunk_num (function) - get_fchunk_num(ea) -> int - Get ordinal number of a function chunk in the global list of function chunks. - - @param ea: (C++: ea_t) any address in the function chunk - @return: number of function chunk (0..get_fchunk_qty()-1). -1 means 'no function - chunk at the specified address'. - -ida_funcs.get_fchunk_qty (function) - get_fchunk_qty() -> size_t - Get total number of function chunks in the program. - -ida_funcs.get_fchunk_referer (function) - get_fchunk_referer(ea, idx) -> ea_t - - @param ea: ea_t - @param idx: size_t - -ida_funcs.get_func (function) - get_func(ea) -> func_t - Get pointer to function structure by address. - - @param ea: (C++: ea_t) any address in a function - @return: ptr to a function or nullptr. This function returns a function entry - chunk. - -ida_funcs.get_func_bitness (function) - get_func_bitness(pfn) -> int - Get function bitness (which is equal to the function segment bitness). - pfn==nullptr => returns 0 - @retval 0: 16 - @retval 1: 32 - @retval 2: 64 - - @param pfn: (C++: const func_t *) func_t const * - -ida_funcs.get_func_bits (function) - get_func_bits(pfn) -> int - Get number of bits in the function addressing. - - @param pfn: (C++: const func_t *) func_t const * - -ida_funcs.get_func_bytes (function) - get_func_bytes(pfn) -> int - Get number of bytes in the function addressing. - - @param pfn: (C++: const func_t *) func_t const * - -ida_funcs.get_func_chunknum (function) - get_func_chunknum(pfn, ea) -> int - Get the containing tail chunk of 'ea'. - @retval -1: means 'does not contain ea' - @retval 0: means the 'pfn' itself contains ea - @retval >0: the number of the containing function tail chunk - - @param pfn: (C++: func_t *) - @param ea: (C++: ea_t) - -ida_funcs.get_func_cmt (function) - get_func_cmt(pfn, repeatable) -> str - Get function comment. - - @param pfn: (C++: const func_t *) ptr to function structure - @param repeatable: (C++: bool) get repeatable comment? - @return: size of comment or -1 In fact this function works with function chunks - too. - -ida_funcs.get_func_name (function) - get_func_name(ea) -> str - Get function name. - - @param ea: (C++: ea_t) any address in the function - @return: length of the function name - -ida_funcs.get_func_num (function) - get_func_num(ea) -> int - Get ordinal number of a function. - - @param ea: (C++: ea_t) any address in the function - @return: number of function (0..get_func_qty()-1). -1 means 'no function at the - specified address'. - -ida_funcs.get_func_qty (function) - get_func_qty() -> size_t - Get total number of functions in the program. - -ida_funcs.get_func_ranges (function) - get_func_ranges(ranges, pfn) -> ea_t - Get function ranges. - - @param ranges: (C++: rangeset_t *) buffer to receive the range info - @param pfn: (C++: func_t *) ptr to function structure - @return: end address of the last function range (BADADDR-error) - -ida_funcs.get_idasgn_desc (function) - get_idasgn_desc(n) -> (str, str) - Get information about a signature in the list. - It returns: (name of signature, names of optional libraries) - - See also: get_idasgn_desc_with_matches - - @param n: number of signature in the list (0..get_idasgn_qty()-1) - @return: None on failure or tuple(signame, optlibs) - -ida_funcs.get_idasgn_desc_with_matches (function) - get_idasgn_desc_with_matches(n) -> (str, str, int) - Get information about a signature in the list. - It returns: (name of signature, names of optional libraries, number of matches) - - @param n: number of signature in the list (0..get_idasgn_qty()-1) - @return: None on failure or tuple(signame, optlibs, nmatches) - -ida_funcs.get_idasgn_qty (function) - get_idasgn_qty() -> int - Get number of signatures in the list of planned and applied signatures. - - @return: 0..n - -ida_funcs.get_idasgn_title (function) - get_idasgn_title(name) -> str - Get full description of the signature by its short name. - - @param name: (C++: const char *) short name of a signature - @return: size of signature description or -1 - -ida_funcs.get_next_fchunk (function) - get_next_fchunk(ea) -> func_t - Get pointer to the next function chunk in the global list. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function chunk or nullptr if next function chunk doesn't exist - -ida_funcs.get_next_func (function) - get_next_func(ea) -> func_t - Get pointer to the next function. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function or nullptr if next function doesn't exist - -ida_funcs.get_next_func_addr (function) - get_next_func_addr(pfn, ea) -> ea_t - - @param pfn: func_t * - @param ea: ea_t - -ida_funcs.get_prev_fchunk (function) - get_prev_fchunk(ea) -> func_t - Get pointer to the previous function chunk in the global list. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function chunk or nullptr if previous function chunk doesn't - exist - -ida_funcs.get_prev_func (function) - get_prev_func(ea) -> func_t - Get pointer to the previous function. - - @param ea: (C++: ea_t) any address in the program - @return: ptr to function or nullptr if previous function doesn't exist - -ida_funcs.get_prev_func_addr (function) - get_prev_func_addr(pfn, ea) -> ea_t - - @param pfn: func_t * - @param ea: ea_t - -ida_funcs.getn_fchunk (function) - getn_fchunk(n) -> func_t - Get pointer to function chunk structure by number. - - @param n: (C++: int) number of function chunk, is in range 0..get_fchunk_qty()-1 - @return: ptr to a function chunk or nullptr. This function may return a function - entry as well as a function tail. - -ida_funcs.getn_func (function) - getn_func(n) -> func_t - Get pointer to function structure by number. - - @param n: (C++: size_t) number of function, is in range 0..get_func_qty()-1 - @return: ptr to a function or nullptr. This function returns a function entry - chunk. - -ida_funcs.is_finally_visible_func (function) - is_finally_visible_func(pfn) -> bool - Is the function visible (event after considering SCF_SHHID_FUNC)? - - @param pfn: (C++: func_t *) - -ida_funcs.is_func_entry (function) - is_func_entry(pfn) -> bool - Does function describe a function entry chunk? - - @param pfn: (C++: const func_t *) func_t const * - -ida_funcs.is_func_locked (function) - is_func_locked(pfn) -> bool - Is the function pointer locked? - - @param pfn: (C++: const func_t *) func_t const * - -ida_funcs.is_func_tail (function) - is_func_tail(pfn) -> bool - Does function describe a function tail chunk? - - @param pfn: (C++: const func_t *) func_t const * - -ida_funcs.is_same_func (function) - is_same_func(ea1, ea2) -> bool - Do two addresses belong to the same function? - - @param ea1: (C++: ea_t) - @param ea2: (C++: ea_t) - -ida_funcs.is_visible_func (function) - is_visible_func(pfn) -> bool - Is the function visible (not hidden)? - - @param pfn: (C++: func_t *) - -ida_funcs.lock_func (class) - Proxy of C++ lock_func class. - -ida_funcs.lock_func.__init__ (method) - __init__(self, _pfn) -> lock_func - - @param _pfn: func_t const * - -ida_funcs.lock_func_range (function) - lock_func_range(pfn, lock) - Lock function pointer Locked pointers are guaranteed to remain valid until they - are unlocked. Ranges with locked pointers cannot be deleted or moved. - - @param pfn: (C++: const func_t *) func_t const * - @param lock: (C++: bool) - -ida_funcs.lock_func_with_tails_t (class) - Proxy of C++ lock_func_with_tails_t class. - -ida_funcs.lock_func_with_tails_t.__init__ (method) - __init__(self, pfn) -> lock_func_with_tails_t - - @param pfn: func_t * - -ida_funcs.plan_to_apply_idasgn (function) - plan_to_apply_idasgn(fname) -> int - Add a signature file to the list of planned signature files. - - @param fname: (C++: const char *) file name. should not contain directory part. - @return: 0 if failed, otherwise number of planned (and applied) signatures - -ida_funcs.read_regargs (function) - read_regargs(pfn) - - @param pfn: func_t * - -ida_funcs.reanalyze_function (function) - reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False) - Reanalyze a function. This function plans to analyzes all chunks of the given - function. Optional parameters (ea1, ea2) may be used to narrow the analyzed - range. - - @param pfn: (C++: func_t *) pointer to a function - @param ea1: (C++: ea_t) start of the range to analyze - @param ea2: (C++: ea_t) end of range to analyze - @param analyze_parents: (C++: bool) meaningful only if pfn points to a function tail. if - true, all tail parents will be reanalyzed. if false, - only the given tail will be reanalyzed. - -ida_funcs.reanalyze_noret_flag (function) - reanalyze_noret_flag(ea) -> bool - Plan to reanalyze noret flag. This function does not remove FUNC_NORET if it is - already present. It just plans to reanalysis. - - @param ea: (C++: ea_t) - -ida_funcs.regarg_t (class) - Proxy of C++ regarg_t class. - -ida_funcs.regarg_t.__init__ (method) - __init__(self) -> regarg_t - __init__(self, r) -> regarg_t - - @param r: regarg_t const & - -ida_funcs.regarg_t.swap (method) - swap(self, r) - - @param r: regarg_t & - -ida_funcs.remove_func_tail (function) - remove_func_tail(pfn, tail_ea) -> bool - Remove a function tail. If the tail belongs only to one function, it will be - completely removed. Otherwise if the function was the tail owner, the first - function using this tail becomes the owner of the tail. - - @param pfn: (C++: func_t *) pointer to the function - @param tail_ea: (C++: ea_t) any address inside the tail to remove - -ida_funcs.set_func_cmt (function) - set_func_cmt(pfn, cmt, repeatable) -> bool - Set function comment. This function works with function chunks too. - - @param pfn: (C++: const func_t *) ptr to function structure - @param cmt: (C++: const char *) comment string, may be multiline (with ' - '). Use empty str ("") to delete comment - @param repeatable: (C++: bool) set repeatable comment? - -ida_funcs.set_func_end (function) - set_func_end(ea, newend) -> bool - Move function chunk end address. - - @param ea: (C++: ea_t) any address in the function - @param newend: (C++: ea_t) new end address of the function - @return: success - -ida_funcs.set_func_name_if_jumpfunc (function) - set_func_name_if_jumpfunc(pfn, oldname) -> int - Give a meaningful name to function if it consists of only 'jump' instruction. - - @param pfn: (C++: func_t *) pointer to function (may be nullptr) - @param oldname: (C++: const char *) old name of function. if old name was in "j_..." form, then we - may discard it and set a new name. if oldname is not known, you - may pass nullptr. - @return: success - -ida_funcs.set_func_start (function) - set_func_start(ea, newstart) -> int - Move function chunk start address. - - @param ea: (C++: ea_t) any address in the function - @param newstart: (C++: ea_t) new end address of the function - @return: Function move result codes - -ida_funcs.set_noret_insn (function) - set_noret_insn(insn_ea, noret) -> bool - Signal a non-returning instruction. This function can be used by the processor - module to tell the kernel about non-returning instructions (like call exit). The - kernel will perform the global function analysis and find out if the function - returns at all. This analysis will be done at the first call to - func_does_return() - - @param insn_ea: (C++: ea_t) - @param noret: (C++: bool) - @return: true if the instruction 'noret' flag has been changed - -ida_funcs.set_tail_owner (function) - set_tail_owner(fnt, new_owner) -> bool - Set a new owner of a function tail. The new owner function must be already - referring to the tail (after append_func_tail). - - @param fnt: (C++: func_t *) pointer to the function tail - @param new_owner: (C++: ea_t) the entry point of the new owner function - -ida_funcs.set_visible_func (function) - set_visible_func(pfn, visible) - Set visibility of function. - - @param pfn: (C++: func_t *) - @param visible: (C++: bool) - -ida_funcs.try_to_add_libfunc (function) - try_to_add_libfunc(ea) -> int - Apply the currently loaded signature file to the specified address. If a library - function is found, then create a function and name it accordingly. - - @param ea: (C++: ea_t) any address in the program - @return: Library function codes - -ida_funcs.update_func (function) - update_func(pfn) -> bool - Update information about a function in the database (func_t). You must not - change the function start and end addresses using this function. Use - set_func_start() and set_func_end() for it. - - @param pfn: (C++: func_t *) ptr to function structure - @return: success - -ida_gdl (module) - Low level graph drawing operations. - -ida_gdl.BasicBlock (class) - Basic block class. It is returned by the Flowchart class - -ida_gdl.BasicBlock.__init__ (method) - Block type (check fc_block_type_t enum) - -ida_gdl.BasicBlock.preds (method) - Iterates the predecessors list - -ida_gdl.BasicBlock.succs (method) - Iterates the successors list - -ida_gdl.CHART_FOLLOW_DIRECTION (variable) - analyze references to added blocks only in the direction of the reference who - discovered the current block - -ida_gdl.CHART_GEN_DOT (variable) - generate .dot file (file extension is forced to .dot) - -ida_gdl.CHART_GEN_GDL (variable) - generate .gdl file (file extension is forced to .gdl) - -ida_gdl.CHART_IGNORE_LIB_FROM (variable) - ignore references from library functions - -ida_gdl.CHART_IGNORE_LIB_TO (variable) - ignore references to library functions - -ida_gdl.CHART_NOLIBFUNCS (variable) - don't include library functions in the graph - -ida_gdl.CHART_PRINT_DOTS (variable) - print dots if xrefs exist outside of the range recursion depth - -ida_gdl.CHART_PRINT_NAMES (variable) - print labels for each block? - -ida_gdl.CHART_RECURSIVE (variable) - analyze added blocks - -ida_gdl.CHART_REFERENCED (variable) - references from the addresses in the list - -ida_gdl.CHART_REFERENCING (variable) - references to the addresses in the list - -ida_gdl.CHART_WINGRAPH (variable) - call grapher to display the graph - -ida_gdl.FC_APPND (variable) - multirange flowchart (set by append_to_flowchart) - -ida_gdl.FC_CALL_ENDS (variable) - call instructions terminate basic blocks - -ida_gdl.FC_CHKBREAK (variable) - build_qflow_chart() may be aborted by user - -ida_gdl.FC_NOEXT (variable) - do not compute external blocks. Use this to prevent jumps leaving the function - from appearing in the flow chart. Unless specified, the targets of those - outgoing jumps will be present in the flow chart under the form of one- - instruction blocks - -ida_gdl.FC_NOPREDS (variable) - do not compute predecessor lists - -ida_gdl.FC_OUTLINES (variable) - include outlined code (with FUNC_OUTLINE) - -ida_gdl.FC_PRINT (variable) - print names (used only by display_flow_chart()) - -ida_gdl.FlowChart (class) - Flowchart class used to determine basic blocks. - Check ex_gdl_qflow_chart.py for sample usage. - -ida_gdl.FlowChart.__getitem__ (method) - Returns a basic block - - @return: BasicBlock - -ida_gdl.FlowChart.__init__ (method) - Constructor - @param f: A func_t type, use get_func(ea) to get a reference - @param bounds: A tuple of the form (start, end). Used if "f" is None - @param flags: one of the FC_xxxx flags. - -ida_gdl.FlowChart.__iter__ (method) - -ida_gdl.FlowChart._getitem (method) - -ida_gdl.FlowChart.refresh (method) - Refreshes the flow chart - -ida_gdl.FlowChart.size (variable) - Number of blocks in the flow chart - -ida_gdl.cancellable_graph_t (class) - Proxy of C++ cancellable_graph_t class. - -ida_gdl.cancellable_graph_t.__disown__ (method) - -ida_gdl.cancellable_graph_t.__init__ (method) - __init__(self) -> cancellable_graph_t - - @param self: PyObject * - -ida_gdl.display_gdl (function) - display_gdl(fname) -> int - Display GDL file by calling wingraph32. The exact name of the grapher is taken - from the configuration file and set up by setup_graph_subsystem(). The path - should point to a temporary file: when wingraph32 succeeds showing the graph, - the input file will be deleted. - - @param fname: (C++: const char *) char const * - @return: error code from os, 0 if ok - -ida_gdl.fcb_cndret (variable) - conditional return block - -ida_gdl.fcb_enoret (variable) - external noreturn block (does not belong to the function) - -ida_gdl.fcb_error (variable) - block passes execution past the function end - -ida_gdl.fcb_extern (variable) - external normal block - -ida_gdl.fcb_indjump (variable) - block ends with indirect jump - -ida_gdl.fcb_noret (variable) - noreturn block - -ida_gdl.fcb_normal (variable) - normal block - -ida_gdl.fcb_ret (variable) - return block - -ida_gdl.gdl_graph_t (class) - Proxy of C++ gdl_graph_t class. - -ida_gdl.gdl_graph_t.__disown__ (method) - -ida_gdl.gdl_graph_t.__init__ (method) - __init__(self) -> gdl_graph_t - - @param self: PyObject * - -ida_gdl.gdl_graph_t.begin (method) - begin(self) -> node_iterator - -ida_gdl.gdl_graph_t.edge (method) - edge(self, node, i, ispred) -> int - - @param node: int - @param i: int - @param ispred: bool - -ida_gdl.gdl_graph_t.empty (method) - empty(self) -> bool - -ida_gdl.gdl_graph_t.end (method) - end(self) -> node_iterator - -ida_gdl.gdl_graph_t.entry (method) - entry(self) -> int - -ida_gdl.gdl_graph_t.exists (method) - exists(self, node) -> bool - - @param node: int - -ida_gdl.gdl_graph_t.exit (method) - exit(self) -> int - -ida_gdl.gdl_graph_t.front (method) - front(self) -> int - -ida_gdl.gdl_graph_t.get_edge_color (method) - get_edge_color(self, i, j) -> bgcolor_t - - @param i: int - @param j: int - -ida_gdl.gdl_graph_t.get_node_color (method) - get_node_color(self, n) -> bgcolor_t - - @param n: int - -ida_gdl.gdl_graph_t.get_node_label (method) - get_node_label(self, n) -> char * - - @param n: int - -ida_gdl.gdl_graph_t.nedge (method) - nedge(self, node, ispred) -> size_t - - @param node: int - @param ispred: bool - -ida_gdl.gdl_graph_t.node_qty (method) - node_qty(self) -> int - -ida_gdl.gdl_graph_t.npred (method) - npred(self, node) -> int - - @param node: int - -ida_gdl.gdl_graph_t.nsucc (method) - nsucc(self, node) -> int - - @param node: int - -ida_gdl.gdl_graph_t.pred (method) - pred(self, node, i) -> int - - @param node: int - @param i: int - -ida_gdl.gdl_graph_t.print_edge (method) - print_edge(self, fp, i, j) -> bool - - @param fp: FILE * - @param i: int - @param j: int - -ida_gdl.gdl_graph_t.print_graph_attributes (method) - print_graph_attributes(self, fp) - - @param fp: FILE * - -ida_gdl.gdl_graph_t.print_node (method) - print_node(self, fp, n) -> bool - - @param fp: FILE * - @param n: int - -ida_gdl.gdl_graph_t.print_node_attributes (method) - print_node_attributes(self, fp, n) - - @param fp: FILE * - @param n: int - -ida_gdl.gdl_graph_t.size (method) - size(self) -> int - -ida_gdl.gdl_graph_t.succ (method) - succ(self, node, i) -> int - - @param node: int - @param i: int - -ida_gdl.gen_complex_call_chart (function) - gen_complex_call_chart(filename, wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool - Build and display a complex xref graph. - - @param filename: (C++: const char *) output file name. the file extension is not used. maybe - nullptr. - @param wait: (C++: const char *) message to display during graph building - @param title: (C++: const char *) graph title - @param ea1: (C++: ea_t) ,ea2: address range - @param flags: (C++: int) combination of Call chart building flags and Flow graph building - flags. if none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is - specified, the function will return false. - @param flags: (C++: int) combination of Call chart building flags and Flow graph building - flags. if none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is - specified, the function will return false. - @param recursion_depth: (C++: int32) optional limit of recursion - @return: success. if fails, a warning message is displayed on the screen - -ida_gdl.gen_flow_graph (function) - gen_flow_graph(filename, title, pfn, ea1, ea2, gflags) -> bool - Build and display a flow graph. - - @param filename: (C++: const char *) output file name. the file extension is not used. maybe - nullptr. - @param title: (C++: const char *) graph title - @param pfn: (C++: func_t *) function to graph - @param ea1: (C++: ea_t) ,ea2: if pfn == nullptr, then the address range - @param gflags: (C++: int) combination of Flow graph building flags. if none of - CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is specified, the - function will return false - @param gflags: (C++: int) combination of Flow graph building flags. if none of - CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is specified, the - function will return false - @return: success. if fails, a warning message is displayed on the screen - -ida_gdl.gen_gdl (function) - gen_gdl(g, fname) - Create GDL file for graph. - - @param g: (C++: const gdl_graph_t *) gdl_graph_t const * - @param fname: (C++: const char *) char const * - -ida_gdl.gen_simple_call_chart (function) - gen_simple_call_chart(filename, wait, title, gflags) -> bool - Build and display a simple function call graph. - - @param filename: (C++: const char *) output file name. the file extension is not used. maybe - nullptr. - @param wait: (C++: const char *) message to display during graph building - @param title: (C++: const char *) graph title - @param gflags: (C++: int) combination of CHART_NOLIBFUNCS and Flow graph building flags. if - none of CHART_GEN_DOT, CHART_GEN_GDL, CHART_WINGRAPH is - specified, the function will return false. - @return: success. if fails, a warning message is displayed on the screen - -ida_gdl.is_noret_block (function) - is_noret_block(btype) -> bool - Does this block never return? - - @param btype: (C++: fc_block_type_t) enum fc_block_type_t - -ida_gdl.is_ret_block (function) - is_ret_block(btype) -> bool - Does this block return? - - @param btype: (C++: fc_block_type_t) enum fc_block_type_t - -ida_gdl.node_iterator (class) - Proxy of C++ node_iterator class. - -ida_gdl.node_iterator.__eq__ (method) - __eq__(self, n) -> bool - - @param n: node_iterator const & - -ida_gdl.node_iterator.__init__ (method) - __init__(self, _g, n) -> node_iterator - - @param _g: gdl_graph_t const * - @param n: int - -ida_gdl.node_iterator.__ne__ (method) - __ne__(self, n) -> bool - - @param n: node_iterator const & - -ida_gdl.node_iterator.__ref__ (method) - __ref__(self) -> int - -ida_gdl.qbasic_block_t (class) - Proxy of C++ qbasic_block_t class. - -ida_gdl.qbasic_block_t.__init__ (method) - __init__(self) -> qbasic_block_t - -ida_gdl.qflow_chart_t (class) - Proxy of C++ qflow_chart_t class. - -ida_gdl.qflow_chart_t.__getitem__ (method) - __getitem__(self, n) -> qbasic_block_t - - @param n: int - -ida_gdl.qflow_chart_t.__init__ (method) - __init__(self) -> qflow_chart_t - __init__(self, _title, _pfn, _ea1, _ea2, _flags) -> qflow_chart_t - - @param _title: char const * - @param _pfn: func_t * - @param _ea1: ea_t - @param _ea2: ea_t - @param _flags: int - -ida_gdl.qflow_chart_t.append_to_flowchart (method) - append_to_flowchart(self, ea1, ea2) - - @param ea1: ea_t - @param ea2: ea_t - -ida_gdl.qflow_chart_t.bounds (variable) - overall bounds of the qflow_chart_t instance - -ida_gdl.qflow_chart_t.calc_block_type (method) - calc_block_type(self, blknum) -> fc_block_type_t - - @param blknum: size_t - -ida_gdl.qflow_chart_t.create (method) - create(self, _title, _pfn, _ea1, _ea2, _flags) - - @param _title: char const * - @param _pfn: func_t * - @param _ea1: ea_t - @param _ea2: ea_t - @param _flags: int - - create(self, _title, ranges, _flags) - - @param _title: char const * - @param ranges: rangevec_t const & - @param _flags: int - -ida_gdl.qflow_chart_t.flags (variable) - flags. See Flow chart flags - -ida_gdl.qflow_chart_t.get_node_label (method) - get_node_label(self, n) -> char * - - @param n: int - -ida_gdl.qflow_chart_t.is_noret_block (method) - is_noret_block(self, blknum) -> bool - - @param blknum: size_t - -ida_gdl.qflow_chart_t.is_ret_block (method) - is_ret_block(self, blknum) -> bool - - @param blknum: size_t - -ida_gdl.qflow_chart_t.npred (method) - npred(self, node) -> int - - @param node: int - -ida_gdl.qflow_chart_t.nproper (variable) - number of basic blocks belonging to the specified range - -ida_gdl.qflow_chart_t.nsucc (method) - nsucc(self, node) -> int - - @param node: int - -ida_gdl.qflow_chart_t.pfn (variable) - the function this instance was built upon - -ida_gdl.qflow_chart_t.pred (method) - pred(self, node, i) -> int - - @param node: int - @param i: int - -ida_gdl.qflow_chart_t.print_names (method) - print_names(self) -> bool - -ida_gdl.qflow_chart_t.print_node_attributes (method) - print_node_attributes(self, fp, n) - - @param fp: FILE * - @param n: int - -ida_gdl.qflow_chart_t.refresh (method) - refresh(self) - -ida_gdl.qflow_chart_t.size (method) - size(self) -> int - -ida_gdl.qflow_chart_t.succ (method) - succ(self, node, i) -> int - - @param node: int - @param i: int - -ida_graph (module) - Graph view management. - -ida_graph.GLICTL_CENTER (variable) - the gli should be set/get as center - -ida_graph.GraphViewer (class) - This class wraps the user graphing facility provided by the graph.hpp file - -ida_graph.GraphViewer.AddCommand (method) - -ida_graph.GraphViewer.AddEdge (method) - Creates an edge between two given node ids - -ida_graph.GraphViewer.AddNode (method) - Creates a node associated with the given object and returns the node id - -ida_graph.GraphViewer.Clear (method) - Clears all the nodes and edges - -ida_graph.GraphViewer.Close (method) - Closes the graph. - It is possible to call Show() again (which will recreate the graph) - -ida_graph.GraphViewer.Count (method) - Returns the node count - -ida_graph.GraphViewer.OnCommand (method) - -ida_graph.GraphViewer.OnPopup (method) - -ida_graph.GraphViewer.OnRefresh (method) - Event called when the graph is refreshed or first created. - From this event you are supposed to create nodes and edges. - This callback is mandatory. - - @note: ***It is important to clear previous nodes before adding nodes.*** - @return: Returning True tells the graph viewer to use the items. Otherwise old items will be used. - -ida_graph.GraphViewer.Select (method) - Selects a node on the graph - -ida_graph.GraphViewer.Show (method) - Shows an existing graph or creates a new one - - @return: Boolean - -ida_graph.GraphViewer.UI_Hooks_Trampoline (class) - -ida_graph.GraphViewer.UI_Hooks_Trampoline.__init__ (method) - -ida_graph.GraphViewer.UI_Hooks_Trampoline.populating_widget_popup (method) - -ida_graph.GraphViewer._OnBind (method) - -ida_graph.GraphViewer.__getitem__ (method) - Returns a reference to the object associated with this node id - -ida_graph.GraphViewer.__init__ (method) - Constructs the GraphView object. - Please do not remove or rename the private fields - - @param title: The title of the graph window - @param close_open: Should it attempt to close an existing graph (with same title) before creating this graph? - -ida_graph.GraphViewer.__init__._qccb (function) - -ida_graph.GraphViewer.__iter__ (method) - -ida_graph.MTG_DOT_NODE (variable) - is dot node? - -ida_graph.MTG_GROUP_NODE (variable) - is group node? - -ida_graph.MTG_NON_DISPLAYABLE_NODE (variable) - for disassembly graphs - non-displayable nodes have a visible area that is too - large to generate disassembly lines for without IDA slowing down significantly - (see MAX_VISIBLE_NODE_AREA) - -ida_graph.NIF_BG_COLOR (variable) - node_info_t::bg_color - -ida_graph.NIF_EA (variable) - node_info_t::ea - -ida_graph.NIF_FLAGS (variable) - node_info_t::flags - -ida_graph.NIF_FRAME_COLOR (variable) - node_info_t::frame_color - -ida_graph.NIF_TEXT (variable) - node_info_t::text - -ida_graph.TPointDouble (class) - Proxy of C++ TPointDouble class. - -ida_graph.TPointDouble.__eq__ (method) - __eq__(self, r) -> bool - - @param r: TPointDouble const & - -ida_graph.TPointDouble.__init__ (method) - __init__(self) -> TPointDouble - __init__(self, a, b) -> TPointDouble - - @param a: double - @param b: double - - __init__(self, r) -> TPointDouble - - @param r: point_t const & - -ida_graph.TPointDouble.__ne__ (method) - __ne__(self, r) -> bool - - @param r: TPointDouble const & - -ida_graph.TPointDouble.add (method) - add(self, r) - - @param r: TPointDouble const & - -ida_graph.TPointDouble.negate (method) - negate(self) - -ida_graph.TPointDouble.sub (method) - sub(self, r) - - @param r: TPointDouble const & - -ida_graph.abstract_graph_t (class) - Proxy of C++ abstract_graph_t class. - -ida_graph.abstract_graph_t.__disown__ (method) - -ida_graph.abstract_graph_t.__init__ (method) - __init__(self) -> abstract_graph_t - - @param self: PyObject * - -ida_graph.abstract_graph_t.callback_ud (variable) - user data for callback - -ida_graph.abstract_graph_t.circle_center (variable) - for layout_circle - -ida_graph.abstract_graph_t.circle_radius (variable) - for layout_circle - -ida_graph.abstract_graph_t.create_circle_layout (method) - create_circle_layout(self, p, radius) -> bool - - @param p: point_t - @param radius: int - -ida_graph.abstract_graph_t.create_tree_layout (method) - create_tree_layout(self) -> bool - -ida_graph.abstract_graph_t.current_layout (variable) - see Proximity view layouts - -ida_graph.abstract_graph_t.get_edge (method) - get_edge(self, e) -> edge_info_t - - @param e: edge_t - -ida_graph.abstract_graph_t.grcall (method) - grcall(self, code) -> ssize_t - - @param code: int - -ida_graph.abstract_graph_t.nrect (method) - nrect(self, n) -> rect_t - - @param n: int - -ida_graph.abstract_graph_t.rect_edges_made (variable) - have create rectangular edges? - -ida_graph.abstract_graph_t.set_callback (method) - set_callback(self, _callback, _ud) - - @param _callback: hook_cb_t * - @param _ud: void * - -ida_graph.abstract_graph_t.title (variable) - graph title - -ida_graph.calc_dist (function) - calc_dist(p, q) -> double - Calculate distance between p and q. - - @param p: (C++: point_t) - @param q: (C++: point_t) - -ida_graph.clr_node_info (function) - clr_node_info(gid, node, flags) - Clear node info for the given node. - - @param gid: (C++: graph_id_t) id of desired graph - @param node: (C++: int) node number - @param flags: (C++: uint32) combination of Node info flags, identifying which fields of - node_info_t will be cleared - -ida_graph.create_disasm_graph (function) - create_disasm_graph(ea) -> mutable_graph_t - Create a graph using an arbitrary set of ranges. - - @param ea: ea_t - - create_disasm_graph(ranges) -> mutable_graph_t - - @param ranges: rangevec_t const & - -ida_graph.create_graph_viewer (function) - create_graph_viewer(title, id, callback, ud, title_height, parent=None) -> graph_viewer_t * - Create a custom graph viewer. - - @param title: (C++: const char *) the widget title - @param id: (C++: uval_t) graph id - @param callback: (C++: hook_cb_t *) callback to handle graph notifications (graph_notification_t) - @param ud: (C++: void *) user data passed to callback - @param title_height: (C++: int) node title height - @param parent: (C++: TWidget *) the parent widget of the graph viewer - @return: new viewer - -ida_graph.create_mutable_graph (function) - create_mutable_graph(id) -> mutable_graph_t - Create a new empty graph with given id. - - @param id: (C++: uval_t) - -ida_graph.create_user_graph_place (function) - create_user_graph_place(node, lnnum) -> user_graph_place_t - Get a copy of a user_graph_place_t (returns a pointer to static storage) - - @param node: (C++: int) - @param lnnum: (C++: int) - -ida_graph.del_node_info (function) - del_node_info(gid, node) - Delete the node_info_t for the given node. - - @param gid: (C++: graph_id_t) - @param node: (C++: int) - -ida_graph.delete_mutable_graph (function) - delete_mutable_graph(g) - Delete graph object. - @warning: use this only if you are dealing with mutable_graph_t instances that - have not been used together with a graph_viewer_t. If you have called - set_viewer_graph() with your graph, the graph's lifecycle will be - managed by the viewer, and you shouldn't interfere with it - - @param g: (C++: mutable_graph_t *) - -ida_graph.edge_info_t (class) - Proxy of C++ edge_info_t class. - -ida_graph.edge_info_t.__init__ (method) - __init__(self) -> edge_info_t - -ida_graph.edge_info_t.color (variable) - edge color - -ida_graph.edge_info_t.layout (variable) - describes geometry of edge - -ida_graph.edge_info_t.reverse_layout (method) - reverse_layout(self) - -ida_graph.edge_info_t.width (variable) - edge width - -ida_graph.edge_infos_wrapper_t (class) - Proxy of C++ edge_infos_wrapper_t class. - -ida_graph.edge_infos_wrapper_t.__init__ (method) - -ida_graph.edge_infos_wrapper_t.clear (method) - clear(self) - -ida_graph.edge_layout_point_t (class) - Proxy of C++ edge_layout_point_t class. - -ida_graph.edge_layout_point_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: edge_layout_point_t const & - -ida_graph.edge_layout_point_t.__init__ (method) - __init__(self) -> edge_layout_point_t - __init__(self, _e, _pidx) -> edge_layout_point_t - - @param _e: edge_t const & - @param _pidx: int - -ida_graph.edge_layout_point_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: edge_layout_point_t const & - -ida_graph.edge_layout_point_t.compare (method) - compare(self, r) -> int - - @param r: edge_layout_point_t const & - -ida_graph.edge_layout_point_t.e (variable) - parent edge - -ida_graph.edge_layout_point_t.pidx (variable) - index into edge_info_t::layout - -ida_graph.edge_segment_t (class) - Proxy of C++ edge_segment_t class. - -ida_graph.edge_segment_t.__init__ (method) - __init__(self) -> edge_segment_t - -ida_graph.edge_segment_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: edge_segment_t const & - -ida_graph.edge_segment_t.length (method) - length(self) -> size_t - -ida_graph.edge_segment_t.toright (method) - toright(self) -> bool - -ida_graph.edge_t (class) - Proxy of C++ edge_t class. - -ida_graph.edge_t.__eq__ (method) - __eq__(self, y) -> bool - - @param y: edge_t const & - -ida_graph.edge_t.__init__ (method) - __init__(self) -> edge_t - __init__(self, x, y) -> edge_t - - @param x: int - @param y: int - -ida_graph.edge_t.__lt__ (method) - __lt__(self, y) -> bool - - @param y: edge_t const & - -ida_graph.edge_t.__ne__ (method) - __ne__(self, y) -> bool - - @param y: edge_t const & - -ida_graph.edge_t.dst (variable) - destination node number - -ida_graph.edge_t.src (variable) - source node number - -ida_graph.get_graph_viewer (function) - get_graph_viewer(parent) -> graph_viewer_t * - Get custom graph viewer for given form. - - @param parent: (C++: TWidget *) - -ida_graph.get_node_info (function) - get_node_info(out, gid, node) -> bool - Get node info. - - @param out: (C++: node_info_t *) result - @param gid: (C++: graph_id_t) id of desired graph - @param node: (C++: int) node number - @return: success - -ida_graph.get_viewer_graph (function) - get_viewer_graph(gv) -> mutable_graph_t - Get graph object for given custom graph viewer. - - @param gv: (C++: graph_viewer_t *) - -ida_graph.git_edge (variable) - edge (graph_item_t::e, graph_item_t::n. n is farthest edge endpoint) - -ida_graph.git_elp (variable) - edge layout point (graph_item_t::elp) - -ida_graph.git_node (variable) - node title (graph_item_t::n) - -ida_graph.git_none (variable) - nothing - -ida_graph.git_text (variable) - node text (graph_item_t::n, graph_item_t::p) - -ida_graph.git_tool (variable) - node title button (graph_item_t::n, graph_item_t::b) - -ida_graph.graph_item_t (class) - Proxy of C++ graph_item_t class. - -ida_graph.graph_item_t.__init__ (method) - __init__(self) -> graph_item_t - -ida_graph.graph_item_t.b (variable) - button number - -ida_graph.graph_item_t.e (variable) - edge source and destination - -ida_graph.graph_item_t.elp (variable) - edge layout point - -ida_graph.graph_item_t.is_edge (method) - is_edge(self) -> bool - -ida_graph.graph_item_t.is_node (method) - is_node(self) -> bool - -ida_graph.graph_item_t.n (variable) - node number - -ida_graph.graph_item_t.p (variable) - text coordinates in the node - -ida_graph.graph_item_t.type (variable) - type - -ida_graph.graph_node_visitor_t (class) - Proxy of C++ graph_node_visitor_t class. - -ida_graph.graph_node_visitor_t.__disown__ (method) - -ida_graph.graph_node_visitor_t.__init__ (method) - __init__(self) -> graph_node_visitor_t - - @param self: PyObject * - -ida_graph.graph_node_visitor_t.is_forbidden_edge (method) - is_forbidden_edge(self, arg0, arg1) -> bool - Should the edge between 'n' and 'm' be ignored? - - @param arg0: int - @param arg1: int - -ida_graph.graph_node_visitor_t.is_visited (method) - is_visited(self, n) -> bool - Have we already visited the given node? - - @param n: (C++: int) - -ida_graph.graph_node_visitor_t.reinit (method) - reinit(self) - Reset visited nodes. - -ida_graph.graph_node_visitor_t.set_visited (method) - set_visited(self, n) - Mark node as visited. - - @param n: (C++: int) - -ida_graph.graph_node_visitor_t.visit_node (method) - visit_node(self, arg0) -> int - Implements action to take when a node is visited. - - @param arg0: int - -ida_graph.graph_path_visitor_t (class) - Proxy of C++ graph_path_visitor_t class. - -ida_graph.graph_path_visitor_t.__disown__ (method) - -ida_graph.graph_path_visitor_t.__init__ (method) - __init__(self) -> graph_path_visitor_t - - @param self: PyObject * - -ida_graph.graph_path_visitor_t.path (variable) - current path - -ida_graph.graph_path_visitor_t.prune (variable) - walk_forward(): prune := true means to stop the current path - -ida_graph.graph_path_visitor_t.walk_backward (method) - walk_backward(self, arg0) -> int - - @param arg0: int - -ida_graph.graph_path_visitor_t.walk_forward (method) - walk_forward(self, arg0) -> int - - @param arg0: int - -ida_graph.graph_visitor_t (class) - Proxy of C++ graph_visitor_t class. - -ida_graph.graph_visitor_t.__disown__ (method) - -ida_graph.graph_visitor_t.__init__ (method) - __init__(self) -> graph_visitor_t - - @param self: PyObject * - -ida_graph.graph_visitor_t.visit_edge (method) - visit_edge(self, arg2, arg3) -> int - - @param arg2: edge_t - @param arg3: edge_info_t * - -ida_graph.graph_visitor_t.visit_node (method) - visit_node(self, arg2, arg3) -> int - - @param arg2: int - @param arg3: rect_t & - -ida_graph.grcode_calculating_layout (variable) - calculating user-defined graph layout. - - @retval 0: not implemented - @retval 1: graph layout calculated by the plugin - -ida_graph.grcode_center_on (variable) - use viewer_center_on() - -ida_graph.grcode_change_group_visibility (variable) - use mutable_graph_t::change_group_visibility() - -ida_graph.grcode_changed_graph (variable) - new graph has been set. - - @retval 0: must return 0 - -ida_graph.grcode_clear (variable) - use mutable_graph_t::clear() - -ida_graph.grcode_clicked (variable) - graph is being clicked. this callback allows you to ignore some clicks. it - occurs too early, internal graph variables are not updated yet. current_item1, - current_item2 point to the same thing. item2 has more information. see also: - custom_viewer_click_t - - @retval 0: ok - @retval 1: ignore click - -ida_graph.grcode_create_circle_layout (variable) - use abstract_graph_t::create_circle_layout() - -ida_graph.grcode_create_digraph_layout (variable) - use mutable_graph_t::create_digraph_layout() - -ida_graph.grcode_create_disasm_graph1 (variable) - use create_disasm_graph(ea_t ea) - -ida_graph.grcode_create_disasm_graph2 (variable) - use create_disasm_graph(const rangevec_t &ranges) - -ida_graph.grcode_create_graph_viewer (variable) - use create_graph_viewer() - -ida_graph.grcode_create_group (variable) - use mutable_graph_t::create_group() - -ida_graph.grcode_create_mutable_graph (variable) - use create_mutable_graph() - -ida_graph.grcode_create_tree_layout (variable) - use abstract_graph_t::create_tree_layout() - -ida_graph.grcode_create_user_graph_place (variable) - use create_user_graph_place() - -ida_graph.grcode_creating_group (variable) - a group is being created. this provides an opportunity for the graph to forbid - creation of the group. Note that groups management is done by the - mutable_graph_t instance itself: there is no need to modify the graph in this - callback. - - @retval 0: ok - @retval 1: forbid group creation - -ida_graph.grcode_dblclicked (variable) - a graph node has been double clicked. - - @retval 0: ok - @retval 1: ignore click - -ida_graph.grcode_del_custom_layout (variable) - use mutable_graph_t::del_custom_layout() - -ida_graph.grcode_del_node_info (variable) - use viewer_del_node_info() - -ida_graph.grcode_delete_group (variable) - use mutable_graph_t::delete_group() - -ida_graph.grcode_delete_mutable_graph (variable) - use delete_mutable_graph() - -ida_graph.grcode_deleting_group (variable) - a group is being deleted. this provides an opportunity for the graph to forbid - deletion of the group. Note that groups management is done by the - mutable_graph_t instance itself: there is no need to modify the graph in this - callback. - - @retval 0: ok - @retval 1: forbid group deletion - -ida_graph.grcode_destroyed (variable) - graph is being destroyed. Note that this doesn't mean the graph viewer is being - destroyed; this only means that the graph that is being displayed by it is being - destroyed, and that, e.g., any possibly cached data should be invalidated (this - event can happen when, for example, the user decides to group nodes together: - that operation will effectively create a new graph, that will replace the old - one.) To be notified when the graph viewer itself is being destroyed, please see - notification 'view_close', in kernwin.hpp - - @retval 0: must return 0 - -ida_graph.grcode_edge_infos_wrapper_clear (variable) - use edge_infos_wrapper_t::clear() - -ida_graph.grcode_edge_infos_wrapper_copy (variable) - use edge_infos_wrapper_t::operator=() - -ida_graph.grcode_empty (variable) - use mutable_graph_t::empty() - -ida_graph.grcode_find_subgraph_node (variable) - use mutable_graph_t::_find_subgraph_node() - -ida_graph.grcode_fit_window (variable) - use viewer_fit_window() - -ida_graph.grcode_get_curnode (variable) - use viewer_get_curnode() - -ida_graph.grcode_get_custom_layout (variable) - use mutable_graph_t::get_custom_layout() - -ida_graph.grcode_get_gli (variable) - use viewer_get_gli() - -ida_graph.grcode_get_graph_groups (variable) - use mutable_graph_t::get_graph_groups() - -ida_graph.grcode_get_graph_viewer (variable) - use get_graph_viewer() - -ida_graph.grcode_get_node_info (variable) - use viewer_get_node_info() - -ida_graph.grcode_get_node_representative (variable) - use mutable_graph_t::get_node_representative() - -ida_graph.grcode_get_selection (variable) - use viewer_get_selection() - -ida_graph.grcode_get_viewer_graph (variable) - use get_viewer_graph() - -ida_graph.grcode_gotfocus (variable) - a graph viewer got focus. - - @retval 0: must return 0 - -ida_graph.grcode_group_visibility (variable) - a group is being collapsed/uncollapsed this provides an opportunity for the - graph to forbid changing the visibility of the group. Note that groups - management is done by the mutable_graph_t instance itself: there is no need to - modify the graph in this callback. - - @retval 0: ok - @retval 1: forbid group modification - -ida_graph.grcode_is_visible_node (variable) - use mutable_graph_t::is_visible_node() - -ida_graph.grcode_layout_calculated (variable) - graph layout calculated. - - @retval 0: must return 0 - -ida_graph.grcode_lostfocus (variable) - a graph viewer lost focus. - - @retval 0: must return 0 - -ida_graph.grcode_node_qty (variable) - use mutable_graph_t::node_qty() - -ida_graph.grcode_nrect (variable) - use mutable_graph_t::nrect() - -ida_graph.grcode_refresh_viewer (variable) - use refresh_viewer() - -ida_graph.grcode_set_custom_layout (variable) - use mutable_graph_t::set_custom_layout() - -ida_graph.grcode_set_edge (variable) - use mutable_graph_t::set_edge() - -ida_graph.grcode_set_gli (variable) - use viewer_set_gli() - -ida_graph.grcode_set_graph_groups (variable) - use mutable_graph_t::set_graph_groups() - -ida_graph.grcode_set_node_info (variable) - use viewer_set_node_info() - -ida_graph.grcode_set_titlebar_height (variable) - use viewer_set_titlebar_height() - -ida_graph.grcode_set_viewer_graph (variable) - use set_viewer_graph() - -ida_graph.grcode_user_draw (variable) - render node of a user-defined graph. NB: draw only on the specified DC and - nowhere else! - - @retval 0: not rendered - @retval 1: rendered - -ida_graph.grcode_user_hint (variable) - retrieve hint for the user-defined graph. - - @retval 0: use default hint - @retval 1: use proposed hint - -ida_graph.grcode_user_refresh (variable) - refresh user-defined graph nodes and edges This is called when the UI considers - that it is necessary to recreate the graph layout, and thus has to ensure that - the 'mutable_graph_t' instance it is using, is up-to-date. For example: - * at graph creation-time - * if a refresh_viewer() call was made - - @return: success - -ida_graph.grcode_user_size (variable) - calculate node size for user-defined graph. - - @retval 0: did not calculate. ida will use node text size - @retval 1: calculated. ida will add node title to the size - -ida_graph.grcode_user_text (variable) - retrieve text for user-defined graph node. NB: do not use anything calling GDI! - - @return: success, result must be filled - -ida_graph.grcode_user_title (variable) - render node title of a user-defined graph. - - @retval 0: did not render, ida will fill it with title_bg_color - @retval 1: rendered node title - -ida_graph.grcode_viewer_create_groups_vec (variable) - use viewer_create_groups() - -ida_graph.grcode_viewer_delete_groups_vec (variable) - use viewer_delete_groups() - -ida_graph.grcode_viewer_groups_visibility_vec (variable) - use viewer_set_groups_visibility() - -ida_graph.group_crinfo_t (class) - Proxy of C++ group_crinfo_t class. - -ida_graph.group_crinfo_t.__init__ (method) - __init__(self) -> group_crinfo_t - -ida_graph.interval_t (class) - Proxy of C++ interval_t class. - -ida_graph.interval_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: interval_t const & - -ida_graph.interval_t.__init__ (method) - __init__(self) -> interval_t - __init__(self, y0, y1) -> interval_t - - @param y0: int - @param y1: int - - __init__(self, s) -> interval_t - - @param s: edge_segment_t const & - -ida_graph.interval_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: interval_t const & - -ida_graph.interval_t.contains (method) - contains(self, x) -> bool - - @param x: int - -ida_graph.interval_t.empty (method) - empty(self) -> bool - -ida_graph.interval_t.intersect (method) - intersect(self, r) - - @param r: interval_t const & - -ida_graph.interval_t.length (method) - length(self) -> int - -ida_graph.interval_t.make_union (method) - make_union(self, r) - - @param r: interval_t const & - -ida_graph.interval_t.move_by (method) - move_by(self, shift) - - @param shift: int - -ida_graph.mutable_graph_t (class) - Proxy of C++ mutable_graph_t class. - -ida_graph.mutable_graph_t.__init__ (method) - -ida_graph.mutable_graph_t.add_edge (method) - add_edge(self, i, j, ei) -> bool - - @param i: int - @param j: int - @param ei: edge_info_t const * - -ida_graph.mutable_graph_t.add_node (method) - add_node(self, r) -> int - Add a node, possibly with a specific geometry - - @param r: (C++: const rect_t *) the node geometry (can be nullptr) - @return: the new node - -ida_graph.mutable_graph_t.belongs (variable) - the subgraph the node belongs to INT_MAX means that the node doesn't exist sign - bit means collapsed node - -ida_graph.mutable_graph_t.calc_group_ea (method) - calc_group_ea(self, arg2) -> ea_t - - @param arg2: intvec_t const & - -ida_graph.mutable_graph_t.change_group_visibility (method) - change_group_visibility(self, group, expand) -> bool - Expand/collapse a group node - - @param group: (C++: int) the group node - @param expand: (C++: bool) whether to expand or collapse - @return: success - -ida_graph.mutable_graph_t.create_digraph_layout (method) - create_digraph_layout(self) -> bool - -ida_graph.mutable_graph_t.create_group (method) - create_group(self, nodes) -> int - Create a new group node, that will contain all the nodes in 'nodes'. - - @param nodes: (C++: const intvec_t &) the nodes that will be part of the group - @return: the group node, or -1 in case of error - -ida_graph.mutable_graph_t.del_custom_layout (method) - del_custom_layout(self) - -ida_graph.mutable_graph_t.del_edge (method) - del_edge(self, i, j) -> bool - - @param i: int - @param j: int - -ida_graph.mutable_graph_t.del_node (method) - del_node(self, n) -> ssize_t - Delete a node - - @param n: (C++: int) the node to delete - @return: the number of deleted edges - -ida_graph.mutable_graph_t.delete_group (method) - delete_group(self, group) -> bool - Delete a group node. - - This deletes the group node only; it does not delete nodes that are part of the - group. - - @param group: (C++: int) the group node - @return: success - -ida_graph.mutable_graph_t.empty (method) - empty(self) -> bool - Is the graph (visually) empty? - - @return: true if there are no visible nodes - -ida_graph.mutable_graph_t.exists (method) - exists(self, node) -> bool - Is the node visible? - - @param node: (C++: int) the node number - @return: success - -ida_graph.mutable_graph_t.get_custom_layout (method) - get_custom_layout(self) -> bool - -ida_graph.mutable_graph_t.get_first_subgraph_node (method) - get_first_subgraph_node(self, group) -> int - - @param group: int - -ida_graph.mutable_graph_t.get_graph_groups (method) - get_graph_groups(self) -> bool - -ida_graph.mutable_graph_t.get_next_subgraph_node (method) - get_next_subgraph_node(self, group, current) -> int - - @param group: int - @param current: int - -ida_graph.mutable_graph_t.get_node_group (method) - get_node_group(self, node) -> int - - @param node: int - -ida_graph.mutable_graph_t.get_node_representative (method) - get_node_representative(self, node) -> int - Get the node that currently visually represents 'node'. This will find the - "closest" parent group node that's visible, by attempting to walk up the group - nodes that contain 'node', and will stop when it finds a node that is currently - visible. - - See also get_group_node() - - @param node: (C++: int) the node - @return: the node that represents 'node', or 'node' if it's not part of any - group - -ida_graph.mutable_graph_t.gid (variable) - graph id - unique for the database for flowcharts it is equal to the function - start_ea - -ida_graph.mutable_graph_t.is_collapsed_node (method) - is_collapsed_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_deleted_node (method) - is_deleted_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_displayable_node (method) - is_displayable_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_dot_node (method) - is_dot_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_group_node (method) - is_group_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_simple_node (method) - is_simple_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_subgraph_node (method) - is_subgraph_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_uncollapsed_node (method) - is_uncollapsed_node(self, node) -> bool - - @param node: int - -ida_graph.mutable_graph_t.is_user_graph (method) - is_user_graph(self) -> bool - -ida_graph.mutable_graph_t.is_visible_node (method) - is_visible_node(self, node) -> bool - Is the node currently visible? - - An invisible node is a node that's part of a group that's currently collapsed. - - @param node: (C++: int) the node - @return: success - -ida_graph.mutable_graph_t.node_flags (variable) - node flags - -ida_graph.mutable_graph_t.node_qty (method) - node_qty(self) -> int - Get the number of visible nodes (the list can be retrieved using gdl.hpp's - node_iterator) - - See also size() - - @return: the number of visible nodes - -ida_graph.mutable_graph_t.npred (method) - npred(self, b) -> int - - @param b: int - -ida_graph.mutable_graph_t.nsucc (method) - nsucc(self, b) -> int - - @param b: int - -ida_graph.mutable_graph_t.pred (method) - pred(self, b, i) -> int - - @param b: int - @param i: int - -ida_graph.mutable_graph_t.predset (method) - predset(self, b) -> intvec_t const & - - @param b: int - -ida_graph.mutable_graph_t.redo_layout (method) - redo_layout(self) -> bool - Recompute the layout, according to the value of 'current_layout'. - - @return: success - -ida_graph.mutable_graph_t.refresh (method) - refresh(self) -> bool - Refresh the graph - - A graph needs refreshing when it's "backing data". E.g., if the number (or - contents) of the objects in the above example, change. - - Let's say the user's plugin ends up finding a 5th piece of scattered data. It - should then add it to its internal list of known objects, and tell IDA that the - graph needs to be refreshed, using refresh_viewer(). This will cause IDA to: - * discard all its internal rendering information, - * call mutable_graph_t::refresh() on the graph so that the user's plugin has a - chance to "sync" the number of nodes & edges that this graph contains, to the - information that the plugin has collected so far - * re-create internal rendering information, and - * repaint the view - - @return: success - -ida_graph.mutable_graph_t.replace_edge (method) - replace_edge(self, i, j, x, y) -> bool - - @param i: int - @param j: int - @param x: int - @param y: int - -ida_graph.mutable_graph_t.reset (method) - reset(self) - -ida_graph.mutable_graph_t.resize (method) - resize(self, n) - Resize the graph to 'n' nodes - - @param n: (C++: int) the new size - -ida_graph.mutable_graph_t.set_custom_layout (method) - set_custom_layout(self) - -ida_graph.mutable_graph_t.set_deleted_node (method) - set_deleted_node(self, node) - - @param node: int - -ida_graph.mutable_graph_t.set_edge (method) - set_edge(self, e, ei) -> bool - - @param e: edge_t - @param ei: edge_info_t const * - -ida_graph.mutable_graph_t.set_graph_groups (method) - set_graph_groups(self) - -ida_graph.mutable_graph_t.set_node_group (method) - set_node_group(self, node, group) - - @param node: int - @param group: int - -ida_graph.mutable_graph_t.set_nrect (method) - set_nrect(self, n, r) -> bool - - @param n: int - @param r: rect_t const & - -ida_graph.mutable_graph_t.size (method) - size(self) -> int - Get the total number of nodes (including group nodes, and including hidden - nodes.) - - See also node_qty() - - @return: the total number of nodes in the graph - -ida_graph.mutable_graph_t.succ (method) - succ(self, b, i) -> int - - @param b: int - @param i: int - -ida_graph.mutable_graph_t.succset (method) - succset(self, b) -> intvec_t const & - - @param b: int - -ida_graph.node_info_t (class) - Proxy of C++ node_info_t class. - -ida_graph.node_info_t.__init__ (method) - __init__(self) -> node_info_t - -ida_graph.node_info_t.bg_color (variable) - background color - -ida_graph.node_info_t.ea (variable) - address - -ida_graph.node_info_t.flags (variable) - flags - -ida_graph.node_info_t.frame_color (variable) - color of enclosing frame - -ida_graph.node_info_t.get_flags_for_valid (method) - get_flags_for_valid(self) -> uint32 - Get combination of Node info flags describing which attributes are valid. - -ida_graph.node_info_t.text (variable) - node contents - -ida_graph.node_info_t.valid_bg_color (method) - valid_bg_color(self) -> bool - Has valid bg_color? - -ida_graph.node_info_t.valid_ea (method) - valid_ea(self) -> bool - Has valid ea? - -ida_graph.node_info_t.valid_flags (method) - valid_flags(self) -> bool - Has valid flags? - -ida_graph.node_info_t.valid_frame_color (method) - valid_frame_color(self) -> bool - Has valid frame_color? - -ida_graph.node_info_t.valid_text (method) - valid_text(self) -> bool - Has non-empty text? - -ida_graph.node_layout_t (class) - Proxy of C++ qvector< rect_t > class. - -ida_graph.node_layout_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< rect_t > const & - -ida_graph.node_layout_t.__getitem__ (method) - __getitem__(self, i) -> rect_t - - @param i: size_t - -ida_graph.node_layout_t.__init__ (method) - __init__(self) -> node_layout_t - __init__(self, x) -> node_layout_t - - @param x: qvector< rect_t > const & - -ida_graph.node_layout_t.__len__ (method) - __len__(self) -> size_t - -ida_graph.node_layout_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< rect_t > const & - -ida_graph.node_layout_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: rect_t const & - -ida_graph.node_layout_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: rect_t const & - -ida_graph.node_layout_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: rect_t const & - -ida_graph.node_layout_t.at (method) - at(self, _idx) -> rect_t - - @param _idx: size_t - -ida_graph.node_layout_t.begin (method) - begin(self) -> rect_t - -ida_graph.node_layout_t.capacity (method) - capacity(self) -> size_t - -ida_graph.node_layout_t.clear (method) - clear(self) - -ida_graph.node_layout_t.empty (method) - empty(self) -> bool - -ida_graph.node_layout_t.end (method) - end(self) -> rect_t - -ida_graph.node_layout_t.erase (method) - erase(self, it) -> rect_t - - @param it: qvector< rect_t >::iterator - - erase(self, first, last) -> rect_t - - @param first: qvector< rect_t >::iterator - @param last: qvector< rect_t >::iterator - -ida_graph.node_layout_t.extract (method) - extract(self) -> rect_t - -ida_graph.node_layout_t.find (method) - find(self, x) -> rect_t - - @param x: rect_t const & - -ida_graph.node_layout_t.grow (method) - grow(self, x=rect_t()) - - @param x: rect_t const & - -ida_graph.node_layout_t.has (method) - has(self, x) -> bool - - @param x: rect_t const & - -ida_graph.node_layout_t.inject (method) - inject(self, s, len) - - @param s: rect_t * - @param len: size_t - -ida_graph.node_layout_t.insert (method) - insert(self, it, x) -> rect_t - - @param it: qvector< rect_t >::iterator - @param x: rect_t const & - -ida_graph.node_layout_t.pop_back (method) - pop_back(self) - -ida_graph.node_layout_t.push_back (method) - push_back(self, x) - - @param x: rect_t const & - - push_back(self) -> rect_t - -ida_graph.node_layout_t.qclear (method) - qclear(self) - -ida_graph.node_layout_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_graph.node_layout_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: rect_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_graph.node_layout_t.size (method) - size(self) -> size_t - -ida_graph.node_layout_t.swap (method) - swap(self, r) - - @param r: qvector< rect_t > & - -ida_graph.node_layout_t.truncate (method) - truncate(self) - -ida_graph.node_ordering_t (class) - Proxy of C++ node_ordering_t class. - -ida_graph.node_ordering_t.__init__ (method) - __init__(self) -> node_ordering_t - -ida_graph.node_ordering_t.clear (method) - clear(self) - -ida_graph.node_ordering_t.clr (method) - clr(self, _node) -> bool - - @param _node: int - -ida_graph.node_ordering_t.node (method) - node(self, _order) -> int - - @param _order: size_t - -ida_graph.node_ordering_t.order (method) - order(self, _node) -> int - - @param _node: int - -ida_graph.node_ordering_t.resize (method) - resize(self, n) - - @param n: int - -ida_graph.node_ordering_t.set (method) - set(self, _node, num) - - @param _node: int - @param num: int - -ida_graph.node_ordering_t.size (method) - size(self) -> size_t - -ida_graph.point_t (class) - Proxy of C++ point_t class. - -ida_graph.point_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: point_t const & - -ida_graph.point_t.__init__ (method) - __init__(self) -> point_t - __init__(self, _x, _y) -> point_t - - @param _x: int - @param _y: int - -ida_graph.point_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: point_t const & - -ida_graph.point_t.add (method) - add(self, r) -> point_t - - @param r: point_t const & - -ida_graph.point_t.negate (method) - negate(self) - -ida_graph.point_t.sub (method) - sub(self, r) -> point_t - - @param r: point_t const & - -ida_graph.pointseq_t (class) - Proxy of C++ pointseq_t class. - -ida_graph.pointseq_t.__init__ (method) - __init__(self) -> pointseq_t - -ida_graph.pointvec_t (class) - Proxy of C++ qvector< point_t > class. - -ida_graph.pointvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< point_t > const & - -ida_graph.pointvec_t.__getitem__ (method) - __getitem__(self, i) -> point_t - - @param i: size_t - -ida_graph.pointvec_t.__init__ (method) - __init__(self) -> pointvec_t - __init__(self, x) -> pointvec_t - - @param x: qvector< point_t > const & - -ida_graph.pointvec_t.__len__ (method) - __len__(self) -> size_t - -ida_graph.pointvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< point_t > const & - -ida_graph.pointvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: point_t const & - -ida_graph.pointvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: point_t const & - -ida_graph.pointvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: point_t const & - -ida_graph.pointvec_t.at (method) - at(self, _idx) -> point_t - - @param _idx: size_t - -ida_graph.pointvec_t.begin (method) - begin(self) -> point_t - -ida_graph.pointvec_t.capacity (method) - capacity(self) -> size_t - -ida_graph.pointvec_t.clear (method) - clear(self) - -ida_graph.pointvec_t.empty (method) - empty(self) -> bool - -ida_graph.pointvec_t.end (method) - end(self) -> point_t - -ida_graph.pointvec_t.erase (method) - erase(self, it) -> point_t - - @param it: qvector< point_t >::iterator - - erase(self, first, last) -> point_t - - @param first: qvector< point_t >::iterator - @param last: qvector< point_t >::iterator - -ida_graph.pointvec_t.extract (method) - extract(self) -> point_t - -ida_graph.pointvec_t.find (method) - find(self, x) -> point_t - - @param x: point_t const & - -ida_graph.pointvec_t.grow (method) - grow(self, x=point_t()) - - @param x: point_t const & - -ida_graph.pointvec_t.has (method) - has(self, x) -> bool - - @param x: point_t const & - -ida_graph.pointvec_t.inject (method) - inject(self, s, len) - - @param s: point_t * - @param len: size_t - -ida_graph.pointvec_t.insert (method) - insert(self, it, x) -> point_t - - @param it: qvector< point_t >::iterator - @param x: point_t const & - -ida_graph.pointvec_t.pop_back (method) - pop_back(self) - -ida_graph.pointvec_t.push_back (method) - push_back(self, x) - - @param x: point_t const & - - push_back(self) -> point_t - -ida_graph.pointvec_t.qclear (method) - qclear(self) - -ida_graph.pointvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_graph.pointvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: point_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_graph.pointvec_t.size (method) - size(self) -> size_t - -ida_graph.pointvec_t.swap (method) - swap(self, r) - - @param r: qvector< point_t > & - -ida_graph.pointvec_t.truncate (method) - truncate(self) - -ida_graph.pyg_close (function) - pyg_close(_self) - - @param self: PyObject * - -ida_graph.pyg_select_node (function) - pyg_select_node(_self, nid) - - @param self: PyObject * - @param nid: int - -ida_graph.pyg_show (function) - pyg_show(_self) -> bool - - @param self: PyObject * - -ida_graph.rect_t (class) - Proxy of C++ rect_t class. - -ida_graph.rect_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: rect_t const & - -ida_graph.rect_t.__init__ (method) - __init__(self) -> rect_t - __init__(self, l, t, r, b) -> rect_t - - @param l: int - @param t: int - @param r: int - @param b: int - - __init__(self, p0, p1) -> rect_t - - @param p0: point_t const & - @param p1: point_t const & - -ida_graph.rect_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: rect_t const & - -ida_graph.rect_t.area (method) - area(self) -> int - -ida_graph.rect_t.bottomright (method) - bottomright(self) -> point_t - -ida_graph.rect_t.center (method) - center(self) -> point_t - -ida_graph.rect_t.contains (method) - contains(self, p) -> bool - - @param p: point_t const & - -ida_graph.rect_t.empty (method) - empty(self) -> bool - -ida_graph.rect_t.grow (method) - grow(self, delta) - - @param delta: int - -ida_graph.rect_t.height (method) - height(self) -> int - -ida_graph.rect_t.intersect (method) - intersect(self, r) - - @param r: rect_t const & - -ida_graph.rect_t.is_intersection_empty (method) - is_intersection_empty(self, r) -> bool - - @param r: rect_t const & - -ida_graph.rect_t.make_union (method) - make_union(self, r) - - @param r: rect_t const & - -ida_graph.rect_t.move_by (method) - move_by(self, p) - - @param p: point_t const & - -ida_graph.rect_t.move_to (method) - move_to(self, p) - - @param p: point_t const & - -ida_graph.rect_t.topleft (method) - topleft(self) -> point_t - -ida_graph.rect_t.width (method) - width(self) -> int - -ida_graph.refresh_viewer (function) - refresh_viewer(gv) - Redraw the graph in the given view. - - @param gv: (C++: graph_viewer_t *) - -ida_graph.row_info_t (class) - Proxy of C++ row_info_t class. - -ida_graph.row_info_t.__init__ (method) - __init__(self) -> row_info_t - -ida_graph.row_info_t.bottom (variable) - bottom y coord of the row - -ida_graph.row_info_t.height (method) - height(self) -> int - -ida_graph.row_info_t.nodes (variable) - list of nodes at the row - -ida_graph.row_info_t.top (variable) - top y coord of the row - -ida_graph.screen_graph_selection_base_t (class) - Proxy of C++ qvector< selection_item_t > class. - -ida_graph.screen_graph_selection_base_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< selection_item_t > const & - -ida_graph.screen_graph_selection_base_t.__getitem__ (method) - __getitem__(self, i) -> selection_item_t - - @param i: size_t - -ida_graph.screen_graph_selection_base_t.__init__ (method) - __init__(self) -> screen_graph_selection_base_t - __init__(self, x) -> screen_graph_selection_base_t - - @param x: qvector< selection_item_t > const & - -ida_graph.screen_graph_selection_base_t.__len__ (method) - __len__(self) -> size_t - -ida_graph.screen_graph_selection_base_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< selection_item_t > const & - -ida_graph.screen_graph_selection_base_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: selection_item_t const & - -ida_graph.screen_graph_selection_base_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: selection_item_t const & - -ida_graph.screen_graph_selection_base_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: selection_item_t const & - -ida_graph.screen_graph_selection_base_t.at (method) - at(self, _idx) -> selection_item_t - - @param _idx: size_t - -ida_graph.screen_graph_selection_base_t.begin (method) - begin(self) -> selection_item_t - -ida_graph.screen_graph_selection_base_t.capacity (method) - capacity(self) -> size_t - -ida_graph.screen_graph_selection_base_t.clear (method) - clear(self) - -ida_graph.screen_graph_selection_base_t.empty (method) - empty(self) -> bool - -ida_graph.screen_graph_selection_base_t.end (method) - end(self) -> selection_item_t - -ida_graph.screen_graph_selection_base_t.erase (method) - erase(self, it) -> selection_item_t - - @param it: qvector< selection_item_t >::iterator - - erase(self, first, last) -> selection_item_t - - @param first: qvector< selection_item_t >::iterator - @param last: qvector< selection_item_t >::iterator - -ida_graph.screen_graph_selection_base_t.extract (method) - extract(self) -> selection_item_t - -ida_graph.screen_graph_selection_base_t.find (method) - find(self, x) -> selection_item_t - - @param x: selection_item_t const & - -ida_graph.screen_graph_selection_base_t.grow (method) - grow(self, x=selection_item_t()) - - @param x: selection_item_t const & - -ida_graph.screen_graph_selection_base_t.has (method) - has(self, x) -> bool - - @param x: selection_item_t const & - -ida_graph.screen_graph_selection_base_t.inject (method) - inject(self, s, len) - - @param s: selection_item_t * - @param len: size_t - -ida_graph.screen_graph_selection_base_t.insert (method) - insert(self, it, x) -> selection_item_t - - @param it: qvector< selection_item_t >::iterator - @param x: selection_item_t const & - -ida_graph.screen_graph_selection_base_t.pop_back (method) - pop_back(self) - -ida_graph.screen_graph_selection_base_t.push_back (method) - push_back(self, x) - - @param x: selection_item_t const & - - push_back(self) -> selection_item_t - -ida_graph.screen_graph_selection_base_t.qclear (method) - qclear(self) - -ida_graph.screen_graph_selection_base_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_graph.screen_graph_selection_base_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: selection_item_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_graph.screen_graph_selection_base_t.size (method) - size(self) -> size_t - -ida_graph.screen_graph_selection_base_t.swap (method) - swap(self, r) - - @param r: qvector< selection_item_t > & - -ida_graph.screen_graph_selection_base_t.truncate (method) - truncate(self) - -ida_graph.screen_graph_selection_t (class) - Proxy of C++ screen_graph_selection_t class. - -ida_graph.screen_graph_selection_t.__init__ (method) - __init__(self) -> screen_graph_selection_t - -ida_graph.screen_graph_selection_t.add (method) - add(self, s) - - @param s: screen_graph_selection_t const & - -ida_graph.screen_graph_selection_t.add_node (method) - add_node(self, node) - - @param node: int - -ida_graph.screen_graph_selection_t.add_point (method) - add_point(self, e, idx) - - @param e: edge_t - @param idx: int - -ida_graph.screen_graph_selection_t.del_node (method) - del_node(self, node) - - @param node: int - -ida_graph.screen_graph_selection_t.del_point (method) - del_point(self, e, idx) - - @param e: edge_t - @param idx: int - -ida_graph.screen_graph_selection_t.has (method) - has(self, item) -> bool - - @param item: selection_item_t const & - -ida_graph.screen_graph_selection_t.items_count (method) - items_count(self, look_for_nodes) -> size_t - - @param look_for_nodes: bool - -ida_graph.screen_graph_selection_t.nodes_count (method) - nodes_count(self) -> size_t - -ida_graph.screen_graph_selection_t.points_count (method) - points_count(self) -> size_t - -ida_graph.screen_graph_selection_t.sub (method) - sub(self, s) - - @param s: screen_graph_selection_t const & - -ida_graph.selection_item_t (class) - Proxy of C++ selection_item_t class. - -ida_graph.selection_item_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: selection_item_t const & - -ida_graph.selection_item_t.__init__ (method) - __init__(self) -> selection_item_t - __init__(self, n) -> selection_item_t - - @param n: int - - __init__(self, _elp) -> selection_item_t - - @param _elp: edge_layout_point_t & - - __init__(self, e, idx) -> selection_item_t - - @param e: edge_t - @param idx: int - -ida_graph.selection_item_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: selection_item_t const & - -ida_graph.selection_item_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: selection_item_t const & - -ida_graph.selection_item_t.compare (method) - compare(self, r) -> int - - @param r: selection_item_t const & - -ida_graph.selection_item_t.elp (variable) - edge layout point (is_node = false) - -ida_graph.selection_item_t.is_node (variable) - represents a selected node? - -ida_graph.selection_item_t.node (variable) - node number (is_node = true) - -ida_graph.set_node_info (function) - set_node_info(gid, node, ni, flags) - Set node info. - - @param gid: (C++: graph_id_t) id of desired graph - @param node: (C++: int) node number - @param ni: (C++: const node_info_t &) node info to use - @param flags: (C++: uint32) combination of Node info flags, identifying which fields of 'ni' - will be used - -ida_graph.set_viewer_graph (function) - set_viewer_graph(gv, g) - Set the underlying graph object for the given viewer. - - @param gv: (C++: graph_viewer_t *) - @param g: (C++: mutable_graph_t *) - -ida_graph.user_graph_place_t (class) - Proxy of C++ user_graph_place_t class. - -ida_graph.user_graph_place_t.__init__ (method) - -ida_graph.viewer_attach_menu_item (function) - viewer_attach_menu_item(g, name) -> bool - Attach a previously-registered action to the view's context menu. See - kernwin.hpp for how to register actions. - - @param g: (C++: graph_viewer_t *) graph viewer - @param name: (C++: const char *) action name - @return: success - -ida_graph.viewer_center_on (function) - viewer_center_on(gv, node) - Center the graph view on the given node. - - @param gv: (C++: graph_viewer_t *) - @param node: (C++: int) - -ida_graph.viewer_create_groups (function) - viewer_create_groups(gv, out_group_nodes, gi) -> bool - This will perform an operation similar to what happens when a user manually - selects a set of nodes, right-clicks and selects "Create group". This is a - wrapper around mutable_graph_t::create_group that will, in essence: - * clone the current graph - * for each group_crinfo_t, attempt creating group in that new graph - * if all were successful, animate to that new graph. - @note: this accepts parameters that allow creating of multiple groups at once; - which means only one graph animation will be triggered. - - @param gv: (C++: graph_viewer_t *) - @param out_group_nodes: (C++: intvec_t *) - @param gi: (C++: const groups_crinfos_t &) groups_crinfos_t const & - -ida_graph.viewer_del_node_info (function) - viewer_del_node_info(gv, n) - Delete node info for node in given viewer (see del_node_info()) - - @param gv: (C++: graph_viewer_t *) - @param n: (C++: int) - -ida_graph.viewer_delete_groups (function) - viewer_delete_groups(gv, groups, new_current=-1) -> bool - Wrapper around mutable_graph_t::delete_group. This function will: - * clone the current graph - * attempt deleting the groups in that new graph - * if successful, animate to that new graph. - - @param gv: (C++: graph_viewer_t *) - @param groups: (C++: const intvec_t &) intvec_t const & - @param new_current: (C++: int) - -ida_graph.viewer_fit_window (function) - viewer_fit_window(gv) - Fit graph viewer to its parent form. - - @param gv: (C++: graph_viewer_t *) - -ida_graph.viewer_get_curnode (function) - viewer_get_curnode(gv) -> int - Get number of currently selected node (-1 if none) - - @param gv: (C++: graph_viewer_t *) - -ida_graph.viewer_get_gli (function) - viewer_get_gli(out, gv, flags=0) -> bool - Get location info for given graph view If flags contains GLICTL_CENTER, then the - gli that will be retrieved, will be the one at the center of the view. Otherwise - it will be the top-left. - - @param out: (C++: graph_location_info_t *) - @param gv: (C++: graph_viewer_t *) - @param flags: (C++: uint32) - -ida_graph.viewer_get_node_info (function) - viewer_get_node_info(gv, out, n) -> bool - Get node info for node in given viewer (see get_node_info()) - - @param gv: (C++: graph_viewer_t *) - @param out: (C++: node_info_t *) - @param n: (C++: int) - -ida_graph.viewer_get_selection (function) - viewer_get_selection(gv, sgs) -> bool - Get currently selected items for graph viewer. - - @param gv: (C++: graph_viewer_t *) - @param sgs: (C++: screen_graph_selection_t *) - -ida_graph.viewer_set_gli (function) - viewer_set_gli(gv, gli, flags=0) - Set location info for given graph view If flags contains GLICTL_CENTER, then the - gli will be set to be the center of the view. Otherwise it will be the top-left. - - @param gv: (C++: graph_viewer_t *) - @param gli: (C++: const graph_location_info_t *) graph_location_info_t const * - @param flags: (C++: uint32) - -ida_graph.viewer_set_groups_visibility (function) - viewer_set_groups_visibility(gv, groups, expand, new_current=-1) -> bool - Wrapper around mutable_graph_t::change_visibility. This function will: - * clone the current graph - * attempt changing visibility of the groups in that new graph - * if successful, animate to that new graph. - - @param gv: (C++: graph_viewer_t *) - @param groups: (C++: const intvec_t &) intvec_t const & - @param expand: (C++: bool) - @param new_current: (C++: int) - -ida_graph.viewer_set_node_info (function) - viewer_set_node_info(gv, n, ni, flags) - Set node info for node in given viewer (see set_node_info()) - - @param gv: (C++: graph_viewer_t *) - @param n: (C++: int) - @param ni: (C++: const node_info_t &) node_info_t const & - @param flags: (C++: uint32) - -ida_graph.viewer_set_titlebar_height (function) - viewer_set_titlebar_height(gv, height) -> int - Set height of node title bars (grcode_set_titlebar_height) - - @param gv: (C++: graph_viewer_t *) - @param height: (C++: int) - -ida_ida (module) - Contains the inf structure definition and some functions common to the whole IDA - project. - - The inf structure is saved in the database and contains information specific to - the current program being disassembled. Initially it is filled with values from - ida.cfg. - - Although it is not a good idea to change values in inf structure (because you - will overwrite values taken from ida.cfg), you are allowed to do it if you feel - it necessary. - -ida_ida.ABI_8ALIGN4 (variable) - 4 byte alignment for 8byte scalars (__int64/double) inside structures? - -ida_ida.ABI_BIGARG_ALIGN (variable) - use natural type alignment for argument if the alignment exceeds native word - size. (e.g. __int64 argument should be 8byte aligned on some 32bit platforms) - -ida_ida.ABI_GCC_LAYOUT (variable) - use gcc layout for udts (used for mingw) - -ida_ida.ABI_HARD_FLOAT (variable) - use the floating-point register set - -ida_ida.ABI_HUGEARG_ALIGN (variable) - use natural type alignment for an argument even if its alignment exceeds double - native word size (the default is to use double word max). e.g. if this bit is - set, __int128 has 16-byte alignment. this bit is not used by ida yet - -ida_ida.ABI_MAP_STKARGS (variable) - register arguments are mapped to stack area (and consume stack slots) - -ida_ida.ABI_PACK_STKARGS (variable) - do not align stack arguments to stack slots - -ida_ida.ABI_SET_BY_USER (variable) - compiler/abi were set by user flag and require SETCOMP_BY_USER flag to be - changed - -ida_ida.ABI_STACK_LDBL (variable) - long double arguments are passed on stack - -ida_ida.ABI_STACK_VARARGS (variable) - varargs are always passed on stack (even when there are free registers) - -ida_ida.AF2_DOEH (variable) - Handle EH information. - -ida_ida.AF2_DORTTI (variable) - Handle RTTI information. - -ida_ida.AF2_MACRO (variable) - Try to combine several instructions into a macro instruction - -ida_ida.AF2_MERGESTR (variable) - Merge string literals created using data xrefs - -ida_ida.AF_ANORET (variable) - Perform 'no-return' analysis. - -ida_ida.AF_CHKUNI (variable) - Check for unicode strings. - -ida_ida.AF_CODE (variable) - Trace execution flow. - -ida_ida.AF_DATOFF (variable) - Automatically convert data to offsets. - -ida_ida.AF_DOCODE (variable) - Coagulate code segs at the final pass. - -ida_ida.AF_DODATA (variable) - Coagulate data segs at the final pass. - -ida_ida.AF_DREFOFF (variable) - Create offset if data xref to seg32 exists. - -ida_ida.AF_FINAL (variable) - Final pass of analysis. - -ida_ida.AF_FIXUP (variable) - Create offsets and segments using fixup info. - -ida_ida.AF_FLIRT (variable) - Use flirt signatures. - -ida_ida.AF_FTAIL (variable) - Create function tails. - -ida_ida.AF_HFLIRT (variable) - Automatically hide library functions. - -ida_ida.AF_IMMOFF (variable) - Convert 32bit instruction operand to offset. - -ida_ida.AF_JFUNC (variable) - Rename jump functions as j_... - -ida_ida.AF_JUMPTBL (variable) - Locate and create jump tables. - -ida_ida.AF_LVAR (variable) - Create stack variables. - -ida_ida.AF_MARKCODE (variable) - Mark typical code sequences as code. - -ida_ida.AF_MEMFUNC (variable) - Try to guess member function types. - -ida_ida.AF_NULLSUB (variable) - Rename empty functions as nullsub_... - -ida_ida.AF_PROC (variable) - Create functions if call is present. - -ida_ida.AF_PROCPTR (variable) - Create function if data xref data->code32 exists. - -ida_ida.AF_PURDAT (variable) - Control flow to data segment is ignored. - -ida_ida.AF_REGARG (variable) - Propagate register argument information. - -ida_ida.AF_SIGCMT (variable) - Append a signature name comment for recognized anonymous library functions. - -ida_ida.AF_SIGMLT (variable) - Allow recognition of several copies of the same function. - -ida_ida.AF_STKARG (variable) - Propagate stack argument information. - -ida_ida.AF_STRLIT (variable) - Create string literal if data xref exists. - -ida_ida.AF_TRACE (variable) - Trace stack pointer. - -ida_ida.AF_TRFUNC (variable) - Truncate functions upon code deletion. - -ida_ida.AF_UNK (variable) - Delete instructions with no xrefs. - -ida_ida.AF_USED (variable) - Analyze and create all xrefs. - -ida_ida.AF_VERSP (variable) - Perform full SP-analysis. ( processor_t::verify_sp) - -ida_ida.DEMNAM_CMNT (variable) - display demangled names as comments - -ida_ida.DEMNAM_FIRST (variable) - override type info - -ida_ida.DEMNAM_GCC3 (variable) - assume gcc3 names (valid for gnu compiler) - -ida_ida.DEMNAM_MASK (variable) - mask for name form - -ida_ida.DEMNAM_NAME (variable) - display demangled names as regular names - -ida_ida.DEMNAM_NONE (variable) - don't display demangled names - -ida_ida.IDAINFO_TAG_SIZE (variable) - The database parameters. This structure is kept in the ida database. It contains - the essential parameters for the current program - -ida_ida.IDB_COMPRESSED (variable) - compress & pack database components - -ida_ida.IDB_PACKED (variable) - pack database components into .idb - -ida_ida.IDB_UNPACKED (variable) - leave database components unpacked - -ida_ida.INFFL_ALLASM (variable) - may use constructs not supported by the target assembler - -ida_ida.INFFL_AUTO (variable) - Autoanalysis is enabled? - -ida_ida.INFFL_CHKOPS (variable) - check manual operands? (unused) - -ida_ida.INFFL_GRAPH_VIEW (variable) - currently using graph options ( text_options_t::graph) - -ida_ida.INFFL_LOADIDC (variable) - loading an idc file that contains database info - -ida_ida.INFFL_NMOPS (variable) - allow non-matched operands? (unused) - -ida_ida.INFFL_NOUSER (variable) - do not store user info in the database - -ida_ida.INFFL_READONLY (variable) - (internal) temporary interdiction to modify the database - -ida_ida.INF_ABINAME (variable) - ABI name (processor specific) - -ida_ida.INF_ARCHIVE_PATH (variable) - archive file path - -ida_ida.INF_CRC32 (variable) - input file crc32 - -ida_ida.INF_CTIME (variable) - database creation timestamp - -ida_ida.INF_C_MACROS (variable) - C predefined macros. - -ida_ida.INF_DBG_BINPATHS (variable) - unused (20 indexes) - -ida_ida.INF_DUALOP_GRAPH (variable) - Graph text representation options. - -ida_ida.INF_DUALOP_TEXT (variable) - Text text representation options. - -ida_ida.INF_ELAPSED (variable) - seconds database stayed open - -ida_ida.INF_FILE_FORMAT_NAME (variable) - file format name for loader modules - -ida_ida.INF_FSIZE (variable) - input file size - -ida_ida.INF_GROUPS (variable) - segment group information (see init_groups()) - -ida_ida.INF_H_PATH (variable) - C header path. - -ida_ida.INF_IDA_VERSION (variable) - version of ida which created the database - -ida_ida.INF_IDSNODE (variable) - ids modnode id (for import_module) - -ida_ida.INF_IMAGEBASE (variable) - image base - -ida_ida.INF_INCLUDE (variable) - assembler include file name - -ida_ida.INF_INITIAL_VERSION (variable) - initial version of database - -ida_ida.INF_MD5 (variable) - MD5 of the input file. - -ida_ida.INF_NOPENS (variable) - how many times the database is opened - -ida_ida.INF_NOTEPAD (variable) - notepad blob, occupies 1000 indexes (1MB of text) - -ida_ida.INF_OUTFILEENC (variable) - output file encoding index - -ida_ida.INF_PROBLEMS (variable) - problem lists - -ida_ida.INF_SELECTORS (variable) - 2..63 are for selector_t blob (see init_selectors()) - -ida_ida.INF_SHA256 (variable) - SHA256 of the input file. - -ida_ida.INF_SRCDBG_PATHS (variable) - source debug paths, occupies 20 indexes - -ida_ida.INF_SRCDBG_UNDESIRED (variable) - user-closed source files, occupies 20 indexes - -ida_ida.INF_STR_ENCODINGS (variable) - a list of encodings for the program strings - -ida_ida.LFLG_64BIT (variable) - 64-bit program? - -ida_ida.LFLG_COMPRESS (variable) - compress the database? - -ida_ida.LFLG_DBG_NOPATH (variable) - do not store input full path in debugger process options - -ida_ida.LFLG_FLAT_OFF32 (variable) - treat REF_OFF32 as 32-bit offset for 16bit segments (otherwise try SEG16:OFF16) - -ida_ida.LFLG_IS_DLL (variable) - Is dynamic library? - -ida_ida.LFLG_KERNMODE (variable) - is kernel mode binary? - -ida_ida.LFLG_MSF (variable) - Byte order: is MSB first? - -ida_ida.LFLG_PACK (variable) - pack the database? - -ida_ida.LFLG_PC_FLAT (variable) - 32-bit program (or higher)? - -ida_ida.LFLG_PC_FPP (variable) - decode floating point processor instructions? - -ida_ida.LFLG_SNAPSHOT (variable) - memory snapshot was taken? - -ida_ida.LFLG_WIDE_HBF (variable) - Bit order of wide bytes: high byte first? (wide bytes: processor_t::dnbits > 8) - -ida_ida.LMT_EMPTY (variable) - empty lines at the end of basic blocks - -ida_ida.LMT_THICK (variable) - thick borders - -ida_ida.LMT_THIN (variable) - thin borders - -ida_ida.LN_AUTO (variable) - include autogenerated names - -ida_ida.LN_NORMAL (variable) - include normal names - -ida_ida.LN_PUBLIC (variable) - include public names - -ida_ida.LN_WEAK (variable) - include weak names - -ida_ida.OFLG_GEN_ASSUME (variable) - Generate 'assume' directives? - -ida_ida.OFLG_GEN_NULL (variable) - Generate empty lines? - -ida_ida.OFLG_GEN_ORG (variable) - Generate 'org' directives? - -ida_ida.OFLG_GEN_TRYBLKS (variable) - Generate try/catch directives? - -ida_ida.OFLG_LZERO (variable) - generate leading zeroes in numbers - -ida_ida.OFLG_PREF_SEG (variable) - line prefixes with segment name? - -ida_ida.OFLG_SHOW_AUTO (variable) - Display autoanalysis indicator? - -ida_ida.OFLG_SHOW_PREF (variable) - Show line prefixes? - -ida_ida.OFLG_SHOW_VOID (variable) - Display void marks? - -ida_ida.PREF_FNCOFF (variable) - show function offsets? - -ida_ida.PREF_PFXTRUNC (variable) - truncate instruction bytes if they would need more than 1 line - -ida_ida.PREF_SEGADR (variable) - show segment addresses? - -ida_ida.PREF_STACK (variable) - show stack pointer? - -ida_ida.SCF_ALLCMT (variable) - comment all lines? - -ida_ida.SCF_LINNUM (variable) - show source line numbers - -ida_ida.SCF_NOCMT (variable) - no comments at all - -ida_ida.SCF_RPTCMT (variable) - show repeatable comments? - -ida_ida.SCF_SHHID_FUNC (variable) - show hidden functions - -ida_ida.SCF_SHHID_ITEM (variable) - show hidden instructions - -ida_ida.SCF_SHHID_SEGM (variable) - show hidden segments - -ida_ida.SCF_TESTMODE (variable) - testida.idc is running - -ida_ida.STRF_AUTO (variable) - names have 'autogenerated' bit? - -ida_ida.STRF_COMMENT (variable) - generate auto comment for string references? - -ida_ida.STRF_GEN (variable) - generate names? - -ida_ida.STRF_SAVECASE (variable) - preserve case of strings for identifiers - -ida_ida.STRF_SERIAL (variable) - generate serial names? - -ida_ida.STRF_UNICODE (variable) - unicode strings are present? - -ida_ida.STT_CUR (variable) - use current storage type (may be used only as a function argument) - -ida_ida.STT_DBG (variable) - memory map: temporary debugger storage. used internally - -ida_ida.STT_MM (variable) - memory map: sparse storage. useful for huge objects - -ida_ida.STT_VA (variable) - regular storage: virtual arrays, an explicit flag for each byte - -ida_ida.SW_SEGXRF (variable) - show segments in xrefs? - -ida_ida.SW_XRFFNC (variable) - show function offsets? - -ida_ida.SW_XRFMRK (variable) - show xref type marks? - -ida_ida.SW_XRFVAL (variable) - show xref values? (otherwise-"...") - -ida_ida.UA_MAXOP (variable) - max number of operands allowed for an instruction - -ida_ida.VLD_AUTO_REPAIR (variable) - automatically repair the database - -ida_ida.VLD_DIALOG (variable) - ask user to repair (this bit is mutually exclusive with VLD_AUTO_REPAIR) - -ida_ida.VLD_SILENT (variable) - no messages to the output window - -ida_ida.__make_idainfo_accessors (function) - -ida_ida.__make_idainfo_bound (function) - -ida_ida.__make_idainfo_bound.__func (function) - -ida_ida.__make_idainfo_getter (function) - -ida_ida.__set_module_dynattrs (function) - -ida_ida.__wrap_hooks_callback (function) - -ida_ida.__wrap_hooks_callback.__wrapper (function) - -ida_ida.calc_default_idaplace_flags (function) - calc_default_idaplace_flags() -> int - Get default disassembly line options. - -ida_ida.compiler_info_t (class) - Proxy of C++ compiler_info_t class. - -ida_ida.compiler_info_t.__init__ (method) - __init__(self) -> compiler_info_t - -ida_ida.compiler_info_t.cm (variable) - memory model and calling convention (see CM) - -ida_ida.compiler_info_t.defalign (variable) - default alignment for structures - -ida_ida.compiler_info_t.id (variable) - compiler id (see Compiler IDs) - -ida_ida.compiler_info_t.size_b (variable) - sizeof(bool) - -ida_ida.compiler_info_t.size_e (variable) - sizeof(enum) - -ida_ida.compiler_info_t.size_i (variable) - sizeof(int) - -ida_ida.compiler_info_t.size_l (variable) - long - -ida_ida.compiler_info_t.size_ldbl (variable) - longdouble (if different from processor_t::tbyte_size) - -ida_ida.compiler_info_t.size_ll (variable) - longlong - -ida_ida.compiler_info_t.size_s (variable) - short - -ida_ida.delinf (function) - delinf(tag) -> bool - Undefine a program specific information - - @param tag: (C++: inftag_t) one of inftag_t constants - @return: success - -ida_ida.f_AIXAR (variable) - AIX ar library. - -ida_ida.f_AOUT (variable) - Linux a.out (AOUT) - -ida_ida.f_AR (variable) - ar library - -ida_ida.f_BIN (variable) - Binary File. - -ida_ida.f_COFF (variable) - Common Object File Format (COFF) - -ida_ida.f_COM (variable) - MS DOS COM File. - -ida_ida.f_COM_old (variable) - MS DOS COM File. - -ida_ida.f_DRV (variable) - MS DOS Driver. - -ida_ida.f_ELF (variable) - Executable and Linkable Format (ELF) - -ida_ida.f_EXE (variable) - MS DOS EXE File. - -ida_ida.f_EXE_old (variable) - MS DOS EXE File. - -ida_ida.f_HEX (variable) - Intel Hex Object File. - -ida_ida.f_LE (variable) - Linear Executable (LE) - -ida_ida.f_LOADER (variable) - file is loaded using LOADER DLL - -ida_ida.f_LX (variable) - Linear Executable (LX) - -ida_ida.f_MACHO (variable) - Mac OS X Mach-O. - -ida_ida.f_MEX (variable) - MOS Technology Hex Object File. - -ida_ida.f_NLM (variable) - Netware Loadable Module (NLM) - -ida_ida.f_OMF (variable) - Object Module Format. - -ida_ida.f_OMFLIB (variable) - Library of OMF Modules. - -ida_ida.f_PE (variable) - Portable Executable (PE) - -ida_ida.f_PRC (variable) - PalmPilot program file. - -ida_ida.f_PSXOBJ (variable) - Sony Playstation PSX object file. - -ida_ida.f_SREC (variable) - Motorola SREC (S-record) - -ida_ida.f_W32RUN (variable) - Watcom DOS32 Extender (W32RUN) - -ida_ida.f_WIN (variable) - New Executable (NE) - -ida_ida.f_ZIP (variable) - ZIP file (this file is never loaded to IDA database) - -ida_ida.get_dbctx_id (function) - get_dbctx_id() -> ssize_t - Get the current database context ID - - @return: the database context ID, or -1 if no current database - -ida_ida.get_dbctx_qty (function) - get_dbctx_qty() -> size_t - Get number of database contexts - - @return: number of database contexts - -ida_ida.getinf_str (function) - getinf_str(tag) -> str - Get program specific information (a non-scalar value) - - @param tag: (C++: inftag_t) one of inftag_t constants - @return: number of bytes stored in the buffer (<0 - not defined) - -ida_ida.idainfo (class) - Proxy of C++ idainfo class. - -ida_ida.idainfo.__init__ (method) - -ida_ida.idainfo._get_lflags (method) - _get_lflags(self) -> uint32 - -ida_ida.idainfo._set_lflags (method) - _set_lflags(self, _f) - - Parameters - ---------- - _f: uint32 - -ida_ida.idainfo.abibits (variable) - ABI features. Depends on info returned by get_abi_name() Processor modules may - modify them in set_compiler - -ida_ida.idainfo.af (variable) - Analysis flags - -ida_ida.idainfo.af2 (variable) - Analysis flags 2 - -ida_ida.idainfo.appcall_options (variable) - appcall options, see idd.hpp - -ida_ida.idainfo.apptype (variable) - Application type bit definitions in libfuncs.hpp - -ida_ida.idainfo.asmtype (variable) - target assembler number - -ida_ida.idainfo.baseaddr (variable) - remaining 28 bits are reserved - - base address of the program (paragraphs) - -ida_ida.idainfo.bin_prefix_size (variable) - Number of instruction bytes (opcodes) to show in line prefix. - -ida_ida.idainfo.cc (variable) - COMPILER. - - Target compiler - -ida_ida.idainfo.cmt_indent (variable) - Indentation for comments. - -ida_ida.idainfo.database_change_count (variable) - incremented after each byte and regular segment modifications - -ida_ida.idainfo.datatypes (variable) - data types allowed in data carousel - -ida_ida.idainfo.demnames (variable) - Demangled name flags - -ida_ida.idainfo.filetype (variable) - The input file type. - -ida_ida.idainfo.get_abiname (method) - get_abiname(self) -> qstring - -ida_ida.idainfo.highoff (variable) - High limit for offsets (used in calculation of 'void' operands) - -ida_ida.idainfo.indent (variable) - DISASSEMBLY LISTING DETAILS. - - Indentation for instructions - -ida_ida.idainfo.lenxref (variable) - max length of line with xrefs - -ida_ida.idainfo.lflags (variable) - Misc. database flags - -ida_ida.idainfo.listnames (variable) - Name list options - -ida_ida.idainfo.long_demnames (variable) - long form of demangled names see demangle.h for definitions - -ida_ida.idainfo.lowoff (variable) - Low limit for offsets (used in calculation of 'void' operands) - -ida_ida.idainfo.main (variable) - address of main() - -ida_ida.idainfo.margin (variable) - max length of data lines - -ida_ida.idainfo.max_autoname_len (variable) - NAMES. - - max autogenerated name length (without zero byte) - -ida_ida.idainfo.max_ea (variable) - maxEA is excluded - -ida_ida.idainfo.maxref (variable) - Max tail for references. - -ida_ida.idainfo.min_ea (variable) - current limits of program - -ida_ida.idainfo.nametype (variable) - Dummy names representation types - -ida_ida.idainfo.omax_ea (variable) - original maxEA (is set after loading the input file) - -ida_ida.idainfo.omin_ea (variable) - original minEA (is set after loading the input file) - -ida_ida.idainfo.ostype (variable) - OS type the program is for bit definitions in libfuncs.hpp - -ida_ida.idainfo.outflags (variable) - output flags - -ida_ida.idainfo.procname (variable) - Name of the current processor (with \0) - -ida_ida.idainfo.refcmtnum (variable) - Number of comment lines to generate for refs to string literals or demangled - names 0 - such comments won't be generated at all - -ida_ida.idainfo.s_cmtflg (variable) - Comment options - -ida_ida.idainfo.s_genflags (variable) - General idainfo flags - -ida_ida.idainfo.s_limiter (variable) - Delimiter options - -ida_ida.idainfo.s_prefflag (variable) - Line prefix options - -ida_ida.idainfo.s_xrefflag (variable) - Xref options - -ida_ida.idainfo.short_demnames (variable) - short form of demangled names - -ida_ida.idainfo.specsegs (variable) - What format do special segments use? 0-unspecified, 4-entries are 4 bytes, 8- - entries are 8 bytes. - -ida_ida.idainfo.start_cs (variable) - selector of the segment with the main entry point - -ida_ida.idainfo.start_ea (variable) - Linear address of program entry point. - -ida_ida.idainfo.start_ip (variable) - IP register value at the start of program execution - -ida_ida.idainfo.start_sp (variable) - SP register value at the start of program execution - -ida_ida.idainfo.start_ss (variable) - selector of the initial stack segment - -ida_ida.idainfo.strlit_break (variable) - string literal line break symbol - -ida_ida.idainfo.strlit_flags (variable) - STRING LITERALS. - - string literal flags - -ida_ida.idainfo.strlit_pref (variable) - prefix for string literal names - -ida_ida.idainfo.strlit_sernum (variable) - serial number - -ida_ida.idainfo.strlit_zeroes (variable) - leading zeroes - -ida_ida.idainfo.strtype (variable) - current ascii string type see nalt.hpp for string types - -ida_ida.idainfo.tag (variable) - 'IDA' - -ida_ida.idainfo.type_xrefnum (variable) - Number of references to generate in the struct & enum windows 0 - xrefs won't be - generated at all - -ida_ida.idainfo.version (variable) - Version of database. - -ida_ida.idainfo.xrefnum (variable) - CROSS REFERENCES. - - Number of references to generate in the disassembly listing 0 - xrefs won't be - generated at all - -ida_ida.idainfo_is_32bit (function) - -ida_ida.inf_abi_set_by_user (function) - inf_abi_set_by_user() -> bool - -ida_ida.inf_allow_non_matched_ops (function) - inf_allow_non_matched_ops() -> bool - -ida_ida.inf_allow_sigmulti (function) - inf_allow_sigmulti() -> bool - -ida_ida.inf_append_sigcmt (function) - inf_append_sigcmt() -> bool - -ida_ida.inf_big_arg_align (function) - inf_big_arg_align(cc) -> bool - - @param cc: cm_t - - inf_big_arg_align() -> bool - -ida_ida.inf_check_manual_ops (function) - inf_check_manual_ops() -> bool - -ida_ida.inf_check_unicode_strlits (function) - inf_check_unicode_strlits() -> bool - -ida_ida.inf_coagulate_code (function) - inf_coagulate_code() -> bool - -ida_ida.inf_coagulate_data (function) - inf_coagulate_data() -> bool - -ida_ida.inf_compress_idb (function) - inf_compress_idb() -> bool - -ida_ida.inf_create_all_xrefs (function) - inf_create_all_xrefs() -> bool - -ida_ida.inf_create_func_from_call (function) - inf_create_func_from_call() -> bool - -ida_ida.inf_create_func_from_ptr (function) - inf_create_func_from_ptr() -> bool - -ida_ida.inf_create_func_tails (function) - inf_create_func_tails() -> bool - -ida_ida.inf_create_jump_tables (function) - inf_create_jump_tables() -> bool - -ida_ida.inf_create_off_on_dref (function) - inf_create_off_on_dref() -> bool - -ida_ida.inf_create_off_using_fixup (function) - inf_create_off_using_fixup() -> bool - -ida_ida.inf_create_strlit_on_xref (function) - inf_create_strlit_on_xref() -> bool - -ida_ida.inf_data_offset (function) - inf_data_offset() -> bool - -ida_ida.inf_dbg_no_store_path (function) - inf_dbg_no_store_path() -> bool - -ida_ida.inf_decode_fpp (function) - inf_decode_fpp() -> bool - -ida_ida.inf_del_no_xref_insns (function) - inf_del_no_xref_insns() -> bool - -ida_ida.inf_final_pass (function) - inf_final_pass() -> bool - -ida_ida.inf_full_sp_ana (function) - inf_full_sp_ana() -> bool - -ida_ida.inf_gen_assume (function) - inf_gen_assume() -> bool - -ida_ida.inf_gen_lzero (function) - inf_gen_lzero() -> bool - -ida_ida.inf_gen_null (function) - inf_gen_null() -> bool - -ida_ida.inf_gen_org (function) - inf_gen_org() -> bool - -ida_ida.inf_gen_tryblks (function) - inf_gen_tryblks() -> bool - -ida_ida.inf_get_abibits (function) - inf_get_abibits() -> uint32 - -ida_ida.inf_get_af (function) - inf_get_af() -> uint32 - -ida_ida.inf_get_af2 (function) - inf_get_af2() -> uint32 - -ida_ida.inf_get_af2_low (function) - inf_get_af2_low() -> ushort - Get/set low 16bit half of inf.af2. - -ida_ida.inf_get_af_high (function) - inf_get_af_high() -> ushort - -ida_ida.inf_get_af_low (function) - inf_get_af_low() -> ushort - Get/set low/high 16bit halves of inf.af. - -ida_ida.inf_get_app_bitness (function) - inf_get_app_bitness() -> uint - -ida_ida.inf_get_appcall_options (function) - inf_get_appcall_options() -> uint32 - -ida_ida.inf_get_apptype (function) - inf_get_apptype() -> ushort - -ida_ida.inf_get_asmtype (function) - inf_get_asmtype() -> uchar - -ida_ida.inf_get_baseaddr (function) - inf_get_baseaddr() -> uval_t - -ida_ida.inf_get_bin_prefix_size (function) - inf_get_bin_prefix_size() -> short - -ida_ida.inf_get_cc (function) - inf_get_cc(out) -> bool - - @param out: compiler_info_t * - -ida_ida.inf_get_cc_cm (function) - inf_get_cc_cm() -> cm_t - -ida_ida.inf_get_cc_defalign (function) - inf_get_cc_defalign() -> uchar - -ida_ida.inf_get_cc_id (function) - inf_get_cc_id() -> comp_t - -ida_ida.inf_get_cc_size_b (function) - inf_get_cc_size_b() -> uchar - -ida_ida.inf_get_cc_size_e (function) - inf_get_cc_size_e() -> uchar - -ida_ida.inf_get_cc_size_i (function) - inf_get_cc_size_i() -> uchar - -ida_ida.inf_get_cc_size_l (function) - inf_get_cc_size_l() -> uchar - -ida_ida.inf_get_cc_size_ldbl (function) - inf_get_cc_size_ldbl() -> uchar - -ida_ida.inf_get_cc_size_ll (function) - inf_get_cc_size_ll() -> uchar - -ida_ida.inf_get_cc_size_s (function) - inf_get_cc_size_s() -> uchar - -ida_ida.inf_get_cmt_indent (function) - inf_get_cmt_indent() -> uchar - -ida_ida.inf_get_cmtflg (function) - inf_get_cmtflg() -> uchar - -ida_ida.inf_get_database_change_count (function) - inf_get_database_change_count() -> uint32 - -ida_ida.inf_get_datatypes (function) - inf_get_datatypes() -> uval_t - -ida_ida.inf_get_demname_form (function) - inf_get_demname_form() -> uchar - Get DEMNAM_MASK bits of #demnames. - -ida_ida.inf_get_demnames (function) - inf_get_demnames() -> uchar - -ida_ida.inf_get_filetype (function) - inf_get_filetype() -> filetype_t - -ida_ida.inf_get_genflags (function) - inf_get_genflags() -> ushort - -ida_ida.inf_get_highoff (function) - inf_get_highoff() -> ea_t - -ida_ida.inf_get_indent (function) - inf_get_indent() -> uchar - -ida_ida.inf_get_lenxref (function) - inf_get_lenxref() -> ushort - -ida_ida.inf_get_lflags (function) - inf_get_lflags() -> uint32 - -ida_ida.inf_get_limiter (function) - inf_get_limiter() -> uchar - -ida_ida.inf_get_listnames (function) - inf_get_listnames() -> uchar - -ida_ida.inf_get_long_demnames (function) - inf_get_long_demnames() -> uint32 - -ida_ida.inf_get_lowoff (function) - inf_get_lowoff() -> ea_t - -ida_ida.inf_get_main (function) - inf_get_main() -> ea_t - -ida_ida.inf_get_margin (function) - inf_get_margin() -> ushort - -ida_ida.inf_get_max_autoname_len (function) - inf_get_max_autoname_len() -> ushort - -ida_ida.inf_get_max_ea (function) - inf_get_max_ea() -> ea_t - -ida_ida.inf_get_maxref (function) - inf_get_maxref() -> uval_t - -ida_ida.inf_get_min_ea (function) - inf_get_min_ea() -> ea_t - -ida_ida.inf_get_nametype (function) - inf_get_nametype() -> char - -ida_ida.inf_get_netdelta (function) - inf_get_netdelta() -> sval_t - -ida_ida.inf_get_omax_ea (function) - inf_get_omax_ea() -> ea_t - -ida_ida.inf_get_omin_ea (function) - inf_get_omin_ea() -> ea_t - -ida_ida.inf_get_ostype (function) - inf_get_ostype() -> ushort - -ida_ida.inf_get_outflags (function) - inf_get_outflags() -> uint32 - -ida_ida.inf_get_pack_mode (function) - inf_get_pack_mode() -> int - -ida_ida.inf_get_prefflag (function) - inf_get_prefflag() -> uchar - -ida_ida.inf_get_privrange (function) - inf_get_privrange(out) -> bool - - @param out: range_t * - - inf_get_privrange() -> range_t - -ida_ida.inf_get_privrange_end_ea (function) - inf_get_privrange_end_ea() -> ea_t - -ida_ida.inf_get_privrange_start_ea (function) - inf_get_privrange_start_ea() -> ea_t - -ida_ida.inf_get_procname (function) - inf_get_procname() -> str - -ida_ida.inf_get_refcmtnum (function) - inf_get_refcmtnum() -> uchar - -ida_ida.inf_get_short_demnames (function) - inf_get_short_demnames() -> uint32 - -ida_ida.inf_get_specsegs (function) - inf_get_specsegs() -> uchar - -ida_ida.inf_get_start_cs (function) - inf_get_start_cs() -> sel_t - -ida_ida.inf_get_start_ea (function) - inf_get_start_ea() -> ea_t - -ida_ida.inf_get_start_ip (function) - inf_get_start_ip() -> ea_t - -ida_ida.inf_get_start_sp (function) - inf_get_start_sp() -> ea_t - -ida_ida.inf_get_start_ss (function) - inf_get_start_ss() -> sel_t - -ida_ida.inf_get_strlit_break (function) - inf_get_strlit_break() -> uchar - -ida_ida.inf_get_strlit_flags (function) - inf_get_strlit_flags() -> uchar - -ida_ida.inf_get_strlit_pref (function) - inf_get_strlit_pref() -> str - -ida_ida.inf_get_strlit_sernum (function) - inf_get_strlit_sernum() -> uval_t - -ida_ida.inf_get_strlit_zeroes (function) - inf_get_strlit_zeroes() -> char - -ida_ida.inf_get_strtype (function) - inf_get_strtype() -> int32 - -ida_ida.inf_get_type_xrefnum (function) - inf_get_type_xrefnum() -> uchar - -ida_ida.inf_get_version (function) - inf_get_version() -> ushort - -ida_ida.inf_get_xrefflag (function) - inf_get_xrefflag() -> uchar - -ida_ida.inf_get_xrefnum (function) - inf_get_xrefnum() -> uchar - -ida_ida.inf_guess_func_type (function) - inf_guess_func_type() -> bool - -ida_ida.inf_handle_eh (function) - inf_handle_eh() -> bool - -ida_ida.inf_handle_rtti (function) - inf_handle_rtti() -> bool - -ida_ida.inf_hide_comments (function) - inf_hide_comments() -> bool - -ida_ida.inf_hide_libfuncs (function) - inf_hide_libfuncs() -> bool - -ida_ida.inf_huge_arg_align (function) - inf_huge_arg_align(cc) -> bool - - @param cc: cm_t - - inf_huge_arg_align() -> bool - -ida_ida.inf_inc_database_change_count (function) - inf_inc_database_change_count(cnt=1) - - @param cnt: int - -ida_ida.inf_is_16bit (function) - inf_is_16bit() -> bool - -ida_ida.inf_is_32bit_exactly (function) - inf_is_32bit_exactly() -> bool - -ida_ida.inf_is_32bit_or_higher (function) - inf_is_32bit_or_higher() -> bool - -ida_ida.inf_is_64bit (function) - inf_is_64bit() -> bool - -ida_ida.inf_is_auto_enabled (function) - inf_is_auto_enabled() -> bool - -ida_ida.inf_is_be (function) - inf_is_be() -> bool - -ida_ida.inf_is_dll (function) - inf_is_dll() -> bool - -ida_ida.inf_is_flat_off32 (function) - inf_is_flat_off32() -> bool - -ida_ida.inf_is_graph_view (function) - inf_is_graph_view() -> bool - -ida_ida.inf_is_hard_float (function) - inf_is_hard_float() -> bool - -ida_ida.inf_is_kernel_mode (function) - inf_is_kernel_mode() -> bool - -ida_ida.inf_is_limiter_empty (function) - inf_is_limiter_empty() -> bool - -ida_ida.inf_is_limiter_thick (function) - inf_is_limiter_thick() -> bool - -ida_ida.inf_is_limiter_thin (function) - inf_is_limiter_thin() -> bool - -ida_ida.inf_is_mem_aligned4 (function) - inf_is_mem_aligned4() -> bool - -ida_ida.inf_is_snapshot (function) - inf_is_snapshot() -> bool - -ida_ida.inf_is_wide_high_byte_first (function) - inf_is_wide_high_byte_first() -> bool - -ida_ida.inf_like_binary (function) - inf_like_binary() -> bool - -ida_ida.inf_line_pref_with_seg (function) - inf_line_pref_with_seg() -> bool - -ida_ida.inf_loading_idc (function) - inf_loading_idc() -> bool - -ida_ida.inf_macros_enabled (function) - inf_macros_enabled() -> bool - -ida_ida.inf_map_stkargs (function) - inf_map_stkargs() -> bool - -ida_ida.inf_mark_code (function) - inf_mark_code() -> bool - -ida_ida.inf_merge_strlits (function) - inf_merge_strlits() -> bool - -ida_ida.inf_no_store_user_info (function) - inf_no_store_user_info() -> bool - -ida_ida.inf_noflow_to_data (function) - inf_noflow_to_data() -> bool - -ida_ida.inf_noret_ana (function) - inf_noret_ana() -> bool - -ida_ida.inf_op_offset (function) - inf_op_offset() -> bool - -ida_ida.inf_pack_idb (function) - inf_pack_idb() -> bool - -ida_ida.inf_pack_stkargs (function) - inf_pack_stkargs(cc) -> bool - - @param cc: cm_t - - inf_pack_stkargs() -> bool - -ida_ida.inf_postinc_strlit_sernum (function) - inf_postinc_strlit_sernum(cnt=1) -> uval_t - - @param cnt: uval_t - -ida_ida.inf_prefix_show_funcoff (function) - inf_prefix_show_funcoff() -> bool - -ida_ida.inf_prefix_show_segaddr (function) - inf_prefix_show_segaddr() -> bool - -ida_ida.inf_prefix_show_stack (function) - inf_prefix_show_stack() -> bool - -ida_ida.inf_prefix_truncate_opcode_bytes (function) - inf_prefix_truncate_opcode_bytes() -> bool - -ida_ida.inf_propagate_regargs (function) - inf_propagate_regargs() -> bool - -ida_ida.inf_propagate_stkargs (function) - inf_propagate_stkargs() -> bool - -ida_ida.inf_readonly_idb (function) - inf_readonly_idb() -> bool - -ida_ida.inf_rename_jumpfunc (function) - inf_rename_jumpfunc() -> bool - -ida_ida.inf_rename_nullsub (function) - inf_rename_nullsub() -> bool - -ida_ida.inf_set_32bit (function) - inf_set_32bit(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_64bit (function) - inf_set_64bit(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_abi_set_by_user (function) - inf_set_abi_set_by_user(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_abibits (function) - inf_set_abibits(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_af (function) - inf_set_af(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_af2 (function) - inf_set_af2(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_af2_low (function) - inf_set_af2_low(saf) - - @param saf: ushort - -ida_ida.inf_set_af_high (function) - inf_set_af_high(saf2) - - @param saf2: ushort - -ida_ida.inf_set_af_low (function) - inf_set_af_low(saf) - - @param saf: ushort - -ida_ida.inf_set_allow_non_matched_ops (function) - inf_set_allow_non_matched_ops(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_allow_sigmulti (function) - inf_set_allow_sigmulti(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_app_bitness (function) - inf_set_app_bitness(bitness) - - @param bitness: uint - -ida_ida.inf_set_appcall_options (function) - inf_set_appcall_options(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_append_sigcmt (function) - inf_set_append_sigcmt(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_apptype (function) - inf_set_apptype(_v) -> bool - - @param _v: ushort - -ida_ida.inf_set_asmtype (function) - inf_set_asmtype(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_auto_enabled (function) - inf_set_auto_enabled(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_baseaddr (function) - inf_set_baseaddr(_v) -> bool - - @param _v: uval_t - -ida_ida.inf_set_be (function) - inf_set_be(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_big_arg_align (function) - inf_set_big_arg_align(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_bin_prefix_size (function) - inf_set_bin_prefix_size(_v) -> bool - - @param _v: short - -ida_ida.inf_set_cc (function) - inf_set_cc(_v) -> bool - - @param _v: compiler_info_t const & - -ida_ida.inf_set_cc_cm (function) - inf_set_cc_cm(_v) -> bool - - @param _v: cm_t - -ida_ida.inf_set_cc_defalign (function) - inf_set_cc_defalign(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cc_id (function) - inf_set_cc_id(_v) -> bool - - @param _v: comp_t - -ida_ida.inf_set_cc_size_b (function) - inf_set_cc_size_b(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cc_size_e (function) - inf_set_cc_size_e(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cc_size_i (function) - inf_set_cc_size_i(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cc_size_l (function) - inf_set_cc_size_l(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cc_size_ldbl (function) - inf_set_cc_size_ldbl(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cc_size_ll (function) - inf_set_cc_size_ll(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cc_size_s (function) - inf_set_cc_size_s(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_check_manual_ops (function) - inf_set_check_manual_ops(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_check_unicode_strlits (function) - inf_set_check_unicode_strlits(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_cmt_indent (function) - inf_set_cmt_indent(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_cmtflg (function) - inf_set_cmtflg(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_coagulate_code (function) - inf_set_coagulate_code(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_coagulate_data (function) - inf_set_coagulate_data(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_compress_idb (function) - inf_set_compress_idb(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_all_xrefs (function) - inf_set_create_all_xrefs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_func_from_call (function) - inf_set_create_func_from_call(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_func_from_ptr (function) - inf_set_create_func_from_ptr(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_func_tails (function) - inf_set_create_func_tails(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_jump_tables (function) - inf_set_create_jump_tables(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_off_on_dref (function) - inf_set_create_off_on_dref(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_off_using_fixup (function) - inf_set_create_off_using_fixup(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_create_strlit_on_xref (function) - inf_set_create_strlit_on_xref(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_data_offset (function) - inf_set_data_offset(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_database_change_count (function) - inf_set_database_change_count(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_datatypes (function) - inf_set_datatypes(_v) -> bool - - @param _v: uval_t - -ida_ida.inf_set_dbg_no_store_path (function) - inf_set_dbg_no_store_path(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_decode_fpp (function) - inf_set_decode_fpp(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_del_no_xref_insns (function) - inf_set_del_no_xref_insns(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_demnames (function) - inf_set_demnames(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_dll (function) - inf_set_dll(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_filetype (function) - inf_set_filetype(_v) -> bool - - @param _v: enum filetype_t - -ida_ida.inf_set_final_pass (function) - inf_set_final_pass(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_flat_off32 (function) - inf_set_flat_off32(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_full_sp_ana (function) - inf_set_full_sp_ana(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_gen_assume (function) - inf_set_gen_assume(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_gen_lzero (function) - inf_set_gen_lzero(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_gen_null (function) - inf_set_gen_null(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_gen_org (function) - inf_set_gen_org(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_gen_tryblks (function) - inf_set_gen_tryblks(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_genflags (function) - inf_set_genflags(_v) -> bool - - @param _v: ushort - -ida_ida.inf_set_graph_view (function) - inf_set_graph_view(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_guess_func_type (function) - inf_set_guess_func_type(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_handle_eh (function) - inf_set_handle_eh(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_handle_rtti (function) - inf_set_handle_rtti(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_hard_float (function) - inf_set_hard_float(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_hide_comments (function) - inf_set_hide_comments(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_hide_libfuncs (function) - inf_set_hide_libfuncs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_highoff (function) - inf_set_highoff(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_huge_arg_align (function) - inf_set_huge_arg_align(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_indent (function) - inf_set_indent(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_kernel_mode (function) - inf_set_kernel_mode(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_lenxref (function) - inf_set_lenxref(_v) -> bool - - @param _v: ushort - -ida_ida.inf_set_lflags (function) - inf_set_lflags(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_limiter (function) - inf_set_limiter(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_limiter_empty (function) - inf_set_limiter_empty(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_limiter_thick (function) - inf_set_limiter_thick(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_limiter_thin (function) - inf_set_limiter_thin(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_line_pref_with_seg (function) - inf_set_line_pref_with_seg(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_listnames (function) - inf_set_listnames(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_loading_idc (function) - inf_set_loading_idc(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_long_demnames (function) - inf_set_long_demnames(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_lowoff (function) - inf_set_lowoff(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_macros_enabled (function) - inf_set_macros_enabled(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_main (function) - inf_set_main(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_map_stkargs (function) - inf_set_map_stkargs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_margin (function) - inf_set_margin(_v) -> bool - - @param _v: ushort - -ida_ida.inf_set_mark_code (function) - inf_set_mark_code(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_max_autoname_len (function) - inf_set_max_autoname_len(_v) -> bool - - @param _v: ushort - -ida_ida.inf_set_max_ea (function) - inf_set_max_ea(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_maxref (function) - inf_set_maxref(_v) -> bool - - @param _v: uval_t - -ida_ida.inf_set_mem_aligned4 (function) - inf_set_mem_aligned4(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_merge_strlits (function) - inf_set_merge_strlits(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_min_ea (function) - inf_set_min_ea(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_nametype (function) - inf_set_nametype(_v) -> bool - - @param _v: char - -ida_ida.inf_set_netdelta (function) - inf_set_netdelta(_v) -> bool - - @param _v: sval_t - -ida_ida.inf_set_no_store_user_info (function) - inf_set_no_store_user_info(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_noflow_to_data (function) - inf_set_noflow_to_data(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_noret_ana (function) - inf_set_noret_ana(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_omax_ea (function) - inf_set_omax_ea(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_omin_ea (function) - inf_set_omin_ea(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_op_offset (function) - inf_set_op_offset(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_ostype (function) - inf_set_ostype(_v) -> bool - - @param _v: ushort - -ida_ida.inf_set_outflags (function) - inf_set_outflags(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_pack_idb (function) - inf_set_pack_idb(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_pack_mode (function) - inf_set_pack_mode(pack_mode) -> int - - @param pack_mode: int - -ida_ida.inf_set_pack_stkargs (function) - inf_set_pack_stkargs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_prefflag (function) - inf_set_prefflag(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_prefix_show_funcoff (function) - inf_set_prefix_show_funcoff(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_prefix_show_segaddr (function) - inf_set_prefix_show_segaddr(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_prefix_show_stack (function) - inf_set_prefix_show_stack(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_prefix_truncate_opcode_bytes (function) - inf_set_prefix_truncate_opcode_bytes(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_privrange (function) - inf_set_privrange(_v) -> bool - - @param _v: range_t const & - -ida_ida.inf_set_privrange_end_ea (function) - inf_set_privrange_end_ea(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_privrange_start_ea (function) - inf_set_privrange_start_ea(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_procname (function) - inf_set_procname(_v, len=size_t(-1)) -> bool - - @param _v: char const * - @param len: size_t - -ida_ida.inf_set_propagate_regargs (function) - inf_set_propagate_regargs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_propagate_stkargs (function) - inf_set_propagate_stkargs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_readonly_idb (function) - inf_set_readonly_idb(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_refcmtnum (function) - inf_set_refcmtnum(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_rename_jumpfunc (function) - inf_set_rename_jumpfunc(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_rename_nullsub (function) - inf_set_rename_nullsub(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_short_demnames (function) - inf_set_short_demnames(_v) -> bool - - @param _v: uint32 - -ida_ida.inf_set_should_create_stkvars (function) - inf_set_should_create_stkvars(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_should_trace_sp (function) - inf_set_should_trace_sp(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_all_comments (function) - inf_set_show_all_comments(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_auto (function) - inf_set_show_auto(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_hidden_funcs (function) - inf_set_show_hidden_funcs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_hidden_insns (function) - inf_set_show_hidden_insns(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_hidden_segms (function) - inf_set_show_hidden_segms(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_line_pref (function) - inf_set_show_line_pref(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_repeatables (function) - inf_set_show_repeatables(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_src_linnum (function) - inf_set_show_src_linnum(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_void (function) - inf_set_show_void(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_xref_fncoff (function) - inf_set_show_xref_fncoff(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_xref_seg (function) - inf_set_show_xref_seg(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_xref_tmarks (function) - inf_set_show_xref_tmarks(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_show_xref_val (function) - inf_set_show_xref_val(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_snapshot (function) - inf_set_snapshot(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_specsegs (function) - inf_set_specsegs(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_stack_ldbl (function) - inf_set_stack_ldbl(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_stack_varargs (function) - inf_set_stack_varargs(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_start_cs (function) - inf_set_start_cs(_v) -> bool - - @param _v: sel_t - -ida_ida.inf_set_start_ea (function) - inf_set_start_ea(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_start_ip (function) - inf_set_start_ip(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_start_sp (function) - inf_set_start_sp(_v) -> bool - - @param _v: ea_t - -ida_ida.inf_set_start_ss (function) - inf_set_start_ss(_v) -> bool - - @param _v: sel_t - -ida_ida.inf_set_strlit_autocmt (function) - inf_set_strlit_autocmt(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_strlit_break (function) - inf_set_strlit_break(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_strlit_flags (function) - inf_set_strlit_flags(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_strlit_name_bit (function) - inf_set_strlit_name_bit(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_strlit_names (function) - inf_set_strlit_names(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_strlit_pref (function) - inf_set_strlit_pref(_v, len=size_t(-1)) -> bool - - @param _v: char const * - @param len: size_t - -ida_ida.inf_set_strlit_savecase (function) - inf_set_strlit_savecase(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_strlit_serial_names (function) - inf_set_strlit_serial_names(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_strlit_sernum (function) - inf_set_strlit_sernum(_v) -> bool - - @param _v: uval_t - -ida_ida.inf_set_strlit_zeroes (function) - inf_set_strlit_zeroes(_v) -> bool - - @param _v: char - -ida_ida.inf_set_strtype (function) - inf_set_strtype(_v) -> bool - - @param _v: int32 - -ida_ida.inf_set_trace_flow (function) - inf_set_trace_flow(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_truncate_on_del (function) - inf_set_truncate_on_del(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_type_xrefnum (function) - inf_set_type_xrefnum(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_unicode_strlits (function) - inf_set_unicode_strlits(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_use_allasm (function) - inf_set_use_allasm(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_use_flirt (function) - inf_set_use_flirt(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_use_gcc_layout (function) - inf_set_use_gcc_layout(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_version (function) - inf_set_version(_v) -> bool - - @param _v: ushort - -ida_ida.inf_set_wide_high_byte_first (function) - inf_set_wide_high_byte_first(_v=True) -> bool - - @param _v: bool - -ida_ida.inf_set_xrefflag (function) - inf_set_xrefflag(_v) -> bool - - @param _v: uchar - -ida_ida.inf_set_xrefnum (function) - inf_set_xrefnum(_v) -> bool - - @param _v: uchar - -ida_ida.inf_should_create_stkvars (function) - inf_should_create_stkvars() -> bool - -ida_ida.inf_should_trace_sp (function) - inf_should_trace_sp() -> bool - -ida_ida.inf_show_all_comments (function) - inf_show_all_comments() -> bool - -ida_ida.inf_show_auto (function) - inf_show_auto() -> bool - -ida_ida.inf_show_hidden_funcs (function) - inf_show_hidden_funcs() -> bool - -ida_ida.inf_show_hidden_insns (function) - inf_show_hidden_insns() -> bool - -ida_ida.inf_show_hidden_segms (function) - inf_show_hidden_segms() -> bool - -ida_ida.inf_show_line_pref (function) - inf_show_line_pref() -> bool - -ida_ida.inf_show_repeatables (function) - inf_show_repeatables() -> bool - -ida_ida.inf_show_src_linnum (function) - inf_show_src_linnum() -> bool - -ida_ida.inf_show_void (function) - inf_show_void() -> bool - -ida_ida.inf_show_xref_fncoff (function) - inf_show_xref_fncoff() -> bool - -ida_ida.inf_show_xref_seg (function) - inf_show_xref_seg() -> bool - -ida_ida.inf_show_xref_tmarks (function) - inf_show_xref_tmarks() -> bool - -ida_ida.inf_show_xref_val (function) - inf_show_xref_val() -> bool - -ida_ida.inf_stack_ldbl (function) - inf_stack_ldbl() -> bool - -ida_ida.inf_stack_varargs (function) - inf_stack_varargs() -> bool - -ida_ida.inf_strlit_autocmt (function) - inf_strlit_autocmt() -> bool - -ida_ida.inf_strlit_name_bit (function) - inf_strlit_name_bit() -> bool - -ida_ida.inf_strlit_names (function) - inf_strlit_names() -> bool - -ida_ida.inf_strlit_savecase (function) - inf_strlit_savecase() -> bool - -ida_ida.inf_strlit_serial_names (function) - inf_strlit_serial_names() -> bool - -ida_ida.inf_test_mode (function) - inf_test_mode() -> bool - -ida_ida.inf_trace_flow (function) - inf_trace_flow() -> bool - -ida_ida.inf_truncate_on_del (function) - inf_truncate_on_del() -> bool - -ida_ida.inf_unicode_strlits (function) - inf_unicode_strlits() -> bool - -ida_ida.inf_use_allasm (function) - inf_use_allasm() -> bool - -ida_ida.inf_use_flirt (function) - inf_use_flirt() -> bool - -ida_ida.inf_use_gcc_layout (function) - inf_use_gcc_layout() -> bool - -ida_ida.is_database_busy (function) - is_database_busy() -> bool - Check if the database is busy (e.g. performing some critical operations and - cannot be safely accessed) - -ida_ida.is_filetype_like_binary (function) - is_filetype_like_binary(ft) -> bool - Is unstructured input file? - - @param ft: (C++: filetype_t) enum filetype_t - -ida_ida.move_privrange (function) - move_privrange(new_privrange_start) -> bool - Move privrange to the specified address - - @param new_privrange_start: (C++: ea_t) new start address of the privrange - @return: success - -ida_ida.switch_dbctx (function) - switch_dbctx(idx) -> dbctx_t * - Switch to the database with the provided context ID - - @param idx: (C++: size_t) the index of the database to switch to - @return: the current dbctx_t instance or nullptr - -ida_ida.to_ea (function) - to_ea(reg_cs, reg_ip) -> ea_t - Convert (sel,off) value to a linear address. - - @param reg_cs: (C++: sel_t) - @param reg_ip: (C++: uval_t) - -ida_ida.validate_idb (function) - validate_idb(vld_flags=0) -> size_t - Validate the database - - @param vld_flags: (C++: uint32) combination of VLD_.. constants - @return: number of corrupted/fixed records - -ida_idaapi (module) - -ida_idaapi.IDAPython_ExecScript (function) - Run the specified script. - - This function is used by the low-level plugin code. - -ida_idaapi.IDAPython_ExecSystem (function) - Executes a command with popen(). - -ida_idaapi.IDAPython_FormatExc (function) - This function is used to format an exception given the - values returned by a PyErr_Fetch() - -ida_idaapi.IDAPython_LoadProcMod (function) - Load processor module. - -ida_idaapi.IDAPython_UnLoadProcMod (function) - Unload processor module. - -ida_idaapi.IDAPython_displayhook (class) - -ida_idaapi.IDAPython_displayhook.__init__ (method) - -ida_idaapi.IDAPython_displayhook._print_hex (method) - -ida_idaapi.IDAPython_displayhook.displayhook (method) - -ida_idaapi.IDAPython_displayhook.format_item (method) - -ida_idaapi.IDAPython_displayhook.format_seq (method) - -ida_idaapi.NW_CLOSEIDB (variable) - Notify when the database is closed. Its callback is of the form: def notify_when_callback(nw_code) - -ida_idaapi.NW_INITIDA (variable) - Notify when the IDA starts. Its callback is of the form: def notify_when_callback(nw_code) - -ida_idaapi.NW_OPENIDB (variable) - Notify when the database is opened. Its callback is of the form: def notify_when_callback(nw_code, is_old_database) - -ida_idaapi.NW_REMOVE (variable) - Use this flag with other flags to uninstall a notifywhen callback - -ida_idaapi.NW_TERMIDA (variable) - Notify when the IDA terminates. Its callback is of the form: def notify_when_callback(nw_code) - -ida_idaapi.PY_ICID_BYREF (variable) - byref object - -ida_idaapi.PY_ICID_INT64 (variable) - int64 object - -ida_idaapi.PY_ICID_OPAQUE (variable) - opaque object - -ida_idaapi.PyIdc_cvt_int64__ (class) - Helper class for explicitly representing VT_INT64 values - -ida_idaapi.PyIdc_cvt_int64__.__add__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__div__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__init__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__mul__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__op (method) - -ida_idaapi.PyIdc_cvt_int64__.__radd__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__rdiv__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__rmul__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__rsub__ (method) - -ida_idaapi.PyIdc_cvt_int64__.__sub__ (method) - -ida_idaapi.PyIdc_cvt_refclass__ (class) - Helper class for representing references to immutable objects - -ida_idaapi.PyIdc_cvt_refclass__.__init__ (method) - -ida_idaapi.PyIdc_cvt_refclass__.cstr (method) - Returns the string as a C string (up to the zero termination) - -ida_idaapi.ST_OVER_DEBUG_SEG (variable) - step tracing will be disabled when IP is in a debugger segment - -ida_idaapi.ST_OVER_LIB_FUNC (variable) - step tracing will be disabled when IP is in a library function - -ida_idaapi.TRUNC (function) - Truncate EA for the current application bitness - -ida_idaapi.__IDAPython_Completion_Util (class) - Internal utility class for auto-completion support - -ida_idaapi.__IDAPython_Completion_Util.__call__ (method) - -ida_idaapi.__IDAPython_Completion_Util.__init__ (method) - -ida_idaapi.__IDAPython_Completion_Util.debug (method) - -ida_idaapi.__IDAPython_Completion_Util.dir_namespace (method) - -ida_idaapi.__IDAPython_Completion_Util.get_candidates (method) - -ida_idaapi.__IDAPython_Completion_Util.maybe_extend_syntactically (method) - -ida_idaapi.__install_excepthook (function) - -ida_idaapi._bounded_getitem_iterator (function) - Helper function, to be set as __iter__ method for qvector-, or array-based classes. - -ida_idaapi._listify_types (function) - -ida_idaapi._make_missed_695bwcompat_property (function) - -ida_idaapi._make_missed_695bwcompat_property._getter (function) - -ida_idaapi._make_missed_695bwcompat_property._setter (function) - -ida_idaapi._make_one_time_warning_message (function) - -ida_idaapi._make_one_time_warning_message.f (function) - -ida_idaapi._qvector_back (function) - -ida_idaapi._qvector_front (function) - -ida_idaapi._replace_module_function (function) - -ida_idaapi.as_UTF16 (function) - Convenience function to convert a string into appropriate unicode format - -ida_idaapi.as_cstr (function) - Returns a C str from the passed value. The passed value can be of type refclass (returned by a call to buffer() or byref()) - It scans for the first \x00 and returns the string value up to that point. - -ida_idaapi.as_int32 (function) - Returns a number as a signed int32 number - -ida_idaapi.as_signed (function) - Returns a number as signed. The number of bits are specified by the user. - The MSB holds the sign. - -ida_idaapi.as_uint32 (function) - Returns a number as an unsigned int32 number - -ida_idaapi.copy_bits (function) - Copy bits from a value - @param v: the value - @param s: starting bit (0-based) - @param e: ending bit - -ida_idaapi.disable_script_timeout (function) - 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 - -ida_idaapi.enable_extlang_python (function) - 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 - -ida_idaapi.enable_python_cli (function) - enable_python_cli(enable) - - @param enable: bool - -ida_idaapi.format_basestring (function) - format_basestring(_in) -> str - - @param _in: PyObject * - -ida_idaapi.get_inf_structure (function) - get_inf_structure() -> idainfo - Returns the global variable 'inf' (an instance of idainfo structure, see ida.hpp) - -ida_idaapi.loader_input_t (class) - A helper class to work with linput_t related functions. - This class is also used by file loaders scripts. - -ida_idaapi.loader_input_t.__init__ (method) - __init__(self, pycapsule=None) -> loader_input_t - - @param pycapsule: PyObject * - -ida_idaapi.loader_input_t.close (method) - close(self) - Closes the file - -ida_idaapi.loader_input_t.file2base (method) - 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 pos: position in the file - @param ea1: ..ea2): range of destination linear addresses - @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 - -ida_idaapi.loader_input_t.filename (method) - filename(self) -> PyObject * - -ida_idaapi.loader_input_t.from_capsule (method) - from_capsule(pycapsule) -> loader_input_t - - @param pycapsule: PyObject * - -ida_idaapi.loader_input_t.from_fp (method) - from_fp(fp) -> loader_input_t - A static method to construct an instance from a FILE* - - @param fp: FILE * - -ida_idaapi.loader_input_t.from_linput (method) - from_linput(linput) -> loader_input_t - - @param linput: linput_t * - -ida_idaapi.loader_input_t.get_byte (method) - get_byte(self) -> PyObject * - Reads a single byte from the file. Returns None if EOF or the read byte - -ida_idaapi.loader_input_t.get_linput (method) - get_linput(self) -> linput_t * - -ida_idaapi.loader_input_t.gets (method) - gets(self, len) -> str - Reads a line from the input file. Returns the read line or None - - @param len: size_t - -ida_idaapi.loader_input_t.getz (method) - 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. - -ida_idaapi.loader_input_t.open (method) - open(self, filename, remote=False) -> bool - Opens a file (or a remote file) - - @param filename: char const * - @param remote: bool - @return: Boolean - -ida_idaapi.loader_input_t.open_memory (method) - 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 range to represent as linput - if unknown, may be passed as 0 - -ida_idaapi.loader_input_t.opened (method) - opened(self) -> bool - Checks if the file is opened or not - -ida_idaapi.loader_input_t.read (method) - read(self, size) -> bytes or None - Reads from the file. Returns the buffer or None - - @param size: size_t - -ida_idaapi.loader_input_t.readbytes (method) - readbytes(self, size, big_endian) -> PyObject * - Similar to read() but it respect the endianness - - @param size: size_t - @param big_endian: bool - -ida_idaapi.loader_input_t.seek (method) - seek(self, pos, whence=SEEK_SET) -> int64 - Set input source position - - @param pos: int64 - @param whence: int - @return: the new position (not 0 as fseek!) - -ida_idaapi.loader_input_t.set_linput (method) - set_linput(self, linput) - Links the current loader_input_t instance to a linput_t instance - - @param linput: linput_t * - -ida_idaapi.loader_input_t.size (method) - size(self) -> int64 - -ida_idaapi.loader_input_t.tell (method) - tell(self) -> int64 - Returns the current position - -ida_idaapi.loader_input_t_from_capsule (function) - loader_input_t_from_capsule(pycapsule) -> loader_input_t - - @param pycapsule: PyObject * - -ida_idaapi.loader_input_t_from_fp (function) - loader_input_t_from_fp(fp) -> loader_input_t - - @param fp: FILE * - -ida_idaapi.loader_input_t_from_linput (function) - loader_input_t_from_linput(linput) -> loader_input_t - - @param linput: linput_t * - -ida_idaapi.notify_when (function) - 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 - -ida_idaapi.object_t (class) - Helper class used to initialize empty objects - -ida_idaapi.object_t.__getitem__ (method) - Allow access to object attributes by index (like dictionaries) - -ida_idaapi.object_t.__init__ (method) - -ida_idaapi.parse_command_line3 (function) - parse_command_line3(cmdline) -> PyObject * - - @param cmdline: char const * - -ida_idaapi.plugin_t (class) - Base class for all scripted plugins. - -ida_idaapi.plugin_t.run (method) - -ida_idaapi.plugin_t.term (method) - -ida_idaapi.plugmod_t (class) - Base class for all scripted multi-plugins. - -ida_idaapi.py_clinked_object_t (class) - This is a utility and base class for C linked objects - -ida_idaapi.py_clinked_object_t.__del__ (method) - Delete the link upon object destruction (only if not static) - -ida_idaapi.py_clinked_object_t.__init__ (method) - -ida_idaapi.py_clinked_object_t._create_clink (method) - Overwrite me. - Creates a new clink - @return: PyCapsule representing the C link - -ida_idaapi.py_clinked_object_t._del_clink (method) - Overwrite me. - This method deletes the link - -ida_idaapi.py_clinked_object_t._free (method) - Explicitly delete the link (only if not static) - -ida_idaapi.py_clinked_object_t._get_clink_ptr (method) - Overwrite me. - Returns the C link pointer as a 64bit number - -ida_idaapi.py_clinked_object_t.assign (method) - Overwrite me. - This method allows you to assign an instance contents to anothers - @return: Boolean - -ida_idaapi.py_clinked_object_t.clink (variable) - Returns the C link as a PyObject - -ida_idaapi.py_clinked_object_t.clink_ptr (variable) - Returns the C link pointer as a number - -ida_idaapi.py_clinked_object_t.copy (method) - Returns a new copy of this class - -ida_idaapi.pycim_get_widget (function) - pycim_get_widget(_self) -> TWidget * - - @param self: PyObject * - -ida_idaapi.pycim_view_close (function) - pycim_view_close(_self) - - @param self: PyObject * - -ida_idaapi.pygc_create_groups (function) - pygc_create_groups(_self, groups_infos) -> [int, ...] or None - - @param self: PyObject * - @param groups_infos: PyObject * - -ida_idaapi.pygc_delete_groups (function) - pygc_delete_groups(_self, groups, new_current) -> bool - - @param self: PyObject * - @param groups: PyObject * - @param new_current: PyObject * - -ida_idaapi.pygc_refresh (function) - pygc_refresh(_self) - - @param self: PyObject * - -ida_idaapi.pygc_set_groups_visibility (function) - pygc_set_groups_visibility(_self, groups, expand, new_current) -> bool - - @param self: PyObject * - @param groups: PyObject * - @param expand: PyObject * - @param new_current: PyObject * - -ida_idaapi.pyidc_cvt_helper__ (class) - This is a special helper object that helps detect which kind - of object is this python object wrapping and how to convert it - back and from IDC. - This object is characterized by its special attribute and its value - -ida_idaapi.pyidc_cvt_helper__.__get_value (method) - -ida_idaapi.pyidc_cvt_helper__.__init__ (method) - -ida_idaapi.pyidc_cvt_helper__.__set_value (method) - -ida_idaapi.pyidc_opaque_object_t (class) - This is the base class for all Python<->IDC opaque objects - -ida_idaapi.replfun (function) - -ida_idaapi.require (function) - Load, or reload a module. - - When under heavy development, a user's tool might consist of multiple - modules. If those are imported using the standard 'import' mechanism, - there is no guarantee that the Python implementation will re-read - and re-evaluate the module's Python code. In fact, it usually doesn't. - What should be done instead is 'reload()'-ing that module. - - This is a simple helper function that will do just that: In case the - module doesn't exist, it 'import's it, and if it does exist, - 'reload()'s it. - - The importing module (i.e., the module calling require()) will have - the loaded module bound to its globals(), under the name 'modulename'. - (If require() is called from the command line, the importing module - will be '__main__'.) - - For more information, see: <http://www.hexblog.com/?p=749>. - -ida_idaapi.set_script_timeout (function) - 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 - -ida_idaapi.struct_unpack (function) - Unpack a buffer given its length and offset using struct.unpack_from(). - This function will know how to unpack the given buffer by using the lookup table '__struct_unpack_table' - If the buffer is of unknown length then None is returned. Otherwise the unpacked value is returned. - -ida_idc (module) - -ida_idc.get_mark_comment (function) - get_mark_comment(slot) -> PyObject * - - @param slot: int32 - -ida_idc.get_marked_pos (function) - get_marked_pos(slot) -> ea_t - - @param slot: int32 - -ida_idc.mark_position (function) - mark_position(ea, lnnum, x, y, slot, comment) - - @param ea: ea_t - @param lnnum: int - @param x: short - @param y: short - @param slot: int32 - @param comment: char const * - -ida_idd (module) - Contains definition of the interface to IDD modules. - - The interface consists of structures describing the target debugged processor - and a debugging API. - -ida_idd.APPCALL_DEBEV (variable) - Return debug event information. - -ida_idd.APPCALL_MANUAL (variable) - Only set up the appcall, do not run. debugger_t::cleanup_appcall will not be - generated by ida! - -ida_idd.APPCALL_TIMEOUT (variable) - Appcall with timeout. If timed out, errbuf will contain "timeout". See - SET_APPCALL_TIMEOUT and GET_APPCALL_TIMEOUT - -ida_idd.Appcall__ (class) - -ida_idd.Appcall__.APPCALL_DEBEV (variable) - Return debug event information - If this bit is set, exceptions during appcall - will generate idc exceptions with full - information about the exception - -ida_idd.Appcall__.APPCALL_MANUAL (variable) - Only set up the appcall, do not run it. - you should call CleanupAppcall() when finished - -ida_idd.Appcall__.APPCALL_TIMEOUT (variable) - Appcall with timeout - The timeout value in milliseconds is specified - in the high 2 bytes of the 'options' argument: - If timed out, errbuf will contain "timeout". - -ida_idd.Appcall__.Consts (variable) - Use Appcall.Consts.CONST_NAME to access constants - -ida_idd.Appcall__.UTF16 (method) - -ida_idd.Appcall__.__get_consts (method) - -ida_idd.Appcall__.__getattr__ (method) - Allows you to call functions as if they were member functions (by returning a callable object) - -ida_idd.Appcall__.__getitem__ (method) - Use self[func_name] syntax if the function name contains invalid characters for an attribute name - See __getattr___ - -ida_idd.Appcall__.__init__ (method) - -ida_idd.Appcall__.__name_or_ea (method) - Function that accepts a name or an ea and checks if the address is enabled. - If a name is passed then idaapi.get_name_ea() is applied to retrieve the name - @return: - Returns the resolved EA or - - Raises an exception if the address is not enabled - -ida_idd.Appcall__.__typedecl_or_tinfo (method) - Function that accepts a tinfo_t object or type declaration as a string - If a type declaration is passed then ida_typeinf.parse_decl() is applied to prepare tinfo_t object - @return: - Returns the tinfo_t object - - Raises an exception if the declaration cannot be parsed - -ida_idd.Appcall__.array (method) - Defines an array type. Later you need to pack() / unpack() - -ida_idd.Appcall__.buffer (method) - Creates a string buffer. The returned value (r) will be a byref object. - Use r.value to get the contents and r.size to get the buffer's size - -ida_idd.Appcall__.byref (method) - Method to create references to immutable objects - Currently we support references to int/strings - Objects need not be passed by reference (this will be done automatically) - -ida_idd.Appcall__.cleanup_appcall (method) - Equivalent to IDC's CleanupAppcall() - -ida_idd.Appcall__.cstr (method) - -ida_idd.Appcall__.get_appcall_options (method) - Return the global Appcall options - -ida_idd.Appcall__.int64 (method) - Whenever a 64bit number is needed use this method to construct an object - -ida_idd.Appcall__.obj (method) - Returns an empty object or objects with attributes as passed via its keywords arguments - -ida_idd.Appcall__.proto (method) - Allows you to instantiate an appcall (callable object) with the desired prototype - @param name_or_ea: The name of the function (will be resolved with LocByName()) - @param proto_or_tinfo: function prototype as a string or type of the function as tinfo_t object - @return: - On failure it raises an exception if the prototype could not be parsed - or the address is not resolvable - - Returns a callbable Appcall instance with the given prototypes and flags - -ida_idd.Appcall__.set_appcall_options (method) - Method to change the Appcall options globally (not per Appcall) - -ida_idd.Appcall__.typedobj (method) - Returns an appcall object for a type (can be given as tinfo_t object or - as a string declaration) - One can then use retrieve() member method - @param ea: Optional parameter that later can be used to retrieve the type - @return: Appcall object or raises ValueError exception - -ida_idd.Appcall__.valueof (method) - Returns the numeric value of a given name string. - If the name could not be resolved then the default value will be returned - -ida_idd.Appcall_array__ (class) - This class is used with Appcall.array() method - -ida_idd.Appcall_array__.__init__ (method) - -ida_idd.Appcall_array__.pack (method) - Packs a list or tuple into a byref buffer - -ida_idd.Appcall_array__.try_to_convert_to_list (method) - Is this object a list? We check for the existance of attribute zero and attribute self.size-1 - -ida_idd.Appcall_array__.unpack (method) - Unpacks an array back into a list or an object - -ida_idd.Appcall_callable__ (class) - Helper class to issue appcalls using a natural syntax: - appcall.FunctionNameInTheDatabase(arguments, ....) - or - appcall["Function@8"](arguments, ...) - or - f8 = appcall["Function@8"] - f8(arg1, arg2, ...) - or - o = appcall.obj() - i = byref(5) - appcall.funcname(arg1, i, "hello", o) - -ida_idd.Appcall_callable__.__call__ (method) - Make object callable. We redirect execution to idaapi.appcall() - -ida_idd.Appcall_callable__.__get_ea (method) - -ida_idd.Appcall_callable__.__get_fields (method) - -ida_idd.Appcall_callable__.__get_options (method) - -ida_idd.Appcall_callable__.__get_size (method) - -ida_idd.Appcall_callable__.__get_tif (method) - -ida_idd.Appcall_callable__.__get_timeout (method) - -ida_idd.Appcall_callable__.__get_type (method) - -ida_idd.Appcall_callable__.__init__ (method) - Initializes an appcall with a given function ea - -ida_idd.Appcall_callable__.__set_ea (method) - -ida_idd.Appcall_callable__.__set_options (method) - -ida_idd.Appcall_callable__.__set_timeout (method) - -ida_idd.Appcall_callable__.ea (variable) - Returns or sets the EA associated with this object - -ida_idd.Appcall_callable__.fields (variable) - Returns the field names - -ida_idd.Appcall_callable__.options (variable) - Sets the Appcall options locally to this Appcall instance - -ida_idd.Appcall_callable__.retrieve (method) - Unpacks a typed object from the database if an ea is given or from a string if a string was passed - @param src: the address of the object or a string - @return: Returns a tuple of boolean and object or error number (Bool, Error | Object). - -ida_idd.Appcall_callable__.size (variable) - Returns the size of the type - -ida_idd.Appcall_callable__.store (method) - Packs an object into a given ea if provided or into a string if no address was passed. - @param obj: The object to pack - @param dest_ea: If packing to idb this will be the store location - @param base_ea: If packing to a buffer, this will be the base that will be used to relocate the pointers - - @return: - If packing to a string then a Tuple(Boolean, packed_string or error code) - - If packing to the database then a return code is returned (0 is success) - -ida_idd.Appcall_callable__.tif (variable) - Returns the tinfo_t object - -ida_idd.Appcall_callable__.timeout (variable) - An Appcall instance can change its timeout value with this attribute - -ida_idd.Appcall_callable__.type (variable) - Returns the typestring - -ida_idd.Appcall_consts__ (class) - Helper class used by Appcall.Consts attribute - It is used to retrieve constants via attribute access - -ida_idd.Appcall_consts__.__getattr__ (method) - -ida_idd.Appcall_consts__.__init__ (method) - -ida_idd.BPT_BAD_ADDR (variable) - ea is invalid - -ida_idd.BPT_BAD_ALIGN (variable) - alignment is invalid - -ida_idd.BPT_BAD_LEN (variable) - bpt len is invalid - -ida_idd.BPT_BAD_TYPE (variable) - bpt type is not supported - -ida_idd.BPT_DEFAULT (variable) - Choose bpt type automatically. - -ida_idd.BPT_EXEC (variable) - Execute instruction. - -ida_idd.BPT_INTERNAL_ERR (variable) - interr occurred when verifying breakpoint - -ida_idd.BPT_OK (variable) - breakpoint can be set - -ida_idd.BPT_PAGE_OK (variable) - update_bpts(): ok, added a page bpt - -ida_idd.BPT_RDWR (variable) - Read/write access. - -ida_idd.BPT_READ (variable) - Read access. - -ida_idd.BPT_READ_ERROR (variable) - failed to read memory at bpt ea - -ida_idd.BPT_SKIP (variable) - update_bpts(): do not process bpt - -ida_idd.BPT_SOFT (variable) - Software breakpoint. - -ida_idd.BPT_TOO_MANY (variable) - reached max number of supported breakpoints - -ida_idd.BPT_WRITE (variable) - Write access. - -ida_idd.BPT_WRITE_ERROR (variable) - failed to write memory at bpt ea - -ida_idd.BREAKPOINT (variable) - Breakpoint has been reached. IDA will complain about unknown breakpoints, they - should be reported as exceptions. - -ida_idd.DBG_FLAG_ADD_ENVS (variable) - The debugger supports launching processes with environment variables. - -ida_idd.DBG_FLAG_ANYSIZE_HWBPT (variable) - The debugger supports arbitrary size hardware breakpoints. - -ida_idd.DBG_FLAG_CAN_CONT_BPT (variable) - Debugger knows to continue from a bpt. This flag also means that the debugger - module hides breakpoints from ida upon read_memory - -ida_idd.DBG_FLAG_CLEAN_EXIT (variable) - IDA must suspend the application and remove all breakpoints before terminating - the application. Usually this is not required because the application memory - disappears upon termination. - -ida_idd.DBG_FLAG_CONNSTRING (variable) - Display "Connection string" instead of "Hostname" and hide the "Port" field. - -ida_idd.DBG_FLAG_DEBTHREAD (variable) - Supports creation of a separate thread in ida for the debugger (the debthread). - Most debugger functions will be called from debthread (exceptions are marked - below) The debugger module may directly call only THREAD_SAFE functions. To call - other functions please use execute_sync(). The debthread significantly increases - debugging speed, especially if debug events occur frequently. - -ida_idd.DBG_FLAG_DEBUG_DLL (variable) - Can debug standalone DLLs. For example, Bochs debugger can debug any snippet of - code - -ida_idd.DBG_FLAG_DONT_DISTURB (variable) - Debugger can handle only get_debug_event(), request_pause(), exit_process() when - the debugged process is running. The kernel may also call service functions - (file I/O, map_address, etc) - -ida_idd.DBG_FLAG_EXITSHOTOK (variable) - IDA may take a memory snapshot at PROCESS_EXITED event. - -ida_idd.DBG_FLAG_FAKE_ATTACH (variable) - PROCESS_ATTACHED is a fake event and does not suspend the execution - -ida_idd.DBG_FLAG_FAKE_MEMORY (variable) - get_memory_info()/read_memory()/write_memory() work with the idb. (there is no - real process to read from, as for the replayer module) the kernel will not call - these functions if this flag is set. however, third party plugins may call them, - they must be implemented. - -ida_idd.DBG_FLAG_FAST_STEP (variable) - Do not refresh memory layout info after single stepping. - -ida_idd.DBG_FLAG_HWDATBPT_ONE (variable) - Hardware data breakpoints are one byte size by default - -ida_idd.DBG_FLAG_LAZY_WATCHPTS (variable) - Watchpoints are triggered before the offending instruction is executed. The - debugger must temporarily disable the watchpoint and single-step before - resuming. - -ida_idd.DBG_FLAG_LOWCNDS (variable) - Low level breakpoint conditions are supported. - -ida_idd.DBG_FLAG_MANMEMINFO (variable) - If set, manual memory region manipulation commands will be available. Use this - bit for debugger modules that cannot return memory layout information - -ida_idd.DBG_FLAG_MERGE_ENVS (variable) - The debugger supports merge or replace setting for environment variables (only - makes sense if DBG_FLAG_ADD_ENVS is set) - -ida_idd.DBG_FLAG_NEEDPORT (variable) - Remote debugger requires port number (to be used with DBG_FLAG_NOHOST) - -ida_idd.DBG_FLAG_NOHOST (variable) - Remote debugger with does not require network params (host/port/pass). (a unique - device connected to the machine) - -ida_idd.DBG_FLAG_NOPARAMETERS (variable) - Debugger module doesn't use commandline parameters. - -ida_idd.DBG_FLAG_NOPASSWORD (variable) - Remote debugger doesn't use password. - -ida_idd.DBG_FLAG_NOSTARTDIR (variable) - Debugger module doesn't use startup directory. - -ida_idd.DBG_FLAG_PREFER_SWBPTS (variable) - Prefer to use software breakpoints. - -ida_idd.DBG_FLAG_REMOTE (variable) - Remote debugger (requires remote host name unless DBG_FLAG_NOHOST) - -ida_idd.DBG_FLAG_SAFE (variable) - The debugger is safe (probably because it just emulates the application without - really running it) - -ida_idd.DBG_FLAG_SMALLBLKS (variable) - If set, IDA uses 256-byte blocks for caching memory contents. Otherwise, - 1024-byte blocks are used - -ida_idd.DBG_FLAG_TRACER_MODULE (variable) - The module is a tracer, not a full featured debugger module. - -ida_idd.DBG_FLAG_USE_SREGS (variable) - Take segment register values into account (non flat memory) - -ida_idd.DBG_FLAG_VIRTHREADS (variable) - Thread IDs may be shuffled after each debug event. (to be used for virtual - threads that represent cpus for windbg kmode) - -ida_idd.DBG_HAS_APPCALL (variable) - supports ev_appcall, ev_cleanup_appcall - -ida_idd.DBG_HAS_ATTACH_PROCESS (variable) - supports ev_attach_process - -ida_idd.DBG_HAS_CHECK_BPT (variable) - supports ev_check_bpt - -ida_idd.DBG_HAS_DETACH_PROCESS (variable) - supports ev_detach_process - -ida_idd.DBG_HAS_GET_PROCESSES (variable) - supports ev_get_processes - -ida_idd.DBG_HAS_MAP_ADDRESS (variable) - supports ev_map_address. Avoid using this bit, especially together with - DBG_FLAG_DEBTHREAD because it may cause big slow downs - -ida_idd.DBG_HAS_OPEN_FILE (variable) - supports ev_open_file, ev_close_file, ev_read_file, ev_write_file - -ida_idd.DBG_HAS_REQUEST_PAUSE (variable) - supports ev_request_pause - -ida_idd.DBG_HAS_REXEC (variable) - supports ev_rexec - -ida_idd.DBG_HAS_SET_EXCEPTION_INFO (variable) - supports ev_set_exception_info - -ida_idd.DBG_HAS_SET_RESUME_MODE (variable) - supports ev_set_resume_mode. Cannot be set inside the - debugger_t::init_debugger() - -ida_idd.DBG_HAS_THREAD_CONTINUE (variable) - supports ev_thread_continue - -ida_idd.DBG_HAS_THREAD_GET_SREG_BASE (variable) - supports ev_thread_get_sreg_base - -ida_idd.DBG_HAS_THREAD_SUSPEND (variable) - supports ev_thread_suspend - -ida_idd.DBG_HAS_UPDATE_CALL_STACK (variable) - supports ev_update_call_stack - -ida_idd.DBG_HIDE_WINDOW (variable) - application should be hidden on startup (windows) - -ida_idd.DBG_NO_ASLR (variable) - disable ASLR (linux) - -ida_idd.DBG_NO_TRACE (variable) - do not trace the application (mac/linux) - -ida_idd.DBG_PROC_32BIT (variable) - application is 32-bit - -ida_idd.DBG_PROC_64BIT (variable) - application is 64-bit - -ida_idd.DBG_PROC_IS_DLL (variable) - database contains a dll (not exe) - -ida_idd.DBG_PROC_IS_GUI (variable) - using gui version of ida - -ida_idd.DBG_RESMOD_STEP_HANDLE (variable) - RESMOD_HANDLE is available - -ida_idd.DBG_RESMOD_STEP_INTO (variable) - RESMOD_INTO is available - -ida_idd.DBG_RESMOD_STEP_OUT (variable) - RESMOD_OUT is available - -ida_idd.DBG_RESMOD_STEP_OVER (variable) - RESMOD_OVER is available - -ida_idd.DBG_RESMOD_STEP_SRCINTO (variable) - RESMOD_SRCINTO is available - -ida_idd.DBG_RESMOD_STEP_SRCOUT (variable) - RESMOD_SRCOUT is available - -ida_idd.DBG_RESMOD_STEP_SRCOVER (variable) - RESMOD_SRCOVER is available - -ida_idd.DBG_RESMOD_STEP_USER (variable) - RESMOD_USER is available - -ida_idd.DBG_SUSPENDED (variable) - application should be suspended on startup (mac) - -ida_idd.DEBUGGER_ID_6811_EMULATOR (variable) - MC6812 emulator (beta) - -ida_idd.DEBUGGER_ID_ARM_IPHONE_USER (variable) - iPhone 1.x - -ida_idd.DEBUGGER_ID_ARM_LINUX_USER (variable) - Userland arm linux. - -ida_idd.DEBUGGER_ID_ARM_MACOS_USER (variable) - Userland arm MAC OS. - -ida_idd.DEBUGGER_ID_DALVIK_USER (variable) - Dalvik. - -ida_idd.DEBUGGER_ID_GDB_USER (variable) - GDB remote. - -ida_idd.DEBUGGER_ID_TRACE_REPLAYER (variable) - Fake debugger to replay recorded traces. - -ida_idd.DEBUGGER_ID_WINDBG (variable) - WinDBG using Microsoft Debug engine. - -ida_idd.DEBUGGER_ID_X86_DOSBOX_EMULATOR (variable) - Dosbox MS-DOS emulator. - -ida_idd.DEBUGGER_ID_X86_IA32_BOCHS (variable) - BochsDbg.exe 32. - -ida_idd.DEBUGGER_ID_X86_IA32_LINUX_USER (variable) - Userland linux processes (ptrace()) - -ida_idd.DEBUGGER_ID_X86_IA32_MACOSX_USER (variable) - Userland MAC OS X processes. - -ida_idd.DEBUGGER_ID_X86_IA32_WIN32_USER (variable) - Userland win32 processes (win32 debugging APIs) - -ida_idd.DEBUGGER_ID_X86_PIN_TRACER (variable) - PIN Tracer module. - -ida_idd.DEBUGGER_ID_XNU_USER (variable) - XNU Kernel. - -ida_idd.DRC_CRC (variable) - success, but the input file crc does not match - -ida_idd.DRC_ERROR (variable) - unclassified error, may be complemented by errbuf - -ida_idd.DRC_EVENTS (variable) - success, there are pending events - -ida_idd.DRC_FAILED (variable) - failed or false - -ida_idd.DRC_IDBSEG (variable) - use idb segmentation - -ida_idd.DRC_NETERR (variable) - network error - -ida_idd.DRC_NOCHG (variable) - no changes - -ida_idd.DRC_NOFILE (variable) - file not found - -ida_idd.DRC_NONE (variable) - reaction to the event not implemented - -ida_idd.DRC_NOPROC (variable) - the process does not exist anymore - -ida_idd.DRC_OK (variable) - success - -ida_idd.EXCEPTION (variable) - Exception. - -ida_idd.EXC_BREAK (variable) - break on the exception - -ida_idd.EXC_HANDLE (variable) - should be handled by the debugger? - -ida_idd.EXC_MSG (variable) - instead of a warning, log the exception to the output window - -ida_idd.EXC_SILENT (variable) - do not warn or log to the output window - -ida_idd.IDD_INTERFACE_VERSION (variable) - The IDD interface version number. - -ida_idd.INFORMATION (variable) - User-defined information. This event can be used to return empty information - This will cause IDA to call get_debug_event() immediately once more. - -ida_idd.LIB_LOADED (variable) - New library has been loaded. - -ida_idd.LIB_UNLOADED (variable) - Library has been unloaded. - -ida_idd.NO_EVENT (variable) - Not an interesting event. This event can be used if the debugger module needs to - return an event but there are no valid events. - -ida_idd.NO_PROCESS (variable) - No process. - -ida_idd.NO_THREAD (variable) - No thread. in PROCESS_STARTED this value can be used to specify that the main - thread has not been created. It will be initialized later by a THREAD_STARTED - event. - -ida_idd.PROCESS_ATTACHED (variable) - Successfully attached to running process. - -ida_idd.PROCESS_DETACHED (variable) - Successfully detached from process. - -ida_idd.PROCESS_EXITED (variable) - Process has been stopped. - -ida_idd.PROCESS_STARTED (variable) - New process has been started. - -ida_idd.PROCESS_SUSPENDED (variable) - Process has been suspended. This event can be used by the debugger module to - signal if the process spontaneously gets suspended (not because of an exception, - breakpoint, or single step). IDA will silently switch to the 'suspended process' - mode without displaying any messages. - -ida_idd.REGISTER_ADDRESS (variable) - may contain an address - -ida_idd.REGISTER_CS (variable) - code segment - -ida_idd.REGISTER_CUSTFMT (variable) - register should be displayed using a custom data format. the format name is in - bit_strings[0]; the corresponding regval_t will use bytevec_t - -ida_idd.REGISTER_FP (variable) - frame pointer - -ida_idd.REGISTER_IP (variable) - instruction pointer - -ida_idd.REGISTER_NOLF (variable) - displays this register without returning to the next line, allowing the next - register to be displayed to its right (on the same line) - -ida_idd.REGISTER_READONLY (variable) - the user can't modify the current value of this register - -ida_idd.REGISTER_SP (variable) - stack pointer - -ida_idd.REGISTER_SS (variable) - stack segment - -ida_idd.RESMOD_HANDLE (variable) - step into the exception handler - -ida_idd.RESMOD_INTO (variable) - step into call (the most typical single stepping) - -ida_idd.RESMOD_NONE (variable) - no stepping, run freely - -ida_idd.RESMOD_OUT (variable) - step out of the current function (run until return) - -ida_idd.RESMOD_OVER (variable) - step over call - -ida_idd.RESMOD_SRCINTO (variable) - until control reaches a different source line - -ida_idd.RESMOD_SRCOUT (variable) - next source line in the previous stack frame - -ida_idd.RESMOD_SRCOVER (variable) - next source line in the current stack frame - -ida_idd.RESMOD_USER (variable) - step out to the user code - -ida_idd.RVT_FLOAT (variable) - floating point - -ida_idd.RVT_INT (variable) - integer - -ida_idd.RVT_UNAVAILABLE (variable) - unavailable; other values mean custom data type - -ida_idd.STEP (variable) - One instruction has been executed. Spurious events of this kind are silently - ignored by IDA. - -ida_idd.THREAD_EXITED (variable) - Thread has been stopped. - -ida_idd.THREAD_STARTED (variable) - New thread has been started. - -ida_idd.TRACE_FULL (variable) - The trace buffer of the tracer module is full and IDA needs to read it before - continuing - -ida_idd.appcall (function) - appcall(func_ea, tid, _type_or_none, _fields, arg_list) -> PyObject * - - @param func_ea: ea_t - @param tid: thid_t - @param _type_or_none: bytevec_t const & - @param _fields: bytevec_t const & - @param arg_list: PyObject * - -ida_idd.bptaddr_t (class) - Proxy of C++ bptaddr_t class. - -ida_idd.bptaddr_t.__init__ (method) - __init__(self) -> bptaddr_t - -ida_idd.bptaddr_t.hea (variable) - Possible address referenced by hardware breakpoints. - -ida_idd.bptaddr_t.kea (variable) - Address of the triggered bpt from the kernel's point of view. (for some systems - with special memory mappings, the triggered ea might be different from event - ea). Use to BADADDR for flat memory model. - -ida_idd.call_stack_info_t (class) - Proxy of C++ call_stack_info_t class. - -ida_idd.call_stack_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: call_stack_info_t const & - -ida_idd.call_stack_info_t.__init__ (method) - __init__(self) -> call_stack_info_t - -ida_idd.call_stack_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: call_stack_info_t const & - -ida_idd.call_stack_info_t.callea (variable) - the address of the call instruction. for the 0th frame this is usually just the - current value of EIP. - -ida_idd.call_stack_info_t.fp (variable) - the value of the frame pointer of the called function - -ida_idd.call_stack_info_t.funcea (variable) - the address of the called function - -ida_idd.call_stack_info_t.funcok (variable) - is the function present? - -ida_idd.call_stack_info_vec_t (class) - Proxy of C++ qvector< call_stack_info_t > class. - -ida_idd.call_stack_info_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< call_stack_info_t > const & - -ida_idd.call_stack_info_vec_t.__getitem__ (method) - __getitem__(self, i) -> call_stack_info_t - - @param i: size_t - -ida_idd.call_stack_info_vec_t.__init__ (method) - __init__(self) -> call_stack_info_vec_t - __init__(self, x) -> call_stack_info_vec_t - - @param x: qvector< call_stack_info_t > const & - -ida_idd.call_stack_info_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_idd.call_stack_info_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< call_stack_info_t > const & - -ida_idd.call_stack_info_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: call_stack_info_t const & - -ida_idd.call_stack_info_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: call_stack_info_t const & - -ida_idd.call_stack_info_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: call_stack_info_t const & - -ida_idd.call_stack_info_vec_t.at (method) - at(self, _idx) -> call_stack_info_t - - @param _idx: size_t - -ida_idd.call_stack_info_vec_t.begin (method) - begin(self) -> call_stack_info_t - -ida_idd.call_stack_info_vec_t.capacity (method) - capacity(self) -> size_t - -ida_idd.call_stack_info_vec_t.clear (method) - clear(self) - -ida_idd.call_stack_info_vec_t.empty (method) - empty(self) -> bool - -ida_idd.call_stack_info_vec_t.end (method) - end(self) -> call_stack_info_t - -ida_idd.call_stack_info_vec_t.erase (method) - erase(self, it) -> call_stack_info_t - - @param it: qvector< call_stack_info_t >::iterator - - erase(self, first, last) -> call_stack_info_t - - @param first: qvector< call_stack_info_t >::iterator - @param last: qvector< call_stack_info_t >::iterator - -ida_idd.call_stack_info_vec_t.extract (method) - extract(self) -> call_stack_info_t - -ida_idd.call_stack_info_vec_t.find (method) - find(self, x) -> call_stack_info_t - - @param x: call_stack_info_t const & - -ida_idd.call_stack_info_vec_t.grow (method) - grow(self, x=call_stack_info_t()) - - @param x: call_stack_info_t const & - -ida_idd.call_stack_info_vec_t.has (method) - has(self, x) -> bool - - @param x: call_stack_info_t const & - -ida_idd.call_stack_info_vec_t.inject (method) - inject(self, s, len) - - @param s: call_stack_info_t * - @param len: size_t - -ida_idd.call_stack_info_vec_t.insert (method) - insert(self, it, x) -> call_stack_info_t - - @param it: qvector< call_stack_info_t >::iterator - @param x: call_stack_info_t const & - -ida_idd.call_stack_info_vec_t.pop_back (method) - pop_back(self) - -ida_idd.call_stack_info_vec_t.push_back (method) - push_back(self, x) - - @param x: call_stack_info_t const & - - push_back(self) -> call_stack_info_t - -ida_idd.call_stack_info_vec_t.qclear (method) - qclear(self) - -ida_idd.call_stack_info_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idd.call_stack_info_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: call_stack_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idd.call_stack_info_vec_t.size (method) - size(self) -> size_t - -ida_idd.call_stack_info_vec_t.swap (method) - swap(self, r) - - @param r: qvector< call_stack_info_t > & - -ida_idd.call_stack_info_vec_t.truncate (method) - truncate(self) - -ida_idd.call_stack_t (class) - Proxy of C++ call_stack_t class. - -ida_idd.call_stack_t.__init__ (method) - __init__(self) -> call_stack_t - -ida_idd.can_exc_continue (function) - can_exc_continue(ev) -> bool - - @param ev: debug_event_t const * - -ida_idd.cleanup_appcall (function) - cleanup_appcall(tid) -> error_t - Cleanup after manual appcall. - - @param tid: (C++: thid_t) thread to use. NO_THREAD means to use the current thread The - application state is restored as it was before calling the last - appcall(). Nested appcalls are supported. - @return: eOk if successful, otherwise an error code - -ida_idd.dbg_appcall (function) - dbg_appcall(retval, func_ea, tid, ptif, argv, argnum) -> error_t - Call a function from the debugged application. - - @param retval: (C++: idc_value_t *) function return value - * for APPCALL_MANUAL, r will hold the new stack point value - * for APPCALL_DEBEV, r will hold the exception information upon failure and the - return code will be eExecThrow - @param func_ea: (C++: ea_t) address to call - @param tid: (C++: thid_t) thread to use. NO_THREAD means to use the current thread - @param ptif: (C++: const tinfo_t *) pointer to type of the function to call - @param argv: (C++: idc_value_t *) array of arguments - @param argnum: (C++: size_t) number of actual arguments - @return: eOk if successful, otherwise an error code - -ida_idd.dbg_get_memory_info (function) - dbg_get_memory_info() -> PyObject * - This function returns the memory configuration of a debugged process. - - @return: None if no debugger is active - tuple(start_ea, end_ea, name, sclass, sbase, bitness, perm) - -ida_idd.dbg_get_name (function) - dbg_get_name() -> PyObject * - This function returns the current debugger's name. - - @return: Debugger name or None if no debugger is active - -ida_idd.dbg_get_registers (function) - 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, dtype, bit_strings, default_bit_strings_mask) - The bit_strings can be a tuple of strings or None (if the register does not have bit_strings) - -ida_idd.dbg_get_thread_sreg_base (function) - dbg_get_thread_sreg_base(tid, 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 - -ida_idd.dbg_read_memory (function) - dbg_read_memory(ea, sz) -> PyObject * - Reads from the debugee's memory at the specified ea - - @param ea: ea_t - @param sz: size_t - @return: - The read buffer (as a string) - - Or None on failure - -ida_idd.dbg_write_memory (function) - dbg_write_memory(ea, buf) -> bool - Writes a buffer to the debugee's memory - - @param ea: ea_t - @param buf: bytevec_t const & - @return: Boolean - -ida_idd.debapp_attrs_t (class) - Proxy of C++ debapp_attrs_t class. - -ida_idd.debapp_attrs_t.__init__ (method) - __init__(self) -> debapp_attrs_t - -ida_idd.debapp_attrs_t.addrsize (variable) - address size of the process. Since 64-bit debuggers usually can debug 32-bit - applications, we cannot rely on sizeof(ea_t) to detect the current address size. - The following variable should be used instead. It is initialized with 8 for - 64-bit debuggers but they should adjust it as soon as they learn that a 32-bit - application is being debugged. For 32-bit debuggers it is initialized with 4. - -ida_idd.debapp_attrs_t.cbsize (variable) - control field: size of this structure - -ida_idd.debapp_attrs_t.platform (variable) - platform name process is running/debugging under. (is used as a key value in - exceptions.cfg) - -ida_idd.debug_event_t (class) - Proxy of C++ debug_event_t class. - -ida_idd.debug_event_t.__init__ (method) - __init__(self) -> debug_event_t - __init__(self, r) -> debug_event_t - - @param r: debug_event_t const & - -ida_idd.debug_event_t.bpt (method) - bpt(self) -> bptaddr_t - -ida_idd.debug_event_t.bpt_ea (method) - bpt_ea(self) -> ea_t - On some systems with special memory mappings the triggered ea might be different - from the actual ea. Calculate the address to use. - -ida_idd.debug_event_t.clear (method) - clear(self) - clear the dependent information (see below), set event code to NO_EVENT - -ida_idd.debug_event_t.clear_all (method) - clear_all(self) - -ida_idd.debug_event_t.copy (method) - copy(self, r) -> debug_event_t - - @param r: debug_event_t const & - -ida_idd.debug_event_t.ea (variable) - Address where the event occurred. - -ida_idd.debug_event_t.eid (method) - eid(self) -> event_id_t - Event code. - -ida_idd.debug_event_t.exc (method) - exc(self) -> excinfo_t - -ida_idd.debug_event_t.exit_code (method) - exit_code(self) -> int const & - -ida_idd.debug_event_t.handled (variable) - Is event handled by the debugger?. (from the system's point of view) Meaningful - for EXCEPTION events - -ida_idd.debug_event_t.info (method) - info(self) -> qstring - info(self) -> qstring const & - -ida_idd.debug_event_t.modinfo (method) - modinfo(self) -> modinfo_t - -ida_idd.debug_event_t.pid (variable) - Process where the event occurred. - -ida_idd.debug_event_t.set_bpt (method) - set_bpt(self) -> bptaddr_t - -ida_idd.debug_event_t.set_eid (method) - set_eid(self, id) - Set event code. If the new event code is compatible with the old one then the - dependent information (see below) will be preserved. Otherwise the event will be - cleared and the new event code will be set. - - @param id: (C++: event_id_t) enum event_id_t - -ida_idd.debug_event_t.set_exception (method) - set_exception(self) -> excinfo_t - -ida_idd.debug_event_t.set_exit_code (method) - set_exit_code(self, id, code) - - @param id: enum event_id_t - @param code: int - -ida_idd.debug_event_t.set_info (method) - set_info(self, id) -> qstring & - - @param id: enum event_id_t - -ida_idd.debug_event_t.set_modinfo (method) - set_modinfo(self, id) -> modinfo_t - - @param id: enum event_id_t - -ida_idd.debug_event_t.tid (variable) - Thread where the event occurred. - -ida_idd.debugger_t (class) - Proxy of C++ debugger_t class. - -ida_idd.debugger_t.__get_bpt_bytes (method) - __get_bpt_bytes(self) -> bytevec_t - -ida_idd.debugger_t.__get_nregs (method) - __get_nregs(self) -> int - -ida_idd.debugger_t.__get_regclasses (method) - __get_regclasses(self) -> PyObject * - -ida_idd.debugger_t.__get_registers (method) - __get_registers(self) -> dyn_register_info_array - -ida_idd.debugger_t.__init__ (method) - __init__(self) -> debugger_t - -ida_idd.debugger_t.attach_process (method) - attach_process(self, pid, event_id, dbg_proc_flags) -> drc_t - - @param pid: pid_t - @param event_id: int - @param dbg_proc_flags: uint32 - -ida_idd.debugger_t.bin_search (method) - bin_search(self, start_ea, end_ea, data, srch_flags) -> drc_t - - @param start_ea: ea_t - @param end_ea: ea_t - @param data: compiled_binpat_vec_t const & - @param srch_flags: int - -ida_idd.debugger_t.bpt_bytes (variable) - A software breakpoint instruction. - -ida_idd.debugger_t.bpt_size (variable) - Size of the software breakpoint instruction in bytes. - -ida_idd.debugger_t.cache_block_size (method) - cache_block_size(self) -> size_t - -ida_idd.debugger_t.can_continue_from_bpt (method) - can_continue_from_bpt(self) -> bool - -ida_idd.debugger_t.can_debug_standalone_dlls (method) - can_debug_standalone_dlls(self) -> bool - -ida_idd.debugger_t.check_bpt (method) - check_bpt(self, bptvc, type, ea, len) -> drc_t - - @param bptvc: int * - @param type: bpttype_t - @param ea: ea_t - @param len: int - -ida_idd.debugger_t.cleanup_appcall (method) - cleanup_appcall(self, tid) -> drc_t - - @param tid: thid_t - -ida_idd.debugger_t.close_file (method) - close_file(self, fn) - - @param fn: int - -ida_idd.debugger_t.dbg_enable_trace (method) - dbg_enable_trace(self, tid, enable, trace_flags) -> bool - - @param tid: thid_t - @param enable: bool - @param trace_flags: int - -ida_idd.debugger_t.default_regclasses (variable) - Mask of default printed register classes. - -ida_idd.debugger_t.detach_process (method) - detach_process(self) -> drc_t - -ida_idd.debugger_t.ev_appcall (variable) - Call application function. This event calls a function from the debugged - application. This event is generated in debthread Available if HAS_APPCALL is - set - - @retval DRC_NONE - @retval DRC_OK,see: BLOB_EA - -ida_idd.debugger_t.ev_attach_process (variable) - Attach to an existing running process. event_id should be equal to -1 if not - attaching to a crashed process. This event is generated in debthread. Available - if DBG_HAS_ATTACH_PROCESS is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_bin_search (variable) - Search for a binary pattern in the program. - - @return: DRC_OK EA contains the binary pattern address - @retval DRC_FAILED: not found - @retval DRC_NONE: not implemented - @retval DRC_NETERR,DRC_ERROR - -ida_idd.debugger_t.ev_check_bpt (variable) - Is it possible to set breakpoint? This event is generated in debthread or in the - main thread if debthread is not running yet. It is generated to verify hardware - breakpoints. Available if DBG_HAS_CHECK_BPT is set - - @return: DRC_OK, DRC_NONE - -ida_idd.debugger_t.ev_cleanup_appcall (variable) - Cleanup after appcall(). The debugger module must keep the stack blob in the - memory until this event is generated. It will be generated by the kernel for - each successful appcall(). There is an exception: if APPCALL_MANUAL, IDA may not - call cleanup_appcall. If the user selects to terminate a manual appcall, then - cleanup_appcall will be generated. Otherwise, the debugger module should - terminate the appcall when the generated event returns. This event is generated - in debthread. Available if HAS_APPCALL is set - - @retval DRC_EVENTS: success, there are pending events - @retval DRC_OK: success - @retval DRC_FAILED: failed - @retval DRC_NETERR: network error - -ida_idd.debugger_t.ev_close_file (variable) - @return: ignored - -ida_idd.debugger_t.ev_dbg_enable_trace (variable) - Enable/Disable tracing. The kernel will generated this event if the debugger - plugin set DBG_FLAG_TRACER_MODULE. TRACE_FLAGS can be a set of #STEP_TRACE, - #INSN_TRACE, #BBLK_TRACE or #FUNC_TRACE. This event is generated in the main - thread. - - @return: DRC_OK, DRC_FAILED, DRC_NONE - -ida_idd.debugger_t.ev_detach_process (variable) - Detach from the debugged process. May be generated while the process is running - or suspended. Must detach from the process in any case. The kernel will - repeatedly call get_debug_event() until PROCESS_DETACHED is received. In this - mode, all other events will be automatically handled and process will be - resumed. This event is generated from debthread. Available if - DBG_HAS_DETACH_PROCESS is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_eval_lowcnd (variable) - Evaluate a low level breakpoint condition at 'ea'. Other evaluation errors are - displayed in a dialog box. This call is used by IDA when the process has already - been temporarily suspended for some reason and IDA has to decide whether the - process should be resumed or definitely suspended because of a breakpoint with a - low level condition. This event is generated in debthread. - - @retval DRC_OK: condition is satisfied - @retval DRC_FAILED: not satisfied - @retval DRC_NETERR: network error - -ida_idd.debugger_t.ev_exit_process (variable) - Stop the process. May be generated while the process is running or suspended. - Must terminate the process in any case. The kernel will repeatedly call - get_debug_event() until PROCESS_EXITED is received. In this mode, all other - events will be automatically handled and process will be resumed. This event is - generated in debthread. Must be implemented. - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_get_debapp_attrs (variable) - Retrieve process- and debugger-specific runtime attributes. This event is - generated in the main thread. - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_get_debmod_extensions (variable) - Get pointer to debugger specific events. This event returns a pointer to a - structure that holds pointers to debugger module specific events. For - information on the structure layout, please check the corresponding debugger - module. Most debugger modules return nullptr because they do not have any - extensions. Available extensions may be generated from plugins. This event is - generated in the main thread. - - @return: DRC_NONE, DRC_OK see EXT - -ida_idd.debugger_t.ev_get_debug_event (variable) - Get a pending debug event and suspend the process. This event will be generated - regularly by IDA. This event is generated in debthread. IMPORTANT: the - BREAKPOINT/EXCEPTION/STEP events must be reported only after reporting other - pending events for a thread. Must be implemented. - - @retval ignored - -ida_idd.debugger_t.ev_get_memory_info (variable) - Get information on the memory ranges. The debugger module fills 'ranges'. The - returned vector must be sorted. This event is generated in debthread. Must be - implemented. - - @retval DRC_OK: new memory layout is returned - @retval DRC_FAILED,DRC_NETERR,DRC_NOPROC,DRC_NOCHG,DRC_IDBSEG - -ida_idd.debugger_t.ev_get_processes (variable) - Return information about the running processes. This event is generated in the - main thread. Available if DBG_HAS_GET_PROCESSES is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_get_srcinfo_path (variable) - Get the path to a file containing source debug info for the given module. This - allows srcinfo providers to call into the debugger when looking for debug info. - It is useful in certain cases like the iOS debugger, which is a remote debugger - but the remote debugserver does not provide dwarf info. So, we allow the - debugger client to decide where to look for debug info locally. - - @return: DRC_NONE, DRC_OK result stored in PATH - -ida_idd.debugger_t.ev_init_debugger (variable) - Initialize debugger. This event is generated in the main thread. - - @return: DRC_OK, DRC_FAILED - -ida_idd.debugger_t.ev_is_tracing_enabled (variable) - Is tracing enabled? The kernel will generated this event if the debugger plugin - set DBG_FLAG_TRACER_MODULE. TRACE_BIT can be one of the following: #STEP_TRACE, - #INSN_TRACE, #BBLK_TRACE or #FUNC_TRACE - - @retval DRC_OK: bit is set - @retval DRC_NONE: bit is not set or not implemented - -ida_idd.debugger_t.ev_map_address (variable) - Map process address. The debugger module may ignore this event. This event is - generated in debthread. IDA will generate this event only if DBG_HAS_MAP_ADDRESS - is set. - - @return: DRC_NONE, DRC_OK see MAPPED - -ida_idd.debugger_t.ev_open_file (variable) - @retval (int): handle - @retval -1: error - -ida_idd.debugger_t.ev_read_file (variable) - @retval number: of read bytes - -ida_idd.debugger_t.ev_read_memory (variable) - Read process memory. This event is generated in debthread. - - @return: DRC_OK, DRC_FAILED, DRC_NOPROC - -ida_idd.debugger_t.ev_read_registers (variable) - Read thread registers. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_rebase_if_required_to (variable) - Rebase database if the debugged program has been rebased by the system. This - event is generated in the main thread. - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_request_pause (variable) - Prepare to pause the process. Normally the next get_debug_event() will pause the - process If the process is sleeping, then the pause will not occur until the - process wakes up. If the debugger module does not react to this event, then it - will be impossible to pause the program. This event is generated in debthread. - Available if DBG_HAS_REQUEST_PAUSE is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_resume (variable) - Continue after handling the event. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_rexec (variable) - Execute a command on the remote computer. Available if DBG_HAS_REXEC is set - - @return: (int) exit code - -ida_idd.debugger_t.ev_send_ioctl (variable) - Perform a debugger-specific event. This event is generated in debthread - - @retval DRC_... - -ida_idd.debugger_t.ev_set_exception_info (variable) - Set exception handling. This event is generated in debthread or the main thread. - Available if DBG_HAS_SET_EXCEPTION_INFO is set - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_set_resume_mode (variable) - Specify resume action Available if DBG_HAS_SET_RESUME_MODE is set - -ida_idd.debugger_t.ev_start_process (variable) - Start an executable to debug. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_CRC, DRC_FAILED, DRC_NETERR, DRC_NOFILE - -ida_idd.debugger_t.ev_suspended (variable) - This event will be generated by the kernel each time it has suspended the - debuggee process and refreshed the database. The debugger module may add - information to the database if necessary. - - The reason for introducing this event is that when an event like LOAD_DLL - happens, the database does not reflect the memory state yet and therefore we - can't add information about the dll into the database in the get_debug_event() - function. Only when the kernel has adjusted the database we can do it. Example: - for loaded PE DLLs we can add the exported function names to the list of debug - names (see set_debug_names()). - - This event is generated in the main thread. - - @return: DRC_NONE, DRC_OK - -ida_idd.debugger_t.ev_term_debugger (variable) - Terminate debugger. This event is generated in the main thread. - - @return: DRC_OK, DRC_FAILED - -ida_idd.debugger_t.ev_thread_continue (variable) - Resume a suspended thread Available if DBG_HAS_THREAD_CONTINUE is set - -ida_idd.debugger_t.ev_thread_get_sreg_base (variable) - Get information about the base of a segment register. Currently used by the IBM - PC module to resolve references like fs:0. This event is generated in debthread. - Available if DBG_HAS_THREAD_GET_SREG_BASE is set - - @return: DRC_NONE, DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_thread_suspend (variable) - Suspend a running thread Available if DBG_HAS_THREAD_SUSPEND is set - -ida_idd.debugger_t.ev_update_bpts (variable) - Add/del breakpoints. bpts array contains nadd bpts to add, followed by ndel bpts - to del. This event is generated in debthread. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.ev_update_call_stack (variable) - Calculate the call stack trace for the given thread. This event is generated - when the process is suspended and should fill the 'trace' object with the - information about the current call stack. If this event returns DRC_NONE, IDA - will try to invoke a processor-specific mechanism (see - processor_t::ev_update_call_stack). If the current processor module does not - implement stack tracing, then IDA will fall back to a generic algorithm (based - on the frame pointer chain) to calculate the trace. This event is ideal if the - debugging targets manage stack frames in a peculiar way, requiring special - analysis. This event is generated in the main thread. Available if - DBG_HAS_UPDATE_CALL_STACK is set - - @retval DRC_NONE: false or not implemented - @return: DRC_OK success - -ida_idd.debugger_t.ev_update_lowcnds (variable) - Update low-level (server side) breakpoint conditions. This event is generated in - debthread. - - @return: DRC_OK, DRC_NETERR - -ida_idd.debugger_t.ev_write_file (variable) - @retval number: of written bytes - -ida_idd.debugger_t.ev_write_memory (variable) - Write process memory. This event is generated in debthread. - - @retval DRC_OK,DRC_FAILED,DRC_NOPROC - -ida_idd.debugger_t.ev_write_register (variable) - Write one thread register. This event is generated in debthread. Must be - implemented. - - @return: DRC_OK, DRC_FAILED, DRC_NETERR - -ida_idd.debugger_t.eval_lowcnd (method) - eval_lowcnd(self, tid, ea) -> drc_t - - @param tid: thid_t - @param ea: ea_t - -ida_idd.debugger_t.exit_process (method) - exit_process(self) -> drc_t - -ida_idd.debugger_t.fake_memory (method) - fake_memory(self) -> bool - -ida_idd.debugger_t.filetype (variable) - Input file type for the instant debugger. This value will be used after - attaching to a new process. - -ida_idd.debugger_t.flags2 (variable) - Debugger module features - -ida_idd.debugger_t.get_debapp_attrs (method) - get_debapp_attrs(self, out_pattrs) -> bool - - @param out_pattrs: debapp_attrs_t * - -ida_idd.debugger_t.get_debmod_extensions (method) - get_debmod_extensions(self) -> void const * - -ida_idd.debugger_t.get_debug_event (method) - get_debug_event(self, event, timeout_ms) -> gdecode_t - - @param event: debug_event_t * - @param timeout_ms: int - -ida_idd.debugger_t.get_memory_info (method) - get_memory_info(self, ranges) -> drc_t - - @param ranges: meminfo_vec_t & - -ida_idd.debugger_t.get_processes (method) - get_processes(self, procs) -> drc_t - - @param procs: procinfo_vec_t * - -ida_idd.debugger_t.get_srcinfo_path (method) - get_srcinfo_path(self, path, base) -> bool - - @param path: qstring * - @param base: ea_t - -ida_idd.debugger_t.has_appcall (method) - has_appcall(self) -> bool - -ida_idd.debugger_t.has_attach_process (method) - has_attach_process(self) -> bool - -ida_idd.debugger_t.has_check_bpt (method) - has_check_bpt(self) -> bool - -ida_idd.debugger_t.has_detach_process (method) - has_detach_process(self) -> bool - -ida_idd.debugger_t.has_get_processes (method) - has_get_processes(self) -> bool - -ida_idd.debugger_t.has_map_address (method) - has_map_address(self) -> bool - -ida_idd.debugger_t.has_open_file (method) - has_open_file(self) -> bool - -ida_idd.debugger_t.has_request_pause (method) - has_request_pause(self) -> bool - -ida_idd.debugger_t.has_rexec (method) - has_rexec(self) -> bool - -ida_idd.debugger_t.has_set_exception_info (method) - has_set_exception_info(self) -> bool - -ida_idd.debugger_t.has_set_resume_mode (method) - has_set_resume_mode(self) -> bool - -ida_idd.debugger_t.has_soft_bpt (method) - has_soft_bpt(self) -> bool - -ida_idd.debugger_t.has_thread_continue (method) - has_thread_continue(self) -> bool - -ida_idd.debugger_t.has_thread_get_sreg_base (method) - has_thread_get_sreg_base(self) -> bool - -ida_idd.debugger_t.has_thread_suspend (method) - has_thread_suspend(self) -> bool - -ida_idd.debugger_t.has_update_call_stack (method) - has_update_call_stack(self) -> bool - -ida_idd.debugger_t.id (variable) - one of Debugger API module id - -ida_idd.debugger_t.init_debugger (method) - init_debugger(self, hostname, portnum, password) -> bool - - @param hostname: char const * - @param portnum: int - @param password: char const * - -ida_idd.debugger_t.is_remote (method) - is_remote(self) -> bool - -ida_idd.debugger_t.is_resmod_avail (method) - is_resmod_avail(self, resmod) -> bool - - @param resmod: int - -ida_idd.debugger_t.is_safe (method) - is_safe(self) -> bool - -ida_idd.debugger_t.is_tracing_enabled (method) - is_tracing_enabled(self, tid, tracebit) -> bool - - @param tid: thid_t - @param tracebit: int - -ida_idd.debugger_t.map_address (method) - map_address(self, off, regs, regnum) -> ea_t - - @param off: ea_t - @param regs: regval_t const * - @param regnum: int - -ida_idd.debugger_t.may_disturb (method) - may_disturb(self) -> bool - -ida_idd.debugger_t.may_take_exit_snapshot (method) - may_take_exit_snapshot(self) -> bool - -ida_idd.debugger_t.memory_page_size (variable) - Size of a memory page. Usually 4K. - -ida_idd.debugger_t.must_have_hostname (method) - must_have_hostname(self) -> bool - -ida_idd.debugger_t.name (variable) - Short debugger name like win32 or linux. - -ida_idd.debugger_t.nregs (variable) - Number of registers. - -ida_idd.debugger_t.open_file (method) - open_file(self, file, fsize, readonly) -> int - - @param file: char const * - @param fsize: uint64 * - @param readonly: bool - -ida_idd.debugger_t.processor (variable) - Required processor name. Used for instant debugging to load the correct - processor module - -ida_idd.debugger_t.read_file (method) - read_file(self, fn, off, buf, size) -> ssize_t - - @param fn: int - @param off: qoff64_t - @param buf: void * - @param size: size_t - -ida_idd.debugger_t.read_memory (method) - read_memory(self, nbytes, ea, buffer, size) -> drc_t - - @param nbytes: size_t * - @param ea: ea_t - @param buffer: void * - @param size: size_t - -ida_idd.debugger_t.read_registers (method) - read_registers(self, tid, clsmask, values) -> drc_t - - @param tid: thid_t - @param clsmask: int - @param values: regval_t * - -ida_idd.debugger_t.rebase_if_required_to (method) - rebase_if_required_to(self, new_base) - - @param new_base: ea_t - -ida_idd.debugger_t.regclasses (variable) - Array of register class names. - -ida_idd.debugger_t.registers (variable) - Array of registers. Use regs() to access it. - -ida_idd.debugger_t.regs (method) - regs(self, idx) -> register_info_t - - @param idx: int - -ida_idd.debugger_t.request_pause (method) - request_pause(self) -> drc_t - -ida_idd.debugger_t.resume (method) - resume(self, event) -> drc_t - - @param event: debug_event_t const * - -ida_idd.debugger_t.resume_modes (variable) - Resume modes - -ida_idd.debugger_t.rexec (method) - rexec(self, cmdline) -> int - - @param cmdline: char const * - -ida_idd.debugger_t.send_ioctl (method) - send_ioctl(self, fn, buf, poutbuf, poutsize) -> drc_t - - @param fn: int - @param buf: void const * - @param poutbuf: void ** - @param poutsize: ssize_t * - -ida_idd.debugger_t.set_exception_info (method) - set_exception_info(self, info, qty) - - @param info: exception_info_t const * - @param qty: int - -ida_idd.debugger_t.set_resume_mode (method) - set_resume_mode(self, tid, resmod) -> drc_t - - @param tid: thid_t - @param resmod: enum resume_mode_t - -ida_idd.debugger_t.start_process (method) - start_process(self, path, args, envs, startdir, dbg_proc_flags, input_path, input_file_crc32) -> drc_t - - @param path: char const * - @param args: char const * - @param envs: launch_env_t * - @param startdir: char const * - @param dbg_proc_flags: uint32 - @param input_path: char const * - @param input_file_crc32: uint32 - -ida_idd.debugger_t.supports_debthread (method) - supports_debthread(self) -> bool - -ida_idd.debugger_t.supports_lowcnds (method) - supports_lowcnds(self) -> bool - -ida_idd.debugger_t.suspended (method) - suspended(self, dlls_added, thr_names=None) - - @param dlls_added: bool - @param thr_names: thread_name_vec_t * - -ida_idd.debugger_t.term_debugger (method) - term_debugger(self) -> bool - -ida_idd.debugger_t.thread_continue (method) - thread_continue(self, tid) -> drc_t - - @param tid: thid_t - -ida_idd.debugger_t.thread_get_sreg_base (method) - thread_get_sreg_base(self, answer, tid, sreg_value) -> drc_t - - @param answer: ea_t * - @param tid: thid_t - @param sreg_value: int - -ida_idd.debugger_t.thread_suspend (method) - thread_suspend(self, tid) -> drc_t - - @param tid: thid_t - -ida_idd.debugger_t.update_bpts (method) - update_bpts(self, nbpts, bpts, nadd, ndel) -> drc_t - - @param nbpts: int * - @param bpts: update_bpt_info_t * - @param nadd: int - @param ndel: int - -ida_idd.debugger_t.update_call_stack (method) - update_call_stack(self, tid, trace) -> drc_t - - @param tid: thid_t - @param trace: call_stack_t * - -ida_idd.debugger_t.update_lowcnds (method) - update_lowcnds(self, nupdated, lowcnds, nlowcnds) -> drc_t - - @param nupdated: int * - @param lowcnds: lowcnd_t const * - @param nlowcnds: int - -ida_idd.debugger_t.use_memregs (method) - use_memregs(self) -> bool - -ida_idd.debugger_t.use_sregs (method) - use_sregs(self) -> bool - -ida_idd.debugger_t.version (variable) - Expected kernel version, should be IDD_INTERFACE_VERSION - -ida_idd.debugger_t.virtual_threads (method) - virtual_threads(self) -> bool - -ida_idd.debugger_t.write_file (method) - write_file(self, fn, off, buf) -> ssize_t - - @param fn: int - @param off: qoff64_t - @param buf: void const * - -ida_idd.debugger_t.write_memory (method) - write_memory(self, nbytes, ea, buffer, size) -> drc_t - - @param nbytes: size_t * - @param ea: ea_t - @param buffer: void const * - @param size: size_t - -ida_idd.debugger_t.write_register (method) - write_register(self, tid, regidx, value) -> drc_t - - @param tid: thid_t - @param regidx: int - @param value: regval_t const * - -ida_idd.dyn_register_info_array (class) - Proxy of C++ dynamic_wrapped_array_t< register_info_t > class. - -ida_idd.dyn_register_info_array.__getitem__ (method) - __getitem__(self, i) -> register_info_t - - @param i: size_t - -ida_idd.dyn_register_info_array.__init__ (method) - __init__(self, _data, _count) -> dyn_register_info_array - - @param _data: register_info_t * - @param _count: size_t - -ida_idd.dyn_register_info_array.__len__ (method) - __len__(self) -> size_t - -ida_idd.dyn_register_info_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: register_info_t const & - -ida_idd.exception_info_t (class) - Proxy of C++ exception_info_t class. - -ida_idd.exception_info_t.__init__ (method) - __init__(self) -> exception_info_t - __init__(self, _code, _flags, _name, _desc) -> exception_info_t - - @param _code: uint - @param _flags: uint32 - @param _name: char const * - @param _desc: char const * - -ida_idd.exception_info_t.break_on (method) - break_on(self) -> bool - Should we break on the exception? - -ida_idd.exception_info_t.code (variable) - exception code - -ida_idd.exception_info_t.desc (variable) - Long message used to display info about the exception. - -ida_idd.exception_info_t.flags (variable) - Exception info flags - -ida_idd.exception_info_t.handle (method) - handle(self) -> bool - Should we handle the exception? - -ida_idd.exception_info_t.name (variable) - Exception standard name. - -ida_idd.excinfo_t (class) - Proxy of C++ excinfo_t class. - -ida_idd.excinfo_t.__init__ (method) - __init__(self) -> excinfo_t - -ida_idd.excinfo_t.can_cont (variable) - Execution of the process can continue after this exception? - -ida_idd.excinfo_t.code (variable) - Exception code. - -ida_idd.excinfo_t.ea (variable) - Possible address referenced by the exception. - -ida_idd.excinfo_t.info (variable) - Exception message. - -ida_idd.excvec_t (class) - Proxy of C++ qvector< exception_info_t > class. - -ida_idd.excvec_t.__getitem__ (method) - __getitem__(self, i) -> exception_info_t - - @param i: size_t - -ida_idd.excvec_t.__init__ (method) - __init__(self) -> excvec_t - __init__(self, x) -> excvec_t - - @param x: qvector< exception_info_t > const & - -ida_idd.excvec_t.__len__ (method) - __len__(self) -> size_t - -ida_idd.excvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: exception_info_t const & - -ida_idd.excvec_t.at (method) - at(self, _idx) -> exception_info_t - - @param _idx: size_t - -ida_idd.excvec_t.begin (method) - begin(self) -> exception_info_t - -ida_idd.excvec_t.capacity (method) - capacity(self) -> size_t - -ida_idd.excvec_t.clear (method) - clear(self) - -ida_idd.excvec_t.empty (method) - empty(self) -> bool - -ida_idd.excvec_t.end (method) - end(self) -> exception_info_t - -ida_idd.excvec_t.erase (method) - erase(self, it) -> exception_info_t - - @param it: qvector< exception_info_t >::iterator - - erase(self, first, last) -> exception_info_t - - @param first: qvector< exception_info_t >::iterator - @param last: qvector< exception_info_t >::iterator - -ida_idd.excvec_t.extract (method) - extract(self) -> exception_info_t - -ida_idd.excvec_t.grow (method) - grow(self, x=exception_info_t()) - - @param x: exception_info_t const & - -ida_idd.excvec_t.inject (method) - inject(self, s, len) - - @param s: exception_info_t * - @param len: size_t - -ida_idd.excvec_t.insert (method) - insert(self, it, x) -> exception_info_t - - @param it: qvector< exception_info_t >::iterator - @param x: exception_info_t const & - -ida_idd.excvec_t.pop_back (method) - pop_back(self) - -ida_idd.excvec_t.push_back (method) - push_back(self, x) - - @param x: exception_info_t const & - - push_back(self) -> exception_info_t - -ida_idd.excvec_t.qclear (method) - qclear(self) - -ida_idd.excvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idd.excvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: exception_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idd.excvec_t.size (method) - size(self) -> size_t - -ida_idd.excvec_t.swap (method) - swap(self, r) - - @param r: qvector< exception_info_t > & - -ida_idd.excvec_t.truncate (method) - truncate(self) - -ida_idd.get_dbg (function) - get_dbg() -> debugger_t - -ida_idd.get_event_bpt_hea (function) - get_event_bpt_hea(ev) -> ea_t - - @param ev: debug_event_t const * - -ida_idd.get_event_exc_code (function) - get_event_exc_code(ev) -> uint - - @param ev: debug_event_t const * - -ida_idd.get_event_exc_ea (function) - get_event_exc_ea(ev) -> ea_t - - @param ev: debug_event_t const * - -ida_idd.get_event_exc_info (function) - get_event_exc_info(ev) -> str - - @param ev: debug_event_t const * - -ida_idd.get_event_info (function) - get_event_info(ev) -> str - - @param ev: debug_event_t const * - -ida_idd.get_event_module_base (function) - get_event_module_base(ev) -> ea_t - - @param ev: debug_event_t const * - -ida_idd.get_event_module_name (function) - get_event_module_name(ev) -> str - - @param ev: debug_event_t const * - -ida_idd.get_event_module_size (function) - get_event_module_size(ev) -> asize_t - - @param ev: debug_event_t const * - -ida_idd.launch_env_t (class) - Proxy of C++ launch_env_t class. - -ida_idd.launch_env_t.__init__ (method) - __init__(self) -> launch_env_t - -ida_idd.meminfo_vec_t (class) - Proxy of C++ meminfo_vec_t class. - -ida_idd.meminfo_vec_t.__init__ (method) - __init__(self) -> meminfo_vec_t - -ida_idd.meminfo_vec_template_t (class) - Proxy of C++ qvector< memory_info_t > class. - -ida_idd.meminfo_vec_template_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< memory_info_t > const & - -ida_idd.meminfo_vec_template_t.__getitem__ (method) - __getitem__(self, i) -> memory_info_t - - @param i: size_t - -ida_idd.meminfo_vec_template_t.__init__ (method) - __init__(self) -> meminfo_vec_template_t - __init__(self, x) -> meminfo_vec_template_t - - @param x: qvector< memory_info_t > const & - -ida_idd.meminfo_vec_template_t.__len__ (method) - __len__(self) -> size_t - -ida_idd.meminfo_vec_template_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< memory_info_t > const & - -ida_idd.meminfo_vec_template_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: memory_info_t const & - -ida_idd.meminfo_vec_template_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.at (method) - at(self, _idx) -> memory_info_t - - @param _idx: size_t - -ida_idd.meminfo_vec_template_t.begin (method) - begin(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.capacity (method) - capacity(self) -> size_t - -ida_idd.meminfo_vec_template_t.clear (method) - clear(self) - -ida_idd.meminfo_vec_template_t.empty (method) - empty(self) -> bool - -ida_idd.meminfo_vec_template_t.end (method) - end(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.erase (method) - erase(self, it) -> memory_info_t - - @param it: qvector< memory_info_t >::iterator - - erase(self, first, last) -> memory_info_t - - @param first: qvector< memory_info_t >::iterator - @param last: qvector< memory_info_t >::iterator - -ida_idd.meminfo_vec_template_t.extract (method) - extract(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.find (method) - find(self, x) -> memory_info_t - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.grow (method) - grow(self, x=memory_info_t()) - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.has (method) - has(self, x) -> bool - - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.inject (method) - inject(self, s, len) - - @param s: memory_info_t * - @param len: size_t - -ida_idd.meminfo_vec_template_t.insert (method) - insert(self, it, x) -> memory_info_t - - @param it: qvector< memory_info_t >::iterator - @param x: memory_info_t const & - -ida_idd.meminfo_vec_template_t.pop_back (method) - pop_back(self) - -ida_idd.meminfo_vec_template_t.push_back (method) - push_back(self, x) - - @param x: memory_info_t const & - - push_back(self) -> memory_info_t - -ida_idd.meminfo_vec_template_t.qclear (method) - qclear(self) - -ida_idd.meminfo_vec_template_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idd.meminfo_vec_template_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: memory_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idd.meminfo_vec_template_t.size (method) - size(self) -> size_t - -ida_idd.meminfo_vec_template_t.swap (method) - swap(self, r) - - @param r: qvector< memory_info_t > & - -ida_idd.meminfo_vec_template_t.truncate (method) - truncate(self) - -ida_idd.memory_info_t (class) - Proxy of C++ memory_info_t class. - -ida_idd.memory_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: memory_info_t const & - -ida_idd.memory_info_t.__init__ (method) - __init__(self) -> memory_info_t - -ida_idd.memory_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: memory_info_t const & - -ida_idd.memory_info_t.bitness (variable) - Number of bits in segment addresses (0-16bit, 1-32bit, 2-64bit) - -ida_idd.memory_info_t.name (variable) - Memory range name. - -ida_idd.memory_info_t.perm (variable) - Memory range permissions (0-no information): see segment.hpp. - -ida_idd.memory_info_t.sbase (variable) - Segment base (meaningful only for segmented architectures, e.g. 16-bit x86) The - base is specified in paragraphs (i.e. shifted to the right by 4) - -ida_idd.memory_info_t.sclass (variable) - Memory range class name. - -ida_idd.modinfo_t (class) - Proxy of C++ modinfo_t class. - -ida_idd.modinfo_t.__init__ (method) - __init__(self) -> modinfo_t - -ida_idd.modinfo_t.base (variable) - module base address. if unknown pass BADADDR - -ida_idd.modinfo_t.name (variable) - full name of the module - -ida_idd.modinfo_t.rebase_to (variable) - if not BADADDR, then rebase the program to the specified address - -ida_idd.modinfo_t.size (variable) - module size. if unknown pass 0 - -ida_idd.process_info_t (class) - Proxy of C++ process_info_t class. - -ida_idd.process_info_t.__init__ (method) - __init__(self) -> process_info_t - -ida_idd.process_info_t.name (variable) - process name - -ida_idd.process_info_t.pid (variable) - process id - -ida_idd.procinfo_vec_t (class) - Proxy of C++ qvector< process_info_t > class. - -ida_idd.procinfo_vec_t.__getitem__ (method) - __getitem__(self, i) -> process_info_t - - @param i: size_t - -ida_idd.procinfo_vec_t.__init__ (method) - __init__(self) -> procinfo_vec_t - __init__(self, x) -> procinfo_vec_t - - @param x: qvector< process_info_t > const & - -ida_idd.procinfo_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_idd.procinfo_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: process_info_t const & - -ida_idd.procinfo_vec_t.at (method) - at(self, _idx) -> process_info_t - - @param _idx: size_t - -ida_idd.procinfo_vec_t.begin (method) - begin(self) -> process_info_t - -ida_idd.procinfo_vec_t.capacity (method) - capacity(self) -> size_t - -ida_idd.procinfo_vec_t.clear (method) - clear(self) - -ida_idd.procinfo_vec_t.empty (method) - empty(self) -> bool - -ida_idd.procinfo_vec_t.end (method) - end(self) -> process_info_t - -ida_idd.procinfo_vec_t.erase (method) - erase(self, it) -> process_info_t - - @param it: qvector< process_info_t >::iterator - - erase(self, first, last) -> process_info_t - - @param first: qvector< process_info_t >::iterator - @param last: qvector< process_info_t >::iterator - -ida_idd.procinfo_vec_t.extract (method) - extract(self) -> process_info_t - -ida_idd.procinfo_vec_t.grow (method) - grow(self, x=process_info_t()) - - @param x: process_info_t const & - -ida_idd.procinfo_vec_t.inject (method) - inject(self, s, len) - - @param s: process_info_t * - @param len: size_t - -ida_idd.procinfo_vec_t.insert (method) - insert(self, it, x) -> process_info_t - - @param it: qvector< process_info_t >::iterator - @param x: process_info_t const & - -ida_idd.procinfo_vec_t.pop_back (method) - pop_back(self) - -ida_idd.procinfo_vec_t.push_back (method) - push_back(self, x) - - @param x: process_info_t const & - - push_back(self) -> process_info_t - -ida_idd.procinfo_vec_t.qclear (method) - qclear(self) - -ida_idd.procinfo_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idd.procinfo_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: process_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idd.procinfo_vec_t.size (method) - size(self) -> size_t - -ida_idd.procinfo_vec_t.swap (method) - swap(self, r) - - @param r: qvector< process_info_t > & - -ida_idd.procinfo_vec_t.truncate (method) - truncate(self) - -ida_idd.register_info_t (class) - Proxy of C++ register_info_t class. - -ida_idd.register_info_t.__get_bit_strings (method) - __get_bit_strings(self) -> PyObject * - -ida_idd.register_info_t.__init__ (method) - __init__(self) -> register_info_t - -ida_idd.register_info_t.bit_strings (variable) - strings corresponding to each bit of the register. (nullptr = no bit, same name - = multi-bits mask) - -ida_idd.register_info_t.default_bit_strings_mask (variable) - mask of default bits - -ida_idd.register_info_t.dtype (variable) - Register size (see Operand value types) - -ida_idd.register_info_t.flags (variable) - Register info attribute flags - -ida_idd.register_info_t.name (variable) - Register name. - -ida_idd.register_info_t.register_class (variable) - segment, mmx, etc. - -ida_idd.regval_t (class) - Proxy of C++ regval_t class. - -ida_idd.regval_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: regval_t const & - -ida_idd.regval_t.__init__ (method) - __init__(self) -> regval_t - __init__(self, r) -> regval_t - - @param r: regval_t const & - -ida_idd.regval_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: regval_t const & - -ida_idd.regval_t.bytes (method) - bytes(self) -> bytevec_t - Get const custom value. - bytes(self) -> bytevec_t const & - -ida_idd.regval_t.clear (method) - clear(self) - Clear register value. - -ida_idd.regval_t.fval (variable) - 12: floating point value in the internal representation (see ieee.h) - -ida_idd.regval_t.get_data (method) - get_data(self) - Get const pointer to value. - get_data(self) -> void const * - -ida_idd.regval_t.get_data_size (method) - get_data_size(self) -> size_t - Get size of value. - -ida_idd.regval_t.ival (variable) - 8: integer value - -ida_idd.regval_t.pyval (method) - pyval(self, dtype) -> PyObject * - - @param dtype: op_dtype_t - -ida_idd.regval_t.rvtype (variable) - one of Register value types - -ida_idd.regval_t.set_bytes (method) - set_bytes(self, data, size) - Initialize this regval to an empty custom value. - - @param data: uchar const * - @param size: size_t - - set_bytes(self, v) - - @param v: bytevec_t const & - - set_bytes(self) -> bytevec_t & - -ida_idd.regval_t.set_float (method) - set_float(self, x) - Set float value (fval) - - @param x: (C++: const fpvalue_t &) fpvalue_t const & - -ida_idd.regval_t.set_int (method) - set_int(self, x) - - @param x: uint64 - -ida_idd.regval_t.set_pyval (method) - set_pyval(self, o, dtype) -> bool - - @param o: PyObject * - @param dtype: op_dtype_t - -ida_idd.regval_t.set_unavailable (method) - set_unavailable(self) - Mark as unavailable. - -ida_idd.regval_t.swap (method) - swap(self, r) - Set this = r and r = this. - - @param r: (C++: regval_t &) - -ida_idd.regvals_t (class) - Proxy of C++ qvector< regval_t > class. - -ida_idd.regvals_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< regval_t > const & - -ida_idd.regvals_t.__getitem__ (method) - __getitem__(self, i) -> regval_t - - @param i: size_t - -ida_idd.regvals_t.__init__ (method) - __init__(self) -> regvals_t - __init__(self, x) -> regvals_t - - @param x: qvector< regval_t > const & - -ida_idd.regvals_t.__len__ (method) - __len__(self) -> size_t - -ida_idd.regvals_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< regval_t > const & - -ida_idd.regvals_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regval_t const & - -ida_idd.regvals_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: regval_t const & - -ida_idd.regvals_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: regval_t const & - -ida_idd.regvals_t.at (method) - at(self, _idx) -> regval_t - - @param _idx: size_t - -ida_idd.regvals_t.begin (method) - begin(self) -> regval_t - -ida_idd.regvals_t.capacity (method) - capacity(self) -> size_t - -ida_idd.regvals_t.clear (method) - clear(self) - -ida_idd.regvals_t.empty (method) - empty(self) -> bool - -ida_idd.regvals_t.end (method) - end(self) -> regval_t - -ida_idd.regvals_t.erase (method) - erase(self, it) -> regval_t - - @param it: qvector< regval_t >::iterator - - erase(self, first, last) -> regval_t - - @param first: qvector< regval_t >::iterator - @param last: qvector< regval_t >::iterator - -ida_idd.regvals_t.extract (method) - extract(self) -> regval_t - -ida_idd.regvals_t.find (method) - find(self, x) -> regval_t - - @param x: regval_t const & - -ida_idd.regvals_t.grow (method) - grow(self, x=regval_t()) - - @param x: regval_t const & - -ida_idd.regvals_t.has (method) - has(self, x) -> bool - - @param x: regval_t const & - -ida_idd.regvals_t.inject (method) - inject(self, s, len) - - @param s: regval_t * - @param len: size_t - -ida_idd.regvals_t.insert (method) - insert(self, it, x) -> regval_t - - @param it: qvector< regval_t >::iterator - @param x: regval_t const & - -ida_idd.regvals_t.pop_back (method) - pop_back(self) - -ida_idd.regvals_t.push_back (method) - push_back(self, x) - - @param x: regval_t const & - - push_back(self) -> regval_t - -ida_idd.regvals_t.qclear (method) - qclear(self) - -ida_idd.regvals_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idd.regvals_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: regval_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idd.regvals_t.size (method) - size(self) -> size_t - -ida_idd.regvals_t.swap (method) - swap(self, r) - - @param r: qvector< regval_t > & - -ida_idd.regvals_t.truncate (method) - truncate(self) - -ida_idd.scattered_segm_t (class) - Proxy of C++ scattered_segm_t class. - -ida_idd.scattered_segm_t.__init__ (method) - __init__(self) -> scattered_segm_t - -ida_idd.scattered_segm_t.name (variable) - name of the segment - -ida_idd.set_debug_event_code (function) - set_debug_event_code(ev, id) - - @param ev: debug_event_t * - @param id: enum event_id_t - -ida_idd.thread_name_t (class) - Proxy of C++ thread_name_t class. - -ida_idd.thread_name_t.__init__ (method) - __init__(self) -> thread_name_t - -ida_idd.thread_name_t.name (variable) - new thread name - -ida_idd.thread_name_t.tid (variable) - thread - -ida_idp (module) - Contains definition of the interface to IDP modules. - - The interface consists of two structures: - * definition of target assembler: ::ash - * definition of current processor: ::ph - - These structures contain information about target processor and assembler - features. - - It also defines two groups of kernel events: - * processor_t::event_t processor related events - * idb_event:event_code_t database related events - - The processor related events are used to communicate with the processor module. - The database related events are used to inform any interested parties, like - plugins or processor modules, about the changes in the database. - -ida_idp.AS2_BRACE (variable) - Use braces for all expressions. - -ida_idp.AS2_BYTE1CHAR (variable) - One symbol per processor byte. Meaningful only for wide byte processors - -ida_idp.AS2_COLONSUF (variable) - addresses may have ":xx" suffix; this suffix must be ignored when extracting the - address under the cursor - -ida_idp.AS2_IDEALDSCR (variable) - Description of struc/union is in the 'reverse' form (keyword before name), the - same as in borland tasm ideal - -ida_idp.AS2_STRINV (variable) - Invert meaning of idainfo::wide_high_byte_first for text strings (for processors - with bytes bigger than 8 bits) - -ida_idp.AS2_TERSESTR (variable) - 'terse' structure initialization form; NAME<fld,fld,...> is supported - -ida_idp.AS2_YWORD (variable) - a_yword field is present and valid - -ida_idp.AS2_ZWORD (variable) - a_zword field is present and valid - -ida_idp.ASB_BINF0 (variable) - 010101b - -ida_idp.ASB_BINF1 (variable) - ^B010101 - -ida_idp.ASB_BINF2 (variable) - %010101 - -ida_idp.ASB_BINF3 (variable) - 0b1010101 - -ida_idp.ASB_BINF4 (variable) - b'1010101 - -ida_idp.ASB_BINF5 (variable) - b'1010101' - -ida_idp.ASD_DECF0 (variable) - 34 - -ida_idp.ASD_DECF1 (variable) - #34 - -ida_idp.ASD_DECF2 (variable) - 34. - -ida_idp.ASD_DECF3 (variable) - .34 - -ida_idp.ASH_HEXF0 (variable) - 34h - -ida_idp.ASH_HEXF1 (variable) - h'34 - -ida_idp.ASH_HEXF2 (variable) - 34 - -ida_idp.ASH_HEXF3 (variable) - 0x34 - -ida_idp.ASH_HEXF4 (variable) - $34 - -ida_idp.ASH_HEXF5 (variable) - <^R > (radix) - -ida_idp.ASO_OCTF0 (variable) - 123o - -ida_idp.ASO_OCTF1 (variable) - 0123 - -ida_idp.ASO_OCTF2 (variable) - 123 - -ida_idp.ASO_OCTF3 (variable) - @123 - -ida_idp.ASO_OCTF4 (variable) - o'123 - -ida_idp.ASO_OCTF5 (variable) - 123q - -ida_idp.ASO_OCTF6 (variable) - ~123 - -ida_idp.ASO_OCTF7 (variable) - q'123 - -ida_idp.AS_1TEXT (variable) - 1 text per line, no bytes - -ida_idp.AS_2CHRE (variable) - double char constants are: "xy - -ida_idp.AS_ALIGN2 (variable) - .align directive expects an exponent rather than a power of 2 (.align 5 means to - align at 32byte boundary) - -ida_idp.AS_ASCIIC (variable) - ascii directive accepts C-like escape sequences (\n,\x01 and similar) - -ida_idp.AS_ASCIIZ (variable) - ascii directive inserts implicit zero byte at the end - -ida_idp.AS_BINFM (variable) - mask - binary number format - -ida_idp.AS_COLON (variable) - create colons after data names ? - -ida_idp.AS_DECFM (variable) - mask - decimal number format - -ida_idp.AS_HEXFM (variable) - mask - hex number format - -ida_idp.AS_LALIGN (variable) - Labels at "align" keyword are supported. - -ida_idp.AS_N2CHR (variable) - can't have 2 byte char consts - -ida_idp.AS_NCHRE (variable) - char constants are: 'x - -ida_idp.AS_NCMAS (variable) - no commas in ascii directives - -ida_idp.AS_NHIAS (variable) - no characters with high bit - -ida_idp.AS_NOCODECLN (variable) - don't create colons after code names - -ida_idp.AS_NOSPACE (variable) - No spaces in expressions. - -ida_idp.AS_NOXRF (variable) - Disable xrefs during the output file generation. - -ida_idp.AS_OCTFM (variable) - mask - octal number format - -ida_idp.AS_OFFST (variable) - offsets are 'offset xxx' ? - -ida_idp.AS_ONEDUP (variable) - One array definition per line. - -ida_idp.AS_RELSUP (variable) - Checkarg: 'and','or','xor' operations with addresses are possible. - -ida_idp.AS_UDATA (variable) - can use '?' in data directives - -ida_idp.AS_UNEQU (variable) - replace undefined data items with EQU (for ANTA's A80) - -ida_idp.AS_XTRNTYPE (variable) - Assembler understands type of extern symbols as ":type" suffix. - -ida_idp.AssembleLine (function) - AssembleLine(ea, cs, ip, use32, nonnul_line) -> bytes - 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 nonnul_line: char const * - @return: - None on failure - - or a string containing the assembled instruction - -ida_idp.CF_CALL (variable) - CALL instruction (should make a procedure here) - -ida_idp.CF_CHG1 (variable) - The instruction modifies the first operand. - -ida_idp.CF_CHG2 (variable) - The instruction modifies the second operand. - -ida_idp.CF_CHG3 (variable) - The instruction modifies the third operand. - -ida_idp.CF_CHG4 (variable) - The instruction modifies the fourth operand. - -ida_idp.CF_CHG5 (variable) - The instruction modifies the fifth operand. - -ida_idp.CF_CHG6 (variable) - The instruction modifies the sixth operand. - -ida_idp.CF_CHG7 (variable) - The instruction modifies the seventh operand. - -ida_idp.CF_CHG8 (variable) - The instruction modifies the eighth operand. - -ida_idp.CF_HLL (variable) - Instruction may be present in a high level language function - -ida_idp.CF_JUMP (variable) - The instruction passes execution using indirect jump or call (thus needs - additional analysis) - -ida_idp.CF_SHFT (variable) - Bit-shift instruction (shl,shr...) - -ida_idp.CF_STOP (variable) - Instruction doesn't pass execution to the next instruction - -ida_idp.CF_USE1 (variable) - The instruction uses value of the first operand. - -ida_idp.CF_USE2 (variable) - The instruction uses value of the second operand. - -ida_idp.CF_USE3 (variable) - The instruction uses value of the third operand. - -ida_idp.CF_USE4 (variable) - The instruction uses value of the fourth operand. - -ida_idp.CF_USE5 (variable) - The instruction uses value of the fifth operand. - -ida_idp.CF_USE6 (variable) - The instruction uses value of the sixth operand. - -ida_idp.CF_USE7 (variable) - The instruction uses value of the seventh operand. - -ida_idp.CF_USE8 (variable) - The instruction uses value of the eighth operand. - -ida_idp.CUSTOM_INSN_ITYPE (variable) - Custom instruction codes defined by processor extension plugins must be greater - than or equal to this - -ida_idp.HKCB_GLOBAL (variable) - is global event listener? if true, the listener will survive database closing - and opening. it will stay in the memory until explicitly unhooked. otherwise the - kernel will delete it as soon as the owner is unloaded. should be used only with - PLUGIN_FIX plugins. - -ida_idp.IDB_Hooks (class) - Proxy of C++ IDB_Hooks class. - -ida_idp.IDB_Hooks.__disown__ (method) - -ida_idp.IDB_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> IDB_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 - -ida_idp.IDB_Hooks.adding_segm (method) - adding_segm(self, s) - A segment is being created. - - @param s: (segment_t *) - -ida_idp.IDB_Hooks.allsegs_moved (method) - allsegs_moved(self, info) - Program rebasing is complete. This event is generated after series of segm_moved - events - - @param info: (segm_move_infos_t *) - -ida_idp.IDB_Hooks.auto_empty (method) - auto_empty(self) - -ida_idp.IDB_Hooks.auto_empty_finally (method) - auto_empty_finally(self) - -ida_idp.IDB_Hooks.bookmark_changed (method) - bookmark_changed(self, index, pos, desc, operation) - Boomarked position changed. - - @param index: (uint32) - @param pos: (::const lochist_entry_t *) - @param desc: (::const char *) - @param operation: (int) 0-added, 1-updated, 2-deleted if desc==nullptr, then the - bookmark was deleted. - -ida_idp.IDB_Hooks.byte_patched (method) - byte_patched(self, ea, old_value) - A byte has been patched. - - @param ea: (::ea_t) - @param old_value: (uint32) - -ida_idp.IDB_Hooks.callee_addr_changed (method) - callee_addr_changed(self, ea, callee) - Callee address has been updated by the user. - - @param ea: (::ea_t) - @param callee: (::ea_t) - -ida_idp.IDB_Hooks.changing_cmt (method) - changing_cmt(self, ea, repeatable_cmt, newcmt) - An item comment is to be changed. - - @param ea: (::ea_t) - @param repeatable_cmt: (bool) - @param newcmt: (const char *) - -ida_idp.IDB_Hooks.changing_enum_bf (method) - changing_enum_bf(self, id, new_bf) - An enum type 'bitfield' attribute is to be changed. - - @param id: (enum_t) - @param new_bf: (bool) - -ida_idp.IDB_Hooks.changing_enum_cmt (method) - changing_enum_cmt(self, id, repeatable, newcmt) - An enum or member type comment is to be changed. - - @param id: (tid_t) - @param repeatable: (bool) - @param newcmt: (const char *) - -ida_idp.IDB_Hooks.changing_op_ti (method) - changing_op_ti(self, ea, n, new_type, new_fnames) - An operand typestring (c/c++ prototype) is to be changed. - - @param ea: (::ea_t) - @param n: (int) - @param new_type: (const type_t *) - @param new_fnames: (const p_list *) - -ida_idp.IDB_Hooks.changing_op_type (method) - changing_op_type(self, ea, n, opinfo) - An operand type (offset, hex, etc...) is to be changed. - - @param ea: (::ea_t) - @param n: (int) eventually or'ed with OPND_OUTER or OPND_ALL - @param opinfo: (const opinfo_t *) additional operand info - -ida_idp.IDB_Hooks.changing_range_cmt (method) - changing_range_cmt(self, kind, a, cmt, repeatable) - Range comment is to be changed. - - @param kind: (range_kind_t) - @param a: (const range_t *) - @param cmt: (const char *) - @param repeatable: (bool) - -ida_idp.IDB_Hooks.changing_segm_class (method) - changing_segm_class(self, s) - Segment class is being changed. - - @param s: (segment_t *) - -ida_idp.IDB_Hooks.changing_segm_end (method) - changing_segm_end(self, s, new_end, segmod_flags) - Segment end address is to be changed. - - @param s: (segment_t *) - @param new_end: (::ea_t) - @param segmod_flags: (int) - -ida_idp.IDB_Hooks.changing_segm_name (method) - changing_segm_name(self, s, oldname) - Segment name is being changed. - - @param s: (segment_t *) - @param oldname: (const char *) - -ida_idp.IDB_Hooks.changing_segm_start (method) - changing_segm_start(self, s, new_start, segmod_flags) - Segment start address is to be changed. - - @param s: (segment_t *) - @param new_start: (::ea_t) - @param segmod_flags: (int) - -ida_idp.IDB_Hooks.changing_struc_align (method) - changing_struc_align(self, sptr) - A structure type is being changed (the struct alignment). - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.changing_struc_cmt (method) - changing_struc_cmt(self, struc_id, repeatable, newcmt) - A structure type comment is to be changed. - - @param struc_id: (tid_t) - @param repeatable: (bool) - @param newcmt: (const char *) - -ida_idp.IDB_Hooks.changing_struc_member (method) - changing_struc_member(self, sptr, mptr, flag, ti, nbytes) - A structure member is to be changed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - @param flag: (flags64_t) - @param ti: (const opinfo_t *) - @param nbytes: (::asize_t) - -ida_idp.IDB_Hooks.changing_ti (method) - changing_ti(self, ea, new_type, new_fnames) - An item typestring (c/c++ prototype) is to be changed. - - @param ea: (::ea_t) - @param new_type: (const type_t *) - @param new_fnames: (const p_list *) - -ida_idp.IDB_Hooks.closebase (method) - closebase(self) - The database will be closed now. - -ida_idp.IDB_Hooks.cmt_changed (method) - cmt_changed(self, ea, repeatable_cmt) - An item comment has been changed. - - @param ea: (::ea_t) - @param repeatable_cmt: (bool) - -ida_idp.IDB_Hooks.compiler_changed (method) - compiler_changed(self, adjust_inf_fields) - The kernel has changed the compiler information. ( idainfo::cc structure; - get_abi_name) - - @param adjust_inf_fields: (::bool) may change inf fields? - -ida_idp.IDB_Hooks.deleting_enum (method) - deleting_enum(self, id) - An enum type is to be deleted. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.deleting_enum_member (method) - deleting_enum_member(self, id, cid) - An enum member is to be deleted. - - @param id: (enum_t) - @param cid: (const_t) - -ida_idp.IDB_Hooks.deleting_func (method) - deleting_func(self, pfn) - The kernel is about to delete a function. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.deleting_func_tail (method) - deleting_func_tail(self, pfn, tail) - A function tail chunk is to be removed. - - @param pfn: (func_t *) - @param tail: (const range_t *) - -ida_idp.IDB_Hooks.deleting_segm (method) - deleting_segm(self, start_ea) - A segment is to be deleted. - - @param start_ea: (::ea_t) - -ida_idp.IDB_Hooks.deleting_struc (method) - deleting_struc(self, sptr) - A structure type is to be deleted. - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.deleting_struc_member (method) - deleting_struc_member(self, sptr, mptr) - A structure member is to be deleted. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.deleting_tryblks (method) - deleting_tryblks(self, range) - About to delete tryblk information in given range - - @param range: (const range_t *) - -ida_idp.IDB_Hooks.destroyed_items (method) - destroyed_items(self, ea1, ea2, will_disable_range) - Instructions/data have been destroyed in [ea1,ea2). - - @param ea1: (::ea_t) - @param ea2: (::ea_t) - @param will_disable_range: (bool) - -ida_idp.IDB_Hooks.determined_main (method) - determined_main(self, main) - The main() function has been determined. - - @param main: (::ea_t) address of the main() function - -ida_idp.IDB_Hooks.dirtree_link (method) - dirtree_link(self, dt, path, link) - - @param dt: (dirtree_t *) - @param path: (::const char *) - @param link: (::bool) - -ida_idp.IDB_Hooks.dirtree_mkdir (method) - dirtree_mkdir(self, dt, path) - - @param dt: (dirtree_t *) - @param path: (::const char *) - -ida_idp.IDB_Hooks.dirtree_move (method) - dirtree_move(self, dt, _from, to) - - @param dt: (dirtree_t *) - @param from: (::const char *) - @param to: (::const char *) - -ida_idp.IDB_Hooks.dirtree_rank (method) - dirtree_rank(self, dt, path, rank) - - @param dt: (dirtree_t *) - @param path: (::const char *) - @param rank: (::size_t) - -ida_idp.IDB_Hooks.dirtree_rmdir (method) - dirtree_rmdir(self, dt, path) - - @param dt: (dirtree_t *) - @param path: (::const char *) - -ida_idp.IDB_Hooks.dirtree_rminode (method) - dirtree_rminode(self, dt, inode) - - @param dt: (dirtree_t *) - @param inode: (inode_t) - -ida_idp.IDB_Hooks.dirtree_segm_moved (method) - dirtree_segm_moved(self, dt) - - @param dt: (dirtree_t *) - -ida_idp.IDB_Hooks.enum_bf_changed (method) - enum_bf_changed(self, id) - An enum type 'bitfield' attribute has been changed. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.enum_cmt_changed (method) - enum_cmt_changed(self, id, repeatable) - An enum or member type comment has been changed. - - @param id: (tid_t) - @param repeatable: (bool) - -ida_idp.IDB_Hooks.enum_created (method) - enum_created(self, id) - An enum type has been created. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.enum_deleted (method) - enum_deleted(self, id) - An enum type has been deleted. - - @param id: (enum_t) - -ida_idp.IDB_Hooks.enum_flag_changed (method) - enum_flag_changed(self, id, F) - Enum flags have been changed. - - @param id: (enum_t) - @param F: (flags64_t) - -ida_idp.IDB_Hooks.enum_member_created (method) - enum_member_created(self, id, cid) - An enum member has been created. - - @param id: (enum_t) - @param cid: (const_t) - -ida_idp.IDB_Hooks.enum_member_deleted (method) - enum_member_deleted(self, id, cid) - An enum member has been deleted. - - @param id: (enum_t) - @param cid: (const_t) - -ida_idp.IDB_Hooks.enum_ordinal_changed (method) - enum_ordinal_changed(self, id, ord) - Enum mapping to a local type has been changed. - - @param id: (enum_t) - @param ord: (int) - -ida_idp.IDB_Hooks.enum_renamed (method) - enum_renamed(self, id) - An enum or member has been renamed. - - @param id: (tid_t) - -ida_idp.IDB_Hooks.enum_width_changed (method) - enum_width_changed(self, id, width) - Enum width has been changed. - - @param id: (enum_t) - @param width: (int) - -ida_idp.IDB_Hooks.expanding_struc (method) - expanding_struc(self, sptr, offset, delta) - A structure type is to be expanded/shrunk. - - @param sptr: (struc_t *) - @param offset: (::ea_t) - @param delta: (::adiff_t) - -ida_idp.IDB_Hooks.extlang_changed (method) - extlang_changed(self, kind, el, idx) - The list of extlangs or the default extlang was changed. - - @param kind: (int) 0: extlang installed 1: extlang removed 2: default extlang - changed - @param el: (extlang_t *) pointer to the extlang affected - @param idx: (int) extlang index - -ida_idp.IDB_Hooks.extra_cmt_changed (method) - extra_cmt_changed(self, ea, line_idx, cmt) - An extra comment has been changed. - - @param ea: (::ea_t) - @param line_idx: (int) - @param cmt: (const char *) - -ida_idp.IDB_Hooks.flow_chart_created (method) - flow_chart_created(self, fc) - Gui has retrieved a function flow chart. Plugins may modify the flow chart in - this callback. - - @param fc: (qflow_chart_t *) - -ida_idp.IDB_Hooks.frame_deleted (method) - frame_deleted(self, pfn) - The kernel has deleted a function frame. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.func_added (method) - func_added(self, pfn) - The kernel has added a function. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.func_deleted (method) - func_deleted(self, func_ea) - A function has been deleted. - - @param func_ea: (::ea_t) - -ida_idp.IDB_Hooks.func_noret_changed (method) - func_noret_changed(self, pfn) - FUNC_NORET bit has been changed. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.func_tail_appended (method) - func_tail_appended(self, pfn, tail) - A function tail chunk has been appended. - - @param pfn: (func_t *) - @param tail: (func_t *) - -ida_idp.IDB_Hooks.func_tail_deleted (method) - func_tail_deleted(self, pfn, tail_ea) - A function tail chunk has been removed. - - @param pfn: (func_t *) - @param tail_ea: (::ea_t) - -ida_idp.IDB_Hooks.func_updated (method) - func_updated(self, pfn) - The kernel has updated a function. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.hook (method) - hook(self) -> bool - -ida_idp.IDB_Hooks.idasgn_loaded (method) - idasgn_loaded(self, short_sig_name) - FLIRT signature has been loaded for normal processing (not for recognition of - startup sequences). - - @param short_sig_name: (const char *) - -ida_idp.IDB_Hooks.item_color_changed (method) - item_color_changed(self, ea, color) - An item color has been changed. - - @param ea: (::ea_t) - @param color: (bgcolor_t) if color==DEFCOLOR, the the color is deleted. - -ida_idp.IDB_Hooks.kernel_config_loaded (method) - kernel_config_loaded(self, pass_number) - This event is issued when ida.cfg is parsed. - - @param pass_number: (int) - -ida_idp.IDB_Hooks.loader_finished (method) - loader_finished(self, li, neflags, filetypename) - External file loader finished its work. Use this event to augment the existing - loader functionality. - - @param li: (linput_t *) - @param neflags: (uint16) Load file flags - @param filetypename: (const char *) - -ida_idp.IDB_Hooks.local_types_changed (method) - local_types_changed(self, ltc, ordinal, name) - Local types have been changed - - @param ltc: (::local_type_change_t) - @param ordinal: (uint32) 0 means ordinal is unknown - @param name: (const char *) nullptr means name is unknown - -ida_idp.IDB_Hooks.make_code (method) - make_code(self, insn) - An instruction is being created. - - @param insn: (const insn_t*) - -ida_idp.IDB_Hooks.make_data (method) - make_data(self, ea, flags, tid, len) - A data item is being created. - - @param ea: (::ea_t) - @param flags: (flags64_t) - @param tid: (tid_t) - @param len: (::asize_t) - -ida_idp.IDB_Hooks.op_ti_changed (method) - op_ti_changed(self, ea, n, type, fnames) - An operand typestring (c/c++ prototype) has been changed. - - @param ea: (::ea_t) - @param n: (int) - @param type: (const type_t *) - @param fnames: (const p_list *) - -ida_idp.IDB_Hooks.op_type_changed (method) - op_type_changed(self, ea, n) - An operand type (offset, hex, etc...) has been set or deleted. - - @param ea: (::ea_t) - @param n: (int) eventually or'ed with OPND_OUTER or OPND_ALL - -ida_idp.IDB_Hooks.range_cmt_changed (method) - range_cmt_changed(self, kind, a, cmt, repeatable) - Range comment has been changed. - - @param kind: (range_kind_t) - @param a: (const range_t *) - @param cmt: (const char *) - @param repeatable: (bool) - -ida_idp.IDB_Hooks.renamed (method) - renamed(self, ea, new_name, local_name, old_name) - The kernel has renamed a byte. See also the rename event - - @param ea: (::ea_t) - @param new_name: (const char *) can be nullptr - @param local_name: (bool) - @param old_name: (const char *) can be nullptr - -ida_idp.IDB_Hooks.renaming_enum (method) - renaming_enum(self, id, is_enum, newname) - An enum or enum member is to be renamed. - - @param id: (tid_t) - @param is_enum: (bool) - @param newname: (const char *) - -ida_idp.IDB_Hooks.renaming_struc (method) - renaming_struc(self, id, oldname, newname) - A structure type is to be renamed. - - @param id: (tid_t) - @param oldname: (const char *) - @param newname: (const char *) - -ida_idp.IDB_Hooks.renaming_struc_member (method) - renaming_struc_member(self, sptr, mptr, newname) - A structure member is to be renamed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - @param newname: (const char *) - -ida_idp.IDB_Hooks.savebase (method) - savebase(self) - The database is being saved. - -ida_idp.IDB_Hooks.segm_added (method) - segm_added(self, s) - A new segment has been created. - - @param s: (segment_t *) See also adding_segm - -ida_idp.IDB_Hooks.segm_attrs_updated (method) - segm_attrs_updated(self, s) - Segment attributes has been changed. - - @param s: (segment_t *) This event is generated for secondary segment attributes - (examples: color, permissions, etc) - -ida_idp.IDB_Hooks.segm_class_changed (method) - segm_class_changed(self, s, sclass) - Segment class has been changed. - - @param s: (segment_t *) - @param sclass: (const char *) - -ida_idp.IDB_Hooks.segm_deleted (method) - segm_deleted(self, start_ea, end_ea, flags) - A segment has been deleted. - - @param start_ea: (::ea_t) - @param end_ea: (::ea_t) - @param flags: (int) - -ida_idp.IDB_Hooks.segm_end_changed (method) - segm_end_changed(self, s, oldend) - Segment end address has been changed. - - @param s: (segment_t *) - @param oldend: (::ea_t) - -ida_idp.IDB_Hooks.segm_moved (method) - segm_moved(self, _from, to, size, changed_netmap) - Segment has been moved. - - @param from: (::ea_t) - @param to: (::ea_t) - @param size: (::asize_t) - @param changed_netmap: (bool) See also idb_event::allsegs_moved - -ida_idp.IDB_Hooks.segm_name_changed (method) - segm_name_changed(self, s, name) - Segment name has been changed. - - @param s: (segment_t *) - @param name: (const char *) - -ida_idp.IDB_Hooks.segm_start_changed (method) - segm_start_changed(self, s, oldstart) - Segment start address has been changed. - - @param s: (segment_t *) - @param oldstart: (::ea_t) - -ida_idp.IDB_Hooks.set_func_end (method) - set_func_end(self, pfn, new_end) - Function chunk end address will be changed. - - @param pfn: (func_t *) - @param new_end: (::ea_t) - -ida_idp.IDB_Hooks.set_func_start (method) - set_func_start(self, pfn, new_start) - Function chunk start address will be changed. - - @param pfn: (func_t *) - @param new_start: (::ea_t) - -ida_idp.IDB_Hooks.sgr_changed (method) - sgr_changed(self, start_ea, end_ea, regnum, value, old_value, tag) - The kernel has changed a segment register value. - - @param start_ea: (::ea_t) - @param end_ea: (::ea_t) - @param regnum: (int) - @param value: (::sel_t) - @param old_value: (::sel_t) - @param tag: (uchar) Segment register range tags - -ida_idp.IDB_Hooks.sgr_deleted (method) - sgr_deleted(self, start_ea, end_ea, regnum) - The kernel has deleted a segment register value. - - @param start_ea: (::ea_t) - @param end_ea: (::ea_t) - @param regnum: (int) - -ida_idp.IDB_Hooks.stkpnts_changed (method) - stkpnts_changed(self, pfn) - Stack change points have been modified. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.struc_align_changed (method) - struc_align_changed(self, sptr) - A structure type has been changed (the struct alignment). - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.struc_cmt_changed (method) - struc_cmt_changed(self, struc_id, repeatable_cmt) - A structure type comment has been changed. - - @param struc_id: (tid_t) - @param repeatable_cmt: (bool) - -ida_idp.IDB_Hooks.struc_created (method) - struc_created(self, struc_id) - A new structure type has been created. - - @param struc_id: (tid_t) - -ida_idp.IDB_Hooks.struc_deleted (method) - struc_deleted(self, struc_id) - A structure type has been deleted. - - @param struc_id: (tid_t) - -ida_idp.IDB_Hooks.struc_expanded (method) - struc_expanded(self, sptr) - A structure type has been expanded/shrank. - - @param sptr: (struc_t *) - -ida_idp.IDB_Hooks.struc_member_changed (method) - struc_member_changed(self, sptr, mptr) - A structure member has been changed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.struc_member_created (method) - struc_member_created(self, sptr, mptr) - A structure member has been created. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.struc_member_deleted (method) - struc_member_deleted(self, sptr, member_id, offset) - A structure member has been deleted. - - @param sptr: (struc_t *) - @param member_id: (tid_t) - @param offset: (::ea_t) - -ida_idp.IDB_Hooks.struc_member_renamed (method) - struc_member_renamed(self, sptr, mptr) - A structure member has been renamed. - - @param sptr: (struc_t *) - @param mptr: (member_t *) - -ida_idp.IDB_Hooks.struc_renamed (method) - struc_renamed(self, sptr, success) - A structure type has been renamed. - - @param sptr: (struc_t *) - @param success: (::bool) the structure was successfully renamed - -ida_idp.IDB_Hooks.tail_owner_changed (method) - tail_owner_changed(self, tail, owner_func, old_owner) - A tail chunk owner has been changed. - - @param tail: (func_t *) - @param owner_func: (::ea_t) - @param old_owner: (::ea_t) - -ida_idp.IDB_Hooks.thunk_func_created (method) - thunk_func_created(self, pfn) - A thunk bit has been set for a function. - - @param pfn: (func_t *) - -ida_idp.IDB_Hooks.ti_changed (method) - ti_changed(self, ea, type, fnames) - An item typestring (c/c++ prototype) has been changed. - - @param ea: (::ea_t) - @param type: (const type_t *) - @param fnames: (const p_list *) - -ida_idp.IDB_Hooks.tryblks_updated (method) - tryblks_updated(self, tbv) - Updated tryblk information - - @param tbv: (const ::tryblks_t *) - -ida_idp.IDB_Hooks.unhook (method) - unhook(self) -> bool - -ida_idp.IDB_Hooks.updating_tryblks (method) - updating_tryblks(self, tbv) - About to update tryblk information - - @param tbv: (const ::tryblks_t *) - -ida_idp.IDB_Hooks.upgraded (method) - upgraded(self, _from) - The database has been upgraded and the receiver can upgrade its info as well - - @param from: (int) - old IDB version - -ida_idp.IDP_Hooks (class) - Proxy of C++ IDP_Hooks class. - -ida_idp.IDP_Hooks.__disown__ (method) - -ida_idp.IDP_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> IDP_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 - -ida_idp.IDP_Hooks.ev_add_cref (method) - ev_add_cref(self, _from, to, type) -> int - A code reference is being created. - - @param from: (::ea_t) - @param to: (::ea_t) - @param type: (cref_t) - @retval <0: cancel cref creation - @retval 0: not implemented or continue - -ida_idp.IDP_Hooks.ev_add_dref (method) - ev_add_dref(self, _from, to, type) -> int - A data reference is being created. - - @param from: (::ea_t) - @param to: (::ea_t) - @param type: (dref_t) - @retval <0: cancel dref creation - @retval 0: not implemented or continue - -ida_idp.IDP_Hooks.ev_adjust_argloc (method) - ev_adjust_argloc(self, argloc, optional_type, size) -> int - Adjust argloc according to its type/size and platform endianess - - @param argloc: (argloc_t *), inout - @param type: (const tinfo_t *), may be nullptr nullptr means primitive type of - given size - @param size: (int) 'size' makes no sense if type != nullptr (type->get_size() - should be used instead) - @retval 0: not implemented - @retval 1: ok - @retval -1: error - -ida_idp.IDP_Hooks.ev_adjust_libfunc_ea (method) - ev_adjust_libfunc_ea(self, sig, libfun, ea) -> int - Called when a signature module has been matched against bytes in the database. - This is used to compute the offset at which a particular module's libfunc should - be applied. - - @param sig: (const idasgn_t *) - @param libfun: (const libfunc_t *) - @param ea: (::ea_t *) - @note: 'ea' initially contains the ea_t of the start of the pattern match - @retval 1: the ea_t pointed to by the third argument was modified. - @retval <=0: not modified. use default algorithm. - -ida_idp.IDP_Hooks.ev_adjust_refinfo (method) - ev_adjust_refinfo(self, ri, ea, n, fd) -> int - Called from apply_fixup before converting operand to reference. Can be used for - changing the reference info. (e.g. the PPC module adds REFINFO_NOBASE for some - references) - - @param ri: (refinfo_t *) - @param ea: (::ea_t) instruction address - @param n: (int) operand number - @param fd: (const fixup_data_t *) - @retval <0: do not create an offset - @retval 0: not implemented or refinfo adjusted - -ida_idp.IDP_Hooks.ev_ana_insn (method) - ev_ana_insn(self, out) -> bool - Analyze one instruction and fill 'out' structure. This function shouldn't change - the database, flags or anything else. All these actions should be performed only - by emu_insn() function. insn_t::ea contains address of instruction to analyze. - - @param out: (insn_t *) - @return: length of the instruction in bytes, 0 if instruction can't be decoded. - @retval 0: if instruction can't be decoded. - -ida_idp.IDP_Hooks.ev_analyze_prolog (method) - ev_analyze_prolog(self, ea) -> int - Analyzes function prolog, epilog, and updates purge, and function attributes - - @param ea: (::ea_t) start of function - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_arch_changed (method) - ev_arch_changed(self) -> int - The loader is done parsing arch-related information, which the processor module - might want to use to finish its initialization. - @retval 1: if success - @retval 0: not implemented or failed - -ida_idp.IDP_Hooks.ev_arg_addrs_ready (method) - ev_arg_addrs_ready(self, caller, n, tif, addrs) -> int - Argument address info is ready. - - @param caller: (::ea_t) - @param n: (int) number of formal arguments - @param tif: (tinfo_t *) call prototype - @param addrs: (::ea_t *) argument intilization addresses - @retval <0: do not save into idb; other values mean "ok to save" - -ida_idp.IDP_Hooks.ev_asm_installed (method) - ev_asm_installed(self, asmnum) -> int - After setting a new assembler - - @param asmnum: (int) See also ev_newasm - -ida_idp.IDP_Hooks.ev_assemble (method) - ev_assemble(self, ea, cs, ip, use32, line) -> PyObject * - Assemble an instruction. (display a warning if an error is found). - - @param ea: (::ea_t) linear address of instruction - @param cs: (::ea_t) cs of instruction - @param ip: (::ea_t) ip of instruction - @param use32: (bool) is 32bit segment? - @param line: (const char *) line to assemble - @return: size of the instruction in bytes - -ida_idp.IDP_Hooks.ev_auto_queue_empty (method) - ev_auto_queue_empty(self, type) -> int - One analysis queue is empty. - - @param type: (atype_t) - @retval void: see also idb_event::auto_empty_finally - -ida_idp.IDP_Hooks.ev_calc_arglocs (method) - ev_calc_arglocs(self, fti) -> int - Calculate function argument locations. This callback should fill retloc, all - arglocs, and stkargs. This callback is never called for CM_CC_SPECIAL functions. - - @param fti: (func_type_data_t *) points to the func type info - @retval 0: not implemented - @retval 1: ok - @retval -1: error - -ida_idp.IDP_Hooks.ev_calc_cdecl_purged_bytes (method) - ev_calc_cdecl_purged_bytes(self, ea) -> int - Calculate number of purged bytes after call. - - @param ea: (::ea_t) address of the call instruction - @return: number of purged bytes (usually add sp, N) - -ida_idp.IDP_Hooks.ev_calc_next_eas (method) - ev_calc_next_eas(self, res, insn, over) -> int - Calculate list of addresses the instruction in 'insn' may pass control to. This - callback is required for source level debugging. - - @param res: (eavec_t *), out: array for the results. - @param insn: (const insn_t*) the instruction - @param over: (bool) calculate for step over (ignore call targets) - @retval <0: incalculable (indirect jumps, for example) - @retval >=0: number of addresses of called functions in the array. They must be - put at the beginning of the array (0 if over=true) - -ida_idp.IDP_Hooks.ev_calc_purged_bytes (method) - ev_calc_purged_bytes(self, p_purged_bytes, fti) -> int - Calculate number of purged bytes by the given function type. - - @param p_purged_bytes: (int *) ptr to output - @param fti: (const func_type_data_t *) func type details - @retval 1 - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_calc_retloc (method) - ev_calc_retloc(self, retloc, rettype, cc) -> int - Calculate return value location. - - @param retloc: (argloc_t *) - @param rettype: (const tinfo_t *) - @param cc: (cm_t) - @retval 0: not implemented - @retval 1: ok, - @retval -1: error - -ida_idp.IDP_Hooks.ev_calc_spdelta (method) - ev_calc_spdelta(self, spdelta, insn) -> int - Calculate amount of change to sp for the given insn. This event is required to - decompile code snippets. - - @param spdelta: (sval_t *) - @param insn: (const insn_t *) - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_calc_step_over (method) - ev_calc_step_over(self, target, ip) -> int - Calculate the address of the instruction which will be executed after "step - over". The kernel will put a breakpoint there. If the step over is equal to step - into or we cannot calculate the address, return BADADDR. - - @param target: (::ea_t *) pointer to the answer - @param ip: (::ea_t) instruction address - @retval 0: unimplemented - @retval 1: implemented - -ida_idp.IDP_Hooks.ev_calc_switch_cases (method) - ev_calc_switch_cases(self, casevec, targets, insn_ea, si) -> int - Calculate case values and targets for a custom jump table. - - @param casevec: (::casevec_t *) vector of case values (may be nullptr) - @param targets: (eavec_t *) corresponding target addresses (my be nullptr) - @param insn_ea: (::ea_t) address of the 'indirect jump' instruction - @param si: (switch_info_t *) switch information - @retval 1: ok - @retval <=0: failed - -ida_idp.IDP_Hooks.ev_calc_varglocs (method) - ev_calc_varglocs(self, ftd, aux_regs, aux_stkargs, nfixed) -> int - Calculate locations of the arguments that correspond to '...'. - - @param ftd: (func_type_data_t *), inout: info about all arguments (including - varargs) - @param aux_regs: (regobjs_t *) buffer for hidden register arguments, may be - nullptr - @param aux_stkargs: (relobj_t *) buffer for hidden stack arguments, may be - nullptr - @param nfixed: (int) number of fixed arguments - @retval 0: not implemented - @retval 1: ok - @retval -1: error On some platforms variadic calls require passing additional - information: for example, number of floating variadic arguments must - be passed in rax on gcc-x64. The locations and values that - constitute this additional information are returned in the buffers - pointed by aux_regs and aux_stkargs - -ida_idp.IDP_Hooks.ev_calcrel (method) - ev_calcrel(self) -> int - Reserved. - -ida_idp.IDP_Hooks.ev_can_have_type (method) - ev_can_have_type(self, op) -> int - Can the operand have a type as offset, segment, decimal, etc? (for example, a - register AX can't have a type, meaning that the user can't change its - representation. see bytes.hpp for information about types and flags) - - @param op: (const op_t *) - @retval 0: unknown - @retval <0: no - @retval 1: yes - -ida_idp.IDP_Hooks.ev_clean_tbit (method) - ev_clean_tbit(self, ea, getreg, regvalues) -> int - Clear the TF bit after an insn like pushf stored it in memory. - - @param ea: (::ea_t) instruction address - @param getreg: (::processor_t::regval_getter_t *) function to get register - values - @param regvalues: (const regval_t *) register values array - @retval 1: ok - @retval 0: failed - -ida_idp.IDP_Hooks.ev_cmp_operands (method) - ev_cmp_operands(self, op1, op2) -> int - Compare instruction operands - - @param op1: (const op_t*) - @param op2: (const op_t*) - @retval 1: equal - @retval -1: not equal - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_coagulate (method) - ev_coagulate(self, start_ea) -> int - Try to define some unexplored bytes. This notification will be called if the - kernel tried all possibilities and could not find anything more useful than to - convert to array of bytes. The module can help the kernel and convert the bytes - into something more useful. - - @param start_ea: (::ea_t) - @return: number of converted bytes - -ida_idp.IDP_Hooks.ev_coagulate_dref (method) - ev_coagulate_dref(self, _from, to, may_define, code_ea) -> int - Data reference is being analyzed. plugin may correct 'code_ea' (e.g. for thumb - mode refs, we clear the last bit) - - @param from: (::ea_t) - @param to: (::ea_t) - @param may_define: (bool) - @param code_ea: (::ea_t *) - @retval <0: failed dref analysis, >0 done dref analysis - @retval 0: not implemented or continue - -ida_idp.IDP_Hooks.ev_create_flat_group (method) - ev_create_flat_group(self, image_base, bitness, dataseg_sel) -> int - Create special segment representing the flat group. - - @param image_base: (::ea_t) - @param bitness: (int) - @param dataseg_sel: (::sel_t) return value is ignored - -ida_idp.IDP_Hooks.ev_create_func_frame (method) - ev_create_func_frame(self, pfn) -> int - Create a function frame for a newly created function Set up frame size, its - attributes etc - - @param pfn: (func_t *) - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_create_merge_handlers (method) - ev_create_merge_handlers(self, md) -> int - Create merge handlers, if needed - - @param md: (::merge_data_t *) This event is generated immediately after opening - idbs. - @return: must be 0 - -ida_idp.IDP_Hooks.ev_create_switch_xrefs (method) - ev_create_switch_xrefs(self, jumpea, si) -> int - Create xrefs for a custom jump table. - - @param jumpea: (::ea_t) address of the jump insn - @param si: (const switch_info_t *) switch information - @return: must return 1 Must be implemented if module uses custom jump tables, - SWI_CUSTOM - -ida_idp.IDP_Hooks.ev_creating_segm (method) - ev_creating_segm(self, seg) -> int - A new segment is about to be created. - - @param seg: (segment_t *) - @retval 1: ok - @retval <0: segment should not be created - -ida_idp.IDP_Hooks.ev_cvt64_hashval (method) - ev_cvt64_hashval(self, node, tag, name, data) -> int - perform 32-64 conversion for a hash value - - @param node: (::nodeidx_t) - @param tag: (uchar) - @param name: (const ::char *) - @param data: (const uchar *) - @return: 0 nothing was done - 1 converted successfully - -1 error (and message in errbuf) - -ida_idp.IDP_Hooks.ev_cvt64_supval (method) - ev_cvt64_supval(self, node, tag, idx, data) -> int - perform 32-64 conversion for a netnode array element - - @param node: (::nodeidx_t) - @param tag: (uchar) - @param idx: (::nodeidx_t) - @param data: (const uchar *) - @return: 0 nothing was done - 1 converted successfully - -1 error (and message in errbuf) - -ida_idp.IDP_Hooks.ev_decorate_name (method) - ev_decorate_name(self, name, mangle, cc, optional_type) -> PyObject * - Decorate/undecorate a C symbol name. - - @param name: (const char *) name of symbol - @param mangle: (bool) true-mangle, false-unmangle - @param cc: (cm_t) calling convention - @param optional_type: tinfo_t const * - @retval 1: if success - @retval 0: not implemented or failed - -ida_idp.IDP_Hooks.ev_del_cref (method) - ev_del_cref(self, _from, to, expand) -> int - A code reference is being deleted. - - @param from: (::ea_t) - @param to: (::ea_t) - @param expand: (bool) - @retval <0: cancel cref deletion - @retval 0: not implemented or continue - -ida_idp.IDP_Hooks.ev_del_dref (method) - ev_del_dref(self, _from, to) -> int - A data reference is being deleted. - - @param from: (::ea_t) - @param to: (::ea_t) - @retval <0: cancel dref deletion - @retval 0: not implemented or continue - -ida_idp.IDP_Hooks.ev_delay_slot_insn (method) - ev_delay_slot_insn(self, ea, bexec, fexec) -> PyObject * - Get delay slot instruction - - @param ea: (::ea_t *) in: instruction address in question, out: (if the answer - is positive) if the delay slot contains valid insn: the address of - the delay slot insn else: BADADDR (invalid insn, e.g. a branch) - @param bexec: (bool *) execute slot if jumping, initially set to 'true' - @param fexec: (bool *) execute slot if not jumping, initally set to 'true' - @retval 1: positive answer - @retval <=0: ordinary insn - @note: Input EA may point to the instruction with a delay slot or to the delay - slot instruction itself. - -ida_idp.IDP_Hooks.ev_demangle_name (method) - ev_demangle_name(self, name, disable_mask, demreq) -> PyObject * - Demangle a C++ (or another language) name into a user-readable string. This - event is called by demangle_name() - - @param name: (const char *) mangled name - @param disable_mask: (uint32) flags to inhibit parts of output or compiler - info/other (see MNG_) - @param demreq: (demreq_type_t) operation to perform - @retval 1: if success - @retval 0: not implemented - @note: if you call demangle_name() from the handler, protect against recursion! - -ida_idp.IDP_Hooks.ev_emu_insn (method) - ev_emu_insn(self, insn) -> 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 'insn' structure. - - @param insn: (const insn_t *) - @retval 1: ok - @retval -1: the kernel will delete the instruction - -ida_idp.IDP_Hooks.ev_endbinary (method) - ev_endbinary(self, ok) -> int - IDA has loaded a binary file. - - @param ok: (bool) file loaded successfully? - -ida_idp.IDP_Hooks.ev_ending_undo (method) - ev_ending_undo(self, action_name, is_undo) -> int - Ended undoing/redoing an action - - @param action_name: (const char *) action that we finished undoing/redoing. is - not nullptr. - @param is_undo: (bool) true if performing undo, false if performing redo - -ida_idp.IDP_Hooks.ev_equal_reglocs (method) - ev_equal_reglocs(self, a1, a2) -> int - Are 2 register arglocs the same?. We need this callback for the pc module. - - @param a1: (argloc_t *) - @param a2: (argloc_t *) - @retval 1: yes - @retval -1: no - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_extract_address (method) - ev_extract_address(self, out_ea, screen_ea, string, position) -> int - Extract address from a string. - - @param out_ea: (ea_t *), out - @param screen_ea: (ea_t) - @param string: (const char *) - @param position: (size_t) - @retval 1: ok - @retval 0: kernel should use the standard algorithm - @retval -1: error - -ida_idp.IDP_Hooks.ev_find_op_value (method) - ev_find_op_value(self, pinsn, opn) -> PyObject * - Find operand value via a register tracker. The returned value in 'out' is valid - before executing the instruction. - - @param pinsn: (const insn_t *) instruction - @param opn: (int) operand index - @retval 1: if implemented, and value was found - @retval 0: not implemented, -1 decoding failed, or no value found - -ida_idp.IDP_Hooks.ev_find_reg_value (method) - ev_find_reg_value(self, pinsn, reg) -> PyObject * - Find register value via a register tracker. The returned value in 'out' is valid - before executing the instruction. - - @param pinsn: (const insn_t *) instruction - @param reg: (int) register index - @retval 1: if implemented, and value was found - @retval 0: not implemented, -1 decoding failed, or no value found - -ida_idp.IDP_Hooks.ev_func_bounds (method) - ev_func_bounds(self, possible_return_code, pfn, max_func_end_ea) -> int - find_func_bounds() finished its work. The module may fine tune the function - bounds - - @param possible_return_code: (int *), in/out - @param pfn: (func_t *) - @param max_func_end_ea: (::ea_t) (from the kernel's point of view) - @retval void - -ida_idp.IDP_Hooks.ev_gen_asm_or_lst (method) - ev_gen_asm_or_lst(self, starting, fp, is_asm, flags, outline) -> int - - @param starting: (bool) beginning listing generation - @param fp: (FILE *) output file - @param is_asm: (bool) true:assembler, false:listing - @param flags: (int) flags passed to gen_file() - @param outline: (html_line_cb_t **) ptr to ptr to outline callback. if this - callback is defined for this code, it will be used by the kernel - to output the generated lines - @retval void - -ida_idp.IDP_Hooks.ev_gen_map_file (method) - ev_gen_map_file(self, nlines, fp) -> int - Generate map file. If not implemented the kernel itself will create the map - file. - - @param nlines: (int *) number of lines in map file (-1 means write error) - @param fp: (FILE *) output file - @retval 0: not implemented - @retval 1: ok - @retval -1: write error - -ida_idp.IDP_Hooks.ev_gen_regvar_def (method) - ev_gen_regvar_def(self, outctx, v) -> int - Generate register variable definition line. - - @param outctx: (outctx_t *) - @param v: (regvar_t *) - @retval >0: ok, generated the definition text - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_gen_src_file_lnnum (method) - ev_gen_src_file_lnnum(self, outctx, file, lnnum) -> int - - @param outctx: (outctx_t *) output context - @param file: (const char *) source file (may be nullptr) - @param lnnum: (size_t) line number - @retval 1: directive has been generated - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_gen_stkvar_def (method) - ev_gen_stkvar_def(self, outctx, mptr, v) -> int - Generate stack variable definition line Default line is varname = type ptr - value, where 'type' is one of byte,word,dword,qword,tbyte - - @param outctx: (outctx_t *) - @param mptr: (const member_t *) - @param v: (sval_t) - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_get_abi_info (method) - ev_get_abi_info(self, abi_names, abi_opts, comp) -> int - Get all possible ABI names and optional extensions for given compiler - abiname/option is a string entirely consisting of letters, digits and underscore - - @param abi_names: (qstrvec_t *) - all possible ABis each in form abiname- - opt1-opt2-... - @param abi_opts: (qstrvec_t *) - array of all possible options in form - "opt:description" or opt:hint-line#description - @param comp: (comp_t) - compiler ID - @retval 0: not implemented - @retval 1: ok - -ida_idp.IDP_Hooks.ev_get_autocmt (method) - ev_get_autocmt(self, insn) -> PyObject * - - @param insn: (const insn_t*) the instruction - @retval 1: new comment has been generated - @retval 0: callback has not been handled. the buffer must not be changed in this - case - -ida_idp.IDP_Hooks.ev_get_bg_color (method) - ev_get_bg_color(self, color, ea) -> int - Get item background color. Plugins can hook this callback to color disassembly - lines dynamically - - @param color: (bgcolor_t *), out - @param ea: (::ea_t) - @retval 0: not implemented - @retval 1: color set - -ida_idp.IDP_Hooks.ev_get_cc_regs (method) - ev_get_cc_regs(self, regs, cc) -> int - Get register allocation convention for given calling convention - - @param regs: (callregs_t *), out - @param cc: (cm_t) - @retval 1 - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_get_code16_mode (method) - ev_get_code16_mode(self, ea) -> int - Get ISA 16-bit mode - - @param ea: (ea_t) address to get the ISA mode - @retval 1: 16-bit mode - @retval 0: not implemented or 32-bit mode - -ida_idp.IDP_Hooks.ev_get_dbr_opnum (method) - ev_get_dbr_opnum(self, opnum, insn) -> int - Get the number of the operand to be displayed in the debugger reference view - (text mode). - - @param opnum: (int *) operand number (out, -1 means no such operand) - @param insn: (const insn_t*) the instruction - @retval 0: unimplemented - @retval 1: implemented - -ida_idp.IDP_Hooks.ev_get_default_enum_size (method) - ev_get_default_enum_size(self) -> int - Get default enum size. Not generated anymore. inf_get_cc_size_e() is used - instead - -ida_idp.IDP_Hooks.ev_get_frame_retsize (method) - ev_get_frame_retsize(self, frsize, pfn) -> int - Get size of function return address in bytes If this event is not implemented, - the kernel will assume - * 8 bytes for 64-bit function - * 4 bytes for 32-bit function - * 2 bytes otherwise - - @param frsize: (int *) frame size (out) - @param pfn: (const func_t *), can't be nullptr - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_get_macro_insn_head (method) - ev_get_macro_insn_head(self, head, ip) -> int - Calculate the start of a macro instruction. This notification is called if IP - points to the middle of an instruction - - @param head: (::ea_t *), out: answer, BADADDR means normal instruction - @param ip: (::ea_t) instruction address - @retval 0: unimplemented - @retval 1: implemented - -ida_idp.IDP_Hooks.ev_get_operand_string (method) - ev_get_operand_string(self, insn, opnum) -> PyObject * - Request text string for operand (cli, java, ...). - - @param insn: (const insn_t*) the instruction - @param opnum: (int) operand number, -1 means any string operand - @retval 0: no string (or empty string) - @retval >0: original string length without terminating zero - -ida_idp.IDP_Hooks.ev_get_procmod (method) - ev_get_procmod(self) -> int - Get pointer to the processor module object. All processor modules must implement - this. The pointer is returned as size_t. - -ida_idp.IDP_Hooks.ev_get_reg_accesses (method) - ev_get_reg_accesses(self, accvec, insn, flags) -> int - Get info about the registers that are used/changed by an instruction. - - @param accvec: (reg_accesses_t*) out: info about accessed registers - @param insn: (const insn_t *) instruction in question - @param flags: (int) reserved, must be 0 - @retval -1: if accvec is nullptr - @retval 1: found the requested access (and filled accvec) - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_get_reg_info (method) - ev_get_reg_info(self, main_regname, bitrange, regname) -> int - Get register information by its name. example: "ah" returns: - * main_regname="eax" - * bitrange_t = { offset==8, nbits==8 } - - This callback may be unimplemented if the register names are all present in - processor_t::reg_names and they all have the same size - - @param main_regname: (const char **), out - @param bitrange: (bitrange_t *), out: position and size of the value within - 'main_regname' (empty bitrange == whole register) - @param regname: (const char *) - @retval 1: ok - @retval -1: failed (not found) - @retval 0: unimplemented - -ida_idp.IDP_Hooks.ev_get_reg_name (method) - ev_get_reg_name(self, reg, width, reghi) -> PyObject * - Generate text representation of a register. Most processor modules do not need - to implement this callback. It is useful only if processor_t::reg_names[reg] - does not provide the correct register name. - - @param reg: (int) internal register number as defined in the processor module - @param width: (size_t) register width in bytes - @param reghi: (int) if not -1 then this function will return the register pair - @retval -1: if error - @retval strlen(buf): if success - -ida_idp.IDP_Hooks.ev_get_simd_types (method) - ev_get_simd_types(self, out, simd_attrs, argloc, create_tifs) -> int - Get SIMD-related types according to given attributes ant/or argument location - - @param out: (::simd_info_vec_t *) - @param simd_attrs: (const simd_info_t *), may be nullptr - @param argloc: (const argloc_t *), may be nullptr - @param create_tifs: (bool) return valid tinfo_t objects, create if neccessary - @retval number: of found types - @retval -1: error If name==nullptr, initialize all SIMD types - -ida_idp.IDP_Hooks.ev_get_stkarg_area_info (method) - ev_get_stkarg_area_info(self, out, cc) -> int - Get some metrics of the stack argument area. - - @param out: (stkarg_area_info_t *) ptr to stkarg_area_info_t - @param cc: (cm_t) calling convention - @retval 1: if success - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_get_stkvar_scale_factor (method) - ev_get_stkvar_scale_factor(self) -> int - Should stack variable references be multiplied by a coefficient before being - used in the stack frame?. Currently used by TMS320C55 because the references - into the stack should be multiplied by 2 - - @return: scaling factor - @retval 0: not implemented - @note: PR_SCALE_STKVARS should be set to use this callback - -ida_idp.IDP_Hooks.ev_getreg (method) - ev_getreg(self, regval, regnum) -> int - IBM PC only internal request, should never be used for other purpose Get - register value by internal index - - @param regval: (uval_t *), out - @param regnum: (int) - @retval 1: ok - @retval 0: not implemented - @retval -1: failed (undefined value or bad regnum) - -ida_idp.IDP_Hooks.ev_init (method) - ev_init(self, idp_modname) -> int - The IDP module is just loaded. - - @param idp_modname: (const char *) processor module name - @retval <0: on failure - -ida_idp.IDP_Hooks.ev_insn_reads_tbit (method) - ev_insn_reads_tbit(self, insn, getreg, regvalues) -> int - Check if insn will read the TF bit. - - @param insn: (const insn_t*) the instruction - @param getreg: (::processor_t::regval_getter_t *) function to get register - values - @param regvalues: (const regval_t *) register values array - @retval 2: yes, will generate 'step' exception - @retval 1: yes, will store the TF bit in memory - @retval 0: no - -ida_idp.IDP_Hooks.ev_is_align_insn (method) - ev_is_align_insn(self, ea) -> int - Is the instruction created only for alignment purposes?. Do not directly call - this function, use is_align_insn() - - @param ea: (ea_t) - instruction address - @retval number: of bytes in the instruction - -ida_idp.IDP_Hooks.ev_is_alloca_probe (method) - ev_is_alloca_probe(self, ea) -> int - Does the function at 'ea' behave as __alloca_probe? - - @param ea: (::ea_t) - @retval 1: yes - @retval 0: no - -ida_idp.IDP_Hooks.ev_is_basic_block_end (method) - ev_is_basic_block_end(self, insn, call_insn_stops_block) -> int - Is the current instruction end of a basic block?. This function should be - defined for processors with delayed jump slots. - - @param insn: (const insn_t*) the instruction - @param call_insn_stops_block: (bool) - @retval 0: unknown - @retval <0: no - @retval 1: yes - -ida_idp.IDP_Hooks.ev_is_call_insn (method) - ev_is_call_insn(self, insn) -> int - Is the instruction a "call"? - - @param insn: (const insn_t *) instruction - @retval 0: unknown - @retval <0: no - @retval 1: yes - -ida_idp.IDP_Hooks.ev_is_cond_insn (method) - ev_is_cond_insn(self, insn) -> int - Is conditional instruction? - - @param insn: (const insn_t *) instruction address - @retval 1: yes - @retval -1: no - @retval 0: not implemented or not instruction - -ida_idp.IDP_Hooks.ev_is_control_flow_guard (method) - ev_is_control_flow_guard(self, p_reg, insn) -> int - Detect if an instruction is a "thunk call" to a flow guard function (equivalent - to call reg/return/nop) - - @param p_reg: (int *) indirect register number, may be -1 - @param insn: (const insn_t *) call/jump instruction - @retval -1: no thunk detected - @retval 1: indirect call - @retval 2: security check routine call (NOP) - @retval 3: return thunk - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_is_far_jump (method) - ev_is_far_jump(self, icode) -> int - is indirect far jump or call instruction? meaningful only if the processor has - 'near' and 'far' reference types - - @param icode: (int) - @retval 0: not implemented - @retval 1: yes - @retval -1: no - -ida_idp.IDP_Hooks.ev_is_indirect_jump (method) - ev_is_indirect_jump(self, insn) -> int - Determine if instruction is an indirect jump. If CF_JUMP bit cannot describe all - jump types jumps, please define this callback. - - @param insn: (const insn_t*) the instruction - @retval 0: use CF_JUMP - @retval 1: no - @retval 2: yes - -ida_idp.IDP_Hooks.ev_is_insn_table_jump (method) - ev_is_insn_table_jump(self) -> int - Reserved. - -ida_idp.IDP_Hooks.ev_is_jump_func (method) - ev_is_jump_func(self, pfn, jump_target, func_pointer) -> int - Is the function a trivial "jump" function?. - - @param pfn: (func_t *) - @param jump_target: (::ea_t *) - @param func_pointer: (::ea_t *) - @retval <0: no - @retval 0: don't know - @retval 1: yes, see 'jump_target' and 'func_pointer' - -ida_idp.IDP_Hooks.ev_is_ret_insn (method) - ev_is_ret_insn(self, insn, strict) -> int - Is the instruction a "return"? - - @param insn: (const insn_t *) instruction - @param strict: (bool) 1: report only ret instructions 0: include instructions - like "leave" which begins the function epilog - @retval 0: unknown - @retval <0: no - @retval 1: yes - -ida_idp.IDP_Hooks.ev_is_sane_insn (method) - ev_is_sane_insn(self, insn, no_crefs) -> int - Is the instruction sane for the current file type?. - - @param insn: (const insn_t*) the instruction - @param no_crefs: (int) 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. - @retval >=0: ok - @retval <0: no, the instruction isn't likely to appear in the program - -ida_idp.IDP_Hooks.ev_is_sp_based (method) - ev_is_sp_based(self, mode, insn, op) -> int - Check whether the operand is relative to stack pointer or frame pointer This - event is used to determine how to output a stack variable If not implemented, - then all operands are sp based by default. Implement this event only if some - stack references use frame pointer instead of stack pointer. - - @param mode: (int *) out, combination of SP/FP operand flags - @param insn: (const insn_t *) - @param op: (const op_t *) - @retval 0: not implemented - @retval 1: ok - -ida_idp.IDP_Hooks.ev_is_switch (method) - ev_is_switch(self, si, insn) -> int - Find 'switch' idiom or override processor module's decision. It will be called - for instructions marked with CF_JUMP. - - @param si: (switch_info_t *), out - @param insn: (const insn_t *) instruction possibly belonging to a switch - @retval 1: switch is found, 'si' is filled. IDA will create the switch using the - filled 'si' - @retval -1: no switch found. This value forbids switch creation by the processor - module - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_last_cb_before_loader (method) - ev_last_cb_before_loader(self) -> int - -ida_idp.IDP_Hooks.ev_loader (method) - ev_loader(self) -> int - This code and higher ones are reserved for the loaders. The arguments and the - return values are defined by the loaders - -ida_idp.IDP_Hooks.ev_lower_func_type (method) - ev_lower_func_type(self, argnums, fti) -> int - Get function arguments which should be converted to pointers when lowering - function prototype. The processor module can also modify 'fti' in order to make - non-standard conversion of some arguments. - - @param argnums: (intvec_t *), out - numbers of arguments to be converted to - pointers in acsending order - @param fti: (func_type_data_t *), inout func type details (special values -1/-2 - for return value - position of hidden 'retstr' argument: -1 - at the - beginning, -2 - at the end) - @retval 0: not implemented - @retval 1: argnums was filled - @retval 2: argnums was filled and made substantial changes to fti - -ida_idp.IDP_Hooks.ev_max_ptr_size (method) - ev_max_ptr_size(self) -> int - Get maximal size of a pointer in bytes. - - @return: max possible size of a pointer - -ida_idp.IDP_Hooks.ev_may_be_func (method) - ev_may_be_func(self, insn, state) -> int - Can a function start here? - - @param insn: (const insn_t*) the instruction - @param state: (int) autoanalysis phase 0: creating functions 1: creating chunks - @return: probability 1..100 - @note: Actually IDA uses 3 intervals of a probability: 0..50 not a function, - 51..99 a function (IDA needs another proof), 100 a function (no other - proofs needed) - -ida_idp.IDP_Hooks.ev_may_show_sreg (method) - ev_may_show_sreg(self, current_ea) -> int - The kernel wants to display the segment registers in the messages window. - - @param current_ea: (::ea_t) - @retval <0: if the kernel should not show the segment registers. (assuming that - the module has done it) - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_moving_segm (method) - ev_moving_segm(self, seg, to, flags) -> int - May the kernel move the segment? - - @param seg: (segment_t *) segment to move - @param to: (::ea_t) new segment start address - @param flags: (int) combination of Move segment flags - @retval 0: yes - @retval <0: the kernel should stop - -ida_idp.IDP_Hooks.ev_newasm (method) - ev_newasm(self, asmnum) -> int - Before setting a new assembler. - - @param asmnum: (int) See also ev_asm_installed - -ida_idp.IDP_Hooks.ev_newbinary (method) - ev_newbinary(self, filename, fileoff, basepara, binoff, nbytes) -> int - IDA is about to load a binary file. - - @param filename: (char *) binary file name - @param fileoff: (qoff64_t) offset in the file - @param basepara: (::ea_t) base loading paragraph - @param binoff: (::ea_t) loader offset - @param nbytes: (::uint64) number of bytes to load - -ida_idp.IDP_Hooks.ev_newfile (method) - ev_newfile(self, fname) -> int - A new file has been loaded. - - @param fname: (char *) input file name - -ida_idp.IDP_Hooks.ev_newprc (method) - ev_newprc(self, pnum, keep_cfg) -> int - Before changing processor type. - - @param pnum: (int) processor number in the array of processor names - @param keep_cfg: (bool) true: do not modify kernel configuration - @retval 1: ok - @retval <0: prohibit - -ida_idp.IDP_Hooks.ev_next_exec_insn (method) - ev_next_exec_insn(self, target, ea, tid, getreg, regvalues) -> int - Get next address to be executed This function must return the next address to be - executed. If the instruction following the current one is executed, then it must - return BADADDR Usually the instructions to consider are: jumps, branches, calls, - returns. This function is essential if the 'single step' is not supported in - hardware. - - @param target: (::ea_t *), out: pointer to the answer - @param ea: (::ea_t) instruction address - @param tid: (int) current therad id - @param getreg: (::processor_t::regval_getter_t *) function to get register - values - @param regvalues: (const regval_t *) register values array - @retval 0: unimplemented - @retval 1: implemented - -ida_idp.IDP_Hooks.ev_oldfile (method) - ev_oldfile(self, fname) -> int - An old file has been loaded. - - @param fname: (char *) input file name - -ida_idp.IDP_Hooks.ev_out_assumes (method) - ev_out_assumes(self, outctx) -> int - Function to produce assume directives when segment register value changes. - - @param outctx: (outctx_t *) - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_out_data (method) - ev_out_data(self, outctx, analyze_only) -> int - Generate text representation of data items This function may change the database - and create cross-references if analyze_only is set - - @param outctx: (outctx_t *) - @param analyze_only: (bool) - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_out_footer (method) - ev_out_footer(self, outctx) -> int - Function to produce end of disassembled text - - @param outctx: (outctx_t *) - @retval void - -ida_idp.IDP_Hooks.ev_out_header (method) - ev_out_header(self, outctx) -> int - Function to produce start of disassembled text - - @param outctx: (outctx_t *) - @retval void - -ida_idp.IDP_Hooks.ev_out_insn (method) - ev_out_insn(self, outctx) -> bool - Generate text representation of an instruction in 'ctx.insn' outctx_t provides - functions to output the generated text. This function shouldn't change the - database, flags or anything else. All these actions should be performed only by - emu_insn() function. - - @param outctx: (outctx_t *) - @retval void - -ida_idp.IDP_Hooks.ev_out_label (method) - ev_out_label(self, outctx, colored_name) -> int - The kernel is going to generate an instruction label line or a function header. - - @param outctx: (outctx_t *) - @param colored_name: (const char *) - @retval <0: if the kernel should not generate the label - @retval 0: not implemented or continue - -ida_idp.IDP_Hooks.ev_out_mnem (method) - ev_out_mnem(self, outctx) -> int - Generate instruction mnemonics. This callback should append the colored - mnemonics to ctx.outbuf Optional notification, if absent, out_mnem will be - called. - - @param outctx: (outctx_t *) - @retval 1: if appended the mnemonics - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_out_operand (method) - ev_out_operand(self, outctx, op) -> bool - Generate text representation of an instruction operand outctx_t provides - functions to output the generated text. All these actions should be performed - only by emu_insn() function. - - @param outctx: (outctx_t *) - @param op: (const op_t *) - @retval 1: ok - @retval -1: operand is hidden - -ida_idp.IDP_Hooks.ev_out_segend (method) - ev_out_segend(self, outctx, seg) -> int - Function to produce end of segment - - @param outctx: (outctx_t *) - @param seg: (segment_t *) - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_out_segstart (method) - ev_out_segstart(self, outctx, seg) -> int - Function to produce start of segment - - @param outctx: (outctx_t *) - @param seg: (segment_t *) - @retval 1: ok - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_out_special_item (method) - ev_out_special_item(self, outctx, segtype) -> int - Generate text representation of an item in a special segment i.e. absolute - symbols, externs, communal definitions etc - - @param outctx: (outctx_t *) - @param segtype: (uchar) - @retval 1: ok - @retval 0: not implemented - @retval -1: overflow - -ida_idp.IDP_Hooks.ev_privrange_changed (method) - ev_privrange_changed(self, old_privrange, delta) -> int - Privrange interval has been moved to a new location. Most common actions to be - done by module in this case: fix indices of netnodes used by module - - @param old_privrange: (const range_t *) - old privrange interval - @param delta: (::adiff_t) - @return: 0 Ok - -1 error (and message in errbuf) - -ida_idp.IDP_Hooks.ev_realcvt (method) - ev_realcvt(self, m, e, swt) -> int - Floating point -> IEEE conversion - - @param m: (void *) ptr to processor-specific floating point value - @param e: (fpvalue_t *) IDA representation of a floating point value - @param swt: (uint16) operation (see realcvt() in ieee.h) - @retval 0: not implemented - @retval 1: ok - @retval unknown - -ida_idp.IDP_Hooks.ev_rename (method) - ev_rename(self, ea, new_name) -> int - The kernel is going to rename a byte. - - @param ea: (::ea_t) - @param new_name: (const char *) - @retval <0: if the kernel should not rename it. - @retval 2: to inhibit the notification. I.e., the kernel should not rename, but - 'set_name()' should return 'true'. also see renamed the return value - is ignored when kernel is going to delete name - -ida_idp.IDP_Hooks.ev_replaying_undo (method) - ev_replaying_undo(self, action_name, vec, is_undo) -> int - Replaying an undo/redo buffer - - @param action_name: (const char *) action that we perform undo/redo for. may be - nullptr for intermediary buffers. - @param vec: (const undo_records_t *) - @param is_undo: (bool) true if performing undo, false if performing redo This - event may be generated multiple times per undo/redo - -ida_idp.IDP_Hooks.ev_set_code16_mode (method) - ev_set_code16_mode(self, ea, code16) -> int - Some processors have ISA 16-bit mode e.g. ARM Thumb mode, PPC VLE, MIPS16 Set - ISA 16-bit mode - - @param ea: (ea_t) address to set new ISA mode - @param code16: (bool) true for 16-bit mode, false for 32-bit mode - -ida_idp.IDP_Hooks.ev_set_idp_options (method) - ev_set_idp_options(self, keyword, value_type, value, idb_loaded) -> int - Set IDP-specific configuration option Also see set_options_t in config.hpp - - @param keyword: (const char *) - @param value_type: (int) - @param value: (const void *) - @param idb_loaded: (bool) true if the ev_oldfile/ev_newfile events have been - generated - @retval 1: ok - @retval 0: not implemented - @retval -1: error (and message in errbuf) - -ida_idp.IDP_Hooks.ev_set_proc_options (method) - ev_set_proc_options(self, options, confidence) -> int - Called if the user specified an option string in the command line: -p<processor - name>:<options>. Can be used for setting a processor subtype. Also called if - option string is passed to set_processor_type() and IDC's SetProcessorType(). - - @param options: (const char *) - @param confidence: (int) 0: loader's suggestion 1: user's decision - @retval <0: if bad option string - -ida_idp.IDP_Hooks.ev_setup_til (method) - ev_setup_til(self) -> int - Setup default type libraries. (called after loading a new file into the - database). The processor module may load tils, setup memory model and perform - other actions required to set up the type system. This is an optional callback. - @retval void - -ida_idp.IDP_Hooks.ev_str2reg (method) - ev_str2reg(self, regname) -> int - Convert a register name to a register number. The register number is the - register index in the processor_t::reg_names array Most processor modules do not - need to implement this callback It is useful only if processor_t::reg_names[reg] - does not provide the correct register names - - @param regname: (const char *) - @retval register: number + 1 - @retval 0: not implemented or could not be decoded - -ida_idp.IDP_Hooks.ev_term (method) - ev_term(self) -> int - The IDP module is being unloaded. - -ida_idp.IDP_Hooks.ev_treat_hindering_item (method) - ev_treat_hindering_item(self, hindering_item_ea, new_item_flags, new_item_ea, new_item_length) -> int - An item hinders creation of another item. - - @param hindering_item_ea: (::ea_t) - @param new_item_flags: (flags64_t) (0 for code) - @param new_item_ea: (::ea_t) - @param new_item_length: (::asize_t) - @retval 0: no reaction - @retval !=0: the kernel may delete the hindering item - -ida_idp.IDP_Hooks.ev_undefine (method) - ev_undefine(self, ea) -> int - An item in the database (insn or data) is being deleted. - - @param ea: (ea_t) - @retval 1: do not delete srranges at the item end - @retval 0: srranges can be deleted - -ida_idp.IDP_Hooks.ev_update_call_stack (method) - ev_update_call_stack(self, stack, tid, getreg, regvalues) -> int - Calculate the call stack trace for the given thread. This callback is invoked - when the process is suspended and should fill the 'trace' object with the - information about the current call stack. Note that this callback is NOT invoked - if the current debugger backend implements stack tracing via - debugger_t::event_t::ev_update_call_stack. The debugger-specific algorithm takes - priority. Implementing this callback in the processor module is useful when - multiple debugging platforms follow similar patterns, and thus the same - processor-specific algorithm can be used for different platforms. - - @param stack: (call_stack_t *) result - @param tid: (int) thread id - @param getreg: (::processor_t::regval_getter_t *) function to get register - values - @param regvalues: (const regval_t *) register values array - @retval 1: ok - @retval -1: failed - @retval 0: unimplemented - -ida_idp.IDP_Hooks.ev_use_arg_types (method) - ev_use_arg_types(self, ea, fti, rargs) -> int - Use information about callee arguments. - - @param ea: (::ea_t) address of the call instruction - @param fti: (func_type_data_t *) info about function type - @param rargs: (funcargvec_t *) array of register arguments - @retval 1: (and removes handled arguments from fti and rargs) - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_use_regarg_type (method) - ev_use_regarg_type(self, ea, rargs) -> PyObject * - Use information about register argument. - - @param ea: (::ea_t) address of the instruction - @param rargs: (const funcargvec_t *) vector of register arguments (including - regs extracted from scattered arguments) - @retval 1 - @retval 0: not implemented - -ida_idp.IDP_Hooks.ev_use_stkarg_type (method) - ev_use_stkarg_type(self, ea, arg) -> int - Use information about a stack argument. - - @param ea: (::ea_t) address of the push instruction which pushes the function - argument into the stack - @param arg: (const funcarg_t *) argument info - @retval 1: ok - @retval <=0: failed, the kernel will create a comment with the argument name or - type for the instruction - -ida_idp.IDP_Hooks.ev_validate_flirt_func (method) - ev_validate_flirt_func(self, start_ea, funcname) -> int - Flirt has recognized a library function. This callback can be used by a plugin - or proc module to intercept it and validate such a function. - - @param start_ea: (::ea_t) - @param funcname: (const char *) - @retval -1: do not create a function, - @retval 0: function is validated - -ida_idp.IDP_Hooks.ev_verify_noreturn (method) - ev_verify_noreturn(self, pfn) -> int - The kernel wants to set 'noreturn' flags for a function. - - @param pfn: (func_t *) - @retval 0: ok. any other value: do not set 'noreturn' flag - -ida_idp.IDP_Hooks.ev_verify_sp (method) - ev_verify_sp(self, pfn) -> int - All function instructions have been analyzed. Now the processor module can - analyze the stack pointer for the whole function - - @param pfn: (func_t *) - @retval 0: ok - @retval <0: bad stack pointer - -ida_idp.IDP_Hooks.hook (method) - hook(self) -> bool - -ida_idp.IDP_Hooks.unhook (method) - unhook(self) -> bool - -ida_idp.IDP_INTERFACE_VERSION (variable) - The interface version number. - @note: see also IDA_SDK_VERSION from pro.h - -ida_idp.OP_FP_BASED (variable) - operand is FP based - -ida_idp.OP_SP_ADD (variable) - operand value is added to the pointer - -ida_idp.OP_SP_BASED (variable) - operand is SP based - -ida_idp.OP_SP_SUB (variable) - operand value is subtracted from the pointer - -ida_idp.PLFM_386 (variable) - Intel 80x86. - -ida_idp.PLFM_6502 (variable) - 6502 - -ida_idp.PLFM_65C816 (variable) - 65802/65816 - -ida_idp.PLFM_6800 (variable) - Motorola 68xx. - -ida_idp.PLFM_68K (variable) - Motorola 680x0. - -ida_idp.PLFM_80196 (variable) - Intel 80196. - -ida_idp.PLFM_8051 (variable) - 8051 - -ida_idp.PLFM_AD2106X (variable) - Analog Devices ADSP 2106X. - -ida_idp.PLFM_AD218X (variable) - Analog Devices ADSP 218X. - -ida_idp.PLFM_ALPHA (variable) - DEC Alpha. - -ida_idp.PLFM_ARC (variable) - Argonaut RISC Core. - -ida_idp.PLFM_ARM (variable) - Advanced RISC Machines. - -ida_idp.PLFM_AVR (variable) - Atmel 8-bit RISC processor(s) - -ida_idp.PLFM_C166 (variable) - Siemens C166 family. - -ida_idp.PLFM_C39 (variable) - Rockwell C39. - -ida_idp.PLFM_CR16 (variable) - NSC CR16. - -ida_idp.PLFM_DALVIK (variable) - Android Dalvik Virtual Machine. - -ida_idp.PLFM_DSP56K (variable) - Motorola DSP5600x. - -ida_idp.PLFM_DSP96K (variable) - Motorola DSP96000. - -ida_idp.PLFM_EBC (variable) - EFI Bytecode. - -ida_idp.PLFM_F2MC (variable) - Fujistu F2MC-16. - -ida_idp.PLFM_FR (variable) - Fujitsu FR Family. - -ida_idp.PLFM_H8 (variable) - Hitachi H8/300, H8/2000. - -ida_idp.PLFM_H8500 (variable) - Hitachi H8/500. - -ida_idp.PLFM_HPPA (variable) - Hewlett-Packard PA-RISC. - -ida_idp.PLFM_I860 (variable) - Intel 860. - -ida_idp.PLFM_I960 (variable) - Intel 960. - -ida_idp.PLFM_IA64 (variable) - Intel Itanium IA64. - -ida_idp.PLFM_JAVA (variable) - Java. - -ida_idp.PLFM_KR1878 (variable) - Angstrem KR1878. - -ida_idp.PLFM_M16C (variable) - Renesas M16C. - -ida_idp.PLFM_M32R (variable) - Mitsubishi 32bit RISC. - -ida_idp.PLFM_M740 (variable) - Mitsubishi 8bit. - -ida_idp.PLFM_M7700 (variable) - Mitsubishi 16bit. - -ida_idp.PLFM_M7900 (variable) - Mitsubishi 7900. - -ida_idp.PLFM_MC6812 (variable) - Motorola 68HC12. - -ida_idp.PLFM_MC6816 (variable) - Motorola 68HC16. - -ida_idp.PLFM_MIPS (variable) - MIPS. - -ida_idp.PLFM_MN102L00 (variable) - Panasonic MN10200. - -ida_idp.PLFM_MSP430 (variable) - Texas Instruments MSP430. - -ida_idp.PLFM_NEC_78K0 (variable) - NEC 78K0. - -ida_idp.PLFM_NEC_78K0S (variable) - NEC 78K0S. - -ida_idp.PLFM_NEC_V850X (variable) - NEC V850 and V850ES/E1/E2. - -ida_idp.PLFM_NET (variable) - Microsoft Visual Studio.Net. - -ida_idp.PLFM_OAKDSP (variable) - Atmel OAK DSP. - -ida_idp.PLFM_PDP (variable) - PDP11. - -ida_idp.PLFM_PIC (variable) - Microchip's PIC. - -ida_idp.PLFM_PIC16 (variable) - Microchip's 16-bit PIC. - -ida_idp.PLFM_PPC (variable) - PowerPC. - -ida_idp.PLFM_RISCV (variable) - RISC-V. - -ida_idp.PLFM_RL78 (variable) - Renesas RL78. - -ida_idp.PLFM_RX (variable) - Renesas RX. - -ida_idp.PLFM_S390 (variable) - IBM's S390. - -ida_idp.PLFM_SCR_ADPT (variable) - Processor module adapter for processor modules written in scripting languages. - -ida_idp.PLFM_SH (variable) - Renesas (formerly Hitachi) SuperH. - -ida_idp.PLFM_SPARC (variable) - SPARC. - -ida_idp.PLFM_SPC700 (variable) - Sony SPC700. - -ida_idp.PLFM_SPU (variable) - Cell Broadband Engine Synergistic Processor Unit. - -ida_idp.PLFM_ST20 (variable) - SGS-Thomson ST20. - -ida_idp.PLFM_ST7 (variable) - SGS-Thomson ST7. - -ida_idp.PLFM_ST9 (variable) - ST9+. - -ida_idp.PLFM_TLCS900 (variable) - Toshiba TLCS-900. - -ida_idp.PLFM_TMS (variable) - Texas Instruments TMS320C5x. - -ida_idp.PLFM_TMS320C1X (variable) - Texas Instruments TMS320C1x. - -ida_idp.PLFM_TMS320C28 (variable) - Texas Instruments TMS320C28x. - -ida_idp.PLFM_TMS320C3 (variable) - Texas Instruments TMS320C3. - -ida_idp.PLFM_TMS320C54 (variable) - Texas Instruments TMS320C54xx. - -ida_idp.PLFM_TMS320C55 (variable) - Texas Instruments TMS320C55xx. - -ida_idp.PLFM_TMSC6 (variable) - Texas Instruments TMS320C6x. - -ida_idp.PLFM_TRICORE (variable) - Tasking Tricore. - -ida_idp.PLFM_TRIMEDIA (variable) - Trimedia. - -ida_idp.PLFM_UNSP (variable) - SunPlus unSP. - -ida_idp.PLFM_XTENSA (variable) - Tensilica Xtensa. - -ida_idp.PLFM_Z8 (variable) - Z8. - -ida_idp.PLFM_Z80 (variable) - 8085, Z80 - -ida_idp.PR2_CODE16_BIT (variable) - low bit of code addresses has special meaning e.g. ARM Thumb, MIPS16 - -ida_idp.PR2_FORCE_16BIT (variable) - use 16-bit basic types despite of 32-bit segments (used by c166) - -ida_idp.PR2_IDP_OPTS (variable) - the module has processor-specific configuration options - -ida_idp.PR2_MACRO (variable) - processor supports macro instructions - -ida_idp.PR2_MAPPINGS (variable) - the processor module uses memory mapping - -ida_idp.PR2_REALCVT (variable) - the module has a custom 'ev_realcvt' implementation (otherwise IEEE-754 format - is assumed) - -ida_idp.PR2_REL_BITS (variable) - (Lumina) calcrel info has bits granularity, not bytes - construction flag only - -ida_idp.PR2_USE_CALCREL (variable) - (Lumina) the module supports calcrel info - -ida_idp.PRN_BIN (variable) - binary - -ida_idp.PRN_DEC (variable) - decimal - -ida_idp.PRN_HEX (variable) - hex - -ida_idp.PRN_OCT (variable) - octal - -ida_idp.PR_ADJSEGS (variable) - IDA may adjust segments' starting/ending addresses. - -ida_idp.PR_ALIGN (variable) - All data items should be aligned properly. - -ida_idp.PR_ALIGN_INSN (variable) - allow ida to create alignment instructions arbitrarily. Since these instructions - might lead to other wrong instructions and spoil the listing, IDA does not - create them by default anymore - -ida_idp.PR_ASSEMBLE (variable) - Module has a built-in assembler and will react to ev_assemble. - -ida_idp.PR_BINMEM (variable) - the processor module provides correct segmentation for binary files (i.e. it - creates additional segments). The kernel will not ask the user to specify the - RAM/ROM sizes - -ida_idp.PR_CHK_XREF (variable) - don't allow near xrefs between segments with different bases - -ida_idp.PR_CNDINSNS (variable) - has conditional instructions - -ida_idp.PR_DEFNUM (variable) - mask - default number representation - -ida_idp.PR_DEFSEG32 (variable) - segments are 32-bit by default - -ida_idp.PR_DEFSEG64 (variable) - segments are 64-bit by default - -ida_idp.PR_DELAYED (variable) - has delayed jumps and calls. If this flag is set, - processor_t::is_basic_block_end, processor_t::delay_slot_insn should be - implemented - -ida_idp.PR_NOCHANGE (variable) - The user can't change segments and code/data attributes (display only) - -ida_idp.PR_NO_SEGMOVE (variable) - the processor module doesn't support move_segm() (i.e. the user can't move - segments) - -ida_idp.PR_OUTER (variable) - has outer operands (currently only mc68k) - -ida_idp.PR_PURGING (variable) - there are calling conventions which may purge bytes from the stack - -ida_idp.PR_RNAMESOK (variable) - allow user register names for location names - -ida_idp.PR_SCALE_STKVARS (variable) - use processor_t::get_stkvar_scale callback - -ida_idp.PR_SEGS (variable) - has segment registers? - -ida_idp.PR_SEGTRANS (variable) - the processor module supports the segment translation feature (meaning it - calculates the code addresses using the map_code_ea() function) - -ida_idp.PR_SGROTHER (variable) - the segment registers don't contain the segment selectors. - -ida_idp.PR_STACK_UP (variable) - the stack grows up - -ida_idp.PR_TYPEINFO (variable) - the processor module fully supports type information callbacks; without full - support, function argument locations and other things will probably be wrong. - -ida_idp.PR_USE32 (variable) - supports 32-bit addressing? - -ida_idp.PR_USE64 (variable) - supports 64-bit addressing? - -ida_idp.PR_USE_ARG_TYPES (variable) - use processor_t::use_arg_types callback - -ida_idp.PR_USE_TBYTE (variable) - BTMT_SPECFLT means _TBYTE type - -ida_idp.PR_WORD_INS (variable) - instruction codes are grouped 2bytes in binary line prefix - -ida_idp.REG_SPOIL (variable) - processor_t::use_regarg_type uses this bit in the return value to indicate that - the register value has been spoiled - -ida_idp.SETPROC_IDB (variable) - set processor type for old idb - -ida_idp.SETPROC_LOADER (variable) - set processor type for new idb; if the user has specified a compatible - processor, return success without changing it. if failure, call loader_failure() - -ida_idp.SETPROC_LOADER_NON_FATAL (variable) - the same as SETPROC_LOADER but non-fatal failures. - -ida_idp.SETPROC_USER (variable) - set user-specified processor used for -p and manual processor change at later - time - -ida_idp.__ph (class) - -ida_idp._idp_cvar_t (class) - -ida_idp._notify_when_dispatcher_t (class) - -ida_idp._notify_when_dispatcher_t._IDB_Hooks (class) - -ida_idp._notify_when_dispatcher_t._IDB_Hooks.__init__ (method) - -ida_idp._notify_when_dispatcher_t._IDB_Hooks.closebase (method) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks (class) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks.__init__ (method) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_newfile (method) - -ida_idp._notify_when_dispatcher_t._IDP_Hooks.ev_oldfile (method) - -ida_idp._notify_when_dispatcher_t.__init__ (method) - -ida_idp._notify_when_dispatcher_t._callback_t (class) - -ida_idp._notify_when_dispatcher_t._callback_t.__init__ (method) - -ida_idp._notify_when_dispatcher_t._find (method) - -ida_idp._notify_when_dispatcher_t.dispatch (method) - -ida_idp._notify_when_dispatcher_t.notify_when (method) - -ida_idp._processor_t (class) - Proxy of C++ processor_t class. - -ida_idp._processor_t.__init__ (method) - __init__(self) -> _processor_t - -ida_idp._processor_t.add_cref (method) - add_cref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum cref_t - -ida_idp._processor_t.add_dref (method) - add_dref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum dref_t - -ida_idp._processor_t.adjust_argloc (method) - adjust_argloc(argloc, type, size) -> ssize_t - - Parameters - ---------- - argloc: argloc_t * - type: tinfo_t const * - size: int - -ida_idp._processor_t.adjust_libfunc_ea (method) - adjust_libfunc_ea(sig, libfun, ea) -> ssize_t - - Parameters - ---------- - sig: idasgn_t const & - libfun: libfunc_t const & - ea: ea_t * - -ida_idp._processor_t.adjust_refinfo (method) - adjust_refinfo(ri, ea, n, fd) -> ssize_t - - Parameters - ---------- - ri: refinfo_t * - ea: ea_t - n: int - fd: fixup_data_t const & - -ida_idp._processor_t.ana_insn (method) - ana_insn(out) -> ssize_t - - Parameters - ---------- - out: insn_t * - -ida_idp._processor_t.analyze_prolog (method) - analyze_prolog(fct_ea) -> ssize_t - - Parameters - ---------- - fct_ea: ea_t - -ida_idp._processor_t.arch_changed (method) - arch_changed() -> ssize_t - -ida_idp._processor_t.arg_addrs_ready (method) - arg_addrs_ready(caller, n, tif, addrs) -> ssize_t - - Parameters - ---------- - caller: ea_t - n: int - tif: tinfo_t const & - addrs: ea_t * - -ida_idp._processor_t.asm_installed (method) - asm_installed(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t.assemble (method) - assemble(_bin, ea, cs, ip, _use32, line) -> ssize_t - - Parameters - ---------- - _bin: uchar * - ea: ea_t - cs: ea_t - ip: ea_t - _use32: bool - line: char const * - -ida_idp._processor_t.auto_queue_empty (method) - auto_queue_empty(type) - - Parameters - ---------- - type: int - -ida_idp._processor_t.calc_arglocs (method) - calc_arglocs(fti) -> ssize_t - - Parameters - ---------- - fti: func_type_data_t * - -ida_idp._processor_t.calc_cdecl_purged_bytes (method) - calc_cdecl_purged_bytes(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.calc_next_eas (method) - calc_next_eas(res, insn, over) -> ssize_t - - Parameters - ---------- - res: eavec_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - over: bool - -ida_idp._processor_t.calc_purged_bytes (method) - calc_purged_bytes(p_purged_bytes, fti) -> ssize_t - - Parameters - ---------- - p_purged_bytes: int * - fti: func_type_data_t const & - -ida_idp._processor_t.calc_retloc (method) - calc_retloc(retloc, rettype, cc) -> ssize_t - - Parameters - ---------- - retloc: argloc_t * - rettype: tinfo_t const & - cc: cm_t - -ida_idp._processor_t.calc_spdelta (method) - calc_spdelta(spdelta, ins) -> ssize_t - - Parameters - ---------- - spdelta: sval_t * - ins: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.calc_step_over (method) - calc_step_over(target, ip) -> ssize_t - - Parameters - ---------- - target: ea_t * - ip: ea_t - -ida_idp._processor_t.calc_switch_cases (method) - calc_switch_cases(casevec, targets, insn_ea, si) -> ssize_t - - Parameters - ---------- - casevec: void * - targets: eavec_t * - insn_ea: ea_t - si: switch_info_t const & - -ida_idp._processor_t.calc_varglocs (method) - calc_varglocs(ftd, regs, stkargs, nfixed) -> ssize_t - - Parameters - ---------- - ftd: func_type_data_t * - regs: regobjs_t * - stkargs: relobj_t * - nfixed: int - -ida_idp._processor_t.calcrel (method) - calcrel(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.calcrel_in_bits (method) - calcrel_in_bits(self) -> bool - -ida_idp._processor_t.can_have_type (method) - can_have_type(op) -> ssize_t - - Parameters - ---------- - op: op_t const & - -ida_idp._processor_t.cbsize (method) - cbsize(self) -> int - -ida_idp._processor_t.clean_tbit (method) - clean_tbit(ea, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - ea: ea_t - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.cmp_operands (method) - cmp_operands(op1, op2) -> ssize_t - - Parameters - ---------- - op1: op_t const & - op2: op_t const & - -ida_idp._processor_t.coagulate (method) - coagulate(start_ea) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - -ida_idp._processor_t.coagulate_dref (method) - coagulate_dref(_from, to, may_define, code_ea) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - may_define: bool - code_ea: ea_t * - -ida_idp._processor_t.create_flat_group (method) - create_flat_group(image_base, bitness, dataseg_sel) -> ssize_t - - Parameters - ---------- - image_base: ea_t - bitness: int - dataseg_sel: sel_t - -ida_idp._processor_t.create_func_frame (method) - create_func_frame(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t.create_merge_handlers (method) - create_merge_handlers(md) -> ssize_t - - Parameters - ---------- - md: merge_data_t * - -ida_idp._processor_t.create_switch_xrefs (method) - create_switch_xrefs(jumpea, si) -> ssize_t - - Parameters - ---------- - jumpea: ea_t - si: switch_info_t const & - -ida_idp._processor_t.creating_segm (method) - creating_segm(seg) -> ssize_t - - Parameters - ---------- - seg: segment_t * - -ida_idp._processor_t.cvt64_hashval (method) - cvt64_hashval(self, node, tag, name, data) -> ssize_t - - Parameters - ---------- - node: nodeidx_t - tag: uchar - name: char const * - data: uchar const * - -ida_idp._processor_t.cvt64_supval (method) - cvt64_supval(self, node, tag, idx, data) -> ssize_t - - Parameters - ---------- - node: nodeidx_t - tag: uchar - idx: nodeidx_t - data: uchar const * - -ida_idp._processor_t.dbsize (method) - dbsize(self) -> int - -ida_idp._processor_t.decorate_name (method) - decorate_name(outbuf, name, mangle, cc, type) -> ssize_t - - Parameters - ---------- - outbuf: qstring * - name: char const * - mangle: bool - cc: cm_t - type: tinfo_t const & - -ida_idp._processor_t.del_cref (method) - del_cref(_from, to, expand) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - expand: bool - -ida_idp._processor_t.del_dref (method) - del_dref(_from, to) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - -ida_idp._processor_t.delay_slot_insn (method) - delay_slot_insn(self, ea, bexec, fexec) -> bool - - Parameters - ---------- - ea: ea_t * - bexec: bool * - fexec: bool * - -ida_idp._processor_t.demangle_name (method) - demangle_name(res, name, disable_mask, demreq) -> ssize_t - - Parameters - ---------- - res: int32 * - name: char const * - disable_mask: uint32 - demreq: int - -ida_idp._processor_t.emu_insn (method) - emu_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.endbinary (method) - endbinary(ok) -> ssize_t - - Parameters - ---------- - ok: bool - -ida_idp._processor_t.equal_reglocs (method) - equal_reglocs(a1, a2) -> ssize_t - - Parameters - ---------- - a1: argloc_t const & - a2: argloc_t const & - -ida_idp._processor_t.extract_address (method) - extract_address(out_ea, screen_ea, string, x) -> ssize_t - - Parameters - ---------- - out_ea: ea_t * - screen_ea: ea_t - string: char const * - x: size_t - -ida_idp._processor_t.find_op_value (method) - find_op_value(insn, op) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - op: int - -ida_idp._processor_t.find_reg_value (method) - find_reg_value(insn, reg) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - reg: int - -ida_idp._processor_t.func_bounds (method) - func_bounds(possible_return_code, pfn, max_func_end_ea) -> ssize_t - - Parameters - ---------- - possible_return_code: int * - pfn: func_t * - max_func_end_ea: ea_t - -ida_idp._processor_t.gen_asm_or_lst (method) - gen_asm_or_lst(starting, fp, is_asm, flags, outline) -> ssize_t - - Parameters - ---------- - starting: bool - fp: FILE * - is_asm: bool - flags: int - outline: void * - -ida_idp._processor_t.gen_map_file (method) - gen_map_file(nlines, fp) -> ssize_t - - Parameters - ---------- - nlines: int * - fp: FILE * - -ida_idp._processor_t.gen_regvar_def (method) - gen_regvar_def(ctx, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - v: regvar_t * - -ida_idp._processor_t.gen_src_file_lnnum (method) - gen_src_file_lnnum(ctx, file, lnnum) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - file: char const * - lnnum: size_t - -ida_idp._processor_t.gen_stkvar_def (method) - gen_stkvar_def(ctx, mptr, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - mptr: member_t const * - v: sval_t - -ida_idp._processor_t.get_abi_info (method) - get_abi_info(abi_names, abi_opts, comp) -> ssize_t - - Parameters - ---------- - abi_names: qstrvec_t * - abi_opts: qstrvec_t * - comp: comp_t - -ida_idp._processor_t.get_autocmt (method) - get_autocmt(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.get_bg_color (method) - get_bg_color(color, ea) -> ssize_t - - Parameters - ---------- - color: bgcolor_t * - ea: ea_t - -ida_idp._processor_t.get_canon_feature (method) - get_canon_feature(self, itype) -> uint32 - - Parameters - ---------- - itype: uint16 - -ida_idp._processor_t.get_canon_mnem (method) - get_canon_mnem(self, itype) -> char const * - - Parameters - ---------- - itype: uint16 - -ida_idp._processor_t.get_cc_regs (method) - get_cc_regs(regs, cc) -> ssize_t - - Parameters - ---------- - regs: callregs_t * - cc: cm_t - -ida_idp._processor_t.get_code16_mode (method) - get_code16_mode(ea) -> bool - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.get_dbr_opnum (method) - get_dbr_opnum(opnum, insn) -> ssize_t - - Parameters - ---------- - opnum: int * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.get_default_segm_bitness (method) - get_default_segm_bitness(self, is_64bit_app) -> int - - Parameters - ---------- - is_64bit_app: bool - -ida_idp._processor_t.get_frame_retsize (method) - get_frame_retsize(retsize, pfn) -> ssize_t - - Parameters - ---------- - retsize: int * - pfn: func_t const * - -ida_idp._processor_t.get_idd_opinfo (method) - get_idd_opinfo(opinf, ea, n, thread_id, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - opinf: idd_opinfo_t * - ea: ea_t - n: int - thread_id: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.get_macro_insn_head (method) - get_macro_insn_head(head, ip) -> ssize_t - - Parameters - ---------- - head: ea_t * - ip: ea_t - -ida_idp._processor_t.get_operand_string (method) - get_operand_string(insn, opnum) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - opnum: int - -ida_idp._processor_t.get_proc_index (method) - get_proc_index(self) -> int - -ida_idp._processor_t.get_reg_accesses (method) - get_reg_accesses(accvec, insn, flags) -> ssize_t - - Parameters - ---------- - accvec: reg_accesses_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - flags: int - -ida_idp._processor_t.get_reg_info (method) - get_reg_info(regname, bitrange) -> char const * - - Parameters - ---------- - regname: char const * - bitrange: bitrange_t * - -ida_idp._processor_t.get_reg_name (method) - get_reg_name(reg, width, reghi) -> ssize_t - - Parameters - ---------- - reg: int - width: size_t - reghi: int - -ida_idp._processor_t.get_simd_types (method) - get_simd_types(out, simd_attrs, argloc, create_tifs) -> ssize_t - - Parameters - ---------- - out: void * - simd_attrs: simd_info_t const * - argloc: argloc_t const * - create_tifs: bool - -ida_idp._processor_t.get_stkarg_area_info (method) - get_stkarg_area_info(out, cc) -> ssize_t - - Parameters - ---------- - out: stkarg_area_info_t * - cc: cm_t - -ida_idp._processor_t.get_stkvar_scale (method) - get_stkvar_scale(self) -> int - -ida_idp._processor_t.get_stkvar_scale_factor (method) - get_stkvar_scale_factor() -> ssize_t - -ida_idp._processor_t.getreg (method) - getreg(rv, regnum) -> ssize_t - - Parameters - ---------- - rv: uval_t * - regnum: int - -ida_idp._processor_t.has_code16_bit (method) - has_code16_bit(self) -> bool - -ida_idp._processor_t.has_idp_opts (method) - has_idp_opts(self) -> bool - -ida_idp._processor_t.has_realcvt (method) - has_realcvt(self) -> bool - -ida_idp._processor_t.has_segregs (method) - has_segregs(self) -> bool - -ida_idp._processor_t.init (method) - init(idp_modname) -> ssize_t - - Parameters - ---------- - idp_modname: char const * - -ida_idp._processor_t.insn_reads_tbit (method) - insn_reads_tbit(insn, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.is_align_insn (method) - is_align_insn(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.is_alloca_probe (method) - is_alloca_probe(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.is_basic_block_end (method) - is_basic_block_end(insn, call_insn_stops_block) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - call_insn_stops_block: bool - -ida_idp._processor_t.is_call_insn (method) - is_call_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.is_cond_insn (method) - is_cond_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.is_control_flow_guard (method) - is_control_flow_guard(p_reg, insn) -> ssize_t - - Parameters - ---------- - p_reg: int * - insn: insn_t const * - -ida_idp._processor_t.is_far_jump (method) - is_far_jump(icode) -> ssize_t - - Parameters - ---------- - icode: int - -ida_idp._processor_t.is_indirect_jump (method) - is_indirect_jump(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.is_jump_func (method) - is_jump_func(pfn, jump_target, func_pointer) -> ssize_t - - Parameters - ---------- - pfn: func_t * - jump_target: ea_t * - func_pointer: ea_t * - -ida_idp._processor_t.is_ret_insn (method) - is_ret_insn(insn, strict) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - strict: bool - -ida_idp._processor_t.is_sane_insn (method) - is_sane_insn(insn, no_crefs) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - no_crefs: int - -ida_idp._processor_t.is_sp_based (method) - is_sp_based(insn, x) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - x: op_t const & - -ida_idp._processor_t.is_switch (method) - is_switch(si, insn) -> ssize_t - - Parameters - ---------- - si: switch_info_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t.loader_elf_machine (method) - loader_elf_machine(li, machine_type, p_procname, p_pd, ldr, reader) -> ssize_t - - Parameters - ---------- - li: linput_t * - machine_type: int - p_procname: char const ** - p_pd: proc_def_t ** - ldr: elf_loader_t * - reader: reader_t * - -ida_idp._processor_t.lower_func_type (method) - lower_func_type(argnums, fti) -> ssize_t - - Parameters - ---------- - argnums: intvec_t * - fti: func_type_data_t * - -ida_idp._processor_t.max_ptr_size (method) - max_ptr_size() -> ssize_t - -ida_idp._processor_t.may_be_func (method) - may_be_func(insn, state) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - state: int - -ida_idp._processor_t.may_show_sreg (method) - may_show_sreg(current_ea) -> ssize_t - - Parameters - ---------- - current_ea: ea_t - -ida_idp._processor_t.moving_segm (method) - moving_segm(seg, to, flags) -> ssize_t - - Parameters - ---------- - seg: segment_t * - to: ea_t - flags: int - -ida_idp._processor_t.newasm (method) - newasm(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t.newbinary (method) - newbinary(filename, fileoff, basepara, binoff, nbytes) -> ssize_t - - Parameters - ---------- - filename: char const * - fileoff: qoff64_t - basepara: ea_t - binoff: ea_t - nbytes: uint64 - -ida_idp._processor_t.newfile (method) - newfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t.newprc (method) - newprc(pnum, keep_cfg) -> ssize_t - - Parameters - ---------- - pnum: int - keep_cfg: bool - -ida_idp._processor_t.next_exec_insn (method) - next_exec_insn(target, ea, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - target: ea_t * - ea: ea_t - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.notify (method) - notify(event_code) -> ssize_t - - Parameters - ---------- - event_code: enum processor_t::event_t - -ida_idp._processor_t.oldfile (method) - oldfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t.out_assumes (method) - out_assumes(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_data (method) - out_data(ctx, analyze_only) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - analyze_only: bool - -ida_idp._processor_t.out_footer (method) - out_footer(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_header (method) - out_header(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_insn (method) - out_insn(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_label (method) - out_label(ctx, colored_name) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - colored_name: char const * - -ida_idp._processor_t.out_mnem (method) - out_mnem(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t.out_operand (method) - out_operand(ctx, op) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - op: op_t const & - -ida_idp._processor_t.out_segend (method) - out_segend(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t.out_segstart (method) - out_segstart(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t.out_special_item (method) - out_special_item(ctx, segtype) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - segtype: uchar - -ida_idp._processor_t.privrange_changed (method) - privrange_changed(self, old_privrange, delta) -> ssize_t - - Parameters - ---------- - old_privrange: range_t const & - delta: adiff_t - -ida_idp._processor_t.realcvt (method) - realcvt(m, e, swt) -> fpvalue_error_t - - Parameters - ---------- - m: void * - e: fpvalue_t * - swt: uint16 - -ida_idp._processor_t.rename (method) - rename(ea, new_name, flags) -> ssize_t - - Parameters - ---------- - ea: ea_t - new_name: char const * - flags: int - -ida_idp._processor_t.set_code16_mode (method) - set_code16_mode(ea, code16=True) -> ssize_t - - Parameters - ---------- - ea: ea_t - code16: bool - -ida_idp._processor_t.set_idp_options (method) - set_idp_options(keyword, vtype, value, idb_loaded=True) -> char const * - - Parameters - ---------- - keyword: char const * - vtype: int - value: void const * - idb_loaded: bool - -ida_idp._processor_t.set_proc_options (method) - set_proc_options(options, confidence) -> ssize_t - - Parameters - ---------- - options: char const * - confidence: int - -ida_idp._processor_t.setup_til (method) - setup_til() -> ssize_t - -ida_idp._processor_t.sizeof_ldbl (method) - sizeof_ldbl(self) -> size_t - -ida_idp._processor_t.stkup (method) - stkup(self) -> bool - -ida_idp._processor_t.str2reg (method) - str2reg(regname) -> ssize_t - - Parameters - ---------- - regname: char const * - -ida_idp._processor_t.supports_calcrel (method) - supports_calcrel(self) -> bool - -ida_idp._processor_t.supports_macros (method) - supports_macros(self) -> bool - -ida_idp._processor_t.term (method) - term() -> ssize_t - -ida_idp._processor_t.ti (method) - ti(self) -> bool - -ida_idp._processor_t.treat_hindering_item (method) - treat_hindering_item(hindering_item_ea, new_item_flags, new_item_ea, new_item_length) -> ssize_t - - Parameters - ---------- - hindering_item_ea: ea_t - new_item_flags: flags64_t - new_item_ea: ea_t - new_item_length: asize_t - -ida_idp._processor_t.undefine (method) - undefine(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t.update_call_stack (method) - update_call_stack(stack, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - stack: call_stack_t * - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t.use32 (method) - use32(self) -> bool - -ida_idp._processor_t.use64 (method) - use64(self) -> bool - -ida_idp._processor_t.use_arg_types (method) - use_arg_types(ea, fti, rargs) -> ssize_t - - Parameters - ---------- - ea: ea_t - fti: func_type_data_t * - rargs: void * - -ida_idp._processor_t.use_mappings (method) - use_mappings(self) -> bool - -ida_idp._processor_t.use_regarg_type (method) - use_regarg_type(idx, ea, rargs) -> ssize_t - - Parameters - ---------- - idx: int * - ea: ea_t - rargs: void * - -ida_idp._processor_t.use_stkarg_type (method) - use_stkarg_type(ea, arg) -> ssize_t - - Parameters - ---------- - ea: ea_t - arg: funcarg_t const & - -ida_idp._processor_t.use_tbyte (method) - use_tbyte(self) -> bool - -ida_idp._processor_t.validate_flirt_func (method) - validate_flirt_func(start_ea, funcname) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - funcname: char const * - -ida_idp._processor_t.verify_noreturn (method) - verify_noreturn(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t.verify_sp (method) - verify_sp(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t_Trampoline_IDB_Hooks (class) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__dummy (method) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__init__ (method) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller (method) - -ida_idp._processor_t_Trampoline_IDB_Hooks.__make_parent_caller.call_parent (function) - -ida_idp._processor_t_add_cref (function) - _processor_t_add_cref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum cref_t - -ida_idp._processor_t_add_dref (function) - _processor_t_add_dref(_from, to, type) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - type: enum dref_t - -ida_idp._processor_t_adjust_argloc (function) - _processor_t_adjust_argloc(argloc, type, size) -> ssize_t - - Parameters - ---------- - argloc: argloc_t * - type: tinfo_t const * - size: int - -ida_idp._processor_t_adjust_libfunc_ea (function) - _processor_t_adjust_libfunc_ea(sig, libfun, ea) -> ssize_t - - Parameters - ---------- - sig: idasgn_t const & - libfun: libfunc_t const & - ea: ea_t * - -ida_idp._processor_t_adjust_refinfo (function) - _processor_t_adjust_refinfo(ri, ea, n, fd) -> ssize_t - - Parameters - ---------- - ri: refinfo_t * - ea: ea_t - n: int - fd: fixup_data_t const & - -ida_idp._processor_t_ana_insn (function) - _processor_t_ana_insn(out) -> ssize_t - - Parameters - ---------- - out: insn_t * - -ida_idp._processor_t_analyze_prolog (function) - _processor_t_analyze_prolog(fct_ea) -> ssize_t - - Parameters - ---------- - fct_ea: ea_t - -ida_idp._processor_t_arch_changed (function) - _processor_t_arch_changed() -> ssize_t - -ida_idp._processor_t_arg_addrs_ready (function) - _processor_t_arg_addrs_ready(caller, n, tif, addrs) -> ssize_t - - Parameters - ---------- - caller: ea_t - n: int - tif: tinfo_t const & - addrs: ea_t * - -ida_idp._processor_t_asm_installed (function) - _processor_t_asm_installed(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t_assemble (function) - _processor_t_assemble(_bin, ea, cs, ip, _use32, line) -> ssize_t - - Parameters - ---------- - _bin: uchar * - ea: ea_t - cs: ea_t - ip: ea_t - _use32: bool - line: char const * - -ida_idp._processor_t_auto_queue_empty (function) - _processor_t_auto_queue_empty(type) - - Parameters - ---------- - type: int - -ida_idp._processor_t_calc_arglocs (function) - _processor_t_calc_arglocs(fti) -> ssize_t - - Parameters - ---------- - fti: func_type_data_t * - -ida_idp._processor_t_calc_cdecl_purged_bytes (function) - _processor_t_calc_cdecl_purged_bytes(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_calc_next_eas (function) - _processor_t_calc_next_eas(res, insn, over) -> ssize_t - - Parameters - ---------- - res: eavec_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - over: bool - -ida_idp._processor_t_calc_purged_bytes (function) - _processor_t_calc_purged_bytes(p_purged_bytes, fti) -> ssize_t - - Parameters - ---------- - p_purged_bytes: int * - fti: func_type_data_t const & - -ida_idp._processor_t_calc_retloc (function) - _processor_t_calc_retloc(retloc, rettype, cc) -> ssize_t - - Parameters - ---------- - retloc: argloc_t * - rettype: tinfo_t const & - cc: cm_t - -ida_idp._processor_t_calc_spdelta (function) - _processor_t_calc_spdelta(spdelta, ins) -> ssize_t - - Parameters - ---------- - spdelta: sval_t * - ins: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_calc_step_over (function) - _processor_t_calc_step_over(target, ip) -> ssize_t - - Parameters - ---------- - target: ea_t * - ip: ea_t - -ida_idp._processor_t_calc_switch_cases (function) - _processor_t_calc_switch_cases(casevec, targets, insn_ea, si) -> ssize_t - - Parameters - ---------- - casevec: void * - targets: eavec_t * - insn_ea: ea_t - si: switch_info_t const & - -ida_idp._processor_t_calc_varglocs (function) - _processor_t_calc_varglocs(ftd, regs, stkargs, nfixed) -> ssize_t - - Parameters - ---------- - ftd: func_type_data_t * - regs: regobjs_t * - stkargs: relobj_t * - nfixed: int - -ida_idp._processor_t_calcrel (function) - _processor_t_calcrel(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_can_have_type (function) - _processor_t_can_have_type(op) -> ssize_t - - Parameters - ---------- - op: op_t const & - -ida_idp._processor_t_clean_tbit (function) - _processor_t_clean_tbit(ea, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - ea: ea_t - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_cmp_operands (function) - _processor_t_cmp_operands(op1, op2) -> ssize_t - - Parameters - ---------- - op1: op_t const & - op2: op_t const & - -ida_idp._processor_t_coagulate (function) - _processor_t_coagulate(start_ea) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - -ida_idp._processor_t_coagulate_dref (function) - _processor_t_coagulate_dref(_from, to, may_define, code_ea) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - may_define: bool - code_ea: ea_t * - -ida_idp._processor_t_create_flat_group (function) - _processor_t_create_flat_group(image_base, bitness, dataseg_sel) -> ssize_t - - Parameters - ---------- - image_base: ea_t - bitness: int - dataseg_sel: sel_t - -ida_idp._processor_t_create_func_frame (function) - _processor_t_create_func_frame(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t_create_merge_handlers (function) - _processor_t_create_merge_handlers(md) -> ssize_t - - Parameters - ---------- - md: merge_data_t * - -ida_idp._processor_t_create_switch_xrefs (function) - _processor_t_create_switch_xrefs(jumpea, si) -> ssize_t - - Parameters - ---------- - jumpea: ea_t - si: switch_info_t const & - -ida_idp._processor_t_creating_segm (function) - _processor_t_creating_segm(seg) -> ssize_t - - Parameters - ---------- - seg: segment_t * - -ida_idp._processor_t_decorate_name (function) - _processor_t_decorate_name(outbuf, name, mangle, cc, type) -> ssize_t - - Parameters - ---------- - outbuf: qstring * - name: char const * - mangle: bool - cc: cm_t - type: tinfo_t const & - -ida_idp._processor_t_del_cref (function) - _processor_t_del_cref(_from, to, expand) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - expand: bool - -ida_idp._processor_t_del_dref (function) - _processor_t_del_dref(_from, to) -> ssize_t - - Parameters - ---------- - from: ea_t - to: ea_t - -ida_idp._processor_t_demangle_name (function) - _processor_t_demangle_name(res, name, disable_mask, demreq) -> ssize_t - - Parameters - ---------- - res: int32 * - name: char const * - disable_mask: uint32 - demreq: int - -ida_idp._processor_t_emu_insn (function) - _processor_t_emu_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_endbinary (function) - _processor_t_endbinary(ok) -> ssize_t - - Parameters - ---------- - ok: bool - -ida_idp._processor_t_equal_reglocs (function) - _processor_t_equal_reglocs(a1, a2) -> ssize_t - - Parameters - ---------- - a1: argloc_t const & - a2: argloc_t const & - -ida_idp._processor_t_extract_address (function) - _processor_t_extract_address(out_ea, screen_ea, string, x) -> ssize_t - - Parameters - ---------- - out_ea: ea_t * - screen_ea: ea_t - string: char const * - x: size_t - -ida_idp._processor_t_find_op_value (function) - _processor_t_find_op_value(insn, op) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - op: int - -ida_idp._processor_t_find_reg_value (function) - _processor_t_find_reg_value(insn, reg) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - reg: int - -ida_idp._processor_t_func_bounds (function) - _processor_t_func_bounds(possible_return_code, pfn, max_func_end_ea) -> ssize_t - - Parameters - ---------- - possible_return_code: int * - pfn: func_t * - max_func_end_ea: ea_t - -ida_idp._processor_t_gen_asm_or_lst (function) - _processor_t_gen_asm_or_lst(starting, fp, is_asm, flags, outline) -> ssize_t - - Parameters - ---------- - starting: bool - fp: FILE * - is_asm: bool - flags: int - outline: void * - -ida_idp._processor_t_gen_map_file (function) - _processor_t_gen_map_file(nlines, fp) -> ssize_t - - Parameters - ---------- - nlines: int * - fp: FILE * - -ida_idp._processor_t_gen_regvar_def (function) - _processor_t_gen_regvar_def(ctx, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - v: regvar_t * - -ida_idp._processor_t_gen_src_file_lnnum (function) - _processor_t_gen_src_file_lnnum(ctx, file, lnnum) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - file: char const * - lnnum: size_t - -ida_idp._processor_t_gen_stkvar_def (function) - _processor_t_gen_stkvar_def(ctx, mptr, v) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - mptr: member_t const * - v: sval_t - -ida_idp._processor_t_get_abi_info (function) - _processor_t_get_abi_info(abi_names, abi_opts, comp) -> ssize_t - - Parameters - ---------- - abi_names: qstrvec_t * - abi_opts: qstrvec_t * - comp: comp_t - -ida_idp._processor_t_get_autocmt (function) - _processor_t_get_autocmt(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_get_bg_color (function) - _processor_t_get_bg_color(color, ea) -> ssize_t - - Parameters - ---------- - color: bgcolor_t * - ea: ea_t - -ida_idp._processor_t_get_cc_regs (function) - _processor_t_get_cc_regs(regs, cc) -> ssize_t - - Parameters - ---------- - regs: callregs_t * - cc: cm_t - -ida_idp._processor_t_get_code16_mode (function) - _processor_t_get_code16_mode(ea) -> bool - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_get_dbr_opnum (function) - _processor_t_get_dbr_opnum(opnum, insn) -> ssize_t - - Parameters - ---------- - opnum: int * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_get_frame_retsize (function) - _processor_t_get_frame_retsize(retsize, pfn) -> ssize_t - - Parameters - ---------- - retsize: int * - pfn: func_t const * - -ida_idp._processor_t_get_idd_opinfo (function) - _processor_t_get_idd_opinfo(opinf, ea, n, thread_id, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - opinf: idd_opinfo_t * - ea: ea_t - n: int - thread_id: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_get_macro_insn_head (function) - _processor_t_get_macro_insn_head(head, ip) -> ssize_t - - Parameters - ---------- - head: ea_t * - ip: ea_t - -ida_idp._processor_t_get_operand_string (function) - _processor_t_get_operand_string(insn, opnum) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - opnum: int - -ida_idp._processor_t_get_reg_accesses (function) - _processor_t_get_reg_accesses(accvec, insn, flags) -> ssize_t - - Parameters - ---------- - accvec: reg_accesses_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - flags: int - -ida_idp._processor_t_get_reg_info (function) - _processor_t_get_reg_info(regname, bitrange) -> char const * - - Parameters - ---------- - regname: char const * - bitrange: bitrange_t * - -ida_idp._processor_t_get_reg_name (function) - _processor_t_get_reg_name(reg, width, reghi) -> ssize_t - - Parameters - ---------- - reg: int - width: size_t - reghi: int - -ida_idp._processor_t_get_simd_types (function) - _processor_t_get_simd_types(out, simd_attrs, argloc, create_tifs) -> ssize_t - - Parameters - ---------- - out: void * - simd_attrs: simd_info_t const * - argloc: argloc_t const * - create_tifs: bool - -ida_idp._processor_t_get_stkarg_area_info (function) - _processor_t_get_stkarg_area_info(out, cc) -> ssize_t - - Parameters - ---------- - out: stkarg_area_info_t * - cc: cm_t - -ida_idp._processor_t_get_stkvar_scale_factor (function) - _processor_t_get_stkvar_scale_factor() -> ssize_t - -ida_idp._processor_t_getreg (function) - _processor_t_getreg(rv, regnum) -> ssize_t - - Parameters - ---------- - rv: uval_t * - regnum: int - -ida_idp._processor_t_init (function) - _processor_t_init(idp_modname) -> ssize_t - - Parameters - ---------- - idp_modname: char const * - -ida_idp._processor_t_insn_reads_tbit (function) - _processor_t_insn_reads_tbit(insn, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_is_align_insn (function) - _processor_t_is_align_insn(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_is_alloca_probe (function) - _processor_t_is_alloca_probe(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_is_basic_block_end (function) - _processor_t_is_basic_block_end(insn, call_insn_stops_block) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - call_insn_stops_block: bool - -ida_idp._processor_t_is_call_insn (function) - _processor_t_is_call_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_is_cond_insn (function) - _processor_t_is_cond_insn(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_is_control_flow_guard (function) - _processor_t_is_control_flow_guard(p_reg, insn) -> ssize_t - - Parameters - ---------- - p_reg: int * - insn: insn_t const * - -ida_idp._processor_t_is_far_jump (function) - _processor_t_is_far_jump(icode) -> ssize_t - - Parameters - ---------- - icode: int - -ida_idp._processor_t_is_indirect_jump (function) - _processor_t_is_indirect_jump(insn) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_is_jump_func (function) - _processor_t_is_jump_func(pfn, jump_target, func_pointer) -> ssize_t - - Parameters - ---------- - pfn: func_t * - jump_target: ea_t * - func_pointer: ea_t * - -ida_idp._processor_t_is_ret_insn (function) - _processor_t_is_ret_insn(insn, strict) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - strict: bool - -ida_idp._processor_t_is_sane_insn (function) - _processor_t_is_sane_insn(insn, no_crefs) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - no_crefs: int - -ida_idp._processor_t_is_sp_based (function) - _processor_t_is_sp_based(insn, x) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - x: op_t const & - -ida_idp._processor_t_is_switch (function) - _processor_t_is_switch(si, insn) -> ssize_t - - Parameters - ---------- - si: switch_info_t * - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp._processor_t_loader_elf_machine (function) - _processor_t_loader_elf_machine(li, machine_type, p_procname, p_pd, ldr, reader) -> ssize_t - - Parameters - ---------- - li: linput_t * - machine_type: int - p_procname: char const ** - p_pd: proc_def_t ** - ldr: elf_loader_t * - reader: reader_t * - -ida_idp._processor_t_lower_func_type (function) - _processor_t_lower_func_type(argnums, fti) -> ssize_t - - Parameters - ---------- - argnums: intvec_t * - fti: func_type_data_t * - -ida_idp._processor_t_max_ptr_size (function) - _processor_t_max_ptr_size() -> ssize_t - -ida_idp._processor_t_may_be_func (function) - _processor_t_may_be_func(insn, state) -> ssize_t - - Parameters - ---------- - insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - state: int - -ida_idp._processor_t_may_show_sreg (function) - _processor_t_may_show_sreg(current_ea) -> ssize_t - - Parameters - ---------- - current_ea: ea_t - -ida_idp._processor_t_moving_segm (function) - _processor_t_moving_segm(seg, to, flags) -> ssize_t - - Parameters - ---------- - seg: segment_t * - to: ea_t - flags: int - -ida_idp._processor_t_newasm (function) - _processor_t_newasm(asmnum) -> ssize_t - - Parameters - ---------- - asmnum: int - -ida_idp._processor_t_newbinary (function) - _processor_t_newbinary(filename, fileoff, basepara, binoff, nbytes) -> ssize_t - - Parameters - ---------- - filename: char const * - fileoff: qoff64_t - basepara: ea_t - binoff: ea_t - nbytes: uint64 - -ida_idp._processor_t_newfile (function) - _processor_t_newfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t_newprc (function) - _processor_t_newprc(pnum, keep_cfg) -> ssize_t - - Parameters - ---------- - pnum: int - keep_cfg: bool - -ida_idp._processor_t_next_exec_insn (function) - _processor_t_next_exec_insn(target, ea, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - target: ea_t * - ea: ea_t - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_notify (function) - _processor_t_notify(event_code) -> ssize_t - - Parameters - ---------- - event_code: enum processor_t::event_t - -ida_idp._processor_t_oldfile (function) - _processor_t_oldfile(fname) -> ssize_t - - Parameters - ---------- - fname: char const * - -ida_idp._processor_t_out_assumes (function) - _processor_t_out_assumes(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_data (function) - _processor_t_out_data(ctx, analyze_only) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - analyze_only: bool - -ida_idp._processor_t_out_footer (function) - _processor_t_out_footer(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_header (function) - _processor_t_out_header(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_insn (function) - _processor_t_out_insn(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_label (function) - _processor_t_out_label(ctx, colored_name) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - colored_name: char const * - -ida_idp._processor_t_out_mnem (function) - _processor_t_out_mnem(ctx) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - -ida_idp._processor_t_out_operand (function) - _processor_t_out_operand(ctx, op) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - op: op_t const & - -ida_idp._processor_t_out_segend (function) - _processor_t_out_segend(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t_out_segstart (function) - _processor_t_out_segstart(ctx, seg) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - seg: segment_t * - -ida_idp._processor_t_out_special_item (function) - _processor_t_out_special_item(ctx, segtype) -> ssize_t - - Parameters - ---------- - ctx: outctx_t & - segtype: uchar - -ida_idp._processor_t_realcvt (function) - _processor_t_realcvt(m, e, swt) -> fpvalue_error_t - - Parameters - ---------- - m: void * - e: fpvalue_t * - swt: uint16 - -ida_idp._processor_t_rename (function) - _processor_t_rename(ea, new_name, flags) -> ssize_t - - Parameters - ---------- - ea: ea_t - new_name: char const * - flags: int - -ida_idp._processor_t_set_code16_mode (function) - _processor_t_set_code16_mode(ea, code16=True) -> ssize_t - - Parameters - ---------- - ea: ea_t - code16: bool - -ida_idp._processor_t_set_idp_options (function) - _processor_t_set_idp_options(keyword, vtype, value, idb_loaded=True) -> char const * - - Parameters - ---------- - keyword: char const * - vtype: int - value: void const * - idb_loaded: bool - -ida_idp._processor_t_set_proc_options (function) - _processor_t_set_proc_options(options, confidence) -> ssize_t - - Parameters - ---------- - options: char const * - confidence: int - -ida_idp._processor_t_setup_til (function) - _processor_t_setup_til() -> ssize_t - -ida_idp._processor_t_str2reg (function) - _processor_t_str2reg(regname) -> ssize_t - - Parameters - ---------- - regname: char const * - -ida_idp._processor_t_term (function) - _processor_t_term() -> ssize_t - -ida_idp._processor_t_treat_hindering_item (function) - _processor_t_treat_hindering_item(hindering_item_ea, new_item_flags, new_item_ea, new_item_length) -> ssize_t - - Parameters - ---------- - hindering_item_ea: ea_t - new_item_flags: flags64_t - new_item_ea: ea_t - new_item_length: asize_t - -ida_idp._processor_t_undefine (function) - _processor_t_undefine(ea) -> ssize_t - - Parameters - ---------- - ea: ea_t - -ida_idp._processor_t_update_call_stack (function) - _processor_t_update_call_stack(stack, tid, _getreg, regvalues) -> ssize_t - - Parameters - ---------- - stack: call_stack_t * - tid: int - _getreg: processor_t::regval_getter_t * - regvalues: regval_t const & - -ida_idp._processor_t_use_arg_types (function) - _processor_t_use_arg_types(ea, fti, rargs) -> ssize_t - - Parameters - ---------- - ea: ea_t - fti: func_type_data_t * - rargs: void * - -ida_idp._processor_t_use_regarg_type (function) - _processor_t_use_regarg_type(idx, ea, rargs) -> ssize_t - - Parameters - ---------- - idx: int * - ea: ea_t - rargs: void * - -ida_idp._processor_t_use_stkarg_type (function) - _processor_t_use_stkarg_type(ea, arg) -> ssize_t - - Parameters - ---------- - ea: ea_t - arg: funcarg_t const & - -ida_idp._processor_t_validate_flirt_func (function) - _processor_t_validate_flirt_func(start_ea, funcname) -> ssize_t - - Parameters - ---------- - start_ea: ea_t - funcname: char const * - -ida_idp._processor_t_verify_noreturn (function) - _processor_t_verify_noreturn(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp._processor_t_verify_sp (function) - _processor_t_verify_sp(pfn) -> ssize_t - - Parameters - ---------- - pfn: func_t * - -ida_idp.asm_t (class) - Proxy of C++ asm_t class. - -ida_idp.asm_t.__init__ (method) - __init__(self) -> asm_t - -ida_idp.asm_t.a_align (variable) - "align" keyword - -ida_idp.asm_t.a_ascii (variable) - string literal directive - -ida_idp.asm_t.a_band (variable) - & bit and assembler time operation - -ida_idp.asm_t.a_bnot (variable) - ~ bit not assembler time operation - -ida_idp.asm_t.a_bor (variable) - | bit or assembler time operation - -ida_idp.asm_t.a_bss (variable) - uninitialized data directive should include 's' for the size of data - -ida_idp.asm_t.a_byte (variable) - byte directive - -ida_idp.asm_t.a_comdef (variable) - "comm" (communal variable) - -ida_idp.asm_t.a_curip (variable) - current IP (instruction pointer) symbol in assembler - -ida_idp.asm_t.a_double (variable) - double; 8bytes; nullptr if not allowed - -ida_idp.asm_t.a_dups (variable) - array keyword. the following sequences may appear: - * #h header - * #d size - * #v value - * #s(b,w,l,q,f,d,o) size specifiers for byte,word, dword,qword, - float,double,oword - -ida_idp.asm_t.a_dword (variable) - nullptr if not allowed - -ida_idp.asm_t.a_equ (variable) - 'equ' Used if AS_UNEQU is set - -ida_idp.asm_t.a_extrn (variable) - "extern" name keyword - -ida_idp.asm_t.a_float (variable) - float; 4bytes; nullptr if not allowed - -ida_idp.asm_t.a_include_fmt (variable) - the include directive (format string) - -ida_idp.asm_t.a_mod (variable) - % mod assembler time operation - -ida_idp.asm_t.a_oword (variable) - nullptr if not allowed - -ida_idp.asm_t.a_packreal (variable) - packed decimal real nullptr if not allowed - -ida_idp.asm_t.a_public (variable) - "public" name keyword. nullptr-use default, ""-do not generate - -ida_idp.asm_t.a_qword (variable) - nullptr if not allowed - -ida_idp.asm_t.a_rva (variable) - 'rva' keyword for image based offsets (see REFINFO_RVAOFF) - -ida_idp.asm_t.a_seg (variable) - 'seg ' prefix (example: push seg seg001) - -ida_idp.asm_t.a_shl (variable) - << shift left assembler time operation - -ida_idp.asm_t.a_shr (variable) - >> shift right assembler time operation - -ida_idp.asm_t.a_sizeof_fmt (variable) - size of type (format string) - -ida_idp.asm_t.a_tbyte (variable) - long double; nullptr if not allowed - -ida_idp.asm_t.a_vstruc_fmt (variable) - if a named item is a structure and displayed in the verbose (multiline) form - then display the name as printf(a_strucname_fmt, typename) (for asms with type - checking, e.g. tasm ideal) - -ida_idp.asm_t.a_weak (variable) - "weak" name keyword. nullptr-use default, ""-do not generate - -ida_idp.asm_t.a_word (variable) - word directive - -ida_idp.asm_t.a_xor (variable) - ^ bit xor assembler time operation - -ida_idp.asm_t.a_yword (variable) - 32-byte (256-bit) data; nullptr if not allowed requires AS2_YWORD - -ida_idp.asm_t.a_zword (variable) - 64-byte (512-bit) data; nullptr if not allowed requires AS2_ZWORD - -ida_idp.asm_t.accsep (variable) - char constant delimiter - -ida_idp.asm_t.ascsep (variable) - string literal delimiter - -ida_idp.asm_t.cmnt (variable) - comment string (see also cmnt2) - -ida_idp.asm_t.cmnt2 (variable) - comment close string (usually nullptr) this is used to denote a string which - closes comments, for example, if the comments are represented with (* ... *) - then cmnt = "(*" and cmnt2 = "*)" - -ida_idp.asm_t.end (variable) - end directive - -ida_idp.asm_t.esccodes (variable) - special chars that cannot appear as is in string and char literals - -ida_idp.asm_t.flag (variable) - Assembler feature bits - -ida_idp.asm_t.flag2 (variable) - Secondary assembler feature bits - -ida_idp.asm_t.header (variable) - array of automatically generated header lines they appear at the start of - disassembled text - -ida_idp.asm_t.help (variable) - Help screen number, 0 - no help. - -ida_idp.asm_t.high16 (variable) - high16 - -ida_idp.asm_t.high8 (variable) - high8 - -ida_idp.asm_t.lbrace (variable) - left brace used in complex expressions - -ida_idp.asm_t.low16 (variable) - low16 - -ida_idp.asm_t.low8 (variable) - low8 operation, should contain s for the operand - -ida_idp.asm_t.name (variable) - Assembler name (displayed in menus) - -ida_idp.asm_t.origin (variable) - org directive - -ida_idp.asm_t.rbrace (variable) - right brace used in complex expressions - -ida_idp.asm_t.uflag (variable) - user defined flags (local only for IDP) you may define and use your own bits - -ida_idp.assemble (function) - 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. - -ida_idp.cfg_get_cc_header_path (function) - cfg_get_cc_header_path(compid) -> char const * - - @param compid: comp_t - -ida_idp.cfg_get_cc_parm (function) - cfg_get_cc_parm(compid, name) -> char const * - - @param compid: comp_t - @param name: char const * - -ida_idp.cfg_get_cc_predefined_macros (function) - cfg_get_cc_predefined_macros(compid) -> char const * - - @param compid: comp_t - -ida_idp.delay_slot_insn (function) - delay_slot_insn(ea, bexec, fexec) -> bool - - @param ea: ea_t * - @param bexec: bool * - @param fexec: bool * - -ida_idp.gen_idb_event (function) - gen_idb_event(code) - the kernel will use this function to generate idb_events - - @param code: (C++: idb_event::event_code_t) enum idb_event::event_code_t - -ida_idp.get_ash (function) - get_ash() -> asm_t - -ida_idp.get_config_value (function) - get_config_value(key) -> bool - - @param key: char const * - -ida_idp.get_idb_notifier_addr (function) - get_idb_notifier_addr(arg1) -> PyObject * - - @param arg1: PyObject * - -ida_idp.get_idb_notifier_ud_addr (function) - get_idb_notifier_ud_addr(hooks) -> PyObject * - - @param hooks: IDB_Hooks * - -ida_idp.get_idp_name (function) - get_idp_name() -> str - Get name of the current processor module. The name is derived from the file - name. For example, for IBM PC the module is named "pc.w32" (windows version), - then the module name is "PC" (uppercase). If no processor module is loaded, this - function will return nullptr - -ida_idp.get_idp_notifier_addr (function) - get_idp_notifier_addr(arg1) -> PyObject * - - @param arg1: PyObject * - -ida_idp.get_idp_notifier_ud_addr (function) - get_idp_notifier_ud_addr(hooks) -> PyObject * - - @param hooks: IDP_Hooks * - -ida_idp.get_ph (function) - get_ph() -> _processor_t - -ida_idp.get_reg_info (function) - get_reg_info(regname, bitrange) -> char const * - - @param regname: char const * - @param bitrange: bitrange_t * - -ida_idp.get_reg_name (function) - get_reg_name(reg, width, reghi=-1) -> str - Get text representation of a register. For most processors this function will - just return processor_t::reg_names[reg]. If the processor module has implemented - processor_t::get_reg_name, it will be used instead - - @param reg: (C++: int) internal register number as defined in the processor module - @param width: (C++: size_t) register width in bytes - @param reghi: (C++: int) if specified, then this function will return the register pair - @return: length of register name in bytes or -1 if failure - -ida_idp.has_cf_chg (function) - has_cf_chg(feature, opnum) -> bool - Does an instruction with the specified feature modify the i-th operand? - - @param feature: (C++: uint32) - @param opnum: (C++: uint) - -ida_idp.has_cf_use (function) - has_cf_use(feature, opnum) -> bool - Does an instruction with the specified feature use a value of the i-th operand? - - @param feature: (C++: uint32) - @param opnum: (C++: uint) - -ida_idp.has_insn_feature (function) - has_insn_feature(icode, bit) -> bool - Does the specified instruction have the specified feature? - - @param icode: (C++: uint16) - @param bit: (C++: uint32) - -ida_idp.is_align_insn (function) - is_align_insn(ea) -> int - If the instruction at 'ea' looks like an alignment instruction, return its - length in bytes. Otherwise return 0. - - @param ea: (C++: ea_t) - -ida_idp.is_basic_block_end (function) - is_basic_block_end(insn, call_insn_stops_block) -> bool - Is the instruction the end of a basic block? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param call_insn_stops_block: (C++: bool) - -ida_idp.is_call_insn (function) - is_call_insn(insn) -> bool - Is the instruction a "call"? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp.is_indirect_jump_insn (function) - is_indirect_jump_insn(insn) -> bool - Is the instruction an indirect jump? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_idp.is_ret_insn (function) - is_ret_insn(insn, strict=True) -> bool - Is the instruction a "return"? - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param strict: (C++: bool) - -ida_idp.num_range_t (class) - Proxy of C++ cfgopt_t::num_range_t class. - -ida_idp.num_range_t.__init__ (method) - __init__(self, _min, _max) -> num_range_t - - @param _min: int64 - @param _max: int64 - -ida_idp.params_t (class) - Proxy of C++ cfgopt_t::params_t class. - -ida_idp.params_t.__init__ (method) - __init__(self, _p1, _p2) -> params_t - - @param _p1: int64 - @param _p2: int64 - -ida_idp.parse_reg_name (function) - parse_reg_name(ri, regname) -> bool - Get register info by name. - - @param ri: (C++: reg_info_t *) result - @param regname: (C++: const char *) name of register - @return: success - -ida_idp.ph_calcrel (function) - ph_calcrel(ea) - - @param ea: ea_t - -ida_idp.ph_find_op_value (function) - ph_find_op_value(insn, op) -> ssize_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: int - -ida_idp.ph_find_reg_value (function) - ph_find_reg_value(insn, reg) -> ssize_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param reg: int - -ida_idp.ph_get_cnbits (function) - ph_get_cnbits() -> size_t - Returns the 'ph.cnbits' - -ida_idp.ph_get_dnbits (function) - ph_get_dnbits() -> size_t - Returns the 'ph.dnbits' - -ida_idp.ph_get_flag (function) - ph_get_flag() -> size_t - Returns the 'ph.flag' - -ida_idp.ph_get_icode_return (function) - ph_get_icode_return() -> size_t - Returns the 'ph.icode_return' - -ida_idp.ph_get_id (function) - ph_get_id() -> size_t - Returns the 'ph.id' field - -ida_idp.ph_get_instruc (function) - ph_get_instruc() -> [(str, int), ...] - Returns a list of tuples (instruction_name, instruction_feature) containing the - instructions list as defined in he processor module - -ida_idp.ph_get_instruc_end (function) - ph_get_instruc_end() -> size_t - Returns the 'ph.instruc_end' - -ida_idp.ph_get_instruc_start (function) - ph_get_instruc_start() -> size_t - Returns the 'ph.instruc_start' - -ida_idp.ph_get_operand_info (function) - ph_get_operand_info(ea, n) -> (int, int, int, int, int) or None - 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. - -ida_idp.ph_get_reg_accesses (function) - ph_get_reg_accesses(accvec, insn, flags) -> ssize_t - - @param accvec: reg_accesses_t * - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param flags: int - -ida_idp.ph_get_reg_code_sreg (function) - ph_get_reg_code_sreg() -> size_t - Returns the 'ph.reg_code_sreg' - -ida_idp.ph_get_reg_data_sreg (function) - ph_get_reg_data_sreg() -> size_t - Returns the 'ph.reg_data_sreg' - -ida_idp.ph_get_reg_first_sreg (function) - ph_get_reg_first_sreg() -> size_t - Returns the 'ph.reg_first_sreg' - -ida_idp.ph_get_reg_last_sreg (function) - ph_get_reg_last_sreg() -> size_t - Returns the 'ph.reg_last_sreg' - -ida_idp.ph_get_regnames (function) - ph_get_regnames() -> [str, ...] - Returns the list of register names as defined in the processor module - -ida_idp.ph_get_segreg_size (function) - ph_get_segreg_size() -> size_t - Returns the 'ph.segreg_size' - -ida_idp.ph_get_tbyte_size (function) - ph_get_tbyte_size() -> size_t - Returns the 'ph.tbyte_size' field as defined in he processor module - -ida_idp.ph_get_version (function) - ph_get_version() -> size_t - Returns the 'ph.version' - -ida_idp.process_config_directive (function) - process_config_directive(directive, priority=2) - - @param directive: char const * - @param priority: int - -ida_idp.processor_t (class) - Base class for all processor module scripts - - A processor_t instance is both an ida_idp.IDP_Hooks, and an - ida_idp.IDB_Hooks at the same time: any method of those two classes - can be overridden in your processor_t subclass (with the exception of - 'ida_idp.IDP_Hooks.ev_init' (replaced with processor_t.__init__), - and 'ida_idp.IDP_Hooks.ev_term' (replaced with processor_t.__del__)). - -ida_idp.processor_t.__init__ (method) - -ida_idp.processor_t._get_idb_notifier_addr (method) - -ida_idp.processor_t._get_idb_notifier_ud_addr (method) - -ida_idp.processor_t._get_idp_notifier_addr (method) - -ida_idp.processor_t._get_idp_notifier_ud_addr (method) - -ida_idp.processor_t._get_notify (method) - This helper is used to implement backward-compatibility - of pre IDA 7.3 processor_t interfaces. - -ida_idp.processor_t._make_forced_value_wrapper (method) - -ida_idp.processor_t._make_forced_value_wrapper.f (function) - -ida_idp.processor_t._make_int_returning_wrapper (method) - -ida_idp.processor_t._make_int_returning_wrapper.f (function) - -ida_idp.processor_t.auto_empty (method) - -ida_idp.processor_t.auto_empty_finally (method) - -ida_idp.processor_t.closebase (method) - -ida_idp.processor_t.compiler_changed (method) - -ida_idp.processor_t.deleting_func (method) - -ida_idp.processor_t.determined_main (method) - -ida_idp.processor_t.ev_ana_insn (method) - -ida_idp.processor_t.ev_assemble (method) - -ida_idp.processor_t.ev_auto_queue_empty (method) - -ida_idp.processor_t.ev_calc_step_over (method) - -ida_idp.processor_t.ev_can_have_type (method) - -ida_idp.processor_t.ev_cmp_operands (method) - -ida_idp.processor_t.ev_coagulate (method) - -ida_idp.processor_t.ev_coagulate_dref (method) - -ida_idp.processor_t.ev_create_func_frame (method) - -ida_idp.processor_t.ev_create_switch_xrefs (method) - -ida_idp.processor_t.ev_creating_segm (method) - -ida_idp.processor_t.ev_emu_insn (method) - -ida_idp.processor_t.ev_endbinary (method) - -ida_idp.processor_t.ev_func_bounds (method) - -ida_idp.processor_t.ev_gen_map_file (method) - -ida_idp.processor_t.ev_gen_regvar_def (method) - -ida_idp.processor_t.ev_gen_src_file_lnnum (method) - -ida_idp.processor_t.ev_get_autocmt (method) - -ida_idp.processor_t.ev_get_frame_retsize (method) - -ida_idp.processor_t.ev_get_operand_string (method) - -ida_idp.processor_t.ev_is_align_insn (method) - -ida_idp.processor_t.ev_is_alloca_probe (method) - -ida_idp.processor_t.ev_is_basic_block_end (method) - -ida_idp.processor_t.ev_is_call_insn (method) - -ida_idp.processor_t.ev_is_far_jump (method) - -ida_idp.processor_t.ev_is_indirect_jump (method) - -ida_idp.processor_t.ev_is_insn_table_jump (method) - -ida_idp.processor_t.ev_is_ret_insn (method) - -ida_idp.processor_t.ev_is_sane_insn (method) - -ida_idp.processor_t.ev_is_sp_based (method) - -ida_idp.processor_t.ev_is_switch (method) - -ida_idp.processor_t.ev_may_be_func (method) - -ida_idp.processor_t.ev_may_show_sreg (method) - -ida_idp.processor_t.ev_moving_segm (method) - -ida_idp.processor_t.ev_newbinary (method) - -ida_idp.processor_t.ev_newfile (method) - -ida_idp.processor_t.ev_newprc (method) - -ida_idp.processor_t.ev_oldfile (method) - -ida_idp.processor_t.ev_out_assumes (method) - -ida_idp.processor_t.ev_out_data (method) - -ida_idp.processor_t.ev_out_footer (method) - -ida_idp.processor_t.ev_out_header (method) - -ida_idp.processor_t.ev_out_insn (method) - -ida_idp.processor_t.ev_out_label (method) - -ida_idp.processor_t.ev_out_mnem (method) - -ida_idp.processor_t.ev_out_operand (method) - -ida_idp.processor_t.ev_out_segend (method) - -ida_idp.processor_t.ev_out_segstart (method) - -ida_idp.processor_t.ev_out_special_item (method) - -ida_idp.processor_t.ev_rename (method) - -ida_idp.processor_t.ev_set_idp_options (method) - -ida_idp.processor_t.ev_set_proc_options (method) - -ida_idp.processor_t.ev_str2reg (method) - -ida_idp.processor_t.ev_treat_hindering_item (method) - -ida_idp.processor_t.ev_undefine (method) - -ida_idp.processor_t.ev_validate_flirt_func (method) - -ida_idp.processor_t.ev_verify_noreturn (method) - -ida_idp.processor_t.ev_verify_sp (method) - -ida_idp.processor_t.func_added (method) - -ida_idp.processor_t.get_auxpref (method) - This function returns insn.auxpref value - -ida_idp.processor_t.get_idpdesc (method) - This function must be present and should return the list of - short processor names similar to the one in ph.psnames. - This method can be overridden to return to the kernel a different IDP description. - -ida_idp.processor_t.get_uFlag (method) - Use this utility function to retrieve the 'uFlag' global variable - -ida_idp.processor_t.idasgn_loaded (method) - -ida_idp.processor_t.kernel_config_loaded (method) - -ida_idp.processor_t.make_code (method) - -ida_idp.processor_t.make_data (method) - -ida_idp.processor_t.renamed (method) - -ida_idp.processor_t.savebase (method) - -ida_idp.processor_t.segm_moved (method) - -ida_idp.processor_t.set_func_end (method) - -ida_idp.processor_t.set_func_start (method) - -ida_idp.processor_t.sgr_changed (method) - -ida_idp.reg_access_t (class) - Proxy of C++ reg_access_t class. - -ida_idp.reg_access_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: reg_access_t const & - -ida_idp.reg_access_t.__init__ (method) - __init__(self) -> reg_access_t - -ida_idp.reg_access_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: reg_access_t const & - -ida_idp.reg_access_t.have_common_bits (method) - have_common_bits(self, r) -> bool - - @param r: reg_access_t const & - -ida_idp.reg_access_t.opnum (variable) - operand number - -ida_idp.reg_access_t.range (variable) - bitrange inside the register - -ida_idp.reg_access_t.regnum (variable) - register number (only entire registers) - -ida_idp.reg_access_vec_t (class) - Proxy of C++ qvector< reg_access_t > class. - -ida_idp.reg_access_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< reg_access_t > const & - -ida_idp.reg_access_vec_t.__getitem__ (method) - __getitem__(self, i) -> reg_access_t - - @param i: size_t - -ida_idp.reg_access_vec_t.__init__ (method) - __init__(self) -> reg_access_vec_t - __init__(self, x) -> reg_access_vec_t - - @param x: qvector< reg_access_t > const & - -ida_idp.reg_access_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_idp.reg_access_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< reg_access_t > const & - -ida_idp.reg_access_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: reg_access_t const & - -ida_idp.reg_access_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: reg_access_t const & - -ida_idp.reg_access_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: reg_access_t const & - -ida_idp.reg_access_vec_t.at (method) - at(self, _idx) -> reg_access_t - - @param _idx: size_t - -ida_idp.reg_access_vec_t.begin (method) - begin(self) -> reg_access_t - -ida_idp.reg_access_vec_t.capacity (method) - capacity(self) -> size_t - -ida_idp.reg_access_vec_t.clear (method) - clear(self) - -ida_idp.reg_access_vec_t.empty (method) - empty(self) -> bool - -ida_idp.reg_access_vec_t.end (method) - end(self) -> reg_access_t - -ida_idp.reg_access_vec_t.erase (method) - erase(self, it) -> reg_access_t - - @param it: qvector< reg_access_t >::iterator - - erase(self, first, last) -> reg_access_t - - @param first: qvector< reg_access_t >::iterator - @param last: qvector< reg_access_t >::iterator - -ida_idp.reg_access_vec_t.extract (method) - extract(self) -> reg_access_t - -ida_idp.reg_access_vec_t.find (method) - find(self, x) -> reg_access_t - - @param x: reg_access_t const & - -ida_idp.reg_access_vec_t.grow (method) - grow(self, x=reg_access_t()) - - @param x: reg_access_t const & - -ida_idp.reg_access_vec_t.has (method) - has(self, x) -> bool - - @param x: reg_access_t const & - -ida_idp.reg_access_vec_t.inject (method) - inject(self, s, len) - - @param s: reg_access_t * - @param len: size_t - -ida_idp.reg_access_vec_t.insert (method) - insert(self, it, x) -> reg_access_t - - @param it: qvector< reg_access_t >::iterator - @param x: reg_access_t const & - -ida_idp.reg_access_vec_t.pop_back (method) - pop_back(self) - -ida_idp.reg_access_vec_t.push_back (method) - push_back(self, x) - - @param x: reg_access_t const & - - push_back(self) -> reg_access_t - -ida_idp.reg_access_vec_t.qclear (method) - qclear(self) - -ida_idp.reg_access_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_idp.reg_access_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: reg_access_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_idp.reg_access_vec_t.size (method) - size(self) -> size_t - -ida_idp.reg_access_vec_t.swap (method) - swap(self, r) - - @param r: qvector< reg_access_t > & - -ida_idp.reg_access_vec_t.truncate (method) - truncate(self) - -ida_idp.reg_accesses_t (class) - Proxy of C++ reg_accesses_t class. - -ida_idp.reg_accesses_t.__init__ (method) - __init__(self) -> reg_accesses_t - -ida_idp.reg_info_t (class) - Proxy of C++ reg_info_t class. - -ida_idp.reg_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: reg_info_t const & - -ida_idp.reg_info_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: reg_info_t const & - -ida_idp.reg_info_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: reg_info_t const & - -ida_idp.reg_info_t.__init__ (method) - __init__(self) -> reg_info_t - -ida_idp.reg_info_t.__le__ (method) - __le__(self, r) -> bool - - @param r: reg_info_t const & - -ida_idp.reg_info_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: reg_info_t const & - -ida_idp.reg_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: reg_info_t const & - -ida_idp.reg_info_t.compare (method) - compare(self, r) -> int - - @param r: reg_info_t const & - -ida_idp.reg_info_t.reg (variable) - register number - -ida_idp.reg_info_t.size (variable) - register size - -ida_idp.register_cfgopts (function) - register_cfgopts(opts, nopts, cb=None, obj=None) -> bool - - @param opts: cfgopt_t const [] - @param nopts: size_t - @param cb: config_changed_cb_t * - @param obj: void * - -ida_idp.set_processor_type (function) - set_processor_type(procname, level) -> bool - Set target processor type. Once a processor module is loaded, it cannot be - replaced until we close the idb. - - @param procname: (C++: const char *) name of processor type (one of names present in - processor_t::psnames) - @param level: (C++: setproc_level_t) SETPROC_ - @return: success - -ida_idp.set_target_assembler (function) - set_target_assembler(asmnum) -> bool - Set target assembler. - - @param asmnum: (C++: int) number of assembler in the current processor module - @return: success - -ida_idp.sizeof_ldbl (function) - sizeof_ldbl() -> size_t - -ida_idp.str2reg (function) - str2reg(p) -> int - Get any reg number (-1 on error) - - @param p: (C++: const char *) char const * - -ida_ieee (module) - IEEE floating point functions. - -ida_ieee.E_SPECIAL_EXP (variable) - Exponent in fpvalue_t for NaN and Inf. - -ida_ieee.FPV_BADARG (variable) - wrong value of max_exp - -ida_ieee.FPV_NAN (variable) - NaN. - -ida_ieee.FPV_NINF (variable) - negative infinity - -ida_ieee.FPV_NORM (variable) - regular value - -ida_ieee.FPV_PINF (variable) - positive infinity - -ida_ieee.IEEE_EXONE (variable) - The exponent of 1.0. - -ida_ieee.REAL_ERROR_FPOVER (variable) - floating overflow or underflow - -ida_ieee.REAL_ERROR_INTOVER (variable) - eetol*: integer overflow - -ida_ieee.REAL_ERROR_OK (variable) - no error - -ida_ieee.ecleaz (function) - ecleaz(x) - - @param x: unsigned short [(6+3)] - -ida_ieee.fpvalue_shorts_array_t (class) - Proxy of C++ wrapped_array_t< uint16,FPVAL_NWORDS > class. - -ida_ieee.fpvalue_shorts_array_t.__getitem__ (method) - __getitem__(self, i) -> unsigned short const & - - @param i: size_t - -ida_ieee.fpvalue_shorts_array_t.__init__ (method) - __init__(self, data) -> fpvalue_shorts_array_t - - @param data: unsigned short (&)[FPVAL_NWORDS] - -ida_ieee.fpvalue_shorts_array_t.__len__ (method) - __len__(self) -> size_t - -ida_ieee.fpvalue_shorts_array_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned short const & - -ida_ieee.fpvalue_shorts_array_t._get_bytes (method) - _get_bytes(self) -> bytevec_t - -ida_ieee.fpvalue_shorts_array_t._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & - -ida_ieee.fpvalue_t (class) - Proxy of C++ fpvalue_t class. - -ida_ieee.fpvalue_t.__add__ (method) - __add__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & - -ida_ieee.fpvalue_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.__getitem__ (method) - -ida_ieee.fpvalue_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.__init__ (method) - __init__(self) -> fpvalue_t - __init__(self, _in) -> fpvalue_t - - @param in: bytevec12_t const & - -ida_ieee.fpvalue_t.__iter__ (method) - -ida_ieee.fpvalue_t.__le__ (method) - __le__(self, r) -> bool - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.__mul__ (method) - __mul__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & - -ida_ieee.fpvalue_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.__setitem__ (method) - -ida_ieee.fpvalue_t.__str__ (method) - __str__(self) -> qstring - -ida_ieee.fpvalue_t.__sub__ (method) - __sub__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & - -ida_ieee.fpvalue_t.__truediv__ (method) - __truediv__(self, o) -> fpvalue_t - - @param o: fpvalue_t const & - -ida_ieee.fpvalue_t._get_10bytes (method) - _get_10bytes(self) - -ida_ieee.fpvalue_t._get_bytes (method) - _get_bytes(self) - -ida_ieee.fpvalue_t._get_float (method) - _get_float(self) -> double - -ida_ieee.fpvalue_t._get_shorts (method) - _get_shorts(self) -> fpvalue_shorts_array_t - -ida_ieee.fpvalue_t._set_10bytes (method) - _set_10bytes(self, _in) - - Parameters - ---------- - in: bytevec10_t const & - -ida_ieee.fpvalue_t._set_bytes (method) - _set_bytes(self, _in) - - Parameters - ---------- - in: bytevec12_t const & - -ida_ieee.fpvalue_t._set_float (method) - _set_float(self, v) - - Parameters - ---------- - v: double - -ida_ieee.fpvalue_t.assign (method) - assign(self, r) - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.clear (method) - clear(self) - -ida_ieee.fpvalue_t.compare (method) - compare(self, r) -> int - - @param r: fpvalue_t const & - -ida_ieee.fpvalue_t.eabs (method) - eabs(self) - Calculate absolute value. - -ida_ieee.fpvalue_t.fadd (method) - fadd(self, y) -> fpvalue_error_t - Arithmetic operations. - - @param y: (C++: const fpvalue_t &) fpvalue_t const & - -ida_ieee.fpvalue_t.fdiv (method) - fdiv(self, y) -> fpvalue_error_t - - @param y: fpvalue_t const & - -ida_ieee.fpvalue_t.fmul (method) - fmul(self, y) -> fpvalue_error_t - - @param y: fpvalue_t const & - -ida_ieee.fpvalue_t.from_10bytes (method) - from_10bytes(self, fpval) -> fpvalue_error_t - Conversions for 10-byte floating point values. - - @param fpval: (C++: const void *) void const * - -ida_ieee.fpvalue_t.from_12bytes (method) - from_12bytes(self, fpval) -> fpvalue_error_t - Conversions for 12-byte floating point values. - - @param fpval: (C++: const void *) void const * - -ida_ieee.fpvalue_t.from_int64 (method) - from_int64(self, x) - - @param x: int64 - -ida_ieee.fpvalue_t.from_str (method) - from_str(self, p) -> fpvalue_error_t - Convert string to IEEE. - - @param p_str: (C++: const char **) pointer to pointer to string. it will advanced. - -ida_ieee.fpvalue_t.from_sval (method) - from_sval(self, x) - Convert integer to IEEE. - - @param x: (C++: sval_t) - -ida_ieee.fpvalue_t.from_uint64 (method) - from_uint64(self, x) - - @param x: uint64 - -ida_ieee.fpvalue_t.fsub (method) - fsub(self, y) -> fpvalue_error_t - - @param y: fpvalue_t const & - -ida_ieee.fpvalue_t.get_kind (method) - get_kind(self) -> fpvalue_kind_t - Get value kind. - -ida_ieee.fpvalue_t.is_negative (method) - is_negative(self) -> bool - Is negative value? - -ida_ieee.fpvalue_t.mul_pow2 (method) - mul_pow2(self, power_of_2) -> fpvalue_error_t - Multiply by a power of 2. - - @param power_of_2: (C++: int32) - -ida_ieee.fpvalue_t.negate (method) - negate(self) - Negate. - -ida_ieee.fpvalue_t.to_10bytes (method) - to_10bytes(self, fpval) -> fpvalue_error_t - - @param fpval: void * - -ida_ieee.fpvalue_t.to_12bytes (method) - to_12bytes(self, fpval) -> fpvalue_error_t - - @param fpval: void * - -ida_ieee.fpvalue_t.to_int64 (method) - to_int64(self, round=False) -> fpvalue_error_t - - @param round: bool - -ida_ieee.fpvalue_t.to_str (method) - to_str(self, mode) - Convert IEEE to string. - - @param mode: (C++: uint) broken down into: - * low byte: number of digits after '.' - * second byte: FPNUM_LENGTH - * third byte: FPNUM_DIGITS - -ida_ieee.fpvalue_t.to_sval (method) - to_sval(self, round=False) -> fpvalue_error_t - Convert IEEE to integer (+-0.5 if round) - - @param round: (C++: bool) - -ida_ieee.fpvalue_t.to_uint64 (method) - to_uint64(self, round=False) -> fpvalue_error_t - - @param round: bool - -ida_kernwin (module) - Defines the interface between the kernel and the UI. - - It contains: - * the UI dispatcher notification codes (ui_notification_t) - * convenience functions for UI services - * structures which hold information about the lines (disassembly, structures, - enums) generated by the kernel - * functions to interact with the user (dialog boxes) - * some string and conversion functions. - -ida_kernwin.AA_CHECKABLE (variable) - see update_action_checkable() - -ida_kernwin.AA_CHECKED (variable) - see update_action_checked() - -ida_kernwin.AA_ICON (variable) - see update_action_icon() - -ida_kernwin.AA_LABEL (variable) - see update_action_label() - -ida_kernwin.AA_NONE (variable) - no effect - -ida_kernwin.AA_SHORTCUT (variable) - see update_action_shortcut() - -ida_kernwin.AA_STATE (variable) - see update_action_state() - -ida_kernwin.AA_TOOLTIP (variable) - see update_action_tooltip() - -ida_kernwin.AA_VISIBILITY (variable) - see update_action_visibility() - -ida_kernwin.ACF_HAS_FIELD_DIRTREE_SELECTION (variable) - 'cur_enum_member' and 'dirtree_selection' fields are present - -ida_kernwin.ACF_HAS_SELECTION (variable) - there is currently a valid selection - -ida_kernwin.ACF_HAS_SOURCE (variable) - 'source' field is present - -ida_kernwin.ACF_HAS_TYPE_REF (variable) - 'type_ref' field is present - -ida_kernwin.ACF_XTRN_EA (variable) - cur_ea is in 'externs' segment - -ida_kernwin.ADF_CHECKABLE (variable) - action is checkable - -ida_kernwin.ADF_CHECKED (variable) - starts in a checked state (requires ADF_CHECKABLE) - -ida_kernwin.ADF_GLOBAL (variable) - Register the action globally, so that it's available even if no IDB is present - -ida_kernwin.ADF_NO_HIGHLIGHT (variable) - After activating, do not update the highlight according to what's under the - cursor (listings only.) - -ida_kernwin.ADF_NO_UNDO (variable) - the action does not create an undo point. useful for actions that do not modify - the database. - -ida_kernwin.ADF_OT_MASK (variable) - Owner type mask. - -ida_kernwin.ADF_OT_PLUGIN (variable) - Owner is a plugin_t. - -ida_kernwin.ADF_OT_PLUGMOD (variable) - Owner is a plugmod_t. - -ida_kernwin.ADF_OT_PROCMOD (variable) - Owner is a procmod_t. - -ida_kernwin.ADF_OWN_HANDLER (variable) - handler is owned by the action; it'll be destroyed when the action is - unregistered. Use DYNACTION_DESC_LITERAL to set this bit. - -ida_kernwin.AHF_VERSION (variable) - action handler version (used by action_handler_t::flags) - -ida_kernwin.AHF_VERSION_MASK (variable) - mask for action_handler_t::flags - -ida_kernwin.ASKBTN_BTN1 (variable) - First (Yes) button. - -ida_kernwin.ASKBTN_BTN2 (variable) - Second (No) button. - -ida_kernwin.ASKBTN_BTN3 (variable) - Third (Cancel) button. - -ida_kernwin.ASKBTN_CANCEL (variable) - Cancel button. - -ida_kernwin.ASKBTN_NO (variable) - No button. - -ida_kernwin.ASKBTN_YES (variable) - Yes button. - -ida_kernwin.AST_DISABLE (variable) - analog of AST_ENABLE - -ida_kernwin.AST_DISABLE_ALWAYS (variable) - disable action and do not call action_handler_t::action() anymore - -ida_kernwin.AST_DISABLE_FOR_IDB (variable) - analog of AST_ENABLE_FOR_IDB - -ida_kernwin.AST_DISABLE_FOR_WIDGET (variable) - analog of AST_ENABLE_FOR_WIDGET - -ida_kernwin.AST_ENABLE (variable) - enable action - call action_handler_t::update() when anything changes - -ida_kernwin.AST_ENABLE_ALWAYS (variable) - enable action and do not call action_handler_t::update() anymore - -ida_kernwin.AST_ENABLE_FOR_IDB (variable) - enable action for the current idb. call action_handler_t::update() when a - database is opened/closed - -ida_kernwin.AST_ENABLE_FOR_WIDGET (variable) - enable action for the current widget. call action_handler_t::update() when a - widget gets/loses focus - -ida_kernwin.BWN_ADDRWATCH (variable) - the 'Watch List' window - -ida_kernwin.BWN_BOOKMARKS (variable) - a persistent 'Bookmarks' widget - -ida_kernwin.BWN_BPTS (variable) - breakpoints - -ida_kernwin.BWN_CALLS (variable) - function calls - -ida_kernwin.BWN_CALLS_CALLEES (variable) - function calls, callees - -ida_kernwin.BWN_CALLS_CALLERS (variable) - function calls, callers - -ida_kernwin.BWN_CALL_STACK (variable) - call stack - -ida_kernwin.BWN_CHOOSER (variable) - a non-builtin chooser - -ida_kernwin.BWN_CLI (variable) - the command-line, in the output window - -ida_kernwin.BWN_CMDPALCSR (variable) - the command palette chooser (Qt version only) - -ida_kernwin.BWN_CMDPALWIN (variable) - the command palette window (Qt version only) - -ida_kernwin.BWN_CPUREGS (variable) - one of the 'General registers', 'FPU register', ... debugger windows - -ida_kernwin.BWN_CUSTVIEW (variable) - custom viewers - -ida_kernwin.BWN_CV_LINE_INFOS (variable) - custom viewers' lineinfo widget - -ida_kernwin.BWN_DISASM (variable) - disassembly views - -ida_kernwin.BWN_DISASMS (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_DISASM_ARROWS (variable) - disassembly arrows widget - -ida_kernwin.BWN_DUMP (variable) - hex dumps - -ida_kernwin.BWN_DUMPS (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_ENUMS (variable) - enumerations - -ida_kernwin.BWN_EXPORTS (variable) - exports - -ida_kernwin.BWN_FRAME (variable) - function frame - -ida_kernwin.BWN_FUNCS (variable) - functions - -ida_kernwin.BWN_IMPORTS (variable) - imports - -ida_kernwin.BWN_LOCALS (variable) - the 'locals' debugger window - -ida_kernwin.BWN_LOCTYPS (variable) - local types - -ida_kernwin.BWN_MDVIEWCSR (variable) - lumina metadata view chooser - -ida_kernwin.BWN_MODULES (variable) - modules - -ida_kernwin.BWN_NAMES (variable) - names - -ida_kernwin.BWN_NAVBAND (variable) - navigation band - -ida_kernwin.BWN_NOTEPAD (variable) - notepad - -ida_kernwin.BWN_OUTPUT (variable) - the text area, in the output window - -ida_kernwin.BWN_PROBS (variable) - problems - -ida_kernwin.BWN_PSEUDOCODE (variable) - hexrays decompiler views - -ida_kernwin.BWN_SCRIPTS_CSR (variable) - the "Recent scripts" chooser - -ida_kernwin.BWN_SEARCH (variable) - search results - -ida_kernwin.BWN_SEARCHS (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_SEGREGS (variable) - segment registers - -ida_kernwin.BWN_SEGS (variable) - segments - -ida_kernwin.BWN_SELS (variable) - selectors - -ida_kernwin.BWN_SHORTCUTCSR (variable) - the shortcuts chooser (Qt version only) - -ida_kernwin.BWN_SHORTCUTWIN (variable) - the shortcuts window (Qt version only) - -ida_kernwin.BWN_SIGNS (variable) - signatures - -ida_kernwin.BWN_SNIPPETS (variable) - the 'Execute script' window - -ida_kernwin.BWN_SNIPPETS_CSR (variable) - the list of snippets in the 'Execute script' window - -ida_kernwin.BWN_SO_OFFSETS (variable) - the 'Structure offsets' dialog's offset panel - -ida_kernwin.BWN_SO_STRUCTS (variable) - the 'Structure offsets' dialog's 'Structures and Unions' panel - -ida_kernwin.BWN_SRCPTHMAP_CSR (variable) - "Source paths..."'s path mappings chooser - -ida_kernwin.BWN_SRCPTHUND_CSR (variable) - "Source paths..."'s undesired paths chooser - -ida_kernwin.BWN_STACK (variable) - Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.BWN_STKVIEW (variable) - the 'Stack view' debugger window - -ida_kernwin.BWN_STRINGS (variable) - strings - -ida_kernwin.BWN_STRUCTS (variable) - structures - -ida_kernwin.BWN_THREADS (variable) - threads - -ida_kernwin.BWN_TILIST (variable) - a types listing widget - -ida_kernwin.BWN_TILS (variable) - type libraries - -ida_kernwin.BWN_TRACE (variable) - tracing view - -ida_kernwin.BWN_UNDOHIST (variable) - Undo history. - -ida_kernwin.BWN_UNKNOWN (variable) - unknown window - -ida_kernwin.BWN_WATCH (variable) - the 'watches' debugger window - -ida_kernwin.BWN_XREFS (variable) - xrefs - -ida_kernwin.CDVF_LINEICONS (variable) - icons can be drawn over the line control - -ida_kernwin.CDVF_NOLINES (variable) - don't show line numbers - -ida_kernwin.CDVF_STATUSBAR (variable) - keep the status bar in the custom viewer - -ida_kernwin.CDVH_LINES_ALIGNMENT (variable) - see set_code_viewer_lines_alignment() - -ida_kernwin.CDVH_LINES_CLICK (variable) - see code_viewer_lines_click_t - -ida_kernwin.CDVH_LINES_DBLCLICK (variable) - see code_viewer_lines_click_t - -ida_kernwin.CDVH_LINES_DRAWICON (variable) - see code_viewer_lines_icon_t - -ida_kernwin.CDVH_LINES_ICONMARGIN (variable) - see set_code_viewer_lines_icon_margin() - -ida_kernwin.CDVH_LINES_LINENUM (variable) - see code_viewer_lines_linenum_t - -ida_kernwin.CDVH_LINES_POPUP (variable) - see code_viewer_lines_click_t - -ida_kernwin.CDVH_LINES_RADIX (variable) - see set_code_viewer_lines_radix() - -ida_kernwin.CDVH_SRCVIEW (variable) - see set_code_viewer_is_source() - -ida_kernwin.CDVH_USERDATA (variable) - see set_code_viewer_user_data() - -ida_kernwin.CH2_LAZY_LOADED (variable) - The chooser is lazy-loaded; it receives the callback do_lazy_load_dir() (only - meaningful when CH_HAS_DIRTREE is set) - -ida_kernwin.CHCOL_DEC (variable) - decimal number - -ida_kernwin.CHCOL_DEFHIDDEN (variable) - column should be hidden by default - -ida_kernwin.CHCOL_DRAGHINT (variable) - the column number that will be used to build hints for the dragging undo label. - This should be provided for at most one column for any given chooser. - -ida_kernwin.CHCOL_EA (variable) - address - -ida_kernwin.CHCOL_FNAME (variable) - function name. If a chooser column has this flag set and implements - chooser_base_t::get_ea(), rows background colors will be automatically set to - match the navigator's "Library function", "Lumina function" and "External - symbol" colors - -ida_kernwin.CHCOL_FORMAT (variable) - column format mask - -ida_kernwin.CHCOL_HEX (variable) - hexadecimal number - -ida_kernwin.CHCOL_INODENAME (variable) - if CH_HAS_DIRTREE has been specified, this instructs the chooser that this - column shows the inode name. This should be provided for at most one column for - any given chooser. - -ida_kernwin.CHCOL_PATH (variable) - file path. TUI IDA will truncate excessive cell lengths starting at their - beginning, and prepending the resulting text with "..." order to leave the - filename visible - -ida_kernwin.CHCOL_PLAIN (variable) - plain string - -ida_kernwin.CHITEM_BOLD (variable) - display the item in bold - -ida_kernwin.CHITEM_GRAY (variable) - gray out the item - -ida_kernwin.CHITEM_ITALIC (variable) - display the item in italic - -ida_kernwin.CHITEM_STRIKE (variable) - strikeout the item - -ida_kernwin.CHITEM_UNDER (variable) - underline the item - -ida_kernwin.CHOOSER_NOMAINMENU (variable) - do not display main menu - -ida_kernwin.CHOOSER_NOSTATUSBAR (variable) - do not display status bar (obsolete. Use CH_NO_STATUS_BAR instead) - -ida_kernwin.CH_ATTRS (variable) - generate ui_get_chooser_item_attrs (gui only) - -ida_kernwin.CH_BUILTIN_MASK (variable) - Mask for builtin chooser numbers. Plugins should not use them. - -ida_kernwin.CH_CAN_DEL (variable) - allow to delete existing item(s) - -ida_kernwin.CH_CAN_EDIT (variable) - allow to edit existing item(s) - -ida_kernwin.CH_CAN_INS (variable) - allow to insert new items - -ida_kernwin.CH_CAN_REFRESH (variable) - allow to refresh chooser - -ida_kernwin.CH_FORCE_DEFAULT (variable) - if a non-modal chooser was already open, change selection to the default one - -ida_kernwin.CH_HAS_DIFF (variable) - The chooser can be used in a diffing/merging workflow. - -ida_kernwin.CH_HAS_DIRTREE (variable) - The chooser can provide a dirtree_t, meaning a tree-like structure can be - provided to the user (instead of a flat table) - -ida_kernwin.CH_KEEP (variable) - The chooser instance's lifecycle is not tied to the lifecycle of the widget - showing its contents. Closing the widget will not destroy the chooser structure. - This allows for, e.g., static global chooser instances that don't need to be - allocated on the heap. Also stack-allocated chooser instances must set this bit. - -ida_kernwin.CH_MODAL (variable) - Modal chooser. - -ida_kernwin.CH_MULTI (variable) - The chooser will allow multi-selection (only for GUI choosers). This bit is set - when using the chooser_multi_t structure. - -ida_kernwin.CH_MULTI_EDIT (variable) - Obsolete. - -ida_kernwin.CH_NOBTNS (variable) - do not display ok/cancel/help/search buttons. Meaningful only for gui modal - windows because non-modal windows do not have any buttons anyway. Text mode does - not have them neither. - -ida_kernwin.CH_NON_PERSISTED_TREE (variable) - the chooser tree is not persisted (it is not loaded on startup and is not saved - on exit) - -ida_kernwin.CH_NO_FILTER (variable) - The chooser will not have filtering abilities. - -ida_kernwin.CH_NO_SORT (variable) - The chooser will not have sorting abilities. - -ida_kernwin.CH_NO_STATUS_BAR (variable) - don't show a status bar - -ida_kernwin.CH_QFLT (variable) - open with quick filter enabled and focused - -ida_kernwin.CH_QFTYP_DEFAULT (variable) - set quick filtering type to the possible existing default for this chooser - -ida_kernwin.CH_QFTYP_FUZZY (variable) - fuzzy search quick filter type - -ida_kernwin.CH_QFTYP_NORMAL (variable) - normal (i.e., lexicographical) quick filter type - -ida_kernwin.CH_QFTYP_REGEX (variable) - regex quick filter type - -ida_kernwin.CH_QFTYP_WHOLE_WORDS (variable) - whole words quick filter type - -ida_kernwin.CH_RENAME_IS_EDIT (variable) - triggering a 'edit/rename' (i.e., F2 shortcut) on a cell, should call the edit() - callback for the corresponding row. - -ida_kernwin.CH_RESTORE (variable) - restore floating position if present (equivalent of WOPN_RESTORE) (GUI version - only) - -ida_kernwin.CH_TM_FOLDERS_ONLY (variable) - chooser will show in folders-only mode - -ida_kernwin.CH_TM_FULL_TREE (variable) - chooser will show in no-tree mode - -ida_kernwin.CH_TM_NO_TREE (variable) - chooser will show up in no-tree mode - -ida_kernwin.CK_EXTRA1 (variable) - extra background overlay #1 - -ida_kernwin.CK_EXTRA10 (variable) - extra background overlay #10 - -ida_kernwin.CK_EXTRA11 (variable) - extra background overlay #11 - -ida_kernwin.CK_EXTRA12 (variable) - extra background overlay #12 - -ida_kernwin.CK_EXTRA13 (variable) - extra background overlay #13 - -ida_kernwin.CK_EXTRA14 (variable) - extra background overlay #14 - -ida_kernwin.CK_EXTRA15 (variable) - extra background overlay #15 - -ida_kernwin.CK_EXTRA16 (variable) - extra background overlay #16 - -ida_kernwin.CK_EXTRA2 (variable) - extra background overlay #2 - -ida_kernwin.CK_EXTRA3 (variable) - extra background overlay #3 - -ida_kernwin.CK_EXTRA4 (variable) - extra background overlay #4 - -ida_kernwin.CK_EXTRA5 (variable) - extra background overlay #5 - -ida_kernwin.CK_EXTRA6 (variable) - extra background overlay #6 - -ida_kernwin.CK_EXTRA7 (variable) - extra background overlay #7 - -ida_kernwin.CK_EXTRA8 (variable) - extra background overlay #8 - -ida_kernwin.CK_EXTRA9 (variable) - extra background overlay #9 - -ida_kernwin.CK_TRACE (variable) - traced address - -ida_kernwin.CK_TRACE_OVL (variable) - overlay trace address - -ida_kernwin.CLNL_FINDCMT (variable) - Search for the comment symbol everywhere in the line, not only at the beginning. - -ida_kernwin.CLNL_LTRIM (variable) - Remove leading space characters. - -ida_kernwin.CLNL_RTRIM (variable) - Remove trailing space characters. - -ida_kernwin.CREATETB_ADV (variable) - toolbar is for 'advanced mode' only - -ida_kernwin.CVH_CLICK (variable) - see custom_viewer_click_t - -ida_kernwin.CVH_CLOSE (variable) - see custom_viewer_close_t - -ida_kernwin.CVH_CURPOS (variable) - see custom_viewer_curpos_t - -ida_kernwin.CVH_DBLCLICK (variable) - see custom_viewer_dblclick_t - -ida_kernwin.CVH_HELP (variable) - see custom_viewer_help_t - -ida_kernwin.CVH_KEYDOWN (variable) - see custom_viewer_keydown_t - -ida_kernwin.CVH_MOUSEMOVE (variable) - see custom_viewer_mouse_moved_t - -ida_kernwin.CVH_POPUP (variable) - see custom_viewer_popup_t - -ida_kernwin.CVH_QT_AWARE (variable) - see set_custom_viewer_qt_aware() - -ida_kernwin.CVLF_USE_MOUSE (variable) - Fetch the location from the mouse, instead of caret in the listing. - -ida_kernwin.CVNF_ACT (variable) - activate (i.e., switch to) the viewer. Activation is performed before the new - lochist_entry_t instance is actually copied to the viewer's lochist_t - (otherwise, if the viewer was invisible its on_location_changed() handler - wouldn't be called.) - -ida_kernwin.CVNF_JUMP (variable) - push the current position in this viewer's lochist_t before going to the new - location - -ida_kernwin.CVNF_LAZY (variable) - try and move the cursor to a line displaying the place_t if possible. This might - disregard the Y position in case of success - -ida_kernwin.Choose (class) - The chooser can be used in a diffing/merging workflow - -ida_kernwin.Choose.ALREADY_EXISTS (variable) - the non-modal chooser with the same data is already open - -ida_kernwin.Choose.Activate (method) - Activates a visible chooser - -ida_kernwin.Choose.AddCommand (method) - -ida_kernwin.Choose.CH_CAN_DEL (variable) - allow to delete existing item(s) - -ida_kernwin.Choose.CH_CAN_EDIT (variable) - allow to edit existing item(s) - -ida_kernwin.Choose.CH_CAN_INS (variable) - allow to insert new items - -ida_kernwin.Choose.CH_CAN_REFRESH (variable) - allow to refresh chooser - -ida_kernwin.Choose.CH_FORCE_DEFAULT (variable) - If a non-modal chooser was already open, change selection to the given - default one - -ida_kernwin.Choose.CH_MODAL (variable) - Modal chooser - -ida_kernwin.Choose.CH_MULTI (variable) - Allow multi selection. - Refer the description of the OnInsertLine(), OnDeleteLine(), - OnEditLine(), OnSelectLine(), OnRefresh(), OnSelectionChange() to - see a difference between single and multi selection callbacks. - -ida_kernwin.Choose.CH_NOIDB (variable) - use the chooser even without an open database, same as x0=-2 - -ida_kernwin.Choose.CH_NO_STATUS_BAR (variable) - don't show a status bar - -ida_kernwin.Choose.CH_QFLT (variable) - open with quick filter enabled and focused - -ida_kernwin.Choose.CH_RENAME_IS_EDIT (variable) - triggering a 'edit/rename' (i.e., F2 shortcut) on a cell, - should call the edit() callback for the corresponding row. - -ida_kernwin.Choose.CH_RESTORE (variable) - restore floating position if present (equivalent of WOPN_RESTORE) (GUI version only) - -ida_kernwin.Choose.Close (method) - Closes the chooser - -ida_kernwin.Choose.EMPTY_CHOOSER (variable) - the chooser is initialized - -ida_kernwin.Choose.Embedded (method) - Creates an embedded chooser (as opposed to Show()) - @return: Returns 0 on success or NO_ATTR - -ida_kernwin.Choose.GetEmbSelection (method) - Deprecated. For embedded choosers, the selection is - available through 'Form.EmbeddedChooserControl.selection' - -ida_kernwin.Choose.GetWidget (method) - Return the TWidget underlying this view. - - @return: The TWidget underlying this view, or None. - -ida_kernwin.Choose.NO_ATTR (variable) - some mandatory attribute is missing - -ida_kernwin.Choose.NO_SELECTION (variable) - there is no selected item - -ida_kernwin.Choose.OnClose (method) - The chooser window is closed. - -ida_kernwin.Choose.OnDeleteLine (method) - User deleted an element - - @param sel: the current selection - @return: a tuple (changed, selection) - -ida_kernwin.Choose.OnEditLine (method) - User asked to edit an element. - - @param sel: the current selection - @return: a tuple (changed, selection) - -ida_kernwin.Choose.OnGetDirTree (method) - Get the dirtree_t that will be used to present a tree-like - structure to the user (see CH_HAS_DIRTREE) - - @return: the dirtree_t, or None - -ida_kernwin.Choose.OnGetEA (method) - Get the address of an element - - When this function returns valid addresses: - * If any column has the `CHCOL_FNAME` flag, rows will - be colored according to the attributes of the functions - who own those addresses (extern, library function, - Lumina, ... - similar to what the "Functions" widget does) - * When a selection is present and the user presses `<Enter>` - (`<Shift+Enter>` if the chooser is modal), IDA will jump - to that address (through jumpto()) - @param n: element number (0-based) - @return: the effective address, ida_idaapi.BADADDR if the element has no address - -ida_kernwin.Choose.OnGetIcon (method) - Get an icon to associate with the first cell of an element - - @param n: index of the element - @return: an icon ID - -ida_kernwin.Choose.OnGetLine (method) - Get data for an element - - This callback is mandatory - - @param n: the index to fetch data for - @return: a list of strings - -ida_kernwin.Choose.OnGetLineAttr (method) - Get attributes for an element - - @param n: index of the element - @return: a tuple (color, flags) - -ida_kernwin.Choose.OnGetSize (method) - Get the number of elements in the chooser. - - This callback is mandatory - - @return: the number of elements - -ida_kernwin.Choose.OnIndexToDiffpos (method) - Map an element index to a diffpos_t - - This callback is mandatory if CH_HAS_DIFF is specified - - @param n: index of the element - @return: the diffpos - -ida_kernwin.Choose.OnIndexToInode (method) - Map an element index to a dirtree_t inode - - This callback is mandatory if CH_HAS_DIRTREE is specified - - @param n: index of the element - @return: the inode number - -ida_kernwin.Choose.OnInit (method) - Initialize the chooser and populate it. - - This callback is optional - -ida_kernwin.Choose.OnInsertLine (method) - User asked to insert an element - - @param sel: the current selection - @return: a tuple (changed, selection) - -ida_kernwin.Choose.OnLazyLoadDir (method) - Callback for lazy-loaded, dirtree-based choosers; - the function will be called when a folder is expanded and it has - not been loaded before. The implementation should use the - given dirtree's link() or mkdir() methods to add the folder contents. - - @param path: an absolute dirtree path to the directory that is being expanded - @return: success - -ida_kernwin.Choose.OnPopup (method) - -ida_kernwin.Choose.OnRefresh (method) - The chooser needs to be refreshed. - It returns the new positions of the selected items. - - @param sel: the current selection - @return: a tuple (changed, selection) - -ida_kernwin.Choose.OnSelectLine (method) - User pressed the enter key, or double-clicked a selection - - @param sel: the current selection - @return: a tuple (changed, selection) - -ida_kernwin.Choose.OnSelectionChange (method) - Selection changed - - @param sel: the new selection - -ida_kernwin.Choose.Refresh (method) - Causes the refresh callback to trigger - -ida_kernwin.Choose.Show (method) - Activates or creates a chooser window - @param modal: Display as modal dialog - @return: For all choosers it will return NO_ATTR if some mandatory - attribute is missing. The mandatory attributes are: flags, - title, cols, OnGetSize(), OnGetLine(); - For modal choosers it will return the selected item index (0-based), - or NO_SELECTION if no selection, - or EMPTY_CHOOSER if the OnRefresh() callback returns EMPTY_CHOOSER; - For non-modal choosers it will return 0 - or ALREADY_EXISTS if the chooser was already open and is active now; - -ida_kernwin.Choose.UI_Hooks_Trampoline (class) - -ida_kernwin.Choose.UI_Hooks_Trampoline.__init__ (method) - -ida_kernwin.Choose.UI_Hooks_Trampoline.populating_widget_popup (method) - -ida_kernwin.Choose.__init__ (method) - Constructs a chooser window. - @param title: The chooser title - @param cols: a list of colums; each list item is a list of two items - example: [ ["Address", 10 | Choose.CHCOL_HEX], - ["Name", 30 | Choose.CHCOL_PLAIN] ] - @param flags: One of CH_XXXX constants - @param flags2: One of CH2_XXXX constants - @param deflt: The index of the default item (0-based) for single - selection choosers or the list of indexes for multi selection - chooser - @param popup_names: List of new captions to replace this list - ["Insert", "Delete", "Edit", "Refresh"] - @param icon: Icon index (the icon should exist in ida resources or - an index to a custom loaded icon) - @param x1: , y1, x2, y2: The default location (for txt-version) - @param embedded: Create as embedded chooser - @param width: Embedded chooser width - @param height: Embedded chooser height - @param forbidden_cb: Explicitly forbidden callbacks - -ida_kernwin.Choose.__init__._qccb (function) - -ida_kernwin.Choose.adjust_last_item (method) - Helper for OnDeleteLine() and OnRefresh() callbacks. - They can be finished by the following line: - return [Choose.ALL_CHANGED] + self.adjust_last_item(n) - @param line: number of the remaining select item - @return: list of selected lines numbers (one element or empty) - -ida_kernwin.CustomIDAMemo (class) - -ida_kernwin.CustomIDAMemo.CreateGroups (method) - Send a request to modify the graph by creating a - (set of) group(s), and perform an animation. - - Each object in the 'groups_infos' list must be of the format: - { - "nodes" : [<int>, <int>, <int>, ...] # The list of nodes to group - "text" : <string> # The synthetic text for that group - } - - @param groups_infos: A list of objects that describe those groups. - @return: A [<int>, <int>, ...] list of group nodes, or None (failure). - -ida_kernwin.CustomIDAMemo.DelNodesInfos (method) - Delete the properties for the given node(s). - - @param nodes: A list of node IDs - -ida_kernwin.CustomIDAMemo.DeleteGroups (method) - Send a request to delete the specified groups in the graph, - and perform an animation. - - @param groups: A list of group node numbers. - @param new_current: A node to focus on after the groups have been deleted - @return: True on success, False otherwise. - -ida_kernwin.CustomIDAMemo.GetCurrentRendererType (method) - -ida_kernwin.CustomIDAMemo.GetNodeInfo (method) - Get the properties for the given node. - - @param ni: A node_info_t instance - @param node: The index of the node. - @return: success - -ida_kernwin.CustomIDAMemo.GetWidget (method) - Return the TWidget underlying this view. - - @return: The TWidget underlying this view, or None. - -ida_kernwin.CustomIDAMemo.GetWidgetAsGraphViewer (method) - Return the graph_viewer_t underlying this view. - - @return: The graph_viewer_t underlying this view, or None. - -ida_kernwin.CustomIDAMemo.Refresh (method) - Refreshes the view. This causes the OnRefresh() to be called - -ida_kernwin.CustomIDAMemo.SetCurrentRendererType (method) - Set the current view's renderer. - - @param rtype: The renderer type. Should be one of the idaapi.TCCRT_* values. - -ida_kernwin.CustomIDAMemo.SetGroupsVisibility (method) - Send a request to expand/collapse the specified groups in the graph, - and perform an animation. - - @param groups: A list of group node numbers. - @param expand: True to expand the group, False otherwise. - @param new_current: A node to focus on after the groups have been expanded/collapsed. - @return: True on success, False otherwise. - -ida_kernwin.CustomIDAMemo.SetNodeInfo (method) - Set the properties for the given node. - - Example usage (set second nodes's bg color to red): - inst = ... - p = idaapi.node_info_t() - p.bg_color = 0x00ff0000 - inst.SetNodeInfo(1, p, idaapi.NIF_BG_COLOR) - - @param node_index: The node index. - @param node_info: An idaapi.node_info_t instance. - @param flags: An OR'ed value of NIF_* values. - -ida_kernwin.CustomIDAMemo.SetNodesInfos (method) - Set the properties for the given nodes. - - Example usage (set first three nodes's bg color to purple): - inst = ... - p = idaapi.node_info_t() - p.bg_color = 0x00ff00ff - inst.SetNodesInfos({0 : p, 1 : p, 2 : p}) - - @param values: A dictionary of 'int -> node_info_t' objects. - -ida_kernwin.CustomIDAMemo._OnBind (method) - -ida_kernwin.CustomIDAMemo.__init__ (method) - -ida_kernwin.CustomIDAMemo._dummy_cb (method) - -ida_kernwin.CustomIDAMemo._get_cb (method) - -ida_kernwin.CustomIDAMemo._get_cb_arity (method) - -ida_kernwin.CustomIDAMemo._graph_item_tuple (method) - -ida_kernwin.CustomIDAMemo.view_activated (method) - -ida_kernwin.CustomIDAMemo.view_click (method) - -ida_kernwin.CustomIDAMemo.view_close (method) - -ida_kernwin.CustomIDAMemo.view_curpos (method) - -ida_kernwin.CustomIDAMemo.view_dblclick (method) - -ida_kernwin.CustomIDAMemo.view_deactivated (method) - -ida_kernwin.CustomIDAMemo.view_keydown (method) - -ida_kernwin.CustomIDAMemo.view_loc_changed (method) - -ida_kernwin.CustomIDAMemo.view_mouse_moved (method) - -ida_kernwin.CustomIDAMemo.view_mouse_over (method) - -ida_kernwin.CustomIDAMemo.view_switched (method) - -ida_kernwin.DP_BEFORE (variable) - Place src_form before dst_form in the tab bar instead of after; used with - DP_INSIDE or DP_TAB. - -ida_kernwin.DP_BOTTOM (variable) - Dock src_form below dest_form. - -ida_kernwin.DP_FLOATING (variable) - Make src_form floating. - -ida_kernwin.DP_INSIDE (variable) - Create a new tab bar with both src_form and dest_form. - -ida_kernwin.DP_LEFT (variable) - Dock src_form to the left of dest_form. - -ida_kernwin.DP_RIGHT (variable) - Dock src_form to the right of dest_form. - -ida_kernwin.DP_SZHINT (variable) - When floating or in a splitter (i.e., not tabbed), use the widget's size hint to - determine the best geometry (Qt only) - -ida_kernwin.DP_TAB (variable) - Place src_form into a tab next to dest_form, if dest_form is in a tab bar - (otherwise the same as DP_INSIDE) - -ida_kernwin.DP_TOP (variable) - Dock src_form above dest_form. - -ida_kernwin.Form (class) - -ida_kernwin.Form.Add (method) - Low level function. Prefer AddControls() to this function. - This function adds one control to the form. - - @param name: Control name - @param ctrl: Control object - @param mkattr: Create control name / control object as a form attribute - -ida_kernwin.Form.AddControls (method) - Adds controls from a dictionary. - The dictionary key is the control name and the value is a Form.Control object - @param controls: The control dictionary - -ida_kernwin.Form.ButtonInput (class) - Button control. - A handler along with a 'code' (numeric value) can be associated with the button. - This way one handler can handle many buttons based on the button code (or in other terms id or tag) - -ida_kernwin.Form.ButtonInput.__init__ (method) - @param handler: Button handler. A callback taking one argument which is the code. - @param code: A code associated with the button and that is later passed to the handler. - -ida_kernwin.Form.ButtonInput.helper_cb (method) - -ida_kernwin.Form.ButtonInput.is_input_field (method) - -ida_kernwin.Form.ChkGroupControl (class) - Checkbox group control class. - It holds a set of checkbox controls - -ida_kernwin.Form.ChkGroupControl.ItemClass (variable) - Group control item factory class instance - We need this because later we won't be treating ChkGroupControl or RadGroupControl - individually, instead we will be working with GroupControl in general. - -ida_kernwin.Form.ChkGroupControl.__init__ (method) - -ida_kernwin.Form.ChkGroupItemControl (class) - Checkbox group item control - -ida_kernwin.Form.ChkGroupItemControl.__get_value (method) - -ida_kernwin.Form.ChkGroupItemControl.__init__ (method) - -ida_kernwin.Form.ChkGroupItemControl.__set_value (method) - -ida_kernwin.Form.ChkGroupItemControl.checked (variable) - Get/Sets checkbox item check status - -ida_kernwin.Form.Close (method) - Close the form - @param close_normally - 1: form is closed normally as if the user pressed Enter - 0: form is closed abnormally as if the user pressed Esc - @return: None - -ida_kernwin.Form.ColorInput (class) - Color button input control - -ida_kernwin.Form.ColorInput.__init__ (method) - @param value: Initial color value in RGB - -ida_kernwin.Form.Compile (method) - Compiles a form and returns the form object (self) and the argument list. - The form object will contain object names corresponding to the form elements - - @return: It will raise an exception on failure. Otherwise the return value is ignored - -ida_kernwin.Form.CompileEx (method) - Low level function. - Compiles (parses the form syntax and adds the control) the form string and - returns the argument list to be passed the argument list to ask_form(). - - The form controls are wrapped inside curly braces: {ControlName}. - - A special operator can be used to return the index of a given control by its name: {id:ControlName}. - This is useful when you use the STARTITEM form keyword to set the initially focused control. - (note that, technically, the index is not the same as the ID; that's because STARTITEM - uses raw, 0-based indexes rather than control IDs to determine the focused widget.) - - @param form: Compiles the form and returns the arguments needed to be passed to ask_form() - -ida_kernwin.Form.CompileEx.next_control (function) - -ida_kernwin.Form.Compiled (method) - Checks if the form has already been compiled - - @return: Boolean - -ida_kernwin.Form.Control (class) - -ida_kernwin.Form.Control.__init__ (method) - Reference to the parent form. It is filled by Form.Add() - -ida_kernwin.Form.Control.free (method) - Free the control - -ida_kernwin.Form.Control.get_arg (method) - Control returns the parameter to be pushed on the stack - (Of ask_form()) - -ida_kernwin.Form.Control.get_tag (method) - Control tag character. One of Form.FT_XXXX. - The form class will expand the {} notation and replace them with the tags - -ida_kernwin.Form.Control.is_input_field (method) - Return True if this field acts as an input - -ida_kernwin.Form.ControlToFieldTypeIdAndSize (method) - Converts a control object to a tuple containing the field id - and the associated buffer size - -ida_kernwin.Form.DirInput (class) - Directory browsing control - -ida_kernwin.Form.DirInput.__init__ (method) - -ida_kernwin.Form.DropdownListControl (class) - Dropdown control - This control allows manipulating a dropdown control - -ida_kernwin.Form.DropdownListControl.__get_selval (method) - -ida_kernwin.Form.DropdownListControl.__init__ (method) - @param items: A string list of items used to prepopulate the control - @param readonly: Specifies whether the dropdown list is editable or not - @param selval: The preselected item index (when readonly) or text value (when editable) - @param width: the control width (n/a if the dropdown list is readonly) - @param swidth: string width - -ida_kernwin.Form.DropdownListControl.__set_selval (method) - -ida_kernwin.Form.DropdownListControl.free (method) - -ida_kernwin.Form.DropdownListControl.selval (variable) - Read/write the selection value. - The value is used as an item index in readonly mode or text value in editable mode - This value can be used only after the form has been closed. - -ida_kernwin.Form.DropdownListControl.set_items (method) - Sets the dropdown list items - -ida_kernwin.Form.EmbeddedChooserControl (class) - Embedded chooser control. - This control links to a Chooser2 control created with the 'embedded=True' - -ida_kernwin.Form.EmbeddedChooserControl.__get_selection__ (method) - -ida_kernwin.Form.EmbeddedChooserControl.__init__ (method) - Embedded chooser control - - @param chooser: A chooser2 instance (must be constructed with 'embedded=True') - -ida_kernwin.Form.EmbeddedChooserControl.free (method) - Frees the embedded chooser data - -ida_kernwin.Form.EmbeddedChooserControl.selection (variable) - Returns the selection - -ida_kernwin.Form.EmbeddedChooserControl.value (variable) - Returns the embedded chooser instance - -ida_kernwin.Form.EnableField (method) - Enable or disable an input field - @return: False - no such control - -ida_kernwin.Form.Execute (method) - Displays a modal dialog containing the compiled form. - @return: 1 - ok ; 0 - cancel - -ida_kernwin.Form.FT_ADDR (variable) - Address - ea_t * - -ida_kernwin.Form.FT_ASCII (variable) - Ascii string - char * - -ida_kernwin.Form.FT_BIN (variable) - Binary number, 0b prefix - sval_t * - -ida_kernwin.Form.FT_BUTTON (variable) - Button - def handler(code) - -ida_kernwin.Form.FT_CHAR (variable) - Char value -- sval_t * - -ida_kernwin.Form.FT_COLOR (variable) - Color button - bgcolor_t * - -ida_kernwin.Form.FT_DEC (variable) - Decimal number - sval_t * - -ida_kernwin.Form.FT_DIR (variable) - Path to directory - char * at least QMAXPATH - -ida_kernwin.Form.FT_DROPDOWN_LIST (variable) - Dropdown list control - Form.DropdownControl - -ida_kernwin.Form.FT_ECHOOSER (variable) - Embedded chooser - idaapi.Choose - -ida_kernwin.Form.FT_FILE (variable) - File browse - char * at least QMAXPATH - -ida_kernwin.Form.FT_FORMCHG (variable) - Form change callback - formchgcb_t - -ida_kernwin.Form.FT_HEX (variable) - Hex number - uval_t * - -ida_kernwin.Form.FT_HTML_LABEL (variable) - HTML label to display (only for GUI version, and for dynamic labels; no input) - -ida_kernwin.Form.FT_IDENT (variable) - Identifier - char * at least MAXNAMELEN - -ida_kernwin.Form.FT_INT64 (variable) - default base int64 - int64 - -ida_kernwin.Form.FT_MULTI_LINE_TEXT (variable) - Multi text control - textctrl_info_t - -ida_kernwin.Form.FT_OCT (variable) - Octal number, C notation - sval_t * - -ida_kernwin.Form.FT_RAWHEX (variable) - Hex number, no 0x prefix - uval_t * - -ida_kernwin.Form.FT_SEG (variable) - Segment - sel_t * - -ida_kernwin.Form.FT_SHEX (variable) - Signed hex number - sval_t * - -ida_kernwin.Form.FT_TYPE (variable) - Type declaration - char * at least MAXSTR - -ida_kernwin.Form.FT_UINT64 (variable) - default base uint64 - uint64 - -ida_kernwin.Form.FileInput (class) - File Open/Save input control - -ida_kernwin.Form.FileInput.__init__ (method) - -ida_kernwin.Form.FindControlById (method) - Finds a control instance given its id - -ida_kernwin.Form.FormChangeCb (class) - Form change handler. - This can be thought of like a dialog procedure. - Everytime a form action occurs, this handler will be called along with the control id. - The programmer can then call various form actions accordingly: - - EnableField - - ShowField - - MoveField - - GetFieldValue - - etc... - - Special control IDs: -1 (The form is initialized) and -2 (Ok has been clicked) - -ida_kernwin.Form.FormChangeCb.__init__ (method) - Constructs the handler. - @param handler: The handler (preferrably a member function of a class derived from the Form class). - -ida_kernwin.Form.FormChangeCb.free (method) - -ida_kernwin.Form.FormChangeCb.get_tag (method) - -ida_kernwin.Form.FormChangeCb.helper_cb (method) - -ida_kernwin.Form.Free (method) - Frees all resources associated with a compiled form. - Make sure you call this function when you finish using the form. - -ida_kernwin.Form.GetControlValue (method) - Returns the control's value depending on its type - @param ctrl: Form control instance - @return: - color button, radio controls: integer - - file/dir input, string input and string label: string - - embedded chooser control (0-based indices of selected items): integer list - - for multilinetext control: textctrl_info_t - - dropdown list controls: string (when editable) or index (when readonly) - - None: on failure - -ida_kernwin.Form.GetFocusedField (method) - Get currently focused input field. - @return: None if no field is selected otherwise the control ID - -ida_kernwin.Form.GroupControl (class) - Base class for group controls - -ida_kernwin.Form.GroupControl.__init__ (method) - -ida_kernwin.Form.GroupControl._reset (method) - -ida_kernwin.Form.GroupControl.get_tag (method) - -ida_kernwin.Form.GroupControl.next_child_pos (method) - -ida_kernwin.Form.GroupItemControl (class) - Base class for group control items - -ida_kernwin.Form.GroupItemControl.__init__ (method) - -ida_kernwin.Form.GroupItemControl.assign_pos (method) - -ida_kernwin.Form.GroupItemControl.get_tag (method) - -ida_kernwin.Form.GroupItemControl.is_input_field (method) - -ida_kernwin.Form.InputControl (class) - Generic form input control. - It could be numeric control, string control, directory/file browsing, etc... - -ida_kernwin.Form.InputControl.__init__ (method) - @param width: The maximum possible number of characters that - can be entered into the input field - @param swidth: The width of visible part of the input field - -ida_kernwin.Form.InputControl.get_tag (method) - -ida_kernwin.Form.InputControl.is_input_field (method) - -ida_kernwin.Form.LabelControl (class) - Base class for static label control - -ida_kernwin.Form.LabelControl.__init__ (method) - -ida_kernwin.Form.LabelControl.get_tag (method) - -ida_kernwin.Form.MoveField (method) - Move/resize an input field - - @return: False - no such fiel - -ida_kernwin.Form.MultiLineTextControl (class) - Multi line text control. - This class inherits from textctrl_info_t. Thus the attributes are also inherited - This control allows manipulating a multilinetext control - -ida_kernwin.Form.MultiLineTextControl.__init__ (method) - @param text: Initial text value - @param flags: One of textctrl_info_t.TXTF_.... values - @param tabsize: Tab size - @param width: Display width - @param swidth: String width - -ida_kernwin.Form.MultiLineTextControl.free (method) - -ida_kernwin.Form.NumericArgument (class) - Argument representing various integer arguments (ushort, uint32, uint64, etc...) - @param tp: One of Form.FT_XXX - -ida_kernwin.Form.NumericArgument.__init__ (method) - -ida_kernwin.Form.NumericArgument.__set_value (method) - -ida_kernwin.Form.NumericInput (class) - A composite class serving as a base numeric input control class - -ida_kernwin.Form.NumericInput.__init__ (method) - -ida_kernwin.Form.NumericLabel (class) - Numeric label control - -ida_kernwin.Form.NumericLabel.__init__ (method) - -ida_kernwin.Form.Open (method) - Opens a widget containing the compiled form. - -ida_kernwin.Form.RadGroupControl (class) - Radiobox group control class. - It holds a set of radiobox controls - -ida_kernwin.Form.RadGroupControl.__init__ (method) - Creates a radiogroup control. - @param children_names: A tuple containing group item names - @param value: Initial selected radio item - @param secondory: Allows rendering one the same line as the previous group control. - Use this if you have another group control on the same line. - -ida_kernwin.Form.RadGroupItemControl (class) - Radiobox group item control - -ida_kernwin.Form.RadGroupItemControl.__get_value (method) - -ida_kernwin.Form.RadGroupItemControl.__init__ (method) - -ida_kernwin.Form.RadGroupItemControl.__set_value (method) - -ida_kernwin.Form.RadGroupItemControl.selected (variable) - Get/Sets radiobox item selection status - -ida_kernwin.Form.RefreshField (method) - Refresh a field - @return: False - no such control - -ida_kernwin.Form.SetControlValue (method) - Set the control's value depending on its type - @param ctrl: Form control instance - @param value - - embedded chooser: a 0-base indices list to select embedded chooser items - - multilinetext: a textctrl_info_t - - dropdown list: an integer designating the selection index if readonly - a string designating the edit control value if not readonly - @return: Boolean true on success - -ida_kernwin.Form.SetFocusedField (method) - Set currently focused input field - @return: False - no such control - -ida_kernwin.Form.ShowField (method) - Show or hide an input field - @return: False - no such control - -ida_kernwin.Form.StringArgument (class) - Argument representing a character buffer - -ida_kernwin.Form.StringArgument.__get_value (method) - -ida_kernwin.Form.StringArgument.__init__ (method) - -ida_kernwin.Form.StringArgument.__set_value (method) - -ida_kernwin.Form.StringInput (class) - Base string input control class. - This class also constructs a StringArgument - -ida_kernwin.Form.StringInput.__init__ (method) - @param width: String size. But in some cases it has special meaning. For example in FileInput control. - If you want to define the string buffer size then pass the 'size' argument - @param swidth: Control width - @param value: Initial value - @param size: String size - -ida_kernwin.Form.StringLabel (class) - String label control - -ida_kernwin.Form.StringLabel.__init__ (method) - Type field can be one of: - A - ascii string - T - type declaration - I - ident - F - folder - f - file - X - command - -ida_kernwin.Form._AddGroup (method) - Internal function. - This function expands the group item names and creates individual group item controls - - @param Group: The group class (checkbox or radio group class) - -ida_kernwin.Form._ChkCompiled (method) - -ida_kernwin.Form._FT_USHORT (variable) - Unsigned short - -ida_kernwin.Form._ParseFormTitle (method) - Parses the form's title from the form text - -ida_kernwin.Form.__getitem__ (method) - Returns a control object by name - -ida_kernwin.Form.__init__ (method) - If non-modal, these flags will be passed to open_form. - This is an OR'ed combination of the PluginForm.FORM_* values. - -ida_kernwin.Form._reset (method) - Resets the Form class state variables - -ida_kernwin.Form.create_string_buffer (method) - -ida_kernwin.Form.fieldtype_to_ctype (method) - Factory method returning a ctype class corresponding to the field type string - -ida_kernwin.GCRF_ALL (variable) - Return all rows. - -ida_kernwin.GCRF_CURRENT (variable) - Return the current row. - -ida_kernwin.GCRF_HEADER (variable) - Return header texts. - -ida_kernwin.GCRF_SELECTION (variable) - Return selected rows. - -ida_kernwin.HIF_IDENTIFIER (variable) - text is an identifier (i.e., when searching for the current highlight, - SEARCH_IDENT will be used) - -ida_kernwin.HIF_LOCKED (variable) - locked; clicking/moving the cursor around doesn't change the highlight - -ida_kernwin.HIF_NOCASE (variable) - case insensitive - -ida_kernwin.HIF_REGISTER (variable) - text represents a register (aliases/subregisters will be highlit as well) - -ida_kernwin.HIF_SLOT_0 (variable) - operate on slot 0 - -ida_kernwin.HIF_SLOT_1 (variable) - operate on slot 1 - -ida_kernwin.HIF_SLOT_2 (variable) - operate on slot 2 - -ida_kernwin.HIF_SLOT_3 (variable) - operate on slot 3 - -ida_kernwin.HIF_SLOT_4 (variable) - operate on slot 4 - -ida_kernwin.HIF_SLOT_5 (variable) - operate on slot 5 - -ida_kernwin.HIF_SLOT_6 (variable) - operate on slot 6 - -ida_kernwin.HIF_SLOT_7 (variable) - operate on slot 7 - -ida_kernwin.HIF_SLOT_SHIFT (variable) - position of the 3 top bits specifying which highlight to use - -ida_kernwin.HIF_USE_SLOT (variable) - use the given number, or just use the "floating" highlight - -ida_kernwin.HIST_CMD (variable) - commands - -ida_kernwin.HIST_CMT (variable) - comments - -ida_kernwin.HIST_DIR (variable) - directory names (text version only) - -ida_kernwin.HIST_FILE (variable) - file names - -ida_kernwin.HIST_IDENT (variable) - identifiers. usually CPU register names are forbidden - -ida_kernwin.HIST_IDENT2 (variable) - identifiers, including CPU register names - -ida_kernwin.HIST_SEG (variable) - segment names - -ida_kernwin.HIST_SRCH (variable) - search substrings - -ida_kernwin.HIST_TYPE (variable) - type declarations - -ida_kernwin.IDAViewWrapper (class) - Deprecated. Use View_Hooks instead. - - Because the lifecycle of an IDAView is not trivial to track (e.g., a user - might close, then re-open the same disassembly view), this wrapper doesn't - bring anything superior to the View_Hooks: quite the contrary, as the - latter is much more generic (and better maps IDA's internal model.) - -ida_kernwin.IDAViewWrapper.Bind (method) - -ida_kernwin.IDAViewWrapper.Unbind (method) - -ida_kernwin.IDAViewWrapper.__init__ (method) - -ida_kernwin.IDA_DEBUG_ACCESSIBILITY (variable) - accessibility - -ida_kernwin.IDA_DEBUG_ALREADY (variable) - already data or code - -ida_kernwin.IDA_DEBUG_ALWAYS (variable) - everything - -ida_kernwin.IDA_DEBUG_APPCALL (variable) - appcall - -ida_kernwin.IDA_DEBUG_CHECKMEM (variable) - check heap consistency - -ida_kernwin.IDA_DEBUG_CONFIG (variable) - config file - -ida_kernwin.IDA_DEBUG_DBGINFO (variable) - handling of debug info (e.g. pdb, dwarf) - -ida_kernwin.IDA_DEBUG_DEBUGGER (variable) - debugger - -ida_kernwin.IDA_DEBUG_DEMANGLE (variable) - demangler - -ida_kernwin.IDA_DEBUG_DREFS (variable) - drefs - -ida_kernwin.IDA_DEBUG_FLIRT (variable) - flirt - -ida_kernwin.IDA_DEBUG_IDP (variable) - idp module - -ida_kernwin.IDA_DEBUG_IDS (variable) - ids files - -ida_kernwin.IDA_DEBUG_INTERNET (variable) - internet connection (for API backward compatibility) - -ida_kernwin.IDA_DEBUG_LDR (variable) - ldr module - -ida_kernwin.IDA_DEBUG_LICENSE (variable) - licensing - -ida_kernwin.IDA_DEBUG_LUMINA (variable) - lumina related - -ida_kernwin.IDA_DEBUG_NETWORK (variable) - network - -ida_kernwin.IDA_DEBUG_NOTIFY (variable) - show all notifications - -ida_kernwin.IDA_DEBUG_OFFSET (variable) - offsets - -ida_kernwin.IDA_DEBUG_PLUGIN (variable) - plugin module - -ida_kernwin.IDA_DEBUG_QUEUE (variable) - queue - -ida_kernwin.IDA_DEBUG_REGEX (variable) - regular expression - -ida_kernwin.IDA_DEBUG_ROLLBACK (variable) - rollback - -ida_kernwin.IDA_DEBUG_SIMPLEX (variable) - full stack analysis - -ida_kernwin.IDA_DEBUG_SRCDBG (variable) - source debugging - -ida_kernwin.IDA_DEBUG_SUBPROC (variable) - sub process - -ida_kernwin.IDA_DEBUG_THEMES (variable) - themes - -ida_kernwin.IDA_DEBUG_TIL (variable) - type system - -ida_kernwin.IDCHK_ARG (variable) - bad argument(s) - -ida_kernwin.IDCHK_KEY (variable) - bad hotkey name - -ida_kernwin.IDCHK_MAX (variable) - too many IDC hotkeys - -ida_kernwin.IDCHK_OK (variable) - ok - -ida_kernwin.IWID_ADDRWATCH (variable) - address watches (47) - -ida_kernwin.IWID_ALL (variable) - mask - -ida_kernwin.IWID_BOOKMARKS (variable) - bookmarks list (59) - -ida_kernwin.IWID_BPTS (variable) - breakpoints (13) - -ida_kernwin.IWID_CALLS (variable) - function calls (11) - -ida_kernwin.IWID_CALLS_CALLEES (variable) - funcalls, callees (50) - -ida_kernwin.IWID_CALLS_CALLERS (variable) - funcalls, callers (49) - -ida_kernwin.IWID_CALL_STACK (variable) - call stack (17) - -ida_kernwin.IWID_CHOOSER (variable) - chooser (37) - -ida_kernwin.IWID_CLI (variable) - input line (33) - -ida_kernwin.IWID_CMDPALCSR (variable) - command palette (43) - -ida_kernwin.IWID_CMDPALWIN (variable) - command palette (44) - -ida_kernwin.IWID_CPUREGS (variable) - registers (40) - -ida_kernwin.IWID_CUSTVIEW (variable) - custom viewers (46) - -ida_kernwin.IWID_CV_LINE_INFOS (variable) - lineinfo widget (53) - -ida_kernwin.IWID_DISASM (variable) - disassembly views (29) - -ida_kernwin.IWID_DISASM_ARROWS (variable) - arrows widget (52) - -ida_kernwin.IWID_DUMP (variable) - hex dumps (30) - -ida_kernwin.IWID_ENUMS (variable) - enumerations (27) - -ida_kernwin.IWID_EXPORTS (variable) - exports (0) - -ida_kernwin.IWID_FRAME (variable) - function frame (25) - -ida_kernwin.IWID_FUNCS (variable) - functions (3) - -ida_kernwin.IWID_IMPORTS (variable) - imports (1) - -ida_kernwin.IWID_LOCALS (variable) - locals (35) - -ida_kernwin.IWID_LOCTYPS (variable) - local types (10) - -ida_kernwin.IWID_MDVIEWCSR (variable) - lumina md view (51) - -ida_kernwin.IWID_MODULES (variable) - modules (15) - -ida_kernwin.IWID_NAMES (variable) - names (2) - -ida_kernwin.IWID_NAVBAND (variable) - navigation band (26) - -ida_kernwin.IWID_NOTEPAD (variable) - notepad (31) - -ida_kernwin.IWID_OUTPUT (variable) - output (32) - -ida_kernwin.IWID_PROBS (variable) - problems (12) - -ida_kernwin.IWID_PSEUDOCODE (variable) - decompiler (48) - -ida_kernwin.IWID_SCRIPTS_CSR (variable) - recent scripts (58) - -ida_kernwin.IWID_SEARCH (variable) - search results (19) - -ida_kernwin.IWID_SEGREGS (variable) - segment registers (6) - -ida_kernwin.IWID_SEGS (variable) - segments (5) - -ida_kernwin.IWID_SELS (variable) - selectors (7) - -ida_kernwin.IWID_SHORTCUTCSR (variable) - shortcuts chooser (38) - -ida_kernwin.IWID_SHORTCUTWIN (variable) - shortcuts window (39) - -ida_kernwin.IWID_SIGNS (variable) - signatures (8) - -ida_kernwin.IWID_SNIPPETS (variable) - snippets (45) - -ida_kernwin.IWID_SNIPPETS_CSR (variable) - snippets chooser (57) - -ida_kernwin.IWID_SO_OFFSETS (variable) - stroff (42) - -ida_kernwin.IWID_SO_STRUCTS (variable) - stroff (41) - -ida_kernwin.IWID_SRCPTHMAP_CSR (variable) - mappings chooser (54) - -ida_kernwin.IWID_SRCPTHUND_CSR (variable) - undesired chooser (55) - -ida_kernwin.IWID_STACK (variable) - Alias. Some IWID_* were confusing, and thus have been renamed. This is to ensure - bw-compat. - -ida_kernwin.IWID_STKVIEW (variable) - stack view (36) - -ida_kernwin.IWID_STRINGS (variable) - strings (4) - -ida_kernwin.IWID_STRUCTS (variable) - structures (28) - -ida_kernwin.IWID_THREADS (variable) - threads (14) - -ida_kernwin.IWID_TILIST (variable) - types listing (60) - -ida_kernwin.IWID_TILS (variable) - type libraries (9) - -ida_kernwin.IWID_TRACE (variable) - tracing view (16) - -ida_kernwin.IWID_UNDOHIST (variable) - Undo history (56) - -ida_kernwin.IWID_WATCH (variable) - watches (34) - -ida_kernwin.IWID_XREFS (variable) - xrefs (18) - -ida_kernwin.LROEF_CPS_RANGE (variable) - background for range of chars - -ida_kernwin.LROEF_FULL_LINE (variable) - full line background - -ida_kernwin.MFF_FAST (variable) - execute code as soon as possible - this mode is ok call ui related functions - that do not query the database. - -ida_kernwin.MFF_NOWAIT (variable) - Do not wait for the request to be executed. - he caller should ensure that the request is not - destroyed until the execution completes. - if not, the request will be ignored. - the return code of execute_sync() is meaningless - in this case. - This flag can be used to delay the code execution - until the next UI loop run even from the main thread - -ida_kernwin.MFF_READ (variable) - execute code only when ida is idle and it is safe to query the database. - this mode is recommended only for code that does not modify the database. - (nb: ida may be in the middle of executing another user request, for example it may be waiting for him to enter values into a modal dialog box) - -ida_kernwin.MFF_WRITE (variable) - execute code only when ida is idle and it is safe to modify the database. in particular, this flag will suspend execution if there is - a modal dialog box on the screen this mode can be used to call any ida api function. MFF_WRITE implies MFF_READ - -ida_kernwin.PCF_EA_CAPABLE (variable) - toea() implementation returns meaningful data - -ida_kernwin.PCF_MAKEPLACE_ALLOCATES (variable) - makeplace() returns a freshly allocated (i.e., non-static) instance. All new - code should pass that flag to register_place_class(), and the corresponding - makeplace() class implementation should return new instances. - -ida_kernwin.PluginForm (class) - PluginForm class. - - This form can be used to host additional controls. Please check the PyQt example. - -ida_kernwin.PluginForm.Close (method) - Closes the form. - - @param options: Close options (WCLS_SAVE, WCLS_NO_CONTEXT, ...) - - @return: None - -ida_kernwin.PluginForm.GetWidget (method) - Return the TWidget underlying this view. - - @return: The TWidget underlying this view, or None. - -ida_kernwin.PluginForm.OnClose (method) - Called when the plugin form is closed - - @return: None - -ida_kernwin.PluginForm.OnCreate (method) - This event is called when the plugin form is created. - The programmer should populate the form when this event is triggered. - - @return: None - -ida_kernwin.PluginForm.QtWidgetToTWidget (method) - Convert a QWidget to a TWidget* to be used by IDA - - @param ctx: Context. Reference to a module that already imported SIP and QtWidgets modules - -ida_kernwin.PluginForm.Show (method) - Creates the form if not was not created or brings to front if it was already created - - @param caption: The form caption - @param options: One of PluginForm.WOPN_ constants - -ida_kernwin.PluginForm.TWidgetToPyQtWidget (method) - Convert a TWidget* to a QWidget to be used by PyQt - - @param ctx: Context. Reference to a module that already imported SIP and QtWidgets modules - -ida_kernwin.PluginForm.TWidgetToPySideWidget (method) - Use this method to convert a TWidget* to a QWidget to be used by PySide - - @param ctx: Context. Reference to a module that already imported QtWidgets module - -ida_kernwin.PluginForm.WCLS_DELETE_LATER (variable) - This flag should be used when Close() is called from an event handler - -ida_kernwin.PluginForm.WCLS_DONT_SAVE_SIZE (variable) - Don't save size of the window - -ida_kernwin.PluginForm.WCLS_NO_CONTEXT (variable) - Don't change the current context (useful for toolbars) - -ida_kernwin.PluginForm.WCLS_SAVE (variable) - Save state in desktop config - -ida_kernwin.PluginForm.WOPN_DP_BEFORE (variable) - place widget before dst_form in the tab bar instead of after - used with #WOPN_DP_INSIDE and #WOPN_DP_TAB - -ida_kernwin.PluginForm.WOPN_DP_BOTTOM (variable) - Dock widget below dest_ctrl - -ida_kernwin.PluginForm.WOPN_DP_FLOATING (variable) - When floating or in a splitter (i.e., not tabbed), - use the widget's size hint to determine the best - geometry (Qt only) - -ida_kernwin.PluginForm.WOPN_DP_INSIDE (variable) - Create a new tab bar with both widget and dest_ctrl - -ida_kernwin.PluginForm.WOPN_DP_LEFT (variable) - Dock widget to the left of dest_ctrl - -ida_kernwin.PluginForm.WOPN_DP_RIGHT (variable) - Dock widget to the right of dest_ctrl - -ida_kernwin.PluginForm.WOPN_DP_SZHINT (variable) - Make widget floating - -ida_kernwin.PluginForm.WOPN_DP_TAB (variable) - Place widget into a tab next to dest_ctrl, - if dest_ctrl is in a tab bar - (otherwise the same as #WOPN_DP_INSIDE) - -ida_kernwin.PluginForm.WOPN_DP_TOP (variable) - Dock widget above dest_ctrl - -ida_kernwin.PluginForm.WOPN_PERSIST (variable) - form will persist until explicitly closed with Close() - -ida_kernwin.PluginForm.WOPN_RESTORE (variable) - if the widget is the only widget in a floating area when - it is closed, remember that area's geometry. The next - time that widget is created as floating (i.e., WOPN_DP_FLOATING) - its geometry will be restored (e.g., "Execute script" - -ida_kernwin.PluginForm.__init__ (method) - -ida_kernwin.PluginForm._ensure_widget_deps (method) - -ida_kernwin.RENADDR_HR (variable) - dialog for "Pseudocode"; additional flags: - * 0x01 Library function - * 0x02 Mark as decompiled - -ida_kernwin.RENADDR_IDA (variable) - dialog for "IDA View" - -ida_kernwin.S2EAOPT_NOCALC (variable) - don't try to interpret string as IDC (or current extlang) expression - -ida_kernwin.SETMENU_APP (variable) - add menu item after the specified path - -ida_kernwin.SETMENU_ENSURE_SEP (variable) - make sure there is a separator before the action - -ida_kernwin.SETMENU_FIRST (variable) - add item to the beginning of menu - -ida_kernwin.SETMENU_INS (variable) - add menu item before the specified path (default) - -ida_kernwin.SVF_COPY_LINES (variable) - keep a local copy of '*lines' - -ida_kernwin.SVF_LINES_BYPTR (variable) - remember the 'lines' ptr. do not make a copy of '*lines' - -ida_kernwin.TCCPT_ENUMPLACE (variable) - enumplace_t - -ida_kernwin.TCCPT_IDAPLACE (variable) - idaplace_t - -ida_kernwin.TCCPT_INVALID (variable) - invalid - -ida_kernwin.TCCPT_PLACE (variable) - place_t - -ida_kernwin.TCCPT_SIMPLELINE_PLACE (variable) - simpleline_place_t - -ida_kernwin.TCCPT_STRUCTPLACE (variable) - structplace_t - -ida_kernwin.TCCPT_TIPLACE (variable) - tiplace_t - -ida_kernwin.TCCRT_FLAT (variable) - flat view - -ida_kernwin.TCCRT_GRAPH (variable) - graph view - -ida_kernwin.TCCRT_INVALID (variable) - invalid - -ida_kernwin.TCCRT_PROXIMITY (variable) - proximity view - -ida_kernwin.TWidget__from_ptrval__ (function) - TWidget__from_ptrval__(ptrval) -> TWidget * - - @param ptrval: size_t - -ida_kernwin.UIJMP_ACTIVATE (variable) - activate the new window - -ida_kernwin.UIJMP_ANYVIEW (variable) - jump in any ea_t-capable view - -ida_kernwin.UIJMP_DONTPUSH (variable) - do not remember the current address in the navigation history - -ida_kernwin.UIJMP_IDAVIEW (variable) - jump in idaview - -ida_kernwin.UIJMP_IDAVIEW_NEW (variable) - jump in new idaview - -ida_kernwin.UI_Hooks (class) - Proxy of C++ UI_Hooks class. - -ida_kernwin.UI_Hooks.__disown__ (method) - -ida_kernwin.UI_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> UI_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 - -ida_kernwin.UI_Hooks.create_desktop_widget (method) - create_desktop_widget(self, title, cfg) -> PyObject * - create a widget, to be placed in the widget tree (at desktop-creation time.) - - @param title: (const char *) - @param cfg: (const jobj_t *) - @return: TWidget * the created widget, or null - -ida_kernwin.UI_Hooks.current_widget_changed (method) - current_widget_changed(self, widget, prev_widget) - The currently-active TWidget changed. - - @param widget: (TWidget *) - @param prev_widget: (TWidget *) - -ida_kernwin.UI_Hooks.database_closed (method) - database_closed(self) - The database has been closed. See also processor_t::closebase, it occurs - earlier. See also ui_initing_database. This is not the same as IDA exiting. If - you need to perform cleanup at the exiting time, use qatexit(). - -ida_kernwin.UI_Hooks.database_inited (method) - database_inited(self, is_new_database, idc_script) - database initialization has completed. the kernel is about to run idc - scripts - - @param is_new_database: (int) - @param idc_script: (const char *) - may be nullptr - @return: void See also ui_initing_database. This event is called for both new - and old databases. - -ida_kernwin.UI_Hooks.debugger_menu_change (method) - debugger_menu_change(self, enable) - debugger menu modification detected - - @param enable: (bool) true: debugger menu has been added, or a different - debugger has been selected false: debugger menu will be removed - (user switched to "No debugger") - -ida_kernwin.UI_Hooks.desktop_applied (method) - desktop_applied(self, name, from_idb, type) - a desktop has been applied - - @param name: (const char *) the desktop name - @param from_idb: (bool) the desktop was stored in the IDB (false if it comes - from the registry) - @param type: (int) the desktop type (1-disassembly, 2-debugger, 3-merge) - -ida_kernwin.UI_Hooks.destroying_plugmod (method) - destroying_plugmod(self, plugmod, entry) - The plugin object is about to be destroyed - - @param plugmod: (const plugmod_t *) - @param entry: (const plugin_t *) - -ida_kernwin.UI_Hooks.destroying_procmod (method) - destroying_procmod(self, procmod) - The processor module is about to be destroyed - - @param procmod: (const procmod_t *) - -ida_kernwin.UI_Hooks.finish_populating_widget_popup (method) - finish_populating_widget_popup(self, widget, popup_handle, ctx=None) - IDA is about to be done populating the context menu for a widget. This is - your chance to attach_action_to_popup(). - - @param widget: (TWidget *) - @param popup_handle: (TPopupMenu *) - @param ctx: (const action_activation_ctx_t *) - -ida_kernwin.UI_Hooks.get_chooser_item_attrs (method) - get_chooser_item_attrs(self, chooser, n, attrs) - get item-specific attributes for a chooser. This callback is generated only - after enable_chooser_attrs() - - @param chooser: (const chooser_base_t *) - @param n: (::size_t) - @param attrs: (chooser_item_attrs_t *) - -ida_kernwin.UI_Hooks.get_custom_viewer_hint (method) - get_custom_viewer_hint(self, viewer, place) -> PyObject * - ui wants to display a hint for a viewer (idaview or custom). Every - subscriber is supposed to append the hint lines to HINT and increment - IMPORTANT_LINES accordingly. Completely overwriting the existing lines in HINT - is possible but not recommended. If the REG_HINTS_MARKER sequence is found in - the returned hints string, it will be replaced with the contents of the - "regular" hints. If the SRCDBG_HINTS_MARKER sequence is found in the returned - hints string, it will be replaced with the contents of the source-level - debugger-generated hints. The following keywords might appear at the beginning - of the returned hints: HIGHLIGHT text - where text will be highlighted CAPTION caption - caption for the hint widget - - @param viewer: (TWidget*) viewer - @param place: (place_t *) current position in the viewer - @retval 0: continue collecting hints with other subscribers - @retval 1: stop collecting hints - -ida_kernwin.UI_Hooks.get_ea_hint (method) - get_ea_hint(self, ea) -> PyObject * - ui wants to display a simple hint for an address. Use this event to generate - a custom hint See also more generic ui_get_item_hint - - @param ea: (::ea_t) - @return: true if generated a hint - -ida_kernwin.UI_Hooks.get_item_hint (method) - get_item_hint(self, ea, max_lines) -> PyObject * - ui wants to display multiline hint for an item. See also more generic - ui_get_custom_viewer_hint - - @param ea: (ea_t) or item id like a structure or enum member - @param max_lines: (int) maximal number of lines - @return: true if generated a hint - -ida_kernwin.UI_Hooks.get_lines_rendering_info (method) - get_lines_rendering_info(self, out, widget, info) - get lines rendering information - - @param out: (lines_rendering_output_t *) - @param widget: (const TWidget *) - @param info: (const lines_rendering_input_t *) - -ida_kernwin.UI_Hooks.get_widget_config (method) - get_widget_config(self, widget, cfg) -> PyObject * - retrieve the widget configuration (it will be passed back at - ui_create_desktop_widget-, and ui_set_widget_config-time) - - @param widget: (const TWidget *) - @param cfg: (jobj_t *) - -ida_kernwin.UI_Hooks.hook (method) - hook(self) -> bool - -ida_kernwin.UI_Hooks.idcstart (method) - idcstart(self) - Start of IDC engine work. - -ida_kernwin.UI_Hooks.idcstop (method) - idcstop(self) - Stop of IDC engine work. - -ida_kernwin.UI_Hooks.initing_database (method) - initing_database(self) - database initialization has started. - - @return: void See also ui_database_inited. This event is called for both new and - old databases. - -ida_kernwin.UI_Hooks.plugin_loaded (method) - plugin_loaded(self, plugin_info) - The plugin was loaded in memory. - - @param plugin_info: (const plugin_info_t *) - -ida_kernwin.UI_Hooks.plugin_unloading (method) - plugin_unloading(self, plugin_info) - The plugin is about to be unloaded - - @param plugin_info: (const plugin_info_t *) - -ida_kernwin.UI_Hooks.populating_widget_popup (method) - populating_widget_popup(self, widget, popup_handle, ctx=None) - IDA is populating the context menu for a widget. This is your chance to - attach_action_to_popup(). - - Have a look at ui_finish_populating_widget_popup, if you want to augment the - context menu with your own actions after the menu has had a chance to be - properly populated by the owning component or plugin (which typically does it on - ui_populating_widget_popup.) - - @param widget: (TWidget *) - @param popup_handle: (TPopupMenu *) - @param ctx: (const action_activation_ctx_t *) - -ida_kernwin.UI_Hooks.postprocess_action (method) - postprocess_action(self) - an ida ui action has been handled - -ida_kernwin.UI_Hooks.preprocess_action (method) - preprocess_action(self, name) -> int - ida ui is about to handle a user action. - - @param name: (const char *) ui action name. these names can be looked up in - ida[tg]ui.cfg - @retval 0: ok - @retval nonzero: a plugin has handled the command - -ida_kernwin.UI_Hooks.range (method) - range(self) - The disassembly range has been changed ( idainfo::min_ea ... - idainfo::max_ea). UI should redraw the scrollbars. See also: - ui_lock_range_refresh - -ida_kernwin.UI_Hooks.ready_to_run (method) - ready_to_run(self) - all UI elements have been initialized. Automatic plugins may hook to this - event to perform their tasks. - -ida_kernwin.UI_Hooks.resume (method) - resume(self) - Resume the suspended graphical interface. Only the text version. Interface - should respond to it - -ida_kernwin.UI_Hooks.saved (method) - saved(self, path) - The kernel has saved the database. This callback just informs the interface. - Note that at the time this notification is sent, the internal paths are not - updated yet, and calling get_path(PATH_TYPE_IDB) will return the previous path. - - @param path: (const char *) the database path - -ida_kernwin.UI_Hooks.saving (method) - saving(self) - The kernel is flushing its buffers to the disk. The user interface should - save its state. Parameters: none Returns: none - -ida_kernwin.UI_Hooks.screen_ea_changed (method) - screen_ea_changed(self, ea, prev_ea) - The "current address" changed - - @param ea: (ea_t) - @param prev_ea: (ea_t) - -ida_kernwin.UI_Hooks.set_widget_config (method) - set_widget_config(self, widget, cfg) - set the widget configuration - - @param widget: (const TWidget *) - @param cfg: (const jobj_t *) - -ida_kernwin.UI_Hooks.suspend (method) - suspend(self) - Suspend graphical interface. Only the text version. Interface should respond - to it. - -ida_kernwin.UI_Hooks.unhook (method) - unhook(self) -> bool - -ida_kernwin.UI_Hooks.updated_actions (method) - updated_actions(self) - IDA is done updating actions. - -ida_kernwin.UI_Hooks.updating_actions (method) - updating_actions(self, ctx) - IDA is about to update all actions. If your plugin needs to perform - expensive operations more than once (e.g., once per action it registers), you - should do them only once, right away. - - @param ctx: (action_update_ctx_t *) - -ida_kernwin.UI_Hooks.widget_closing (method) - widget_closing(self, widget) - TWidget is about to close. This event precedes ui_widget_invisible. Use this to - perform some possible actions relevant to the lifecycle of this widget - - @param widget: (TWidget *) - -ida_kernwin.UI_Hooks.widget_invisible (method) - widget_invisible(self, widget) - TWidget is being closed. Use this event to destroy the window controls - - @param widget: (TWidget *) - -ida_kernwin.UI_Hooks.widget_visible (method) - widget_visible(self, widget) - TWidget is displayed on the screen. Use this event to populate the window with - controls - - @param widget: (TWidget *) - -ida_kernwin.VES_SHIFT (variable) - state & 1 => Shift is pressed - state & 2 => Alt is pressed - state & 4 => Ctrl is pressed - state & 8 => Mouse left button is pressed - state & 16 => Mouse right button is pressed - state & 32 => Mouse middle button is pressed - state & 128 => Meta is pressed (OSX only) - -ida_kernwin.VME_LEFT_BUTTON (variable) - left mouse button - -ida_kernwin.VME_MID_BUTTON (variable) - middle mouse button - -ida_kernwin.VME_RIGHT_BUTTON (variable) - right mouse button - -ida_kernwin.VME_UNKNOWN (variable) - unknown mouse button - -ida_kernwin.View_Hooks (class) - Proxy of C++ View_Hooks class. - -ida_kernwin.View_Hooks.__disown__ (method) - -ida_kernwin.View_Hooks.__init__ (method) - __init__(self, _flags=0, _hkcb_flags=0x0001) -> View_Hooks - - @param _flags: uint32 - @param _hkcb_flags: uint32 - -ida_kernwin.View_Hooks.hook (method) - hook(self) -> bool - -ida_kernwin.View_Hooks.unhook (method) - unhook(self) -> bool - -ida_kernwin.View_Hooks.view_activated (method) - view_activated(self, view) - A view is activated - - @param view: (TWidget *) - -ida_kernwin.View_Hooks.view_click (method) - view_click(self, view, event) - Click event - - @param view: (TWidget *) - @param event: (const view_mouse_event_t *) - -ida_kernwin.View_Hooks.view_close (method) - view_close(self, view) - View closed - - @param view: (TWidget *) - -ida_kernwin.View_Hooks.view_created (method) - view_created(self, view) - A view is being created. - - @param view: (TWidget *) - -ida_kernwin.View_Hooks.view_curpos (method) - view_curpos(self, view) - Cursor position changed - - @param view: (TWidget *) - -ida_kernwin.View_Hooks.view_dblclick (method) - view_dblclick(self, view, event) - Double click event - - @param view: (TWidget *) - @param event: (const view_mouse_event_t *) - -ida_kernwin.View_Hooks.view_deactivated (method) - view_deactivated(self, view) - A view is deactivated - - @param view: (TWidget *) - -ida_kernwin.View_Hooks.view_keydown (method) - view_keydown(self, view, key, state) - Key down event - - @param view: (TWidget *) - @param key: (int) - @param state: (::view_event_state_t) - -ida_kernwin.View_Hooks.view_loc_changed (method) - view_loc_changed(self, view, now, was) - The location for the view has changed (can be either the place_t, the - renderer_info_t, or both.) - - @param view: (TWidget *) - @param now: (const lochist_entry_t *) - @param was: (const lochist_entry_t *) - -ida_kernwin.View_Hooks.view_mouse_moved (method) - view_mouse_moved(self, view, event) - The mouse moved on the view - - @param view: (TWidget *) - @param event: (const view_mouse_event_t *) - -ida_kernwin.View_Hooks.view_mouse_over (method) - view_mouse_over(self, view, event) - The user moved the mouse over (or out of) a node or an edge. This is only - relevant in a graph view. - - @param view: (TWidget *) - @param event: (const view_mouse_event_t *) - -ida_kernwin.View_Hooks.view_switched (method) - view_switched(self, view, rt) - A view's renderer has changed. - - @param view: (TWidget *) - @param rt: (tcc_renderer_type_t) - -ida_kernwin.WCLS_DELETE_LATER (variable) - assign the deletion of the widget to the UI loop ///< - -ida_kernwin.WCLS_DONT_SAVE_SIZE (variable) - don't save size of the window - -ida_kernwin.WCLS_NO_CONTEXT (variable) - don't change the current context (useful for toolbars) - -ida_kernwin.WCLS_SAVE (variable) - save state in desktop config - -ida_kernwin.WOPN_CLOSED_BY_ESC (variable) - override idagui.cfg:CLOSED_BY_ESC: esc will close - -ida_kernwin.WOPN_DP_BEFORE (variable) - Place widget before dst_form in the tab bar instead of after; used with - WOPN_DP_INSIDE and WOPN_DP_TAB - -ida_kernwin.WOPN_DP_BOTTOM (variable) - Dock widget below dest_ctrl. - -ida_kernwin.WOPN_DP_FLOATING (variable) - Make widget floating. - -ida_kernwin.WOPN_DP_INSIDE (variable) - Create a new tab bar with both widget and dest_ctrl. - -ida_kernwin.WOPN_DP_LEFT (variable) - Dock widget to the left of dest_ctrl. - -ida_kernwin.WOPN_DP_RIGHT (variable) - Dock widget to the right of dest_ctrl. - -ida_kernwin.WOPN_DP_SZHINT (variable) - when floating or in a splitter (i.e., not tabbed), use the widget's size hint to - determine the best geometry (Qt only) - -ida_kernwin.WOPN_DP_TAB (variable) - Place widget into a tab next to dest_ctrl, if dest_ctrl is in a tab bar - (otherwise the same as WOPN_DP_INSIDE) - -ida_kernwin.WOPN_DP_TOP (variable) - Dock widget above dest_ctrl. - -ida_kernwin.WOPN_NOT_CLOSED_BY_ESC (variable) - override idagui.cfg:CLOSED_BY_ESC: esc will not close - -ida_kernwin.WOPN_PERSIST (variable) - widget will remain available when starting or stopping debugger sessions - -ida_kernwin.WOPN_RESTORE (variable) - if the widget was the only widget in a floating area the last time it was - closed, it will be restored as floating, with the same position+size as before - -ida_kernwin.__qtimer_t (class) - Proxy of C++ __qtimer_t class. - -ida_kernwin.__qtimer_t.__init__ (method) - __init__(self) -> __qtimer_t - -ida_kernwin._ask_addr (function) - _ask_addr(addr, format) -> bool - - Parameters - ---------- - addr: ea_t * - format: char const * - -ida_kernwin._ask_long (function) - _ask_long(value, format) -> bool - - Parameters - ---------- - value: sval_t * - format: char const * - -ida_kernwin._ask_seg (function) - _ask_seg(sel, format) -> bool - - Parameters - ---------- - sel: sel_t * - format: char const * - -ida_kernwin._kludge_force_declare_dirspec_t (function) - _kludge_force_declare_dirspec_t(arg1) - - Parameters - ---------- - arg1: dirspec_t const * - -ida_kernwin._kludge_force_declare_dirtree_t (function) - _kludge_force_declare_dirtree_t(arg1) - - Parameters - ---------- - arg1: dirtree_t const * - -ida_kernwin.action_ctx_base_cur_sel_t (class) - Proxy of C++ action_ctx_base_cur_sel_t class. - -ida_kernwin.action_ctx_base_cur_sel_t.__init__ (method) - __init__(self) -> action_ctx_base_cur_sel_t - -ida_kernwin.action_ctx_base_cur_sel_t.reset (method) - reset(self) - -ida_kernwin.action_ctx_base_cur_sel_t.to (variable) - end of selection - -ida_kernwin.action_ctx_base_source_t (class) - Proxy of C++ action_ctx_base_source_t class. - -ida_kernwin.action_ctx_base_source_t.__init__ (method) - __init__(self) -> action_ctx_base_source_t - -ida_kernwin.action_ctx_base_source_t.reset (method) - reset(self) - -ida_kernwin.action_ctx_base_t (class) - Proxy of C++ action_ctx_base_t class. - -ida_kernwin.action_ctx_base_t.__init__ (method) - __init__(self) -> action_ctx_base_t - -ida_kernwin.action_ctx_base_t.action (variable) - action name - -ida_kernwin.action_ctx_base_t.chooser_selection (variable) - current chooser selection (0-based) - -ida_kernwin.action_ctx_base_t.cur_ea (variable) - the current EA of the position in the view - -ida_kernwin.action_ctx_base_t.cur_enum (variable) - the current enum - -ida_kernwin.action_ctx_base_t.cur_fchunk (variable) - the current function chunk - -ida_kernwin.action_ctx_base_t.cur_flags (variable) - Current address information. see Action context property bits. - -ida_kernwin.action_ctx_base_t.cur_func (variable) - the current function - -ida_kernwin.action_ctx_base_t.cur_seg (variable) - the current segment - -ida_kernwin.action_ctx_base_t.cur_sel (variable) - the currently selected range. also see ACF_HAS_SELECTION - -ida_kernwin.action_ctx_base_t.cur_strmem (variable) - the current structure member - -ida_kernwin.action_ctx_base_t.cur_struc (variable) - the current structure - -ida_kernwin.action_ctx_base_t.cur_value (variable) - the possible address, or value the cursor is positioned on - -ida_kernwin.action_ctx_base_t.dirtree_selection (variable) - the current dirtree_t selection (if applicable) - -ida_kernwin.action_ctx_base_t.focus (variable) - The focused widget in case it is not the 'form' itself (e.g., the 'quick filter' - input in choosers.) - -ida_kernwin.action_ctx_base_t.graph_selection (variable) - the current graph selection (if in a graph view) - -ida_kernwin.action_ctx_base_t.has_flag (method) - has_flag(self, flag) -> bool - Check if the given flag is set. - - @param flag: (C++: uint32) - -ida_kernwin.action_ctx_base_t.regname (variable) - register name (if widget_type == BWN_CPUREGS and context menu opened on - register) - -ida_kernwin.action_ctx_base_t.reset (method) - reset(self) - Invalidate all context info. - -ida_kernwin.action_ctx_base_t.source (variable) - the underlying chooser_base_t (if 'widget' is a chooser widget) - -ida_kernwin.action_ctx_base_t.type_ref (variable) - a reference to the current type (if 'widget' is a types listing widget; nullptr - otherwise) - -ida_kernwin.action_ctx_base_t.widget_title (variable) - title of current widget - -ida_kernwin.action_ctx_base_t.widget_type (variable) - type of current widget - -ida_kernwin.action_desc_t (class) - Proxy of C++ action_desc_t class. - -ida_kernwin.action_desc_t.__init__ (method) - __init__(self, name, label, handler, shortcut=None, tooltip=None, icon=-1, flags=0) -> action_desc_t - - @param name: char const * - @param label: char const * - @param handler: PyObject * - @param shortcut: char const * - @param tooltip: char const * - @param icon: int - @param flags: int - -ida_kernwin.action_desc_t.cb (variable) - size of this structure - -ida_kernwin.action_desc_t.flags (variable) - See Action flags. - -ida_kernwin.action_desc_t.icon (variable) - an optional icon ID to use - -ida_kernwin.action_desc_t.label (variable) - the label of the action, possibly with an accelerator key definition (e.g., - "~J~ump to operand") - -ida_kernwin.action_desc_t.name (variable) - the internal name of the action; must be unique. a way to reduce possible - conflicts is to prefix it with some specific prefix. E.g., "myplugin:doSthg". - -ida_kernwin.action_desc_t.owner (variable) - either the plugin_t, or plugmod_t responsible for registering the action. Can be - nullptr Please see ACTION_DESC_LITERAL_PLUGMOD - -ida_kernwin.action_desc_t.shortcut (variable) - an optional shortcut definition. E.g., "Ctrl+Enter" - -ida_kernwin.action_desc_t.tooltip (variable) - an optional tooltip for the action - -ida_kernwin.action_handler_t (class) - -ida_kernwin.action_handler_t.__init__ (method) - -ida_kernwin.action_handler_t.activate (method) - Activate an action. This function implements the core behavior of an action. It - is called when the action is triggered, from a menu, from a popup menu, from the - toolbar, or programmatically. - - @return: non-zero: all IDA windows will be refreshed - -ida_kernwin.action_handler_t.update (method) - Update an action. This is called when the context of the UI changed, and we need - to let the action update some of its properties if needed (label, icon, ...) - - In addition, this lets IDA know whether the action is enabled, and when it - should be queried for availability again. - - Note: This callback is not meant to change anything in the application's state, - except by calling one (or many) of the "update_action_*()" functions on this - very action. - -ida_kernwin.activate_widget (function) - activate_widget(widget, take_focus) - Activate widget (only gui version) (ui_activate_widget). - - @param widget: (C++: TWidget *) existing widget to display - @param take_focus: (C++: bool) give focus to given widget - -ida_kernwin.add_hotkey (function) - add_hotkey(hotkey, pyfunc) -> PyCapsule - 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. - -ida_kernwin.add_idc_hotkey (function) - add_idc_hotkey(hotkey, idcfunc) -> int - Add hotkey for IDC function (ui_add_idckey). - - @param hotkey: (C++: const char *) hotkey name - @param idcfunc: (C++: const char *) IDC function name - @return: IDC hotkey error codes - -ida_kernwin.add_spaces (function) - add_spaces(s, len) -> str - Add space characters to the colored string so that its length will be at least - 'len' characters. Don't trim the string if it is longer than 'len'. - - @param str: (C++: char *) pointer to colored string to modify (may not be nullptr) - @param len: (C++: ssize_t) the desired length of the string - @return: pointer to the end of input string - -ida_kernwin.addon_count (function) - addon_count() -> int - Get number of installed addons. - -ida_kernwin.addon_info_t (class) - Proxy of C++ addon_info_t class. - -ida_kernwin.addon_info_t.__init__ (method) - __init__(self) -> addon_info_t - -ida_kernwin.analyzer_options (function) - analyzer_options() - Allow the user to set analyzer options. (show a dialog box) - (ui_analyzer_options) - -ida_kernwin.ask_addr (function) - Output a formatted string to the output window (msg) preprended with "**DATABASE - IS CORRUPTED: " Display a dialog box and wait for the user to input an address - (ui_ask_addr). - - @retval 0: the user pressed Esc. - @retval 1: ok, the user entered an address - -ida_kernwin.ask_buttons (function) - ask_buttons(Yes, No, Cancel, deflt, format) -> int - Display a dialog box and get choice from maximum three possibilities - (ui_ask_buttons). - @note: for all buttons: - * use "" or nullptr to take the default name for the button. - * prepend "HIDECANCEL\n" in 'format' to hide the Cancel button - - @param Yes: (C++: const char *) text for the first button - @param No: (C++: const char *) text for the second button - @param Cancel: (C++: const char *) text for the third button - @param deflt: (C++: int) default choice: one of Button IDs - @param format: (C++: const char *) printf-style format string for question. It may have some - prefixes, see below. - @return: one of Button IDs specifying the selected button (Esc key returns - Cancel/3rd button value) - -ida_kernwin.ask_file (function) - ask_file(for_saving, defval, format) -> char * - - @param for_saving: bool - @param defval: char const * - @param format: char const * - -ida_kernwin.ask_for_feedback (function) - ask_for_feedback(format) - Show a message box asking to send the input file to \link{mailto:support@hex- - rays.com,support@hex-rays.com}. - - @param format: (C++: const char *) the reason why the input file is bad - -ida_kernwin.ask_form (function) - Display a dialog box and wait for the user. If the form contains the "BUTTON NO - <title>" keyword, then the return values are the same as in the ask_yn() - function (Button IDs) - - @retval 0: no memory to display or form syntax error (a warning is displayed in - this case). the user pressed the 'No' button (if the form has it) or - the user cancelled the dialog otherwise. all variables retain their - original values. - @retval 1: ok, all input fields are filled and validated. - @retval -1: the form has the 'No' button and the user cancelled the dialog - -ida_kernwin.ask_ident (function) - Display a dialog box and wait for the user to input an identifier. If the user - enters a non-valid identifier, this function displays a warning and allows the - user to correct it. CPU register names are usually forbidden. - - @return: false if the user cancelled the dialog, otherwise returns true. - -ida_kernwin.ask_ident2 (function) - ask_ident2(str, format) -> bool - Display a dialog box and wait for the user to input an identifier. If the user - enters a non-valid identifier, this function displays a warning and allows the - user to correct it. CPU register names are permitted. - - @param str: (C++: qstring *) qstring to fill. Can contain the default value. Cannot be nullptr. - @param format: (C++: const char *) printf() style format string with the question - @return: false if the user cancelled the dialog, otherwise returns true. - -ida_kernwin.ask_long (function) - Display a dialog box and wait for the user to input an number (ui_ask_long). The - number is represented in C-style. This function allows to enter any IDC - expression and properly calculates it. - - @retval 0: if the user pressed Esc. - @retval 1: ok, the user entered a valid number. - -ida_kernwin.ask_seg (function) - Display a dialog box and wait for the user to input an segment name - (ui_ask_seg). This function allows to enter segment register names, segment base - paragraphs, segment names to denote a segment. - - @retval 0: if the user pressed Esc. - @retval 1: ok, the user entered an segment name - -ida_kernwin.ask_str (function) - ask_str(defval, hist, prompt) -> str or None - Asks for a long text - - @param defval: The default value - @param hist: history id - @param prompt: The prompt value - @return: None or the entered string - -ida_kernwin.ask_text (function) - ask_text(max_size, defval, prompt) -> str - Asks for a long text - - @param max_size: Maximum text length, 0 for unlimited - @param defval: The default value - @param prompt: The prompt value - @return: None or the entered string - -ida_kernwin.ask_yn (function) - ask_yn(deflt, format) -> int - Display a dialog box and get choice from "Yes", "No", "Cancel". - - @param deflt: (C++: int) default choice: one of Button IDs - @param format: (C++: const char *) The question in printf() style format - @return: the selected button (one of Button IDs). Esc key returns ASKBTN_CANCEL. - -ida_kernwin.atoea (function) - atoea(str) -> bool - Convert a number in C notation to an address. decimal: 1234 - octal: 0123 - hexadecimal: 0xabcd - binary: 0b00101010 - - @param str: (C++: const char *) the string to parse - -ida_kernwin.attach_action_to_menu (function) - attach_action_to_menu(menupath, name, flags=0) -> bool - Attach a previously-registered action to the menu (ui_attach_action_to_menu). - @note: You should not change top level menu, or the Edit,Plugins submenus If you - want to modify the debugger menu, do it at the ui_debugger_menu_change - event (ida might destroy your menu item if you do it elsewhere). - - @param menupath: (C++: const char *) path to the menu item after or before which the insertion will - take place. - * Example: Debug/StartProcess - * Whitespace, punctuation are ignored. - * It is allowed to specify only the prefix of the menu item. - * Comparison is case insensitive. - * menupath may start with the following prefixes: - * [S] - modify the main menu of the structure window - * [E] - modify the main menu of the enum window - @param name: (C++: const char *) the action name - @param flags: (C++: int) a combination of Set menu flags, to determine menu item position - @return: success - -ida_kernwin.attach_action_to_popup (function) - attach_action_to_popup(widget, popup_handle, name, popuppath=None, flags=0) -> bool - Insert a previously-registered action into the widget's popup menu - (ui_attach_action_to_popup). This function has two "modes": 'single-shot', and - 'permanent'. - - @param widget: (C++: TWidget *) target widget - @param popup_handle: (C++: TPopupMenu *) target popup menu - * if non-nullptr, the action is added to this popup menu invocation (i.e., - 'single-shot') - * if nullptr, the action is added to a list of actions that should always be - present in context menus for this widget (i.e., 'permanent'.) - @param name: (C++: const char *) action name - @param popuppath: (C++: const char *) can be nullptr - @param flags: (C++: int) a combination of SETMENU_ flags (see Set menu flags) - @return: success - -ida_kernwin.attach_action_to_toolbar (function) - attach_action_to_toolbar(toolbar_name, name) -> bool - Attach an action to an existing toolbar (ui_attach_action_to_toolbar). - - @param toolbar_name: (C++: const char *) the name of the toolbar - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.attach_dynamic_action_to_popup (function) - attach_dynamic_action_to_popup(unused, popup_handle, desc, popuppath=None, flags=0) -> bool - Create & insert an action into the widget's popup menu - (::ui_attach_dynamic_action_to_popup). - Note: The action description in the 'desc' parameter is modified by - this call so you should prepare a new description for each call. - For example: - desc = idaapi.action_desc_t(None, 'Dynamic popup action', Handler()) - idaapi.attach_dynamic_action_to_popup(form, popup, desc) - - @param unused: deprecated; should be None - @param popup_handle: target popup - @param desc: action description of type action_desc_t - @param popuppath: can be None - @param flags: a combination of SETMENU_ constants - @return: success - -ida_kernwin.banner (function) - banner(wait) -> bool - Show a banner dialog box (ui_banner). - - @param wait: (C++: int) time to wait before closing - @retval 1: ok - @retval 0: esc was pressed - -ida_kernwin.beep (function) - beep(beep_type=beep_default) - Issue a beeping sound (ui_beep). - - @param beep_type: (C++: beep_t) - -ida_kernwin.call_nav_colorizer (function) - call_nav_colorizer(dict, ea, nbytes) -> uint32 - To be used with the IDA-provided colorizer, that is - returned as result of the first call to set_nav_colorizer(). - - @param dict: PyObject * - @param ea: ea_t - @param nbytes: asize_t - -ida_kernwin.cancel_exec_request (function) - cancel_exec_request(req_id) -> bool - Try to cancel an asynchronous exec request (ui_cancel_exec_request). - - @param req_id: (C++: int) request id - @retval true: successfully canceled - @retval false: request has already been processed. - -ida_kernwin.cancel_thread_exec_requests (function) - cancel_thread_exec_requests(tid) -> int - Try to cancel asynchronous exec requests created by the specified thread. - - @param tid: (C++: qthread_t) thread id - @return: number of the canceled requests. - -ida_kernwin.choose_activate (function) - choose_activate(_self) - - @param self: PyObject * - -ida_kernwin.choose_choose (function) - choose_choose(_self) -> PyObject * - - @param self: PyObject * - -ida_kernwin.choose_close (function) - choose_close(_self) - - @param self: PyObject * - -ida_kernwin.choose_create_embedded_chobj (function) - choose_create_embedded_chobj(_self) -> PyObject * - - @param self: PyObject * - -ida_kernwin.choose_entry (function) - choose_entry(title) -> ea_t - Choose an entry point (ui_choose, chtype_entry). - - @param title: (C++: const char *) chooser title - @return: ea of selected entry point, BADADDR if none selected - -ida_kernwin.choose_enum (function) - choose_enum(out, title, default_ord) -> bool - - @param out: tinfo_t * - @param title: char const * - @param default_ord: uint32 - - choose_enum(title, default_id) -> enum_t - - @param title: char const * - @param default_id: enum_t - -ida_kernwin.choose_enum_by_value (function) - choose_enum_by_value(out, title, default_ord, value, nbytes) -> bool - - @param out: tinfo_t * - @param title: char const * - @param default_ord: uint32 - @param value: uint64 - @param nbytes: int - - choose_enum_by_value(title, default_id, value, nbytes) -> enum_t - - @param title: char const * - @param default_id: enum_t - @param value: uint64 - @param nbytes: int - -ida_kernwin.choose_find (function) - choose_find(title) -> MyChoose or None - - @param title: char const * - -ida_kernwin.choose_func (function) - choose_func(title, default_ea) -> func_t * - Choose a function (ui_choose, chtype_func). - - @param title: (C++: const char *) chooser title - @param default_ea: (C++: ea_t) ea of function to select by default - @return: pointer to function that was selected, nullptr if none selected - -ida_kernwin.choose_get_widget (function) - choose_get_widget(_self) -> TWidget * - - @param self: PyObject * - -ida_kernwin.choose_idasgn (function) - choose_idasgn() -> PyObject * - Opens the signature chooser - - @return: None or the selected signature name - -ida_kernwin.choose_name (function) - choose_name(title) -> ea_t - Choose a name (ui_choose, chtype_name). - - @param title: (C++: const char *) chooser title - @return: ea of selected name, BADADDR if none selected - -ida_kernwin.choose_refresh (function) - choose_refresh(_self) - - @param self: PyObject * - -ida_kernwin.choose_segm (function) - choose_segm(title, default_ea) -> segment_t * - Choose a segment (ui_choose, chtype_segm). - - @param title: (C++: const char *) chooser title - @param default_ea: (C++: ea_t) ea of segment to select by default - @return: pointer to segment that was selected, nullptr if none selected - -ida_kernwin.choose_srcp (function) - choose_srcp(title) -> sreg_range_t * - Choose a segment register change point (ui_choose, chtype_srcp). - - @param title: (C++: const char *) chooser title - @return: pointer to segment register range of selected change point, nullptr if - none selected - -ida_kernwin.choose_stkvar_xref (function) - choose_stkvar_xref(pfn, mptr) -> ea_t - Choose an xref to a stack variable (ui_choose, chtype_name). - - @param pfn: (C++: func_t *) function - @param mptr: (C++: member_t *) variable - @return: ea of the selected xref, BADADDR if none selected - -ida_kernwin.choose_struc (function) - choose_struc(title) -> struc_t * - - @param title: char const * - -ida_kernwin.choose_struct (function) - choose_struct(out, title) -> bool - Choose a structure (ui_choose, chtype_struct). - - @param out: (C++: tinfo_t *) the selected structure type - @param title: (C++: const char *) chooser title - @retval true: the selected type is in OUT - @retval false: nothing was selected - -ida_kernwin.choose_til (function) - choose_til() -> str - Choose a type library (ui_choose, chtype_idatil). - - @retval true: 'buf' was filled with the name of the selected til - @retval false: otherwise - -ida_kernwin.choose_xref (function) - choose_xref(to) -> ea_t - Choose an xref to an address (ui_choose, chtype_xref). - - @param to: (C++: ea_t) referenced address - @return: ea of selected xref, BADADDR if none selected - -ida_kernwin.chooser_base_t (class) - Proxy of C++ chooser_base_t class. - -ida_kernwin.chooser_base_t.__init__ (method) - -ida_kernwin.chooser_base_t.ask_item_attrs (method) - ask_item_attrs(self) -> bool - should chooser generate ui_get_chooser_item_attrs events? - -ida_kernwin.chooser_base_t.can_del (method) - can_del(self) -> bool - -ida_kernwin.chooser_base_t.can_edit (method) - can_edit(self) -> bool - -ida_kernwin.chooser_base_t.can_filter (method) - can_filter(self) -> bool - -ida_kernwin.chooser_base_t.can_ins (method) - can_ins(self) -> bool - is an operation allowed? - -ida_kernwin.chooser_base_t.can_refresh (method) - can_refresh(self) -> bool - -ida_kernwin.chooser_base_t.can_sort (method) - can_sort(self) -> bool - -ida_kernwin.chooser_base_t.columns (variable) - number of columns - -ida_kernwin.chooser_base_t.deflt_col (variable) - Column that will have focus. - -ida_kernwin.chooser_base_t.get_builtin_number (method) - get_builtin_number(self) -> uint - get number of the built-in chooser - -ida_kernwin.chooser_base_t.get_count (method) - get_count(self) -> size_t - get the number of elements in the chooser - -ida_kernwin.chooser_base_t.get_ea (method) - get_ea(self, arg2) -> ea_t - get the address of an element. When this function returns valid addresses: * If - any column has the `CHCOL_FNAME` flag, rows will be colored according to the - attributes of the functions who own those addresses (extern, library function, - Lumina, ... - similar to what the "Functions" widget does) * When a selection is - present and the user presses `<Enter>` (`<Shift+Enter>` if the chooser is - modal), IDA will jump to that address (through jumpto()) - - @param arg2: size_t - @return: the effective address, BADADDR if the element has no address - -ida_kernwin.chooser_base_t.get_quick_filter_initial_mode (method) - get_quick_filter_initial_mode(self) -> int - -ida_kernwin.chooser_base_t.get_row (method) - get_row(self, n) -> ([str, ...], int, chooser_item_attrs_t) - get a description of an element. - - @param n: (C++: size_t) element number (0..get_count()-1) - -ida_kernwin.chooser_base_t.has_diff_capability (method) - has_diff_capability(self) -> bool - -ida_kernwin.chooser_base_t.has_dirtree (method) - has_dirtree(self) -> bool - -ida_kernwin.chooser_base_t.has_inode_to_index (method) - has_inode_to_index(self) -> bool - -ida_kernwin.chooser_base_t.header (variable) - header line; contains the tooltips, and column name for each of 'columns' - columns. When tooltips need to be provided, the syntax should be: - "#tooltip#column-name". (Otherwise, the syntax is simply "column-name".) - -ida_kernwin.chooser_base_t.height (variable) - (in chars) - -ida_kernwin.chooser_base_t.icon (variable) - default icon - -ida_kernwin.chooser_base_t.is_dirtree_persisted (method) - is_dirtree_persisted(self) -> bool - -ida_kernwin.chooser_base_t.is_force_default (method) - is_force_default(self) -> bool - should selection of the already opened non-modal chooser be changed? - -ida_kernwin.chooser_base_t.is_lazy_loaded (method) - is_lazy_loaded(self) -> bool - -ida_kernwin.chooser_base_t.is_modal (method) - is_modal(self) -> bool - is choose modal? - -ida_kernwin.chooser_base_t.is_multi (method) - is_multi(self) -> bool - is multi-selection allowed? - -ida_kernwin.chooser_base_t.is_quick_filter_visible_initially (method) - is_quick_filter_visible_initially(self) -> bool - -ida_kernwin.chooser_base_t.is_same (method) - is_same(self, other) -> bool - do the current and the given objects hold the same data? - - @param other: (C++: const chooser_base_t *) chooser_base_t const * - -ida_kernwin.chooser_base_t.is_status_bar_hidden (method) - is_status_bar_hidden(self) -> bool - -ida_kernwin.chooser_base_t.popup_allowed (method) - popup_allowed(self, stdact_idx) -> bool - is a standard action allowed? - - @param stdact_idx: (C++: int) - -ida_kernwin.chooser_base_t.popup_names (variable) - array of custom labels of the standard actions. Used to replace labels for these - actions. - An empty name means that the default name will be used. - @note: Availability of these actions is determined by the CH_CAN_... flags. The - label, icon and other action attributes can be overwritten in the action - description returned by get_stdact_descs() - -ida_kernwin.chooser_base_t.should_rename_trigger_edit (method) - should_rename_trigger_edit(self) -> bool - -ida_kernwin.chooser_base_t.should_restore_geometry (method) - should_restore_geometry(self) -> bool - -ida_kernwin.chooser_base_t.title (variable) - menu title (includes ptr to help). May have chooser title prefixes (see "Chooser - title" above). - -ida_kernwin.chooser_base_t.width (variable) - (in chars) - -ida_kernwin.chooser_base_t.widths (variable) - column widths - * low 16 bits of each value hold the column width - * high 16 bits are flags (see Chooser column flags) - -ida_kernwin.chooser_base_t.x0 (variable) - screen position, Functions: generic list choosers - -ida_kernwin.chooser_item_attrs_t (class) - Proxy of C++ chooser_item_attrs_t class. - -ida_kernwin.chooser_item_attrs_t.__eq__ (method) - __eq__(self, other) -> bool - - @param other: chooser_item_attrs_t const & - -ida_kernwin.chooser_item_attrs_t.__init__ (method) - __init__(self) -> chooser_item_attrs_t - -ida_kernwin.chooser_item_attrs_t.color (variable) - item color - -ida_kernwin.chooser_item_attrs_t.flags (variable) - Chooser item property bits - -ida_kernwin.chooser_item_attrs_t.reset (method) - reset(self) - -ida_kernwin.chooser_row_info_t (class) - Proxy of C++ chooser_row_info_t class. - -ida_kernwin.chooser_row_info_t.__eq__ (method) - __eq__(self, other) -> bool - - @param other: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_t.__init__ (method) - __init__(self) -> chooser_row_info_t - -ida_kernwin.chooser_row_info_t.__ne__ (method) - __ne__(self, other) -> bool - - @param other: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_t.attrs (variable) - styling attributes - -ida_kernwin.chooser_row_info_t.icon (variable) - icon number - -ida_kernwin.chooser_row_info_t.texts (variable) - texts, one per chooser column - -ida_kernwin.chooser_row_info_vec_t (class) - Proxy of C++ qvector< chooser_row_info_t > class. - -ida_kernwin.chooser_row_info_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< chooser_row_info_t > const & - -ida_kernwin.chooser_row_info_vec_t.__getitem__ (method) - __getitem__(self, i) -> chooser_row_info_t - - @param i: size_t - -ida_kernwin.chooser_row_info_vec_t.__init__ (method) - __init__(self) -> chooser_row_info_vec_t - __init__(self, x) -> chooser_row_info_vec_t - - @param x: qvector< chooser_row_info_t > const & - -ida_kernwin.chooser_row_info_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.chooser_row_info_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< chooser_row_info_t > const & - -ida_kernwin.chooser_row_info_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_vec_t.at (method) - at(self, _idx) -> chooser_row_info_t - - @param _idx: size_t - -ida_kernwin.chooser_row_info_vec_t.begin (method) - begin(self) -> chooser_row_info_t - -ida_kernwin.chooser_row_info_vec_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.chooser_row_info_vec_t.clear (method) - clear(self) - -ida_kernwin.chooser_row_info_vec_t.empty (method) - empty(self) -> bool - -ida_kernwin.chooser_row_info_vec_t.end (method) - end(self) -> chooser_row_info_t - -ida_kernwin.chooser_row_info_vec_t.erase (method) - erase(self, it) -> chooser_row_info_t - - @param it: qvector< chooser_row_info_t >::iterator - - erase(self, first, last) -> chooser_row_info_t - - @param first: qvector< chooser_row_info_t >::iterator - @param last: qvector< chooser_row_info_t >::iterator - -ida_kernwin.chooser_row_info_vec_t.extract (method) - extract(self) -> chooser_row_info_t - -ida_kernwin.chooser_row_info_vec_t.find (method) - find(self, x) -> chooser_row_info_t - - @param x: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_vec_t.grow (method) - grow(self, x=chooser_row_info_t()) - - @param x: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_vec_t.has (method) - has(self, x) -> bool - - @param x: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_vec_t.inject (method) - inject(self, s, len) - - @param s: chooser_row_info_t * - @param len: size_t - -ida_kernwin.chooser_row_info_vec_t.insert (method) - insert(self, it, x) -> chooser_row_info_t - - @param it: qvector< chooser_row_info_t >::iterator - @param x: chooser_row_info_t const & - -ida_kernwin.chooser_row_info_vec_t.pop_back (method) - pop_back(self) - -ida_kernwin.chooser_row_info_vec_t.push_back (method) - push_back(self, x) - - @param x: chooser_row_info_t const & - - push_back(self) -> chooser_row_info_t - -ida_kernwin.chooser_row_info_vec_t.qclear (method) - qclear(self) - -ida_kernwin.chooser_row_info_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.chooser_row_info_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: chooser_row_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_kernwin.chooser_row_info_vec_t.size (method) - size(self) -> size_t - -ida_kernwin.chooser_row_info_vec_t.swap (method) - swap(self, r) - - @param r: qvector< chooser_row_info_t > & - -ida_kernwin.chooser_row_info_vec_t.truncate (method) - truncate(self) - -ida_kernwin.chooser_stdact_desc_t (class) - Proxy of C++ chooser_stdact_desc_t class. - -ida_kernwin.chooser_stdact_desc_t.__disown__ (method) - -ida_kernwin.chooser_stdact_desc_t.__init__ (method) - __init__(self, _label=None, _tooltip=None, _icon=-1) -> chooser_stdact_desc_t - - @param _label: char const * - @param _tooltip: char const * - @param _icon: int - -ida_kernwin.chooser_stdact_desc_t.label (variable) - see action_desc_t - -ida_kernwin.chooser_stdact_desc_t.ucb (method) - ucb(self, arg0) -> action_state_t - the update callback, see action_handler_t::update() When the update callback is - called from the chooser UI engine, it can be sure that ctx.source.chooser is a - valid pointer to chooser_base_t and that there are selected items for the Delete - and Edit actions. - - @param arg0: action_update_ctx_t * - -ida_kernwin.chooser_stdact_desc_t.version (variable) - to support the backward compatibility - -ida_kernwin.chtype_entry (variable) - see choose_entry() - -ida_kernwin.chtype_enum (variable) - see choose_enum() - -ida_kernwin.chtype_enum_by_value (variable) - Deprecated. See chtype_enum_by_value_and_size. - -ida_kernwin.chtype_enum_by_value_and_size (variable) - see choose_enum_by_value() - -ida_kernwin.chtype_func (variable) - see choose_func() - -ida_kernwin.chtype_generic (variable) - the generic choose() function - -ida_kernwin.chtype_idasgn (variable) - see choose_idasgn() - -ida_kernwin.chtype_idatil (variable) - see choose_til() - -ida_kernwin.chtype_name (variable) - see choose_name() - -ida_kernwin.chtype_obsolete_enum (variable) - see choose_enum() - -ida_kernwin.chtype_obsolete_enum_by_value_and_size (variable) - see choose_enum_by_value() - -ida_kernwin.chtype_obsolete_struc (variable) - see choose_struc() - -ida_kernwin.chtype_segm (variable) - see choose_segm() - -ida_kernwin.chtype_srcp (variable) - see choose_srcp() - -ida_kernwin.chtype_stkvar_xref (variable) - see choose_stkvar_xref() - -ida_kernwin.chtype_strpath (variable) - see choose_struc_path() - -ida_kernwin.chtype_struct (variable) - see choose_struct() - -ida_kernwin.chtype_xref (variable) - see choose_xref() - -ida_kernwin.clear_refresh_request (function) - clear_refresh_request(mask) - - @param mask: uint64 - -ida_kernwin.cli_t (class) - cli_t wrapper class. - - This class allows you to implement your own command line interface handlers. - -ida_kernwin.cli_t.OnCompleteLine (method) - The user pressed Tab. Find a completion number N for prefix PREFIX - - This callback is optional. - - @param prefix: Line prefix at prefix_start (string) - @param n: completion number (int) - @param line: the current line (string) - @param prefix_start: the index where PREFIX starts in LINE (int) - - @return: None if no completion could be generated otherwise a String with the completion suggestion - -ida_kernwin.cli_t.OnExecuteLine (method) - The user pressed Enter. The CLI is free to execute the line immediately or ask for more lines. - - This callback is mandatory. - - @param line: typed line(s) - @return: Boolean: True-executed line, False-ask for more lines - -ida_kernwin.cli_t.OnKeydown (method) - A keyboard key has been pressed - This is a generic callback and the CLI is free to do whatever it wants. - - This callback is optional. - - @param line: current input line - @param x: current x coordinate of the cursor - @param sellen: current selection length (usually 0) - @param vkey: virtual key code. if the key has been handled, it should be returned as zero - @param shift: shift state - - @return: None - Nothing was changed - tuple(line, x, sellen, vkey): if either of the input line or the x coordinate or the selection length has been modified. - It is possible to return a tuple with None elements to preserve old values. Example: tuple(new_line, None, None, None) or tuple(new_line) - -ida_kernwin.cli_t.__del__ (method) - -ida_kernwin.cli_t.__init__ (method) - -ida_kernwin.cli_t.register (method) - Registers the CLI. - - @param flags: Feature bits. No bits are defined yet, must be 0 - @param sname: Short name (displayed on the button) - @param lname: Long name (displayed in the menu) - @param hint: Hint for the input line - - @return: Boolean: True-Success, False-Failed - -ida_kernwin.cli_t.unregister (method) - Unregisters the CLI (if it was registered) - -ida_kernwin.close_chooser (function) - close_chooser(title) -> bool - Close a non-modal chooser (ui_close_chooser). - - @param title: (C++: const char *) window title of chooser to close - @return: success - -ida_kernwin.close_widget (function) - close_widget(widget, options) - Close widget (ui_close_widget, only gui version). - - @param widget: (C++: TWidget *) pointer to the widget to close - @param options: (C++: int) Form close flags - -ida_kernwin.clr_cancelled (function) - clr_cancelled() - Clear "Cancelled" flag (ui_clr_cancelled) - -ida_kernwin.create_code_viewer (function) - create_code_viewer(custview, flags=0, parent=None) -> TWidget * - Create a code viewer (ui_create_code_viewer). A code viewer contains on the left - side a widget representing the line numbers, and on the right side, the child - widget passed as parameter. It will inherit its title from the child widget. - - @param custview: (C++: TWidget *) the custom view to be added - @param flags: (C++: int) Code viewer flags - @param parent: (C++: TWidget *) widget to contain the new code viewer - -ida_kernwin.create_empty_widget (function) - create_empty_widget(title, icon=-1) -> TWidget * - Create an empty widget, serving as a container for custom user widgets - - @param title: (C++: const char *) char const * - @param icon: (C++: int) - -ida_kernwin.create_menu (function) - create_menu(name, label, menupath=None) -> bool - Create a menu with the given name, label and optional position, either in the - menubar, or as a submenu. If 'menupath' is non-nullptr, it provides information - about where the menu should be positioned. First, IDA will try and resolve the - corresponding menu by its name. If such an existing menu is found and is present - in the menubar, then the new menu will be inserted in the menubar before it. - Otherwise, IDA will try to resolve 'menupath' as it would for - attach_action_to_menu() and, if found, add the new menu like so: - // The new 'My menu' submenu will appear in the 'Comments' submenu - // before the 'Enter comment..." command - create_menu("(...)", "My menu", "Edit/Comments/Enter comment..."); - or - // The new 'My menu' submenu will appear at the end of the - // 'Comments' submenu. - create_menu("(...)", "My menu", "Edit/Comments/"); - If the above fails, the new menu will be appended to the menubar. - - @param name: (C++: const char *) name of menu (must be unique) - @param label: (C++: const char *) label of menu - @param menupath: (C++: const char *) where should the menu be inserted - @return: success - -ida_kernwin.create_toolbar (function) - create_toolbar(name, label, before=None, flags=0) -> bool - Create a toolbar with the given name, label and optional position - - @param name: (C++: const char *) name of toolbar (must be unique) - @param label: (C++: const char *) label of toolbar - @param before: (C++: const char *) if non-nullptr, the toolbar before which the new toolbar will be - inserted - @param flags: (C++: int) a combination of create toolbar flags, to determine toolbar - position - @return: success - -ida_kernwin.custom_viewer_jump (function) - custom_viewer_jump(v, loc, flags=0) -> bool - Append 'loc' to the viewer's history, and cause the viewer to display it. - - @param v: (C++: TWidget *) (TWidget *) - @param loc: (C++: const lochist_entry_t &) (const lochist_entry_t &) - @param flags: (C++: uint32) (uint32) or'ed combination of CVNF_* values - @return: success - -ida_kernwin.del_hotkey (function) - del_hotkey(pyctx) -> bool - Deletes a previously registered function hotkey - - @param ctx: Hotkey context previously returned by add_hotkey() - - @return: Boolean. - -ida_kernwin.del_idc_hotkey (function) - del_idc_hotkey(hotkey) -> bool - - @param hotkey: char const * - -ida_kernwin.delete_menu (function) - delete_menu(name) -> bool - Delete an existing menu - - @param name: (C++: const char *) name of menu - @return: success - -ida_kernwin.delete_toolbar (function) - delete_toolbar(name) -> bool - Delete an existing toolbar - - @param name: (C++: const char *) name of toolbar - @return: success - -ida_kernwin.detach_action_from_menu (function) - detach_action_from_menu(menupath, name) -> bool - Detach an action from the menu (ui_detach_action_from_menu). - - @param menupath: (C++: const char *) path to the menu item - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.detach_action_from_popup (function) - detach_action_from_popup(widget, name) -> bool - Remove a previously-registered action, from the list of 'permanent' context menu - actions for this widget (ui_detach_action_from_popup). This only makes sense if - the action has been added to 'widget's list of permanent popup actions by - calling attach_action_to_popup in 'permanent' mode. - - @param widget: (C++: TWidget *) target widget - @param name: (C++: const char *) action name - -ida_kernwin.detach_action_from_toolbar (function) - detach_action_from_toolbar(toolbar_name, name) -> bool - Detach an action from the toolbar (ui_detach_action_from_toolbar). - - @param toolbar_name: (C++: const char *) the name of the toolbar - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.disabled_script_timeout_t (class) - -ida_kernwin.disabled_script_timeout_t.__enter__ (method) - -ida_kernwin.disabled_script_timeout_t.__exit__ (method) - -ida_kernwin.disasm_line_t (class) - Proxy of C++ disasm_line_t class. - -ida_kernwin.disasm_line_t.__init__ (method) - __init__(self) -> disasm_line_t - __init__(self, other) -> disasm_line_t - - @param other: disasm_line_t const & - -ida_kernwin.disasm_text_t (class) - Proxy of C++ qvector< disasm_line_t > class. - -ida_kernwin.disasm_text_t.__getitem__ (method) - __getitem__(self, i) -> disasm_line_t - - @param i: size_t - -ida_kernwin.disasm_text_t.__init__ (method) - __init__(self) -> disasm_text_t - __init__(self, x) -> disasm_text_t - - @param x: qvector< disasm_line_t > const & - -ida_kernwin.disasm_text_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.disasm_text_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: disasm_line_t const & - -ida_kernwin.disasm_text_t.at (method) - at(self, _idx) -> disasm_line_t - - @param _idx: size_t - -ida_kernwin.disasm_text_t.begin (method) - begin(self) -> disasm_line_t - -ida_kernwin.disasm_text_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.disasm_text_t.clear (method) - clear(self) - -ida_kernwin.disasm_text_t.empty (method) - empty(self) -> bool - -ida_kernwin.disasm_text_t.end (method) - end(self) -> disasm_line_t - -ida_kernwin.disasm_text_t.erase (method) - erase(self, it) -> disasm_line_t - - @param it: qvector< disasm_line_t >::iterator - - erase(self, first, last) -> disasm_line_t - - @param first: qvector< disasm_line_t >::iterator - @param last: qvector< disasm_line_t >::iterator - -ida_kernwin.disasm_text_t.extract (method) - extract(self) -> disasm_line_t - -ida_kernwin.disasm_text_t.grow (method) - grow(self, x=disasm_line_t()) - - @param x: disasm_line_t const & - -ida_kernwin.disasm_text_t.inject (method) - inject(self, s, len) - - @param s: disasm_line_t * - @param len: size_t - -ida_kernwin.disasm_text_t.insert (method) - insert(self, it, x) -> disasm_line_t - - @param it: qvector< disasm_line_t >::iterator - @param x: disasm_line_t const & - -ida_kernwin.disasm_text_t.pop_back (method) - pop_back(self) - -ida_kernwin.disasm_text_t.push_back (method) - push_back(self, x) - - @param x: disasm_line_t const & - - push_back(self) -> disasm_line_t - -ida_kernwin.disasm_text_t.qclear (method) - qclear(self) - -ida_kernwin.disasm_text_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.disasm_text_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: disasm_line_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_kernwin.disasm_text_t.size (method) - size(self) -> size_t - -ida_kernwin.disasm_text_t.swap (method) - swap(self, r) - - @param r: qvector< disasm_line_t > & - -ida_kernwin.disasm_text_t.truncate (method) - truncate(self) - -ida_kernwin.display_copyright_warning (function) - display_copyright_warning() -> bool - Display copyright warning (ui_copywarn). - - @return: yes/no - -ida_kernwin.display_widget (function) - display_widget(widget, options, dest_ctrl=None) - Display a widget, dock it if not done before - - @param widget: (C++: TWidget *) widget to display - @param options: (C++: uint32) Widget open flags - @param dest_ctrl: (C++: const char *) where to dock: if nullptr or invalid then use the active - docker if there is not create a new tab relative to current - active tab - -ida_kernwin.ea2str (function) - ea2str(ea) -> str - Convert linear address to UTF-8 string. - - @param ea: (C++: ea_t) - -ida_kernwin.ea_viewer_history_push_and_jump (function) - ea_viewer_history_push_and_jump(v, ea, x, y, lnnum) -> bool - Push current location in the history and jump to the given location - (ui_ea_viewer_history_push_and_jump). This will jump in the given ea viewer and - also in other synchronized views. - - @param v: (C++: TWidget *) ea viewer - @param ea: (C++: ea_t) jump destination - @param x: (C++: int) ,y: coords on screen - @param lnnum: (C++: int) desired line number of given address - @param lnnum: (C++: int) desired line number of given address - -ida_kernwin.enable_chooser_item_attrs (function) - enable_chooser_item_attrs(chooser_caption, enable) -> bool - Enable item-specific attributes for chooser items - (ui_enable_chooser_item_attrs). For example: color list items differently - depending on a criterium. - If enabled, the chooser will generate ui_get_chooser_item_attrs - events that can be intercepted by a plugin to modify the item attributes. - This event is generated only in the GUI version of IDA. - Specifying CH_ATTRS bit at the chooser creation time has the same effect. - - @param chooser_caption: (C++: const char *) char const * - @param enable: (C++: bool) - @return: success - -ida_kernwin.enumplace_t (class) - Proxy of C++ enumplace_t class. - -ida_kernwin.enumplace_t.__init__ (method) - -ida_kernwin.enumplace_t.bmask (variable) - enum member bitmask - -ida_kernwin.enumplace_t.idx (variable) - enum serial number - -ida_kernwin.enumplace_t.serial (variable) - enum member serial number - -ida_kernwin.enumplace_t.value (variable) - enum member value - -ida_kernwin.error (function) - error(format) - Display a fatal message in a message box and quit IDA - - @param format: message to print - -ida_kernwin.execute_sync (function) - 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. - - @param py_callable: A python callable object, must return an integer value - @param reqf: one of MFF_ flags - @return: -1 or the return value of the callable - -ida_kernwin.execute_ui_requests (function) - 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 callable item - -ida_kernwin.find_widget (function) - find_widget(caption) -> TWidget * - Find widget with the specified caption (only gui version) (ui_find_widget). NB: - this callback works only with the tabbed widgets! - - @param caption: (C++: const char *) title of tab, or window title if widget is not tabbed - @return: pointer to the TWidget, nullptr if none is found - -ida_kernwin.formchgcbfa_close (function) - formchgcbfa_close(p_fa, close_normally) - - @param p_fa: size_t - @param close_normally: int - -ida_kernwin.formchgcbfa_enable_field (function) - formchgcbfa_enable_field(p_fa, fid, enable) -> bool - - @param p_fa: size_t - @param fid: int - @param enable: bool - -ida_kernwin.formchgcbfa_get_field_value (function) - formchgcbfa_get_field_value(p_fa, fid, ft, sz) -> PyObject * - - @param p_fa: size_t - @param fid: int - @param ft: int - @param sz: size_t - -ida_kernwin.formchgcbfa_get_focused_field (function) - formchgcbfa_get_focused_field(p_fa) -> int - - @param p_fa: size_t - -ida_kernwin.formchgcbfa_move_field (function) - formchgcbfa_move_field(p_fa, fid, x, y, w, h) -> bool - - @param p_fa: size_t - @param fid: int - @param x: int - @param y: int - @param w: int - @param h: int - -ida_kernwin.formchgcbfa_refresh_field (function) - formchgcbfa_refresh_field(p_fa, fid) - - @param p_fa: size_t - @param fid: int - -ida_kernwin.formchgcbfa_set_field_value (function) - formchgcbfa_set_field_value(p_fa, fid, ft, py_val) -> bool - - @param p_fa: size_t - @param fid: int - @param ft: int - @param py_val: PyObject * - -ida_kernwin.formchgcbfa_set_focused_field (function) - formchgcbfa_set_focused_field(p_fa, fid) -> bool - - @param p_fa: size_t - @param fid: int - -ida_kernwin.formchgcbfa_show_field (function) - formchgcbfa_show_field(p_fa, fid, show) -> bool - - @param p_fa: size_t - @param fid: int - @param show: bool - -ida_kernwin.free_custom_icon (function) - free_custom_icon(icon_id) - Frees an icon loaded with load_custom_icon() - - @param icon_id: int - -ida_kernwin.gen_disasm_text (function) - gen_disasm_text(text, ea1, ea2, truncate_lines) - Generate disassembly text for a range. - - @param text: (C++: text_t &) result - @param ea1: (C++: ea_t) start address - @param ea2: (C++: ea_t) end address - @param truncate_lines: (C++: bool) (on idainfo::margin) - -ida_kernwin.get_action_checkable (function) - get_action_checkable(name) -> bool - Get an action's checkability (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_action_checked (function) - get_action_checked(name) -> bool - Get an action's checked state (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_action_icon (function) - get_action_icon(name) -> bool - Get an action's icon (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_action_label (function) - get_action_label(name) -> str - Get an action's label (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_action_shortcut (function) - get_action_shortcut(name) -> str - Get an action's shortcut (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_action_state (function) - get_action_state(name) -> bool - Get an action's state (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_action_tooltip (function) - get_action_tooltip(name) -> str - Get an action's tooltip (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_action_visibility (function) - get_action_visibility(name) -> bool - Get an action's visibility (ui_get_action_attr). - - @param name: (C++: const char *) the action name - @return: success - -ida_kernwin.get_active_modal_widget (function) - get_active_modal_widget() -> TWidget * - Get the current, active modal TWidget instance. Note that in this context, the - "wait dialog" is not considered: this function will return nullptr even if it is - currently shown. - - @return: TWidget * the active modal widget, or nullptr - -ida_kernwin.get_addon_info (function) - get_addon_info(id, info) -> bool - Get info about a registered addon with a given product code. info->cb must be - valid! NB: all pointers are invalidated by next call to register_addon or - get_addon_info - - @param id: (C++: const char *) char const * - @param info: (C++: addon_info_t *) - @return: false if not found - -ida_kernwin.get_addon_info_idx (function) - get_addon_info_idx(index, info) -> bool - Get info about a registered addon with specific index. info->cb must be valid! - NB: all pointers are invalidated by next call to register_addon or - get_addon_info - - @param index: (C++: int) - @param info: (C++: addon_info_t *) - @return: false if index is out of range - -ida_kernwin.get_chooser_data (function) - get_chooser_data(chooser_caption, n) -> [str, ...] - Get the text corresponding to the index N in the chooser data. Use -1 to get the - header. - - See also get_chooser_rows(). - - @param chooser_caption: (C++: const char *) char const * - @param n: (C++: int) - -ida_kernwin.get_chooser_obj (function) - get_chooser_obj(chooser_caption) -> void * - Get the underlying object of the specified chooser (ui_get_chooser_obj). - - This attemps to find the choser by its title and, if found, returns the result - of calling its chooser_base_t::get_chooser_obj() method. - - @note: This is object is chooser-specific. - - @param chooser_caption: (C++: const char *) char const * - @return: the object that was used to create the chooser - -ida_kernwin.get_chooser_rows (function) - get_chooser_rows(out, chooser_caption, what) -> bool - Get the chooser contents corresponding to the rows indicated by "what". - - @param out: (C++: chooser_row_info_vec_t *) A vector of chooser_row_info_t, one entry per returned row. - @param chooser_caption: (C++: const char *) The caption that identifies the desired chooser. - @param what: (C++: size_t) Either one of the GCRF_ flags, or a row index. - @return: Success. - -ida_kernwin.get_curline (function) - get_curline() -> char const * - Get current line from the disassemble window (ui_get_curline). - - @return: cptr current line with the color codes (use tag_remove() to remove the - color codes) - -ida_kernwin.get_current_viewer (function) - get_current_viewer() -> TWidget * - Get current ida viewer (idaview or custom viewer) (ui_get_current_viewer) - -ida_kernwin.get_current_widget (function) - get_current_widget() -> TWidget * - Get a pointer to the current widget (ui_get_current_widget). - -ida_kernwin.get_cursor (function) - get_cursor() -> bool - Get the cursor position on the screen (ui_get_cursor). - @note: coordinates are 0-based - - @retval true: pointers are filled - @retval false: no disassembly window open - -ida_kernwin.get_custom_viewer_curline (function) - get_custom_viewer_curline(custom_viewer, mouse) -> char const * - Get current line of custom viewer (ui_get_custom_viewer_curline). The returned - line contains color codes - - See also the more powerful get_custom_viewer_location() - - @param custom_viewer: (C++: TWidget *) view - @param mouse: (C++: bool) mouse position (otherwise cursor position) - @return: pointer to contents of current line - -ida_kernwin.get_custom_viewer_location (function) - get_custom_viewer_location(out, custom_viewer, mouse=False) -> bool - Get the current location in a custom viewer (ui_get_custom_viewer_location_2). - - @param out: (C++: listing_location_t *) output structure to fill - @param custom_viewer: (C++: TWidget *) the listing widget - @param flags: (C++: uint32) or'ed combination of CVLF_* values - get_custom_viewer_location(out, custom_viewer, flags=0) -> bool - - @param out: listing_location_t * - @param custom_viewer: TWidget * - @param flags: uint32 - -ida_kernwin.get_custom_viewer_place (function) - get_custom_viewer_place(custom_viewer, mouse) -> place_t - Get current place in a custom viewer (ui_get_curplace). - - See also the more complete get_custom_viewer_location() - - @param custom_viewer: (C++: TWidget *) view - @param mouse: (C++: bool) mouse position (otherwise cursor position) - -ida_kernwin.get_custom_viewer_place_xcoord (function) - get_custom_viewer_place_xcoord(custom_viewer, pline, pitem) -> int - Get the X position of the item, in the line - - @param custom_viewer: (C++: TWidget *) the widget - @param pline: (C++: const place_t *) a place corresponding to the line - @param pitem: (C++: const place_t *) a place corresponding to the item - @return: -1 if 'pitem' is not included in the line - -2 if 'pitem' points at the entire line - >= 0 for the X coordinate within the pline, where pitem points - -ida_kernwin.get_ea_viewer_history_info (function) - get_ea_viewer_history_info(nback, nfwd, v) -> bool - Get information about what's in the history (ui_ea_viewer_history_info). - - @param nback: (C++: int *) number of available back steps - @param nfwd: (C++: int *) number of available forward steps - @param v: (C++: TWidget *) ea viewer - @retval false: if the given ea viewer does not exist - @retval true: otherwise - -ida_kernwin.get_hexdump_ea (function) - get_hexdump_ea(hexdump_num) -> ea_t - Get the current address in a hex view. - - @param hexdump_num: (C++: int) number of hexview window - -ida_kernwin.get_highlight (function) - get_highlight(v, in_flags=0) -> (str, int) or None - Returns the currently highlighted identifier and flags - - @param v: The UI widget to operate on - @param flags: Optionally specify a slot (see kernwin.hpp), current otherwise - @return: a tuple (text, flags), or None if nothing - is highlighted or in case of error. - -ida_kernwin.get_icon_id_by_name (function) - get_icon_id_by_name(icon_name) -> int - Retrieve the id of the icon by name (ui_get_icon_id_by_name). - - @param icon_name: (C++: const char *) full name of the icon - @return: icon id - -ida_kernwin.get_kernel_version (function) - get_kernel_version() -> str - Get IDA kernel version (in a string like "5.1"). - -ida_kernwin.get_key_code (function) - get_key_code(keyname) -> ushort - Get keyboard key code by its name (ui_get_key_code) - - @param keyname: (C++: const char *) char const * - -ida_kernwin.get_navband_ea (function) - get_navband_ea(pixel) -> ea_t - Translate the pixel position on the navigation band, into an address. - - @param pixel: (C++: int) - -ida_kernwin.get_navband_pixel (function) - get_navband_pixel(ea) -> int - Maps an address, onto a pixel coordinate within the navigation band - - @param ea: The address to map - @return: a list [pixel, is_vertical] - -ida_kernwin.get_opnum (function) - get_opnum() -> int - Get current operand number, -1 means no operand (ui_get_opnum) - -ida_kernwin.get_output_curline (function) - get_output_curline(mouse) -> str - Get current line of output window (ui_get_output_curline). - - @param mouse: (C++: bool) current for mouse pointer? - @return: false if output contains no text - -ida_kernwin.get_output_cursor (function) - get_output_cursor() -> bool - Get coordinates of the output window's cursor (ui_get_output_cursor). - @note: coordinates are 0-based - @note: this function will succeed even if the output window is not visible - - @retval false: the output window has been destroyed. - @retval true: pointers are filled - -ida_kernwin.get_output_selected_text (function) - get_output_selected_text() -> str - Returns selected text from output window (ui_get_output_selected_text). - - @return: true if there is a selection - -ida_kernwin.get_place_class (function) - get_place_class(out_flags, out_sdk_version, id) -> place_t - Get information about a previously-registered place_t class. See also - register_place_class(). - - @param out_flags: (C++: int *) output flags (can be nullptr) - @param out_sdk_version: (C++: int *) sdk version the place was created with (can be nullptr) - @param id: (C++: int) place class ID - @return: the place_t template, or nullptr if not found - -ida_kernwin.get_place_class_id (function) - get_place_class_id(name) -> int - Get the place class ID for the place that has been registered as 'name'. - - @param name: (C++: const char *) the class name - @return: the place class ID, or -1 if not found - -ida_kernwin.get_place_class_template (function) - get_place_class_template(id) -> place_t - See get_place_class() - - @param id: (C++: int) - -ida_kernwin.get_registered_actions (function) - get_registered_actions() -> [str, ...] - Get a list of all currently-registered actions - -ida_kernwin.get_screen_ea (function) - get_screen_ea() -> ea_t - Get the address at the screen cursor (ui_screenea) - -ida_kernwin.get_synced_group (function) - get_synced_group(w) -> synced_group_t - Get the group of widgets/registers this view is synchronized with - - @param w: (C++: const TWidget *) the widget - @return: the group of widgets/registers, or nullptr - -ida_kernwin.get_tab_size (function) - get_tab_size(path) -> int - Get the size of a tab in spaces (ui_get_tab_size). - - @param path: (C++: const char *) the path of the source view for which the tab size is requested. - * if nullptr, the default size is returned. - -ida_kernwin.get_user_input_event (function) - get_user_input_event(out) -> bool - Get the current user input event (mouse button press, key press, ...) It is - sometimes desirable to be able to tell when a certain situation happens (e.g., - 'view_curpos' gets triggered); this function exists to provide that context (GUI - version only) - - @param out: (C++: input_event_t *) the input event data - @return: false if we are not currently processing a user input event - -ida_kernwin.get_user_strlist_options (function) - get_user_strlist_options(out) - - @param out: strwinsetup_t * - -ida_kernwin.get_view_renderer_type (function) - get_view_renderer_type(v) -> tcc_renderer_type_t - Get the type of renderer currently in use in the given view - (ui_get_renderer_type) - - @param v: (C++: TWidget *) - -ida_kernwin.get_viewer_place_type (function) - get_viewer_place_type(viewer) -> tcc_place_type_t - Get the type of place_t instances a viewer uses & creates - (ui_get_viewer_place_type). - - @param viewer: (C++: TWidget *) - -ida_kernwin.get_viewer_user_data (function) - get_viewer_user_data(viewer) -> void * - Get the user data from a custom viewer (ui_get_viewer_user_data) - - @param viewer: (C++: TWidget *) - -ida_kernwin.get_widget_title (function) - get_widget_title(widget) -> str - Get the TWidget's title (ui_get_widget_title). - - @param widget: (C++: TWidget *) - -ida_kernwin.get_widget_type (function) - get_widget_type(widget) -> twidget_type_t - Get the type of the TWidget * (ui_get_widget_type). - - @param widget: (C++: TWidget *) - -ida_kernwin.get_window_id (function) - get_window_id(name=None) -> void * - Get the system-specific window ID (GUI version only) - - @param name: (C++: const char *) name of the window (nullptr means the main IDA window) - @return: the low-level window ID - -ida_kernwin.hide_wait_box (function) - hide_wait_box() - Hide the "Please wait dialog box". - -ida_kernwin.idaplace_t (class) - Proxy of C++ idaplace_t class. - -ida_kernwin.idaplace_t.__init__ (method) - -ida_kernwin.idaplace_t.ea (variable) - address - -ida_kernwin.info (function) - info(format) - - @param format: char const * - -ida_kernwin.input_event_keyboard_data_t (class) - Proxy of C++ input_event_t::input_event_keyboard_data_t class. - -ida_kernwin.input_event_keyboard_data_t.__init__ (method) - __init__(self) -> input_event_keyboard_data_t - -ida_kernwin.input_event_mouse_data_t (class) - Proxy of C++ input_event_t::input_event_mouse_data_t class. - -ida_kernwin.input_event_mouse_data_t.__init__ (method) - __init__(self) -> input_event_mouse_data_t - -ida_kernwin.input_event_shortcut_data_t (class) - Proxy of C++ input_event_t::input_event_shortcut_data_t class. - -ida_kernwin.input_event_shortcut_data_t.__init__ (method) - __init__(self) -> input_event_shortcut_data_t - -ida_kernwin.input_event_t (class) - Proxy of C++ input_event_t class. - -ida_kernwin.input_event_t.__init__ (method) - __init__(self) -> input_event_t - -ida_kernwin.input_event_t._source_as_size (method) - _source_as_size(self) -> size_t - -ida_kernwin.input_event_t._target_as_size (method) - _target_as_size(self) -> size_t - -ida_kernwin.input_event_t.cb (variable) - size marker - -ida_kernwin.input_event_t.get_source_QEvent (method) - -ida_kernwin.input_event_t.get_target_QWidget (method) - -ida_kernwin.input_event_t.kind (variable) - the kind of event - -ida_kernwin.input_event_t.modifiers (variable) - current keyboard (and mouse) modifiers - -ida_kernwin.input_event_t.source (variable) - the source event, should it be required for detailed inform (e.g., a QEvent in - the GUI version of IDA) - -ida_kernwin.input_event_t.target (variable) - the target widget - -ida_kernwin.install_command_interpreter (function) - install_command_interpreter(py_obj) -> int - Install command line interpreter (ui_install_cli) - - @param py_obj: PyObject * - -ida_kernwin.internal_register_place_class (function) - internal_register_place_class(tmplate, flags, owner, sdk_version) -> int - - @param tmplate: place_t const * - @param flags: int - @param owner: plugin_t const * - @param sdk_version: int - -ida_kernwin.is_action_enabled (function) - is_action_enabled(s) -> bool - Check if the given action state is one of AST_ENABLE*. - - @param s: (C++: action_state_t) enum action_state_t - -ida_kernwin.is_chooser_widget (function) - is_chooser_widget(t) -> bool - Does the given widget type specify a chooser widget? - - @param t: (C++: twidget_type_t) - -ida_kernwin.is_idaq (function) - is_idaq() -> bool - Returns True or False depending if IDAPython is hosted by IDAQ - -ida_kernwin.is_idaview (function) - is_idaview(v) -> bool - Is the given custom view an idaview? (ui_is_idaview) - - @param v: (C++: TWidget *) - -ida_kernwin.is_msg_inited (function) - is_msg_inited() -> bool - Can we use msg() functions? - -ida_kernwin.is_place_class_ea_capable (function) - is_place_class_ea_capable(id) -> bool - See get_place_class() - - @param id: (C++: int) - -ida_kernwin.is_refresh_requested (function) - is_refresh_requested(mask) -> bool - Get a refresh request state - - @param mask: (C++: uint64) Window refresh flags - @return: the state (set or cleared) - -ida_kernwin.is_tif_cursor_footer (function) - is_tif_cursor_footer(c) -> bool - - @param c: tif_cursor_t - -ida_kernwin.is_tif_cursor_header (function) - is_tif_cursor_header(c) -> bool - - @param c: tif_cursor_t - -ida_kernwin.is_tif_cursor_index (function) - is_tif_cursor_index(c) -> bool - - @param c: tif_cursor_t - -ida_kernwin.jobj_wrapper_t (class) - Proxy of C++ jobj_wrapper_t class. - -ida_kernwin.jobj_wrapper_t.__init__ (method) - -ida_kernwin.jobj_wrapper_t.get_dict (method) - get_dict(self) -> dict - -ida_kernwin.jumpto (function) - jumpto(ea, opnum=-1, uijmp_flags=0x0001) -> bool - Set cursor position in custom ida viewer. - - @param custom_viewer: (C++: TWidget *) view - @param place: (C++: place_t *) target position - @param uijmp_flags: int - - @return: success - jumpto(custom_viewer, place, x, y) -> bool - - @param custom_viewer: TWidget * - @param place: place_t * - @param x: int - -ida_kernwin.l_compare2 (function) - l_compare2(t1, t2, ud) -> int - - @param t1: place_t const * - @param t2: place_t const * - @param ud: void * - -ida_kernwin.line_rendering_output_entries_refs_t (class) - Proxy of C++ qvector< line_rendering_output_entry_t * > class. - -ida_kernwin.line_rendering_output_entries_refs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< line_rendering_output_entry_t * > const & - -ida_kernwin.line_rendering_output_entries_refs_t.__getitem__ (method) - __getitem__(self, i) -> line_rendering_output_entry_t - - @param i: size_t - -ida_kernwin.line_rendering_output_entries_refs_t.__init__ (method) - __init__(self) -> line_rendering_output_entries_refs_t - __init__(self, x) -> line_rendering_output_entries_refs_t - - @param x: qvector< line_rendering_output_entry_t * > const & - -ida_kernwin.line_rendering_output_entries_refs_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.line_rendering_output_entries_refs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< line_rendering_output_entry_t * > const & - -ida_kernwin.line_rendering_output_entries_refs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: line_rendering_output_entry_t *const & - -ida_kernwin.line_rendering_output_entries_refs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: line_rendering_output_entry_t *const & - -ida_kernwin.line_rendering_output_entries_refs_t._internal_push_back (method) - _internal_push_back(self, e) - - Parameters - ---------- - e: line_rendering_output_entry_t * - -ida_kernwin.line_rendering_output_entries_refs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: line_rendering_output_entry_t *const & - -ida_kernwin.line_rendering_output_entries_refs_t.at (method) - at(self, _idx) -> line_rendering_output_entry_t - - @param _idx: size_t - -ida_kernwin.line_rendering_output_entries_refs_t.begin (method) - begin(self) -> qvector< line_rendering_output_entry_t * >::iterator - begin(self) -> qvector< line_rendering_output_entry_t * >::const_iterator - -ida_kernwin.line_rendering_output_entries_refs_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.line_rendering_output_entries_refs_t.clear (method) - clear(self) - -ida_kernwin.line_rendering_output_entries_refs_t.empty (method) - empty(self) -> bool - -ida_kernwin.line_rendering_output_entries_refs_t.end (method) - end(self) -> qvector< line_rendering_output_entry_t * >::iterator - end(self) -> qvector< line_rendering_output_entry_t * >::const_iterator - -ida_kernwin.line_rendering_output_entries_refs_t.erase (method) - erase(self, it) -> qvector< line_rendering_output_entry_t * >::iterator - - @param it: qvector< line_rendering_output_entry_t * >::iterator - - erase(self, first, last) -> qvector< line_rendering_output_entry_t * >::iterator - - @param first: qvector< line_rendering_output_entry_t * >::iterator - @param last: qvector< line_rendering_output_entry_t * >::iterator - -ida_kernwin.line_rendering_output_entries_refs_t.extract (method) - extract(self) -> line_rendering_output_entry_t ** - -ida_kernwin.line_rendering_output_entries_refs_t.find (method) - find(self, x) -> qvector< line_rendering_output_entry_t * >::iterator - - @param x: line_rendering_output_entry_t *const & - - find(self, x) -> qvector< line_rendering_output_entry_t * >::const_iterator - - @param x: line_rendering_output_entry_t *const & - -ida_kernwin.line_rendering_output_entries_refs_t.has (method) - has(self, x) -> bool - - @param x: line_rendering_output_entry_t *const & - -ida_kernwin.line_rendering_output_entries_refs_t.inject (method) - inject(self, s, len) - - @param s: line_rendering_output_entry_t ** - @param len: size_t - -ida_kernwin.line_rendering_output_entries_refs_t.insert (method) - insert(self, it, x) -> qvector< line_rendering_output_entry_t * >::iterator - - @param it: qvector< line_rendering_output_entry_t * >::iterator - @param x: line_rendering_output_entry_t *const & - -ida_kernwin.line_rendering_output_entries_refs_t.pop_back (method) - pop_back(self) - -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) - push_back(self, x) - - @param x: line_rendering_output_entry_t *const & - - push_back(self) -> line_rendering_output_entry_t *& - -ida_kernwin.line_rendering_output_entries_refs_t.push_back (method) - -ida_kernwin.line_rendering_output_entries_refs_t.qclear (method) - qclear(self) - -ida_kernwin.line_rendering_output_entries_refs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.line_rendering_output_entries_refs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: line_rendering_output_entry_t *const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_kernwin.line_rendering_output_entries_refs_t.size (method) - size(self) -> size_t - -ida_kernwin.line_rendering_output_entries_refs_t.swap (method) - swap(self, r) - - @param r: qvector< line_rendering_output_entry_t * > & - -ida_kernwin.line_rendering_output_entries_refs_t.truncate (method) - truncate(self) - -ida_kernwin.line_rendering_output_entry_t (class) - Proxy of C++ line_rendering_output_entry_t class. - -ida_kernwin.line_rendering_output_entry_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: line_rendering_output_entry_t const & - -ida_kernwin.line_rendering_output_entry_t.__init__ (method) - __init__(self, _line, _flags=0, _bg_color=0) -> line_rendering_output_entry_t - - @param _line: twinline_t const * - @param _flags: uint32 - @param _bg_color: bgcolor_t - - __init__(self, _line, _cpx, _nchars, _flags, _bg_color) -> line_rendering_output_entry_t - - @param _line: twinline_t const * - @param _cpx: int - @param _nchars: int - @param _flags: uint32 - @param _bg_color: bgcolor_t - -ida_kernwin.line_rendering_output_entry_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: line_rendering_output_entry_t const & - -ida_kernwin.line_rendering_output_entry_t.cpx (variable) - number of char to start from, valid if LROEF_CPS_RANGE - -ida_kernwin.line_rendering_output_entry_t.flags (variable) - line_rendering_output_entry_t flags - -ida_kernwin.line_rendering_output_entry_t.is_bg_color_direct (method) - is_bg_color_direct(self) -> bool - -ida_kernwin.line_rendering_output_entry_t.is_bg_color_empty (method) - is_bg_color_empty(self) -> bool - -ida_kernwin.line_rendering_output_entry_t.is_bg_color_key (method) - is_bg_color_key(self) -> bool - -ida_kernwin.line_rendering_output_entry_t.nchars (variable) - chars count, valid if LROEF_CPS_RANGE - -ida_kernwin.line_section_t (class) - Proxy of C++ line_section_t class. - -ida_kernwin.line_section_t.__init__ (method) - __init__(self) -> line_section_t - -ida_kernwin.line_section_t.contains (method) - contains(self, x) -> bool - - @param x: cpidx_t - -ida_kernwin.line_section_t.is_closed (method) - is_closed(self) -> bool - -ida_kernwin.line_section_t.is_open (method) - is_open(self) -> bool - -ida_kernwin.line_section_t.valid (method) - valid(self) -> bool - -ida_kernwin.linearray_t (class) - Proxy of C++ linearray_t class. - -ida_kernwin.linearray_t.__init__ (method) - __init__(self, _ud) -> linearray_t - - @param _ud: void * - -ida_kernwin.linearray_t.beginning (method) - beginning(self) -> bool - Are we at the beginning? - -ida_kernwin.linearray_t.down (method) - down(self) -> qstring const * - Get a line from down direction. place is ok BEFORE - -ida_kernwin.linearray_t.ending (method) - ending(self) -> bool - -ida_kernwin.linearray_t.get_bg_color (method) - get_bg_color(self) -> bgcolor_t - Get current background color. (the same behavior as with get_place(): good - before down() and after up()) - -ida_kernwin.linearray_t.get_dlnnum (method) - get_dlnnum(self) -> int - Get default line number. (the same behavior as with get_place(): good before - down() and after up()) - -ida_kernwin.linearray_t.get_linecnt (method) - get_linecnt(self) -> int - Get number of lines for the current place. (the same behavior as with - get_place(): good before down() and after up()) - -ida_kernwin.linearray_t.get_pfx_color (method) - get_pfx_color(self) -> bgcolor_t - Get current prefix color. (the same behavior as with get_place(): good before - down() and after up()) - -ida_kernwin.linearray_t.get_place (method) - get_place(self) -> place_t - Get the current place. If called before down(), then returns place of line which - will be returned by down(). If called after up(), then returns place if line - returned by up(). - -ida_kernwin.linearray_t.set_place (method) - set_place(self, new_at) -> int - Position the array. This function must be called before calling any other member - functions. - - linearray_t doesn't own place_t structures. The caller must take care of place_t - objects. - - @param new_at: (C++: const place_t *) new position of the array - @return: the delta of lines that the linearray_t had to adjust the place by. - For example, if the place_t has a lnnum of 5, but it turns out, upon generating - lines, - that the number of lines for that particular place is only 2, then 3 will be - returned. - -ida_kernwin.linearray_t.set_userdata (method) - set_userdata(self, userd) - Change the user data. - - @param userd: (C++: void *) - -ida_kernwin.linearray_t.up (method) - up(self) -> qstring const * - Get a line from up direction. place is ok AFTER - -ida_kernwin.linearray_t.userdata (method) - userdata(self) -> void * - Get pointer to user data. - -ida_kernwin.lines_rendering_input_t (class) - Proxy of C++ lines_rendering_input_t class. - -ida_kernwin.lines_rendering_input_t.__init__ (method) - __init__(self) -> lines_rendering_input_t - -ida_kernwin.lines_rendering_input_t.sections_lines (variable) - references to the lines that are used for rendering - -ida_kernwin.lines_rendering_input_t.sync_group (variable) - the 'synced' group 'widget' (see ui_get_lines_rendering_info) belongs to, or - nullptr - -ida_kernwin.lines_rendering_output_t (class) - Proxy of C++ lines_rendering_output_t class. - -ida_kernwin.lines_rendering_output_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: lines_rendering_output_t const & - -ida_kernwin.lines_rendering_output_t.__init__ (method) - __init__(self) -> lines_rendering_output_t - -ida_kernwin.lines_rendering_output_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: lines_rendering_output_t const & - -ida_kernwin.lines_rendering_output_t.clear (method) - clear(self) - -ida_kernwin.lines_rendering_output_t.swap (method) - swap(self, r) - - @param r: lines_rendering_output_t & - -ida_kernwin.listing_location_t (class) - Proxy of C++ listing_location_t class. - -ida_kernwin.listing_location_t.__init__ (method) - __init__(self) -> listing_location_t - -ida_kernwin.load_custom_icon (function) - Loads a custom icon and returns an identifier that can be used with other APIs - - If file_name is passed then the other two arguments are ignored. - - Load an icon and return its id (ui_load_custom_icon). - - @return: icon id - -ida_kernwin.load_dbg_dbginfo (function) - load_dbg_dbginfo(path, li=None, base=BADADDR, verbose=False) -> bool - Load debugging information from a file. - - @param path: (C++: const char *) path to file - @param li: (C++: linput_t *) loader input. if nullptr, check DBG_NAME_KEY - @param base: (C++: ea_t) loading address - @param verbose: (C++: bool) dump status to message window - -ida_kernwin.lookup_key_code (function) - lookup_key_code(key, shift, is_qt) -> ushort - Get shortcut code previously created by ui_get_key_code. - - @param key: (C++: int) key constant - @param shift: (C++: int) modifiers - @param is_qt: (C++: bool) are we using gui version? - -ida_kernwin.mbox_internal (variable) - internal error - -ida_kernwin.msg (function) - msg(o) -> int - 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 message: message to print (formatting is done in Python) - - This function can be used to debug IDAPython scripts - -ida_kernwin.msg_activated (variable) - The message window is activated. - -ida_kernwin.msg_clear (function) - msg_clear() - Clear the "Output" window. - -ida_kernwin.msg_click (variable) - Click event. - - @retval 1: handled - @retval 0: not handled (invoke default handler) - -ida_kernwin.msg_closed (variable) - View closed. - -ida_kernwin.msg_dblclick (variable) - Double click event. - - @retval 1: handled - @retval 0: not handled (invoke default handler) - -ida_kernwin.msg_deactivated (variable) - The message window is deactivated. - -ida_kernwin.msg_get_lines (function) - msg_get_lines(count=-1) -> [str, ...] - Retrieve the last 'count' lines from the output window, in reverse order (from - most recent, to least recent) - - @param count: (C++: int) The number of lines to retrieve. -1 means: all - -ida_kernwin.msg_keydown (variable) - Key down event. - - @retval 1: handled - @retval 0: not handled (invoke default handler) - -ida_kernwin.msg_save (function) - msg_save(path) -> bool - Save the "Output" window contents into a file - - @param path: (C++: qstring &) The path of the file to save the contents into. An empty path means - that the user will be prompted for the destination and, if the file - already exists, the user will be asked to confirm before overriding - its contents. Upon return, 'path' will contain the path that the - user chose. - @return: success - -ida_kernwin.nomem (function) - nomem(format) - - @param format: char const * - -ida_kernwin.open_bookmarks_window (function) - open_bookmarks_window(w) -> TWidget * - Open the bookmarks window (ui_open_builtin). - - @param w: (C++: TWidget *) The widget for which the bookmarks will open. For example, this can be - an IDAView, or Enums view, etc. - @return: pointer to resulting window - -ida_kernwin.open_bpts_window (function) - open_bpts_window(ea) -> TWidget * - Open the breakpoints window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_calls_window (function) - open_calls_window(ea) -> TWidget * - Open the function calls window (ui_open_builtin). - - @param ea: (C++: ea_t) - @return: pointer to resulting window - -ida_kernwin.open_disasm_window (function) - open_disasm_window(window_title, ranges=None) -> TWidget * - Open a disassembly view (ui_open_builtin). - - @param window_title: (C++: const char *) title of view to open - @param ranges: (C++: const rangevec_t *) if != nullptr, then display a flow chart with the specified - ranges - @return: pointer to resulting window - -ida_kernwin.open_enums_window (function) - open_enums_window(const_id=BADADDR) -> TWidget * - Open the enums window (ui_open_builtin). - - @param const_id: (C++: tid_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_exports_window (function) - open_exports_window(ea) -> TWidget * - Open the exports window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_form (function) - Display a dockable modeless dialog box and return a handle to it. The modeless - form can be closed in the following ways: - * by pressing the small 'x' in the window title - * by calling form_actions_t::close() from the form callback (form_actions_t) - @note: pressing the 'Yes/No/Cancel' buttons does not close the modeless form, - except if the form callback explicitly calls close(). - - @return: handle to the form or nullptr. the handle can be used with TWidget - -ida_kernwin.open_frame_window (function) - open_frame_window(pfn, offset) -> TWidget * - Open the frame window for the given function (ui_open_builtin). - - @param pfn: (C++: func_t *) function to analyze - @param offset: (C++: uval_t) offset where the cursor is placed - @return: pointer to resulting window if 'pfn' is a valid function and the window - was displayed, - nullptr otherwise - -ida_kernwin.open_funcs_window (function) - open_funcs_window(ea) -> TWidget * - Open the 'Functions' window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_hexdump_window (function) - open_hexdump_window(window_title) -> TWidget * - Open a hexdump view (ui_open_builtin). - - @param window_title: (C++: const char *) title of view to open - @return: pointer to resulting window - -ida_kernwin.open_imports_window (function) - open_imports_window(ea) -> TWidget * - Open the exports window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_loctypes_window (function) - open_loctypes_window(ordinal, cursor=None) -> TWidget * - Open the local types window (ui_open_builtin). - - @param ordinal: (C++: int) ordinal of type to select by default - @param cursor: (C++: const tif_cursor_t *) cursor to the type member - @return: pointer to resulting window - -ida_kernwin.open_modules_window (function) - open_modules_window() -> TWidget * - Open the modules window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_names_window (function) - open_names_window(ea) -> TWidget * - Open the names window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_navband_window (function) - open_navband_window(ea, zoom) -> TWidget * - Open the navigation band window (ui_open_builtin). - - @param ea: (C++: ea_t) sets the address of the navband arrow - @param zoom: (C++: int) sets the navband zoom level - @return: pointer to resulting window - -ida_kernwin.open_notepad_window (function) - open_notepad_window() -> TWidget * - Open the notepad window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_problems_window (function) - open_problems_window(ea) -> TWidget * - Open the problems window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_segments_window (function) - open_segments_window(ea) -> TWidget * - Open the segments window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_segregs_window (function) - open_segregs_window(ea) -> TWidget * - Open the segment registers window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.open_selectors_window (function) - open_selectors_window() -> TWidget * - Open the selectors window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_signatures_window (function) - open_signatures_window() -> TWidget * - Open the signatures window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_stack_window (function) - open_stack_window() -> TWidget * - Open the call stack window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_strings_window (function) - open_strings_window(ea, selstart=BADADDR, selend=BADADDR) -> TWidget * - Open the 'Strings' window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @param selstart: (C++: ea_t) ,selend: only display strings that occur within this range - @param selend: (C++: ea_t) - @return: pointer to resulting window - -ida_kernwin.open_structs_window (function) - open_structs_window(id=BADADDR, offset=0) -> TWidget * - Open the structs window (ui_open_builtin). - - @param id: (C++: tid_t) index of entry to select by default - @param offset: (C++: uval_t) offset where the cursor is placed - @return: pointer to resulting window - -ida_kernwin.open_threads_window (function) - open_threads_window() -> TWidget * - Open the threads window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_tils_window (function) - open_tils_window() -> TWidget * - Open the type libraries window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_trace_window (function) - open_trace_window() -> TWidget * - Open the tracing window (ui_open_builtin). - - @return: pointer to resulting window - -ida_kernwin.open_url (function) - open_url(url) - Open the given url (ui_open_url) - - @param url: (C++: const char *) char const * - -ida_kernwin.open_xrefs_window (function) - open_xrefs_window(ea) -> TWidget * - Open the cross references window (ui_open_builtin). - - @param ea: (C++: ea_t) index of entry to select by default - @return: pointer to resulting window - -ida_kernwin.place_t (class) - Proxy of C++ place_t class. - -ida_kernwin.place_t.__init__ (method) - -ida_kernwin.place_t._print (method) - _print(self, ud) - - Parameters - ---------- - ud: void * - -ida_kernwin.place_t.adjust (method) - adjust(self, ud) - Adjust the current location to point to a displayable object. This function - validates the location and makes sure that it points to an existing object. For - example, if the location points to the middle of an instruction, it will be - adjusted to point to the beginning of the instruction. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - -ida_kernwin.place_t.as_enumplace_t (method) - as_enumplace_t(p) -> enumplace_t - - @param p: place_t * - -ida_kernwin.place_t.as_idaplace_t (method) - as_idaplace_t(p) -> idaplace_t - - @param p: place_t * - -ida_kernwin.place_t.as_simpleline_place_t (method) - as_simpleline_place_t(p) -> simpleline_place_t - - @param p: place_t * - -ida_kernwin.place_t.as_structplace_t (method) - as_structplace_t(p) -> structplace_t - - @param p: place_t * - -ida_kernwin.place_t.as_tiplace_t (method) - as_tiplace_t(p) -> tiplace_t - - @param p: place_t * - -ida_kernwin.place_t.beginning (method) - beginning(self, ud) -> bool - Are we at the first displayable object?. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: true if the current location points to the first displayable object - -ida_kernwin.place_t.clone (method) - clone(self) -> place_t - Clone the location. - - @return: a pointer to a copy of the current location in dynamic memory - -ida_kernwin.place_t.compare (method) - compare(self, t2) -> int - Deprecated. Please consider compare2(const place_t *, void *) instead. - - @param t2: (C++: const place_t *) place_t const * - -ida_kernwin.place_t.compare2 (method) - compare2(self, t2, arg3) -> int - Compare two locations except line numbers (lnnum). This function is used to - organize loops. For example, if the user has selected an range, its boundaries - are remembered as location objects. Any operation within the selection will have - the following look: for ( loc=starting_location; loc < ending_location; - loc.next() ) In this loop, the comparison function is used. - - @param t2: (C++: const place_t *) the place to compare this one to. - @param arg3: void * - -ida_kernwin.place_t.copyfrom (method) - copyfrom(self, _from) - Copy the specified location object to the current object. - - @param from: (C++: const place_t *) place_t const * - -ida_kernwin.place_t.deserialize (method) - deserialize(self, _in) -> bool - De-serialize into this instance. 'pptr' should be incremented by as many bytes - as de-serialization consumed. - - @param pptr: (C++: const uchar **) pointer to a serialized representation of a place_t of this type. - @return: whether de-serialization was successful - -ida_kernwin.place_t.ending (method) - ending(self, ud) -> bool - Are we at the last displayable object?. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: true if the current location points to the last displayable object - -ida_kernwin.place_t.enter (method) - enter(self, arg2) -> place_t - Visit this place, possibly 'unhiding' a section of text. If entering that place - required some expanding, a place_t should be returned that represents that - section, plus some flags for later use by 'leave()'. - - @param out_flags: flags to be used together with the place_t that is returned, - in order to restore the section to its original state when - leave() is called. - @return: a place_t corresponding to the beginning of the section of text that - had to be expanded. That place_t's leave() will be called with the - flags contained in 'out_flags' when the user navigates away from it. - -ida_kernwin.place_t.generate (method) - generate(self, ud, maxsize) -> ([str, ...], int, int, int) - Generate text lines for the current location. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @param maxsize: (C++: int) the maximum number of lines to generate - @return: number of generated lines - -ida_kernwin.place_t.id (method) - id(self) -> int - Get the place's ID (i.e., the value returned by register_place_class()) - - @return: the id - -ida_kernwin.place_t.leave (method) - leave(self, arg2) - Leave this place, possibly 'hiding' a section of text that was previously - expanded (at enter()-time.) - - @param arg2: uint32 - -ida_kernwin.place_t.lnnum (variable) - Number of line within the current object. - -ida_kernwin.place_t.makeplace (method) - makeplace(self, ud, x, lnnum) -> place_t - Map a number to a location. When the user clicks on the scrollbar and drags it, - we need to determine the location corresponding to the new scrollbar position. - This function is used to determine it. It builds a location object for the - specified 'x' and returns a pointer to it. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @param x: (C++: uval_t) number to map - @param lnnum: (C++: int) line number to initialize 'lnnum' - @return: a freshly allocated object. See also PCF_MAKEPLACE_ALLOCATES - -ida_kernwin.place_t.name (method) - name(self) -> char const * - Get this place type name. All instances of a given class must return the same - string. - - @return: the place type name. Please try and pick something that is not too - generic, as it might clash w/ other plugins. A good practice is to - prefix the class name with the name of your plugin. E.g., - "myplugin:srcplace_t". - -ida_kernwin.place_t.next (method) - next(self, ud) -> bool - Move to the next displayable location. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: success - -ida_kernwin.place_t.prev (method) - prev(self, ud) -> bool - Move to the previous displayable location. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @return: success - -ida_kernwin.place_t.rebase (method) - rebase(self, arg2) -> bool - Rebase the place instance - - @param arg2: segm_move_infos_t const & - @return: true if place was rebased, false otherwise - -ida_kernwin.place_t.serialize (method) - serialize(self) - Serialize this instance. It is fundamental that all instances of a particular - subclass of of place_t occupy the same number of bytes when serialized. - -ida_kernwin.place_t.toea (method) - toea(self) -> ea_t - Map the location to an ea_t. - - @return: the corresponding ea_t, or BADADDR; - -ida_kernwin.place_t.touval (method) - touval(self, ud) -> uval_t - Map the location to a number. This mapping is used to draw the vertical - scrollbar. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - -ida_kernwin.place_t_as_enumplace_t (function) - place_t_as_enumplace_t(p) -> enumplace_t - - @param p: place_t * - -ida_kernwin.place_t_as_idaplace_t (function) - place_t_as_idaplace_t(p) -> idaplace_t - - @param p: place_t * - -ida_kernwin.place_t_as_simpleline_place_t (function) - place_t_as_simpleline_place_t(p) -> simpleline_place_t - - @param p: place_t * - -ida_kernwin.place_t_as_structplace_t (function) - place_t_as_structplace_t(p) -> structplace_t - - @param p: place_t * - -ida_kernwin.place_t_as_tiplace_t (function) - place_t_as_tiplace_t(p) -> tiplace_t - - @param p: place_t * - -ida_kernwin.plgform_close (function) - plgform_close(py_link, options) - - @param py_link: PyObject * - @param options: int - -ida_kernwin.plgform_get_widget (function) - plgform_get_widget(py_link) -> TWidget * - - @param py_link: PyObject * - -ida_kernwin.plgform_new (function) - plgform_new() -> PyObject * - -ida_kernwin.plgform_show (function) - plgform_show(py_link, py_obj, caption, options=(0x0040 << 16)|0x00000004u) -> bool - - @param py_link: PyObject * - @param py_obj: PyObject * - @param caption: char const * - @param options: int - -ida_kernwin.process_ui_action (function) - process_ui_action(name, flags=0) -> bool - Invokes an IDA UI action by name - - @param name: action name - @param flags: int - @return: Boolean - -ida_kernwin.py_chooser_base_t_get_row (function) - py_chooser_base_t_get_row(chobj, n) -> PyObject * - - @param chobj: chooser_base_t const * - @param n: size_t - -ida_kernwin.py_get_ask_form (function) - py_get_ask_form() -> size_t - -ida_kernwin.py_get_open_form (function) - py_get_open_form() -> size_t - -ida_kernwin.py_load_custom_icon_data (function) - py_load_custom_icon_data(data, format) -> int - - @param data: PyObject * - @param format: char const * - -ida_kernwin.py_load_custom_icon_fn (function) - py_load_custom_icon_fn(filename) -> int - - @param filename: char const * - -ida_kernwin.py_register_compiled_form (function) - py_register_compiled_form(py_form) - - @param py_form: PyObject * - -ida_kernwin.py_unregister_compiled_form (function) - py_unregister_compiled_form(py_form) - - @param py_form: PyObject * - -ida_kernwin.pyidag_bind (function) - pyidag_bind(_self) -> bool - - @param self: PyObject * - -ida_kernwin.pyidag_unbind (function) - pyidag_unbind(_self) -> bool - - @param self: PyObject * - -ida_kernwin.pyscv_add_line (function) - pyscv_add_line(py_this, py_sl) -> bool - - @param py_this: PyObject * - @param py_sl: PyObject * - -ida_kernwin.pyscv_clear_lines (function) - pyscv_clear_lines(py_this) -> PyObject * - - @param py_this: PyObject * - -ida_kernwin.pyscv_close (function) - pyscv_close(py_this) - - @param py_this: PyObject * - -ida_kernwin.pyscv_count (function) - pyscv_count(py_this) -> size_t - - @param py_this: PyObject * - -ida_kernwin.pyscv_del_line (function) - pyscv_del_line(py_this, nline) -> bool - - @param py_this: PyObject * - @param nline: size_t - -ida_kernwin.pyscv_edit_line (function) - pyscv_edit_line(py_this, nline, py_sl) -> bool - - @param py_this: PyObject * - @param nline: size_t - @param py_sl: PyObject * - -ida_kernwin.pyscv_get_current_line (function) - pyscv_get_current_line(py_this, mouse, notags) -> PyObject * - - @param py_this: PyObject * - @param mouse: bool - @param notags: bool - -ida_kernwin.pyscv_get_current_word (function) - pyscv_get_current_word(py_this, mouse) -> PyObject * - - @param py_this: PyObject * - @param mouse: bool - -ida_kernwin.pyscv_get_line (function) - pyscv_get_line(py_this, nline) -> PyObject * - - @param py_this: PyObject * - @param nline: size_t - -ida_kernwin.pyscv_get_pos (function) - pyscv_get_pos(py_this, mouse) -> PyObject * - - @param py_this: PyObject * - @param mouse: bool - -ida_kernwin.pyscv_get_selection (function) - pyscv_get_selection(py_this) -> PyObject * - - @param py_this: PyObject * - -ida_kernwin.pyscv_get_widget (function) - pyscv_get_widget(py_this) -> TWidget * - - @param py_this: PyObject * - -ida_kernwin.pyscv_init (function) - pyscv_init(py_link, title) -> PyObject * - - @param py_link: PyObject * - @param title: char const * - -ida_kernwin.pyscv_insert_line (function) - pyscv_insert_line(py_this, nline, py_sl) -> bool - - @param py_this: PyObject * - @param nline: size_t - @param py_sl: PyObject * - -ida_kernwin.pyscv_is_focused (function) - pyscv_is_focused(py_this) -> bool - - @param py_this: PyObject * - -ida_kernwin.pyscv_jumpto (function) - pyscv_jumpto(py_this, ln, x, y) -> bool - - @param py_this: PyObject * - @param ln: size_t - @param x: int - @param y: int - -ida_kernwin.pyscv_patch_line (function) - pyscv_patch_line(py_this, nline, offs, value) -> bool - - @param py_this: PyObject * - @param nline: size_t - @param offs: size_t - @param value: int - -ida_kernwin.pyscv_refresh (function) - pyscv_refresh(py_this) -> bool - - @param py_this: PyObject * - -ida_kernwin.pyscv_show (function) - pyscv_show(py_this) -> bool - - @param py_this: PyObject * - -ida_kernwin.qcleanline (function) - qcleanline(cmt_char='\0', flags=((1 << 0)|(1 << 1))|(1 << 2)) -> str - Performs some cleanup operations to a line. - - @param cmt_char: (C++: char) character that denotes the start of a comment: - * the entire text is removed if the line begins with this character (ignoring - leading spaces) - * all text after (and including) this character is removed if flag CLNL_FINDCMT - is set - @param flags: (C++: uint32) a combination of line cleanup flags. defaults to CLNL_TRIM - @return: length of line - -ida_kernwin.quick_widget_commands_t (class) - -ida_kernwin.quick_widget_commands_t.__init__ (method) - -ida_kernwin.quick_widget_commands_t._ah_t (class) - -ida_kernwin.quick_widget_commands_t._ah_t.__init__ (method) - -ida_kernwin.quick_widget_commands_t._ah_t.activate (method) - -ida_kernwin.quick_widget_commands_t._ah_t.update (method) - -ida_kernwin.quick_widget_commands_t._cmd_t (class) - -ida_kernwin.quick_widget_commands_t._cmd_t.__init__ (method) - -ida_kernwin.quick_widget_commands_t.add (method) - -ida_kernwin.quick_widget_commands_t.populate_popup (method) - -ida_kernwin.read_range_selection (function) - read_range_selection(v) -> bool - Get the address range for the selected range boundaries, this is the convenient - function for read_selection() - - @param v: (C++: TWidget *) view, nullptr means the last active window containing addresses - @retval 0: no range is selected - @retval 1: ok, start ea and end ea are filled - -ida_kernwin.read_selection (function) - read_selection(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.read_selection(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 p1: Storage for the "to" part of the selection. - @param p1: Storage for the "to" part of the selection. - @return: a bool value indicating success. - -ida_kernwin.refresh_chooser (function) - refresh_chooser(title) -> bool - Mark a non-modal custom chooser for a refresh (ui_refresh_chooser). - - @param title: (C++: const char *) title of chooser - @return: success - -ida_kernwin.refresh_choosers (function) - refresh_choosers() - -ida_kernwin.refresh_custom_viewer (function) - refresh_custom_viewer(custom_viewer) - Refresh custom ida viewer (ui_refresh_custom_viewer) - - @param custom_viewer: (C++: TWidget *) - -ida_kernwin.refresh_idaview (function) - refresh_idaview() - Refresh marked windows (ui_refreshmarked) - -ida_kernwin.refresh_idaview_anyway (function) - refresh_idaview_anyway() - Refresh all disassembly views (ui_refresh), forces an immediate refresh. Please - consider request_refresh() instead - -ida_kernwin.refresh_navband (function) - refresh_navband(force) - Refresh navigation band if changed (ui_refresh_navband). - - @param force: (C++: bool) refresh regardless - -ida_kernwin.register_action (function) - register_action(desc) -> bool - Create a new action (ui_register_action). After an action has been created, it - is possible to attach it to menu items (attach_action_to_menu()), or to popup - menus (attach_action_to_popup()). - - Because the actions will need to call the handler's activate() and update() - methods at any time, you shouldn't build your action handler on the stack. - - Please see the SDK's "ht_view" plugin for an example how to register actions. - - @param desc: (C++: const action_desc_t &) action to register - @return: success - -ida_kernwin.register_addon (function) - register_addon(info) -> int - Register an add-on. Show its info in the About box. For plugins, should be - called from init() function (repeated calls with the same product code overwrite - previous entries) returns: index of the add-on in the list, or -1 on error - - @param info: (C++: const addon_info_t *) addon_info_t const * - -ida_kernwin.register_and_attach_to_menu (function) - register_and_attach_to_menu(menupath, name, label, shortcut, flags, handler, owner, action_desc_t_flags) -> bool - Helper. - - You are not encouraged to use this, as it mixes flags for both - register_action(), and attach_action_to_menu(). - - The only reason for its existence is to make it simpler to port existing plugins - to the new actions API. - - @param menupath: (C++: const char *) char const * - @param name: (C++: const char *) char const * - @param label: (C++: const char *) char const * - @param shortcut: (C++: const char *) char const * - @param flags: (C++: int) - @param handler: (C++: action_handler_t *) - @param owner: (C++: void *) - @param action_desc_t_flags: (C++: int) - -ida_kernwin.register_timer (function) - register_timer(interval, py_callback) -> PyCapsule - Register a timer - - @param interval: Interval in milliseconds - @param py_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 - -ida_kernwin.remove_command_interpreter (function) - remove_command_interpreter(cli_idx) - Remove command line interpreter (ui_install_cli) - - @param cli_idx: int - -ida_kernwin.renderer_pos_info_t (class) - Proxy of C++ renderer_pos_info_t class. - -ida_kernwin.renderer_pos_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: renderer_pos_info_t const & - -ida_kernwin.renderer_pos_info_t.__init__ (method) - __init__(self) -> renderer_pos_info_t - -ida_kernwin.renderer_pos_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: renderer_pos_info_t const & - -ida_kernwin.renderer_pos_info_t.cx (variable) - the X coords of the character in the current line. When in graph mode: X coords - of the character in 'node'. - When in flat mode: X coords of the character in the line, w/o - taking scrolling into consideration. - -ida_kernwin.renderer_pos_info_t.cy (variable) - the Y coords of the character. When in graph mode: Y coords of the character in - 'node'. - When in flat mode: Line number, starting from the top. - -ida_kernwin.renderer_pos_info_t.node (variable) - the node, or -1 if the current renderer is not a graph renderer. - -ida_kernwin.renderer_pos_info_t.sx (variable) - the number of chars that are scrolled (flat mode only) - -ida_kernwin.repaint_custom_viewer (function) - repaint_custom_viewer(custom_viewer) - Repaint the given widget immediately (ui_repaint_qwidget) - - @param custom_viewer: (C++: TWidget *) - -ida_kernwin.replace_wait_box (function) - replace_wait_box(format) - Replace the label of "Please wait dialog box". - - @param format: (C++: const char *) char const * - -ida_kernwin.request_refresh (function) - request_refresh(mask, cnd=True) - Request a refresh of a builtin window. - - @param mask: (C++: uint64) Window refresh flags - @param cnd: (C++: bool) set if true or clear flag otherwise - -ida_kernwin.restore_database_snapshot (function) - restore_database_snapshot(ss, pyfunc_or_none, pytuple_or_none) -> bool - Restore a database snapshot. Note: This call is asynchronous. When it is - completed, the callback will be triggered. - - @param ss: (C++: const snapshot_t *) snapshot instance (see build_snapshot_tree()) - @param pyfunc_or_none: PyObject * - @param pytuple_or_none: PyObject * - @return: false if restoration could not be started (snapshot file was not - found). - If the returned value is True then check if the operation succeeded from the - callback. - -ida_kernwin.section_lines_refs_t (class) - Proxy of C++ qvector< twinline_t const * > class. - -ida_kernwin.section_lines_refs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< twinline_t const * > const & - -ida_kernwin.section_lines_refs_t.__getitem__ (method) - __getitem__(self, i) -> twinline_t - - @param i: size_t - -ida_kernwin.section_lines_refs_t.__init__ (method) - __init__(self) -> section_lines_refs_t - __init__(self, x) -> section_lines_refs_t - - @param x: qvector< twinline_t const * > const & - -ida_kernwin.section_lines_refs_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.section_lines_refs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< twinline_t const * > const & - -ida_kernwin.section_lines_refs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: twinline_t const *const & - -ida_kernwin.section_lines_refs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: twinline_t const *const & - -ida_kernwin.section_lines_refs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: twinline_t const *const & - -ida_kernwin.section_lines_refs_t.at (method) - at(self, _idx) -> twinline_t - - @param _idx: size_t - -ida_kernwin.section_lines_refs_t.begin (method) - begin(self) -> qvector< twinline_t const * >::iterator - begin(self) -> qvector< twinline_t const * >::const_iterator - -ida_kernwin.section_lines_refs_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.section_lines_refs_t.clear (method) - clear(self) - -ida_kernwin.section_lines_refs_t.empty (method) - empty(self) -> bool - -ida_kernwin.section_lines_refs_t.end (method) - end(self) -> qvector< twinline_t const * >::iterator - end(self) -> qvector< twinline_t const * >::const_iterator - -ida_kernwin.section_lines_refs_t.erase (method) - erase(self, it) -> qvector< twinline_t const * >::iterator - - @param it: qvector< twinline_t const * >::iterator - - erase(self, first, last) -> qvector< twinline_t const * >::iterator - - @param first: qvector< twinline_t const * >::iterator - @param last: qvector< twinline_t const * >::iterator - -ida_kernwin.section_lines_refs_t.extract (method) - extract(self) -> twinline_t const ** - -ida_kernwin.section_lines_refs_t.find (method) - find(self, x) -> qvector< twinline_t const * >::iterator - - @param x: twinline_t const *const & - - find(self, x) -> qvector< twinline_t const * >::const_iterator - - @param x: twinline_t const *const & - -ida_kernwin.section_lines_refs_t.has (method) - has(self, x) -> bool - - @param x: twinline_t const *const & - -ida_kernwin.section_lines_refs_t.inject (method) - inject(self, s, len) - - @param s: twinline_t const ** - @param len: size_t - -ida_kernwin.section_lines_refs_t.insert (method) - insert(self, it, x) -> qvector< twinline_t const * >::iterator - - @param it: qvector< twinline_t const * >::iterator - @param x: twinline_t const *const & - -ida_kernwin.section_lines_refs_t.pop_back (method) - pop_back(self) - -ida_kernwin.section_lines_refs_t.push_back (method) - push_back(self, x) - - @param x: twinline_t const *const & - - push_back(self) -> twinline_t const *& - -ida_kernwin.section_lines_refs_t.qclear (method) - qclear(self) - -ida_kernwin.section_lines_refs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.section_lines_refs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: twinline_t const *const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_kernwin.section_lines_refs_t.size (method) - size(self) -> size_t - -ida_kernwin.section_lines_refs_t.swap (method) - swap(self, r) - - @param r: qvector< twinline_t const * > & - -ida_kernwin.section_lines_refs_t.truncate (method) - truncate(self) - -ida_kernwin.sections_lines_refs_t (class) - Proxy of C++ qvector< section_lines_refs_t > class. - -ida_kernwin.sections_lines_refs_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< section_lines_refs_t > const & - -ida_kernwin.sections_lines_refs_t.__getitem__ (method) - __getitem__(self, i) -> section_lines_refs_t - - @param i: size_t - -ida_kernwin.sections_lines_refs_t.__init__ (method) - __init__(self) -> sections_lines_refs_t - __init__(self, x) -> sections_lines_refs_t - - @param x: qvector< section_lines_refs_t > const & - -ida_kernwin.sections_lines_refs_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.sections_lines_refs_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< section_lines_refs_t > const & - -ida_kernwin.sections_lines_refs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: section_lines_refs_t const & - -ida_kernwin.sections_lines_refs_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: section_lines_refs_t const & - -ida_kernwin.sections_lines_refs_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: section_lines_refs_t const & - -ida_kernwin.sections_lines_refs_t.at (method) - at(self, _idx) -> section_lines_refs_t - - @param _idx: size_t - -ida_kernwin.sections_lines_refs_t.begin (method) - begin(self) -> qvector< section_lines_refs_t >::iterator - begin(self) -> qvector< section_lines_refs_t >::const_iterator - -ida_kernwin.sections_lines_refs_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.sections_lines_refs_t.clear (method) - clear(self) - -ida_kernwin.sections_lines_refs_t.empty (method) - empty(self) -> bool - -ida_kernwin.sections_lines_refs_t.end (method) - end(self) -> qvector< section_lines_refs_t >::iterator - end(self) -> qvector< section_lines_refs_t >::const_iterator - -ida_kernwin.sections_lines_refs_t.erase (method) - erase(self, it) -> qvector< section_lines_refs_t >::iterator - - @param it: qvector< section_lines_refs_t >::iterator - - erase(self, first, last) -> qvector< section_lines_refs_t >::iterator - - @param first: qvector< section_lines_refs_t >::iterator - @param last: qvector< section_lines_refs_t >::iterator - -ida_kernwin.sections_lines_refs_t.extract (method) - extract(self) -> section_lines_refs_t - -ida_kernwin.sections_lines_refs_t.find (method) - find(self, x) -> qvector< section_lines_refs_t >::iterator - - @param x: section_lines_refs_t const & - - find(self, x) -> qvector< section_lines_refs_t >::const_iterator - - @param x: section_lines_refs_t const & - -ida_kernwin.sections_lines_refs_t.grow (method) - grow(self, x=section_lines_refs_t()) - - @param x: section_lines_refs_t const & - -ida_kernwin.sections_lines_refs_t.has (method) - has(self, x) -> bool - - @param x: section_lines_refs_t const & - -ida_kernwin.sections_lines_refs_t.inject (method) - inject(self, s, len) - - @param s: section_lines_refs_t * - @param len: size_t - -ida_kernwin.sections_lines_refs_t.insert (method) - insert(self, it, x) -> qvector< section_lines_refs_t >::iterator - - @param it: qvector< section_lines_refs_t >::iterator - @param x: section_lines_refs_t const & - -ida_kernwin.sections_lines_refs_t.pop_back (method) - pop_back(self) - -ida_kernwin.sections_lines_refs_t.push_back (method) - push_back(self, x) - - @param x: section_lines_refs_t const & - - push_back(self) -> section_lines_refs_t - -ida_kernwin.sections_lines_refs_t.qclear (method) - qclear(self) - -ida_kernwin.sections_lines_refs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.sections_lines_refs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: section_lines_refs_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_kernwin.sections_lines_refs_t.size (method) - size(self) -> size_t - -ida_kernwin.sections_lines_refs_t.swap (method) - swap(self, r) - - @param r: qvector< section_lines_refs_t > & - -ida_kernwin.sections_lines_refs_t.truncate (method) - truncate(self) - -ida_kernwin.set_cancelled (function) - set_cancelled() - Set "Cancelled" flag (ui_set_cancelled) - -ida_kernwin.set_code_viewer_handler (function) - set_code_viewer_handler(code_viewer, handler_id, handler_or_data) -> void * - Set a handler for a code viewer event (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) the code viewer - @param handler_id: (C++: custom_viewer_handler_id_t) one of CDVH_ in custom_viewer_handler_id_t - @param handler_or_data: (C++: void *) can be a handler or data. see examples in Functions: - custom viewer handlers - @return: old value of the handler or data - -ida_kernwin.set_code_viewer_is_source (function) - set_code_viewer_is_source(code_viewer) -> bool - Specify that the given code viewer is used to display source code - (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - -ida_kernwin.set_code_viewer_line_handlers (function) - set_code_viewer_line_handlers(code_viewer, click_handler, popup_handler, dblclick_handler, drawicon_handler, linenum_handler) - Set handlers for code viewer line events. Any of these handlers may be nullptr - - @param code_viewer: (C++: TWidget *) - @param click_handler: (C++: code_viewer_lines_click_t *) - @param popup_handler: (C++: code_viewer_lines_click_t *) - @param dblclick_handler: (C++: code_viewer_lines_click_t *) - @param drawicon_handler: (C++: code_viewer_lines_icon_t *) - @param linenum_handler: (C++: code_viewer_lines_linenum_t *) - -ida_kernwin.set_code_viewer_lines_alignment (function) - set_code_viewer_lines_alignment(code_viewer, align) -> bool - Set alignment for lines in a code viewer (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param align: (C++: int) - -ida_kernwin.set_code_viewer_lines_icon_margin (function) - set_code_viewer_lines_icon_margin(code_viewer, margin) -> bool - Set space allowed for icons in the margin of a code viewer - (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param margin: (C++: int) - -ida_kernwin.set_code_viewer_lines_radix (function) - set_code_viewer_lines_radix(code_viewer, radix) -> bool - Set radix for values displayed in a code viewer (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param radix: (C++: int) - -ida_kernwin.set_code_viewer_user_data (function) - set_code_viewer_user_data(code_viewer, ud) -> bool - Set the user data on a code viewer (ui_set_custom_viewer_handler). - - @param code_viewer: (C++: TWidget *) - @param ud: (C++: void *) - -ida_kernwin.set_custom_viewer_qt_aware (function) - set_custom_viewer_qt_aware(custom_viewer) -> bool - Allow the given viewer to interpret Qt events (ui_set_custom_viewer_handler) - - @param custom_viewer: (C++: TWidget *) - -ida_kernwin.set_dock_pos (function) - 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. - - Use the left, top, right, bottom parameters if DP_FLOATING is used, - or if you want to specify the width of docked windows. - - @param src_ctrl: char const * - @param dest_ctrl: char const * - @param orient: One of DP_XXXX constants - @param left: int - @param top: int - @param right: int - @param bottom: int - @return: Boolean - - Example: - set_dock_pos('Structures', 'Enums', DP_RIGHT) <- docks the Structures window to the right of Enums window - -ida_kernwin.set_highlight (function) - set_highlight(viewer, str, flags) -> bool - Set the highlighted identifier in the viewer (ui_set_highlight). - - @param viewer: (C++: TWidget *) the viewer - @param str: (C++: const char *) the text to match, or nullptr to remove current - @param flags: (C++: int) combination of HIF_... bits (see set_highlight flags) - @return: false if an error occurred - -ida_kernwin.set_nav_colorizer (function) - set_nav_colorizer(new_py_colorizer) -> dict or None - Set a new colorizer for the navigation band. - - The 'callback' is a function of 2 arguments: - - ea (the EA to colorize for) - - nbytes (the number of bytes at that EA) - and must return a 'long' value. - - The previous colorizer is returned, allowing - the new 'callback' to use 'call_nav_colorizer' - with it. - - Note that the previous colorizer is returned - only the first time set_nav_colorizer() is called: - due to the way the colorizers API is defined in C, - it is impossible to chain more than 2 colorizers - in IDAPython: the original, IDA-provided colorizer, - and a user-provided one. - - Example: colorizer inverting the color provided by the IDA colorizer: - def my_colorizer(ea, nbytes): - global ida_colorizer - orig = idaapi.call_nav_colorizer(ida_colorizer, ea, nbytes) - return long(~orig) - - ida_colorizer = idaapi.set_nav_colorizer(my_colorizer) - - @param new_py_colorizer: PyObject * - -ida_kernwin.set_view_renderer_type (function) - set_view_renderer_type(v, rt) - Set the type of renderer to use in a view (ui_set_renderer_type) - - @param v: (C++: TWidget *) - @param rt: (C++: tcc_renderer_type_t) enum tcc_renderer_type_t - -ida_kernwin.show_wait_box (function) - show_wait_box(message) - Display a dialog box with "Please wait...". The behavior of the dialog box can - be configured with well-known - tokens, that should be placed at the start of the format string: - "NODELAY\n": the dialog will show immediately, instead of - appearing after usual grace threshold - "HIDECANCEL\n": the cancel button won't be added to the dialog box - and user_cancelled() will always return false (but - can be called to refresh UI) - Using "HIDECANCEL" implies "NODELAY" - Plugins must call hide_wait_box() to close the dialog box, otherwise - the user interface will remain disabled. - Note that, if the wait dialog is already visible, show_wait_box() will - 1) push the currently-displayed text on a stack - 2) display the new text - Then, when hide_wait_box() is called, if that stack isn't empty its top - label will be popped and restored in the wait dialog. - This implies that a plugin should call hide_wait_box() exactly as many - times as it called show_wait_box(), or the wait dialog might remain - visible and block the UI. - Also, in case the plugin knows the wait dialog is currently displayed, - alternatively it can call replace_wait_box(), to replace the text of the - dialog without pushing the currently-displayed text on the stack. - - @param message: char const * - -ida_kernwin.simplecustviewer_t (class) - The base class for implementing simple custom viewers - -ida_kernwin.simplecustviewer_t.AddLine (method) - Adds a colored line to the view - @return: Boolean - -ida_kernwin.simplecustviewer_t.ClearLines (method) - Clears all the lines - -ida_kernwin.simplecustviewer_t.Close (method) - Destroys the view. - One has to call Create() afterwards. - Show() can be called and it will call Create() internally. - @return: Boolean - -ida_kernwin.simplecustviewer_t.Count (method) - Returns the number of lines in the view - -ida_kernwin.simplecustviewer_t.Create (method) - Creates the custom view. This should be the first method called after instantiation - - @param title: The title of the view - @return: Boolean whether it succeeds or fails. It may fail if a window with the same title is already open. - In this case better close existing windows - -ida_kernwin.simplecustviewer_t.DelLine (method) - Deletes an existing line - @return: Boolean - -ida_kernwin.simplecustviewer_t.EditLine (method) - Edits an existing line. - @return: Boolean - -ida_kernwin.simplecustviewer_t.GetCurrentLine (method) - Returns the current line. - @param mouse: Current line at mouse pos - @param notags: If True then tag_remove() will be called before returning the line - @return: Returns the current line (colored or uncolored) or None on failure - -ida_kernwin.simplecustviewer_t.GetCurrentWord (method) - Returns the current word - @param mouse: Use mouse position or cursor position - @return: None if failed or a String containing the current word at mouse or cursor - -ida_kernwin.simplecustviewer_t.GetLine (method) - Returns a line - @param lineno: The line number - @return: Returns a tuple (colored_line, fgcolor, bgcolor) or None - -ida_kernwin.simplecustviewer_t.GetLineNo (method) - Calls GetPos() and returns the current line number or -1 on failure - -ida_kernwin.simplecustviewer_t.GetPos (method) - Returns the current cursor or mouse position. - @param mouse: return mouse position - @return: Returns a tuple (lineno, x, y) - -ida_kernwin.simplecustviewer_t.GetSelection (method) - Returns the selected range or None - @return: - tuple(x1, y1, x2, y2) - - None if no selection - -ida_kernwin.simplecustviewer_t.GetWidget (method) - Return the TWidget underlying this view. - - @return: The TWidget underlying this view, or None. - -ida_kernwin.simplecustviewer_t.InsertLine (method) - Inserts a line in the given position - @return: Boolean - -ida_kernwin.simplecustviewer_t.IsFocused (method) - Returns True if the current view is the focused view - -ida_kernwin.simplecustviewer_t.Jump (method) - -ida_kernwin.simplecustviewer_t.OnPopup (method) - Context menu popup is about to be shown. Create items dynamically if you wish - @return: Boolean. True if you handled the event - -ida_kernwin.simplecustviewer_t.PatchLine (method) - Patches an existing line character at the given offset. This is a low level function. You must know what you're doing - -ida_kernwin.simplecustviewer_t.Refresh (method) - -ida_kernwin.simplecustviewer_t.RefreshCurrent (method) - Refreshes the current line only - -ida_kernwin.simplecustviewer_t.Show (method) - Shows an already created view. It the view was closed, then it will call Create() for you - @return: Boolean - -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline (class) - -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.__init__ (method) - -ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.populating_widget_popup (method) - -ida_kernwin.simplecustviewer_t.__init__ (method) - -ida_kernwin.simplecustviewer_t.__make_sl_arg (method) - -ida_kernwin.simpleline_place_t (class) - Proxy of C++ simpleline_place_t class. - -ida_kernwin.simpleline_place_t.__init__ (method) - -ida_kernwin.simpleline_place_t.n (variable) - line number - -ida_kernwin.simpleline_t (class) - Proxy of C++ simpleline_t class. - -ida_kernwin.simpleline_t.__init__ (method) - __init__(self) -> simpleline_t - __init__(self, c, str) -> simpleline_t - - @param c: color_t - @param str: char const * - - __init__(self, str) -> simpleline_t - - @param str: char const * - -ida_kernwin.simpleline_t.bgcolor (variable) - line background color - -ida_kernwin.simpleline_t.color (variable) - line prefix color - -ida_kernwin.simpleline_t.line (variable) - line text - -ida_kernwin.str2ea (function) - str2ea(str, screen_ea=BADADDR) -> bool - Convert string to linear address. Tries to interpret the string as: - 1) "current IP" keyword if supported by assembler (e.g. "$" in x86) - 2) segment:offset expression, where "segment" may be a name or a fixed segment - register (e.g. cs, ds) - 3) just segment name/register (translated to segment's start address) - 4) a name in the database (or debug name during debugging) - 5) hexadecimal value without prefix or suffix - 6) +delta or -delta, where numerical 'delta' is added to or subtracted from - 'screen_ea' - 7) register name (only during debugging) - 8) if all else fails, try to evaluate 'str' as an IDC expression - - @param str: (C++: const char *) string to parse - @param screen_ea: (C++: ea_t) the current address in the disassembly/pseudocode view - @return: success - -ida_kernwin.str2ea_ex (function) - str2ea_ex(str, screen_ea=BADADDR, flags=0) -> bool - Same as str2ea() but possibly with some steps skipped. - - @param str: (C++: const char *) string to parse - @param screen_ea: (C++: ea_t) the current address in the disassembly/pseudocode view - @param flags: (C++: int) see String to address conversion flags - @return: success - -ida_kernwin.strarray (function) - strarray(array, array_size, code) -> char const * - Find a line with the specified code in the strarray_t array. If the last element - of the array has code==0 then it is considered as the default entry. - If no default entry exists and the code is not found, strarray() returns "". - - @param array: (C++: const strarray_t *) strarray_t const * - @param array_size: (C++: size_t) - @param code: (C++: int) - -ida_kernwin.strarray_t (class) - Proxy of C++ strarray_t class. - -ida_kernwin.strarray_t.__init__ (method) - __init__(self) -> strarray_t - -ida_kernwin.structplace_t (class) - Proxy of C++ structplace_t class. - -ida_kernwin.structplace_t.__init__ (method) - -ida_kernwin.structplace_t.idx (variable) - struct serial number - -ida_kernwin.structplace_t.offset (variable) - offset within struct - -ida_kernwin.sync_source_t (class) - Proxy of C++ sync_source_t class. - -ida_kernwin.sync_source_t.__eq__ (method) - __eq__(self, _o) -> bool - - @param _o: sync_source_t const & - -ida_kernwin.sync_source_t.__init__ (method) - __init__(self, _view) -> sync_source_t - - @param _view: TWidget const * - - __init__(self, _regname) -> sync_source_t - - @param _regname: char const * - -ida_kernwin.sync_source_t.__ne__ (method) - __ne__(self, _o) -> bool - - @param _o: sync_source_t const & - -ida_kernwin.sync_source_t.get_register (method) - get_register(self) -> char const * - -ida_kernwin.sync_source_t.get_widget (method) - get_widget(self) -> TWidget const * - -ida_kernwin.sync_source_t.is_register (method) - is_register(self) -> bool - -ida_kernwin.sync_source_t.is_widget (method) - is_widget(self) -> bool - -ida_kernwin.sync_source_vec_t (class) - Proxy of C++ qvector< sync_source_t > class. - -ida_kernwin.sync_source_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< sync_source_t > const & - -ida_kernwin.sync_source_vec_t.__getitem__ (method) - __getitem__(self, i) -> sync_source_t - - @param i: size_t - -ida_kernwin.sync_source_vec_t.__init__ (method) - __init__(self) -> sync_source_vec_t - __init__(self, x) -> sync_source_vec_t - - @param x: qvector< sync_source_t > const & - -ida_kernwin.sync_source_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.sync_source_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< sync_source_t > const & - -ida_kernwin.sync_source_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: sync_source_t const & - -ida_kernwin.sync_source_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.at (method) - at(self, _idx) -> sync_source_t - - @param _idx: size_t - -ida_kernwin.sync_source_vec_t.begin (method) - begin(self) -> sync_source_t - -ida_kernwin.sync_source_vec_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.sync_source_vec_t.clear (method) - clear(self) - -ida_kernwin.sync_source_vec_t.empty (method) - empty(self) -> bool - -ida_kernwin.sync_source_vec_t.end (method) - end(self) -> sync_source_t - -ida_kernwin.sync_source_vec_t.erase (method) - erase(self, it) -> sync_source_t - - @param it: qvector< sync_source_t >::iterator - - erase(self, first, last) -> sync_source_t - - @param first: qvector< sync_source_t >::iterator - @param last: qvector< sync_source_t >::iterator - -ida_kernwin.sync_source_vec_t.extract (method) - extract(self) -> sync_source_t - -ida_kernwin.sync_source_vec_t.find (method) - find(self, x) -> sync_source_t - - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.has (method) - has(self, x) -> bool - - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.inject (method) - inject(self, s, len) - - @param s: sync_source_t * - @param len: size_t - -ida_kernwin.sync_source_vec_t.insert (method) - insert(self, it, x) -> sync_source_t - - @param it: qvector< sync_source_t >::iterator - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.pop_back (method) - pop_back(self) - -ida_kernwin.sync_source_vec_t.push_back (method) - push_back(self, x) - - @param x: sync_source_t const & - -ida_kernwin.sync_source_vec_t.qclear (method) - qclear(self) - -ida_kernwin.sync_source_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.sync_source_vec_t.size (method) - size(self) -> size_t - -ida_kernwin.sync_source_vec_t.swap (method) - swap(self, r) - - @param r: qvector< sync_source_t > & - -ida_kernwin.sync_source_vec_t.truncate (method) - truncate(self) - -ida_kernwin.sync_sources (function) - sync_sources(what, _with, sync) -> bool - [Un]synchronize sources - - @param what: (C++: const sync_source_t &) - @param with: (C++: const sync_source_t &) - @param sync: (C++: bool) - @return: success - -ida_kernwin.synced_group_t (class) - Proxy of C++ synced_group_t class. - -ida_kernwin.synced_group_t.__init__ (method) - __init__(self) -> synced_group_t - -ida_kernwin.synced_group_t.has (method) - has(self, ss) -> bool - - @param ss: sync_source_t const & - -ida_kernwin.synced_group_t.has_register (method) - has_register(self, r) -> bool - - @param r: char const * - -ida_kernwin.synced_group_t.has_widget (method) - has_widget(self, v) -> bool - - @param v: TWidget const * - -ida_kernwin.tagged_line_section_t (class) - Proxy of C++ tagged_line_section_t class. - -ida_kernwin.tagged_line_section_t.__init__ (method) - __init__(self) -> tagged_line_section_t - -ida_kernwin.tagged_line_section_t.substr (method) - substr(self, _in) -> bool - - @param in: qstring const & - -ida_kernwin.tagged_line_section_t.valid (method) - valid(self) -> bool - -ida_kernwin.tagged_line_section_t.valid_in (method) - valid_in(self, _in) -> bool - - @param in: qstring const & - -ida_kernwin.tagged_line_sections_t (class) - Proxy of C++ tagged_line_sections_t class. - -ida_kernwin.tagged_line_sections_t.__init__ (method) - __init__(self) -> tagged_line_sections_t - -ida_kernwin.tagged_line_sections_t.find_in (method) - find_in(self, range, tag=0) -> tagged_line_section_t - - @param range: tagged_line_section_t const & - @param tag: color_t - -ida_kernwin.tagged_line_sections_t.nearest_at (method) - nearest_at(self, x, tag=0) -> tagged_line_section_t - - @param x: cpidx_t - @param tag: color_t - -ida_kernwin.tagged_line_sections_t.sections_at (method) - sections_at(self, out, x, tag=0) - - @param out: tagged_line_sections_t * - @param x: cpidx_t - @param tag: color_t - -ida_kernwin.take_database_snapshot (function) - take_database_snapshot(ss) -> (bool, NoneType) - Take a database snapshot (ui_take_database_snapshot). - - @param ss: (C++: snapshot_t *) in/out parameter. - * in: description, flags - * out: filename, id - @return: success - -ida_kernwin.text_t (class) - Proxy of C++ qvector< twinline_t > class. - -ida_kernwin.text_t.__getitem__ (method) - __getitem__(self, i) -> twinline_t - - @param i: size_t - -ida_kernwin.text_t.__init__ (method) - __init__(self) -> text_t - __init__(self, x) -> text_t - - @param x: qvector< twinline_t > const & - -ida_kernwin.text_t.__len__ (method) - __len__(self) -> size_t - -ida_kernwin.text_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: twinline_t const & - -ida_kernwin.text_t.at (method) - at(self, _idx) -> twinline_t - - @param _idx: size_t - -ida_kernwin.text_t.begin (method) - begin(self) -> twinline_t - -ida_kernwin.text_t.capacity (method) - capacity(self) -> size_t - -ida_kernwin.text_t.clear (method) - clear(self) - -ida_kernwin.text_t.empty (method) - empty(self) -> bool - -ida_kernwin.text_t.end (method) - end(self) -> twinline_t - -ida_kernwin.text_t.erase (method) - erase(self, it) -> twinline_t - - @param it: qvector< twinline_t >::iterator - - erase(self, first, last) -> twinline_t - - @param first: qvector< twinline_t >::iterator - @param last: qvector< twinline_t >::iterator - -ida_kernwin.text_t.extract (method) - extract(self) -> twinline_t - -ida_kernwin.text_t.grow (method) - grow(self, x=twinline_t()) - - @param x: twinline_t const & - -ida_kernwin.text_t.inject (method) - inject(self, s, len) - - @param s: twinline_t * - @param len: size_t - -ida_kernwin.text_t.insert (method) - insert(self, it, x) -> twinline_t - - @param it: qvector< twinline_t >::iterator - @param x: twinline_t const & - -ida_kernwin.text_t.pop_back (method) - pop_back(self) - -ida_kernwin.text_t.push_back (method) - push_back(self, x) - - @param x: twinline_t const & - - push_back(self) -> twinline_t - -ida_kernwin.text_t.qclear (method) - qclear(self) - -ida_kernwin.text_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_kernwin.text_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: twinline_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_kernwin.text_t.size (method) - size(self) -> size_t - -ida_kernwin.text_t.swap (method) - swap(self, r) - - @param r: qvector< twinline_t > & - -ida_kernwin.text_t.truncate (method) - truncate(self) - -ida_kernwin.textctrl_info_t (class) - Class representing textctrl_info_t - -ida_kernwin.textctrl_info_t.TXTF_ACCEPTTABS (variable) - Tab key inserts 'tabsize' spaces - -ida_kernwin.textctrl_info_t.TXTF_AUTOINDENT (variable) - Auto-indent on new line - -ida_kernwin.textctrl_info_t.TXTF_FIXEDFONT (variable) - The control uses IDA's fixed font - -ida_kernwin.textctrl_info_t.TXTF_MODIFIED (variable) - Gets/sets the modified status - -ida_kernwin.textctrl_info_t.TXTF_READONLY (variable) - Text cannot be edited (but can be selected and copied) - -ida_kernwin.textctrl_info_t.TXTF_SELECTED (variable) - Shows the field with its text selected - -ida_kernwin.textctrl_info_t.__get_flags__ (method) - Returns the flags value - -ida_kernwin.textctrl_info_t.__get_tabsize__ (method) - Returns the tabsize value - -ida_kernwin.textctrl_info_t.__get_text (method) - Sets the text value - -ida_kernwin.textctrl_info_t.__init__ (method) - -ida_kernwin.textctrl_info_t.__set_flags__ (method) - Sets the flags value - -ida_kernwin.textctrl_info_t.__set_tabsize__ (method) - Sets the tabsize value - -ida_kernwin.textctrl_info_t.__set_text (method) - Sets the text value - -ida_kernwin.textctrl_info_t._create_clink (method) - -ida_kernwin.textctrl_info_t._del_clink (method) - -ida_kernwin.textctrl_info_t._get_clink_ptr (method) - -ida_kernwin.textctrl_info_t.assign (method) - Copies the contents of 'other' to 'self' - -ida_kernwin.textctrl_info_t.flags (variable) - Text control property bits - -ida_kernwin.textctrl_info_t.tabsize (variable) - how many spaces a single tab will indent - -ida_kernwin.textctrl_info_t.text (variable) - in, out: text control value - -ida_kernwin.textctrl_info_t.value (variable) - Alias for the text property - -ida_kernwin.textctrl_info_t_assign (function) - textctrl_info_t_assign(_self, other) -> bool - - @param self: PyObject * - @param other: PyObject * - -ida_kernwin.textctrl_info_t_create (function) - textctrl_info_t_create() -> PyObject * - -ida_kernwin.textctrl_info_t_destroy (function) - textctrl_info_t_destroy(py_obj) -> bool - - @param py_obj: PyObject * - -ida_kernwin.textctrl_info_t_get_clink (function) - textctrl_info_t_get_clink(_self) -> textctrl_info_t * - - @param self: PyObject * - -ida_kernwin.textctrl_info_t_get_clink_ptr (function) - textctrl_info_t_get_clink_ptr(_self) -> PyObject * - - @param self: PyObject * - -ida_kernwin.textctrl_info_t_get_flags (function) - textctrl_info_t_get_flags(_self) -> unsigned int - - @param self: PyObject * - -ida_kernwin.textctrl_info_t_get_tabsize (function) - textctrl_info_t_get_tabsize(_self) -> unsigned int - - @param self: PyObject * - -ida_kernwin.textctrl_info_t_get_text (function) - textctrl_info_t_get_text(_self) -> char const * - - @param self: PyObject * - -ida_kernwin.textctrl_info_t_set_flags (function) - textctrl_info_t_set_flags(_self, flags) -> bool - - @param self: PyObject * - @param flags: unsigned int - -ida_kernwin.textctrl_info_t_set_tabsize (function) - textctrl_info_t_set_tabsize(_self, tabsize) -> bool - - @param self: PyObject * - @param tabsize: unsigned int - -ida_kernwin.textctrl_info_t_set_text (function) - textctrl_info_t_set_text(_self, s) -> bool - - @param self: PyObject * - @param s: char const * - -ida_kernwin.tiplace_t (class) - Proxy of C++ tiplace_t class. - -ida_kernwin.tiplace_t.__init__ (method) - -ida_kernwin.tiplace_t.calc_udm_offset (method) - calc_udm_offset(self, ud, p_udmidx=None, p_bitoff=None) -> uint64 - for structs: calculate the offset that corresponds to the tiplace. - - @param ud: (C++: const void *) pointer to user-defined context data. Is supplied by linearray_t - @param p_udmidx: (C++: ssize_t *) place to return the index of the current udt member, if any. if - there is no member at the current offset, return -1 - @param p_bitoff: (C++: int *) place to return the bit offset of the item from the beginning - of the bit bucket if there no bitfields, return -1 - @return: the current offset or uint64(-1) - -ida_kernwin.tiplace_t.fill_type_ref (method) - fill_type_ref(self, out, ud) -> bool - fill the type information for use in actions - - @param out: (C++: til_type_ref_t *) pointer to storage - @param ud: (C++: const void *) pointer to user-defined context data. Is supplied by linearray_t - @return: success - -ida_kernwin.tiplace_t.get_kind (method) - get_kind(self, ud) -> type_t - get the kind of type this place represents - - @param ud: (C++: const void *) pointer to user-defined context data. Is supplied by linearray_t - @return: one of BTF_TYPEDEF, BTF_STRUCT, BTF_UNION, BTF_ENUM or BT_UNK - -ida_kernwin.tiplace_t.is_footer (method) - is_footer(self) -> bool - -ida_kernwin.tiplace_t.is_header (method) - is_header(self) -> bool - -ida_kernwin.tiplace_t.is_index (method) - is_index(self) -> bool - -ida_kernwin.tiplace_t.reset (method) - reset(self) - -ida_kernwin.tiplace_t.set_footer (method) - set_footer(self) - -ida_kernwin.tiplace_t.set_header (method) - set_header(self) - -ida_kernwin.tiplace_t.set_index_by_offset (method) - set_index_by_offset(self, ud, offset) - for structs: calculate the index that corresponds to the offset and set it. - - @param ud: (C++: void *) pointer to user-defined context data. Is supplied by linearray_t - @param offset: (C++: uint64) offset of udt member - -ida_kernwin.tiplace_t.valid_ord (method) - valid_ord(self) -> bool - -ida_kernwin.twinline_t (class) - Proxy of C++ twinline_t class. - -ida_kernwin.twinline_t.__init__ (method) - __init__(self) -> twinline_t - __init__(self, t, pc, bc) -> twinline_t - - @param t: place_t * - @param pc: color_t - @param bc: bgcolor_t - -ida_kernwin.twinline_t.at (variable) - location in view - -ida_kernwin.twinline_t.bg_color (variable) - line background color - -ida_kernwin.twinline_t.is_default (variable) - is this the default line of the current location? - -ida_kernwin.twinline_t.line (variable) - line contents - -ida_kernwin.twinline_t.prefix_color (variable) - line prefix color - -ida_kernwin.twinpos_t (class) - Proxy of C++ twinpos_t class. - -ida_kernwin.twinpos_t.__init__ (method) - __init__(self) -> twinpos_t - __init__(self, t) -> twinpos_t - - @param t: place_t * - - __init__(self, t, x0) -> twinpos_t - - @param t: place_t * - @param x0: int - -ida_kernwin.twinpos_t.at (variable) - location in view - -ida_kernwin.twinpos_t.place (method) - -ida_kernwin.twinpos_t.place_as_enumplace_t (method) - -ida_kernwin.twinpos_t.place_as_idaplace_t (method) - -ida_kernwin.twinpos_t.place_as_simpleline_place_t (method) - -ida_kernwin.twinpos_t.place_as_structplace_t (method) - -ida_kernwin.twinpos_t.place_as_tiplace_t (method) - -ida_kernwin.twinpos_t.x (variable) - cursor x - -ida_kernwin.ui_load_new_file (function) - ui_load_new_file(temp_file, filename, pli, neflags, ploaders) -> bool - Display a load file dialog and load file (ui_load_file). - - @param temp_file: (C++: qstring *) name of the file with the extracted archive member. - @param filename: (C++: qstring *) the name of input file as is, library or archive name - @param pli: (C++: linput_t **) loader input source, may be changed to point to temp_file - @param neflags: (C++: ushort) combination of NEF_... bits (see Load file flags) - @param ploaders: (C++: load_info_t **) list of loaders which accept file, may be changed for loaders - of temp_file - @retval true: file was successfully loaded - @retval false: otherwise - -ida_kernwin.ui_requests_t (class) - Proxy of C++ ui_requests_t class. - -ida_kernwin.ui_requests_t.__init__ (method) - __init__(self) -> ui_requests_t - -ida_kernwin.ui_run_debugger (function) - ui_run_debugger(dbgopts, exename, argc, argv) -> bool - Load a debugger plugin and run the specified program (ui_run_dbg). - - @param dbgopts: (C++: const char *) value of the -r command line switch - @param exename: (C++: const char *) name of the file to run - @param argc: (C++: int) number of arguments for the executable - @param argv: (C++: const char *const *) argument vector - @return: success - -ida_kernwin.unmark_selection (function) - unmark_selection() - Unmark selection (ui_unmarksel) - -ida_kernwin.unregister_action (function) - unregister_action(name) -> bool - Delete a previously-registered action (ui_unregister_action). - - @param name: (C++: const char *) name of action - @return: success - -ida_kernwin.unregister_timer (function) - unregister_timer(py_timerctx) -> bool - 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. - -ida_kernwin.update_action_checkable (function) - update_action_checkable(name, checkable) -> bool - Update an action's checkability (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param checkable: (C++: bool) new checkability - @return: success - -ida_kernwin.update_action_checked (function) - update_action_checked(name, checked) -> bool - Update an action's checked state (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param checked: (C++: bool) new checked state - @return: success - -ida_kernwin.update_action_icon (function) - update_action_icon(name, icon) -> bool - Update an action's icon (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param icon: (C++: int) new icon id - @return: success - -ida_kernwin.update_action_label (function) - update_action_label(name, label) -> bool - Update an action's label (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param label: (C++: const char *) new label - @return: success - -ida_kernwin.update_action_shortcut (function) - update_action_shortcut(name, shortcut) -> bool - Update an action's shortcut (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param shortcut: (C++: const char *) new shortcut - @return: success - -ida_kernwin.update_action_state (function) - update_action_state(name, state) -> bool - Update an action's state (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param state: (C++: action_state_t) new state - @return: success - -ida_kernwin.update_action_tooltip (function) - update_action_tooltip(name, tooltip) -> bool - Update an action's tooltip (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param tooltip: (C++: const char *) new tooltip - @return: success - -ida_kernwin.update_action_visibility (function) - update_action_visibility(name, visible) -> bool - Update an action's visibility (ui_update_action_attr). - - @param name: (C++: const char *) action name - @param visible: (C++: bool) new visibility - @return: success - -ida_kernwin.user_cancelled (function) - user_cancelled() -> bool - Test the ctrl-break flag (ui_test_cancelled). - @retval 1: Ctrl-Break is detected, a message is displayed - @retval 2: Ctrl-Break is detected again, a message is not displayed - @retval 0: Ctrl-Break is not detected - -ida_kernwin.view_activated (variable) - A view is activated - -ida_kernwin.view_click (variable) - Click event - -ida_kernwin.view_close (variable) - View closed - -ida_kernwin.view_created (variable) - A view is being created. - -ida_kernwin.view_curpos (variable) - Cursor position changed - -ida_kernwin.view_dblclick (variable) - Double click event - -ida_kernwin.view_deactivated (variable) - A view is deactivated - -ida_kernwin.view_keydown (variable) - Key down event - -ida_kernwin.view_loc_changed (variable) - The location for the view has changed (can be either the place_t, the - renderer_info_t, or both.) - -ida_kernwin.view_mouse_event_location_t (class) - Proxy of C++ view_mouse_event_location_t class. - -ida_kernwin.view_mouse_event_location_t.__init__ (method) - __init__(self) -> view_mouse_event_location_t - -ida_kernwin.view_mouse_event_location_t.ea (variable) - flat view (rtype == TCCRT_FLAT) - -ida_kernwin.view_mouse_event_location_t.item (variable) - graph views (rtype != TCCRT_FLAT). nullptr if mouse is not currently over an - item. - -ida_kernwin.view_mouse_event_t (class) - Proxy of C++ view_mouse_event_t class. - -ida_kernwin.view_mouse_event_t.__init__ (method) - __init__(self) -> view_mouse_event_t - -ida_kernwin.view_mouse_event_t.button (variable) - represents which mouse button was responsible for generating the event. This - field does not care about the current state of the mouse. - -ida_kernwin.view_mouse_event_t.location (variable) - location where event was generated - -ida_kernwin.view_mouse_event_t.renderer_pos (variable) - position where event was generated, relative to the renderer - -ida_kernwin.view_mouse_event_t.rtype (variable) - type of renderer that received the event - -ida_kernwin.view_mouse_event_t.state (variable) - contains information about what buttons are CURRENTLY pressed on the keyboard - and mouse. view_mouse_event_t instances created in functions like - mouseReleaseEvent() won't contain any information about the mouse, because it - has been released. - -ida_kernwin.view_mouse_event_t.x (variable) - screen x coordinate - -ida_kernwin.view_mouse_event_t.y (variable) - screen y coordinate - -ida_kernwin.view_mouse_moved (variable) - The mouse moved on the view - -ida_kernwin.view_mouse_over (variable) - The user moved the mouse over (or out of) a node or an edge. This is only - relevant in a graph view. - -ida_kernwin.view_switched (variable) - A view's renderer has changed. - -ida_kernwin.warning (function) - warning(format) - Display a message in a message box - - @param message: message to print (formatting is done in Python) - - This function can be used to debug IDAPython scripts - The user will be able to hide messages if they appear twice in a row on - the screen - -ida_lines (module) - High level functions that deal with the generation of the disassembled text - lines. - - This file also contains definitions for the syntax highlighting. - - Finally there are functions that deal with anterior/posterior user-defined - lines. - -ida_lines.COLOR_ADDR (variable) - hidden address marks. the address is represented as 8digit hex number: 01234567. - it doesn't have COLOR_OFF pair. NB: for 64-bit IDA, the address is 16digit. - -ida_lines.COLOR_ADDR_SIZE (variable) - Size of a tagged address (see COLOR_ADDR) - -ida_lines.COLOR_ALTOP (variable) - Alternative operand. - -ida_lines.COLOR_ASMDIR (variable) - Assembler directive. - -ida_lines.COLOR_AUTOCMT (variable) - Automatic comment. - -ida_lines.COLOR_BG_MAX (variable) - Max color number. - -ida_lines.COLOR_BINPREF (variable) - Binary line prefix bytes. - -ida_lines.COLOR_CHAR (variable) - Char constant in instruction. - -ida_lines.COLOR_CNAME (variable) - Regular code name. - -ida_lines.COLOR_CODE (variable) - Single instruction. - -ida_lines.COLOR_CODNAME (variable) - Dummy code name. - -ida_lines.COLOR_COLLAPSED (variable) - Collapsed line. - -ida_lines.COLOR_CREF (variable) - Code reference. - -ida_lines.COLOR_CREFTAIL (variable) - Code reference to tail byte. - -ida_lines.COLOR_CURITEM (variable) - Current item. - -ida_lines.COLOR_CURLINE (variable) - Current line. - -ida_lines.COLOR_DATA (variable) - Data bytes. - -ida_lines.COLOR_DATNAME (variable) - Dummy Data Name. - -ida_lines.COLOR_DCHAR (variable) - Char constant in data directive. - -ida_lines.COLOR_DEFAULT (variable) - Default. - -ida_lines.COLOR_DEMNAME (variable) - Demangled Name. - -ida_lines.COLOR_DNAME (variable) - Regular Data Name. - -ida_lines.COLOR_DNUM (variable) - Numeric constant in data directive. - -ida_lines.COLOR_DREF (variable) - Data reference. - -ida_lines.COLOR_DREFTAIL (variable) - Data reference to tail byte. - -ida_lines.COLOR_DSTR (variable) - String constant in data directive. - -ida_lines.COLOR_ERROR (variable) - Error or problem. - -ida_lines.COLOR_ESC (variable) - Escape character (Quote next character). This is needed to output '\1' and '\2' - characters. - -ida_lines.COLOR_EXTERN (variable) - External name definition segment. - -ida_lines.COLOR_EXTRA (variable) - Extra line. - -ida_lines.COLOR_FG_MAX (variable) - Max color number. - -ida_lines.COLOR_HIDLINE (variable) - Hidden line. - -ida_lines.COLOR_HIDNAME (variable) - Hidden name. - -ida_lines.COLOR_IMPNAME (variable) - Imported name. - -ida_lines.COLOR_INSN (variable) - Instruction. - -ida_lines.COLOR_INV (variable) - Escape character (Inverse foreground and background colors). This escape - character has no corresponding COLOR_OFF. Its action continues until the next - COLOR_INV or end of line. - -ida_lines.COLOR_KEYWORD (variable) - Keywords. - -ida_lines.COLOR_LIBFUNC (variable) - Library function. - -ida_lines.COLOR_LIBNAME (variable) - Library function name. - -ida_lines.COLOR_LOCNAME (variable) - Local variable name. - -ida_lines.COLOR_LUMFUNC (variable) - Lumina function. - -ida_lines.COLOR_LUMINA (variable) - Lumina-related, only for the navigation band. - -ida_lines.COLOR_MACRO (variable) - Macro. - -ida_lines.COLOR_NUMBER (variable) - Numeric constant in instruction. - -ida_lines.COLOR_OFF (variable) - Escape character (OFF). Followed by a color code (color_t). - -ida_lines.COLOR_ON (variable) - Escape character (ON). Followed by a color code (color_t). - -ida_lines.COLOR_OPND1 (variable) - Instruction operand 1. - -ida_lines.COLOR_OPND2 (variable) - Instruction operand 2. - -ida_lines.COLOR_OPND3 (variable) - Instruction operand 3. - -ida_lines.COLOR_OPND4 (variable) - Instruction operand 4. - -ida_lines.COLOR_OPND5 (variable) - Instruction operand 5. - -ida_lines.COLOR_OPND6 (variable) - Instruction operand 6. - -ida_lines.COLOR_OPND7 (variable) - Instruction operand 7. - -ida_lines.COLOR_OPND8 (variable) - Instruction operand 8. - -ida_lines.COLOR_PREFIX (variable) - Line prefix. - -ida_lines.COLOR_REG (variable) - Register name. - -ida_lines.COLOR_REGCMT (variable) - Regular comment. - -ida_lines.COLOR_REGFUNC (variable) - Regular function. - -ida_lines.COLOR_RESERVED1 (variable) - This tag is reserved for internal IDA use. - -ida_lines.COLOR_RPTCMT (variable) - Repeatable comment (comment defined somewhere else) - -ida_lines.COLOR_SEGNAME (variable) - Segment name. - -ida_lines.COLOR_SELECTED (variable) - Selected. - -ida_lines.COLOR_STRING (variable) - String constant in instruction. - -ida_lines.COLOR_SYMBOL (variable) - Punctuation. - -ida_lines.COLOR_UNAME (variable) - Regular unknown name. - -ida_lines.COLOR_UNKNAME (variable) - Dummy unknown name. - -ida_lines.COLOR_UNKNOWN (variable) - Unexplored byte. - -ida_lines.COLOR_VOIDOP (variable) - Void operand. - -ida_lines.COLSTR (function) - Utility function to create a colored line - @param str: The string - @param tag: Color tag constant. One of SCOLOR_XXXX - -ida_lines.SCOLOR_ADDR (variable) - Hidden address mark. - -ida_lines.SCOLOR_ALTOP (variable) - Alternative operand. - -ida_lines.SCOLOR_ASMDIR (variable) - Assembler directive. - -ida_lines.SCOLOR_AUTOCMT (variable) - Automatic comment. - -ida_lines.SCOLOR_BINPREF (variable) - Binary line prefix bytes. - -ida_lines.SCOLOR_CHAR (variable) - Char constant in instruction. - -ida_lines.SCOLOR_CNAME (variable) - Regular code name. - -ida_lines.SCOLOR_CODNAME (variable) - Dummy code name. - -ida_lines.SCOLOR_COLLAPSED (variable) - Collapsed line. - -ida_lines.SCOLOR_CREF (variable) - Code reference. - -ida_lines.SCOLOR_CREFTAIL (variable) - Code reference to tail byte. - -ida_lines.SCOLOR_DATNAME (variable) - Dummy Data Name. - -ida_lines.SCOLOR_DCHAR (variable) - Char constant in data directive. - -ida_lines.SCOLOR_DEFAULT (variable) - Default. - -ida_lines.SCOLOR_DEMNAME (variable) - Demangled Name. - -ida_lines.SCOLOR_DNAME (variable) - Regular Data Name. - -ida_lines.SCOLOR_DNUM (variable) - Numeric constant in data directive. - -ida_lines.SCOLOR_DREF (variable) - Data reference. - -ida_lines.SCOLOR_DREFTAIL (variable) - Data reference to tail byte. - -ida_lines.SCOLOR_DSTR (variable) - String constant in data directive. - -ida_lines.SCOLOR_ERROR (variable) - Error or problem. - -ida_lines.SCOLOR_ESC (variable) - Escape character (Quote next character) - -ida_lines.SCOLOR_EXTRA (variable) - Extra line. - -ida_lines.SCOLOR_HIDNAME (variable) - Hidden name. - -ida_lines.SCOLOR_IMPNAME (variable) - Imported name. - -ida_lines.SCOLOR_INSN (variable) - Instruction. - -ida_lines.SCOLOR_INV (variable) - Escape character (Inverse colors) - -ida_lines.SCOLOR_KEYWORD (variable) - Keywords. - -ida_lines.SCOLOR_LIBNAME (variable) - Library function name. - -ida_lines.SCOLOR_LOCNAME (variable) - Local variable name. - -ida_lines.SCOLOR_MACRO (variable) - Macro. - -ida_lines.SCOLOR_NUMBER (variable) - Numeric constant in instruction. - -ida_lines.SCOLOR_OFF (variable) - Escape character (OFF) - -ida_lines.SCOLOR_ON (variable) - Escape character (ON) - -ida_lines.SCOLOR_PREFIX (variable) - Line prefix. - -ida_lines.SCOLOR_REG (variable) - Register name. - -ida_lines.SCOLOR_REGCMT (variable) - Regular comment. - -ida_lines.SCOLOR_RPTCMT (variable) - Repeatable comment (defined not here) - -ida_lines.SCOLOR_SEGNAME (variable) - Segment name. - -ida_lines.SCOLOR_STRING (variable) - String constant in instruction. - -ida_lines.SCOLOR_SYMBOL (variable) - Punctuation. - -ida_lines.SCOLOR_UNAME (variable) - Regular unknown name. - -ida_lines.SCOLOR_UNKNAME (variable) - Dummy unknown name. - -ida_lines.SCOLOR_VOIDOP (variable) - Void operand. - -ida_lines.add_extra_cmt (function) - add_extra_cmt(ea, isprev, format) -> bool - Add anterior/posterior comment line(s). - - @param ea: (C++: ea_t) linear address - @param isprev: (C++: bool) do we add anterior lines? (0-no, posterior) - @param format: (C++: const char *) printf() style format string. may contain \n to denote new lines. - The resulting string should not contain comment characters (;), - the kernel will add them automatically. - @return: true if success - -ida_lines.add_extra_line (function) - add_extra_line(ea, isprev, format) -> bool - Add anterior/posterior non-comment line(s). - - @param ea: (C++: ea_t) linear address - @param isprev: (C++: bool) do we add anterior lines? (0-no, posterior) - @param format: (C++: const char *) printf() style format string. may contain \n to denote new lines. - @return: true if success - -ida_lines.add_pgm_cmt (function) - add_pgm_cmt(format) -> bool - Add anterior comment line(s) at the start of program. - - @param format: (C++: const char *) printf() style format string. may contain \n to denote new lines. - The resulting string should not contain comment characters (;), - the kernel will add them automatically. - @return: true if success - -ida_lines.add_sourcefile (function) - add_sourcefile(ea1, ea2, filename) -> bool - Mark a range of address as belonging to a source file. An address range may - belong only to one source file. A source file may be represented by several - address ranges. - - @param ea1: (C++: ea_t) linear address of start of the address range - @param ea2: (C++: ea_t) linear address of end of the address range (excluded) - @param filename: (C++: const char *) name of source file. - @return: success - -ida_lines.calc_bg_color (function) - calc_bg_color(ea) -> bgcolor_t - Get background color for line at 'ea' - - @param ea: (C++: ea_t) - @return: RGB color - -ida_lines.calc_prefix_color (function) - calc_prefix_color(ea) -> color_t - Get prefix color for line at 'ea' - - @param ea: (C++: ea_t) - @return: Line prefix colors - -ida_lines.create_encoding_helper (function) - create_encoding_helper(encidx=-1, nr=nr_once) -> encoder_t * - - @param encidx: int - @param nr: enum encoder_t::notify_recerr_t - -ida_lines.del_extra_cmt (function) - del_extra_cmt(ea, what) - - @param ea: ea_t - @param what: int - -ida_lines.del_sourcefile (function) - del_sourcefile(ea) -> bool - Delete information about the source file. - - @param ea: (C++: ea_t) linear address - @return: success - -ida_lines.delete_extra_cmts (function) - delete_extra_cmts(ea, what) - - @param ea: ea_t - @param what: int - -ida_lines.generate_disasm_line (function) - generate_disasm_line(ea, flags=0) -> str - - @param ea: ea_t - @param flags: int - -ida_lines.generate_disassembly (function) - generate_disassembly(ea, max_lines, as_stack, notags) -> (int, [str, ...]) - 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 - @param notags: bool - @return: - None on failure - - tuple(most_important_line_number, list(lines)) : Returns a tuple containing - the most important line number and a list of generated lines - -ida_lines.get_extra_cmt (function) - get_extra_cmt(ea, what) -> ssize_t - - @param ea: ea_t - @param what: int - -ida_lines.get_first_free_extra_cmtidx (function) - get_first_free_extra_cmtidx(ea, start) -> int - - @param ea: ea_t - @param start: int - -ida_lines.get_sourcefile (function) - get_sourcefile(ea, bounds=None) -> char const * - Get name of source file occupying the given address. - - @param ea: (C++: ea_t) linear address - @param bounds: (C++: range_t *) pointer to the output buffer with the address range for the - current file. May be nullptr. - @return: nullptr if source file information is not found, otherwise returns - pointer to file name - -ida_lines.install_user_defined_prefix (function) - install_user_defined_prefix(prefix_len, udp, owner) -> bool - User-defined line-prefixes are displayed just after the autogenerated line - prefixes in the disassembly listing. There is no need to call this function - explicitly. Use the user_defined_prefix_t class. - - @param prefix_len: (C++: size_t) prefixed length. if 0, then uninstall UDP - @param udp: (C++: struct user_defined_prefix_t *) object to generate user-defined prefix - @param owner: (C++: const void *) pointer to the plugin_t that owns UDP if non-nullptr, then the - object will be uninstalled and destroyed when the plugin gets - unloaded - -ida_lines.requires_color_esc (function) - Checks if the given character requires escaping - Is the given char a color escape character? - -ida_lines.set_user_defined_prefix (function) - set_user_defined_prefix(width, pycb) -> bool - Deprecated. Please use install_user_defined_prefix() instead - - @param width: size_t - @param pycb: PyObject * - -ida_lines.tag_addr (function) - tag_addr(ea) -> PyObject * - Insert an address mark into a string. - - @param ea: (C++: ea_t) address to include - -ida_lines.tag_advance (function) - tag_advance(line, cnt) -> int - Move pointer to a 'line' to 'cnt' positions right. Take into account escape - sequences. - - @param line: (C++: const char *) pointer to string - @param cnt: (C++: int) number of positions to move right - @return: moved pointer - -ida_lines.tag_remove (function) - tag_remove(nonnul_instr) -> str - - @param nonnul_instr: char const * - -ida_lines.tag_skipcode (function) - tag_skipcode(line) -> int - Skip one color code. This function should be used if you are interested in color - codes and want to analyze all of them. Otherwise tag_skipcodes() function is - better since it will skip all colors at once. This function will skip the - current color code if there is one. If the current symbol is not a color code, - it will return the input. - - @param line: (C++: const char *) char const * - @return: moved pointer - -ida_lines.tag_skipcodes (function) - tag_skipcodes(line) -> int - Move the pointer past all color codes. - - @param line: (C++: const char *) can't be nullptr - @return: moved pointer, can't be nullptr - -ida_lines.tag_strlen (function) - tag_strlen(line) -> ssize_t - Calculate length of a colored string This function computes the length in - unicode codepoints of a line - - @param line: (C++: const char *) char const * - @return: the number of codepoints in the line, or -1 on error - -ida_lines.update_extra_cmt (function) - update_extra_cmt(ea, what, str) - - @param ea: ea_t - @param what: int - @param str: char const * - -ida_lines.user_defined_prefix_t (class) - Proxy of C++ user_defined_prefix_t class. - -ida_lines.user_defined_prefix_t.__disown__ (method) - -ida_lines.user_defined_prefix_t.__init__ (method) - __init__(self, prefix_len, owner) -> user_defined_prefix_t - - @param prefix_len: size_t - @param owner: void const * - -ida_lines.user_defined_prefix_t.get_user_defined_prefix (method) - get_user_defined_prefix(self, ea, insn, lnnum, indent, line) - This callback must be overridden by the derived class. - - @param ea: (C++: ea_t) the current address - @param insn: (C++: const class insn_t &) the current instruction. if the current item is not an instruction, - then insn.itype is zero. - @param lnnum: (C++: int) number of the current line (each address may have several listing - lines for it). 0 means the very first line for the current - address. - @param indent: (C++: int) see explanations for gen_printf() - @param line: (C++: const char *) the line to be generated. the line usually contains color tags. - this argument can be examined to decide whether to generate the - prefix. - -ida_loader (module) - Definitions of IDP, LDR, PLUGIN module interfaces. - - This file also contains: - * functions to load files into the database - * functions to generate output files - * high level functions to work with the database (open, save, close) - - The LDR interface consists of one structure: loader_t - The IDP interface consists of one structure: processor_t - The PLUGIN interface consists of one structure: plugin_t - - Modules can't use standard FILE* functions. They must use functions from - <fpro.h> - - Modules can't use standard memory allocation functions. They must use functions - from <pro.h> - - The exported entry #1 in the module should point to the the appropriate - structure. (loader_t for LDR module, for example) - -ida_loader.ACCEPT_ARCHIVE (variable) - Specify that a file format is served by archive loader See loader_t::accept_file - -ida_loader.ACCEPT_CONTINUE (variable) - Specify that the function must be called another time See loader_t::accept_file - -ida_loader.ACCEPT_FIRST (variable) - Specify that a file format should be place first in "load file" dialog box. See - loader_t::accept_file - -ida_loader.DBFL_BAK (variable) - create backup file (if !DBFL_KILL) - -ida_loader.DBFL_COMP (variable) - collect garbage - -ida_loader.DBFL_KILL (variable) - delete unpacked database - -ida_loader.DBFL_TEMP (variable) - temporary database - -ida_loader.FILEREG_NOTPATCHABLE (variable) - the data is kept in some encoded form in the file. - -ida_loader.FILEREG_PATCHABLE (variable) - means that the input file may be patched (i.e. no compression, no iterated data, - etc) - -ida_loader.GENFLG_ASMINC (variable) - OFILE_ASM,OFILE_LST: gen information only about types - -ida_loader.GENFLG_ASMTYPE (variable) - OFILE_ASM,OFILE_LST: gen information about types too - -ida_loader.GENFLG_GENHTML (variable) - OFILE_ASM,OFILE_LST: generate html (ui_genfile_callback will be used) - -ida_loader.LDRF_RELOAD (variable) - loader recognizes NEF_RELOAD flag - -ida_loader.LDRF_REQ_PROC (variable) - Requires a processor to be set. if this bit is not set, load_file() must call - set_processor_type(..., SETPROC_LOADER) - -ida_loader.MAX_DATABASE_DESCRIPTION (variable) - Maximum database snapshot description length. - -ida_loader.NEF_CODE (variable) - for load_binary_file(): load as a code segment - -ida_loader.NEF_FILL (variable) - Fill segment gaps. - -ida_loader.NEF_FIRST (variable) - This is the first file loaded into the database. - -ida_loader.NEF_FLAT (variable) - Autocreate FLAT group (PE) - -ida_loader.NEF_IMPS (variable) - Create import segment. - -ida_loader.NEF_LALL (variable) - Load all segments without questions. - -ida_loader.NEF_LOPT (variable) - Display additional loader options dialog. - -ida_loader.NEF_MAN (variable) - Manual load. - -ida_loader.NEF_MINI (variable) - Create mini database (do not copy segment bytes from the input file; use only - the file header metadata) - -ida_loader.NEF_NAME (variable) - Rename entries. - -ida_loader.NEF_RELOAD (variable) - reload the file at the same place: - * don't create segments - * don't create fixup info - * don't import segments - * etc. - - Load only the bytes into the base. A loader should have the LDRF_RELOAD bit set. - -ida_loader.NEF_RSCS (variable) - Load resources. - -ida_loader.NEF_SEGS (variable) - Create segments. - -ida_loader.OFILE_ASM (variable) - Assembly. - -ida_loader.OFILE_DIF (variable) - Difference. - -ida_loader.OFILE_EXE (variable) - Executable file. - -ida_loader.OFILE_IDC (variable) - IDC file. - -ida_loader.OFILE_LST (variable) - Disassembly listing. - -ida_loader.OFILE_MAP (variable) - MAP file. - -ida_loader.PATH_TYPE_CMD (variable) - full path to the file specified in the command line - -ida_loader.PATH_TYPE_ID0 (variable) - full path of ID0 file - -ida_loader.PATH_TYPE_IDB (variable) - full path of IDB file - -ida_loader.PLUGIN_DLL (variable) - Pattern to find plugin files. - -ida_loader.SSF_AUTOMATIC (variable) - automatic snapshot - -ida_loader.SSUF_DESC (variable) - Update the description. - -ida_loader.SSUF_FLAGS (variable) - Update the flags. - -ida_loader.SSUF_PATH (variable) - Update the path. - -ida_loader.base2file (function) - base2file(fp, pos, ea1, ea2) -> int - Unload database to a binary file. This function works for wide byte processors - too. - - @param fp: (C++: FILE *) pointer to file - @param pos: (C++: qoff64_t) position in the file - @param ea1: (C++: ea_t) ,ea2: range of source linear addresses - @param ea2: (C++: ea_t) - @return: 1-ok(always), write error leads to immediate exit - -ida_loader.build_snapshot_tree (function) - build_snapshot_tree(root) -> bool - Build the snapshot tree. - - @param root: (C++: snapshot_t *) snapshot root that will contain the snapshot tree elements. - @return: success - -ida_loader.clr_database_flag (function) - clr_database_flag(dbfl) - - @param dbfl: uint32 - -ida_loader.extract_module_from_archive (function) - extract_module_from_archive(fname, is_remote=False) -> (NoneType, NoneType), (str, str) - Extract a module for an archive file. Parse an archive file, show the list of - modules to the user, allow him to select a module, extract the selected module - to a file (if the extract module is an archive, repeat the process). This - function can handle ZIP, AR, AIXAR, OMFLIB files. The temporary file will be - automatically deleted by IDA at the end. - - @param filename: (C++: char *) in: input file. out: name of the selected module. - @param is_remote: (C++: bool) is the input file remote? - @retval true: ok - @retval false: something bad happened (error message has been displayed to the - user) - -ida_loader.file2base (function) - file2base(li, 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: (C++: linput_t *) pointer of input source - @param pos: (C++: qoff64_t) position in the file - @param ea1: (C++: ea_t) ,ea2: range of destination linear addresses - @param patchable: (C++: int) should the kernel remember correspondence of file offsets to - linear addresses. - @retval 1: ok - @retval 0: read error, a warning is displayed - @note: The storage type of the specified range will be changed to STT_VA. - @param patchable: (C++: int) should the kernel remember correspondence of file offsets to - linear addresses. - @retval 1: ok - @retval 0: read error, a warning is displayed - @note: The storage type of the specified range will be changed to STT_VA. - -ida_loader.find_plugin (function) - find_plugin(name, load_if_needed=False) -> plugin_t * - Find a user-defined plugin and optionally load it. - - @param name: (C++: const char *) short plugin name without path and extension, or absolute path to - the file name - @param load_if_needed: (C++: bool) if the plugin is not present in the memory, try to load - it - @return: pointer to plugin description block - -ida_loader.flush_buffers (function) - flush_buffers() -> int - Flush buffers to the disk. - -ida_loader.gen_exe_file (function) - gen_exe_file(fp) -> int - Generate an exe file (unload the database in binary form). - - @param fp: (C++: FILE *) - @return: fp the output file handle. if fp == nullptr then return: - * 1: can generate an executable file - * 0: can't generate an executable file - @retval 1: ok - @retval 0: failed - -ida_loader.gen_file (function) - gen_file(otype, fp, ea1, ea2, flags) -> int - Generate an output file. - - @param otype: (C++: ofile_type_t) type of output file. - @param fp: (C++: FILE *) the output file handle - @param ea1: (C++: ea_t) start address. For some file types this argument is ignored - @param ea2: (C++: ea_t) end address. For some file types this argument is ignored as usual - in ida, the end address of the range is not included - @param flags: (C++: int) Generate file flagsOFILE_EXE: - @retval 0: can't generate exe file - @retval 1: ok - @return: number of the generated lines. -1 if an error occurred - -ida_loader.get_basic_file_type (function) - get_basic_file_type(li) -> filetype_t - Get the input file type. This function can recognize libraries and zip files. - - @param li: (C++: linput_t *) - -ida_loader.get_elf_debug_file_directory (function) - get_elf_debug_file_directory() -> char const * - Get the value of the ELF_DEBUG_FILE_DIRECTORY configuration directive. - -ida_loader.get_file_type_name (function) - get_file_type_name() -> str - Get name of the current file type. The current file type is kept in - idainfo::filetype. - - @return: size of answer, this function always succeeds - -ida_loader.get_fileregion_ea (function) - get_fileregion_ea(offset) -> ea_t - Get linear address which corresponds to the specified input file offset. If - can't be found, return BADADDR - - @param offset: (C++: qoff64_t) - -ida_loader.get_fileregion_offset (function) - get_fileregion_offset(ea) -> qoff64_t - Get offset in the input file which corresponds to the given ea. If the specified - ea can't be mapped into the input file offset, return -1. - - @param ea: (C++: ea_t) - -ida_loader.get_path (function) - get_path(pt) -> char const * - Get the file path - - @param pt: (C++: path_type_t) file path type Types of the file pathes - @return: file path, never returns nullptr - -ida_loader.get_plugin_options (function) - get_plugin_options(plugin) -> char const * - Get plugin options from the command line. If the user has specified the options - in the -Oplugin_name:options format, them this function will return the - 'options' part of it The 'plugin' parameter should denote the plugin name - Returns nullptr if there we no options specified - - @param plugin: (C++: const char *) char const * - -ida_loader.idp_desc_t (class) - Proxy of C++ idp_desc_t class. - -ida_loader.idp_desc_t.__init__ (method) - __init__(self) -> idp_desc_t - -ida_loader.idp_desc_t.checked (variable) - internal, for cache management - -ida_loader.idp_desc_t.family (variable) - processor's family - -ida_loader.idp_desc_t.is_script (variable) - the processor module is a script - -ida_loader.idp_desc_t.mtime (variable) - time of last modification - -ida_loader.idp_desc_t.names (variable) - processor names - -ida_loader.idp_desc_t.path (variable) - module file name - -ida_loader.idp_name_t (class) - Proxy of C++ idp_name_t class. - -ida_loader.idp_name_t.__init__ (method) - __init__(self) -> idp_name_t - -ida_loader.idp_name_t.hidden (variable) - is hidden - -ida_loader.idp_name_t.lname (variable) - long processor name - -ida_loader.idp_name_t.sname (variable) - short processor name - -ida_loader.is_database_flag (function) - is_database_flag(dbfl) -> bool - Get the current database flag - - @param dbfl: (C++: uint32) flag Database flags - @return: the state of the flag (set or cleared) - -ida_loader.is_trusted_idb (function) - is_trusted_idb() -> bool - Is the database considered as trusted? - -ida_loader.load_and_run_plugin (function) - load_and_run_plugin(name, arg) -> bool - Load & run a plugin. - - @param name: (C++: const char *) char const * - @param arg: (C++: size_t) - -ida_loader.load_binary_file (function) - load_binary_file(filename, li, _neflags, fileoff, basepara, binoff, nbytes) -> bool - Load a binary file into the database. This function usually is called from ui. - - @param filename: (C++: const char *) the name of input file as is (if the input file is from - library, then this is the name from the library) - @param li: (C++: linput_t *) loader input source - @param _neflags: (C++: ushort) Load file flags. For the first file, the flag NEF_FIRST must be - set. - @param fileoff: (C++: qoff64_t) Offset in the input file - @param basepara: (C++: ea_t) Load address in paragraphs - @param binoff: (C++: ea_t) Load offset (load_address=(basepara<<4)+binoff) - @param nbytes: (C++: uint64) Number of bytes to load from the file. - * 0: up to the end of the file - @retval true: ok - @retval false: failed (couldn't open the file) - -ida_loader.load_ids_module (function) - load_ids_module(fname) -> int - Load and apply IDS file. This function loads the specified IDS file and applies - it to the database. If the program imports functions from a module with the same - name as the name of the ids file being loaded, then only functions from this - module will be affected. Otherwise (i.e. when the program does not import a - module with this name) any function in the program may be affected. - - @param fname: (C++: char *) name of file to apply - @retval 1: ok - @retval 0: some error (a message is displayed). if the ids file does not exist, - no message is displayed - -ida_loader.load_plugin (function) - load_plugin(name) -> PyCapsule or None - Loads a plugin - - @param name: char const * - @return: - None if plugin could not be loaded - - An opaque object representing the loaded plugin - -ida_loader.loader_t (class) - Proxy of C++ loader_t class. - -ida_loader.loader_t.__init__ (method) - __init__(self) -> loader_t - -ida_loader.loader_t.flags (variable) - Loader flags - -ida_loader.loader_t.version (variable) - api version, should be IDP_INTERFACE_VERSION - -ida_loader.mem2base (function) - mem2base(py_mem, ea, fpos=-1) -> int - Load database from the memory. - - @param py_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 - -ida_loader.plugin_info_t (class) - Proxy of C++ plugin_info_t class. - -ida_loader.plugin_info_t.__init__ (method) - __init__(self) -> plugin_info_t - -ida_loader.plugin_info_t.arg (variable) - argument used to call the plugin - -ida_loader.plugin_info_t.comment (variable) - a copy of plugin_t::comment - -ida_loader.plugin_info_t.entry (variable) - pointer to the plugin if it is already loaded - -ida_loader.plugin_info_t.flags (variable) - a copy of plugin_t::flags - -ida_loader.plugin_info_t.hotkey (variable) - current hotkey to run the plugin - -ida_loader.plugin_info_t.name (variable) - short name of the plugin it will appear in the menu - -ida_loader.plugin_info_t.next (variable) - next plugin information - -ida_loader.plugin_info_t.org_hotkey (variable) - original hotkey to run the plugin - -ida_loader.plugin_info_t.org_name (variable) - original short name of the plugin - -ida_loader.plugin_info_t.path (variable) - full path to the plugin - -ida_loader.process_archive (function) - process_archive(temp_file, li, module_name, neflags, defmember, loader) -> str - Calls loader_t::process_archive() For parameters and return value description - look at loader_t::process_archive(). Additional parameter 'loader' is a pointer - to load_info_t structure. - - @param temp_file: (C++: qstring *) - @param li: (C++: linput_t *) - @param module_name: (C++: qstring *) - @param neflags: (C++: ushort *) - @param defmember: (C++: const char *) char const * - @param loader: (C++: const load_info_t *) load_info_t const * - -ida_loader.qvector_snapshotvec_t (class) - Proxy of C++ qvector< snapshot_t * > class. - -ida_loader.qvector_snapshotvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< snapshot_t * > const & - -ida_loader.qvector_snapshotvec_t.__getitem__ (method) - __getitem__(self, i) -> snapshot_t - - @param i: size_t - -ida_loader.qvector_snapshotvec_t.__init__ (method) - __init__(self) -> qvector_snapshotvec_t - __init__(self, x) -> qvector_snapshotvec_t - - @param x: qvector< snapshot_t * > const & - -ida_loader.qvector_snapshotvec_t.__len__ (method) - __len__(self) -> size_t - -ida_loader.qvector_snapshotvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< snapshot_t * > const & - -ida_loader.qvector_snapshotvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: snapshot_t *const & - -ida_loader.qvector_snapshotvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: snapshot_t *const & - -ida_loader.qvector_snapshotvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: snapshot_t *const & - -ida_loader.qvector_snapshotvec_t.at (method) - at(self, _idx) -> snapshot_t - - @param _idx: size_t - -ida_loader.qvector_snapshotvec_t.begin (method) - begin(self) -> qvector< snapshot_t * >::iterator - begin(self) -> qvector< snapshot_t * >::const_iterator - -ida_loader.qvector_snapshotvec_t.capacity (method) - capacity(self) -> size_t - -ida_loader.qvector_snapshotvec_t.clear (method) - clear(self) - -ida_loader.qvector_snapshotvec_t.empty (method) - empty(self) -> bool - -ida_loader.qvector_snapshotvec_t.end (method) - end(self) -> qvector< snapshot_t * >::iterator - end(self) -> qvector< snapshot_t * >::const_iterator - -ida_loader.qvector_snapshotvec_t.erase (method) - erase(self, it) -> qvector< snapshot_t * >::iterator - - @param it: qvector< snapshot_t * >::iterator - - erase(self, first, last) -> qvector< snapshot_t * >::iterator - - @param first: qvector< snapshot_t * >::iterator - @param last: qvector< snapshot_t * >::iterator - -ida_loader.qvector_snapshotvec_t.extract (method) - extract(self) -> snapshot_t ** - -ida_loader.qvector_snapshotvec_t.find (method) - find(self, x) -> qvector< snapshot_t * >::iterator - - @param x: snapshot_t *const & - - find(self, x) -> qvector< snapshot_t * >::const_iterator - - @param x: snapshot_t *const & - -ida_loader.qvector_snapshotvec_t.has (method) - has(self, x) -> bool - - @param x: snapshot_t *const & - -ida_loader.qvector_snapshotvec_t.inject (method) - inject(self, s, len) - - @param s: snapshot_t ** - @param len: size_t - -ida_loader.qvector_snapshotvec_t.insert (method) - insert(self, it, x) -> qvector< snapshot_t * >::iterator - - @param it: qvector< snapshot_t * >::iterator - @param x: snapshot_t *const & - -ida_loader.qvector_snapshotvec_t.pop_back (method) - pop_back(self) - -ida_loader.qvector_snapshotvec_t.push_back (method) - push_back(self, x) - - @param x: snapshot_t *const & - - push_back(self) -> snapshot_t *& - -ida_loader.qvector_snapshotvec_t.qclear (method) - qclear(self) - -ida_loader.qvector_snapshotvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_loader.qvector_snapshotvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: snapshot_t *const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_loader.qvector_snapshotvec_t.size (method) - size(self) -> size_t - -ida_loader.qvector_snapshotvec_t.swap (method) - swap(self, r) - - @param r: qvector< snapshot_t * > & - -ida_loader.qvector_snapshotvec_t.truncate (method) - truncate(self) - -ida_loader.reload_file (function) - reload_file(file, is_remote) -> bool - Reload the input file. This function reloads the byte values from the input - file. It doesn't modify the segmentation, names, comments, etc. - - @param file: (C++: const char *) name of the input file. if file == nullptr then returns: - * 1: can reload the input file - * 0: can't reload the input file - @param is_remote: (C++: bool) is the file located on a remote computer with the debugger - server? - @return: success - -ida_loader.run_plugin (function) - run_plugin(plg, arg) -> bool - Runs a plugin - - @param plg: A plugin object (returned by load_plugin()) - @param arg: size_t - @return: Boolean - -ida_loader.save_database (function) - save_database(outfile, flags, root=None, attr=None) -> bool - Save current database using a new file name. - - @param outfile: (C++: const char *) output database file name - @param flags: (C++: uint32) Database flags - @param root: (C++: const snapshot_t *) optional: snapshot tree root. - @param attr: (C++: const snapshot_t *) optional: snapshot attributes - @note: when both root and attr are not nullptr then the snapshot attributes will - be updated, otherwise the snapshot attributes will be inherited from the - current database. - @return: success - -ida_loader.set_database_flag (function) - set_database_flag(dbfl, cnd=True) - Set or clear database flag - - @param dbfl: (C++: uint32) flag Database flags - @param cnd: (C++: bool) set if true or clear flag otherwise - -ida_loader.set_import_name (function) - set_import_name(modnode, ea, name) - Set information about the named import entry. This function performs - 'modnode.supset_ea(ea, name);' - - @param modnode: (C++: uval_t) node with information about imported entries - @param ea: (C++: ea_t) linear address of the entry - @param name: (C++: const char *) name of the entry - -ida_loader.set_import_ordinal (function) - set_import_ordinal(modnode, ea, ord) - Set information about the ordinal import entry. This function performs - 'modnode.altset(ord, ea2node(ea));' - - @param modnode: (C++: uval_t) node with information about imported entries - @param ea: (C++: ea_t) linear address of the entry - @param ord: (C++: uval_t) ordinal number of the entry - -ida_loader.set_path (function) - set_path(pt, path) - Set the file path - - @param pt: (C++: path_type_t) file path type Types of the file pathes - @param path: (C++: const char *) new file path, use nullptr or empty string to clear the file path - -ida_loader.snapshot_t (class) - Proxy of C++ snapshot_t class. - -ida_loader.snapshot_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: snapshot_t const & - -ida_loader.snapshot_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: snapshot_t const & - -ida_loader.snapshot_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: snapshot_t const & - -ida_loader.snapshot_t.__init__ (method) - __init__(self) -> snapshot_t - -ida_loader.snapshot_t.__le__ (method) - __le__(self, r) -> bool - - @param r: snapshot_t const & - -ida_loader.snapshot_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: snapshot_t const & - -ida_loader.snapshot_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: snapshot_t const & - -ida_loader.snapshot_t.children (variable) - snapshot children - -ida_loader.snapshot_t.clear (method) - clear(self) - -ida_loader.snapshot_t.desc (variable) - snapshot description - -ida_loader.snapshot_t.filename (variable) - snapshot file name - -ida_loader.snapshot_t.flags (variable) - Snapshot flags - -ida_loader.snapshot_t.id (variable) - snapshot ID. This value is computed using qgettimeofday() - -ida_moves (module) - - -ida_moves.bookmarks_t (class) - Proxy of C++ bookmarks_t class. - -ida_moves.bookmarks_t.__getitem__ (method) - Get the n-th bookmark for the widget. - -ida_moves.bookmarks_t.__init__ (method) - -ida_moves.bookmarks_t.__init__ (method) - Build an object suitable for iterating bookmarks - associated with the specified widget. - - Note: all ea_t-based widgets (e.g., "IDA View-*", - "Pseudocode-*", "Hex View-*", ...) share a common storage, - so bookmarks can be re-used interchangeably between them - -ida_moves.bookmarks_t.__iter__ (method) - Iterate on bookmarks present for the widget. - -ida_moves.bookmarks_t.__len__ (method) - Get the number of bookmarks for the widget. - -ida_moves.bookmarks_t.erase (method) - erase(e, index, ud) -> bool - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t.find_index (method) - find_index(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t.get (method) - get(out, _index, ud) -> PyObject * - - @param out: lochist_entry_t * - @param _index: uint32 - @param ud: void * - -ida_moves.bookmarks_t.get_desc (method) - get_desc(e, index, ud) -> bool - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t.get_dirtree_id (method) - get_dirtree_id(e, ud) -> dirtree_id_t - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t.mark (method) - mark(e, index, title, desc, ud) -> uint32 - - @param e: lochist_entry_t const & - @param index: uint32 - @param title: char const * - @param desc: char const * - @param ud: void * - -ida_moves.bookmarks_t.size (method) - size(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t_erase (function) - bookmarks_t_erase(e, index, ud) -> bool - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t_find_index (function) - bookmarks_t_find_index(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t_get (function) - bookmarks_t_get(out, _index, ud) -> PyObject * - - @param out: lochist_entry_t * - @param _index: uint32 - @param ud: void * - -ida_moves.bookmarks_t_get_desc (function) - bookmarks_t_get_desc(e, index, ud) -> str - - @param e: lochist_entry_t const & - @param index: uint32 - @param ud: void * - -ida_moves.bookmarks_t_get_dirtree_id (function) - bookmarks_t_get_dirtree_id(e, ud) -> dirtree_id_t - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.bookmarks_t_mark (function) - bookmarks_t_mark(e, index, title, desc, ud) -> uint32 - - @param e: lochist_entry_t const & - @param index: uint32 - @param title: char const * - @param desc: char const * - @param ud: void * - -ida_moves.bookmarks_t_size (function) - bookmarks_t_size(e, ud) -> uint32 - - @param e: lochist_entry_t const & - @param ud: void * - -ida_moves.graph_location_info_t (class) - Proxy of C++ graph_location_info_t class. - -ida_moves.graph_location_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: graph_location_info_t const & - -ida_moves.graph_location_info_t.__init__ (method) - __init__(self) -> graph_location_info_t - -ida_moves.graph_location_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: graph_location_info_t const & - -ida_moves.lochist_entry_t (class) - Proxy of C++ lochist_entry_t class. - -ida_moves.lochist_entry_t.__init__ (method) - __init__(self) -> lochist_entry_t - __init__(self, p, r) -> lochist_entry_t - - @param p: place_t const * - @param r: renderer_info_t const & - - __init__(self, other) -> lochist_entry_t - - @param other: lochist_entry_t const & - -ida_moves.lochist_entry_t.acquire_place (method) - acquire_place(self, in_p) - - @param in_p: place_t * - -ida_moves.lochist_entry_t.is_valid (method) - is_valid(self) -> bool - -ida_moves.lochist_entry_t.place (method) - place(self) -> place_t - -ida_moves.lochist_entry_t.renderer_info (method) - renderer_info(self) -> renderer_info_t - -ida_moves.lochist_entry_t.set_place (method) - set_place(self, p) - - @param p: place_t const * - -ida_moves.lochist_t (class) - Proxy of C++ lochist_t class. - -ida_moves.lochist_t.__init__ (method) - __init__(self) -> lochist_t - -ida_moves.lochist_t.back (method) - back(self, cnt, try_to_unhide) -> bool - - @param cnt: uint32 - @param try_to_unhide: bool - -ida_moves.lochist_t.clear (method) - clear(self) - -ida_moves.lochist_t.current_index (method) - current_index(self) -> uint32 - -ida_moves.lochist_t.fwd (method) - fwd(self, cnt, try_to_unhide) -> bool - - @param cnt: uint32 - @param try_to_unhide: bool - -ida_moves.lochist_t.get (method) - get(self, out, index) -> bool - - @param out: lochist_entry_t * - @param index: uint32 - -ida_moves.lochist_t.get_current (method) - get_current(self) -> lochist_entry_t - -ida_moves.lochist_t.get_place_id (method) - get_place_id(self) -> int - -ida_moves.lochist_t.get_template_place (method) - get_template_place(self) -> place_t - -ida_moves.lochist_t.init (method) - init(self, stream_name, _defpos, _ud, _flags) -> bool - - @param stream_name: char const * - @param _defpos: place_t const * - @param _ud: void * - @param _flags: uint32 - -ida_moves.lochist_t.is_history_enabled (method) - is_history_enabled(self) -> bool - -ida_moves.lochist_t.jump (method) - jump(self, try_to_unhide, e) - - @param try_to_unhide: bool - @param e: lochist_entry_t const & - -ida_moves.lochist_t.netcode (method) - netcode(self) -> nodeidx_t - -ida_moves.lochist_t.save (method) - save(self) - -ida_moves.lochist_t.seek (method) - seek(self, index, try_to_unhide) -> bool - - @param index: uint32 - @param try_to_unhide: bool - -ida_moves.lochist_t.set (method) - set(self, index, e) - - @param index: uint32 - @param e: lochist_entry_t const & - -ida_moves.lochist_t.set_current (method) - set_current(self, e) - - @param e: lochist_entry_t const & - -ida_moves.lochist_t.size (method) - size(self) -> uint32 - -ida_moves.renderer_info_pos_t (class) - Proxy of C++ renderer_info_pos_t class. - -ida_moves.renderer_info_pos_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: renderer_info_pos_t const & - -ida_moves.renderer_info_pos_t.__init__ (method) - __init__(self) -> renderer_info_pos_t - -ida_moves.renderer_info_pos_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: renderer_info_pos_t const & - -ida_moves.renderer_info_t (class) - Proxy of C++ renderer_info_t class. - -ida_moves.renderer_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: renderer_info_t const & - -ida_moves.renderer_info_t.__init__ (method) - __init__(self) -> renderer_info_t - __init__(self, _rtype, cx, cy) -> renderer_info_t - - @param _rtype: enum tcc_renderer_type_t - @param cx: short - @param cy: short - -ida_moves.renderer_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: renderer_info_t const & - -ida_moves.segm_move_info_t (class) - Proxy of C++ segm_move_info_t class. - -ida_moves.segm_move_info_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: segm_move_info_t const & - -ida_moves.segm_move_info_t.__init__ (method) - __init__(self, _from=0, _to=0, _sz=0) -> segm_move_info_t - - @param _from: ea_t - @param _to: ea_t - @param _sz: size_t - -ida_moves.segm_move_info_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t (class) - Proxy of C++ qvector< segm_move_info_t > class. - -ida_moves.segm_move_info_vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< segm_move_info_t > const & - -ida_moves.segm_move_info_vec_t.__getitem__ (method) - __getitem__(self, i) -> segm_move_info_t - - @param i: size_t - -ida_moves.segm_move_info_vec_t.__init__ (method) - __init__(self) -> segm_move_info_vec_t - __init__(self, x) -> segm_move_info_vec_t - - @param x: qvector< segm_move_info_t > const & - -ida_moves.segm_move_info_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_moves.segm_move_info_vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< segm_move_info_t > const & - -ida_moves.segm_move_info_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.at (method) - at(self, _idx) -> segm_move_info_t - - @param _idx: size_t - -ida_moves.segm_move_info_vec_t.begin (method) - begin(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.capacity (method) - capacity(self) -> size_t - -ida_moves.segm_move_info_vec_t.clear (method) - clear(self) - -ida_moves.segm_move_info_vec_t.empty (method) - empty(self) -> bool - -ida_moves.segm_move_info_vec_t.end (method) - end(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.erase (method) - erase(self, it) -> segm_move_info_t - - @param it: qvector< segm_move_info_t >::iterator - - erase(self, first, last) -> segm_move_info_t - - @param first: qvector< segm_move_info_t >::iterator - @param last: qvector< segm_move_info_t >::iterator - -ida_moves.segm_move_info_vec_t.extract (method) - extract(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.find (method) - find(self, x) -> segm_move_info_t - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.grow (method) - grow(self, x=segm_move_info_t()) - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.has (method) - has(self, x) -> bool - - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.inject (method) - inject(self, s, len) - - @param s: segm_move_info_t * - @param len: size_t - -ida_moves.segm_move_info_vec_t.insert (method) - insert(self, it, x) -> segm_move_info_t - - @param it: qvector< segm_move_info_t >::iterator - @param x: segm_move_info_t const & - -ida_moves.segm_move_info_vec_t.pop_back (method) - pop_back(self) - -ida_moves.segm_move_info_vec_t.push_back (method) - push_back(self, x) - - @param x: segm_move_info_t const & - - push_back(self) -> segm_move_info_t - -ida_moves.segm_move_info_vec_t.qclear (method) - qclear(self) - -ida_moves.segm_move_info_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_moves.segm_move_info_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: segm_move_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_moves.segm_move_info_vec_t.size (method) - size(self) -> size_t - -ida_moves.segm_move_info_vec_t.swap (method) - swap(self, r) - - @param r: qvector< segm_move_info_t > & - -ida_moves.segm_move_info_vec_t.truncate (method) - truncate(self) - -ida_moves.segm_move_infos_t (class) - Proxy of C++ segm_move_infos_t class. - -ida_moves.segm_move_infos_t.__init__ (method) - __init__(self) -> segm_move_infos_t - -ida_moves.segm_move_infos_t.find (method) - find(self, ea) -> segm_move_info_t - - @param ea: ea_t - -ida_nalt (module) - Definitions of various information kept in netnodes. - - Each address in the program has a corresponding netnode: netnode(ea). - - If we have no information about an address, the corresponding netnode is not - created. Otherwise we will create a netnode and save information in it. All - variable length information (names, comments, offset information, etc) is stored - in the netnode. - - Don't forget that some information is already stored in the flags (bytes.hpp) - - @warning: Many of the functions in this file are very low level (they are marked - as low level functions). Use them only if you can't find higher level - function to set/get/del information.netnode. - -ida_nalt.AFL_ALIGNFLOW (variable) - the previous insn was created for alignment purposes only - -ida_nalt.AFL_BNOT0 (variable) - the 1st operand is bitwise negated - -ida_nalt.AFL_BNOT1 (variable) - the 2nd operand is bitwise negated - -ida_nalt.AFL_COLORED (variable) - has user defined instruction color? - -ida_nalt.AFL_FIXEDSPD (variable) - sp delta value is fixed by analysis. should not be modified by modules - -ida_nalt.AFL_HIDDEN (variable) - the item is hidden completely - -ida_nalt.AFL_HR_DETERMINED (variable) - the type is definitely guessed by the decompiler - -ida_nalt.AFL_HR_GUESSED_DATA (variable) - the data type is guessed by the decompiler - -ida_nalt.AFL_HR_GUESSED_FUNC (variable) - the function type is guessed by the decompiler - -ida_nalt.AFL_IDA_GUESSED (variable) - the type is guessed by IDA - -ida_nalt.AFL_LIB (variable) - item from the standard library. low level flag, is used to set FUNC_LIB of - func_t - -ida_nalt.AFL_LINNUM (variable) - has line number info - -ida_nalt.AFL_LNAME (variable) - has local name too (FF_NAME should be set) - -ida_nalt.AFL_LZERO0 (variable) - toggle leading zeroes for the 1st operand - -ida_nalt.AFL_LZERO1 (variable) - toggle leading zeroes for the 2nd operand - -ida_nalt.AFL_MANUAL (variable) - the instruction/data is specified by the user - -ida_nalt.AFL_NOBRD (variable) - the code/data border is hidden - -ida_nalt.AFL_NORET (variable) - for imported function pointers: doesn't return. this flag can also be used for - any instruction which halts or finishes the program execution - -ida_nalt.AFL_NOTCODE (variable) - autoanalysis should not create code here - -ida_nalt.AFL_NOTPROC (variable) - autoanalysis should not create proc here - -ida_nalt.AFL_PUBNAM (variable) - name is public (inter-file linkage) - -ida_nalt.AFL_RETFP (variable) - function returns a floating point value - -ida_nalt.AFL_TERSESTR (variable) - terse structure variable display? - -ida_nalt.AFL_TI (variable) - has typeinfo? (NSUP_TYPEINFO); used only for addresses, not for member_t - -ida_nalt.AFL_TI0 (variable) - has typeinfo for operand 0? (NSUP_OPTYPES) - -ida_nalt.AFL_TI1 (variable) - has typeinfo for operand 1? (NSUP_OPTYPES+1) - -ida_nalt.AFL_TILCMT (variable) - has type comment? (such a comment may be changed by IDA) - -ida_nalt.AFL_TYPE_GUESSED (variable) - who guessed the type information? - -ida_nalt.AFL_USEMODSP (variable) - insn modifes SP and uses the modified value; example: pop [rsp+N] - -ida_nalt.AFL_USERSP (variable) - user-defined SP value - -ida_nalt.AFL_USERTI (variable) - the type information is definitive. (comes from the user or type library) if not - set see AFL_TYPE_GUESSED - -ida_nalt.AFL_WEAKNAM (variable) - name is weak - -ida_nalt.AFL_ZSTROFF (variable) - display struct field name at 0 offset when displaying an offset. example: - offset somestruct.field_0 if this flag is clear, then - offset somestruct - -ida_nalt.AP_ALLOWDUPS (variable) - use 'dup' construct - -ida_nalt.AP_ARRAY (variable) - create as array (this flag is not stored in database) - -ida_nalt.AP_IDXBASEMASK (variable) - mask for number base of the indexes - -ida_nalt.AP_IDXBIN (variable) - display indexes in binary - -ida_nalt.AP_IDXDEC (variable) - display indexes in decimal - -ida_nalt.AP_IDXHEX (variable) - display indexes in hex - -ida_nalt.AP_IDXOCT (variable) - display indexes in octal - -ida_nalt.AP_INDEX (variable) - display array element indexes as comments - -ida_nalt.AP_SIGNED (variable) - treats numbers as signed - -ida_nalt.IDB_DESKTOPS_NODE_NAME (variable) - hash indexed by desktop name with dekstop netnode - -ida_nalt.IDB_DESKTOPS_TAG (variable) - tag to store desktop blob & timestamp - -ida_nalt.MAXSTRUCPATH (variable) - maximal inclusion depth of unions - -ida_nalt.NALT_ABSBASE (variable) - absolute segment location - -ida_nalt.NALT_AFLAGS (variable) - additional flags for an item - -ida_nalt.NALT_ALIGN (variable) - alignment value if the item is FF_ALIGN (should by equal to power of 2) - -ida_nalt.NALT_COLOR (variable) - instruction/data background color - -ida_nalt.NALT_CREF_FROM (variable) - code xref from, idx: source address - -ida_nalt.NALT_CREF_TO (variable) - code xref to, idx: target address - -ida_nalt.NALT_DREF_FROM (variable) - data xref from, idx: source address - -ida_nalt.NALT_DREF_TO (variable) - data xref to, idx: target address - -ida_nalt.NALT_ENUM0 (variable) - enum id for the first operand - -ida_nalt.NALT_ENUM1 (variable) - enum id for the second operand - -ida_nalt.NALT_GR_LAYX (variable) - group layout ptrs, hash: md5 of 'belongs' - -ida_nalt.NALT_LINNUM (variable) - source line number - -ida_nalt.NALT_PURGE (variable) - number of bytes purged from the stack when a function is called indirectly - -ida_nalt.NALT_STRTYPE (variable) - type of string item - -ida_nalt.NALT_STRUCT (variable) - struct id - -ida_nalt.NALT_SWITCH (variable) - switch idiom address (used at jump targets) - -ida_nalt.NSUP_ARGEAS (variable) - instructions that initialize call arguments - -ida_nalt.NSUP_ARRAY (variable) - array parameters - -ida_nalt.NSUP_CMT (variable) - regular comment - -ida_nalt.NSUP_CUSTDT (variable) - custom data type id - -ida_nalt.NSUP_EX_FLAGS (variable) - Extended flags. - -ida_nalt.NSUP_FOP1 (variable) - forced operand 1 - -ida_nalt.NSUP_FOP2 (variable) - forced operand 2 - -ida_nalt.NSUP_FOP3 (variable) - forced operand 3 - -ida_nalt.NSUP_FOP4 (variable) - forced operand 4 - -ida_nalt.NSUP_FOP5 (variable) - forced operand 5 - -ida_nalt.NSUP_FOP6 (variable) - forced operand 6 - -ida_nalt.NSUP_FOP7 (variable) - forced operand 7 - -ida_nalt.NSUP_FOP8 (variable) - forced operand 8 - -ida_nalt.NSUP_FTAILS (variable) - function tails or tail referers values NSUP_FTAILS..NSUP_FTAILS+0x1000 are - reserved - -ida_nalt.NSUP_GROUP (variable) - graph group information values NSUP_GROUP..NSUP_GROUP+0x1000 are reserved - -ida_nalt.NSUP_GR_INFO (variable) - group node info: color, ea, text - -ida_nalt.NSUP_GR_LAYT (variable) - group layouts, idx: layout pointer - -ida_nalt.NSUP_JINFO (variable) - jump table info - -ida_nalt.NSUP_LLABEL (variable) - local labels. values NSUP_LLABEL..NSUP_LLABEL+0x1000 are reserved - -ida_nalt.NSUP_MANUAL (variable) - manual instruction. values NSUP_MANUAL..NSUP_MANUAL+0x1000 are reserved - -ida_nalt.NSUP_OPTYPES (variable) - operand type information. values NSUP_OPTYPES..NSUP_OPTYPES+0x100000 are - reserved - -ida_nalt.NSUP_OREF0 (variable) - outer complex reference information for operand 1 - -ida_nalt.NSUP_OREF1 (variable) - outer complex reference information for operand 2 - -ida_nalt.NSUP_OREF2 (variable) - outer complex reference information for operand 3 - -ida_nalt.NSUP_OREF3 (variable) - outer complex reference information for operand 4 - -ida_nalt.NSUP_OREF4 (variable) - outer complex reference information for operand 5 - -ida_nalt.NSUP_OREF5 (variable) - outer complex reference information for operand 6 - -ida_nalt.NSUP_OREF6 (variable) - outer complex reference information for operand 7 - -ida_nalt.NSUP_OREF7 (variable) - outer complex reference information for operand 8 - -ida_nalt.NSUP_ORIGFMD (variable) - function metadata before lumina information was applied values - NSUP_ORIGFMD..NSUP_ORIGFMD+0x1000 are reserved - -ida_nalt.NSUP_POINTS (variable) - SP change points blob (see funcs.cpp). values NSUP_POINTS..NSUP_POINTS+0x1000 - are reserved - -ida_nalt.NSUP_REF0 (variable) - complex reference information for operand 1 - -ida_nalt.NSUP_REF1 (variable) - complex reference information for operand 2 - -ida_nalt.NSUP_REF2 (variable) - complex reference information for operand 3 - -ida_nalt.NSUP_REF3 (variable) - complex reference information for operand 4 - -ida_nalt.NSUP_REF4 (variable) - complex reference information for operand 5 - -ida_nalt.NSUP_REF5 (variable) - complex reference information for operand 6 - -ida_nalt.NSUP_REF6 (variable) - complex reference information for operand 7 - -ida_nalt.NSUP_REF7 (variable) - complex reference information for operand 8 - -ida_nalt.NSUP_REGARG (variable) - register argument type/name descriptions values NSUP_REGARG..NSUP_REGARG+0x1000 - are reserved - -ida_nalt.NSUP_REGVAR (variable) - register variables. values NSUP_REGVAR..NSUP_REGVAR+0x1000 are reserved - -ida_nalt.NSUP_REPCMT (variable) - repeatable comment - -ida_nalt.NSUP_SEGTRANS (variable) - segment translations - -ida_nalt.NSUP_SWITCH (variable) - switch information - -ida_nalt.NSUP_TYPEINFO (variable) - type information. values NSUP_TYPEINFO..NSUP_TYPEINFO+0x1000 are reserved - -ida_nalt.NSUP_XREFPOS (variable) - saved xref address and type in the xrefs window - -ida_nalt.PATCH_TAG (variable) - Patch netnode tag. - -ida_nalt.REFINFO_CUSTOM (variable) - a custom reference. see custom_refinfo_handler_t. the id of the custom refinfo - is stored under the REFINFO_TYPE mask. - -ida_nalt.REFINFO_NOBASE (variable) - don't create the base xref; implies that the base can be any value. nb: base - xrefs are created only if the offset base points to the middle of a segment - -ida_nalt.REFINFO_NO_ONES (variable) - an opval of ~0 will be considered invalid - -ida_nalt.REFINFO_NO_ZEROS (variable) - an opval of 0 will be considered invalid - -ida_nalt.REFINFO_PASTEND (variable) - reference past an item; it may point to an nonexistent address; do not destroy - alignment dirs - -ida_nalt.REFINFO_RVAOFF (variable) - based reference (rva); refinfo_t::base will be forced to get_imagebase(); such a - reference is displayed with the asm_t::a_rva keyword - -ida_nalt.REFINFO_SELFREF (variable) - the self-based reference; refinfo_t::base will be forced to the reference - address - -ida_nalt.REFINFO_SIGNEDOP (variable) - the operand value is sign-extended (only supported for REF_OFF8/16/32/64) - -ida_nalt.REFINFO_SUBTRACT (variable) - the reference value is subtracted from the base value instead of (as usual) - being added to it - -ida_nalt.REFINFO_TYPE (variable) - reference type (reftype_t), or custom reference ID if REFINFO_CUSTOM set - -ida_nalt.REF_HIGH16 (variable) - high 16bits of 32bit offset - -ida_nalt.REF_HIGH8 (variable) - high 8bits of 16bit offset - -ida_nalt.REF_LOW16 (variable) - low 16bits of 32bit offset - -ida_nalt.REF_LOW8 (variable) - low 8bits of 16bit offset - -ida_nalt.REF_OFF16 (variable) - 16bit full offset - -ida_nalt.REF_OFF32 (variable) - 32bit full offset - -ida_nalt.REF_OFF64 (variable) - 64bit full offset - -ida_nalt.REF_OFF8 (variable) - 8bit full offset - -ida_nalt.RIDX_ABINAME (variable) - ABI name (processor specific) - -ida_nalt.RIDX_ARCHIVE_PATH (variable) - archive file path - -ida_nalt.RIDX_C_MACROS (variable) - C predefined macros. - -ida_nalt.RIDX_DBG_BINPATHS (variable) - unused (20 indexes) - -ida_nalt.RIDX_DUALOP_GRAPH (variable) - Graph text representation options. - -ida_nalt.RIDX_DUALOP_TEXT (variable) - Text text representation options. - -ida_nalt.RIDX_FILE_FORMAT_NAME (variable) - file format name for loader modules - -ida_nalt.RIDX_GROUPS (variable) - segment group information (see init_groups()) - -ida_nalt.RIDX_H_PATH (variable) - C header path. - -ida_nalt.RIDX_IDA_VERSION (variable) - version of ida which created the database - -ida_nalt.RIDX_INCLUDE (variable) - assembler include file name - -ida_nalt.RIDX_MD5 (variable) - MD5 of the input file. - -ida_nalt.RIDX_NOTEPAD (variable) - notepad blob, occupies 1000 indexes (1MB of text) - -ida_nalt.RIDX_PROBLEMS (variable) - problem lists - -ida_nalt.RIDX_SELECTORS (variable) - 2..63 are for selector_t blob (see init_selectors()) - -ida_nalt.RIDX_SHA256 (variable) - SHA256 of the input file. - -ida_nalt.RIDX_SMALL_IDC (variable) - Instant IDC statements, blob. - -ida_nalt.RIDX_SMALL_IDC_OLD (variable) - Instant IDC statements (obsolete) - -ida_nalt.RIDX_SRCDBG_PATHS (variable) - source debug paths, occupies 20 indexes - -ida_nalt.RIDX_SRCDBG_UNDESIRED (variable) - user-closed source files, occupies 20 indexes - -ida_nalt.RIDX_STR_ENCODINGS (variable) - a list of encodings for the program strings - -ida_nalt.STRENC_DEFAULT (variable) - use default encoding for this type (see get_default_encoding_idx()) - -ida_nalt.STRENC_NONE (variable) - force no-conversion encoding - -ida_nalt.STRTYPE_C (variable) - Zero-terminated 16bit chars. - -ida_nalt.STRTYPE_C_16 (variable) - Zero-terminated 32bit chars. - -ida_nalt.STRTYPE_C_32 (variable) - Pascal-style, one-byte length prefix. - -ida_nalt.STRTYPE_LEN2 (variable) - Pascal-style, 16bit chars, two-byte length prefix. - -ida_nalt.STRTYPE_LEN2_16 (variable) - Pascal-style, 32bit chars, two-byte length prefix. - -ida_nalt.STRTYPE_LEN2_32 (variable) - Pascal-style, four-byte length prefix. - -ida_nalt.STRTYPE_LEN4 (variable) - Pascal-style, 16bit chars, four-byte length prefix. - -ida_nalt.STRTYPE_LEN4_16 (variable) - Pascal-style, 32bit chars, four-byte length prefix. - -ida_nalt.STRTYPE_PASCAL (variable) - Pascal-style, 16bit chars, one-byte length prefix. - -ida_nalt.STRTYPE_PASCAL_16 (variable) - Pascal-style, 32bit chars, one-byte length prefix. - -ida_nalt.STRTYPE_PASCAL_32 (variable) - Pascal-style, two-byte length prefix. - -ida_nalt.STRTYPE_TERMCHR (variable) - C-style string. - -ida_nalt.SWI_CUSTOM (variable) - custom jump table. processor_t::create_switch_xrefs will be called to create - code xrefs for the table. Custom jump table must be created by the module (see - also SWI_STDTBL) - -ida_nalt.SWI_DEFRET (variable) - return in the default case (defjump==BADADDR) - -ida_nalt.SWI_DEF_IN_TBL (variable) - default case is an entry in the jump table. This flag is applicable in 2 cases: - * The sparse indirect switch (i.e. a switch with a values table) {jump table - size} == {value table size} + 1. The default case entry is the last one in the - table (or the first one in the case of an inversed jump table). - * The switch with insns in the jump table. The default case entry is before the - first entry of the table. - See also the find_defjump_from_table() helper function. - -ida_nalt.SWI_ELBASE (variable) - elbase is present (otherwise the base of the switch segment will be used) - -ida_nalt.SWI_HXNOLOWCASE (variable) - lowcase value should not be used by the decompiler (internal flag) - -ida_nalt.SWI_INDIRECT (variable) - value table elements are used as indexes into the jump table (for sparse - switches) - -ida_nalt.SWI_J32 (variable) - 32-bit jump offsets - -ida_nalt.SWI_JMPINSN (variable) - jump table entries are insns. For such entries SHIFT has a different meaning. It - denotes the number of insns in the entry. For example, 0 - the entry contains - the jump to the case, 1 - the entry contains one insn like a 'mov' and jump to - the end of case, and so on. - -ida_nalt.SWI_JMP_INV (variable) - jumptable is inversed. (last entry is for first entry in values table) - -ida_nalt.SWI_JSIZE (variable) - jump offset expansion bit - -ida_nalt.SWI_SELFREL (variable) - jump address is relative to the element not to ELBASE - -ida_nalt.SWI_SEPARATE (variable) - create an array of individual elements (otherwise separate items) - -ida_nalt.SWI_SHIFT_MASK (variable) - use formula (element<<shift) + elbase to find jump targets - -ida_nalt.SWI_SIGNED (variable) - jump table entries are signed - -ida_nalt.SWI_SPARSE (variable) - sparse switch (value table present), otherwise lowcase present - -ida_nalt.SWI_STDTBL (variable) - custom jump table with standard table formatting. ATM IDA doesn't use SWI_CUSTOM - for switches with standard table formatting. So this flag can be considered as - obsolete. - -ida_nalt.SWI_SUBTRACT (variable) - table values are subtracted from the elbase instead of being added - -ida_nalt.SWI_USER (variable) - user specified switch (starting from version 2) - -ida_nalt.SWI_V32 (variable) - 32-bit values in table - -ida_nalt.SWI_VERSION (variable) - the structure contains the VERSION member - -ida_nalt.SWI_VSIZE (variable) - value table element size expansion bit - -ida_nalt.SWI_VSPLIT (variable) - value table is split (only for 32-bit values) - -ida_nalt.V695_REF_OFF8 (variable) - reserved - -ida_nalt.V695_REF_VHIGH (variable) - obsolete - -ida_nalt.V695_REF_VLOW (variable) - obsolete - -ida_nalt.add_encoding (function) - add_encoding(encname) -> int - Add a new encoding (e.g. "UTF-8"). If it's already in the list, return its - index. - - @param encname: (C++: const char *) the encoding name - @return: its index (1-based); -1 means error - -ida_nalt.array_parameters_t (class) - Proxy of C++ array_parameters_t class. - -ida_nalt.array_parameters_t.__init__ (method) - __init__(self, _f=0x00000001, _l=0, _a=-1) -> array_parameters_t - - @param _f: int32 - @param _l: int32 - @param _a: int32 - -ida_nalt.array_parameters_t.alignment (variable) - -1 - don't align. 0 - align automatically. else item width - -ida_nalt.array_parameters_t.is_default (method) - is_default(self) -> bool - -ida_nalt.array_parameters_t.lineitems (variable) - number of items on a line - -ida_nalt.clr__bnot0 (function) - clr__bnot0(ea) - - @param ea: ea_t - -ida_nalt.clr__bnot1 (function) - clr__bnot1(ea) - - @param ea: ea_t - -ida_nalt.clr__invsign0 (function) - clr__invsign0(ea) - - @param ea: ea_t - -ida_nalt.clr__invsign1 (function) - clr__invsign1(ea) - - @param ea: ea_t - -ida_nalt.clr_abits (function) - clr_abits(ea, bits) - - @param ea: ea_t - @param bits: aflags_t - -ida_nalt.clr_align_flow (function) - clr_align_flow(ea) - - @param ea: ea_t - -ida_nalt.clr_colored_item (function) - clr_colored_item(ea) - - @param ea: ea_t - -ida_nalt.clr_fixed_spd (function) - clr_fixed_spd(ea) - - @param ea: ea_t - -ida_nalt.clr_has_lname (function) - clr_has_lname(ea) - - @param ea: ea_t - -ida_nalt.clr_has_ti (function) - clr_has_ti(ea) - - @param ea: ea_t - -ida_nalt.clr_has_ti0 (function) - clr_has_ti0(ea) - - @param ea: ea_t - -ida_nalt.clr_has_ti1 (function) - clr_has_ti1(ea) - - @param ea: ea_t - -ida_nalt.clr_libitem (function) - clr_libitem(ea) - - @param ea: ea_t - -ida_nalt.clr_lzero0 (function) - clr_lzero0(ea) - - @param ea: ea_t - -ida_nalt.clr_lzero1 (function) - clr_lzero1(ea) - - @param ea: ea_t - -ida_nalt.clr_noret (function) - clr_noret(ea) - - @param ea: ea_t - -ida_nalt.clr_notcode (function) - clr_notcode(ea) - Clear not-code mark. - - @param ea: (C++: ea_t) - -ida_nalt.clr_notproc (function) - clr_notproc(ea) - - @param ea: ea_t - -ida_nalt.clr_retfp (function) - clr_retfp(ea) - - @param ea: ea_t - -ida_nalt.clr_terse_struc (function) - clr_terse_struc(ea) - - @param ea: ea_t - -ida_nalt.clr_tilcmt (function) - clr_tilcmt(ea) - - @param ea: ea_t - -ida_nalt.clr_usemodsp (function) - clr_usemodsp(ea) - - @param ea: ea_t - -ida_nalt.clr_usersp (function) - clr_usersp(ea) - - @param ea: ea_t - -ida_nalt.clr_userti (function) - clr_userti(ea) - - @param ea: ea_t - -ida_nalt.clr_zstroff (function) - clr_zstroff(ea) - - @param ea: ea_t - -ida_nalt.custom_data_type_ids_fids_array (class) - Proxy of C++ wrapped_array_t< int16,8 > class. - -ida_nalt.custom_data_type_ids_fids_array.__getitem__ (method) - __getitem__(self, i) -> short const & - - @param i: size_t - -ida_nalt.custom_data_type_ids_fids_array.__init__ (method) - __init__(self, data) -> custom_data_type_ids_fids_array - - @param data: short (&)[8] - -ida_nalt.custom_data_type_ids_fids_array.__len__ (method) - __len__(self) -> size_t - -ida_nalt.custom_data_type_ids_fids_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: short const & - -ida_nalt.custom_data_type_ids_fids_array._get_bytes (method) - _get_bytes(self) -> bytevec_t - -ida_nalt.custom_data_type_ids_fids_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & - -ida_nalt.custom_data_type_ids_t (class) - Proxy of C++ custom_data_type_ids_t class. - -ida_nalt.custom_data_type_ids_t.__getFids (method) - __getFids(self) -> custom_data_type_ids_fids_array - -ida_nalt.custom_data_type_ids_t.__init__ (method) - __init__(self) -> custom_data_type_ids_t - -ida_nalt.custom_data_type_ids_t.dtid (variable) - data type id - -ida_nalt.custom_data_type_ids_t.fids (variable) - data format ids - -ida_nalt.custom_data_type_ids_t.get_dtid (method) - get_dtid(self) -> tid_t - -ida_nalt.custom_data_type_ids_t.set (method) - set(self, tid) - - @param tid: tid_t - -ida_nalt.dbg_get_input_path (function) - dbg_get_input_path() -> str - Get debugger input file name/path (see LFLG_DBG_NOPATH) - -ida_nalt.del_absbase (function) - del_absbase(ea) - - @param ea: ea_t - -ida_nalt.del_aflags (function) - del_aflags(ea) - - @param ea: ea_t - -ida_nalt.del_alignment (function) - del_alignment(ea) - - @param ea: ea_t - -ida_nalt.del_array_parameters (function) - del_array_parameters(ea) - - @param ea: ea_t - -ida_nalt.del_custom_data_type_ids (function) - del_custom_data_type_ids(ea) - - @param ea: ea_t - -ida_nalt.del_encoding (function) - del_encoding(idx) -> bool - Delete an encoding The encoding is not actually removed because its index may be - used in strtype. So the deletion just clears the encoding name. The default - encoding cannot be deleted. - - @param idx: (C++: int) the encoding index (1-based) - -ida_nalt.del_ind_purged (function) - del_ind_purged(ea) - - @param ea: ea_t - -ida_nalt.del_item_color (function) - del_item_color(ea) -> bool - - @param ea: ea_t - -ida_nalt.del_op_tinfo (function) - del_op_tinfo(ea, n) - - @param ea: ea_t - @param n: int - -ida_nalt.del_refinfo (function) - del_refinfo(ea, n) -> bool - - @param ea: ea_t - @param n: int - -ida_nalt.del_source_linnum (function) - del_source_linnum(ea) - - @param ea: ea_t - -ida_nalt.del_str_type (function) - del_str_type(ea) - - @param ea: ea_t - -ida_nalt.del_switch_info (function) - del_switch_info(ea) - - @param ea: ea_t - -ida_nalt.del_switch_parent (function) - del_switch_parent(ea) - - @param ea: ea_t - -ida_nalt.del_tinfo (function) - del_tinfo(ea) - - @param ea: ea_t - -ida_nalt.delete_imports (function) - delete_imports() - Delete all imported modules information. - -ida_nalt.ea2node (function) - ea2node(ea) -> nodeidx_t - Get netnode for the specified address. - - @param ea: (C++: ea_t) - -ida_nalt.encoding_from_strtype (function) - encoding_from_strtype(strtype) -> char const * - Get encoding name for this strtype - @retval nullptr: if STRTYPE has an incorrent encoding index - @retval empty: string if the encoding was deleted - - @param strtype: (C++: int32) - -ida_nalt.end_ea2node (function) - end_ea2node(ea) -> nodeidx_t - - @param ea: ea_t - -ida_nalt.enum_const_t (class) - Proxy of C++ enum_const_t class. - -ida_nalt.enum_const_t.__init__ (method) - __init__(self) -> enum_const_t - -ida_nalt.enum_import_names (function) - 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) - -ida_nalt.find_custom_refinfo (function) - find_custom_refinfo(name) -> int - Get id of a custom refinfo type. - - @param name: (C++: const char *) char const * - -ida_nalt.get_abi_name (function) - -ida_nalt.get_absbase (function) - get_absbase(ea) -> ea_t - - @param ea: ea_t - -ida_nalt.get_aflags (function) - get_aflags(ea) -> aflags_t - - @param ea: ea_t - -ida_nalt.get_alignment (function) - get_alignment(ea) -> uint32 - - @param ea: ea_t - -ida_nalt.get_archive_path (function) - get_archive_path() -> str - Get archive file path from which input file was extracted. - -ida_nalt.get_array_parameters (function) - get_array_parameters(out, ea) -> ssize_t - - @param out: array_parameters_t * - @param ea: ea_t - -ida_nalt.get_asm_inc_file (function) - get_asm_inc_file() -> str - Get name of the include file. - -ida_nalt.get_custom_data_type_ids (function) - get_custom_data_type_ids(cdis, ea) -> int - - @param cdis: custom_data_type_ids_t * - @param ea: ea_t - -ida_nalt.get_custom_refinfo (function) - get_custom_refinfo(crid) -> custom_refinfo_handler_t const * - Get definition of a registered custom refinfo type. - - @param crid: (C++: int) - -ida_nalt.get_default_encoding_idx (function) - get_default_encoding_idx(bpu) -> int - Get default encoding index for a specific string type. - - @param bpu: (C++: int) the amount of bytes per unit (e.g., 1 for ASCII, CP1252, UTF-8..., 2 - for UTF-16, 4 for UTF-32) - @retval 0: bad BPU argument - -ida_nalt.get_elapsed_secs (function) - get_elapsed_secs() -> size_t - Get seconds database stayed open. - -ida_nalt.get_encoding_bpu (function) - get_encoding_bpu(idx) -> int - Get the amount of bytes per unit (e.g., 2 for UTF-16, 4 for UTF-32) for the - encoding with the given index. - - @param idx: (C++: int) the encoding index (1-based) - @return: the number of bytes per units (1/2/4); -1 means error - -ida_nalt.get_encoding_bpu_by_name (function) - get_encoding_bpu_by_name(encname) -> int - Get the amount of bytes per unit for the given encoding - - @param encname: (C++: const char *) the encoding name - @return: the number of bytes per units (1/2/4); -1 means error - -ida_nalt.get_encoding_name (function) - get_encoding_name(idx) -> char const * - Get encoding name for specific index (1-based). - - @param idx: (C++: int) the encoding index (1-based) - @retval nullptr: if IDX is out of bounds - @retval empty: string if the encoding was deleted - -ida_nalt.get_encoding_qty (function) - get_encoding_qty() -> int - Get total number of encodings (counted from 0) - -ida_nalt.get_gotea (function) - get_gotea() -> ea_t - -ida_nalt.get_ida_notepad_text (function) - get_ida_notepad_text() -> str - Get notepad text. - -ida_nalt.get_idb_ctime (function) - get_idb_ctime() -> time_t - Get database creation timestamp. - -ida_nalt.get_idb_nopens (function) - get_idb_nopens() -> size_t - Get number of times the database is opened. - -ida_nalt.get_ids_modnode (function) - get_ids_modnode() -> netnode - Get ids modnode. - -ida_nalt.get_imagebase (function) - get_imagebase() -> ea_t - Get image base address. - -ida_nalt.get_import_module_name (function) - get_import_module_name(mod_index) -> str - Returns the name of an imported module given its index - - @param mod_index: int - @return: None or the module name - -ida_nalt.get_import_module_qty (function) - get_import_module_qty() -> uint - Get number of import modules. - -ida_nalt.get_ind_purged (function) - get_ind_purged(ea) -> ea_t - - @param ea: ea_t - -ida_nalt.get_initial_ida_version (function) - get_initial_ida_version() -> str - Get version of ida which created the database (string format like "7.5") - -ida_nalt.get_initial_idb_version (function) - get_initial_idb_version() -> ushort - Get initial version of the database (numeric format like 700) - -ida_nalt.get_input_file_path (function) - get_input_file_path() -> str - Get full path of the input file. - -ida_nalt.get_item_color (function) - get_item_color(ea) -> bgcolor_t - - @param ea: ea_t - -ida_nalt.get_loader_format_name (function) - get_loader_format_name() -> str - Get file format name for loader modules. - -ida_nalt.get_op_tinfo (function) - get_op_tinfo(tif, ea, n) -> bool - - @param tif: tinfo_t * - @param ea: ea_t - @param n: int - -ida_nalt.get_outfile_encoding_idx (function) - get_outfile_encoding_idx() -> int - Get the index of the encoding used when producing files - @retval 0: the IDB's default 1 byte-per-unit encoding is used - -ida_nalt.get_refinfo (function) - get_refinfo(ri, ea, n) -> bool - - @param ri: refinfo_t * - @param ea: ea_t - @param n: int - -ida_nalt.get_reftype_by_size (function) - get_reftype_by_size(size) -> reftype_t - Get REF_... constant from size Supported sizes: 1,2,4,8,16 For other sizes - returns reftype_t(-1) - - @param size: (C++: size_t) - -ida_nalt.get_root_filename (function) - get_root_filename() -> str - Get file name only of the input file. - -ida_nalt.get_source_linnum (function) - get_source_linnum(ea) -> uval_t - - @param ea: ea_t - -ida_nalt.get_srcdbg_paths (function) - get_srcdbg_paths() -> str - Get source debug paths. - -ida_nalt.get_srcdbg_undesired_paths (function) - get_srcdbg_undesired_paths() -> str - Get user-closed source files. - -ida_nalt.get_str_encoding_idx (function) - get_str_encoding_idx(strtype) -> uchar - Get index of the string encoding for this string. - - @param strtype: (C++: int32) - -ida_nalt.get_str_term1 (function) - get_str_term1(strtype) -> char - - @param strtype: int32 - -ida_nalt.get_str_term2 (function) - get_str_term2(strtype) -> char - - @param strtype: int32 - -ida_nalt.get_str_type (function) - get_str_type(ea) -> uint32 - - @param ea: ea_t - -ida_nalt.get_str_type_code (function) - get_str_type_code(strtype) -> uchar - - @param strtype: int32 - -ida_nalt.get_str_type_prefix_length (function) - get_str_type_prefix_length(strtype) -> size_t - - @param strtype: int32 - -ida_nalt.get_strid (function) - get_strid(ea) -> tid_t - - @param ea: ea_t - -ida_nalt.get_strtype_bpu (function) - get_strtype_bpu(strtype) -> int - - @param strtype: int32 - -ida_nalt.get_switch_info (function) - get_switch_info(out, ea) -> ssize_t - - @param out: switch_info_t * - @param ea: ea_t - -ida_nalt.get_switch_info (function) - -ida_nalt.get_switch_parent (function) - get_switch_parent(ea) -> ea_t - - @param ea: ea_t - -ida_nalt.get_tinfo (function) - get_tinfo(tif, ea) -> bool - - @param tif: tinfo_t * - @param ea: ea_t - -ida_nalt.getnode (function) - getnode(ea) -> netnode - - @param ea: ea_t - -ida_nalt.has_aflag_linnum (function) - has_aflag_linnum(flags) -> bool - - @param flags: aflags_t - -ida_nalt.has_aflag_lname (function) - has_aflag_lname(flags) -> bool - - @param flags: aflags_t - -ida_nalt.has_aflag_ti (function) - has_aflag_ti(flags) -> bool - - @param flags: aflags_t - -ida_nalt.has_aflag_ti0 (function) - has_aflag_ti0(flags) -> bool - - @param flags: aflags_t - -ida_nalt.has_aflag_ti1 (function) - has_aflag_ti1(flags) -> bool - - @param flags: aflags_t - -ida_nalt.has_lname (function) - has_lname(ea) -> bool - - @param ea: ea_t - -ida_nalt.has_ti (function) - has_ti(ea) -> bool - - @param ea: ea_t - -ida_nalt.has_ti0 (function) - has_ti0(ea) -> bool - - @param ea: ea_t - -ida_nalt.has_ti1 (function) - has_ti1(ea) -> bool - - @param ea: ea_t - -ida_nalt.hide_border (function) - hide_border(ea) - - @param ea: ea_t - -ida_nalt.hide_item (function) - hide_item(ea) - - @param ea: ea_t - -ida_nalt.is__bnot0 (function) - is__bnot0(ea) -> bool - - @param ea: ea_t - -ida_nalt.is__bnot1 (function) - is__bnot1(ea) -> bool - - @param ea: ea_t - -ida_nalt.is__invsign0 (function) - is__invsign0(ea) -> bool - - @param ea: ea_t - -ida_nalt.is__invsign1 (function) - is__invsign1(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_aflag__bnot0 (function) - is_aflag__bnot0(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag__bnot1 (function) - is_aflag__bnot1(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag__invsign0 (function) - is_aflag__invsign0(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag__invsign1 (function) - is_aflag__invsign1(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_align_flow (function) - is_aflag_align_flow(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_colored_item (function) - is_aflag_colored_item(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_data_guessed_by_hexrays (function) - is_aflag_data_guessed_by_hexrays(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_fixed_spd (function) - is_aflag_fixed_spd(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_func_guessed_by_hexrays (function) - is_aflag_func_guessed_by_hexrays(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_hidden_border (function) - is_aflag_hidden_border(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_hidden_item (function) - is_aflag_hidden_item(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_libitem (function) - is_aflag_libitem(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_lzero0 (function) - is_aflag_lzero0(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_lzero1 (function) - is_aflag_lzero1(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_manual_insn (function) - is_aflag_manual_insn(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_noret (function) - is_aflag_noret(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_notcode (function) - is_aflag_notcode(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_notproc (function) - is_aflag_notproc(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_public_name (function) - is_aflag_public_name(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_retfp (function) - is_aflag_retfp(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_terse_struc (function) - is_aflag_terse_struc(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_tilcmt (function) - is_aflag_tilcmt(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_type_determined_by_hexrays (function) - is_aflag_type_determined_by_hexrays(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_type_guessed_by_hexrays (function) - is_aflag_type_guessed_by_hexrays(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_type_guessed_by_ida (function) - is_aflag_type_guessed_by_ida(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_usersp (function) - is_aflag_usersp(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_userti (function) - is_aflag_userti(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_weak_name (function) - is_aflag_weak_name(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_aflag_zstroff (function) - is_aflag_zstroff(flags) -> bool - - @param flags: aflags_t - -ida_nalt.is_align_flow (function) - is_align_flow(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_colored_item (function) - is_colored_item(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_data_guessed_by_hexrays (function) - is_data_guessed_by_hexrays(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_finally_visible_item (function) - is_finally_visible_item(ea) -> bool - Is instruction visible? - - @param ea: (C++: ea_t) - -ida_nalt.is_fixed_spd (function) - is_fixed_spd(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_func_guessed_by_hexrays (function) - is_func_guessed_by_hexrays(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_hidden_border (function) - is_hidden_border(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_hidden_item (function) - is_hidden_item(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_libitem (function) - is_libitem(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_lzero0 (function) - is_lzero0(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_lzero1 (function) - is_lzero1(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_noret (function) - is_noret(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_notcode (function) - is_notcode(ea) -> bool - Is the address marked as not-code? - - @param ea: (C++: ea_t) - -ida_nalt.is_notproc (function) - is_notproc(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_pascal (function) - is_pascal(strtype) -> bool - - @param strtype: int32 - -ida_nalt.is_reftype_target_optional (function) - is_reftype_target_optional(type) -> bool - Can the target be calculated using operand value? - - @param type: (C++: reftype_t) - -ida_nalt.is_retfp (function) - is_retfp(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_terse_struc (function) - is_terse_struc(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_tilcmt (function) - is_tilcmt(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_type_determined_by_hexrays (function) - is_type_determined_by_hexrays(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_type_guessed_by_hexrays (function) - is_type_guessed_by_hexrays(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_type_guessed_by_ida (function) - is_type_guessed_by_ida(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_usersp (function) - is_usersp(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_userti (function) - is_userti(ea) -> bool - - @param ea: ea_t - -ida_nalt.is_visible_item (function) - is_visible_item(ea) -> bool - Test visibility of item at given ea. - - @param ea: (C++: ea_t) - -ida_nalt.is_zstroff (function) - is_zstroff(ea) -> bool - - @param ea: ea_t - -ida_nalt.make_str_type (function) - make_str_type(type_code, encoding_idx, term1=0, term2=0) -> int32 - Get string type for a string in the given encoding. - - @param type_code: (C++: uchar) - @param encoding_idx: (C++: int) - @param term1: (C++: uchar) - @param term2: (C++: uchar) - -ida_nalt.node2ea (function) - node2ea(ndx) -> ea_t - - @param ndx: nodeidx_t - -ida_nalt.opinfo_t (class) - Proxy of C++ opinfo_t class. - -ida_nalt.opinfo_t.__init__ (method) - __init__(self) -> opinfo_t - -ida_nalt.opinfo_t.cd (variable) - for custom data - -ida_nalt.opinfo_t.ec (variable) - for enums - -ida_nalt.opinfo_t.path (variable) - for stroff - -ida_nalt.opinfo_t.ri (variable) - for offset members - -ida_nalt.opinfo_t.strtype (variable) - for strings (String type codes) - -ida_nalt.opinfo_t.tid (variable) - for struct, etc. members - -ida_nalt.printop_t (class) - Proxy of C++ printop_t class. - -ida_nalt.printop_t.__init__ (method) - __init__(self) -> printop_t - -ida_nalt.printop_t.get_ti (method) - get_ti(self) -> opinfo_t - -ida_nalt.printop_t.is_aflags_initialized (method) - is_aflags_initialized(self) -> bool - -ida_nalt.printop_t.is_f64 (method) - is_f64(self) -> bool - -ida_nalt.printop_t.is_ti_initialized (method) - is_ti_initialized(self) -> bool - -ida_nalt.printop_t.set_aflags_initialized (method) - set_aflags_initialized(self, v=True) - - @param v: bool - -ida_nalt.printop_t.set_ti_initialized (method) - set_ti_initialized(self, v=True) - - @param v: bool - -ida_nalt.refinfo_t (class) - Proxy of C++ refinfo_t class. - -ida_nalt.refinfo_t.__init__ (method) - __init__(self) -> refinfo_t - -ida_nalt.refinfo_t.base (variable) - base of reference (may be BADADDR) - -ida_nalt.refinfo_t.flags (variable) - Reference info flags - -ida_nalt.refinfo_t.init (method) - init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0) - - @param reft_and_flags: uint32 - @param _base: ea_t - @param _target: ea_t - @param _tdelta: adiff_t - -ida_nalt.refinfo_t.is_custom (method) - is_custom(self) -> bool - -ida_nalt.refinfo_t.is_no_ones (method) - is_no_ones(self) -> bool - -ida_nalt.refinfo_t.is_no_zeros (method) - is_no_zeros(self) -> bool - -ida_nalt.refinfo_t.is_pastend (method) - is_pastend(self) -> bool - -ida_nalt.refinfo_t.is_rvaoff (method) - is_rvaoff(self) -> bool - -ida_nalt.refinfo_t.is_selfref (method) - is_selfref(self) -> bool - -ida_nalt.refinfo_t.is_signed (method) - is_signed(self) -> bool - -ida_nalt.refinfo_t.is_subtract (method) - is_subtract(self) -> bool - -ida_nalt.refinfo_t.is_target_optional (method) - is_target_optional(self) -> bool - < is_reftype_target_optional() - -ida_nalt.refinfo_t.no_base_xref (method) - no_base_xref(self) -> bool - -ida_nalt.refinfo_t.set_type (method) - set_type(self, rt) - - @param rt: reftype_t - -ida_nalt.refinfo_t.target (variable) - reference target (BADADDR-none) - -ida_nalt.refinfo_t.tdelta (variable) - offset from the target - -ida_nalt.refinfo_t.type (method) - type(self) -> reftype_t - -ida_nalt.rename_encoding (function) - rename_encoding(idx, encname) -> bool - Change name for an encoding The number of bytes per unit (BPU) of the new - encoding must match this number of the existing default encoding. Specifying the - empty name simply deletes this encoding. - - @param idx: (C++: int) the encoding index (1-based) - @param encname: (C++: const char *) the new encoding name - -ida_nalt.retrieve_input_file_crc32 (function) - retrieve_input_file_crc32() -> uint32 - Get input file crc32 stored in the database. it can be used to check that the - input file has not been changed. - -ida_nalt.retrieve_input_file_md5 (function) - retrieve_input_file_md5() -> bytes - Get input file md5. - -ida_nalt.retrieve_input_file_sha256 (function) - retrieve_input_file_sha256() -> bytes - Get input file sha256. - -ida_nalt.retrieve_input_file_size (function) - retrieve_input_file_size() -> size_t - Get size of input file in bytes. - -ida_nalt.set__bnot0 (function) - set__bnot0(ea) - - @param ea: ea_t - -ida_nalt.set__bnot1 (function) - set__bnot1(ea) - - @param ea: ea_t - -ida_nalt.set__invsign0 (function) - set__invsign0(ea) - - @param ea: ea_t - -ida_nalt.set__invsign1 (function) - set__invsign1(ea) - - @param ea: ea_t - -ida_nalt.set_abits (function) - set_abits(ea, bits) - - @param ea: ea_t - @param bits: aflags_t - -ida_nalt.set_absbase (function) - set_absbase(ea, x) - - @param ea: ea_t - @param x: ea_t - -ida_nalt.set_aflags (function) - set_aflags(ea, flags) - - @param ea: ea_t - @param flags: aflags_t - -ida_nalt.set_align_flow (function) - set_align_flow(ea) - - @param ea: ea_t - -ida_nalt.set_alignment (function) - set_alignment(ea, x) - - @param ea: ea_t - @param x: uint32 - -ida_nalt.set_archive_path (function) - set_archive_path(file) -> bool - Set archive file path from which input file was extracted. - - @param file: (C++: const char *) char const * - -ida_nalt.set_array_parameters (function) - set_array_parameters(ea, _in) - - @param ea: ea_t - @param in: array_parameters_t const * - -ida_nalt.set_asm_inc_file (function) - set_asm_inc_file(file) -> bool - Set name of the include file. - - @param file: (C++: const char *) char const * - -ida_nalt.set_colored_item (function) - set_colored_item(ea) - - @param ea: ea_t - -ida_nalt.set_custom_data_type_ids (function) - set_custom_data_type_ids(ea, cdis) - - @param ea: ea_t - @param cdis: custom_data_type_ids_t const * - -ida_nalt.set_data_guessed_by_hexrays (function) - set_data_guessed_by_hexrays(ea) - - @param ea: ea_t - -ida_nalt.set_default_encoding_idx (function) - set_default_encoding_idx(bpu, idx) -> bool - Set default encoding for a string type - - @param bpu: (C++: int) the amount of bytes per unit - @param idx: (C++: int) the encoding index. It cannot be 0 - -ida_nalt.set_fixed_spd (function) - set_fixed_spd(ea) - - @param ea: ea_t - -ida_nalt.set_func_guessed_by_hexrays (function) - set_func_guessed_by_hexrays(ea) - - @param ea: ea_t - -ida_nalt.set_gotea (function) - set_gotea(gotea) - - @param gotea: ea_t - -ida_nalt.set_has_lname (function) - set_has_lname(ea) - - @param ea: ea_t - -ida_nalt.set_has_ti (function) - set_has_ti(ea) - - @param ea: ea_t - -ida_nalt.set_has_ti0 (function) - set_has_ti0(ea) - - @param ea: ea_t - -ida_nalt.set_has_ti1 (function) - set_has_ti1(ea) - - @param ea: ea_t - -ida_nalt.set_ida_notepad_text (function) - set_ida_notepad_text(text, size=0) - Set notepad text. - - @param text: (C++: const char *) char const * - @param size: (C++: size_t) - -ida_nalt.set_ids_modnode (function) - set_ids_modnode(id) - Set ids modnode. - - @param id: (C++: netnode) - -ida_nalt.set_imagebase (function) - set_imagebase(base) - Set image base address. - - @param base: (C++: ea_t) - -ida_nalt.set_item_color (function) - set_item_color(ea, color) - - @param ea: ea_t - @param color: bgcolor_t - -ida_nalt.set_libitem (function) - set_libitem(ea) - - @param ea: ea_t - -ida_nalt.set_loader_format_name (function) - set_loader_format_name(name) - Set file format name for loader modules. - - @param name: (C++: const char *) char const * - -ida_nalt.set_lzero0 (function) - set_lzero0(ea) - - @param ea: ea_t - -ida_nalt.set_lzero1 (function) - set_lzero1(ea) - - @param ea: ea_t - -ida_nalt.set_noret (function) - set_noret(ea) - - @param ea: ea_t - -ida_nalt.set_notcode (function) - set_notcode(ea) - Mark address so that it cannot be converted to instruction. - - @param ea: (C++: ea_t) - -ida_nalt.set_notproc (function) - set_notproc(ea) - - @param ea: ea_t - -ida_nalt.set_op_tinfo (function) - set_op_tinfo(ea, n, tif) -> bool - - @param ea: ea_t - @param n: int - @param tif: tinfo_t const * - -ida_nalt.set_outfile_encoding_idx (function) - set_outfile_encoding_idx(idx) -> bool - set encoding to be used when producing files - - @param idx: (C++: int) the encoding index IDX can be 0 to use the IDB's default 1-byte-per- - unit encoding - -ida_nalt.set_refinfo (function) - set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> bool - - @param ea: ea_t - @param n: int - @param type: reftype_t - @param target: ea_t - @param base: ea_t - @param tdelta: adiff_t - -ida_nalt.set_refinfo_ex (function) - set_refinfo_ex(ea, n, ri) -> bool - - @param ea: ea_t - @param n: int - @param ri: refinfo_t const * - -ida_nalt.set_retfp (function) - set_retfp(ea) - - @param ea: ea_t - -ida_nalt.set_root_filename (function) - set_root_filename(file) - Set full path of the input file. - - @param file: (C++: const char *) char const * - -ida_nalt.set_source_linnum (function) - set_source_linnum(ea, lnnum) - - @param ea: ea_t - @param lnnum: uval_t - -ida_nalt.set_srcdbg_paths (function) - set_srcdbg_paths(paths) - Set source debug paths. - - @param paths: (C++: const char *) char const * - -ida_nalt.set_srcdbg_undesired_paths (function) - set_srcdbg_undesired_paths(paths) - Set user-closed source files. - - @param paths: (C++: const char *) char const * - -ida_nalt.set_str_encoding_idx (function) - set_str_encoding_idx(strtype, encoding_idx) -> int32 - Set index of the string encoding in the string type. - - @param strtype: (C++: int32) - @param encoding_idx: (C++: int) - -ida_nalt.set_str_type (function) - set_str_type(ea, x) - - @param ea: ea_t - @param x: uint32 - -ida_nalt.set_switch_info (function) - set_switch_info(ea, _in) - - @param ea: ea_t - @param in: switch_info_t const & - -ida_nalt.set_switch_parent (function) - set_switch_parent(ea, x) - - @param ea: ea_t - @param x: ea_t - -ida_nalt.set_terse_struc (function) - set_terse_struc(ea) - - @param ea: ea_t - -ida_nalt.set_tilcmt (function) - set_tilcmt(ea) - - @param ea: ea_t - -ida_nalt.set_tinfo (function) - set_tinfo(ea, tif) -> bool - - @param ea: ea_t - @param tif: tinfo_t const * - -ida_nalt.set_type_determined_by_hexrays (function) - set_type_determined_by_hexrays(ea) - - @param ea: ea_t - -ida_nalt.set_type_guessed_by_ida (function) - set_type_guessed_by_ida(ea) - - @param ea: ea_t - -ida_nalt.set_usemodsp (function) - set_usemodsp(ea) - - @param ea: ea_t - -ida_nalt.set_usersp (function) - set_usersp(ea) - - @param ea: ea_t - -ida_nalt.set_userti (function) - set_userti(ea) - - @param ea: ea_t - -ida_nalt.set_visible_item (function) - set_visible_item(ea, visible) - Change visibility of item at given ea. - - @param ea: (C++: ea_t) - @param visible: (C++: bool) - -ida_nalt.set_zstroff (function) - set_zstroff(ea) - - @param ea: ea_t - -ida_nalt.strpath_ids_array (class) - Proxy of C++ wrapped_array_t< tid_t,32 > class. - -ida_nalt.strpath_ids_array.__getitem__ (method) - __getitem__(self, i) -> unsigned-ea-like-numeric-type const & - - @param i: size_t - -ida_nalt.strpath_ids_array.__init__ (method) - __init__(self, data) -> strpath_ids_array - - @param data: unsigned-ea-like-numeric-type (&)[32] - -ida_nalt.strpath_ids_array.__len__ (method) - __len__(self) -> size_t - -ida_nalt.strpath_ids_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned-ea-like-numeric-type const & - -ida_nalt.strpath_ids_array._get_bytes (method) - _get_bytes(self) -> bytevec_t - -ida_nalt.strpath_ids_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & - -ida_nalt.strpath_t (class) - Proxy of C++ strpath_t class. - -ida_nalt.strpath_t.__getIds (method) - __getIds(self) -> strpath_ids_array - -ida_nalt.strpath_t.__init__ (method) - __init__(self) -> strpath_t - -ida_nalt.switch_info_t (class) - Proxy of C++ switch_info_t class. - -ida_nalt.switch_info_t.__init__ (method) - __init__(self) -> switch_info_t - -ida_nalt.switch_info_t._get_values_lowcase (method) - _get_values_lowcase(self) -> ea_t - -ida_nalt.switch_info_t._set_values_lowcase (method) - _set_values_lowcase(self, values) - - Parameters - ---------- - values: ea_t - -ida_nalt.switch_info_t.assign (method) - assign(self, other) - - @param other: switch_info_t const & - -ida_nalt.switch_info_t.clear (method) - clear(self) - -ida_nalt.switch_info_t.custom (variable) - information for custom tables (filled and used by modules) - -ida_nalt.switch_info_t.defjump (variable) - default jump address (BADADDR if no default case) - -ida_nalt.switch_info_t.elbase (variable) - element base - -ida_nalt.switch_info_t.expr_ea (variable) - the address before that the switch expression is in REGNUM. If BADADDR, then the - first insn marked as IM_SWITCH after STARTEA is used. - -ida_nalt.switch_info_t.flags (variable) - Switch info flags - -ida_nalt.switch_info_t.get_jrange_vrange (method) - get_jrange_vrange(self, jrange=None, vrange=None) -> bool - get separate parts of the switch - - @param jrange: (C++: range_t *) - @param vrange: (C++: range_t *) - -ida_nalt.switch_info_t.get_jtable_element_size (method) - get_jtable_element_size(self) -> int - -ida_nalt.switch_info_t.get_jtable_size (method) - get_jtable_size(self) -> int - -ida_nalt.switch_info_t.get_lowcase (method) - get_lowcase(self) -> sval_t - -ida_nalt.switch_info_t.get_shift (method) - get_shift(self) -> int - See SWI_SHIFT_MASK. possible answers: 0..3. - -ida_nalt.switch_info_t.get_version (method) - get_version(self) -> int - -ida_nalt.switch_info_t.get_vtable_element_size (method) - get_vtable_element_size(self) -> int - -ida_nalt.switch_info_t.has_default (method) - has_default(self) -> bool - -ida_nalt.switch_info_t.has_elbase (method) - has_elbase(self) -> bool - -ida_nalt.switch_info_t.is_custom (method) - is_custom(self) -> bool - -ida_nalt.switch_info_t.is_indirect (method) - is_indirect(self) -> bool - -ida_nalt.switch_info_t.is_nolowcase (method) - is_nolowcase(self) -> bool - -ida_nalt.switch_info_t.is_sparse (method) - is_sparse(self) -> bool - -ida_nalt.switch_info_t.is_subtract (method) - is_subtract(self) -> bool - -ida_nalt.switch_info_t.is_user_defined (method) - is_user_defined(self) -> bool - -ida_nalt.switch_info_t.jcases (variable) - number of entries in the jump table (SWI_INDIRECT) - -ida_nalt.switch_info_t.jumps (variable) - jump table start address - -ida_nalt.switch_info_t.lowcase (variable) - the lowest value in cases - -ida_nalt.switch_info_t.marks (variable) - the insns marked as IM_SWITCH. They are used to delete the switch. - -ida_nalt.switch_info_t.ncases (variable) - number of cases (excluding default) - -ida_nalt.switch_info_t.regdtype (variable) - size of the switch expression register as dtype - -ida_nalt.switch_info_t.regnum (variable) - the switch expression as a value of the REGNUM register before the instruction - at EXPR_EA. -1 means 'unknown' - -ida_nalt.switch_info_t.set_elbase (method) - set_elbase(self, base) - - @param base: ea_t - -ida_nalt.switch_info_t.set_expr (method) - set_expr(self, r, dt) - - @param r: int - @param dt: op_dtype_t - -ida_nalt.switch_info_t.set_jtable_element_size (method) - set_jtable_element_size(self, size) - - @param size: int - -ida_nalt.switch_info_t.set_jtable_size (method) - set_jtable_size(self, size) - - @param size: int - -ida_nalt.switch_info_t.set_shift (method) - set_shift(self, shift) - See SWI_SHIFT_MASK. - - @param shift: (C++: int) - -ida_nalt.switch_info_t.set_vtable_element_size (method) - set_vtable_element_size(self, size) - - @param size: int - -ida_nalt.switch_info_t.startea (variable) - start of the switch idiom - -ida_nalt.switch_info_t.use_std_table (method) - use_std_table(self) -> bool - -ida_nalt.switch_info_t.values (variable) - values table address (if SWI_SPARSE is set) - -ida_nalt.switch_info_t__from_ptrval__ (function) - switch_info_t__from_ptrval__(ptrval) -> switch_info_t - - @param ptrval: size_t - -ida_nalt.unhide_border (function) - unhide_border(ea) - - @param ea: ea_t - -ida_nalt.unhide_item (function) - unhide_item(ea) - - @param ea: ea_t - -ida_nalt.upd_abits (function) - upd_abits(ea, clr_bits, set_bits) - - @param ea: ea_t - @param clr_bits: aflags_t - @param set_bits: aflags_t - -ida_nalt.uses_aflag_modsp (function) - uses_aflag_modsp(flags) -> bool - - @param flags: aflags_t - -ida_nalt.uses_modsp (function) - uses_modsp(ea) -> bool - - @param ea: ea_t - -ida_nalt.validate_idb_names (function) - validate_idb_names(do_repair) -> int - - @param do_repair: bool - -ida_name (module) - Functions that deal with names. - - A non-tail address of the program may have a name. Tail addresses (i.e. the - addresses in the middle of an instruction or data item) cannot have names. - -ida_name.DEBNAME_EXACT (variable) - find a name at exactly the specified address - -ida_name.DEBNAME_LOWER (variable) - find a name with the address >= the specified address - -ida_name.DEBNAME_NICE (variable) - find a name with the address <= the specified address - -ida_name.DEBNAME_UPPER (variable) - find a name with the address > the specified address - -ida_name.FUNC_IMPORT_PREFIX (variable) - Name prefix used by IDA for the imported functions. - -ida_name.GETN_APPZERO (variable) - meaningful only if the name refers to a structure. append a struct field name if - the field offset is zero? - -ida_name.GETN_NODUMMY (variable) - do not create a new dummy name but pretend it exists - -ida_name.GETN_NOFIXUP (variable) - ignore the fixup information when producing the name - -ida_name.GNCN_NOCOLOR (variable) - generate an uncolored name - -ida_name.GNCN_NODBGNM (variable) - don't use debug names - -ida_name.GNCN_NOFUNC (variable) - don't generate funcname+... expressions - -ida_name.GNCN_NOLABEL (variable) - don't generate labels - -ida_name.GNCN_NOSEG (variable) - ignore the segment prefix when producing the name - -ida_name.GNCN_PREFDBG (variable) - if using debug names, prefer debug names over function names - -ida_name.GNCN_REQFUNC (variable) - return 0 if the address does not belong to a function - -ida_name.GNCN_REQNAME (variable) - return 0 if the address can only be represented as a hex number - -ida_name.GNCN_SEGNUM (variable) - segment part is displayed as a hex number - -ida_name.GNCN_SEG_FUNC (variable) - generate both segment and function names (default is to omit segment name if a - function name is present) - -ida_name.GN_COLORED (variable) - return colored name - -ida_name.GN_DEMANGLED (variable) - return demangled name - -ida_name.GN_ISRET (variable) - for dummy names: use retloc - -ida_name.GN_LOCAL (variable) - try to get local name first; if failed, get global - -ida_name.GN_LONG (variable) - use long form of demangled name - -ida_name.GN_NOT_DUMMY (variable) - do not return a dummy name - -ida_name.GN_NOT_ISRET (variable) - for dummy names: do not use retloc - -ida_name.GN_SHORT (variable) - use short form of demangled name - -ida_name.GN_STRICT (variable) - fail if cannot demangle - -ida_name.GN_VISIBLE (variable) - replace forbidden characters by SUBSTCHAR - -ida_name.MAXNAMELEN (variable) - Maximum length of a name in IDA (with the trailing zero) - -ida_name.NT_ABS (variable) - name is absolute symbol (SEG_ABSSYM) - -ida_name.NT_BMASK (variable) - name is a bit group mask name - -ida_name.NT_BYTE (variable) - name is byte name (regular name) - -ida_name.NT_ENUM (variable) - name is symbolic constant - -ida_name.NT_LOCAL (variable) - name is local label - -ida_name.NT_NONE (variable) - name doesn't exist or has no value - -ida_name.NT_REGVAR (variable) - name is a renamed register (*value is idx into pfn->regvars) - -ida_name.NT_SEG (variable) - name is segment or segment register name - -ida_name.NT_STKVAR (variable) - name is stack variable name - -ida_name.NT_STROFF (variable) - name is structure member - -ida_name.NearestName (class) - Utility class to help find the nearest name in a given ea/name dictionary - -ida_name.NearestName.__getitem__ (method) - Returns the tupple (ea, name, index) - -ida_name.NearestName.__init__ (method) - -ida_name.NearestName.__iter__ (method) - -ida_name.NearestName._get_item (method) - -ida_name.NearestName.find (method) - Returns a tupple (ea, name, pos) that is the nearest to the passed ea - If no name is matched then None is returned - -ida_name.NearestName.update (method) - Updates the ea/names map - -ida_name.SN_AUTO (variable) - if set, make name autogenerated - -ida_name.SN_CHECK (variable) - Fail if the name contains invalid characters. - -ida_name.SN_DELTAIL (variable) - if name cannot be set because of a tail byte, delete the hindering item - -ida_name.SN_FORCE (variable) - if the specified name is already present in the database, try variations with a - numerical suffix like "_123" - -ida_name.SN_IDBENC (variable) - the name is given in the IDB encoding; non-ASCII bytes will be decoded - accordingly. Specifying SN_IDBENC also implies SN_NODUMMY - -ida_name.SN_LOCAL (variable) - create local name. a function should exist. local names can't be public or weak. - also they are not included into the list of names they can't have dummy - prefixes. - -ida_name.SN_NOCHECK (variable) - Replace invalid characters silently. If this bit is set, all invalid chars (not - in NameChars or MangleChars) will be replaced by '_' List of valid characters is - defined in ida.cfg - -ida_name.SN_NODUMMY (variable) - automatically prepend the name with '_' if it begins with a dummy suffix such as - 'sub_'. See also SN_IDBENC - -ida_name.SN_NOLIST (variable) - if set, exclude name from the list. if not set, then include the name into the - list (however, if other bits are set, the name might be immediately excluded - from the list). - -ida_name.SN_NON_AUTO (variable) - if set, make name non-autogenerated - -ida_name.SN_NON_PUBLIC (variable) - if set, make name non-public - -ida_name.SN_NON_WEAK (variable) - if set, make name non-weak - -ida_name.SN_NOWARN (variable) - don't display a warning if failed - -ida_name.SN_PUBLIC (variable) - if set, make name public - -ida_name.SN_WEAK (variable) - if set, make name weak - -ida_name.append_struct_fields (function) - append_struct_fields(disp, n, path, flags, delta, appzero) -> str - Append names of struct fields to a name if the name is a struct name. - - @param disp: (C++: adiff_t *) displacement from the name - @param n: (C++: int) operand number in which the name appears - @param path: (C++: const tid_t *) path in the struct. path is an array of id's. maximal length of - array is MAXSTRUCPATH. the first element of the array is the - structure id. consecutive elements are id's of used union members - (if any). - @param flags: (C++: flags64_t) the input flags. they will be returned if the struct cannot be - found. - @param delta: (C++: adiff_t) delta to add to displacement - @param appzero: (C++: bool) should append a struct field name if the displacement is zero? - @return: flags of the innermost struct member or the input flags - -ida_name.calc_gtn_flags (function) - Calculate flags for get_ea_name() function - - @param fromaddr: the referring address. May be BADADDR. - @param ea: linear address - - @return: flags - -ida_name.cleanup_name (function) - cleanup_name(ea, name, flags=0) -> str - - @param ea: ea_t - @param name: char const * - @param flags: uint32 - -ida_name.del_debug_names (function) - del_debug_names(ea1, ea2) - - @param ea1: ea_t - @param ea2: ea_t - -ida_name.del_global_name (function) - del_global_name(ea) -> bool - - @param ea: ea_t - -ida_name.del_local_name (function) - del_local_name(ea) -> bool - - @param ea: ea_t - -ida_name.demangle_name (function) - demangle_name(name, disable_mask, demreq=DQT_FULL) -> str - Demangle a name. - - @param name: (C++: const char *) char const * - @param disable_mask: (C++: uint32) - @param demreq: (C++: demreq_type_t) enum demreq_type_t - -ida_name.ea_name_t (class) - Proxy of C++ ea_name_t class. - -ida_name.ea_name_t.__init__ (method) - __init__(self) -> ea_name_t - __init__(self, _ea, _name) -> ea_name_t - - @param _ea: ea_t - @param _name: qstring const & - -ida_name.ea_name_vec_t (class) - Proxy of C++ qvector< ea_name_t > class. - -ida_name.ea_name_vec_t.__getitem__ (method) - __getitem__(self, i) -> ea_name_t - - @param i: size_t - -ida_name.ea_name_vec_t.__init__ (method) - __init__(self) -> ea_name_vec_t - __init__(self, x) -> ea_name_vec_t - - @param x: qvector< ea_name_t > const & - -ida_name.ea_name_vec_t.__len__ (method) - __len__(self) -> size_t - -ida_name.ea_name_vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: ea_name_t const & - -ida_name.ea_name_vec_t.at (method) - at(self, _idx) -> ea_name_t - - @param _idx: size_t - -ida_name.ea_name_vec_t.begin (method) - begin(self) -> ea_name_t - -ida_name.ea_name_vec_t.capacity (method) - capacity(self) -> size_t - -ida_name.ea_name_vec_t.clear (method) - clear(self) - -ida_name.ea_name_vec_t.empty (method) - empty(self) -> bool - -ida_name.ea_name_vec_t.end (method) - end(self) -> ea_name_t - -ida_name.ea_name_vec_t.erase (method) - erase(self, it) -> ea_name_t - - @param it: qvector< ea_name_t >::iterator - - erase(self, first, last) -> ea_name_t - - @param first: qvector< ea_name_t >::iterator - @param last: qvector< ea_name_t >::iterator - -ida_name.ea_name_vec_t.extract (method) - extract(self) -> ea_name_t - -ida_name.ea_name_vec_t.grow (method) - grow(self, x=ea_name_t()) - - @param x: ea_name_t const & - -ida_name.ea_name_vec_t.inject (method) - inject(self, s, len) - - @param s: ea_name_t * - @param len: size_t - -ida_name.ea_name_vec_t.insert (method) - insert(self, it, x) -> ea_name_t - - @param it: qvector< ea_name_t >::iterator - @param x: ea_name_t const & - -ida_name.ea_name_vec_t.pop_back (method) - pop_back(self) - -ida_name.ea_name_vec_t.push_back (method) - push_back(self, x) - - @param x: ea_name_t const & - - push_back(self) -> ea_name_t - -ida_name.ea_name_vec_t.qclear (method) - qclear(self) - -ida_name.ea_name_vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_name.ea_name_vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: ea_name_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_name.ea_name_vec_t.size (method) - size(self) -> size_t - -ida_name.ea_name_vec_t.swap (method) - swap(self, r) - - @param r: qvector< ea_name_t > & - -ida_name.ea_name_vec_t.truncate (method) - truncate(self) - -ida_name.extract_name (function) - extract_name(line, x) -> str - Extract a name or address from the specified string. - - @param line: (C++: const char *) input string - @param x: (C++: int) x coordinate of cursor - @return: -1 if cannot extract. otherwise length of the name - -ida_name.force_name (function) - force_name(ea, name, flags=0) -> bool - - @param ea: ea_t - @param name: char const * - @param flags: int - -ida_name.get_colored_demangled_name (function) - get_colored_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring - - @param ea: ea_t - @param inhibitor: int32 - @param demform: int - @param gtn_flags: int - -ida_name.get_colored_long_name (function) - get_colored_long_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int - -ida_name.get_colored_name (function) - get_colored_name(ea) -> qstring - - @param ea: ea_t - -ida_name.get_colored_short_name (function) - get_colored_short_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int - -ida_name.get_cp_validity (function) - get_cp_validity(kind, cp, endcp=wchar32_t(-1)) -> bool - Is the given codepoint (or range) acceptable in the given context? If 'endcp' is - not BADCP, it is considered to be the end of the range: [cp, endcp), and is not - included in the range - - @param kind: (C++: ucdr_kind_t) enum ucdr_kind_t - @param cp: (C++: wchar32_t) - @param endcp: (C++: wchar32_t) - -ida_name.get_debug_name (function) - get_debug_name(ea_ptr, how) -> str - - @param ea_ptr: ea_t * - @param how: enum debug_name_how_t - -ida_name.get_debug_name_ea (function) - get_debug_name_ea(name) -> ea_t - - @param name: char const * - -ida_name.get_debug_names (function) - get_debug_names(names, ea1, ea2) - - @param names: ea_name_vec_t * - @param ea1: ea_t - @param ea2: ea_t - - get_debug_names(ea1, ea2, return_list=False) -> dict or None - - @param ea1: ea_t - @param ea2: ea_t - @param return_list: bool - -ida_name.get_demangled_name (function) - get_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring - - @param ea: ea_t - @param inhibitor: int32 - @param demform: int - @param gtn_flags: int - -ida_name.get_ea_name (function) - get_ea_name(ea, gtn_flags=0) -> qstring - Get name at the specified address. - - @param ea: (C++: ea_t) linear address - @param gtn_flags: (C++: int) how exactly the name should be retrieved. combination of bits - for get_ea_name() function. There is a convenience bits - @return: success - -ida_name.get_long_name (function) - get_long_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int - -ida_name.get_mangled_name_type (function) - get_mangled_name_type(name) -> mangled_name_type_t - - @param name: char const * - -ida_name.get_name (function) - get_name(ea) -> qstring - - @param ea: ea_t - -ida_name.get_name_base_ea (function) - get_name_base_ea(_from, to) -> ea_t - Get address of the name used in the expression for the address - - @param from: (C++: ea_t) address of the operand which references to the address - @param to: (C++: ea_t) the referenced address - @return: address of the name used to represent the operand - -ida_name.get_name_color (function) - get_name_color(_from, ea) -> color_t - Calculate flags for get_ea_name() function. - - Get name color. - - @param from: (C++: ea_t) linear address where the name is used. if not applicable, then - should be BADADDR. The kernel returns a local name color if the - reference is within a function, i.e. 'from' and 'ea' belong to the - same function. - @param ea: (C++: ea_t) linear address - -ida_name.get_name_ea (function) - get_name_ea(_from, name) -> ea_t - Get the address of a name. This function resolves a name into an address. It can - handle regular global and local names, as well as debugger names. - - @param from: (C++: ea_t) linear address where the name is used. If specified, the local - labels of the function at the specified address will will be - checked. BADADDR means that local names won't be consulted. - @param name: (C++: const char *) any name in the program or nullptr - @return: address of the name or BADADDR - -ida_name.get_name_expr (function) - get_name_expr(_from, n, ea, off, flags=0x0001) -> str - Convert address to name expression (name with a displacement). This function - takes into account fixup information and returns a colored name expression (in - the form <name> +/- <offset>). It also knows about structure members and arrays. - If the specified address doesn't have a name, a dummy name is generated. - - @param from: (C++: ea_t) linear address of instruction operand or data referring to the - name. This address will be used to get fixup information, so it - should point to exact position of the operand in the instruction. - @param n: (C++: int) number of referencing operand. for data items specify 0 - @param ea: (C++: ea_t) address to convert to name expression - @param off: (C++: uval_t) the value of name expression. this parameter is used only to check - that the name expression will have the wanted value. 'off' may be - equal to BADADDR but this is discouraged because it prohibits - checks. - @param flags: (C++: int) Name expression flags - @return: < 0 if address is not valid, no segment or other failure. otherwise the - length of the name expression in characters. - -ida_name.get_name_value (function) - get_name_value(_from, name) -> int - Get value of the name. This function knows about: regular names, enums, special - segments, etc. - - @param from: (C++: ea_t) linear address where the name is used if not applicable, then - should be BADADDR - @param name: (C++: const char *) any name in the program or nullptr - @return: Name value result codes - -ida_name.get_nice_colored_name (function) - get_nice_colored_name(ea, flags=0) -> str - Get a nice colored name at the specified address. Ex: - * segment:sub+offset - * segment:sub:local_label - * segment:label - * segment:address - * segment:address+offset - - @param ea: (C++: ea_t) linear address - @param flags: (C++: int) Nice colored name flags - @return: the length of the generated name in bytes. - -ida_name.get_nlist_ea (function) - get_nlist_ea(idx) -> ea_t - Get address from the list at 'idx'. - - @param idx: (C++: size_t) - -ida_name.get_nlist_idx (function) - get_nlist_idx(ea) -> size_t - Get index of the name in the list - @warning: returns the closest match. may return idx >= size. - - @param ea: (C++: ea_t) - -ida_name.get_nlist_name (function) - get_nlist_name(idx) -> char const * - Get name using idx. - - @param idx: (C++: size_t) - -ida_name.get_nlist_size (function) - get_nlist_size() -> size_t - Get number of names in the list. - -ida_name.get_short_name (function) - get_short_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int - -ida_name.get_visible_name (function) - get_visible_name(ea, gtn_flags=0) -> qstring - - @param ea: ea_t - @param gtn_flags: int - -ida_name.hide_name (function) - hide_name(ea) - Remove name from the list of names - - @param ea: (C++: ea_t) address of the name - -ida_name.is_ident (function) - is_ident(name) -> bool - Is a valid name? (including ::MangleChars) - - @param name: (C++: const char *) char const * - -ida_name.is_ident_cp (function) - is_ident_cp(cp) -> bool - Can a character appear in a name? (present in ::NameChars or ::MangleChars) - - @param cp: (C++: wchar32_t) - -ida_name.is_in_nlist (function) - is_in_nlist(ea) -> bool - Is the name included into the name list? - - @param ea: (C++: ea_t) - -ida_name.is_name_defined_locally (function) - is_name_defined_locally(pfn, name, ignore_name_def, ea1=BADADDR, ea2=BADADDR) -> bool - Is the name defined locally in the specified function? - - @param pfn: (C++: func_t *) pointer to function - @param name: (C++: const char *) name to check - @param ignore_name_def: (C++: ignore_name_def_t) which names to ignore when checking - @param ea1: (C++: ea_t) the starting address of the range inside the function (optional) - @param ea2: (C++: ea_t) the ending address of the range inside the function (optional) - @return: true if the name has been defined - -ida_name.is_public_name (function) - is_public_name(ea) -> bool - - @param ea: ea_t - -ida_name.is_strlit_cp (function) - is_strlit_cp(cp, specific_ranges=None) -> bool - Can a character appear in a string literal (present in ::StrlitChars) If - 'specific_ranges' are specified, those will be used instead of the ones - corresponding to the current culture (only if ::StrlitChars is configured to use - the current culture) - - @param cp: (C++: wchar32_t) - @param specific_ranges: (C++: const rangeset_crefvec_t *) rangeset_crefvec_t const * - -ida_name.is_uname (function) - is_uname(name) -> bool - Is valid user-specified name? (valid name & !dummy prefix). - - @param name: (C++: const char *) name to test. may be nullptr. - @retval 1: yes - @retval 0: no - -ida_name.is_valid_cp (function) - is_valid_cp(cp, kind, data=None) -> bool - Is the given codepoint acceptable in the given context? - - @param cp: (C++: wchar32_t) - @param kind: (C++: nametype_t) enum nametype_t - @param data: (C++: void *) - -ida_name.is_valid_name (function) - is_valid_name(name, cpuregs_permitted) -> bool - - @param name: char const * - @param cpuregs_permitted: bool - -ida_name.is_valid_typename (function) - is_valid_typename(name) -> bool - Is valid type name? - - @param name: (C++: const char *) name to test. may be nullptr. - @retval 1: yes - @retval 0: no - -ida_name.is_visible_cp (function) - is_visible_cp(cp) -> bool - Can a character be displayed in a name? (present in ::NameChars) - - @param cp: (C++: wchar32_t) - -ida_name.is_weak_name (function) - is_weak_name(ea) -> bool - - @param ea: ea_t - -ida_name.make_name_auto (function) - make_name_auto(ea) -> bool - - @param ea: ea_t - -ida_name.make_name_non_public (function) - make_name_non_public(ea) - - @param ea: ea_t - -ida_name.make_name_non_weak (function) - make_name_non_weak(ea) - - @param ea: ea_t - -ida_name.make_name_public (function) - make_name_public(ea) - - @param ea: ea_t - -ida_name.make_name_user (function) - make_name_user(ea) -> bool - - @param ea: ea_t - -ida_name.make_name_weak (function) - make_name_weak(ea) - - @param ea: ea_t - -ida_name.rebuild_nlist (function) - rebuild_nlist() - Rebuild the name list. - -ida_name.reorder_dummy_names (function) - reorder_dummy_names() - Renumber dummy names. - -ida_name.set_cp_validity (function) - set_cp_validity(kind, cp, endcp=wchar32_t(-1), valid=True) - Mark the given codepoint (or range) as acceptable or unacceptable in the given - context If 'endcp' is not BADCP, it is considered to be the end of the range: - [cp, endcp), and is not included in the range - - @param kind: (C++: ucdr_kind_t) enum ucdr_kind_t - @param cp: (C++: wchar32_t) - @param endcp: (C++: wchar32_t) - -ida_name.set_debug_name (function) - set_debug_name(ea, name) -> bool - - @param ea: ea_t - @param name: char const * - -ida_name.set_dummy_name (function) - set_dummy_name(_from, ea) -> bool - Give an autogenerated (dummy) name. Autogenerated names have special prefixes - (loc_...). - - @param from: (C++: ea_t) linear address of the operand which references to the address - @param ea: (C++: ea_t) linear address - @retval 1: ok, dummy name is generated or the byte already had a name - @retval 0: failure, invalid address or tail byte - -ida_name.set_name (function) - set_name(ea, name, flags=0) -> bool - Set or delete name of an item at the specified address. An item can be anything: - instruction, function, data byte, word, string, structure, etc... Include name - into the list of names. - - @param ea: (C++: ea_t) linear address. do nothing if ea is not valid (return 0). tail bytes - can't have names. - @param name: (C++: const char *) new name. - * nullptr: do nothing (return 0). - * "" : delete name. - * otherwise this is a new name. - @param flags: (C++: int) Set name flags. If a bit is not specified, then the corresponding - action is not performed and the name will retain the same bits as - before calling this function. For new names, default is: non- - public, non-weak, non-auto. - @retval 1: ok, name is changed - @retval 0: failure, a warning is displayed - -ida_name.show_name (function) - show_name(ea) - Insert name to the list of names. - - @param ea: (C++: ea_t) - -ida_name.validate_name (function) - validate_name(name, type, flags=0) -> PyObject * - Validate a name. If SN_NOCHECK is specified, this function replaces all invalid - characters in the name with SUBSTCHAR. However, it will return false if name is - valid but not allowed to be an identifier (is a register name). - - @param name: (C++: qstring *) ptr to name. the name will be modified - @param type: (C++: nametype_t) the type of name we want to validate - @param flags: (C++: int) see SN_* - @return: success - -ida_netnode (module) - Functions that provide the lowest level public interface to the database. - Namely, we use Btree. To learn more about BTree: - - \link{https://en.wikipedia.org/wiki/B-tree} - - We do not use Btree directly. Instead, we have another layer built on the top of - Btree. Here is a brief explanation of this layer. - - An object called "netnode" is modeled on the top of Btree. Each netnode has a - unique id: a 32-bit value (64-bit for ida64). Initially there is a trivial - mapping of the linear addresses used in the program to netnodes (later this - mapping may be modified using ea2node and node2ea functions; this is used for - fast database rebasings). If we have additional information about an address - (for example, a comment is attached to it), this information is stored in the - corresponding netnode. See nalt.hpp to see how the kernel uses netnodes. Also, - some netnodes have no corresponding linear address (however, they still have an - id). They are used to store information not related to a particular address. - - Each netnode _may_ have the following attributes: - - * a name: an arbitrary non-empty string, up to 255KB-1 bytes - * a value: arbitrary sized object, max size is MAXSPECSIZE - * altvals: a sparse array of 32-bit values. indexes in this array may be 8-bit - or 32-bit values - * supvals: an array of arbitrary sized objects. (size of each object is limited - by MAXSPECSIZE) indexes in this array may be 8-bit or 32-bit values - * charvals: a sparse array of 8-bit values. indexes in this array may be 8-bit - or 32-bit values - * hashvals: a hash (an associative array). indexes in this array are strings - values are arbitrary sized (max size is MAXSPECSIZE) - - Initially a new netnode contains no information at all so no disk space is used - for it. As you add new information, the netnode grows. - - All arrays that are attached to the netnode behave in the same manner. - Initially: - * all members of altvals/charvals array are zeroes - * all members of supvals/hashvals array are undefined - - If you need to store objects bigger that MAXSPECSIZE, please note that there are - high-level functions to store arbitrary sized objects in supvals. See - setblob/getblob and other blob-related functions. - - You may use netnodes to store additional information about the program. - Limitations on the use of netnodes are the following: - - * use netnodes only if you could not find a kernel service to store your type of - information - * do not create netnodes with valid identifier names. Use the "$ " prefix (or - any other prefix with characters not allowed in the identifiers for the names of - your netnodes. Although you will probably not destroy anything by accident, - using already defined names for the names of your netnodes is still discouraged. - * you may create as many netnodes as you want (creation of an unnamed netnode - does not increase the size of the database). however, since each netnode has a - number, creating too many netnodes could lead to the exhaustion of the netnode - numbers (the numbering starts at 0xFF000000) - * remember that netnodes are automatically saved to the disk by the kernel. - - Advanced info: - - In fact a netnode may contain up to 256 arrays of arbitrary sized objects (not - only the 4 listed above). Each array has an 8-bit tag. Usually tags are - represented by character constants. For example, altvals and supvals are simply - 2 of 256 arrays, with the tags 'A' and 'S' respectively. - -ida_netnode.BADNODE (variable) - A number to represent a bad netnode reference. - -ida_netnode.MAXNAMESIZE (variable) - Maximum length of a netnode name. WILL BE REMOVED IN THE FUTURE. - -ida_netnode.MAXSPECSIZE (variable) - Maximum length of strings or objects stored in a supval array element. - -ida_netnode.MAX_NODENAME_SIZE (variable) - Maximum length of a name. We permit names up to 32KB-1 bytes. - -ida_netnode.atag (variable) - Array of altvals. - -ida_netnode.exist (function) - exist(n) -> bool - - @param n: netnode const & - -ida_netnode.htag (variable) - Array of hashvals. - -ida_netnode.ltag (variable) - Links between netnodes. - -ida_netnode.netnode (class) - Proxy of C++ netnode class. - -ida_netnode.netnode.__eq__ (method) - __eq__(self, n) -> bool - - @param n: netnode & - - __eq__(self, x) -> bool - - @param x: nodeidx_t - -ida_netnode.netnode.__init__ (method) - __init__(self, num=nodeidx_t(-1)) -> netnode - - @param num: nodeidx_t - - __init__(self, _name, namlen=0, do_create=False) -> netnode - - @param _name: char const * - @param namlen: size_t - @param do_create: bool - -ida_netnode.netnode.__ne__ (method) - __ne__(self, n) -> bool - - @param n: netnode & - - __ne__(self, x) -> bool - - @param x: nodeidx_t - -ida_netnode.netnode.altdel (method) - altdel(self, alt, tag=atag) -> bool - Delete all elements of altval array. This function may be applied to 32-bit and - 8-bit altval arrays. This function deletes the whole altval array. - - @param alt: nodeidx_t - @param tag: uchar - - @return: success - altdel(self) -> bool - -ida_netnode.netnode.altdel_all (method) - altdel_all(self, tag=atag) -> bool - Delete all elements of the specified altval array. This function may be applied - to 32-bit and 8-bit altval arrays. This function deletes the whole altval array. - - @param tag: (C++: uchar) tag of array - @return: success - -ida_netnode.netnode.altdel_ea (method) - altdel_ea(self, ea, tag=atag) -> bool - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.altdel_idx8 (method) - altdel_idx8(self, alt, tag) -> bool - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.altfirst (method) - altfirst(self, tag=atag) -> nodeidx_t - Get first existing element of altval array. - - @param tag: (C++: uchar) tag of array - @return: index of first existing element of altval array, BADNODE if altval - array is empty - -ida_netnode.netnode.altfirst_idx8 (method) - altfirst_idx8(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.altlast (method) - altlast(self, tag=atag) -> nodeidx_t - Get last element of altval array. - - @param tag: (C++: uchar) tag of array - @return: index of last existing element of altval array, BADNODE if altval array - is empty - -ida_netnode.netnode.altlast_idx8 (method) - altlast_idx8(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.altnext (method) - altnext(self, cur, tag=atag) -> nodeidx_t - Get next existing element of altval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the next existing element of altval array, BADNODE if no more - altval array elements exist - -ida_netnode.netnode.altnext_idx8 (method) - altnext_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar - -ida_netnode.netnode.altprev (method) - altprev(self, cur, tag=atag) -> nodeidx_t - Get previous existing element of altval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the previous existing element of altval array, BADNODE if no - more altval array elements exist - -ida_netnode.netnode.altprev_idx8 (method) - altprev_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar - -ida_netnode.netnode.altset (method) - altset(self, alt, value, tag=atag) -> bool - Set value of altval array. - - @param alt: (C++: nodeidx_t) index into array of altvals - @param value: (C++: nodeidx_t) new value of altval element - @param tag: (C++: uchar) tag of array - @retval 1: ok - @retval 0: failed, normally should not occur - -ida_netnode.netnode.altset_ea (method) - altset_ea(self, ea, value, tag=atag) -> bool - - @param ea: ea_t - @param value: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.altset_idx8 (method) - altset_idx8(self, alt, val, tag) -> bool - - @param alt: uchar - @param val: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.altshift (method) - altshift(self, _from, to, size, tag=atag) -> size_t - Shift the altval array elements. Moves the array elements at (from..from+size) - to (to..to+size) - - @param from: (C++: nodeidx_t) - @param to: (C++: nodeidx_t) - @param size: (C++: nodeidx_t) - @param tag: (C++: uchar) - @return: number of shifted elements - -ida_netnode.netnode.altval (method) - altval(self, alt, tag=atag) -> nodeidx_t - Get altval element of the specified array. - - @param alt: (C++: nodeidx_t) index into array of altvals - @param tag: (C++: uchar) tag of array. may be omitted - @return: value of altval element. nonexistent altval members are returned as - zeroes - -ida_netnode.netnode.altval_ea (method) - altval_ea(self, ea, tag=atag) -> nodeidx_t - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.altval_idx8 (method) - altval_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.blobshift (method) - blobshift(self, _from, to, size, tag) -> size_t - Shift the blob array elements. Moves the array elements at (from..from+size) to - (to..to+size) - - @param from: (C++: nodeidx_t) - @param to: (C++: nodeidx_t) - @param size: (C++: nodeidx_t) - @param tag: (C++: uchar) - @return: number of shifted elements - -ida_netnode.netnode.blobsize (method) - blobsize(self, _start, tag) -> size_t - Get size of blob. - - @param _start: (C++: nodeidx_t) index of the first supval element used to store blob - @param tag: (C++: uchar) tag of supval array - @return: number of bytes required to store a blob - -ida_netnode.netnode.blobsize_ea (method) - blobsize_ea(self, ea, tag) -> size_t - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.chardel (method) - chardel(self, alt, tag) -> bool - - @param alt: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.chardel_ea (method) - chardel_ea(self, ea, tag) -> bool - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.chardel_idx8 (method) - chardel_idx8(self, alt, tag) -> bool - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.charfirst (method) - charfirst(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.charfirst_idx8 (method) - charfirst_idx8(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.charlast (method) - charlast(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.charlast_idx8 (method) - charlast_idx8(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.charnext (method) - charnext(self, cur, tag) -> nodeidx_t - - @param cur: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.charnext_idx8 (method) - charnext_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar - -ida_netnode.netnode.charprev (method) - charprev(self, cur, tag) -> nodeidx_t - - @param cur: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.charprev_idx8 (method) - charprev_idx8(self, cur, tag) -> nodeidx_t - - @param cur: uchar - @param tag: uchar - -ida_netnode.netnode.charset (method) - charset(self, alt, val, tag) -> bool - - @param alt: nodeidx_t - @param val: uchar - @param tag: uchar - -ida_netnode.netnode.charset_ea (method) - charset_ea(self, ea, val, tag) -> bool - - @param ea: ea_t - @param val: uchar - @param tag: uchar - -ida_netnode.netnode.charset_idx8 (method) - charset_idx8(self, alt, val, tag) -> bool - - @param alt: uchar - @param val: uchar - @param tag: uchar - -ida_netnode.netnode.charshift (method) - charshift(self, _from, to, size, tag) -> size_t - - @param from: nodeidx_t - @param to: nodeidx_t - @param size: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.charval (method) - charval(self, alt, tag) -> uchar - - @param alt: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.charval_ea (method) - charval_ea(self, ea, tag) -> uchar - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.charval_idx8 (method) - charval_idx8(self, alt, tag) -> uchar - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.copyto (method) - copyto(self, destnode, count=1) -> size_t - - @param destnode: netnode - @param count: nodeidx_t - -ida_netnode.netnode.create (method) - create(self, _name, namlen=0) -> bool - Create unnamed netnode. - @retval 1: ok - @retval 0: should not happen, indicates internal error - - @param _name: char const * - @param namlen: size_t - - create(self) -> bool - -ida_netnode.netnode.delblob (method) - delblob(self, _start, tag) -> int - Delete a blob. - - @param _start: (C++: nodeidx_t) index of the first supval element used to store blob - @param tag: (C++: uchar) tag of supval array - @return: number of deleted supvals - -ida_netnode.netnode.delblob_ea (method) - delblob_ea(self, ea, tag) -> int - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.delvalue (method) - delvalue(self) -> bool - Delete value of netnode. - @retval 1: ok - @retval 0: failed, netnode is bad or other error - -ida_netnode.netnode.eadel (method) - eadel(self, ea, tag) -> bool - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.eadel_idx8 (method) - eadel_idx8(self, idx, tag) -> bool - - @param idx: uchar - @param tag: uchar - -ida_netnode.netnode.eaget (method) - eaget(self, ea, tag) -> ea_t - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.eaget_idx (method) - eaget_idx(self, idx, tag) -> ea_t - - @param idx: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.eaget_idx8 (method) - eaget_idx8(self, idx, tag) -> ea_t - - @param idx: uchar - @param tag: uchar - -ida_netnode.netnode.easet (method) - easet(self, ea, addr, tag) -> bool - Store/retrieve/delete an address value in the netnode that corresponds to an - address. - - @param ea: (C++: ea_t) - @param addr: (C++: ea_t) - @param tag: (C++: uchar) - -ida_netnode.netnode.easet_idx (method) - easet_idx(self, idx, addr, tag) -> bool - - @param idx: nodeidx_t - @param addr: ea_t - @param tag: uchar - -ida_netnode.netnode.easet_idx8 (method) - easet_idx8(self, idx, addr, tag) -> bool - - @param idx: uchar - @param addr: ea_t - @param tag: uchar - -ida_netnode.netnode.end (method) - end(self) -> bool - Get last netnode in the graph. Sets netnodenumber to the highest existing - number. - @retval true: ok - @retval false: graph is empty - -ida_netnode.netnode.exist (method) - exist(_name) -> bool - Does the netnode with the specified name exist? - - @param _name: (C++: const char *) char const * - -ida_netnode.netnode.get_name (method) - get_name(self) -> ssize_t - Get the netnode name. - - @return: -1 if netnode is unnamed (buf is untouched in this case), otherwise the - name length - -ida_netnode.netnode.getblob (method) - getblob(self, start, tag) -> bytes or None - Get blob from a netnode into a qstring* and make sure the string is null- - terminated. - - @param start: nodeidx_t - @param tag: (C++: uchar) tag of supval array - @return: -1 if blob doesn't exist size of string (including terminating null) - otherwise - -ida_netnode.netnode.getblob_ea (method) - getblob_ea(self, ea, tag) -> PyObject * - - @param ea: ea_t - @param tag: char - -ida_netnode.netnode.getclob (method) - getclob(self, start, tag) -> str - - @param start: nodeidx_t - @param tag: char - -ida_netnode.netnode.hashdel (method) - hashdel(self, idx, tag=htag) -> bool - Delete hash element. - - @param idx: (C++: const char *) index into hash - @param tag: (C++: uchar) tag of hash. Default: htag - @retval true: deleted - @retval false: element does not exist - -ida_netnode.netnode.hashdel_all (method) - hashdel_all(self, tag=htag) -> bool - Delete all elements of hash. This function deletes the whole hash. - - @param tag: (C++: uchar) tag of hash. Default: htag - @return: success - -ida_netnode.netnode.hashfirst (method) - hashfirst(self, tag=htag) -> ssize_t - @see: hashfirst(qstring *buf, uchar tag=htag) const - - @param tag: (C++: uchar) - -ida_netnode.netnode.hashlast (method) - hashlast(self, tag=htag) -> ssize_t - @see: hashlast(qstring *buf, uchar tag=htag) const - - @param tag: (C++: uchar) - -ida_netnode.netnode.hashnext (method) - hashnext(self, idx, tag=htag) -> ssize_t - @see: hashnext(qstring *buf, const char *idx, uchar tag=htag) const - - @param idx: (C++: const char *) char const * - @param tag: (C++: uchar) - -ida_netnode.netnode.hashprev (method) - hashprev(self, idx, tag=htag) -> ssize_t - @see: hashprev(qstring *buf, const char *idx, uchar tag=htag) const - - @param idx: (C++: const char *) char const * - @param tag: (C++: uchar) - -ida_netnode.netnode.hashset (method) - hashset(self, idx, value, tag=htag) -> bool - Set value of hash element to long value. - - @param idx: (C++: const char *) index into hash - @param value: (C++: nodeidx_t) new value of hash element - @param tag: (C++: uchar) tag of hash. Default: htag - @retval 1: ok - @retval 0: should not occur - indicates internal error - -ida_netnode.netnode.hashset_buf (method) - hashset_buf(self, idx, py_str, tag=htag) -> bool - - @param idx: char const * - @param py_str: PyObject * - @param tag: char - -ida_netnode.netnode.hashset_idx (method) - hashset_idx(self, idx, value, tag=htag) -> bool - - @param idx: char const * - @param value: nodeidx_t - @param tag: uchar - -ida_netnode.netnode.hashstr (method) - hashstr(self, idx, tag=htag) -> ssize_t - @see: hashstr(qstring *buf, const char *idx, uchar tag=htag) const - - @param idx: (C++: const char *) char const * - @param tag: (C++: uchar) - -ida_netnode.netnode.hashstr_buf (method) - hashstr_buf(self, idx, tag=htag) -> PyObject * - - @param idx: char const * - @param tag: char - -ida_netnode.netnode.hashval (method) - hashval(self, idx, tag=htag) -> ssize_t - Get value of the specified hash element. - - @param idx: (C++: const char *) index into hash - @param tag: (C++: uchar) tag of hash. Default: htag - @return: -1 if element doesn't exist or idx is nullptr. otherwise returns the - value size in bytes - -ida_netnode.netnode.hashval_long (method) - hashval_long(self, idx, tag=htag) -> nodeidx_t - Get value of the specified hash element. - - @param idx: (C++: const char *) index into hash - @param tag: (C++: uchar) tag of hash. Default: htag - @return: value of hash element (it should be set using hashset(nodeidx_t)), 0 if - the element does not exist - -ida_netnode.netnode.index (method) - index(self) -> nodeidx_t - -ida_netnode.netnode.kill (method) - kill(self) - Delete a netnode with all information attached to it. - -ida_netnode.netnode.long_value (method) - long_value(self) -> nodeidx_t - -ida_netnode.netnode.lower_bound (method) - lower_bound(self, cur, tag=stag) -> nodeidx_t - Get lower bound of existing elements of supval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of first existing element of supval array >= cur BADNODE if - supval array is empty - -ida_netnode.netnode.lower_bound_ea (method) - lower_bound_ea(self, ea, tag=stag) -> nodeidx_t - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.lower_bound_idx8 (method) - lower_bound_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.moveto (method) - moveto(self, destnode, count=1) -> size_t - - @param destnode: netnode - @param count: nodeidx_t - -ida_netnode.netnode.next (method) - next(self) -> bool - Get next netnode in the graph. Sets netnodenumber to the next existing number - @retval true: ok - @retval false: no more netnodes - -ida_netnode.netnode.prev (method) - prev(self) -> bool - Get prev netnode in the graph. Sets netnodenumber to the previous existing - number - @retval true: ok - @retval false: no more netnodes - -ida_netnode.netnode.rename (method) - rename(self, newname, namlen=0) -> bool - Rename a netnode. - - @param newname: (C++: const char *) new name of netnode. nullptr or "" means to delete name. names - of user-defined netnodes must have the "$ " prefix in order to - avoid clashes with program byte names. - @param namlen: (C++: size_t) length of new name. if not specified, it will be calculated using - strlen() - @retval 1: ok - @retval 0: failed, newname is already used - -ida_netnode.netnode.set (method) - set(self, value) -> bool - Set value of netnode. - - @param value: (C++: const void *) pointer to value - @return: 1 - ok - -ida_netnode.netnode.set_long (method) - set_long(self, x) -> bool - Value of netnode as a long number: - - @param x: (C++: nodeidx_t) - -ida_netnode.netnode.setblob (method) - setblob(self, buf, _start, tag) -> bool - Store a blob in a netnode. - - @param buf: (C++: const void *) pointer to blob to save - @param _start: (C++: nodeidx_t) - @param tag: (C++: uchar) tag of supval array - @return: success - -ida_netnode.netnode.setblob_ea (method) - setblob_ea(self, buf, ea, tag) -> bool - - @param buf: void const * - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.start (method) - start(self) -> bool - Get first netnode in the graph. Sets netnodenumber to the lowest existing - number. - @retval true: ok - @retval false: graph is empty - -ida_netnode.netnode.supdel (method) - supdel(self, alt, tag=stag) -> bool - Delete all elements of supval array. This function may be applied to 32-bit and - 8-bit supval arrays. This function deletes the whole supval array. - - @param alt: nodeidx_t - @param tag: uchar - - @return: success - supdel(self) -> bool - -ida_netnode.netnode.supdel_all (method) - supdel_all(self, tag) -> bool - Delete all elements of the specified supval array. This function may be applied - to 32-bit and 8-bit supval arrays. This function deletes the whole supval array. - - @param tag: (C++: uchar) - @return: success - -ida_netnode.netnode.supdel_ea (method) - supdel_ea(self, ea, tag=stag) -> bool - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.supdel_idx8 (method) - supdel_idx8(self, alt, tag) -> bool - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.supdel_range (method) - supdel_range(self, idx1, idx2, tag) -> int - Delete range of elements in the specified supval array. Elements in range [idx1, - idx2) will be deleted. - @note: This function can also be used to delete a range of altval elements - - @param idx1: (C++: nodeidx_t) first element to delete - @param idx2: (C++: nodeidx_t) last element to delete + 1 - @param tag: (C++: uchar) tag of array - @return: number of deleted elements - -ida_netnode.netnode.supdel_range_idx8 (method) - supdel_range_idx8(self, idx1, idx2, tag) -> int - Same as above, but accepts 8-bit indexes. - - @param idx1: (C++: uchar) - @param idx2: (C++: uchar) - @param tag: (C++: uchar) - -ida_netnode.netnode.supfirst (method) - supfirst(self, tag=stag) -> nodeidx_t - Get first existing element of supval array. - - @param tag: (C++: uchar) tag of array - @return: index of first existing element of supval array, BADNODE if supval - array is empty - -ida_netnode.netnode.supfirst_idx8 (method) - supfirst_idx8(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.suplast (method) - suplast(self, tag=stag) -> nodeidx_t - Get last existing element of supval array. - - @param tag: (C++: uchar) tag of array - @return: index of last existing element of supval array, BADNODE if supval array - is empty - -ida_netnode.netnode.suplast_idx8 (method) - suplast_idx8(self, tag) -> nodeidx_t - - @param tag: uchar - -ida_netnode.netnode.supnext (method) - supnext(self, cur, tag=stag) -> nodeidx_t - Get next existing element of supval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the next existing element of supval array, BADNODE if no more - supval array elements exist - -ida_netnode.netnode.supnext_idx8 (method) - supnext_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.supprev (method) - supprev(self, cur, tag=stag) -> nodeidx_t - Get previous existing element of supval array. - - @param cur: (C++: nodeidx_t) current index - @param tag: (C++: uchar) tag of array - @return: index of the previous existing element of supval array BADNODE if no - more supval array elements exist - -ida_netnode.netnode.supprev_idx8 (method) - supprev_idx8(self, alt, tag) -> nodeidx_t - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.supset (method) - supset(self, alt, value, tag=stag) -> bool - Set value of supval array element. - - @param alt: (C++: nodeidx_t) index into array of supvals - @param value: (C++: const void *) pointer to supval value - @param tag: (C++: uchar) tag of array - @retval 1: ok - @retval 0: should not occur - indicates internal error - -ida_netnode.netnode.supset_ea (method) - supset_ea(self, ea, value, tag=stag) -> bool - - @param ea: ea_t - @param value: void const * - @param tag: uchar - -ida_netnode.netnode.supset_idx8 (method) - supset_idx8(self, alt, value, tag) -> bool - - @param alt: uchar - @param value: void const * - @param tag: uchar - -ida_netnode.netnode.supshift (method) - supshift(self, _from, to, size, tag=stag) -> size_t - Shift the supval array elements. Moves the array elements at (from..from+size) - to (to..to+size) - - @param from: (C++: nodeidx_t) - @param to: (C++: nodeidx_t) - @param size: (C++: nodeidx_t) - @param tag: (C++: uchar) - @return: number of shifted elements - -ida_netnode.netnode.supstr (method) - supstr(self, alt, tag=stag) -> ssize_t - @see: supstr(qstring *buf, nodeidx_t alt, uchar tag=stag) const - - @param alt: (C++: nodeidx_t) - @param tag: (C++: uchar) - -ida_netnode.netnode.supstr_ea (method) - supstr_ea(self, ea, tag=stag) -> ssize_t - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.supstr_idx8 (method) - supstr_idx8(self, alt, tag) -> ssize_t - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.supval (method) - supval(self, alt, tag=stag) -> ssize_t - Get value of the specified supval array element. NB: do not use this function to - retrieve strings, see supstr()! - - @param alt: (C++: nodeidx_t) index into array of supvals - @param tag: (C++: uchar) tag of array. Default: stag - @return: size of value, -1 if element doesn't exist - -ida_netnode.netnode.supval_ea (method) - supval_ea(self, ea, tag=stag) -> ssize_t - - @param ea: ea_t - @param tag: uchar - -ida_netnode.netnode.supval_idx8 (method) - supval_idx8(self, alt, tag) -> ssize_t - - @param alt: uchar - @param tag: uchar - -ida_netnode.netnode.valobj (method) - valobj(self) -> ssize_t - Get value of netnode. Netnode values are arbitrary sized objects with max size - is MAXSPECSIZE. NB: do not use this function for strings - see valstr(). - - @return: length of value, -1 if no value present - -ida_netnode.netnode.valstr (method) - valstr(self) -> ssize_t - @see: valstr(qstring *buf) const - -ida_netnode.netnode.value_exists (method) - value_exists(self) -> bool - -ida_netnode.netnode_exist (function) - netnode_exist(_name) -> bool - - @param _name: char const * - -ida_netnode.ntag (variable) - Name of netnode. - -ida_netnode.stag (variable) - Array of supvals. - -ida_netnode.vtag (variable) - Value of netnode. - -ida_offset (module) - Functions that deal with offsets. - - "Being an offset" is a characteristic of an operand. This means that operand or - its part represent offset from some address in the program. This linear address - is called "offset base". Some operands may have 2 offsets simultaneously. - Generally, IDA doesn't handle this except for Motorola outer offsets. Thus there - may be two offset values in an operand: simple offset and outer offset. - - Outer offsets are handled by specifying special operand number: it should be - ORed with OPND_OUTER value. - - See bytes.hpp for further explanation of operand numbers. - -ida_offset.add_refinfo_dref (function) - add_refinfo_dref(insn, _from, ri, opval, type, opoff) -> ea_t - Add xrefs for a reference from the given instruction ( insn_t::ea). This - function creates a cross references to the target and the base. - insn_t::add_off_drefs() calls this function to create xrefs for 'offset' - operand. - - @param insn: (C++: const insn_t &) the referencing instruction - @param from: (C++: ea_t) the referencing instruction/data address - @param ri: (C++: const refinfo_t &) reference info block from the database - @param opval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr) - @param type: (C++: dref_t) type of xref - @param opoff: (C++: int) offset of the operand from the start of instruction - @return: the target address of the reference - -ida_offset.calc_basevalue (function) - calc_basevalue(target, base) -> ea_t - Calculate the value of the reference base. - - @param target: (C++: ea_t) - @param base: (C++: ea_t) - -ida_offset.calc_offset_base (function) - calc_offset_base(ea, n) -> ea_t - Try to calculate the offset base This function takes into account the fixup - information, current ds and cs values. - - @param ea: (C++: ea_t) the referencing instruction/data address - @param n: (C++: int) operand number - * 0: first operand - * 1: second operand - * ... - * 7: eighth operand - @return: output base address or BADADDR - -ida_offset.calc_probable_base_by_value (function) - calc_probable_base_by_value(ea, off) -> ea_t - Try to calculate the offset base. 2 bases are checked: current ds and cs. If - fails, return BADADDR - - @param ea: (C++: ea_t) - @param off: (C++: uval_t) - -ida_offset.calc_reference_data (function) - calc_reference_data(target, base, _from, ri, opval) -> bool - Calculate the target and base addresses of an offset expression. The calculated - target and base addresses are returned in the locations pointed by 'base' and - 'target'. In case 'ri.base' is BADADDR, the function calculates the offset base - address from the referencing instruction/data address. The target address is - copied from ri.target. If ri.target is BADADDR then the target is calculated - using the base address and 'opval'. This function also checks if 'opval' matches - the full value of the reference and takes in account the memory-mapping. - - @param target: (C++: ea_t *) output target address - @param base: (C++: ea_t *) output base address - @param from: (C++: ea_t) the referencing instruction/data address - @param ri: (C++: const refinfo_t &) reference info block from the database - @param opval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr) - @return: success - -ida_offset.calc_target (function) - calc_target(_from, opval, ri) -> ea_t - Retrieve refinfo_t structure and calculate the target. - - @param from: (C++: ea_t) - @param opval: (C++: adiff_t) - @param ri: refinfo_t const & - - calc_target(_from, ea, n, opval) -> ea_t - - @param from: ea_t - @param ea: ea_t - @param n: int - @param opval: adiff_t - -ida_offset.can_be_off32 (function) - can_be_off32(ea) -> ea_t - Does the specified address contain a valid OFF32 value?. For symbols in special - segments the displacement is not taken into account. If yes, then the target - address of OFF32 will be returned. If not, then BADADDR is returned. - - @param ea: (C++: ea_t) - -ida_offset.get_default_reftype (function) - get_default_reftype(ea) -> reftype_t - Get default reference type depending on the segment. - - @param ea: (C++: ea_t) - @return: one of REF_OFF8, REF_OFF16, REF_OFF32, REF_OFF64 - -ida_offset.get_offbase (function) - get_offbase(ea, n) -> ea_t - Get offset base value - - @param ea: (C++: ea_t) linear address - @param n: (C++: int) 0..UA_MAXOP-1 operand number - @return: offset base or BADADDR - -ida_offset.get_offset_expr (function) - get_offset_expr(ea, n, ri, _from, offset, getn_flags=0) -> str - See get_offset_expression() - - @param ea: (C++: ea_t) - @param n: (C++: int) - @param ri: (C++: const refinfo_t &) refinfo_t const & - @param from: (C++: ea_t) - @param offset: (C++: adiff_t) - @param getn_flags: (C++: int) - -ida_offset.get_offset_expression (function) - get_offset_expression(ea, n, _from, offset, getn_flags=0) -> str - Get offset expression (in the form "offset name+displ"). This function uses - offset translation function ( processor_t::translate) if your IDP module has - such a function. Translation function is used to map linear addresses in the - program (only for offsets). - - Example: suppose we have instruction at linear address 0x00011000: - mov ax, [bx+7422h] and at ds:7422h: - array dw ... We want to represent the second operand with an offset - expression, so then we call: - get_offset_expresion(0x001100, 1, 0x001102, 0x7422, buf); - | | | | | - | | | | +output buffer - | | | +value of offset expression - | | +address offset value in the instruction - | +the second operand - +address of instruction and the function will return a - colored string: - offset array - - @param ea: (C++: ea_t) start of instruction or data with the offset expression - @param n: (C++: int) operand number (may be ORed with OPND_OUTER) - * 0: first operand - * 1: second operand - * ... - * 7: eighth operand - @param from: (C++: ea_t) linear address of instruction operand or data referring to the - name. This address will be used to get fixup information, so it - should point to exact position of operand in the instruction. - @param offset: (C++: adiff_t) value of operand or its part. The function will return text - representation of this value as offset expression. - @param getn_flags: (C++: int) combination of: - * GETN_APPZERO: meaningful only if the name refers to a structure. appends the - struct field name if the field offset is zero - * GETN_NODUMMY: do not generate dummy names for the expression but pretend they - already exist (useful to verify that the offset expression can be represented) - @retval 0: can't convert to offset expression - @retval 1: ok, a simple offset expression - @retval 2: ok, a complex offset expression - -ida_offset.op_offset (function) - op_offset(ea, n, type_and_flags, target=BADADDR, base=0, tdelta=0) -> bool - See op_offset_ex() - - @param ea: (C++: ea_t) - @param n: (C++: int) - @param type_and_flags: (C++: uint32) - @param target: (C++: ea_t) - @param base: (C++: ea_t) - @param tdelta: (C++: adiff_t) - -ida_offset.op_offset_ex (function) - op_offset_ex(ea, n, ri) -> bool - Convert operand to a reference. To delete an offset, use clr_op_type() function. - - @param ea: (C++: ea_t) linear address. if 'ea' has unexplored bytes, try to convert them to - * no segment: fail - * 16bit segment: to 16bit word data - * 32bit segment: to dword - @param n: (C++: int) operand number (may be ORed with OPND_OUTER) - * 0: first - * 1: second - * ... - * 7: eighth operand - * OPND_MASK: all operands - @param ri: (C++: const refinfo_t *) reference information - @return: success - -ida_offset.op_plain_offset (function) - op_plain_offset(ea, n, base) -> bool - Convert operand to a reference with the default reference type. - - @param ea: (C++: ea_t) - @param n: (C++: int) - @param base: (C++: ea_t) - -ida_pro (module) - This is the first header included in the IDA project. - - It defines the most common types, functions and data. Also, it tries to make - system dependent definitions. - - The following preprocessor macros are used in the project (the list may be - incomplete) - - Platform must be specified as one of: - - __NT__ - MS Windows (all platforms) - __LINUX__ - Linux - __MAC__ - MAC OS X - - __EA64__ - 64-bit address size (sizeof(ea_t)==8) - __X86__ - 32-bit debug servers (sizeof(void*)==4) - __X64__ - x64 processor (sizeof(void*)==8) default - __PPC__ - PowerPC - __ARM__ - ARM - -ida_pro.CP_UTF16 (variable) - UTF-16 codepage. - -ida_pro.IDA_SDK_VERSION (variable) - IDA SDK v8.4. - -ida_pro.IDBDEC_ESCAPE (variable) - convert non-printable characters to C escapes ( - , \xNN, \uNNNN) - -ida_pro.IOREDIR_APPEND (variable) - append, do not overwrite the output file - -ida_pro.IOREDIR_INPUT (variable) - input redirection - -ida_pro.IOREDIR_OUTPUT (variable) - output redirection - -ida_pro.IOREDIR_QUOTED (variable) - the file name was quoted - -ida_pro.MAXSTR (variable) - maximum string size - -ida_pro.SUBSTCHAR (variable) - default char, used if a char cannot be represented in a codepage - -ida_pro.__MF__ (variable) - byte sex of our platform (Most significant byte First). 0: little endian (Intel - 80x86). 1: big endian (PowerPC). - -ida_pro.__qmutex_t (class) - Proxy of C++ __qmutex_t class. - -ida_pro.__qmutex_t.__init__ (method) - __init__(self) -> __qmutex_t - -ida_pro.__qsemaphore_t (class) - Proxy of C++ __qsemaphore_t class. - -ida_pro.__qsemaphore_t.__init__ (method) - __init__(self) -> __qsemaphore_t - -ida_pro.__qthread_t (class) - Proxy of C++ __qthread_t class. - -ida_pro.__qthread_t.__init__ (method) - __init__(self) -> __qthread_t - -ida_pro._qstrvec_t (class) - WARNING: It is very unlikely an IDAPython user should ever, ever - have to use this type. It should only be used for IDAPython internals. - - For example, in py_askusingform.py, we ctypes-expose to the IDA - kernel & UI a qstrvec instance, in case a DropdownListControl is - constructed. - That's because that's what ask_form expects, and we have no - choice but to make a DropdownListControl hold a qstrvec_t. - This is, afaict, the only situation where a Python - _qstrvec_t is required. - -ida_pro._qstrvec_t.__get_size (method) - -ida_pro._qstrvec_t.__getitem__ (method) - Gets the string at the given index - -ida_pro._qstrvec_t.__init__ (method) - -ida_pro._qstrvec_t.__setitem__ (method) - Sets string at the given index - -ida_pro._qstrvec_t._create_clink (method) - -ida_pro._qstrvec_t._del_clink (method) - -ida_pro._qstrvec_t._get_clink_ptr (method) - -ida_pro._qstrvec_t.add (method) - Add a string to the vector - -ida_pro._qstrvec_t.addressof (method) - Returns the address (as number) of the qstring at the given index - -ida_pro._qstrvec_t.assign (method) - Copies the contents of 'other' to 'self' - -ida_pro._qstrvec_t.clear (method) - Clears all strings from the vector. - @param qclear: Just reset the size but do not actually free the memory - -ida_pro._qstrvec_t.from_list (method) - Populates the vector from a Python string list - -ida_pro._qstrvec_t.insert (method) - Insert a string into the vector - -ida_pro._qstrvec_t.remove (method) - Removes a string from the vector - -ida_pro._qstrvec_t.size (variable) - Returns the count of elements - -ida_pro.boolvec_t (class) - Proxy of C++ qvector< bool > class. - -ida_pro.boolvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< bool > const & - -ida_pro.boolvec_t.__getitem__ (method) - __getitem__(self, i) -> bool const & - - @param i: size_t - -ida_pro.boolvec_t.__init__ (method) - __init__(self) -> boolvec_t - __init__(self, x) -> boolvec_t - - @param x: qvector< bool > const & - -ida_pro.boolvec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.boolvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< bool > const & - -ida_pro.boolvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: bool const & - -ida_pro.boolvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: bool const & - -ida_pro.boolvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: bool const & - -ida_pro.boolvec_t.at (method) - at(self, _idx) -> bool const & - - @param _idx: size_t - -ida_pro.boolvec_t.begin (method) - begin(self) -> qvector< bool >::iterator - begin(self) -> qvector< bool >::const_iterator - -ida_pro.boolvec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.boolvec_t.clear (method) - clear(self) - -ida_pro.boolvec_t.empty (method) - empty(self) -> bool - -ida_pro.boolvec_t.end (method) - end(self) -> qvector< bool >::iterator - end(self) -> qvector< bool >::const_iterator - -ida_pro.boolvec_t.erase (method) - erase(self, it) -> qvector< bool >::iterator - - @param it: qvector< bool >::iterator - - erase(self, first, last) -> qvector< bool >::iterator - - @param first: qvector< bool >::iterator - @param last: qvector< bool >::iterator - -ida_pro.boolvec_t.extract (method) - extract(self) -> bool * - -ida_pro.boolvec_t.find (method) - find(self, x) -> qvector< bool >::iterator - - @param x: bool const & - - find(self, x) -> qvector< bool >::const_iterator - - @param x: bool const & - -ida_pro.boolvec_t.grow (method) - grow(self, x=bool()) - - @param x: bool const & - -ida_pro.boolvec_t.has (method) - has(self, x) -> bool - - @param x: bool const & - -ida_pro.boolvec_t.inject (method) - inject(self, s, len) - - @param s: bool * - @param len: size_t - -ida_pro.boolvec_t.insert (method) - insert(self, it, x) -> qvector< bool >::iterator - - @param it: qvector< bool >::iterator - @param x: bool const & - -ida_pro.boolvec_t.pop_back (method) - pop_back(self) - -ida_pro.boolvec_t.push_back (method) - push_back(self, x) - - @param x: bool const & - - push_back(self) -> bool & - -ida_pro.boolvec_t.qclear (method) - qclear(self) - -ida_pro.boolvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.boolvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: bool const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.boolvec_t.size (method) - size(self) -> size_t - -ida_pro.boolvec_t.swap (method) - swap(self, r) - - @param r: qvector< bool > & - -ida_pro.boolvec_t.truncate (method) - truncate(self) - -ida_pro.channel_redir_t (class) - Proxy of C++ channel_redir_t class. - -ida_pro.channel_redir_t.__init__ (method) - __init__(self) -> channel_redir_t - -ida_pro.channel_redir_t.fd (variable) - channel number - -ida_pro.channel_redir_t.file (variable) - file name to redirect to/from. if empty, the channel must be closed. - -ida_pro.channel_redir_t.flags (variable) - i/o redirection flags - -ida_pro.channel_redir_t.is_append (method) - is_append(self) -> bool - -ida_pro.channel_redir_t.is_input (method) - is_input(self) -> bool - -ida_pro.channel_redir_t.is_output (method) - is_output(self) -> bool - -ida_pro.channel_redir_t.is_quoted (method) - is_quoted(self) -> bool - -ida_pro.channel_redir_t.length (variable) - length of the redirection string in the command line - -ida_pro.channel_redir_t.start (variable) - begin of the redirection string in the command line - -ida_pro.check_process_exit (function) - check_process_exit(handle, exit_code, msecs=-1) -> int - Check whether process has terminated or not. - - @param handle: (C++: void *) process handle to wait for - @param exit_code: (C++: int *) pointer to the buffer for the exit code - @param msecs: how long to wait. special values: - * 0: do not wait - * 1 or -1: wait infinitely - * other values: timeout in milliseconds - @retval 0: process has exited, and the exit code is available. if *exit_code < - 0: the process was killed with a signal -*exit_code - @retval 1: process has not exited yet - @retval -1: error happened, see error code for winerr() in *exit_code - -ida_pro.ea_array (class) - Proxy of C++ ea_array class. - -ida_pro.ea_array.__getitem__ (method) - __getitem__(self, index) -> ea_t - - @param index: size_t - -ida_pro.ea_array.__init__ (method) - __init__(self, nelements) -> ea_array - - @param nelements: size_t - -ida_pro.ea_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: ea_t - -ida_pro.ea_array.cast (method) - cast(self) -> ea_t * - -ida_pro.ea_array.frompointer (method) - frompointer(t) -> ea_array - - @param t: ea_t * - -ida_pro.ea_array_frompointer (function) - ea_array_frompointer(t) -> ea_array - - @param t: ea_t * - -ida_pro.ea_pointer (class) - Proxy of C++ ea_pointer class. - -ida_pro.ea_pointer.__init__ (method) - __init__(self) -> ea_pointer - -ida_pro.ea_pointer.assign (method) - assign(self, value) - - @param value: ea_t - -ida_pro.ea_pointer.cast (method) - cast(self) -> ea_t * - -ida_pro.ea_pointer.frompointer (method) - frompointer(t) -> ea_pointer - - @param t: ea_t * - -ida_pro.ea_pointer.value (method) - value(self) -> ea_t - -ida_pro.ea_pointer_frompointer (function) - ea_pointer_frompointer(t) -> ea_pointer - - @param t: ea_t * - -ida_pro.extend_sign (function) - extend_sign(v, nbytes, sign_extend) -> uint64 - Sign-, or zero-extend the value 'v' to occupy 64 bits. The value 'v' is - considered to be of size 'nbytes'. - - @param v: (C++: uint64) - @param nbytes: (C++: int) - @param sign_extend: (C++: bool) - -ida_pro.instant_dbgopts_t (class) - Proxy of C++ instant_dbgopts_t class. - -ida_pro.instant_dbgopts_t.__init__ (method) - __init__(self) -> instant_dbgopts_t - -ida_pro.instant_dbgopts_t.attach (variable) - should attach to a process? - -ida_pro.instant_dbgopts_t.debmod (variable) - name of debugger module - -ida_pro.instant_dbgopts_t.env (variable) - config variables for debmod. example: DEFAULT_CPU=13;MAXPACKETSIZE=-1 - -ida_pro.instant_dbgopts_t.event_id (variable) - event to trigger upon attaching - -ida_pro.instant_dbgopts_t.host (variable) - remote hostname (if remote debugging) - -ida_pro.instant_dbgopts_t.pid (variable) - process to attach to (-1: ask the user) - -ida_pro.instant_dbgopts_t.port (variable) - port number for the remote debugger server - -ida_pro.int64vec_t (class) - Proxy of C++ qvector< long long > class. - -ida_pro.int64vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< long long > const & - -ida_pro.int64vec_t.__getitem__ (method) - __getitem__(self, i) -> long long const & - - @param i: size_t - -ida_pro.int64vec_t.__init__ (method) - __init__(self) -> int64vec_t - __init__(self, x) -> int64vec_t - - @param x: qvector< long long > const & - -ida_pro.int64vec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.int64vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< long long > const & - -ida_pro.int64vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: long long const & - -ida_pro.int64vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: long long const & - -ida_pro.int64vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: long long const & - -ida_pro.int64vec_t.at (method) - at(self, _idx) -> long long const & - - @param _idx: size_t - -ida_pro.int64vec_t.begin (method) - begin(self) -> qvector< long long >::iterator - begin(self) -> qvector< long long >::const_iterator - -ida_pro.int64vec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.int64vec_t.clear (method) - clear(self) - -ida_pro.int64vec_t.empty (method) - empty(self) -> bool - -ida_pro.int64vec_t.end (method) - end(self) -> qvector< long long >::iterator - end(self) -> qvector< long long >::const_iterator - -ida_pro.int64vec_t.erase (method) - erase(self, it) -> qvector< long long >::iterator - - @param it: qvector< long long >::iterator - - erase(self, first, last) -> qvector< long long >::iterator - - @param first: qvector< long long >::iterator - @param last: qvector< long long >::iterator - -ida_pro.int64vec_t.extract (method) - extract(self) -> long long * - -ida_pro.int64vec_t.find (method) - find(self, x) -> qvector< long long >::iterator - - @param x: long long const & - - find(self, x) -> qvector< long long >::const_iterator - - @param x: long long const & - -ida_pro.int64vec_t.has (method) - has(self, x) -> bool - - @param x: long long const & - -ida_pro.int64vec_t.inject (method) - inject(self, s, len) - - @param s: long long * - @param len: size_t - -ida_pro.int64vec_t.insert (method) - insert(self, it, x) -> qvector< long long >::iterator - - @param it: qvector< long long >::iterator - @param x: long long const & - -ida_pro.int64vec_t.pop_back (method) - pop_back(self) - -ida_pro.int64vec_t.push_back (method) - push_back(self, x) - - @param x: long long const & - - push_back(self) -> long long & - -ida_pro.int64vec_t.qclear (method) - qclear(self) - -ida_pro.int64vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.int64vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: long long const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.int64vec_t.size (method) - size(self) -> size_t - -ida_pro.int64vec_t.swap (method) - swap(self, r) - - @param r: qvector< long long > & - -ida_pro.int64vec_t.truncate (method) - truncate(self) - -ida_pro.int_pointer (class) - Proxy of C++ int_pointer class. - -ida_pro.int_pointer.__init__ (method) - __init__(self) -> int_pointer - -ida_pro.int_pointer.assign (method) - assign(self, value) - - @param value: int - -ida_pro.int_pointer.cast (method) - cast(self) -> int * - -ida_pro.int_pointer.frompointer (method) - frompointer(t) -> int_pointer - - @param t: int * - -ida_pro.int_pointer.value (method) - value(self) -> int - -ida_pro.int_pointer_frompointer (function) - int_pointer_frompointer(t) -> int_pointer - - @param t: int * - -ida_pro.intvec_t (class) - Proxy of C++ qvector< int > class. - -ida_pro.intvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< int > const & - -ida_pro.intvec_t.__getitem__ (method) - __getitem__(self, i) -> int const & - - @param i: size_t - -ida_pro.intvec_t.__init__ (method) - __init__(self) -> intvec_t - __init__(self, x) -> intvec_t - - @param x: qvector< int > const & - -ida_pro.intvec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.intvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< int > const & - -ida_pro.intvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: int const & - -ida_pro.intvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: int const & - -ida_pro.intvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: int const & - -ida_pro.intvec_t.at (method) - at(self, _idx) -> int const & - - @param _idx: size_t - -ida_pro.intvec_t.begin (method) - begin(self) -> qvector< int >::iterator - begin(self) -> qvector< int >::const_iterator - -ida_pro.intvec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.intvec_t.clear (method) - clear(self) - -ida_pro.intvec_t.empty (method) - empty(self) -> bool - -ida_pro.intvec_t.end (method) - end(self) -> qvector< int >::iterator - end(self) -> qvector< int >::const_iterator - -ida_pro.intvec_t.erase (method) - erase(self, it) -> qvector< int >::iterator - - @param it: qvector< int >::iterator - - erase(self, first, last) -> qvector< int >::iterator - - @param first: qvector< int >::iterator - @param last: qvector< int >::iterator - -ida_pro.intvec_t.extract (method) - extract(self) -> int * - -ida_pro.intvec_t.find (method) - find(self, x) -> qvector< int >::iterator - - @param x: int const & - - find(self, x) -> qvector< int >::const_iterator - - @param x: int const & - -ida_pro.intvec_t.has (method) - has(self, x) -> bool - - @param x: int const & - -ida_pro.intvec_t.inject (method) - inject(self, s, len) - - @param s: int * - @param len: size_t - -ida_pro.intvec_t.insert (method) - insert(self, it, x) -> qvector< int >::iterator - - @param it: qvector< int >::iterator - @param x: int const & - -ida_pro.intvec_t.pop_back (method) - pop_back(self) - -ida_pro.intvec_t.push_back (method) - push_back(self, x) - - @param x: int const & - - push_back(self) -> int & - -ida_pro.intvec_t.qclear (method) - qclear(self) - -ida_pro.intvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.intvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: int const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.intvec_t.size (method) - size(self) -> size_t - -ida_pro.intvec_t.swap (method) - swap(self, r) - - @param r: qvector< int > & - -ida_pro.intvec_t.truncate (method) - truncate(self) - -ida_pro.is_control_tty (function) - is_control_tty(fd) -> enum tty_control_t - Check if the current process is the owner of the TTY specified by 'fd' - (typically an opened descriptor to /dev/tty). - - @param fd: (C++: int) - -ida_pro.is_cvt64 (function) - is_cvt64() -> bool - is IDA converting IDB into I64? - -ida_pro.is_main_thread (function) - is_main_thread() -> bool - Are we running in the main thread? - -ida_pro.log2ceil (function) - log2ceil(d64) -> int - calculate ceil(log2(d64)) or floor(log2(d64)), it returns 0 if d64 == 0 - - @param d64: (C++: uint64) - -ida_pro.log2floor (function) - log2floor(d64) -> int - - @param d64: uint64 - -ida_pro.parse_dbgopts (function) - parse_dbgopts(ido, r_switch) -> bool - Parse the -r command line switch (for instant debugging). r_switch points to the - value of the -r switch. Example: win32@localhost+ - - @param ido: (C++: struct instant_dbgopts_t *) instant_dbgopts_t * - @param r_switch: (C++: const char *) char const * - @return: true-ok, false-parse error - -ida_pro.qatoll (function) - qatoll(nptr) -> int64 - - @param nptr: char const * - -ida_pro.qcontrol_tty (function) - qcontrol_tty() - Make the current terminal the controlling terminal of the calling process. - @note: The current terminal is supposed to be /dev/tty - -ida_pro.qdetach_tty (function) - qdetach_tty() - If the current terminal is the controlling terminal of the calling process, give - up this controlling terminal. - @note: The current terminal is supposed to be /dev/tty - -ida_pro.qexit (function) - qexit(code) - Call qatexit functions, shut down UI and kernel, and exit. - - @param code: (C++: int) exit code - -ida_pro.qmutex_locker_t (class) - Proxy of C++ qmutex_locker_t class. - -ida_pro.qmutex_locker_t.__init__ (method) - __init__(self, _lock) -> qmutex_locker_t - - @param _lock: qmutex_t - -ida_pro.qrefcnt_obj_t (class) - Proxy of C++ qrefcnt_obj_t class. - -ida_pro.qrefcnt_obj_t.__init__ (method) - -ida_pro.qrefcnt_obj_t.refcnt (variable) - counter - -ida_pro.qrefcnt_obj_t.release (method) - release(self) - Call destructor. We use release() instead of operator delete() to maintain - binary compatibility with all compilers (vc and gcc use different vtable layouts - for operator delete) - -ida_pro.qstrvec_t_add (function) - qstrvec_t_add(_self, s) -> bool - - @param self: PyObject * - @param s: char const * - -ida_pro.qstrvec_t_addressof (function) - qstrvec_t_addressof(_self, idx) -> PyObject * - - @param self: PyObject * - @param idx: size_t - -ida_pro.qstrvec_t_assign (function) - qstrvec_t_assign(_self, other) -> bool - - @param self: PyObject * - @param other: PyObject * - -ida_pro.qstrvec_t_clear (function) - qstrvec_t_clear(_self, qclear) -> bool - - @param self: PyObject * - @param qclear: bool - -ida_pro.qstrvec_t_create (function) - qstrvec_t_create() -> PyObject * - -ida_pro.qstrvec_t_destroy (function) - qstrvec_t_destroy(py_obj) -> bool - - @param py_obj: PyObject * - -ida_pro.qstrvec_t_from_list (function) - qstrvec_t_from_list(_self, py_list) -> bool - - @param self: PyObject * - @param py_list: PyObject * - -ida_pro.qstrvec_t_get (function) - qstrvec_t_get(_self, idx) -> PyObject * - - @param self: PyObject * - @param idx: size_t - -ida_pro.qstrvec_t_get_clink (function) - qstrvec_t_get_clink(_self) -> qstrvec_t * - - @param self: PyObject * - -ida_pro.qstrvec_t_get_clink_ptr (function) - qstrvec_t_get_clink_ptr(_self) -> PyObject * - - @param self: PyObject * - -ida_pro.qstrvec_t_insert (function) - qstrvec_t_insert(_self, idx, s) -> bool - - @param self: PyObject * - @param idx: size_t - @param s: char const * - -ida_pro.qstrvec_t_remove (function) - qstrvec_t_remove(_self, idx) -> bool - - @param self: PyObject * - @param idx: size_t - -ida_pro.qstrvec_t_set (function) - qstrvec_t_set(_self, idx, s) -> bool - - @param self: PyObject * - @param idx: size_t - @param s: char const * - -ida_pro.qstrvec_t_size (function) - qstrvec_t_size(_self) -> size_t - - @param self: PyObject * - -ida_pro.qthread_equal (function) - qthread_equal(q1, q2) -> bool - Are two threads equal? - - @param q1: (C++: qthread_t) - @param q2: (C++: qthread_t) - -ida_pro.quote_cmdline_arg (function) - quote_cmdline_arg(arg) -> bool - Quote a command line argument if it contains escape characters. For example, *.c - will be converted into "*.c" because * may be inadvertently expanded by the - shell - - @param arg: (C++: qstring *) - @return: true: modified 'arg' - -ida_pro.qvector_reserve (function) - qvector_reserve(vec, old, cnt, elsize) -> void * - Change capacity of given qvector. - - @param vec: (C++: void *) a pointer to a qvector - @param old: (C++: void *) a pointer to the qvector's array - @param cnt: (C++: size_t) number of elements to reserve - @param elsize: (C++: size_t) size of each element - @return: a pointer to the newly allocated array - -ida_pro.readbytes (function) - readbytes(h, res, size, mf) -> int - Read at most 4 bytes from file. - - @param h: (C++: int) file handle - @param res: (C++: uint32 *) value read from file - @param size: (C++: int) size of value in bytes (1,2,4) - @param mf: (C++: bool) is MSB first? - @return: 0 on success, nonzero otherwise - -ida_pro.reloc_value (function) - reloc_value(value, size, delta, mf) - - @param value: void * - @param size: int - @param delta: adiff_t - @param mf: bool - -ida_pro.relocate_relobj (function) - relocate_relobj(_relobj, ea, mf) -> bool - - @param _relobj: relobj_t * - @param ea: ea_t - @param mf: bool - -ida_pro.sel_array (class) - Proxy of C++ sel_array class. - -ida_pro.sel_array.__getitem__ (method) - __getitem__(self, index) -> sel_t - - @param index: size_t - -ida_pro.sel_array.__init__ (method) - __init__(self, nelements) -> sel_array - - @param nelements: size_t - -ida_pro.sel_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: sel_t - -ida_pro.sel_array.cast (method) - cast(self) -> sel_t * - -ida_pro.sel_array.frompointer (method) - frompointer(t) -> sel_array - - @param t: sel_t * - -ida_pro.sel_array_frompointer (function) - sel_array_frompointer(t) -> sel_array - - @param t: sel_t * - -ida_pro.sel_pointer (class) - Proxy of C++ sel_pointer class. - -ida_pro.sel_pointer.__init__ (method) - __init__(self) -> sel_pointer - -ida_pro.sel_pointer.assign (method) - assign(self, value) - - @param value: sel_t - -ida_pro.sel_pointer.cast (method) - cast(self) -> sel_t * - -ida_pro.sel_pointer.frompointer (method) - frompointer(t) -> sel_pointer - - @param t: sel_t * - -ida_pro.sel_pointer.value (method) - value(self) -> sel_t - -ida_pro.sel_pointer_frompointer (function) - sel_pointer_frompointer(t) -> sel_pointer - - @param t: sel_t * - -ida_pro.sizevec_t (class) - Proxy of C++ qvector< size_t > class. - -ida_pro.sizevec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< size_t > const & - -ida_pro.sizevec_t.__getitem__ (method) - __getitem__(self, i) -> size_t const & - - @param i: size_t - -ida_pro.sizevec_t.__init__ (method) - __init__(self) -> sizevec_t - __init__(self, x) -> sizevec_t - - @param x: qvector< size_t > const & - -ida_pro.sizevec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.sizevec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< size_t > const & - -ida_pro.sizevec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: size_t const & - -ida_pro.sizevec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: size_t const & - -ida_pro.sizevec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: size_t const & - -ida_pro.sizevec_t.at (method) - at(self, _idx) -> size_t const & - - @param _idx: size_t - -ida_pro.sizevec_t.begin (method) - begin(self) -> qvector< size_t >::iterator - begin(self) -> qvector< size_t >::const_iterator - -ida_pro.sizevec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.sizevec_t.clear (method) - clear(self) - -ida_pro.sizevec_t.empty (method) - empty(self) -> bool - -ida_pro.sizevec_t.end (method) - end(self) -> qvector< size_t >::iterator - end(self) -> qvector< size_t >::const_iterator - -ida_pro.sizevec_t.erase (method) - erase(self, it) -> qvector< size_t >::iterator - - @param it: qvector< size_t >::iterator - - erase(self, first, last) -> qvector< size_t >::iterator - - @param first: qvector< size_t >::iterator - @param last: qvector< size_t >::iterator - -ida_pro.sizevec_t.extract (method) - extract(self) -> size_t * - -ida_pro.sizevec_t.find (method) - find(self, x) -> qvector< size_t >::iterator - - @param x: size_t const & - - find(self, x) -> qvector< size_t >::const_iterator - - @param x: size_t const & - -ida_pro.sizevec_t.grow (method) - grow(self, x=size_t()) - - @param x: size_t const & - -ida_pro.sizevec_t.has (method) - has(self, x) -> bool - - @param x: size_t const & - -ida_pro.sizevec_t.inject (method) - inject(self, s, len) - - @param s: size_t * - @param len: size_t - -ida_pro.sizevec_t.insert (method) - insert(self, it, x) -> qvector< size_t >::iterator - - @param it: qvector< size_t >::iterator - @param x: size_t const & - -ida_pro.sizevec_t.pop_back (method) - pop_back(self) - -ida_pro.sizevec_t.push_back (method) - push_back(self, x) - - @param x: size_t const & - - push_back(self) -> size_t & - -ida_pro.sizevec_t.qclear (method) - qclear(self) - -ida_pro.sizevec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.sizevec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: size_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.sizevec_t.size (method) - size(self) -> size_t - -ida_pro.sizevec_t.swap (method) - swap(self, r) - - @param r: qvector< size_t > & - -ida_pro.sizevec_t.truncate (method) - truncate(self) - -ida_pro.str2user (function) - str2user(str) -> str or None - Insert C-style escape characters to string - - @param str: char const * - @return: new string with escape characters inserted - -ida_pro.strvec_t (class) - Proxy of C++ qvector< simpleline_t > class. - -ida_pro.strvec_t.__getitem__ (method) - __getitem__(self, i) -> simpleline_t const & - - @param i: size_t - -ida_pro.strvec_t.__init__ (method) - __init__(self) -> strvec_t - __init__(self, x) -> strvec_t - - @param x: qvector< simpleline_t > const & - -ida_pro.strvec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.strvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: simpleline_t const & - -ida_pro.strvec_t.at (method) - at(self, _idx) -> simpleline_t const & - - @param _idx: size_t - -ida_pro.strvec_t.begin (method) - begin(self) -> qvector< simpleline_t >::iterator - begin(self) -> qvector< simpleline_t >::const_iterator - -ida_pro.strvec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.strvec_t.clear (method) - clear(self) - -ida_pro.strvec_t.empty (method) - empty(self) -> bool - -ida_pro.strvec_t.end (method) - end(self) -> qvector< simpleline_t >::iterator - end(self) -> qvector< simpleline_t >::const_iterator - -ida_pro.strvec_t.erase (method) - erase(self, it) -> qvector< simpleline_t >::iterator - - @param it: qvector< simpleline_t >::iterator - - erase(self, first, last) -> qvector< simpleline_t >::iterator - - @param first: qvector< simpleline_t >::iterator - @param last: qvector< simpleline_t >::iterator - -ida_pro.strvec_t.extract (method) - extract(self) -> simpleline_t * - -ida_pro.strvec_t.grow (method) - grow(self, x=simpleline_t()) - - @param x: simpleline_t const & - -ida_pro.strvec_t.inject (method) - inject(self, s, len) - - @param s: simpleline_t * - @param len: size_t - -ida_pro.strvec_t.insert (method) - insert(self, it, x) -> qvector< simpleline_t >::iterator - - @param it: qvector< simpleline_t >::iterator - @param x: simpleline_t const & - -ida_pro.strvec_t.pop_back (method) - pop_back(self) - -ida_pro.strvec_t.push_back (method) - push_back(self, x) - - @param x: simpleline_t const & - - push_back(self) -> simpleline_t & - -ida_pro.strvec_t.qclear (method) - qclear(self) - -ida_pro.strvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.strvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: simpleline_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.strvec_t.size (method) - size(self) -> size_t - -ida_pro.strvec_t.swap (method) - swap(self, r) - - @param r: qvector< simpleline_t > & - -ida_pro.strvec_t.truncate (method) - truncate(self) - -ida_pro.sval_pointer (class) - Proxy of C++ sval_pointer class. - -ida_pro.sval_pointer.__init__ (method) - __init__(self) -> sval_pointer - -ida_pro.sval_pointer.assign (method) - assign(self, value) - - @param value: sval_t - -ida_pro.sval_pointer.cast (method) - cast(self) -> sval_t * - -ida_pro.sval_pointer.frompointer (method) - frompointer(t) -> sval_pointer - - @param t: sval_t * - -ida_pro.sval_pointer.value (method) - value(self) -> sval_t - -ida_pro.sval_pointer_frompointer (function) - sval_pointer_frompointer(t) -> sval_pointer - - @param t: sval_t * - -ida_pro.tid_array (class) - Proxy of C++ tid_array class. - -ida_pro.tid_array.__getitem__ (method) - __getitem__(self, index) -> tid_t - - @param index: size_t - -ida_pro.tid_array.__init__ (method) - __init__(self, nelements) -> tid_array - - @param nelements: size_t - -ida_pro.tid_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: tid_t - -ida_pro.tid_array.cast (method) - cast(self) -> tid_t * - -ida_pro.tid_array.frompointer (method) - frompointer(t) -> tid_array - - @param t: tid_t * - -ida_pro.tid_array_frompointer (function) - tid_array_frompointer(t) -> tid_array - - @param t: tid_t * - -ida_pro.uchar_array (class) - Proxy of C++ uchar_array class. - -ida_pro.uchar_array.__getitem__ (method) - __getitem__(self, index) -> uchar - - @param index: size_t - -ida_pro.uchar_array.__init__ (method) - __init__(self, nelements) -> uchar_array - - @param nelements: size_t - -ida_pro.uchar_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: uchar - -ida_pro.uchar_array.cast (method) - cast(self) -> uchar * - -ida_pro.uchar_array.frompointer (method) - frompointer(t) -> uchar_array - - @param t: uchar * - -ida_pro.uchar_array_frompointer (function) - uchar_array_frompointer(t) -> uchar_array - - @param t: uchar * - -ida_pro.uint64vec_t (class) - Proxy of C++ qvector< unsigned long long > class. - -ida_pro.uint64vec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< unsigned long long > const & - -ida_pro.uint64vec_t.__getitem__ (method) - __getitem__(self, i) -> unsigned long long const & - - @param i: size_t - -ida_pro.uint64vec_t.__init__ (method) - __init__(self) -> uint64vec_t - __init__(self, x) -> uint64vec_t - - @param x: qvector< unsigned long long > const & - -ida_pro.uint64vec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.uint64vec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< unsigned long long > const & - -ida_pro.uint64vec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned long long const & - -ida_pro.uint64vec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: unsigned long long const & - -ida_pro.uint64vec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: unsigned long long const & - -ida_pro.uint64vec_t.at (method) - at(self, _idx) -> unsigned long long const & - - @param _idx: size_t - -ida_pro.uint64vec_t.begin (method) - begin(self) -> qvector< unsigned long long >::iterator - begin(self) -> qvector< unsigned long long >::const_iterator - -ida_pro.uint64vec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.uint64vec_t.clear (method) - clear(self) - -ida_pro.uint64vec_t.empty (method) - empty(self) -> bool - -ida_pro.uint64vec_t.end (method) - end(self) -> qvector< unsigned long long >::iterator - end(self) -> qvector< unsigned long long >::const_iterator - -ida_pro.uint64vec_t.erase (method) - erase(self, it) -> qvector< unsigned long long >::iterator - - @param it: qvector< unsigned long long >::iterator - - erase(self, first, last) -> qvector< unsigned long long >::iterator - - @param first: qvector< unsigned long long >::iterator - @param last: qvector< unsigned long long >::iterator - -ida_pro.uint64vec_t.extract (method) - extract(self) -> unsigned long long * - -ida_pro.uint64vec_t.find (method) - find(self, x) -> qvector< unsigned long long >::iterator - - @param x: unsigned long long const & - - find(self, x) -> qvector< unsigned long long >::const_iterator - - @param x: unsigned long long const & - -ida_pro.uint64vec_t.has (method) - has(self, x) -> bool - - @param x: unsigned long long const & - -ida_pro.uint64vec_t.inject (method) - inject(self, s, len) - - @param s: unsigned long long * - @param len: size_t - -ida_pro.uint64vec_t.insert (method) - insert(self, it, x) -> qvector< unsigned long long >::iterator - - @param it: qvector< unsigned long long >::iterator - @param x: unsigned long long const & - -ida_pro.uint64vec_t.pop_back (method) - pop_back(self) - -ida_pro.uint64vec_t.push_back (method) - push_back(self, x) - - @param x: unsigned long long const & - - push_back(self) -> unsigned long long & - -ida_pro.uint64vec_t.qclear (method) - qclear(self) - -ida_pro.uint64vec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.uint64vec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: unsigned long long const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.uint64vec_t.size (method) - size(self) -> size_t - -ida_pro.uint64vec_t.swap (method) - swap(self, r) - - @param r: qvector< unsigned long long > & - -ida_pro.uint64vec_t.truncate (method) - truncate(self) - -ida_pro.uintvec_t (class) - Proxy of C++ qvector< unsigned int > class. - -ida_pro.uintvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< unsigned int > const & - -ida_pro.uintvec_t.__getitem__ (method) - __getitem__(self, i) -> unsigned int const & - - @param i: size_t - -ida_pro.uintvec_t.__init__ (method) - __init__(self) -> uintvec_t - __init__(self, x) -> uintvec_t - - @param x: qvector< unsigned int > const & - -ida_pro.uintvec_t.__len__ (method) - __len__(self) -> size_t - -ida_pro.uintvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< unsigned int > const & - -ida_pro.uintvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned int const & - -ida_pro.uintvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: unsigned int const & - -ida_pro.uintvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: unsigned int const & - -ida_pro.uintvec_t.at (method) - at(self, _idx) -> unsigned int const & - - @param _idx: size_t - -ida_pro.uintvec_t.begin (method) - begin(self) -> qvector< unsigned int >::iterator - begin(self) -> qvector< unsigned int >::const_iterator - -ida_pro.uintvec_t.capacity (method) - capacity(self) -> size_t - -ida_pro.uintvec_t.clear (method) - clear(self) - -ida_pro.uintvec_t.empty (method) - empty(self) -> bool - -ida_pro.uintvec_t.end (method) - end(self) -> qvector< unsigned int >::iterator - end(self) -> qvector< unsigned int >::const_iterator - -ida_pro.uintvec_t.erase (method) - erase(self, it) -> qvector< unsigned int >::iterator - - @param it: qvector< unsigned int >::iterator - - erase(self, first, last) -> qvector< unsigned int >::iterator - - @param first: qvector< unsigned int >::iterator - @param last: qvector< unsigned int >::iterator - -ida_pro.uintvec_t.extract (method) - extract(self) -> unsigned int * - -ida_pro.uintvec_t.find (method) - find(self, x) -> qvector< unsigned int >::iterator - - @param x: unsigned int const & - - find(self, x) -> qvector< unsigned int >::const_iterator - - @param x: unsigned int const & - -ida_pro.uintvec_t.has (method) - has(self, x) -> bool - - @param x: unsigned int const & - -ida_pro.uintvec_t.inject (method) - inject(self, s, len) - - @param s: unsigned int * - @param len: size_t - -ida_pro.uintvec_t.insert (method) - insert(self, it, x) -> qvector< unsigned int >::iterator - - @param it: qvector< unsigned int >::iterator - @param x: unsigned int const & - -ida_pro.uintvec_t.pop_back (method) - pop_back(self) - -ida_pro.uintvec_t.push_back (method) - push_back(self, x) - - @param x: unsigned int const & - - push_back(self) -> unsigned int & - -ida_pro.uintvec_t.qclear (method) - qclear(self) - -ida_pro.uintvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_pro.uintvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: unsigned int const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_pro.uintvec_t.size (method) - size(self) -> size_t - -ida_pro.uintvec_t.swap (method) - swap(self, r) - - @param r: qvector< unsigned int > & - -ida_pro.uintvec_t.truncate (method) - truncate(self) - -ida_pro.uval_array (class) - Proxy of C++ uval_array class. - -ida_pro.uval_array.__getitem__ (method) - __getitem__(self, index) -> uval_t - - @param index: size_t - -ida_pro.uval_array.__init__ (method) - __init__(self, nelements) -> uval_array - - @param nelements: size_t - -ida_pro.uval_array.__setitem__ (method) - __setitem__(self, index, value) - - @param index: size_t - @param value: uval_t - -ida_pro.uval_array.cast (method) - cast(self) -> uval_t * - -ida_pro.uval_array.frompointer (method) - frompointer(t) -> uval_array - - @param t: uval_t * - -ida_pro.uval_array_frompointer (function) - uval_array_frompointer(t) -> uval_array - - @param t: uval_t * - -ida_pro.writebytes (function) - writebytes(h, l, size, mf) -> int - Write at most 4 bytes to file. - - @param h: (C++: int) file handle - @param l: (C++: uint32) value to write - @param size: (C++: int) size of value in bytes (1,2,4) - @param mf: (C++: bool) is MSB first? - @return: 0 on success, nonzero otherwise - -ida_problems (module) - Functions that deal with the list of problems. - - There are several problem lists. An address may be inserted to any list. The - kernel simply maintains these lists, no additional processing is done. - - The problem lists are accessible for the user from the View->Subviews->Problems - menu item. - - Addresses in the lists are kept sorted. In general IDA just maintains these - lists without using them during analysis (except PR_ROLLED). - -ida_problems.PR_ATTN (variable) - Attention! Probably erroneous situation. - -ida_problems.PR_BADSTACK (variable) - Failed to trace the value of the stack pointer. - -ida_problems.PR_COLLISION (variable) - FLAIR collision: the function with the given name already exists. - -ida_problems.PR_DECIMP (variable) - FLAIR match indecision: the patterns matched, but not the function(s) being - referenced. - -ida_problems.PR_DISASM (variable) - Can't disasm. - -ida_problems.PR_END (variable) - Number of problem types. - -ida_problems.PR_FINAL (variable) - Decision to convert to instruction/data is made by IDA. - -ida_problems.PR_HEAD (variable) - Already head. - -ida_problems.PR_ILLADDR (variable) - Exec flows beyond limits. - -ida_problems.PR_JUMP (variable) - Jump by table !!!! ignored. - -ida_problems.PR_MANYLINES (variable) - Too many lines. - -ida_problems.PR_NOBASE (variable) - Can't find offset base. - -ida_problems.PR_NOCMT (variable) - Can't find comment (not used anymore) - -ida_problems.PR_NOFOP (variable) - Can't find forced op (not used anymore) - -ida_problems.PR_NONAME (variable) - Can't find name. - -ida_problems.PR_NOXREFS (variable) - Can't find references. - -ida_problems.PR_ROLLED (variable) - The decision made by IDA was wrong and rolled back. - -ida_problems.forget_problem (function) - forget_problem(type, ea) -> bool - Remove an address from a problem list - - @param type: (C++: problist_id_t) problem list type - @param ea: (C++: ea_t) linear address - @return: success - -ida_problems.get_problem (function) - get_problem(type, lowea) -> ea_t - Get an address from the specified problem list. The address is not removed from - the list. - - @param type: (C++: problist_id_t) problem list type - @param lowea: (C++: ea_t) the returned address will be higher or equal than the specified - address - @return: linear address or BADADDR - -ida_problems.get_problem_desc (function) - get_problem_desc(t, ea) -> str - Get the human-friendly description of the problem, if one was provided to - remember_problem. - - @param t: (C++: problist_id_t) problem list type. - @param ea: (C++: ea_t) linear address. - @return: the message length or -1 if none - -ida_problems.get_problem_name (function) - get_problem_name(type, longname=True) -> char const * - Get problem list description. - - @param type: (C++: problist_id_t) - @param longname: (C++: bool) - -ida_problems.is_problem_present (function) - is_problem_present(t, ea) -> bool - Check if the specified address is present in the problem list. - - @param t: (C++: problist_id_t) - @param ea: (C++: ea_t) - -ida_problems.remember_problem (function) - remember_problem(type, ea, msg=None) - Insert an address to a list of problems. Display a message saying about the - problem (except of PR_ATTN,PR_FINAL) PR_JUMP is temporarily ignored. - - @param type: (C++: problist_id_t) problem list type - @param ea: (C++: ea_t) linear address - @param msg: (C++: const char *) a user-friendly message to be displayed instead of the default more - generic one associated with the type of problem. Defaults to - nullptr. - -ida_problems.was_ida_decision (function) - was_ida_decision(ea) -> bool - - @param ea: ea_t - -ida_range (module) - Contains the definition of range_t. - - A range is a non-empty continuous range of addresses (specified by its start and - end addresses, the end address is excluded from the range). - - Ranges are stored in the Btree part of the IDA database. To learn more about - Btrees (Balanced Trees): \link{http://www.bluerwhite.org/btree/} - -ida_range.RANGE_KIND_FUNC (variable) - func_t - -ida_range.RANGE_KIND_HIDDEN_RANGE (variable) - hidden_range_t - -ida_range.RANGE_KIND_SEGMENT (variable) - segment_t - -ida_range.array_of_rangesets (class) - Proxy of C++ qvector< rangeset_t > class. - -ida_range.array_of_rangesets.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< rangeset_t > const & - -ida_range.array_of_rangesets.__getitem__ (method) - __getitem__(self, i) -> rangeset_t - - @param i: size_t - -ida_range.array_of_rangesets.__init__ (method) - __init__(self) -> array_of_rangesets - __init__(self, x) -> array_of_rangesets - - @param x: qvector< rangeset_t > const & - -ida_range.array_of_rangesets.__len__ (method) - __len__(self) -> size_t - -ida_range.array_of_rangesets.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< rangeset_t > const & - -ida_range.array_of_rangesets.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: rangeset_t const & - -ida_range.array_of_rangesets._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: rangeset_t const & - -ida_range.array_of_rangesets.add_unique (method) - add_unique(self, x) -> bool - - @param x: rangeset_t const & - -ida_range.array_of_rangesets.at (method) - at(self, _idx) -> rangeset_t - - @param _idx: size_t - -ida_range.array_of_rangesets.begin (method) - begin(self) -> rangeset_t - -ida_range.array_of_rangesets.capacity (method) - capacity(self) -> size_t - -ida_range.array_of_rangesets.clear (method) - clear(self) - -ida_range.array_of_rangesets.empty (method) - empty(self) -> bool - -ida_range.array_of_rangesets.end (method) - end(self) -> rangeset_t - -ida_range.array_of_rangesets.erase (method) - erase(self, it) -> rangeset_t - - @param it: qvector< rangeset_t >::iterator - - erase(self, first, last) -> rangeset_t - - @param first: qvector< rangeset_t >::iterator - @param last: qvector< rangeset_t >::iterator - -ida_range.array_of_rangesets.extract (method) - extract(self) -> rangeset_t - -ida_range.array_of_rangesets.find (method) - find(self, x) -> rangeset_t - - @param x: rangeset_t const & - -ida_range.array_of_rangesets.grow (method) - grow(self, x=rangeset_t()) - - @param x: rangeset_t const & - -ida_range.array_of_rangesets.has (method) - has(self, x) -> bool - - @param x: rangeset_t const & - -ida_range.array_of_rangesets.inject (method) - inject(self, s, len) - - @param s: rangeset_t * - @param len: size_t - -ida_range.array_of_rangesets.insert (method) - insert(self, it, x) -> rangeset_t - - @param it: qvector< rangeset_t >::iterator - @param x: rangeset_t const & - -ida_range.array_of_rangesets.pop_back (method) - pop_back(self) - -ida_range.array_of_rangesets.push_back (method) - push_back(self, x) - - @param x: rangeset_t const & - - push_back(self) -> rangeset_t - -ida_range.array_of_rangesets.qclear (method) - qclear(self) - -ida_range.array_of_rangesets.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_range.array_of_rangesets.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: rangeset_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_range.array_of_rangesets.size (method) - size(self) -> size_t - -ida_range.array_of_rangesets.swap (method) - swap(self, r) - - @param r: qvector< rangeset_t > & - -ida_range.array_of_rangesets.truncate (method) - truncate(self) - -ida_range.range_t (class) - Proxy of C++ range_t class. - -ida_range.range_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: range_t const & - -ida_range.range_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: range_t const & - -ida_range.range_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: range_t const & - -ida_range.range_t.__init__ (method) - __init__(self, ea1=0, ea2=0) -> range_t - - @param ea1: ea_t - @param ea2: ea_t - -ida_range.range_t.__le__ (method) - __le__(self, r) -> bool - - @param r: range_t const & - -ida_range.range_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: range_t const & - -ida_range.range_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: range_t const & - -ida_range.range_t._print (method) - _print(self) -> size_t - -ida_range.range_t.clear (method) - clear(self) - Set start_ea, end_ea to 0. - -ida_range.range_t.compare (method) - compare(self, r) -> int - - @param r: range_t const & - -ida_range.range_t.contains (method) - contains(self, ea) -> bool - Is every ea in 'r' also in this range_t? - - @param ea: ea_t - - contains(self, r) -> bool - - @param r: range_t const & - -ida_range.range_t.empty (method) - empty(self) -> bool - Is the size of the range_t <= 0? - -ida_range.range_t.end_ea (variable) - end_ea excluded - -ida_range.range_t.extend (method) - extend(self, ea) - Ensure that the range_t includes 'ea'. - - @param ea: (C++: ea_t) - -ida_range.range_t.intersect (method) - intersect(self, r) - Assign the range_t to the intersection between the range_t and 'r'. - - @param r: (C++: const range_t &) range_t const & - -ida_range.range_t.overlaps (method) - overlaps(self, r) -> bool - Is there an ea in 'r' that is also in this range_t? - - @param r: (C++: const range_t &) range_t const & - -ida_range.range_t.size (method) - size(self) -> asize_t - Get end_ea - start_ea. - -ida_range.range_t.start_ea (variable) - start_ea included - -ida_range.range_t_print (function) - range_t_print(cb) -> str - Helper function. Should not be called directly! - - @param cb: range_t const * - -ida_range.rangeset_t (class) - Proxy of C++ rangeset_t class. - -ida_range.rangeset_t.__eq__ (method) - __eq__(self, aset) -> bool - - @param aset: rangeset_t const & - -ida_range.rangeset_t.__getitem__ (method) - -ida_range.rangeset_t.__init__ (method) - __init__(self) -> rangeset_t - __init__(self, range) -> rangeset_t - - @param range: range_t const & - - __init__(self, ivs) -> rangeset_t - - @param ivs: rangeset_t const & - -ida_range.rangeset_t.__ne__ (method) - __ne__(self, aset) -> bool - - @param aset: rangeset_t const & - -ida_range.rangeset_t._print (method) - _print(self) -> size_t - -ida_range.rangeset_t.add (method) - add(self, range) -> bool - Add each element of 'aset' to the set. - - @param range: range_t const & - - @return: false if no elements were added (the set was unchanged) - add(self, start, _end) -> bool - - @param start: ea_t - @param _end: ea_t - - add(self, aset) -> bool - - @param aset: rangeset_t const & - -ida_range.rangeset_t.begin (method) - begin(self) -> range_t - Get an iterator that points to the first element in the set. - -ida_range.rangeset_t.cached_range (method) - cached_range(self) -> range_t - When searching the rangeset, we keep a cached element to help speed up searches. - - @return: a pointer to the cached element - -ida_range.rangeset_t.clear (method) - clear(self) - Delete all elements from the set. See qvector::clear() - -ida_range.rangeset_t.contains (method) - contains(self, ea) -> bool - Is every element in 'aset' contained in an element of this rangeset?. See - range_t::contains(range_t) - - @param ea: ea_t - - contains(self, aset) -> bool - - @param aset: rangeset_t const & - -ida_range.rangeset_t.empty (method) - empty(self) -> bool - Does the set have zero elements. - -ida_range.rangeset_t.end (method) - end(self) -> range_t - Get an iterator that points to the end of the set. (This is NOT the last - element) - -ida_range.rangeset_t.find_range (method) - find_range(self, ea) -> range_t - Get the element from the set that contains 'ea'. - - @param ea: (C++: ea_t) - @return: nullptr if there is no such element - -ida_range.rangeset_t.getrange (method) - getrange(self, idx) -> range_t - Get the range_t at index 'idx'. - - @param idx: (C++: int) - -ida_range.rangeset_t.has_common (method) - has_common(self, range) -> bool - Does any element of 'aset' overlap with an element in this rangeset?. See - range_t::overlaps() - - @param range: range_t const & - - has_common(self, aset) -> bool - - @param aset: rangeset_t const & - -ida_range.rangeset_t.includes (method) - includes(self, range) -> bool - Is every ea in 'range' contained in the rangeset? - - @param range: (C++: const range_t &) range_t const & - -ida_range.rangeset_t.intersect (method) - intersect(self, aset) -> bool - Set the rangeset to its intersection with 'aset'. - - @param aset: (C++: const rangeset_t &) rangeset_t const & - @return: false if the set was unchanged - -ida_range.rangeset_t.is_equal (method) - is_equal(self, aset) -> bool - Do this rangeset and 'aset' have identical elements? - - @param aset: (C++: const rangeset_t &) rangeset_t const & - -ida_range.rangeset_t.is_subset_of (method) - is_subset_of(self, aset) -> bool - Is every element in the rangeset contained in an element of 'aset'? - - @param aset: (C++: const rangeset_t &) rangeset_t const & - -ida_range.rangeset_t.lastrange (method) - lastrange(self) -> range_t - Get the last range_t in the set. - -ida_range.rangeset_t.next_addr (method) - next_addr(self, ea) -> ea_t - Get the smallest ea_t value greater than 'ea' contained in the rangeset. - - @param ea: (C++: ea_t) - -ida_range.rangeset_t.next_range (method) - next_range(self, ea) -> ea_t - Get the smallest ea_t value greater than 'ea' that is not in the same range as - 'ea'. - - @param ea: (C++: ea_t) - -ida_range.rangeset_t.nranges (method) - nranges(self) -> size_t - Get the number of range_t elements in the set. - -ida_range.rangeset_t.prev_addr (method) - prev_addr(self, ea) -> ea_t - Get the largest ea_t value less than 'ea' contained in the rangeset. - - @param ea: (C++: ea_t) - -ida_range.rangeset_t.prev_range (method) - prev_range(self, ea) -> ea_t - Get the largest ea_t value less than 'ea' that is not in the same range as 'ea'. - - @param ea: (C++: ea_t) - -ida_range.rangeset_t.sub (method) - sub(self, range) -> bool - Subtract each range in 'aset' from the set - - @param range: range_t const & - - @return: false if nothing was subtracted (the set was unchanged) - sub(self, ea) -> bool - - @param ea: ea_t - - sub(self, aset) -> bool - - @param aset: rangeset_t const & - -ida_range.rangeset_t.swap (method) - swap(self, r) - Set this = 'r' and 'r' = this. See qvector::swap() - - @param r: (C++: rangeset_t &) - -ida_range.rangevec_base_t (class) - Proxy of C++ qvector< range_t > class. - -ida_range.rangevec_base_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< range_t > const & - -ida_range.rangevec_base_t.__getitem__ (method) - __getitem__(self, i) -> range_t - - @param i: size_t - -ida_range.rangevec_base_t.__init__ (method) - __init__(self) -> rangevec_base_t - __init__(self, x) -> rangevec_base_t - - @param x: qvector< range_t > const & - -ida_range.rangevec_base_t.__len__ (method) - __len__(self) -> size_t - -ida_range.rangevec_base_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< range_t > const & - -ida_range.rangevec_base_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: range_t const & - -ida_range.rangevec_base_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: range_t const & - -ida_range.rangevec_base_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: range_t const & - -ida_range.rangevec_base_t.at (method) - at(self, _idx) -> range_t - - @param _idx: size_t - -ida_range.rangevec_base_t.begin (method) - begin(self) -> range_t - -ida_range.rangevec_base_t.capacity (method) - capacity(self) -> size_t - -ida_range.rangevec_base_t.clear (method) - clear(self) - -ida_range.rangevec_base_t.empty (method) - empty(self) -> bool - -ida_range.rangevec_base_t.end (method) - end(self) -> range_t - -ida_range.rangevec_base_t.erase (method) - erase(self, it) -> range_t - - @param it: qvector< range_t >::iterator - - erase(self, first, last) -> range_t - - @param first: qvector< range_t >::iterator - @param last: qvector< range_t >::iterator - -ida_range.rangevec_base_t.extract (method) - extract(self) -> range_t - -ida_range.rangevec_base_t.find (method) - find(self, x) -> range_t - - @param x: range_t const & - -ida_range.rangevec_base_t.grow (method) - grow(self, x=range_t()) - - @param x: range_t const & - -ida_range.rangevec_base_t.has (method) - has(self, x) -> bool - - @param x: range_t const & - -ida_range.rangevec_base_t.inject (method) - inject(self, s, len) - - @param s: range_t * - @param len: size_t - -ida_range.rangevec_base_t.insert (method) - insert(self, it, x) -> range_t - - @param it: qvector< range_t >::iterator - @param x: range_t const & - -ida_range.rangevec_base_t.pop_back (method) - pop_back(self) - -ida_range.rangevec_base_t.push_back (method) - push_back(self, x) - - @param x: range_t const & - - push_back(self) -> range_t - -ida_range.rangevec_base_t.qclear (method) - qclear(self) - -ida_range.rangevec_base_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_range.rangevec_base_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: range_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_range.rangevec_base_t.size (method) - size(self) -> size_t - -ida_range.rangevec_base_t.swap (method) - swap(self, r) - - @param r: qvector< range_t > & - -ida_range.rangevec_base_t.truncate (method) - truncate(self) - -ida_range.rangevec_t (class) - Proxy of C++ rangevec_t class. - -ida_range.rangevec_t.__init__ (method) - __init__(self) -> rangevec_t - -ida_registry (module) - Registry related functions. - - IDA uses the registry to store global configuration options that must persist - after IDA has been closed. - - On Windows, IDA uses the Windows registry directly. On Unix systems, the - registry is stored in a file (typically ~/.idapro/ida.reg). - - The root key for accessing IDA settings in the registry is defined by - ROOT_KEY_NAME. - -ida_registry.ROOT_KEY_NAME (variable) - Default key used to store IDA settings in registry (Windows version). - @note: this name is automatically prepended to all key names passed to functions - in this file. - -ida_registry.reg_binary (variable) - binary data - -ida_registry.reg_data_type (function) - reg_data_type(name, subkey=None) -> regval_type_t - Get data type of a given value. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) key name - @return: false if the [key+]value doesn't exist - -ida_registry.reg_delete (function) - reg_delete(name, subkey=None) -> bool - Delete a value from the registry. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) parent key - @return: success - -ida_registry.reg_delete_subkey (function) - reg_delete_subkey(name) -> bool - Delete a key from the registry. - - @param name: (C++: const char *) char const * - -ida_registry.reg_delete_tree (function) - reg_delete_tree(name) -> bool - Delete a subtree from the registry. - - @param name: (C++: const char *) char const * - -ida_registry.reg_dword (variable) - 32-bit number - -ida_registry.reg_exists (function) - reg_exists(name, subkey=None) -> bool - Is there already a value with the given name? - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) parent key - -ida_registry.reg_flush (function) - reg_flush() - -ida_registry.reg_load (function) - reg_load() - -ida_registry.reg_read_binary (function) - reg_read_binary(name, subkey=None) -> bytes or None - Read binary data from the registry. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) key name - @return: success - -ida_registry.reg_read_bool (function) - reg_read_bool(name, defval, subkey=None) -> bool - Read boolean value from the registry. - - @param name: (C++: const char *) value name - @param defval: (C++: bool) default value - @param subkey: (C++: const char *) key name - @return: boolean read from registry, or 'defval' if the read failed - -ida_registry.reg_read_int (function) - reg_read_int(name, defval, subkey=None) -> int - Read integer value from the registry. - - @param name: (C++: const char *) value name - @param defval: (C++: int) default value - @param subkey: (C++: const char *) key name - @return: the value read from the registry, or 'defval' if the read failed - -ida_registry.reg_read_string (function) - reg_read_string(name, subkey=None, _def=None) -> str - Read a string from the registry. - - @param name: (C++: const char *) value name - @param subkey: (C++: const char *) key name - @param def: char const * - @return: success - -ida_registry.reg_read_strlist (function) - reg_read_strlist(subkey) - Retrieve all string values associated with the given key. Also see - reg_update_strlist(). - - @param subkey: (C++: const char *) char const * - -ida_registry.reg_subkey_exists (function) - reg_subkey_exists(name) -> bool - Is there already a key with the given name? - - @param name: (C++: const char *) char const * - -ida_registry.reg_subkey_subkeys (function) - reg_subkey_subkeys(name) -> [str, ...] - Get all subkey names of given key. - - @param name: (C++: const char *) char const * - -ida_registry.reg_subkey_values (function) - reg_subkey_values(name) -> [str, ...] - Get all value names under given key. - - @param name: (C++: const char *) char const * - -ida_registry.reg_sz (variable) - utf8 string - -ida_registry.reg_unknown (variable) - unknown - -ida_registry.reg_update_filestrlist (function) - reg_update_filestrlist(subkey, add, maxrecs, rem=None) - Update registry with a file list. Case sensitivity will vary depending on the - target OS. - @note: 'add' and 'rem' must be UTF-8, just like for regular string operations. - - @param subkey: (C++: const char *) char const * - @param add: (C++: const char *) char const * - @param maxrecs: (C++: size_t) - @param rem: (C++: const char *) char const * - -ida_registry.reg_update_strlist (function) - reg_update_strlist(subkey, add, maxrecs, rem=None, ignorecase=False) - Update list of strings associated with given key. - - @param subkey: (C++: const char *) key name - @param add: (C++: const char *) string to be added to list, can be nullptr - @param maxrecs: (C++: size_t) limit list to this size - @param rem: (C++: const char *) string to be removed from list, can be nullptr - @param ignorecase: (C++: bool) ignore case for 'add' and 'rem' - -ida_registry.reg_write_binary (function) - reg_write_binary(name, py_bytes, subkey=None) -> PyObject * - Write binary data to the registry. - - @param name: (C++: const char *) value name - @param py_bytes: PyObject * - @param subkey: (C++: const char *) key name - -ida_registry.reg_write_bool (function) - reg_write_bool(name, value, subkey=None) - Write boolean value to the registry. - - @param name: (C++: const char *) value name - @param value: (C++: int) boolean to write (nonzero = true) - @param subkey: (C++: const char *) key name - -ida_registry.reg_write_int (function) - reg_write_int(name, value, subkey=None) - Write integer value to the registry. - - @param name: (C++: const char *) value name - @param value: (C++: int) value to write - @param subkey: (C++: const char *) key name - -ida_registry.reg_write_string (function) - reg_write_string(name, utf8, subkey=None) - Write a string to the registry. - - @param name: (C++: const char *) value name - @param utf8: (C++: const char *) utf8-encoded string - @param subkey: (C++: const char *) key name - -ida_registry.set_registry_root (function) - set_registry_root(name) -> bool - - @param name: char const * - -ida_regfinder (module) - - -ida_regfinder.find_nearest_rvi (function) - find_nearest_rvi(rvi, ea, reg) -> int - Find the value of any of the two registers using the register tracker. First, - this function tries to find the registers in the basic block of EA, and if it - could not do this, then it tries to find in the entire function. - - @param rvi: (C++: reg_value_info_t *) the found value with additional attributes - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: const int) the registers to find - @return: the index of the found register or -1 - -ida_regfinder.find_reg_value (function) - find_reg_value(ea, reg) -> int - Find register value using the register tracker. - @note: The returned value is valid *before* executing the instruction. - - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: int) the register to find - @retval 0: no value (the value is varying or the find depth is not enough to - find a value) - @retval 1: the found value is in VAL - @retval -1: the processor module does not support a register tracker - -ida_regfinder.find_reg_value_info (function) - find_reg_value_info(rvi, ea, reg, max_depth=0) -> bool - Find register value using the register tracker. - @note: The returned value is valid *before* executing the instruction. - @note: The _undefined_ value means that there is no execution flow to EA, e.g. - we try to find a value after the call of NORET function. - @note: The _unknown_ value means that the value is: - * a result of unsupported instruction, e.g. the result of a call, - * a function argument, - * is varying, e.g. it is a loop counter. - - @param rvi: (C++: reg_value_info_t *) the found value with additional attributes - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: int) the register to find - @param max_depth: (C++: int) the number of basic blocks to look before aborting the search - and returning the unknown value. 0 means the value of - REGTRACK_MAX_DEPTH from ida.cfg for ordinal registers or - REGTRACK_FUNC_MAX_DEPTH for the function-wide registers, -1 - means the value of REGTRACK_FUNC_MAX_DEPTH from ida.cfg. - @retval 'false': the processor module does not support a register tracker - @retval 'true': the found value is in RVI - -ida_regfinder.find_sp_value (function) - find_sp_value(ea, reg=-1) -> int - Find a value of the SP based register using the register tracker. - @note: The returned value is valid *before* executing the instruction. - - @param ea: (C++: ea_t) the address to find a value at - @param reg: (C++: int) the register to find. by default the SP register is used. - @retval 0: no value (the value is varying or the find depth is not enough to - find a value) - @retval 1: the found value is in VAL - @retval -1: the processor module does not support a register tracker - -ida_regfinder.invalidate_regfinder_cache (function) - invalidate_regfinder_cache(ea=BADADDR) - Remove from the register tracker cache all values at EA and all dependent - values. As if the control flow to this instruction has changed. if EA == BADADDR - then clear the entire cache. - - @param ea: (C++: ea_t) - -ida_regfinder.reg_value_def_t (class) - Proxy of C++ reg_value_def_t class. - -ida_regfinder.reg_value_def_t.LIKE_GOT (variable) - the value is like GOT only for numbers - @see: is_num() - -ida_regfinder.reg_value_def_t.NOVAL (variable) - without a value - -ida_regfinder.reg_value_def_t.PC_BASED (variable) - the value depends on DEF_EA only for numbers - @see: is_num() - -ida_regfinder.reg_value_def_t.SHORT_INSN (variable) - like 'addi reg, imm' - -ida_regfinder.reg_value_def_t.SPVAL (variable) - as a SP delta - -ida_regfinder.reg_value_def_t.UVAL (variable) - as a number - -ida_regfinder.reg_value_def_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: reg_value_def_t const & - -ida_regfinder.reg_value_def_t.__init__ (method) - __init__(self) -> reg_value_def_t - __init__(self, _val, ea, _flags=0) -> reg_value_def_t - - @param _val: uval_t - @param ea: ea_t - @param _flags: uint16 - - __init__(self, _val, insn, _flags=0) -> reg_value_def_t - - @param _val: uval_t - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param _flags: uint16 - -ida_regfinder.reg_value_def_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: reg_value_def_t const & - -ida_regfinder.reg_value_def_t.def_ea (variable) - the instruction address - -ida_regfinder.reg_value_def_t.def_itype (variable) - the instruction code (processor specific) - -ida_regfinder.reg_value_def_t.dstr (method) - dstr(self, how, pm=None) -> qstring - Return the string representation. - - @param how: (C++: dstr_val_t) enum reg_value_def_t::dstr_val_t - @param pm: (C++: const procmod_t *) procmod_t const * - -ida_regfinder.reg_value_def_t.flags (variable) - additional info about the value - -ida_regfinder.reg_value_def_t.is_like_got (method) - is_like_got(self) -> bool - -ida_regfinder.reg_value_def_t.is_pc_based (method) - is_pc_based(self) -> bool - -ida_regfinder.reg_value_def_t.is_short_insn (method) - is_short_insn(self, insn) -> bool - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - - is_short_insn(self) -> bool - -ida_regfinder.reg_value_def_t.val (variable) - the value - -ida_regfinder.reg_value_info_t (class) - Proxy of C++ reg_value_info_t class. - -ida_regfinder.reg_value_info_t.CONTAINED (variable) - L is contained in R (i.e. L\R is empty) - -ida_regfinder.reg_value_info_t.CONTAINS (variable) - L contains R (i.e. R\L is empty) - -ida_regfinder.reg_value_info_t.EQUAL (variable) - L==R. - -ida_regfinder.reg_value_info_t.NOT_COMPARABLE (variable) - L\R is not empty and R\L is not empty. - -ida_regfinder.reg_value_info_t.__getitem__ (method) - __getitem__(self, i) -> reg_value_def_t - - @param i: size_t - -ida_regfinder.reg_value_info_t.__init__ (method) - __init__(self) -> reg_value_info_t - -ida_regfinder.reg_value_info_t.__len__ (method) - __len__(self) -> size_t - -ida_regfinder.reg_value_info_t.__str__ (method) - __str__(self) -> qstring - -ida_regfinder.reg_value_info_t.aborted (method) - aborted(self) -> bool - Return 'true' if the tracking process was aborted. - -ida_regfinder.reg_value_info_t.add (method) - add(self, r, insn) - Add R to the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.add_num (method) - add_num(self, r, insn) - Add R to the value, do not change the defining instructions. - @note: This method do nothing for unknown values. - - @param r: (C++: uval_t) - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - - add_num(self, r) - - @param r: uval_t - -ida_regfinder.reg_value_info_t.band (method) - band(self, r, insn) - Make bitwise AND of R to the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.bandnot (method) - bandnot(self, r, insn) - Make bitwise AND of the inverse of R to the value, save INSN as a defining - instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.bnot (method) - bnot(self, insn) - Make bitwise inverse of the value, save INSN as a defining instruction. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.bor (method) - bor(self, r, insn) - Make bitwise OR of R to the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.bxor (method) - bxor(self, r, insn) - Make bitwise eXclusive OR of R to the value, save INSN as a defining - instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.clear (method) - clear(self) - Undefine the value. - -ida_regfinder.reg_value_info_t.empty (method) - empty(self) -> bool - Return 'true' if we know nothing about a value. - -ida_regfinder.reg_value_info_t.extend (method) - extend(self, pm, width, is_signed) - Sign-, or zero-extend the number or SP delta value to full size. The initial - value is considered to be of size WIDTH. - @note: This method do nothing for unknown values. - - @param pm: (C++: const procmod_t &) procmod_t const & - @param width: (C++: int) - @param is_signed: (C++: bool) - -ida_regfinder.reg_value_info_t.get_def_ea (method) - get_def_ea(self) -> ea_t - Return the defining address. - -ida_regfinder.reg_value_info_t.get_def_itype (method) - get_def_itype(self) -> uint16 - Return the defining instruction code (processor specific). - -ida_regfinder.reg_value_info_t.get_num (method) - get_num(self) -> bool - Return the number if the value is a constant. - @see: is_num() - -ida_regfinder.reg_value_info_t.get_spd (method) - get_spd(self) -> bool - Return the SP delta if the value depends on the stack pointer. - @see: is_spd() - -ida_regfinder.reg_value_info_t.have_all_vals_flag (method) - have_all_vals_flag(self, val_flags) -> bool - Check the given flag for each value. - - @param val_flags: (C++: uint16) - -ida_regfinder.reg_value_info_t.is_all_vals_like_got (method) - is_all_vals_like_got(self) -> bool - -ida_regfinder.reg_value_info_t.is_all_vals_pc_based (method) - is_all_vals_pc_based(self) -> bool - -ida_regfinder.reg_value_info_t.is_badinsn (method) - is_badinsn(self) -> bool - Return 'true' if the value is unknown because of a bad insn. - -ida_regfinder.reg_value_info_t.is_dead_end (method) - is_dead_end(self) -> bool - Return 'true' if the value is undefined because of a dead end. - -ida_regfinder.reg_value_info_t.is_known (method) - is_known(self) -> bool - Return 'true' if the value is known (i.e. it is a number or SP delta). - -ida_regfinder.reg_value_info_t.is_num (method) - is_num(self) -> bool - Return 'true' if the value is a constant. - -ida_regfinder.reg_value_info_t.is_spd (method) - is_spd(self) -> bool - Return 'true' if the value depends on the stack pointer. - -ida_regfinder.reg_value_info_t.is_special (method) - is_special(self) -> bool - Return 'true' if the value requires special handling. - -ida_regfinder.reg_value_info_t.is_unkfunc (method) - is_unkfunc(self) -> bool - Return 'true' if the value is unknown from the function start. - -ida_regfinder.reg_value_info_t.is_unkinsn (method) - is_unkinsn(self) -> bool - Return 'true' if the value is unknown after executing the insn. - -ida_regfinder.reg_value_info_t.is_unkloop (method) - is_unkloop(self) -> bool - Return 'true' if the value is unknown because it changes in a loop. - -ida_regfinder.reg_value_info_t.is_unkmult (method) - is_unkmult(self) -> bool - Return 'true' if the value is unknown because the register has incompatible - values (a number and SP delta). - -ida_regfinder.reg_value_info_t.is_unknown (method) - is_unknown(self) -> bool - Return 'true' if the value is unknown. - -ida_regfinder.reg_value_info_t.is_value_unique (method) - is_value_unique(self) -> bool - Check that the value is unique. - -ida_regfinder.reg_value_info_t.make_aborted (method) - make_aborted(bblk_ea) -> reg_value_info_t - Return the value after aborting. - @see: aborted() - - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.make_badinsn (method) - make_badinsn(insn_ea) -> reg_value_info_t - Return the unknown value after a bad insn. - @see: is_badinsn() - - @param insn_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.make_dead_end (method) - make_dead_end(dead_end_ea) -> reg_value_info_t - Return the undefined value because of a dead end. - @see: is_dead_end() - - @param dead_end_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.make_initial_sp (method) - make_initial_sp(func_ea) -> reg_value_info_t - Return the value that is the initial stack pointer. - @see: is_spd() - - @param func_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.make_num (method) - make_num(rval, insn, val_flags=0) -> reg_value_info_t - Return the value that is the RVAL number. - @see: is_num() - - @param rval: (C++: uval_t) - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param val_flags: (C++: uint16) - - make_num(rval, val_ea, val_flags=0) -> reg_value_info_t - - @param rval: uval_t - @param val_ea: ea_t - @param val_flags: uint16 - -ida_regfinder.reg_value_info_t.make_unkfunc (method) - make_unkfunc(func_ea) -> reg_value_info_t - Return the unknown value from the function start. - @see: is_unkfunc() - - @param func_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.make_unkinsn (method) - make_unkinsn(insn) -> reg_value_info_t - Return the unknown value after executing the insn. - @see: is_unkinsn() - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.make_unkloop (method) - make_unkloop(bblk_ea) -> reg_value_info_t - Return the unknown value if it changes in a loop. - @see: is_unkloop() - - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.make_unkmult (method) - make_unkmult(bblk_ea) -> reg_value_info_t - Return the unknown value if the register has incompatible values. - @see: is_unkmult() - - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.neg (method) - neg(self, insn) - Negate the value, save INSN as a defining instruction. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.set_aborted (method) - set_aborted(self, bblk_ea) - Set the value after aborting. - @see: aborted() - - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.set_badinsn (method) - set_badinsn(self, insn_ea) - Set the value to be unknown after a bad insn. - @see: is_badinsn() - - @param insn_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.set_dead_end (method) - set_dead_end(self, dead_end_ea) - Set the value to be undefined because of a dead end. - @see: is_dead_end() - - @param dead_end_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.set_num (method) - set_num(self, rval, insn, val_flags=0) - Set the value to be a number before an address. - @see: is_num() - - @param rval: (C++: uval_t) - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param val_flags: (C++: uint16) - - set_num(self, rvals, insn) - - @param rvals: uvalvec_t * - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - - set_num(self, rval, val_ea, val_flags=0) - - @param rval: uval_t - @param val_ea: ea_t - @param val_flags: uint16 - -ida_regfinder.reg_value_info_t.set_unkfunc (method) - set_unkfunc(self, func_ea) - Set the value to be unknown from the function start. - @see: is_unkfunc() - - @param func_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.set_unkinsn (method) - set_unkinsn(self, insn) - Set the value to be unknown after executing the insn. - @see: is_unkinsn() - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.set_unkloop (method) - set_unkloop(self, bblk_ea) - Set the value to be unknown because it changes in a loop. - @see: is_unkloop() - - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.set_unkmult (method) - set_unkmult(self, bblk_ea) - Set the value to be unknown because the register has incompatible values. - @see: is_unkmult() - - @param bblk_ea: (C++: ea_t) - -ida_regfinder.reg_value_info_t.shift_left (method) - shift_left(self, r) - Shift the value left by R, do not change the defining instructions. - @note: This method do nothing for unknown values. - - @param r: (C++: uval_t) - -ida_regfinder.reg_value_info_t.shift_right (method) - shift_right(self, r) - Shift the value right by R, do not change the defining instructions. - @note: This method do nothing for unknown values. - - @param r: (C++: uval_t) - -ida_regfinder.reg_value_info_t.sll (method) - sll(self, r, insn) - Shift the value left by R, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.slr (method) - slr(self, r, insn) - Shift the value right by R, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.sub (method) - sub(self, r, insn) - Subtract R from the value, save INSN as a defining instruction. - @note: Either THIS or R must have a single value. - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t.trunc_uval (method) - trunc_uval(self, pm) - Truncate the number to the application bitness. - @note: This method do nothing for non-number values. - - @param pm: (C++: const procmod_t &) procmod_t const & - -ida_regfinder.reg_value_info_t.vals_union (method) - vals_union(self, r) -> reg_value_info_t::set_compare_res_t - Add values from R into THIS ignoring duplicates. - @note: This method is the only way to get multiple values. - @retval EQUAL: THIS is not changed - @retval CONTAINS: THIS is not changed - @retval CONTAINED: THIS is a copy of R - @retval NOT_COMPARABLE: values from R are added to THIS - - @param r: (C++: const reg_value_info_t &) reg_value_info_t const & - -ida_regfinder.reg_value_info_t_make_aborted (function) - reg_value_info_t_make_aborted(bblk_ea) -> reg_value_info_t - - @param bblk_ea: ea_t - -ida_regfinder.reg_value_info_t_make_badinsn (function) - reg_value_info_t_make_badinsn(insn_ea) -> reg_value_info_t - - @param insn_ea: ea_t - -ida_regfinder.reg_value_info_t_make_dead_end (function) - reg_value_info_t_make_dead_end(dead_end_ea) -> reg_value_info_t - - @param dead_end_ea: ea_t - -ida_regfinder.reg_value_info_t_make_initial_sp (function) - reg_value_info_t_make_initial_sp(func_ea) -> reg_value_info_t - - @param func_ea: ea_t - -ida_regfinder.reg_value_info_t_make_num (function) - reg_value_info_t_make_num(rval, insn, val_flags=0) -> reg_value_info_t - - @param rval: uval_t - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param val_flags: uint16 - - reg_value_info_t_make_num(rval, val_ea, val_flags=0) -> reg_value_info_t - - @param rval: uval_t - @param val_ea: ea_t - @param val_flags: uint16 - -ida_regfinder.reg_value_info_t_make_unkfunc (function) - reg_value_info_t_make_unkfunc(func_ea) -> reg_value_info_t - - @param func_ea: ea_t - -ida_regfinder.reg_value_info_t_make_unkinsn (function) - reg_value_info_t_make_unkinsn(insn) -> reg_value_info_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_regfinder.reg_value_info_t_make_unkloop (function) - reg_value_info_t_make_unkloop(bblk_ea) -> reg_value_info_t - - @param bblk_ea: ea_t - -ida_regfinder.reg_value_info_t_make_unkmult (function) - reg_value_info_t_make_unkmult(bblk_ea) -> reg_value_info_t - - @param bblk_ea: ea_t - -ida_search (module) - Middle-level search functions. - - They all are controlled by Search flags - -ida_search.SEARCH_BRK (variable) - return BADADDR if the search was cancelled. - -ida_search.SEARCH_CASE (variable) - case-sensitive search (case-insensitive otherwise) - -ida_search.SEARCH_DOWN (variable) - search towards higher addresses - -ida_search.SEARCH_IDENT (variable) - search for an identifier (text search). it means that the characters before and - after the match cannot be is_visible_char(). - -ida_search.SEARCH_NEXT (variable) - skip the starting address when searching. this bit is useful only for search(), - bin_search2(), find_reg_access(). find_.. functions skip the starting address - automatically. - -ida_search.SEARCH_NOBRK (variable) - do not test if the user clicked cancel to interrupt the search - -ida_search.SEARCH_NOSHOW (variable) - do not display the search progress/refresh screen - -ida_search.SEARCH_REGEX (variable) - regular expressions in search string (supported only for the text search) - -ida_search.SEARCH_UP (variable) - search towards lower addresses - -ida_search.SEARCH_USESEL (variable) - query the UI for a possible current selection to limit the search to - -ida_search.find_binary (function) - find_binary(arg1, arg2, arg3, arg4, arg5) -> ea_t - Deprecated. Please use ida_bytes.bin_search() instead. - - @param arg1: ea_t - @param arg2: ea_t - @param arg3: char const * - @param arg4: int - @param arg5: int - -ida_search.find_code (function) - find_code(ea, sflag) -> ea_t - Find next code address. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.find_data (function) - find_data(ea, sflag) -> ea_t - Find next data address. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.find_defined (function) - find_defined(ea, sflag) -> ea_t - Find next ea that is the start of an instruction or data. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.find_error (function) - find_error(ea, sflag) -> ea_t - Find next error or problem. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.find_imm (function) - find_imm(ea, sflag, search_value) -> ea_t - Find next immediate operand with the given value. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - @param search_value: (C++: uval_t) - -ida_search.find_not_func (function) - find_not_func(ea, sflag) -> ea_t - Find next code address that does not belong to a function. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.find_notype (function) - find_notype(ea, sflag) -> ea_t - Find next operand without any type info. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.find_reg_access (function) - find_reg_access(out, start_ea, end_ea, regname, sflag) -> ea_t - Find access to a register. - - @param out: (C++: struct reg_access_t *) pointer to the output buffer. must be non-null. upon success - contains info about the found register. upon failed search for a - read access out->range contains the info about the non-redefined - parts of the register. - @param start_ea: (C++: ea_t) starting address - @param end_ea: (C++: ea_t) ending address. BADADDR means that the end limit is missing. - otherwise, if the search direction is SEARCH_UP, END_EA must be - lower than START_EA. - @param regname: (C++: const char *) the register to search for. - @param sflag: (C++: int) combination of Search flags bits. - @note: This function does not care about the control flow and probes all - instructions in the specified range, starting from START_EA. Only direct - references to registers are detected. Function calls and system traps are - ignored. - @return: the found address. BADADDR if not found or error. - -ida_search.find_suspop (function) - find_suspop(ea, sflag) -> ea_t - Find next suspicious operand. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.find_text (function) - find_text(start_ea, y, x, ustr, sflag) -> ea_t - See search() - - @param start_ea: (C++: ea_t) - @param y: (C++: int) - @param x: (C++: int) - @param ustr: (C++: const char *) char const * - @param sflag: (C++: int) - -ida_search.find_unknown (function) - find_unknown(ea, sflag) -> ea_t - Find next unexplored address. - - @param ea: (C++: ea_t) - @param sflag: (C++: int) - -ida_search.search_down (function) - search_down(sflag) -> bool - Is the SEARCH_DOWN bit set? - - @param sflag: (C++: int) - -ida_segment (module) - Functions that deal with segments. - - IDA requires that all program addresses belong to segments (each address must - belong to exactly one segment). The situation when an address doesn't belong to - any segment is allowed as a temporary situation only when the user changes - program segmentation. Bytes outside a segment can't be converted to - instructions, have names, comments, etc. Each segment has its start address, - ending address and represents a contiguous range of addresses. There might be - unused holes between segments. - - Each segment has its unique segment selector. This selector is used to - distinguish the segment from other segments. For 16-bit programs the selector is - equal to the segment base paragraph. For 32-bit programs there is special array - to translate the selectors to the segment base paragraphs. A selector is a 32/64 - bit value. - - The segment base paragraph determines the offsets in the segment. If the start - address of the segment == (base << 4) then the first offset in the segment will - be 0. The start address should be higher or equal to (base << 4). We will call - the offsets in the segment 'virtual addresses'. So, the virtual address of the - first byte of the segment is - - (start address of segment - segment base linear address) - - For IBM PC, the virtual address corresponds to the offset part of the address. - For other processors (Z80, for example), virtual addresses correspond to Z80 - addresses and linear addresses are used only internally. For MS Windows programs - the segment base paragraph is 0 and therefore the segment virtual addresses are - equal to linear addresses. - -ida_segment.ADDSEG_FILLGAP (variable) - fill gap between new segment and previous one. i.e. if such a gap exists, and - this gap is less than 64K, then fill the gap by extending the previous segment - and adding .align directive to it. This way we avoid gaps between segments. too - many gaps lead to a virtual array failure. it cannot hold more than ~1000 gaps. - -ida_segment.ADDSEG_IDBENC (variable) - 'name' and 'sclass' are given in the IDB encoding; non-ASCII bytes will be - decoded accordingly - -ida_segment.ADDSEG_NOAA (variable) - do not mark new segment for auto-analysis - -ida_segment.ADDSEG_NOSREG (variable) - set all default segment register values to BADSEL (undefine all default segment - registers) - -ida_segment.ADDSEG_NOTRUNC (variable) - don't truncate the new segment at the beginning of the next segment if they - overlap. destroy/truncate old segments instead. - -ida_segment.ADDSEG_OR_DIE (variable) - qexit() if can't add a segment - -ida_segment.ADDSEG_QUIET (variable) - silent mode, no "Adding segment..." in the messages window - -ida_segment.ADDSEG_SPARSE (variable) - use sparse storage method for the new ranges of the created segment. please note - that the ranges that were already enabled before creating the segment will not - change their storage type. - -ida_segment.CSS_BREAK (variable) - memory reading process stopped by user - -ida_segment.CSS_NODBG (variable) - debugger is not running - -ida_segment.CSS_NOMEM (variable) - not enough memory (might be because the segment is too big) - -ida_segment.CSS_NORANGE (variable) - could not find corresponding memory range - -ida_segment.CSS_OK (variable) - ok - -ida_segment.MAX_GROUPS (variable) - max number of segment groups - -ida_segment.MAX_SEGM_TRANSLATIONS (variable) - max number of segment translations - -ida_segment.MOVE_SEGM_CHUNK (variable) - Too many chunks are defined, can't move. - -ida_segment.MOVE_SEGM_DEBUG (variable) - Debugger segments cannot be moved. - -ida_segment.MOVE_SEGM_IDP (variable) - IDP module forbids moving the segment. - -ida_segment.MOVE_SEGM_INVAL (variable) - Invalid argument (delta/target does not fit the address space) - -ida_segment.MOVE_SEGM_LOADER (variable) - The segment has been moved but the loader complained. - -ida_segment.MOVE_SEGM_MAPPING (variable) - Memory mapping ranges of addresses hinder segment movement. - -ida_segment.MOVE_SEGM_ODD (variable) - Cannot move segments by an odd number of bytes. - -ida_segment.MOVE_SEGM_OK (variable) - all ok - -ida_segment.MOVE_SEGM_ORPHAN (variable) - Orphan bytes hinder segment movement. - -ida_segment.MOVE_SEGM_PARAM (variable) - The specified segment does not exist. - -ida_segment.MOVE_SEGM_ROOM (variable) - Not enough free room at the target address. - -ida_segment.MOVE_SEGM_SOURCEFILES (variable) - Source files ranges of addresses hinder segment movement. - -ida_segment.MSF_FIXONCE (variable) - call loader only once with the special calling method. valid for - rebase_program(). see loader_t::move_segm. - -ida_segment.MSF_LDKEEP (variable) - keep the loader in the memory (optimization) - -ida_segment.MSF_NETNODES (variable) - move netnodes instead of changing inf.netdelta (this is slower); valid for - rebase_program() - -ida_segment.MSF_NOFIX (variable) - don't call the loader to fix relocations - -ida_segment.MSF_PRIORITY (variable) - loader segments will overwrite any existing debugger segments when moved. valid - for move_segm() - -ida_segment.MSF_SILENT (variable) - don't display a "please wait" box on the screen - -ida_segment.SEGMOD_KEEP (variable) - keep information (code & data, etc) - -ida_segment.SEGMOD_KEEP0 (variable) - flag for internal use, don't set - -ida_segment.SEGMOD_KEEPSEL (variable) - do not try to delete unused selector - -ida_segment.SEGMOD_KILL (variable) - disable addresses if segment gets shrinked or deleted - -ida_segment.SEGMOD_NOMOVE (variable) - don't move info from the start of segment to the new start address (for - set_segm_start()) - -ida_segment.SEGMOD_SILENT (variable) - be silent - -ida_segment.SEGMOD_SPARSE (variable) - use sparse storage if extending the segment (for set_segm_start(), - set_segm_end()) - -ida_segment.SEGPERM_EXEC (variable) - Execute. - -ida_segment.SEGPERM_READ (variable) - Read. - -ida_segment.SEGPERM_WRITE (variable) - Write. - -ida_segment.SEG_ABSSYM (variable) - * segment with definitions of absolute symbols - -ida_segment.SEG_BSS (variable) - uninitialized segment - -ida_segment.SEG_CODE (variable) - code segment - -ida_segment.SEG_COMM (variable) - * segment with communal definitions - -ida_segment.SEG_DATA (variable) - data segment - -ida_segment.SEG_GRP (variable) - * group of segments - -ida_segment.SEG_IMEM (variable) - internal processor memory & sfr (8051) - -ida_segment.SEG_NORM (variable) - unknown type, no assumptions - -ida_segment.SEG_NULL (variable) - zero-length segment - -ida_segment.SEG_UNDF (variable) - undefined segment type (not used) - -ida_segment.SEG_XTRN (variable) - * segment with 'extern' definitions. no instructions are allowed - -ida_segment.SFL_COMORG (variable) - IDP dependent field (IBM PC: if set, ORG directive is not commented out) - -ida_segment.SFL_DEBUG (variable) - Is the segment created for the debugger?. Such segments are temporary and do not - have permanent flags. - -ida_segment.SFL_HEADER (variable) - Header segment (do not create offsets to it in the disassembly) - -ida_segment.SFL_HIDDEN (variable) - Is the segment hidden? - -ida_segment.SFL_HIDETYPE (variable) - Hide segment type (do not print it in the listing) - -ida_segment.SFL_LOADER (variable) - Is the segment created by the loader? - -ida_segment.SFL_OBOK (variable) - Orgbase is present? (IDP dependent field) - -ida_segment.SNAP_ALL_SEG (variable) - Take a snapshot of all segments. - -ida_segment.SNAP_CUR_SEG (variable) - Take a snapshot of current segment. - -ida_segment.SNAP_LOAD_SEG (variable) - Take a snapshot of loader segments. - -ida_segment.SREG_NUM (variable) - Maximum number of segment registers is 16 (see segregs.hpp) - -ida_segment.add_segm (function) - add_segm(para, start, end, name, sclass, flags=0) -> bool - Add a new segment, second form. Segment alignment is set to saRelByte. Segment - combination is "public" or "stack" (if segment class is "STACK"). Addressing - mode of segment is taken as default (16bit or 32bit). Default segment registers - are set to BADSEL. If a segment already exists at the specified range of - addresses, this segment will be truncated. Instructions and data in the old - segment will be deleted if the new segment has another addressing mode or - another segment base address. - - @param para: (C++: ea_t) segment base paragraph. if paragraph can't fit in 16bit, then a new - selector is allocated and mapped to the paragraph. - @param start: (C++: ea_t) start address of the segment. if start==BADADDR then start <- - to_ea(para,0). - @param end: (C++: ea_t) end address of the segment. end address should be higher than start - address. For emulate empty segments, use SEG_NULL segment type. If - the end address is lower than start address, then fail. If - end==BADADDR, then a segment up to the next segment will be created - (if the next segment doesn't exist, then 1 byte segment will be - created). If 'end' is too high and the new segment would overlap the - next segment, 'end' is adjusted properly. - @param name: (C++: const char *) name of new segment. may be nullptr - @param sclass: (C++: const char *) class of the segment. may be nullptr. type of the new segment is - modified if class is one of predefined names: - * "CODE" -> SEG_CODE - * "DATA" -> SEG_DATA - * "CONST" -> SEG_DATA - * "STACK" -> SEG_BSS - * "BSS" -> SEG_BSS - * "XTRN" -> SEG_XTRN - * "COMM" -> SEG_COMM - * "ABS" -> SEG_ABSSYM - @param flags: (C++: int) Add segment flags - @retval 1: ok - @retval 0: failed, a warning message is displayed - -ida_segment.add_segm_ex (function) - add_segm_ex(NONNULL_s, name, sclass, flags) -> bool - Add a new segment. If a segment already exists at the specified range of - addresses, this segment will be truncated. Instructions and data in the old - segment will be deleted if the new segment has another addressing mode or - another segment base address. - - @param NONNULL_s: (C++: segment_t *) - @param name: (C++: const char *) name of new segment. may be nullptr. if specified, the segment is - immediately renamed - @param sclass: (C++: const char *) class of the segment. may be nullptr. if specified, the segment - class is immediately changed - @param flags: (C++: int) Add segment flags - @retval 1: ok - @retval 0: failed, a warning message is displayed - -ida_segment.add_segment_translation (function) - add_segment_translation(segstart, mappedseg) -> bool - Add segment translation. - - @param segstart: (C++: ea_t) start address of the segment to add translation to - @param mappedseg: (C++: ea_t) start address of the overlayed segment - @retval 1: ok - @retval 0: too many translations or bad segstart - -ida_segment.allocate_selector (function) - allocate_selector(segbase) -> sel_t - Allocate a selector for a segment unconditionally. You must call this function - before calling add_segm_ex(). add_segm() calls this function itself, so you - don't need to allocate a selector. This function will allocate a new free - selector and setup its mapping using find_free_selector() and set_selector() - functions. - - @param segbase: (C++: ea_t) a new segment base paragraph - @return: the allocated selector number - -ida_segment.change_segment_status (function) - change_segment_status(s, is_deb_segm) -> int - Convert a debugger segment to a regular segment and vice versa. When converting - debug->regular, the memory contents will be copied to the database. - - @param s: (C++: segment_t *) segment to modify - @param is_deb_segm: (C++: bool) new status of the segment - @return: Change segment status result codes - -ida_segment.del_segm (function) - del_segm(ea, flags) -> bool - Delete a segment. - - @param ea: (C++: ea_t) any address belonging to the segment - @param flags: (C++: int) Segment modification flags - @retval 1: ok - @retval 0: failed, no segment at 'ea'. - -ida_segment.del_segment_translations (function) - del_segment_translations(segstart) - Delete the translation list - - @param segstart: (C++: ea_t) start address of the segment to delete translation list - -ida_segment.del_selector (function) - del_selector(selector) - Delete mapping of a selector. Be wary of deleting selectors that are being used - in the program, this can make a mess in the segments. - - @param selector: (C++: sel_t) number of selector to remove from the translation table - -ida_segment.find_free_selector (function) - find_free_selector() -> sel_t - Find first unused selector. - - @return: a number >= 1 - -ida_segment.find_selector (function) - find_selector(base) -> sel_t - Find a selector that has mapping to the specified paragraph. - - @param base: (C++: ea_t) paragraph to search in the translation table - @return: selector value or base - -ida_segment.get_defsr (function) - get_defsr(s, reg) -> sel_t - Deprecated, use instead: - value = s.defsr[reg] - - @param s: segment_t * - @param reg: int - -ida_segment.get_first_seg (function) - get_first_seg() -> segment_t - Get pointer to the first segment. - -ida_segment.get_group_selector (function) - get_group_selector(grpsel) -> sel_t - Get common selector for a group of segments. - - @param grpsel: (C++: sel_t) selector of group segment - @return: common selector of the group or 'grpsel' if no such group is found - -ida_segment.get_last_seg (function) - get_last_seg() -> segment_t - Get pointer to the last segment. - -ida_segment.get_next_seg (function) - get_next_seg(ea) -> segment_t - Get pointer to the next segment. - - @param ea: (C++: ea_t) - -ida_segment.get_prev_seg (function) - get_prev_seg(ea) -> segment_t - Get pointer to the previous segment. - - @param ea: (C++: ea_t) - -ida_segment.get_segm_base (function) - get_segm_base(s) -> ea_t - Get segment base linear address. Segment base linear address is used to - calculate virtual addresses. The virtual address of the first byte of the - segment will be (start address of segment - segment base linear address) - - @param s: (C++: const segment_t *) pointer to segment - @return: 0 if s == nullptr, otherwise segment base linear address - -ida_segment.get_segm_by_name (function) - get_segm_by_name(name) -> segment_t - Get pointer to segment by its name. If there are several segments with the same - name, returns the first of them. - - @param name: (C++: const char *) segment name. may be nullptr. - @return: nullptr or pointer to segment structure - -ida_segment.get_segm_by_sel (function) - get_segm_by_sel(selector) -> segment_t - Get pointer to segment structure. This function finds a segment by its selector. - If there are several segments with the same selectors, the last one will be - returned. - - @param selector: (C++: sel_t) a segment with the specified selector will be returned - @return: pointer to segment or nullptr - -ida_segment.get_segm_class (function) - get_segm_class(s) -> str - Get segment class. Segment class is arbitrary text (max 8 characters). - - @param s: (C++: const segment_t *) pointer to segment - @return: size of segment class (-1 if s==nullptr or bufsize<=0) - -ida_segment.get_segm_name (function) - get_segm_name(s, flags=0) -> str - Get true segment name by pointer to segment. - - @param s: (C++: const segment_t *) pointer to segment - @param flags: (C++: int) 0-return name as is; 1-substitute bad symbols with _ 1 corresponds - to GN_VISIBLE - @return: size of segment name (-1 if s==nullptr) - -ida_segment.get_segm_num (function) - get_segm_num(ea) -> int - Get number of segment by address. - - @param ea: (C++: ea_t) linear address belonging to the segment - @return: -1 if no segment occupies the specified address. otherwise returns - number of the specified segment (0..get_segm_qty()-1) - -ida_segment.get_segm_para (function) - get_segm_para(s) -> ea_t - Get segment base paragraph. Segment base paragraph may be converted to segment - base linear address using to_ea() function. In fact, to_ea(get_segm_para(s), 0) - == get_segm_base(s). - - @param s: (C++: const segment_t *) pointer to segment - @return: 0 if s == nullptr, the segment base paragraph - -ida_segment.get_segm_qty (function) - get_segm_qty() -> int - Get number of segments. - -ida_segment.get_segment_alignment (function) - get_segment_alignment(align) -> char const * - Get text representation of segment alignment code. - - @param align: (C++: uchar) - @return: text digestable by IBM PC assembler. - -ida_segment.get_segment_cmt (function) - get_segment_cmt(s, repeatable) -> str - Get segment comment. - - @param s: (C++: const segment_t *) pointer to segment structure - @param repeatable: (C++: bool) 0: get regular comment. 1: get repeatable comment. - @return: size of comment or -1 - -ida_segment.get_segment_combination (function) - get_segment_combination(comb) -> char const * - Get text representation of segment combination code. - - @param comb: (C++: uchar) - @return: text digestable by IBM PC assembler. - -ida_segment.get_segment_translations (function) - get_segment_translations(transmap, segstart) -> ssize_t - Get segment translation list. - - @param transmap: (C++: eavec_t *) vector of segment start addresses for the translation list - @param segstart: (C++: ea_t) start address of the segment to get information about - @return: -1 if no translation list or bad segstart. otherwise returns size of - translation list. - -ida_segment.get_selector_qty (function) - get_selector_qty() -> size_t - Get number of defined selectors. - -ida_segment.get_visible_segm_name (function) - get_visible_segm_name(s) -> str - Get segment name by pointer to segment. - - @param s: (C++: const segment_t *) pointer to segment - @return: size of segment name (-1 if s==nullptr) - -ida_segment.getn_selector (function) - getn_selector(n) -> bool - Get description of selector (0..get_selector_qty()-1) - - @param n: (C++: int) - -ida_segment.getnseg (function) - getnseg(n) -> segment_t - Get pointer to segment by its number. - @warning: Obsoleted because it can slow down the debugger (it has to refresh the - whole memory segmentation to calculate the correct answer) - - @param n: (C++: int) segment number in the range (0..get_segm_qty()-1) - @return: nullptr or pointer to segment structure - -ida_segment.getseg (function) - getseg(ea) -> segment_t - Get pointer to segment by linear address. - - @param ea: (C++: ea_t) linear address belonging to the segment - @return: nullptr or pointer to segment structure - -ida_segment.is_finally_visible_segm (function) - is_finally_visible_segm(s) -> bool - See SFL_HIDDEN, SCF_SHHID_SEGM. - - @param s: (C++: segment_t *) - -ida_segment.is_miniidb (function) - is_miniidb() -> bool - Is the database a miniidb created by the debugger?. - - @return: true if the database contains no segments or only debugger segments - -ida_segment.is_segm_locked (function) - is_segm_locked(segm) -> bool - Is a segment pointer locked? - - @param segm: (C++: const segment_t *) segment_t const * - -ida_segment.is_spec_ea (function) - is_spec_ea(ea) -> bool - Does the address belong to a segment with a special type?. (SEG_XTRN, SEG_GRP, - SEG_ABSSYM, SEG_COMM) - - @param ea: (C++: ea_t) linear address - -ida_segment.is_spec_segm (function) - is_spec_segm(seg_type) -> bool - Has segment a special type?. (SEG_XTRN, SEG_GRP, SEG_ABSSYM, SEG_COMM) - - @param seg_type: (C++: uchar) - -ida_segment.is_visible_segm (function) - is_visible_segm(s) -> bool - See SFL_HIDDEN. - - @param s: (C++: segment_t *) - -ida_segment.lock_segm (function) - lock_segm(segm, lock) - Lock segment pointer Locked pointers are guaranteed to remain valid until they - are unlocked. Ranges with locked pointers cannot be deleted or moved. - - @param segm: (C++: const segment_t *) segment_t const * - @param lock: (C++: bool) - -ida_segment.lock_segment (class) - Proxy of C++ lock_segment class. - -ida_segment.lock_segment.__init__ (method) - __init__(self, _segm) -> lock_segment - - @param _segm: segment_t const * - -ida_segment.move_segm (function) - move_segm(s, to, flags=0) -> move_segm_code_t - This function moves all information to the new address. It fixes up address - sensitive information in the kernel. The total effect is equal to reloading the - segment to the target address. For the file format dependent address sensitive - information, loader_t::move_segm is called. Also IDB notification event - idb_event::segm_moved is called. - - @param s: (C++: segment_t *) segment to move - @param to: (C++: ea_t) new segment start address - @param flags: (C++: int) Move segment flags - @return: Move segment result codes - -ida_segment.move_segm_start (function) - move_segm_start(ea, newstart, mode) -> bool - Move segment start. The main difference between this function and - set_segm_start() is that this function may expand the previous segment while - set_segm_start() never does it. So, this function allows to change bounds of two - segments simultaneously. If the previous segment and the specified segment have - the same addressing mode and segment base, then instructions and data are not - destroyed - they simply move from one segment to another. Otherwise all - instructions/data which migrate from one segment to another are destroyed. - @note: this function never disables addresses. - - @param ea: (C++: ea_t) any address belonging to the segment - @param newstart: (C++: ea_t) new start address of the segment note that segment start - address should be higher than segment base linear address. - @param mode: (C++: int) policy for destroying defined items - * 0: if it is necessary to destroy defined items, display a dialog box and ask - confirmation - * 1: if it is necessary to destroy defined items, just destroy them without - asking the user - * -1: if it is necessary to destroy defined items, don't destroy them (i.e. - function will fail) - * -2: don't destroy defined items (function will succeed) - @retval 1: ok - @retval 0: failed, a warning message is displayed - -ida_segment.move_segm_strerror (function) - move_segm_strerror(code) -> char const * - Return string describing error MOVE_SEGM_... code. - - @param code: (C++: move_segm_code_t) enum move_segm_code_t - -ida_segment.rebase_program (function) - rebase_program(delta, flags) -> int - Rebase the whole program by 'delta' bytes. - - @param delta: (C++: adiff_t) number of bytes to move the program - @param flags: (C++: int) Move segment flags it is recommended to use MSF_FIXONCE so that - the loader takes care of global variables it stored in the - database - @return: Move segment result codes - -ida_segment.saAbs (variable) - Absolute segment. - -ida_segment.saGroup (variable) - Segment group. - -ida_segment.saRel1024Bytes (variable) - 1024 bytes - -ida_segment.saRel128Bytes (variable) - 128 bytes - -ida_segment.saRel2048Bytes (variable) - 2048 bytes - -ida_segment.saRel32Bytes (variable) - 32 bytes - -ida_segment.saRel4K (variable) - This value is used by the PharLap OMF for page (4K) alignment. It is not - supported by LINK. - -ida_segment.saRel512Bytes (variable) - 512 bytes - -ida_segment.saRel64Bytes (variable) - 64 bytes - -ida_segment.saRelByte (variable) - Relocatable, byte aligned. - -ida_segment.saRelDble (variable) - Relocatable, aligned on a double word (4-byte) boundary. - -ida_segment.saRelPage (variable) - Relocatable, aligned on 256-byte boundary. - -ida_segment.saRelPara (variable) - Relocatable, paragraph (16-byte) aligned. - -ida_segment.saRelQword (variable) - 8 bytes - -ida_segment.saRelWord (variable) - Relocatable, word (2-byte) aligned. - -ida_segment.scCommon (variable) - Common. Combine by overlay using maximum size. - -ida_segment.scGroup (variable) - Segment group. - -ida_segment.scPriv (variable) - Private. Do not combine with any other program segment. - -ida_segment.scPub (variable) - Public. Combine by appending at an offset that meets the alignment requirement. - -ida_segment.scPub2 (variable) - As defined by Microsoft, same as C=2 (public). - -ida_segment.scPub3 (variable) - As defined by Microsoft, same as C=2 (public). - -ida_segment.scStack (variable) - Stack. Combine as for C=2. This combine type forces byte alignment. - -ida_segment.segm_adjust_diff (function) - segm_adjust_diff(s, delta) -> adiff_t - Truncate and sign extend a delta depending on the segment. - - @param s: (C++: const segment_t *) segment_t const * - @param delta: (C++: adiff_t) - -ida_segment.segm_adjust_ea (function) - segm_adjust_ea(s, ea) -> ea_t - Truncate an address depending on the segment. - - @param s: (C++: const segment_t *) segment_t const * - @param ea: (C++: ea_t) - -ida_segment.segment_defsr_array (class) - Proxy of C++ wrapped_array_t< sel_t,SREG_NUM > class. - -ida_segment.segment_defsr_array.__getitem__ (method) - __getitem__(self, i) -> unsigned-ea-like-numeric-type const & - - @param i: size_t - -ida_segment.segment_defsr_array.__init__ (method) - __init__(self, data) -> segment_defsr_array - - @param data: unsigned-ea-like-numeric-type (&)[SREG_NUM] - -ida_segment.segment_defsr_array.__len__ (method) - __len__(self) -> size_t - -ida_segment.segment_defsr_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: unsigned-ea-like-numeric-type const & - -ida_segment.segment_defsr_array._get_bytes (method) - _get_bytes(self) -> bytevec_t - -ida_segment.segment_defsr_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & - -ida_segment.segment_t (class) - Proxy of C++ segment_t class. - -ida_segment.segment_t.__getDefsr (method) - __getDefsr(self) -> segment_defsr_array - -ida_segment.segment_t.__init__ (method) - __init__(self) -> segment_t - -ida_segment.segment_t.abits (method) - abits(self) -> int - Get number of address bits. - -ida_segment.segment_t.abytes (method) - abytes(self) -> int - Get number of address bytes. - -ida_segment.segment_t.align (variable) - Segment alignment codes - -ida_segment.segment_t.bitness (variable) - Number of bits in the segment addressing - * 0: 16 bits - * 1: 32 bits - * 2: 64 bits - -ida_segment.segment_t.clr_comorg (method) - clr_comorg(self) - -ida_segment.segment_t.clr_ob_ok (method) - clr_ob_ok(self) - -ida_segment.segment_t.color (variable) - the segment color - -ida_segment.segment_t.comb (variable) - Segment combination codes - -ida_segment.segment_t.comorg (method) - comorg(self) -> bool - -ida_segment.segment_t.defsr (variable) - default segment register values. first element of this array keeps information - about value of processor_t::reg_first_sreg - -ida_segment.segment_t.flags (variable) - Segment flags - -ida_segment.segment_t.is_16bit (method) - is_16bit(self) -> bool - Is a 16-bit segment? - -ida_segment.segment_t.is_32bit (method) - is_32bit(self) -> bool - Is a 32-bit segment? - -ida_segment.segment_t.is_64bit (method) - is_64bit(self) -> bool - Is a 64-bit segment? - -ida_segment.segment_t.is_header_segm (method) - is_header_segm(self) -> bool - -ida_segment.segment_t.is_hidden_segtype (method) - is_hidden_segtype(self) -> bool - -ida_segment.segment_t.is_loader_segm (method) - is_loader_segm(self) -> bool - -ida_segment.segment_t.is_visible_segm (method) - is_visible_segm(self) -> bool - -ida_segment.segment_t.name (variable) - use get/set_segm_name() functions - -ida_segment.segment_t.ob_ok (method) - ob_ok(self) -> bool - -ida_segment.segment_t.orgbase (variable) - this field is IDP dependent. you may keep your information about the segment - here - -ida_segment.segment_t.perm (variable) - Segment permissions (0 means no information) - -ida_segment.segment_t.sclass (variable) - use get/set_segm_class() functions - -ida_segment.segment_t.sel (variable) - segment selector - should be unique. You can't change this field after creating - the segment. Exception: 16bit OMF files may have several segments with the same - selector, but this is not good (no way to denote a segment exactly) so it should - be fixed in the future. - -ida_segment.segment_t.set_comorg (method) - set_comorg(self) - -ida_segment.segment_t.set_debugger_segm (method) - set_debugger_segm(self, debseg) - - @param debseg: bool - -ida_segment.segment_t.set_header_segm (method) - set_header_segm(self, on) - - @param on: bool - -ida_segment.segment_t.set_hidden_segtype (method) - set_hidden_segtype(self, hide) - - @param hide: bool - -ida_segment.segment_t.set_loader_segm (method) - set_loader_segm(self, ldrseg) - - @param ldrseg: bool - -ida_segment.segment_t.set_ob_ok (method) - set_ob_ok(self) - -ida_segment.segment_t.set_visible_segm (method) - set_visible_segm(self, visible) - - @param visible: bool - -ida_segment.segment_t.type (variable) - segment type (see Segment types). The kernel treats different segment types - differently. Segments marked with '*' contain no instructions or data and are - not declared as 'segments' in the disassembly. - -ida_segment.segment_t.update (method) - update(self) -> bool - Update segment information. You must call this function after modification of - segment characteristics. Note that not all fields of segment structure may be - modified directly, there are special functions to modify some fields. - - @return: success - -ida_segment.segtype (function) - segtype(ea) -> uchar - Get segment type. - - @param ea: (C++: ea_t) any linear address within the segment - @return: Segment types, SEG_UNDF if no segment found at 'ea' - -ida_segment.sel2ea (function) - sel2ea(selector) -> ea_t - Get mapping of a selector as a linear address. - - @param selector: (C++: sel_t) number of selector to translate to linear address - @return: linear address the specified selector is mapped to. if there is no - mapping, returns to_ea(selector,0); - -ida_segment.sel2para (function) - sel2para(selector) -> ea_t - Get mapping of a selector. - - @param selector: (C++: sel_t) number of selector to translate - @return: paragraph the specified selector is mapped to. if there is no mapping, - returns 'selector'. - -ida_segment.set_defsr (function) - set_defsr(s, reg, value) - Deprecated, use instead: - s.defsr[reg] = value - - @param s: segment_t * - @param reg: int - @param value: sel_t - -ida_segment.set_group_selector (function) - set_group_selector(grp, sel) -> int - Create a new group of segments (used OMF files). - - @param grp: (C++: sel_t) selector of group segment (segment type is SEG_GRP) You should - create an 'empty' (1 byte) group segment It won't contain anything - and will be used to redirect references to the group of segments to - the common selector. - @param sel: (C++: sel_t) common selector of all segments belonging to the segment You should - create all segments within the group with the same selector value. - @return: 1 ok - 0 too many groups (see MAX_GROUPS) - -ida_segment.set_segm_addressing (function) - set_segm_addressing(s, bitness) -> bool - Change segment addressing mode (16, 32, 64 bits). You must use this function to - change segment addressing, never change the 'bitness' field directly. This - function will delete all instructions, comments and names in the segment - - @param s: (C++: segment_t *) pointer to segment - @param bitness: (C++: size_t) new addressing mode of segment - * 2: 64bit segment - * 1: 32bit segment - * 0: 16bit segment - @return: success - -ida_segment.set_segm_base (function) - set_segm_base(s, newbase) -> bool - Internal function. - - @param s: (C++: segment_t *) - @param newbase: (C++: ea_t) - -ida_segment.set_segm_class (function) - set_segm_class(s, sclass, flags=0) -> int - Set segment class. - - @param s: (C++: segment_t *) pointer to segment (may be nullptr) - @param sclass: (C++: const char *) segment class (may be nullptr). If segment type is SEG_NORM and - segment class is one of predefined names, then segment type is - changed to: - * "CODE" -> SEG_CODE - * "DATA" -> SEG_DATA - * "STACK" -> SEG_BSS - * "BSS" -> SEG_BSS - * if "UNK" then segment type is reset to SEG_NORM. - @param flags: (C++: int) Add segment flags - @retval 1: ok, name is good and segment is renamed - @retval 0: failure, name is nullptr or bad or segment is nullptr - -ida_segment.set_segm_end (function) - set_segm_end(ea, newend, flags) -> bool - Set segment end address. The next segment is shrinked to allow expansion of the - specified segment. The kernel might even delete the next segment if necessary. - The kernel will ask the user for a permission to destroy instructions or data - going out of segment scope if such instructions exist. - - @param ea: (C++: ea_t) any address belonging to the segment - @param newend: (C++: ea_t) new end address of the segment - @param flags: (C++: int) Segment modification flags - @retval 1: ok - @retval 0: failed, a warning message is displayed - -ida_segment.set_segm_name (function) - set_segm_name(s, name, flags=0) -> int - Rename segment. The new name is validated (see validate_name). A segment always - has a name. If you hadn't specified a name, the kernel will assign it "seg###" - name where ### is segment number. - - @param s: (C++: segment_t *) pointer to segment (may be nullptr) - @param name: (C++: const char *) new segment name - @param flags: (C++: int) ADDSEG_IDBENC or 0 - @retval 1: ok, name is good and segment is renamed - @retval 0: failure, name is bad or segment is nullptr - -ida_segment.set_segm_start (function) - set_segm_start(ea, newstart, flags) -> bool - Set segment start address. The previous segment is trimmed to allow expansion of - the specified segment. The kernel might even delete the previous segment if - necessary. The kernel will ask the user for a permission to destroy instructions - or data going out of segment scope if such instructions exist. - - @param ea: (C++: ea_t) any address belonging to the segment - @param newstart: (C++: ea_t) new start address of the segment note that segment start - address should be higher than segment base linear address. - @param flags: (C++: int) Segment modification flags - @retval 1: ok - @retval 0: failed, a warning message is displayed - -ida_segment.set_segment_cmt (function) - set_segment_cmt(s, cmt, repeatable) - Set segment comment. - - @param s: (C++: const segment_t *) pointer to segment structure - @param cmt: (C++: const char *) comment string, may be multiline (with ' - '). maximal size is 4096 bytes. Use empty str ("") to delete comment - @param repeatable: (C++: bool) 0: set regular comment. 1: set repeatable comment. - -ida_segment.set_segment_translations (function) - set_segment_translations(segstart, transmap) -> bool - Set new translation list. - - @param segstart: (C++: ea_t) start address of the segment to add translation to - @param transmap: (C++: const eavec_t &) vector of segment start addresses for the translation list. If - transmap is empty, the translation list is deleted. - @retval 1: ok - @retval 0: too many translations or bad segstart - -ida_segment.set_selector (function) - set_selector(selector, paragraph) -> int - Set mapping of selector to a paragraph. You should call this function _before_ - creating a segment which uses the selector, otherwise the creation of the - segment will fail. - - @param selector: (C++: sel_t) number of selector to map - * if selector == BADSEL, then return 0 (fail) - * if the selector has had a mapping, old mapping is destroyed - * if the selector number is equal to paragraph value, then the mapping is - destroyed because we don't need to keep trivial mappings. - @param paragraph: (C++: ea_t) paragraph to map selector - @retval 1: ok - @retval 0: failure (bad selector or too many mappings) - -ida_segment.set_visible_segm (function) - set_visible_segm(s, visible) - See SFL_HIDDEN. - - @param s: (C++: segment_t *) - @param visible: (C++: bool) - -ida_segment.setup_selector (function) - setup_selector(segbase) -> sel_t - Allocate a selector for a segment if necessary. You must call this function - before calling add_segm_ex(). add_segm() calls this function itself, so you - don't need to allocate a selector. This function will allocate a selector if - 'segbase' requires more than 16 bits and the current processor is IBM PC. - Otherwise it will return the segbase value. - - @param segbase: (C++: ea_t) a new segment base paragraph - @return: the allocated selector number - -ida_segment.std_out_segm_footer (function) - std_out_segm_footer(ctx, seg) - Generate segment footer line as a comment line. This function may be used in IDP - modules to generate segment footer if the target assembler doesn't have 'ends' - directive. - - @param ctx: (C++: struct outctx_t &) outctx_t & - @param seg: (C++: segment_t *) - -ida_segment.take_memory_snapshot (function) - take_memory_snapshot(type) -> bool - Take a memory snapshot of the running process. - - @param type: (C++: int) specifies which snapshot we want (see SNAP_ Snapshot types) - @return: success - -ida_segment.update_segm (function) - update_segm(s) -> bool - - @param s: segment_t * - -ida_segregs (module) - Functions that deal with the segment registers. - - If your processor doesn't use segment registers, then these functions are of no - use for you. However, you should define two virtual segment registers - CS and - DS (for code segment and data segment) and specify their internal numbers in the - LPH structure (processor_t::reg_code_sreg and processor_t::reg_data_sreg). - -ida_segregs.SR_auto (variable) - the value is determined by IDA - -ida_segregs.SR_autostart (variable) - used as SR_auto for segment starting address - -ida_segregs.SR_inherit (variable) - the value is inherited from the previous range - -ida_segregs.SR_user (variable) - the value is specified by the user - -ida_segregs.copy_sreg_ranges (function) - copy_sreg_ranges(dst_rg, src_rg, map_selector=False) - Duplicate segment register ranges. - - @param dst_rg: (C++: int) number of destination segment register - @param src_rg: (C++: int) copy ranges from - @param map_selector: (C++: bool) map selectors to linear addresses using sel2ea() - -ida_segregs.del_sreg_range (function) - del_sreg_range(ea, rg) -> bool - Delete segment register range started at ea. When a segment register range is - deleted, the previous range is extended to cover the empty space. The segment - register range at the beginning of a segment cannot be deleted. - - @param ea: (C++: ea_t) start_ea of the deleted range - @param rg: (C++: int) the segment register number - @return: success - -ida_segregs.get_prev_sreg_range (function) - get_prev_sreg_range(out, ea, rg) -> bool - Get segment register range previous to one with address. - @note: more efficient then get_sreg_range(reg, ea-1) - - @param out: (C++: sreg_range_t *) segment register range - @param ea: (C++: ea_t) any linear address in the program - @param rg: (C++: int) the segment register number - @return: success - -ida_segregs.get_sreg (function) - get_sreg(ea, rg) -> sel_t - Get value of a segment register. This function uses segment register range and - default segment register values stored in the segment structure. - - @param ea: (C++: ea_t) linear address in the program - @param rg: (C++: int) number of the segment register - @return: value of the segment register, BADSEL if value is unknown. - -ida_segregs.get_sreg_range (function) - get_sreg_range(out, ea, rg) -> bool - Get segment register range by linear address. - - @param out: (C++: sreg_range_t *) segment register range - @param ea: (C++: ea_t) any linear address in the program - @param rg: (C++: int) the segment register number - @return: success - -ida_segregs.get_sreg_range_num (function) - get_sreg_range_num(ea, rg) -> int - Get number of segment register range by address. - - @param ea: (C++: ea_t) any address in the range - @param rg: (C++: int) the segment register number - @return: -1 if no range occupies the specified address. otherwise returns number - of the specified range (0..get_srranges_qty()-1) - -ida_segregs.get_sreg_ranges_qty (function) - get_sreg_ranges_qty(rg) -> size_t - Get number of segment register ranges. - - @param rg: (C++: int) the segment register number - -ida_segregs.getn_sreg_range (function) - getn_sreg_range(out, rg, n) -> bool - Get segment register range by its number. - - @param out: (C++: sreg_range_t *) segment register range - @param rg: (C++: int) the segment register number - @param n: (C++: int) number of range (0..qty()-1) - @return: success - -ida_segregs.set_default_dataseg (function) - set_default_dataseg(ds_sel) - Set default value of DS register for all segments. - - @param ds_sel: (C++: sel_t) - -ida_segregs.set_default_sreg_value (function) - set_default_sreg_value(sg, rg, value) -> bool - Set default value of a segment register for a segment. - - @param sg: (C++: segment_t *) pointer to segment structure if nullptr, then set the register for - all segments - @param rg: (C++: int) number of segment register - @param value: (C++: sel_t) its default value. this value will be used by get_sreg() if value - of the register is unknown at the specified address. - @return: success - -ida_segregs.set_sreg_at_next_code (function) - set_sreg_at_next_code(ea1, ea2, rg, value) - Set the segment register value at the next instruction. This function is - designed to be called from idb_event::sgr_changed handler in order to contain - the effect of changing a segment register value only until the next instruction. - - It is useful, for example, in the ARM module: the modification of the T register - does not affect existing instructions later in the code. - - @param ea1: (C++: ea_t) address to start to search for an instruction - @param ea2: (C++: ea_t) the maximal address - @param rg: (C++: int) the segment register number - @param value: (C++: sel_t) the segment register value - -ida_segregs.split_sreg_range (function) - split_sreg_range(ea, rg, v, tag, silent=False) -> bool - Create a new segment register range. This function is used when the IDP emulator - detects that a segment register changes its value. - - @param ea: (C++: ea_t) linear address where the segment register will have a new value. if - ea==BADADDR, nothing to do. - @param rg: (C++: int) the number of the segment register - @param v: (C++: sel_t) the new value of the segment register. If the value is unknown, you - should specify BADSEL. - @param tag: (C++: uchar) the register info tag. see Segment register range tags - @param silent: (C++: bool) if false, display a warning() in the case of failure - @return: success - -ida_segregs.sreg_range_t (class) - Proxy of C++ sreg_range_t class. - -ida_segregs.sreg_range_t.__init__ (method) - __init__(self) -> sreg_range_t - -ida_segregs.sreg_range_t.tag (variable) - Segment register range tags - -ida_segregs.sreg_range_t.val (variable) - segment register value - -ida_srclang (module) - Third-party compiler support. - -ida_srclang.SRCLANG_C (variable) - C. - -ida_srclang.SRCLANG_CPP (variable) - C++. - -ida_srclang.SRCLANG_GO (variable) - Golang (not supported yet) - -ida_srclang.SRCLANG_OBJC (variable) - Objective-C. - -ida_srclang.SRCLANG_SWIFT (variable) - Swift (not supported yet) - -ida_srclang.parse_decls_for_srclang (function) - parse_decls_for_srclang(lang, til, input, is_path) -> int - Parse type declarations in the specified language - - @param lang: (C++: srclang_t) the source language(s) expected in the input - @param til: (C++: til_t *) type library to store the types - @param input: (C++: const char *) input source. can be a file path or decl string - @param is_path: (C++: bool) true if input parameter is a path to a source file, false if the - input is an in-memory source snippet - @retval -1: no parser was found that supports the given source language(s) - @retval else: the number of errors encountered in the input source - -ida_srclang.parse_decls_with_parser (function) - parse_decls_with_parser(parser_name, til, input, is_path) -> int - Parse type declarations using the parser with the specified name - - @param parser_name: (C++: const char *) name of the target parser - @param til: (C++: til_t *) type library to store the types - @param input: (C++: const char *) input source. can be a file path or decl string - @param is_path: (C++: bool) true if input parameter is a path to a source file, false if the - input is an in-memory source snippet - @retval -1: no parser was found with the given name - @retval else: the number of errors encountered in the input source - -ida_srclang.select_parser_by_name (function) - select_parser_by_name(name) -> bool - Set the parser with the given name as the current parser. Pass nullptr or an - empty string to select the default parser. - - @param name: (C++: const char *) char const * - @return: false if no parser was found with the given name - -ida_srclang.select_parser_by_srclang (function) - select_parser_by_srclang(lang) -> bool - Set the parser that supports the given language(s) as the current parser. The - selected parser must support all languages specified by the given srclang_t. - - @param lang: (C++: srclang_t) - @return: false if no such parser was found - -ida_srclang.set_parser_argv (function) - set_parser_argv(parser_name, argv) -> int - Set the command-line args to use for invocations of the parser with the given - name - - @param parser_name: (C++: const char *) name of the target parser - @param argv: (C++: const char *) argument list - @retval -1: no parser was found with the given name - @retval -2: the operation is not supported by the given parser - @retval 0: success - -ida_strlist (module) - Functions that deal with the string list. - - While the kernel keeps the string list, it does not update it. The string list - is not used by the kernel because keeping it up-to-date would slow down IDA - without any benefit. If the string list is not cleared using clear_strlist(), - the list will be saved to the database and restored on the next startup. - - The users of this list should call build_strlist() if they need an up-to-date - version. - -ida_strlist.build_strlist (function) - build_strlist() - Rebuild the string list. - -ida_strlist.clear_strlist (function) - clear_strlist() - Clear the string list. - -ida_strlist.get_strlist_item (function) - get_strlist_item(si, n) -> bool - Get nth element of the string list (n=0..get_strlist_qty()-1) - - @param si: (C++: string_info_t *) - @param n: (C++: size_t) - -ida_strlist.get_strlist_options (function) - get_strlist_options() -> strwinsetup_t - Get the static string list options. - -ida_strlist.get_strlist_qty (function) - get_strlist_qty() -> size_t - Get number of elements in the string list. The list will be loaded from the - database (if saved) or built from scratch. - -ida_strlist.string_info_t (class) - Proxy of C++ string_info_t class. - -ida_strlist.string_info_t.__init__ (method) - __init__(self, _ea=BADADDR) -> string_info_t - - @param _ea: ea_t - -ida_strlist.string_info_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: string_info_t const & - -ida_strlist.strwinsetup_t (class) - Proxy of C++ strwinsetup_t class. - -ida_strlist.strwinsetup_t.__init__ (method) - __init__(self) -> strwinsetup_t - -ida_strlist.strwinsetup_t._get_strtypes (method) - _get_strtypes(self) -> PyObject * - -ida_strlist.strwinsetup_t._set_strtypes (method) - _set_strtypes(self, py_t) -> PyObject * - - Parameters - ---------- - py_t: PyObject * - -ida_struct (module) - Structure type management (assembly level types) - -ida_struct.MF_BASECLASS (variable) - a special member representing base class - -ida_struct.MF_BYTIL (variable) - the member was created due to the type system - -ida_struct.MF_DTOR (variable) - a special member representing destructor - -ida_struct.MF_DUPNAME (variable) - duplicate name resolved with _N suffix (N==soff) - -ida_struct.MF_HASTI (variable) - has type information? - -ida_struct.MF_HASUNI (variable) - has members of type "union"? - -ida_struct.MF_OK (variable) - is the member ok? (always yes) - -ida_struct.MF_UNIMEM (variable) - is a member of a union? - -ida_struct.SET_MEMTI_BYTIL (variable) - new type was created by the type subsystem - -ida_struct.SET_MEMTI_COMPATIBLE (variable) - new type must be compatible with the old - -ida_struct.SET_MEMTI_FUNCARG (variable) - mptr is function argument (cannot create arrays) - -ida_struct.SET_MEMTI_MAY_DESTROY (variable) - may destroy other members - -ida_struct.SET_MEMTI_USERTI (variable) - user-specified type - -ida_struct.SF_ALIGN (variable) - alignment (shift amount: 0..31) - -ida_struct.SF_FRAME (variable) - the structure is a function frame - -ida_struct.SF_GHOST (variable) - ghost copy of a local type - -ida_struct.SF_HASUNI (variable) - has members of type "union"? - -ida_struct.SF_HIDDEN (variable) - the structure is collapsed - -ida_struct.SF_NOLIST (variable) - don't include in the chooser list - -ida_struct.SF_TYPLIB (variable) - the structure comes from type library - -ida_struct.SF_UNION (variable) - is a union? varunions are prohibited! - -ida_struct.SF_VAR (variable) - is variable size structure (varstruct)? a variable size structure is one with - the zero size last member. if the last member is a varstruct, then the current - structure is a varstruct too. - -ida_struct.SMT_ARRAY (variable) - arrays are forbidden as function arguments - -ida_struct.SMT_BADARG (variable) - bad parameters - -ida_struct.SMT_FAILED (variable) - failed to set new member type - -ida_struct.SMT_KEEP (variable) - no need to change the member type, the old type is better - -ida_struct.SMT_NOCOMPAT (variable) - the new type is not compatible with the old type - -ida_struct.SMT_OVERLAP (variable) - member would overlap with members that cannot be deleted - -ida_struct.SMT_SIZE (variable) - the new type is incompatible with the member size - -ida_struct.SMT_WORSE (variable) - the new type is worse than the old type - -ida_struct.STRNFL_REGEX (variable) - apply regular expressions to beautify the name - -ida_struct.STRUC_ERROR_MEMBER_LTUDT (variable) - failed to change corresponding local type - -ida_struct.STRUC_ERROR_MEMBER_NAME (variable) - already has member with this name (bad name) - -ida_struct.STRUC_ERROR_MEMBER_NESTED (variable) - recursive structure nesting is forbidden - -ida_struct.STRUC_ERROR_MEMBER_OFFSET (variable) - already has member at this offset - -ida_struct.STRUC_ERROR_MEMBER_OK (variable) - success - -ida_struct.STRUC_ERROR_MEMBER_SIZE (variable) - bad number of bytes or bad sizeof(type) - -ida_struct.STRUC_ERROR_MEMBER_STRUCT (variable) - bad struct id (the 1st argument) - -ida_struct.STRUC_ERROR_MEMBER_TINFO (variable) - bad typeid parameter - -ida_struct.STRUC_ERROR_MEMBER_UNIVAR (variable) - unions can't have variable sized members - -ida_struct.STRUC_ERROR_MEMBER_VARLAST (variable) - variable sized member should be the last member in the structure - -ida_struct.STRUC_SEPARATOR (variable) - structname.fieldname - -ida_struct.add_struc (function) - add_struc(idx, name, is_union=False) -> tid_t - Create a structure type. if idx==BADADDR then add as the last idx. if - name==nullptr then a name will be generated "struct_%d". - - @param idx: (C++: uval_t) - @param name: (C++: const char *) char const * - @param is_union: (C++: bool) - -ida_struct.add_struc_member (function) - add_struc_member(sptr, fieldname, offset, flag, mt, nbytes) -> struc_error_t - Add member to existing structure. - - @param sptr: (C++: struc_t *) structure to modify - @param fieldname: (C++: const char *) if nullptr, then "anonymous_#" name will be generated - @param offset: (C++: ea_t) BADADDR means add to the end of structure - @param flag: (C++: flags64_t) type + representation bits - @param mt: (C++: const opinfo_t *) additional info about member type. must be present for structs, - offsets, enums, strings, struct offsets. - @param nbytes: (C++: asize_t) if == 0 then the structure will be a varstruct. in this case the - member should be the last member in the structure - -ida_struct.del_member_tinfo (function) - del_member_tinfo(sptr, mptr) -> bool - Delete tinfo for given member. - - @param sptr: (C++: struc_t *) - @param mptr: (C++: member_t *) - -ida_struct.del_struc (function) - del_struc(sptr) -> bool - Delete a structure type This function deletes as well local type synced with the - structure - - @param sptr: (C++: struc_t *) - -ida_struct.del_struc_member (function) - del_struc_member(sptr, offset) -> bool - Delete member at given offset. - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - -ida_struct.del_struc_members (function) - del_struc_members(sptr, off1, off2) -> int - Delete members which occupy range of offsets (off1..off2). - - @param sptr: (C++: struc_t *) - @param off1: (C++: ea_t) - @param off2: (C++: ea_t) - @return: number of deleted members or -1 on error - -ida_struct.dyn_member_ref_array (class) - Proxy of C++ dynamic_wrapped_array_t< member_t > class. - -ida_struct.dyn_member_ref_array.__getitem__ (method) - __getitem__(self, i) -> member_t - - @param i: size_t - -ida_struct.dyn_member_ref_array.__init__ (method) - __init__(self, _data, _count) -> dyn_member_ref_array - - @param _data: member_t * - @param _count: size_t - -ida_struct.dyn_member_ref_array.__len__ (method) - __len__(self) -> size_t - -ida_struct.dyn_member_ref_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: member_t const & - -ida_struct.expand_struc (function) - expand_struc(sptr, offset, delta, recalc=True) -> bool - Expand/Shrink structure type. - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - @param delta: (C++: adiff_t) - @param recalc: (C++: bool) - -ida_struct.get_best_fit_member (function) - get_best_fit_member(sptr, offset) -> member_t - Get member that is most likely referenced by the specified offset. Useful for - offsets > sizeof(struct). - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: asize_t) - -ida_struct.get_first_struc_idx (function) - get_first_struc_idx() -> uval_t - Get index of first structure. - - @return: BADADDR if no known structures, 0 otherwise - -ida_struct.get_innermost_member (function) - get_innermost_member(sptr, offset) -> (member_t, struc_t, int) - Get the innermost member at the given offset - - @param sptr: the starting structure - @param offset: offset into the starting structure - @return: - None on failure - - tuple(member_t, struct_t, offset) - where member_t: a member in SPTR (it is not a structure), - struct_t: the innermost structure, - offset: remaining offset into the returned member - -ida_struct.get_last_struc_idx (function) - get_last_struc_idx() -> uval_t - Get index of last structure. - - @return: BADADDR if no known structures, get_struc_qty()-1 otherwise - -ida_struct.get_max_offset (function) - get_max_offset(sptr) -> ea_t - For unions: returns number of members, for structs: returns size of structure. - - @param sptr: (C++: struc_t *) - -ida_struct.get_member (function) - get_member(sptr, offset) -> member_t - Get member at given offset. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: asize_t) - -ida_struct.get_member_by_fullname (function) - get_member_by_fullname(fullname) -> member_t - Get a member by its fully qualified name, "struct.field". - - @param fullname: (C++: const char *) char const * - -ida_struct.get_member_by_id (function) - get_member_by_id(mid) -> member_t - Check if the specified member id points to a struct member. convenience - function. - - @param mid: (C++: tid_t) - -ida_struct.get_member_by_name (function) - get_member_by_name(sptr, membername) -> member_t - Get a member by its name, like "field44". - - @param sptr: (C++: const struc_t *) struc_t const * - @param membername: (C++: const char *) char const * - -ida_struct.get_member_cmt (function) - get_member_cmt(mid, repeatable) -> str - Get comment of structure member. - - @param mid: (C++: tid_t) - @param repeatable: (C++: bool) - -ida_struct.get_member_fullname (function) - get_member_fullname(mid) -> str - Get a member's fully qualified name, "struct.field". - - @param mid: (C++: tid_t) - -ida_struct.get_member_id (function) - get_member_id(sptr, offset) -> tid_t - Get member id at given offset. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: asize_t) - -ida_struct.get_member_name (function) - get_member_name(mid) -> str - - @param mid: tid_t - -ida_struct.get_member_size (function) - get_member_size(NONNULL_mptr) -> asize_t - Get size of structure member. May return 0 for the last member of varstruct. For - union members, returns member_t::eoff. - - @param NONNULL_mptr: (C++: const member_t *) member_t const * - -ida_struct.get_member_struc (function) - get_member_struc(fullname) -> struc_t - Get containing structure of member by its full name "struct.field". - - @param fullname: (C++: const char *) char const * - -ida_struct.get_member_tinfo (function) - get_member_tinfo(tif, mptr) -> bool - Get tinfo for given member. - - @param tif: (C++: tinfo_t *) - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.get_next_member_idx (function) - get_next_member_idx(sptr, off) -> ssize_t - Get the next member idx, if it does not exist, return -1. - - @param sptr: (C++: const struc_t *) struc_t const * - @param off: (C++: asize_t) - -ida_struct.get_next_struc_idx (function) - get_next_struc_idx(idx) -> uval_t - Get next struct index. - - @param idx: (C++: uval_t) - @return: BADADDR if resulting index is out of bounds, otherwise idx++ - -ida_struct.get_or_guess_member_tinfo (function) - get_or_guess_member_tinfo(tif, mptr) -> bool - Try to get tinfo for given member - if failed, generate a tinfo using - information about the member id from the disassembly - - @param tif: (C++: tinfo_t *) - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.get_prev_member_idx (function) - get_prev_member_idx(sptr, off) -> ssize_t - Get the prev member idx, if it does not exist, return -1. - - @param sptr: (C++: const struc_t *) struc_t const * - @param off: (C++: asize_t) - -ida_struct.get_prev_struc_idx (function) - get_prev_struc_idx(idx) -> uval_t - Get previous struct index. - - @param idx: (C++: uval_t) - @return: BADADDR if resulting index is negative, otherwise idx - 1 - -ida_struct.get_sptr (function) - get_sptr(mptr) -> struc_t - Get child struct if member is a struct. - - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.get_struc (function) - get_struc(id) -> struc_t - Get pointer to struct type info. - - @param id: (C++: tid_t) - -ida_struct.get_struc_by_idx (function) - get_struc_by_idx(idx) -> tid_t - Get struct id by struct number. - - @param idx: (C++: uval_t) - -ida_struct.get_struc_cmt (function) - get_struc_cmt(id, repeatable) -> str - Get struct comment. - - @param id: (C++: tid_t) - @param repeatable: (C++: bool) - -ida_struct.get_struc_first_offset (function) - get_struc_first_offset(sptr) -> ea_t - Get offset of first member. - - @param sptr: (C++: const struc_t *) struc_t const * - @return: BADADDR if memqty == 0 - -ida_struct.get_struc_id (function) - get_struc_id(name) -> tid_t - Get struct id by name. - - @param name: (C++: const char *) char const * - -ida_struct.get_struc_idx (function) - get_struc_idx(id) -> uval_t - Get internal number of the structure. - - @param id: (C++: tid_t) - -ida_struct.get_struc_last_offset (function) - get_struc_last_offset(sptr) -> ea_t - Get offset of last member. - - @param sptr: (C++: const struc_t *) struc_t const * - @return: BADADDR if memqty == 0 - -ida_struct.get_struc_name (function) - get_struc_name(id, flags=0) -> str - - @param id: tid_t - @param flags: int - -ida_struct.get_struc_next_offset (function) - get_struc_next_offset(sptr, offset) -> ea_t - Get offset of member with smallest offset larger than 'offset'. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: ea_t) - @return: BADADDR if no next offset - -ida_struct.get_struc_prev_offset (function) - get_struc_prev_offset(sptr, offset) -> ea_t - Get offset of member with largest offset less than 'offset'. - - @param sptr: (C++: const struc_t *) struc_t const * - @param offset: (C++: ea_t) - @return: BADADDR if no prev offset - -ida_struct.get_struc_qty (function) - get_struc_qty() -> size_t - Get number of known structures. - -ida_struct.get_struc_size (function) - get_struc_size(sptr) -> asize_t - Get struct size (also see get_struc_size(const struc_t *)) - - @param sptr: struc_t const * - - get_struc_size(id) -> asize_t - - @param id: tid_t - -ida_struct.is_anonymous_member_name (function) - is_anonymous_member_name(name) -> bool - Is member name prefixed with "anonymous"? - - @param name: (C++: const char *) char const * - -ida_struct.is_dummy_member_name (function) - is_dummy_member_name(name) -> bool - Is member name an auto-generated name? - - @param name: (C++: const char *) char const * - -ida_struct.is_member_id (function) - is_member_id(mid) -> bool - Is a member id? - - @param mid: (C++: tid_t) - -ida_struct.is_special_member (function) - is_special_member(id) -> bool - Is a special member with the name beginning with ' '? - - @param id: (C++: tid_t) - -ida_struct.is_union (function) - is_union(id) -> bool - Is a union? - - @param id: (C++: tid_t) - -ida_struct.is_varmember (function) - is_varmember(mptr) -> bool - Is variable size member? - - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.is_varstr (function) - is_varstr(id) -> bool - Is variable size structure? - - @param id: (C++: tid_t) - -ida_struct.member_t (class) - Proxy of C++ member_t class. - -ida_struct.member_t.__init__ (method) - __init__(self) -> member_t - -ida_struct.member_t.by_til (method) - by_til(self) -> bool - Was the member created due to the type system? - -ida_struct.member_t.eoff (variable) - end offset - -ida_struct.member_t.flag (variable) - type+representation bits - -ida_struct.member_t.get_size (method) - get_size(self) -> asize_t - Get member size. - -ida_struct.member_t.get_soff (method) - get_soff(self) -> ea_t - Get start offset (for unions - returns 0) - -ida_struct.member_t.has_ti (method) - has_ti(self) -> bool - Has type information? - -ida_struct.member_t.has_union (method) - has_union(self) -> bool - Has members of type "union"? - -ida_struct.member_t.id (variable) - name(), cmt, rptcmt - -ida_struct.member_t.is_baseclass (method) - is_baseclass(self) -> bool - Is a base class member? - -ida_struct.member_t.is_destructor (method) - is_destructor(self) -> bool - Is a virtual destructor? - -ida_struct.member_t.is_dupname (method) - is_dupname(self) -> bool - Duplicate name was resolved during import? - -ida_struct.member_t.props (variable) - Struct member properties - -ida_struct.member_t.soff (variable) - start offset (for unions - number of the member 0..n) - -ida_struct.member_t.unimem (method) - unimem(self) -> bool - Is a member of a union? - -ida_struct.retrieve_member_info (function) - retrieve_member_info(buf, mptr) -> opinfo_t - Get operand type info for member. - - @param buf: (C++: opinfo_t *) - @param mptr: (C++: const member_t *) member_t const * - -ida_struct.save_struc (function) - save_struc(sptr, may_update_ltypes=True) - Update struct information in the database (internal function) - - @param sptr: (C++: const struc_t *) struc_t const * - @param may_update_ltypes: (C++: bool) - -ida_struct.set_member_cmt (function) - set_member_cmt(mptr, cmt, repeatable) -> bool - Set member comment. - - @param mptr: (C++: member_t *) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_struct.set_member_name (function) - set_member_name(sptr, offset, name) -> bool - Set name of member at given offset. - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - @param name: (C++: const char *) char const * - -ida_struct.set_member_tinfo (function) - set_member_tinfo(sptr, mptr, memoff, tif, flags) -> smt_code_t - Set tinfo for given member. - - @param sptr: (C++: struc_t *) containing struct - @param mptr: (C++: member_t *) target member - @param memoff: (C++: uval_t) offset within member - @param tif: (C++: const tinfo_t &) type info - @param flags: (C++: int) Set member tinfo flags - -ida_struct.set_member_type (function) - set_member_type(sptr, offset, flag, mt, nbytes) -> bool - Set type of member at given offset (also see add_struc_member()) - - @param sptr: (C++: struc_t *) - @param offset: (C++: ea_t) - @param flag: (C++: flags64_t) - @param mt: (C++: const opinfo_t *) opinfo_t const * - @param nbytes: (C++: asize_t) - -ida_struct.set_struc_align (function) - set_struc_align(sptr, shift) -> bool - Set structure alignment (SF_ALIGN) - - @param sptr: (C++: struc_t *) - @param shift: (C++: int) - -ida_struct.set_struc_cmt (function) - set_struc_cmt(id, cmt, repeatable) -> bool - Set structure comment. - - @param id: (C++: tid_t) - @param cmt: (C++: const char *) char const * - @param repeatable: (C++: bool) - -ida_struct.set_struc_hidden (function) - set_struc_hidden(sptr, is_hidden) - Hide/unhide a struct type. - - @param sptr: (C++: struc_t *) - @param is_hidden: (C++: bool) - -ida_struct.set_struc_idx (function) - set_struc_idx(sptr, idx) -> bool - Set internal number of struct. Also see get_struc_idx(), get_struc_by_idx(). - - @param sptr: (C++: const struc_t *) struc_t const * - @param idx: (C++: uval_t) - -ida_struct.set_struc_listed (function) - set_struc_listed(sptr, is_listed) - Add/remove a struct type from the struct list. - - @param sptr: (C++: struc_t *) - @param is_listed: (C++: bool) - -ida_struct.set_struc_name (function) - set_struc_name(id, name) -> bool - Set structure name. - - @param id: (C++: tid_t) - @param name: (C++: const char *) char const * - -ida_struct.stroff_as_size (function) - stroff_as_size(plen, sptr, value) -> bool - - @param plen: int - @param sptr: struc_t const * - @param value: asize_t - - stroff_as_size(plen, tif, value) -> bool - - @param plen: int - @param tif: tinfo_t const & - @param value: asize_t - -ida_struct.struc_t (class) - Proxy of C++ struc_t class. - -ida_struct.struc_t.__get_members__ (method) - __get_members__(self) -> dyn_member_ref_array - -ida_struct.struc_t.__init__ (method) - -ida_struct.struc_t.age (variable) - not used - -ida_struct.struc_t.from_til (method) - from_til(self) -> bool - Does structure come from a type library? - -ida_struct.struc_t.get_alignment (method) - get_alignment(self) -> int - See SF_ALIGN. - -ida_struct.struc_t.get_last_member (method) - get_last_member(self) -> member_t - -ida_struct.struc_t.get_member (method) - -ida_struct.struc_t.has_union (method) - has_union(self) -> bool - Has members of type "union"? - -ida_struct.struc_t.id (variable) - struct id - -ida_struct.struc_t.is_choosable (method) - is_choosable(self) -> bool - Is included in chooser list? Use set_struc_listed to change the listed status - -ida_struct.struc_t.is_copyof (method) - is_copyof(self) -> bool - Is copied from a local type? - -ida_struct.struc_t.is_frame (method) - is_frame(self) -> bool - Is this structure a function frame? - -ida_struct.struc_t.is_ghost (method) - is_ghost(self) -> bool - Is a ghost copy of a local type? - -ida_struct.struc_t.is_hidden (method) - is_hidden(self) -> bool - Is the structure collapsed? Use set_struc_hidden to change the hidden status - -ida_struct.struc_t.is_mappedto (method) - is_mappedto(self) -> bool - Is mapped to a local type? - -ida_struct.struc_t.is_synced (method) - is_synced(self) -> bool - Is synced with a local type? - -ida_struct.struc_t.is_union (method) - is_union(self) -> bool - Is a union? - -ida_struct.struc_t.is_varstr (method) - is_varstr(self) -> bool - Is variable size structure? - -ida_struct.struc_t.like_union (method) - like_union(self) -> bool - Is a union or contains members of type "union"? - -ida_struct.struc_t.members (variable) - only defined members are stored here. there may be gaps between members. - -ida_struct.struc_t.memqty (variable) - number of members - -ida_struct.struc_t.ordinal (variable) - corresponding local type ordinal number - -ida_struct.struc_t.props (variable) - Structure properties - -ida_struct.struc_t.set_alignment (method) - set_alignment(self, shift) - Do not use; use set_struc_align() - - @param shift: (C++: int) - -ida_struct.struct_field_visitor_t (class) - Proxy of C++ struct_field_visitor_t class. - -ida_struct.struct_field_visitor_t.__disown__ (method) - -ida_struct.struct_field_visitor_t.__init__ (method) - __init__(self) -> struct_field_visitor_t - - @param self: PyObject * - -ida_struct.struct_field_visitor_t.visit_field (method) - visit_field(self, sptr, mptr) -> int - - @param sptr: struc_t * - @param mptr: member_t * - -ida_struct.udm_visitor_t (class) - Proxy of C++ udm_visitor_t class. - -ida_struct.udm_visitor_t.__disown__ (method) - -ida_struct.udm_visitor_t.__init__ (method) - __init__(self) -> udm_visitor_t - - @param self: PyObject * - -ida_struct.udm_visitor_t.visit_udm (method) - visit_udm(self, tid, tif, udt, idx) -> int - - @param tid: (C++: tid_t) udt tid - @param tif: (C++: const tinfo_t *) udt type info (may be nullptr for corrupted idbs) - @param udt: (C++: const udt_type_data_t *) udt type data (may be nullptr for corrupted idbs) - @param idx: (C++: ssize_t) the index of udt the member (may be -1 if udm was not found) - -ida_struct.unsync_and_delete_struc (function) - unsync_and_delete_struc(sptr) - Delete the structure but leave synced ltudt unchanged. Note del_struc() deletes - both ASM struc and the corresponding local type - - @param sptr: (C++: struc_t *) - -ida_struct.visit_stroff_fields (function) - visit_stroff_fields(sfv, path, disp, appzero) -> flags64_t - - @param sfv: struct_field_visitor_t & - @param path: tid_t const * - @param disp: adiff_t * - @param appzero: bool - -ida_struct.visit_stroff_udms (function) - visit_stroff_udms(sfv, path, disp, appzero) -> int - Visit structure fields in a stroff expression or in a reference to a struct data - variable. This function can be used to enumerate all components of an expression - like 'a.b.c'. - - @param sfv: (C++: udm_visitor_t &) visitor object - @param path: (C++: const tid_t *) struct path (path[0] contains the initial struct id) - @param disp: (C++: adiff_t *) offset into structure - @param appzero: (C++: bool) should visit field at offset zero? - @return: visitor result - -ida_tryblks (module) - Architecture independent exception handling info. - - Try blocks have the following general properties: - * A try block specifies a possibly fragmented guarded code region. - * Each try block has always at least one catch/except block description - * Each catch block contains its boundaries and a filter. - * Additionally a catch block can hold sp adjustment and the offset to the - exception object offset (C++). - * Try blocks can be nested. Nesting is automatically calculated at the retrieval - time. - * There may be (nested) multiple try blocks starting at the same address. - - See examples in tests/input/src/eh_tests. - -ida_tryblks.TBERR_EMPTY (variable) - empty try block - -ida_tryblks.TBERR_END (variable) - bad end address - -ida_tryblks.TBERR_INTERSECT (variable) - range would intersect inner tryblk - -ida_tryblks.TBERR_KIND (variable) - illegal try block kind - -ida_tryblks.TBERR_NO_CATCHES (variable) - no catch blocks at all - -ida_tryblks.TBERR_OK (variable) - ok - -ida_tryblks.TBERR_ORDER (variable) - bad address order - -ida_tryblks.TBERR_START (variable) - bad start address - -ida_tryblks.add_tryblk (function) - add_tryblk(tb) -> int - Add one try block information. - - @param tb: (C++: const tryblk_t &) try block to add. - @return: error code; 0 means good - -ida_tryblks.catch_t (class) - Proxy of C++ catch_t class. - -ida_tryblks.catch_t.__init__ (method) - __init__(self) -> catch_t - -ida_tryblks.catchvec_t (class) - Proxy of C++ qvector< catch_t > class. - -ida_tryblks.catchvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< catch_t > const & - -ida_tryblks.catchvec_t.__getitem__ (method) - __getitem__(self, i) -> catch_t - - @param i: size_t - -ida_tryblks.catchvec_t.__init__ (method) - __init__(self) -> catchvec_t - __init__(self, x) -> catchvec_t - - @param x: qvector< catch_t > const & - -ida_tryblks.catchvec_t.__len__ (method) - __len__(self) -> size_t - -ida_tryblks.catchvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< catch_t > const & - -ida_tryblks.catchvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: catch_t const & - -ida_tryblks.catchvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: catch_t const & - -ida_tryblks.catchvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: catch_t const & - -ida_tryblks.catchvec_t.at (method) - at(self, _idx) -> catch_t - - @param _idx: size_t - -ida_tryblks.catchvec_t.begin (method) - begin(self) -> catch_t - -ida_tryblks.catchvec_t.capacity (method) - capacity(self) -> size_t - -ida_tryblks.catchvec_t.clear (method) - clear(self) - -ida_tryblks.catchvec_t.empty (method) - empty(self) -> bool - -ida_tryblks.catchvec_t.end (method) - end(self) -> catch_t - -ida_tryblks.catchvec_t.erase (method) - erase(self, it) -> catch_t - - @param it: qvector< catch_t >::iterator - - erase(self, first, last) -> catch_t - - @param first: qvector< catch_t >::iterator - @param last: qvector< catch_t >::iterator - -ida_tryblks.catchvec_t.extract (method) - extract(self) -> catch_t - -ida_tryblks.catchvec_t.find (method) - find(self, x) -> catch_t - - @param x: catch_t const & - -ida_tryblks.catchvec_t.grow (method) - grow(self, x=catch_t()) - - @param x: catch_t const & - -ida_tryblks.catchvec_t.has (method) - has(self, x) -> bool - - @param x: catch_t const & - -ida_tryblks.catchvec_t.inject (method) - inject(self, s, len) - - @param s: catch_t * - @param len: size_t - -ida_tryblks.catchvec_t.insert (method) - insert(self, it, x) -> catch_t - - @param it: qvector< catch_t >::iterator - @param x: catch_t const & - -ida_tryblks.catchvec_t.pop_back (method) - pop_back(self) - -ida_tryblks.catchvec_t.push_back (method) - push_back(self, x) - - @param x: catch_t const & - - push_back(self) -> catch_t - -ida_tryblks.catchvec_t.qclear (method) - qclear(self) - -ida_tryblks.catchvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_tryblks.catchvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: catch_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_tryblks.catchvec_t.size (method) - size(self) -> size_t - -ida_tryblks.catchvec_t.swap (method) - swap(self, r) - - @param r: qvector< catch_t > & - -ida_tryblks.catchvec_t.truncate (method) - truncate(self) - -ida_tryblks.del_tryblks (function) - del_tryblks(range) - Delete try block information in the specified range. - - @param range: (C++: const range_t &) the range to be cleared - -ida_tryblks.find_syseh (function) - find_syseh(ea) -> ea_t - Find the start address of the system eh region including the argument. - - @param ea: (C++: ea_t) search address - @return: start address of surrounding tryblk, otherwise BADADDR - -ida_tryblks.get_tryblks (function) - get_tryblks(tbv, range) -> size_t - Retrieve try block information from the specified address range. Try blocks are - sorted by starting address and their nest levels calculated. - - @param tbv: (C++: tryblks_t *) output buffer; may be nullptr - @param range: (C++: const range_t &) address range to change - @return: number of found try blocks - -ida_tryblks.is_ea_tryblks (function) - is_ea_tryblks(ea, flags) -> bool - Check if the given address ea is part of tryblks description. - - @param ea: (C++: ea_t) address to check - @param flags: (C++: uint32) combination of flags for is_ea_tryblks() - -ida_tryblks.seh_t (class) - Proxy of C++ seh_t class. - -ida_tryblks.seh_t.__init__ (method) - __init__(self) -> seh_t - -ida_tryblks.seh_t.clear (method) - clear(self) - -ida_tryblks.try_handler_t (class) - Proxy of C++ try_handler_t class. - -ida_tryblks.try_handler_t.__init__ (method) - __init__(self) -> try_handler_t - -ida_tryblks.try_handler_t.clear (method) - clear(self) - -ida_tryblks.tryblk_t (class) - Proxy of C++ tryblk_t class. - -ida_tryblks.tryblk_t.__init__ (method) - __init__(self) -> tryblk_t - __init__(self, r) -> tryblk_t - - @param r: tryblk_t const & - -ida_tryblks.tryblk_t.clear (method) - clear(self) - -ida_tryblks.tryblk_t.cpp (method) - cpp(self) -> catchvec_t - -ida_tryblks.tryblk_t.empty (method) - empty(self) -> bool - -ida_tryblks.tryblk_t.get_kind (method) - get_kind(self) -> uchar - -ida_tryblks.tryblk_t.is_cpp (method) - is_cpp(self) -> bool - -ida_tryblks.tryblk_t.is_seh (method) - is_seh(self) -> bool - -ida_tryblks.tryblk_t.seh (method) - seh(self) -> seh_t - -ida_tryblks.tryblk_t.set_cpp (method) - set_cpp(self) -> catchvec_t - -ida_tryblks.tryblk_t.set_seh (method) - set_seh(self) -> seh_t - -ida_tryblks.tryblks_t (class) - Proxy of C++ qvector< tryblk_t > class. - -ida_tryblks.tryblks_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< tryblk_t > const & - -ida_tryblks.tryblks_t.__getitem__ (method) - __getitem__(self, i) -> tryblk_t - - @param i: size_t - -ida_tryblks.tryblks_t.__init__ (method) - __init__(self) -> tryblks_t - __init__(self, x) -> tryblks_t - - @param x: qvector< tryblk_t > const & - -ida_tryblks.tryblks_t.__len__ (method) - __len__(self) -> size_t - -ida_tryblks.tryblks_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< tryblk_t > const & - -ida_tryblks.tryblks_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: tryblk_t const & - -ida_tryblks.tryblks_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: tryblk_t const & - -ida_tryblks.tryblks_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.at (method) - at(self, _idx) -> tryblk_t - - @param _idx: size_t - -ida_tryblks.tryblks_t.begin (method) - begin(self) -> tryblk_t - -ida_tryblks.tryblks_t.capacity (method) - capacity(self) -> size_t - -ida_tryblks.tryblks_t.clear (method) - clear(self) - -ida_tryblks.tryblks_t.empty (method) - empty(self) -> bool - -ida_tryblks.tryblks_t.end (method) - end(self) -> tryblk_t - -ida_tryblks.tryblks_t.erase (method) - erase(self, it) -> tryblk_t - - @param it: qvector< tryblk_t >::iterator - - erase(self, first, last) -> tryblk_t - - @param first: qvector< tryblk_t >::iterator - @param last: qvector< tryblk_t >::iterator - -ida_tryblks.tryblks_t.extract (method) - extract(self) -> tryblk_t - -ida_tryblks.tryblks_t.find (method) - find(self, x) -> tryblk_t - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.grow (method) - grow(self, x=tryblk_t()) - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.has (method) - has(self, x) -> bool - - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.inject (method) - inject(self, s, len) - - @param s: tryblk_t * - @param len: size_t - -ida_tryblks.tryblks_t.insert (method) - insert(self, it, x) -> tryblk_t - - @param it: qvector< tryblk_t >::iterator - @param x: tryblk_t const & - -ida_tryblks.tryblks_t.pop_back (method) - pop_back(self) - -ida_tryblks.tryblks_t.push_back (method) - push_back(self, x) - - @param x: tryblk_t const & - - push_back(self) -> tryblk_t - -ida_tryblks.tryblks_t.qclear (method) - qclear(self) - -ida_tryblks.tryblks_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_tryblks.tryblks_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: tryblk_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_tryblks.tryblks_t.size (method) - size(self) -> size_t - -ida_tryblks.tryblks_t.swap (method) - swap(self, r) - - @param r: qvector< tryblk_t > & - -ida_tryblks.tryblks_t.truncate (method) - truncate(self) - -ida_typeinf (module) - Describes the type information records in IDA. - - The recommended way of using type info is to use the tinfo_t class. The type - information is internally kept as an array of bytes terminated by 0. - - Items in brackets [] are optional and sometimes are omitted. type_t... means a - sequence of type_t bytes which defines a type. - - @note: to work with the types of instructions or data in the database, use - get_tinfo()/set_tinfo() and similar functions. - -ida_typeinf.ADDTIL_ABORTED (variable) - til was not loaded (incompatible til rejected by user) - -ida_typeinf.ADDTIL_COMP (variable) - ok, but til is not compatible with the current compiler - -ida_typeinf.ADDTIL_DEFAULT (variable) - default behavior - -ida_typeinf.ADDTIL_FAILED (variable) - something bad, the warning is displayed - -ida_typeinf.ADDTIL_INCOMP (variable) - load incompatible tils - -ida_typeinf.ADDTIL_OK (variable) - ok, til is loaded - -ida_typeinf.ADDTIL_SILENT (variable) - do not ask any questions - -ida_typeinf.ALOC_CUSTOM (variable) - custom argloc (7 or higher) - -ida_typeinf.ALOC_DIST (variable) - distributed (scattered) - -ida_typeinf.ALOC_NONE (variable) - none - -ida_typeinf.ALOC_REG1 (variable) - one register (and offset within it) - -ida_typeinf.ALOC_REG2 (variable) - register pair - -ida_typeinf.ALOC_RREL (variable) - register relative - -ida_typeinf.ALOC_STACK (variable) - stack offset - -ida_typeinf.ALOC_STATIC (variable) - global address - -ida_typeinf.ARGREGS_BY_SLOTS (variable) - fixed FP/GP register per each slot (like vc64) - -ida_typeinf.ARGREGS_FP_CONSUME_GP (variable) - FP register also consumes one or more GP regs but not vice versa (aix ppc ABI) - -ida_typeinf.ARGREGS_GP_ONLY (variable) - GP registers used for all arguments. - -ida_typeinf.ARGREGS_INDEPENDENT (variable) - FP/GP registers used separately (like gcc64) - -ida_typeinf.ARGREGS_MIPS_O32 (variable) - MIPS ABI o32. - -ida_typeinf.BADSIZE (variable) - bad type size - -ida_typeinf.BFA_FUNC_EXT_FORMAT (variable) - This is NOT a real attribute (used internally as marker for extended format) - -ida_typeinf.BFA_FUNC_MARKER (variable) - This is NOT a cc! (used internally as a marker) - -ida_typeinf.BFA_HIGH (variable) - high level prototype (with possibly hidden args) - -ida_typeinf.BFA_NORET (variable) - __noreturn - -ida_typeinf.BFA_PURE (variable) - __pure - -ida_typeinf.BFA_STATIC (variable) - static - -ida_typeinf.BFA_VIRTUAL (variable) - virtual - -ida_typeinf.BTE_ALWAYS (variable) - this bit MUST be present - -ida_typeinf.BTE_BITMASK (variable) - 'subarrays'. In this case ANY record has the following format: - * 'de' mask (has name) - * 'dt' cnt - * cnt records of 'de' values (cnt CAN be 0) - @note: delta for ALL subsegment is ONE - -ida_typeinf.BTE_CHAR (variable) - char or hex - -ida_typeinf.BTE_HEX (variable) - hex - -ida_typeinf.BTE_OUT_MASK (variable) - output style mask - -ida_typeinf.BTE_RESERVED (variable) - must be 0, in order to distinguish from a tah-byte - -ida_typeinf.BTE_SDEC (variable) - signed decimal - -ida_typeinf.BTE_SIZE_MASK (variable) - storage size. - * if == 0 then inf_get_cc_size_e() - * else 1 << (n -1) = 1,2,4,8 - * n == 5,6,7 are reserved - -ida_typeinf.BTE_UDEC (variable) - unsigned decimal - -ida_typeinf.BTF_BOOL (variable) - boolean - -ida_typeinf.BTF_BYTE (variable) - byte - -ida_typeinf.BTF_CHAR (variable) - signed char - -ida_typeinf.BTF_DOUBLE (variable) - double - -ida_typeinf.BTF_ENUM (variable) - enum - -ida_typeinf.BTF_FLOAT (variable) - float - -ida_typeinf.BTF_INT (variable) - int, unknown signedness - -ida_typeinf.BTF_INT128 (variable) - signed 128-bit value - -ida_typeinf.BTF_INT16 (variable) - signed short - -ida_typeinf.BTF_INT32 (variable) - signed int - -ida_typeinf.BTF_INT64 (variable) - signed long - -ida_typeinf.BTF_INT8 (variable) - signed byte - -ida_typeinf.BTF_LDOUBLE (variable) - long double - -ida_typeinf.BTF_SINT (variable) - singed int - -ida_typeinf.BTF_STRUCT (variable) - struct - -ida_typeinf.BTF_TBYTE (variable) - see BTMT_SPECFLT - -ida_typeinf.BTF_TYPEDEF (variable) - typedef - -ida_typeinf.BTF_UCHAR (variable) - unsigned char - -ida_typeinf.BTF_UINT (variable) - unsigned int - -ida_typeinf.BTF_UINT128 (variable) - unsigned 128-bit value - -ida_typeinf.BTF_UINT16 (variable) - unsigned short - -ida_typeinf.BTF_UINT32 (variable) - unsigned int - -ida_typeinf.BTF_UINT64 (variable) - unsigned long - -ida_typeinf.BTF_UINT8 (variable) - unsigned byte - -ida_typeinf.BTF_UNION (variable) - union - -ida_typeinf.BTF_UNK (variable) - unknown - -ida_typeinf.BTF_VOID (variable) - void - -ida_typeinf.BTMT_ARRESERV (variable) - reserved bit - -ida_typeinf.BTMT_BFLDI16 (variable) - __int16 - -ida_typeinf.BTMT_BFLDI32 (variable) - __int32 - -ida_typeinf.BTMT_BFLDI64 (variable) - __int64 - -ida_typeinf.BTMT_BFLDI8 (variable) - __int8 - -ida_typeinf.BTMT_BOOL1 (variable) - size 1byte - -ida_typeinf.BTMT_BOOL2 (variable) - size 2bytes - !inf_is_64bit() - -ida_typeinf.BTMT_BOOL4 (variable) - size 4bytes - -ida_typeinf.BTMT_BOOL8 (variable) - size 8bytes - inf_is_64bit() - -ida_typeinf.BTMT_CHAR (variable) - specify char or segment register - * BT_INT8 - char - * BT_INT - segment register - * other BT_INT... - don't use - -ida_typeinf.BTMT_CLOSURE (variable) - closure. - * if ptr to BT_FUNC - __closure. in this case next byte MUST be RESERVED_BYTE, - and after it BT_FUNC - * else the next byte contains sizeof(ptr) allowed values are 1 - ph.max_ptr_size - * if value is bigger than ph.max_ptr_size, based_ptr_name_and_size() is called - to find out the typeinfo - -ida_typeinf.BTMT_DEFBOOL (variable) - size is model specific or unknown(?) - -ida_typeinf.BTMT_DEFCALL (variable) - call method - default for model or unknown - -ida_typeinf.BTMT_DEFPTR (variable) - default for model - -ida_typeinf.BTMT_DOUBLE (variable) - double (8 bytes) - -ida_typeinf.BTMT_FAR (variable) - far - -ida_typeinf.BTMT_FARCALL (variable) - function returns by retf - -ida_typeinf.BTMT_FLOAT (variable) - float (4 bytes) - -ida_typeinf.BTMT_INTCALL (variable) - function returns by iret in this case cc MUST be 'unknown' - -ida_typeinf.BTMT_LNGDBL (variable) - long double (compiler specific) - -ida_typeinf.BTMT_NEAR (variable) - near - -ida_typeinf.BTMT_NEARCALL (variable) - function returns by retn - -ida_typeinf.BTMT_NONBASED (variable) - if set - array base==0 - format: dt num_elem; [tah-typeattrs]; type_t... - if num_elem==0 then the array size is unknown - else - format: da num_elem, base; [tah-typeattrs]; type_t... - used only for serialization - -ida_typeinf.BTMT_SIGNED (variable) - signed - -ida_typeinf.BTMT_SIZE0 (variable) - BT_VOID - normal void; BT_UNK - don't use - -ida_typeinf.BTMT_SIZE12 (variable) - size = 1 byte if BT_VOID; 2 if BT_UNK - -ida_typeinf.BTMT_SIZE128 (variable) - size = 16 bytes if BT_VOID; unknown if BT_UNK (IN struct alignment - see below) - -ida_typeinf.BTMT_SIZE48 (variable) - size = 4 bytes if BT_VOID; 8 if BT_UNK - -ida_typeinf.BTMT_SPECFLT (variable) - float (variable size). if processor_t::use_tbyte() then use - processor_t::tbyte_size, otherwise 2 bytes - -ida_typeinf.BTMT_TYPEDEF (variable) - named reference always p_string name - -ida_typeinf.BTMT_UNKSIGN (variable) - unknown signedness - -ida_typeinf.BTMT_USIGNED (variable) - unsigned - -ida_typeinf.BTM_CONST (variable) - const - -ida_typeinf.BTM_VOLATILE (variable) - volatile - -ida_typeinf.BT_ARRAY (variable) - array - -ida_typeinf.BT_BITFIELD (variable) - bitfield (only in struct) ['bitmasked' enum see below] next byte is dt ((size in - bits << 1) | (unsigned ? 1 : 0)) - -ida_typeinf.BT_BOOL (variable) - bool - -ida_typeinf.BT_COMPLEX (variable) - struct/union/enum/typedef. format: - [dt N (N=field count) if !BTMT_TYPEDEF] - if N == 0: - p_string name (unnamed types have names "anon_...") - [sdacl-typeattrs]; - else, for struct & union: - if N == 0x7FFE // Support for high (i.e., > 4095) members count - N = deserialize_de() - ALPOW = N & 0x7 - MCNT = N >> 3 - if MCNT == 0 - empty struct - if ALPOW == 0 - ALIGN = get_default_align() - else - ALIGN = (1 << (ALPOW - 1)) - [sdacl-typeattrs]; - else, for enums: - if N == 0x7FFE // Support for high enum entries count. - N = deserialize_de() - [tah-typeattrs]; - -ida_typeinf.BT_FLOAT (variable) - float - -ida_typeinf.BT_FUNC (variable) - function. format: - optional: CM_CC_SPOILED | num_of_spoiled_regs - if num_of_spoiled_reg == BFA_FUNC_MARKER: - ::bfa_byte - if (bfa_byte & BFA_FUNC_EXT_FORMAT) != 0 - ::fti_bits (only low bits: FTI_SPOILED,...,FTI_VIRTUAL) - num_of_spoiled_reg times: spoiled reg info (see - extract_spoiledreg) - else - bfa_byte is function attribute byte (see Function attribute - byte...) - else: - num_of_spoiled_reg times: spoiled reg info (see - extract_spoiledreg) - cm_t ... calling convention and memory model - [tah-typeattrs]; - type_t ... return type; - [serialized argloc_t of returned value (if CM_CC_SPECIAL{PE} && !return - void); - if !CM_CC_VOIDARG: - dt N (N=number of parameters) - if ( N == 0 ) - if CM_CC_ELLIPSIS or CM_CC_SPECIALE - func(...) - else - parameters are unknown - else - N records: - type_t ... (i.e. type of each parameter) - [serialized argloc_t (if CM_CC_SPECIAL{PE})] (i.e. place of each - parameter) - [FAH_BYTE + de( funcarg_t::flags )] - -ida_typeinf.BT_INT (variable) - natural int. (size provided by idp module) - -ida_typeinf.BT_INT128 (variable) - __int128 (for alpha & future use) - -ida_typeinf.BT_INT16 (variable) - __int16 - -ida_typeinf.BT_INT32 (variable) - __int32 - -ida_typeinf.BT_INT64 (variable) - __int64 - -ida_typeinf.BT_INT8 (variable) - __int8 - -ida_typeinf.BT_PTR (variable) - pointer. has the following format: [db sizeof(ptr)]; [tah-typeattrs]; type_t... - -ida_typeinf.BT_RESERVED (variable) - RESERVED. - -ida_typeinf.BT_SEGREG (variable) - segment register - -ida_typeinf.BT_UNK (variable) - unknown - -ida_typeinf.BT_UNKNOWN (variable) - unknown size - for parameters - -ida_typeinf.BT_UNK_BYTE (variable) - 1 byte - -ida_typeinf.BT_UNK_DWORD (variable) - 4 bytes - -ida_typeinf.BT_UNK_OWORD (variable) - 16 bytes - -ida_typeinf.BT_UNK_QWORD (variable) - 8 bytes - -ida_typeinf.BT_UNK_WORD (variable) - 2 bytes - -ida_typeinf.BT_VOID (variable) - void - -ida_typeinf.CC_ALLOW_ARGPERM (variable) - disregard argument order? - -ida_typeinf.CC_ALLOW_REGHOLES (variable) - allow holes in register argument list? - -ida_typeinf.CC_CDECL_OK (variable) - can use __cdecl calling convention? - -ida_typeinf.CC_GOLANG_OK (variable) - can use __golang calling convention - -ida_typeinf.CC_HAS_ELLIPSIS (variable) - function has a variable list of arguments? - -ida_typeinf.CM_CC_CDECL (variable) - stack - -ida_typeinf.CM_CC_ELLIPSIS (variable) - cdecl + ellipsis - -ida_typeinf.CM_CC_FASTCALL (variable) - stack, purged (x86), first args are in regs (compiler-dependent) - -ida_typeinf.CM_CC_GOLANG (variable) - (Go) arguments and return value in stack - -ida_typeinf.CM_CC_INVALID (variable) - this value is invalid - -ida_typeinf.CM_CC_PASCAL (variable) - stack, purged, reverse order of args - -ida_typeinf.CM_CC_SPECIALE (variable) - CM_CC_SPECIAL with ellipsis - -ida_typeinf.CM_CC_SPECIALP (variable) - Equal to CM_CC_SPECIAL, but with purged stack. - -ida_typeinf.CM_CC_SPOILED (variable) - This is NOT a cc! Mark of __spoil record the low nibble is count and after n - {spoilreg_t} present real cm_t byte. if n == BFA_FUNC_MARKER, the next byte is - the function attribute byte. - -ida_typeinf.CM_CC_STDCALL (variable) - stack, purged - -ida_typeinf.CM_CC_SWIFT (variable) - (Swift) arguments and return values in registers (compiler-dependent) - -ida_typeinf.CM_CC_THISCALL (variable) - stack, purged (x86), first arg is in reg (compiler-dependent) - -ida_typeinf.CM_CC_UNKNOWN (variable) - unknown calling convention - -ida_typeinf.CM_CC_VOIDARG (variable) - function without arguments if has other cc and argnum == 0, represent as f() - - unknown list - -ida_typeinf.CM_N16_F32 (variable) - near 2 bytes, far 4 bytes - -ida_typeinf.CM_N32_F48 (variable) - near 4 bytes, far 6 bytes - -ida_typeinf.CM_N64 (variable) - if sizeof(int)>2: near 8 bytes, far 8 bytes - -ida_typeinf.CM_N8_F16 (variable) - if sizeof(int)<=2: near 1 byte, far 2 bytes - -ida_typeinf.CM_UNKNOWN (variable) - unknown - -ida_typeinf.COMP_BC (variable) - Borland C++. - -ida_typeinf.COMP_BP (variable) - Delphi. - -ida_typeinf.COMP_GNU (variable) - GNU C++. - -ida_typeinf.COMP_MS (variable) - Visual C++. - -ida_typeinf.COMP_UNK (variable) - Unknown. - -ida_typeinf.COMP_UNSURE (variable) - uncertain compiler id - -ida_typeinf.COMP_VISAGE (variable) - Visual Age C++. - -ida_typeinf.COMP_WATCOM (variable) - Watcom C++. - -ida_typeinf.DEFMASK64 (variable) - default bitmask 64bits - -ida_typeinf.ETF_ASMENUM (variable) - asm enum compatibility mode *- - -ida_typeinf.ETF_AUTONAME (variable) - generate a member name if was not specified (add_udm, set_udm_type) - -ida_typeinf.ETF_COMPATIBLE (variable) - new type must be compatible with the old - -ida_typeinf.ETF_FORCENAME (variable) - anyway use name, see below for more usage description - -ida_typeinf.ETF_FUNCARG (variable) - mptr is function argument (cannot create arrays) - -ida_typeinf.ETF_MAY_DESTROY (variable) - may destroy other members - -ida_typeinf.ETF_NO_IDBSYNC (variable) - do not sync type to IDB (udt only) *- - -ida_typeinf.ETF_NO_LAYOUT (variable) - don't calc type layout before editing - -ida_typeinf.ETF_NO_SAVE (variable) - don't save to til (normally typerefs are saved to til) A call with ETF_NO_SAVE - must be followed by a call without it. Otherwise there may be inconsistencies - between the memory and the type library. - -ida_typeinf.FAH_BYTE (variable) - function argument attribute header byte - -ida_typeinf.FAI_ARRAY (variable) - was initially an array; see "__org_typedef" or "__org_arrdim" type attributes to - determine the original type - -ida_typeinf.FAI_HIDDEN (variable) - hidden argument - -ida_typeinf.FAI_RETPTR (variable) - pointer to return value. implies hidden - -ida_typeinf.FAI_STRUCT (variable) - was initially a structure - -ida_typeinf.FAI_UNUSED (variable) - argument is not used by the function - -ida_typeinf.FIRST_NONTRIVIAL_TYPID (variable) - Denotes the first bit describing a nontrivial type. - -ida_typeinf.FRB_CHAR (variable) - Char. - -ida_typeinf.FRB_CUSTOM (variable) - *Custom data type - -ida_typeinf.FRB_ENUM (variable) - *Enumeration - -ida_typeinf.FRB_FLOAT (variable) - Floating point number (for interpreting an integer type as a floating value) - -ida_typeinf.FRB_INVBITS (variable) - Invert bits (0x01 is represented as ~0xFE) - -ida_typeinf.FRB_INVSIGN (variable) - Invert sign (0x01 is represented as -0xFF) - -ida_typeinf.FRB_LZERO (variable) - Toggle leading zeroes (used for integers) - -ida_typeinf.FRB_MASK (variable) - Mask for the value type (* means requires additional info): - -ida_typeinf.FRB_NUMB (variable) - Binary number. - -ida_typeinf.FRB_NUMD (variable) - Decimal number. - -ida_typeinf.FRB_NUMH (variable) - Hexadecimal number. - -ida_typeinf.FRB_NUMO (variable) - Octal number. - -ida_typeinf.FRB_OFFSET (variable) - *Offset - -ida_typeinf.FRB_SEG (variable) - Segment. - -ida_typeinf.FRB_SIGNED (variable) - Force signed representation. - -ida_typeinf.FRB_STRLIT (variable) - *String literal (used for arrays) - -ida_typeinf.FRB_STROFF (variable) - *Struct offset - -ida_typeinf.FRB_TABFORM (variable) - has additional tabular parameters - -ida_typeinf.FRB_UNK (variable) - Unknown. - -ida_typeinf.FTI_ALL (variable) - all defined bits - -ida_typeinf.FTI_ARGLOCS (variable) - info about argument locations has been calculated (stkargs and retloc too) - -ida_typeinf.FTI_CALLTYPE (variable) - mask for FTI_*CALL - -ida_typeinf.FTI_CONST (variable) - const member function - -ida_typeinf.FTI_CTOR (variable) - constructor - -ida_typeinf.FTI_DEFCALL (variable) - default call - -ida_typeinf.FTI_DTOR (variable) - destructor - -ida_typeinf.FTI_EXPLOCS (variable) - all arglocs are specified explicitly - -ida_typeinf.FTI_FARCALL (variable) - far call - -ida_typeinf.FTI_HIGH (variable) - high level prototype (with possibly hidden args) - -ida_typeinf.FTI_INTCALL (variable) - interrupt call - -ida_typeinf.FTI_NEARCALL (variable) - near call - -ida_typeinf.FTI_NORET (variable) - noreturn - -ida_typeinf.FTI_PURE (variable) - __pure - -ida_typeinf.FTI_SPOILED (variable) - information about spoiled registers is present - -ida_typeinf.FTI_STATIC (variable) - static - -ida_typeinf.FTI_VIRTUAL (variable) - virtual - -ida_typeinf.GTD_CALC_ARGLOCS (variable) - calculate func arg locations - -ida_typeinf.GTD_CALC_LAYOUT (variable) - calculate udt layout - -ida_typeinf.GTD_DEL_BITFLDS (variable) - delete udt bitfields - -ida_typeinf.GTD_NO_ARGLOCS (variable) - don't calculate func arg locations please note that the locations may have been - calculated earlier - -ida_typeinf.GTD_NO_LAYOUT (variable) - don't calculate udt layout please note that udt layout may have been calculated - earlier - -ida_typeinf.GTS_BASECLASS (variable) - is baseclass of a udt - -ida_typeinf.GTS_NESTED (variable) - nested type (embedded into a udt) - -ida_typeinf.GUESS_FUNC_FAILED (variable) - couldn't guess the function type - -ida_typeinf.GUESS_FUNC_OK (variable) - ok, some non-trivial information is gathered - -ida_typeinf.GUESS_FUNC_TRIVIAL (variable) - the function type doesn't have interesting info - -ida_typeinf.HTI_CPP (variable) - C++ mode (not implemented) - -ida_typeinf.HTI_DCL (variable) - don't complain about redeclarations - -ida_typeinf.HTI_FIL (variable) - "input" is file name, otherwise "input" contains a C declaration - -ida_typeinf.HTI_HIGH (variable) - assume high level prototypes (with hidden args, etc) - -ida_typeinf.HTI_LOWER (variable) - lower the function prototypes - -ida_typeinf.HTI_MAC (variable) - define macros from the base tils - -ida_typeinf.HTI_NDC (variable) - don't decorate names - -ida_typeinf.HTI_NER (variable) - ignore all errors but display them - -ida_typeinf.HTI_NOBASE (variable) - do not inspect base tils - -ida_typeinf.HTI_NWR (variable) - no warning messages - -ida_typeinf.HTI_PAK (variable) - explicit structure pack value (#pragma pack) - -ida_typeinf.HTI_PAK1 (variable) - #pragma pack(1) - -ida_typeinf.HTI_PAK16 (variable) - #pragma pack(16) - -ida_typeinf.HTI_PAK2 (variable) - #pragma pack(2) - -ida_typeinf.HTI_PAK4 (variable) - #pragma pack(4) - -ida_typeinf.HTI_PAK8 (variable) - #pragma pack(8) - -ida_typeinf.HTI_PAKDEF (variable) - default pack value - -ida_typeinf.HTI_PAK_SHIFT (variable) - shift for HTI_PAK. This field should be used if you want to remember an explicit - pack value for each structure/union type. See HTI_PAK... definitions - -ida_typeinf.HTI_RAWARGS (variable) - leave argument names unchanged (do not remove underscores) - -ida_typeinf.HTI_RELAXED (variable) - accept references to unknown namespaces - -ida_typeinf.HTI_TST (variable) - test mode: discard the result - -ida_typeinf.IMPTYPE_LOCAL (variable) - the type is local, the struct/enum won't be marked as til type. there is no need - to specify this bit if til==idati, the kernel will set it automatically - -ida_typeinf.MAX_FUNC_ARGS (variable) - max number of function arguments - -ida_typeinf.NTF_64BIT (variable) - value is 64bit - -ida_typeinf.NTF_CHKSYNC (variable) - check that synchronization to IDB passed OK (set_numbered_type, set_named_type) - -ida_typeinf.NTF_COPY (variable) - save a new type definition, not a typeref (tinfo_t::set_numbered_type, - tinfo_t::set_named_type) - -ida_typeinf.NTF_FIXNAME (variable) - force-validate the name of the type when setting (set_named_type, - set_numbered_type only) - -ida_typeinf.NTF_IDBENC (variable) - the name is given in the IDB encoding; non-ASCII bytes will be decoded - accordingly (set_named_type, set_numbered_type only) - -ida_typeinf.NTF_NOBASE (variable) - don't inspect base tils (for get_named_type) - -ida_typeinf.NTF_NOCUR (variable) - don't inspect current til file (for get_named_type) - -ida_typeinf.NTF_NO_NAMECHK (variable) - do not validate type name (set_numbered_type, set_named_type) - -ida_typeinf.NTF_REPLACE (variable) - replace original type (for set_named_type) - -ida_typeinf.NTF_SYMM (variable) - symbol, name is mangled ('_func'); only one of NTF_TYPE and NTF_SYMU, NTF_SYMM - can be used - -ida_typeinf.NTF_SYMU (variable) - symbol, name is unmangled ('func') - -ida_typeinf.NTF_TYPE (variable) - type name - -ida_typeinf.NTF_UMANGLED (variable) - name is unmangled (don't use this flag) - -ida_typeinf.PDF_DEF_BASE (variable) - Include base types: __int8, __int16, etc.. - -ida_typeinf.PDF_DEF_FWD (variable) - Allow forward declarations. - -ida_typeinf.PDF_HEADER_CMT (variable) - Prepend output with a descriptive comment. - -ida_typeinf.PDF_INCL_DEPS (variable) - Include all type dependencies. - -ida_typeinf.PIO_IGNORE_PTRS (variable) - do not follow pointers - -ida_typeinf.PIO_NOATTR_FAIL (variable) - missing attributes are not ok - -ida_typeinf.PRALOC_STKOFF (variable) - print stack offsets - -ida_typeinf.PRALOC_VERIFY (variable) - interr if illegal argloc - -ida_typeinf.PRTYPE_1LINCMT (variable) - print comments even in the one line mode - -ida_typeinf.PRTYPE_1LINE (variable) - print to one line - -ida_typeinf.PRTYPE_COLORED (variable) - add color tag COLOR_SYMBOL for any parentheses, commas and colons - -ida_typeinf.PRTYPE_CPP (variable) - use c++ name (only for print_type()) - -ida_typeinf.PRTYPE_HEADER (variable) - print only type header (only for definitions) - -ida_typeinf.PRTYPE_MAXSTR (variable) - limit the output length to 1024 bytes (the output may be slightly longer) - -ida_typeinf.PRTYPE_MULTI (variable) - print to many lines - -ida_typeinf.PRTYPE_NOREGEX (variable) - do not apply regular expressions to beautify name - -ida_typeinf.PRTYPE_PRAGMA (variable) - print pragmas for alignment - -ida_typeinf.PRTYPE_SEMI (variable) - append ; to the end - -ida_typeinf.PRTYPE_TYPE (variable) - print type declaration (not variable declaration) - -ida_typeinf.PT_HIGH (variable) - assume high level prototypes (with hidden args, etc) - -ida_typeinf.PT_LOWER (variable) - lower the function prototypes - -ida_typeinf.PT_NDC (variable) - don't decorate names - -ida_typeinf.PT_PACKMASK (variable) - mask for pack alignment values - -ida_typeinf.PT_RAWARGS (variable) - leave argument names unchanged (do not remove underscores) - -ida_typeinf.PT_RELAXED (variable) - accept references to unknown namespaces - -ida_typeinf.PT_REPLACE (variable) - replace the old type (used in idc) - -ida_typeinf.PT_SIL (variable) - silent, no messages - -ida_typeinf.PT_TYP (variable) - return declared type information - -ida_typeinf.PT_VAR (variable) - return declared object information - -ida_typeinf.RESERVED_BYTE (variable) - multifunctional purpose - -ida_typeinf.SC_AUTO (variable) - auto - -ida_typeinf.SC_EXT (variable) - extern - -ida_typeinf.SC_FRIEND (variable) - friend - -ida_typeinf.SC_REG (variable) - register - -ida_typeinf.SC_STAT (variable) - static - -ida_typeinf.SC_TYPE (variable) - typedef - -ida_typeinf.SC_UNK (variable) - unknown - -ida_typeinf.SC_VIRT (variable) - virtual - -ida_typeinf.SETCOMP_BY_USER (variable) - invoked by user, cannot be replaced by module/loader - -ida_typeinf.SETCOMP_ONLY_ABI (variable) - ignore cc field complete, use only abiname - -ida_typeinf.SETCOMP_ONLY_ID (variable) - cc has only 'id' field; the rest will be set to defaults corresponding to the - program bitness - -ida_typeinf.SETCOMP_OVERRIDE (variable) - may override old compiler info - -ida_typeinf.STI_ACCHAR (variable) - const char[] - -ida_typeinf.STI_ACHAR (variable) - char[] - -ida_typeinf.STI_ACUCHAR (variable) - const uint8[] - -ida_typeinf.STI_AEABI_LCMP (variable) - int __fastcall __pure(int64 x, int64 y) - -ida_typeinf.STI_AEABI_MEMCLR (variable) - void __fastcall(void *, size_t) - -ida_typeinf.STI_AEABI_MEMCPY (variable) - void __fastcall(void *, const void *, size_t) - -ida_typeinf.STI_AEABI_MEMSET (variable) - void __fastcall(void *, size_t, int) - -ida_typeinf.STI_AEABI_ULCMP (variable) - int __fastcall __pure(uint64 x, uint64 y) - -ida_typeinf.STI_AUCHAR (variable) - uint8[] - -ida_typeinf.STI_COMPLEX128 (variable) - struct complex128_t { double real, imag; } - -ida_typeinf.STI_COMPLEX64 (variable) - struct complex64_t { float real, imag; } - -ida_typeinf.STI_DONT_USE (variable) - unused stock type id; should not be used - -ida_typeinf.STI_FDELOP (variable) - void __cdecl(void *) - -ida_typeinf.STI_FPURGING (variable) - void __userpurge(int) - -ida_typeinf.STI_MSGSEND (variable) - void *(void *, const char *, ...) - -ida_typeinf.STI_PBYTE (variable) - _BYTE * - -ida_typeinf.STI_PCCHAR (variable) - const char * - -ida_typeinf.STI_PCHAR (variable) - char * - -ida_typeinf.STI_PCUCHAR (variable) - const uint8 * - -ida_typeinf.STI_PCVOID (variable) - const void * - -ida_typeinf.STI_PINT (variable) - int * - -ida_typeinf.STI_PPVOID (variable) - void ** - -ida_typeinf.STI_PUCHAR (variable) - uint8 * - -ida_typeinf.STI_PUINT (variable) - unsigned int * - -ida_typeinf.STI_PVOID (variable) - void * - -ida_typeinf.STI_RTC_CHECK_2 (variable) - int16 __fastcall(int16 x) - -ida_typeinf.STI_RTC_CHECK_4 (variable) - int32 __fastcall(int32 x) - -ida_typeinf.STI_RTC_CHECK_8 (variable) - int64 __fastcall(int64 x) - -ida_typeinf.STI_SIZE_T (variable) - size_t - -ida_typeinf.STI_SSIZE_T (variable) - ssize_t - -ida_typeinf.STRMEM_ANON (variable) - can be combined with STRMEM_NAME: look inside anonymous members too. - -ida_typeinf.STRMEM_AUTO (variable) - get member by offset if struct, or get member by index if union - * nb: union: index is stored in the udm->offset field! - * nb: struct: offset is in bytes (not in bits)! - -ida_typeinf.STRMEM_CASTABLE_TO (variable) - can be combined with STRMEM_TYPE: member type must be castable to the specified - type - -ida_typeinf.STRMEM_INDEX (variable) - get member by number - * in: udm->offset - is a member number - -ida_typeinf.STRMEM_MAXS (variable) - get biggest member by size. - -ida_typeinf.STRMEM_MINS (variable) - get smallest member by size. - -ida_typeinf.STRMEM_NAME (variable) - get member by name - * in: udm->name - the desired member name. - -ida_typeinf.STRMEM_OFFSET (variable) - get member by offset - * in: udm->offset - is a member offset in bits - -ida_typeinf.STRMEM_SIZE (variable) - get member by size. - * in: udm->size - the desired member size. - -ida_typeinf.STRMEM_SKIP_EMPTY (variable) - can be combined with STRMEM_OFFSET, STRMEM_AUTO skip empty members (i.e. having - zero size) only last empty member can be returned - -ida_typeinf.STRMEM_TYPE (variable) - get member by type. - * in: udm->type - the desired member type. member types are compared with - tinfo_t::equals_to() - -ida_typeinf.STRMEM_VFTABLE (variable) - can be combined with STRMEM_OFFSET, STRMEM_AUTO get vftable instead of the base - class - -ida_typeinf.SUDT_ALIGN (variable) - recalculate field alignments, struct packing, etc to match the offsets and size - info - -ida_typeinf.SUDT_CONST (variable) - only for serialize_udt: make type const - -ida_typeinf.SUDT_FAST (variable) - serialize without verifying offsets and alignments - -ida_typeinf.SUDT_GAPS (variable) - allow to fill gaps with additional members (_BYTE[]) - -ida_typeinf.SUDT_SORT (variable) - fields are not sorted by offset, sort them first - -ida_typeinf.SUDT_UNEX (variable) - references to nonexistent member types are acceptable; in this case it is better - to set the corresponding udm_t::fda field to the type alignment. If this field - is not set, ida will try to guess the alignment. - -ida_typeinf.SUDT_VOLATILE (variable) - only for serialize_udt: make type volatile - -ida_typeinf.TAFLD_METHOD (variable) - denotes a udt member function - -ida_typeinf.TAH_ALL (variable) - all defined bits - -ida_typeinf.TAH_BYTE (variable) - type attribute header byte - -ida_typeinf.TAH_HASATTRS (variable) - has extended attributes - -ida_typeinf.TA_FORMAT (variable) - info about the 'format' argument. 3 times pack_dd: format_functype_t, argument - number of 'format', argument number of '...' - -ida_typeinf.TA_ORG_ARRDIM (variable) - the original array dimension (pack_dd) - -ida_typeinf.TA_ORG_TYPEDEF (variable) - the original typedef name (simple string) - -ida_typeinf.TA_VALUE_REPR (variable) - serialized value_repr_t (used for scalars and arrays) - -ida_typeinf.TCMP_ANYBASE (variable) - accept any base class when casting - -ida_typeinf.TCMP_AUTOCAST (variable) - can t1 be cast into t2 automatically? - -ida_typeinf.TCMP_CALL (variable) - can t1 be called with t2 type? - -ida_typeinf.TCMP_DECL (variable) - compare declarations without resolving them - -ida_typeinf.TCMP_DELPTR (variable) - remove pointer from types before comparing - -ida_typeinf.TCMP_EQUAL (variable) - are types equal? - -ida_typeinf.TCMP_IGNMODS (variable) - ignore const/volatile modifiers - -ida_typeinf.TCMP_MANCAST (variable) - can t1 be cast into t2 manually? - -ida_typeinf.TCMP_SKIPTHIS (variable) - skip the first function argument in comparison - -ida_typeinf.TERR_ALIEN_NAME (variable) - enum member name is used in another enum - -ida_typeinf.TERR_BAD_ARG (variable) - bad argument - -ida_typeinf.TERR_BAD_ARRAY (variable) - arrays are forbidden as function arguments - -ida_typeinf.TERR_BAD_BASE (variable) - bad base class - -ida_typeinf.TERR_BAD_BF (variable) - bitfields are forbidden as function arguments - -ida_typeinf.TERR_BAD_BMASK (variable) - Bad enum member mask 0xI64X. The specified mask should not intersect with any - existing mask in the enum. Zero masks are prohibited too. - -ida_typeinf.TERR_BAD_GAP (variable) - bad gap - -ida_typeinf.TERR_BAD_GROUPS (variable) - bad group sizes for bitmask enum - -ida_typeinf.TERR_BAD_INDEX (variable) - bad index d - -ida_typeinf.TERR_BAD_LAYOUT (variable) - failed to calculate the structure/union layout - -ida_typeinf.TERR_BAD_MSKVAL (variable) - bad bmask and value combination (value=0xI64X; bitmask 0xI64X) - -ida_typeinf.TERR_BAD_NAME (variable) - name s is not acceptable - -ida_typeinf.TERR_BAD_OFFSET (variable) - bad member offset s - -ida_typeinf.TERR_BAD_REPR (variable) - bad or incompatible field representation - -ida_typeinf.TERR_BAD_SERIAL (variable) - enum value has too many serials - -ida_typeinf.TERR_BAD_SIZE (variable) - bad size d - -ida_typeinf.TERR_BAD_SUBTYPE (variable) - recursive structure nesting is forbidden - -ida_typeinf.TERR_BAD_SYNC (variable) - failed to synchronize with IDB - -ida_typeinf.TERR_BAD_TAH (variable) - bad bits in the type attributes (TAH bits) - -ida_typeinf.TERR_BAD_TYPE (variable) - bad type - -ida_typeinf.TERR_BAD_UNIVAR (variable) - unions cannot have variable sized members - -ida_typeinf.TERR_BAD_VALUE (variable) - value 0xI64X is not acceptable - -ida_typeinf.TERR_BAD_VARLAST (variable) - variable sized member must be the last member in the structure - -ida_typeinf.TERR_DUPNAME (variable) - duplicate name s - -ida_typeinf.TERR_ENUM_SIZE (variable) - bad enum size - -ida_typeinf.TERR_GRP_NOEMPTY (variable) - could not delete group mask for not empty group 0xI64X - -ida_typeinf.TERR_NESTED (variable) - recursive structure nesting is forbidden - -ida_typeinf.TERR_NOT_COMPAT (variable) - the new type is not compatible with the old type - -ida_typeinf.TERR_NOT_IMPL (variable) - not implemented - -ida_typeinf.TERR_NO_BMASK (variable) - bitmask 0xI64X is not found - -ida_typeinf.TERR_OK (variable) - ok - -ida_typeinf.TERR_OVERLAP (variable) - the member overlaps with other members that cannot be deleted - -ida_typeinf.TERR_SAVE_ERROR (variable) - failed to save - -ida_typeinf.TERR_SERIALIZE (variable) - failed to serialize - -ida_typeinf.TERR_STOCK (variable) - stock type info cannot be modified - -ida_typeinf.TERR_UNION_BF (variable) - unions cannot have bitfields - -ida_typeinf.TIL_ADD_ALREADY (variable) - the base til was already added - -ida_typeinf.TIL_ADD_FAILED (variable) - see errbuf - -ida_typeinf.TIL_ADD_OK (variable) - some tils were added - -ida_typeinf.TIL_ALI (variable) - type aliases are present (this bit is used only on the disk) - -ida_typeinf.TIL_ESI (variable) - extended sizeof info (short, long, longlong) - -ida_typeinf.TIL_MAC (variable) - til has macro table - -ida_typeinf.TIL_MOD (variable) - til has been modified, should be saved - -ida_typeinf.TIL_ORD (variable) - type ordinal numbers are present - -ida_typeinf.TIL_SLD (variable) - sizeof(long double) - -ida_typeinf.TIL_STM (variable) - til has extra streams - -ida_typeinf.TIL_UNI (variable) - universal til for any compiler - -ida_typeinf.TIL_ZIP (variable) - pack buckets using zip - -ida_typeinf.TINFO_DEFINITE (variable) - this is a definite type - -ida_typeinf.TINFO_DELAYFUNC (variable) - if type is a function and no function exists at ea, schedule its creation and - argument renaming to auto-analysis, otherwise try to create it immediately - -ida_typeinf.TINFO_GUESSED (variable) - this is a guessed type - -ida_typeinf.TINFO_STRICT (variable) - never convert given type to another one before applying - -ida_typeinf.TVIS_CMT (variable) - new comment is present (only for udt members) - -ida_typeinf.TVIS_NAME (variable) - new name is present (only for funcargs and udt members) - -ida_typeinf.TVIS_RPTCMT (variable) - the new comment is repeatable - -ida_typeinf.TVIS_TYPE (variable) - new type info is present - -ida_typeinf.TVST_DEF (variable) - visit type definition (meaningful for typerefs) - -ida_typeinf.TVST_PRUNE (variable) - don't visit children of current type - -ida_typeinf.TYPE_BASE_MASK (variable) - the low 4 bits define the basic type - -ida_typeinf.TYPE_FLAGS_MASK (variable) - type flags - they have different meaning depending on the basic type - -ida_typeinf.TYPE_FULL_MASK (variable) - basic type with type flags - -ida_typeinf.TYPE_MODIF_MASK (variable) - modifiers. - * for BT_ARRAY see Derived type: array - * BT_VOID can have them ONLY in 'void *' - -ida_typeinf.TYPID_ISREF (variable) - Identifies that a type that is a typeref. - -ida_typeinf.TYPID_SHIFT (variable) - First type detail bit. - -ida_typeinf.VALSTR_OPEN (variable) - printed opening curly brace '{' - -ida_typeinf._BT_LAST_BASIC (variable) - the last basic type, all basic types may be followed by [tah-typeattrs] - -ida_typeinf._wrap_cvar (class) - -ida_typeinf._wrap_cvar.__getattr__ (method) - -ida_typeinf._wrap_cvar.__setattr__ (method) - -ida_typeinf.add_til (function) - add_til(name, flags) -> int - Load a til file and add it the database type libraries list. IDA will also apply - function prototypes for matching function names. - - @param name: (C++: const char *) til name - @param flags: (C++: int) combination of Load TIL flags - @return: one of Load TIL result codes - -ida_typeinf.alloc_type_ordinal (function) - alloc_type_ordinal(ti) -> uint32 - alloc_type_ordinals(ti, 1) - - @param ti: (C++: til_t *) - -ida_typeinf.alloc_type_ordinals (function) - alloc_type_ordinals(ti, qty) -> uint32 - Allocate a range of ordinal numbers for new types. - - @param ti: (C++: til_t *) type library - @param qty: (C++: int) number of ordinals to allocate - @return: the first ordinal. 0 means failure. - -ida_typeinf.aloc_visitor_t (class) - Proxy of C++ aloc_visitor_t class. - -ida_typeinf.aloc_visitor_t.__disown__ (method) - -ida_typeinf.aloc_visitor_t.__init__ (method) - __init__(self) -> aloc_visitor_t - - @param self: PyObject * - -ida_typeinf.aloc_visitor_t.visit_location (method) - visit_location(self, v, off, size) -> int - - @param v: argloc_t & - @param off: int - @param size: int - -ida_typeinf.append_abi_opts (function) - append_abi_opts(abi_opts, user_level=False) -> bool - Add/remove/check ABI option General form of full abi name: abiname-opt1-opt2-... - or -opt1-opt2-... - - @param abi_opts: (C++: const char *) - ABI options to add/remove in form opt1-opt2-... - @param user_level: (C++: bool) - initiated by user if TRUE (==SETCOMP_BY_USER) - @return: success - -ida_typeinf.append_argloc (function) - append_argloc(out, vloc) -> bool - Serialize argument location - - @param out: (C++: qtype *) - @param vloc: (C++: const argloc_t &) argloc_t const & - -ida_typeinf.append_tinfo_covered (function) - append_tinfo_covered(out, typid, offset) -> bool - - @param out: rangeset_t * - @param typid: uint32 - @param offset: uint64 - -ida_typeinf.apply_callee_tinfo (function) - apply_callee_tinfo(caller, tif) -> bool - Apply the type of the called function to the calling instruction. This function - will append parameter comments and rename the local variables of the calling - function. It also stores information about the instructions that initialize call - arguments in the database. Use get_arg_addrs() to retrieve it if necessary. - Alternatively it is possible to hook to processor_t::arg_addrs_ready event. - - @param caller: (C++: ea_t) linear address of the calling instruction. must belong to a - function. - @param tif: (C++: const tinfo_t &) type info - @return: success - -ida_typeinf.apply_cdecl (function) - apply_cdecl(til, ea, decl, flags=0) -> bool - Apply the specified type to the address. This function parses the declaration - and calls apply_tinfo() - - @param til: (C++: til_t *) type library - @param ea: (C++: ea_t) linear address - @param decl: (C++: const char *) type declaration in C form - @param flags: (C++: int) flags to pass to apply_tinfo (TINFO_DEFINITE is always passed) - @return: success - -ida_typeinf.apply_named_type (function) - apply_named_type(ea, name) -> bool - Apply the specified named type to the address. - - @param ea: (C++: ea_t) linear address - @param name: (C++: const char *) the type name, e.g. "FILE" - @return: success - -ida_typeinf.apply_once_tinfo_and_name (function) - apply_once_tinfo_and_name(dea, tif, name) -> bool - Apply the specified type and name to the address. This function checks if the - address already has a type. If the old type - does not exist or the new type is 'better' than the old type, then the - new type will be applied. A type is considered better if it has more - information (e.g. BTMT_STRUCT is better than BT_INT). - The same logic is with the name: if the address already have a meaningful - name, it will be preserved. Only if the old name does not exist or it - is a dummy name like byte_123, it will be replaced by the new name. - - @param dea: (C++: ea_t) linear address - @param tif: (C++: const tinfo_t &) type string in the internal format - @param name: (C++: const char *) new name for the address - @return: success - -ida_typeinf.apply_tinfo (function) - apply_tinfo(ea, tif, flags) -> bool - Apply the specified type to the specified address. This function sets the type - and tries to convert the item at the specified address to conform the type. - - @param ea: (C++: ea_t) linear address - @param tif: (C++: const tinfo_t &) type string in internal format - @param flags: (C++: uint32) combination of Apply tinfo flags - @return: success - -ida_typeinf.apply_tinfo_to_stkarg (function) - apply_tinfo_to_stkarg(insn, x, v, tif, name) -> bool - Helper function for the processor modules. to be called from - processor_t::use_stkarg_type - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: (C++: const op_t &) op_t const & - @param v: (C++: uval_t) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param name: (C++: const char *) char const * - -ida_typeinf.apply_type (function) - apply_type(ti, type, fields, ea, flags) -> bool - Apply the specified type to the address - - @param ti: Type info library. 'None' can be used. - @param type: type_t const * - @param fields: p_list const * - @param ea: the address of the object - @param flags: combination of TINFO_... constants or 0 - @return: Boolean - -ida_typeinf.argloc_t (class) - Proxy of C++ argloc_t class. - -ida_typeinf.argloc_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: argloc_t const & - -ida_typeinf.argloc_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: argloc_t const & - -ida_typeinf.argloc_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: argloc_t const & - -ida_typeinf.argloc_t.__init__ (method) - __init__(self) -> argloc_t - __init__(self, r) -> argloc_t - - @param r: argloc_t const & - -ida_typeinf.argloc_t.__le__ (method) - __le__(self, r) -> bool - - @param r: argloc_t const & - -ida_typeinf.argloc_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: argloc_t const & - -ida_typeinf.argloc_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: argloc_t const & - -ida_typeinf.argloc_t._consume_rrel (method) - _consume_rrel(self, p) -> bool - - Parameters - ---------- - p: rrel_t * - -ida_typeinf.argloc_t._consume_scattered (method) - _consume_scattered(self, p) -> bool - - Parameters - ---------- - p: scattered_aloc_t * - -ida_typeinf.argloc_t._set_badloc (method) - _set_badloc(self) - -ida_typeinf.argloc_t._set_biggest (method) - _set_biggest(self, ct, data) - - Parameters - ---------- - ct: argloc_type_t - data: argloc_t::biggest_t - -ida_typeinf.argloc_t._set_custom (method) - _set_custom(self, ct, pdata) - - Parameters - ---------- - ct: argloc_type_t - pdata: void * - -ida_typeinf.argloc_t._set_ea (method) - _set_ea(self, _ea) - - Parameters - ---------- - _ea: ea_t - -ida_typeinf.argloc_t._set_reg1 (method) - _set_reg1(self, reg, off=0) - - Parameters - ---------- - reg: int - off: int - -ida_typeinf.argloc_t._set_reg2 (method) - _set_reg2(self, _reg1, _reg2) - - Parameters - ---------- - _reg1: int - _reg2: int - -ida_typeinf.argloc_t._set_stkoff (method) - _set_stkoff(self, off) - - Parameters - ---------- - off: sval_t - -ida_typeinf.argloc_t.advance (method) - advance(self, delta) -> bool - Move the location to point 'delta' bytes further. - - @param delta: (C++: int) - -ida_typeinf.argloc_t.align_reg_high (method) - align_reg_high(self, size, _slotsize) - Set register offset to align it to the upper part of _SLOTSIZE. - - @param size: (C++: size_t) - @param _slotsize: (C++: size_t) - -ida_typeinf.argloc_t.align_stkoff_high (method) - align_stkoff_high(self, size, _slotsize) - Set stack offset to align to the upper part of _SLOTSIZE. - - @param size: (C++: size_t) - @param _slotsize: (C++: size_t) - -ida_typeinf.argloc_t.atype (method) - atype(self) -> argloc_type_t - Get type (Argument location types) - -ida_typeinf.argloc_t.calc_offset (method) - calc_offset(self) -> sval_t - Calculate offset that can be used to compare 2 similar arglocs. - -ida_typeinf.argloc_t.compare (method) - compare(self, r) -> int - - @param r: argloc_t const & - -ida_typeinf.argloc_t.consume_rrel (method) - consume_rrel(self, p) - Set register-relative location - can't be nullptr. - - @param p: (C++: rrel_t *) - -ida_typeinf.argloc_t.consume_scattered (method) - consume_scattered(self, p) - Set distributed argument location. - - @param p: (C++: scattered_aloc_t *) scattered_aloc_t const & - -ida_typeinf.argloc_t.get_biggest (method) - get_biggest(self) -> argloc_t::biggest_t - Get largest element in internal union. - -ida_typeinf.argloc_t.get_custom (method) - get_custom(self) -> void * - Get custom argloc info. Use if atype() == ALOC_CUSTOM - -ida_typeinf.argloc_t.get_ea (method) - get_ea(self) -> ea_t - Get the global address. Use when atype() == ALOC_STATIC - -ida_typeinf.argloc_t.get_reginfo (method) - get_reginfo(self) -> uint32 - Get all register info. Use when atype() == ALOC_REG1 or ALOC_REG2 - -ida_typeinf.argloc_t.get_rrel (method) - get_rrel(self) -> rrel_t - Get register-relative info. Use when atype() == ALOC_RREL - -ida_typeinf.argloc_t.has_reg (method) - has_reg(self) -> bool - TRUE if argloc has a register part. - -ida_typeinf.argloc_t.has_stkoff (method) - has_stkoff(self) -> bool - TRUE if argloc has a stack part. - -ida_typeinf.argloc_t.in_stack (method) - in_stack(self) -> bool - TRUE if argloc is in stack entirely. - -ida_typeinf.argloc_t.is_badloc (method) - is_badloc(self) -> bool - See ALOC_NONE. - -ida_typeinf.argloc_t.is_custom (method) - is_custom(self) -> bool - See ALOC_CUSTOM. - -ida_typeinf.argloc_t.is_ea (method) - is_ea(self) -> bool - See ALOC_STATIC. - -ida_typeinf.argloc_t.is_fragmented (method) - is_fragmented(self) -> bool - is_scattered() || is_reg2() - -ida_typeinf.argloc_t.is_mixed_scattered (method) - is_mixed_scattered(self) -> bool - mixed scattered: consists of register and stack parts - -ida_typeinf.argloc_t.is_reg (method) - is_reg(self) -> bool - is_reg1() || is_reg2() - -ida_typeinf.argloc_t.is_reg1 (method) - is_reg1(self) -> bool - See ALOC_REG1. - -ida_typeinf.argloc_t.is_reg2 (method) - is_reg2(self) -> bool - See ALOC_REG2. - -ida_typeinf.argloc_t.is_rrel (method) - is_rrel(self) -> bool - See ALOC_RREL. - -ida_typeinf.argloc_t.is_scattered (method) - is_scattered(self) -> bool - See ALOC_DIST. - -ida_typeinf.argloc_t.is_stkoff (method) - is_stkoff(self) -> bool - See ALOC_STACK. - -ida_typeinf.argloc_t.reg1 (method) - reg1(self) -> int - Get the register info. Use when atype() == ALOC_REG1 or ALOC_REG2 - -ida_typeinf.argloc_t.reg2 (method) - reg2(self) -> int - Get info for the second register. Use when atype() == ALOC_REG2 - -ida_typeinf.argloc_t.regoff (method) - regoff(self) -> int - Get offset from the beginning of the register in bytes. Use when atype() == - ALOC_REG1 - -ida_typeinf.argloc_t.scattered (method) - scattered(self) -> scattered_aloc_t - Get scattered argument info. Use when atype() == ALOC_DIST - -ida_typeinf.argloc_t.set_badloc (method) - set_badloc(self) - Set to invalid location. - -ida_typeinf.argloc_t.set_ea (method) - set_ea(self, _ea) - Set static ea location. - - @param _ea: (C++: ea_t) - -ida_typeinf.argloc_t.set_reg1 (method) - set_reg1(self, reg, off=0) - Set register location. - - @param reg: (C++: int) - @param off: (C++: int) - -ida_typeinf.argloc_t.set_reg2 (method) - set_reg2(self, _reg1, _reg2) - Set secondary register location. - - @param _reg1: (C++: int) - @param _reg2: (C++: int) - -ida_typeinf.argloc_t.set_stkoff (method) - set_stkoff(self, off) - Set stack offset location. - - @param off: (C++: sval_t) - -ida_typeinf.argloc_t.stkoff (method) - stkoff(self) -> sval_t - Get the stack offset. Use if atype() == ALOC_STACK - -ida_typeinf.argloc_t.swap (method) - swap(self, r) - Assign this == r and r == this. - - @param r: (C++: argloc_t &) - -ida_typeinf.argpart_t (class) - Proxy of C++ argpart_t class. - -ida_typeinf.argpart_t.__init__ (method) - __init__(self, a) -> argpart_t - - @param a: argloc_t const & - - __init__(self) -> argpart_t - -ida_typeinf.argpart_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: argpart_t const & - -ida_typeinf.argpart_t.bad_offset (method) - bad_offset(self) -> bool - Does this argpart have a valid offset? - -ida_typeinf.argpart_t.bad_size (method) - bad_size(self) -> bool - Does this argpart have a valid size? - -ida_typeinf.argpart_t.off (variable) - offset from the beginning of the argument - -ida_typeinf.argpart_t.size (variable) - the number of bytes - -ida_typeinf.argpart_t.swap (method) - swap(self, r) - Assign this = r and r = this. - - @param r: (C++: argpart_t &) - -ida_typeinf.argpartvec_t (class) - Proxy of C++ qvector< argpart_t > class. - -ida_typeinf.argpartvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< argpart_t > const & - -ida_typeinf.argpartvec_t.__getitem__ (method) - __getitem__(self, i) -> argpart_t - - @param i: size_t - -ida_typeinf.argpartvec_t.__init__ (method) - __init__(self) -> argpartvec_t - __init__(self, x) -> argpartvec_t - - @param x: qvector< argpart_t > const & - -ida_typeinf.argpartvec_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.argpartvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< argpart_t > const & - -ida_typeinf.argpartvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: argpart_t const & - -ida_typeinf.argpartvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: argpart_t const & - -ida_typeinf.argpartvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: argpart_t const & - -ida_typeinf.argpartvec_t.at (method) - at(self, _idx) -> argpart_t - - @param _idx: size_t - -ida_typeinf.argpartvec_t.begin (method) - begin(self) -> argpart_t - -ida_typeinf.argpartvec_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.argpartvec_t.clear (method) - clear(self) - -ida_typeinf.argpartvec_t.empty (method) - empty(self) -> bool - -ida_typeinf.argpartvec_t.end (method) - end(self) -> argpart_t - -ida_typeinf.argpartvec_t.erase (method) - erase(self, it) -> argpart_t - - @param it: qvector< argpart_t >::iterator - - erase(self, first, last) -> argpart_t - - @param first: qvector< argpart_t >::iterator - @param last: qvector< argpart_t >::iterator - -ida_typeinf.argpartvec_t.extract (method) - extract(self) -> argpart_t - -ida_typeinf.argpartvec_t.find (method) - find(self, x) -> argpart_t - - @param x: argpart_t const & - -ida_typeinf.argpartvec_t.grow (method) - grow(self, x=argpart_t()) - - @param x: argpart_t const & - -ida_typeinf.argpartvec_t.has (method) - has(self, x) -> bool - - @param x: argpart_t const & - -ida_typeinf.argpartvec_t.inject (method) - inject(self, s, len) - - @param s: argpart_t * - @param len: size_t - -ida_typeinf.argpartvec_t.insert (method) - insert(self, it, x) -> argpart_t - - @param it: qvector< argpart_t >::iterator - @param x: argpart_t const & - -ida_typeinf.argpartvec_t.pop_back (method) - pop_back(self) - -ida_typeinf.argpartvec_t.push_back (method) - push_back(self, x) - - @param x: argpart_t const & - - push_back(self) -> argpart_t - -ida_typeinf.argpartvec_t.qclear (method) - qclear(self) - -ida_typeinf.argpartvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.argpartvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: argpart_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.argpartvec_t.size (method) - size(self) -> size_t - -ida_typeinf.argpartvec_t.swap (method) - swap(self, r) - - @param r: qvector< argpart_t > & - -ida_typeinf.argpartvec_t.truncate (method) - truncate(self) - -ida_typeinf.argtinfo_helper_t (class) - Proxy of C++ argtinfo_helper_t class. - -ida_typeinf.argtinfo_helper_t.__disown__ (method) - -ida_typeinf.argtinfo_helper_t.__init__ (method) - __init__(self) -> argtinfo_helper_t - - @param self: PyObject * - -ida_typeinf.argtinfo_helper_t.has_delay_slot (method) - has_delay_slot(self, arg0) -> bool - The call instruction with a delay slot?. - - @param arg0: ea_t - -ida_typeinf.argtinfo_helper_t.is_stkarg_load (method) - is_stkarg_load(self, insn, src, dst) -> bool - Is the current insn a stkarg load?. if yes: - * src: index of the source operand in insn_t::ops - * dst: index of the destination operand in insn_t::ops insn_t::ops[dst].addr is - expected to have the stack offset - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param src: (C++: int *) - @param dst: (C++: int *) - -ida_typeinf.argtinfo_helper_t.set_op_tinfo (method) - set_op_tinfo(self, insn, x, tif, name) -> bool - Set the operand type as specified. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: (C++: const op_t &) op_t const & - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param name: (C++: const char *) char const * - -ida_typeinf.argtinfo_helper_t.use_arg_tinfos (method) - use_arg_tinfos(self, caller, fti, rargs) - This function is to be called by the processor module in response to - ev_use_arg_types. - - @param caller: (C++: ea_t) - @param fti: (C++: func_type_data_t *) - @param rargs: (C++: funcargvec_t *) - -ida_typeinf.array_type_data_t (class) - Proxy of C++ array_type_data_t class. - -ida_typeinf.array_type_data_t.__init__ (method) - __init__(self, b=0, n=0) -> array_type_data_t - - @param b: size_t - @param n: size_t - -ida_typeinf.array_type_data_t.base (variable) - array base - -ida_typeinf.array_type_data_t.elem_type (variable) - element type - -ida_typeinf.array_type_data_t.nelems (variable) - number of elements - -ida_typeinf.array_type_data_t.swap (method) - swap(self, r) - set this = r and r = this - - @param r: (C++: array_type_data_t &) - -ida_typeinf.begin_type_updating (function) - begin_type_updating(utp) - Mark the beginning of a large update operation on the types. Can be used with - add_enum_member(), add_struc_member, etc... Also see end_type_updating() - - @param utp: (C++: update_type_t) enum update_type_t - -ida_typeinf.bitfield_type_data_t (class) - Proxy of C++ bitfield_type_data_t class. - -ida_typeinf.bitfield_type_data_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: bitfield_type_data_t const & - -ida_typeinf.bitfield_type_data_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: bitfield_type_data_t const & - -ida_typeinf.bitfield_type_data_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: bitfield_type_data_t const & - -ida_typeinf.bitfield_type_data_t.__init__ (method) - __init__(self, _nbytes=0, _width=0, _is_unsigned=False) -> bitfield_type_data_t - - @param _nbytes: uchar - @param _width: uchar - @param _is_unsigned: bool - -ida_typeinf.bitfield_type_data_t.__le__ (method) - __le__(self, r) -> bool - - @param r: bitfield_type_data_t const & - -ida_typeinf.bitfield_type_data_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: bitfield_type_data_t const & - -ida_typeinf.bitfield_type_data_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: bitfield_type_data_t const & - -ida_typeinf.bitfield_type_data_t.compare (method) - compare(self, r) -> int - - @param r: bitfield_type_data_t const & - -ida_typeinf.bitfield_type_data_t.is_unsigned (variable) - is bitfield unsigned? - -ida_typeinf.bitfield_type_data_t.is_valid_bitfield (method) - is_valid_bitfield(self) -> bool - -ida_typeinf.bitfield_type_data_t.nbytes (variable) - enclosing type size (1,2,4,8 bytes) - -ida_typeinf.bitfield_type_data_t.swap (method) - swap(self, r) - - @param r: bitfield_type_data_t & - -ida_typeinf.bitfield_type_data_t.width (variable) - number of bits - -ida_typeinf.calc_c_cpp_name (function) - calc_c_cpp_name(name, type, ccn_flags) -> str - Get C or C++ form of the name. - - @param name: (C++: const char *) original (mangled or decorated) name - @param type: (C++: const tinfo_t *) name type if known, otherwise nullptr - @param ccn_flags: (C++: int) one of C/C++ naming flags - -ida_typeinf.calc_number_of_children (function) - calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int - Calculate max number of lines of a formatted c data, when expanded (PTV_EXPAND). - - @param loc: (C++: const argloc_t &) location of the data (ALOC_STATIC or ALOC_CUSTOM) - @param tif: (C++: const tinfo_t &) type info - @param dont_deref_ptr: (C++: bool) consider 'ea' as the ptr value - @retval 0: data is not expandable - @retval -1: error, see qerrno - @retval else: the max number of lines - -ida_typeinf.calc_tinfo_gaps (function) - calc_tinfo_gaps(out, typid) -> bool - - @param out: rangeset_t * - @param typid: uint32 - -ida_typeinf.calc_type_size (function) - calc_type_size(ti, tp) -> PyObject * - Returns the size of a type - - @param ti: Type info library. 'None' can be passed. - @param tp: serialized type byte string - @return: - None on failure - - The size of the type - -ida_typeinf.callregs_t (class) - Proxy of C++ callregs_t class. - -ida_typeinf.callregs_t.__init__ (method) - __init__(self) -> callregs_t - __init__(self, cc) -> callregs_t - - @param cc: cm_t - -ida_typeinf.callregs_t.by_slots (method) - by_slots(self) -> bool - -ida_typeinf.callregs_t.fpregs (variable) - array of fp registers - -ida_typeinf.callregs_t.gpregs (variable) - array of gp registers - -ida_typeinf.callregs_t.init_regs (method) - init_regs(self, cc) - Init policy & registers for given CC. - - @param cc: (C++: cm_t) - -ida_typeinf.callregs_t.nregs (variable) - max number of registers that can be used in a call - -ida_typeinf.callregs_t.policy (variable) - argument policy - -ida_typeinf.callregs_t.regcount (method) - regcount(cc) -> int - Get max number of registers may be used in a function call. - - @param cc: (C++: cm_t) - -ida_typeinf.callregs_t.reginds (method) - reginds(self, gp_ind, fp_ind, r) -> bool - Get register indexes within GP/FP arrays. (-1 -> is not present in the - corresponding array) - - @param gp_ind: (C++: int *) - @param fp_ind: (C++: int *) - @param r: (C++: int) - -ida_typeinf.callregs_t.reset (method) - reset(self) - Set policy and registers to invalid values. - -ida_typeinf.callregs_t.set (method) - set(self, _policy, gprs, fprs) - Init policy & registers (arrays are -1-terminated) - - @param _policy: (C++: argreg_policy_t) enum argreg_policy_t - @param gprs: (C++: const int *) int const * - @param fprs: (C++: const int *) int const * - -ida_typeinf.callregs_t.swap (method) - swap(self, r) - swap two instances - - @param r: (C++: callregs_t &) - -ida_typeinf.callregs_t_regcount (function) - callregs_t_regcount(cc) -> int - - @param cc: cm_t - -ida_typeinf.choose_local_tinfo (function) - choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None) -> uint32 - Choose a type from the local type library. - - @param ti: (C++: const til_t *) pointer to til - @param title: (C++: const char *) title of listbox to display - @param func: (C++: local_tinfo_predicate_t *) predicate to select types to display (maybe nullptr) - @param def_ord: (C++: uint32) ordinal to position cursor before choose - @param ud: (C++: void *) user data - @return: == 0 means nothing is chosen, otherwise an ordinal number - -ida_typeinf.choose_local_tinfo_and_delta (function) - choose_local_tinfo_and_delta(delta, ti, title, func=None, def_ord=0, ud=None) -> uint32 - Choose a type from the local type library and specify the pointer shift value. - - @param delta: (C++: int32 *) pointer shift value - @param ti: (C++: const til_t *) pointer to til - @param title: (C++: const char *) title of listbox to display - @param func: (C++: local_tinfo_predicate_t *) predicate to select types to display (maybe nullptr) - @param def_ord: (C++: uint32) ordinal to position cursor before choose - @param ud: (C++: void *) user data - @return: == 0 means nothing is chosen, otherwise an ordinal number - -ida_typeinf.choose_named_type (function) - choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None) -> bool - Choose a type from a type library. - - @param out_sym: (C++: til_symbol_t *) pointer to be filled with the chosen type - @param root_til: (C++: const til_t *) pointer to starting til (the function will inspect the base - tils if allowed by flags) - @param title: (C++: const char *) title of listbox to display - @param ntf_flags: (C++: int) combination of Flags for named types - @param predicate: (C++: predicate_t *) predicate to select types to display (maybe nullptr) - @return: false if nothing is chosen, otherwise true - -ida_typeinf.clear_tinfo_t (function) - clear_tinfo_t(_this) - - @param _this: tinfo_t * - -ida_typeinf.compact_til (function) - compact_til(ti) -> bool - Collect garbage in til. Must be called before storing the til. - - @param ti: (C++: til_t *) - @return: true if any memory was freed - -ida_typeinf.compare_tinfo (function) - compare_tinfo(t1, t2, tcflags) -> bool - - @param t1: uint32 - @param t2: uint32 - @param tcflags: int - -ida_typeinf.const_aloc_visitor_t (class) - Proxy of C++ const_aloc_visitor_t class. - -ida_typeinf.const_aloc_visitor_t.__disown__ (method) - -ida_typeinf.const_aloc_visitor_t.__init__ (method) - __init__(self) -> const_aloc_visitor_t - - @param self: PyObject * - -ida_typeinf.const_aloc_visitor_t.visit_location (method) - visit_location(self, v, off, size) -> int - - @param v: argloc_t const & - @param off: int - @param size: int - -ida_typeinf.convert_pt_flags_to_hti (function) - convert_pt_flags_to_hti(pt_flags) -> int - Convert Type parsing flags to Type formatting flags. Type parsing flags lesser - than 0x10 don't have stable meaning and will be ignored (more on these flags can - be seen in idc.idc) - - @param pt_flags: (C++: int) - -ida_typeinf.copy_named_type (function) - copy_named_type(dsttil, srctil, name) -> uint32 - Copy a named type from one til to another. This function will copy the specified - type and all dependent types from the source type library to the destination - library. - - @param dsttil: (C++: til_t *) Destination til. It must have orginal types enabled - @param srctil: (C++: const til_t *) Source til. - @param name: (C++: const char *) name of the type to copy - @return: ordinal number of the copied type. 0 means error - -ida_typeinf.copy_tinfo_t (function) - copy_tinfo_t(_this, r) - - @param _this: tinfo_t * - @param r: tinfo_t const & - -ida_typeinf.create_enum_type (function) - create_enum_type(enum_name, ei, enum_width, sign, convert_to_bitmask, enum_cmt=None) -> tid_t - Create type enum - - @param enum_name: (C++: const char *) type name - @param ei: (C++: enum_type_data_t &) enum type data - @param enum_width: (C++: int) the width of an enum element allowed values: 0 - (unspecified),1,2,4,8,16,32,64 - @param sign: (C++: type_sign_t) enum sign - @param convert_to_bitmask: (C++: bool) try convert enum to bitmask enum - @param enum_cmt: (C++: const char *) enum type comment - @return: enum TID - -ida_typeinf.create_numbered_type_name (function) - create_numbered_type_name(ord) -> str - Create anonymous name for numbered type. This name can be used to reference a - numbered type by its ordinal Ordinal names have the following format: '#' + - set_de(ord) Returns: -1 if error, otherwise the name length - - @param ord: (C++: int32) - -ida_typeinf.create_tinfo (function) - create_tinfo(_this, bt, bt2, ptr) -> bool - - @param _this: tinfo_t * - @param bt: type_t - @param bt2: type_t - @param ptr: void * - -ida_typeinf.create_tinfo2 (function) - create_tinfo2(_this, bt, bt2, ptr) -> bool - - @param _this: tinfo_t * - @param bt: type_t - @param bt2: type_t - @param ptr: void * - -ida_typeinf.custom_data_type_info_t (class) - Proxy of C++ custom_data_type_info_t class. - -ida_typeinf.custom_data_type_info_t.__init__ (method) - __init__(self) -> custom_data_type_info_t - -ida_typeinf.custom_data_type_info_t.dtid (variable) - data type id - -ida_typeinf.custom_data_type_info_t.fid (variable) - data format ids - -ida_typeinf.default_compiler (function) - default_compiler() -> comp_t - Get compiler specified by inf.cc. - -ida_typeinf.del_named_type (function) - del_named_type(ti, name, ntf_flags) -> bool - Delete information about a symbol. - - @param ti: (C++: til_t *) type library - @param name: (C++: const char *) name of symbol - @param ntf_flags: (C++: int) combination of Flags for named types - @return: success - -ida_typeinf.del_numbered_type (function) - del_numbered_type(ti, ordinal) -> bool - Delete a numbered type. - - @param ti: (C++: til_t *) - @param ordinal: (C++: uint32) - -ida_typeinf.del_til (function) - del_til(name) -> bool - Unload a til file. - - @param name: (C++: const char *) char const * - -ida_typeinf.del_tinfo_attr (function) - del_tinfo_attr(tif, key, make_copy) -> bool - - @param tif: tinfo_t * - @param key: qstring const & - @param make_copy: bool - -ida_typeinf.del_vftable_ea (function) - del_vftable_ea(ordinal) -> bool - Delete the address of a vftable instance for a vftable type. - - @param ordinal: (C++: uint32) ordinal number of a vftable type. - @return: success - -ida_typeinf.deref_ptr (function) - deref_ptr(ptr_ea, tif, closure_obj=None) -> bool - Dereference a pointer. - - @param ptr_ea: (C++: ea_t *) in/out parameter - * in: address of the pointer - * out: the pointed address - @param tif: (C++: const tinfo_t &) type of the pointer - @param closure_obj: (C++: ea_t *) closure object (not used yet) - @return: success - -ida_typeinf.deserialize_tinfo (function) - deserialize_tinfo(tif, til, ptype, pfields, pfldcmts, cmt=None) -> bool - - @param tif: tinfo_t * - @param til: til_t const * - @param ptype: type_t const ** - @param pfields: p_list const ** - @param pfldcmts: p_list const ** - @param cmt: char const * - -ida_typeinf.dstr_tinfo (function) - dstr_tinfo(tif) -> char const * - - @param tif: tinfo_t const * - -ida_typeinf.dump_func_type_data (function) - dump_func_type_data(fti, praloc_bits) -> str - Use func_type_data_t::dump() - - @param fti: (C++: const func_type_data_t &) func_type_data_t const & - @param praloc_bits: (C++: int) - -ida_typeinf.edm_t (class) - Proxy of C++ edm_t class. - -ida_typeinf.edm_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: edm_t const & - -ida_typeinf.edm_t.__init__ (method) - __init__(self) -> edm_t - -ida_typeinf.edm_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: edm_t const & - -ida_typeinf.edm_t.get_tid (method) - get_tid(self) -> tid_t - -ida_typeinf.edm_t.swap (method) - swap(self, r) - - @param r: edm_t & - -ida_typeinf.edmvec_t (class) - Proxy of C++ qvector< edm_t > class. - -ida_typeinf.edmvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< edm_t > const & - -ida_typeinf.edmvec_t.__getitem__ (method) - __getitem__(self, i) -> edm_t - - @param i: size_t - -ida_typeinf.edmvec_t.__init__ (method) - __init__(self) -> edmvec_t - __init__(self, x) -> edmvec_t - - @param x: qvector< edm_t > const & - -ida_typeinf.edmvec_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.edmvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< edm_t > const & - -ida_typeinf.edmvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: edm_t const & - -ida_typeinf.edmvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: edm_t const & - -ida_typeinf.edmvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: edm_t const & - -ida_typeinf.edmvec_t.at (method) - at(self, _idx) -> edm_t - - @param _idx: size_t - -ida_typeinf.edmvec_t.begin (method) - begin(self) -> edm_t - -ida_typeinf.edmvec_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.edmvec_t.clear (method) - clear(self) - -ida_typeinf.edmvec_t.empty (method) - empty(self) -> bool - -ida_typeinf.edmvec_t.end (method) - end(self) -> edm_t - -ida_typeinf.edmvec_t.erase (method) - erase(self, it) -> edm_t - - @param it: qvector< edm_t >::iterator - - erase(self, first, last) -> edm_t - - @param first: qvector< edm_t >::iterator - @param last: qvector< edm_t >::iterator - -ida_typeinf.edmvec_t.extract (method) - extract(self) -> edm_t - -ida_typeinf.edmvec_t.find (method) - find(self, x) -> edm_t - - @param x: edm_t const & - -ida_typeinf.edmvec_t.grow (method) - grow(self, x=edm_t()) - - @param x: edm_t const & - -ida_typeinf.edmvec_t.has (method) - has(self, x) -> bool - - @param x: edm_t const & - -ida_typeinf.edmvec_t.inject (method) - inject(self, s, len) - - @param s: edm_t * - @param len: size_t - -ida_typeinf.edmvec_t.insert (method) - insert(self, it, x) -> edm_t - - @param it: qvector< edm_t >::iterator - @param x: edm_t const & - -ida_typeinf.edmvec_t.pop_back (method) - pop_back(self) - -ida_typeinf.edmvec_t.push_back (method) - push_back(self, x) - - @param x: edm_t const & - - push_back(self) -> edm_t - -ida_typeinf.edmvec_t.qclear (method) - qclear(self) - -ida_typeinf.edmvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.edmvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: edm_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.edmvec_t.size (method) - size(self) -> size_t - -ida_typeinf.edmvec_t.swap (method) - swap(self, r) - - @param r: qvector< edm_t > & - -ida_typeinf.edmvec_t.truncate (method) - truncate(self) - -ida_typeinf.enable_numbered_types (function) - enable_numbered_types(ti, enable) -> bool - Enable the use of numbered types in til. Currently it is impossible to disable - numbered types once they are enabled - - @param ti: (C++: til_t *) - @param enable: (C++: bool) - -ida_typeinf.end_type_updating (function) - end_type_updating(utp) - Mark the end of a large update operation on the types (see - begin_type_updating()) - - @param utp: (C++: update_type_t) enum update_type_t - -ida_typeinf.enum_type_data_t (class) - Proxy of C++ enum_type_data_t class. - -ida_typeinf.enum_type_data_t.__init__ (method) - __init__(self, _bte=BTE_ALWAYS|BTE_HEX) -> enum_type_data_t - - @param _bte: bte_t - -ida_typeinf.enum_type_data_t.add_constant (method) - add_constant(self, name, value, cmt=None) - add constant for regular enum - - @param name: (C++: const char *) char const * - @param value: (C++: uint64) - @param cmt: (C++: const char *) char const * - -ida_typeinf.enum_type_data_t.bte (variable) - enum member sizes (shift amount) and style. do not manually set BTE_BITMASK, use - set_enum_is_bitmask() - -ida_typeinf.enum_type_data_t.calc_mask (method) - calc_mask(self) -> uint64 - -ida_typeinf.enum_type_data_t.calc_nbytes (method) - calc_nbytes(self) -> int - get the width of enum in bytes - -ida_typeinf.enum_type_data_t.find_member (method) - find_member(self, name, _from=0, to=size_t(-1)) -> ssize_t - find member (constant or bmask) by value - - @param name: char const * - @param from: (C++: size_t) - @param to: (C++: size_t) - - find_member(self, value, serial, _from=0, to=size_t(-1), vmask=uint64(-1)) -> ssize_t - - @param value: uint64 - @param serial: uchar - @param from: size_t - @param to: size_t - @param vmask: uint64 - -ida_typeinf.enum_type_data_t.get_constant_group (method) - get_constant_group(self, group_start_index, group_size, idx) -> bool - get group parameters for the constant, valid for etimask enum - - @param group_start_index: (C++: size_t *) index of the group mask - @param group_size: (C++: size_t *) group size (>=1) - @param idx: (C++: size_t) constant index - @return: success - -ida_typeinf.enum_type_data_t.get_enum_radix (method) - get_enum_radix(self) -> int - Get enum constant radix - - @return: radix or 1 for BTE_CHAR - -ida_typeinf.enum_type_data_t.group_sizes (variable) - if present, specifies bitmask group sizes each non-trivial group starts with a - mask member - -ida_typeinf.enum_type_data_t.has_lzero (method) - has_lzero(self) -> bool - -ida_typeinf.enum_type_data_t.is_bf (method) - is_bf(self) -> bool - is bitmask or ordinary enum? - -ida_typeinf.enum_type_data_t.is_bin (method) - is_bin(self) -> bool - -ida_typeinf.enum_type_data_t.is_char (method) - is_char(self) -> bool - -ida_typeinf.enum_type_data_t.is_dec (method) - is_dec(self) -> bool - -ida_typeinf.enum_type_data_t.is_group_mask_at (method) - is_group_mask_at(self, idx) -> bool - is the enum member at IDX a non-trivial group mask? a trivial group consist of - one bit and has just one member, which can be considered as a mask or a bitfield - constant - - @param idx: (C++: size_t) index - @return: success - -ida_typeinf.enum_type_data_t.is_hex (method) - is_hex(self) -> bool - -ida_typeinf.enum_type_data_t.is_number_signed (method) - is_number_signed(self) -> bool - -ida_typeinf.enum_type_data_t.is_oct (method) - is_oct(self) -> bool - -ida_typeinf.enum_type_data_t.is_sbin (method) - is_sbin(self) -> bool - -ida_typeinf.enum_type_data_t.is_shex (method) - is_shex(self) -> bool - -ida_typeinf.enum_type_data_t.is_soct (method) - is_soct(self) -> bool - -ida_typeinf.enum_type_data_t.is_udec (method) - is_udec(self) -> bool - -ida_typeinf.enum_type_data_t.is_valid_group_sizes (method) - is_valid_group_sizes(self) -> bool - is valid group sizes - -ida_typeinf.enum_type_data_t.set_enum_radix (method) - set_enum_radix(self, radix, sign) - Set radix to display constants - - @param radix: (C++: int) radix with the special case 1 to display as character - @param sign: (C++: bool) - -ida_typeinf.enum_type_data_t.set_lzero (method) - set_lzero(self, on) - - @param on: bool - -ida_typeinf.enum_type_data_t.set_nbytes (method) - set_nbytes(self, nbytes) -> bool - set enum width (nbytes) - - @param nbytes: (C++: int) - -ida_typeinf.enum_type_data_t.set_value_repr (method) - set_value_repr(self, repr) -> tinfo_code_t - set enum radix and other representation info - - @param repr: (C++: const value_repr_t &) value display info - -ida_typeinf.enum_type_data_t.store_64bit_values (method) - store_64bit_values(self) -> bool - -ida_typeinf.enum_type_data_t.swap (method) - swap(self, r) - swap two instances - - @param r: (C++: enum_type_data_t &) - -ida_typeinf.enum_type_data_t.taenum_bits (variable) - Type attributes for enums - -ida_typeinf.enum_type_data_t__get_max_serial (function) - enum_type_data_t__get_max_serial(ei, value) -> uchar - - @param ei: enum_type_data_t const * - @param value: uint64 - -ida_typeinf.extract_argloc (function) - extract_argloc(vloc, ptype, forbid_stkoff) -> bool - Deserialize an argument location. Argument FORBID_STKOFF checks location type. - It can be used, for example, to check the return location of a function that - cannot return a value in the stack - - @param vloc: (C++: argloc_t *) - @param ptype: (C++: const type_t **) type_t const ** - @param forbid_stkoff: (C++: bool) - -ida_typeinf.find_tinfo_udt_member (function) - find_tinfo_udt_member(udm, typid, strmem_flags) -> int - - @param udm: udm_t * - @param typid: uint32 - @param strmem_flags: int - -ida_typeinf.first_named_type (function) - first_named_type(ti, ntf_flags) -> char const * - Enumerate types. - - @param ti: (C++: const til_t *) type library. nullptr means the local type library for the current - database. - @param ntf_flags: (C++: int) combination of Flags for named types - @return: Type or symbol names, depending of ntf_flags. Returns mangled names. - Never returns anonymous types. To include them, enumerate types by - ordinals. - -ida_typeinf.for_all_arglocs (function) - for_all_arglocs(vv, vloc, size, off=0) -> int - Compress larger argloc types and initiate the aloc visitor. - - @param vv: (C++: aloc_visitor_t &) - @param vloc: (C++: argloc_t &) - @param size: (C++: int) - @param off: (C++: int) - -ida_typeinf.for_all_const_arglocs (function) - for_all_const_arglocs(vv, vloc, size, off=0) -> int - See for_all_arglocs() - - @param vv: (C++: const_aloc_visitor_t &) - @param vloc: (C++: const argloc_t &) argloc_t const & - @param size: (C++: int) - @param off: (C++: int) - -ida_typeinf.free_til (function) - free_til(ti) - Free memory allocated by til. - - @param ti: (C++: til_t *) - -ida_typeinf.func_has_stkframe_hole (function) - func_has_stkframe_hole(ea, fti) -> bool - Looks for a hole at the beginning of the stack arguments. Will make use of the - IDB's func_t function at that place (if present) to help determine the presence - of such a hole. - - @param ea: (C++: ea_t) - @param fti: (C++: const func_type_data_t &) func_type_data_t const & - -ida_typeinf.func_type_data_t (class) - Proxy of C++ func_type_data_t class. - -ida_typeinf.func_type_data_t.__init__ (method) - __init__(self) -> func_type_data_t - -ida_typeinf.func_type_data_t.cc (variable) - calling convention - -ida_typeinf.func_type_data_t.dump (method) - dump(self, praloc_bits=0x02) -> bool - Dump information that is not always visible in the function prototype. (argument - locations, return location, total stkarg size) - - @param praloc_bits: (C++: int) - -ida_typeinf.func_type_data_t.flags (variable) - Function type data property bits - -ida_typeinf.func_type_data_t.get_call_method (method) - get_call_method(self) -> int - -ida_typeinf.func_type_data_t.guess_cc (method) - guess_cc(self, purged, cc_flags) -> cm_t - Guess function calling convention use the following info: argument locations and - 'stkargs' - - @param purged: (C++: int) - @param cc_flags: (C++: int) - -ida_typeinf.func_type_data_t.is_const (method) - is_const(self) -> bool - -ida_typeinf.func_type_data_t.is_ctor (method) - is_ctor(self) -> bool - -ida_typeinf.func_type_data_t.is_dtor (method) - is_dtor(self) -> bool - -ida_typeinf.func_type_data_t.is_golang_cc (method) - is_golang_cc(self) -> bool - -ida_typeinf.func_type_data_t.is_high (method) - is_high(self) -> bool - -ida_typeinf.func_type_data_t.is_noret (method) - is_noret(self) -> bool - -ida_typeinf.func_type_data_t.is_pure (method) - is_pure(self) -> bool - -ida_typeinf.func_type_data_t.is_static (method) - is_static(self) -> bool - -ida_typeinf.func_type_data_t.is_swift_cc (method) - is_swift_cc(self) -> bool - -ida_typeinf.func_type_data_t.is_vararg_cc (method) - is_vararg_cc(self) -> bool - -ida_typeinf.func_type_data_t.is_virtual (method) - is_virtual(self) -> bool - -ida_typeinf.func_type_data_t.retloc (variable) - return location - -ida_typeinf.func_type_data_t.rettype (variable) - return type - -ida_typeinf.func_type_data_t.spoiled (variable) - spoiled register information. if spoiled register info is present, it overrides - the standard spoil info (eax, edx, ecx for x86) - -ida_typeinf.func_type_data_t.stkargs (variable) - size of stack arguments (not used in build_func_type) - -ida_typeinf.func_type_data_t.swap (method) - swap(self, r) - - @param r: func_type_data_t & - -ida_typeinf.funcarg_t (class) - Proxy of C++ funcarg_t class. - -ida_typeinf.funcarg_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: funcarg_t const & - -ida_typeinf.funcarg_t.__init__ (method) - __init__(self) -> funcarg_t - -ida_typeinf.funcarg_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: funcarg_t const & - -ida_typeinf.funcarg_t.argloc (variable) - argument location - -ida_typeinf.funcarg_t.cmt (variable) - argument comment (may be empty) - -ida_typeinf.funcarg_t.flags (variable) - Function argument property bits - -ida_typeinf.funcarg_t.name (variable) - argument name (may be empty) - -ida_typeinf.funcarg_t.type (variable) - argument type - -ida_typeinf.funcargvec_t (class) - Proxy of C++ qvector< funcarg_t > class. - -ida_typeinf.funcargvec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< funcarg_t > const & - -ida_typeinf.funcargvec_t.__getitem__ (method) - __getitem__(self, i) -> funcarg_t - - @param i: size_t - -ida_typeinf.funcargvec_t.__init__ (method) - __init__(self) -> funcargvec_t - __init__(self, x) -> funcargvec_t - - @param x: qvector< funcarg_t > const & - -ida_typeinf.funcargvec_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.funcargvec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< funcarg_t > const & - -ida_typeinf.funcargvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: funcarg_t const & - -ida_typeinf.funcargvec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: funcarg_t const & - -ida_typeinf.funcargvec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: funcarg_t const & - -ida_typeinf.funcargvec_t.at (method) - at(self, _idx) -> funcarg_t - - @param _idx: size_t - -ida_typeinf.funcargvec_t.begin (method) - begin(self) -> funcarg_t - -ida_typeinf.funcargvec_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.funcargvec_t.clear (method) - clear(self) - -ida_typeinf.funcargvec_t.empty (method) - empty(self) -> bool - -ida_typeinf.funcargvec_t.end (method) - end(self) -> funcarg_t - -ida_typeinf.funcargvec_t.erase (method) - erase(self, it) -> funcarg_t - - @param it: qvector< funcarg_t >::iterator - - erase(self, first, last) -> funcarg_t - - @param first: qvector< funcarg_t >::iterator - @param last: qvector< funcarg_t >::iterator - -ida_typeinf.funcargvec_t.extract (method) - extract(self) -> funcarg_t - -ida_typeinf.funcargvec_t.find (method) - find(self, x) -> funcarg_t - - @param x: funcarg_t const & - -ida_typeinf.funcargvec_t.grow (method) - grow(self, x=funcarg_t()) - - @param x: funcarg_t const & - -ida_typeinf.funcargvec_t.has (method) - has(self, x) -> bool - - @param x: funcarg_t const & - -ida_typeinf.funcargvec_t.inject (method) - inject(self, s, len) - - @param s: funcarg_t * - @param len: size_t - -ida_typeinf.funcargvec_t.insert (method) - insert(self, it, x) -> funcarg_t - - @param it: qvector< funcarg_t >::iterator - @param x: funcarg_t const & - -ida_typeinf.funcargvec_t.pop_back (method) - pop_back(self) - -ida_typeinf.funcargvec_t.push_back (method) - push_back(self, x) - - @param x: funcarg_t const & - - push_back(self) -> funcarg_t - -ida_typeinf.funcargvec_t.qclear (method) - qclear(self) - -ida_typeinf.funcargvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.funcargvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: funcarg_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.funcargvec_t.size (method) - size(self) -> size_t - -ida_typeinf.funcargvec_t.swap (method) - swap(self, r) - - @param r: qvector< funcarg_t > & - -ida_typeinf.funcargvec_t.truncate (method) - truncate(self) - -ida_typeinf.gcc_layout (function) - gcc_layout() -> bool - Should use the struct/union layout as done by gcc? - -ida_typeinf.gen_decorate_name (function) - gen_decorate_name(name, mangle, cc, type) -> str - Generic function for decorate_name() (may be used in IDP modules) - - @param name: (C++: const char *) char const * - @param mangle: (C++: bool) - @param cc: (C++: cm_t) - @param type: (C++: const tinfo_t *) tinfo_t const * - -ida_typeinf.gen_use_arg_tinfos (function) - gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot) - - @param caller: ea_t - @param fti: func_type_data_t * - @param rargs: funcargvec_t * - @param set_optype: set_op_tinfo_t * - @param is_stkarg_load: is_stkarg_load_t * - @param has_delay_slot: has_delay_slot_t * - -ida_typeinf.gen_use_arg_tinfos2 (function) - gen_use_arg_tinfos2(_this, caller, fti, rargs) - Do not call this function directly, use argtinfo_helper_t. - - @param _this: (C++: struct argtinfo_helper_t *) argtinfo_helper_t * - @param caller: (C++: ea_t) - @param fti: (C++: func_type_data_t *) - @param rargs: (C++: funcargvec_t *) - -ida_typeinf.get_abi_name (function) - get_abi_name() -> str - Get ABI name. - - @return: length of the name (>=0) - -ida_typeinf.get_alias_target (function) - get_alias_target(ti, ordinal) -> uint32 - Find the final alias destination. If the ordinal has not been aliased, return - the specified ordinal itself If failed, returns 0. - - @param ti: (C++: const til_t *) til_t const * - @param ordinal: (C++: uint32) - -ida_typeinf.get_arg_addrs (function) - get_arg_addrs(caller) -> PyObject * - Retrieve addresses of argument initialization instructions - - @param caller: the address of the call instruction - @return: list of instruction addresses - -ida_typeinf.get_base_type (function) - get_base_type(t) -> type_t - Get get basic type bits (TYPE_BASE_MASK) - - @param t: (C++: type_t) - -ida_typeinf.get_c_header_path (function) - get_c_header_path() -> str - Get the include directory path of the target compiler. - -ida_typeinf.get_c_macros (function) - get_c_macros() -> str - Get predefined macros for the target compiler. - -ida_typeinf.get_comp (function) - get_comp(comp) -> comp_t - Get compiler bits. - - @param comp: (C++: comp_t) - -ida_typeinf.get_compiler_abbr (function) - get_compiler_abbr(id) -> char const * - Get abbreviated compiler name. - - @param id: (C++: comp_t) - -ida_typeinf.get_compiler_name (function) - get_compiler_name(id) -> char const * - Get full compiler name. - - @param id: (C++: comp_t) - -ida_typeinf.get_compilers (function) - get_compilers(ids, names, abbrs) - Get names of all built-in compilers. - - @param ids: (C++: compvec_t *) - @param names: (C++: qstrvec_t *) - @param abbrs: (C++: qstrvec_t *) - -ida_typeinf.get_enum_member_expr (function) - get_enum_member_expr(tif, serial, value) -> str - Return a C expression that can be used to represent an enum member. If the value - does not correspond to any single enum member, this function tries to find a - bitwise combination of enum members that correspond to it. If more than half of - value bits do not match any enum members, it fails. - - @param tif: (C++: const tinfo_t &) enumeration type - @param serial: (C++: int) which enumeration member to use (0 means the first with the given - value) - @param value: (C++: uint64) value to search in the enumeration type - @return: success - -ida_typeinf.get_full_type (function) - get_full_type(t) -> type_t - Get basic type bits + type flags (TYPE_FULL_MASK) - - @param t: (C++: type_t) - -ida_typeinf.get_idainfo64_by_type (function) - get_idainfo64_by_type(out_flags, tif) -> bool - Extract information from a tinfo_t. - - @param out_flags: (C++: flags64_t *) description of type using flags64_t - @param tif: (C++: const tinfo_t &) the type to inspect - -ida_typeinf.get_idainfo_by_type (function) - get_idainfo_by_type(tif) -> bool - Extract information from a tinfo_t. - - @param tif: (C++: const tinfo_t &) the type to inspect - -ida_typeinf.get_idati (function) - get_idati() -> til_t - Pointer to the local type library - this til is private for each IDB file - Functions that accept til_t* default to `idati` when is nullptr provided. - -ida_typeinf.get_named_type (function) - get_named_type(til, name, ntf_flags) -> (int, bytes, bytes, NoneType, NoneType, int, int) - Get a type data by its name. - - @param til: the type library - @param name: the type name - @param ntf_flags: a combination of NTF_* constants - @return: None on failure - tuple(code, type_str, fields_str, cmt, field_cmts, sclass, value) on success - -ida_typeinf.get_named_type64 (function) - get_named_type64(til, name, ntf_flags) -> (int, bytes, NoneType, NoneType, NoneType, int, int) - See get_named_type() above. - @note: If the value in the 'ti' library is 32-bit, it will be sign-extended - before being stored in the 'value' pointer. - - @param til: til_t const * - @param name: (C++: const char *) char const * - @param ntf_flags: (C++: int) - -ida_typeinf.get_named_type_tid (function) - get_named_type_tid(name) -> tid_t - Get named local type TID - - @param name: (C++: const char *) type name - @return: TID or BADADDR - -ida_typeinf.get_numbered_type (function) - get_numbered_type(til, ordinal) -> (bytes, NoneType, NoneType, NoneType, int), (bytes, bytes, NoneType, NoneType, int) - Retrieve a type by its ordinal number. - - @param til: til_t const * - @param ordinal: (C++: uint32) - -ida_typeinf.get_numbered_type_name (function) - get_numbered_type_name(ti, ordinal) -> char const * - Get type name (if exists) by its ordinal. If the type is anonymous, returns "". - If failed, returns nullptr - - @param ti: (C++: const til_t *) til_t const * - @param ordinal: (C++: uint32) - -ida_typeinf.get_ordinal_count (function) - get_ordinal_count(ti=None) -> uint32 - Get number of allocated ordinals. - - @param ti: (C++: const til_t *) type library; nullptr means the local types for the current database. - @return: 0 if ordinals have not been enabled for the til. - -ida_typeinf.get_ordinal_from_idb_type (function) - get_ordinal_from_idb_type(name, type) -> int - Get ordinal number of an idb type (struct/enum). The 'type' parameter is used - only to determine the kind of the type (struct or enum) Use this function to - find out the correspondence between idb types and til types - - @param name: (C++: const char *) char const * - @param type: (C++: const type_t *) type_t const * - -ida_typeinf.get_ordinal_limit (function) - get_ordinal_limit(ti=None) -> uint32 - Get number of allocated ordinals + 1. If there are no allocated ordinals, return - 0. To enumerate all ordinals, use: for ( uint32 i = 1; i < limit; ++i ) - - @param ti: (C++: const til_t *) type library; nullptr means the local types for the current database. - @return: uint32(-1) if ordinals have not been enabled for the til. For local - types (idati), ordinals are always enabled. - -ida_typeinf.get_ordinal_qty (function) - get_ordinal_qty(ti) -> uint32 - - @param ti: til_t const * - -ida_typeinf.get_scalar_bt (function) - get_scalar_bt(size) -> type_t - - @param size: int - -ida_typeinf.get_stock_tinfo (function) - get_stock_tinfo(tif, id) -> bool - - @param tif: tinfo_t * - @param id: enum stock_type_id_t - -ida_typeinf.get_tid_name (function) - get_tid_name(tid) -> str - Get a type name for the specified TID - - @param tid: (C++: tid_t) type TID - @return: true if there is type with TID - @note: this function is the inverse to get_named_type_tid - -ida_typeinf.get_tid_ordinal (function) - get_tid_ordinal(tid) -> uint32 - Get type ordinal number for TID - - @param tid: (C++: tid_t) type/enum constant/udt member TID - @return: type ordinal number or 0 - -ida_typeinf.get_tinfo_attr (function) - get_tinfo_attr(typid, key, bv, all_attrs) -> bool - - @param typid: uint32 - @param key: qstring const & - @param bv: bytevec_t * - @param all_attrs: bool - -ida_typeinf.get_tinfo_attrs (function) - get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool - - @param typid: uint32 - @param tav: type_attrs_t * - @param include_ref_attrs: bool - -ida_typeinf.get_tinfo_by_flags (function) - get_tinfo_by_flags(out, flags) -> bool - Get tinfo object that corresponds to data flags - - @param out: (C++: tinfo_t *) type info - @param flags: (C++: flags64_t) simple flags (byte, word, ..., zword) - -ida_typeinf.get_tinfo_details (function) - get_tinfo_details(typid, bt2, buf) -> bool - - @param typid: uint32 - @param bt2: type_t - @param buf: void * - -ida_typeinf.get_tinfo_details2 (function) - get_tinfo_details2(typid, bt2, buf) -> bool - - @param typid: uint32 - @param bt2: type_t - @param buf: void * - -ida_typeinf.get_tinfo_pdata (function) - get_tinfo_pdata(outptr, typid, what) -> size_t - - @param outptr: void * - @param typid: uint32 - @param what: int - -ida_typeinf.get_tinfo_property (function) - get_tinfo_property(typid, gta_prop) -> size_t - - @param typid: uint32 - @param gta_prop: int - -ida_typeinf.get_tinfo_property4 (function) - get_tinfo_property4(typid, gta_prop, p1, p2, p3, p4) -> size_t - - @param typid: uint32 - @param gta_prop: int - @param p1: size_t - @param p2: size_t - @param p3: size_t - @param p4: size_t - -ida_typeinf.get_tinfo_size (function) - get_tinfo_size(p_effalign, typid, gts_code) -> size_t - - @param p_effalign: uint32 * - @param typid: uint32 - @param gts_code: int - -ida_typeinf.get_tinfo_tid (function) - get_tinfo_tid(tif, force_tid) -> tid_t - - @param tif: tinfo_t * - @param force_tid: bool - -ida_typeinf.get_type_flags (function) - get_type_flags(t) -> type_t - Get type flags (TYPE_FLAGS_MASK) - - @param t: (C++: type_t) - -ida_typeinf.get_type_ordinal (function) - get_type_ordinal(ti, name) -> int32 - Get type ordinal by its name. - - @param ti: (C++: const til_t *) til_t const * - @param name: (C++: const char *) char const * - -ida_typeinf.get_udm_by_fullname (function) - get_udm_by_fullname(udm, fullname) -> ssize_t - Get udt member by full name - - @param udm: (C++: udm_t *) member, can be NULL - @param fullname: (C++: const char *) udt member name in format <udt name>.<member name> - @return: member index into udt_type_data_t or -1 - -ida_typeinf.get_udm_tid (function) - get_udm_tid(udm, udt_name) -> tid_t - - @param udm: udm_t const * - @param udt_name: char const * - -ida_typeinf.get_vftable_ea (function) - get_vftable_ea(ordinal) -> ea_t - Get address of a virtual function table. - - @param ordinal: (C++: uint32) ordinal number of a vftable type. - @return: address of the corresponding virtual function table in the current - database. - -ida_typeinf.get_vftable_ordinal (function) - get_vftable_ordinal(vftable_ea) -> uint32 - Get ordinal number of the virtual function table. - - @param vftable_ea: (C++: ea_t) address of a virtual function table. - @return: ordinal number of the corresponding vftable type. 0 - failure. - -ida_typeinf.guess_func_cc (function) - guess_func_cc(fti, npurged, cc_flags) -> cm_t - Use func_type_data_t::guess_cc() - - @param fti: (C++: const func_type_data_t &) func_type_data_t const & - @param npurged: (C++: int) - @param cc_flags: (C++: int) - -ida_typeinf.guess_tinfo (function) - guess_tinfo(out, id) -> int - Generate a type information about the id from the disassembly. id can be a - structure/union/enum id or an address. - - @param out: (C++: tinfo_t *) - @param id: (C++: tid_t) - @return: one of Guess tinfo codes - -ida_typeinf.ida_lowertype_helper_t (class) - Proxy of C++ ida_lowertype_helper_t class. - -ida_typeinf.ida_lowertype_helper_t.__init__ (method) - __init__(self, _tif, _ea, _pb) -> ida_lowertype_helper_t - - @param _tif: tinfo_t const & - @param _ea: ea_t - @param _pb: int - -ida_typeinf.ida_lowertype_helper_t.func_has_stkframe_hole (method) - func_has_stkframe_hole(self, candidate, candidate_data) -> bool - - @param candidate: tinfo_t const & - @param candidate_data: func_type_data_t const & - -ida_typeinf.ida_lowertype_helper_t.get_func_purged_bytes (method) - get_func_purged_bytes(self, candidate, arg3) -> int - - @param candidate: tinfo_t const & - @param arg3: func_type_data_t const & - -ida_typeinf.idc_get_local_type (function) - idc_get_local_type(ordinal, flags) -> str - - @param ordinal: int - @param flags: int - -ida_typeinf.idc_get_local_type_name (function) - idc_get_local_type_name(ordinal) -> str - - @param ordinal: int - -ida_typeinf.idc_get_local_type_raw (function) - idc_get_local_type_raw(ordinal) -> (bytes, bytes) - - @param ordinal: int - -ida_typeinf.idc_get_type (function) - idc_get_type(ea) -> str - - @param ea: ea_t - -ida_typeinf.idc_get_type_raw (function) - idc_get_type_raw(ea) -> PyObject * - - @param ea: ea_t - -ida_typeinf.idc_guess_type (function) - idc_guess_type(ea) -> str - - @param ea: ea_t - -ida_typeinf.idc_parse_decl (function) - idc_parse_decl(ti, decl, flags) -> (str, bytes, bytes) or None - - @param ti: til_t * - @param decl: char const * - @param flags: int - -ida_typeinf.idc_parse_types (function) - idc_parse_types(input, flags) -> int - - @param input: char const * - @param flags: int - -ida_typeinf.idc_print_type (function) - idc_print_type(type, fields, name, flags) -> str - - @param type: type_t const * - @param fields: p_list const * - @param name: char const * - @param flags: int - -ida_typeinf.idc_set_local_type (function) - idc_set_local_type(ordinal, dcl, flags) -> int - - @param ordinal: int - @param dcl: char const * - @param flags: int - -ida_typeinf.import_type (function) - import_type(til, idx, name, flags=0) -> tid_t - Copy a named type from til to idb. - - @param til: (C++: const til_t *) type library - @param idx: (C++: int) the position of the new type in the list of types (structures or - enums). -1 means at the end of the list - @param name: (C++: const char *) the type name - @param flags: (C++: int) combination of Import type flags - @return: BADNODE on error - -ida_typeinf.inf_big_arg_align (function) - inf_big_arg_align() -> bool - inf_big_arg_align(cc) -> bool - - @param cc: cm_t - -ida_typeinf.inf_huge_arg_align (function) - inf_huge_arg_align() -> bool - inf_huge_arg_align(cc) -> bool - - @param cc: cm_t - -ida_typeinf.inf_pack_stkargs (function) - inf_pack_stkargs() -> bool - inf_pack_stkargs(cc) -> bool - - @param cc: cm_t - -ida_typeinf.is_autosync (function) - is_autosync(name, type) -> bool - Is the specified idb type automatically synchronized? - - @param name: (C++: const char *) char const * - @param type: type_t const * - - is_autosync(name, tif) -> bool - - @param name: char const * - @param tif: tinfo_t const & - -ida_typeinf.is_code_far (function) - is_code_far(cm) -> bool - Does the given model specify far code?. - - @param cm: (C++: cm_t) - -ida_typeinf.is_comp_unsure (function) - is_comp_unsure(comp) -> comp_t - See COMP_UNSURE. - - @param comp: (C++: comp_t) - -ida_typeinf.is_data_far (function) - is_data_far(cm) -> bool - Does the given model specify far data?. - - @param cm: (C++: cm_t) - -ida_typeinf.is_gcc (function) - is_gcc() -> bool - Is the target compiler COMP_GNU? - -ida_typeinf.is_gcc32 (function) - is_gcc32() -> bool - Is the target compiler 32 bit gcc? - -ida_typeinf.is_gcc64 (function) - is_gcc64() -> bool - Is the target compiler 64 bit gcc? - -ida_typeinf.is_golang_cc (function) - is_golang_cc(cc) -> bool - GO language calling convention (return value in stack)? - - @param cc: (C++: cm_t) - -ida_typeinf.is_ordinal_name (function) - is_ordinal_name(name, ord=None) -> bool - Check if the name is an ordinal name. Ordinal names have the following format: - '#' + set_de(ord) - - @param name: (C++: const char *) char const * - @param ord: (C++: uint32 *) - -ida_typeinf.is_purging_cc (function) - is_purging_cc(cm) -> bool - Does the calling convention clean the stack arguments upon return?. - @note: this function is valid only for x86 code - - @param cm: (C++: cm_t) - -ida_typeinf.is_restype_enum (function) - is_restype_enum(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * - -ida_typeinf.is_restype_struct (function) - is_restype_struct(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * - -ida_typeinf.is_restype_struni (function) - is_restype_struni(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * - -ida_typeinf.is_restype_void (function) - is_restype_void(til, type) -> bool - - @param til: til_t const * - @param type: type_t const * - -ida_typeinf.is_sdacl_byte (function) - is_sdacl_byte(t) -> bool - Identify an sdacl byte. The first sdacl byte has the following format: 11xx000x. - The sdacl bytes are appended to udt fields. They indicate the start of type - attributes (as the tah-bytes do). The sdacl bytes are used in the udt headers - instead of the tah-byte. This is done for compatibility with old databases, they - were already using sdacl bytes in udt headers and as udt field postfixes. (see - "sdacl-typeattrs" in the type bit definitions) - - @param t: (C++: type_t) - -ida_typeinf.is_swift_cc (function) - is_swift_cc(cc) -> bool - Swift calling convention (arguments and return values in registers)? - - @param cc: (C++: cm_t) - -ida_typeinf.is_tah_byte (function) - is_tah_byte(t) -> bool - The TAH byte (type attribute header byte) denotes the start of type attributes. - (see "tah-typeattrs" in the type bit definitions) - - @param t: (C++: type_t) - -ida_typeinf.is_type_arithmetic (function) - is_type_arithmetic(t) -> bool - Is the type an arithmetic type? (floating or integral) - - @param t: (C++: type_t) - -ida_typeinf.is_type_array (function) - is_type_array(t) -> bool - See BT_ARRAY. - - @param t: (C++: type_t) - -ida_typeinf.is_type_bitfld (function) - is_type_bitfld(t) -> bool - See BT_BITFIELD. - - @param t: (C++: type_t) - -ida_typeinf.is_type_bool (function) - is_type_bool(t) -> bool - See BTF_BOOL. - - @param t: (C++: type_t) - -ida_typeinf.is_type_char (function) - is_type_char(t) -> bool - Does the type specify a char value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) - -ida_typeinf.is_type_choosable (function) - is_type_choosable(ti, ordinal) -> bool - Check if a struct/union type is choosable - - @param ti: (C++: const til_t *) type library - @param ordinal: (C++: uint32) ordinal number of a UDT type - -ida_typeinf.is_type_complex (function) - is_type_complex(t) -> bool - See BT_COMPLEX. - - @param t: (C++: type_t) - -ida_typeinf.is_type_const (function) - is_type_const(t) -> bool - See BTM_CONST. - - @param t: (C++: type_t) - -ida_typeinf.is_type_double (function) - is_type_double(t) -> bool - See BTF_DOUBLE. - - @param t: (C++: type_t) - -ida_typeinf.is_type_enum (function) - is_type_enum(t) -> bool - See BTF_ENUM. - - @param t: (C++: type_t) - -ida_typeinf.is_type_ext_arithmetic (function) - is_type_ext_arithmetic(t) -> bool - Is the type an extended arithmetic type? (arithmetic or enum) - - @param t: (C++: type_t) - -ida_typeinf.is_type_ext_integral (function) - is_type_ext_integral(t) -> bool - Is the type an extended integral type? (integral or enum) - - @param t: (C++: type_t) - -ida_typeinf.is_type_float (function) - is_type_float(t) -> bool - See BTF_FLOAT. - - @param t: (C++: type_t) - -ida_typeinf.is_type_floating (function) - is_type_floating(t) -> bool - Is the type a floating point type? - - @param t: (C++: type_t) - -ida_typeinf.is_type_func (function) - is_type_func(t) -> bool - See BT_FUNC. - - @param t: (C++: type_t) - -ida_typeinf.is_type_int (function) - is_type_int(bt) -> bool - Does the type_t specify one of the basic types in Basic type: integer? - - @param bt: (C++: type_t) - -ida_typeinf.is_type_int128 (function) - is_type_int128(t) -> bool - Does the type specify a 128-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) - -ida_typeinf.is_type_int16 (function) - is_type_int16(t) -> bool - Does the type specify a 16-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) - -ida_typeinf.is_type_int32 (function) - is_type_int32(t) -> bool - Does the type specify a 32-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) - -ida_typeinf.is_type_int64 (function) - is_type_int64(t) -> bool - Does the type specify a 64-bit value? (signed or unsigned, see Basic type: - integer) - - @param t: (C++: type_t) - -ida_typeinf.is_type_integral (function) - is_type_integral(t) -> bool - Is the type an integral type (char/short/int/long/bool)? - - @param t: (C++: type_t) - -ida_typeinf.is_type_ldouble (function) - is_type_ldouble(t) -> bool - See BTF_LDOUBLE. - - @param t: (C++: type_t) - -ida_typeinf.is_type_paf (function) - is_type_paf(t) -> bool - Is the type a pointer, array, or function type? - - @param t: (C++: type_t) - -ida_typeinf.is_type_partial (function) - is_type_partial(t) -> bool - Identifies an unknown or void type with a known size (see Basic type: unknown & - void) - - @param t: (C++: type_t) - -ida_typeinf.is_type_ptr (function) - is_type_ptr(t) -> bool - See BT_PTR. - - @param t: (C++: type_t) - -ida_typeinf.is_type_ptr_or_array (function) - is_type_ptr_or_array(t) -> bool - Is the type a pointer or array type? - - @param t: (C++: type_t) - -ida_typeinf.is_type_struct (function) - is_type_struct(t) -> bool - See BTF_STRUCT. - - @param t: (C++: type_t) - -ida_typeinf.is_type_struni (function) - is_type_struni(t) -> bool - Is the type a struct or union? - - @param t: (C++: type_t) - -ida_typeinf.is_type_sue (function) - is_type_sue(t) -> bool - Is the type a struct/union/enum? - - @param t: (C++: type_t) - -ida_typeinf.is_type_tbyte (function) - is_type_tbyte(t) -> bool - See BTF_FLOAT. - - @param t: (C++: type_t) - -ida_typeinf.is_type_typedef (function) - is_type_typedef(t) -> bool - See BTF_TYPEDEF. - - @param t: (C++: type_t) - -ida_typeinf.is_type_uchar (function) - is_type_uchar(t) -> bool - See BTF_UCHAR. - - @param t: (C++: type_t) - -ida_typeinf.is_type_uint (function) - is_type_uint(t) -> bool - See BTF_UINT. - - @param t: (C++: type_t) - -ida_typeinf.is_type_uint128 (function) - is_type_uint128(t) -> bool - See BTF_UINT128. - - @param t: (C++: type_t) - -ida_typeinf.is_type_uint16 (function) - is_type_uint16(t) -> bool - See BTF_UINT16. - - @param t: (C++: type_t) - -ida_typeinf.is_type_uint32 (function) - is_type_uint32(t) -> bool - See BTF_UINT32. - - @param t: (C++: type_t) - -ida_typeinf.is_type_uint64 (function) - is_type_uint64(t) -> bool - See BTF_UINT64. - - @param t: (C++: type_t) - -ida_typeinf.is_type_union (function) - is_type_union(t) -> bool - See BTF_UNION. - - @param t: (C++: type_t) - -ida_typeinf.is_type_unknown (function) - is_type_unknown(t) -> bool - See BT_UNKNOWN. - - @param t: (C++: type_t) - -ida_typeinf.is_type_void (function) - is_type_void(t) -> bool - See BTF_VOID. - - @param t: (C++: type_t) - -ida_typeinf.is_type_volatile (function) - is_type_volatile(t) -> bool - See BTM_VOLATILE. - - @param t: (C++: type_t) - -ida_typeinf.is_typeid_last (function) - is_typeid_last(t) -> bool - Is the type_t the last byte of type declaration? (there are no additional bytes - after a basic type, see _BT_LAST_BASIC) - - @param t: (C++: type_t) - -ida_typeinf.is_user_cc (function) - is_user_cc(cm) -> bool - Does the calling convention specify argument locations explicitly? - - @param cm: (C++: cm_t) - -ida_typeinf.is_vararg_cc (function) - is_vararg_cc(cm) -> bool - Does the calling convention use ellipsis? - - @param cm: (C++: cm_t) - -ida_typeinf.lexcompare_tinfo (function) - lexcompare_tinfo(t1, t2, arg3) -> int - - @param t1: uint32 - @param t2: uint32 - @param arg3: int - -ida_typeinf.load_til (function) - load_til(name, tildir=None) -> til_t - Load til from a file without adding it to the database list (see also add_til). - Failure to load base tils are reported into 'errbuf'. They do not prevent - loading of the main til. - - @param name: (C++: const char *) filename of the til. If it's an absolute path, tildir is ignored. - * NB: the file extension is forced to .til - @param tildir: (C++: const char *) directory where to load the til from. nullptr means default til - subdirectories. - @return: pointer to resulting til, nullptr if failed and error message is in - errbuf - -ida_typeinf.load_til_header (function) - load_til_header(tildir, name) -> til_t - Get human-readable til description. - - @param tildir: (C++: const char *) char const * - @param name: (C++: const char *) char const * - -ida_typeinf.lower_type (function) - lower_type(til, tif, name=None, _helper=None) -> int - Lower type. Inspect the type and lower all function subtypes using - lower_func_type(). - We call the prototypes usually encountered in source files "high level" - They may have implicit arguments, array arguments, big structure retvals, etc - We introduce explicit arguments (i.e. 'this' pointer) and call the result - "low level prototype". See FTI_HIGH. - - In order to improve heuristics for recognition of big structure retvals, - it is recommended to pass a helper that will be used to make decisions. - That helper will be used only for lowering 'tif', and not for the children - types walked through by recursion. - @retval 1: removed FTI_HIGH, - @retval 2: made substantial changes - @retval -1: failure - - @param til: (C++: til_t *) - @param tif: (C++: tinfo_t *) - @param name: (C++: const char *) char const * - @param _helper: (C++: lowertype_helper_t *) - -ida_typeinf.lowertype_helper_t (class) - Proxy of C++ lowertype_helper_t class. - -ida_typeinf.lowertype_helper_t.__init__ (method) - -ida_typeinf.lowertype_helper_t.func_has_stkframe_hole (method) - func_has_stkframe_hole(self, candidate, candidate_data) -> bool - - @param candidate: tinfo_t const & - @param candidate_data: func_type_data_t const & - -ida_typeinf.lowertype_helper_t.get_func_purged_bytes (method) - get_func_purged_bytes(self, candidate, candidate_data) -> int - - @param candidate: tinfo_t const & - @param candidate_data: func_type_data_t const & - -ida_typeinf.new_til (function) - new_til(name, desc) -> til_t - Initialize a til. - - @param name: (C++: const char *) char const * - @param desc: (C++: const char *) char const * - -ida_typeinf.next_named_type (function) - next_named_type(ti, name, ntf_flags) -> char const * - Enumerate types. - - @param ti: (C++: const til_t *) type library. nullptr means the local type library for the current - database. - @param name: (C++: const char *) the current name. the name that follows this one will be returned. - @param ntf_flags: (C++: int) combination of Flags for named types - @return: Type or symbol names, depending of ntf_flags. Returns mangled names. - Never returns anonymous types. To include them, enumerate types by - ordinals. - -ida_typeinf.no_sign (variable) - no sign, or unknown - -ida_typeinf.optimize_argloc (function) - optimize_argloc(vloc, size, gaps) -> bool - Verify and optimize scattered argloc into simple form. All new arglocs must be - processed by this function. - @retval true: success - @retval false: the input argloc was illegal - - @param vloc: (C++: argloc_t *) - @param size: (C++: int) - @param gaps: (C++: const rangeset_t *) rangeset_t const * - -ida_typeinf.pack_idcobj_to_bv (function) - pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t - Write a typed idc object to the byte vector. Byte vector may be non-empty, this - function will append data to it - - @param obj: (C++: const idc_value_t *) idc_value_t const * - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param bytes: (C++: relobj_t *) - @param objoff: (C++: void *) - @param pio_flags: (C++: int) - -ida_typeinf.pack_idcobj_to_idb (function) - pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t - Write a typed idc object to the database. - - @param obj: (C++: const idc_value_t *) idc_value_t const * - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param ea: (C++: ea_t) - @param pio_flags: (C++: int) - -ida_typeinf.pack_object_to_bv (function) - pack_object_to_bv(py_obj, ti, type, fields, base_ea, pio_flags=0) -> PyObject * - Packs a typed object to a string - - @param py_obj: PyObject * - @param ti: Type info. 'None' can be passed. - @param type: type_t const * - @param fields: fields string (may be empty or None) - @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 - -ida_typeinf.pack_object_to_idb (function) - pack_object_to_idb(py_obj, ti, type, 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 py_obj: PyObject * - @param ti: Type info. 'None' can be passed. - @param type: type_t const * - @param fields: fields string (may be empty or None) - @param ea: ea to be used while packing - @param pio_flags: flags used while unpacking - -ida_typeinf.parse_decl (function) - parse_decl(out_tif, til, decl, pt_flags) -> str - Parse ONE declaration. If the input string contains more than one declaration, - the first complete type declaration (PT_TYP) or the last variable declaration - (PT_VAR) will be used. - @note: name & tif may be empty after the call! - - @param out_tif: (C++: tinfo_t *) type info - @param til: (C++: til_t *) type library to use. may be nullptr - @param decl: (C++: const char *) C declaration to parse - @param pt_flags: (C++: int) combination of Type parsing flags bits - @retval true: ok - @retval false: declaration is bad, the error message is displayed if !PT_SIL - -ida_typeinf.parse_decls (function) - parse_decls(til, input, printer, hti_flags) -> int - Parse many declarations and store them in a til. If there are any errors, they - will be printed using 'printer'. This function uses default include path and - predefined macros from the database settings. It always uses the HTI_DCL bit. - - @param til: (C++: til_t *) type library to store the result - @param input: (C++: const char *) input string or file name (see hti_flags) - @param printer: (C++: printer_t *) function to output error messages (use msg or nullptr or your - own callback) - @param hti_flags: (C++: int) combination of Type formatting flags - @return: number of errors, 0 means ok. - -ida_typeinf.predicate_t (class) - Proxy of C++ predicate_t class. - -ida_typeinf.predicate_t.__disown__ (method) - -ida_typeinf.predicate_t.__init__ (method) - __init__(self) -> predicate_t - - @param self: PyObject * - -ida_typeinf.predicate_t.should_display (method) - should_display(self, til, name, type, fields) -> bool - - @param til: til_t const * - @param name: char const * - @param type: type_t const * - @param fields: p_list const * - -ida_typeinf.print_argloc (function) - print_argloc(vloc, size=0, vflags=0) -> str - Convert an argloc to human readable form. - - @param vloc: (C++: const argloc_t &) argloc_t const & - @param size: (C++: int) - @param vflags: (C++: int) - -ida_typeinf.print_decls (function) - print_decls(printer, til, py_ordinals, flags) -> int - Print types (and possibly their dependencies) in a format suitable for using in - a header file. This is the reverse parse_decls(). - - @param printer: (C++: text_sink_t &) a handler for printing text - @param til: (C++: til_t *) the type library holding the ordinals - @param py_ordinals: ordinals of types to export. nullptr means: all ordinals in til - @param pdf_flags: (C++: uint32) flags for the algorithm. A combination of PDF_ constants - @retval >0: the number of types exported - @retval 0: an error occurred - @retval <0: the negated number of types exported. There were minor errors and - the resulting output might not be compilable. - -ida_typeinf.print_tinfo (function) - print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> str - - @param prefix: char const * - @param indent: int - @param cmtindent: int - @param flags: int - @param tif: tinfo_t const * - @param name: char const * - @param cmt: char const * - -ida_typeinf.print_type (function) - print_type(ea, prtype_flags) -> str - Get type declaration for the specified address. - - @param ea: (C++: ea_t) address - @param prtype_flags: (C++: int) combination of Type printing flags - @return: success - -ida_typeinf.ptr_type_data_t (class) - Proxy of C++ ptr_type_data_t class. - -ida_typeinf.ptr_type_data_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: ptr_type_data_t const & - -ida_typeinf.ptr_type_data_t.__init__ (method) - __init__(self, c=tinfo_t(), bps=0, p=tinfo_t(), d=0) -> ptr_type_data_t - - @param c: tinfo_t - @param bps: uchar - @param p: tinfo_t - @param d: int32 - -ida_typeinf.ptr_type_data_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: ptr_type_data_t const & - -ida_typeinf.ptr_type_data_t.closure (variable) - cannot have both closure and based_ptr_size - -ida_typeinf.ptr_type_data_t.delta (variable) - Offset from the beginning of the parent struct. - -ida_typeinf.ptr_type_data_t.is_code_ptr (method) - is_code_ptr(self) -> bool - Are we pointing to code? - -ida_typeinf.ptr_type_data_t.is_shifted (method) - is_shifted(self) -> bool - -ida_typeinf.ptr_type_data_t.obj_type (variable) - pointed object type - -ida_typeinf.ptr_type_data_t.parent (variable) - Parent struct. - -ida_typeinf.ptr_type_data_t.swap (method) - swap(self, r) - Set this = r and r = this. - - @param r: (C++: ptr_type_data_t &) - -ida_typeinf.ptr_type_data_t.taptr_bits (variable) - TAH bits. - -ida_typeinf.read_tinfo_bitfield_value (function) - read_tinfo_bitfield_value(typid, v, bitoff) -> uint64 - - @param typid: uint32 - @param v: uint64 - @param bitoff: int - -ida_typeinf.reginfovec_t (class) - Proxy of C++ qvector< reg_info_t > class. - -ida_typeinf.reginfovec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< reg_info_t > const & - -ida_typeinf.reginfovec_t.__getitem__ (method) - __getitem__(self, i) -> reg_info_t - - @param i: size_t - -ida_typeinf.reginfovec_t.__init__ (method) - __init__(self) -> reginfovec_t - __init__(self, x) -> reginfovec_t - - @param x: qvector< reg_info_t > const & - -ida_typeinf.reginfovec_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.reginfovec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< reg_info_t > const & - -ida_typeinf.reginfovec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: reg_info_t const & - -ida_typeinf.reginfovec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: reg_info_t const & - -ida_typeinf.reginfovec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: reg_info_t const & - -ida_typeinf.reginfovec_t.at (method) - at(self, _idx) -> reg_info_t - - @param _idx: size_t - -ida_typeinf.reginfovec_t.begin (method) - begin(self) -> reg_info_t - -ida_typeinf.reginfovec_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.reginfovec_t.clear (method) - clear(self) - -ida_typeinf.reginfovec_t.empty (method) - empty(self) -> bool - -ida_typeinf.reginfovec_t.end (method) - end(self) -> reg_info_t - -ida_typeinf.reginfovec_t.erase (method) - erase(self, it) -> reg_info_t - - @param it: qvector< reg_info_t >::iterator - - erase(self, first, last) -> reg_info_t - - @param first: qvector< reg_info_t >::iterator - @param last: qvector< reg_info_t >::iterator - -ida_typeinf.reginfovec_t.extract (method) - extract(self) -> reg_info_t - -ida_typeinf.reginfovec_t.find (method) - find(self, x) -> reg_info_t - - @param x: reg_info_t const & - -ida_typeinf.reginfovec_t.grow (method) - grow(self, x=reg_info_t()) - - @param x: reg_info_t const & - -ida_typeinf.reginfovec_t.has (method) - has(self, x) -> bool - - @param x: reg_info_t const & - -ida_typeinf.reginfovec_t.inject (method) - inject(self, s, len) - - @param s: reg_info_t * - @param len: size_t - -ida_typeinf.reginfovec_t.insert (method) - insert(self, it, x) -> reg_info_t - - @param it: qvector< reg_info_t >::iterator - @param x: reg_info_t const & - -ida_typeinf.reginfovec_t.pop_back (method) - pop_back(self) - -ida_typeinf.reginfovec_t.push_back (method) - push_back(self, x) - - @param x: reg_info_t const & - - push_back(self) -> reg_info_t - -ida_typeinf.reginfovec_t.qclear (method) - qclear(self) - -ida_typeinf.reginfovec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.reginfovec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: reg_info_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.reginfovec_t.size (method) - size(self) -> size_t - -ida_typeinf.reginfovec_t.swap (method) - swap(self, r) - - @param r: qvector< reg_info_t > & - -ida_typeinf.reginfovec_t.truncate (method) - truncate(self) - -ida_typeinf.regobj_t (class) - Proxy of C++ regobj_t class. - -ida_typeinf.regobj_t.__init__ (method) - __init__(self) -> regobj_t - -ida_typeinf.regobj_t.regidx (variable) - index into dbg->registers - -ida_typeinf.regobj_t.relocate (variable) - 0-plain num, 1-must relocate - -ida_typeinf.regobj_t.size (method) - size(self) -> size_t - -ida_typeinf.regobjs_t (class) - Proxy of C++ regobjs_t class. - -ida_typeinf.regobjs_t.__init__ (method) - __init__(self) -> regobjs_t - -ida_typeinf.regobjvec_t (class) - Proxy of C++ qvector< regobj_t > class. - -ida_typeinf.regobjvec_t.__getitem__ (method) - __getitem__(self, i) -> regobj_t - - @param i: size_t - -ida_typeinf.regobjvec_t.__init__ (method) - __init__(self) -> regobjvec_t - __init__(self, x) -> regobjvec_t - - @param x: qvector< regobj_t > const & - -ida_typeinf.regobjvec_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.regobjvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: regobj_t const & - -ida_typeinf.regobjvec_t.at (method) - at(self, _idx) -> regobj_t - - @param _idx: size_t - -ida_typeinf.regobjvec_t.begin (method) - begin(self) -> regobj_t - -ida_typeinf.regobjvec_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.regobjvec_t.clear (method) - clear(self) - -ida_typeinf.regobjvec_t.empty (method) - empty(self) -> bool - -ida_typeinf.regobjvec_t.end (method) - end(self) -> regobj_t - -ida_typeinf.regobjvec_t.erase (method) - erase(self, it) -> regobj_t - - @param it: qvector< regobj_t >::iterator - - erase(self, first, last) -> regobj_t - - @param first: qvector< regobj_t >::iterator - @param last: qvector< regobj_t >::iterator - -ida_typeinf.regobjvec_t.extract (method) - extract(self) -> regobj_t - -ida_typeinf.regobjvec_t.grow (method) - grow(self, x=regobj_t()) - - @param x: regobj_t const & - -ida_typeinf.regobjvec_t.inject (method) - inject(self, s, len) - - @param s: regobj_t * - @param len: size_t - -ida_typeinf.regobjvec_t.insert (method) - insert(self, it, x) -> regobj_t - - @param it: qvector< regobj_t >::iterator - @param x: regobj_t const & - -ida_typeinf.regobjvec_t.pop_back (method) - pop_back(self) - -ida_typeinf.regobjvec_t.push_back (method) - push_back(self, x) - - @param x: regobj_t const & - - push_back(self) -> regobj_t - -ida_typeinf.regobjvec_t.qclear (method) - qclear(self) - -ida_typeinf.regobjvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.regobjvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: regobj_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.regobjvec_t.size (method) - size(self) -> size_t - -ida_typeinf.regobjvec_t.swap (method) - swap(self, r) - - @param r: qvector< regobj_t > & - -ida_typeinf.regobjvec_t.truncate (method) - truncate(self) - -ida_typeinf.remove_abi_opts (function) - remove_abi_opts(abi_opts, user_level=False) -> bool - - @param abi_opts: char const * - @param user_level: bool - -ida_typeinf.remove_pointer (function) - remove_pointer(tif) -> tinfo_t - - @param BT_PTR: If the current type is a pointer, return the pointed object. If the - current type is not a pointer, return the current type. See also - get_ptrarr_object() and get_pointed_object() - -ida_typeinf.remove_tinfo_pointer (function) - remove_tinfo_pointer(tif, name, til) -> (bool, NoneType), (bool, str) - Remove pointer of a type. (i.e. convert "char *" into "char"). Optionally remove - the "lp" (or similar) prefix of the input name. If the input type is not a - pointer, then fail. - - @param tif: (C++: tinfo_t *) - @param name: char const * - @param til: (C++: const til_t *) til_t const * - -ida_typeinf.replace_ordinal_typerefs (function) - replace_ordinal_typerefs(til, tif) -> int - Replace references to ordinal types by name references. This function 'unties' - the type from the current local type library and makes it easier to export it. - - @param til: (C++: til_t *) type library to use. may be nullptr. - @param tif: (C++: tinfo_t *) type to modify (in/out) - @retval number: of replaced subtypes, -1 on failure - -ida_typeinf.resolve_typedef (function) - resolve_typedef(til, type) -> type_t const * - - @param til: til_t const * - @param type: type_t const * - -ida_typeinf.rrel_t (class) - Proxy of C++ rrel_t class. - -ida_typeinf.rrel_t.__init__ (method) - __init__(self) -> rrel_t - -ida_typeinf.rrel_t.off (variable) - displacement from the address pointed by the register - -ida_typeinf.rrel_t.reg (variable) - register index (into ph.reg_names) - -ida_typeinf.save_tinfo (function) - save_tinfo(tif, til, ord, name, ntf_flags) -> tinfo_code_t - - @param tif: tinfo_t * - @param til: til_t * - @param ord: size_t - @param name: char const * - @param ntf_flags: int - -ida_typeinf.scattered_aloc_t (class) - Proxy of C++ scattered_aloc_t class. - -ida_typeinf.scattered_aloc_t.__init__ (method) - __init__(self) -> scattered_aloc_t - -ida_typeinf.score_tinfo (function) - score_tinfo(tif) -> uint32 - - @param tif: tinfo_t const * - -ida_typeinf.serialize_tinfo (function) - serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool - - @param type: qtype * - @param fields: qtype * - @param fldcmts: qtype * - @param tif: tinfo_t const * - @param sudt_flags: int - -ida_typeinf.set_abi_name (function) - set_abi_name(abiname, user_level=False) -> bool - Set abi name (see Compiler IDs) - - @param abiname: (C++: const char *) char const * - @param user_level: (C++: bool) - -ida_typeinf.set_c_header_path (function) - set_c_header_path(incdir) - Set include directory path the target compiler. - - @param incdir: (C++: const char *) char const * - -ida_typeinf.set_c_macros (function) - set_c_macros(macros) - Set predefined macros for the target compiler. - - @param macros: (C++: const char *) char const * - -ida_typeinf.set_compiler (function) - set_compiler(cc, flags, abiname=None) -> bool - Change current compiler. - - @param cc: (C++: const compiler_info_t &) compiler to switch to - @param flags: (C++: int) Set compiler flags - @param abiname: (C++: const char *) ABI name - @return: success - -ida_typeinf.set_compiler_id (function) - set_compiler_id(id, abiname=None) -> bool - Set the compiler id (see Compiler IDs) - - @param id: (C++: comp_t) - @param abiname: (C++: const char *) char const * - -ida_typeinf.set_compiler_string (function) - set_compiler_string(compstr, user_level) -> bool - - @param compstr: (C++: const char *) - compiler description in form <abbr>:<abiname> - @param user_level: (C++: bool) - initiated by user if TRUE - @return: success - -ida_typeinf.set_numbered_type (function) - set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> tinfo_code_t - Store a type in the til. 'name' may be nullptr for anonymous types. To replace - the existed type use NTF_REPLACE - - @param ti: (C++: til_t *) - @param ordinal: (C++: uint32) - @param ntf_flags: (C++: int) - @param name: (C++: const char *) char const * - @param type: (C++: const type_t *) type_t const * - @param fields: (C++: const p_list *) p_list const * - @param cmt: (C++: const char *) char const * - @param fldcmts: (C++: const p_list *) p_list const * - @param sclass: (C++: const sclass_t *) sclass_t const * - -ida_typeinf.set_tinfo_attr (function) - set_tinfo_attr(tif, ta, may_overwrite) -> bool - - @param tif: tinfo_t * - @param ta: type_attr_t const & - @param may_overwrite: bool - -ida_typeinf.set_tinfo_attrs (function) - set_tinfo_attrs(tif, ta) -> bool - - @param tif: tinfo_t * - @param ta: type_attrs_t * - -ida_typeinf.set_tinfo_property (function) - set_tinfo_property(tif, sta_prop, x) -> size_t - - @param tif: tinfo_t * - @param sta_prop: int - @param x: size_t - -ida_typeinf.set_tinfo_property4 (function) - set_tinfo_property4(tif, sta_prop, p1, p2, p3, p4) -> size_t - - @param tif: tinfo_t * - @param sta_prop: int - @param p1: size_t - @param p2: size_t - @param p3: size_t - @param p4: size_t - -ida_typeinf.set_type_alias (function) - set_type_alias(ti, src_ordinal, dst_ordinal) -> bool - Create a type alias. Redirects all references to source type to the destination - type. This is equivalent to instantaneous replacement all references to srctype - by dsttype. - - @param ti: (C++: til_t *) - @param src_ordinal: (C++: uint32) - @param dst_ordinal: (C++: uint32) - -ida_typeinf.set_type_choosable (function) - set_type_choosable(ti, ordinal, value) - Enable/disable 'choosability' flag for a struct/union type - - @param ti: (C++: til_t *) type library - @param ordinal: (C++: uint32) ordinal number of a UDT type - @param value: (C++: bool) flag value - -ida_typeinf.set_vftable_ea (function) - set_vftable_ea(ordinal, vftable_ea) -> bool - Set the address of a vftable instance for a vftable type. - - @param ordinal: (C++: uint32) ordinal number of the corresponding vftable type. - @param vftable_ea: (C++: ea_t) address of a virtual function table. - @return: success - -ida_typeinf.simd_info_t (class) - Proxy of C++ simd_info_t class. - -ida_typeinf.simd_info_t.__init__ (method) - __init__(self, nm=None, sz=0, memt=BTF_UNK) -> simd_info_t - - @param nm: char const * - @param sz: uint16 - @param memt: type_t - -ida_typeinf.simd_info_t.match_pattern (method) - match_pattern(self, pattern) -> bool - - @param pattern: simd_info_t const * - -ida_typeinf.simd_info_t.memtype (variable) - member type BTF_INT8/16/32/64/128, BTF_UINT8/16/32/64/128 BTF_INT - integrals of - any size/sign BTF_FLOAT, BTF_DOUBLE BTF_TBYTE - floatings of any size BTF_UNION - - union of integral and floating types BTF_UNK - undefined - -ida_typeinf.simd_info_t.name (variable) - name of SIMD type (nullptr-undefined) - -ida_typeinf.simd_info_t.size (variable) - SIMD type size in bytes (0-undefined) - -ida_typeinf.simd_info_t.tif (variable) - SIMD type (empty-undefined) - -ida_typeinf.stkarg_area_info_t (class) - Proxy of C++ stkarg_area_info_t class. - -ida_typeinf.stkarg_area_info_t.__init__ (method) - __init__(self) -> stkarg_area_info_t - -ida_typeinf.stkarg_area_info_t.linkage_area (variable) - Size of the linkage area. explanations at: \link{https://www.ibm.com/docs/en/xl- - fortran-aix/16.1.0?topic=conventions-linkage-area} examples: pc: 0, hppa: 0, ppc - aix: 0x18 (equal to stkarg_offset) - -ida_typeinf.stkarg_area_info_t.shadow_size (variable) - Size of the shadow area. explanations at: - \link{https://stackoverflow.com/questions/30190132/what-is-the-shadow-space- - in-x64-assembly} examples: x64 Visual Studio C++: 0x20, x64 gcc: 0, ppc aix: - 0x20 - -ida_typeinf.stkarg_area_info_t.stkarg_offset (variable) - Offset from the SP to the first stack argument (can include linkage area) - examples: pc: 0, hppa: -0x34, ppc aix: 0x18 - -ida_typeinf.store_til (function) - store_til(ti, tildir, name) -> bool - Store til to a file. If the til contains garbage, it will be collected before - storing the til. Your plugin should call compact_til() before calling - store_til(). - - @param ti: (C++: til_t *) type library to store - @param tildir: (C++: const char *) directory where to store the til. nullptr means current - directory. - @param name: (C++: const char *) filename of the til. If it's an absolute path, tildir is ignored. - * NB: the file extension is forced to .til - @return: success - -ida_typeinf.switch_to_golang (function) - switch_to_golang() - switch to GOLANG calling convention (to be used as default CC) - -ida_typeinf.text_sink_t (class) - Proxy of C++ text_sink_t class. - -ida_typeinf.text_sink_t.__disown__ (method) - -ida_typeinf.text_sink_t.__init__ (method) - __init__(self) -> text_sink_t - - @param self: PyObject * - -ida_typeinf.text_sink_t._print (method) - _print(self, str) -> int - - Parameters - ---------- - str: char const * - -ida_typeinf.til_symbol_t (class) - Proxy of C++ til_symbol_t class. - -ida_typeinf.til_symbol_t.__init__ (method) - __init__(self, n=None, t=None) -> til_symbol_t - - @param n: char const * - @param t: til_t const * - -ida_typeinf.til_symbol_t.name (variable) - symbol name - -ida_typeinf.til_symbol_t.til (variable) - pointer to til - -ida_typeinf.til_t (class) - Proxy of C++ til_t class. - -ida_typeinf.til_t.__init__ (method) - __init__(self) -> til_t - -ida_typeinf.til_t.base (method) - base(self, n) -> til_t - tils that our til is based on - - @param n: int - -ida_typeinf.til_t.cc (variable) - information about the target compiler - -ida_typeinf.til_t.desc (variable) - human readable til description - -ida_typeinf.til_t.flags (variable) - Type info library property bits - -ida_typeinf.til_t.is_dirty (method) - is_dirty(self) -> bool - Has the til been modified? (TIL_MOD) - -ida_typeinf.til_t.name (variable) - short file name (without path and extension) - -ida_typeinf.til_t.nbases (variable) - number of base tils - -ida_typeinf.til_t.nrefs (variable) - number of references to the til - -ida_typeinf.til_t.nstreams (variable) - number of extra streams - -ida_typeinf.til_t.set_dirty (method) - set_dirty(self) - Mark the til as modified (TIL_MOD) - -ida_typeinf.til_t.streams (variable) - symbol stream storage - -ida_typeinf.tinfo_errstr (function) - tinfo_errstr(code) -> char const * - Helper function to convert an error code into a printable string. Additional - arguments are handled using the functions from err.h - - @param code: (C++: tinfo_code_t) enum tinfo_code_t - -ida_typeinf.tinfo_t (class) - Proxy of C++ tinfo_t class. - -ida_typeinf.tinfo_t.ENUMBM_AUTO (variable) - convert to bitmask if the outcome is nice and useful - -ida_typeinf.tinfo_t.ENUMBM_OFF (variable) - convert to ordinal enum - -ida_typeinf.tinfo_t.ENUMBM_ON (variable) - convert to bitmask enum - -ida_typeinf.tinfo_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__gt__ (method) - __gt__(self, r) -> bool - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__init__ (method) - __init__(self) -> tinfo_t - __init__(self, decl_type) -> tinfo_t - - @param decl_type: type_t - - __init__(self, r) -> tinfo_t - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__le__ (method) - __le__(self, r) -> bool - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.__str__ (method) - __str__(self) -> qstring - -ida_typeinf.tinfo_t._print (method) - _print(self, name=None, prtype_flags=0, indent=0, cmtindent=0, prefix=None, cmt=None) -> bool - - Parameters - ---------- - name: char const * - prtype_flags: int - indent: int - cmtindent: int - prefix: char const * - cmt: char const * - -ida_typeinf.tinfo_t.add_edm (method) - add_edm(self, edm, bmask=bmask64_t(-1), etf_flags=0, idx=-1) -> tinfo_code_t - Add a new enum member (a new symbolic constant) - - @param edm: (C++: const edm_t &) the constant name, value, and comment - @param bmask: (C++: bmask64_t) bmask of the group to add the constant to - @note: 1. For non-bitmask enum push back constant, BMASK is not used (set it ot - -1), never failed 2. For bitmask enum: - * if VAL and BMASK are not agreed, return TERR_BAD_MSKVAL - * if group with BMASK exists, push back constant to group - * otherwise use constant as bitmask for a new group - @note: ETF_NO_SAVE is ignored - -ida_typeinf.tinfo_t.add_udm (method) - add_udm(self, udm, etf_flags=0, times=1, idx=-1) -> tinfo_code_t - Add a structure/union member. - - @param udm: (C++: const udm_t &) member to add - @param etf_flags: (C++: uint) edit_type() flags flags - @param times: (C++: size_t) how many times to add. if times > 1, the member name will be - appended a suffix like "_2" and so on - @param idx: (C++: ssize_t) the index in the udm array where the new udm should be placed. if - the specified index cannot be honored because it would spoil the udm - sorting order, it is silently ignored. - @note: ETF_NO_SAVE is ignored - -ida_typeinf.tinfo_t.append_covered (method) - append_covered(self, out, offset=0) -> bool - Calculate set of covered bytes for the type - - @param out: (C++: rangeset_t *) pointer to the output buffer. covered bytes will be appended to it. - @param offset: (C++: uint64) delta in bytes to add to all calculations. used internally during - recurion. - -ida_typeinf.tinfo_t.calc_gaps (method) - calc_gaps(self, out) -> bool - Calculate set of padding bytes for the type - - @param out: (C++: rangeset_t *) pointer to the output buffer; old buffer contents will be lost. - -ida_typeinf.tinfo_t.calc_purged_bytes (method) - calc_purged_bytes(self) -> int - -ida_typeinf.tinfo_t.calc_score (method) - calc_score(self) -> uint32 - Calculate the type score (the higher - the nicer is the type) - -ida_typeinf.tinfo_t.calc_udt_aligns (method) - calc_udt_aligns(self, sudt_flags=0x0004) -> bool - Calculate the udt alignments using the field offsets/sizes and the total udt - size This function does not work on typerefs - - @param sudt_flags: (C++: int) - -ida_typeinf.tinfo_t.change_sign (method) - change_sign(self, sign) -> bool - Change the type sign. Works only for the types that may have sign. - - @param sign: (C++: type_sign_t) - -ida_typeinf.tinfo_t.clear (method) - clear(self) - Clear contents of this tinfo, and remove from the type system. - -ida_typeinf.tinfo_t.clr_const (method) - clr_const(self) -> bool - -ida_typeinf.tinfo_t.clr_const_volatile (method) - clr_const_volatile(self) -> bool - -ida_typeinf.tinfo_t.clr_decl_const_volatile (method) - clr_decl_const_volatile(self) - -ida_typeinf.tinfo_t.clr_volatile (method) - clr_volatile(self) -> bool - -ida_typeinf.tinfo_t.compare (method) - compare(self, r) -> int - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.compare_with (method) - compare_with(self, r, tcflags=0) -> bool - Compare two types, based on given flags (see tinfo_t comparison flags) - - @param r: (C++: const tinfo_t &) tinfo_t const & - @param tcflags: (C++: int) - -ida_typeinf.tinfo_t.convert_array_to_ptr (method) - convert_array_to_ptr(self) -> bool - Convert an array into a pointer. type[] => type * - -ida_typeinf.tinfo_t.copy (method) - copy(self) -> tinfo_t - -ida_typeinf.tinfo_t.copy_type (method) - copy_type(self, til, name, ntf_flags=0x0001|0x1000) -> tinfo_code_t - - @param til: til_t * - @param name: char const * - @param ntf_flags: int - -ida_typeinf.tinfo_t.create_array (method) - create_array(self, p, decl_type=BT_ARRAY) -> bool - - @param p: array_type_data_t const & - @param decl_type: type_t - - create_array(self, tif, nelems=0, base=0, decl_type=BT_ARRAY) -> bool - - @param tif: tinfo_t const & - @param nelems: uint32 - @param base: uint32 - @param decl_type: type_t - -ida_typeinf.tinfo_t.create_bitfield (method) - create_bitfield(self, p, decl_type=BT_BITFIELD) -> bool - - @param p: bitfield_type_data_t const & - @param decl_type: type_t - - create_bitfield(self, nbytes, width, is_unsigned=False, decl_type=BT_BITFIELD) -> bool - - @param nbytes: uchar - @param width: uchar - @param is_unsigned: bool - @param decl_type: type_t - -ida_typeinf.tinfo_t.create_enum (method) - create_enum(self, p, decl_type=BTF_ENUM) -> bool - - @param p: enum_type_data_t & - @param decl_type: type_t - -ida_typeinf.tinfo_t.create_forward_decl (method) - create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> tinfo_code_t - Create a forward declaration. decl_type: BTF_STRUCT, BTF_UNION, or BTF_ENUM - - @param til: (C++: til_t *) - @param decl_type: (C++: type_t) - @param name: (C++: const char *) char const * - @param ntf_flags: (C++: int) - -ida_typeinf.tinfo_t.create_func (method) - create_func(self, p, decl_type=BT_FUNC) -> bool - - @param p: func_type_data_t & - @param decl_type: type_t - -ida_typeinf.tinfo_t.create_ptr (method) - create_ptr(self, p, decl_type=BT_PTR) -> bool - - @param p: ptr_type_data_t const & - @param decl_type: type_t - - create_ptr(self, tif, bps=0, decl_type=BT_PTR) -> bool - - @param tif: tinfo_t const & - @param bps: uchar - @param decl_type: type_t - -ida_typeinf.tinfo_t.create_simple_type (method) - create_simple_type(self, decl_type) -> bool - - @param decl_type: type_t - -ida_typeinf.tinfo_t.create_typedef (method) - create_typedef(self, p, decl_type=BTF_TYPEDEF, try_ordinal=True) -> bool - - @param p: typedef_type_data_t const & - @param decl_type: type_t - @param try_ordinal: bool - - create_typedef(self, til, name, decl_type=BTF_TYPEDEF, try_ordinal=True) - - @param til: til_t const * - @param name: char const * - @param decl_type: type_t - @param try_ordinal: bool - - create_typedef(self, til, ord, decl_type=BTF_TYPEDEF) - - @param til: til_t const * - @param ord: uint - @param decl_type: type_t - -ida_typeinf.tinfo_t.create_udt (method) - create_udt(self, p) -> bool - - @param p: udt_type_data_t & - - create_udt(self, p, decl_type) -> bool - - @param p: udt_type_data_t & - @param decl_type: type_t - -ida_typeinf.tinfo_t.del_attr (method) - del_attr(self, key, make_copy=True) -> bool - Del a type attribute. typerefs cannot be modified by this function. - - @param key: (C++: const qstring &) qstring const & - @param make_copy: (C++: bool) - -ida_typeinf.tinfo_t.del_attrs (method) - del_attrs(self) - Del all type attributes. typerefs cannot be modified by this function. - -ida_typeinf.tinfo_t.del_edm (method) - del_edm(self, idx, etf_flags=0) -> tinfo_code_t - - @param idx: size_t - @param etf_flags: uint - -ida_typeinf.tinfo_t.del_edms (method) - del_edms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t - Delete enum members - - @param idx1: (C++: size_t) index in edmvec_t - @param idx2: (C++: size_t) index in edmvec_t or size_t(-1) - @param etf_flags: (C++: uint) etf_flag_t Delete enum members in [idx1, idx2) - @note: For bitmask enum, the first member of a non-trivial group (having 2 or - more members) is considered as a group mask. It is impossible to delete - the group mask of a non-trivial group, other members of the group must be - deleted first. Empty groups are automatically deleted. - -ida_typeinf.tinfo_t.del_udm (method) - del_udm(self, index, etf_flags=0) -> tinfo_code_t - Delete a structure/union member. - - @param index: (C++: size_t) - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.del_udms (method) - del_udms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t - Delete structure/union members in the range [idx1, idx2) - - @param idx1: (C++: size_t) - @param idx2: (C++: size_t) - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.deserialize (method) - deserialize(self, til, ptype, pfields=None, pfldcmts=None, cmt=None) -> bool - Deserialize a type string into a tinfo_t object. - - @param til: (C++: const til_t *) til_t const * - @param ptype: (C++: const qtype *) type_t const ** - @param pfields: (C++: const qtype *) p_list const ** - @param pfldcmts: (C++: const qtype *) p_list const ** - @param cmt: (C++: const char *) char const * - - deserialize(self, til, type, fields, cmts=None) -> bool - - @param til: til_t const * - @param type: type_t const * - @param fields: p_list const * - @param cmts: p_list const * - -ida_typeinf.tinfo_t.dstr (method) - dstr(self) -> char const * - Function to facilitate debugging. - -ida_typeinf.tinfo_t.edit_array (method) - edit_array(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (array_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_bitfield (method) - edit_bitfield(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (bitfield_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_edm (method) - edit_edm(self, idx, value, bmask=bmask64_t(-1), etf_flags=0) -> tinfo_code_t - Change constant value and/or bitmask - - @param idx: (C++: size_t) index in edmvec_t - @param value: (C++: uint64) old or new value - @param bmask: (C++: bmask64_t) old or new bitmask - @note: if new bitmask is specified the index of constant may be changed - -ida_typeinf.tinfo_t.edit_enum (method) - edit_enum(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (enum_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_func (method) - edit_func(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (func_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_ptr (method) - edit_ptr(self, editor, etf_flags=0) -> tinfo_code_t - - @param editor: std::function< tinfo_code_t (ptr_type_data_t *) > const & - @param etf_flags: uint - -ida_typeinf.tinfo_t.edit_udt (method) - edit_udt(self, editor, etf_flags=0) -> tinfo_code_t - Edit udt/enum/func/array/ptr/bitfield. These functions may be used if the - desired functionality is not provided by the STA_... based functions. - - @param editor: (C++: const std::function< tinfo_code_t(udt_type_data_t *)> &) callback to modify the type details; should return true on - success - @param etf_flags: (C++: uint) combination of etf_flag_t constants - -ida_typeinf.tinfo_t.empty (method) - empty(self) -> bool - Was tinfo_t initialized with some type info or not? - -ida_typeinf.tinfo_t.equals_to (method) - equals_to(self, r) -> bool - - @param r: tinfo_t const & - -ida_typeinf.tinfo_t.expand_udt (method) - expand_udt(self, idx, delta, etf_flags=0) -> tinfo_code_t - Expand/shtrink a structure by adding/removing a gap before the specified member. - - @param idx: (C++: size_t) index of the member - @param delta: (C++: adiff_t) number of bytes to add or remove - @param etf_flags: (C++: uint) etf_flag_t Please note that it is impossible to add a gap at - the very end of a structure. However, adding before a regular - member is possible. This function can be used to remove gaps - in the middle of a structure by specifying a negative delta - value. - -ida_typeinf.tinfo_t.find_edm (method) - find_edm(self, edm, value, bmask=bmask64_t(-1), serial=0) -> tinfo_code_t - Find enum member - - @param edm: (C++: edm_t *) enum type member - @param value: uint64 - @param bmask: bmask64_t - find_edm(self, edm, name) -> tinfo_code_t - - @param edm: edm_t * - @param name: char const * - -ida_typeinf.tinfo_t.find_udm (method) - find_udm(self, udm, strmem_flags) -> int - BTF_STRUCT,BTF_UNION: Find a udt member. - * at the specified offset (STRMEM_OFFSET) - * with the specified index (STRMEM_INDEX) - * with the specified type (STRMEM_TYPE) - * with the specified name (STRMEM_NAME) - - @param udm: (C++: struct udm_t *) udm_t * - @param strmem_flags: (C++: int) - @return: the index of the found member or -1 - -ida_typeinf.tinfo_t.force_tid (method) - force_tid(self) -> tid_t - Get the type tid. Create if it does not exist yet. If the type comes from a base - til, the type will be copied to the local til and a new tid will be created for - it. (if the type comes from a base til, it does not have a tid yet). If the type - comes from the local til, this function is equivalent to get_tid() - - @return: tid or BADADDR - -ida_typeinf.tinfo_t.get_alias_target (method) - get_alias_target(self) -> uint32 - Get type alias If the type has no alias, return 0. - -ida_typeinf.tinfo_t.get_array_details (method) - get_array_details(self, ai) -> bool - Get the array specific info. - - @param ai: (C++: array_type_data_t *) - -ida_typeinf.tinfo_t.get_array_element (method) - get_array_element(self) -> tinfo_t - -ida_typeinf.tinfo_t.get_array_nelems (method) - get_array_nelems(self) -> int - -ida_typeinf.tinfo_t.get_attr (method) - get_attr(self, key, all_attrs=True) -> str or None - Get a type attribute. - - @param key: (C++: const qstring &) qstring const & - @param all_attrs: (C++: bool) - -ida_typeinf.tinfo_t.get_attrs (method) - get_attrs(self, tav, all_attrs=False) -> bool - Get type attributes (all_attrs: include attributes of referenced types, if any) - - @param tav: (C++: type_attrs_t *) - @param all_attrs: (C++: bool) - -ida_typeinf.tinfo_t.get_bit_buckets (method) - get_bit_buckets(self, buckets) -> bool - ::BT_STRUCT: get bit buckets Bit buckets are used to layout bitfields - - @param buckets: (C++: range64vec_t *) - @return: false if wrong type was passed - -ida_typeinf.tinfo_t.get_bitfield_details (method) - get_bitfield_details(self, bi) -> bool - Get the bitfield specific info. - - @param bi: (C++: bitfield_type_data_t *) - -ida_typeinf.tinfo_t.get_declalign (method) - get_declalign(self) -> uchar - Get declared alignment of the type. - -ida_typeinf.tinfo_t.get_decltype (method) - get_decltype(self) -> type_t - Get declared type (without resolving type references; they are returned as is). - Obviously this is a very fast function and should be used instead of - get_realtype() if possible. Please note that for typerefs this function will - return BTF_TYPEDEF. To determine if a typeref is a typedef, use is_typedef() - -ida_typeinf.tinfo_t.get_edm (method) - get_edm(self, edm, idx) -> tinfo_code_t - Get enum member - - @param edm: (C++: edm_t *) enum type member - @param idx: (C++: size_t) enum member index - -ida_typeinf.tinfo_t.get_edm_by_tid (method) - get_edm_by_tid(self, edm, tid) -> ssize_t - - @param edm: edm_t * - @param tid: tid_t - -ida_typeinf.tinfo_t.get_enum_base_type (method) - get_enum_base_type(self) -> type_t - Get enum base type (convert enum to integer type) Returns BT_UNK if failed to - convert - -ida_typeinf.tinfo_t.get_enum_details (method) - get_enum_details(self, ei) -> bool - Get the enum specific info. - - @param ei: (C++: enum_type_data_t *) - -ida_typeinf.tinfo_t.get_enum_radix (method) - get_enum_radix(self) -> int - Get enum constant radix - - @return: radix or 1 for BTE_CHAR enum_type_data_t::get_enum_radix() - -ida_typeinf.tinfo_t.get_final_element (method) - get_final_element(self) -> tinfo_t - repeat recursively: if an array, return the type of its element; else return the - type itself. - -ida_typeinf.tinfo_t.get_final_ordinal (method) - get_final_ordinal(self) -> uint32 - Get final type ordinal (0 if none) - -ida_typeinf.tinfo_t.get_final_type_name (method) - get_final_type_name(self) -> bool - Use in the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn). - - @return: the name of the last type in the chain (TYPEn). if there is no chain, - returns TYPE1 - -ida_typeinf.tinfo_t.get_forward_type (method) - get_forward_type(self) -> type_t - Get type of a forward declaration. For a forward declaration this function - returns its base type. In other cases it returns BT_UNK - -ida_typeinf.tinfo_t.get_func_details (method) - get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool - Get only the function specific info for this tinfo_t. - - @param fi: (C++: func_type_data_t *) - @param gtd: (C++: gtd_func_t) enum gtd_func_t - -ida_typeinf.tinfo_t.get_innermost_udm (method) - get_innermost_udm(self, bitoffset) -> tinfo_t - Get the innermost member at the given offset - - @param bitoffset: (C++: uint64) bit offset into the structure - @retval udt: with the innermost member - @retval empty: type if it is not a struct type or OFFSET could not be found - -ida_typeinf.tinfo_t.get_methods (method) - get_methods(self, methods) -> bool - - @param BT_COMPLEX: get a list of member functions declared in this udt. - @return: false if no member functions exist - -ida_typeinf.tinfo_t.get_modifiers (method) - get_modifiers(self) -> type_t - -ida_typeinf.tinfo_t.get_named_type (method) - get_named_type(self, til, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool - Create a tinfo_t object for an existing named type. - - @param til: (C++: const til_t *) type library to use - @param name: (C++: const char *) name of the type to link to - @param decl_type: (C++: type_t) if the reference was explicitly specified with the type tag - (BTF_STRUCT/BTF_UNION/BTF_ENUM) you may specify it. - the kernel will accept only the specified tag after resolving - the type. If the resolved type does not correspond to the - explicitly specified tag, the type will be considered as undefined - @param resolve: (C++: bool) true: immediately resolve the type and return success code. - @param try_ordinal: (C++: bool) true: try to replace name reference by an ordinal reference - -ida_typeinf.tinfo_t.get_nargs (method) - get_nargs(self) -> int - BT_FUNC or BT_PTR BT_FUNC: Calculate number of arguments (-1 - error) - -ida_typeinf.tinfo_t.get_next_type_name (method) - get_next_type_name(self) -> bool - Use In the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn). - - @return: the name of the next type in the chain (TYPE2). if there is no chain, - returns failure - -ida_typeinf.tinfo_t.get_nice_type_name (method) - get_nice_type_name(self) -> bool - Get the beautified type name. Get the referenced name and apply regular - expressions from goodname.cfg to beautify the name - -ida_typeinf.tinfo_t.get_nth_arg (method) - get_nth_arg(self, n) -> tinfo_t - BT_FUNC or BT_PTR BT_FUNC: Get type of n-th arg (-1 means return type, see - get_rettype()) - - @param n: (C++: int) - -ida_typeinf.tinfo_t.get_numbered_type (method) - get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool - Create a tinfo_t object for an existing ordinal type. - - @param til: (C++: const til_t *) type library to use - @param ordinal: (C++: uint32) number of the type to link to - @param decl_type: (C++: type_t) if the reference was explicitly specified with the type tag - (BTF_STRUCT/BTF_UNION/BTF_ENUM) you may specify it. the kernel - will accept only the specified tag after resolving the type. - If the resolved type does not correspond to the explicitly - specified tag, the type will be considered as undefined - @param resolve: (C++: bool) true: immediately resolve the type and return success code - -ida_typeinf.tinfo_t.get_onemember_type (method) - get_onemember_type(self) -> tinfo_t - For objects consisting of one member entirely: return type of the member. - -ida_typeinf.tinfo_t.get_ordinal (method) - get_ordinal(self) -> uint32 - Get type ordinal (only if the type was created as a numbered type, 0 if none) - -ida_typeinf.tinfo_t.get_pointed_object (method) - get_pointed_object(self) -> tinfo_t - -ida_typeinf.tinfo_t.get_ptr_details (method) - get_ptr_details(self, pi) -> bool - Get the pointer info. - - @param pi: (C++: ptr_type_data_t *) - -ida_typeinf.tinfo_t.get_ptrarr_object (method) - get_ptrarr_object(self) -> tinfo_t - BT_PTR & BT_ARRAY: get the pointed object or array element. If the current type - is not a pointer or array, return empty type info. - -ida_typeinf.tinfo_t.get_ptrarr_objsize (method) - get_ptrarr_objsize(self) -> int - BT_PTR & BT_ARRAY: get size of pointed object or array element. On error returns - -1 - -ida_typeinf.tinfo_t.get_realtype (method) - get_realtype(self, full=False) -> type_t - Get the resolved base type. Deserialization options: - * if full=true, the referenced type will be deserialized fully, this may not - always be desirable (slows down things) - * if full=false, we just return the base type, the referenced type will be - resolved again later if necessary (this may lead to multiple resolvings of the - same type) imho full=false is a better approach because it does not perform - unnecessary actions just in case. however, in some cases the caller knows that - it is very likely that full type info will be required. in those cases full=true - makes sense - - @param full: (C++: bool) - -ida_typeinf.tinfo_t.get_rettype (method) - get_rettype(self) -> tinfo_t - BT_FUNC or BT_PTR BT_FUNC: Get the function's return type - -ida_typeinf.tinfo_t.get_sign (method) - get_sign(self) -> type_sign_t - Get type sign. - -ida_typeinf.tinfo_t.get_size (method) - get_size(self, p_effalign=None, gts_code=0) -> size_t - Get the type size in bytes. - - @param p_effalign: (C++: uint32 *) buffer for the alignment value - @param gts_code: (C++: int) combination of GTS_... constants - @return: BADSIZE in case of problems - -ida_typeinf.tinfo_t.get_stock (method) - get_stock(id) -> tinfo_t - Get stock type information. This function can be used to get tinfo_t for some - common types. The same tinfo_t will be returned for the same id, thus saving - memory and increasing the speed Please note that retrieving the STI_SIZE_T or - STI_SSIZE_T stock type, will also have the side-effect of adding that type to - the 'idati' TIL, under the well-known name 'size_t' or 'ssize_t' (respectively). - The same is valid for STI_COMPLEX64 and STI_COMPLEX64 stock types with names - 'complex64_t' and 'complex128_t' (respectively). - - @param id: (C++: stock_type_id_t) enum stock_type_id_t - -ida_typeinf.tinfo_t.get_tid (method) - get_tid(self) -> tid_t - Get the type tid Each type in the local type library has a so-called `tid` - associated with it. The tid is used to collect xrefs to the type. The tid is - created when the type is created in the local type library and does not change - afterwards. It can be passed to xref-related functions instead of the address. - - @return: tid or BADADDR - @note: types that do not come from a type library (that exist only in the - memory) can not have a tid. - -ida_typeinf.tinfo_t.get_til (method) - get_til(self) -> til_t - Get the type library for tinfo_t. - -ida_typeinf.tinfo_t.get_type_by_edm_name (method) - get_type_by_edm_name(self, mname, til=None) -> bool - Retrieve enum tinfo using enum member name - - @param mname: (C++: const char *) enum type member name - @param til: (C++: til_t *) type library - @return: success If the function fails, THIS object becomes empty. - -ida_typeinf.tinfo_t.get_type_by_tid (method) - get_type_by_tid(self, tid) -> bool - - @param tid: tid_t - -ida_typeinf.tinfo_t.get_type_cmt (method) - get_type_cmt(self) -> int - Get type comment - - @return: 0-failed, 1-returned regular comment, 2-returned repeatable comment - -ida_typeinf.tinfo_t.get_type_name (method) - get_type_name(self) -> bool - Does a type refer to a name?. If yes, fill the provided buffer with the type - name and return true. Names are returned for numbered types too: either a user- - defined nice name or, if a user-provided name does not exist, an ordinal name - (like #xx, see create_numbered_type_name()). - -ida_typeinf.tinfo_t.get_type_rptcmt (method) - get_type_rptcmt(self) -> bool - Get type comment only if it is repeatable. - -ida_typeinf.tinfo_t.get_udm_by_tid (method) - get_udm_by_tid(self, udm, tid) -> ssize_t - Retrive tinfo using type TID or struct/enum member MID - - @param udm: (C++: udm_t *) [out]: place to save the found member to, may be nullptr - @param tid: (C++: tid_t) tid can denote a type tid or a member tid. - @return: if a member tid was specified, returns the member index, otherwise - returns -1. if the function fails, THIS object becomes empty. - -ida_typeinf.tinfo_t.get_udm_tid (method) - get_udm_tid(self, idx) -> tid_t - Get udt member TID - - @param idx: (C++: size_t) the index of udt the member - @return: tid or BADADDR The tid is used to collect xrefs to the member, it can - be passed to xref-related functions instead of the address. - -ida_typeinf.tinfo_t.get_udt_details (method) - get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool - Get the udt specific info. - - @param udt: (C++: udt_type_data_t *) - @param gtd: (C++: gtd_udt_t) enum gtd_udt_t - -ida_typeinf.tinfo_t.get_udt_nmembers (method) - get_udt_nmembers(self) -> int - Get number of udt members. -1-error. - -ida_typeinf.tinfo_t.get_unpadded_size (method) - get_unpadded_size(self) -> size_t - Get the type size in bytes without the final padding, in bytes. For some UDTs - get_unpadded_size() != get_size() - -ida_typeinf.tinfo_t.has_details (method) - has_details(self) -> bool - Does this type refer to a nontrivial type? - -ida_typeinf.tinfo_t.has_union (method) - has_union(self) -> bool - Has a member of type "union"? - -ida_typeinf.tinfo_t.has_vftable (method) - has_vftable(self) -> bool - Has a vftable? - -ida_typeinf.tinfo_t.is_aliased (method) - is_aliased(self) -> bool - -ida_typeinf.tinfo_t.is_anonymous_udt (method) - is_anonymous_udt(self) -> bool - Is an anonymous struct/union? We assume that types with names are anonymous if - the name starts with $ - -ida_typeinf.tinfo_t.is_arithmetic (method) - is_arithmetic(self) -> bool - is_type_arithmetic(get_realtype()) - -ida_typeinf.tinfo_t.is_array (method) - is_array(self) -> bool - is_type_array(get_realtype()) - -ida_typeinf.tinfo_t.is_bitfield (method) - is_bitfield(self) -> bool - is_type_bitfld(get_realtype()) - -ida_typeinf.tinfo_t.is_bitmask_enum (method) - is_bitmask_enum(self) -> bool - Is bitmask enum? - - @return: true for bitmask enum and false in other cases - enum_type_data_t::is_bf() - -ida_typeinf.tinfo_t.is_bool (method) - is_bool(self) -> bool - is_type_bool(get_realtype()) - -ida_typeinf.tinfo_t.is_castable_to (method) - is_castable_to(self, target) -> bool - - @param target: tinfo_t const & - -ida_typeinf.tinfo_t.is_char (method) - is_char(self) -> bool - is_type_char(get_realtype()) - -ida_typeinf.tinfo_t.is_complex (method) - is_complex(self) -> bool - is_type_complex(get_realtype()) - -ida_typeinf.tinfo_t.is_const (method) - is_const(self) -> bool - is_type_const(get_realtype()) - -ida_typeinf.tinfo_t.is_correct (method) - is_correct(self) -> bool - Is the type object correct?. It is possible to create incorrect types. For - example, we can define a function that returns an enum and then delete the enum - type. If this function returns false, the type should not be used in - disassembly. Please note that this function does not verify all involved types: - for example, pointers to undefined types are permitted. - -ida_typeinf.tinfo_t.is_decl_array (method) - is_decl_array(self) -> bool - is_type_array(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_bitfield (method) - is_decl_bitfield(self) -> bool - is_type_bitfld(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_bool (method) - is_decl_bool(self) -> bool - is_type_bool(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_char (method) - is_decl_char(self) -> bool - is_type_char(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_complex (method) - is_decl_complex(self) -> bool - is_type_complex(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_const (method) - is_decl_const(self) -> bool - is_type_const(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_double (method) - is_decl_double(self) -> bool - is_type_double(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_enum (method) - is_decl_enum(self) -> bool - is_type_enum(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_float (method) - is_decl_float(self) -> bool - is_type_float(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_floating (method) - is_decl_floating(self) -> bool - is_type_floating(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_func (method) - is_decl_func(self) -> bool - is_type_func(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_int (method) - is_decl_int(self) -> bool - is_type_int(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_int128 (method) - is_decl_int128(self) -> bool - is_type_int128(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_int16 (method) - is_decl_int16(self) -> bool - is_type_int16(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_int32 (method) - is_decl_int32(self) -> bool - is_type_int32(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_int64 (method) - is_decl_int64(self) -> bool - is_type_int64(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_last (method) - is_decl_last(self) -> bool - is_typeid_last(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_ldouble (method) - is_decl_ldouble(self) -> bool - is_type_ldouble(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_paf (method) - is_decl_paf(self) -> bool - is_type_paf(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_partial (method) - is_decl_partial(self) -> bool - is_type_partial(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_ptr (method) - is_decl_ptr(self) -> bool - is_type_ptr(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_struct (method) - is_decl_struct(self) -> bool - is_type_struct(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_sue (method) - is_decl_sue(self) -> bool - is_type_sue(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_tbyte (method) - is_decl_tbyte(self) -> bool - is_type_tbyte(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_typedef (method) - is_decl_typedef(self) -> bool - is_type_typedef(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_uchar (method) - is_decl_uchar(self) -> bool - is_type_uchar(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_udt (method) - is_decl_udt(self) -> bool - is_type_struni(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_uint (method) - is_decl_uint(self) -> bool - is_type_uint(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_uint128 (method) - is_decl_uint128(self) -> bool - is_type_uint128(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_uint16 (method) - is_decl_uint16(self) -> bool - is_type_uint16(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_uint32 (method) - is_decl_uint32(self) -> bool - is_type_uint32(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_uint64 (method) - is_decl_uint64(self) -> bool - is_type_uint64(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_union (method) - is_decl_union(self) -> bool - is_type_union(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_unknown (method) - is_decl_unknown(self) -> bool - is_type_unknown(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_void (method) - is_decl_void(self) -> bool - is_type_void(get_decltype()) - -ida_typeinf.tinfo_t.is_decl_volatile (method) - is_decl_volatile(self) -> bool - is_type_volatile(get_decltype()) - -ida_typeinf.tinfo_t.is_double (method) - is_double(self) -> bool - is_type_double(get_realtype()) - -ida_typeinf.tinfo_t.is_empty_udt (method) - is_empty_udt(self) -> bool - Is an empty struct/union? (has no fields) - -ida_typeinf.tinfo_t.is_enum (method) - is_enum(self) -> bool - is_type_enum(get_realtype()) - -ida_typeinf.tinfo_t.is_ext_arithmetic (method) - is_ext_arithmetic(self) -> bool - is_type_ext_arithmetic(get_realtype()) - -ida_typeinf.tinfo_t.is_ext_integral (method) - is_ext_integral(self) -> bool - is_type_ext_integral(get_realtype()) - -ida_typeinf.tinfo_t.is_float (method) - is_float(self) -> bool - is_type_float(get_realtype()) - -ida_typeinf.tinfo_t.is_floating (method) - is_floating(self) -> bool - is_type_floating(get_realtype()) - -ida_typeinf.tinfo_t.is_forward_decl (method) - is_forward_decl(self) -> bool - Is this a forward declaration?. Forward declarations are placeholders: the type - definition does not exist - -ida_typeinf.tinfo_t.is_forward_enum (method) - is_forward_enum(self) -> bool - -ida_typeinf.tinfo_t.is_forward_struct (method) - is_forward_struct(self) -> bool - -ida_typeinf.tinfo_t.is_forward_union (method) - is_forward_union(self) -> bool - -ida_typeinf.tinfo_t.is_from_subtil (method) - is_from_subtil(self) -> bool - Was the named type found in some base type library (not the top level type - library)?. If yes, it usually means that the type comes from some loaded type - library, not the local type library for the database - -ida_typeinf.tinfo_t.is_func (method) - is_func(self) -> bool - is_type_func(get_realtype()) - -ida_typeinf.tinfo_t.is_funcptr (method) - is_funcptr(self) -> bool - Is this pointer to a function? - -ida_typeinf.tinfo_t.is_high_func (method) - is_high_func(self) -> bool - -ida_typeinf.tinfo_t.is_int (method) - is_int(self) -> bool - is_type_int(get_realtype()) - -ida_typeinf.tinfo_t.is_int128 (method) - is_int128(self) -> bool - is_type_int128(get_realtype()) - -ida_typeinf.tinfo_t.is_int16 (method) - is_int16(self) -> bool - is_type_int16(get_realtype()) - -ida_typeinf.tinfo_t.is_int32 (method) - is_int32(self) -> bool - is_type_int32(get_realtype()) - -ida_typeinf.tinfo_t.is_int64 (method) - is_int64(self) -> bool - is_type_int64(get_realtype()) - -ida_typeinf.tinfo_t.is_integral (method) - is_integral(self) -> bool - is_type_integral(get_realtype()) - -ida_typeinf.tinfo_t.is_ldouble (method) - is_ldouble(self) -> bool - is_type_ldouble(get_realtype()) - -ida_typeinf.tinfo_t.is_manually_castable_to (method) - is_manually_castable_to(self, target) -> bool - - @param target: tinfo_t const & - -ida_typeinf.tinfo_t.is_one_fpval (method) - is_one_fpval(self) -> bool - Floating value or an object consisting of one floating member entirely. - -ida_typeinf.tinfo_t.is_paf (method) - is_paf(self) -> bool - is_type_paf(get_realtype()) - -ida_typeinf.tinfo_t.is_partial (method) - is_partial(self) -> bool - is_type_partial(get_realtype()) - -ida_typeinf.tinfo_t.is_ptr (method) - is_ptr(self) -> bool - is_type_ptr(get_realtype()) - -ida_typeinf.tinfo_t.is_ptr_or_array (method) - is_ptr_or_array(self) -> bool - is_type_ptr_or_array(get_realtype()) - -ida_typeinf.tinfo_t.is_purging_cc (method) - is_purging_cc(self) -> bool - is_purging_cc(get_cc()) - -ida_typeinf.tinfo_t.is_pvoid (method) - is_pvoid(self) -> bool - Is "void *"?. This function does not check the pointer attributes and type - modifiers. - -ida_typeinf.tinfo_t.is_scalar (method) - is_scalar(self) -> bool - Does the type represent a single number? - -ida_typeinf.tinfo_t.is_shifted_ptr (method) - is_shifted_ptr(self) -> bool - Is a shifted pointer? - -ida_typeinf.tinfo_t.is_signed (method) - is_signed(self) -> bool - Is this a signed type? - -ida_typeinf.tinfo_t.is_small_udt (method) - is_small_udt(self) -> bool - Is a small udt? (can fit a register or a pair of registers) - -ida_typeinf.tinfo_t.is_sse_type (method) - is_sse_type(self) -> bool - Is a SSE vector type? - -ida_typeinf.tinfo_t.is_struct (method) - is_struct(self) -> bool - is_type_struct(get_realtype()) - -ida_typeinf.tinfo_t.is_sue (method) - is_sue(self) -> bool - is_type_sue(get_realtype()) - -ida_typeinf.tinfo_t.is_tbyte (method) - is_tbyte(self) -> bool - is_type_tbyte(get_realtype()) - -ida_typeinf.tinfo_t.is_typedef (method) - is_typedef(self) -> bool - Is this a typedef?. This function will return true for a reference to a local - type that is declared as a typedef. - -ida_typeinf.tinfo_t.is_typeref (method) - is_typeref(self) -> bool - Is this type a type reference?. - -ida_typeinf.tinfo_t.is_uchar (method) - is_uchar(self) -> bool - is_type_uchar(get_realtype()) - -ida_typeinf.tinfo_t.is_udt (method) - is_udt(self) -> bool - is_type_struni(get_realtype()) - -ida_typeinf.tinfo_t.is_uint (method) - is_uint(self) -> bool - is_type_uint(get_realtype()) - -ida_typeinf.tinfo_t.is_uint128 (method) - is_uint128(self) -> bool - is_type_uint128(get_realtype()) - -ida_typeinf.tinfo_t.is_uint16 (method) - is_uint16(self) -> bool - is_type_uint16(get_realtype()) - -ida_typeinf.tinfo_t.is_uint32 (method) - is_uint32(self) -> bool - is_type_uint32(get_realtype()) - -ida_typeinf.tinfo_t.is_uint64 (method) - is_uint64(self) -> bool - is_type_uint64(get_realtype()) - -ida_typeinf.tinfo_t.is_union (method) - is_union(self) -> bool - is_type_union(get_realtype()) - -ida_typeinf.tinfo_t.is_unknown (method) - is_unknown(self) -> bool - is_type_unknown(get_realtype()) - -ida_typeinf.tinfo_t.is_unsigned (method) - is_unsigned(self) -> bool - Is this an unsigned type? - -ida_typeinf.tinfo_t.is_user_cc (method) - is_user_cc(self) -> bool - is_user_cc(get_cc()) - -ida_typeinf.tinfo_t.is_vararg_cc (method) - is_vararg_cc(self) -> bool - is_vararg_cc(get_cc()) - -ida_typeinf.tinfo_t.is_varmember (method) - is_varmember(self) -> bool - Can the type be of a variable struct member? This function checks for: - is_array() && array.nelems==0 Such a member can be only the very last member of - a structure - -ida_typeinf.tinfo_t.is_varstruct (method) - is_varstruct(self) -> bool - Is a variable-size structure? - -ida_typeinf.tinfo_t.is_vftable (method) - is_vftable(self) -> bool - Is a vftable type? - -ida_typeinf.tinfo_t.is_void (method) - is_void(self) -> bool - is_type_void(get_realtype()) - -ida_typeinf.tinfo_t.is_volatile (method) - is_volatile(self) -> bool - is_type_volatile(get_realtype()) - -ida_typeinf.tinfo_t.is_well_defined (method) - is_well_defined(self) -> bool - !(empty()) && !(is_decl_partial()) - -ida_typeinf.tinfo_t.parse (method) - parse(self, decl, til=None, pt_flags=0) -> bool - Convenience function to parse a string with a type declaration - - @param decl: (C++: const char *) a type declaration - @param til: (C++: til_t *) type library to use - @param pt_flags: (C++: int) combination of Type parsing flags bits - -ida_typeinf.tinfo_t.present (method) - present(self) -> bool - Is the type really present? (not a reference to a missing type, for example) - -ida_typeinf.tinfo_t.read_bitfield_value (method) - read_bitfield_value(self, v, bitoff) -> uint64 - - @param v: uint64 - @param bitoff: int - -ida_typeinf.tinfo_t.remove_ptr_or_array (method) - remove_ptr_or_array(self) -> bool - Replace the current type with the ptr obj or array element. This function - performs one of the following conversions: - * type[] => type - * type* => type If the conversion is performed successfully, return true - -ida_typeinf.tinfo_t.rename_edm (method) - rename_edm(self, idx, name, etf_flags=0) -> tinfo_code_t - Rename a enum member - - @param idx: (C++: size_t) index in edmvec_t - @param name: (C++: const char *) new name - @param etf_flags: (C++: uint) etf_flag_t ETF_FORCENAME may be used in case of - TERR_ALIEN_NAME - @note: ETF_NO_SAVE is ignored - -ida_typeinf.tinfo_t.rename_type (method) - rename_type(self, name, ntf_flags=0) -> tinfo_code_t - Rename a type - - @param name: (C++: const char *) new type name - @param ntf_flags: (C++: int) Flags for named types - @note: The change is saved immediately - -ida_typeinf.tinfo_t.rename_udm (method) - rename_udm(self, index, name, etf_flags=0) -> tinfo_code_t - Rename a structure/union member. The new name must be unique. - @note: ETF_NO_SAVE is ignored - - @param index: (C++: size_t) - @param name: (C++: const char *) char const * - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.requires_qualifier (method) - requires_qualifier(self, name, offset) -> bool - Requires full qualifier? (name is not unique) - - @param name: (C++: const char *) field name - @param offset: (C++: uint64) field offset in bits - @return: if the name is not unique, returns true - -ida_typeinf.tinfo_t.save_type (method) - save_type(self, ntf_flags=0x0001|0x0004) -> tinfo_code_t - - @param ntf_flags: int - -ida_typeinf.tinfo_t.serialize (method) - serialize(self, sudt_flags=SUDT_FAST|SUDT_TRUNC) -> (bytes, NoneType, NoneType), (bytes, bytes, NoneType) - Serialize tinfo_t object into a type string. - - @param sudt_flags: (C++: int) - -ida_typeinf.tinfo_t.set_attr (method) - set_attr(self, ta, may_overwrite=True) -> bool - Set a type attribute. If necessary, a new typid will be created. - - @param ta: (C++: const type_attr_t &) type_attr_t const & - @param may_overwrite: (C++: bool) - -ida_typeinf.tinfo_t.set_attrs (method) - set_attrs(self, tav) -> bool - Set type attributes. If necessary, a new typid will be created. this function - modifies tav! (returns old attributes, if any) - - @param tav: (C++: type_attrs_t *) - @return: false: bad attributes - -ida_typeinf.tinfo_t.set_const (method) - set_const(self) - -ida_typeinf.tinfo_t.set_declalign (method) - set_declalign(self, declalign) -> bool - - @param declalign: uchar - -ida_typeinf.tinfo_t.set_edm_cmt (method) - set_edm_cmt(self, idx, cmt, etf_flags=0) -> tinfo_code_t - Set a comment for an enum member. Such comments are always considered as - repeatable. - - @param idx: (C++: size_t) index in edmvec_t - @param cmt: (C++: const char *) comment - @param etf_flags: (C++: uint) etf_flag_t - -ida_typeinf.tinfo_t.set_enum_is_bitmask (method) - set_enum_is_bitmask(self, stance=ENUMBM_ON, etf_flags=0) -> tinfo_code_t - - @param stance: enum tinfo_t::bitmask_cvt_stance_t - @param etf_flags: uint - -ida_typeinf.tinfo_t.set_enum_repr (method) - set_enum_repr(self, repr, etf_flags=0) -> tinfo_code_t - Set the representation of enum members. - - @param repr: (C++: const value_repr_t &) value_repr_t - @param etf_flags: (C++: uint) etf_flag_t - -ida_typeinf.tinfo_t.set_enum_sign (method) - set_enum_sign(self, sign, etf_flags=0) -> tinfo_code_t - Set enum sign - - @param sign: (C++: type_sign_t) - @param etf_flags: (C++: uint) etf_flag_t - -ida_typeinf.tinfo_t.set_enum_width (method) - set_enum_width(self, nbytes, etf_flags=0) -> tinfo_code_t - Set the width of enum base type - - @param nbytes: (C++: int) width of enum base type, allowed values: 0 - (unspecified),1,2,4,8,16,32,64 - @param etf_flags: (C++: uint) etf_flag_t - -ida_typeinf.tinfo_t.set_methods (method) - set_methods(self, methods) -> bool - - @param BT_COMPLEX: set the list of member functions. This function consumes 'methods' - (makes it empty). - @return: false if this type is not a udt, or if the given list is empty - -ida_typeinf.tinfo_t.set_modifiers (method) - set_modifiers(self, mod) - - @param mod: type_t - -ida_typeinf.tinfo_t.set_named_type (method) - set_named_type(self, til, name, ntf_flags=0) -> tinfo_code_t - - @param til: til_t * - @param name: char const * - @param ntf_flags: int - -ida_typeinf.tinfo_t.set_numbered_type (method) - set_numbered_type(self, til, ord, ntf_flags=0, name=None) -> tinfo_code_t - - @param til: til_t * - @param ord: uint32 - @param ntf_flags: int - @param name: char const * - -ida_typeinf.tinfo_t.set_symbol_type (method) - set_symbol_type(self, til, name, ntf_flags=0) -> tinfo_code_t - - @param til: til_t * - @param name: char const * - @param ntf_flags: int - -ida_typeinf.tinfo_t.set_type_alias (method) - set_type_alias(self, dest_ord) -> bool - Set type alias Redirects all references to source type to the destination type. - This is equivalent to instantaneous replacement all references to srctype by - dsttype. - - @param dest_ord: (C++: uint32) - -ida_typeinf.tinfo_t.set_type_alignment (method) - set_type_alignment(self, declalign, etf_flags=0) -> tinfo_code_t - Set type alignment. - - @param declalign: (C++: uchar) - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.set_type_cmt (method) - set_type_cmt(self, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t - Set type comment This function works only for non-trivial types - - @param cmt: (C++: const char *) char const * - @param is_regcmt: (C++: bool) - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.set_udm_cmt (method) - set_udm_cmt(self, index, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t - Set a comment for a structure/union member. A member may have just one comment, - and it is either repeatable or regular. - - @param index: (C++: size_t) - @param cmt: (C++: const char *) char const * - @param is_regcmt: (C++: bool) - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.set_udm_repr (method) - set_udm_repr(self, index, repr, etf_flags=0) -> tinfo_code_t - Set the representation of a structure/union member. - - @param index: (C++: size_t) - @param repr: (C++: const value_repr_t &) value_repr_t const & - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.set_udm_type (method) - set_udm_type(self, index, tif, etf_flags=0, repr=None) -> tinfo_code_t - Set type of a structure/union member. - - @param index: (C++: size_t) member index in the udm array - @param tif: (C++: const tinfo_t &) new type for the member - @param etf_flags: (C++: uint) etf_flag_t - @param repr: (C++: const value_repr_t *) new representation for the member (optional) - @return: tinfo_code_t - -ida_typeinf.tinfo_t.set_udt_alignment (method) - set_udt_alignment(self, sda, etf_flags=0) -> tinfo_code_t - Set declared structure alignment (sda) This alignment supersedes the alignment - returned by get_declalign() and is really used when calculating the struct - layout. However, the effective structure alignment may differ from `sda` because - of packing. The type editing functions (they accept etf_flags) may overwrite - this attribute. - - @param sda: (C++: int) - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.set_udt_pack (method) - set_udt_pack(self, pack, etf_flags=0) -> tinfo_code_t - Set structure packing. The value controls how little a structure member - alignment can be. Example: if pack=1, then it is possible to align a double to a - byte. __attribute__((aligned(1))) double x; However, if pack=3, a double will be - aligned to 8 (2**3) even if requested to be aligned to a byte. pack==0 will have - the same effect. The type editing functions (they accept etf_flags) may - overwrite this attribute. - - @param pack: (C++: int) - @param etf_flags: (C++: uint) - -ida_typeinf.tinfo_t.set_volatile (method) - set_volatile(self) - -ida_typeinf.tinfo_t.swap (method) - swap(self, r) - Assign this = r and r = this. - - @param r: (C++: tinfo_t &) - -ida_typeinf.tinfo_t.write_bitfield_value (method) - write_bitfield_value(self, dst, v, bitoff) -> uint64 - - @param dst: uint64 - @param v: uint64 - @param bitoff: int - -ida_typeinf.tinfo_t_get_stock (function) - tinfo_t_get_stock(id) -> tinfo_t - - @param id: enum stock_type_id_t - -ida_typeinf.tinfo_visitor_t (class) - Proxy of C++ tinfo_visitor_t class. - -ida_typeinf.tinfo_visitor_t.__disown__ (method) - -ida_typeinf.tinfo_visitor_t.__init__ (method) - __init__(self, s=0) -> tinfo_visitor_t - - @param s: int - -ida_typeinf.tinfo_visitor_t.apply_to (method) - apply_to(self, tif, out=None, name=None, cmt=None) -> int - Call this function to initiate the traversal. - - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param out: (C++: type_mods_t *) - @param name: (C++: const char *) char const * - @param cmt: (C++: const char *) char const * - -ida_typeinf.tinfo_visitor_t.prune_now (method) - prune_now(self) - To refuse to visit children of the current type, use this: - -ida_typeinf.tinfo_visitor_t.state (variable) - tinfo visitor states - -ida_typeinf.tinfo_visitor_t.visit_type (method) - visit_type(self, out, tif, name, cmt) -> int - Visit a subtype. this function must be implemented in the derived class. it may - optionally fill out with the new type info. this can be used to modify types (in - this case the 'out' argument of apply_to() may not be nullptr) return 0 to - continue the traversal. return !=0 to stop the traversal. - - @param out: (C++: type_mods_t *) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param name: (C++: const char *) char const * - @param cmt: (C++: const char *) char const * - -ida_typeinf.type_attr_t (class) - Proxy of C++ type_attr_t class. - -ida_typeinf.type_attr_t.__ge__ (method) - __ge__(self, r) -> bool - - @param r: type_attr_t const & - -ida_typeinf.type_attr_t.__init__ (method) - __init__(self) -> type_attr_t - -ida_typeinf.type_attr_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: type_attr_t const & - -ida_typeinf.type_attr_t.key (variable) - one symbol keys are reserved to be used by the kernel the ones starting with an - underscore are reserved too - -ida_typeinf.type_attr_t.value (variable) - attribute bytes - -ida_typeinf.type_attrs_t (class) - Proxy of C++ qvector< type_attr_t > class. - -ida_typeinf.type_attrs_t.__getitem__ (method) - __getitem__(self, i) -> type_attr_t - - @param i: size_t - -ida_typeinf.type_attrs_t.__init__ (method) - __init__(self) -> type_attrs_t - __init__(self, x) -> type_attrs_t - - @param x: qvector< type_attr_t > const & - -ida_typeinf.type_attrs_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.type_attrs_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: type_attr_t const & - -ida_typeinf.type_attrs_t.at (method) - at(self, _idx) -> type_attr_t - - @param _idx: size_t - -ida_typeinf.type_attrs_t.begin (method) - begin(self) -> type_attr_t - -ida_typeinf.type_attrs_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.type_attrs_t.clear (method) - clear(self) - -ida_typeinf.type_attrs_t.empty (method) - empty(self) -> bool - -ida_typeinf.type_attrs_t.end (method) - end(self) -> type_attr_t - -ida_typeinf.type_attrs_t.erase (method) - erase(self, it) -> type_attr_t - - @param it: qvector< type_attr_t >::iterator - - erase(self, first, last) -> type_attr_t - - @param first: qvector< type_attr_t >::iterator - @param last: qvector< type_attr_t >::iterator - -ida_typeinf.type_attrs_t.extract (method) - extract(self) -> type_attr_t - -ida_typeinf.type_attrs_t.grow (method) - grow(self, x=type_attr_t()) - - @param x: type_attr_t const & - -ida_typeinf.type_attrs_t.inject (method) - inject(self, s, len) - - @param s: type_attr_t * - @param len: size_t - -ida_typeinf.type_attrs_t.insert (method) - insert(self, it, x) -> type_attr_t - - @param it: qvector< type_attr_t >::iterator - @param x: type_attr_t const & - -ida_typeinf.type_attrs_t.pop_back (method) - pop_back(self) - -ida_typeinf.type_attrs_t.push_back (method) - push_back(self, x) - - @param x: type_attr_t const & - - push_back(self) -> type_attr_t - -ida_typeinf.type_attrs_t.qclear (method) - qclear(self) - -ida_typeinf.type_attrs_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.type_attrs_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: type_attr_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.type_attrs_t.size (method) - size(self) -> size_t - -ida_typeinf.type_attrs_t.swap (method) - swap(self, r) - - @param r: qvector< type_attr_t > & - -ida_typeinf.type_attrs_t.truncate (method) - truncate(self) - -ida_typeinf.type_mods_t (class) - Proxy of C++ type_mods_t class. - -ida_typeinf.type_mods_t.__init__ (method) - __init__(self) -> type_mods_t - -ida_typeinf.type_mods_t.clear (method) - clear(self) - -ida_typeinf.type_mods_t.cmt (variable) - comment for current type - -ida_typeinf.type_mods_t.flags (variable) - Type modification bits - -ida_typeinf.type_mods_t.has_cmt (method) - has_cmt(self) -> bool - -ida_typeinf.type_mods_t.has_info (method) - has_info(self) -> bool - -ida_typeinf.type_mods_t.has_name (method) - has_name(self) -> bool - -ida_typeinf.type_mods_t.has_type (method) - has_type(self) -> bool - -ida_typeinf.type_mods_t.is_rptcmt (method) - is_rptcmt(self) -> bool - -ida_typeinf.type_mods_t.name (variable) - current type name - -ida_typeinf.type_mods_t.set_new_cmt (method) - set_new_cmt(self, c, rptcmt) - - @param c: qstring const & - @param rptcmt: bool - -ida_typeinf.type_mods_t.set_new_name (method) - set_new_name(self, n) - - @param n: qstring const & - -ida_typeinf.type_mods_t.set_new_type (method) - set_new_type(self, t) - The visit_type() function may optionally save the modified type info. Use the - following functions for that. The new name and comment will be applied only if - the current tinfo element has storage for them. - - @param t: (C++: const tinfo_t &) tinfo_t const & - -ida_typeinf.type_mods_t.type (variable) - current type - -ida_typeinf.type_signed (variable) - signed type - -ida_typeinf.type_unsigned (variable) - unsigned type - -ida_typeinf.typedef_type_data_t (class) - Proxy of C++ typedef_type_data_t class. - -ida_typeinf.typedef_type_data_t.__init__ (method) - __init__(self, _til, _name, _resolve=False) -> typedef_type_data_t - - @param _til: til_t const * - @param _name: char const * - @param _resolve: bool - - __init__(self, _til, ord, _resolve=False) -> typedef_type_data_t - - @param _til: til_t const * - @param ord: uint32 - @param _resolve: bool - -ida_typeinf.typedef_type_data_t.is_ordref (variable) - is reference by ordinal? - -ida_typeinf.typedef_type_data_t.name (variable) - is_ordref=false: target type name. we do not own this pointer! - -ida_typeinf.typedef_type_data_t.ordinal (variable) - is_ordref=true: type ordinal number - -ida_typeinf.typedef_type_data_t.resolve (variable) - should resolve immediately? - -ida_typeinf.typedef_type_data_t.swap (method) - swap(self, r) - - @param r: typedef_type_data_t & - -ida_typeinf.typedef_type_data_t.til (variable) - type library to use when resolving - -ida_typeinf.udm_t (class) - Proxy of C++ udm_t class. - -ida_typeinf.udm_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: udm_t const & - -ida_typeinf.udm_t.__init__ (method) - __init__(self) -> udm_t - -ida_typeinf.udm_t.__lt__ (method) - __lt__(self, r) -> bool - - @param r: udm_t const & - -ida_typeinf.udm_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: udm_t const & - -ida_typeinf.udm_t.begin (method) - begin(self) -> uint64 - -ida_typeinf.udm_t.can_be_dtor (method) - can_be_dtor(self) -> bool - -ida_typeinf.udm_t.can_rename (method) - can_rename(self) -> bool - -ida_typeinf.udm_t.clr_baseclass (method) - clr_baseclass(self) - -ida_typeinf.udm_t.clr_method (method) - clr_method(self) - -ida_typeinf.udm_t.clr_unaligned (method) - clr_unaligned(self) - -ida_typeinf.udm_t.clr_vftable (method) - clr_vftable(self) - -ida_typeinf.udm_t.clr_virtbase (method) - clr_virtbase(self) - -ida_typeinf.udm_t.cmt (variable) - member comment - -ida_typeinf.udm_t.effalign (variable) - effective field alignment (in bytes) - -ida_typeinf.udm_t.end (method) - end(self) -> uint64 - -ida_typeinf.udm_t.fda (variable) - field alignment (shift amount) - -ida_typeinf.udm_t.is_anonymous_udm (method) - is_anonymous_udm(self) -> bool - -ida_typeinf.udm_t.is_baseclass (method) - is_baseclass(self) -> bool - -ida_typeinf.udm_t.is_bitfield (method) - is_bitfield(self) -> bool - -ida_typeinf.udm_t.is_gap (method) - is_gap(self) -> bool - -ida_typeinf.udm_t.is_method (method) - is_method(self) -> bool - -ida_typeinf.udm_t.is_regcmt (method) - is_regcmt(self) -> bool - -ida_typeinf.udm_t.is_unaligned (method) - is_unaligned(self) -> bool - -ida_typeinf.udm_t.is_vftable (method) - is_vftable(self) -> bool - -ida_typeinf.udm_t.is_virtbase (method) - is_virtbase(self) -> bool - -ida_typeinf.udm_t.is_zero_bitfield (method) - is_zero_bitfield(self) -> bool - -ida_typeinf.udm_t.make_gap (method) - make_gap(self, byteoff, nbytes) -> bool - - @param byteoff: uval_t - @param nbytes: uval_t - -ida_typeinf.udm_t.name (variable) - member name - -ida_typeinf.udm_t.offset (variable) - member offset in bits - -ida_typeinf.udm_t.repr (variable) - radix, refinfo, strpath, custom_id, strtype - -ida_typeinf.udm_t.set_baseclass (method) - set_baseclass(self, on=True) - - @param on: bool - -ida_typeinf.udm_t.set_method (method) - set_method(self, on=True) - - @param on: bool - -ida_typeinf.udm_t.set_regcmt (method) - set_regcmt(self, on=True) - - @param on: bool - -ida_typeinf.udm_t.set_unaligned (method) - set_unaligned(self, on=True) - - @param on: bool - -ida_typeinf.udm_t.set_value_repr (method) - set_value_repr(self, r) - - @param r: value_repr_t const & - -ida_typeinf.udm_t.set_vftable (method) - set_vftable(self, on=True) - - @param on: bool - -ida_typeinf.udm_t.set_virtbase (method) - set_virtbase(self, on=True) - - @param on: bool - -ida_typeinf.udm_t.size (variable) - size in bits - -ida_typeinf.udm_t.swap (method) - swap(self, r) - - @param r: udm_t & - -ida_typeinf.udm_t.tafld_bits (variable) - TAH bits. - -ida_typeinf.udm_t.type (variable) - member type - -ida_typeinf.udm_t__make_gap (function) - udm_t__make_gap(_this, byteoff, nbytes) -> bool - - @param _this: udm_t * - @param byteoff: uval_t - @param nbytes: uval_t - -ida_typeinf.udt_type_data_t (class) - Proxy of C++ udt_type_data_t class. - -ida_typeinf.udt_type_data_t.__init__ (method) - __init__(self) -> udt_type_data_t - -ida_typeinf.udt_type_data_t.effalign (variable) - effective structure alignment (in bytes) - -ida_typeinf.udt_type_data_t.find_member (method) - find_member(self, pattern_udm, strmem_flags) -> ssize_t - - @param pattern_udm: udm_t * - @param strmem_flags: int - - find_member(self, name) -> ssize_t - - @param name: char const * - - find_member(self, bit_offset) -> ssize_t - - @param bit_offset: uint64 - -ida_typeinf.udt_type_data_t.get_best_fit_member (method) - get_best_fit_member(self, disp) -> ssize_t - Get member that is most likely referenced by the specified offset. Useful for - offsets > sizeof(struct). - - @param disp: (C++: asize_t) - -ida_typeinf.udt_type_data_t.is_cppobj (method) - is_cppobj(self) -> bool - -ida_typeinf.udt_type_data_t.is_last_baseclass (method) - is_last_baseclass(self, idx) -> bool - - @param idx: size_t - -ida_typeinf.udt_type_data_t.is_msstruct (method) - is_msstruct(self) -> bool - -ida_typeinf.udt_type_data_t.is_unaligned (method) - is_unaligned(self) -> bool - -ida_typeinf.udt_type_data_t.is_union (variable) - is union or struct? - -ida_typeinf.udt_type_data_t.is_vftable (method) - is_vftable(self) -> bool - -ida_typeinf.udt_type_data_t.pack (variable) - #pragma pack() alignment (shift amount) - -ida_typeinf.udt_type_data_t.sda (variable) - declared structure alignment (shift amount+1). 0 - unspecified - -ida_typeinf.udt_type_data_t.set_vftable (method) - set_vftable(self, on=True) - - @param on: bool - -ida_typeinf.udt_type_data_t.swap (method) - swap(self, r) - - @param r: udt_type_data_t & - -ida_typeinf.udt_type_data_t.taudt_bits (variable) - TA... and TAUDT... bits. - -ida_typeinf.udt_type_data_t.total_size (variable) - total structure size in bytes - -ida_typeinf.udt_type_data_t.unpadded_size (variable) - unpadded structure size in bytes - -ida_typeinf.udt_type_data_t.version (variable) - version of udt_type_data_t - -ida_typeinf.udt_type_data_t__find_member (function) - udt_type_data_t__find_member(_this, udm, strmem_flags) -> ssize_t - - @param _this: udt_type_data_t const * - @param udm: udm_t * - @param strmem_flags: int - -ida_typeinf.udt_type_data_t__get_best_fit_member (function) - udt_type_data_t__get_best_fit_member(_this, disp) -> ssize_t - - @param _this: udt_type_data_t const * - @param disp: asize_t - -ida_typeinf.udtmembervec_t (class) - Proxy of C++ udtmembervec_t class. - -ida_typeinf.udtmembervec_t.__init__ (method) - __init__(self) -> udtmembervec_t - -ida_typeinf.udtmembervec_template_t (class) - Proxy of C++ qvector< udm_t > class. - -ida_typeinf.udtmembervec_template_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< udm_t > const & - -ida_typeinf.udtmembervec_template_t.__getitem__ (method) - __getitem__(self, i) -> udm_t - - @param i: size_t - -ida_typeinf.udtmembervec_template_t.__init__ (method) - __init__(self) -> udtmembervec_template_t - __init__(self, x) -> udtmembervec_template_t - - @param x: qvector< udm_t > const & - -ida_typeinf.udtmembervec_template_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.udtmembervec_template_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< udm_t > const & - -ida_typeinf.udtmembervec_template_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: udm_t const & - -ida_typeinf.udtmembervec_template_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: udm_t const & - -ida_typeinf.udtmembervec_template_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: udm_t const & - -ida_typeinf.udtmembervec_template_t.at (method) - at(self, _idx) -> udm_t - - @param _idx: size_t - -ida_typeinf.udtmembervec_template_t.begin (method) - begin(self) -> udm_t - -ida_typeinf.udtmembervec_template_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.udtmembervec_template_t.clear (method) - clear(self) - -ida_typeinf.udtmembervec_template_t.empty (method) - empty(self) -> bool - -ida_typeinf.udtmembervec_template_t.end (method) - end(self) -> udm_t - -ida_typeinf.udtmembervec_template_t.erase (method) - erase(self, it) -> udm_t - - @param it: qvector< udm_t >::iterator - - erase(self, first, last) -> udm_t - - @param first: qvector< udm_t >::iterator - @param last: qvector< udm_t >::iterator - -ida_typeinf.udtmembervec_template_t.extract (method) - extract(self) -> udm_t - -ida_typeinf.udtmembervec_template_t.find (method) - find(self, x) -> udm_t - - @param x: udm_t const & - -ida_typeinf.udtmembervec_template_t.grow (method) - grow(self, x=udm_t()) - - @param x: udm_t const & - -ida_typeinf.udtmembervec_template_t.has (method) - has(self, x) -> bool - - @param x: udm_t const & - -ida_typeinf.udtmembervec_template_t.inject (method) - inject(self, s, len) - - @param s: udm_t * - @param len: size_t - -ida_typeinf.udtmembervec_template_t.insert (method) - insert(self, it, x) -> udm_t - - @param it: qvector< udm_t >::iterator - @param x: udm_t const & - -ida_typeinf.udtmembervec_template_t.pop_back (method) - pop_back(self) - -ida_typeinf.udtmembervec_template_t.push_back (method) - push_back(self, x) - - @param x: udm_t const & - - push_back(self) -> udm_t - -ida_typeinf.udtmembervec_template_t.qclear (method) - qclear(self) - -ida_typeinf.udtmembervec_template_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.udtmembervec_template_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: udm_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.udtmembervec_template_t.size (method) - size(self) -> size_t - -ida_typeinf.udtmembervec_template_t.swap (method) - swap(self, r) - - @param r: qvector< udm_t > & - -ida_typeinf.udtmembervec_template_t.truncate (method) - truncate(self) - -ida_typeinf.unpack_idcobj_from_bv (function) - unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t - Read a typed idc object from the byte vector. - - @param obj: (C++: idc_value_t *) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param bytes: (C++: const bytevec_t &) bytevec_t const & - @param pio_flags: (C++: int) - -ida_typeinf.unpack_idcobj_from_idb (function) - unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t - Collection of register objects. - - Read a typed idc object from the database - - @param obj: (C++: idc_value_t *) - @param tif: (C++: const tinfo_t &) tinfo_t const & - @param ea: (C++: ea_t) - @param off0: (C++: const bytevec_t *) bytevec_t const * - @param pio_flags: (C++: int) - -ida_typeinf.unpack_object_from_bv (function) - unpack_object_from_bv(ti, type, fields, 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. 'None' can be passed. - @param type: type_t const * - @param fields: fields string (may be empty or None) - @param bytes: the bytes to unpack - @param pio_flags: flags used while unpacking - @return: - tuple(0, err) on failure - - tuple(1, obj) on success - -ida_typeinf.unpack_object_from_idb (function) - unpack_object_from_idb(ti, type, fields, ea, pio_flags=0) -> PyObject * - - @param ti: til_t * - @param type: type_t const * - @param fields: p_list const * - @param ea: ea_t - @param pio_flags: int - -ida_typeinf.use_golang_cc (function) - use_golang_cc() -> bool - is GOLANG calling convention used by default? - -ida_typeinf.valstr_t (class) - Proxy of C++ valstr_t class. - -ida_typeinf.valstr_t.__init__ (method) - __init__(self) -> valstr_t - -ida_typeinf.valstr_t.info (variable) - additional info - -ida_typeinf.valstr_t.length (variable) - length if printed on one line - -ida_typeinf.valstr_t.members (variable) - strings for members, each member separately - -ida_typeinf.valstr_t.oneline (variable) - result if printed on one line in UTF-8 encoding - -ida_typeinf.valstr_t.props (variable) - temporary properties, used internally - -ida_typeinf.valstrs_t (class) - Proxy of C++ valstrs_t class. - -ida_typeinf.valstrs_t.__init__ (method) - __init__(self) -> valstrs_t - -ida_typeinf.valstrvec_t (class) - Proxy of C++ qvector< valstr_t > class. - -ida_typeinf.valstrvec_t.__getitem__ (method) - __getitem__(self, i) -> valstr_t - - @param i: size_t - -ida_typeinf.valstrvec_t.__init__ (method) - __init__(self) -> valstrvec_t - __init__(self, x) -> valstrvec_t - - @param x: qvector< valstr_t > const & - -ida_typeinf.valstrvec_t.__len__ (method) - __len__(self) -> size_t - -ida_typeinf.valstrvec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: valstr_t const & - -ida_typeinf.valstrvec_t.at (method) - at(self, _idx) -> valstr_t - - @param _idx: size_t - -ida_typeinf.valstrvec_t.begin (method) - begin(self) -> valstr_t - -ida_typeinf.valstrvec_t.capacity (method) - capacity(self) -> size_t - -ida_typeinf.valstrvec_t.clear (method) - clear(self) - -ida_typeinf.valstrvec_t.empty (method) - empty(self) -> bool - -ida_typeinf.valstrvec_t.end (method) - end(self) -> valstr_t - -ida_typeinf.valstrvec_t.erase (method) - erase(self, it) -> valstr_t - - @param it: qvector< valstr_t >::iterator - - erase(self, first, last) -> valstr_t - - @param first: qvector< valstr_t >::iterator - @param last: qvector< valstr_t >::iterator - -ida_typeinf.valstrvec_t.extract (method) - extract(self) -> valstr_t - -ida_typeinf.valstrvec_t.grow (method) - grow(self, x=valstr_t()) - - @param x: valstr_t const & - -ida_typeinf.valstrvec_t.inject (method) - inject(self, s, len) - - @param s: valstr_t * - @param len: size_t - -ida_typeinf.valstrvec_t.insert (method) - insert(self, it, x) -> valstr_t - - @param it: qvector< valstr_t >::iterator - @param x: valstr_t const & - -ida_typeinf.valstrvec_t.pop_back (method) - pop_back(self) - -ida_typeinf.valstrvec_t.push_back (method) - push_back(self, x) - - @param x: valstr_t const & - - push_back(self) -> valstr_t - -ida_typeinf.valstrvec_t.qclear (method) - qclear(self) - -ida_typeinf.valstrvec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_typeinf.valstrvec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: valstr_t const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_typeinf.valstrvec_t.size (method) - size(self) -> size_t - -ida_typeinf.valstrvec_t.swap (method) - swap(self, r) - - @param r: qvector< valstr_t > & - -ida_typeinf.valstrvec_t.truncate (method) - truncate(self) - -ida_typeinf.value_repr_t (class) - Proxy of C++ value_repr_t class. - -ida_typeinf.value_repr_t.__init__ (method) - __init__(self) -> value_repr_t - -ida_typeinf.value_repr_t.__str__ (method) - __str__(self) -> qstring - -ida_typeinf.value_repr_t._print (method) - _print(self, colored=False) -> size_t - - Parameters - ---------- - colored: bool - -ida_typeinf.value_repr_t.ap (variable) - FRB_TABFORM, AP_SIGNED is ignored, use FRB_SIGNED instead - -ida_typeinf.value_repr_t.cd (variable) - FRB_CUSTOM. - -ida_typeinf.value_repr_t.clear (method) - clear(self) - -ida_typeinf.value_repr_t.delta (variable) - FRB_STROFF. - -ida_typeinf.value_repr_t.empty (method) - empty(self) -> bool - -ida_typeinf.value_repr_t.from_opinfo (method) - from_opinfo(self, flags, afl, opinfo, _ap) -> bool - - @param flags: flags64_t - @param afl: aflags_t - @param opinfo: opinfo_t const * - @param _ap: array_parameters_t const * - -ida_typeinf.value_repr_t.get_vtype (method) - get_vtype(self) -> uint64 - -ida_typeinf.value_repr_t.has_lzeroes (method) - has_lzeroes(self) -> bool - -ida_typeinf.value_repr_t.has_tabform (method) - has_tabform(self) -> bool - -ida_typeinf.value_repr_t.init_ap (method) - init_ap(self, _ap) - - @param _ap: array_parameters_t * - -ida_typeinf.value_repr_t.is_custom (method) - is_custom(self) -> bool - -ida_typeinf.value_repr_t.is_enum (method) - is_enum(self) -> bool - -ida_typeinf.value_repr_t.is_offset (method) - is_offset(self) -> bool - -ida_typeinf.value_repr_t.is_signed (method) - is_signed(self) -> bool - -ida_typeinf.value_repr_t.is_strlit (method) - is_strlit(self) -> bool - -ida_typeinf.value_repr_t.is_stroff (method) - is_stroff(self) -> bool - -ida_typeinf.value_repr_t.is_typref (method) - is_typref(self) -> bool - -ida_typeinf.value_repr_t.parse_value_repr (method) - parse_value_repr(self, attr, target_type=BTF_STRUCT) -> bool - - @param attr: qstring const & - @param target_type: type_t - -ida_typeinf.value_repr_t.ri (variable) - FRB_OFFSET. - -ida_typeinf.value_repr_t.set_ap (method) - set_ap(self, _ap) - - @param _ap: array_parameters_t const & - -ida_typeinf.value_repr_t.set_lzeroes (method) - set_lzeroes(self, on) - - @param on: bool - -ida_typeinf.value_repr_t.set_signed (method) - set_signed(self, on) - - @param on: bool - -ida_typeinf.value_repr_t.set_tabform (method) - set_tabform(self, on) - - @param on: bool - -ida_typeinf.value_repr_t.set_vtype (method) - set_vtype(self, vt) - - @param vt: uint64 - -ida_typeinf.value_repr_t.strtype (variable) - FRB_STRLIT. - -ida_typeinf.value_repr_t.swap (method) - swap(self, r) - - @param r: value_repr_t & - -ida_typeinf.value_repr_t.type_ordinal (variable) - FRB_STROFF, FRB_ENUM. - -ida_typeinf.value_repr_t__from_opinfo (function) - value_repr_t__from_opinfo(_this, flags, afl, opinfo, ap) -> bool - - @param _this: value_repr_t * - @param flags: flags64_t - @param afl: aflags_t - @param opinfo: opinfo_t const * - @param ap: array_parameters_t const * - -ida_typeinf.value_repr_t__print_ (function) - value_repr_t__print_(_this, colored) -> str - - @param _this: value_repr_t const * - @param colored: bool - -ida_typeinf.verify_argloc (function) - verify_argloc(vloc, size, gaps) -> int - Verify argloc_t. - - @param vloc: (C++: const argloc_t &) argloc to verify - @param size: (C++: int) total size of the variable - @param gaps: (C++: const rangeset_t *) if not nullptr, specifies gaps in structure definition. these gaps - should not map to any argloc, but everything else must be covered - @return: 0 if ok, otherwise an interr code. - -ida_typeinf.verify_tinfo (function) - verify_tinfo(typid) -> int - - @param typid: uint32 - -ida_typeinf.visit_subtypes (function) - visit_subtypes(visitor, out, tif, name, cmt) -> int - - @param visitor: tinfo_visitor_t * - @param out: type_mods_t * - @param tif: tinfo_t const & - @param name: char const * - @param cmt: char const * - -ida_typeinf.write_tinfo_bitfield_value (function) - write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64 - - @param typid: uint32 - @param dst: uint64 - @param v: uint64 - @param bitoff: int - -ida_ua (module) - Functions that deal with the disassembling of program instructions. - - There are 2 kinds of functions: - * functions that are called from the kernel to disassemble an instruction. These - functions call IDP module for it. - * functions that are called from IDP module to disassemble an instruction. We - will call them 'helper functions'. - - Disassembly of an instruction is made in three steps: - 1. analysis: ana.cpp - 2. emulation: emu.cpp - 3. conversion to text: out.cpp - - The kernel calls the IDP module to perform these steps. At first, the kernel - always calls the analysis. The analyzer must decode the instruction and fill the - insn_t instance that it receives through its callback. It must not change - anything in the database. - - The second step, the emulation, is called for each instruction. This step must - make necessary changes to the database, plan analysis of subsequent - instructions, track register values, memory contents, etc. Please keep in mind - that the kernel may call the emulation step for any address in the program - - there is no ordering of addresses. Usually, the emulation is called for - consecutive addresses but this is not guaranteed. - - The last step, conversion to text, is called each time an instruction is - displayed on the screen. The kernel will always call the analysis step before - calling the text conversion step. The emulation and the text conversion steps - should use the information stored in the insn_t instance they receive. They - should not access the bytes of the instruction and decode it again - this should - only be done in the analysis step. - -ida_ua.FCBF_CONT (variable) - don't stop on decoding, or any other kind of error - -ida_ua.FCBF_DELIM (variable) - add the 'ash'-specified delimiters around the generated data. Note: if those are - not defined and the INFFL_ALLASM is not set, format_charlit() will return an - error - -ida_ua.FCBF_ERR_REPL (variable) - in case of an error, use a CP_REPLCHAR instead of a hex representation of the - problematic byte - -ida_ua.FCBF_FF_LIT (variable) - in case of codepoints == 0xFF, use it as-is (i.e., LATIN SMALL LETTER Y WITH - DIAERESIS). If both this, and FCBF_REPL are specified, this will take precedence - -ida_ua.INSN_64BIT (variable) - belongs to 64bit segment? - -ida_ua.INSN_MACRO (variable) - macro instruction - -ida_ua.INSN_MODMAC (variable) - may modify the database to make room for the macro insn - -ida_ua.OF_NO_BASE_DISP (variable) - base displacement doesn't exist. meaningful only for o_displ type. if set, base - displacement (op_t::addr) doesn't exist. - -ida_ua.OF_NUMBER (variable) - the operand can be converted to a number only - -ida_ua.OF_OUTER_DISP (variable) - outer displacement exists. meaningful only for o_displ type. if set, outer - displacement (op_t::value) exists. - -ida_ua.OF_SHOW (variable) - should the operand be displayed? - -ida_ua.OOFS_IFSIGN (variable) - output sign if needed - -ida_ua.OOFS_NEEDSIGN (variable) - always out sign (+-) - -ida_ua.OOFS_NOSIGN (variable) - don't output sign, forbid the user to change the sign - -ida_ua.OOFW_16 (variable) - 16 bit width - -ida_ua.OOFW_24 (variable) - 24 bit width - -ida_ua.OOFW_32 (variable) - 32 bit width - -ida_ua.OOFW_64 (variable) - 64 bit width - -ida_ua.OOFW_8 (variable) - 8 bit width - -ida_ua.OOFW_IMM (variable) - take from x.dtype - -ida_ua.OOF_ADDR (variable) - output x.addr, otherwise x.value - -ida_ua.OOF_ANYSERIAL (variable) - if enum: select first available serial - -ida_ua.OOF_LZEROES (variable) - print leading zeroes - -ida_ua.OOF_NOBNOT (variable) - prohibit use of binary not - -ida_ua.OOF_NO_LZEROES (variable) - do not print leading zeroes; if none of OOF_LZEROES and OOF_NO_LZEROES was - specified, is_lzero() is used - -ida_ua.OOF_NUMBER (variable) - always as a number - -ida_ua.OOF_OUTER (variable) - output outer operand - -ida_ua.OOF_SIGNED (variable) - output as signed if < 0 - -ida_ua.OOF_SIGNMASK (variable) - sign symbol (+/-) output - -ida_ua.OOF_SPACES (variable) - do not suppress leading spaces; currently works only for floating point numbers - -ida_ua.OOF_WIDTHMASK (variable) - width of value in bits - -ida_ua.OOF_ZSTROFF (variable) - meaningful only if is_stroff(F); append a struct field name if the field offset - is zero? if AFL_ZSTROFF is set, then this flag is ignored. - -ida_ua.PACK_FORM_DEF (variable) - packed factor defined. (!o_reg + dt_packreal) - -ida_ua.STKVAR_VALID_SIZE (variable) - x.dtype contains correct variable type (for insns like 'lea' this bit must be - off). in general, dr_O references do not allow to determine the variable size - -ida_ua.calc_dataseg (function) - calc_dataseg(insn, n=-1, rgnum=-1) -> ea_t - Get data segment for the instruction operand. 'opnum' and 'rgnum' are meaningful - only if the processor has segment registers. - - @param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) - @param n: (C++: int) - @param rgnum: (C++: int) - -ida_ua.can_decode (function) - can_decode(ea) -> bool - Can the bytes at address 'ea' be decoded as instruction? - - @param ea: (C++: ea_t) linear address - @return: whether or not the contents at that address could be a valid - instruction - -ida_ua.construct_macro (function) - construct_macro(insn, enable, build_macro) -> bool - See ua.hpp's construct_macro(). - - @param insn: insn_t & - @param enable: bool - @param build_macro: PyObject * - -ida_ua.construct_macro2 (function) - construct_macro2(_this, insn, enable) -> bool - - @param _this: macro_constructor_t * - @param insn: insn_t * - @param enable: bool - -ida_ua.create_insn (function) - create_insn(ea, out=None) -> int - Create an instruction at the specified address. This function checks if an - instruction is present at the specified address and will try to create one if - there is none. It will fail if there is a data item or other items hindering the - creation of the new instruction. This function will also fill the 'out' - structure. - - @param ea: (C++: ea_t) linear address - @param out: (C++: insn_t *) the resulting instruction - @return: the length of the instruction or 0 - -ida_ua.create_outctx (function) - create_outctx(ea, F=0, suspop=0) -> outctx_base_t - Create a new output context. To delete it, just use "delete pctx" - - @param ea: (C++: ea_t) - @param F: (C++: flags64_t) - @param suspop: (C++: int) - -ida_ua.decode_insn (function) - decode_insn(out, ea) -> int - Analyze the specified address and fill 'out'. This function does not modify the - database. It just tries to interpret the specified address as an instruction and - fills the 'out' structure. - - @param out: (C++: insn_t *) the resulting instruction - @param ea: (C++: ea_t) linear address - @return: the length of the (possible) instruction or 0 - -ida_ua.decode_preceding_insn (function) - decode_preceding_insn(out, ea) -> (int, int) - Decodes the preceding instruction. Please check ua.hpp / decode_preceding_insn() - - @param out: instruction storage - @param ea: current ea - @return: tuple(preceeding_ea or BADADDR, farref = Boolean) - -ida_ua.decode_prev_insn (function) - decode_prev_insn(out, ea) -> ea_t - Decode previous instruction if it exists, fill 'out'. - - @param out: (C++: insn_t *) the resulting instruction - @param ea: (C++: ea_t) the address to decode the previous instruction from - @return: the previous instruction address (BADADDR-no such insn) - -ida_ua.dt_bitfild (variable) - bit field (mc680x0) - -ida_ua.dt_byte (variable) - 8 bit integer - -ida_ua.dt_byte16 (variable) - 128 bit integer - -ida_ua.dt_byte32 (variable) - 256 bit integer - -ida_ua.dt_byte64 (variable) - 512 bit integer - -ida_ua.dt_code (variable) - ptr to code (not used?) - -ida_ua.dt_double (variable) - 8 byte floating point - -ida_ua.dt_dword (variable) - 32 bit integer - -ida_ua.dt_float (variable) - 4 byte floating point - -ida_ua.dt_fword (variable) - 48 bit - -ida_ua.dt_half (variable) - 2-byte floating point - -ida_ua.dt_ldbl (variable) - long double (which may be different from tbyte) - -ida_ua.dt_packreal (variable) - packed real format for mc68040 - -ida_ua.dt_qword (variable) - 64 bit integer - -ida_ua.dt_string (variable) - pointer to asciiz string - -ida_ua.dt_tbyte (variable) - variable size ( processor_t::tbyte_size) floating point - -ida_ua.dt_unicode (variable) - pointer to unicode string - -ida_ua.dt_void (variable) - none - -ida_ua.dt_word (variable) - 16 bit integer - -ida_ua.get_dtype_by_size (function) - get_dtype_by_size(size) -> int - Get op_t::dtype from size. - - @param size: (C++: asize_t) - -ida_ua.get_dtype_flag (function) - get_dtype_flag(dtype) -> flags64_t - Get flags for op_t::dtype field. - - @param dtype: (C++: op_dtype_t) - -ida_ua.get_dtype_size (function) - get_dtype_size(dtype) -> size_t - Get size of opt_::dtype field. - - @param dtype: (C++: op_dtype_t) - -ida_ua.get_immvals (function) - get_immvals(ea, n, F=0) -> [int, ...] - Get immediate values at the specified address. This function decodes instruction - at the specified address or inspects the data item. It finds immediate values - and copies them to 'out'. This function will store the original value of the - operands in 'out', unless the last bits of 'F' are "...0 11111111", in which - case the transformed values (as needed for printing) will be stored instead. - - @param ea: (C++: ea_t) address to analyze - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all the operands - @param F: (C++: flags64_t) flags for the specified address - @return: number of immediate values (0..2*UA_MAXOP) - -ida_ua.get_lookback (function) - get_lookback() -> int - Number of instructions to look back. This variable is not used by the kernel. - Its value may be specified in ida.cfg: LOOKBACK = <number>. IDP may use it as - you like it. (TMS module uses it) - -ida_ua.get_printable_immvals (function) - get_printable_immvals(ea, n, F=0) -> PyObject * - Get immediate ready-to-print values at the specified address - - @param ea: (C++: ea_t) address to analyze - @param n: (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all the operands - @param F: (C++: flags64_t) flags for the specified address - @return: number of immediate values (0..2*UA_MAXOP) - -ida_ua.insn_add_cref (function) - insn_add_cref(insn, to, opoff, type) - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param to: ea_t - @param opoff: int - @param type: enum cref_t - -ida_ua.insn_add_dref (function) - insn_add_dref(insn, to, opoff, type) - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param to: ea_t - @param opoff: int - @param type: enum dref_t - -ida_ua.insn_add_off_drefs (function) - insn_add_off_drefs(insn, x, type, outf) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: op_t const & - @param type: enum dref_t - @param outf: int - -ida_ua.insn_create_stkvar (function) - insn_create_stkvar(insn, x, v, flags) -> bool - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param x: op_t const & - @param v: adiff_t - @param flags: int - -ida_ua.insn_t (class) - Proxy of C++ insn_t class. - -ida_ua.insn_t.__get_auxpref__ (method) - __get_auxpref__(self) -> uint32 - -ida_ua.insn_t.__get_operand__ (method) - __get_operand__(self, n) -> op_t - - @param n: int - -ida_ua.insn_t.__get_ops__ (method) - __get_ops__(self) -> operands_array - -ida_ua.insn_t.__getitem__ (method) - Operands can be accessed directly as indexes - @return: op_t: Returns an operand of type op_t - -ida_ua.insn_t.__init__ (method) - __init__(self) -> insn_t - -ida_ua.insn_t.__iter__ (method) - -ida_ua.insn_t.__set_auxpref__ (method) - __set_auxpref__(self, v) - - @param v: uint32 - -ida_ua.insn_t.add_cref (method) - add_cref(self, to, opoff, type) - Add a code cross-reference from the instruction. - - @param to: (C++: ea_t) target linear address - @param opoff: (C++: int) offset of the operand from the start of instruction. if the offset - is unknown, then 0. - @param type: (C++: cref_t) type of xref - -ida_ua.insn_t.add_dref (method) - add_dref(self, to, opoff, type) - Add a data cross-reference from the instruction. See add_off_drefs() - usually - it can be used in most cases. - - @param to: (C++: ea_t) target linear address - @param opoff: (C++: int) offset of the operand from the start of instruction if the offset - is unknown, then 0 - @param type: (C++: dref_t) type of xref - -ida_ua.insn_t.add_off_drefs (method) - add_off_drefs(self, x, type, outf) -> ea_t - Add xrefs for an operand of the instruction. This function creates all cross - references for 'enum', 'offset' and 'structure offset' operands. Use - add_off_drefs() in the presence of negative offsets. - - @param x: (C++: const op_t &) reference to operand - @param type: (C++: dref_t) type of xref - @param outf: (C++: int) out_value() flags. These flags should match the flags used to - output the operand - @return: if is_off(): the reference target address (the same as - calc_reference_data). if is_stroff(): BADADDR because for stroffs the - target address is unknown else: BADADDR because enums do not represent - addresses - -ida_ua.insn_t.assign (method) - assign(self, other) - - @param other: an ida_ua.insn_t, or an address (C++: const insn_t &) - -ida_ua.insn_t.auxpref (variable) - processor dependent field - -ida_ua.insn_t.create_op_data (method) - create_op_data(self, ea_, opoff, dtype) -> bool - Convenient alias. - - @param ea_: (C++: ea_t) - @param opoff: int - @param dtype: op_dtype_t - - create_op_data(self, ea_, op) -> bool - - @param ea_: ea_t - @param op: op_t const & - -ida_ua.insn_t.create_stkvar (method) - create_stkvar(self, x, v, flags_) -> bool - Create or modify a stack variable in the function frame. The emulator could use - this function to create stack variables in the function frame before converting - the operand to a stack variable. Please check with may_create_stkvars() before - calling this function. - - @param x: (C++: const op_t &) operand (used to determine the addressing type) - @param v: (C++: adiff_t) a displacement in the operand - @param flags_: (C++: int) Stack variable flags - @retval 1: ok, a stack variable exists now - @retval 0: no, couldn't create stack variable - -ida_ua.insn_t.cs (variable) - Current segment base paragraph. Initialized by the kernel. - -ida_ua.insn_t.ea (variable) - Linear address of the instruction. Initialized by the kernel. - -ida_ua.insn_t.flags (variable) - Instruction flags - -ida_ua.insn_t.get_canon_feature (method) - get_canon_feature(self, ph) -> uint32 - see instruc_t::feature - - @param ph: (C++: const processor_t &) processor_t const & - - get_canon_feature(self) -> uint32 - -ida_ua.insn_t.get_canon_mnem (method) - get_canon_mnem(self, ph) -> char const - see instruc_t::name - - @param ph: (C++: const processor_t &) processor_t const & - - get_canon_mnem(self) -> char const * - -ida_ua.insn_t.get_next_byte (method) - get_next_byte(self) -> uint8 - -ida_ua.insn_t.get_next_dword (method) - get_next_dword(self) -> uint32 - -ida_ua.insn_t.get_next_qword (method) - get_next_qword(self) -> uint64 - -ida_ua.insn_t.get_next_word (method) - get_next_word(self) -> uint16 - -ida_ua.insn_t.insnpref (variable) - processor dependent field - -ida_ua.insn_t.ip (variable) - Virtual address of the instruction (address within the segment). Initialized by - the kernel. - -ida_ua.insn_t.is_64bit (method) - is_64bit(self) -> bool - Belongs to a 64bit segment? - -ida_ua.insn_t.is_canon_insn (method) - is_canon_insn(self, ph) -> bool - see processor_t::is_canon_insn() - - @param ph: (C++: const processor_t &) processor_t const & - - is_canon_insn(self) -> bool - -ida_ua.insn_t.is_macro (method) - is_macro(self) -> bool - Is a macro instruction? - -ida_ua.insn_t.itype (variable) - Internal code of instruction (only for canonical insns - not user defined!). IDP - should define its own instruction codes. These codes are usually defined in - ins.hpp. The array of instruction names and features (ins.cpp) is accessed using - this code. - -ida_ua.insn_t.ops (variable) - array of operands - -ida_ua.insn_t.segpref (variable) - processor dependent field - -ida_ua.insn_t.size (variable) - Size of instruction in bytes. The analyzer should put here the actual size of - the instruction. - -ida_ua.insn_t__from_ptrval__ (function) - insn_t__from_ptrval__(ptrval) -> insn_t - - @param ptrval: size_t - -ida_ua.is_floating_dtype (function) - is_floating_dtype(dtype) -> bool - Is a floating type operand? - - @param dtype: (C++: op_dtype_t) - -ida_ua.macro_constructor_t (class) - Proxy of C++ macro_constructor_t class. - -ida_ua.macro_constructor_t.__disown__ (method) - -ida_ua.macro_constructor_t.__init__ (method) - __init__(self) -> macro_constructor_t - - @param self: PyObject * - -ida_ua.macro_constructor_t.build_macro (method) - build_macro(self, insn, may_go_forward) -> bool - Try to extend the instruction. - - @param insn: (C++: insn_t *) Instruction to modify, usually the first instruction of the macro - @param may_go_forward: (C++: bool) Is it ok to consider the next instruction for the macro? - This argument may be false, for example, if there is a - cross reference to the end of INSN. In this case creating - a macro is not desired. However, it may still be useful - to perform minor tweaks to the instruction using the - information about the surrounding instructions. - @return: true if created an macro instruction. This function may modify 'insn' - and return false; these changes will be accepted by the kernel but the - instruction will not be considered as a macro. - -ida_ua.map_code_ea (function) - map_code_ea(insn, addr, opnum) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param addr: ea_t - @param opnum: int - - map_code_ea(insn, op) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: op_t const & - -ida_ua.map_data_ea (function) - map_data_ea(insn, addr, opnum=-1) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param addr: ea_t - @param opnum: int - - map_data_ea(insn, op) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: op_t const & - -ida_ua.map_ea (function) - map_ea(insn, op, iscode) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param op: op_t const & - @param iscode: bool - - map_ea(insn, addr, opnum, iscode) -> ea_t - - @param insn: an ida_ua.insn_t, or an address (C++: const insn_t &) - @param addr: ea_t - @param opnum: int - @param iscode: bool - -ida_ua.o_displ (variable) - Memory Ref [Base Reg + Index Reg + Displacement]. - - A memory reference using register contents with displacement. The displacement - should be stored in the op_t::addr field. The rest of information is stored the - same way as in o_phrase. - -ida_ua.o_far (variable) - Immediate Far Address (CODE). - - If the current processor has a special addressing mode for inter-segment - references, then this operand type should be used instead of o_near. If you - want, you may use PR_CHK_XREF in processor_t::flag to disable inter-segment - calls if o_near operand type is used. Currently only IBM PC uses this flag. - -ida_ua.o_idpspec0 (variable) - processor specific type. - -ida_ua.o_idpspec1 (variable) - processor specific type. - -ida_ua.o_idpspec2 (variable) - processor specific type. - -ida_ua.o_idpspec3 (variable) - processor specific type. - -ida_ua.o_idpspec4 (variable) - processor specific type. - -ida_ua.o_idpspec5 (variable) - processor specific type. (there can be more processor specific types) - -ida_ua.o_imm (variable) - Immediate Value. - - Any operand consisting of only a number is represented by this operand type. The - value should be stored in op_t::value. You may sign extend short (1-2 byte) - values. In any case don't forget to specify op_t::dtype (should be set for all - operand types). - -ida_ua.o_mem (variable) - Direct Memory Reference (DATA). - - A direct memory data reference whose target address is known at compilation - time. The target virtual address is stored in op_t::addr and the full address is - calculated as to_ea( insn_t::cs, op_t::addr ). For the processors with complex - memory organization the final address can be calculated using other segment - registers. For flat memories, op_t::addr is the final address and insn_t::cs is - usually equal to zero. In any case, the address within the segment should be - stored in op_t::addr. - -ida_ua.o_near (variable) - Immediate Near Address (CODE). - - A direct memory code reference whose target address is known at the compilation - time. The target virtual address is stored in op_t::addr and the final address - is always to_ea( insn_t::cs, op_t::addr). Usually this operand type is used for - the branches and calls whose target address is known. If the current processor - has 2 different types of references for inter-segment and intra-segment - references, then this should be used only for intra-segment references. - - If the above operand types do not cover all possible addressing modes, then use - o_idpspec... operand types. - -ida_ua.o_phrase (variable) - Memory Ref [Base Reg + Index Reg]. - - A memory reference using register contents. Indexed, register based, and other - addressing modes can be represented with the operand type. This addressing mode - cannot contain immediate values (use o_displ instead). The phrase number should - be stored in op_t::phrase. To denote the pre-increment and similar features - please use additional operand fields like op_t::specflag... Usually op_t::phrase - contains the register number and additional information is stored in - op_t::specflags... Please note that this operand type cannot contain immediate - values (except the scaling coefficients). - -ida_ua.o_reg (variable) - General Register (al,ax,es,ds...). - - The register number should be stored in op_t::reg. All processor registers, - including special registers, can be represented by this operand type. - -ida_ua.o_void (variable) - No Operand. - -ida_ua.op_t (class) - Proxy of C++ op_t class. - -ida_ua.op_t.__get_addr__ (method) - __get_addr__(self) -> ea_t - -ida_ua.op_t.__get_reg_phrase__ (method) - __get_reg_phrase__(self) -> uint16 - -ida_ua.op_t.__get_specval__ (method) - __get_specval__(self) -> ea_t - -ida_ua.op_t.__get_value64__ (method) - __get_value64__(self) -> uint64 - -ida_ua.op_t.__get_value__ (method) - __get_value__(self) -> ea_t - -ida_ua.op_t.__init__ (method) - __init__(self) -> op_t - -ida_ua.op_t.__set_addr__ (method) - __set_addr__(self, v) - - @param v: ea_t - -ida_ua.op_t.__set_reg_phrase__ (method) - __set_reg_phrase__(self, r) - - @param r: uint16 - -ida_ua.op_t.__set_specval__ (method) - __set_specval__(self, v) - - @param v: ea_t - -ida_ua.op_t.__set_value64__ (method) - __set_value64__(self, v) - - @param v: uint64 - -ida_ua.op_t.__set_value__ (method) - __set_value__(self, v) - - @param v: ea_t - -ida_ua.op_t.addr (variable) - virtual address pointed or used by the operand. (o_mem,o_displ,o_far,o_near) - -ida_ua.op_t.assign (method) - assign(self, other) - - @param other: op_t const & - -ida_ua.op_t.clr_shown (method) - clr_shown(self) - Set operand to hidden. - -ida_ua.op_t.dtype (variable) - Type of operand value (see Operand value types). Usually first 9 types are used. - This is the type of the operand itself, not the size of the addressing mode. for - example, byte ptr [epb+32_bit_offset] will have dt_byte type. - -ida_ua.op_t.flags (variable) - Operand flags - -ida_ua.op_t.has_reg (method) - Checks if the operand accesses the given processor register - -ida_ua.op_t.is_imm (method) - is_imm(self, v) -> bool - Is immediate operand? - - @param v: (C++: uval_t) - -ida_ua.op_t.is_reg (method) - is_reg(self, r) -> bool - Is register operand? - - @param r: (C++: int) - -ida_ua.op_t.n (variable) - Number of operand (0,1,2). Initialized once at the start of work. You have no - right to change its value. - -ida_ua.op_t.offb (variable) - Offset of operand value from the instruction start (0 means unknown). Of course - this field is meaningful only for certain types of operands. Leave it equal to - zero if the operand has no offset. This offset should point to the 'interesting' - part of operand. For example, it may point to the address of a function in - call func or it may point to bytes holding '5' in - mov ax, [bx+5] Usually bytes pointed to this offset are relocated (have fixup - information). - -ida_ua.op_t.offo (variable) - Same as offb (some operands have 2 numeric values used to form an operand). This - field is used for the second part of operand if it exists. Currently this field - is used only for outer offsets of Motorola processors. Leave it equal to zero if - the operand has no offset. - -ida_ua.op_t.phrase (variable) - number of register phrase (o_phrase,o_displ). you yourself define numbers of - phrases as you like - -ida_ua.op_t.reg (variable) - number of register (o_reg) - -ida_ua.op_t.set_shown (method) - set_shown(self) - Set operand to be shown. - -ida_ua.op_t.shown (method) - shown(self) -> bool - Is operand set to be shown? - -ida_ua.op_t.specval (variable) - This field may be used as you want. - -ida_ua.op_t.type (variable) - Type of operand (see Operand types) - -ida_ua.op_t.value (variable) - operand value (o_imm) or outer displacement (o_displ+OF_OUTER_DISP). integer - values should be in IDA's (little-endian) order. when using ieee_realcvt(), - floating point values should be in the processor's native byte order. dt_double - and dt_qword values take up 8 bytes (value and addr fields for 32-bit modules). - NB: in case a dt_dword/dt_qword immediate is forced to float by user, the kernel - converts it to processor's native order before calling FP conversion routines. - -ida_ua.op_t__from_ptrval__ (function) - op_t__from_ptrval__(ptrval) -> op_t - - @param ptrval: size_t - -ida_ua.operands_array (class) - Proxy of C++ wrapped_array_t< op_t,8 > class. - -ida_ua.operands_array.__getitem__ (method) - __getitem__(self, i) -> op_t - - @param i: size_t - -ida_ua.operands_array.__init__ (method) - __init__(self, data) -> operands_array - - @param data: op_t (&)[8] - -ida_ua.operands_array.__len__ (method) - __len__(self) -> size_t - -ida_ua.operands_array.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: op_t const & - -ida_ua.operands_array._get_bytes (method) - _get_bytes(self) -> bytevec_t - -ida_ua.operands_array._set_bytes (method) - _set_bytes(self, bts) - - Parameters - ---------- - bts: bytevec_t const & - -ida_ua.outctx_base_t (class) - Proxy of C++ outctx_base_t class. - -ida_ua.outctx_base_t.__init__ (method) - -ida_ua.outctx_base_t.close_comment (method) - close_comment(self) - -ida_ua.outctx_base_t.clr_gen_label (method) - clr_gen_label(self) - -ida_ua.outctx_base_t.display_voids (method) - display_voids(self) -> bool - -ida_ua.outctx_base_t.flush_buf (method) - flush_buf(self, buf, indent=-1) -> bool - Append contents of 'buf' to the line array. Behaves like flush_outbuf but - accepts an arbitrary buffer - - @param buf: (C++: const char *) char const * - @param indent: (C++: int) - -ida_ua.outctx_base_t.flush_outbuf (method) - flush_outbuf(self, indent=-1) -> bool - Functions to populate the output line array (lnar) Move the contents of the - output buffer to the line array (outbuf->lnar) The kernel augments the outbuf - contents with additional text like the line prefix, user-defined comments, - xrefs, etc at this call. - - @param indent: (C++: int) - -ida_ua.outctx_base_t.forbid_annotations (method) - forbid_annotations(self) -> int - -ida_ua.outctx_base_t.force_code (method) - force_code(self) -> bool - -ida_ua.outctx_base_t.gen_block_cmt (method) - gen_block_cmt(self, cmt, color) -> bool - Generate big non-indented comment lines. - - @param cmt: (C++: const char *) comment text. may contain \n characters to denote new lines. should - not contain comment character (;) - @param color: (C++: color_t) color of comment text (one of Color tags) - @return: overflow, lnar_maxsize has been reached - -ida_ua.outctx_base_t.gen_border_line (method) - gen_border_line(self, solid=False) -> bool - Generate thin border line. This function does nothing if generation of border - lines is disabled. - - @param solid: (C++: bool) generate solid border line (with =), otherwise with - - @return: overflow, lnar_maxsize has been reached - -ida_ua.outctx_base_t.gen_cmt_line (method) - gen_cmt_line(self, format) -> bool - Generate one non-indented comment line, colored with COLOR_AUTOCMT. - - @param format: (C++: const char *) printf() style format line. The resulting comment line should not - include comment character (;) - @return: overflow, lnar_maxsize has been reached - -ida_ua.outctx_base_t.gen_collapsed_line (method) - gen_collapsed_line(self, format) -> bool - Generate one non-indented comment line, colored with COLOR_COLLAPSED. - - @param format: (C++: const char *) printf() style format line. The resulting comment line should not - include comment character (;) - @return: overflow, lnar_maxsize has been reached - -ida_ua.outctx_base_t.gen_empty_line (method) - gen_empty_line(self) -> bool - Generate empty line. This function does nothing if generation of empty lines is - disabled. - - @return: overflow, lnar_maxsize has been reached - -ida_ua.outctx_base_t.gen_empty_line_without_annotations (method) - gen_empty_line_without_annotations(self) - -ida_ua.outctx_base_t.gen_printf (method) - gen_printf(self, indent, format) -> bool - printf-like function to add lines to the line array. - - @param indent: (C++: int) indention of the line. if indent == -1, the kernel will indent - the line at idainfo::indent. if indent < 0, -indent will be used - for indention. The first line printed with indent < 0 is - considered as the most important line at the current address. - Usually it is the line with the instruction itself. This line - will be displayed in the cross-reference lists and other places. - If you need to output an additional line before the main line - then pass DEFAULT_INDENT instead of -1. The kernel will know that - your line is not the most important one. - @param format: (C++: const char *) printf style colored line to generate - @return: overflow, lnar_maxsize has been reached - -ida_ua.outctx_base_t.gen_xref_lines (method) - gen_xref_lines(self) -> bool - -ida_ua.outctx_base_t.getF (method) - getF(self) -> flags64_t - -ida_ua.outctx_base_t.get_stkvar (method) - get_stkvar(self, arg2, arg3, arg4, arg5) -> member_t * - - @param arg2: op_t const & - @param arg3: uval_t - @param arg4: sval_t * - @param arg5: int * - -ida_ua.outctx_base_t.init_lines_array (method) - init_lines_array(self, answers, maxsize) - - @param answers: qstrvec_t * - @param maxsize: int - -ida_ua.outctx_base_t.multiline (method) - multiline(self) -> bool - -ida_ua.outctx_base_t.only_main_line (method) - only_main_line(self) -> bool - -ida_ua.outctx_base_t.out_addr_tag (method) - out_addr_tag(self, ea) - Output "address" escape sequence. - - @param ea: (C++: ea_t) - -ida_ua.outctx_base_t.out_btoa (method) - out_btoa(self, Word, radix=0) - Output a number with the specified base (binary, octal, decimal, hex) The number - is output without color codes. see also out_long() - - @param Word: (C++: uval_t) - @param radix: (C++: char) - -ida_ua.outctx_base_t.out_char (method) - out_char(self, c) - Output one character. The character is output without color codes. see also - out_symbol() - - @param c: (C++: char) - -ida_ua.outctx_base_t.out_chars (method) - out_chars(self, c, n) - Append a character multiple times. - - @param c: (C++: char) - @param n: (C++: int) - -ida_ua.outctx_base_t.out_colored_register_line (method) - out_colored_register_line(self, str) - Output a colored line with register names in it. The register names will be - substituted by user-defined names (regvar_t) Please note that out_tagoff tries - to make substitutions too (when called with COLOR_REG) - - @param str: (C++: const char *) char const * - -ida_ua.outctx_base_t.out_keyword (method) - out_keyword(self, str) - Output a string with COLOR_KEYWORD color. - - @param str: (C++: const char *) char const * - -ida_ua.outctx_base_t.out_line (method) - out_line(self, str, color=0) - Output a string with the specified color. - - @param str: (C++: const char *) char const * - @param color: (C++: color_t) - -ida_ua.outctx_base_t.out_long (method) - out_long(self, v, radix) - Output a number with appropriate color. Low level function. Use out_value() if - you can. if 'suspop' is set then this function uses COLOR_VOIDOP instead of - COLOR_NUMBER. 'suspop' is initialized: - * in out_one_operand() - * in ..\ida\gl.cpp (before calling processor_t::d_out()) - - @param v: (C++: sval_t) value to output - @param radix: (C++: char) base (2,8,10,16) - -ida_ua.outctx_base_t.out_name_expr (method) - out_name_expr(self, x, ea, off=BADADDR) -> bool - Output a name expression. - - @param x: (C++: const op_t &) instruction operand referencing the name expression - @param ea: (C++: ea_t) address to convert to name expression - @param off: (C++: adiff_t) 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 but I discourage it because it prohibits - checks. - @return: true if the name expression has been produced - -ida_ua.outctx_base_t.out_printf (method) - out_printf(self, format) -> size_t - Functions to append text to the current output buffer (outbuf) Append a - formatted string to the output string. - - @param format: (C++: const char *) char const * - @return: the number of characters appended - -ida_ua.outctx_base_t.out_register (method) - out_register(self, str) - Output a character with COLOR_REG color. - - @param str: (C++: const char *) char const * - -ida_ua.outctx_base_t.out_spaces (method) - out_spaces(self, len) - Appends spaces to outbuf until its tag_strlen becomes 'len'. - - @param len: (C++: ssize_t) - -ida_ua.outctx_base_t.out_symbol (method) - out_symbol(self, c) - Output a character with COLOR_SYMBOL color. - - @param c: (C++: char) - -ida_ua.outctx_base_t.out_tagoff (method) - out_tagoff(self, tag) - Output "turn color off" escape sequence. - - @param tag: (C++: color_t) - -ida_ua.outctx_base_t.out_tagon (method) - out_tagon(self, tag) - Output "turn color on" escape sequence. - - @param tag: (C++: color_t) - -ida_ua.outctx_base_t.out_value (method) - out_value(self, x, outf=0) -> flags64_t - Output immediate value. Try to use this function to output all constants of - instruction operands. This function outputs a number from x.addr or x.value in - the form determined by F. It outputs colored text. - - @param x: (C++: const op_t &) value to output - @param outf: (C++: int) Output value flags - @return: flags of the output value, otherwise: -1 if printed a number with - COLOR_ERROR 0 if printed a nice number or character or segment or enum - -ida_ua.outctx_base_t.print_label_now (method) - print_label_now(self) -> bool - -ida_ua.outctx_base_t.restore_ctxflags (method) - restore_ctxflags(self, saved_flags) - - @param saved_flags: int - -ida_ua.outctx_base_t.retrieve_cmt (method) - retrieve_cmt(self) -> ssize_t - -ida_ua.outctx_base_t.retrieve_name (method) - retrieve_name(self, arg2, arg3) -> ssize_t - - @param arg2: qstring * - @param arg3: color_t * - -ida_ua.outctx_base_t.set_comment_addr (method) - set_comment_addr(self, ea) - - @param ea: ea_t - -ida_ua.outctx_base_t.set_dlbind_opnd (method) - set_dlbind_opnd(self) - -ida_ua.outctx_base_t.set_gen_cmt (method) - set_gen_cmt(self, on=True) - - @param on: bool - -ida_ua.outctx_base_t.set_gen_demangled_label (method) - set_gen_demangled_label(self) - -ida_ua.outctx_base_t.set_gen_label (method) - set_gen_label(self) - -ida_ua.outctx_base_t.set_gen_xrefs (method) - set_gen_xrefs(self, on=True) - - @param on: bool - -ida_ua.outctx_base_t.setup_outctx (method) - setup_outctx(self, prefix, makeline_flags) - Initialization; normally used only by the kernel. - - @param prefix: (C++: const char *) char const * - @param makeline_flags: (C++: int) - -ida_ua.outctx_base_t.stack_view (method) - stack_view(self) -> bool - -ida_ua.outctx_base_t.term_outctx (method) - term_outctx(self, prefix=None) -> int - Finalize the output context. - - @param prefix: (C++: const char *) char const * - @return: the number of generated lines. - -ida_ua.outctx_base_t__from_ptrval__ (function) - outctx_base_t__from_ptrval__(ptrval) -> outctx_base_t - - @param ptrval: size_t - -ida_ua.outctx_t (class) - Proxy of C++ outctx_t class. - -ida_ua.outctx_t.__init__ (method) - -ida_ua.outctx_t.gen_func_footer (method) - gen_func_footer(self, pfn) - - @param pfn: func_t const * - -ida_ua.outctx_t.gen_func_header (method) - gen_func_header(self, pfn) - - @param pfn: func_t * - -ida_ua.outctx_t.gen_header (method) - gen_header(self, flags=((1 << 0)|(1 << 1)), proc_name=None, proc_flavour=None) - - @param flags: int - @param proc_name: char const * - @param proc_flavour: char const * - -ida_ua.outctx_t.gen_header_extra (method) - gen_header_extra(self) - -ida_ua.outctx_t.gen_xref_lines (method) - gen_xref_lines(self) -> bool - -ida_ua.outctx_t.out_btoa (method) - out_btoa(self, Word, radix=0) - Output a number with the specified base (binary, octal, decimal, hex) The number - is output without color codes. see also out_long() - - @param Word: (C++: uval_t) - @param radix: (C++: char) - -ida_ua.outctx_t.out_custom_mnem (method) - out_custom_mnem(self, mnem, width=8, postfix=None) - Output custom mnemonic for 'insn'. E.g. if it should differ from the one in - 'ph.instruc'. This function outputs colored text. See out_mnem - - @param mnem: (C++: const char *) custom mnemonic - @param width: (C++: int) width of field with mnemonic. if < 0, then 'postfix' will be - output before the mnemonic, i.e. as a prefix - @param postfix: (C++: const char *) optional postfix added to 'mnem' - -ida_ua.outctx_t.out_data (method) - out_data(self, analyze_only) - - @param analyze_only: bool - -ida_ua.outctx_t.out_fcref_names (method) - out_fcref_names(self) - Print addresses referenced *from* the specified address as commented symbolic - names. This function is used to show, for example, multiple callees of an - indirect call. This function outputs colored text. - -ida_ua.outctx_t.out_immchar_cmts (method) - out_immchar_cmts(self) - Print all operand values as commented character constants. This function is used - to comment void operands with their representation in the form of character - constants. This function outputs colored text. - -ida_ua.outctx_t.out_mnem (method) - out_mnem(self, width=8, postfix=None) - Output instruction mnemonic for 'insn' using information in 'ph.instruc' array. - This function outputs colored text. It should be called from - processor_t::ev_out_insn() or processor_t::ev_out_mnem() handler. It will output - at least one space after the instruction. mnemonic even if the specified 'width' - is not enough. - - @param width: (C++: int) width of field with mnemonic. if < 0, then 'postfix' will be - output before the mnemonic, i.e. as a prefix - @param postfix: (C++: const char *) optional postfix added to the instruction mnemonic - -ida_ua.outctx_t.out_mnemonic (method) - out_mnemonic(self) - Output instruction mnemonic using information in 'insn'. It should be called - from processor_t::ev_out_insn() and it will call processor_t::ev_out_mnem() or - out_mnem. This function outputs colored text. - -ida_ua.outctx_t.out_one_operand (method) - out_one_operand(self, n) -> bool - Use this function to output an operand of an instruction. This function checks - for the existence of a manually defined operand and will output it if it exists. - It should be called from processor_t::ev_out_insn() and it will call - processor_t::ev_out_operand(). This function outputs colored text. - - @param n: (C++: int) 0..UA_MAXOP-1 operand number - @retval 1: operand is displayed - @retval 0: operand is hidden - -ida_ua.outctx_t.out_specea (method) - out_specea(self, segtype) -> bool - - @param segtype: uchar - -ida_ua.outctx_t.retrieve_cmt (method) - retrieve_cmt(self) -> ssize_t - -ida_ua.outctx_t.retrieve_name (method) - retrieve_name(self, arg2, arg3) -> ssize_t - - @param arg2: qstring * - @param arg3: color_t * - -ida_ua.outctx_t.set_bin_state (method) - set_bin_state(self, value) - - @param value: int - -ida_ua.outctx_t.setup_outctx (method) - setup_outctx(self, prefix, flags) - Initialization; normally used only by the kernel. - - @param prefix: (C++: const char *) char const * - @param flags: int - -ida_ua.outctx_t.term_outctx (method) - term_outctx(self, prefix=None) -> int - Finalize the output context. - - @param prefix: (C++: const char *) char const * - @return: the number of generated lines. - -ida_ua.outctx_t__from_ptrval__ (function) - outctx_t__from_ptrval__(ptrval) -> outctx_t - - @param ptrval: size_t - -ida_ua.print_insn_mnem (function) - print_insn_mnem(ea) -> str - Print instruction mnemonics. - - @param ea: (C++: ea_t) linear address of the instruction - @return: success - -ida_ua.print_operand (function) - print_operand(ea, n, getn_flags=0, newtype=None) -> str - Generate text representation for operand #n. This function will generate the - text representation of the specified operand (includes color codes.) - - @param ea: (C++: ea_t) the item address (instruction or data) - @param n: (C++: int) 0..UA_MAXOP-1 operand number, meaningful only for instructions - @param getn_flags: (C++: int) Name expression flags Currently only GETN_NODUMMY is - accepted. - @param newtype: (C++: struct printop_t *) if specified, print the operand using the specified type - @return: success - -ida_xref (module) - Functions that deal with cross-references. - - There are 2 types of xrefs: CODE and DATA references. All xrefs are kept in the - bTree except ordinary execution flow to the next instruction. Ordinary execution - flow to the next instruction is kept in flags (see bytes.hpp) - - The source address of a cross-reference must be an item head (is_head) or a - structure member id. - - Cross-references are automatically sorted. - -ida_xref.XREF_ALL (variable) - return all references - -ida_xref.XREF_BASE (variable) - Reference to the base part of an offset. - -ida_xref.XREF_DATA (variable) - return data references only - -ida_xref.XREF_FAR (variable) - don't return ordinary flow xrefs - -ida_xref.XREF_MASK (variable) - Mask to get xref type. - -ida_xref.XREF_PASTEND (variable) - Reference is past item. This bit may be passed to add_dref() functions but it - won't be saved in the database. It will prevent the destruction of eventual - alignment directives. - -ida_xref.XREF_TAIL (variable) - Reference to tail byte in extrn symbols. - -ida_xref.XREF_USER (variable) - User specified xref. This xref will not be deleted by IDA. This bit should be - combined with the existing xref types (cref_t & dref_t) Cannot be used for fl_F - xrefs - -ida_xref.add_cref (function) - add_cref(frm, to, type) -> bool - Create a code cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction - @param to: (C++: ea_t) linear address of referenced instruction - @param type: (C++: cref_t) cross-reference type - @return: success - -ida_xref.add_dref (function) - add_dref(frm, to, type) -> bool - Create a data cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @param to: (C++: ea_t) linear address of referenced data - @param type: (C++: dref_t) cross-reference type - @return: success (may fail if user-defined xref exists from->to) - -ida_xref.calc_switch_cases (function) - calc_switch_cases(ea, si) -> cases_and_targets_t - Get information about a switch's cases. - - The returned information can be used as follows: - - for idx in range(len(results.cases)): - cur_case = results.cases[idx] - for cidx in range(len(cur_case)): - print("case: %d" % cur_case[cidx]) - print(" goto 0x%x" % results.targets[idx]) - - @param ea: address of the 'indirect jump' instruction - @param si: switch information - - @return: a structure with 2 members: 'cases', and 'targets'. - -ida_xref.cases_and_targets_t (class) - Proxy of C++ cases_and_targets_t class. - -ida_xref.cases_and_targets_t.__init__ (method) - __init__(self) -> cases_and_targets_t - -ida_xref.casevec_t (class) - Proxy of C++ qvector< qvector< sval_t > > class. - -ida_xref.casevec_t.__eq__ (method) - __eq__(self, r) -> bool - - @param r: qvector< qvector< signed-ea-like-numeric-type > > const & - -ida_xref.casevec_t.__getitem__ (method) - __getitem__(self, i) -> qvector< signed-ea-like-numeric-type > const & - - @param i: size_t - -ida_xref.casevec_t.__init__ (method) - __init__(self) -> casevec_t - __init__(self, x) -> casevec_t - - @param x: qvector< qvector< signed-ea-like-numeric-type > > const & - -ida_xref.casevec_t.__len__ (method) - __len__(self) -> size_t - -ida_xref.casevec_t.__ne__ (method) - __ne__(self, r) -> bool - - @param r: qvector< qvector< signed-ea-like-numeric-type > > const & - -ida_xref.casevec_t.__setitem__ (method) - __setitem__(self, i, v) - - @param i: size_t - @param v: qvector< signed-ea-like-numeric-type > const & - -ida_xref.casevec_t._del (method) - _del(self, x) -> bool - - Parameters - ---------- - x: qvector< signed-ea-like-numeric-type > const & - -ida_xref.casevec_t.add_unique (method) - add_unique(self, x) -> bool - - @param x: qvector< signed-ea-like-numeric-type > const & - -ida_xref.casevec_t.at (method) - at(self, _idx) -> qvector< signed-ea-like-numeric-type > const & - - @param _idx: size_t - -ida_xref.casevec_t.begin (method) - begin(self) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - begin(self) -> qvector< qvector< signed-ea-like-numeric-type > >::const_iterator - -ida_xref.casevec_t.capacity (method) - capacity(self) -> size_t - -ida_xref.casevec_t.clear (method) - clear(self) - -ida_xref.casevec_t.empty (method) - empty(self) -> bool - -ida_xref.casevec_t.end (method) - end(self) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - end(self) -> qvector< qvector< signed-ea-like-numeric-type > >::const_iterator - -ida_xref.casevec_t.erase (method) - erase(self, it) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param it: qvector< qvector< signed-ea-like-numeric-type > >::iterator - - erase(self, first, last) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param first: qvector< qvector< signed-ea-like-numeric-type > >::iterator - @param last: qvector< qvector< signed-ea-like-numeric-type > >::iterator - -ida_xref.casevec_t.extract (method) - extract(self) -> qvector< signed-ea-like-numeric-type > * - -ida_xref.casevec_t.find (method) - find(self, x) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param x: qvector< signed-ea-like-numeric-type > const & - - find(self, x) -> qvector< qvector< signed-ea-like-numeric-type > >::const_iterator - - @param x: qvector< signed-ea-like-numeric-type > const & - -ida_xref.casevec_t.grow (method) - grow(self, x=qvector< signed-ea-like-numeric-type >()) - - @param x: qvector< signed-ea-like-numeric-type > const & - -ida_xref.casevec_t.has (method) - has(self, x) -> bool - - @param x: qvector< signed-ea-like-numeric-type > const & - -ida_xref.casevec_t.inject (method) - inject(self, s, len) - - @param s: qvector< signed-ea-like-numeric-type > * - @param len: size_t - -ida_xref.casevec_t.insert (method) - insert(self, it, x) -> qvector< qvector< signed-ea-like-numeric-type > >::iterator - - @param it: qvector< qvector< signed-ea-like-numeric-type > >::iterator - @param x: qvector< signed-ea-like-numeric-type > const & - -ida_xref.casevec_t.pop_back (method) - pop_back(self) - -ida_xref.casevec_t.push_back (method) - push_back(self, x) - - @param x: qvector< signed-ea-like-numeric-type > const & - - push_back(self) -> qvector< signed-ea-like-numeric-type > & - -ida_xref.casevec_t.qclear (method) - qclear(self) - -ida_xref.casevec_t.reserve (method) - reserve(self, cnt) - - @param cnt: size_t - -ida_xref.casevec_t.resize (method) - resize(self, _newsize, x) - - @param _newsize: size_t - @param x: qvector< signed-ea-like-numeric-type > const & - - resize(self, _newsize) - - @param _newsize: size_t - -ida_xref.casevec_t.size (method) - size(self) -> size_t - -ida_xref.casevec_t.swap (method) - swap(self, r) - - @param r: qvector< qvector< signed-ea-like-numeric-type > > & - -ida_xref.casevec_t.truncate (method) - truncate(self) - -ida_xref.create_switch_table (function) - create_switch_table(ea, si) -> bool - Create switch table from the switch information - - @param ea: address of the 'indirect jump' instruction - @param si: switch information - - @return: Boolean - -ida_xref.create_switch_xrefs (function) - create_switch_xrefs(ea, si) -> 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 ea: address of the 'indirect jump' instruction - @param si: switch information - - @return: Boolean - -ida_xref.del_cref (function) - del_cref(frm, to, expand) -> bool - Delete a code cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction - @param to: (C++: ea_t) linear address of referenced instruction - @param expand: (C++: bool) policy to delete the referenced instruction - * 1: plan to delete the referenced instruction if it has no more references. - * 0: don't delete the referenced instruction even if no more cross-references - point to it - @retval true: if the referenced instruction will be deleted - -ida_xref.del_dref (function) - del_dref(frm, to) - Delete a data cross-reference. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @param to: (C++: ea_t) linear address of referenced data - -ida_xref.delete_switch_table (function) - delete_switch_table(jump_ea, si) - - @param jump_ea: ea_t - @param si: switch_info_t const & - -ida_xref.dr_I (variable) - Informational (a derived java class references its base class informationally) - -ida_xref.dr_O (variable) - Offset The reference uses 'offset' of data rather than its value OR The - reference appeared because the "OFFSET" flag of instruction is set. The meaning - of this type is IDP dependent. - -ida_xref.dr_R (variable) - Read access. - -ida_xref.dr_S (variable) - Reference to enum member (symbolic constant) - -ida_xref.dr_T (variable) - Text (for forced operands only) Name of data is used in manual operand - -ida_xref.dr_U (variable) - Unknown - for compatibility with old versions. Should not be used anymore. - -ida_xref.dr_W (variable) - Write access. - -ida_xref.fl_CF (variable) - Call Far This xref creates a function at the referenced location - -ida_xref.fl_CN (variable) - Call Near This xref creates a function at the referenced location - -ida_xref.fl_F (variable) - Ordinary flow: used to specify execution flow to the next instruction. - -ida_xref.fl_JF (variable) - Jump Far. - -ida_xref.fl_JN (variable) - Jump Near. - -ida_xref.fl_U (variable) - unknown - for compatibility with old versions. Should not be used anymore. - -ida_xref.fl_USobsolete (variable) - User specified (obsolete) - -ida_xref.get_first_cref_from (function) - get_first_cref_from(frm) -> ea_t - Get first instruction referenced from the specified instruction. If the - specified instruction passes execution to the next instruction then the next - instruction is returned. Otherwise the lowest referenced address is returned - (remember that xrefs are kept sorted!). - - @param from: (C++: ea_t) linear address of referencing instruction - @return: first referenced address. If the specified instruction doesn't - reference to other instructions then returns BADADDR. - -ida_xref.get_first_cref_to (function) - get_first_cref_to(to) -> ea_t - Get first instruction referencing to the specified instruction. If the specified - instruction may be executed immediately after its previous instruction then the - previous instruction is returned. Otherwise the lowest referencing address is - returned. (remember that xrefs are kept sorted!). - - @param to: (C++: ea_t) linear address of referenced instruction - @return: linear address of the first referencing instruction or BADADDR. - -ida_xref.get_first_dref_from (function) - get_first_dref_from(frm) -> ea_t - Get first data referenced from the specified address. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @return: linear address of first (lowest) data referenced from the specified - address. Return BADADDR if the specified instruction/data doesn't - reference to anything. - -ida_xref.get_first_dref_to (function) - get_first_dref_to(to) -> ea_t - Get address of instruction/data referencing to the specified data. - - @param to: (C++: ea_t) linear address of referencing instruction or data - @return: BADADDR if nobody refers to the specified data. - -ida_xref.get_first_fcref_from (function) - get_first_fcref_from(frm) -> ea_t - - @param from: ea_t - -ida_xref.get_first_fcref_to (function) - get_first_fcref_to(to) -> ea_t - - @param to: ea_t - -ida_xref.get_next_cref_from (function) - get_next_cref_from(frm, current) -> ea_t - Get next instruction referenced from the specified instruction. - - @param from: (C++: ea_t) linear address of referencing instruction - @param current: (C++: ea_t) linear address of current referenced instruction This value is - returned by get_first_cref_from() or previous call to - get_next_cref_from() functions. - @return: next referenced address or BADADDR. - -ida_xref.get_next_cref_to (function) - get_next_cref_to(to, current) -> ea_t - Get next instruction referencing to the specified instruction. - - @param to: (C++: ea_t) linear address of referenced instruction - @param current: (C++: ea_t) linear address of current referenced instruction This value is - returned by get_first_cref_to() or previous call to - get_next_cref_to() functions. - @return: linear address of the next referencing instruction or BADADDR. - -ida_xref.get_next_dref_from (function) - get_next_dref_from(frm, current) -> ea_t - Get next data referenced from the specified address. - - @param from: (C++: ea_t) linear address of referencing instruction or data - @param current: (C++: ea_t) linear address of current referenced data. This value is - returned by get_first_dref_from() or previous call to - get_next_dref_from() functions. - @return: linear address of next data or BADADDR. - -ida_xref.get_next_dref_to (function) - get_next_dref_to(to, current) -> ea_t - Get address of instruction/data referencing to the specified data - - @param to: (C++: ea_t) linear address of referencing instruction or data - @param current: (C++: ea_t) current linear address. This value is returned by - get_first_dref_to() or previous call to get_next_dref_to() - functions. - @return: BADADDR if nobody refers to the specified data. - -ida_xref.get_next_fcref_from (function) - get_next_fcref_from(frm, current) -> ea_t - - @param from: ea_t - @param current: ea_t - -ida_xref.get_next_fcref_to (function) - get_next_fcref_to(to, current) -> ea_t - - @param to: ea_t - @param current: ea_t - -ida_xref.has_external_refs (function) - has_external_refs(pfn, ea) -> bool - Does 'ea' have references from outside of 'pfn'? - - @param pfn: (C++: func_t *) - @param ea: (C++: ea_t) - -ida_xref.xrefblk_t (class) - Proxy of C++ xrefblk_t class. - -ida_xref.xrefblk_t.__init__ (method) - __init__(self) -> xrefblk_t - -ida_xref.xrefblk_t.crefs_from (method) - Provide an iterator on code references from ea including flow references - -ida_xref.xrefblk_t.crefs_to (method) - Provide an iterator on code references to ea including flow references - -ida_xref.xrefblk_t.drefs_from (method) - Provide an iterator on data references from ea - -ida_xref.xrefblk_t.drefs_to (method) - Provide an iterator on data references to ea - -ida_xref.xrefblk_t.fcrefs_from (method) - Provide an iterator on code references from ea - -ida_xref.xrefblk_t.fcrefs_to (method) - Provide an iterator on code references to ea - -ida_xref.xrefblk_t.first_from (method) - first_from(self, _from, flags) -> bool - Get first xref from the given address (store in to) - - @param _from: (C++: ea_t) - @param flags: (C++: int) - -ida_xref.xrefblk_t.first_to (method) - first_to(self, _to, flags) -> bool - Get xref to given address (store in from) - - @param _to: (C++: ea_t) - @param flags: (C++: int) - -ida_xref.xrefblk_t.iscode (variable) - 1-is code reference; 0-is data reference - -ida_xref.xrefblk_t.next_from (method) - next_from(self) -> bool - Get xref from '_from' that comes after '_to'. - next_from(self, _from, _to, flags) -> bool - - @param _from: ea_t - @param _to: ea_t - @param flags: int - -ida_xref.xrefblk_t.next_to (method) - next_to(self) -> bool - Get xref to '_to' that comes after '_from'. - next_to(self, _from, _to, flags) -> bool - - @param _from: ea_t - @param _to: ea_t - @param flags: int - -ida_xref.xrefblk_t.refs_from (method) - Provide an iterator on from reference represented by flag - -ida_xref.xrefblk_t.refs_from._copy_xref (function) - Make a private copy of the xref class to preserve its contents - -ida_xref.xrefblk_t.refs_to (method) - Provide an iterator on to reference represented by flag - -ida_xref.xrefblk_t.refs_to._copy_xref (function) - Make a private copy of the xref class to preserve its contents - -ida_xref.xrefblk_t.to (variable) - the referenced address - filled by first_from(), next_from() - -ida_xref.xrefblk_t.type (variable) - type of the last returned reference (cref_t & dref_t) - -ida_xref.xrefblk_t.user (variable) - 1-is user defined xref, 0-defined by ida - -ida_xref.xrefchar (function) - xrefchar(xrtype) -> char - Get character describing the xref type. - - @param xrtype: (C++: char) combination of Cross-Reference type flags and a cref_t of dref_t - value - diff --git a/apidoc/ida_bytes.py b/apidoc/ida_bytes.py new file mode 100644 index 0000000..57927c2 --- /dev/null +++ b/apidoc/ida_bytes.py @@ -0,0 +1,242 @@ + +class data_type_t(object): + """ + Information about a data type + """ + + def may_create_at(self, ea, nbytes): + """May create data? + No such callback means: always succeed (i.e., no restriction where + such a data type can be created.) + @param ea: candidate address for the data item + @param nbytes: candidate size for the data item + @return: True/False + """ + return True + + def calc_item_size(self, ea, maxsize): + """This callback is used to determine size of the (possible) + item at `ea`. + No such callback means that datatype is of fixed size `value_size`. + (thus, this callback is required only for varsize datatypes.) + @param ea: address of the item + @param maxsize: maximum size of the item + @return: 0 - no such item can be created/displayed + """ + return 0 + + +class data_format_t(object): + """ + Information about a data format + """ + + def printf(self, value, current_ea, operand_num, dtid): + """Convert `value` to colored string using custom format. + @param value: value to print (of type 'str', sequence of bytes) + @param current_ea: current address (BADADDR if unknown) + @param operand_num: current operand number + @param dtid: custom data type id + @return: string representing data + """ + return None + + def scan(self, input, current_ea, operand_num): + """Convert uncolored string (user input) to the value. + This callback is called from the debugger when an user enters a + new value for a register with a custom data representation (e.g., + an MMX register.) + @param input: input string + @param current_ea: current address (BADADDR if unknown) + @param operand_num: current operand number (-1 if unknown) + @return: tuple(bool, string) + (True, output value) or + (False, error message) + """ + return (False, "Not implemented") + + def analyze(self, current_ea, operand_num): + """Analyze custom data format occurrence. + This callback is called in 2 cases: + - after emulating an instruction (after a call of + 'ev_emu_insn') if its operand is marked as "custom data + representation" + - when emulating data (this is done using a call of + 'ev_out_data' with analyze_only == true). This is the right + place to create cross references from the current item. + @param current_ea: current address (BADADDR if unknown) + @param operand_num: current operand number + """ + pass + + +def register_custom_data_type(dt): + """ + 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 + """ + pass + + +def unregister_custom_data_type(dtid): + """ + Unregisters a custom data type. + + @param dtid: the data type id + @return: Boolean + """ + pass + + +def register_custom_data_format(df): + """ + Registers a custom data format with a given data type. + + @param df: an instance of data_format_t + @return: + < 0 if failed to register + > 0 data format id + """ + pass + +def unregister_custom_data_format(dfid): + """ + Unregisters a custom data format + + @param dfid: data format id + @return: Boolean + """ + pass + +def visit_patched_bytes(ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, callable): + """ + 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. + """ + pass + +def get_bytes(ea: ida_idaapi.ea_t, size: int, gmb_flags: int=GMB_READALL): + """ + Get the specified number of bytes of the program. + + @param ea: program address + @param size: number of bytes to return + @param gmb_flags: OR'ed combination of GMB_* values (defaults to GMB_READALL) + @return: the bytes (as bytes object), or None in case of failure + """ + pass + +def get_bytes_and_mask(ea: ida_idaapi.ea_t, size: int, gmb_flags: int=GMB_READALL): + """ + Get the specified number of bytes of the program, and a bitmask + specifying what bytes are defined and what bytes are not. + + @param ea: program address + @param size: number of bytes to return + @param gmb_flags: OR'ed combination of GMB_* values (defaults to GMB_READALL) + @return: a tuple (bytes, mask), or None in case of failure. + Both 'bytes' and 'mask' are 'str' instances. + """ + pass + +# Conversion options for get_strlit_contents(): +STRCONV_ESCAPE = 0x00000001 # convert non-printable characters to C escapes (\n, \xNN, \uNNNN) + +def get_strlit_contents(ea: ida_idaapi.ea_t, len: int, type: int, flags: int = 0): + """ + Get contents of string literal, as UTF-8-encoded codepoints. + It works even if the string has not been created in the database yet. + + Note that the returned value will be of type 'bytes'; if + you want auto-conversion to unicode strings (that is: real Python + strings), you should probably be using the idautils.Strings class. + + @param ea: linear address of the string + @param len: length of the string in bytes (including terminating 0) + @param type: type of the string. Represents both the character encoding, + <u>and</u> the 'type' of string at the given location. + @param flags: combination of STRCONV_..., to perform output conversion. + @return: a bytes-filled str object. + """ + pass + + +def op_stroff(*args) -> bool: + """ + Set operand representation to be 'struct offset'. + + This function has the following signatures: + + 1. op_stroff(ins: ida_ua.insn_t, n: int, path: List[int], delta: int) + 2. op_stroff(ins: ida_ua.insn_t, n: int, path: ida_pro.tid_array, path_len: int, delta: int) (backward-compatibility only) + + Here is an example using this function: + + ins = ida_ua.insn_t() + if ida_ua.decode_insn(ins, some_address): + operand = 0 + path = [ida_typeinf.get_named_type_tid("my_stucture_t")] # a one-element path + ida_bytes.op_stroff(ins, operand, path, 0) + """ + pass + +def get_stroff_path(*args): + """ + Get the structure offset path for operand `n`, at the + specified address. + + This function has the following signatures: + + 1. get_stroff_path(ea: ida_idaapi.ea_t, n : int) -> Tuple[List[int], int] + 2. get_stroff_path(path: tid_array, delta: sval_pointer, ea: ida_idaapi.ea_t, n : int) (backward-compatibility only) + + @param ea address where the operand holds a path to a structure offset (1st form) + @param n operand number (1st form) + @return a tuple holding a (list_of_tid_t's, delta_within_the_last_type), or (None, None) + """ + pass + +def bin_search(*args): + """ + Search for a set of bytes in the program + + This function has the following signatures: + + 1. bin_search(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, data: compiled_binpat_vec_t, flags: int) -> Tuple[ida_idaapi.ea_t, int] + 2. bin_search(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, image: bytes, mask: bytes, len: int, flags: int) -> ida_idaapi.ea_t + + The return value type will differ depending on the form: + + 1. a tuple `(matched-address, index-in-compiled_binpat_vec_t)` (1st form) + 2. the address of a match, or ida_idaapi.BADADDR if not found (2nd form) + + This is a low-level function; more user-friendly alternatives + are available. Please see 'find_bytes' and 'find_string'. + + @param start_ea: linear address, start of range to search + @param end_ea: linear address, end of range to search (exclusive) + @param data: (1st form) the prepared data to search for (see parse_binpat_str()) + @param bytes: (2nd form) a set of bytes to match + @param mask: (2nd form) a mask to apply to the set of bytes + @param flags: combination of BIN_SEARCH_* flags + @return: either a tuple holding both the address of the match and the index of the compiled pattern that matched, or the address of a match (ida_idaapi.BADADDR if not found) + """ + pass + + + + + diff --git a/apidoc/ida_dbg.py b/apidoc/ida_dbg.py new file mode 100644 index 0000000..780a743 --- /dev/null +++ b/apidoc/ida_dbg.py @@ -0,0 +1,125 @@ + +def get_manual_regions(*args): + """ + Returns the manual memory regions + + This function has the following signatures: + + 1. get_manual_regions() -> List[Tuple(ida_idaapi.ea_t, ida_idaapi.ea_t, str, str, ida_idaapi.ea_t, int, int)] + Where each tuple holds (start_ea, end_ea, name, sclass, sbase, bitness, perm) + 2. get_manual_regions(storage: meminfo_vec_t) -> None + """ + pass + + +def dbg_is_loaded(): + """ + Checks if a debugger is loaded + + @return: Boolean + """ + pass + + +def refresh_debugger_memory(): + """ + Refreshes the debugger memory + + @return: Nothing + """ + pass + + +def py_list_bptgrps(): + """ + Returns list of breakpoint group names + + @return: A list of strings or None on failure + """ + pass + + +def internal_get_sreg_base(tid: int, sreg_value: int): + """ + Get the sreg base, for the given thread. + + @param tid: the thread ID + @param sreg_value: the sreg value + @return: The sreg base, or BADADDR on failure. + """ + pass + + +def dbg_can_query(): + """ + 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 + """ + pass + + +def get_reg_vals(tid: int, clsmask: int=-1) -> 'ida_idd.regvals_t': + """ + Fetch live registers values for the thread + + @param tid The ID of the thread to read registers for + @param clsmask An OR'ed mask of register classes to + read values for (can be used to speed up the + retrieval process) + + @return: a list of register values (empty if an error occurs) + """ + pass + + +def get_reg_val(*args): + """ + Get a register value. + + This function has the following signatures: + + 1. get_reg_val(name: str) -> Union[int, float, bytes] + 2. get_reg_val(name: str, regval: regval_t) -> bool + + The first (and most user-friendly) form will return + a value whose type is related to the register type. + I.e., either an integer, a float or, in the case of large + vector registers, a bytes sequence. + + @param name the register name + @return the register value (1st form) + """ + pass + +def set_reg_val(*args) -> bool: + """ + Set a register value by name + + This function has the following signatures: + 1. set_reg_val(name: str, value: Union[int, float, bytes]) -> bool + 1. set_reg_val(tid: int, regidx: int, value: Union[int, float, bytes]) -> bool + + Depending on the register type, this will expect + either an integer, a float or, in the case of large + vector registers, a bytes sequence. + + @param name (1st form) the register name + @param tid (2nd form) the thread ID + @param regidx (2nd form) the register index + @param value the register value + @return success + """ + pass + +def list_bptgrps() -> List[str]: + """ + Retrieve the list of absolute path of all folders of bpt dirtree. + Synchronous function, Notification, none (synchronous function) + """ + pass diff --git a/apidoc/ida_diskio.py b/apidoc/ida_diskio.py new file mode 100644 index 0000000..e84db5b --- /dev/null +++ b/apidoc/ida_diskio.py @@ -0,0 +1,16 @@ + +def enumerate_files(path, fname, callback): + """ + 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 + """ + pass + diff --git a/apidoc/ida_fpro.py b/apidoc/ida_fpro.py new file mode 100644 index 0000000..bd773e1 --- /dev/null +++ b/apidoc/ida_fpro.py @@ -0,0 +1,109 @@ + +class qfile_t(pyidc_opaque_object_t): + + """A helper class to work with FILE related functions.""" + + def __init__(self, *args): + pass + + def close(self): + """Closes the file""" + pass + + def open(self, filename, mode): + """ + Opens a file + + @param filename: the file name + @param mode: The mode string, ala fopen() style + @return: Boolean + """ + pass + + def set_linput(self, linput): + """Links the current loader_input_t instance to a linput_t instance""" + pass + + @staticmethod + def tmpfile(): + """A static method to construct an instance using a temporary file""" + pass + + def seek(self, offset, whence = ida_idaapi.SEEK_SET): + """ + Set input source position + + @param offset: the seek offset + @param whence: the position to seek from + @return: the new position (not 0 as fseek!) + """ + pass + + def tell(self): + """Returns the current position""" + pass + + def gets(self, len): + """ + Reads a line from the input file. Returns the read line or None + + @param len: the maximum line length + """ + pass + + def read(self, size): + """ + Reads from the file. Returns the buffer or None + + @param size: the maximum number of bytes to read + @return: a str, or None + """ + pass + + def write(self, buf): + """ + Writes to the file. Returns 0 or the number of bytes written + + @param buf: the str to write + @return: result code + """ + pass + + def readbytes(self, size, big_endian): + """ + Similar to read() but it respect the endianness + + @param size: the maximum number of bytes to read + @param big_endian: endianness + @return a str, or None + """ + pass + + def writebytes(self, size, big_endian): + """ + Similar to write() but it respect the endianness + + @param buf: the str to write + @param big_endian: endianness + @return: result code + """ + pass + + def flush(self): + pass + + def get_byte(self): + """Reads a single byte from the file. Returns None if EOF or the read byte""" + pass + + def put_byte(self): + """ + Writes a single byte to the file + + @param chr: the byte value + """ + pass + + def opened(self): + """Checks if the file is opened or not""" + pass diff --git a/apidoc/ida_funcs.py b/apidoc/ida_funcs.py new file mode 100644 index 0000000..ada3106 --- /dev/null +++ b/apidoc/ida_funcs.py @@ -0,0 +1,63 @@ + +def get_fchunk_referer(ea: int, idx): + pass + +def get_idasgn_desc(n): + """ + Get information about a signature in the list. + It returns: (name of signature, names of optional libraries) + + See also: get_idasgn_desc_with_matches + + @param n: number of signature in the list (0..get_idasgn_qty()-1) + @return: None on failure or tuple(signame, optlibs) + """ + pass + +def get_idasgn_desc_with_matches(n): + """ + Get information about a signature in the list. + It returns: (name of signature, names of optional libraries, number of matches) + + @param n: number of signature in the list (0..get_idasgn_qty()-1) + @return: None on failure or tuple(signame, optlibs, nmatches) + """ + pass + +class func_t(object): + def get_name(self): + """ + Get the function name + + @return the function name + """ + pass + + def get_frame_object(self): + """ + Retrieve the function frame, in the form of a structure + where frame offsets that are accessed by the program, as well + as areas for "saved registers" and "return address", are + represented by structure members. + + If the function has no associated frame, return None + + @return a ida_typeinf.tinfo_t object representing the frame, or None + """ + pass + + def get_prototype(self): + """ + Retrieve the function prototype. + + Once you have obtained the prototype, you can: + + * retrieve the return type through ida_typeinf.tinfo_t.get_rettype() + * iterate on the arguments using ida_typeinf.tinfo_t.iter_func() + + If the function has no associated prototype, return None + + @return a ida_typeinf.tinfo_t object representing the prototype, or None + """ + pass + diff --git a/apidoc/ida_graph.py b/apidoc/ida_graph.py new file mode 100644 index 0000000..a8ee32d --- /dev/null +++ b/apidoc/ida_graph.py @@ -0,0 +1,65 @@ + +class GraphViewer(ida_kernwin.CustomIDAMemo): + + def OnGetText(self, node_id): + """ + Triggered when the graph viewer wants the text and color for a given node. + This callback is triggered one time for a given node (the value will be cached and used later without callin Python). + When you call refresh then again this callback will be called for each node. + + This callback is mandatory. + + @return: Return a string to describe the node text or return a tuple (node_text, node_color) to describe bot text and color + """ + return str(self[node_id]) + + def OnActivate(self): + """ + Triggered when the graph window gets the focus + @return: None + """ + print("Activated....") + + def OnDeactivate(self): + """Triggered when the graph window loses the focus + @return: None + """ + print("Deactivated....") + + def OnHint(self, node_id): + """ + Triggered when the graph viewer wants to retrieve hint text associated with a given node + + @return: None if no hint is avail or a string designating the hint + """ + return "hint for " + str(node_id) + + def OnEdgeHint(self, src, dst): + """ + Triggered when the graph viewer wants to retrieve hint text associated with a edge + + @return: None if no hint is avail or a string designating the hint + """ + return "hint for edge %d -> %d" % (src, dst) + + def OnClose(self): + """Triggered when the graph viewer window is being closed + @return: None + """ + print("Closing.......") + + def OnClick(self, node_id): + """ + Triggered when a node is clicked + @return: False to ignore the click and True otherwise + """ + print("clicked on", self[node_id]) + return True + + def OnDblClick(self, node_id): + """ + Triggerd when a node is double-clicked. + @return: False to ignore the click and True otherwise + """ + print("dblclicked on", self[node_id]) + return True diff --git a/apidoc/ida_hexrays.py b/apidoc/ida_hexrays.py new file mode 100644 index 0000000..e9d1fdc --- /dev/null +++ b/apidoc/ida_hexrays.py @@ -0,0 +1,31 @@ + +class cfunc_t(object): + def find_item_coords(self, *args): + """ + This method has the following signatures: + + 1. find_item_coords(item: citem_t) -> Tuple[int, int] + 2. find_item_coords(item: citem_t, x: int_pointer, y: int_pointer) -> bool + + NOTE: The second form is retained for backward-compatibility, + but we strongly recommend using the first. + + @param item The item to find coordinates for in the pseudocode listing + """ + pass + +class cfuncptr_t(object): + def find_item_coords(self, *args): + """ + This method has the following signatures: + + 1. find_item_coords(item: citem_t) -> Tuple[int, int] + 2. find_item_coords(item: citem_t, x: int_pointer, y: int_pointer) -> bool + + NOTE: The second form is retained for backward-compatibility, + but we strongly recommend using the first. + + @param item The item to find coordinates for in the pseudocode listing + """ + pass + diff --git a/apidoc/ida_idaapi.py b/apidoc/ida_idaapi.py new file mode 100644 index 0000000..d9a55de --- /dev/null +++ b/apidoc/ida_idaapi.py @@ -0,0 +1,171 @@ +def parse_command_line(cmdline): + """ + Parses a space separated string (quotes and escape character are supported) + @param cmdline: The command line to parse + @return: A list of strings or None on failure + """ + pass + +def set_script_timeout(timeout): + """ + 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 + """ + pass + +def 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 + """ + pass + +def 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 + """ + pass + +def RunPythonStatement(stmt): + """ + This is an IDC function exported from the Python plugin. + It is used to evaluate Python statements from IDC. + @param stmt: The statement to evaluate + @return: 0 - on success otherwise a string containing the error + """ + pass + +class loader_input_t(pyidc_opaque_object_t): + """ + A helper class to work with linput_t related functions. + This class is also used by file loaders scripts. + """ + def __init__(self, pycapsule=None): + pass + + def close(self): + """Closes the file""" + pass + + def open(self, filename, remote = False): + """ + Opens a file (or a remote file) + + @param filename: the file name + @param remote: whether the file is local, or remote + @return: Boolean + """ + pass + + def set_linput(self, linput): + """ + Links the current loader_input_t instance to a linput_t instance + + @param linput: the linput_t to link to + """ + pass + + @staticmethod + def from_fp(fp): + """ + A static method to construct an instance from a FILE* + + @param fp: a FILE pointer + @return: a new instance, or None + """ + pass + + def open_memory(self, start: ea_t, size: int): + """ + 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 range to represent as linput + if unknown, may be passed as 0 + """ + pass + + def seek(self, offset: int, whence = SEEK_SET): + """ + Set input source position + + @param offset: the seek offset + @param whence: the position to seek from + @return: the new position (not 0 as fseek!) + """ + pass + + def tell(self): + """Returns the current position""" + pass + + def getz(self, size: int, fpos: int=-1): + """ + Returns a zero terminated string at the given position + + @param size: maximum size of the string + @param fpos: if != -1 then seek will be performed before reading + @return: The string or None on failure. + """ + pass + + def gets(self, len: int): + """ + Reads a line from the input file. Returns the read line or None + + @param len: the maximum line length + @return: a str, or None + """ + pass + + def read(self, size: int=-1): + """ + Read up to size bytes (all data if size is negative). Return an empty bytes object on EOF. + + @param size: the maximum number of bytes to read + @return a bytes object + """ + pass + + def readbytes(self, size: int, big_endian: bool): + """ + Similar to read() but it respect the endianness + + @param size: the maximum number of bytes to read + @param big_endian: endianness + @return a str, or None + """ + pass + + def file2base(self, pos: int, ea1: ea_t, ea2: ea_t, patchable: bool): + """ + 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 + """ + pass + + def get_byte(self): + """Reads a single byte from the file. Returns None if EOF or the read byte""" + pass + + def opened(self): + """Checks if the file is opened or not""" + pass diff --git a/apidoc/ida_idd.py b/apidoc/ida_idd.py new file mode 100644 index 0000000..ed4fe9e --- /dev/null +++ b/apidoc/ida_idd.py @@ -0,0 +1,71 @@ + +def dbg_get_registers(): + """ + 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, dtype, bit_strings, default_bit_strings_mask) + The bit_strings can be a tuple of strings or None (if the register does not have bit_strings) + """ + pass + + +def dbg_get_thread_sreg_base(tid, sreg_value): + """ + 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 + """ + pass + + +def dbg_read_memory(ea, sz): + """ + Reads from the debugee's memory at the specified ea + + @param ea: the debuggee's memory address + @param sz: the amount of data to read + @return: + - The read buffer (as bytes) + - Or None on failure + """ + pass + + +def dbg_write_memory(ea, buffer): + """ + Writes a buffer to the debugee's memory + + @param ea: the debuggee's memory address + @param buf: a bytes object to write + @return: Boolean + """ + pass + + +def dbg_get_name(): + """ + This function returns the current debugger's name. + + @return: Debugger name or None if no debugger is active + """ + pass + + +def dbg_get_memory_info(): + """ + This function returns the memory configuration of a debugged process. + + @return: + None if no debugger is active + tuple(start_ea, end_ea, name, sclass, sbase, bitness, perm) + """ + pass + + diff --git a/apidoc/ida_idp.py b/apidoc/ida_idp.py new file mode 100644 index 0000000..5548965 --- /dev/null +++ b/apidoc/ida_idp.py @@ -0,0 +1,138 @@ + +def AssembleLine(ea, cs, ip, use32, line): + """ + 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 + """ + pass + + +def assemble(ea, cs, ip, use32, line): + """ + 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. + """ + +def ph_get_id(): + """ + Returns the 'ph.id' field + """ + pass + +def ph_get_version(): + """ + Returns the 'ph.version' + """ + pass + +def ph_get_flag(): + """ + Returns the 'ph.flag' + """ + pass + +def ph_get_cnbits(): + """ + Returns the 'ph.cnbits' + """ + pass + +def ph_get_dnbits(): + """ + Returns the 'ph.dnbits' + """ + pass + +def ph_get_reg_first_sreg(): + """ + Returns the 'ph.reg_first_sreg' + """ + pass + +def ph_get_reg_last_sreg(): + """ + Returns the 'ph.reg_last_sreg' + """ + pass + +def ph_get_segreg_size(): + """ + Returns the 'ph.segreg_size' + """ + pass + +def ph_get_reg_code_sreg(): + """ + Returns the 'ph.reg_code_sreg' + """ + pass + +def ph_get_reg_data_sreg(): + """ + Returns the 'ph.reg_data_sreg' + """ + pass + +def ph_get_icode_return(): + """ + Returns the 'ph.icode_return' + """ + pass + +def ph_get_instruc_start(): + """ + Returns the 'ph.instruc_start' + """ + pass + +def ph_get_instruc_end(): + """ + Returns the 'ph.instruc_end' + """ + pass + +def ph_get_tbyte_size(): + """ + Returns the 'ph.tbyte_size' field as defined in he processor module + """ + pass + +def ph_get_instruc(): + """ + Returns a list of tuples (instruction_name, instruction_feature) containing the + instructions list as defined in he processor module + """ + pass + +def ph_get_regnames(): + """ + Returns the list of register names as defined in the processor module + """ + pass + +def ph_get_operand_info(ea: ida_idaapi.ea_t, n: int) -> Union[Tuple[int, ida_idaapi.ea_t, int, int, int], None]: + """ + 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. + """ + pass diff --git a/apidoc/ida_kernwin.py b/apidoc/ida_kernwin.py new file mode 100644 index 0000000..bd76dc3 --- /dev/null +++ b/apidoc/ida_kernwin.py @@ -0,0 +1,466 @@ + +class simplecustviewer_t(object): + def OnClick(self, shift): + """ + User clicked in the view + @param shift: Shift flag + @return: Boolean. True if you handled the event + """ + print("OnClick, shift=%d" % shift) + return True + + def OnDblClick(self, shift): + """ + User dbl-clicked in the view + @param shift: Shift flag + @return: Boolean. True if you handled the event + """ + print("OnDblClick, shift=%d" % shift) + return True + + def OnCursorPosChanged(self): + """ + Cursor position changed. + @return: Nothing + """ + print("OnCurposChanged") + + def OnClose(self): + """ + The view is closing. Use this event to cleanup. + @return: Nothing + """ + print("OnClose") + + def OnKeydown(self, vkey, shift): + """ + User pressed a key + @param vkey: Virtual key code + @param shift: Shift flag + @return: Boolean. True if you handled the event + """ + print("OnKeydown, vk=%d shift=%d" % (vkey, shift)) + return False + + def OnHint(self, lineno): + """ + Hint requested for the given line number. + @param lineno: The line number (zero based) + @return: + - tuple(number of important lines, hint string) + - None: if no hint available + """ + return (1, "OnHint, line=%d" % lineno) + + def OnPopupMenu(self, menu_id): + """ + A context (or popup) menu item was executed. + @param menu_id: ID previously registered with add_popup_menu() + @return: Boolean + """ + print("OnPopupMenu, menu_id=" % menu_id) + return True + +def register_timer(interval, callback): + """ + 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 + """ + pass + +def unregister_timer(timer_obj): + """ + 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. + """ + pass + +def choose_idasgn(): + """ + Opens the signature chooser + + @return: None or the selected signature name + """ + pass + +def get_highlight(v, flags=0): + """ + Returns the currently highlighted identifier and flags + + @param v: The UI widget to operate on + @param flags: Optionally specify a slot (see kernwin.hpp), current otherwise + @return: a tuple (text, flags), or None if nothing + is highlighted or in case of error. + """ + pass + +def free_custom_icon(icon_id): + """ + Frees an icon loaded with load_custom_icon() + + @param icon_id: The ID of the icon to free + """ + pass + +def read_selection(v, p1, p2): + """ + Read the user selection, and store its information in p1 (from) and p2 (to). + + This can be used as follows: + + + >>> p1 = ida_kernwin.twinpos_t() + p2 = ida_kernwin.twinpos_t() + view = ida_kernwin.get_current_viewer() + ida_kernwin.read_selection(view, p1, p2) + + + At that point, p1 and p2 hold information for the selection. + But, the 'at' property of p1 and p2 is not properly typed. + To specialize it, call #place() on it, passing it the view + they were retrieved from. Like so: + + + >>> place0 = p1.place(view) + place1 = p2.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 v: The view to retrieve the selection for. + @param p1: Storage for the "from" part of the selection. + @param p2: Storage for the "to" part of the selection. + @return: a bool value indicating success. + """ + pass + + +def ask_text(max_size: int, defval: str, prompt: str) -> Union[str, None]: + """ + Asks for a long text + + @param max_size: Maximum text length, 0 for unlimited + @param defval: The default value + @param prompt: The prompt value + @return: None or the entered string + """ + pass + +def ask_str(defval, hist, prompt): + """ + Asks for a long text + + @param defval: The default value + @param hist: history id + @param prompt: The prompt value + @return: None or the entered string + """ + pass + +def process_ui_action(name: str, flags: int=0): + """ + Invokes an IDA UI action by name + + @param name: action name + @param flags: reserved + @return: Boolean + """ + pass + +def del_hotkey(ctx): + """ + Deletes a previously registered function hotkey + + @param ctx: Hotkey context previously returned by add_hotkey() + + @return: Boolean. + """ + pass + +def add_hotkey(hotkey, callable): + """ + Associates a function call with a hotkey. + Callable 'callable' will be called each time the hotkey is pressed + + @param hotkey: The hotkey + @param callable: Callable + + @return: Context object on success or None on failure. + """ + pass + + +MFF_FAST = 0x0000 +"""execute code as soon as possible +this mode is ok call ui related functions +that do not query the database.""" + +MFF_READ = 0x0001 +"""execute code only when ida is idle and it is safe to query the database. +this mode is recommended only for code that does not modify the database. +(nb: ida may be in the middle of executing another user request, for example it may be waiting for him to enter values into a modal dialog box)""" + +MFF_WRITE = 0x0002 +"""execute code only when ida is idle and it is safe to modify the database. in particular, this flag will suspend execution if there is +a modal dialog box on the screen this mode can be used to call any ida api function. MFF_WRITE implies MFF_READ""" + +MFF_NOWAIT = 0x0004 +"""Do not wait for the request to be executed. +he caller should ensure that the request is not +destroyed until the execution completes. +if not, the request will be ignored. +the return code of execute_sync() is meaningless +in this case. +This flag can be used to delay the code execution +until the next UI loop run even from the main thread""" + +def execute_sync(callable, reqf): + """ + 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. + + @param callable: A python callable object, must return an integer value + @param reqf: one of MFF_ flags + @return: -1 or the return value of the callable + """ + pass + +def execute_ui_requests(callable_list): + """ + 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 callable item + """ + pass + +def set_dock_pos(src_ctrl, dest_ctrl, orient, left = 0, top = 0, right = 0, bottom = 0): + """ + Sets the dock orientation of a window relatively to another window. + + Use the left, top, right, bottom parameters if DP_FLOATING is used, + or if you want to specify the width of docked windows. + + @param src_ctrl: Source docking control + @param dest_ctrl: Destination docking control + @param orient: One of DP_XXXX constants + @return: Boolean + + Example: + set_dock_pos('Structures', 'Enums', DP_RIGHT) <- docks the Structures window to the right of Enums window + """ + pass + +def is_idaq(): + """ + Returns True or False depending if IDAPython is hosted by IDAQ + """ + pass + +def attach_dynamic_action_to_popup( + unused, + popup_handle, + desc, + popuppath = None, + flags = 0): + """ + Create & insert an action into the widget's popup menu + (::ui_attach_dynamic_action_to_popup). + Note: The action description in the 'desc' parameter is modified by + this call so you should prepare a new description for each call. + For example: + desc = ida_kernwin.action_desc_t(None, 'Dynamic popup action', Handler()) + ida_kernwin.attach_dynamic_action_to_popup(form, popup, desc) + + @param unused: deprecated; should be None + @param popup_handle: target popup + @param desc: action description of type action_desc_t + @param popuppath: can be None + @param flags: a combination of SETMENU_ constants + @return: success + """ + pass + +def set_nav_colorizer(callback): + """ + Set a new colorizer for the navigation band. + + The 'callback' is a function of 2 arguments: + - ea (the EA to colorize for) + - nbytes (the number of bytes at that EA) + and must return a 'long' value. + + The previous colorizer is returned, allowing + the new 'callback' to use 'call_nav_colorizer' + with it. + + Note that the previous colorizer is returned + only the first time set_nav_colorizer() is called: + due to the way the colorizers API is defined in C, + it is impossible to chain more than 2 colorizers + in IDAPython: the original, IDA-provided colorizer, + and a user-provided one. + + Example: colorizer inverting the color provided by the IDA colorizer: + def my_colorizer(ea, nbytes): + global ida_colorizer + orig = ida_kernwin.call_nav_colorizer(ida_colorizer, ea, nbytes) + return long(~orig) + + ida_colorizer = ida_kernwin.set_nav_colorizer(my_colorizer) + + @param callback: the new colorizer + """ + pass + +def call_nav_colorizer(colorizer, ea: ida_idaapi.ea_t, nbytes: int): + """ + To be used with the IDA-provided colorizer, that is + returned as result of the first call to set_nav_colorizer(). + + @param colorizer: the Python colorizer to call + @param ea: the address to colorize + @param nbytes: the size of the range to colorize + """ + pass + +def msg(message): + """ + Display a message in the message window + + @param message: message to print + """ + pass + +def warning(message): + """ + Display a message in a warning message box + + @param message: message to print + """ + pass + +def error(message): + """ + Display a fatal message in a message box and quit IDA + + @param format: message to print + """ + pass + +def get_navband_pixel(ea): + """ + Maps an address, onto a pixel coordinate within the navigation band + + @param ea: The address to map + @return: a list [pixel, is_vertical] + """ + pass + +def choose_find(title: str) -> Union[object, None]: + """ + Retrieve the chooser object by title + + @param title the chooser title + @return the chooser, or None + """ + pass + +class chooser_base_t(object): + def get_row(self, n: int) -> Tuple[List[str], int, chooser_item_attrs_t]: + """ + Get data & attributes for a row in a chooser. + + @param n The row number + @return a tuple (list-of-strings, icon-id, row-attributes) + """ + pass + +def get_chooser_data(title: str, n: int) -> List[str]: + """ + Get the text corresponding to the index N in the chooser data. + Use -1 to get the header. + + @param title The chooser title + @return a list of strings, or None + """ + pass + +def get_registered_actions() -> List[str]: + """ + Get a list with the names of all currently-registered actions. + + @return the list of action names + """ + pass + +class jobj_wrapper_t(object): + def get_dict(self) -> dict: + """ + Retrieve the contents of this object, as a dict + + @return a dict containing all kvp's in this object + """ + pass + +class place_t(object): + def generate(self, ud, maxsize: int) -> Tuple[List[str], int, int, int]: + """ + Generate text lines for the current location. + + @param ud The user data object + @param maxsize The maximum number of lines to generate + @return a tuple (lines-of-text, default-line-number, prefix-color, background-color) + """ + pass + +def restore_database_snapshot(snapshot, callback, userdata) -> bool: + """ + Restore a database snapshot. + + Note: This call is asynchronous. When it is completed, the callback will be triggered. + + @param snapshot the snapshot object + @param callback a callback function + @param userdata payload to pass to the callback + @return success + """ + pass + +def take_database_snapshot(snapshot) -> Tuple[bool, str]: + """ + Take a database snapshot. + + @param snapshot the snapshot object + @return a tuple (success, error-message) + """ + pass + +def get_custom_viewer_location(*args) -> bool: + """ + Get information about the current location in a listing + + This function has the following signatures: + + 1. get_custom_viewer_location(out_entry: ida_moves.lochist_entry_t, widget: TWidget, mouse: bool=False) -> bool + 2. get_custom_viewer_location(out_entry: ida_kernwin.listing_location_t, widget: TWidget, flags: int=0) -> bool + + The 2nd form is a superset of the 1st, and retrieves + the text (and tags) of the text. + """ + pass diff --git a/apidoc/ida_lines.py b/apidoc/ida_lines.py new file mode 100644 index 0000000..c1a354d --- /dev/null +++ b/apidoc/ida_lines.py @@ -0,0 +1,15 @@ + +def generate_disassembly(ea, max_lines, as_stack, notags): + """ + 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, list(lines)) : Returns a tuple containing + the most important line number and a list of generated lines + """ + pass + diff --git a/apidoc/ida_loader.py b/apidoc/ida_loader.py new file mode 100644 index 0000000..b2dcb4e --- /dev/null +++ b/apidoc/ida_loader.py @@ -0,0 +1,36 @@ + +def mem2base(mem, ea, fpos): + """ + 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 + """ + pass + +def load_plugin(name): + """ + Loads a plugin + + @param name: short plugin name without path and extension, + or absolute path to the file name + @return: + - None if plugin could not be loaded + - An opaque object representing the loaded plugin + """ + pass + +def run_plugin(plg, arg): + """ + Runs a plugin + + @param plg: A plugin object (returned by load_plugin()) + @param arg: the code to pass to the plugin's "run()" function + @return: Boolean + """ + pass diff --git a/apidoc/ida_lumina.py b/apidoc/ida_lumina.py new file mode 100644 index 0000000..a4d2850 --- /dev/null +++ b/apidoc/ida_lumina.py @@ -0,0 +1,9 @@ + +def split_metadata(metadata: bytes) -> dict: + """ + Split the metadata blob into a set of KVP's + + @param metadata a metadata blob + @return a set of KVP's + """ + pass diff --git a/apidoc/ida_nalt.py b/apidoc/ida_nalt.py new file mode 100644 index 0000000..2a5f005 --- /dev/null +++ b/apidoc/ida_nalt.py @@ -0,0 +1,21 @@ + +def get_import_module_name(mod_index): + """ + Returns the name of an imported module given its index + + @param mod_index: the module index + @return: None or the module name + """ + pass + + +def enum_import_names(mod_index, callback): + """ + Enumerate imports from a specific module. + Please refer to list_imports.py example. + + @param mod_index: The module index + @param callback: A callable object that will be invoked with an ea, name (could be None) and ordinal. + @return: 1-finished ok, -1 on error, otherwise callback return value (<=0) + """ + pass diff --git a/apidoc/ida_netnode.py b/apidoc/ida_netnode.py new file mode 100644 index 0000000..837912c --- /dev/null +++ b/apidoc/ida_netnode.py @@ -0,0 +1,22 @@ + +class netnode(object): + def getblob(self, start, tag) -> Union[bytes, None]: + """ + Get a blob from a netnode. + + @param start the index where the blob starts (it may span on multiple indexes) + @param tag the netnode tag + @return a blob, or None + """ + pass + + def getclob(self, start, tag) -> Union[str, None]: + """ + Get a large amount of text from a netnode. + + @param start the index where the clob starts (it may span on multiple indexes) + @param tag the netnode tag + @return a clob, or None + """ + pass + diff --git a/apidoc/ida_pro.py b/apidoc/ida_pro.py new file mode 100644 index 0000000..eb81e9a --- /dev/null +++ b/apidoc/ida_pro.py @@ -0,0 +1,9 @@ + +def str2user(str): + """ + Insert C-style escape characters to string + + @param str: the input string + @return: new string with escape characters inserted, or None + """ + pass diff --git a/apidoc/ida_segment.py b/apidoc/ida_segment.py new file mode 100644 index 0000000..79dc64e --- /dev/null +++ b/apidoc/ida_segment.py @@ -0,0 +1,15 @@ + +def get_defsr(s, reg): + """ + Deprecated, use instead: + value = s.defsr[reg] + """ + pass + + +def set_defsr(s, reg, value): + """ + Deprecated, use instead: + s.defsr[reg] = value + """ + pass diff --git a/apidoc/ida_typeinf.py b/apidoc/ida_typeinf.py new file mode 100644 index 0000000..1e3a5de --- /dev/null +++ b/apidoc/ida_typeinf.py @@ -0,0 +1,559 @@ + +def calc_type_size(til: til_t, type: bytes): + """ + Returns the size of a type + @param til: Type info library. 'None' can be passed. + @param type: serialized type byte string + @return: + - None on failure + - The size of the type + """ + pass + +def apply_type(til: til_t, type: bytes, fields: bytes, ea: ida_idaapi.ea_t, flags: int) -> bool: + """ + Apply the specified type to the address + + @param til: Type info library. 'None' can be used. + @param type: type string + @param fields: fields string (may be empty or None) + @param ea: the address of the object + @param flags: combination of TINFO_... constants or 0 + @return: Boolean + """ + pass + +def get_arg_addrs(caller: ida_idaapi.ea_t): + """ + Retrieve addresses of argument initialization instructions + + @param caller: the address of the call instruction + @return: list of instruction addresses + """ + pass + +def unpack_object_from_idb(til: til_t, type: bytes, fields: bytes, ea: ida_idaapi.ea_t, pio_flags: int = 0): + """ + Unpacks from the database at 'ea' to an object. + Please refer to unpack_object_from_bv() + """ + pass + +def unpack_object_from_bv(til: til_t, type: bytes, fields: bytes, bytes, pio_flags: int = 0): + """ + Unpacks a buffer into an object. + Returns the error_t returned by idaapi.pack_object_to_idb + + @param til: Type library. 'None' can be passed. + @param type: type string + @param fields: fields string (may be empty or None) + @param bytes: the bytes to unpack + @param pio_flags: flags used while unpacking + @return: + - tuple(0, err) on failure + - tuple(1, obj) on success + """ + pass + +def pack_object_to_idb(obj, til: til_t, type: bytes, fields: bytes, ea: ida_idaapi.ea_t, pio_flags: int = 0): + """ + 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 til: Type library. 'None' can be passed. + @param type: type string + @param fields: fields string (may be empty or None) + @param ea: ea to be used while packing + @param pio_flags: flags used while unpacking + """ + pass + +def pack_object_to_bv(obj, til: til_t, type: bytes, fields: bytes, base_ea: ida_idaapi.ea_t, pio_flags: int = 0): + """ + Packs a typed object to a string + + @param til: Type library. 'None' can be passed. + @param type: type string + @param fields: fields string (may be empty or None) + @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 + """ + pass + +def get_named_type(til: til_t, name: str, ntf_flags: int): + """ + Get a type data by its name. + + @param til: Type library + @param name: the type name + @param ntf_flags: a combination of NTF_* constants + @return: + None on failure + tuple(code, type_str, fields_str, cmt, field_cmts, sclass, value) on success + """ + pass + +class tinfo_t(object): + def __init__(self, *args, ordinal=None, name=None, tid=None, til=None): + """ + Create a type object with the provided argumens. + + This constructor has the following signatures: + + 1. tinfo_t(decl_type: type_t) + 2. tinfo_t(decl: str, til: til_t = None, pt_flags: int = 0) + + The latter form will create the type object by parsing the type declaration + + Alternatively, you can use a form accepting the following keyword arguments: + + * ordinal: int + * name: str + * tid: int + * til: til_t=None # `None` means `get_idati()` + + E.g., + + * tinfo_t(ordinal=3) + * tinfo_t(ordinal=10, til=get_idati()) + * tinfo_t(name="mytype_t") + * tinfo_t(name="thattype_t", til=my_other_til) + * tinfo_t(tid=ida_nalt.get_strid(some_address)) + + The constructor may raise an exception if data was invalid, or if parsing failed. + + @param decl_type A simple type + @param decl A valid C declaration + @param til A type library, or `None` to use the (`get_idati()`) default + @param ordinal An ordinal in the type library + @param name A valid type name + @param pt_flags Parsing flags + """ + pass + + def get_udm(self, *args) -> Union[Tuple[int, 'udm_t'], Tuple[None, None]]: + """ + Retrieve a structure/union member with either the specified name + or the specified index, in the specified tinfo_t object. + + This function has the following signatures: + + 1. get_udm(index: int) + 2. get_udm(name: str) + + @param index a member index (1st form) + @param name a member name (2nd form) + @return a tuple (int, udm_t), or (-1, None) if member not found + """ + pass + + def get_udm_by_offset(self, offset: int): + """ + Retrieve a structure/union member with the specified offset, + in the specified tinfo_t object. + + @param offset the member offset + @return a tuple (int, udm_t), or (-1, None) if member not found + """ + pass + + def add_udm(self, *args): + """ + Add a member to the current structure/union. + + When creating a new structure/union from scratch, you might + want to first call `create_udt()` + + This method has the following signatures: + + 1. add_udm(udm: udm_t, etf_flags: int = 0, times: int = 1, idx: int = -1) + 2. add_udm(name: str, type: type_t | tinfo_t | str, offset: int = 0, etf_flags: int = 0, times: int = 1, idx: int = -1) + + In the 2nd form, the 'type' descriptor, can be one of: + + * type_t: if the type is simple (integral/floating/bool). E.g., `BTF_INT` + * tinfo_t: can handle more complex types (structures, pointers, arrays, ...) + * str: a C type declaration + + If an input argument is incorrect, the constructor may raise an exception + + @param udm The member, fully initialized (1st form) + @param name Member name - must not be empty + @param type Member type + @param offset the member offset in bits. It is the caller's responsibility + to specify correct offsets. + @param etf_flags an OR'ed combination of ETF_ flags + @param times how many times to add the new member + @param idx the index in the udm array where the new udm should be placed. + If the specified index cannot be honored because it would spoil + the udm sorting order, it is silently ignored. + """ + pass + + def get_edm(self, *args) -> Tuple[int, 'edm_t']: + """ + Retrieve an enumerator with either the specified name + or the specified index, in the specified tinfo_t object. + + This function has the following signatures: + + 1. get_edm(index: int) + 2. get_edm(name: str) + + @param index an enumerator index (1st form). + @param name an enumerator name (2nd form). + @return a tuple (int, edm_t), or (-1, None) if member not found + """ + pass + + def get_edm_by_value(self, value: int, bmask: int = DEFMASK64, serial: int = 0) -> Tuple[int, 'edm_t']: + """ + Retrieve an enumerator with the specified value, + in the specified tinfo_t object. + + @param value the enumerator value + @return a tuple (int, edm_t), or (-1, None) if member not found + """ + pass + + def add_edm(self, *args): + """ + Add an enumerator to the current enumeration. + + When creating a new enumeration from scratch, you might + want to first call `create_enum()` + + This method has the following signatures: + + 1. add_edm(edm: edm_t, bmask: int = -1, etf_flags: int = 0, idx: int = -1) + 2. add_edm(name: str, value: int, bmask: int = -1, etf_flags: int = 0, idx: int = -1) + + If an input argument is incorrect, the constructor may raise an exception + + @param edm The member, fully initialized (1st form) + @param name Enumerator name - must not be empty + @param value Enumerator value + @param bmask A bitmask to which the enumerator belongs + @param etf_flags an OR'ed combination of ETF_ flags + @param idx the index in the edm array where the new udm should be placed. + If the specified index cannot be honored because it would spoil + the edm sorting order, it is silently ignored. + """ + pass + + def del_edm(self, *args): + """ + Delete an enumerator with the specified name + or the specified index, in the specified tinfo_t object. + + This method has the following signatures: + + 1. del_edm(name: str) -> int + 2. del_edm(index: int) -> int + + @param name an enumerator name (1st form) + @param index an enumerator index (2nd form) + @return TERR_OK in case of success, or another TERR_* value in case of error + """ + pass + + def del_edm_by_value(self, value: int, etf_flags: int=0, bmask: int = DEFMASK64, serial: int = 0): + """ + Delete an enumerator with the specified value, + in the specified tinfo_t object. + + @param value the enumerator value + @return TERR_OK in case of success, or another TERR_* value in case of error + """ + pass + + def iter_struct(self): + """ + Iterate on the members composing this structure. + + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_struc") + for udm in tif.iter_struct(): + print(f"{udm.name} at bit offset {udm.offset}") + + Will raise an exception if this type is not a structure. + + @return a udm_t-producing generator + """ + pass + + def iter_union(self): + """ + Iterate on the members composing this union. + + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_union") + for udm in tif.iter_union(): + print(f"{udm.name}, with type {udm.type}") + + Will raise an exception if this type is not a union. + + @return a udm_t-producing generator + """ + pass + + def iter_udt(self): + """ + Iterate on the members composing this structure, or union. + + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_type") + for udm in tif.iter_udt(): + print(f"{udm.name} at bit offset {udm.offset} with type {udm.type}") + + Will raise an exception if this type is not a structure, or union + + @return a udm_t-producing generator + """ + pass + + def iter_enum(self): + """ + Iterate on the members composing this enumeration. + + Example: + + til = ida_typeinf.get_idati() + tif = til.get_named_type("my_enum") + for edm in tif.iter_enum(): + print(f"{edm.name} = {edm.value}") + + Will raise an exception if this type is not an enumeration + + @return a edm_t-producing generator + """ + pass + + def iter_func(self): + """ + Iterate on the arguments contained in this function prototype + + Example: + + address = ... + func = ida_funcs.get_func(address) + func_type = func.prototype + for arg in func_type.iter_func(): + print(f"{arg.name}, of type {arg.type}") + + Will raise an exception if this type is not a function + + @return a funcarg_t-producing generator + """ + pass + +class edm_t(object): + def __init__(self, *args): + """ + Create an enumerator, with the specified name and value + + This constructor has the following signatures: + + 1. edm_t(edm: edm_t) + 2. edm_t(name: str, value: int, cmt: str=None) + + @param name Enumerator name. Must not be empty (1st form) + @param value Enumerator value (1st form) + @param cmt Enumerator repeatable comment. May be empty (1st form) + @param edm An enum member to copy + """ + pass + +class udm_t(object): + def __init__(self, *args): + """ + Create a structure/union member, with the specified name and type. + + This constructor has the following signatures: + + 1. udm_t(udm: udm_t) + 2. udm_t(name: str, type, offset: int) + + The 'type' descriptor, can be one of: + + * type_t: if the type is simple (integral/floating/bool). E.g., `BTF_INT` + * tinfo_t: can handle more complex types (structures, pointers, arrays, ...) + * str: a C type declaration + + If an input argument is incorrect, the constructor may raise an exception + The size will be computed automatically. + + @param udm a source udm_t + @param name a valid member name. Must not be empty. + @param type the member type + @param offset the member offset in bits. It is the caller's responsibility + to specify correct offsets. + """ + pass + + def copy(self, src): + """ + Copy the src, into this instance + + @param src The source udm_t + """ + pass + +class udt_type_data_t(object): + def get_best_fit_member(self, disp): + """ + Get the member that is most likely referenced by the specified offset. + + @param disp the byte offset + @return a tuple (int, udm_t), or (-1, None) if member not found + """ + pass + + +class funcarg_t(object): + def __init__(self, *args): + """ + Create a function argument, with the specified name and type. + + This constructor has the following signatures: + + 1. funcarg_t(name: str, type, argloc: argloc_t) + 2. funcarg_t(funcarg: funcarg_t) + + In the 1st form, the 'type' descriptor, can be one of: + + * type_t: if the type is simple (integral/floating/bool). E.g., `BTF_INT` + * tinfo_t: can handle more complex types (structures, pointers, arrays, ...) + * str: a C type declaration + + If an input argument is incorrect, the constructor may raise an exception + + @param name a valid argument name. May not be empty (1st form). + @param type the member type (1st form). + @param argloc the argument location. Can be empty (1st form). + @param funcarg a funcarg_t to copy + """ + pass + +class til_t(object): + def import_type(self, src): + """ + Import a type (and all its dependencies) into this type info library. + + @param src The type to import + @return the imported copy, or None + """ + + def numbered_types(self): + """ + Returns a generator over the numbered types contained in this + type library. + + Every iteration returns a fresh new tinfo_t object + + @return a tinfo_t-producing generator + """ + pass + + def named_types(self): + """ + Returns a generator over the named types contained in this + type library. + + Every iteration returns a fresh new tinfo_t object + + @return a tinfo_t-producing generator + """ + pass + + def get_named_type(self, name): + """ + Retrieves a tinfo_t representing the named type in this type library. + + @param name a type name + @return a new tinfo_t object, or None if not found + """ + pass + + def get_numbered_type(self, ordinal): + """ + Retrieves a tinfo_t representing the numbered type in this type library. + + @param ordinal a type ordinal + @return a new tinfo_t object, or None if not found + """ + pass + +def get_named_type64(til: til_t, name: str, ntf_flags: int=0) -> Union[Tuple[int, bytes, bytes, str, str, int, int], None]: + """ + Get a named type from a type library. + + Please use til_t.get_named_type instead. + """ + pass + +def get_numbered_type(til: til_t, ordinal: int) -> Union[Tuple[bytes, bytes, str, str, int], None]: + """ + Get a type from a type library, by its ordinal + + Please use til_t.get_numbered_type instead. + """ + pass + +def idc_get_local_type_raw(ordinal) -> Tuple[bytes, bytes]: + """ + """ + pass + +def idc_parse_decl(til: til_t, decl: str, flags: int) -> Tuple[str, bytes, bytes]: + """ + """ + pass + +def idc_print_type(type: bytes, fields: bytes, name: str, flags: int) -> str: + """ + """ + pass + +def print_decls(printer: text_sink_t, til: til_t, ordinals: List[int], flags: int) -> int: + """ + Print types (and possibly their dependencies) in a format suitable for using in + a header file. This is the reverse parse_decls(). + + @param printer a handler for printing text + @param til the type library holding the ordinals + @param ordinals a list of ordinals corresponding to the types to print + @param flags a combination of PDF_ constants + @return + >0: the number of types exported + 0: an error occurred + <0: the negated number of types exported. There were minor errors and + the resulting output might not be compilable. + """ + pass + +def remove_tinfo_pointer(tif: tinfo_t, name: str, til: til_t) -> Tuple[bool, str]: + """ + Remove pointer of a type. (i.e. convert "char *" into "char"). Optionally remove + the "lp" (or similar) prefix of the input name. If the input type is not a + pointer, then fail. + + @param tif the type info + @param name the name of the type to "unpointerify" + @param til the type library + @return a tuple (success, new-name) + """ + pass + + + diff --git a/apidoc/ida_ua.py b/apidoc/ida_ua.py new file mode 100644 index 0000000..745b1df --- /dev/null +++ b/apidoc/ida_ua.py @@ -0,0 +1,29 @@ + +def decode_preceding_insn(out: insn_t, ea: ida_idaapi.ea_t) -> Tuple[ida_idaapi.ea_t, bool]: + """ + Decodes the preceding instruction. + + @param out: instruction storage + @param ea: current ea + @return: tuple(preceeding_ea or BADADDR, farref = Boolean) + """ + pass + +def construct_macro(*args): + """ + See ua.hpp's construct_macro(). + + This function has the following signatures + + 1. construct_macro(insn: insn_t, enable: bool, build_macro: callable) -> bool + 2. construct_macro(constuctor: macro_constructor_t, insn: insn_t, enable: bool) -> bool + + @param insn: the instruction to build the macro for + @param enable: enable macro generation + @param build_macro: a callable with 2 arguments: an insn_t, and + whether it is ok to consider the next instruction + for the macro + @param constructor: a macro_constructor_t implementation + @return: success + """ + pass diff --git a/apidoc/ida_xref.py b/apidoc/ida_xref.py new file mode 100644 index 0000000..26d47da --- /dev/null +++ b/apidoc/ida_xref.py @@ -0,0 +1,47 @@ + +def create_switch_xrefs(ea, si): + """ + 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 ea: address of the 'indirect jump' instruction + @param si: switch information + + @return: Boolean + """ + pass + + +def calc_switch_cases(ea, si): + """ + Get information about a switch's cases. + + The returned information can be used as follows: + + for idx in range(len(results.cases)): + cur_case = results.cases[idx] + for cidx in range(len(cur_case)): + print("case: %d" % cur_case[cidx]) + print(" goto 0x%x" % results.targets[idx]) + + @param ea: address of the 'indirect jump' instruction + @param si: switch information + + @return: a structure with 2 members: 'cases', and 'targets'. + """ + pass + +def create_switch_table(ea, si): + """ + Create switch table from the switch information + + @param ea: address of the 'indirect jump' instruction + @param si: switch information + + @return: Boolean + """ + pass diff --git a/copy_docs_to_p4.sh b/copy_docs_to_p4.sh new file mode 100755 index 0000000..0fd3d66 --- /dev/null +++ b/copy_docs_to_p4.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash + +set -e + +#ensure out folder exists +mkdir -p $3 + +IN_FOLDER=$(realpath $2) +OUT_FOLDER=$(realpath $3) + +ARTIFACTS=$1 + +echo "[${ARTIFACTS}] GOING to COPY FILES from ${IN_FOLDER} to ${OUT_FOLDER}" + +cd ${OUT_FOLDER} + +echo "[${ARTIFACTS}] make the out folder p4 edit" +p4 edit ... + +echo "[${ARTIFACTS}] copy new files" +rm -rf * +cp -R ${IN_FOLDER}/* . + +echo "[${ARTIFACTS}] adding files to p4" +p4 add ... +p4 revert -a ... + diff --git a/examples-internal/dirtree_missing_inode.py b/examples-internal/dirtree_missing_inode.py new file mode 100755 index 0000000..bf140ab --- /dev/null +++ b/examples-internal/dirtree_missing_inode.py @@ -0,0 +1,138 @@ +""" +summary: Add missing inodes in dirtree structure in "/lost+found" directory + +description: + How to collects inodes for various dirtrees ('Local Types', 'Names', + 'Functions', 'Imports', 'Address bookmark' and 'Breakpoints') in both + the dirtree structure and the database. + Create a directory an links inodes to them in the dirtree structure + You cannot add all inodes to the "/lost+found" directory because inodes + can be at various places in a dirtree structure. + The early dirtree implementations were not perfect and may have missed to + add some inodes in the tree structure, this script corrects this issue. + +keywords: dirtree, recovery +""" + +import ida_dirtree +from ida_dirtree import dirtree_t +import ida_typeinf +import ida_funcs +import ida_name +import ida_dbg +import ida_nalt +import ida_kernwin +import ida_moves + + +def get_ltypes_inode(n): + inode = n + 1 + name = ida_typeinf.get_numbered_type_name(None, inode) + if name is None: + # if the name is None, we have a #deleted type, + # present in flat mode but not in fulltree mode + return True, None + else: + return False, inode + + +def get_func_inode(n): + inode = ida_funcs.getn_func(n).start_ea + return False, inode + + +def get_name_inode(n): + inode = ida_name.get_nlist_ea(n) + if inode is None: + print(hex(inode)) + return False, inode + + +list_inodes_in_idb = [] +def get_import_list(): + def imp_cb(ea, name, ordinal): + list_inodes_in_idb.append(ea) + return True + nimps = ida_nalt.get_import_module_qty() + for i in range(nimps): + ida_nalt.enum_import_names(i, imp_cb) + list_inodes_in_idb.sort() + return len(list_inodes_in_idb) + + +def get_nth_inode_in_idb(n): + return False, list_inodes_in_idb[n] + + +def get_idaplace_list_inodes_in_idb(): + id = ida_kernwin.get_place_class_id("idaplace_t") + p = ida_kernwin.get_place_class_template(id) + r = ida_moves.renderer_info_t() + l = ida_moves.lochist_entry_t(p, r) + for idx in range(ida_moves.bookmarks_t.size(l, None)): + ida_moves.bookmarks_t.get(l, idx, None) + idaloc = ida_kernwin.place_t.as_idaplace_t(l.place()) + list_inodes_in_idb.append(idaloc.ea) + list_inodes_in_idb.sort() + return len(list_inodes_in_idb) + + +def get_bpt_inode(n): + bpt = ida_dbg.bpt_t() + if not ida_dbg.getn_bpt(n, bpt): + return True, None + return False, bpt.bptid + + +class dt_collect_inode_t(ida_dirtree.dirtree_visitor_t): + def __init__(self): + ida_dirtree.dirtree_visitor_t.__init__(self) + self.list_inodes_in_dirtree = [] + def visit(self, c, de): + if dirtree_t.isfile(de): + self.list_inodes_in_dirtree.append(de.idx) + return 0 + + +std_recovery_data = [ + ( ida_dirtree.DIRTREE_LOCAL_TYPES, ida_typeinf.get_ordinal_count, get_ltypes_inode, "Local Types" ), + ( ida_dirtree.DIRTREE_FUNCS, ida_funcs.get_func_qty, get_func_inode, "Local Types" ), + ( ida_dirtree.DIRTREE_NAMES, ida_name.get_nlist_size, get_name_inode, "Names" ), + ( ida_dirtree.DIRTREE_IMPORTS, get_import_list, get_nth_inode_in_idb, "Imports" ), + ( ida_dirtree.DIRTREE_IDAPLACE_BOOKMARKS, get_idaplace_list_inodes_in_idb, get_nth_inode_in_idb, "Address bookmarks" ), + ( ida_dirtree.DIRTREE_BPTS, ida_dbg.get_bpt_qty, get_bpt_inode, "Breakpoints" ), + ] + + +for dt_id, get_count_and_maybe_list_inodes_in_idb, get_inode, title in std_recovery_data: + dt = ida_dirtree.get_std_dirtree(dt_id) + print("### Dirtree ", title) + list_inodes_in_idb = [] + collector = dt_collect_inode_t() + dt.traverse(collector) + set_inodes_in_dirtree = set(collector.list_inodes_in_dirtree) + nb_inodes = get_count_and_maybe_list_inodes_in_idb() + nb_not_list = 0 + nb_list = len(set_inodes_in_dirtree) + print("Number of unique inodes in the idb: %d\nNumber of unique inodes in fulltree mode: %d"%(nb_inodes, nb_list)) + + if nb_list < nb_inodes: + err = dt.mkdir("/lost+found") + if err != ida_dirtree.DTE_OK: + print(dt.errstr(err)) + err = dt.chdir("/lost+found") + if err != ida_dirtree.DTE_OK: + print(dt.errstr(err)) + for n in range(nb_inodes): + inc, inode = get_inode(n) + if inode is not None: + if inode not in set_inodes_in_dirtree: + err = dt.link(inode) + if err != ida_dirtree.DTE_OK: + print("Failed to link inode ", hex(inode), " ", dt.errstr(err) ) + inc = True + if inc: + nb_not_list += 1 + if nb_inodes == nb_list + nb_not_list: + break + diff --git a/examples-internal/idapython_example_raise_exception.py b/examples-internal/idapython_example_raise_exception.py new file mode 100644 index 0000000..d1f5517 --- /dev/null +++ b/examples-internal/idapython_example_raise_exception.py @@ -0,0 +1,4 @@ +"""This internal test is used to verify that pc_api tests won't swallow +exceptions while using IDAPYTHON_EXAMPLE <path_to_script>""" + +raise ImportError("Nasty exception at the script") diff --git a/examples/README.md b/examples/README.md index 3ae4985..1a440b1 100644 --- a/examples/README.md +++ b/examples/README.md @@ -18,6 +18,29 @@ with one or many examples, and those should be also put under test rather than if it consists of a bunch of IDAPython code our users will never see, and cannot be inspired from.) +### Best practices + +* don't use `idc.py`: some of its operations are a bit too elusive +* don't use `idaapi`: that "hides" the provenance of the + function/type/item being used, and makes it that much harder to + group ideas by module +* don't `from <something> import <whatever>`: for the same reason +* use double-quotes for all string literals, unless there's a good + reason not to do so (e.g., the string literal contains some `"` + characters, and `\`-escaping them would be inconvenient & make the + code awkward to read). + Double-quoted string literals let us grep more predictably & reliably. + +## Example header + +Every example must have a valid header, holding a one-liner `summary:`, +as well as a description further explaining what the example is about. + +Some notes: + +* `summary:`: the one-liner must not end with a `.` +* `summary:`: prefer the `list something...` form over the `listing something...` + ## Helping our customers, teaching IDAPython in the process In addition, when a customer asks for help on support@ (or the forums) diff --git a/examples/core/add_idc_hotkey.py b/examples/core/add_idc_hotkey.py deleted file mode 100644 index acf3ebb..0000000 --- a/examples/core/add_idc_hotkey.py +++ /dev/null @@ -1,30 +0,0 @@ -""" -summary: triggering bits of code by pressing a shortcut (older version) - -description: - This is a somewhat ancient way of registering actions & binding - shortcuts. It's still here for reference, but "fresher" alternatives - should be preferred. - -keywords: actions - -see_also: actions, add_hotkey -""" - -import ida_expr -import ida_kernwin - -def say_hi(): - print("Hotkey activated!") - -# IDA binds hotkeys to IDC functions so a trampoline IDC function must be created -ida_expr.compile_idc_text('static key_2() { RunPythonStatement("say_hi()"); }') - -# Add the hotkey -ida_kernwin.add_idc_hotkey("2", 'key_2') - -# Press 2 to activate foo() - -# The hotkey can be removed with -# ida_kernwin.del_idc_hotkey('2') - diff --git a/examples/core/bin_search.py b/examples/core/bin_search.py deleted file mode 100644 index 7b4c77b..0000000 --- a/examples/core/bin_search.py +++ /dev/null @@ -1,94 +0,0 @@ -""" -summary: showcasing `ida_bytes.bin_search` - -description: - IDAPython's ida_bytes.bin_search function is pretty powerful, - but can be tough to figure out at first. This example introduces - - * `ida_bytes.bin_search`, and - * `ida_bytes.parse_binpat_str` - - in order to implement a simple replacement for the - 'Search > Sequence of bytes...' dialog, that lets users - search for sequences of bytes that compose string literals - in the binary file (either in the default 1-byte-per-char - encoding, or as UTF-16.) -""" - -import ida_kernwin -import ida_bytes -import ida_ida -import ida_idaapi -import ida_nalt - -class search_strlit_form_t(ida_kernwin.Form): - def __init__(self): - ida_kernwin.Form.__init__( - self, - r"""Please enter string literal - -<Text: {Text}> -<#UTF16-BE if file is big-endian, UTF16-LE otherwise#As UTF-16: {UTF16}>{Encoding}> -""", - { - "Text" : ida_kernwin.Form.StringInput(), - "Encoding" : ida_kernwin.Form.ChkGroupControl(("UTF16",)), - }) - -class search_strlit_ah_t(ida_kernwin.action_handler_t): - def __init__(self): - ida_kernwin.action_handler_t.__init__(self) - - def activate(self, ctx): - f = search_strlit_form_t() - f, args = f.Compile() - ok = f.Execute() - if ok: - current_ea = ida_kernwin.get_screen_ea() - patterns = ida_bytes.compiled_binpat_vec_t() - encoding = ida_nalt.get_default_encoding_idx( - ida_nalt.BPU_2B if f.Encoding.value else ida_nalt.BPU_1B) - # string literals must be quoted. That's how parse_binpat_str - # recognizes them (we want to be careful though: the user - # might type in something like 'L"hello"', which should - # decode to the IDB-specific wide-char set of bytes) - text = f.Text.value - if text.find('"') < 0: - text = '"%s"' % text - err = ida_bytes.parse_binpat_str( - patterns, - current_ea, - text, - 10, # radix (not that it matters though, since we're all about string literals) - encoding) - if not err: - ea = ida_bytes.bin_search( - current_ea, - ida_ida.inf_get_max_ea(), - patterns, - ida_bytes.BIN_SEARCH_FORWARD - | ida_bytes.BIN_SEARCH_NOBREAK - | ida_bytes.BIN_SEARCH_NOSHOW) - ok = ea != ida_idaapi.BADADDR - if ok: - ida_kernwin.jumpto(ea) - else: - print("Failed parsing binary pattern: \"%s\"" % err) - return ok - - def update(self, ctx): - return ida_kernwin.AST_ENABLE_FOR_WIDGET \ - if ctx.widget_type == ida_kernwin.BWN_DISASM \ - else ida_kernwin.AST_DISABLE_FOR_WIDGET - - -ACTION_NAME = "bin_search:search" -ACTION_SHORTCUT = "Ctrl+Shift+S" - -if ida_kernwin.register_action( - ida_kernwin.action_desc_t( - ACTION_NAME, - "Search for string literal", - search_strlit_ah_t(), - ACTION_SHORTCUT)): - print("Please use \"%s\" to search for string literals" % ACTION_SHORTCUT) diff --git a/examples/debugging/appcall/simple_appcall_common.py b/examples/debugger/appcall/simple_appcall_common.py similarity index 100% rename from examples/debugging/appcall/simple_appcall_common.py rename to examples/debugger/appcall/simple_appcall_common.py diff --git a/examples/debugging/appcall/simple_appcall_linux.py b/examples/debugger/appcall/simple_appcall_linux.py similarity index 90% rename from examples/debugging/appcall/simple_appcall_linux.py rename to examples/debugger/appcall/simple_appcall_linux.py index b143be6..39eab1b 100644 --- a/examples/debugging/appcall/simple_appcall_linux.py +++ b/examples/debugger/appcall/simple_appcall_linux.py @@ -1,5 +1,5 @@ """ -summary: executing code into the application being debugged (on Linux) +summary: execute code into the application being debugged (on Linux) description: Using the `ida_idd.Appcall` utility to execute code in @@ -18,6 +18,8 @@ description: * run this script Note: the real body of code is in `simple_appcall_common.py`. + +level: advanced """ import os diff --git a/examples/debugging/appcall/simple_appcall_win.py b/examples/debugger/appcall/simple_appcall_win.py similarity index 88% rename from examples/debugging/appcall/simple_appcall_win.py rename to examples/debugger/appcall/simple_appcall_win.py index 5861e3f..52262e7 100644 --- a/examples/debugging/appcall/simple_appcall_win.py +++ b/examples/debugger/appcall/simple_appcall_win.py @@ -1,5 +1,5 @@ """ -summary: executing code into the application being debugged (on Windows) +summary: execute code into the application being debugged (on Windows) description: Using the `ida_idd.Appcall` utility to execute code in @@ -11,13 +11,15 @@ description: To use this example: - * run `ida64` on test program `simple_appcall_win64.exe`, or + * run `ida` on test program `simple_appcall_win64.exe`, or `ida` on test program `simple_appcall_win32.exe`, and wait for auto-analysis to finish * select the 'windows debugger' (either local, or remote) * run this script Note: the real body of code is in `simple_appcall_common.py`. + +level: advanced """ import os diff --git a/examples/debugging/appcall/test_programs/simple_appcall/makefile b/examples/debugger/appcall/test_programs/simple_appcall/makefile similarity index 100% rename from examples/debugging/appcall/test_programs/simple_appcall/makefile rename to examples/debugger/appcall/test_programs/simple_appcall/makefile diff --git a/examples/debugging/appcall/test_programs/simple_appcall/simple_appcall.c b/examples/debugger/appcall/test_programs/simple_appcall/simple_appcall.c similarity index 100% rename from examples/debugging/appcall/test_programs/simple_appcall/simple_appcall.c rename to examples/debugger/appcall/test_programs/simple_appcall/simple_appcall.c diff --git a/examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_linux32 b/examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_linux32 similarity index 100% rename from examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_linux32 rename to examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_linux32 diff --git a/examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_linux64 b/examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_linux64 similarity index 100% rename from examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_linux64 rename to examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_linux64 diff --git a/examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_win32.exe b/examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_win32.exe similarity index 100% rename from examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_win32.exe rename to examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_win32.exe diff --git a/examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_win64.exe b/examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_win64.exe similarity index 100% rename from examples/debugging/appcall/test_programs/simple_appcall/simple_appcall_win64.exe rename to examples/debugger/appcall/test_programs/simple_appcall/simple_appcall_win64.exe diff --git a/examples/debugging/dbghooks/automatic_steps.py b/examples/debugger/dbghooks/automatic_steps.py similarity index 99% rename from examples/debugging/dbghooks/automatic_steps.py rename to examples/debugger/dbghooks/automatic_steps.py index 9044143..0a2522a 100644 --- a/examples/debugging/dbghooks/automatic_steps.py +++ b/examples/debugger/dbghooks/automatic_steps.py @@ -5,6 +5,8 @@ description: Start a debugging session, step through the first five instructions. Each instruction is disassembled after execution. + +level: advanced """ import ida_dbg diff --git a/examples/debugging/dbghooks/dbg_trace.py b/examples/debugger/dbghooks/dbg_trace.py similarity index 97% rename from examples/debugging/dbghooks/dbg_trace.py rename to examples/debugger/dbghooks/dbg_trace.py index 0ed3aa8..060bd3f 100644 --- a/examples/debugging/dbghooks/dbg_trace.py +++ b/examples/debugger/dbghooks/dbg_trace.py @@ -1,11 +1,13 @@ """ -summary: using the low-level tracing hook +summary: react to trace notifications description: This script demonstrates using the low-level tracing hook (ida_dbg.DBG_Hooks.dbg_trace). It can be run like so: - ida[t].exe -B -Sdbg_trace.py -Ltrace.log file.exe + ida.exe -B -Sdbg_trace.py -Ltrace.log file.exe + +level: advanced """ import time diff --git a/examples/debugging/misc/print_call_stack.py b/examples/debugger/misc/print_call_stack.py similarity index 79% rename from examples/debugging/misc/print_call_stack.py rename to examples/debugger/misc/print_call_stack.py index 441ff6a..1308d34 100644 --- a/examples/debugging/misc/print_call_stack.py +++ b/examples/debugger/misc/print_call_stack.py @@ -1,18 +1,23 @@ """ -summary: print call stack (on Linux) +summary: print call stack -description: print the return addresses from the call stack at a breakpoint. - (and print also the module and the debug name from debugger) +description: + + Print the return addresses from the call stack at a breakpoint, + when debugging a Linux binary. + (and also print the module and the debug name from debugger) To use this example: - * run `ida64` on test program `simple_appcall_linux64`, or + * run `ida` on test program `simple_appcall_linux64`, or `ida` on test program `simple_appcall_linux32`, and wait for auto-analysis to finish * put a breakpoint where you want to see the call stack * select the 'linux debugger' (either local, or remote) * start debugging * Press Shift+C at the breakpoint + +level: intermediate """ import os import ida_idaapi @@ -35,8 +40,8 @@ class print_call_stack_ah_t(): if ida_dbg.get_module_info(frame.callea, mi): module = os.path.basename(mi.name) name = ida_name.get_nice_colored_name( - frame.callea, - ida_name.GNCN_NOCOLOR|ida_name.GNCN_NOLABEL|ida_name.GNCN_NOSEG|ida_name.GNCN_PREFDBG) + frame.callea, + ida_name.GNCN_NOCOLOR|ida_name.GNCN_NOLABEL|ida_name.GNCN_NOSEG|ida_name.GNCN_PREFDBG) log("Return address: " + hex(frame.callea) + " from: " + module + " with debug name: " + name) else: log("Return address: " + hex(frame.callea)) diff --git a/examples/debugging/misc/print_registers.py b/examples/debugger/misc/print_registers.py similarity index 88% rename from examples/debugging/misc/print_registers.py rename to examples/debugger/misc/print_registers.py index d8683f6..55115ae 100644 --- a/examples/debugging/misc/print_registers.py +++ b/examples/debugger/misc/print_registers.py @@ -1,8 +1,9 @@ """ -summary: print all registers, for all threads +summary: print all registers, for all threads in the debugged process -description: iterate over the list of threads in the program being - debugged, and dump all registers contents +description: + Iterate over the list of threads in the program being + debugged, and dump all registers contents To use this example: @@ -13,6 +14,8 @@ description: iterate over the list of threads in the program being * select the 'linux debugger' (either local, or remote) * start debugging * Press Alt+Shift+C at the breakpoint + +level: beginner """ import ida_idd import ida_dbg diff --git a/examples/debugging/misc/registers_context_menu.py b/examples/debugger/misc/registers_context_menu.py similarity index 95% rename from examples/debugging/misc/registers_context_menu.py rename to examples/debugger/misc/registers_context_menu.py index 8692cdb..9f36380 100644 --- a/examples/debugging/misc/registers_context_menu.py +++ b/examples/debugger/misc/registers_context_menu.py @@ -1,5 +1,5 @@ """ -summary: adding actions to the "registers" widget(s) +summary: add a custom action to the "registers" widget description: It's possible to add actions to the context menu of @@ -7,6 +7,8 @@ description: This example shows how to do just that for registers-displaying widgets (e.g., "General registers") + +level: intermediate """ import ida_dbg diff --git a/examples/debugging/show_debug_names.py b/examples/debugger/show_debug_names.py similarity index 89% rename from examples/debugging/show_debug_names.py rename to examples/debugger/show_debug_names.py index 71c5788..0f8c6c2 100644 --- a/examples/debugging/show_debug_names.py +++ b/examples/debugger/show_debug_names.py @@ -1,9 +1,11 @@ """ -summary: retrieving & dumping debuggee symbols +summary: dump symbols from a process being debugged description: Queries the debugger (possibly remotely) for the list of symbols that the process being debugged, provides. + +level: beginner """ import ida_dbg diff --git a/examples/hexrays/colorize_pseudocode_lines.py b/examples/decompiler/colorize_pseudocode_lines.py similarity index 97% rename from examples/hexrays/colorize_pseudocode_lines.py rename to examples/decompiler/colorize_pseudocode_lines.py index 6c6124d..46c916a 100644 --- a/examples/hexrays/colorize_pseudocode_lines.py +++ b/examples/decompiler/colorize_pseudocode_lines.py @@ -1,5 +1,5 @@ """ -summary: interactively color certain pseudocode lines +summary: interactively color decompilation lines description: Provides an action that can be used to dynamically alter the @@ -11,6 +11,8 @@ description: with a special background color. keywords: colors + +level: intermediate """ import ida_kernwin diff --git a/examples/hexrays/curpos_details.py b/examples/decompiler/curpos_details.py similarity index 97% rename from examples/hexrays/curpos_details.py rename to examples/decompiler/curpos_details.py index 775ceff..8197d42 100644 --- a/examples/hexrays/curpos_details.py +++ b/examples/decompiler/curpos_details.py @@ -1,11 +1,13 @@ """ -summary: a focus on the 'curpos' hook, printing additional details about user input +summary: print information about the current position in decompilation description: Shows how user input information can be retrieved during processing of a notification triggered by that input see_also: vds_hooks + +level: advanced """ import ida_hexrays diff --git a/examples/hexrays/decompile_entry_points.py b/examples/decompiler/decompile_entry_points.py similarity index 87% rename from examples/hexrays/decompile_entry_points.py rename to examples/decompiler/decompile_entry_points.py index e363ea4..0f0177f 100644 --- a/examples/hexrays/decompile_entry_points.py +++ b/examples/decompiler/decompile_entry_points.py @@ -1,13 +1,15 @@ """ -summary: automatic decompilation of functions +summary: decompile entrypoint automatically description: Attempts to load a decompiler plugin corresponding to the current - architecture (and address size) right after auto-analysis is performed, + architecture right after auto-analysis is performed, and then tries to decompile the function at the first entrypoint. It is particularly suited for use with the '-S' flag, for example: idat -Ldecompile.log -Sdecompile_entry_points.py -c file + +level: intermediate """ import ida_ida @@ -22,21 +24,17 @@ import ida_kernwin # manually if we want to use it def init_hexrays(): ALL_DECOMPILERS = { - ida_idp.PLFM_386: "hexrays", + ida_idp.PLFM_386: "hexx64", ida_idp.PLFM_ARM: "hexarm", ida_idp.PLFM_PPC: "hexppc", ida_idp.PLFM_MIPS: "hexmips", + ida_idp.PLFM_RISCV: "hexrv", } cpu = ida_idp.ph.id decompiler = ALL_DECOMPILERS.get(cpu, None) if not decompiler: print("No known decompilers for architecture with ID: %d" % ida_idp.ph.id) return False - if ida_ida.inf_is_64bit(): - if cpu == ida_idp.PLFM_386: - decompiler = "hexx64" - else: - decompiler += "64" if ida_loader.load_plugin(decompiler) and ida_hexrays.init_hexrays_plugin(): return True else: diff --git a/examples/core/produce_c_file.py b/examples/decompiler/produce_c_file.py similarity index 93% rename from examples/core/produce_c_file.py rename to examples/decompiler/produce_c_file.py index 1c2ebfb..f1421d1 100644 --- a/examples/core/produce_c_file.py +++ b/examples/decompiler/produce_c_file.py @@ -1,5 +1,5 @@ """ -summary: decompile entire file +summary: produce C listing for the entire file description: automate IDA to perform auto-analysis on a file and, @@ -15,6 +15,8 @@ description: * -A instructs IDA to run in non-interactive mode * -S holds a path to the script to run (note this is a single token; there is no space between '-S' and its path.) + +level: beginner """ import ida_pro diff --git a/examples/hexrays/vds1.py b/examples/decompiler/vds1.py similarity index 84% rename from examples/hexrays/vds1.py rename to examples/decompiler/vds1.py index 668bec8..a3529af 100644 --- a/examples/hexrays/vds1.py +++ b/examples/decompiler/vds1.py @@ -1,5 +1,10 @@ """ -summary: decompile & print current function. +summary: decompile & print current function + +description: + Decompile the function under the cursor + +level: beginner """ import ida_hexrays diff --git a/examples/hexrays/vds10.py b/examples/decompiler/vds10.py similarity index 96% rename from examples/hexrays/vds10.py rename to examples/decompiler/vds10.py index bd57153..f167133 100644 --- a/examples/hexrays/vds10.py +++ b/examples/decompiler/vds10.py @@ -1,5 +1,5 @@ """ -summary: a custom microcode instruction optimization rule +summary: add custom microcode instruction optimization rule description: Installs a custom microcode instruction optimization rule, @@ -12,6 +12,8 @@ description: call !DbgRaiseAssertionFailure <fast:"char *" "assertion text">.0 To see this plugin in action please use arm64_brk.i64 + +level: intermediate """ import ida_bytes diff --git a/examples/hexrays/vds11.py b/examples/decompiler/vds11.py similarity index 97% rename from examples/hexrays/vds11.py rename to examples/decompiler/vds11.py index be84155..ecc856d 100644 --- a/examples/hexrays/vds11.py +++ b/examples/decompiler/vds11.py @@ -1,5 +1,5 @@ """ -summary: a custom microcode block optimization rule (resolve `goto` chains) +summary: add a custom microcode block optimization rule description: Installs a custom microcode block optimization rule, @@ -16,6 +16,8 @@ description: In other words we fix a goto target if it points to a chain of gotos. This improves the decompiler output in some cases. + +level: advanced """ import ida_bytes diff --git a/examples/hexrays/vds12.py b/examples/decompiler/vds12.py similarity index 99% rename from examples/hexrays/vds12.py rename to examples/decompiler/vds12.py index 05608d6..e674eca 100644 --- a/examples/hexrays/vds12.py +++ b/examples/decompiler/vds12.py @@ -4,6 +4,8 @@ summary: list instruction registers description: Shows a list of direct references to a register from the current instruction. + +level: advanced """ import ida_pro diff --git a/examples/hexrays/vds13.py b/examples/decompiler/vds13.py similarity index 92% rename from examples/hexrays/vds13.py rename to examples/decompiler/vds13.py index be9124f..7230bf2 100644 --- a/examples/hexrays/vds13.py +++ b/examples/decompiler/vds13.py @@ -1,8 +1,10 @@ """ -summary: generates microcode for selection +summary: generate microcode for the selected range of instructions description: Generates microcode for selection and dumps it to the output window. + +level: beginner """ import ida_bytes diff --git a/examples/hexrays/vds17.py b/examples/decompiler/vds17.py similarity index 99% rename from examples/hexrays/vds17.py rename to examples/decompiler/vds17.py index 1563920..6ba30a9 100644 --- a/examples/hexrays/vds17.py +++ b/examples/decompiler/vds17.py @@ -1,5 +1,5 @@ """ -summary: using the "Select offsets" widget +summary: invoke the structure offset-choosing dialog from decompilation description: Registers an action opens the "Select offsets" widget @@ -9,6 +9,8 @@ description: through Alt+Y. Place cursor on the union field and press Shift+T + +level: advanced """ import ida_idaapi diff --git a/examples/hexrays/vds19.py b/examples/decompiler/vds19.py similarity index 96% rename from examples/hexrays/vds19.py rename to examples/decompiler/vds19.py index 9bbcfa1..1748f61 100644 --- a/examples/hexrays/vds19.py +++ b/examples/decompiler/vds19.py @@ -1,5 +1,5 @@ """ -summary: a custom microcode instruction optimization rule (`x | ~x => -1`) +summary: add a custom microcode instruction optimization rule description: Installs a custom microcode instruction optimization rule, @@ -12,6 +12,8 @@ description: -1 To see this plugin in action please use be_ornot_be.idb + +level: advanced """ import ida_hexrays diff --git a/examples/hexrays/vds21.py b/examples/decompiler/vds21.py similarity index 99% rename from examples/hexrays/vds21.py rename to examples/decompiler/vds21.py index 3292bed..7178864 100644 --- a/examples/hexrays/vds21.py +++ b/examples/decompiler/vds21.py @@ -22,6 +22,8 @@ description: This plugin illustrates another approach to the problem: if you happen to be able to calculate the call prototypes dynamically, this is how to inform the decompiler about them. + +level: intermediate """ import ida_idaapi diff --git a/examples/hexrays/vds3.py b/examples/decompiler/vds3.py similarity index 99% rename from examples/hexrays/vds3.py rename to examples/decompiler/vds3.py index b7558cb..c65a62e 100644 --- a/examples/hexrays/vds3.py +++ b/examples/decompiler/vds3.py @@ -1,5 +1,5 @@ """ -summary: invert if/else blocks +summary: invert if/else blocks in decompilation description: Registers an action that can be used to invert the `if` @@ -31,6 +31,8 @@ description: IDA, and the changes will be present. author: EiNSTeiN_ (einstein@g3nius.org) + +level: advanced """ import idautils diff --git a/examples/hexrays/vds4.py b/examples/decompiler/vds4.py similarity index 97% rename from examples/hexrays/vds4.py rename to examples/decompiler/vds4.py index 3249d8f..3fdfd9d 100644 --- a/examples/hexrays/vds4.py +++ b/examples/decompiler/vds4.py @@ -1,5 +1,5 @@ """ -summary: dump user-defined information +summary: dump user-defined information for a function description: Prints user-defined information to the "Output" window. @@ -13,6 +13,8 @@ description: This script loads information from the database without decompiling anything. author: EiNSTeiN_ (einstein@g3nius.org) + +level: intermediate """ import ida_kernwin diff --git a/examples/hexrays/vds5.py b/examples/decompiler/vds5.py similarity index 99% rename from examples/hexrays/vds5.py rename to examples/decompiler/vds5.py index e467040..ffc78d5 100644 --- a/examples/hexrays/vds5.py +++ b/examples/decompiler/vds5.py @@ -1,5 +1,5 @@ """ -summary: show ctree graph +summary: dump C-tree graph description: Registers an action that can be used to show the graph of the ctree. @@ -10,6 +10,8 @@ description: To display the graph, we produce a .gdl file, and request that ida displays that using `ida_gdl.display_gdl`. + +level: advanced """ import ida_pro diff --git a/examples/hexrays/vds6.py b/examples/decompiler/vds6.py similarity index 99% rename from examples/hexrays/vds6.py rename to examples/decompiler/vds6.py index 2278c80..541a082 100644 --- a/examples/hexrays/vds6.py +++ b/examples/decompiler/vds6.py @@ -6,6 +6,8 @@ description: by removing some white spaces Note: this is rather crude, not quite "pythonic" code. + +level: intermediate """ import idautils diff --git a/examples/hexrays/vds7.py b/examples/decompiler/vds7.py similarity index 95% rename from examples/hexrays/vds7.py rename to examples/decompiler/vds7.py index ddc296a..2023b68 100644 --- a/examples/hexrays/vds7.py +++ b/examples/decompiler/vds7.py @@ -1,11 +1,13 @@ """ -summary: iterate a cblock_t object +summary: dump statement blocks description: Using a `ida_hexrays.ctree_visitor_t`, search for `ida_hexrays.cit_block` instances and dump them. author: EiNSTeiN_ (einstein@g3nius.org) + +level: beginner """ import ida_hexrays diff --git a/examples/hexrays/vds8.py b/examples/decompiler/vds8.py similarity index 96% rename from examples/hexrays/vds8.py rename to examples/decompiler/vds8.py index 7ac700e..6f73e75 100644 --- a/examples/hexrays/vds8.py +++ b/examples/decompiler/vds8.py @@ -1,5 +1,5 @@ """ -summary: using `ida_hexrays.udc_filter_t` +summary: improve decompilation by turning specific patterns into custom function calls description: Registers an action that uses a `ida_hexrays.udc_filter_t` to decompile @@ -10,6 +10,8 @@ description: In addition to having a shortcut, the action will be present in the context menu. + +level: intermediate """ import ida_idaapi diff --git a/examples/hexrays/vds_create_hint.py b/examples/decompiler/vds_create_hint.py similarity index 94% rename from examples/hexrays/vds_create_hint.py rename to examples/decompiler/vds_create_hint.py index f5326d9..b110f6c 100644 --- a/examples/hexrays/vds_create_hint.py +++ b/examples/decompiler/vds_create_hint.py @@ -1,5 +1,5 @@ """ -summary: decompiler hints +summary: provide custom decompiler hints description: Handle `ida_hexrays.hxe_create_hint` notification using hooks, @@ -12,6 +12,8 @@ description: the form of `!{varname}` (where `{varname}` is replaced with the variable name) * an `if` statement, replace the hint with our own, saying "condition" + +level: beginner """ import ida_idaapi diff --git a/examples/hexrays/vds_hooks.py b/examples/decompiler/vds_hooks.py similarity index 88% rename from examples/hexrays/vds_hooks.py rename to examples/decompiler/vds_hooks.py index 35d6e2e..de9b071 100644 --- a/examples/hexrays/vds_hooks.py +++ b/examples/decompiler/vds_hooks.py @@ -1,5 +1,5 @@ """ -summary: various decompiler hooks +summary: react to decompiler events/notifications description: Shows how to hook to many notifications sent by the decompiler. @@ -12,6 +12,8 @@ description: subclassing `ida_hexrays.Hexrays_Hooks` see_also: curpos_details + +level: intermediate """ import inspect @@ -70,7 +72,7 @@ class vds_hooks_t(ida_hexrays.Hexrays_Hooks): print("### %s: %s" % (method_name, ", ".join(argstrs))) return 0 - def flowchart(self, fc): + def flowchart(self, fc, mba, reachable_blocks, decomp_flags): return self._log() def stkpnts(self, mba, stkpnts): @@ -94,6 +96,9 @@ class vds_hooks_t(ida_hexrays.Hexrays_Hooks): def glbopt(self, mba): return self._log() + def begin_structural(self, out, cfunc, ctrl_graph): + return self._log() + def structural(self, ctrl_graph): return self._log() @@ -172,5 +177,20 @@ class vds_hooks_t(ida_hexrays.Hexrays_Hooks): def calls_done(self, mba): return self._log() + def begin_inlining(self, cdg, flags): + return self._log() + + def inlining_func(self, cdg, blk, mbr): + return self._log() + + def inlined_func(self, cdg, blk, mbr, i1, i2): + return self._log() + + def pre_structural(self, ctrl_graph, cfunc, cfg): + return self._log() + + def collect_warnings(self, cfunc): + return self._log() + vds_hooks = vds_hooks_t() vds_hooks.hook() diff --git a/examples/hexrays/vds_modify_user_lvars.py b/examples/decompiler/vds_modify_user_lvars.py similarity index 96% rename from examples/hexrays/vds_modify_user_lvars.py rename to examples/decompiler/vds_modify_user_lvars.py index f532e64..59f8261 100644 --- a/examples/hexrays/vds_modify_user_lvars.py +++ b/examples/decompiler/vds_modify_user_lvars.py @@ -1,9 +1,11 @@ """ -summary: modifying local variables +summary: modifying function local variables description: Use a `ida_hexrays.user_lvar_modifier_t` to modify names, comments and/or types of local variables. + +level: intermediate """ import ida_hexrays diff --git a/examples/hexrays/vds_xrefs.py b/examples/decompiler/vds_xrefs.py similarity index 99% rename from examples/hexrays/vds_xrefs.py rename to examples/decompiler/vds_xrefs.py index 74d2d77..ef8e461 100644 --- a/examples/hexrays/vds_xrefs.py +++ b/examples/decompiler/vds_xrefs.py @@ -1,5 +1,5 @@ """ -summary: show decompiler xrefs +summary: show decompiler cross-references description: Show decompiler-style Xref when the `Ctrl+X` key is @@ -9,6 +9,8 @@ description: * supports structure member. author: EiNSTeiN_ (einstein@g3nius.org) + +level: advanced """ import ida_kernwin diff --git a/examples/disassembler/add_frame_member.py b/examples/disassembler/add_frame_member.py new file mode 100644 index 0000000..387e671 --- /dev/null +++ b/examples/disassembler/add_frame_member.py @@ -0,0 +1,61 @@ +""" +summary: add a new member to an existing function frame + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we show a way to add a new frame member (a pointer to + an uint64) inside a wide enough gap in the frame: + * Get the function object surrounding cursor location. + * Use this function to retrieve the corresponding frame object. + * Find a wide enough gap to create our new member. + * If found, we use cal_frame_offset() to get the actual + offset in the frame structure. + * Use the previous result to add the new member. + +level: advanced +""" +import ida_funcs +import ida_frame +import ida_typeinf +import ida_range +import idc + +def add_frame_member(func_ea): + name = "my_stkvar" + + tif = ida_typeinf.tinfo_t(ida_typeinf.BTF_UINT64) + tif.create_ptr(tif) + + func = ida_funcs.get_func(func_ea) + if not func: + print('Failed to get function!') + return + print(f"Function @ {func.start_ea:x}") + + frame_tif = ida_typeinf.tinfo_t() + if not ida_frame.get_func_frame(frame_tif, func): + print('Failed to get frame!') + return + print(f"{frame_tif._print()}") + + rs = ida_range.rangeset_t() + sp_offset = 0 + if frame_tif.calc_gaps(rs): + for range in rs: + if range.start_ea <= 0: + continue + elif (range.end_ea - range.start_ea) >= tif.get_size(): + sp_offset = range.start_ea + print(f"Range [{range.start_ea:x}, {range.end_ea:x}[ selected.") + break + + if sp_offset > 0: + sval = ida_frame.calc_frame_offset(func, sp_offset, None, None) + if ida_frame.add_frame_member(func, name, sval, tif): + print(f"Frame member added at frame offset {sval}!") + else: + print("Failed adding frame member") + else: + print("Could not find gaps in current frame...") + +add_frame_member(idc.here()) diff --git a/examples/idphooks/ana_emu_out.py b/examples/disassembler/ana_emu_out.py similarity index 94% rename from examples/idphooks/ana_emu_out.py rename to examples/disassembler/ana_emu_out.py index e7c0741..8cb93e0 100644 --- a/examples/idphooks/ana_emu_out.py +++ b/examples/disassembler/ana_emu_out.py @@ -1,5 +1,5 @@ """ -summary: override some parts of the processor module +summary: rewrite the representation of some instructions description: Implements disassembly of BUG_INSTR used in Linux kernel @@ -7,6 +7,8 @@ description: disassembled by IDA's ARM module See Linux/arch/arm/include/asm/bug.h for more info + +level: intermediate """ import ida_idp diff --git a/examples/idphooks/assemble.py b/examples/disassembler/assemble.py similarity index 94% rename from examples/idphooks/assemble.py rename to examples/disassembler/assemble.py index 0078bbd..84e0c32 100644 --- a/examples/idphooks/assemble.py +++ b/examples/disassembler/assemble.py @@ -1,11 +1,13 @@ """ -summary: an `ida_idp.IDP_Hooks.assembly` implementation +summary: implement assembly of instructions description: We add support for assembling the following pseudo instructions: * "zero eax" -> xor eax, eax * "nothing" -> nop + +level: intermediate """ import ida_idp diff --git a/examples/core/custom_data_types_and_formats.py b/examples/disassembler/custom_data_types_and_formats.py similarity index 96% rename from examples/core/custom_data_types_and_formats.py rename to examples/disassembler/custom_data_types_and_formats.py index 392bf37..7a39893 100644 --- a/examples/core/custom_data_types_and_formats.py +++ b/examples/disassembler/custom_data_types_and_formats.py @@ -1,5 +1,5 @@ """ -summary: using custom data types & printers +summary: custom data types & printers description: IDA can be extended to support certain data types that it @@ -9,6 +9,8 @@ description: size of a piece of data, while a 'custom data format' is in charge of formatting that data (there can be more than one format for a specific 'custom data type'.) + +level: advanced """ import ida_bytes @@ -64,7 +66,7 @@ class pascal_data_format(ida_bytes.data_format_t): for ch in value[1:]: b = ord(ch) if sys.version_info.major < 3 else ch if b < 0x20 or b > 128: - o.append(r'\x%02x' % b) + o.append(r"\x%02x" % b) else: o.append(ch) o.append('"') @@ -111,8 +113,8 @@ class simplevm_data_format(ida_bytes.data_format_t): menu_name) # Some tables for the disassembler - INST = {1: 'add', 2: 'mul', 3: 'sub', 4: 'xor', 5: 'mov'} - REGS = {1: 'r1', 2: 'r2', 3: 'r3'} + INST = {1: "add", 2: "mul", 3: "sub", 4: "xor", 5: "mov"} + REGS = {1: "r1", 2: "r2", 3: "r3"} def disasm(self, inst): """A simple local disassembler. In reality one can use a full-blown disassembler to render the text""" opbyte = ord(inst[0]) if sys.version_info.major < 3 else inst[0] @@ -125,7 +127,7 @@ class simplevm_data_format(ida_bytes.data_format_t): if r2 == 0: if len(inst) != 5: return None - imm = struct.unpack_from('L', inst, 1)[0] + imm = struct.unpack_from("L", inst, 1)[0] sz = 5 else: imm = None @@ -226,7 +228,7 @@ new_formats = [ ] try: - if platform.system() == 'Windows': + if platform.system() == "Windows": new_formats.append((rsrc_string_format(),)) except: pass diff --git a/examples/core/dump_extra_comments.py b/examples/disassembler/dump_extra_comments.py similarity index 97% rename from examples/core/dump_extra_comments.py rename to examples/disassembler/dump_extra_comments.py index 6205282..7904b42 100644 --- a/examples/core/dump_extra_comments.py +++ b/examples/disassembler/dump_extra_comments.py @@ -1,5 +1,5 @@ """ -summary: retrieve extra comments +summary: retrieve comments surrounding instructions description: Use the `ida_lines.get_extra_cmt` API to retrieve anterior @@ -7,6 +7,8 @@ description: This script registers two actions, that can be used to dump the previous and next extra comments. + +level: intermediate """ import ida_lines diff --git a/examples/core/dump_flowchart.py b/examples/disassembler/dump_flowchart.py similarity index 99% rename from examples/core/dump_flowchart.py rename to examples/disassembler/dump_flowchart.py index dd705cf..c90c4a2 100644 --- a/examples/core/dump_flowchart.py +++ b/examples/disassembler/dump_flowchart.py @@ -8,6 +8,8 @@ description: * the low-level `ida_gdl.qflow_chart_t` type * the somewhat higher-level, and slightly more pythonic `ida_gdl.FlowChart` type. + +level: beginner """ import ida_gdl diff --git a/examples/analysis/dump_func_info.py b/examples/disassembler/dump_func_info.py similarity index 98% rename from examples/analysis/dump_func_info.py rename to examples/disassembler/dump_func_info.py index 4e327cc..ce64582 100644 --- a/examples/analysis/dump_func_info.py +++ b/examples/disassembler/dump_func_info.py @@ -1,9 +1,11 @@ """ -summary: dump (some) information about the current function. +summary: dump function information description: Dump some of the most interesting bits of information about the function we are currently looking at. + +level: intermediate """ import binascii diff --git a/examples/disassembler/dump_line_sections.py b/examples/disassembler/dump_line_sections.py new file mode 100644 index 0000000..416364b --- /dev/null +++ b/examples/disassembler/dump_line_sections.py @@ -0,0 +1,53 @@ +""" +summary: parse listing line, and dump some information + +description: + Using `ida_kernwin.parse_tagged_line_sections`, we will parse + so-called "tagged" listing lines, and extract semantic information + such as instruction mnemonic, operand text, ... + + This script registers an actions, that can be used to dump + the line sections. + +level: intermediate +""" + +ACTION_NAME = "dump_line_sections:dump" +ACTION_SHORTCUT = "Ctrl+Shift+D" + +import ida_kernwin +import ida_lines + +class dump_line_sections_ah_t(ida_kernwin.action_handler_t): + + def activate(self, ctx): + tls = ida_kernwin.tagged_line_sections_t() + raw = ida_kernwin.get_custom_viewer_curline(ctx.widget, False) + if ida_kernwin.parse_tagged_line_sections(tls, raw): + insn_section = tls.first(ida_lines.COLOR_INSN) + if insn_section: + print("Found instruction with mnemonic \"%s\"" % insn_section.substr(raw)) + for op_tag in range(ida_lines.COLOR_OPND1, ida_lines.COLOR_OPND8 + 1): + op_n = tls.first(op_tag) + if not op_n: + break + print(" Operand #%d: (raw text) %s" % (op_tag - ida_lines.COLOR_OPND1, op_n.substr(raw))) + as_reg = tls.nearest_at(op_n.start, ida_lines.COLOR_REG) + if as_reg: + print(" Operand is register: \"%s\"" % as_reg.substr(raw)) + + def update(self, ctx): + return ida_kernwin.AST_ENABLE_FOR_WIDGET \ + if ctx.widget_type == ida_kernwin.BWN_DISASM \ + else ida_kernwin.AST_DISABLE_FOR_WIDGET + + + +adesc = ida_kernwin.action_desc_t( + ACTION_NAME, + "Dump line sections", + dump_line_sections_ah_t(), + ACTION_SHORTCUT) + +if ida_kernwin.register_action(adesc): + print("Action registered. Please press \"%s\" to use" % ACTION_SHORTCUT) diff --git a/examples/disassembler/find_string.py b/examples/disassembler/find_string.py new file mode 100644 index 0000000..1c6aa5b --- /dev/null +++ b/examples/disassembler/find_string.py @@ -0,0 +1,74 @@ +""" +summary: using "ida_bytes.find_string" + +description: + IDAPython's ida_bytes.find_string can be used to implement + a simple replacement for the 'Search > Sequence of bytes...' + dialog, that lets users search for sequences of bytes that + compose string literals in the binary file (either in the + default 1-byte-per-char encoding, or as UTF-16.) + +level: intermediate +""" + +import ida_kernwin +import ida_bytes +import ida_ida +import ida_idaapi +import ida_nalt + +class search_strlit_form_t(ida_kernwin.Form): + def __init__(self): + ida_kernwin.Form.__init__( + self, + r"""Please enter string literal + +<Text: {Text}> +<#UTF16-BE if file is big-endian, UTF16-LE otherwise#As UTF-16: {UTF16}>{Encoding}> +""", + { + "Text" : ida_kernwin.Form.StringInput(), + "Encoding" : ida_kernwin.Form.ChkGroupControl(("UTF16",)), + }) + +class search_strlit_ah_t(ida_kernwin.action_handler_t): + def __init__(self): + ida_kernwin.action_handler_t.__init__(self) + + def activate(self, ctx): + f = search_strlit_form_t() + f, args = f.Compile() + ok = f.Execute() + if ok: + current_ea = ida_kernwin.get_screen_ea() + encoding = ida_nalt.get_default_encoding_idx( + ida_nalt.BPU_2B if f.Encoding.value else ida_nalt.BPU_1B) + ea = ida_bytes.find_string( + f.Text.value, + current_ea, + range_end=ida_ida.inf_get_max_ea(), + strlit_encoding=encoding, + flags=ida_bytes.BIN_SEARCH_FORWARD + | ida_bytes.BIN_SEARCH_NOBREAK + | ida_bytes.BIN_SEARCH_NOSHOW) + ok = ea != ida_idaapi.BADADDR + if ok: + ida_kernwin.jumpto(ea) + return ok + + def update(self, ctx): + return ida_kernwin.AST_ENABLE_FOR_WIDGET \ + if ctx.widget_type == ida_kernwin.BWN_DISASM \ + else ida_kernwin.AST_DISABLE_FOR_WIDGET + + +ACTION_NAME = "find_string:search" +ACTION_SHORTCUT = "Ctrl+Shift+S" + +if ida_kernwin.register_action( + ida_kernwin.action_desc_t( + ACTION_NAME, + "Search for string literal", + search_strlit_ah_t(), + ACTION_SHORTCUT)): + print("Please use \"%s\" to search for string literals" % ACTION_SHORTCUT) diff --git a/examples/disassembler/func_ti_changed_listener.py b/examples/disassembler/func_ti_changed_listener.py new file mode 100644 index 0000000..3fd6671 --- /dev/null +++ b/examples/disassembler/func_ti_changed_listener.py @@ -0,0 +1,36 @@ +""" +summary: print notifications about function prototype changes + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we will create an IDB hook that intercepts `ti_changed` + IDB events, and if it is a function prototype that changed, print it. + +level: intermediate +""" +import ida_funcs +import ida_idp +import ida_typeinf + +class ti_changed_t(ida_idp.IDB_Hooks): + + def print_details(self, tif, ea): + if tif.is_func(): + func_name = ida_funcs.get_func_name(ea) + print(f"\t{tif._print(func_name)}") + + def ti_changed(self, ea, types, fields): + tif = ida_typeinf.tinfo_t() + tif.deserialize(None, types, fields) + if tif.is_func(): + print(f"Function type information changed @ {ea:x}") + self.print_details(tif, ea) + +try: + idbhook.unhook() + del idbhook + print(f"IDB hook uninstalled. Run the script again to install") +except: + idbhook = ti_changed_t() + idbhook.hook() + print(f"IDB hook installed. Run the script again to uninstall") diff --git a/examples/core/install_user_defined_prefix.py b/examples/disassembler/install_user_defined_prefix.py similarity index 89% rename from examples/core/install_user_defined_prefix.py rename to examples/disassembler/install_user_defined_prefix.py index 8ddf136..59a2ce4 100644 --- a/examples/core/install_user_defined_prefix.py +++ b/examples/disassembler/install_user_defined_prefix.py @@ -1,17 +1,19 @@ """ -summary: inserting information into disassembly prefixes +summary: insert information into listing prefixes description: By default, disassembly line prefixes contain segment + address information (e.g., '.text:08047718'), but it is possible to "inject" other bits of information in there, thanks to the `ida_lines.user_defined_prefix_t` helper type. + +level: beginner """ import ida_lines import ida_idaapi -PREFIX = ida_lines.SCOLOR_INV + ' ' + ida_lines.SCOLOR_INV +PREFIX = ida_lines.SCOLOR_INV + " " + ida_lines.SCOLOR_INV class my_user_prefix_t(ida_lines.user_defined_prefix_t): def get_user_defined_prefix(self, ea, insn, lnnum, indent, line): diff --git a/examples/core/list_bookmarks.py b/examples/disassembler/list_bookmarks.py similarity index 95% rename from examples/core/list_bookmarks.py rename to examples/disassembler/list_bookmarks.py index 645e577..0198a5f 100644 --- a/examples/core/list_bookmarks.py +++ b/examples/disassembler/list_bookmarks.py @@ -1,5 +1,5 @@ """ -summary: list bookmarks associated to a listing +summary: list listing bookmarks description: This sample shows how to programmatically access the list of @@ -8,6 +8,8 @@ description: type. keywords: bookmarks + +level: intermediate """ import ida_kernwin diff --git a/examples/core/list_function_items.py b/examples/disassembler/list_function_items.py similarity index 96% rename from examples/core/list_function_items.py rename to examples/disassembler/list_function_items.py index efffa8a..7f1a5c8 100644 --- a/examples/core/list_function_items.py +++ b/examples/disassembler/list_function_items.py @@ -1,5 +1,5 @@ """ -summary: showcases (a few of) the iterators available on a function +summary: showcase (some of) the iterators available on a function description: This demonstrates how to use some of the iterators available on the func_t type. @@ -23,6 +23,8 @@ description: that include this chunk keywords: funcs iterator + +level: intermediate """ import ida_bytes @@ -98,5 +100,5 @@ def main(): chunk.start_ea, chunk.end_ea)) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/examples/core/list_imports.py b/examples/disassembler/list_imports.py similarity index 97% rename from examples/core/list_imports.py rename to examples/disassembler/list_imports.py index 72d974e..f889151 100644 --- a/examples/core/list_imports.py +++ b/examples/disassembler/list_imports.py @@ -3,6 +3,8 @@ summary: enumerate file imports description: Using the API to enumerate file imports. + +level: beginner """ import ida_nalt diff --git a/examples/core/list_patched_bytes.py b/examples/disassembler/list_patched_bytes.py similarity index 96% rename from examples/core/list_patched_bytes.py rename to examples/disassembler/list_patched_bytes.py index af7ca82..c6bb15b 100644 --- a/examples/core/list_patched_bytes.py +++ b/examples/disassembler/list_patched_bytes.py @@ -4,6 +4,8 @@ summary: enumerate patched bytes description: Using the API to iterate over all the places in the file, that were patched using IDA. + +level: beginner """ import ida_bytes @@ -37,5 +39,5 @@ def main(): # ------------------------------------------------------------------------- -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/examples/core/list_problems.py b/examples/disassembler/list_problems.py similarity index 90% rename from examples/core/list_problems.py rename to examples/disassembler/list_problems.py index 054c240..f984aa9 100644 --- a/examples/core/list_problems.py +++ b/examples/disassembler/list_problems.py @@ -1,9 +1,11 @@ """ -summary: enumerate problems +summary: enumerate known problems description: - Using the API to list all problem[atic situation]s that IDA + Using the API to list all problems that IDA encountered during analysis. + +level: beginner """ import ida_ida diff --git a/examples/core/list_segment_functions.py b/examples/disassembler/list_segment_functions.py similarity index 84% rename from examples/core/list_segment_functions.py rename to examples/disassembler/list_segment_functions.py index e32ce57..0a71352 100644 --- a/examples/core/list_segment_functions.py +++ b/examples/disassembler/list_segment_functions.py @@ -1,5 +1,5 @@ """ -summary: list all functions (and xrefs) in segment +summary: list segment functions (and cross-references to them) description: List all the functions in the current segment, as well as @@ -8,15 +8,9 @@ description: keywords: xrefs see_also: list_segment_functions_using_idautils -""" -# -# Reference Lister -# -# List all functions and all references to them in the current section. -# -# Implemented using direct IDA Plugin API calls -# +level: beginner +""" import ida_kernwin import ida_segment diff --git a/examples/core/list_segment_functions_using_idautils.py b/examples/disassembler/list_segment_functions_using_idautils.py similarity index 83% rename from examples/core/list_segment_functions_using_idautils.py rename to examples/disassembler/list_segment_functions_using_idautils.py index c983e46..bf93a77 100644 --- a/examples/core/list_segment_functions_using_idautils.py +++ b/examples/disassembler/list_segment_functions_using_idautils.py @@ -1,5 +1,5 @@ """ -summary: list all functions (and xrefs) in segment +summary: list all functions (and cross-references) in segment description: List all the functions in the current segment, as well as @@ -11,15 +11,9 @@ description: keywords: xrefs see_also: list_segment_functions -""" -# -# Reference Lister -# -# List all functions and all references to them in the current section. -# -# Implemented with the idautils module -# +level: beginner +""" import ida_kernwin import ida_idaapi @@ -47,5 +41,5 @@ def main(): else: print("Please position the cursor within a segment") -if __name__=='__main__': +if __name__=="__main__": main() diff --git a/examples/core/list_strings.py b/examples/disassembler/list_strings.py similarity index 89% rename from examples/core/list_strings.py rename to examples/disassembler/list_strings.py index 8cb2a3c..9cc4333 100644 --- a/examples/core/list_strings.py +++ b/examples/disassembler/list_strings.py @@ -1,5 +1,5 @@ """ -summary: retrieve the strings that are present in the IDB +summary: dump the strings that are present in the file description: This uses `idautils.Strings` to iterate over the string literals @@ -7,6 +7,8 @@ description: this will not require that the "Strings" window is opened & available. see_also: show_selected_strings + +level: beginner """ import ida_nalt diff --git a/examples/disassembler/list_struct_accesses.py b/examples/disassembler/list_struct_accesses.py new file mode 100644 index 0000000..2adb188 --- /dev/null +++ b/examples/disassembler/list_struct_accesses.py @@ -0,0 +1,125 @@ +""" +summary: list operands representing a "path" to a (possibly nested) structure member + +description: + It is possible to assign, to instruction operands, the notion of "structure + offset", which really is a pointer to a specific offset in a type, leading + to a possible N-deep path within types. + + E.g., assuming the following types + + struct c + { + int foo; + int bar; + int baz; + int quux; + int trail; + }; + + struct b + { + int gap; + c c_instance; + }; + + struct a + { + int count; + b b_instance; + }; + + and assuming an instruction that initially looks like this: + + mov eax, 10h + + by pressing `t`, the user will be able set the "structure offset" + to either: + + * `c.trail` + * `b.c_instance.quux` + * `a.b_inscance.c_instance.baz` + + Here's why IDA offers `a.b_inscance.c_instance.baz`: + + 0000 struct a + { + 0000 int count; + 0004 struct b + { + 0004 int gap; + 0008 struct c + { + 0008 int foo; + 000C int bar; + 0010 int baz; + 0014 int quux; + 0018 int trail; + }; + }; + }; + + This sample shows how to programmatically retrieve information about + that "structure member path" that an operand was made pointing to. + +keywords: bookmarks + +level: advanced +""" +from typing import List + +import ida_bytes +import ida_pro +import ida_ua +import ida_typeinf +import ida_nalt +import ida_netnode + + +def get_struct_paths(ea: int, opnum: int) -> List[str]: + flags = ida_bytes.get_full_flags(ea) + + if not ida_bytes.is_stroff(flags, opnum): + # requested operand not a structure + return [] + + insn = ida_ua.insn_t() + ins_sz = ida_ua.decode_insn(insn, ea) + if ins_sz == 0: + # could not disassemble + return [] + + num_ops = 0 + # ;! nice idea to inject via Swig a '__len__' method to the instruction + # object that does that. + while insn.ops[num_ops].type != ida_ua.o_void: + num_ops += 1 + + op = insn.ops[opnum] + + if op.type == ida_ua.o_imm: + value = op.value + else: + value = op.addr + + path, delta = ida_bytes.get_stroff_path(insn.ea, opnum) + out = [] + for tid in path: + tif = ida_typeinf.tinfo_t(tid=tid) + sz = tif.get_size() + + if delta + value == sz: + out.append(f"size {tif.get_type_name()}") + else: + for idx, mem in enumerate(tif.iter_udt()): + off = mem.offset // 8 # udm.offset is in bits + size = mem.size // 8 # udm.size is in bits + if off - delta <= value < off - delta + size: + name = ida_typeinf.get_tid_name(tif.get_udm_tid(idx)) + diff = value - (off - delta) + if diff > 0: + out.append(f"{name}+{diff}") + else: + out.append(f"{name}") + + return out diff --git a/examples/idbhooks/log_idb_events.py b/examples/disassembler/log_idb_events.py similarity index 79% rename from examples/idbhooks/log_idb_events.py rename to examples/disassembler/log_idb_events.py index 410aec4..2e56968 100644 --- a/examples/idbhooks/log_idb_events.py +++ b/examples/disassembler/log_idb_events.py @@ -1,9 +1,11 @@ """ -summary: logging IDB events +summary: react to database events/notifications description: these hooks will be notified about IDB events, and dump their information to the "Output" window + +level: intermediate """ import inspect @@ -58,12 +60,6 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def changing_cmt(self, ea, is_repeatable, new_comment): return self._log() - def changing_enum_bf(self, tid, new_bf): - return self._log() - - def changing_enum_cmt(self, tid, is_repeatable, new_comment): - return self._log() - def changing_op_ti(self, ea, n, new_type, new_fnames): return self._log() @@ -85,9 +81,6 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def changing_segm_start(self, segment, new_start, flags): return self._log() - def changing_struc_align(self, sptr): - return self._log() - def changing_struc_cmt(self, tid, is_repeatable, comment): return self._log() @@ -106,12 +99,6 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def compiler_changed(self, may_adjust_inf_fields): return self._log() - def deleting_enum(self, tid): - return self._log() - - def deleting_enum_member(self, tid, cid): - return self._log() - def deleting_func(self, pfn): return self._log() @@ -121,12 +108,6 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def deleting_segm(self, start_ea): return self._log() - def deleting_struc(self, sptr): - return self._log() - - def deleting_struc_member(self, sptr, mptr): - return self._log() - def deleting_tryblks(self, _range): return self._log() @@ -157,30 +138,6 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def dirtree_segm_moved(self, dt): return self._log() - def enum_bf_changed(self, tid): - return self._log() - - def enum_cmt_changed(self, tid, is_repeatable): - return self._log() - - def enum_created(self, tid): - return self._log() - - def enum_deleted(self, tid): - return self._log() - - def enum_member_created(self, tid, cid): - return self._log() - - def enum_member_deleted(self, tid, cid): - return self._log() - - def enum_renamed(self, tid): - return self._log() - - def expanding_struc(self, sptr, offset, delta): - return self._log() - def extlang_changed(self, kind, el, idx): return self._log() @@ -214,6 +171,9 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def idasgn_loaded(self, sig_name): return self._log() + def idasgn_matched_ea(self, ea, name, lib): + return self._log() + def item_color_changed(self, ea, color): return self._log() @@ -244,15 +204,6 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def renamed(self, ea, new_name, is_local_name, old_name): return self._log() - def renaming_enum(self, tid, is_enum, new_name): - return self._log() - - def renaming_struc(self, tid, old_name, new_name): - return self._log() - - def renaming_struc_member(self, sptr, mptr, new_name): - return self._log() - def savebase(self): return self._log() @@ -295,36 +246,9 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def stkpnts_changed(self, pfn): return self._log() - def struc_align_changed(self, sptr): - return self._log() - - def struc_cmt_changed(self, tid, is_repeatable): - return self._log() - - def struc_created(self, tid): - return self._log() - - def struc_deleted(self, tid): - return self._log() - - def struc_expanded(self, sptr): - return self._log() - def struc_member_changed(self, sptr, mptr): return self._log() - def struc_member_created(self, sptr, mptr): - return self._log() - - def struc_member_deleted(self, sptr, mid, offset): - return self._log() - - def struc_member_renamed(self, sptr, mptr): - return self._log() - - def struc_renamed(self, sptr, success): - return self._log() - def tail_owner_changed(self, tail, owner_func, old_owner): return self._log() @@ -343,15 +267,41 @@ class idb_logger_hooks_t(ida_idp.IDB_Hooks): def upgraded(self, _from): return self._log() - def enum_width_changed(self, tid, width): + def lt_udm_created(self, udt_name, udm): return self._log() - def enum_flag_changed(self, tid, flags): + def lt_udm_deleted(self, udt_name, udm_tid, udm): return self._log() - def enum_ordinal_changed(self, tid, ordinal): + def lt_udm_renamed(self, udt_name, udm, oldname): return self._log() + def lt_udm_changed(self, udt_name, tid, old, new): + return self._log() + + def lt_udt_expanded(self, udt_name, udm_tid, delta): + return self._log() + + def frame_created(self, func_ea): + return self._log() + + def frame_deleted(self, pfn): + return self._log() + + def frame_udm_created(self, func_ea, udm): + return self._log() + + def frame_udm_deleted(self, func_ea, udm_tid, udm): + return self._log() + + def frame_udm_renamed(self, func_ea, udm, oldname): + return self._log() + + def frame_udm_changed(self, func_ea, udm_tid, udm_old, udm_new): + return self._log() + + def frame_expanded(self, func_ea, udm_tid, delta): + return self._log() idb_hooks = idb_logger_hooks_t() idb_hooks.hook() diff --git a/examples/disassembler/log_idp_events.py b/examples/disassembler/log_idp_events.py new file mode 100644 index 0000000..b5c6979 --- /dev/null +++ b/examples/disassembler/log_idp_events.py @@ -0,0 +1,44 @@ +""" +summary: react to processor events/notifications + +description: + these hooks will be notified about IDP events, and + dump their information to the "Output" window + +level: intermediate +""" + +import inspect + +import ida_idp + +class idp_logger_hooks_t(ida_idp.IDP_Hooks): + + def __init__(self): + ida_idp.IDP_Hooks.__init__(self) + self.inhibit_log = 0; + + def _format_value(self, v): + return str(v) + + def _log(self, msg=None): + if self.inhibit_log <= 0: + if msg: + print(">>> idp_logger_hooks_t: %s" % msg) + else: + stack = inspect.stack() + frame, _, _, _, _, _ = stack[1] + args, _, _, values = inspect.getargvalues(frame) + method_name = inspect.getframeinfo(frame)[2] + argstrs = [] + for arg in args[1:]: + argstrs.append("%s=%s" % (arg, self._format_value(values[arg]))) + print(">>> idp_logger_hooks_t.%s: %s" % (method_name, ", ".join(argstrs))) + return 0 + + def get_abi_info(self, comp): + self._log() + return None, None + +idp_hooks = idp_logger_hooks_t() +idp_hooks.hook() diff --git a/examples/idbhooks/operand_changed.py b/examples/disassembler/operand_changed.py similarity index 92% rename from examples/idbhooks/operand_changed.py rename to examples/disassembler/operand_changed.py index 7b96c4e..05a1686 100644 --- a/examples/idbhooks/operand_changed.py +++ b/examples/disassembler/operand_changed.py @@ -4,6 +4,8 @@ summary: notify the user when an instruction operand changes description: Show notifications whenever the user changes an instruction's operand, or a data item. + +level: advanced """ import binascii @@ -25,13 +27,13 @@ class operand_changed_t(ida_idp.IDB_Hooks): opi = ida_bytes.get_opinfo(buf, ea, n, flags) if opi: if ida_bytes.is_struct(flags): - tif = ida_typeinf.tinfo_t() - if tif.get_type_by_tid(opi.tid): + try: + tif = ida_typeinf.tinfo_t(tid=opi.tid) self.log("New struct: 0x%08X ordinal: %d (name=%s)" % ( tif.get_tid(), tif.get_ordinal(), tif.get_type_name())) - else: + except: self.log("Failed tif") elif ida_bytes.is_strlit(flags): encidx = ida_nalt.get_str_encoding_idx(opi.strtype) @@ -54,14 +56,14 @@ class operand_changed_t(ida_idp.IDB_Hooks): opi.ri.tdelta, opi.ri.flags)) elif ida_bytes.is_enum(flags, n): - tif = ida_typeinf.tinfo_t() - if tif.get_type_by_tid(opi.ec.tid): + try: + tif = ida_typeinf.tinfo_t(tid=opi.ec.tid) self.log("New enum: 0x%08X ordinal: %d (enum=%s), serial=%d" % ( opi.ec.tid, tif.get_ordinal(), tif.get_type_name(), opi.ec.serial)) - else: + except: self.log("Failed tif") pass elif ida_bytes.is_stroff(flags, n): diff --git a/examples/core/produce_lst_file.py b/examples/disassembler/produce_lst_file.py similarity index 93% rename from examples/core/produce_lst_file.py rename to examples/disassembler/produce_lst_file.py index 6d54063..1ba1b1f 100644 --- a/examples/core/produce_lst_file.py +++ b/examples/disassembler/produce_lst_file.py @@ -1,5 +1,5 @@ """ -summary: produce listing +summary: produce disassembly listing for the entire file description: automate IDA to perform auto-analysis on a file and, @@ -14,6 +14,8 @@ description: * -A instructs IDA to run in non-interactive mode * -S holds a path to the script to run (note this is a single token; there is no space between '-S' and its path.) + +level: beginner """ import ida_auto diff --git a/examples/idbhooks/replay_prototypes_changes.py b/examples/disassembler/replay_prototypes_changes.py similarity index 97% rename from examples/idbhooks/replay_prototypes_changes.py rename to examples/disassembler/replay_prototypes_changes.py index afd5866..d308fa3 100644 --- a/examples/idbhooks/replay_prototypes_changes.py +++ b/examples/disassembler/replay_prototypes_changes.py @@ -1,5 +1,5 @@ """ -summary: Record and replay changes in function prototypes +summary: record and replay changes in function prototypes description: This is a sample script, that will record (in memory) all changes in @@ -15,6 +15,8 @@ description: Note: 'ti_changed' is also called for changes to the function frames, but we'll only record function prototypes changes. + +level: intermediate """ import ida_idp import ida_funcs diff --git a/examples/index.css b/examples/index.css deleted file mode 100644 index 8478dec..0000000 --- a/examples/index.css +++ /dev/null @@ -1,28 +0,0 @@ - -body -{ - margin: 3%; -} - -.exp-col -{ - cursor: pointer; - padding: 0 4px 0 6px; -} - -.collapsed-entry .details -{ - display: none; -} - -.example-entry .details -{ - margin-left: 3%; - padding: 6px; - background-color: #eef; -} - -a -{ - text-decoration: none; -} \ No newline at end of file diff --git a/examples/index.html b/examples/index.html deleted file mode 100644 index 0831210..0000000 --- a/examples/index.html +++ /dev/null @@ -1,4533 +0,0 @@ -<!-- -Used keywords: - actions - bookmarks - chooser - coloring - colors - ctxmenu - DBG_Hooks - desktop - folders - forms - funcs iterator - functions - graph - Hexrays_Hooks - idaview - IDB_Hooks - idc - IDP_Hooks - listing - plugin - UI_Hooks - View_Hooks - xrefs ---> -<html> - <head> - <meta charset="UTF-8"> - <title>IDAPython examples - - - - - - -
- Expand all - | - Collapse all -
- -

IDAPython examples:

-

Category: analysis

-
-
-
- ▹ - - dump_func_info: Dump (some) information about the current function. -
-
- -
-Dump some of the most interesting bits of information about
-the function we are currently looking at.
-
- -
    -
  • Category: analysis
    • -
  • Summary: Dump (some) information about the current function.
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_funcs.FUNC_FRAME
      • -
    • ida_funcs.FUNC_LUMINA
      • -
    • ida_funcs.FUNC_OUTLINE
      • -
    • ida_funcs.FUNC_THUNK
      • -
    • ida_funcs.get_fchunk
      • -
    • ida_funcs.is_func_entry
      • -
    • ida_funcs.is_func_tail
      • -
    • ida_kernwin.get_screen_ea
      • -
    -
    • - - -
-
-
- -
-

Category: core

-
-
-
- ▹ - - actions: Custom actions, with icons & tooltips -
-
- -
-How to create user actions, that once created can be
-inserted in menus, toolbars, context menus, ...
-
-Those actions, when triggered, will be passed a 'context'
-that contains some of the most frequently needed bits of
-information.
-
-In addition, custom actions can determine when they want
-to be available (through their
-`ida_kernwin.action_handler_t.update` callback)
-
- -
    -
  • Category: core
    • -
  • Summary: Custom actions, with icons & tooltips
    • -
  • View on GitHub
    • -
  • Keywords: - actions - ctxmenu - UI_Hooks -
    • - -
  • Shortcut: - Ctrl+F12 -
    • - - -
  • APIs used -
      -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_DISASM
      • -
    • ida_kernwin.SETMENU_APP
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_menu
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.attach_action_to_toolbar
      • -
    • ida_kernwin.get_widget_type
      • -
    • ida_kernwin.load_custom_icon
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.unregister_action
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - add_hotkey: Triggering bits of code by pressing a shortcut -
-
- -
-`ida_kernwin.add_hotkey` is a simpler, but much less flexible
-alternative to `ida_kernwin.register_action` (though it does
-use the same mechanism under the hood.)
-
-It's particularly useful during prototyping, but note that the
-actions that are created cannot be inserted in menus, toolbars
-or cannot provide a custom `ida_kernwin.action_handler_t.update`
-callback.
-
- -
    -
  • Category: core
    • -
  • Summary: Triggering bits of code by pressing a shortcut
    • -
  • View on GitHub
    • -
  • Keywords: - actions -
    • - - - -
  • APIs used -
      -
    • ida_kernwin.add_hotkey
      • -
    • ida_kernwin.del_hotkey
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - add_idc_hotkey: Triggering bits of code by pressing a shortcut (older version) -
-
- -
-This is a somewhat ancient way of registering actions & binding
-shortcuts. It's still here for reference, but "fresher" alternatives
-should be preferred.
-
- -
    -
  • Category: core
    • -
  • Summary: Triggering bits of code by pressing a shortcut (older version)
    • -
  • View on GitHub
    • -
  • Keywords: - actions -
    • - - - -
  • APIs used -
      -
    • ida_expr.compile_idc_text
      • -
    • ida_kernwin.add_idc_hotkey
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - auto_instantiate_widget_plugin: Better integrating custom widgets in the desktop layout -
-
- -
-This is an example demonstrating how one can create widgets from a plugin,
-and have them re-created automatically at IDA startup-time or at desktop load-time.
-
-This example should be placed in the 'plugins' directory of the
-IDA installation, for it to work.
-
-There are 2 ways to use this example:
-1) reloading an IDB, where the widget was opened
-   - open the widget ('View > Open subview > ...')
-   - save this IDB, and close IDA
-   - restart IDA with this IDB
-     => the widget will be visible
-
-2) reloading a desktop, where the widget was opened
-   - open the widget ('View > Open subview > ...')
-   - save the desktop ('Windows > Save desktop...') under, say, the name 'with_auto'
-   - start another IDA instance with some IDB, and load that desktop
-     => the widget will be visible
-
- -
    -
  • Category: core
    • -
  • Summary: Better integrating custom widgets in the desktop layout
    • -
  • View on GitHub
    • -
  • Keywords: - desktop - plugin - UI_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_idaapi.plugin_t
      • -
    • ida_kernwin.AST_ENABLE_ALWAYS
      • -
    • ida_kernwin.SETMENU_APP
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_menu
      • -
    • ida_kernwin.find_widget
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.simplecustviewer_t
      • -
    • ida_kernwin.simplecustviewer_t.Create
      • -
    -
    • - - -
-
-
-
-
- ▹ - - bin_search: Showcasing `ida_bytes.bin_search` -
- -
-
-
- ▹ - - colorize_disassembly_on_the_fly: An easy-to-use way to colorize lines -
-
- -
-This builds upon the `ida_kernwin.UI_Hooks.get_lines_rendering_info`
-feature, to provide a quick & easy way to colorize disassembly
-lines.
-
-Contrary to @colorize_disassembly, the coloring is not persisted in
-the database, and will therefore be lost after the session.
-
-By triggering the action multiple times, the user can "carousel"
-across 4 predefined colors (and return to the "no color" state.)
-
- -
    -
  • Category: core
    • -
  • Summary: An easy-to-use way to colorize lines
    • -
  • View on GitHub
    • -
  • Keywords: - coloring - UI_Hooks -
    • - -
  • Shortcut: - ! -
    • - - -
  • APIs used -
      -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.CK_EXTRA5
      • -
    • ida_kernwin.CK_EXTRA6
      • -
    • ida_kernwin.CK_EXTRA7
      • -
    • ida_kernwin.CK_EXTRA8
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.get_current_viewer
      • -
    • ida_kernwin.get_custom_viewer_location
      • -
    • ida_kernwin.get_custom_viewer_place_xcoord
      • -
    • ida_kernwin.get_widget_title
      • -
    • ida_kernwin.line_rendering_output_entry_t
      • -
    • ida_kernwin.register_action
      • -
    • ida_moves.lochist_entry_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - create_structure_programmatically: Programmatically create & populate a structure -
-
- -
-Usage of the API to create & populate a structure with
-members of different types.
-
- -
    -
  • Category: core
    • -
  • Summary: Programmatically create & populate a structure
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_typeinf.BTF_BYTE
      • -
    • ida_typeinf.BTF_DOUBLE
      • -
    • ida_typeinf.BTF_FLOAT
      • -
    • ida_typeinf.BTF_INT
      • -
    • ida_typeinf.BTF_INT128
      • -
    • ida_typeinf.BTF_INT16
      • -
    • ida_typeinf.BTF_INT64
      • -
    • ida_typeinf.BTF_TBYTE
      • -
    • ida_typeinf.BTF_UINT32
      • -
    • ida_typeinf.FRB_NUMO
      • -
    • ida_typeinf.NTF_TYPE
      • -
    • ida_typeinf.PRTYPE_DEF
      • -
    • ida_typeinf.PRTYPE_MULTI
      • -
    • ida_typeinf.PRTYPE_TYPE
      • -
    • ida_typeinf.del_named_type
      • -
    • ida_typeinf.idc_parse_types
      • -
    • ida_typeinf.tinfo_errstr
      • -
    • ida_typeinf.tinfo_t
      • -
    • ida_typeinf.udm_t
      • -
    • ida_typeinf.udt_type_data_t
      • -
    • ida_typeinf.value_repr_t
      • -
    -
    • - - -
  • Author: Gergely Erdelyi (gergely.erdelyi@d-dome.net)
    • -
-
-
-
-
- ▹ - - custom_cli: A custom command-line interpreter -
-
- -
-Illustrates how one can add command-line interpreters to IDA
-
-This custom interpreter doesn't actually run any code; it's
-there as a 'getting started'.
-It provides an example tab completion support.
-
- -
    -
  • Category: core
    • -
  • Summary: A custom command-line interpreter
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_idaapi.NW_CLOSEIDB
      • -
    • ida_idaapi.NW_OPENIDB
      • -
    • ida_idaapi.NW_REMOVE
      • -
    • ida_idaapi.NW_TERMIDA
      • -
    • ida_idaapi.notify_when
      • -
    • ida_kernwin.cli_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - custom_data_types_and_formats: Using custom data types & printers -
-
- -
-IDA can be extended to support certain data types that it
-does not know about out-of-the-box.
-
-A 'custom data type' provide information about the type &
-size of a piece of data, while a 'custom data format' is in
-charge of formatting that data (there can be more than
-one format for a specific 'custom data type'.)
-
- -
    -
  • Category: core
    • -
  • Summary: Using custom data types & printers
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_bytes.data_format_t
      • -
    • ida_bytes.data_type_t
      • -
    • ida_bytes.find_custom_data_type
      • -
    • ida_bytes.get_byte
      • -
    • ida_bytes.register_data_types_and_formats
      • -
    • ida_bytes.unregister_data_types_and_formats
      • -
    • ida_idaapi.NW_CLOSEIDB
      • -
    • ida_idaapi.NW_OPENIDB
      • -
    • ida_idaapi.NW_REMOVE
      • -
    • ida_idaapi.NW_TERMIDA
      • -
    • ida_idaapi.notify_when
      • -
    • ida_idaapi.struct_unpack
      • -
    • ida_lines.COLSTR
      • -
    • ida_lines.SCOLOR_IMPNAME
      • -
    • ida_lines.SCOLOR_INSN
      • -
    • ida_lines.SCOLOR_NUMBER
      • -
    • ida_lines.SCOLOR_REG
      • -
    • ida_nalt.get_input_file_path
      • -
    • ida_netnode.netnode
      • -
    • ida_typeinf.tinfo_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - dump_extra_comments: Retrieve extra comments -
-
- -
-Use the `ida_lines.get_extra_cmt` API to retrieve anterior
-and posterior extra comments.
-
-This script registers two actions, that can be used to dump
-the previous and next extra comments.
-
- -
    -
  • Category: core
    • -
  • Summary: Retrieve extra comments
    • -
  • View on GitHub
    • -
  • Keywords: - ctxmenu -
    • - -
  • Shortcuts: - Ctrl+Shift+Y - Ctrl+Shift+Z -
    • - - -
  • APIs used -
      -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_DISASM
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.find_widget
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.unregister_action
      • -
    • ida_lines.E_NEXT
      • -
    • ida_lines.E_PREV
      • -
    • ida_lines.get_extra_cmt
      • -
    • ida_view
      • -
    -
    • - - -
-
-
-
-
- ▹ - - dump_flowchart: Dump function flowchart -
-
- -
-Dumps the current function's flowchart, using 2 methods:
-
-  * the low-level `ida_gdl.qflow_chart_t` type
-  * the somewhat higher-level, and slightly more pythonic
-    `ida_gdl.FlowChart` type.
-
- -
    -
  • Category: core
    • -
  • Summary: Dump function flowchart
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_gdl.FlowChart
      • -
    • ida_gdl.qflow_chart_t
      • -
    • ida_kernwin.get_screen_ea
      • -
    -
    • - - -
-
-
-
-
- ▹ - - dump_selection: Retrieve & dump current selection -
-
- -
-Shows how to retrieve the selection from a listing
-widget ("IDA View-A", "Hex View-1", "Pseudocode-A", ...) as
-two "cursors", and from there retrieve (in fact, generate)
-the corresponding text.
-
-After running this script:
-
-  * select some text in one of the listing widgets (i.e.,
-    "IDA View-*", "Enums", "Structures", "Pseudocode-*")
-  * press Ctrl+Shift+S to dump the selection
-
- -
    -
  • Category: core
    • -
  • Summary: Retrieve & dump current selection
    • -
  • View on GitHub
    • - -
  • Shortcut: - Ctrl+Shift+S -
    • - - -
  • APIs used -
      -
    • ida_kernwin.ACF_HAS_SELECTION
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_DISASM
      • -
    • ida_kernwin.BWN_ENUMS
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.BWN_STRUCTS
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.get_current_viewer
      • -
    • ida_kernwin.get_viewer_user_data
      • -
    • ida_kernwin.l_compare2
      • -
    • ida_kernwin.linearray_t
      • -
    • ida_kernwin.read_selection
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.twinpos_t
      • -
    • ida_kernwin.unregister_action
      • -
    • ida_lines.tag_remove
      • -
    -
    • - - -
-
-
-
-
- ▹ - - extend_idc: Add functions to the IDC runtime from IDAPython -
-
- -
-You can add IDC functions to IDA, whose "body" consists of
-IDAPython statements!
-
-We'll register a 'pow' function, available to all IDC code,
-that when invoked will call back into IDAPython, and execute
-the provided function body.
-
-After running this script, try switching to the IDC interpreter
-(using the button on the lower-left corner of IDA) and executing
-`pow(3, 7)`
-
- -
    -
  • Category: core
    • -
  • Summary: Add functions to the IDC runtime from IDAPython
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_expr.VT_LONG
      • -
    • ida_expr.add_idc_func
      • -
    -
    • - - -
-
-
-
-
- ▹ - - idapythonrc: Code to be run right after IDAPython initialization -
-
- -
-The `idapythonrc.py` file:
-
-  * %APPDATA%\Hex-Rays\IDA Pro\idapythonrc.py (on Windows)
-  * ~/.idapro/idapythonrc.py (on Linux & Mac)
-
-can contain any IDAPython code that will be run as soon as
-IDAPython is done successfully initializing.
-
- -
    -
  • Category: core
    • -
  • Summary: Code to be run right after IDAPython initialization
    • -
  • View on GitHub
    • - - - - - -
-
-
-
-
- ▹ - - install_user_defined_prefix: Inserting information into disassembly prefixes -
-
- -
-By default, disassembly line prefixes contain segment + address
-information (e.g., '.text:08047718'), but it is possible to
-"inject" other bits of information in there, thanks to the
-`ida_lines.user_defined_prefix_t` helper type.
-
- -
    -
  • Category: core
    • -
  • Summary: Inserting information into disassembly prefixes
    • -
  • View on GitHub
    • -
  • Keywords: - plugin -
    • - - - -
  • APIs used -
      -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_lines.SCOLOR_INV
      • -
    • ida_lines.user_defined_prefix_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - list_bookmarks: List bookmarks associated to a listing -
-
- -
-This sample shows how to programmatically access the list of
-bookmarks placed in a listing widget (e.g., "IDA View-A",
-"Pseudocode-", …) using the low-level `ida_moves.bookmarks_t`
-type.
-
- -
    -
  • Category: core
    • -
  • Summary: List bookmarks associated to a listing
    • -
  • View on GitHub
    • -
  • Keywords: - bookmarks -
    • - -
  • Shortcut: - Ctrl+! -
    • - - -
  • APIs used -
      -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.get_current_viewer
      • -
    • ida_kernwin.get_viewer_user_data
      • -
    • ida_kernwin.get_widget_title
      • -
    • ida_kernwin.register_action
      • -
    • ida_moves.bookmarks_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - list_function_items: Showcases (a few of) the iterators available on a function -
-
- -
-This demonstrates how to use some of the iterators available on the func_t type.
-
-This example will focus on:
-
-  * `func_t[.__iter__]`: the default iterator; iterates on instructions
-  * `func_t.data_items`: iterate on data items contained within a function
-  * `func_t.head_items`: iterate on 'heads' (i.e., addresses containing
-                         the start of an instruction, or a data item.
-  * `func_t.addresses`: iterate on all addresses within function (code
-                        and data, beginning of an item or not)
-
-Type `help(ida_funcs.func_t)` for a full list of iterators.
-
-In addition, one can use:
-
-  * `func_tail_iterator_t`: iterate on all the chunks (including
-                            the main one) of the function
-  * `func_parent_iterator_t`: iterate on all the parent functions,
-                              that include this chunk
-
- -
    -
  • Category: core
    • -
  • Summary: Showcases (a few of) the iterators available on a function
    • -
  • View on GitHub
    • -
  • Keywords: - funcs iterator -
    • - - - -
  • APIs used -
      -
    • ida_bytes.get_flags
      • -
    • ida_bytes.is_code
      • -
    • ida_bytes.is_data
      • -
    • ida_bytes.is_tail
      • -
    • ida_bytes.is_unknown
      • -
    • ida_funcs.func_tail_iterator_t
      • -
    • ida_funcs.get_fchunk
      • -
    • ida_funcs.get_func
      • -
    • ida_funcs.get_func_name
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_ua.print_insn_mnem
      • -
    -
    • - - -
-
-
-
-
- ▹ - - list_imports: Enumerate file imports -
-
- -
-Using the API to enumerate file imports.
-
- -
    -
  • Category: core
    • -
  • Summary: Enumerate file imports
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_nalt.enum_import_names
      • -
    • ida_nalt.get_import_module_name
      • -
    • ida_nalt.get_import_module_qty
      • -
    -
    • - - -
-
-
-
-
- ▹ - - list_patched_bytes: Enumerate patched bytes -
-
- -
-Using the API to iterate over all the places in the file,
-that were patched using IDA.
-
- -
    -
  • Category: core
    • -
  • Summary: Enumerate patched bytes
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_bytes.visit_patched_bytes
      • -
    • ida_idaapi.BADADDR
      • -
    -
    • - - -
-
-
-
-
- ▹ - - list_problems: Enumerate problems -
-
- -
-Using the API to list all problem[atic situation]s that IDA
-encountered during analysis.
-
- -
    -
  • Category: core
    • -
  • Summary: Enumerate problems
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_ida.inf_get_min_ea
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_problems.PR_ATTN
      • -
    • ida_problems.PR_BADSTACK
      • -
    • ida_problems.PR_COLLISION
      • -
    • ida_problems.PR_DECIMP
      • -
    • ida_problems.PR_DISASM
      • -
    • ida_problems.PR_FINAL
      • -
    • ida_problems.PR_HEAD
      • -
    • ida_problems.PR_ILLADDR
      • -
    • ida_problems.PR_JUMP
      • -
    • ida_problems.PR_MANYLINES
      • -
    • ida_problems.PR_NOBASE
      • -
    • ida_problems.PR_NOCMT
      • -
    • ida_problems.PR_NOFOP
      • -
    • ida_problems.PR_NONAME
      • -
    • ida_problems.PR_NOXREFS
      • -
    • ida_problems.PR_ROLLED
      • -
    • ida_problems.get_problem
      • -
    • ida_problems.get_problem_name
      • -
    -
    • - - -
-
-
-
-
- ▹ - - list_segment_functions: List all functions (and xrefs) in segment -
-
- -
-List all the functions in the current segment, as well as
-all the cross-references to them.
-
- -
    -
  • Category: core
    • -
  • Summary: List all functions (and xrefs) in segment
    • -
  • View on GitHub
    • -
  • Keywords: - xrefs -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_funcs.get_func_name
      • -
    • ida_funcs.get_next_func
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_segment.getseg
      • -
    • ida_xref.xrefblk_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - list_segment_functions_using_idautils: List all functions (and xrefs) in segment -
-
- -
-List all the functions in the current segment, as well as
-all the cross-references to them.
-
-Contrary to @list_segment_functions, this uses the somewhat
-higher-level `idautils` module.
-
- -
    -
  • Category: core
    • -
  • Summary: List all functions (and xrefs) in segment
    • -
  • View on GitHub
    • -
  • Keywords: - xrefs -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func_name
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_segment.getseg
      • -
    • idautils.CodeRefsTo
      • -
    • idautils.Functions
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - list_stkvar_xrefs: List all xrefs to a function stack variable -
-
- -
-Contrary to (in-memory) data & code xrefs, retrieving stack variables
-xrefs requires a bit more work than just using ida_xref's first_to(),
-next_to() (or higher level utilities such as idautils.XrefsTo)
-
- -
    -
  • Category: core
    • -
  • Summary: List all xrefs to a function stack variable
    • -
  • View on GitHub
    • -
  • Keywords: - xrefs -
    • - -
  • Shortcut: - Ctrl+Shift+F7 -
    • - - -
  • APIs used -
      -
    • ida_bytes.get_flags
      • -
    • ida_bytes.is_stkvar
      • -
    • ida_frame.calc_stkvar_struc_offset
      • -
    • ida_frame.get_frame
      • -
    • ida_funcs.get_func
      • -
    • ida_ida.UA_MAXOP
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_DISASM
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.get_current_viewer
      • -
    • ida_kernwin.get_highlight
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_kernwin.register_action
      • -
    • ida_struct.get_member_by_name
      • -
    • ida_struct.get_struc
      • -
    • ida_ua.decode_insn
      • -
    • ida_ua.insn_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - list_strings: Retrieve the strings that are present in the IDB -
-
- -
-This uses `idautils.Strings` to iterate over the string literals
-that are present in the IDB. Contrary to @show_selected_strings,
-this will not require that the "Strings" window is opened & available.
-
- -
    -
  • Category: core
    • -
  • Summary: Retrieve the strings that are present in the IDB
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_nalt.STRTYPE_C
      • -
    • ida_nalt.STRTYPE_C_16
      • -
    • idautils.Strings
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - produce_c_file: Decompile entire file -
-
- -
-Automate IDA to perform auto-analysis on a file and,
-once that is done, produce a .c file containing the
-decompilation of all the functions in that file.
-
-Run like so:
-
-      ida -A "-S...path/to/produce_c_file.py" 
-
-where:
-
-  * -A instructs IDA to run in non-interactive mode
-  * -S holds a path to the script to run (note this is a single token;
-       there is no space between '-S' and its path.)
-
- -
    -
  • Category: core
    • -
  • Summary: Decompile entire file
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_auto.auto_wait
      • -
    • ida_hexrays.VDRUN_MAYSTOP
      • -
    • ida_hexrays.VDRUN_NEWFILE
      • -
    • ida_hexrays.VDRUN_SILENT
      • -
    • ida_hexrays.decompile_many
      • -
    • ida_loader.PATH_TYPE_IDB
      • -
    • ida_loader.get_path
      • -
    • ida_pro.qexit
      • -
    -
    • - - -
-
-
-
-
- ▹ - - produce_lst_file: Produce listing -
-
- -
-Automate IDA to perform auto-analysis on a file and,
-once that is done, produce a .lst file with the disassembly.
-
-Run like so:
-
-      ida -A "-S...path/to/produce_lst_file.py" 
-
-where:
-
-  * -A instructs IDA to run in non-interactive mode
-  * -S holds a path to the script to run (note this is a single token;
-       there is no space between '-S' and its path.)
-
- -
    -
  • Category: core
    • -
  • Summary: Produce listing
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_auto.auto_wait
      • -
    • ida_fpro.qfile_t
      • -
    • ida_ida.inf_get_max_ea
      • -
    • ida_ida.inf_get_min_ea
      • -
    • ida_loader.OFILE_LST
      • -
    • ida_loader.PATH_TYPE_IDB
      • -
    • ida_loader.gen_file
      • -
    • ida_loader.get_path
      • -
    • ida_pro.qexit
      • -
    -
    • - - -
-
-
-
-
- ▹ - - register_timer: Using timers for delayed execution -
-
- -
-Register (possibly repeating) timers.
-
- -
    -
  • Category: core
    • -
  • Summary: Using timers for delayed execution
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_kernwin.register_timer
      • -
    -
    • - - -
-
-
-
-
- ▹ - - trigger_actions_programmatically: Execute existing actions programmatically -
-
- -
-It's possible to invoke any action programmatically, by using
-either of those two:
-
-  * ida_kernwin.execute_ui_requests()
-  * ida_kernwin.process_ui_action()
-
-Ideally, this script should be run through the "File > Script file..."
-menu, so as to keep focus on "IDA View-A" and have the
-'ProcessUiActions' part work as intended.
-
- -
    -
  • Category: core
    • -
  • Summary: Execute existing actions programmatically
    • -
  • View on GitHub
    • -
  • Keywords: - actions -
    • - - - -
  • APIs used -
      -
    • ida_kernwin.ask_yn
      • -
    • ida_kernwin.execute_ui_requests
      • -
    • ida_kernwin.msg
      • -
    • ida_kernwin.process_ui_action
      • -
    -
    • - - -
-
-
- -
-

Category: cvt64

-
-
-
- ▹ - - py_cvt64_sample: This file contains the CVT64 examples. -
-
- -
-For more infortmation see SDK/plugins/cvt64_sample example
-
- -
    -
  • Category: cvt64
    • -
  • Summary: This file contains the CVT64 examples.
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_idaapi.BADADDR
      • -
    • ida_idaapi.BADADDR32
      • -
    • ida_netnode.atag
      • -
    • ida_netnode.htag
      • -
    • ida_netnode.stag
      • -
    -
    • - - -
-
-
- -
-

Category: debugging

-
-
-
- ▹ - - automatic_steps: Programmatically drive a debugging session -
-
- -
-Start a debugging session, step through the first five
-instructions. Each instruction is disassembled after
-execution.
-
- -
    -
  • Category: debugging
    • -
  • Summary: Programmatically drive a debugging session
    • -
  • View on GitHub
    • -
  • Keywords: - DBG_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_dbg.DBG_Hooks
      • -
    • ida_dbg.get_reg_val
      • -
    • ida_dbg.request_exit_process
      • -
    • ida_dbg.request_run_to
      • -
    • ida_dbg.request_step_over
      • -
    • ida_dbg.run_requests
      • -
    • ida_ida.inf_get_start_ip
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_lines.generate_disasm_line
      • -
    • ida_lines.tag_remove
      • -
    -
    • - - -
-
-
-
-
- ▹ - - dbg_trace: Using the low-level tracing hook -
-
- -
-This script demonstrates using the low-level tracing hook
-(ida_dbg.DBG_Hooks.dbg_trace). It can be run like so:
-
-     ida[t].exe -B -Sdbg_trace.py -Ltrace.log file.exe
-
- -
    -
  • Category: debugging
    • -
  • Summary: Using the low-level tracing hook
    • -
  • View on GitHub
    • -
  • Keywords: - DBG_Hooks -
    • - - - -
  • APIs used -
      -
    • GENDSM_FORCE_CODE
      • -
    • GENDSM_REMOVE_TAGS
      • -
    • NN_call
      • -
    • NN_callfi
      • -
    • NN_callni
      • -
    • generate_disasm_line
      • -
    • ida_dbg.DBG_Hooks
      • -
    • ida_dbg.ST_OVER_DEBUG_SEG
      • -
    • ida_dbg.ST_OVER_LIB_FUNC
      • -
    • ida_dbg.enable_step_trace
      • -
    • ida_dbg.get_process_state
      • -
    • ida_dbg.get_reg_val
      • -
    • ida_dbg.get_step_trace_options
      • -
    • ida_dbg.load_debugger
      • -
    • ida_dbg.refresh_debugger_memory
      • -
    • ida_dbg.request_continue_process
      • -
    • ida_dbg.request_enable_step_trace
      • -
    • ida_dbg.request_set_step_trace_options
      • -
    • ida_dbg.run_requests
      • -
    • ida_dbg.run_to
      • -
    • ida_dbg.set_step_trace_options
      • -
    • ida_dbg.wait_for_next_event
      • -
    • ida_ida.f_ELF
      • -
    • ida_ida.f_MACHO
      • -
    • ida_ida.f_PE
      • -
    • ida_ida.inf_get_filetype
      • -
    • ida_ida.inf_get_max_ea
      • -
    • ida_ida.inf_get_min_ea
      • -
    • ida_ida.inf_get_start_ip
      • -
    • ida_pro.qexit
      • -
    • ida_ua.decode_insn
      • -
    • ida_ua.insn_t
      • -
    • idc.ARGV
      • -
    -
    • - - -
-
-
-
-
- ▹ - - print_call_stack: Print call stack (on Linux) -
-
- -
-           Print the return addresses from the call stack at a breakpoint.
-           (and print also the module and the debug name from debugger)
-
-To use this example:
-
-  * run `ida64` on test program `simple_appcall_linux64`, or
-    `ida` on test program `simple_appcall_linux32`, and wait for
-    auto-analysis to finish
-  * put a breakpoint where you want to see the call stack
-  * select the 'linux debugger' (either local, or remote)
-  * start debugging
-  * Press Shift+C at the breakpoint
-
- -
    -
  • Category: debugging
    • -
  • Summary: Print call stack (on Linux)
    • -
  • View on GitHub
    • - -
  • Shortcut: - Shift+C -
    • - - -
  • APIs used -
      -
    • ida_dbg.collect_stack_trace
      • -
    • ida_dbg.get_current_thread
      • -
    • ida_dbg.get_module_info
      • -
    • ida_idd.call_stack_t
      • -
    • ida_idd.modinfo_t
      • -
    • ida_kernwin.AST_ENABLE_ALWAYS
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.register_action
      • -
    • ida_name.GNCN_NOCOLOR
      • -
    • ida_name.GNCN_NOLABEL
      • -
    • ida_name.GNCN_NOSEG
      • -
    • ida_name.GNCN_PREFDBG
      • -
    • ida_name.get_nice_colored_name
      • -
    -
    • - - -
-
-
-
-
- ▹ - - print_registers: Print all registers, for all threads -
-
- -
-           Iterate over the list of threads in the program being
-           debugged, and dump all registers contents
-
-To use this example:
-
-  * run `ida64` on test program `simple_appcall_linux64`, or
-    `ida` on test program `simple_appcall_linux32`, and wait for
-    auto-analysis to finish
-  * put a breakpoint somewhere in the code
-  * select the 'linux debugger' (either local, or remote)
-  * start debugging
-  * Press Alt+Shift+C at the breakpoint
-
- -
    -
  • Category: debugging
    • -
  • Summary: Print all registers, for all threads
    • -
  • View on GitHub
    • - -
  • Shortcut: - Alt+Shift+C -
    • - - -
  • APIs used -
      -
    • ida_dbg.get_reg_vals
      • -
    • ida_dbg.get_thread_qty
      • -
    • ida_dbg.getn_thread
      • -
    • ida_idd.get_dbg
      • -
    • ida_kernwin.AST_ENABLE_ALWAYS
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.register_action
      • -
    -
    • - - -
-
-
-
-
- ▹ - - registers_context_menu: Adding actions to the "registers" widget(s) -
-
- -
-It's possible to add actions to the context menu of
-pretty much all widgets in IDA.
-
-This example shows how to do just that for
-registers-displaying widgets (e.g., "General registers")
-
- -
    -
  • Category: debugging
    • -
  • Summary: Adding actions to the "registers" widget(s)
    • -
  • View on GitHub
    • -
  • Keywords: - ctxmenu - UI_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_dbg.get_dbg_reg_info
      • -
    • ida_dbg.get_reg_val
      • -
    • ida_idd.register_info_t
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_CPUREGS
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.get_widget_type
      • -
    • ida_kernwin.register_action
      • -
    • ida_ua.dt_byte
      • -
    • ida_ua.dt_dword
      • -
    • ida_ua.dt_qword
      • -
    • ida_ua.dt_word
      • -
    -
    • - - -
-
-
-
-
- ▹ - - show_debug_names: Retrieving & dumping debuggee symbols -
-
- -
-Queries the debugger (possibly remotely) for the list of
-symbols that the process being debugged, provides.
-
- -
    -
  • Category: debugging
    • -
  • Summary: Retrieving & dumping debuggee symbols
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_dbg.DSTATE_SUSP
      • -
    • ida_dbg.get_process_state
      • -
    • ida_dbg.is_debugger_on
      • -
    • ida_ida.inf_get_max_ea
      • -
    • ida_ida.inf_get_min_ea
      • -
    • ida_name.get_debug_names
      • -
    -
    • - - -
-
-
-
-
- ▹ - - simple_appcall_linux: Executing code into the application being debugged (on Linux) -
-
- -
-Using the `ida_idd.Appcall` utility to execute code in
-the process being debugged.
-
-This example will run the test program and stop wherever
-the cursor currently is, and then perform an appcall to
-execute the `ref4` and `ref8` functions.
-
-To use this example:
-
-  * run `ida64` on test program `simple_appcall_linux64`, or
-    `ida` on test program `simple_appcall_linux32`, and wait for
-    auto-analysis to finish
-  * select the 'linux debugger' (either local, or remote)
-  * run this script
-
-Note: the real body of code is in `simple_appcall_common.py`.
-
- -
    -
  • Category: debugging
    • -
  • Summary: Executing code into the application being debugged (on Linux)
    • -
  • View on GitHub
    • - - -
  • Imports -
      -
    • simple_appcall_common
      • -
    -
    • - -
  • APIs used -
      -
    • ida_dbg.DBG_Hooks
      • -
    • ida_dbg.run_to
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_idd.Appcall
      • -
    • ida_idd.Appcall.byref
      • -
    • ida_idd.Appcall.int64
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_name.get_name_ea
      • -
    • ida_name.set_name
      • -
    • ida_typeinf.apply_cdecl
      • -
    -
    • - - -
-
-
-
-
- ▹ - - simple_appcall_win: Executing code into the application being debugged (on Windows) -
-
- -
-Using the `ida_idd.Appcall` utility to execute code in
-the process being debugged.
-
-This example will run the test program and stop wherever
-the cursor currently is, and then perform an appcall to
-execute the `ref4` and `ref8` functions.
-
-To use this example:
-
-  * run `ida64` on test program `simple_appcall_win64.exe`, or
-    `ida` on test program `simple_appcall_win32.exe`, and wait for
-    auto-analysis to finish
-  * select the 'windows debugger' (either local, or remote)
-  * run this script
-
-Note: the real body of code is in `simple_appcall_common.py`.
-
- -
    -
  • Category: debugging
    • -
  • Summary: Executing code into the application being debugged (on Windows)
    • -
  • View on GitHub
    • - - -
  • Imports -
      -
    • simple_appcall_common
      • -
    -
    • - -
  • APIs used -
      -
    • ida_dbg.DBG_Hooks
      • -
    • ida_dbg.run_to
      • -
    • ida_ida.inf_is_64bit
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_idd.Appcall
      • -
    • ida_idd.Appcall.byref
      • -
    • ida_idd.Appcall.int64
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_name.get_name_ea
      • -
    • ida_name.set_name
      • -
    • ida_typeinf.apply_cdecl
      • -
    -
    • - - -
-
-
- -
-

Category: disassembly

-
-
-
- ▹ - - colorize_disassembly: Change background colours -
-
- -
-This illustrates the setting/retrieval of background colours
-using the IDC wrappers
-
-In order to do so, we'll be assigning colors to specific ranges
-(item, function, or segment). Those will be persisted in the
-database.
-
- -
    -
  • Category: disassembly
    • -
  • Summary: Change background colours
    • -
  • View on GitHub
    • -
  • Keywords: - coloring - idc -
    • - - - -
  • APIs used -
      -
    • idc.CIC_FUNC
      • -
    • idc.CIC_ITEM
      • -
    • idc.CIC_SEGM
      • -
    • idc.get_color
      • -
    • idc.here
      • -
    • idc.set_color
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
- -
-

Category: hexrays

-
-
-
- ▹ - - colorize_pseudocode_lines: Interactively color certain pseudocode lines -
-
- -
-Provides an action that can be used to dynamically alter the
-lines background rendering for pseudocode listings (as opposed to
-using `ida_hexrays.cfunc_t.pseudocode[N].bgcolor`)
-
-After running this script, pressing 'M' on a line in a
-"Pseudocode-?" widget, will cause that line to be rendered
-with a special background color.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Interactively color certain pseudocode lines
    • -
  • View on GitHub
    • -
  • Keywords: - colors - UI_Hooks -
    • - -
  • Shortcut: - M -
    • - - -
  • APIs used -
      -
    • ida_hexrays.get_widget_vdui
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.CK_EXTRA11
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.get_custom_viewer_location
      • -
    • ida_kernwin.line_rendering_output_entry_t
      • -
    • ida_kernwin.refresh_custom_viewer
      • -
    • ida_kernwin.register_action
      • -
    • ida_moves.lochist_entry_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - curpos_details: A focus on the 'curpos' hook, printing additional details about user input -
-
- -
-Shows how user input information can be retrieved during
-processing of a notification triggered by that input
-
- -
    -
  • Category: hexrays
    • -
  • Summary: A focus on the 'curpos' hook, printing additional details about user input
    • -
  • View on GitHub
    • -
  • Keywords: - Hexrays_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_kernwin.get_user_input_event
      • -
    • ida_kernwin.iek_key_press
      • -
    • ida_kernwin.iek_key_release
      • -
    • ida_kernwin.iek_mouse_button_press
      • -
    • ida_kernwin.iek_mouse_button_release
      • -
    • ida_kernwin.iek_mouse_wheel
      • -
    • ida_kernwin.iek_shortcut
      • -
    • ida_kernwin.input_event_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - decompile_entry_points: Automatic decompilation of functions -
-
- -
-Attempts to load a decompiler plugin corresponding to the current
-architecture (and address size) right after auto-analysis is performed,
-and then tries to decompile the function at the first entrypoint.
-
-It is particularly suited for use with the '-S' flag, for example:
-idat -Ldecompile.log -Sdecompile_entry_points.py -c file
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Automatic decompilation of functions
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_auto.auto_wait
      • -
    • ida_entry.get_entry
      • -
    • ida_entry.get_entry_ordinal
      • -
    • ida_entry.get_entry_qty
      • -
    • ida_hexrays.decompile
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_ida.inf_is_64bit
      • -
    • ida_idp.PLFM_386
      • -
    • ida_idp.PLFM_ARM
      • -
    • ida_idp.PLFM_MIPS
      • -
    • ida_idp.PLFM_PPC
      • -
    • ida_idp.ph.id
      • -
    • ida_kernwin.cvar.batch
      • -
    • ida_kernwin.msg
      • -
    • ida_loader.load_plugin
      • -
    • ida_pro.qexit
      • -
    • idc.get_idb_path
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds1: Decompile & print current function. -
-
- -
-Decompile & print current function.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Decompile & print current function.
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_hexrays.decompile
      • -
    • ida_hexrays.get_hexrays_version
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_lines.tag_remove
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds10: A custom microcode instruction optimization rule -
-
- -
-Installs a custom microcode instruction optimization rule,
-to transform:
-
-    call   !DbgRaiseAssertionFailure .0
-
-into
-
-    call   !DbgRaiseAssertionFailure .0
-
-To see this plugin in action please use arm64_brk.i64
-
- -
    -
  • Category: hexrays
    • -
  • Summary: A custom microcode instruction optimization rule
    • -
  • View on GitHub
    • -
  • Keywords: - plugin -
    • - - - -
  • APIs used -
      -
    • ida_bytes.get_cmt
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.mop_str
      • -
    • ida_hexrays.optinsn_t
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_typeinf.STI_PCCHAR
      • -
    • ida_typeinf.tinfo_t.get_stock
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds11: A custom microcode block optimization rule (resolve `goto` chains) -
-
- -
-Installs a custom microcode block optimization rule,
-to transform:
-
-      goto L1
-      ...
-    L1:
-      goto L2
-
-into
-
-      goto L2
-
-In other words we fix a goto target if it points to a chain of gotos.
-This improves the decompiler output in some cases.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: A custom microcode block optimization rule (resolve `goto` chains)
    • -
  • View on GitHub
    • -
  • Keywords: - plugin -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.getf_reginsn
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.m_goto
      • -
    • ida_hexrays.optblock_t
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds12: List instruction registers -
-
- -
-Shows a list of direct references to a register from the
-current instruction.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: List instruction registers
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_bytes.get_flags
      • -
    • ida_bytes.is_code
      • -
    • ida_funcs.get_func
      • -
    • ida_hexrays.ACFL_GUESS
      • -
    • ida_hexrays.DECOMP_NO_CACHE
      • -
    • ida_hexrays.DECOMP_WARNINGS
      • -
    • ida_hexrays.GCO_DEF
      • -
    • ida_hexrays.GCO_USE
      • -
    • ida_hexrays.GC_REGS_AND_STKVARS
      • -
    • ida_hexrays.MERR_OK
      • -
    • ida_hexrays.MMAT_PREOPTIMIZED
      • -
    • ida_hexrays.MUST_ACCESS
      • -
    • ida_hexrays.gco_info_t
      • -
    • ida_hexrays.gen_microcode
      • -
    • ida_hexrays.get_current_operand
      • -
    • ida_hexrays.get_merror_desc
      • -
    • ida_hexrays.hexrays_failure_t
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.mba_ranges_t
      • -
    • ida_hexrays.mlist_t
      • -
    • ida_hexrays.op_parent_info_t
      • -
    • ida_hexrays.voff_t
      • -
    • ida_kernwin.Choose
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_kernwin.jumpto
      • -
    • ida_kernwin.warning
      • -
    • ida_lines.GENDSM_REMOVE_TAGS
      • -
    • ida_lines.generate_disasm_line
      • -
    • ida_pro.eavec_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds13: Generates microcode for selection -
-
- -
-Generates microcode for selection and dumps it to the output window.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Generates microcode for selection
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_bytes.get_flags
      • -
    • ida_bytes.is_code
      • -
    • ida_hexrays.DECOMP_WARNINGS
      • -
    • ida_hexrays.gen_microcode
      • -
    • ida_hexrays.hexrays_failure_t
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.mba_ranges_t
      • -
    • ida_hexrays.vd_printer_t
      • -
    • ida_kernwin.read_range_selection
      • -
    • ida_kernwin.warning
      • -
    • ida_range.range_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds17: Using the "Select offsets" widget -
-
- -
-Registers an action opens the "Select offsets" widget
-(select_udt_by_offset() call).
-
-This effectively repeats the functionality already available
-through Alt+Y.
-
-Place cursor on the union field and press Shift+T
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Using the "Select offsets" widget
    • -
  • View on GitHub
    • -
  • Keywords: - plugin -
    • - -
  • Shortcut: - Shift+T -
    • - - -
  • APIs used -
      -
    • ida_hexrays.USE_KEYBOARD
      • -
    • ida_hexrays.cot_add
      • -
    • ida_hexrays.cot_cast
      • -
    • ida_hexrays.cot_memptr
      • -
    • ida_hexrays.cot_memref
      • -
    • ida_hexrays.cot_num
      • -
    • ida_hexrays.cot_ref
      • -
    • ida_hexrays.get_hexrays_version
      • -
    • ida_hexrays.get_widget_vdui
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.select_udt_by_offset
      • -
    • ida_hexrays.ui_stroff_applicator_t
      • -
    • ida_hexrays.ui_stroff_ops_t
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.get_custom_viewer_curline
      • -
    • ida_kernwin.msg
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.warning
      • -
    • ida_lines.tag_remove
      • -
    • ida_typeinf.PRTYPE_1LINE
      • -
    • ida_typeinf.print_tinfo
      • -
    • ida_typeinf.remove_pointer
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds19: A custom microcode instruction optimization rule (`x | ~x => -1`) -
-
- -
-Installs a custom microcode instruction optimization rule,
-to transform:
-
-    x | ~x
-
-into
-
-    -1
-
-To see this plugin in action please use be_ornot_be.idb
-
- -
    -
  • Category: hexrays
    • -
  • Summary: A custom microcode instruction optimization rule (`x | ~x => -1`)
    • -
  • View on GitHub
    • -
  • Keywords: - plugin -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.m_bnot
      • -
    • ida_hexrays.m_mov
      • -
    • ida_hexrays.m_or
      • -
    • ida_hexrays.minsn_visitor_t
      • -
    • ida_hexrays.mop_t
      • -
    • ida_hexrays.optinsn_t
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds21: Dynamically provide a custom call type -
-
- -
-This plugin can greatly improve decompilation of indirect calls:
-
-    call    [eax+4]
-
-For them, the decompiler has to guess the prototype of the called function.
-This has to be done at a very early phase of decompilation because
-the function prototype influences the data flow analysis. On the other
-hand, we do not have global data flow analysis results yet because
-we haven't analyzed all calls in the function. It is a chicked-and-egg
-problem.
-
-The decompiler uses various techniques to guess the called function
-prototype. While it works very well, it may fail in some cases.
-
-To fix, the user can specify the call prototype manually, using
-"Edit, Operand types, Set operand type" at the call instruction.
-
-This plugin illustrates another approach to the problem:
-if you happen to be able to calculate the call prototypes dynamically,
-this is how to inform the decompiler about them.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Dynamically provide a custom call type
    • -
  • View on GitHub
    • -
  • Keywords: - Hexrays_Hooks - plugin -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.m_call
      • -
    • ida_hexrays.mcallinfo_t
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_kernwin.msg
      • -
    • ida_kernwin.warning
      • -
    • ida_nalt.get_op_tinfo
      • -
    • ida_typeinf.BT_INT
      • -
    • ida_typeinf.CM_CC_STDCALL
      • -
    • ida_typeinf.CM_N32_F48
      • -
    • ida_typeinf.parse_decl
      • -
    • ida_typeinf.tinfo_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds3: Invert if/else blocks -
-
- -
-Registers an action that can be used to invert the `if`
-and `else` blocks of a `ida_hexrays.cif_t`.
-
-For example, a statement like
-
-    if ( cond )
-    {
-      statements1;
-    }
-    else
-    {
-      statements2;
-    }
-
-will be displayed as
-
-    if ( !cond )
-    {
-      statements2;
-    }
-    else
-    {
-      statements1;
-    }
-
-The modifications are persistent: the user can quit & restart
-IDA, and the changes will be present.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Invert if/else blocks
    • -
  • View on GitHub
    • -
  • Keywords: - ctxmenu - Hexrays_Hooks - IDP_Hooks - plugin -
    • - -
  • Shortcut: - I -
    • - - -
  • APIs used -
      -
    • ida_hexrays.CMAT_FINAL
      • -
    • ida_hexrays.CV_FAST
      • -
    • ida_hexrays.CV_INSNS
      • -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.ITP_ELSE
      • -
    • ida_hexrays.USE_KEYBOARD
      • -
    • ida_hexrays.VDI_TAIL
      • -
    • ida_hexrays.cexpr_t
      • -
    • ida_hexrays.cit_if
      • -
    • ida_hexrays.ctree_visitor_t
      • -
    • ida_hexrays.get_widget_vdui
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.lnot
      • -
    • ida_hexrays.qswap
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_idp.IDP_Hooks
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.register_action
      • -
    • ida_netnode.netnode
      • -
    -
    • - - -
  • Author: EiNSTeiN_ (einstein@g3nius.org)
    • -
-
-
-
-
- ▹ - - vds4: Dump user-defined information -
-
- -
-Prints user-defined information to the "Output" window.
-Namely:
-
-  * user defined label names
-  * user defined indented comments
-  * user defined number formats
-  * user defined local variable names, types, comments
-
-This script loads information from the database without decompiling anything.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Dump user-defined information
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_bytes.get_radix
      • -
    • ida_funcs.get_func
      • -
    • ida_hexrays.CIT_COLLAPSED
      • -
    • ida_hexrays.NF_NEGATE
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.lvar_uservec_t
      • -
    • ida_hexrays.restore_user_cmts
      • -
    • ida_hexrays.restore_user_iflags
      • -
    • ida_hexrays.restore_user_labels
      • -
    • ida_hexrays.restore_user_lvar_settings
      • -
    • ida_hexrays.restore_user_numforms
      • -
    • ida_hexrays.user_cmts_free
      • -
    • ida_hexrays.user_iflags_free
      • -
    • ida_hexrays.user_labels_free
      • -
    • ida_hexrays.user_numforms_free
      • -
    • ida_kernwin.get_screen_ea
      • -
    -
    • - - -
  • Author: EiNSTeiN_ (einstein@g3nius.org)
    • -
-
-
-
-
- ▹ - - vds5: Show ctree graph -
-
- -
-Registers an action that can be used to show the graph of the ctree.
-The current item will be highlighted in the graph.
-
-The command shortcut is `Ctrl+Shift+G`, and is also added
-to the context menu.
-
-To display the graph, we produce a .gdl file, and
-request that ida displays that using `ida_gdl.display_gdl`.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Show ctree graph
    • -
  • View on GitHub
    • -
  • Keywords: - ctxmenu - Hexrays_Hooks - plugin -
    • - -
  • Shortcut: - Ctrl+Shift+G -
    • - - -
  • APIs used -
      -
    • ida_gdl.display_gdl
      • -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.USE_KEYBOARD
      • -
    • ida_hexrays.cit_asm
      • -
    • ida_hexrays.cit_goto
      • -
    • ida_hexrays.cot_helper
      • -
    • ida_hexrays.cot_memptr
      • -
    • ida_hexrays.cot_memref
      • -
    • ida_hexrays.cot_num
      • -
    • ida_hexrays.cot_obj
      • -
    • ida_hexrays.cot_ptr
      • -
    • ida_hexrays.cot_str
      • -
    • ida_hexrays.cot_var
      • -
    • ida_hexrays.ctree_parentee_t
      • -
    • ida_hexrays.get_ctype_name
      • -
    • ida_hexrays.get_widget_vdui
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.warning
      • -
    • ida_lines.tag_remove
      • -
    • ida_pro.str2user
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds6: Superficially modify the decompilation output -
-
- -
-Modifies the decompilation output in a superficial manner,
-by removing some white spaces
-
-Note: this is rather crude, not quite "pythonic" code.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Superficially modify the decompilation output
    • -
  • View on GitHub
    • -
  • Keywords: - Hexrays_Hooks - plugin -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_idaapi.PLUGIN_HIDE
      • -
    • ida_idaapi.PLUGIN_KEEP
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_lines.tag_advance
      • -
    • ida_lines.tag_skipcodes
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds7: Iterate a cblock_t object -
-
- -
-Using a `ida_hexrays.ctree_visitor_t`, search for
-`ida_hexrays.cit_block` instances and dump them.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Iterate a cblock_t object
    • -
  • View on GitHub
    • -
  • Keywords: - Hexrays_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.CMAT_BUILT
      • -
    • ida_hexrays.CV_FAST
      • -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.cit_block
      • -
    • ida_hexrays.ctree_visitor_t
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    -
    • - - -
  • Author: EiNSTeiN_ (einstein@g3nius.org)
    • -
-
-
-
-
- ▹ - - vds8: Using `ida_hexrays.udc_filter_t` -
-
- -
-Registers an action that uses a `ida_hexrays.udc_filter_t` to decompile
-`svc 0x900001` and `svc 0x9000F8` as function calls to
-`svc_exit()` and `svc_exit_group()` respectively.
-
-You will need to have an ARM + Linux IDB for this script to be usable
-
-In addition to having a shortcut, the action will be present
-in the context menu.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Using `ida_hexrays.udc_filter_t`
    • -
  • View on GitHub
    • -
  • Keywords: - ctxmenu - UI_Hooks -
    • - -
  • Shortcut: - Ctrl+Shift+U -
    • - - -
  • APIs used -
      -
    • ida_allins.ARM_svc
      • -
    • ida_hexrays.get_widget_vdui
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.install_microcode_filter
      • -
    • ida_hexrays.udc_filter_t
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.get_widget_type
      • -
    • ida_kernwin.register_action
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds_create_hint: Decompiler hints -
-
- -
-Handle `ida_hexrays.hxe_create_hint` notification using hooks,
-to return our own.
-
-If the object under the cursor is:
-
-* a function call, prefix the original decompiler hint with `==> `
-* a local variable declaration, replace the hint with our own in
-  the form of `!{varname}` (where `{varname}` is replaced with the
-  variable name)
-* an `if` statement, replace the hint with our own, saying "condition"
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Decompiler hints
    • -
  • View on GitHub
    • -
  • Keywords: - Hexrays_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.USE_MOUSE
      • -
    • ida_hexrays.VDI_EXPR
      • -
    • ida_hexrays.VDI_LVAR
      • -
    • ida_hexrays.cit_if
      • -
    • ida_hexrays.cot_call
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds_hooks: Various decompiler hooks -
-
- -
-Shows how to hook to many notifications sent by the decompiler.
-
-This plugin doesn't really accomplish anything: it just prints
-the parameters.
-
-The list of notifications handled below should be exhaustive,
-and is there to hint at what is possible to accomplish by
-subclassing `ida_hexrays.Hexrays_Hooks`
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Various decompiler hooks
    • -
  • View on GitHub
    • -
  • Keywords: - Hexrays_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.cfunc_t
      • -
    • ida_hexrays.lvar_t
      • -
    • ida_hexrays.vdui_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - vds_modify_user_lvars: Modifying local variables -
-
- -
-Use a `ida_hexrays.user_lvar_modifier_t` to modify names,
-comments and/or types of local variables.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Modifying local variables
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_hexrays.modify_user_lvars
      • -
    • ida_hexrays.user_lvar_modifier_t
      • -
    • ida_typeinf.parse_decl
      • -
    • idc.here
      • -
    -
    • - - -
-
-
-
-
- ▹ - - vds_xrefs: Show decompiler xrefs -
-
- -
-Show decompiler-style Xref when the `Ctrl+X` key is
-pressed in the Decompiler window.
-
-* supports any global name: functions, strings, integers, ...
-* supports structure member.
-
- -
    -
  • Category: hexrays
    • -
  • Summary: Show decompiler xrefs
    • -
  • View on GitHub
    • -
  • Keywords: - ctxmenu - Hexrays_Hooks -
    • - -
  • Shortcut: - Ctrl+X -
    • - - -
  • APIs used -
      -
    • ida_funcs.get_func_name
      • -
    • ida_hexrays.DECOMP_GXREFS_FORCE
      • -
    • ida_hexrays.Hexrays_Hooks
      • -
    • ida_hexrays.USE_KEYBOARD
      • -
    • ida_hexrays.VDI_EXPR
      • -
    • ida_hexrays.VDI_FUNC
      • -
    • ida_hexrays.cexpr_t
      • -
    • ida_hexrays.cfunc_t
      • -
    • ida_hexrays.cinsn_t
      • -
    • ida_hexrays.decompile
      • -
    • ida_hexrays.get_widget_vdui
      • -
    • ida_hexrays.init_hexrays_plugin
      • -
    • ida_hexrays.open_pseudocode
      • -
    • ida_hexrays.qstring_printer_t
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_kernwin.AST_DISABLE
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.PluginForm
      • -
    • ida_kernwin.PluginForm.Show
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.register_action
      • -
    • ida_typeinf.PRTYPE_1LINE
      • -
    • ida_typeinf.STRMEM_OFFSET
      • -
    • ida_typeinf.print_tinfo
      • -
    • ida_typeinf.tinfo_t
      • -
    • ida_typeinf.udm_t
      • -
    • idautils.Functions
      • -
    • idautils.XrefsTo
      • -
    -
    • - - -
  • Author: EiNSTeiN_ (einstein@g3nius.org)
    • -
-
-
- -
-

Category: idbhooks

-
-
-
- ▹ - - log_idb_events: Logging IDB events -
-
- -
-These hooks will be notified about IDB events, and
-dump their information to the "Output" window
-
- -
    -
  • Category: idbhooks
    • -
  • Summary: Logging IDB events
    • -
  • View on GitHub
    • -
  • Keywords: - IDB_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_idp.IDB_Hooks
      • -
    -
    • - - -
-
-
-
-
- ▹ - - operand_changed: Notify the user when an instruction operand changes -
-
- -
-Show notifications whenever the user changes
-an instruction's operand, or a data item.
-
- -
    -
  • Category: idbhooks
    • -
  • Summary: Notify the user when an instruction operand changes
    • -
  • View on GitHub
    • -
  • Keywords: - IDB_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_bytes.ALOPT_IGNCLT
      • -
    • ida_bytes.ALOPT_IGNHEADS
      • -
    • ida_bytes.get_flags
      • -
    • ida_bytes.get_max_strlit_length
      • -
    • ida_bytes.get_opinfo
      • -
    • ida_bytes.get_strlit_contents
      • -
    • ida_bytes.is_custfmt
      • -
    • ida_bytes.is_custom
      • -
    • ida_bytes.is_enum
      • -
    • ida_bytes.is_off
      • -
    • ida_bytes.is_strlit
      • -
    • ida_bytes.is_stroff
      • -
    • ida_bytes.is_struct
      • -
    • ida_idp.IDB_Hooks
      • -
    • ida_nalt.STRENC_DEFAULT
      • -
    • ida_nalt.get_default_encoding_idx
      • -
    • ida_nalt.get_encoding_name
      • -
    • ida_nalt.get_str_encoding_idx
      • -
    • ida_nalt.get_strtype_bpu
      • -
    • ida_nalt.opinfo_t
      • -
    • ida_typeinf.get_tid_name
      • -
    • ida_typeinf.tinfo_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - replay_prototypes_changes: Record and replay changes in function prototypes -
-
- -
-This is a sample script, that will record (in memory) all changes in
-functions prototypes, in order to re-apply them later.
-
-To use this script:
- - open an IDB (say, "test.idb")
- - modify some functions prototypes (e.g., by triggering the 'Y'
-   shortcut when the cursor is placed on the first address of a
-   function)
- - reload that IDB, *without saving it first*
- - call rpc.replay(), to re-apply the modifications.
-
-Note: 'ti_changed' is also called for changes to the function
-frames, but we'll only record function prototypes changes.
-
- -
    -
  • Category: idbhooks
    • -
  • Summary: Record and replay changes in function prototypes
    • -
  • View on GitHub
    • -
  • Keywords: - IDB_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_idp.IDB_Hooks
      • -
    • ida_typeinf.PRTYPE_1LINE
      • -
    • ida_typeinf.TINFO_DEFINITE
      • -
    • ida_typeinf.apply_tinfo
      • -
    • ida_typeinf.get_idati
      • -
    • ida_typeinf.tinfo_t
      • -
    -
    • - - -
-
-
- -
-

Category: idphooks

-
-
-
- ▹ - - ana_emu_out: Override some parts of the processor module -
-
- -
-Implements disassembly of BUG_INSTR used in Linux kernel
-BUG() macro, which is architecturally undefined and is not
-disassembled by IDA's ARM module
-
-See Linux/arch/arm/include/asm/bug.h for more info
-
- -
    -
  • Category: idphooks
    • -
  • Summary: Override some parts of the processor module
    • -
  • View on GitHub
    • -
  • Keywords: - IDP_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_bytes.get_wide_dword
      • -
    • ida_bytes.get_wide_word
      • -
    • ida_idp.CUSTOM_INSN_ITYPE
      • -
    • ida_idp.IDP_Hooks
      • -
    • ida_idp.PLFM_ARM
      • -
    • ida_idp.ph.id
      • -
    • ida_idp.str2reg
      • -
    • ida_segregs.get_sreg
      • -
    -
    • - - -
-
-
-
-
- ▹ - - assemble: An `ida_idp.IDP_Hooks.assembly` implementation -
-
- -
-We add support for assembling the following pseudo instructions:
-
-* "zero eax" -> xor eax, eax
-* "nothing" -> nop
-
- -
    -
  • Category: idphooks
    • -
  • Summary: An `ida_idp.IDP_Hooks.assembly` implementation
    • -
  • View on GitHub
    • -
  • Keywords: - IDP_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_idp.IDP_Hooks
      • -
    • idautils.DecodeInstruction
      • -
    -
    • - - -
-
-
- -
-

Category: merge

-
-
-
- ▹ - - py_mex1: Add merge functionality to a simple plugin, example 1 -
-
- -
-This is a primitive plugin which asks user for some info and saves it for
-some addresses.
-
-We will add a merge functionality to plugin.
-
-An IDA plugin may have two kinds of data with permanent storage:
-  1. Data common for entire database (e.g. the options).
-     To describe them we will use the idbattr_info_t type.
-  2. Data specific to a particular address.
-     To describe them we will use the merge_node_info_t type.
-
-Also, see SDK/plugins/mex1 example
-
- -
    -
  • Category: merge
    • -
  • Summary: Add merge functionality to a simple plugin, example 1
    • -
  • View on GitHub
    • -
  • Keywords: - IDP_Hooks - plugin -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_ida.IDI_ALTVAL
      • -
    • ida_ida.IDI_CSTR
      • -
    • ida_ida.IDI_SCALAR
      • -
    • ida_ida.IDI_SUPVAL
      • -
    • ida_ida.idbattr_info_t
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_idaapi.PLUGIN_MOD
      • -
    • ida_idaapi.PLUGIN_MULTI
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_idaapi.plugmod_t
      • -
    • ida_idp.IDP_Hooks
      • -
    • ida_kernwin.Form
      • -
    • ida_kernwin.Form.ChkGroupControl
      • -
    • ida_kernwin.Form.StringInput
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_merge.MERGE_KIND_END
      • -
    • ida_merge.MERGE_KIND_NONE
      • -
    • ida_merge.NDS_IS_STR
      • -
    • ida_merge.NDS_MAP_IDX
      • -
    • ida_merge.merge_handler_params_t
      • -
    • ida_merge.merge_node_info_t
      • -
    • ida_merge.moddata_diff_helper_t
      • -
    • ida_mergemod.create_std_modmerge_handlers
      • -
    • ida_netnode.BADNODE
      • -
    • ida_netnode.SIZEOF_nodeidx_t
      • -
    • ida_netnode.atag
      • -
    • ida_netnode.netnode
      • -
    • ida_netnode.stag
      • -
    -
    • - - -
-
-
-
-
- ▹ - - py_mex3: This example uses the mex1 example and improves the user-interface for it. -
-
- -
-IDA Teams uses a chooser to display the merge conflicts.
-To fill the chooser columns IDA Teams uses the following methods from diff_source_t type:
-  * print_diffpos_name()
-  * print_diffpos_details()
-and UI hints from merge_handler_params_t type:
-  * ui_has_details()
-  * ui_complex_details()
-  * ui_complex_name()
-
-In general, chooser columns are filled as following:
-  columns.clear()
-  NAME = print_diffpos_name()
-  if ui_complex_name()
-  then
-    columns.add(split NAME by ui_split_char())
-  else
-    columns[0] = NAME
-  if not ui_complex_details()
-  then
-    columns.add(print_diffpos_details())
-
-Also, see SDK/plugins/mex3 example
-
- -
    -
  • Category: merge
    • -
  • Summary: This example uses the mex1 example and improves the user-interface for it.
    • -
  • View on GitHub
    • -
  • Keywords: - IDP_Hooks - plugin -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_ida.IDI_ALTVAL
      • -
    • ida_ida.IDI_CSTR
      • -
    • ida_ida.IDI_SCALAR
      • -
    • ida_ida.IDI_SUPVAL
      • -
    • ida_ida.idbattr_info_t
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_idaapi.PLUGIN_MOD
      • -
    • ida_idaapi.PLUGIN_MULTI
      • -
    • ida_idaapi.plugin_t
      • -
    • ida_idaapi.plugmod_t
      • -
    • ida_idp.IDP_Hooks
      • -
    • ida_kernwin.Form
      • -
    • ida_kernwin.Form.ChkGroupControl
      • -
    • ida_kernwin.Form.StringInput
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_merge.MERGE_KIND_END
      • -
    • ida_merge.MERGE_KIND_NONE
      • -
    • ida_merge.MH_UI_COLONNAME
      • -
    • ida_merge.MH_UI_COMMANAME
      • -
    • ida_merge.MH_UI_NODETAILS
      • -
    • ida_merge.NDS_IS_STR
      • -
    • ida_merge.NDS_MAP_IDX
      • -
    • ida_merge.create_nodeval_merge_handlers
      • -
    • ida_merge.get_ea_diffpos_name
      • -
    • ida_merge.merge_handler_params_t
      • -
    • ida_merge.merge_node_helper_t
      • -
    • ida_merge.merge_node_info_t
      • -
    • ida_merge.moddata_diff_helper_t
      • -
    • ida_mergemod.create_std_modmerge_handlers
      • -
    • ida_nalt.node2ea
      • -
    • ida_netnode.BADNODE
      • -
    • ida_netnode.SIZEOF_nodeidx_t
      • -
    • ida_netnode.atag
      • -
    • ida_netnode.netnode
      • -
    • ida_netnode.stag
      • -
    -
    • - - -
-
-
- -
-

Category: pyqt

-
-
-
- ▹ - - inject_command: Injecting commands in the "Output" window -
-
- -
-This example illustrates how one can execute commands in the
-"Output" window, from their own widgets.
-
-A few notes:
-
-* the original, underlying `cli:Execute` action, that has to be
-  triggered for the code present in the input field to execute
-  and be placed in the history, requires that the input field
-  has focus (otherwise it simply won't do anything.)
-* this, in turn, forces us to do "delayed" execution of that action,
-  hence the need for a `QTimer`
-* the IDA/SWiG 'TWidget' type that we retrieve through
-  `ida_kernwin.find_widget`, is not the same type as a
-  `QtWidgets.QWidget`. We therefore need to convert it using
-  `ida_kernwin.PluginForm.TWidgetToPyQtWidget`
-
- -
    -
  • Category: pyqt
    • -
  • Summary: Injecting commands in the "Output" window
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_kernwin.PluginForm.TWidgetToPyQtWidget
      • -
    • ida_kernwin.disabled_script_timeout_t
      • -
    • ida_kernwin.find_widget
      • -
    • ida_kernwin.process_ui_action
      • -
    -
    • - - -
-
-
-
-
- ▹ - - paint_over_graph: Custom painting on top of graph view edges -
-
- -
-This sample registers an action enabling painting of a recognizable
-string of text over horizontal nodes edge sections beyond a
-satisfying size threshold.
-
-In a disassembly view, open the context menu and select
-"Paint on edges". This should work for both graph disassembly,
-and proximity browser.
-
-Using an "event filter", we will intercept paint events
-targeted at the disassembly view, let it paint itself, and
-then add our own markers along.
-
- -
    -
  • Category: pyqt
    • -
  • Summary: Custom painting on top of graph view edges
    • -
  • View on GitHub
    • -
  • Keywords: - ctxmenu - UI_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_graph.edge_t
      • -
    • ida_graph.get_graph_viewer
      • -
    • ida_graph.get_viewer_graph
      • -
    • ida_graph.point_t
      • -
    • ida_graph.viewer_get_gli
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_DISASM
      • -
    • ida_kernwin.PluginForm.FormToPyQtWidget
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.get_widget_type
      • -
    • ida_kernwin.register_action
      • -
    • ida_moves.graph_location_info_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - paint_over_navbar: Custom painting on top of the navigation band -
-
- -
-Using an "event filter", we will intercept paint events
-targeted at the navigation band widget, let it paint itself,
-and then add our own markers on top.
-
- -
    -
  • Category: pyqt
    • -
  • Summary: Custom painting on top of the navigation band
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_kernwin.PluginForm.FormToPyQtWidget
      • -
    • ida_kernwin.get_navband_pixel
      • -
    • ida_kernwin.open_navband_window
      • -
    • ida_segment.get_segm_qty
      • -
    • ida_segment.getnseg
      • -
    • idc.here
      • -
    -
    • - - -
-
-
-
-
- ▹ - - populate_pluginform_with_pyqt_widgets: Adding PyQt5 widgets into an `ida_kernwin.PluginForm` -
-
- -
-Using `ida_kernwin.PluginForm.FormToPyQtWidget`, this script
-converts IDA's own dockable widget into a type that is
-recognized by PyQt5, which then enables populating it with
-regular Qt widgets.
-
- -
    -
  • Category: pyqt
    • -
  • Summary: Adding PyQt5 widgets into an `ida_kernwin.PluginForm`
    • -
  • View on GitHub
    • - - - -
  • APIs used -
      -
    • ida_kernwin.PluginForm
      • -
    -
    • - - -
-
-
- -
-

Category: uihooks

-
-
-
- ▹ - - func_chooser_coloring: Using `ida_kernwin.UI_Hooks.get_chooser_item_attrs` to override some defaults -
-
- -
-Color the function in the Function window according to its size.
-The larger the function, the darker the color.
-
- -
    -
  • Category: uihooks
    • -
  • Summary: Using `ida_kernwin.UI_Hooks.get_chooser_item_attrs` to override some defaults
    • -
  • View on GitHub
    • -
  • Keywords: - UI_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.enable_chooser_item_attrs
      • -
    -
    • - - -
-
-
-
-
- ▹ - - lines_rendering: Dynamically colorize lines backgrounds (or parts of them) -
-
- -
-Shows how one can dynamically alter the lines background
-rendering (as opposed to, say, using ida_nalt.set_item_color()),
-and also shows how that rendering can be limited to just a few
-glyphs, not the whole line.
-
- -
    -
  • Category: uihooks
    • -
  • Summary: Dynamically colorize lines backgrounds (or parts of them)
    • -
  • View on GitHub
    • -
  • Keywords: - UI_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_bytes.next_head
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_kernwin.CK_EXTRA1
      • -
    • ida_kernwin.CK_EXTRA10
      • -
    • ida_kernwin.CK_EXTRA11
      • -
    • ida_kernwin.CK_EXTRA12
      • -
    • ida_kernwin.CK_EXTRA13
      • -
    • ida_kernwin.CK_EXTRA14
      • -
    • ida_kernwin.CK_EXTRA15
      • -
    • ida_kernwin.CK_EXTRA16
      • -
    • ida_kernwin.CK_EXTRA2
      • -
    • ida_kernwin.CK_EXTRA3
      • -
    • ida_kernwin.CK_EXTRA4
      • -
    • ida_kernwin.CK_EXTRA5
      • -
    • ida_kernwin.CK_EXTRA6
      • -
    • ida_kernwin.CK_EXTRA7
      • -
    • ida_kernwin.CK_EXTRA8
      • -
    • ida_kernwin.CK_EXTRA9
      • -
    • ida_kernwin.CK_TRACE
      • -
    • ida_kernwin.CK_TRACE_OVL
      • -
    • ida_kernwin.LROEF_CPS_RANGE
      • -
    • ida_kernwin.UI_Hooks
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_kernwin.line_rendering_output_entry_t
      • -
    • ida_kernwin.refresh_idaview_anyway
      • -
    -
    • - - -
-
-
-
-
- ▹ - - log_misc_events: Being notified, and logging a few UI events -
-
- -
-Hooks to be notified about certain UI events, and
-dump their information to the "Output" window
-
- -
    -
  • Category: uihooks
    • -
  • Summary: Being notified, and logging a few UI events
    • -
  • View on GitHub
    • -
  • Keywords: - UI_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_kernwin.UI_Hooks
      • -
    -
    • - - -
-
-
-
-
- ▹ - - prevent_jump: Taking precedence over actions -
-
- -
-Using `ida_kernwin.UI_Hooks.preprocess_action`, it is possible
-to respond to a command instead of the action that would
-otherwise do it.
-
- -
    -
  • Category: uihooks
    • -
  • Summary: Taking precedence over actions
    • -
  • View on GitHub
    • -
  • Keywords: - UI_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_kernwin.UI_Hooks
      • -
    -
    • - - -
-
-
- -
-

Category: widgets

-
-
-
- ▹ - - add_menus: Adding custom menus to IDA -
-
- -
-It is possible to add custom menus to IDA, either at the
-toplevel (i.e., into the menubar), or as submenus of existing
-menus.
-
-Notes:
-
-  * the same action can be present in more than 1 menu
-  * this example does not deal with context menus
-
- -
    -
  • Category: widgets
    • -
  • Summary: Adding custom menus to IDA
    • -
  • View on GitHub
    • -
  • Keywords: - actions -
    • - - - -
  • APIs used -
      -
    • ida_kernwin.AST_ENABLE_ALWAYS
      • -
    • ida_kernwin.SETMENU_INS
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_menu
      • -
    • ida_kernwin.create_menu
      • -
    • ida_kernwin.register_action
      • -
    -
    • - - -
-
-
-
-
- ▹ - - askusingform: Non-trivial uses of the `ida_kernwin.Form` helper class -
-
- -
-How to query for complex user input, using IDA's built-in forms.
-
-Note: while this example produces full-fledged forms for complex input,
-simpler types of inputs might can be retrieved by using
-`ida_kernwin.ask_str` and similar functions.
-
- -
    -
  • Category: widgets
    • -
  • Summary: Non-trivial uses of the `ida_kernwin.Form` helper class
    • -
  • View on GitHub
    • -
  • Keywords: - forms -
    • - - - -
  • APIs used -
      -
    • ida_kernwin.Choose
      • -
    • ida_kernwin.Choose.CH_MULTI
      • -
    • ida_kernwin.Form
      • -
    • ida_kernwin.PluginForm.FORM_TAB
      • -
    • ida_kernwin.ask_str
      • -
    -
    • - - -
-
-
-
-
- ▹ - - choose: A widget showing data in a tabular fashion -
-
- -
-Shows how to subclass the ida_kernwin.Choose class to
-show data organized in a simple table.
-In addition, registers a couple actions that can be applied to it.
-
- -
    -
  • Category: widgets
    • -
  • Summary: A widget showing data in a tabular fashion
    • -
  • View on GitHub
    • -
  • Keywords: - actions - chooser - ctxmenu -
    • - - - -
  • APIs used -
      -
    • Choose
      • -
    • Choose.ALL_CHANGED
      • -
    • Choose.CH_CAN_DEL
      • -
    • Choose.CH_CAN_EDIT
      • -
    • Choose.CH_CAN_INS
      • -
    • Choose.CH_CAN_REFRESH
      • -
    • Choose.CH_RESTORE
      • -
    • Choose.NOTHING_CHANGED
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.is_chooser_widget
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.unregister_action
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - choose_multi: A widget showing data in a tabular fashion, providing multiple selection -
-
- -
-Similar to choose, but with multiple selection
-
- -
    -
  • Category: widgets
    • -
  • Summary: A widget showing data in a tabular fashion, providing multiple selection
    • -
  • View on GitHub
    • -
  • Keywords: - actions - chooser -
    • - - - -
  • APIs used -
      -
    • Choose
      • -
    • Choose.ALL_CHANGED
      • -
    • Choose.CHCOL_HEX
      • -
    • Choose.CH_MULTI
      • -
    • Choose.NOTHING_CHANGED
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - chooser_with_folders: A widget that can show tabular data either as a simple table, or with a tree-like structure. -
-
- -
-By adding the necessary bits to a ida_kernwin.Choose subclass,
-IDA can show the otherwise tabular data, in a tree-like fashion.
-
-The important bits to enable this are:
-
-  * ida_dirtree.dirspec_t (and my_dirspec_t)
-  * ida_kernwin.CH_HAS_DIRTREE
-  * ida_kernwin.Choose.OnGetDirTree
-  * ida_kernwin.Choose.OnIndexToInode
-
- -
    -
  • Category: widgets
    • -
  • Summary: A widget that can show tabular data either as a simple table, or with a tree-like structure.
    • -
  • View on GitHub
    • -
  • Keywords: - actions - chooser - folders -
    • - - - -
  • APIs used -
      -
    • ida_dirtree.DTE_OK
      • -
    • ida_dirtree.direntry_t
      • -
    • ida_dirtree.direntry_t.BADIDX
      • -
    • ida_dirtree.dirspec_t
      • -
    • ida_dirtree.dirtree_t
      • -
    • ida_dirtree.dirtree_t.isdir
      • -
    • ida_kernwin.CH_CAN_DEL
      • -
    • ida_kernwin.CH_CAN_EDIT
      • -
    • ida_kernwin.CH_CAN_INS
      • -
    • ida_kernwin.CH_HAS_DIRTREE
      • -
    • ida_kernwin.CH_MULTI
      • -
    • ida_kernwin.Choose
      • -
    • ida_kernwin.Choose.ALL_CHANGED
      • -
    • ida_kernwin.Choose.CHCOL_DRAGHINT
      • -
    • ida_kernwin.Choose.CHCOL_INODENAME
      • -
    • ida_kernwin.Choose.CHCOL_PLAIN
      • -
    • ida_kernwin.ask_str
      • -
    • ida_netnode.BADNODE
      • -
    • ida_netnode.netnode
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - custom_graph_with_actions: Drawing custom graphs -
-
- -
-Showing custom graphs, using `ida_graph.GraphViewer`. In addition,
-show how to write actions that can be performed on those.
-
- -
    -
  • Category: widgets
    • -
  • Summary: Drawing custom graphs
    • -
  • View on GitHub
    • -
  • Keywords: - actions - graph - View_Hooks -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func
      • -
    • ida_funcs.get_func_name
      • -
    • ida_graph.GraphViewer
      • -
    • ida_graph.get_graph_viewer
      • -
    • ida_graph.screen_graph_selection_t
      • -
    • ida_graph.viewer_get_selection
      • -
    • ida_idp.is_call_insn
      • -
    • ida_kernwin.AST_ENABLE_ALWAYS
      • -
    • ida_kernwin.View_Hooks
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_dynamic_action_to_popup
      • -
    • ida_kernwin.get_screen_ea
      • -
    • ida_ua.decode_insn
      • -
    • ida_ua.insn_t
      • -
    • ida_xref.XREF_FAR
      • -
    • ida_xref.xrefblk_t
      • -
    -
    • - - -
-
-
-
-
- ▹ - - custom_viewer: Create custom listings in IDA -
-
- -
-How to create simple listings, that will share many of the features
-as the built-in IDA widgets (highlighting, copy & paste,
-notifications, ...)
-
-In addition, creates actions that will be bound to the
-freshly-created widget (using `ida_kernwin.attach_action_to_popup`.)
-
- -
    -
  • Category: widgets
    • -
  • Summary: Create custom listings in IDA
    • -
  • View on GitHub
    • -
  • Keywords: - actions - ctxmenu - listing -
    • - - - -
  • APIs used -
      -
    • ida_kernwin.AST_ENABLE_ALWAYS
      • -
    • ida_kernwin.IK_DELETE
      • -
    • ida_kernwin.IK_ESCAPE
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.ask_long
      • -
    • ida_kernwin.ask_str
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.simplecustviewer_t
      • -
    • ida_kernwin.simplecustviewer_t.Create
      • -
    • ida_kernwin.simplecustviewer_t.Show
      • -
    • ida_kernwin.unregister_action
      • -
    • ida_lines.COLOR_DEFAULT
      • -
    • ida_lines.COLOR_DNAME
      • -
    • ida_lines.COLSTR
      • -
    • ida_lines.SCOLOR_PREFIX
      • -
    • ida_lines.SCOLOR_VOIDOP
      • -
    -
    • - - -
-
-
-
-
- ▹ - - func_chooser: An alternative view over the list of functions -
-
- -
-Partially re-implements the "Functions" widget present in
-IDA, with a custom widget.
-
- -
    -
  • Category: widgets
    • -
  • Summary: An alternative view over the list of functions
    • -
  • View on GitHub
    • -
  • Keywords: - chooser - functions -
    • - - - -
  • APIs used -
      -
    • ida_funcs.get_func_name
      • -
    • ida_kernwin.Choose
      • -
    • ida_kernwin.Choose.ALL_CHANGED
      • -
    • ida_kernwin.Choose.CHCOL_FNAME
      • -
    • ida_kernwin.Choose.CHCOL_HEX
      • -
    • ida_kernwin.Choose.CHCOL_PLAIN
      • -
    • ida_kernwin.get_icon_id_by_name
      • -
    • idautils.Functions
      • -
    • idc.del_func
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - jump_next_comment: Implement a "jump to next comment" action within IDA's disassembly view. -
-
- -
-We want our action not only to find the next line containing a comment,
-but to also place the cursor at the right horizontal position.
-
-To find that position, we will have to inspect the text that IDA
-generates, looking for the start of a comment.
-However, we won't be looking for a comment "prefix" (e.g., "; "),
-as that would be too fragile.
-
-Instead, we will look for special "tags" that IDA injects into textual
-lines, and that bear semantic information.
-
-Those tags are primarily used for rendering (i.e., switching colors),
-but can also be very handy for spotting tokens of interest (registers,
-addresses, comments, prefixes, instruction mnemonics, ...)
-
- -
    -
  • Category: widgets
    • -
  • Summary: Implement a "jump to next comment" action within IDA's disassembly view.
    • -
  • View on GitHub
    • -
  • Keywords: - actions - idaview -
    • - -
  • Shortcut: - Ctrl+Alt+C -
    • - - -
  • APIs used -
      -
    • ida_bytes.next_head
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_DISASM
      • -
    • ida_kernwin.CVNF_LAZY
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.custom_viewer_jump
      • -
    • ida_kernwin.get_custom_viewer_location
      • -
    • ida_kernwin.place_t_as_idaplace_t
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.unregister_action
      • -
    • ida_lines.SCOLOR_AUTOCMT
      • -
    • ida_lines.SCOLOR_ON
      • -
    • ida_lines.SCOLOR_REGCMT
      • -
    • ida_lines.SCOLOR_RPTCMT
      • -
    • ida_lines.generate_disassembly
      • -
    • ida_lines.tag_strlen
      • -
    • ida_moves.lochist_entry_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - lazy_loaded_chooser: -
-
- -
-
-
- -
    -
  • Category: widgets
    • -
  • Summary:
    • -
  • View on GitHub
    • - - - - - -
-
-
-
-
- ▹ - - save_and_restore_listing_pos: Save, and then restore, positions in a listing -
-
- -
-Shows how it is possible re-implement IDA's bookmark capability,
-using 2 custom actions: one action saves the current location,
-and the other restores it.
-
-Note that, contrary to actual bookmarks, this example:
-
-  * remembers only 1 saved position
-  * doesn't save that position in the IDB (and therefore cannot
-    be restored if IDA is closed & reopened.)
-
- -
    -
  • Category: widgets
    • -
  • Summary: Save, and then restore, positions in a listing
    • -
  • View on GitHub
    • -
  • Keywords: - actions - listing -
    • - -
  • Shortcuts: - Ctrl+Shift+O - Ctrl+Shift+S -
    • - - -
  • APIs used -
      -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_CUSTVIEW
      • -
    • ida_kernwin.BWN_DISASM
      • -
    • ida_kernwin.BWN_ENUMS
      • -
    • ida_kernwin.BWN_PSEUDOCODE
      • -
    • ida_kernwin.BWN_STRUCTS
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.custom_viewer_jump
      • -
    • ida_kernwin.find_widget
      • -
    • ida_kernwin.get_custom_viewer_location
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.unregister_action
      • -
    • ida_moves.lochist_entry_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - show_and_hide_waitbox: Showing, updating & hiding the progress dialog -
-
- -
-Using the progress dialog (aka 'wait box') primitives.
-
- -
    -
  • Category: widgets
    • -
  • Summary: Showing, updating & hiding the progress dialog
    • -
  • View on GitHub
    • -
  • Keywords: - actions -
    • - - - -
  • APIs used -
      -
    • ida_hexrays.decompile
      • -
    • ida_kernwin.hide_wait_box
      • -
    • ida_kernwin.replace_wait_box
      • -
    • ida_kernwin.show_wait_box
      • -
    • ida_kernwin.user_cancelled
      • -
    • idautils.Functions
      • -
    -
    • - - -
-
-
-
-
- ▹ - - show_selected_strings: Retrieve the strings that are selected in the "Strings" window. -
-
- -
-In IDA it's possible to write actions that can be applied even to
-core (i.e., "standard") widgets. The actions in this example use the
-action "context" to know what the current selection is.
-
-This example shows how you can either retrieve string literals data
-directly from the chooser (`ida_kernwin.get_chooser_data`), or
-by querying the IDB (`ida_bytes.get_strlit_contents`)
-
- -
    -
  • Category: widgets
    • -
  • Summary: Retrieve the strings that are selected in the "Strings" window.
    • -
  • View on GitHub
    • -
  • Keywords: - actions - ctxmenu -
    • - -
  • Shortcuts: - Ctrl+Shift+K - Ctrl+Shift+S -
    • - - -
  • APIs used -
      -
    • ida_bytes.get_strlit_contents
      • -
    • ida_idaapi.BADADDR
      • -
    • ida_kernwin.AST_DISABLE_FOR_WIDGET
      • -
    • ida_kernwin.AST_ENABLE_FOR_WIDGET
      • -
    • ida_kernwin.BWN_STRINGS
      • -
    • ida_kernwin.action_desc_t
      • -
    • ida_kernwin.action_handler_t
      • -
    • ida_kernwin.attach_action_to_popup
      • -
    • ida_kernwin.find_widget
      • -
    • ida_kernwin.get_chooser_data
      • -
    • ida_kernwin.open_strings_window
      • -
    • ida_kernwin.register_action
      • -
    • ida_kernwin.unregister_action
      • -
    • ida_strlist.get_strlist_item
      • -
    • ida_strlist.string_info_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - sync_two_graphs: Follow the movements of a disassembly graph, in another. -
-
- -
-Since it is possible to be notified of movements that happen
-take place in a widget, it's possible to "replay" those
-movements in another.
-
-In this case, "IDA View-B" (will be opened if necessary) will
-show the same contents as "IDA View-A", slightly zoomed out.
-
- -
    -
  • Category: widgets
    • -
  • Summary: Follow the movements of a disassembly graph, in another.
    • -
  • View on GitHub
    • -
  • Keywords: - graph - idaview -
    • - - - -
  • APIs used -
      -
    • ida_graph.GLICTL_CENTER
      • -
    • ida_graph.viewer_fit_window
      • -
    • ida_graph.viewer_get_gli
      • -
    • ida_graph.viewer_set_gli
      • -
    • ida_kernwin.DP_RIGHT
      • -
    • ida_kernwin.IDAViewWrapper
      • -
    • ida_kernwin.MFF_FAST
      • -
    • ida_kernwin.TCCRT_GRAPH
      • -
    • ida_kernwin.execute_sync
      • -
    • ida_kernwin.find_widget
      • -
    • ida_kernwin.get_custom_viewer_place
      • -
    • ida_kernwin.jumpto
      • -
    • ida_kernwin.open_disasm_window
      • -
    • ida_kernwin.set_dock_pos
      • -
    • ida_kernwin.set_view_renderer_type
      • -
    • ida_moves.graph_location_info_t
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
-
-
- ▹ - - wrap_idaview: Manipulate IDAView and graph -
-
- -
-This is an example illustrating how to manipulate an existing IDA-provided
-view (and thus possibly its graph), in Python.
-
- -
    -
  • Category: widgets
    • -
  • Summary: Manipulate IDAView and graph
    • -
  • View on GitHub
    • -
  • Keywords: - graph - idaview -
    • - - - -
  • APIs used -
      -
    • ida_graph.NIF_BG_COLOR
      • -
    • ida_graph.NIF_FRAME_COLOR
      • -
    • ida_graph.node_info_t
      • -
    • ida_kernwin.IDAViewWrapper
      • -
    • ida_kernwin.MFF_FAST
      • -
    • ida_kernwin.TCCRT_FLAT
      • -
    • ida_kernwin.TCCRT_GRAPH
      • -
    • ida_kernwin.execute_sync
      • -
    -
    • - -
  • See also: - -
    • - -
-
-
- -
- - diff --git a/examples/index.js b/examples/index.js deleted file mode 100644 index 9f8bd2f..0000000 --- a/examples/index.js +++ /dev/null @@ -1,72 +0,0 @@ - -function on_see_also(see_also) -{ - var idx = see_also.indexOf("#"); - if ( idx > -1 ) - see_also = see_also.substring(idx+1,see_also.length); - var entry = find_entry_el(document.getElementById('DIV_' + see_also)); - if ( entry ) - { - set_entry_state(entry, true); - entry.scrollIntoView(); - } -} - -function find_parent_with_class(el, klass) -{ - while ( el ) - { - if ( el.className && el.className.indexOf(klass) > -1 ) - return el; - el = el.parentNode; - } -} - -function find_child_with_class(el, klass) -{ - return el.querySelector("." + klass); -} - -function find_entry_el(el) { return find_parent_with_class(el, "example-entry"); } -function find_expander(entry_el) { return find_child_with_class(entry_el, "expander"); } -function find_collapser(entry_el) { return find_child_with_class(entry_el, "collapser"); } - -function set_entry_state(entry_el, expanded) -{ - var collapser_el = find_collapser(entry_el); - var expander_el = find_expander(entry_el); - collapser_el.style.display = expanded ? "" : "none"; - expander_el.style.display = expanded ? "none" : ""; - if ( expanded ) - entry_el.classList.remove("collapsed-entry"); - else - entry_el.classList.add("collapsed-entry"); -} - -function handle_click(e) -{ - e = e || window.event; - var el = e.target || e.srcElement; - var entry_el = find_entry_el(el); - var ok = false; - if ( el.classList.contains("collapser") ) - set_entry_state(entry_el, false); - else if ( el.classList.contains("expander") ) - set_entry_state(entry_el, true); - else if ( el.classList.contains("ex_link") ) // see also - on_see_also(el.href); - else - return; - e.stopPropagation(); -} - -function handle_toplevel_action(e) -{ - e = e || window.event; - var el = e.target || e.srcElement; - var expanded = el.classList.contains("expand-all"); - var els = document.getElementsByClassName("example-entry"); - for ( var idx = 0, n = els.length; idx < n; ++idx ) - set_entry_state(els[idx], expanded); - e.stopPropagation(); -} diff --git a/examples/index.md b/examples/index.md index 80e42ea..64e992b 100644 --- a/examples/index.md +++ b/examples/index.md @@ -1,54 +1,387 @@ -[HTML version](http://htmlpreview.github.io/?https://github.com/idapython/src/blob/master/examples/index.html) -# IDAPython examples +# Examples -## Category: analysis +## IDAPython examples -#### dump_func_info -
- Dump (some) information about the current function. +This collection of examples organizes all IDAPython sample code into [categories](#example-categories-overview) for easy reference. Each example demonstrates practical implementation for the IDAPython API, complementing the [reference documentation](https://python.docs.hex-rays.com/) with a real-world usage scenario. -
+### How to run the examples? -#### Source code -analysis/dump_func_info.py +#### Load the script via File Loader -#### Category -analysis +1. Navigate to **File -> Script file...**. +2. In the new dialog, select the `.py` script you want to run and click **Open**. -#### Description -Dump some of the most interesting bits of information about -the function we are currently looking at. +#### Load the script via Script command -#### Uses -* ida_funcs.FUNC_FRAME -* ida_funcs.FUNC_LUMINA -* ida_funcs.FUNC_OUTLINE -* ida_funcs.FUNC_THUNK -* ida_funcs.get_fchunk -* ida_funcs.is_func_entry -* ida_funcs.is_func_tail -* ida_kernwin.get_screen_ea +1. Navigate to **File -> Script command...**. +2. Paste the code into _Please enter script body_ field and click **Run**. -
+#### Load the script via output window/console -
+1. In the output window/IDAPython console, type the following command: `exec(open("path/to/your_script.py").read())` to execute the script. -## Category: core +## Example Categories: Overview -#### actions -
- Custom actions, with icons & tooltips + + + -
+
+ + + + + + + + + + + + + + + + + + + + + + + -#### Source code -core/actions.py + +
User interfaceCreating & manipulating user-interface widgets, prompting the user with forms, enriching existing widgets, or creating your own UI through Python Qt bindings.
DisassemblyVarious ways to query, or modify the disassembly listing, alter the way analysis is performed, or be notified of changes made to the IDB.
DecompilationQuerying the decompiler, manipulating the decompilation trees (either at the microcode level, or the C-tree), and examples showing how to intervene in the decompilation output.
DebuggersDriving debugging sessions, be notified of debugging events.
Working with typesThese samples utilize our Type APIs, which allow you to manage the types and perform various operations on them, like creating the structures or enums and adding their members programmatically.
MiscellaneousMiscellaneous examples that don't quite fall into another category, but don't really justify one of their own.
-#### Category -core -#### Description + +## User interface {#ui} + + + + + + + + + + + + + + + + + + + + + + + + +
LevelExamples
Beginner
Intermediate
Advanced
+ + +## Disassembly {#disassembler} + + + + + + + + + + + + + + + + + + + + + + + + +
LevelExamples
Beginner
Intermediate
Advanced
+ + +## Decompilation {#decompiler} + + + + + + + + + + + + + + + + + + + + + + + + +
LevelExamples
Beginner
Intermediate
Advanced
+ + +## Debuggers {#debugger} + + + + + + + + + + + + + + + + + + + + + + + + +
LevelExamples
Beginner
Intermediate
Advanced
+ + +## Working with types {#types} + + + + + + + + + + + + + + + + + + + + + + + + +
LevelExamples
Beginner
Intermediate
Advanced
+ + +## Miscellaneous {#misc} + + + + + + + + + + + + + + + + + + + + + + + + +
LevelExamples
Beginner
Intermediate
Advanced
+ + + +*** + +## Examples list + + +### Assign a shortcut to a custom function {#add_hotkey} +`ida_kernwin.add_hotkey` is a simpler, but much less flexible +alternative to `ida_kernwin.register_action` (though it does +use the same mechanism under the hood.) + +It's particularly useful during prototyping, but note that the +actions that are created cannot be inserted in menus, toolbars +or cannot provide a custom `ida_kernwin.action_handler_t.update` +callback. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [add_hotkey.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/add_hotkey.py) | actions | Beginner | + +**APIs Used:** +* `ida_kernwin.add_hotkey` +* `ida_kernwin.del_hotkey` + +*** + + +### Add custom menus to IDA {#add_menus} +It is possible to add custom menus to IDA, either at the +toplevel (i.e., into the menubar), or as submenus of existing +menus. + +Notes: + + * the same action can be present in more than 1 menu + * this example does not deal with context menus + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [add_menus.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/misc/add_menus.py) | actions | Beginner | + +**APIs Used:** +* `ida_kernwin.AST_ENABLE_ALWAYS` +* `ida_kernwin.SETMENU_INS` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_menu` +* `ida_kernwin.create_menu` +* `ida_kernwin.register_action` + +*** + + +### Assign a background color to an address, function & segment {#colorize_disassembly} +This illustrates the setting/retrieval of background colours +using the IDC wrappers + +In order to do so, we'll be assigning colors to specific ranges +(item, function, or segment). Those will be persisted in the +database. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [colorize_disassembly.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/colorize_disassembly.py) | coloring idc | Beginner | + +**APIs Used:** +* `idc.CIC_FUNC` +* `idc.CIC_ITEM` +* `idc.CIC_SEGM` +* `idc.get_color` +* `idc.here` +* `idc.set_color` + +*** + + +### Override the default "Functions" chooser colors {#func_chooser_coloring} +Color the function in the Function window according to its size. +The larger the function, the darker the color. + +The key, is overriding `ida_kernwin.UI_Hooks.get_chooser_item_attrs` + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [func_chooser_coloring.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/uihooks/func_chooser_coloring.py) | UI_Hooks | Beginner | + +**APIs Used:** +* `ida_funcs.get_func` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.enable_chooser_item_attrs` + +*** + + +### Create a dockable container, and populate it with Qt widgets {#populate_pluginform_with_pyqt_widgets} +Using `ida_kernwin.PluginForm.FormToPyQtWidget`, this script +converts IDA's own dockable widget into a type that is +recognized by PyQt5, which then enables populating it with +regular Qt widgets. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [populate_pluginform_with_pyqt_widgets.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/pyqt/populate_pluginform_with_pyqt_widgets.py) | | Beginner | + +**APIs Used:** +* `ida_kernwin.PluginForm` + +*** + + +### Prevent an action from being triggered {#prevent_jump} +Using `ida_kernwin.UI_Hooks.preprocess_action`, it is possible +to respond to a command instead of the action that would +otherwise do it. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [prevent_jump.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/uihooks/prevent_jump.py) | UI_Hooks | Beginner | + +**APIs Used:** +* `ida_kernwin.UI_Hooks` + +*** + + +### Use timers for delayed execution {#register_timer} +Register (possibly repeating) timers. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [register_timer.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/register_timer.py) | | Beginner | + +**APIs Used:** +* `ida_kernwin.register_timer` + +*** + + +### Show, update & hide the progress dialog {#show_and_hide_waitbox} +Using the progress dialog (aka 'wait box') primitives. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [show_and_hide_waitbox.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/waitbox/show_and_hide_waitbox.py) | actions | Beginner | + +**APIs Used:** +* `ida_hexrays.decompile` +* `ida_kernwin.hide_wait_box` +* `ida_kernwin.replace_wait_box` +* `ida_kernwin.show_wait_box` +* `ida_kernwin.user_cancelled` +* `idautils.Functions` + +*** + + +### Custom actions, with icons & tooltips {#actions} How to create user actions, that once created can be inserted in menus, toolbars, context menus, ... @@ -60,116 +393,398 @@ In addition, custom actions can determine when they want to be available (through their `ida_kernwin.action_handler_t.update` callback) -#### Shortcut -Ctrl+F12 +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [actions.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/actions.py) | actions ctxmenu UI_Hooks | Intermediate | -#### Keywords -actions ctxmenu UI_Hooks +**APIs Used:** +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.SETMENU_APP` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_menu` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.attach_action_to_toolbar` +* `ida_kernwin.get_widget_type` +* `ida_kernwin.load_custom_icon` +* `ida_kernwin.register_action` +* `ida_kernwin.unregister_action` -#### Uses -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_DISASM -* ida_kernwin.SETMENU_APP -* ida_kernwin.UI_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_menu -* ida_kernwin.attach_action_to_popup -* ida_kernwin.attach_action_to_toolbar -* ida_kernwin.get_widget_type -* ida_kernwin.load_custom_icon -* ida_kernwin.register_action -* ida_kernwin.unregister_action +*** -#### See also -* [add_hotkey](#add_hotkey) - +### Show tabular data {#choose} +Shows how to subclass the ida_kernwin.Choose class to +show data organized in a simple table. +In addition, registers a couple actions that can be applied to it. -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [choose.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/tabular_views/custom/choose.py) | actions chooser ctxmenu | Intermediate | -#### add_hotkey -
- Triggering bits of code by pressing a shortcut +**APIs Used:** +* `Choose` +* `Choose.ALL_CHANGED` +* `Choose.CH_CAN_DEL` +* `Choose.CH_CAN_EDIT` +* `Choose.CH_CAN_INS` +* `Choose.CH_CAN_REFRESH` +* `Choose.CH_RESTORE` +* `Choose.NOTHING_CHANGED` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.is_chooser_widget` +* `ida_kernwin.register_action` +* `ida_kernwin.unregister_action` -
+*** -#### Source code -core/add_hotkey.py -#### Category -core +### Show tabular data, with multiple selection {#choose_multi} +Similar to choose, but with multiple selection -#### Description -`ida_kernwin.add_hotkey` is a simpler, but much less flexible -alternative to `ida_kernwin.register_action` (though it does -use the same mechanism under the hood.) +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [choose_multi.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/tabular_views/custom/choose_multi.py) | actions chooser | Intermediate | -It's particularly useful during prototyping, but note that the -actions that are created cannot be inserted in menus, toolbars -or cannot provide a custom `ida_kernwin.action_handler_t.update` -callback. +**APIs Used:** +* `Choose` +* `Choose.ALL_CHANGED` +* `Choose.CHCOL_HEX` +* `Choose.CH_MULTI` +* `Choose.NOTHING_CHANGED` -#### Keywords -actions +*** -#### Uses -* ida_kernwin.add_hotkey -* ida_kernwin.del_hotkey -#### See also -* [actions](#actions) +### Create custom listings in IDA {#custom_viewer} +How to create simple listings, that will share many of the features +as the built-in IDA widgets (highlighting, copy & paste, +notifications, ...) -
+In addition, creates actions that will be bound to the +freshly-created widget (using `ida_kernwin.attach_action_to_popup`.) -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [custom_viewer.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/listings/custom_viewer.py) | actions ctxmenu listing | Intermediate | -#### add_idc_hotkey -
- Triggering bits of code by pressing a shortcut (older version) +**APIs Used:** +* `ida_kernwin.AST_ENABLE_ALWAYS` +* `ida_kernwin.IK_DELETE` +* `ida_kernwin.IK_ESCAPE` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.ask_long` +* `ida_kernwin.ask_str` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.register_action` +* `ida_kernwin.simplecustviewer_t` +* `ida_kernwin.simplecustviewer_t.Create` +* `ida_kernwin.simplecustviewer_t.Show` +* `ida_kernwin.unregister_action` +* `ida_lines.COLOR_DEFAULT` +* `ida_lines.COLOR_DNAME` +* `ida_lines.COLSTR` +* `ida_lines.SCOLOR_PREFIX` +* `ida_lines.SCOLOR_VOIDOP` -
+*** -#### Source code -core/add_idc_hotkey.py -#### Category -core +### Implement an alternative "Functions" window {#func_chooser} +Partially re-implements the "Functions" widget present in +IDA, with a custom widget. -#### Description -This is a somewhat ancient way of registering actions & binding -shortcuts. It's still here for reference, but "fresher" alternatives -should be preferred. +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [func_chooser.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/tabular_views/custom/func_chooser.py) | chooser functions | Intermediate | -#### Keywords -actions +**APIs Used:** +* `ida_funcs.get_func_name` +* `ida_kernwin.Choose` +* `ida_kernwin.Choose.ALL_CHANGED` +* `ida_kernwin.Choose.CHCOL_FNAME` +* `ida_kernwin.Choose.CHCOL_HEX` +* `ida_kernwin.Choose.CHCOL_PLAIN` +* `ida_kernwin.get_icon_id_by_name` +* `idautils.Functions` +* `idc.del_func` -#### Uses -* ida_expr.compile_idc_text -* ida_kernwin.add_idc_hotkey +*** -#### See also -* [actions](#actions) -* [add_hotkey](#add_hotkey) -
+### Implement a "jump to next comment" action within IDA's listing {#jump_next_comment} +We want our action not only to find the next line containing a comment, +but to also place the cursor at the right horizontal position. -
+To find that position, we will have to inspect the text that IDA +generates, looking for the start of a comment. +However, we won't be looking for a comment "prefix" (e.g., "; "), +as that would be too fragile. -#### auto_instantiate_widget_plugin -
- Better integrating custom widgets in the desktop layout +Instead, we will look for special "tags" that IDA injects into textual +lines, and that bear semantic information. -
+Those tags are primarily used for rendering (i.e., switching colors), +but can also be very handy for spotting tokens of interest (registers, +addresses, comments, prefixes, instruction mnemonics, ...) -#### Source code -core/auto_instantiate_widget_plugin.py +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [jump_next_comment.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/listings/jump_next_comment.py) | actions idaview | Intermediate | -#### Category -core +**APIs Used:** +* `ida_bytes.next_head` +* `ida_idaapi.BADADDR` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.CVNF_LAZY` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.custom_viewer_jump` +* `ida_kernwin.get_custom_viewer_location` +* `ida_kernwin.place_t_as_idaplace_t` +* `ida_kernwin.register_action` +* `ida_kernwin.unregister_action` +* `ida_lines.SCOLOR_AUTOCMT` +* `ida_lines.SCOLOR_ON` +* `ida_lines.SCOLOR_REGCMT` +* `ida_lines.SCOLOR_RPTCMT` +* `ida_lines.generate_disassembly` +* `ida_lines.tag_strlen` +* `ida_moves.lochist_entry_t` -#### Description +*** + + +### Dynamically colorize [parts of] lines {#lines_rendering} +Shows how one can dynamically alter the lines background +rendering (as opposed to, say, using ida_nalt.set_item_color()), +and also shows how that rendering can be limited to just a few +glyphs, not the whole line. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [lines_rendering.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/uihooks/lines_rendering.py) | UI_Hooks | Intermediate | + +**APIs Used:** +* `ida_bytes.next_head` +* `ida_idaapi.BADADDR` +* `ida_kernwin.CK_EXTRA1` +* `ida_kernwin.CK_EXTRA10` +* `ida_kernwin.CK_EXTRA11` +* `ida_kernwin.CK_EXTRA12` +* `ida_kernwin.CK_EXTRA13` +* `ida_kernwin.CK_EXTRA14` +* `ida_kernwin.CK_EXTRA15` +* `ida_kernwin.CK_EXTRA16` +* `ida_kernwin.CK_EXTRA2` +* `ida_kernwin.CK_EXTRA3` +* `ida_kernwin.CK_EXTRA4` +* `ida_kernwin.CK_EXTRA5` +* `ida_kernwin.CK_EXTRA6` +* `ida_kernwin.CK_EXTRA7` +* `ida_kernwin.CK_EXTRA8` +* `ida_kernwin.CK_EXTRA9` +* `ida_kernwin.CK_TRACE` +* `ida_kernwin.CK_TRACE_OVL` +* `ida_kernwin.LROEF_CPS_RANGE` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.get_screen_ea` +* `ida_kernwin.line_rendering_output_entry_t` +* `ida_kernwin.refresh_idaview_anyway` + +*** + + +### React to UI events/notifications {#log_misc_events} +Hooks to be notified about certain UI events, and +dump their information to the "Output" window + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [log_misc_events.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/uihooks/log_misc_events.py) | UI_Hooks | Intermediate | + +**APIs Used:** +* `ida_kernwin.UI_Hooks` + +*** + + +### Paint on top of the navigation band {#paint_over_navbar} +Using an "event filter", we will intercept paint events +targeted at the navigation band widget, let it paint itself, +and then add our own markers on top. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [paint_over_navbar.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/pyqt/paint_over_navbar.py) | | Intermediate | + +**APIs Used:** +* `ida_kernwin.PluginForm.FormToPyQtWidget` +* `ida_kernwin.get_navband_pixel` +* `ida_kernwin.open_navband_window` +* `ida_segment.get_segm_qty` +* `ida_segment.getnseg` +* `idc.here` + +*** + + +### Save, and then restore, positions in a listing {#save_and_restore_listing_pos} +Shows how it is possible re-implement IDA's bookmark capability, +using 2 custom actions: one action saves the current location, +and the other restores it. + +Note that, contrary to actual bookmarks, this example: + + * remembers only 1 saved position + * doesn't save that position in the IDB (and therefore cannot + be restored if IDA is closed & reopened.) + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [save_and_restore_listing_pos.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/listings/save_and_restore_listing_pos.py) | actions listing | Intermediate | + +**APIs Used:** +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_CUSTVIEW` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.BWN_TILVIEW` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.custom_viewer_jump` +* `ida_kernwin.find_widget` +* `ida_kernwin.get_custom_viewer_location` +* `ida_kernwin.register_action` +* `ida_kernwin.unregister_action` +* `ida_moves.lochist_entry_t` + +*** + + +### Retrieve the selection from the "Strings" window {#show_selected_strings} +In IDA it's possible to write actions that can be applied even to +core (i.e., "standard") widgets. The actions in this example use the +action "context" to know what the current selection is. + +This example shows how you can either retrieve string literals data +directly from the chooser (`ida_kernwin.get_chooser_data`), or +by querying the IDB (`ida_bytes.get_strlit_contents`) + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [show_selected_strings.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/tabular_views/string_window/show_selected_strings.py) | actions ctxmenu | Intermediate | + +**APIs Used:** +* `ida_bytes.get_strlit_contents` +* `ida_idaapi.BADADDR` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_STRINGS` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.find_widget` +* `ida_kernwin.get_chooser_data` +* `ida_kernwin.open_strings_window` +* `ida_kernwin.register_action` +* `ida_kernwin.unregister_action` +* `ida_strlist.get_strlist_item` +* `ida_strlist.string_info_t` + +*** + + +### Follow the movements of one graph, in another {#sync_two_graphs} +Since it is possible to be notified of movements that happen +take place in a widget, it's possible to "replay" those +movements in another. + +In this case, "IDA View-B" (will be opened if necessary) will +show the same contents as "IDA View-A", slightly zoomed out. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [sync_two_graphs.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/graphs/sync_two_graphs.py) | graph idaview | Intermediate | + +**APIs Used:** +* `ida_graph.GLICTL_CENTER` +* `ida_graph.viewer_fit_window` +* `ida_graph.viewer_get_gli` +* `ida_graph.viewer_set_gli` +* `ida_kernwin.DP_RIGHT` +* `ida_kernwin.IDAViewWrapper` +* `ida_kernwin.MFF_FAST` +* `ida_kernwin.TCCRT_GRAPH` +* `ida_kernwin.execute_sync` +* `ida_kernwin.find_widget` +* `ida_kernwin.get_custom_viewer_place` +* `ida_kernwin.jumpto` +* `ida_kernwin.open_disasm_window` +* `ida_kernwin.set_dock_pos` +* `ida_kernwin.set_view_renderer_type` +* `ida_moves.graph_location_info_t` + +*** + + +### Trigger actions programmatically {#trigger_actions_programmatically} +It's possible to invoke any action programmatically, by using +either of those two: + + * ida_kernwin.execute_ui_requests() + * ida_kernwin.process_ui_action() + +Ideally, this script should be run through the "File > Script file..." +menu, so as to keep focus on "IDA View-A" and have the +'ProcessUiActions' part work as intended. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [trigger_actions_programmatically.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/trigger_actions_programmatically.py) | actions | Intermediate | + +**APIs Used:** +* `ida_kernwin.ask_yn` +* `ida_kernwin.execute_ui_requests` +* `ida_kernwin.msg` +* `ida_kernwin.process_ui_action` + +*** + + +### Advanced usage of the form API {#askusingform} +How to query for complex user input, using IDA's built-in forms. + +Note: while this example produces full-fledged forms for complex input, +simpler types of inputs might can be retrieved by using +`ida_kernwin.ask_str` and similar functions. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [askusingform.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/forms/askusingform.py) | forms | Advanced | + +**APIs Used:** +* `ida_kernwin.Choose` +* `ida_kernwin.Choose.CH_MULTI` +* `ida_kernwin.Form` +* `ida_kernwin.PluginForm.FORM_TAB` +* `ida_kernwin.ask_str` + +*** + + +### Restore custom widgets across sessions {#auto_instantiate_widget_plugin} This is an example demonstrating how one can create widgets from a plugin, and have them re-created automatically at IDA startup-time or at desktop load-time. @@ -189,95 +804,66 @@ There are 2 ways to use this example: - start another IDA instance with some IDB, and load that desktop => the widget will be visible -#### Keywords -desktop plugin UI_Hooks +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [auto_instantiate_widget_plugin.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/auto_instantiate_widget_plugin.py) | desktop plugin UI_Hooks | Advanced | -#### Uses -* ida_idaapi.plugin_t -* ida_kernwin.AST_ENABLE_ALWAYS -* ida_kernwin.SETMENU_APP -* ida_kernwin.UI_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_menu -* ida_kernwin.find_widget -* ida_kernwin.register_action -* ida_kernwin.simplecustviewer_t -* ida_kernwin.simplecustviewer_t.Create +**APIs Used:** +* `ida_idaapi.plugin_t` +* `ida_kernwin.AST_ENABLE_ALWAYS` +* `ida_kernwin.SETMENU_APP` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_menu` +* `ida_kernwin.find_widget` +* `ida_kernwin.register_action` +* `ida_kernwin.simplecustviewer_t` +* `ida_kernwin.simplecustviewer_t.Create` -
+*** -
-#### bin_search -
- Showcasing `ida_bytes.bin_search` +### Showing tabular data in a flat, or tree-like fashion {#chooser_with_folders} +By adding the necessary bits to a ida_kernwin.Choose subclass, +IDA can show the otherwise tabular data, in a tree-like fashion. -
+The important bits to enable this are: -#### Source code -core/bin_search.py + * ida_dirtree.dirspec_t (and my_dirspec_t) + * ida_kernwin.CH_HAS_DIRTREE + * ida_kernwin.Choose.OnGetDirTree + * ida_kernwin.Choose.OnIndexToInode -#### Category -core +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [chooser_with_folders.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/tabular_views/custom/chooser_with_folders.py) | actions chooser folders | Advanced | -#### Description -IDAPython's ida_bytes.bin_search function is pretty powerful, -but can be tough to figure out at first. This example introduces +**APIs Used:** +* `ida_dirtree.DTE_OK` +* `ida_dirtree.direntry_t` +* `ida_dirtree.direntry_t.BADIDX` +* `ida_dirtree.dirspec_t` +* `ida_dirtree.dirtree_t` +* `ida_dirtree.dirtree_t.isdir` +* `ida_kernwin.CH_CAN_DEL` +* `ida_kernwin.CH_CAN_EDIT` +* `ida_kernwin.CH_CAN_INS` +* `ida_kernwin.CH_HAS_DIRTREE` +* `ida_kernwin.CH_MULTI` +* `ida_kernwin.Choose` +* `ida_kernwin.Choose.ALL_CHANGED` +* `ida_kernwin.Choose.CHCOL_DRAGHINT` +* `ida_kernwin.Choose.CHCOL_INODENAME` +* `ida_kernwin.Choose.CHCOL_PLAIN` +* `ida_kernwin.ask_str` +* `ida_netnode.BADNODE` +* `ida_netnode.netnode` - * `ida_bytes.bin_search`, and - * `ida_bytes.parse_binpat_str` +*** -in order to implement a simple replacement for the -'Search > Sequence of bytes...' dialog, that lets users -search for sequences of bytes that compose string literals -in the binary file (either in the default 1-byte-per-char -encoding, or as UTF-16.) -#### Shortcut -Ctrl+Shift+S - -#### Uses -* ida_bytes.BIN_SEARCH_FORWARD -* ida_bytes.BIN_SEARCH_NOBREAK -* ida_bytes.BIN_SEARCH_NOSHOW -* ida_bytes.bin_search -* ida_bytes.compiled_binpat_vec_t -* ida_bytes.parse_binpat_str -* ida_ida.inf_get_max_ea -* ida_idaapi.BADADDR -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_DISASM -* ida_kernwin.Form -* ida_kernwin.Form.ChkGroupControl -* ida_kernwin.Form.StringInput -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.get_screen_ea -* ida_kernwin.jumpto -* ida_kernwin.register_action -* ida_nalt.BPU_1B -* ida_nalt.BPU_2B -* ida_nalt.get_default_encoding_idx - -
- -
- -#### colorize_disassembly_on_the_fly -
- An easy-to-use way to colorize lines - -
- -#### Source code -core/colorize_disassembly_on_the_fly.py - -#### Category -core - -#### Description +### Colorize lines interactively {#colorize_disassembly_on_the_fly} This builds upon the `ida_kernwin.UI_Hooks.get_lines_rendering_info` feature, to provide a quick & easy way to colorize disassembly lines. @@ -288,248 +874,84 @@ the database, and will therefore be lost after the session. By triggering the action multiple times, the user can "carousel" across 4 predefined colors (and return to the "no color" state.) -#### Shortcut -! +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [colorize_disassembly_on_the_fly.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/colorize_disassembly_on_the_fly.py) | coloring UI_Hooks | Advanced | -#### Keywords -coloring UI_Hooks +**APIs Used:** +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.CK_EXTRA5` +* `ida_kernwin.CK_EXTRA6` +* `ida_kernwin.CK_EXTRA7` +* `ida_kernwin.CK_EXTRA8` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_current_viewer` +* `ida_kernwin.get_custom_viewer_location` +* `ida_kernwin.get_custom_viewer_place_xcoord` +* `ida_kernwin.get_widget_title` +* `ida_kernwin.line_rendering_output_entry_t` +* `ida_kernwin.register_action` +* `ida_moves.lochist_entry_t` -#### Uses -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.CK_EXTRA5 -* ida_kernwin.CK_EXTRA6 -* ida_kernwin.CK_EXTRA7 -* ida_kernwin.CK_EXTRA8 -* ida_kernwin.UI_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.get_current_viewer -* ida_kernwin.get_custom_viewer_location -* ida_kernwin.get_custom_viewer_place_xcoord -* ida_kernwin.get_widget_title -* ida_kernwin.line_rendering_output_entry_t -* ida_kernwin.register_action -* ida_moves.lochist_entry_t +*** -#### See also -* [colorize_disassembly](#colorize_disassembly) -
- -
- -#### create_structure_programmatically -
- Programmatically create & populate a structure - -
- -#### Source code -core/create_structure_programmatically.py - -#### Category -core - -#### Description -Usage of the API to create & populate a structure with -members of different types. - -#### Uses -* ida_typeinf.BTF_BYTE -* ida_typeinf.BTF_DOUBLE -* ida_typeinf.BTF_FLOAT -* ida_typeinf.BTF_INT -* ida_typeinf.BTF_INT128 -* ida_typeinf.BTF_INT16 -* ida_typeinf.BTF_INT64 -* ida_typeinf.BTF_TBYTE -* ida_typeinf.BTF_UINT32 -* ida_typeinf.FRB_NUMO -* ida_typeinf.NTF_TYPE -* ida_typeinf.PRTYPE_DEF -* ida_typeinf.PRTYPE_MULTI -* ida_typeinf.PRTYPE_TYPE -* ida_typeinf.del_named_type -* ida_typeinf.idc_parse_types -* ida_typeinf.tinfo_errstr -* ida_typeinf.tinfo_t -* ida_typeinf.udm_t -* ida_typeinf.udt_type_data_t -* ida_typeinf.value_repr_t - -#### Author -Gergely Erdelyi (gergely.erdelyi@d-dome.net) - -
- -
- -#### custom_cli -
- A custom command-line interpreter - -
- -#### Source code -core/custom_cli.py - -#### Category -core - -#### Description +### Add a custom command-line interpreter {#custom_cli} Illustrates how one can add command-line interpreters to IDA This custom interpreter doesn't actually run any code; it's there as a 'getting started'. It provides an example tab completion support. -#### Uses -* ida_idaapi.NW_CLOSEIDB -* ida_idaapi.NW_OPENIDB -* ida_idaapi.NW_REMOVE -* ida_idaapi.NW_TERMIDA -* ida_idaapi.notify_when -* ida_kernwin.cli_t +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [custom_cli.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/custom_cli.py) | | Advanced | -
+**APIs Used:** +* `ida_idaapi.NW_CLOSEIDB` +* `ida_idaapi.NW_OPENIDB` +* `ida_idaapi.NW_REMOVE` +* `ida_idaapi.NW_TERMIDA` +* `ida_idaapi.notify_when` +* `ida_kernwin.cli_t` -
+*** -#### custom_data_types_and_formats -
- Using custom data types & printers -
+### Draw custom graphs {#custom_graph_with_actions} +Showing custom graphs, using `ida_graph.GraphViewer`. In addition, +show how to write actions that can be performed on those. -#### Source code -core/custom_data_types_and_formats.py +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [custom_graph_with_actions.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/graphs/custom_graph_with_actions.py) | actions graph View_Hooks | Advanced | -#### Category -core +**APIs Used:** +* `ida_funcs.get_func` +* `ida_funcs.get_func_name` +* `ida_graph.GraphViewer` +* `ida_graph.get_graph_viewer` +* `ida_graph.screen_graph_selection_t` +* `ida_graph.viewer_get_selection` +* `ida_idp.is_call_insn` +* `ida_kernwin.AST_ENABLE_ALWAYS` +* `ida_kernwin.View_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_dynamic_action_to_popup` +* `ida_kernwin.get_screen_ea` +* `ida_ua.decode_insn` +* `ida_ua.insn_t` +* `ida_xref.XREF_FAR` +* `ida_xref.xrefblk_t` -#### Description -IDA can be extended to support certain data types that it -does not know about out-of-the-box. +*** -A 'custom data type' provide information about the type & -size of a piece of data, while a 'custom data format' is in -charge of formatting that data (there can be more than -one format for a specific 'custom data type'.) -#### Uses -* ida_bytes.data_format_t -* ida_bytes.data_type_t -* ida_bytes.find_custom_data_type -* ida_bytes.get_byte -* ida_bytes.register_data_types_and_formats -* ida_bytes.unregister_data_types_and_formats -* ida_idaapi.NW_CLOSEIDB -* ida_idaapi.NW_OPENIDB -* ida_idaapi.NW_REMOVE -* ida_idaapi.NW_TERMIDA -* ida_idaapi.notify_when -* ida_idaapi.struct_unpack -* ida_lines.COLSTR -* ida_lines.SCOLOR_IMPNAME -* ida_lines.SCOLOR_INSN -* ida_lines.SCOLOR_NUMBER -* ida_lines.SCOLOR_REG -* ida_nalt.get_input_file_path -* ida_netnode.netnode -* ida_typeinf.tinfo_t - -
- -
- -#### dump_extra_comments -
- Retrieve extra comments - -
- -#### Source code -core/dump_extra_comments.py - -#### Category -core - -#### Description -Use the `ida_lines.get_extra_cmt` API to retrieve anterior -and posterior extra comments. - -This script registers two actions, that can be used to dump -the previous and next extra comments. - -#### Shortcuts -Ctrl+Shift+Y Ctrl+Shift+Z - -#### Keywords -ctxmenu - -#### Uses -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_DISASM -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.find_widget -* ida_kernwin.get_screen_ea -* ida_kernwin.register_action -* ida_kernwin.unregister_action -* ida_lines.E_NEXT -* ida_lines.E_PREV -* ida_lines.get_extra_cmt -* ida_view - -
- -
- -#### dump_flowchart -
- Dump function flowchart - -
- -#### Source code -core/dump_flowchart.py - -#### Category -core - -#### Description -Dumps the current function's flowchart, using 2 methods: - - * the low-level `ida_gdl.qflow_chart_t` type - * the somewhat higher-level, and slightly more pythonic - `ida_gdl.FlowChart` type. - -#### Uses -* ida_funcs.get_func -* ida_gdl.FlowChart -* ida_gdl.qflow_chart_t -* ida_kernwin.get_screen_ea - -
- -
- -#### dump_selection -
- Retrieve & dump current selection - -
- -#### Source code -core/dump_selection.py - -#### Category -core - -#### Description +### Retrieve & dump current selection {#dump_selection} Shows how to retrieve the selection from a listing widget ("IDA View-A", "Hex View-1", "Pseudocode-A", ...) as two "cursors", and from there retrieve (in fact, generate) @@ -538,176 +960,532 @@ the corresponding text. After running this script: * select some text in one of the listing widgets (i.e., - "IDA View-*", "Enums", "Structures", "Pseudocode-*") + "IDA View-...", "Local Types", "Pseudocode-...") * press Ctrl+Shift+S to dump the selection -#### Shortcut -Ctrl+Shift+S +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [dump_selection.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/dump_selection.py) | | Advanced | -#### Uses -* ida_kernwin.ACF_HAS_SELECTION -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_DISASM -* ida_kernwin.BWN_ENUMS -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.BWN_STRUCTS -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.get_current_viewer -* ida_kernwin.get_viewer_user_data -* ida_kernwin.l_compare2 -* ida_kernwin.linearray_t -* ida_kernwin.read_selection -* ida_kernwin.register_action -* ida_kernwin.twinpos_t -* ida_kernwin.unregister_action -* ida_lines.tag_remove +**APIs Used:** +* `ida_kernwin.ACF_HAS_SELECTION` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.BWN_TILVIEW` +* `ida_kernwin.IWID_ANY_LISTING` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_last_widget` +* `ida_kernwin.get_viewer_user_data` +* `ida_kernwin.l_compare2` +* `ida_kernwin.linearray_t` +* `ida_kernwin.read_selection` +* `ida_kernwin.register_action` +* `ida_kernwin.twinpos_t` +* `ida_kernwin.unregister_action` +* `ida_lines.tag_remove` -
+*** -
-#### extend_idc -
- Add functions to the IDC runtime from IDAPython +### Inject commands in the "Output" window {#inject_command} +This example illustrates how one can execute commands in the +"Output" window, from their own widgets. -
+A few notes: -#### Source code -core/extend_idc.py +* the original, underlying `cli:Execute` action, that has to be + triggered for the code present in the input field to execute + and be placed in the history, requires that the input field + has focus (otherwise it simply won't do anything.) +* this, in turn, forces us to do "delayed" execution of that action, + hence the need for a `QTimer` +* the IDA/SWiG 'TWidget' type that we retrieve through + `ida_kernwin.find_widget`, is not the same type as a + `QtWidgets.QWidget`. We therefore need to convert it using + `ida_kernwin.PluginForm.TWidgetToPyQtWidget` -#### Category -core +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [inject_command.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/pyqt/inject_command.py) | | Advanced | -#### Description -You can add IDC functions to IDA, whose "body" consists of -IDAPython statements! +**APIs Used:** +* `ida_kernwin.PluginForm.TWidgetToPyQtWidget` +* `ida_kernwin.disabled_script_timeout_t` +* `ida_kernwin.find_widget` +* `ida_kernwin.process_ui_action` -We'll register a 'pow' function, available to all IDC code, -that when invoked will call back into IDAPython, and execute -the provided function body. +*** -After running this script, try switching to the IDC interpreter -(using the button on the lower-left corner of IDA) and executing -`pow(3, 7)` -#### Uses -* ida_expr.VT_LONG -* ida_expr.add_idc_func +### A lazy-loaded, tree-like data view {#lazy_loaded_chooser} +Brings lazy-loading of folders to the tree-like tabular views. -
+The important bit to enable this are: -
+ * ida_kernwin.Choose.OnLazyLoadDir -#### idapythonrc -
- Code to be run right after IDAPython initialization +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [lazy_loaded_chooser.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/tabular_views/custom/lazy_loaded_chooser.py) | actions chooser folders | Advanced | -
-#### Source code -core/idapythonrc.py +*** -#### Category -core -#### Description -The `idapythonrc.py` file: +### Paint text on graph view edges {#paint_over_graph} +This sample registers an action enabling painting of a recognizable +string of text over horizontal nodes edge sections beyond a +satisfying size threshold. - * %APPDATA%\Hex-Rays\IDA Pro\idapythonrc.py (on Windows) - * ~/.idapro/idapythonrc.py (on Linux & Mac) +In a disassembly view, open the context menu and select +"Paint on edges". This should work for both graph disassembly, +and proximity browser. -can contain any IDAPython code that will be run as soon as -IDAPython is done successfully initializing. +Using an "event filter", we will intercept paint events +targeted at the disassembly view, let it paint itself, and +then add our own markers along. -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [paint_over_graph.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/pyqt/paint_over_graph.py) | ctxmenu UI_Hooks | Advanced | -
+**APIs Used:** +* `ida_gdl.edge_t` +* `ida_graph.get_graph_viewer` +* `ida_graph.get_viewer_graph` +* `ida_graph.point_t` +* `ida_graph.viewer_get_gli` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.PluginForm.FormToPyQtWidget` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.get_widget_type` +* `ida_kernwin.register_action` +* `ida_moves.graph_location_info_t` -#### install_user_defined_prefix -
- Inserting information into disassembly prefixes +*** -
-#### Source code -core/install_user_defined_prefix.py +### Programmatically manipulate disassembly and graph widgets {#wrap_idaview} +This is an example illustrating how to manipulate an existing IDA-provided +view (and thus possibly its graph), in Python. -#### Category -core +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [wrap_idaview.py](https://github.com/HexRaysSA/IDAPython/tree//examples/ui/idaview/wrap_idaview.py) | graph idaview | Advanced | -#### Description +**APIs Used:** +* `ida_graph.NIF_BG_COLOR` +* `ida_graph.NIF_FRAME_COLOR` +* `ida_graph.node_info_t` +* `ida_kernwin.IDAViewWrapper` +* `ida_kernwin.MFF_FAST` +* `ida_kernwin.TCCRT_FLAT` +* `ida_kernwin.TCCRT_GRAPH` +* `ida_kernwin.execute_sync` + +*** + + +### Dump function flowchart {#dump_flowchart} +Dumps the current function's flowchart, using 2 methods: + + * the low-level `ida_gdl.qflow_chart_t` type + * the somewhat higher-level, and slightly more pythonic + `ida_gdl.FlowChart` type. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [dump_flowchart.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/dump_flowchart.py) | | Beginner | + +**APIs Used:** +* `ida_funcs.get_func` +* `ida_gdl.FlowChart` +* `ida_gdl.qflow_chart_t` +* `ida_kernwin.get_screen_ea` + +*** + + +### Insert information into listing prefixes {#install_user_defined_prefix} By default, disassembly line prefixes contain segment + address information (e.g., '.text:08047718'), but it is possible to "inject" other bits of information in there, thanks to the `ida_lines.user_defined_prefix_t` helper type. -#### Keywords -plugin +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [install_user_defined_prefix.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/install_user_defined_prefix.py) | plugin | Beginner | -#### Uses -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t -* ida_lines.SCOLOR_INV -* ida_lines.user_defined_prefix_t +**APIs Used:** +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` +* `ida_lines.SCOLOR_INV` +* `ida_lines.user_defined_prefix_t` -
+*** -
-#### list_bookmarks -
- List bookmarks associated to a listing +### Enumerate file imports {#list_imports} +Using the API to enumerate file imports. -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_imports.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_imports.py) | | Beginner | -#### Source code -core/list_bookmarks.py +**APIs Used:** +* `ida_nalt.enum_import_names` +* `ida_nalt.get_import_module_name` +* `ida_nalt.get_import_module_qty` -#### Category -core +*** -#### Description + +### Enumerate patched bytes {#list_patched_bytes} +Using the API to iterate over all the places in the file, +that were patched using IDA. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_patched_bytes.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_patched_bytes.py) | | Beginner | + +**APIs Used:** +* `ida_bytes.visit_patched_bytes` +* `ida_idaapi.BADADDR` + +*** + + +### Enumerate known problems {#list_problems} +Using the API to list all problems that IDA +encountered during analysis. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_problems.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_problems.py) | | Beginner | + +**APIs Used:** +* `ida_ida.inf_get_min_ea` +* `ida_idaapi.BADADDR` +* `ida_problems.PR_ATTN` +* `ida_problems.PR_BADSTACK` +* `ida_problems.PR_COLLISION` +* `ida_problems.PR_DECIMP` +* `ida_problems.PR_DISASM` +* `ida_problems.PR_FINAL` +* `ida_problems.PR_HEAD` +* `ida_problems.PR_ILLADDR` +* `ida_problems.PR_JUMP` +* `ida_problems.PR_MANYLINES` +* `ida_problems.PR_NOBASE` +* `ida_problems.PR_NOCMT` +* `ida_problems.PR_NOFOP` +* `ida_problems.PR_NONAME` +* `ida_problems.PR_NOXREFS` +* `ida_problems.PR_ROLLED` +* `ida_problems.get_problem` +* `ida_problems.get_problem_name` + +*** + + +### List segment functions (and cross-references to them) {#list_segment_functions} +List all the functions in the current segment, as well as +all the cross-references to them. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_segment_functions.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_segment_functions.py) | xrefs | Beginner | + +**APIs Used:** +* `ida_funcs.get_func` +* `ida_funcs.get_func_name` +* `ida_funcs.get_next_func` +* `ida_kernwin.get_screen_ea` +* `ida_segment.getseg` +* `ida_xref.xrefblk_t` + +*** + + +### List all functions (and cross-references) in segment {#list_segment_functions_using_idautils} +List all the functions in the current segment, as well as +all the cross-references to them. + +Contrary to @list_segment_functions, this uses the somewhat +higher-level `idautils` module. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_segment_functions_using_idautils.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_segment_functions_using_idautils.py) | xrefs | Beginner | + +**APIs Used:** +* `ida_funcs.get_func_name` +* `ida_idaapi.BADADDR` +* `ida_kernwin.get_screen_ea` +* `ida_segment.getseg` +* `idautils.CodeRefsTo` +* `idautils.Functions` + +*** + + +### Dump the strings that are present in the file {#list_strings} +This uses `idautils.Strings` to iterate over the string literals +that are present in the IDB. Contrary to @show_selected_strings, +this will not require that the "Strings" window is opened & available. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_strings.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_strings.py) | | Beginner | + +**APIs Used:** +* `ida_nalt.STRTYPE_C` +* `ida_nalt.STRTYPE_C_16` +* `idautils.Strings` + +*** + + +### Produce disassembly listing for the entire file {#produce_lst_file} +Automate IDA to perform auto-analysis on a file and, +once that is done, produce a .lst file with the disassembly. + +Run like so: + + ida -A "-S...path/to/produce_lst_file.py" + +where: + + * -A instructs IDA to run in non-interactive mode + * -S holds a path to the script to run (note this is a single token; + there is no space between '-S' and its path.) + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [produce_lst_file.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/produce_lst_file.py) | | Beginner | + +**APIs Used:** +* `ida_auto.auto_wait` +* `ida_fpro.qfile_t` +* `ida_ida.inf_get_max_ea` +* `ida_ida.inf_get_min_ea` +* `ida_loader.OFILE_LST` +* `ida_loader.PATH_TYPE_IDB` +* `ida_loader.gen_file` +* `ida_loader.get_path` +* `ida_pro.qexit` + +*** + + +### Rewrite the representation of some instructions {#ana_emu_out} +Implements disassembly of BUG_INSTR used in Linux kernel +BUG() macro, which is architecturally undefined and is not +disassembled by IDA's ARM module + +See Linux/arch/arm/include/asm/bug.h for more info + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [ana_emu_out.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/ana_emu_out.py) | IDP_Hooks | Intermediate | + +**APIs Used:** +* `ida_bytes.get_wide_dword` +* `ida_bytes.get_wide_word` +* `ida_idp.CUSTOM_INSN_ITYPE` +* `ida_idp.IDP_Hooks` +* `ida_idp.PLFM_ARM` +* `ida_idp.ph.id` +* `ida_idp.str2reg` +* `ida_segregs.get_sreg` + +*** + + +### Implement assembly of instructions {#assemble} +We add support for assembling the following pseudo instructions: + +* "zero eax" -> xor eax, eax +* "nothing" -> nop + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [assemble.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/assemble.py) | IDP_Hooks | Intermediate | + +**APIs Used:** +* `ida_idp.IDP_Hooks` +* `idautils.DecodeInstruction` + +*** + + +### Retrieve comments surrounding instructions {#dump_extra_comments} +Use the `ida_lines.get_extra_cmt` API to retrieve anterior +and posterior extra comments. + +This script registers two actions, that can be used to dump +the previous and next extra comments. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [dump_extra_comments.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/dump_extra_comments.py) | ctxmenu | Intermediate | + +**APIs Used:** +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.find_widget` +* `ida_kernwin.get_screen_ea` +* `ida_kernwin.register_action` +* `ida_kernwin.unregister_action` +* `ida_lines.E_NEXT` +* `ida_lines.E_PREV` +* `ida_lines.get_extra_cmt` +* `ida_view` + +*** + + +### Dump function information {#dump_func_info} +Dump some of the most interesting bits of information about +the function we are currently looking at. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [dump_func_info.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/dump_func_info.py) | | Intermediate | + +**APIs Used:** +* `ida_funcs.FUNC_FRAME` +* `ida_funcs.FUNC_LUMINA` +* `ida_funcs.FUNC_OUTLINE` +* `ida_funcs.FUNC_THUNK` +* `ida_funcs.get_fchunk` +* `ida_funcs.is_func_entry` +* `ida_funcs.is_func_tail` +* `ida_kernwin.get_screen_ea` + +*** + + +### Parse listing line, and dump some information {#dump_line_sections} +Using `ida_kernwin.parse_tagged_line_sections`, we will parse +so-called "tagged" listing lines, and extract semantic information +such as instruction mnemonic, operand text, ... + +This script registers an actions, that can be used to dump +the line sections. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [dump_line_sections.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/dump_line_sections.py) | | Intermediate | + +**APIs Used:** +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_custom_viewer_curline` +* `ida_kernwin.parse_tagged_line_sections` +* `ida_kernwin.register_action` +* `ida_kernwin.tagged_line_sections_t` +* `ida_lines.COLOR_INSN` +* `ida_lines.COLOR_OPND1` +* `ida_lines.COLOR_OPND8` +* `ida_lines.COLOR_REG` + +*** + + +### Using "ida_bytes.find_string" {#find_string} +IDAPython's ida_bytes.find_string can be used to implement +a simple replacement for the 'Search > Sequence of bytes...' +dialog, that lets users search for sequences of bytes that +compose string literals in the binary file (either in the +default 1-byte-per-char encoding, or as UTF-16.) + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [find_string.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/find_string.py) | | Intermediate | + +**APIs Used:** +* `ida_bytes.BIN_SEARCH_FORWARD` +* `ida_bytes.BIN_SEARCH_NOBREAK` +* `ida_bytes.BIN_SEARCH_NOSHOW` +* `ida_bytes.find_string` +* `ida_ida.inf_get_max_ea` +* `ida_idaapi.BADADDR` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.Form` +* `ida_kernwin.Form.ChkGroupControl` +* `ida_kernwin.Form.StringInput` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_screen_ea` +* `ida_kernwin.jumpto` +* `ida_kernwin.register_action` +* `ida_nalt.BPU_1B` +* `ida_nalt.BPU_2B` +* `ida_nalt.get_default_encoding_idx` + +*** + + +### Print notifications about function prototype changes {#func_ti_changed_listener} +The goal of this script is to demonstrate some usage of the type API. +In this script, we will create an IDB hook that intercepts `ti_changed` +IDB events, and if it is a function prototype that changed, print it. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [func_ti_changed_listener.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/func_ti_changed_listener.py) | IDB_Hooks | Intermediate | + +**APIs Used:** +* `ida_funcs.get_func_name` +* `ida_idp.IDB_Hooks` +* `ida_typeinf.tinfo_t` + +*** + + +### List listing bookmarks {#list_bookmarks} This sample shows how to programmatically access the list of bookmarks placed in a listing widget (e.g., "IDA View-A", "Pseudocode-", …) using the low-level `ida_moves.bookmarks_t` type. -#### Shortcut -Ctrl+! +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_bookmarks.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_bookmarks.py) | bookmarks | Intermediate | -#### Keywords -bookmarks +**APIs Used:** +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_current_viewer` +* `ida_kernwin.get_viewer_user_data` +* `ida_kernwin.get_widget_title` +* `ida_kernwin.register_action` +* `ida_moves.bookmarks_t` -#### Uses -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.get_current_viewer -* ida_kernwin.get_viewer_user_data -* ida_kernwin.get_widget_title -* ida_kernwin.register_action -* ida_moves.bookmarks_t +*** -
-
- -#### list_function_items -
- Showcases (a few of) the iterators available on a function - -
- -#### Source code -core/list_function_items.py - -#### Category -core - -#### Description +### Showcase (some of) the iterators available on a function {#list_function_items} This demonstrates how to use some of the iterators available on the func_t type. This example will focus on: @@ -728,277 +1506,266 @@ In addition, one can use: * `func_parent_iterator_t`: iterate on all the parent functions, that include this chunk -#### Keywords -funcs iterator - -#### Uses -* ida_bytes.get_flags -* ida_bytes.is_code -* ida_bytes.is_data -* ida_bytes.is_tail -* ida_bytes.is_unknown -* ida_funcs.func_tail_iterator_t -* ida_funcs.get_fchunk -* ida_funcs.get_func -* ida_funcs.get_func_name -* ida_kernwin.get_screen_ea -* ida_ua.print_insn_mnem - -
- -
- -#### list_imports -
- Enumerate file imports - -
- -#### Source code -core/list_imports.py - -#### Category -core - -#### Description -Using the API to enumerate file imports. - -#### Uses -* ida_nalt.enum_import_names -* ida_nalt.get_import_module_name -* ida_nalt.get_import_module_qty - -
- -
- -#### list_patched_bytes -
- Enumerate patched bytes - -
- -#### Source code -core/list_patched_bytes.py - -#### Category -core - -#### Description -Using the API to iterate over all the places in the file, -that were patched using IDA. - -#### Uses -* ida_bytes.visit_patched_bytes -* ida_idaapi.BADADDR - -
- -
- -#### list_problems -
- Enumerate problems - -
- -#### Source code -core/list_problems.py - -#### Category -core - -#### Description -Using the API to list all problem[atic situation]s that IDA -encountered during analysis. - -#### Uses -* ida_ida.inf_get_min_ea -* ida_idaapi.BADADDR -* ida_problems.PR_ATTN -* ida_problems.PR_BADSTACK -* ida_problems.PR_COLLISION -* ida_problems.PR_DECIMP -* ida_problems.PR_DISASM -* ida_problems.PR_FINAL -* ida_problems.PR_HEAD -* ida_problems.PR_ILLADDR -* ida_problems.PR_JUMP -* ida_problems.PR_MANYLINES -* ida_problems.PR_NOBASE -* ida_problems.PR_NOCMT -* ida_problems.PR_NOFOP -* ida_problems.PR_NONAME -* ida_problems.PR_NOXREFS -* ida_problems.PR_ROLLED -* ida_problems.get_problem -* ida_problems.get_problem_name - -
- -
- -#### list_segment_functions -
- List all functions (and xrefs) in segment - -
- -#### Source code -core/list_segment_functions.py - -#### Category -core - -#### Description -List all the functions in the current segment, as well as -all the cross-references to them. - -#### Keywords -xrefs - -#### Uses -* ida_funcs.get_func -* ida_funcs.get_func_name -* ida_funcs.get_next_func -* ida_kernwin.get_screen_ea -* ida_segment.getseg -* ida_xref.xrefblk_t - -#### See also -* [list_segment_functions_using_idautils](#list_segment_functions_using_idautils) - -
- -
- -#### list_segment_functions_using_idautils -
- List all functions (and xrefs) in segment - -
- -#### Source code -core/list_segment_functions_using_idautils.py - -#### Category -core - -#### Description -List all the functions in the current segment, as well as -all the cross-references to them. - -Contrary to @list_segment_functions, this uses the somewhat -higher-level `idautils` module. - -#### Keywords -xrefs - -#### Uses -* ida_funcs.get_func_name -* ida_idaapi.BADADDR -* ida_kernwin.get_screen_ea -* ida_segment.getseg -* idautils.CodeRefsTo -* idautils.Functions - -#### See also -* [list_segment_functions](#list_segment_functions) - -
- -
- -#### list_stkvar_xrefs -
- List all xrefs to a function stack variable - -
- -#### Source code -core/list_stkvar_xrefs.py - -#### Category -core - -#### Description -Contrary to (in-memory) data & code xrefs, retrieving stack variables -xrefs requires a bit more work than just using ida_xref's first_to(), -next_to() (or higher level utilities such as idautils.XrefsTo) - -#### Shortcut -Ctrl+Shift+F7 - -#### Keywords -xrefs - -#### Uses -* ida_bytes.get_flags -* ida_bytes.is_stkvar -* ida_frame.calc_stkvar_struc_offset -* ida_frame.get_frame -* ida_funcs.get_func -* ida_ida.UA_MAXOP -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_DISASM -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.get_current_viewer -* ida_kernwin.get_highlight -* ida_kernwin.get_screen_ea -* ida_kernwin.register_action -* ida_struct.get_member_by_name -* ida_struct.get_struc -* ida_ua.decode_insn -* ida_ua.insn_t - -
- -
- -#### list_strings -
- Retrieve the strings that are present in the IDB - -
- -#### Source code -core/list_strings.py - -#### Category -core - -#### Description -This uses `idautils.Strings` to iterate over the string literals -that are present in the IDB. Contrary to @show_selected_strings, -this will not require that the "Strings" window is opened & available. - -#### Uses -* ida_nalt.STRTYPE_C -* ida_nalt.STRTYPE_C_16 -* idautils.Strings - -#### See also -* [show_selected_strings](#show_selected_strings) - -
- -
- -#### produce_c_file -
- Decompile entire file - -
- -#### Source code -core/produce_c_file.py - -#### Category -core - -#### Description +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_function_items.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_function_items.py) | funcs iterator | Intermediate | + +**APIs Used:** +* `ida_bytes.get_flags` +* `ida_bytes.is_code` +* `ida_bytes.is_data` +* `ida_bytes.is_tail` +* `ida_bytes.is_unknown` +* `ida_funcs.func_tail_iterator_t` +* `ida_funcs.get_fchunk` +* `ida_funcs.get_func` +* `ida_funcs.get_func_name` +* `ida_kernwin.get_screen_ea` +* `ida_ua.print_insn_mnem` + +*** + + +### React to database events/notifications {#log_idb_events} +These hooks will be notified about IDB events, and +dump their information to the "Output" window + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [log_idb_events.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/log_idb_events.py) | IDB_Hooks | Intermediate | + +**APIs Used:** +* `ida_idp.IDB_Hooks` + +*** + + +### React to processor events/notifications {#log_idp_events} +These hooks will be notified about IDP events, and +dump their information to the "Output" window + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [log_idp_events.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/log_idp_events.py) | IDP_Hooks | Intermediate | + +**APIs Used:** +* `ida_idp.IDP_Hooks` + +*** + + +### Record and replay changes in function prototypes {#replay_prototypes_changes} +This is a sample script, that will record (in memory) all changes in +functions prototypes, in order to re-apply them later. + +To use this script: + - open an IDB (say, "test.idb") + - modify some functions prototypes (e.g., by triggering the 'Y' + shortcut when the cursor is placed on the first address of a + function) + - reload that IDB, *without saving it first* + - call rpc.replay(), to re-apply the modifications. + +Note: 'ti_changed' is also called for changes to the function +frames, but we'll only record function prototypes changes. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [replay_prototypes_changes.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/replay_prototypes_changes.py) | IDB_Hooks | Intermediate | + +**APIs Used:** +* `ida_funcs.get_func` +* `ida_idp.IDB_Hooks` +* `ida_typeinf.PRTYPE_1LINE` +* `ida_typeinf.TINFO_DEFINITE` +* `ida_typeinf.apply_tinfo` +* `ida_typeinf.get_idati` +* `ida_typeinf.tinfo_t` + +*** + + +### Add a new member to an existing function frame {#add_frame_member} +The goal of this script is to demonstrate some usage of the type API. +In this script, we show a way to add a new frame member (a pointer to + an uint64) inside a wide enough gap in the frame: +* Get the function object surrounding cursor location. +* Use this function to retrieve the corresponding frame object. +* Find a wide enough gap to create our new member. +* If found, we use cal_frame_offset() to get the actual + offset in the frame structure. +* Use the previous result to add the new member. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [add_frame_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/add_frame_member.py) | | Advanced | + +**APIs Used:** +* `ida_frame.add_frame_member` +* `ida_frame.calc_frame_offset` +* `ida_frame.get_func_frame` +* `ida_funcs.get_func` +* `ida_range.rangeset_t` +* `ida_typeinf.BTF_UINT64` +* `ida_typeinf.tinfo_t` +* `idc.here` + +*** + + +### Custom data types & printers {#custom_data_types_and_formats} +IDA can be extended to support certain data types that it +does not know about out-of-the-box. + +A 'custom data type' provide information about the type & +size of a piece of data, while a 'custom data format' is in +charge of formatting that data (there can be more than +one format for a specific 'custom data type'.) + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [custom_data_types_and_formats.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/custom_data_types_and_formats.py) | | Advanced | + +**APIs Used:** +* `ida_bytes.data_format_t` +* `ida_bytes.data_type_t` +* `ida_bytes.find_custom_data_type` +* `ida_bytes.get_byte` +* `ida_bytes.register_data_types_and_formats` +* `ida_bytes.unregister_data_types_and_formats` +* `ida_idaapi.NW_CLOSEIDB` +* `ida_idaapi.NW_OPENIDB` +* `ida_idaapi.NW_REMOVE` +* `ida_idaapi.NW_TERMIDA` +* `ida_idaapi.notify_when` +* `ida_idaapi.struct_unpack` +* `ida_lines.COLSTR` +* `ida_lines.SCOLOR_IMPNAME` +* `ida_lines.SCOLOR_INSN` +* `ida_lines.SCOLOR_NUMBER` +* `ida_lines.SCOLOR_REG` +* `ida_nalt.get_input_file_path` +* `ida_netnode.netnode` +* `ida_typeinf.tinfo_t` + +*** + + +### List operands representing a "path" to a (possibly nested) structure member {#list_struct_accesses} +It is possible to assign, to instruction operands, the notion of "structure +offset", which really is a pointer to a specific offset in a type, leading +to a possible N-deep path within types. + +E.g., assuming the following types + + struct c + { + int foo; + int bar; + int baz; + int quux; + int trail; + }; + + struct b + { + int gap; + c c_instance; + }; + + struct a + { + int count; + b b_instance; + }; + +and assuming an instruction that initially looks like this: + + mov eax, 10h + +by pressing `t`, the user will be able set the "structure offset" +to either: + + * `c.trail` + * `b.c_instance.quux` + * `a.b_inscance.c_instance.baz` + +Here's why IDA offers `a.b_inscance.c_instance.baz`: + + 0000 struct a + { + 0000 int count; + 0004 struct b + { + 0004 int gap; + 0008 struct c + { + 0008 int foo; + 000C int bar; + 0010 int baz; + 0014 int quux; + 0018 int trail; + }; + }; + }; + +This sample shows how to programmatically retrieve information about +that "structure member path" that an operand was made pointing to. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_struct_accesses.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/list_struct_accesses.py) | bookmarks | Advanced | + +**APIs Used:** +* `ida_bytes.get_full_flags` +* `ida_bytes.get_stroff_path` +* `ida_bytes.is_stroff` +* `ida_typeinf.get_tid_name` +* `ida_typeinf.tinfo_t` +* `ida_ua.decode_insn` +* `ida_ua.insn_t` +* `ida_ua.o_imm` +* `ida_ua.o_void` + +*** + + +### Notify the user when an instruction operand changes {#operand_changed} +Show notifications whenever the user changes +an instruction's operand, or a data item. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [operand_changed.py](https://github.com/HexRaysSA/IDAPython/tree//examples/disassembler/operand_changed.py) | IDB_Hooks | Advanced | + +**APIs Used:** +* `ida_bytes.ALOPT_IGNCLT` +* `ida_bytes.ALOPT_IGNHEADS` +* `ida_bytes.get_flags` +* `ida_bytes.get_max_strlit_length` +* `ida_bytes.get_opinfo` +* `ida_bytes.get_strlit_contents` +* `ida_bytes.is_custfmt` +* `ida_bytes.is_custom` +* `ida_bytes.is_enum` +* `ida_bytes.is_off` +* `ida_bytes.is_strlit` +* `ida_bytes.is_stroff` +* `ida_bytes.is_struct` +* `ida_idp.IDB_Hooks` +* `ida_nalt.STRENC_DEFAULT` +* `ida_nalt.get_default_encoding_idx` +* `ida_nalt.get_encoding_name` +* `ida_nalt.get_str_encoding_idx` +* `ida_nalt.get_strtype_bpu` +* `ida_nalt.opinfo_t` +* `ida_typeinf.get_tid_name` +* `ida_typeinf.tinfo_t` + +*** + + +### Produce C listing for the entire file {#produce_c_file} Automate IDA to perform auto-analysis on a file and, once that is done, produce a .c file containing the decompilation of all the functions in that file. @@ -1013,561 +1780,111 @@ where: * -S holds a path to the script to run (note this is a single token; there is no space between '-S' and its path.) -#### Uses -* ida_auto.auto_wait -* ida_hexrays.VDRUN_MAYSTOP -* ida_hexrays.VDRUN_NEWFILE -* ida_hexrays.VDRUN_SILENT -* ida_hexrays.decompile_many -* ida_loader.PATH_TYPE_IDB -* ida_loader.get_path -* ida_pro.qexit +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [produce_c_file.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/produce_c_file.py) | | Beginner | -
+**APIs Used:** +* `ida_auto.auto_wait` +* `ida_hexrays.VDRUN_MAYSTOP` +* `ida_hexrays.VDRUN_NEWFILE` +* `ida_hexrays.VDRUN_SILENT` +* `ida_hexrays.decompile_many` +* `ida_loader.PATH_TYPE_IDB` +* `ida_loader.get_path` +* `ida_pro.qexit` -
+*** -#### produce_lst_file -
- Produce listing -
+### Decompile & print current function {#vds1} +Decompile the function under the cursor -#### Source code -core/produce_lst_file.py +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds1.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds1.py) | | Beginner | -#### Category -core +**APIs Used:** +* `ida_funcs.get_func` +* `ida_hexrays.decompile` +* `ida_hexrays.get_hexrays_version` +* `ida_hexrays.init_hexrays_plugin` +* `ida_kernwin.get_screen_ea` +* `ida_lines.tag_remove` -#### Description -Automate IDA to perform auto-analysis on a file and, -once that is done, produce a .lst file with the disassembly. +*** -Run like so: - ida -A "-S...path/to/produce_lst_file.py" +### Generate microcode for the selected range of instructions {#vds13} +Generates microcode for selection and dumps it to the output window. -where: +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds13.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds13.py) | | Beginner | - * -A instructs IDA to run in non-interactive mode - * -S holds a path to the script to run (note this is a single token; - there is no space between '-S' and its path.) +**APIs Used:** +* `ida_bytes.get_flags` +* `ida_bytes.is_code` +* `ida_hexrays.DECOMP_WARNINGS` +* `ida_hexrays.gen_microcode` +* `ida_hexrays.hexrays_failure_t` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.mba_ranges_t` +* `ida_hexrays.vd_printer_t` +* `ida_kernwin.read_range_selection` +* `ida_kernwin.warning` +* `ida_range.range_t` -#### Uses -* ida_auto.auto_wait -* ida_fpro.qfile_t -* ida_ida.inf_get_max_ea -* ida_ida.inf_get_min_ea -* ida_loader.OFILE_LST -* ida_loader.PATH_TYPE_IDB -* ida_loader.gen_file -* ida_loader.get_path -* ida_pro.qexit +*** -
-
+### Dump statement blocks {#vds7} +Using a `ida_hexrays.ctree_visitor_t`, search for +`ida_hexrays.cit_block` instances and dump them. -#### register_timer -
- Using timers for delayed execution +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds7.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds7.py) | Hexrays_Hooks | Beginner | -
+**APIs Used:** +* `ida_hexrays.CMAT_BUILT` +* `ida_hexrays.CV_FAST` +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.cit_block` +* `ida_hexrays.ctree_visitor_t` +* `ida_hexrays.init_hexrays_plugin` -#### Source code -core/register_timer.py +*** -#### Category -core -#### Description -Register (possibly repeating) timers. +### Provide custom decompiler hints {#vds_create_hint} +Handle `ida_hexrays.hxe_create_hint` notification using hooks, +to return our own. -#### Uses -* ida_kernwin.register_timer +If the object under the cursor is: -
+* a function call, prefix the original decompiler hint with `==> ` +* a local variable declaration, replace the hint with our own in + the form of `!{varname}` (where `{varname}` is replaced with the + variable name) +* an `if` statement, replace the hint with our own, saying "condition" -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds_create_hint.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds_create_hint.py) | Hexrays_Hooks | Beginner | -#### trigger_actions_programmatically -
- Execute existing actions programmatically +**APIs Used:** +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.USE_MOUSE` +* `ida_hexrays.VDI_EXPR` +* `ida_hexrays.VDI_LVAR` +* `ida_hexrays.cit_if` +* `ida_hexrays.cot_call` -
+*** -#### Source code -core/trigger_actions_programmatically.py -#### Category -core - -#### Description -It's possible to invoke any action programmatically, by using -either of those two: - - * ida_kernwin.execute_ui_requests() - * ida_kernwin.process_ui_action() - -Ideally, this script should be run through the "File > Script file..." -menu, so as to keep focus on "IDA View-A" and have the -'ProcessUiActions' part work as intended. - -#### Keywords -actions - -#### Uses -* ida_kernwin.ask_yn -* ida_kernwin.execute_ui_requests -* ida_kernwin.msg -* ida_kernwin.process_ui_action - -
- -
- -## Category: cvt64 - -#### py_cvt64_sample -
- This file contains the CVT64 examples. - -
- -#### Source code -cvt64/py_cvt64_sample.py - -#### Category -cvt64 - -#### Description -For more infortmation see SDK/plugins/cvt64_sample example - -#### Uses -* ida_idaapi.BADADDR -* ida_idaapi.BADADDR32 -* ida_netnode.atag -* ida_netnode.htag -* ida_netnode.stag - -
- -
- -## Category: debugging - -#### automatic_steps -
- Programmatically drive a debugging session - -
- -#### Source code -debugging/dbghooks/automatic_steps.py - -#### Category -debugging - -#### Description -Start a debugging session, step through the first five -instructions. Each instruction is disassembled after -execution. - -#### Keywords -DBG_Hooks - -#### Uses -* ida_dbg.DBG_Hooks -* ida_dbg.get_reg_val -* ida_dbg.request_exit_process -* ida_dbg.request_run_to -* ida_dbg.request_step_over -* ida_dbg.run_requests -* ida_ida.inf_get_start_ip -* ida_idaapi.BADADDR -* ida_lines.generate_disasm_line -* ida_lines.tag_remove - -
- -
- -#### dbg_trace -
- Using the low-level tracing hook - -
- -#### Source code -debugging/dbghooks/dbg_trace.py - -#### Category -debugging - -#### Description -This script demonstrates using the low-level tracing hook -(ida_dbg.DBG_Hooks.dbg_trace). It can be run like so: - - ida[t].exe -B -Sdbg_trace.py -Ltrace.log file.exe - -#### Keywords -DBG_Hooks - -#### Uses -* GENDSM_FORCE_CODE -* GENDSM_REMOVE_TAGS -* NN_call -* NN_callfi -* NN_callni -* generate_disasm_line -* ida_dbg.DBG_Hooks -* ida_dbg.ST_OVER_DEBUG_SEG -* ida_dbg.ST_OVER_LIB_FUNC -* ida_dbg.enable_step_trace -* ida_dbg.get_process_state -* ida_dbg.get_reg_val -* ida_dbg.get_step_trace_options -* ida_dbg.load_debugger -* ida_dbg.refresh_debugger_memory -* ida_dbg.request_continue_process -* ida_dbg.request_enable_step_trace -* ida_dbg.request_set_step_trace_options -* ida_dbg.run_requests -* ida_dbg.run_to -* ida_dbg.set_step_trace_options -* ida_dbg.wait_for_next_event -* ida_ida.f_ELF -* ida_ida.f_MACHO -* ida_ida.f_PE -* ida_ida.inf_get_filetype -* ida_ida.inf_get_max_ea -* ida_ida.inf_get_min_ea -* ida_ida.inf_get_start_ip -* ida_pro.qexit -* ida_ua.decode_insn -* ida_ua.insn_t -* idc.ARGV - -
- -
- -#### print_call_stack -
- Print call stack (on Linux) - -
- -#### Source code -debugging/misc/print_call_stack.py - -#### Category -debugging - -#### Description - Print the return addresses from the call stack at a breakpoint. - (and print also the module and the debug name from debugger) - -To use this example: - - * run `ida64` on test program `simple_appcall_linux64`, or - `ida` on test program `simple_appcall_linux32`, and wait for - auto-analysis to finish - * put a breakpoint where you want to see the call stack - * select the 'linux debugger' (either local, or remote) - * start debugging - * Press Shift+C at the breakpoint - -#### Shortcut -Shift+C - -#### Uses -* ida_dbg.collect_stack_trace -* ida_dbg.get_current_thread -* ida_dbg.get_module_info -* ida_idd.call_stack_t -* ida_idd.modinfo_t -* ida_kernwin.AST_ENABLE_ALWAYS -* ida_kernwin.action_desc_t -* ida_kernwin.register_action -* ida_name.GNCN_NOCOLOR -* ida_name.GNCN_NOLABEL -* ida_name.GNCN_NOSEG -* ida_name.GNCN_PREFDBG -* ida_name.get_nice_colored_name - -
- -
- -#### print_registers -
- Print all registers, for all threads - -
- -#### Source code -debugging/misc/print_registers.py - -#### Category -debugging - -#### Description - Iterate over the list of threads in the program being - debugged, and dump all registers contents - -To use this example: - - * run `ida64` on test program `simple_appcall_linux64`, or - `ida` on test program `simple_appcall_linux32`, and wait for - auto-analysis to finish - * put a breakpoint somewhere in the code - * select the 'linux debugger' (either local, or remote) - * start debugging - * Press Alt+Shift+C at the breakpoint - -#### Shortcut -Alt+Shift+C - -#### Uses -* ida_dbg.get_reg_vals -* ida_dbg.get_thread_qty -* ida_dbg.getn_thread -* ida_idd.get_dbg -* ida_kernwin.AST_ENABLE_ALWAYS -* ida_kernwin.action_desc_t -* ida_kernwin.register_action - -
- -
- -#### registers_context_menu -
- Adding actions to the "registers" widget(s) - -
- -#### Source code -debugging/misc/registers_context_menu.py - -#### Category -debugging - -#### Description -It's possible to add actions to the context menu of -pretty much all widgets in IDA. - -This example shows how to do just that for -registers-displaying widgets (e.g., "General registers") - -#### Keywords -ctxmenu UI_Hooks - -#### Uses -* ida_dbg.get_dbg_reg_info -* ida_dbg.get_reg_val -* ida_idd.register_info_t -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_CPUREGS -* ida_kernwin.UI_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.get_widget_type -* ida_kernwin.register_action -* ida_ua.dt_byte -* ida_ua.dt_dword -* ida_ua.dt_qword -* ida_ua.dt_word - -
- -
- -#### show_debug_names -
- Retrieving & dumping debuggee symbols - -
- -#### Source code -debugging/show_debug_names.py - -#### Category -debugging - -#### Description -Queries the debugger (possibly remotely) for the list of -symbols that the process being debugged, provides. - -#### Uses -* ida_dbg.DSTATE_SUSP -* ida_dbg.get_process_state -* ida_dbg.is_debugger_on -* ida_ida.inf_get_max_ea -* ida_ida.inf_get_min_ea -* ida_name.get_debug_names - -
- -
- -#### simple_appcall_linux -
- Executing code into the application being debugged (on Linux) - -
- -#### Source code -debugging/appcall/simple_appcall_linux.py - -#### Category -debugging - -#### Description -Using the `ida_idd.Appcall` utility to execute code in -the process being debugged. - -This example will run the test program and stop wherever -the cursor currently is, and then perform an appcall to -execute the `ref4` and `ref8` functions. - -To use this example: - - * run `ida64` on test program `simple_appcall_linux64`, or - `ida` on test program `simple_appcall_linux32`, and wait for - auto-analysis to finish - * select the 'linux debugger' (either local, or remote) - * run this script - -Note: the real body of code is in `simple_appcall_common.py`. - -#### Imports -* simple_appcall_common - -#### Uses -* ida_dbg.DBG_Hooks -* ida_dbg.run_to -* ida_idaapi.BADADDR -* ida_idd.Appcall -* ida_idd.Appcall.byref -* ida_idd.Appcall.int64 -* ida_kernwin.get_screen_ea -* ida_name.get_name_ea -* ida_name.set_name -* ida_typeinf.apply_cdecl - -
- -
- -#### simple_appcall_win -
- Executing code into the application being debugged (on Windows) - -
- -#### Source code -debugging/appcall/simple_appcall_win.py - -#### Category -debugging - -#### Description -Using the `ida_idd.Appcall` utility to execute code in -the process being debugged. - -This example will run the test program and stop wherever -the cursor currently is, and then perform an appcall to -execute the `ref4` and `ref8` functions. - -To use this example: - - * run `ida64` on test program `simple_appcall_win64.exe`, or - `ida` on test program `simple_appcall_win32.exe`, and wait for - auto-analysis to finish - * select the 'windows debugger' (either local, or remote) - * run this script - -Note: the real body of code is in `simple_appcall_common.py`. - -#### Imports -* simple_appcall_common - -#### Uses -* ida_dbg.DBG_Hooks -* ida_dbg.run_to -* ida_ida.inf_is_64bit -* ida_idaapi.BADADDR -* ida_idd.Appcall -* ida_idd.Appcall.byref -* ida_idd.Appcall.int64 -* ida_kernwin.get_screen_ea -* ida_name.get_name_ea -* ida_name.set_name -* ida_typeinf.apply_cdecl - -
- -
- -## Category: disassembly - -#### colorize_disassembly -
- Change background colours - -
- -#### Source code -core/colorize_disassembly.py - -#### Category -disassembly - -#### Description -This illustrates the setting/retrieval of background colours -using the IDC wrappers - -In order to do so, we'll be assigning colors to specific ranges -(item, function, or segment). Those will be persisted in the -database. - -#### Keywords -coloring idc - -#### Uses -* idc.CIC_FUNC -* idc.CIC_ITEM -* idc.CIC_SEGM -* idc.get_color -* idc.here -* idc.set_color - -#### See also -* [colorize_disassembly_on_the_fly](#colorize_disassembly_on_the_fly) - -
- -
- -## Category: hexrays - -#### colorize_pseudocode_lines -
- Interactively color certain pseudocode lines - -
- -#### Source code -hexrays/colorize_pseudocode_lines.py - -#### Category -hexrays - -#### Description +### Interactively color decompilation lines {#colorize_pseudocode_lines} Provides an action that can be used to dynamically alter the lines background rendering for pseudocode listings (as opposed to using `ida_hexrays.cfunc_t.pseudocode[N].bgcolor`) @@ -1576,151 +1893,63 @@ After running this script, pressing 'M' on a line in a "Pseudocode-?" widget, will cause that line to be rendered with a special background color. -#### Shortcut -M +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [colorize_pseudocode_lines.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/colorize_pseudocode_lines.py) | colors UI_Hooks | Intermediate | -#### Keywords -colors UI_Hooks +**APIs Used:** +* `ida_hexrays.get_widget_vdui` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.CK_EXTRA11` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_custom_viewer_location` +* `ida_kernwin.line_rendering_output_entry_t` +* `ida_kernwin.refresh_custom_viewer` +* `ida_kernwin.register_action` +* `ida_moves.lochist_entry_t` -#### Uses -* ida_hexrays.get_widget_vdui -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.CK_EXTRA11 -* ida_kernwin.UI_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.get_custom_viewer_location -* ida_kernwin.line_rendering_output_entry_t -* ida_kernwin.refresh_custom_viewer -* ida_kernwin.register_action -* ida_moves.lochist_entry_t +*** -
-
- -#### curpos_details -
- A focus on the 'curpos' hook, printing additional details about user input - -
- -#### Source code -hexrays/curpos_details.py - -#### Category -hexrays - -#### Description -Shows how user input information can be retrieved during -processing of a notification triggered by that input - -#### Keywords -Hexrays_Hooks - -#### Uses -* ida_hexrays.Hexrays_Hooks -* ida_kernwin.get_user_input_event -* ida_kernwin.iek_key_press -* ida_kernwin.iek_key_release -* ida_kernwin.iek_mouse_button_press -* ida_kernwin.iek_mouse_button_release -* ida_kernwin.iek_mouse_wheel -* ida_kernwin.iek_shortcut -* ida_kernwin.input_event_t - -#### See also -* [vds_hooks](#vds_hooks) - -
- -
- -#### decompile_entry_points -
- Automatic decompilation of functions - -
- -#### Source code -hexrays/decompile_entry_points.py - -#### Category -hexrays - -#### Description +### Decompile entrypoint automatically {#decompile_entry_points} Attempts to load a decompiler plugin corresponding to the current -architecture (and address size) right after auto-analysis is performed, +architecture right after auto-analysis is performed, and then tries to decompile the function at the first entrypoint. It is particularly suited for use with the '-S' flag, for example: idat -Ldecompile.log -Sdecompile_entry_points.py -c file -#### Uses -* ida_auto.auto_wait -* ida_entry.get_entry -* ida_entry.get_entry_ordinal -* ida_entry.get_entry_qty -* ida_hexrays.decompile -* ida_hexrays.init_hexrays_plugin -* ida_ida.inf_is_64bit -* ida_idp.PLFM_386 -* ida_idp.PLFM_ARM -* ida_idp.PLFM_MIPS -* ida_idp.PLFM_PPC -* ida_idp.ph.id -* ida_kernwin.cvar.batch -* ida_kernwin.msg -* ida_loader.load_plugin -* ida_pro.qexit -* idc.get_idb_path +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [decompile_entry_points.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/decompile_entry_points.py) | | Intermediate | -
+**APIs Used:** +* `ida_auto.auto_wait` +* `ida_entry.get_entry` +* `ida_entry.get_entry_ordinal` +* `ida_entry.get_entry_qty` +* `ida_hexrays.decompile` +* `ida_hexrays.init_hexrays_plugin` +* `ida_idp.PLFM_386` +* `ida_idp.PLFM_ARM` +* `ida_idp.PLFM_MIPS` +* `ida_idp.PLFM_PPC` +* `ida_idp.PLFM_RISCV` +* `ida_idp.ph.id` +* `ida_kernwin.cvar.batch` +* `ida_kernwin.msg` +* `ida_loader.load_plugin` +* `ida_pro.qexit` +* `idc.get_idb_path` -
+*** -#### vds1 -
- Decompile & print current function. -
- -#### Source code -hexrays/vds1.py - -#### Category -hexrays - -#### Description -Decompile & print current function. - -#### Uses -* ida_funcs.get_func -* ida_hexrays.decompile -* ida_hexrays.get_hexrays_version -* ida_hexrays.init_hexrays_plugin -* ida_kernwin.get_screen_ea -* ida_lines.tag_remove - -
- -
- -#### vds10 -
- A custom microcode instruction optimization rule - -
- -#### Source code -hexrays/vds10.py - -#### Category -hexrays - -#### Description +### Add custom microcode instruction optimization rule {#vds10} Installs a custom microcode instruction optimization rule, to transform: @@ -1732,270 +1961,25 @@ into To see this plugin in action please use arm64_brk.i64 -#### Keywords -plugin +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds10.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds10.py) | plugin | Intermediate | -#### Uses -* ida_bytes.get_cmt -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.mop_str -* ida_hexrays.optinsn_t -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t -* ida_typeinf.STI_PCCHAR -* ida_typeinf.tinfo_t.get_stock +**APIs Used:** +* `ida_bytes.get_cmt` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.mop_str` +* `ida_hexrays.optinsn_t` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` +* `ida_typeinf.STI_PCCHAR` +* `ida_typeinf.tinfo_t.get_stock` -
+*** -
-#### vds11 -
- A custom microcode block optimization rule (resolve `goto` chains) - -
- -#### Source code -hexrays/vds11.py - -#### Category -hexrays - -#### Description -Installs a custom microcode block optimization rule, -to transform: - - goto L1 - ... - L1: - goto L2 - -into - - goto L2 - -In other words we fix a goto target if it points to a chain of gotos. -This improves the decompiler output in some cases. - -#### Keywords -plugin - -#### Uses -* ida_hexrays.getf_reginsn -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.m_goto -* ida_hexrays.optblock_t -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t - -
- -
- -#### vds12 -
- List instruction registers - -
- -#### Source code -hexrays/vds12.py - -#### Category -hexrays - -#### Description -Shows a list of direct references to a register from the -current instruction. - -#### Uses -* ida_bytes.get_flags -* ida_bytes.is_code -* ida_funcs.get_func -* ida_hexrays.ACFL_GUESS -* ida_hexrays.DECOMP_NO_CACHE -* ida_hexrays.DECOMP_WARNINGS -* ida_hexrays.GCO_DEF -* ida_hexrays.GCO_USE -* ida_hexrays.GC_REGS_AND_STKVARS -* ida_hexrays.MERR_OK -* ida_hexrays.MMAT_PREOPTIMIZED -* ida_hexrays.MUST_ACCESS -* ida_hexrays.gco_info_t -* ida_hexrays.gen_microcode -* ida_hexrays.get_current_operand -* ida_hexrays.get_merror_desc -* ida_hexrays.hexrays_failure_t -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.mba_ranges_t -* ida_hexrays.mlist_t -* ida_hexrays.op_parent_info_t -* ida_hexrays.voff_t -* ida_kernwin.Choose -* ida_kernwin.get_screen_ea -* ida_kernwin.jumpto -* ida_kernwin.warning -* ida_lines.GENDSM_REMOVE_TAGS -* ida_lines.generate_disasm_line -* ida_pro.eavec_t - -
- -
- -#### vds13 -
- Generates microcode for selection - -
- -#### Source code -hexrays/vds13.py - -#### Category -hexrays - -#### Description -Generates microcode for selection and dumps it to the output window. - -#### Uses -* ida_bytes.get_flags -* ida_bytes.is_code -* ida_hexrays.DECOMP_WARNINGS -* ida_hexrays.gen_microcode -* ida_hexrays.hexrays_failure_t -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.mba_ranges_t -* ida_hexrays.vd_printer_t -* ida_kernwin.read_range_selection -* ida_kernwin.warning -* ida_range.range_t - -
- -
- -#### vds17 -
- Using the "Select offsets" widget - -
- -#### Source code -hexrays/vds17.py - -#### Category -hexrays - -#### Description -Registers an action opens the "Select offsets" widget -(select_udt_by_offset() call). - -This effectively repeats the functionality already available -through Alt+Y. - -Place cursor on the union field and press Shift+T - -#### Shortcut -Shift+T - -#### Keywords -plugin - -#### Uses -* ida_hexrays.USE_KEYBOARD -* ida_hexrays.cot_add -* ida_hexrays.cot_cast -* ida_hexrays.cot_memptr -* ida_hexrays.cot_memref -* ida_hexrays.cot_num -* ida_hexrays.cot_ref -* ida_hexrays.get_hexrays_version -* ida_hexrays.get_widget_vdui -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.select_udt_by_offset -* ida_hexrays.ui_stroff_applicator_t -* ida_hexrays.ui_stroff_ops_t -* ida_idaapi.BADADDR -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.get_custom_viewer_curline -* ida_kernwin.msg -* ida_kernwin.register_action -* ida_kernwin.warning -* ida_lines.tag_remove -* ida_typeinf.PRTYPE_1LINE -* ida_typeinf.print_tinfo -* ida_typeinf.remove_pointer - -
- -
- -#### vds19 -
- A custom microcode instruction optimization rule (`x | ~x => -1`) - -
- -#### Source code -hexrays/vds19.py - -#### Category -hexrays - -#### Description -Installs a custom microcode instruction optimization rule, -to transform: - - x | ~x - -into - - -1 - -To see this plugin in action please use be_ornot_be.idb - -#### Keywords -plugin - -#### Uses -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.m_bnot -* ida_hexrays.m_mov -* ida_hexrays.m_or -* ida_hexrays.minsn_visitor_t -* ida_hexrays.mop_t -* ida_hexrays.optinsn_t -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t - -
- -
- -#### vds21 -
- Dynamically provide a custom call type - -
- -#### Source code -hexrays/vds21.py - -#### Category -hexrays - -#### Description +### Dynamically provide a custom call type {#vds21} This plugin can greatly improve decompilation of indirect calls: call [eax+4] @@ -2017,43 +2001,337 @@ This plugin illustrates another approach to the problem: if you happen to be able to calculate the call prototypes dynamically, this is how to inform the decompiler about them. -#### Keywords -Hexrays_Hooks plugin +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds21.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds21.py) | Hexrays_Hooks plugin | Intermediate | -#### Uses -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.m_call -* ida_hexrays.mcallinfo_t -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t -* ida_kernwin.msg -* ida_kernwin.warning -* ida_nalt.get_op_tinfo -* ida_typeinf.BT_INT -* ida_typeinf.CM_CC_STDCALL -* ida_typeinf.CM_N32_F48 -* ida_typeinf.parse_decl -* ida_typeinf.tinfo_t +**APIs Used:** +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.m_call` +* `ida_hexrays.mcallinfo_t` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` +* `ida_kernwin.msg` +* `ida_kernwin.warning` +* `ida_nalt.get_op_tinfo` +* `ida_typeinf.BT_INT` +* `ida_typeinf.CM_CC_STDCALL` +* `ida_typeinf.CM_N32_F48` +* `ida_typeinf.parse_decl` +* `ida_typeinf.tinfo_t` -
+*** -
-#### vds3 -
- Invert if/else blocks +### Dump user-defined information for a function {#vds4} +Prints user-defined information to the "Output" window. +Namely: -
+ * user defined label names + * user defined indented comments + * user defined number formats + * user defined local variable names, types, comments -#### Source code -hexrays/vds3.py +This script loads information from the database without decompiling anything. -#### Category -hexrays +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds4.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds4.py) | | Intermediate | -#### Description +**APIs Used:** +* `ida_bytes.get_radix` +* `ida_funcs.get_func` +* `ida_hexrays.CIT_COLLAPSED` +* `ida_hexrays.NF_NEGATE` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.lvar_uservec_t` +* `ida_hexrays.restore_user_cmts` +* `ida_hexrays.restore_user_iflags` +* `ida_hexrays.restore_user_labels` +* `ida_hexrays.restore_user_lvar_settings` +* `ida_hexrays.restore_user_numforms` +* `ida_hexrays.user_cmts_free` +* `ida_hexrays.user_iflags_free` +* `ida_hexrays.user_labels_free` +* `ida_hexrays.user_numforms_free` +* `ida_kernwin.get_screen_ea` + +*** + + +### Superficially modify the decompilation output {#vds6} +Modifies the decompilation output in a superficial manner, +by removing some white spaces + +Note: this is rather crude, not quite "pythonic" code. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds6.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds6.py) | Hexrays_Hooks plugin | Intermediate | + +**APIs Used:** +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.init_hexrays_plugin` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` +* `ida_lines.tag_advance` +* `ida_lines.tag_skipcodes` + +*** + + +### Improve decompilation by turning specific patterns into custom function calls {#vds8} +Registers an action that uses a `ida_hexrays.udc_filter_t` to decompile +`svc 0x900001` and `svc 0x9000F8` as function calls to +`svc_exit()` and `svc_exit_group()` respectively. + +You will need to have an ARM + Linux IDB for this script to be usable + +In addition to having a shortcut, the action will be present +in the context menu. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds8.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds8.py) | ctxmenu UI_Hooks | Intermediate | + +**APIs Used:** +* `ida_allins.ARM_svc` +* `ida_hexrays.get_widget_vdui` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.install_microcode_filter` +* `ida_hexrays.udc_filter_t` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.get_widget_type` +* `ida_kernwin.register_action` + +*** + + +### React to decompiler events/notifications {#vds_hooks} +Shows how to hook to many notifications sent by the decompiler. + +This plugin doesn't really accomplish anything: it just prints +the parameters. + +The list of notifications handled below should be exhaustive, +and is there to hint at what is possible to accomplish by +subclassing `ida_hexrays.Hexrays_Hooks` + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds_hooks.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds_hooks.py) | Hexrays_Hooks | Intermediate | + +**APIs Used:** +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.cfunc_t` +* `ida_hexrays.lvar_t` +* `ida_hexrays.vdui_t` + +*** + + +### Modifying function local variables {#vds_modify_user_lvars} +Use a `ida_hexrays.user_lvar_modifier_t` to modify names, +comments and/or types of local variables. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds_modify_user_lvars.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds_modify_user_lvars.py) | | Intermediate | + +**APIs Used:** +* `ida_hexrays.modify_user_lvars` +* `ida_hexrays.user_lvar_modifier_t` +* `ida_typeinf.parse_decl` +* `idc.here` + +*** + + +### Print information about the current position in decompilation {#curpos_details} +Shows how user input information can be retrieved during +processing of a notification triggered by that input + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [curpos_details.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/curpos_details.py) | Hexrays_Hooks | Advanced | + +**APIs Used:** +* `ida_hexrays.Hexrays_Hooks` +* `ida_kernwin.get_user_input_event` +* `ida_kernwin.iek_key_press` +* `ida_kernwin.iek_key_release` +* `ida_kernwin.iek_mouse_button_press` +* `ida_kernwin.iek_mouse_button_release` +* `ida_kernwin.iek_mouse_wheel` +* `ida_kernwin.iek_shortcut` +* `ida_kernwin.input_event_t` + +*** + + +### Add a custom microcode block optimization rule {#vds11} +Installs a custom microcode block optimization rule, +to transform: + + goto L1 + ... + L1: + goto L2 + +into + + goto L2 + +In other words we fix a goto target if it points to a chain of gotos. +This improves the decompiler output in some cases. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds11.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds11.py) | plugin | Advanced | + +**APIs Used:** +* `ida_hexrays.getf_reginsn` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.m_goto` +* `ida_hexrays.optblock_t` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` + +*** + + +### List instruction registers {#vds12} +Shows a list of direct references to a register from the +current instruction. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds12.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds12.py) | | Advanced | + +**APIs Used:** +* `ida_bytes.get_flags` +* `ida_bytes.is_code` +* `ida_funcs.get_func` +* `ida_hexrays.ACFL_GUESS` +* `ida_hexrays.DECOMP_NO_CACHE` +* `ida_hexrays.DECOMP_WARNINGS` +* `ida_hexrays.GCO_DEF` +* `ida_hexrays.GCO_USE` +* `ida_hexrays.GC_REGS_AND_STKVARS` +* `ida_hexrays.MERR_OK` +* `ida_hexrays.MMAT_PREOPTIMIZED` +* `ida_hexrays.MUST_ACCESS` +* `ida_hexrays.gco_info_t` +* `ida_hexrays.gen_microcode` +* `ida_hexrays.get_current_operand` +* `ida_hexrays.get_merror_desc` +* `ida_hexrays.hexrays_failure_t` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.mba_ranges_t` +* `ida_hexrays.mlist_t` +* `ida_hexrays.op_parent_info_t` +* `ida_hexrays.voff_t` +* `ida_kernwin.Choose` +* `ida_kernwin.get_screen_ea` +* `ida_kernwin.jumpto` +* `ida_kernwin.warning` +* `ida_lines.GENDSM_REMOVE_TAGS` +* `ida_lines.generate_disasm_line` +* `ida_pro.eavec_t` + +*** + + +### Invoke the structure offset-choosing dialog from decompilation {#vds17} +Registers an action opens the "Select offsets" widget +(select_udt_by_offset() call). + +This effectively repeats the functionality already available +through Alt+Y. + +Place cursor on the union field and press Shift+T + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds17.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds17.py) | plugin | Advanced | + +**APIs Used:** +* `ida_hexrays.USE_KEYBOARD` +* `ida_hexrays.cot_add` +* `ida_hexrays.cot_cast` +* `ida_hexrays.cot_memptr` +* `ida_hexrays.cot_memref` +* `ida_hexrays.cot_num` +* `ida_hexrays.cot_ref` +* `ida_hexrays.get_hexrays_version` +* `ida_hexrays.get_widget_vdui` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.select_udt_by_offset` +* `ida_hexrays.ui_stroff_applicator_t` +* `ida_hexrays.ui_stroff_ops_t` +* `ida_idaapi.BADADDR` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_custom_viewer_curline` +* `ida_kernwin.msg` +* `ida_kernwin.register_action` +* `ida_kernwin.warning` +* `ida_lines.tag_remove` +* `ida_typeinf.PRTYPE_1LINE` +* `ida_typeinf.print_tinfo` +* `ida_typeinf.remove_pointer` + +*** + + +### Add a custom microcode instruction optimization rule {#vds19} +Installs a custom microcode instruction optimization rule, +to transform: + + x | ~x + +into + + -1 + +To see this plugin in action please use be_ornot_be.idb + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds19.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds19.py) | plugin | Advanced | + +**APIs Used:** +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.m_bnot` +* `ida_hexrays.m_mov` +* `ida_hexrays.m_or` +* `ida_hexrays.minsn_visitor_t` +* `ida_hexrays.mop_t` +* `ida_hexrays.optinsn_t` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` + +*** + + +### Invert if/else blocks in decompilation {#vds3} Registers an action that can be used to invert the `if` and `else` blocks of a `ida_hexrays.cif_t`. @@ -2082,108 +2360,42 @@ will be displayed as The modifications are persistent: the user can quit & restart IDA, and the changes will be present. -#### Shortcut -I +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds3.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds3.py) | ctxmenu Hexrays_Hooks IDP_Hooks plugin | Advanced | -#### Keywords -ctxmenu Hexrays_Hooks IDP_Hooks plugin +**APIs Used:** +* `ida_hexrays.CMAT_FINAL` +* `ida_hexrays.CV_FAST` +* `ida_hexrays.CV_INSNS` +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.ITP_ELSE` +* `ida_hexrays.USE_KEYBOARD` +* `ida_hexrays.VDI_TAIL` +* `ida_hexrays.cexpr_t` +* `ida_hexrays.cit_if` +* `ida_hexrays.ctree_visitor_t` +* `ida_hexrays.get_widget_vdui` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.lnot` +* `ida_hexrays.qswap` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` +* `ida_idp.IDP_Hooks` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.register_action` +* `ida_netnode.netnode` -#### Uses -* ida_hexrays.CMAT_FINAL -* ida_hexrays.CV_FAST -* ida_hexrays.CV_INSNS -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.ITP_ELSE -* ida_hexrays.USE_KEYBOARD -* ida_hexrays.VDI_TAIL -* ida_hexrays.cexpr_t -* ida_hexrays.cit_if -* ida_hexrays.ctree_visitor_t -* ida_hexrays.get_widget_vdui -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.lnot -* ida_hexrays.qswap -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t -* ida_idp.IDP_Hooks -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.register_action -* ida_netnode.netnode +*** -#### Author -EiNSTeiN_ (einstein@g3nius.org) -
- -
- -#### vds4 -
- Dump user-defined information - -
- -#### Source code -hexrays/vds4.py - -#### Category -hexrays - -#### Description -Prints user-defined information to the "Output" window. -Namely: - - * user defined label names - * user defined indented comments - * user defined number formats - * user defined local variable names, types, comments - -This script loads information from the database without decompiling anything. - -#### Uses -* ida_bytes.get_radix -* ida_funcs.get_func -* ida_hexrays.CIT_COLLAPSED -* ida_hexrays.NF_NEGATE -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.lvar_uservec_t -* ida_hexrays.restore_user_cmts -* ida_hexrays.restore_user_iflags -* ida_hexrays.restore_user_labels -* ida_hexrays.restore_user_lvar_settings -* ida_hexrays.restore_user_numforms -* ida_hexrays.user_cmts_free -* ida_hexrays.user_iflags_free -* ida_hexrays.user_labels_free -* ida_hexrays.user_numforms_free -* ida_kernwin.get_screen_ea - -#### Author -EiNSTeiN_ (einstein@g3nius.org) - -
- -
- -#### vds5 -
- Show ctree graph - -
- -#### Source code -hexrays/vds5.py - -#### Category -hexrays - -#### Description +### Dump C-tree graph {#vds5} Registers an action that can be used to show the graph of the ctree. The current item will be highlighted in the graph. @@ -2193,533 +2405,1153 @@ to the context menu. To display the graph, we produce a .gdl file, and request that ida displays that using `ida_gdl.display_gdl`. -#### Shortcut -Ctrl+Shift+G - -#### Keywords -ctxmenu Hexrays_Hooks plugin - -#### Uses -* ida_gdl.display_gdl -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.USE_KEYBOARD -* ida_hexrays.cit_asm -* ida_hexrays.cit_goto -* ida_hexrays.cot_helper -* ida_hexrays.cot_memptr -* ida_hexrays.cot_memref -* ida_hexrays.cot_num -* ida_hexrays.cot_obj -* ida_hexrays.cot_ptr -* ida_hexrays.cot_str -* ida_hexrays.cot_var -* ida_hexrays.ctree_parentee_t -* ida_hexrays.get_ctype_name -* ida_hexrays.get_widget_vdui -* ida_hexrays.init_hexrays_plugin -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.register_action -* ida_kernwin.warning -* ida_lines.tag_remove -* ida_pro.str2user - -
- -
- -#### vds6 -
- Superficially modify the decompilation output - -
- -#### Source code -hexrays/vds6.py - -#### Category -hexrays - -#### Description -Modifies the decompilation output in a superficial manner, -by removing some white spaces - -Note: this is rather crude, not quite "pythonic" code. - -#### Keywords -Hexrays_Hooks plugin - -#### Uses -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.init_hexrays_plugin -* ida_idaapi.PLUGIN_HIDE -* ida_idaapi.PLUGIN_KEEP -* ida_idaapi.plugin_t -* ida_lines.tag_advance -* ida_lines.tag_skipcodes - -
- -
- -#### vds7 -
- Iterate a cblock_t object - -
- -#### Source code -hexrays/vds7.py - -#### Category -hexrays - -#### Description -Using a `ida_hexrays.ctree_visitor_t`, search for -`ida_hexrays.cit_block` instances and dump them. - -#### Keywords -Hexrays_Hooks - -#### Uses -* ida_hexrays.CMAT_BUILT -* ida_hexrays.CV_FAST -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.cit_block -* ida_hexrays.ctree_visitor_t -* ida_hexrays.init_hexrays_plugin - -#### Author -EiNSTeiN_ (einstein@g3nius.org) - -
- -
- -#### vds8 -
- Using `ida_hexrays.udc_filter_t` - -
- -#### Source code -hexrays/vds8.py - -#### Category -hexrays - -#### Description -Registers an action that uses a `ida_hexrays.udc_filter_t` to decompile -`svc 0x900001` and `svc 0x9000F8` as function calls to -`svc_exit()` and `svc_exit_group()` respectively. - -You will need to have an ARM + Linux IDB for this script to be usable - -In addition to having a shortcut, the action will be present -in the context menu. - -#### Shortcut -Ctrl+Shift+U - -#### Keywords -ctxmenu UI_Hooks - -#### Uses -* ida_allins.ARM_svc -* ida_hexrays.get_widget_vdui -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.install_microcode_filter -* ida_hexrays.udc_filter_t -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.UI_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.get_widget_type -* ida_kernwin.register_action - -
- -
- -#### vds_create_hint -
- Decompiler hints - -
- -#### Source code -hexrays/vds_create_hint.py - -#### Category -hexrays - -#### Description -Handle `ida_hexrays.hxe_create_hint` notification using hooks, -to return our own. - -If the object under the cursor is: - -* a function call, prefix the original decompiler hint with `==> ` -* a local variable declaration, replace the hint with our own in - the form of `!{varname}` (where `{varname}` is replaced with the - variable name) -* an `if` statement, replace the hint with our own, saying "condition" - -#### Keywords -Hexrays_Hooks - -#### Uses -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.USE_MOUSE -* ida_hexrays.VDI_EXPR -* ida_hexrays.VDI_LVAR -* ida_hexrays.cit_if -* ida_hexrays.cot_call - -
- -
- -#### vds_hooks -
- Various decompiler hooks - -
- -#### Source code -hexrays/vds_hooks.py - -#### Category -hexrays - -#### Description -Shows how to hook to many notifications sent by the decompiler. - -This plugin doesn't really accomplish anything: it just prints -the parameters. - -The list of notifications handled below should be exhaustive, -and is there to hint at what is possible to accomplish by -subclassing `ida_hexrays.Hexrays_Hooks` - -#### Keywords -Hexrays_Hooks - -#### Uses -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.cfunc_t -* ida_hexrays.lvar_t -* ida_hexrays.vdui_t - -#### See also -* [curpos_details](#curpos_details) - -
- -
- -#### vds_modify_user_lvars -
- Modifying local variables - -
- -#### Source code -hexrays/vds_modify_user_lvars.py - -#### Category -hexrays - -#### Description -Use a `ida_hexrays.user_lvar_modifier_t` to modify names, -comments and/or types of local variables. - -#### Uses -* ida_hexrays.modify_user_lvars -* ida_hexrays.user_lvar_modifier_t -* ida_typeinf.parse_decl -* idc.here - -
- -
- -#### vds_xrefs -
- Show decompiler xrefs - -
- -#### Source code -hexrays/vds_xrefs.py - -#### Category -hexrays - -#### Description +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds5.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds5.py) | ctxmenu Hexrays_Hooks plugin | Advanced | + +**APIs Used:** +* `ida_gdl.display_gdl` +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.USE_KEYBOARD` +* `ida_hexrays.cit_asm` +* `ida_hexrays.cit_goto` +* `ida_hexrays.cot_helper` +* `ida_hexrays.cot_memptr` +* `ida_hexrays.cot_memref` +* `ida_hexrays.cot_num` +* `ida_hexrays.cot_obj` +* `ida_hexrays.cot_ptr` +* `ida_hexrays.cot_str` +* `ida_hexrays.cot_var` +* `ida_hexrays.ctree_parentee_t` +* `ida_hexrays.get_ctype_name` +* `ida_hexrays.get_widget_vdui` +* `ida_hexrays.init_hexrays_plugin` +* `ida_idaapi.PLUGIN_HIDE` +* `ida_idaapi.PLUGIN_KEEP` +* `ida_idaapi.plugin_t` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.register_action` +* `ida_kernwin.warning` +* `ida_lines.tag_remove` +* `ida_pro.str2user` + +*** + + +### Show decompiler cross-references {#vds_xrefs} Show decompiler-style Xref when the `Ctrl+X` key is pressed in the Decompiler window. * supports any global name: functions, strings, integers, ... * supports structure member. -#### Shortcut -Ctrl+X +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [vds_xrefs.py](https://github.com/HexRaysSA/IDAPython/tree//examples/decompiler/vds_xrefs.py) | ctxmenu Hexrays_Hooks | Advanced | -#### Keywords -ctxmenu Hexrays_Hooks +**APIs Used:** +* `ida_funcs.get_func_name` +* `ida_hexrays.DECOMP_GXREFS_FORCE` +* `ida_hexrays.Hexrays_Hooks` +* `ida_hexrays.USE_KEYBOARD` +* `ida_hexrays.VDI_EXPR` +* `ida_hexrays.VDI_FUNC` +* `ida_hexrays.cexpr_t` +* `ida_hexrays.cfunc_t` +* `ida_hexrays.cinsn_t` +* `ida_hexrays.decompile` +* `ida_hexrays.get_widget_vdui` +* `ida_hexrays.init_hexrays_plugin` +* `ida_hexrays.open_pseudocode` +* `ida_hexrays.qstring_printer_t` +* `ida_idaapi.BADADDR` +* `ida_kernwin.AST_DISABLE` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE` +* `ida_kernwin.BWN_PSEUDOCODE` +* `ida_kernwin.PluginForm` +* `ida_kernwin.PluginForm.Show` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.register_action` +* `ida_typeinf.PRTYPE_1LINE` +* `ida_typeinf.STRMEM_OFFSET` +* `ida_typeinf.print_tinfo` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udm_t` +* `idautils.Functions` +* `idautils.XrefsTo` -#### Uses -* ida_funcs.get_func_name -* ida_hexrays.DECOMP_GXREFS_FORCE -* ida_hexrays.Hexrays_Hooks -* ida_hexrays.USE_KEYBOARD -* ida_hexrays.VDI_EXPR -* ida_hexrays.VDI_FUNC -* ida_hexrays.cexpr_t -* ida_hexrays.cfunc_t -* ida_hexrays.cinsn_t -* ida_hexrays.decompile -* ida_hexrays.get_widget_vdui -* ida_hexrays.init_hexrays_plugin -* ida_hexrays.open_pseudocode -* ida_hexrays.qstring_printer_t -* ida_idaapi.BADADDR -* ida_kernwin.AST_DISABLE -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.PluginForm -* ida_kernwin.PluginForm.Show -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.register_action -* ida_typeinf.PRTYPE_1LINE -* ida_typeinf.STRMEM_OFFSET -* ida_typeinf.print_tinfo -* ida_typeinf.tinfo_t -* ida_typeinf.udm_t -* idautils.Functions -* idautils.XrefsTo +*** -#### Author -EiNSTeiN_ (einstein@g3nius.org) -
+### Print all registers, for all threads in the debugged process {#print_registers} +Iterate over the list of threads in the program being +debugged, and dump all registers contents -
+To use this example: -## Category: idbhooks + * run `ida64` on test program `simple_appcall_linux64`, or + `ida` on test program `simple_appcall_linux32`, and wait for + auto-analysis to finish + * put a breakpoint somewhere in the code + * select the 'linux debugger' (either local, or remote) + * start debugging + * Press Alt+Shift+C at the breakpoint -#### log_idb_events -
- Logging IDB events +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [print_registers.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/misc/print_registers.py) | | Beginner | -
+**APIs Used:** +* `ida_dbg.get_reg_vals` +* `ida_dbg.get_thread_qty` +* `ida_dbg.getn_thread` +* `ida_idd.get_dbg` +* `ida_kernwin.AST_ENABLE_ALWAYS` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.register_action` -#### Source code -idbhooks/log_idb_events.py +*** -#### Category -idbhooks -#### Description -These hooks will be notified about IDB events, and -dump their information to the "Output" window +### Dump symbols from a process being debugged {#show_debug_names} +Queries the debugger (possibly remotely) for the list of +symbols that the process being debugged, provides. -#### Keywords -IDB_Hooks +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [show_debug_names.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/show_debug_names.py) | | Beginner | -#### Uses -* ida_idp.IDB_Hooks +**APIs Used:** +* `ida_dbg.DSTATE_SUSP` +* `ida_dbg.get_process_state` +* `ida_dbg.is_debugger_on` +* `ida_ida.inf_get_max_ea` +* `ida_ida.inf_get_min_ea` +* `ida_name.get_debug_names` -
+*** -
-#### operand_changed -
- Notify the user when an instruction operand changes +### Print call stack {#print_call_stack} +Print the return addresses from the call stack at a breakpoint, +when debugging a Linux binary. +(and also print the module and the debug name from debugger) -
+To use this example: -#### Source code -idbhooks/operand_changed.py + * run `ida` on test program `simple_appcall_linux64`, or + `ida` on test program `simple_appcall_linux32`, and wait for + auto-analysis to finish + * put a breakpoint where you want to see the call stack + * select the 'linux debugger' (either local, or remote) + * start debugging + * Press Shift+C at the breakpoint -#### Category -idbhooks +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [print_call_stack.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/misc/print_call_stack.py) | | Intermediate | -#### Description -Show notifications whenever the user changes -an instruction's operand, or a data item. +**APIs Used:** +* `ida_dbg.collect_stack_trace` +* `ida_dbg.get_current_thread` +* `ida_dbg.get_module_info` +* `ida_idd.call_stack_t` +* `ida_idd.modinfo_t` +* `ida_kernwin.AST_ENABLE_ALWAYS` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.register_action` +* `ida_name.GNCN_NOCOLOR` +* `ida_name.GNCN_NOLABEL` +* `ida_name.GNCN_NOSEG` +* `ida_name.GNCN_PREFDBG` +* `ida_name.get_nice_colored_name` -#### Keywords -IDB_Hooks +*** -#### Uses -* ida_bytes.ALOPT_IGNCLT -* ida_bytes.ALOPT_IGNHEADS -* ida_bytes.get_flags -* ida_bytes.get_max_strlit_length -* ida_bytes.get_opinfo -* ida_bytes.get_strlit_contents -* ida_bytes.is_custfmt -* ida_bytes.is_custom -* ida_bytes.is_enum -* ida_bytes.is_off -* ida_bytes.is_strlit -* ida_bytes.is_stroff -* ida_bytes.is_struct -* ida_idp.IDB_Hooks -* ida_nalt.STRENC_DEFAULT -* ida_nalt.get_default_encoding_idx -* ida_nalt.get_encoding_name -* ida_nalt.get_str_encoding_idx -* ida_nalt.get_strtype_bpu -* ida_nalt.opinfo_t -* ida_typeinf.get_tid_name -* ida_typeinf.tinfo_t -
+### Add a custom action to the "registers" widget {#registers_context_menu} +It's possible to add actions to the context menu of +pretty much all widgets in IDA. -
+This example shows how to do just that for +registers-displaying widgets (e.g., "General registers") -#### replay_prototypes_changes -
- Record and replay changes in function prototypes +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [registers_context_menu.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/misc/registers_context_menu.py) | ctxmenu UI_Hooks | Intermediate | -
+**APIs Used:** +* `ida_dbg.get_dbg_reg_info` +* `ida_dbg.get_reg_val` +* `ida_idd.register_info_t` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_CPUREGS` +* `ida_kernwin.UI_Hooks` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.attach_action_to_popup` +* `ida_kernwin.get_widget_type` +* `ida_kernwin.register_action` +* `ida_ua.dt_byte` +* `ida_ua.dt_dword` +* `ida_ua.dt_qword` +* `ida_ua.dt_word` -#### Source code -idbhooks/replay_prototypes_changes.py +*** -#### Category -idbhooks -#### Description -This is a sample script, that will record (in memory) all changes in -functions prototypes, in order to re-apply them later. +### Programmatically drive a debugging session {#automatic_steps} +Start a debugging session, step through the first five +instructions. Each instruction is disassembled after +execution. -To use this script: - - open an IDB (say, "test.idb") - - modify some functions prototypes (e.g., by triggering the 'Y' - shortcut when the cursor is placed on the first address of a - function) - - reload that IDB, *without saving it first* - - call rpc.replay(), to re-apply the modifications. +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [automatic_steps.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/dbghooks/automatic_steps.py) | DBG_Hooks | Advanced | -Note: 'ti_changed' is also called for changes to the function -frames, but we'll only record function prototypes changes. +**APIs Used:** +* `ida_dbg.DBG_Hooks` +* `ida_dbg.get_reg_val` +* `ida_dbg.request_exit_process` +* `ida_dbg.request_run_to` +* `ida_dbg.request_step_over` +* `ida_dbg.run_requests` +* `ida_ida.inf_get_start_ip` +* `ida_idaapi.BADADDR` +* `ida_lines.generate_disasm_line` +* `ida_lines.tag_remove` -#### Keywords -IDB_Hooks +*** -#### Uses -* ida_funcs.get_func -* ida_idp.IDB_Hooks -* ida_typeinf.PRTYPE_1LINE -* ida_typeinf.TINFO_DEFINITE -* ida_typeinf.apply_tinfo -* ida_typeinf.get_idati -* ida_typeinf.tinfo_t -
+### React to trace notifications {#dbg_trace} +This script demonstrates using the low-level tracing hook +(ida_dbg.DBG_Hooks.dbg_trace). It can be run like so: -
+ ida.exe -B -Sdbg_trace.py -Ltrace.log file.exe -## Category: idphooks +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [dbg_trace.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/dbghooks/dbg_trace.py) | DBG_Hooks | Advanced | -#### ana_emu_out -
- Override some parts of the processor module +**APIs Used:** +* `GENDSM_FORCE_CODE` +* `GENDSM_REMOVE_TAGS` +* `NN_call` +* `NN_callfi` +* `NN_callni` +* `generate_disasm_line` +* `ida_dbg.DBG_Hooks` +* `ida_dbg.ST_OVER_DEBUG_SEG` +* `ida_dbg.ST_OVER_LIB_FUNC` +* `ida_dbg.enable_step_trace` +* `ida_dbg.get_process_state` +* `ida_dbg.get_reg_val` +* `ida_dbg.get_step_trace_options` +* `ida_dbg.load_debugger` +* `ida_dbg.refresh_debugger_memory` +* `ida_dbg.request_continue_process` +* `ida_dbg.request_enable_step_trace` +* `ida_dbg.request_set_step_trace_options` +* `ida_dbg.run_requests` +* `ida_dbg.run_to` +* `ida_dbg.set_step_trace_options` +* `ida_dbg.wait_for_next_event` +* `ida_ida.f_ELF` +* `ida_ida.f_MACHO` +* `ida_ida.f_PE` +* `ida_ida.inf_get_filetype` +* `ida_ida.inf_get_max_ea` +* `ida_ida.inf_get_min_ea` +* `ida_ida.inf_get_start_ip` +* `ida_pro.qexit` +* `ida_ua.decode_insn` +* `ida_ua.insn_t` +* `idc.ARGV` -
+*** -#### Source code -idphooks/ana_emu_out.py -#### Category -idphooks +### Execute code into the application being debugged (on Linux) {#simple_appcall_linux} +Using the `ida_idd.Appcall` utility to execute code in +the process being debugged. -#### Description -Implements disassembly of BUG_INSTR used in Linux kernel -BUG() macro, which is architecturally undefined and is not -disassembled by IDA's ARM module +This example will run the test program and stop wherever +the cursor currently is, and then perform an appcall to +execute the `ref4` and `ref8` functions. -See Linux/arch/arm/include/asm/bug.h for more info +To use this example: -#### Keywords -IDP_Hooks + * run `ida64` on test program `simple_appcall_linux64`, or + `ida` on test program `simple_appcall_linux32`, and wait for + auto-analysis to finish + * select the 'linux debugger' (either local, or remote) + * run this script -#### Uses -* ida_bytes.get_wide_dword -* ida_bytes.get_wide_word -* ida_idp.CUSTOM_INSN_ITYPE -* ida_idp.IDP_Hooks -* ida_idp.PLFM_ARM -* ida_idp.ph.id -* ida_idp.str2reg -* ida_segregs.get_sreg +Note: the real body of code is in `simple_appcall_common.py`. -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [simple_appcall_linux.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/appcall/simple_appcall_linux.py) | | Advanced | -
+**APIs Used:** +* `ida_dbg.DBG_Hooks` +* `ida_dbg.run_to` +* `ida_idaapi.BADADDR` +* `ida_idd.Appcall` +* `ida_idd.Appcall.byref` +* `ida_idd.Appcall.int64` +* `ida_kernwin.get_screen_ea` +* `ida_name.get_name_ea` +* `ida_name.set_name` +* `ida_typeinf.apply_cdecl` -#### assemble -
- An `ida_idp.IDP_Hooks.assembly` implementation +*** -
-#### Source code -idphooks/assemble.py +### Execute code into the application being debugged (on Windows) {#simple_appcall_win} +Using the `ida_idd.Appcall` utility to execute code in +the process being debugged. -#### Category -idphooks +This example will run the test program and stop wherever +the cursor currently is, and then perform an appcall to +execute the `ref4` and `ref8` functions. -#### Description -We add support for assembling the following pseudo instructions: +To use this example: -* "zero eax" -> xor eax, eax -* "nothing" -> nop + * run `ida` on test program `simple_appcall_win64.exe`, or + `ida` on test program `simple_appcall_win32.exe`, and wait for + auto-analysis to finish + * select the 'windows debugger' (either local, or remote) + * run this script -#### Keywords -IDP_Hooks +Note: the real body of code is in `simple_appcall_common.py`. -#### Uses -* ida_idp.IDP_Hooks -* idautils.DecodeInstruction +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [simple_appcall_win.py](https://github.com/HexRaysSA/IDAPython/tree//examples/debugger/appcall/simple_appcall_win.py) | | Advanced | -
+**APIs Used:** +* `ida_dbg.DBG_Hooks` +* `ida_dbg.run_to` +* `ida_ida.inf_is_64bit` +* `ida_idaapi.BADADDR` +* `ida_idd.Appcall` +* `ida_idd.Appcall.byref` +* `ida_idd.Appcall.int64` +* `ida_kernwin.get_screen_ea` +* `ida_name.get_name_ea` +* `ida_name.set_name` +* `ida_typeinf.apply_cdecl` -
+*** -## Category: merge -#### py_mex1 -
- Add merge functionality to a simple plugin, example 1 +### Create a structure by parsing its definition {#create_struct_by_parsing} +The goal of this script is to demonstrate some usage of the type API. +In this script, we create a structure using the "parsing" method. -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_struct_by_parsing.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_struct_by_parsing.py) | | Beginner | -#### Source code -merge/py_mex1.py +**APIs Used:** +* `ida_typeinf.tinfo_t` -#### Category -merge +*** -#### Description + +### Delete structure members that fall within an offset range {#del_struct_members} +The goal of this script is to demonstrate some usage of the type API. +In this script, we first create a structure with many members, and then +remove all those that fall within a range. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [del_struct_members.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/del_struct_members.py) | | Beginner | + +**APIs Used:** +* `ida_typeinf.STRMEM_OFFSET` +* `ida_typeinf.TERR_OK` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udm_t` + +*** + + +### Print enumeration members {#list_enum_member} +In this example, we will first ask the user to provide the name +of an enumeration, and then iterate on it + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_enum_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/list_enum_member.py) | | Beginner | + +**APIs Used:** +* `ida_kernwin.ask_str` + +*** + + +### Print function stack frame information {#list_frame_info} +The goal of this script is to demonstrate some usage of the type API. +In this script, we retrieve the function frame structure, and iterate +on the frame members. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_frame_info.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/list_frame_info.py) | | Beginner | + +**APIs Used:** +* `ida_funcs.get_func` +* `ida_kernwin.get_screen_ea` + +*** + + +### List database functions prototypes {#list_func_details} +This script demonstrates how to list a function return type +along with its parameters types and name if any. +We do this for all the functions found in the database. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_func_details.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/list_func_details.py) | | Beginner | + +**APIs Used:** +* `ida_funcs.get_func` +* `idautils.Functions` + +*** + + +### List structure members {#list_struct_member} +The goal of this script is to demonstrate some usage of the type API. +In this script, we: +* Ask the user for a structure name. It must already be present in the +local types. +* Retrieve the structure type info from the local type +* Extract its type details (udt) +* Iterates it members and prints their names. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_struct_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/list_struct_member.py) | | Beginner | + +**APIs Used:** +* `ida_kernwin.ask_str` +* `ida_typeinf.BTF_STRUCT` +* `ida_typeinf.get_idati` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udt_type_data_t` + +*** + + +### List cross-references to a structure {#list_struct_xrefs} +The goal of this script is to demonstrate some usage of the type API. +In this script, we: +* Ask the user for a structure name. It must already be present in the +local types. +* Get its tid +* Create the list of all the reference. +* Print it + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_struct_xrefs.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/list_struct_xrefs.py) | | Beginner | + +**APIs Used:** +* `ida_kernwin.choose_struct` +* `ida_typeinf.tinfo_t` +* `ida_xref.xrefblk_t` + +*** + + +### List union members {#list_union_member} +The goal of this script is to demonstrate some usage of the type API. +In this script, we: +* Ask the user for a union name. It must already be present in the +local types. +* Retrieve the union type info from the local type +* Extract its type details (udt) +* Iterates it members and prints their names. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_union_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/list_union_member.py) | | Beginner | + +**APIs Used:** +* `ida_kernwin.ask_str` +* `ida_typeinf.BTF_UNION` +* `ida_typeinf.get_idati` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udt_type_data_t` + +*** + + +### Mark a register "spoiled" by a function {#mark_func_spoiled} +At least two possibilies are offered in order to indicate that a function +spoils registers (excluding the "normal" ones): + +You can either parse & apply a declaration: + + func_tfinfo = ida_typeinf.tinfo_t("int _spoils main();") + ida_typeinf.apply_tinfo(func.start_ea, func_tinfo, ida_typeinf.TINFO_DEFINITE) + +or retrieve & modify the `tinfo_t` object directly. + +This script showcases the latter. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [mark_func_spoiled.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/mark_func_spoiled.py) | | Beginner | + +**APIs Used:** +* `ida_funcs.get_func` +* `ida_idp.parse_reg_name` +* `ida_idp.reg_info_t` +* `ida_kernwin.get_screen_ea` +* `ida_nalt.get_tinfo` +* `ida_typeinf.FTI_SPOILED` +* `ida_typeinf.TINFO_DEFINITE` +* `ida_typeinf.apply_tinfo` +* `ida_typeinf.func_type_data_t` +* `ida_typeinf.tinfo_t` + +*** + + +### Apply function prototype to call sites {#apply_callee_tinfo} +The goal of this script is to demonstrate some usage of the type API. +In this script, we: +* Open the private type libary. +* Load its declaration in the type library by parsing its declaration and +keep the return tuple for future use. +* Deserialize the type info stored in the returned tuple. +* Get the address of the function. +* Get the address of the code reference to the function and apply +the type info there. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [apply_callee_tinfo.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/apply_callee_tinfo.py) | | Intermediate | + +**APIs Used:** +* `ida_idaapi.BADADDR` +* `ida_name.get_name_ea` +* `ida_typeinf.PT_REPLACE` +* `ida_typeinf.apply_callee_tinfo` +* `ida_typeinf.get_idati` +* `ida_typeinf.idc_parse_decl` +* `ida_typeinf.tinfo_t` +* `idautils.CodeRefsTo` + +*** + + +### Create an array type {#create_array} +The goal of this script is to demonstrate some usage of the type API. +In this script, we create an array using both versions of +create_array tinfo_t method. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_array.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_array.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.BTF_INT` +* `ida_typeinf.array_type_data_t` +* `ida_typeinf.tinfo_t` + +*** + + +### Create a structure with bitfield members {#create_bfstruct} +The goal of this script is to demonstrate some usage of the type API. +In this script, we: + * Create a bitfield structure. In the present case the bitfield is an int32 +made of three 'members' spanning it entirely: + bit0->bit19: bf1 + bit20->bit25: bf2 + bit26->bit31: bf3 + * For each member create a repeatable comment. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_bfstruct.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_bfstruct.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udm_t` +* `ida_typeinf.udt_type_data_t` + +*** + + +### Create a bitmask enumeration {#create_bmenum} +The goal of this script is to demonstrate some usage of the type API. +In this script, we create a bitmask enumeration member by member. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_bmenum.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_bmenum.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.BTE_BITMASK` +* `ida_typeinf.BTE_HEX` +* `ida_typeinf.tinfo_t` + +*** + + +### Create a type library file {#create_libssh2_til} +The goal of this script is to demonstrate some usage of the type API. +In this script: + * We create a new libssh2-64.til file holding some libssh2 64-bit structures. + * Once the file has been created, it can copied in the IDA install + til directory or in the user IDA til directory. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_libssh2_til.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_libssh2_til.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.HTI_DCL` +* `ida_typeinf.HTI_PAKDEF` +* `ida_typeinf.compact_til` +* `ida_typeinf.free_til` +* `ida_typeinf.new_til` +* `ida_typeinf.parse_decls` +* `ida_typeinf.store_til` + +*** + + +### Create a structure programmatically {#create_struct_by_member} +The goal of this script is to demonstrate some usage of the type API. +In this script, we create a structure by building it member by member. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_struct_by_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_struct_by_member.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.BTF_UINT32` +* `ida_typeinf.NTF_TYPE` +* `ida_typeinf.del_named_type` +* `ida_typeinf.tinfo_errstr` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udt_type_data_t` + +*** + + +### Create & populate a structure {#create_structure_programmatically} +Usage of the API to create & populate a structure with +members of different types. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_structure_programmatically.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_structure_programmatically.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.BTF_BYTE` +* `ida_typeinf.BTF_DOUBLE` +* `ida_typeinf.BTF_FLOAT` +* `ida_typeinf.BTF_INT` +* `ida_typeinf.BTF_INT128` +* `ida_typeinf.BTF_INT16` +* `ida_typeinf.BTF_INT64` +* `ida_typeinf.BTF_TBYTE` +* `ida_typeinf.BTF_UINT32` +* `ida_typeinf.FRB_NUMO` +* `ida_typeinf.NTF_TYPE` +* `ida_typeinf.PRTYPE_DEF` +* `ida_typeinf.PRTYPE_MULTI` +* `ida_typeinf.PRTYPE_TYPE` +* `ida_typeinf.del_named_type` +* `ida_typeinf.idc_parse_types` +* `ida_typeinf.tinfo_errstr` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udm_t` +* `ida_typeinf.udt_type_data_t` +* `ida_typeinf.value_repr_t` + +*** + + +### Create a union {#create_union_by_member} +The goal of this script is to demonstrate some usage of the type API. +In this script, we create a union by building it member after member. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_union_by_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_union_by_member.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.BTF_CHAR` +* `ida_typeinf.BTF_FLOAT` +* `ida_typeinf.BTF_INT32` +* `ida_typeinf.BTF_UNION` +* `ida_typeinf.NTF_TYPE` +* `ida_typeinf.PRTYPE_DEF` +* `ida_typeinf.PRTYPE_MULTI` +* `ida_typeinf.PRTYPE_TYPE` +* `ida_typeinf.del_named_type` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udm_t` +* `ida_typeinf.udt_type_data_t` + +*** + + +### Create a segment, and define (complex) data in it {#create_user_shared_data} +The goal of this script is to demonstrate some usage of the type API. +In this script, we show how to create, set type and name of +a user shared data region in an ntdll IDB: +* Load the `_KUSER_SHARED_DATA` data type from a type info + library shipped with IDA, and import it into the IDB's "local types" +* Create a data segment with UserSharedData as its name. +* Apply the type to the start of the newly created segment base + address. +* Set the address name. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [create_user_shared_data.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/create_user_shared_data.py) | | Intermediate | + +**APIs Used:** +* `ida_name.set_name` +* `ida_segment.add_segm_ex` +* `ida_segment.saRelPara` +* `ida_segment.scPub` +* `ida_segment.segment_t` +* `ida_segment.setup_selector` +* `ida_typeinf.TINFO_DEFINITE` +* `ida_typeinf.apply_tinfo` +* `ida_typeinf.free_til` +* `ida_typeinf.load_til` + +*** + + +### Utilities to detect structure gaps & alignment {#gap_size_align_snippet} +The goal of this script is to illustrate ways to detect gaps & alignments +in structures, from a structure name & (byte) offset. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [gap_size_align_snippet.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/gap_size_align_snippet.py) | | Intermediate | + +**APIs Used:** +* `ida_range.rangeset_t` + +*** + + +### Get member by offset, taking into account variable sized structures {#get_best_fit_member} +The goal of this script is to provide a way to figure out +what structure member, is most likely referenced by an offset. + +This also works for variable sized types. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [get_best_fit_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/get_best_fit_member.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udt_type_data_t` + +*** + + +### Get information about the "innermost" member of a structure {#get_innermost_member} +Assuming the 2 following types: + + struct b + { + int low; + int high; + }; + + struct a + { + int foo; + b b_instance; + int bar; + }; + +looking at an offset of 5 bytes inside an `a` instance, might be +interpreted as pointing somewhere inside member `b_instance`, of type `b`. +Alternatively, that same offset might be intprereted as pointing +somewhere inside `low`, of type `int`. + +We refer to that latter interpretation as "innermost", and this sample +shows how the API lets us "drill down" to retrieve that innermost member. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [get_innermost_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/get_innermost_member.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.get_idati` +* `ida_typeinf.parse_decls` + +*** + + +### Load a type library from a file, and then a type from it {#import_type_from_til} +The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * ask the user for a specific til to be lodaed + * if successfully loaded ask the user for a type name to be imported. + * append the type to the local types. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [import_type_from_til.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/import_type_from_til.py) | | Intermediate | + +**APIs Used:** +* `ida_kernwin.ask_str` +* `ida_typeinf.load_til` + +*** + + +### Inject a member in the middle of a structure {#insert_struct_member} +This sample will retrieve the type info object by its name, +find the member at the specified offset, and insert a +new member right before it + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [insert_struct_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/insert_struct_member.py) | | Intermediate | + +**APIs Used:** +* `ida_typeinf.BT_INT` +* `ida_typeinf.TERR_OK` +* `ida_typeinf.tinfo_t` + +*** + + +### List all xrefs to a function stack variable {#list_stkvar_xrefs} +Contrary to (in-memory) data & code xrefs, retrieving stack variables +xrefs requires a bit more work than just using ida_xref's first_to(), +next_to() (or higher level utilities such as idautils.XrefsTo) + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [list_stkvar_xrefs.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/list_stkvar_xrefs.py) | xrefs | Intermediate | + +**APIs Used:** +* `ida_bytes.get_flags` +* `ida_bytes.is_stkvar` +* `ida_frame.calc_stkvar_struc_offset` +* `ida_funcs.get_func` +* `ida_ida.UA_MAXOP` +* `ida_kernwin.AST_DISABLE_FOR_WIDGET` +* `ida_kernwin.AST_ENABLE_FOR_WIDGET` +* `ida_kernwin.BWN_DISASM` +* `ida_kernwin.action_desc_t` +* `ida_kernwin.action_handler_t` +* `ida_kernwin.get_current_viewer` +* `ida_kernwin.get_highlight` +* `ida_kernwin.get_screen_ea` +* `ida_kernwin.register_action` +* `ida_typeinf.tinfo_t` +* `ida_ua.decode_insn` +* `ida_ua.insn_t` + +*** + + +### Modify structure members attributes programmatically {#modify_struct_member} +This example shows how to access & modify certain less-obvious +attributes of structure members (pointer size, representation, ...) + +We will first create the structure without those, and then +show how to programmatically modify them. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [modify_struct_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/modify_struct_member.py) | | Intermediate | + +**APIs Used:** +* `ida_nalt.REFINFO_RVAOFF` +* `ida_nalt.REF_OFF64` +* `ida_typeinf.FRB_OFFSET` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.value_repr_t` + +*** + + +### List cross-references to function stack frame variables {#print_stkvar_xrefs} +The goal of this script is to demonstrate some usage of the type API. +In this script, we demonstrate how to list each stack variables +xref: +* Get the function object surrounding cursor location. +* Use this function to retrieve the corresponding frame object. +* For each frame element: + - Build the stack variable xref list + - Print it. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [print_stkvar_xrefs.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/print_stkvar_xrefs.py) | | Intermediate | + +**APIs Used:** +* `ida_frame.build_stkvar_xrefs` +* `ida_frame.get_func_frame` +* `ida_frame.xreflist_t` +* `ida_funcs.get_func` +* `ida_kernwin.get_screen_ea` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udt_type_data_t` +* `ida_xref.dr_R` +* `ida_xref.dr_W` + +*** + + +### Assign DOS/PE headers structures to a PE binary {#setpehdr} +The goal of this script is to demonstrate some usage of the type API. + +In this script, we: + +* load a PE64 file in binary mode +* import some types from the mssdk64 til +* apply these types at the correct ofsset in the DB +* finally, rebase the program based on the information stored + in the ImageBase field of the IMAGE_OPTIONAL_HEADER64. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [setpehdr.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/setpehdr.py) | | Intermediate | + +**APIs Used:** +* `ida_bytes.create_struct` +* `ida_bytes.get_dword` +* `ida_bytes.get_qword` +* `ida_bytes.get_word` +* `ida_hexrays.get_type` +* `ida_name.set_name` +* `ida_netnode.BADNODE` +* `ida_segment.MSF_FIXONCE` +* `ida_segment.rebase_program` +* `ida_typeinf.ADDTIL_DEFAULT` +* `ida_typeinf.BTF_STRUCT` +* `ida_typeinf.add_til` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udt_type_data_t` +* `idc.import_type` + +*** + + +### Recursively visit a type and its members {#visit_tinfo} +In this script, we show an example of tinfo_visitor_t to list +a user define type members, recursively. + +This scripts skips array & pointer members (by calling +`tinfo_visitor_t.prune_now()`) + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [visit_tinfo.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/visit_tinfo.py) | | Intermediate | + +**APIs Used:** +* `ida_netnode.BADNODE` +* `ida_typeinf.ADDTIL_DEFAULT` +* `ida_typeinf.TVST_DEF` +* `ida_typeinf.add_til` +* `ida_typeinf.array_type_data_t` +* `ida_typeinf.get_idati` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.tinfo_visitor_t` +* `idc.import_type` + +*** + + +### Change the name of an existing stack variable {#change_stkvar_name} +The goal of this script is to demonstrate some usage of the type API. +In this script, we demonstrate a way to change the name of a +stack variable: +* Get the function object surrounding cursor location. +* Use this function to retrieve the corresponding frame object. +* Find the frame member matching the given name. +* Using its offset in the frame structure object, calculate + the actual stack delta. +* Use the previous result to redefine the stack variable name if + it is not a special or argument member. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [change_stkvar_name.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/change_stkvar_name.py) | | Advanced | + +**APIs Used:** +* `ida_frame.define_stkvar` +* `ida_frame.get_func_frame` +* `ida_frame.is_funcarg_off` +* `ida_frame.is_special_frame_member` +* `ida_frame.soff_to_fpoff` +* `ida_funcs.get_func` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udm_t` +* `idc.here` + +*** + + +### Change the type & name of a function stack frame variable {#change_stkvar_type} +The goal of this script is to demonstrate some usage of the type API. + +In this script, we show a way to change the type and the name +of a stack variable. In this case we will take advantage of the +fact that RtlImageNtHeader calls RtlImageNtHeaderEx which takes +a pointer to PIMAGE_NT_HEADERS as its fourth parameter and, for +this, uses a stack variable of its caller. + +* Get the function object for RtlImageNtHeader. +* Iterate through the function item to localize the load of the + stack variable address before the call to RtlImageNtHeaderEx. We + keep this information. +* Localize the call and take advantage of the previoulsy stored + instruction to get the stack variable index in the frame. +* Set the type and rename the stack variable. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [change_stkvar_type.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/change_stkvar_type.py) | | Advanced | + +**APIs Used:** +* `ida_allins.NN_call` +* `ida_allins.NN_lea` +* `ida_frame.get_func_frame` +* `ida_funcs.func_item_iterator_t` +* `ida_funcs.get_func` +* `ida_funcs.get_func_name` +* `ida_ida.inf_get_procname` +* `ida_ida.inf_is_64bit` +* `ida_idaapi.BADADDR` +* `ida_name.get_name_ea` +* `ida_typeinf.BTF_STRUCT` +* `ida_typeinf.TERR_OK` +* `ida_typeinf.tinfo_t` +* `ida_ua.decode_insn` +* `ida_ua.insn_t` +* `ida_ua.o_reg` +* `idautils.procregs.r9.reg` + +*** + + +### Turn instruction operand into a structure offset {#operand_to_struct_member} +The goal of this script is to demonstrate some usage of the type API. +In this script, we: + * ask the user to choose the structure that will be used for + the conversion. + * build the structure path and call ida_bytes.op_stroff. In case + an enum is found a modal chooser is displayed in order to select + a member. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [operand_to_struct_member.py](https://github.com/HexRaysSA/IDAPython/tree//examples/types/operand_to_struct_member.py) | | Advanced | + +**APIs Used:** +* `ida_bytes.op_stroff` +* `ida_kernwin.Choose` +* `ida_kernwin.Choose.CHCOL_HEX` +* `ida_kernwin.Choose.CHCOL_PLAIN` +* `ida_kernwin.choose_struct` +* `ida_kernwin.get_opnum` +* `ida_kernwin.get_screen_ea` +* `ida_pro.tid_array` +* `ida_typeinf.STRMEM_OFFSET` +* `ida_typeinf.tinfo_t` +* `ida_typeinf.udm_t` +* `ida_typeinf.udt_type_data_t` +* `ida_ua.decode_insn` +* `ida_ua.insn_t` + +*** + + +### Code to be run right after IDAPython initialization {#idapythonrc} +The `idapythonrc.py` file: + + * %APPDATA%\Hex-Rays\IDA Pro\idapythonrc.py (on Windows) + * ~/.idapro/idapythonrc.py (on Linux & Mac) + +can contain any IDAPython code that will be run as soon as +IDAPython is done successfully initializing. + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [idapythonrc.py](https://github.com/HexRaysSA/IDAPython/tree//examples/misc/idapythonrc.py) | | Beginner | + + +*** + + +### Add functions to the IDC runtime, from IDAPython {#extend_idc} +You can add IDC functions to IDA, whose "body" consists of +IDAPython statements! + +We'll register a 'pow' function, available to all IDC code, +that when invoked will call back into IDAPython, and execute +the provided function body. + +After running this script, try switching to the IDC interpreter +(using the button on the lower-left corner of IDA) and executing +`pow(3, 7)` + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [extend_idc.py](https://github.com/HexRaysSA/IDAPython/tree//examples/misc/extend_idc.py) | | Intermediate | + +**APIs Used:** +* `ida_expr.VT_LONG` +* `ida_expr.add_idc_func` + +*** + + +### Add 64-bit (.idb->.i64) conversion capabilities to custom plugins {#py_cvt64_sample} +For more infortmation see SDK/plugins/cvt64_sample example + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [py_cvt64_sample.py](https://github.com/HexRaysSA/IDAPython/tree//examples/misc/cvt64/py_cvt64_sample.py) | | Advanced | + +**APIs Used:** +* `ida_idaapi.BADADDR` +* `ida_idaapi.BADADDR32` +* `ida_netnode.atag` +* `ida_netnode.htag` +* `ida_netnode.stag` + +*** + + +### Add merge functionality to a simple plugin {#py_mex1} This is a primitive plugin which asks user for some info and saves it for some addresses. @@ -2733,1038 +3565,113 @@ An IDA plugin may have two kinds of data with permanent storage: Also, see SDK/plugins/mex1 example -#### Keywords -IDP_Hooks plugin +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [py_mex1.py](https://github.com/HexRaysSA/IDAPython/tree//examples/misc/merge/py_mex1.py) | IDP_Hooks plugin | Advanced | -#### Uses -* ida_funcs.get_func -* ida_ida.IDI_ALTVAL -* ida_ida.IDI_CSTR -* ida_ida.IDI_SCALAR -* ida_ida.IDI_SUPVAL -* ida_ida.idbattr_info_t -* ida_idaapi.BADADDR -* ida_idaapi.PLUGIN_MOD -* ida_idaapi.PLUGIN_MULTI -* ida_idaapi.plugin_t -* ida_idaapi.plugmod_t -* ida_idp.IDP_Hooks -* ida_kernwin.Form -* ida_kernwin.Form.ChkGroupControl -* ida_kernwin.Form.StringInput -* ida_kernwin.get_screen_ea -* ida_merge.MERGE_KIND_END -* ida_merge.MERGE_KIND_NONE -* ida_merge.NDS_IS_STR -* ida_merge.NDS_MAP_IDX -* ida_merge.merge_handler_params_t -* ida_merge.merge_node_info_t -* ida_merge.moddata_diff_helper_t -* ida_mergemod.create_std_modmerge_handlers -* ida_netnode.BADNODE -* ida_netnode.SIZEOF_nodeidx_t -* ida_netnode.atag -* ida_netnode.netnode -* ida_netnode.stag +**APIs Used:** +* `ida_funcs.get_func` +* `ida_ida.IDI_ALTVAL` +* `ida_ida.IDI_CSTR` +* `ida_ida.IDI_SCALAR` +* `ida_ida.IDI_SUPVAL` +* `ida_ida.idbattr_info_t` +* `ida_idaapi.BADADDR` +* `ida_idaapi.PLUGIN_MOD` +* `ida_idaapi.PLUGIN_MULTI` +* `ida_idaapi.plugin_t` +* `ida_idaapi.plugmod_t` +* `ida_idp.IDP_Hooks` +* `ida_kernwin.Form` +* `ida_kernwin.Form.ChkGroupControl` +* `ida_kernwin.Form.StringInput` +* `ida_kernwin.get_screen_ea` +* `ida_merge.MERGE_KIND_END` +* `ida_merge.MERGE_KIND_NONE` +* `ida_merge.NDS_IS_STR` +* `ida_merge.NDS_MAP_IDX` +* `ida_merge.merge_handler_params_t` +* `ida_merge.merge_node_info_t` +* `ida_merge.moddata_diff_helper_t` +* `ida_mergemod.create_std_modmerge_handlers` +* `ida_netnode.BADNODE` +* `ida_netnode.SIZEOF_nodeidx_t` +* `ida_netnode.atag` +* `ida_netnode.netnode` +* `ida_netnode.stag` -
+*** -
-#### py_mex3 -
- This example uses the mex1 example and improves the user-interface for it. - -
- -#### Source code -merge/py_mex3.py - -#### Category -merge - -#### Description +### Implement merging functionality for custom plugins {#py_mex3} IDA Teams uses a chooser to display the merge conflicts. To fill the chooser columns IDA Teams uses the following methods from diff_source_t type: + * print_diffpos_name() * print_diffpos_details() + and UI hints from merge_handler_params_t type: + * ui_has_details() * ui_complex_details() * ui_complex_name() In general, chooser columns are filled as following: - columns.clear() - NAME = print_diffpos_name() - if ui_complex_name() - then - columns.add(split NAME by ui_split_char()) - else - columns[0] = NAME - if not ui_complex_details() - then - columns.add(print_diffpos_details()) + + columns.clear() + NAME = print_diffpos_name() + if ui_complex_name() + then + columns.add(split NAME by ui_split_char()) + else + columns[0] = NAME + if not ui_complex_details() + then + columns.add(print_diffpos_details()) Also, see SDK/plugins/mex3 example -#### Keywords -IDP_Hooks plugin - -#### Uses -* ida_funcs.get_func -* ida_ida.IDI_ALTVAL -* ida_ida.IDI_CSTR -* ida_ida.IDI_SCALAR -* ida_ida.IDI_SUPVAL -* ida_ida.idbattr_info_t -* ida_idaapi.BADADDR -* ida_idaapi.PLUGIN_MOD -* ida_idaapi.PLUGIN_MULTI -* ida_idaapi.plugin_t -* ida_idaapi.plugmod_t -* ida_idp.IDP_Hooks -* ida_kernwin.Form -* ida_kernwin.Form.ChkGroupControl -* ida_kernwin.Form.StringInput -* ida_kernwin.get_screen_ea -* ida_merge.MERGE_KIND_END -* ida_merge.MERGE_KIND_NONE -* ida_merge.MH_UI_COLONNAME -* ida_merge.MH_UI_COMMANAME -* ida_merge.MH_UI_NODETAILS -* ida_merge.NDS_IS_STR -* ida_merge.NDS_MAP_IDX -* ida_merge.create_nodeval_merge_handlers -* ida_merge.get_ea_diffpos_name -* ida_merge.merge_handler_params_t -* ida_merge.merge_node_helper_t -* ida_merge.merge_node_info_t -* ida_merge.moddata_diff_helper_t -* ida_mergemod.create_std_modmerge_handlers -* ida_nalt.node2ea -* ida_netnode.BADNODE -* ida_netnode.SIZEOF_nodeidx_t -* ida_netnode.atag -* ida_netnode.netnode -* ida_netnode.stag - -
- -
- -## Category: pyqt - -#### inject_command -
- Injecting commands in the "Output" window - -
- -#### Source code -pyqt/inject_command.py - -#### Category -pyqt - -#### Description -This example illustrates how one can execute commands in the -"Output" window, from their own widgets. - -A few notes: - -* the original, underlying `cli:Execute` action, that has to be - triggered for the code present in the input field to execute - and be placed in the history, requires that the input field - has focus (otherwise it simply won't do anything.) -* this, in turn, forces us to do "delayed" execution of that action, - hence the need for a `QTimer` -* the IDA/SWiG 'TWidget' type that we retrieve through - `ida_kernwin.find_widget`, is not the same type as a - `QtWidgets.QWidget`. We therefore need to convert it using - `ida_kernwin.PluginForm.TWidgetToPyQtWidget` - -#### Uses -* ida_kernwin.PluginForm.TWidgetToPyQtWidget -* ida_kernwin.disabled_script_timeout_t -* ida_kernwin.find_widget -* ida_kernwin.process_ui_action - -
- -
- -#### paint_over_graph -
- Custom painting on top of graph view edges - -
- -#### Source code -pyqt/paint_over_graph.py - -#### Category -pyqt - -#### Description -This sample registers an action enabling painting of a recognizable -string of text over horizontal nodes edge sections beyond a -satisfying size threshold. - -In a disassembly view, open the context menu and select -"Paint on edges". This should work for both graph disassembly, -and proximity browser. - -Using an "event filter", we will intercept paint events -targeted at the disassembly view, let it paint itself, and -then add our own markers along. - -#### Keywords -ctxmenu UI_Hooks - -#### Uses -* ida_graph.edge_t -* ida_graph.get_graph_viewer -* ida_graph.get_viewer_graph -* ida_graph.point_t -* ida_graph.viewer_get_gli -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_DISASM -* ida_kernwin.PluginForm.FormToPyQtWidget -* ida_kernwin.UI_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.get_widget_type -* ida_kernwin.register_action -* ida_moves.graph_location_info_t - -
- -
- -#### paint_over_navbar -
- Custom painting on top of the navigation band - -
- -#### Source code -pyqt/paint_over_navbar.py - -#### Category -pyqt - -#### Description -Using an "event filter", we will intercept paint events -targeted at the navigation band widget, let it paint itself, -and then add our own markers on top. - -#### Uses -* ida_kernwin.PluginForm.FormToPyQtWidget -* ida_kernwin.get_navband_pixel -* ida_kernwin.open_navband_window -* ida_segment.get_segm_qty -* ida_segment.getnseg -* idc.here - -
- -
- -#### populate_pluginform_with_pyqt_widgets -
- Adding PyQt5 widgets into an `ida_kernwin.PluginForm` - -
- -#### Source code -pyqt/populate_pluginform_with_pyqt_widgets.py - -#### Category -pyqt - -#### Description -Using `ida_kernwin.PluginForm.FormToPyQtWidget`, this script -converts IDA's own dockable widget into a type that is -recognized by PyQt5, which then enables populating it with -regular Qt widgets. - -#### Uses -* ida_kernwin.PluginForm - -
- -
- -## Category: uihooks - -#### func_chooser_coloring -
- Using `ida_kernwin.UI_Hooks.get_chooser_item_attrs` to override some defaults - -
- -#### Source code -uihooks/func_chooser_coloring.py - -#### Category -uihooks - -#### Description -Color the function in the Function window according to its size. -The larger the function, the darker the color. - -#### Keywords -UI_Hooks - -#### Uses -* ida_funcs.get_func -* ida_kernwin.UI_Hooks -* ida_kernwin.enable_chooser_item_attrs - -
- -
- -#### lines_rendering -
- Dynamically colorize lines backgrounds (or parts of them) - -
- -#### Source code -uihooks/lines_rendering.py - -#### Category -uihooks - -#### Description -Shows how one can dynamically alter the lines background -rendering (as opposed to, say, using ida_nalt.set_item_color()), -and also shows how that rendering can be limited to just a few -glyphs, not the whole line. - -#### Keywords -UI_Hooks - -#### Uses -* ida_bytes.next_head -* ida_idaapi.BADADDR -* ida_kernwin.CK_EXTRA1 -* ida_kernwin.CK_EXTRA10 -* ida_kernwin.CK_EXTRA11 -* ida_kernwin.CK_EXTRA12 -* ida_kernwin.CK_EXTRA13 -* ida_kernwin.CK_EXTRA14 -* ida_kernwin.CK_EXTRA15 -* ida_kernwin.CK_EXTRA16 -* ida_kernwin.CK_EXTRA2 -* ida_kernwin.CK_EXTRA3 -* ida_kernwin.CK_EXTRA4 -* ida_kernwin.CK_EXTRA5 -* ida_kernwin.CK_EXTRA6 -* ida_kernwin.CK_EXTRA7 -* ida_kernwin.CK_EXTRA8 -* ida_kernwin.CK_EXTRA9 -* ida_kernwin.CK_TRACE -* ida_kernwin.CK_TRACE_OVL -* ida_kernwin.LROEF_CPS_RANGE -* ida_kernwin.UI_Hooks -* ida_kernwin.get_screen_ea -* ida_kernwin.line_rendering_output_entry_t -* ida_kernwin.refresh_idaview_anyway - -
- -
- -#### log_misc_events -
- Being notified, and logging a few UI events - -
- -#### Source code -uihooks/log_misc_events.py - -#### Category -uihooks - -#### Description -Hooks to be notified about certain UI events, and -dump their information to the "Output" window - -#### Keywords -UI_Hooks - -#### Uses -* ida_kernwin.UI_Hooks - -
- -
- -#### prevent_jump -
- Taking precedence over actions - -
- -#### Source code -uihooks/prevent_jump.py - -#### Category -uihooks - -#### Description -Using `ida_kernwin.UI_Hooks.preprocess_action`, it is possible -to respond to a command instead of the action that would -otherwise do it. - -#### Keywords -UI_Hooks - -#### Uses -* ida_kernwin.UI_Hooks - -
- -
- -## Category: widgets - -#### add_menus -
- Adding custom menus to IDA - -
- -#### Source code -widgets/misc/add_menus.py - -#### Category -widgets - -#### Description -It is possible to add custom menus to IDA, either at the -toplevel (i.e., into the menubar), or as submenus of existing -menus. - -Notes: - - * the same action can be present in more than 1 menu - * this example does not deal with context menus - -#### Keywords -actions - -#### Uses -* ida_kernwin.AST_ENABLE_ALWAYS -* ida_kernwin.SETMENU_INS -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_menu -* ida_kernwin.create_menu -* ida_kernwin.register_action - -
- -
- -#### askusingform -
- Non-trivial uses of the `ida_kernwin.Form` helper class - -
- -#### Source code -widgets/forms/askusingform.py - -#### Category -widgets - -#### Description -How to query for complex user input, using IDA's built-in forms. - -Note: while this example produces full-fledged forms for complex input, -simpler types of inputs might can be retrieved by using -`ida_kernwin.ask_str` and similar functions. - -#### Keywords -forms - -#### Uses -* ida_kernwin.Choose -* ida_kernwin.Choose.CH_MULTI -* ida_kernwin.Form -* ida_kernwin.PluginForm.FORM_TAB -* ida_kernwin.ask_str - -
- -
- -#### choose -
- A widget showing data in a tabular fashion - -
- -#### Source code -widgets/tabular_views/custom/choose.py - -#### Category -widgets - -#### Description -Shows how to subclass the ida_kernwin.Choose class to -show data organized in a simple table. -In addition, registers a couple actions that can be applied to it. - -#### Keywords -actions chooser ctxmenu - -#### Uses -* Choose -* Choose.ALL_CHANGED -* Choose.CH_CAN_DEL -* Choose.CH_CAN_EDIT -* Choose.CH_CAN_INS -* Choose.CH_CAN_REFRESH -* Choose.CH_RESTORE -* Choose.NOTHING_CHANGED -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.is_chooser_widget -* ida_kernwin.register_action -* ida_kernwin.unregister_action - -#### See also -* [choose_multi](#choose_multi) -* [chooser_with_folders](#chooser_with_folders) - -
- -
- -#### choose_multi -
- A widget showing data in a tabular fashion, providing multiple selection - -
- -#### Source code -widgets/tabular_views/custom/choose_multi.py - -#### Category -widgets - -#### Description -Similar to choose, but with multiple selection - -#### Keywords -actions chooser - -#### Uses -* Choose -* Choose.ALL_CHANGED -* Choose.CHCOL_HEX -* Choose.CH_MULTI -* Choose.NOTHING_CHANGED - -#### See also -* [choose](#choose) -* [chooser_with_folders](#chooser_with_folders) - -
- -
- -#### chooser_with_folders -
- A widget that can show tabular data either as a simple table, or with a tree-like structure. - -
- -#### Source code -widgets/tabular_views/custom/chooser_with_folders.py - -#### Category -widgets - -#### Description -By adding the necessary bits to a ida_kernwin.Choose subclass, -IDA can show the otherwise tabular data, in a tree-like fashion. - -The important bits to enable this are: - - * ida_dirtree.dirspec_t (and my_dirspec_t) - * ida_kernwin.CH_HAS_DIRTREE - * ida_kernwin.Choose.OnGetDirTree - * ida_kernwin.Choose.OnIndexToInode - -#### Keywords -actions chooser folders - -#### Uses -* ida_dirtree.DTE_OK -* ida_dirtree.direntry_t -* ida_dirtree.direntry_t.BADIDX -* ida_dirtree.dirspec_t -* ida_dirtree.dirtree_t -* ida_dirtree.dirtree_t.isdir -* ida_kernwin.CH_CAN_DEL -* ida_kernwin.CH_CAN_EDIT -* ida_kernwin.CH_CAN_INS -* ida_kernwin.CH_HAS_DIRTREE -* ida_kernwin.CH_MULTI -* ida_kernwin.Choose -* ida_kernwin.Choose.ALL_CHANGED -* ida_kernwin.Choose.CHCOL_DRAGHINT -* ida_kernwin.Choose.CHCOL_INODENAME -* ida_kernwin.Choose.CHCOL_PLAIN -* ida_kernwin.ask_str -* ida_netnode.BADNODE -* ida_netnode.netnode - -#### See also -* [choose](#choose) -* [choose_multi](#choose_multi) - -
- -
- -#### custom_graph_with_actions -
- Drawing custom graphs - -
- -#### Source code -widgets/graphs/custom_graph_with_actions.py - -#### Category -widgets - -#### Description -Showing custom graphs, using `ida_graph.GraphViewer`. In addition, -show how to write actions that can be performed on those. - -#### Keywords -actions graph View_Hooks - -#### Uses -* ida_funcs.get_func -* ida_funcs.get_func_name -* ida_graph.GraphViewer -* ida_graph.get_graph_viewer -* ida_graph.screen_graph_selection_t -* ida_graph.viewer_get_selection -* ida_idp.is_call_insn -* ida_kernwin.AST_ENABLE_ALWAYS -* ida_kernwin.View_Hooks -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_dynamic_action_to_popup -* ida_kernwin.get_screen_ea -* ida_ua.decode_insn -* ida_ua.insn_t -* ida_xref.XREF_FAR -* ida_xref.xrefblk_t - -
- -
- -#### custom_viewer -
- Create custom listings in IDA - -
- -#### Source code -widgets/listings/custom_viewer.py - -#### Category -widgets - -#### Description -How to create simple listings, that will share many of the features -as the built-in IDA widgets (highlighting, copy & paste, -notifications, ...) - -In addition, creates actions that will be bound to the -freshly-created widget (using `ida_kernwin.attach_action_to_popup`.) - -#### Keywords -actions ctxmenu listing - -#### Uses -* ida_kernwin.AST_ENABLE_ALWAYS -* ida_kernwin.IK_DELETE -* ida_kernwin.IK_ESCAPE -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.ask_long -* ida_kernwin.ask_str -* ida_kernwin.attach_action_to_popup -* ida_kernwin.register_action -* ida_kernwin.simplecustviewer_t -* ida_kernwin.simplecustviewer_t.Create -* ida_kernwin.simplecustviewer_t.Show -* ida_kernwin.unregister_action -* ida_lines.COLOR_DEFAULT -* ida_lines.COLOR_DNAME -* ida_lines.COLSTR -* ida_lines.SCOLOR_PREFIX -* ida_lines.SCOLOR_VOIDOP - -
- -
- -#### func_chooser -
- An alternative view over the list of functions - -
- -#### Source code -widgets/tabular_views/custom/func_chooser.py - -#### Category -widgets - -#### Description -Partially re-implements the "Functions" widget present in -IDA, with a custom widget. - -#### Keywords -chooser functions - -#### Uses -* ida_funcs.get_func_name -* ida_kernwin.Choose -* ida_kernwin.Choose.ALL_CHANGED -* ida_kernwin.Choose.CHCOL_FNAME -* ida_kernwin.Choose.CHCOL_HEX -* ida_kernwin.Choose.CHCOL_PLAIN -* ida_kernwin.get_icon_id_by_name -* idautils.Functions -* idc.del_func - -#### See also -* [choose](#choose) -* [choose_multi](#choose_multi) -* [chooser_with_folders](#chooser_with_folders) - -
- -
- -#### jump_next_comment -
- Implement a "jump to next comment" action within IDA's disassembly view. - -
- -#### Source code -widgets/listings/jump_next_comment.py - -#### Category -widgets - -#### Description -We want our action not only to find the next line containing a comment, -but to also place the cursor at the right horizontal position. - -To find that position, we will have to inspect the text that IDA -generates, looking for the start of a comment. -However, we won't be looking for a comment "prefix" (e.g., "; "), -as that would be too fragile. - -Instead, we will look for special "tags" that IDA injects into textual -lines, and that bear semantic information. - -Those tags are primarily used for rendering (i.e., switching colors), -but can also be very handy for spotting tokens of interest (registers, -addresses, comments, prefixes, instruction mnemonics, ...) - -#### Shortcut -Ctrl+Alt+C - -#### Keywords -actions idaview - -#### Uses -* ida_bytes.next_head -* ida_idaapi.BADADDR -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_DISASM -* ida_kernwin.CVNF_LAZY -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.custom_viewer_jump -* ida_kernwin.get_custom_viewer_location -* ida_kernwin.place_t_as_idaplace_t -* ida_kernwin.register_action -* ida_kernwin.unregister_action -* ida_lines.SCOLOR_AUTOCMT -* ida_lines.SCOLOR_ON -* ida_lines.SCOLOR_REGCMT -* ida_lines.SCOLOR_RPTCMT -* ida_lines.generate_disassembly -* ida_lines.tag_strlen -* ida_moves.lochist_entry_t - -#### See also -* [save_and_restore_listing_pos](#save_and_restore_listing_pos) - -
- -
- -#### lazy_loaded_chooser -
- - -
- -#### Source code -widgets/tabular_views/custom/lazy_loaded_chooser.py - -#### Category -widgets - -#### Description - - -
- -
- -#### save_and_restore_listing_pos -
- Save, and then restore, positions in a listing - -
- -#### Source code -widgets/listings/save_and_restore_listing_pos.py - -#### Category -widgets - -#### Description -Shows how it is possible re-implement IDA's bookmark capability, -using 2 custom actions: one action saves the current location, -and the other restores it. - -Note that, contrary to actual bookmarks, this example: - - * remembers only 1 saved position - * doesn't save that position in the IDB (and therefore cannot - be restored if IDA is closed & reopened.) - -#### Shortcuts -Ctrl+Shift+O Ctrl+Shift+S - -#### Keywords -actions listing - -#### Uses -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_CUSTVIEW -* ida_kernwin.BWN_DISASM -* ida_kernwin.BWN_ENUMS -* ida_kernwin.BWN_PSEUDOCODE -* ida_kernwin.BWN_STRUCTS -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.custom_viewer_jump -* ida_kernwin.find_widget -* ida_kernwin.get_custom_viewer_location -* ida_kernwin.register_action -* ida_kernwin.unregister_action -* ida_moves.lochist_entry_t - -#### See also -* [jump_next_comment](#jump_next_comment) - -
- -
- -#### show_and_hide_waitbox -
- Showing, updating & hiding the progress dialog - -
- -#### Source code -widgets/waitbox/show_and_hide_waitbox.py - -#### Category -widgets - -#### Description -Using the progress dialog (aka 'wait box') primitives. - -#### Keywords -actions - -#### Uses -* ida_hexrays.decompile -* ida_kernwin.hide_wait_box -* ida_kernwin.replace_wait_box -* ida_kernwin.show_wait_box -* ida_kernwin.user_cancelled -* idautils.Functions - -
- -
- -#### show_selected_strings -
- Retrieve the strings that are selected in the "Strings" window. - -
- -#### Source code -widgets/tabular_views/string_window/show_selected_strings.py - -#### Category -widgets - -#### Description -In IDA it's possible to write actions that can be applied even to -core (i.e., "standard") widgets. The actions in this example use the -action "context" to know what the current selection is. - -This example shows how you can either retrieve string literals data -directly from the chooser (`ida_kernwin.get_chooser_data`), or -by querying the IDB (`ida_bytes.get_strlit_contents`) - -#### Shortcuts -Ctrl+Shift+K Ctrl+Shift+S - -#### Keywords -actions ctxmenu - -#### Uses -* ida_bytes.get_strlit_contents -* ida_idaapi.BADADDR -* ida_kernwin.AST_DISABLE_FOR_WIDGET -* ida_kernwin.AST_ENABLE_FOR_WIDGET -* ida_kernwin.BWN_STRINGS -* ida_kernwin.action_desc_t -* ida_kernwin.action_handler_t -* ida_kernwin.attach_action_to_popup -* ida_kernwin.find_widget -* ida_kernwin.get_chooser_data -* ida_kernwin.open_strings_window -* ida_kernwin.register_action -* ida_kernwin.unregister_action -* ida_strlist.get_strlist_item -* ida_strlist.string_info_t - -#### See also -* [list_strings](#list_strings) - -
- -
- -#### sync_two_graphs -
- Follow the movements of a disassembly graph, in another. - -
- -#### Source code -widgets/graphs/sync_two_graphs.py - -#### Category -widgets - -#### Description -Since it is possible to be notified of movements that happen -take place in a widget, it's possible to "replay" those -movements in another. - -In this case, "IDA View-B" (will be opened if necessary) will -show the same contents as "IDA View-A", slightly zoomed out. - -#### Keywords -graph idaview - -#### Uses -* ida_graph.GLICTL_CENTER -* ida_graph.viewer_fit_window -* ida_graph.viewer_get_gli -* ida_graph.viewer_set_gli -* ida_kernwin.DP_RIGHT -* ida_kernwin.IDAViewWrapper -* ida_kernwin.MFF_FAST -* ida_kernwin.TCCRT_GRAPH -* ida_kernwin.execute_sync -* ida_kernwin.find_widget -* ida_kernwin.get_custom_viewer_place -* ida_kernwin.jumpto -* ida_kernwin.open_disasm_window -* ida_kernwin.set_dock_pos -* ida_kernwin.set_view_renderer_type -* ida_moves.graph_location_info_t - -#### See also -* [wrap_idaview](#wrap_idaview) - -
- -
- -#### wrap_idaview -
- Manipulate IDAView and graph - -
- -#### Source code -widgets/idaview/wrap_idaview.py - -#### Category -widgets - -#### Description -This is an example illustrating how to manipulate an existing IDA-provided -view (and thus possibly its graph), in Python. - -#### Keywords -graph idaview - -#### Uses -* ida_graph.NIF_BG_COLOR -* ida_graph.NIF_FRAME_COLOR -* ida_graph.node_info_t -* ida_kernwin.IDAViewWrapper -* ida_kernwin.MFF_FAST -* ida_kernwin.TCCRT_FLAT -* ida_kernwin.TCCRT_GRAPH -* ida_kernwin.execute_sync - -#### See also -* [custom_graph_with_actions](#custom_graph_with_actions) -* [sync_two_graphs](#sync_two_graphs) - -
- -
+| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [py_mex3.py](https://github.com/HexRaysSA/IDAPython/tree//examples/misc/merge/py_mex3.py) | IDP_Hooks plugin | Advanced | + +**APIs Used:** +* `ida_funcs.get_func` +* `ida_ida.IDI_ALTVAL` +* `ida_ida.IDI_CSTR` +* `ida_ida.IDI_SCALAR` +* `ida_ida.IDI_SUPVAL` +* `ida_ida.idbattr_info_t` +* `ida_idaapi.BADADDR` +* `ida_idaapi.PLUGIN_MOD` +* `ida_idaapi.PLUGIN_MULTI` +* `ida_idaapi.plugin_t` +* `ida_idaapi.plugmod_t` +* `ida_idp.IDP_Hooks` +* `ida_kernwin.Form` +* `ida_kernwin.Form.ChkGroupControl` +* `ida_kernwin.Form.StringInput` +* `ida_kernwin.get_screen_ea` +* `ida_merge.MERGE_KIND_END` +* `ida_merge.MERGE_KIND_NONE` +* `ida_merge.MH_UI_COLONNAME` +* `ida_merge.MH_UI_COMMANAME` +* `ida_merge.MH_UI_NODETAILS` +* `ida_merge.NDS_IS_STR` +* `ida_merge.NDS_MAP_IDX` +* `ida_merge.create_nodeval_merge_handlers` +* `ida_merge.get_ea_diffpos_name` +* `ida_merge.merge_handler_params_t` +* `ida_merge.merge_node_helper_t` +* `ida_merge.merge_node_info_t` +* `ida_merge.moddata_diff_helper_t` +* `ida_mergemod.create_std_modmerge_handlers` +* `ida_nalt.node2ea` +* `ida_netnode.BADNODE` +* `ida_netnode.SIZEOF_nodeidx_t` +* `ida_netnode.atag` +* `ida_netnode.netnode` +* `ida_netnode.stag` + +*** diff --git a/examples/cvt64/py_cvt64_sample.py b/examples/misc/cvt64/py_cvt64_sample.py similarity index 91% rename from examples/cvt64/py_cvt64_sample.py rename to examples/misc/cvt64/py_cvt64_sample.py index 11ff7e8..507fb6b 100755 --- a/examples/cvt64/py_cvt64_sample.py +++ b/examples/misc/cvt64/py_cvt64_sample.py @@ -1,8 +1,10 @@ """ -summary: This file contains the CVT64 examples. +summary: add 64-bit (.idb->.i64) conversion capabilities to custom plugins description: For more infortmation see SDK/plugins/cvt64_sample example + +level: advanced """ import idaapi @@ -29,7 +31,7 @@ class idp_listener_t(idaapi.IDP_Hooks): return 1 if name == HASH_ADDRESS: address = helper.hashval_long(name) - if address == ida_idaapi.BADADDR32: + if address == ida_idaapi.BADADDR32: address = ida_idaapi.BADADDR helper.hashset_idx(name, address) return 1 @@ -38,14 +40,14 @@ class idp_listener_t(idaapi.IDP_Hooks): def ev_cvt64_supval(self, node, tag, idx, data): helper = idaapi.netnode(SAMPLE_NETNODE_NAME) if helper == node: - if tag == ida_netnode.stag and idx == ida_idaapi.BADADDR32: + if tag == ida_netnode.stag and idx == ida_idaapi.BADADDR32: helper.supset(DEVICE_INDEX, data) return 1 if tag == ida_netnode.atag and len(data): - if idx == ida_idaapi.BADADDR32: + if idx == ida_idaapi.BADADDR32: idx = IDPFLAGS_INDEX val = int.from_bytes(data, 'little') - if val == ida_idaapi.BADADDR32: + if val == ida_idaapi.BADADDR32: val = ida_idaapi.BADADDR helper.altset(idx, val) return 1 diff --git a/examples/core/extend_idc.py b/examples/misc/extend_idc.py similarity index 89% rename from examples/core/extend_idc.py rename to examples/misc/extend_idc.py index 982006c..e299f29 100644 --- a/examples/core/extend_idc.py +++ b/examples/misc/extend_idc.py @@ -1,5 +1,5 @@ """ -summary: add functions to the IDC runtime from IDAPython +summary: add functions to the IDC runtime, from IDAPython description: You can add IDC functions to IDA, whose "body" consists of @@ -12,6 +12,8 @@ description: After running this script, try switching to the IDC interpreter (using the button on the lower-left corner of IDA) and executing `pow(3, 7)` + +level: intermediate """ import ida_expr diff --git a/examples/core/idapythonrc.py b/examples/misc/idapythonrc.py similarity index 97% rename from examples/core/idapythonrc.py rename to examples/misc/idapythonrc.py index f2cc0d2..160a895 100644 --- a/examples/core/idapythonrc.py +++ b/examples/misc/idapythonrc.py @@ -1,4 +1,4 @@ -""" +r""" summary: code to be run right after IDAPython initialization description: @@ -9,6 +9,8 @@ description: can contain any IDAPython code that will be run as soon as IDAPython is done successfully initializing. + +level: beginner """ # Add your favourite script to ScriptBox for easy access diff --git a/examples/merge/py_mex1.py b/examples/misc/merge/py_mex1.py similarity index 92% rename from examples/merge/py_mex1.py rename to examples/misc/merge/py_mex1.py index c1c6a88..1beef4d 100644 --- a/examples/merge/py_mex1.py +++ b/examples/misc/merge/py_mex1.py @@ -1,7 +1,7 @@ # pylint: disable=line-too-long,invalid-name,import-error """ -summary: add merge functionality to a simple plugin, example 1 +summary: add merge functionality to a simple plugin description: This is a primitive plugin which asks user for some info and saves it for @@ -16,6 +16,8 @@ description: To describe them we will use the merge_node_info_t type. Also, see SDK/plugins/mex1 example + +level: advanced """ @@ -28,6 +30,18 @@ import ida_merge import ida_mergemod import ida_idp +# -------------------------------------------------------------------------- +# netnode to store plugin data +MEX_NODE_NAME = "$ idapython mex1" +# user input +MEX_OPTION_FLAGS_IDX = ida_idaapi.BADADDR & -1 # atag +MEX_OPTION_IDENT_IDX = ida_idaapi.BADADDR & -2 # stag +# EA marks +MEX_EA_TAG = 'm' + +# mex_ctx_t::flags bits +MEX_FLAGS_0 = 0x01 +MEX_FLAGS_1 = 0x02 # -------------------------------------------------------------------------- class idp_listener_t(ida_idp.IDP_Hooks): @@ -62,19 +76,26 @@ class idp_listener_t(ida_idp.IDP_Hooks): return 0 + def ev_cvt64_supval(self, node, tag, idx, data): + """ + Converter to i64 database + """ + nn = ida_netnode.netnode(MEX_NODE_NAME) + if nn == node: + if tag == ida_netnode.stag: + nn.supset(MEX_OPTION_IDENT_IDX, data) + return 1 + if tag == ida_netnode.atag and len(data): + val = int.from_bytes(data, 'little') + nn.altset(MEX_OPTION_FLAGS_IDX, val) + return 1 + if chr(tag) == MEX_EA_TAG: + nn.supset(idx, data, MEX_EA_TAG) + return 1 + return 0 + + # -------------------------------------------------------------------------- -# netnode to store plugin data -MEX_NODE_NAME = "$ idapython mex1" -# user input -MEX_OPTION_FLAGS_IDX = ida_idaapi.BADADDR & -1 # atag -MEX_OPTION_IDENT_IDX = ida_idaapi.BADADDR & -2 # stag -# EA marks -MEX_EA_TAG = 'm' - -# mex_ctx_t::flags bits -MEX_FLAGS_0 = 0x01 -MEX_FLAGS_1 = 0x02 - class mex_ctx_t(ida_idaapi.plugmod_t): """ Regular plugin implementation below. diff --git a/examples/merge/py_mex3.py b/examples/misc/merge/py_mex3.py similarity index 91% rename from examples/merge/py_mex3.py rename to examples/misc/merge/py_mex3.py index dac0393..cb7dd21 100644 --- a/examples/merge/py_mex3.py +++ b/examples/misc/merge/py_mex3.py @@ -1,31 +1,37 @@ # pylint: disable=line-too-long,invalid-name,import-error """ -summary: This example uses the mex1 example and improves the user-interface for it. +summary: implement merging functionality for custom plugins description: IDA Teams uses a chooser to display the merge conflicts. To fill the chooser columns IDA Teams uses the following methods from diff_source_t type: + * print_diffpos_name() * print_diffpos_details() + and UI hints from merge_handler_params_t type: + * ui_has_details() * ui_complex_details() * ui_complex_name() In general, chooser columns are filled as following: - columns.clear() - NAME = print_diffpos_name() - if ui_complex_name() - then - columns.add(split NAME by ui_split_char()) - else - columns[0] = NAME - if not ui_complex_details() - then - columns.add(print_diffpos_details()) + + columns.clear() + NAME = print_diffpos_name() + if ui_complex_name() + then + columns.add(split NAME by ui_split_char()) + else + columns[0] = NAME + if not ui_complex_details() + then + columns.add(print_diffpos_details()) Also, see SDK/plugins/mex3 example + +level: advanced """ @@ -40,6 +46,19 @@ import ida_idp import ida_nalt +# -------------------------------------------------------------------------- +# netnode to store plugin data +MEX_NODE_NAME = "$ idapython mex3" +# user input +MEX_OPTION_FLAGS_IDX = ida_idaapi.BADADDR & -1 # atag +MEX_OPTION_IDENT_IDX = ida_idaapi.BADADDR & -2 # stag +# EA marks +MEX_EA_TAG = 'm' + +# mex_ctx_t::flags bits +MEX_FLAGS_0 = 0x01 +MEX_FLAGS_1 = 0x02 + # -------------------------------------------------------------------------- class idp_listener_t(ida_idp.IDP_Hooks): """ @@ -73,19 +92,26 @@ class idp_listener_t(ida_idp.IDP_Hooks): return 0 + def ev_cvt64_supval(self, node, tag, idx, data): + """ + Converter to i64 database + """ + nn = ida_netnode.netnode(MEX_NODE_NAME) + if nn == node: + if tag == ida_netnode.stag: + nn.supset(MEX_OPTION_IDENT_IDX, data) + return 1 + if tag == ida_netnode.atag and len(data): + val = int.from_bytes(data, 'little') + nn.altset(MEX_OPTION_FLAGS_IDX, val) + return 1 + if chr(tag) == MEX_EA_TAG: + nn.supset(idx, data, MEX_EA_TAG) + return 1 + return 0 + + # -------------------------------------------------------------------------- -# netnode to store plugin data -MEX_NODE_NAME = "$ idapython mex3" -# user input -MEX_OPTION_FLAGS_IDX = ida_idaapi.BADADDR & -1 # atag -MEX_OPTION_IDENT_IDX = ida_idaapi.BADADDR & -2 # stag -# EA marks -MEX_EA_TAG = 'm' - -# mex_ctx_t::flags bits -MEX_FLAGS_0 = 0x01 -MEX_FLAGS_1 = 0x02 - class mex_ctx_t(ida_idaapi.plugmod_t): """ Regular plugin implementation below. diff --git a/examples/types/apply_callee_tinfo.py b/examples/types/apply_callee_tinfo.py new file mode 100644 index 0000000..9c63554 --- /dev/null +++ b/examples/types/apply_callee_tinfo.py @@ -0,0 +1,49 @@ +""" +summary: apply function prototype to call sites + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * Open the private type libary. + * Load its declaration in the type library by parsing its declaration and + keep the return tuple for future use. + * Deserialize the type info stored in the returned tuple. + * Get the address of the function. + * Get the address of the code reference to the function and apply + the type info there. + +level: intermediate +""" +import ida_typeinf +import ida_name +import idautils +import ida_idaapi + +def apply_type_info(callee_name, callee_prototype_decl): + til = ida_typeinf.get_idati() + parse_result = ida_typeinf.idc_parse_decl(til, callee_prototype_decl, ida_typeinf.PT_REPLACE) + if parse_result is None: + print("Failed to parse declaration.") + return + + name, types, fields, *rest = parse_result + tif = ida_typeinf.tinfo_t() + if not tif.deserialize(til, types, fields): + print("Failed to deserialize type info.") + return + + ea = ida_name.get_name_ea(ida_idaapi.BADADDR, callee_name) + if ea == ida_idaapi.BADADDR: + print(f"{callee_name} function not found.") + return + + print(f"{callee_name} function found @ {ea:x}.") + for xref in idautils.CodeRefsTo(ea, 0): + if ida_typeinf.apply_callee_tinfo(xref, tif): + print(f"\tApplied type info @ {xref:x}.") + else: + print(f"Could not apply type info @ {xref:x}") + +apply_type_info( + "KdInitSystem", + "NTSTATUS __fastcall KdInitSystem(ULONG BootPhase, _LOADER_PARAMETER_BLOCK *LoaderBlock);") diff --git a/examples/types/change_stkvar_name.py b/examples/types/change_stkvar_name.py new file mode 100644 index 0000000..0703eb2 --- /dev/null +++ b/examples/types/change_stkvar_name.py @@ -0,0 +1,56 @@ +""" +summary: change the name of an existing stack variable + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we demonstrate a way to change the name of a + stack variable: + * Get the function object surrounding cursor location. + * Use this function to retrieve the corresponding frame object. + * Find the frame member matching the given name. + * Using its offset in the frame structure object, calculate + the actual stack delta. + * Use the previous result to redefine the stack variable name if + it is not a special or argument member. + +level: advanced +""" +import ida_funcs +import ida_frame +import ida_typeinf +import idc + +def rename_stkvar(func_ea, old_name, new_name): + func = ida_funcs.get_func(func_ea) + if func is None: + print("Please position the cursor inside a function.") + return False + + print(f"Function @ {func.start_ea:x}") + frame_tif = ida_typeinf.tinfo_t() + if not ida_frame.get_func_frame(frame_tif, func): + print("No frame returned.") + return + print(f"{frame_tif._print()}") + + idx, udm = frame_tif.get_udm(old_name) + if not udm: + print(f"{old_name} not found.") + return + + print(f"Index of {old_name}: {idx}") + tid = frame_tif.get_udm_tid(idx) + if ida_frame.is_special_frame_member(tid): + print(f"{old_name} is a special frame member. Will not change the name.") + else: + udm = ida_typeinf.udm_t() + frame_tif.get_udm_by_tid(udm, tid) + offset = udm.offset // 8 + if ida_frame.is_funcarg_off(func, offset): + print(f"{old_name} is an argument member. Will not change the name.") + else: + sval = ida_frame.soff_to_fpoff(func, offset) + print(f"Frame offset: {sval:x}") + ida_frame.define_stkvar(func, new_name, sval, udm.type) + +rename_stkvar(idc.here(), "arg_8", "Renamed") diff --git a/examples/types/change_stkvar_type.py b/examples/types/change_stkvar_type.py new file mode 100644 index 0000000..19a0203 --- /dev/null +++ b/examples/types/change_stkvar_type.py @@ -0,0 +1,173 @@ +""" +summary: change the type & name of a function stack frame variable + +description: + The goal of this script is to demonstrate some usage of the type API. + + In this script, we show a way to change the type and the name + of a stack variable. In this case we will take advantage of the + fact that RtlImageNtHeader calls RtlImageNtHeaderEx which takes + a pointer to PIMAGE_NT_HEADERS as its fourth parameter and, for + this, uses a stack variable of its caller. + + * Get the function object for RtlImageNtHeader. + * Iterate through the function item to localize the load of the + stack variable address before the call to RtlImageNtHeaderEx. We + keep this information. + * Localize the call and take advantage of the previoulsy stored + instruction to get the stack variable index in the frame. + * Set the type and rename the stack variable. + +level: advanced +""" +import ida_name +import ida_funcs +import ida_allins +import ida_typeinf +import ida_ua +import ida_frame +import ida_idaapi +import ida_ida + +""" +Before running the script: + + STACK VIEW ++0000000000000000 _UNKNOWN *__return_address; ++0000000000000008 // padding byte ++0000000000000009 // padding byte ++000000000000000A // padding byte ++000000000000000B // padding byte ++000000000000000C // padding byte ++000000000000000D // padding byte ++000000000000000E // padding byte ++000000000000000F // padding byte ++0000000000000010 _QWORD arg_8; + + DISASSEMBLY +.text:000000018002E770 public RtlImageNtHeader +.text:000000018002E770 RtlImageNtHeader proc near ; CODE XREF: sub_180007FF4+1B1↑p +.text:000000018002E770 ; sub_18002E394+66↑p ... +.text:000000018002E770 +.text:000000018002E770 arg_8 = qword ptr 10h +.text:000000018002E770 +.text:000000018002E770 48 83 EC 28 sub rsp, 28h +.text:000000018002E774 48 83 64 24 38 00 and [rsp+28h+arg_8], 0 +.text:000000018002E77A 4C 8D 4C 24 38 lea r9, [rsp+28h+arg_8] +.text:000000018002E77F 45 33 C0 xor r8d, r8d +.text:000000018002E782 48 8B D1 mov rdx, rcx +.text:000000018002E785 41 8D 48 01 lea ecx, [r8+1] +.text:000000018002E789 E8 52 5C FF FF call RtlImageNtHeaderEx +.text:000000018002E789 +.text:000000018002E78E 48 8B 44 24 38 mov rax, [rsp+28h+arg_8] +.text:000000018002E793 48 83 C4 28 add rsp, 28h +.text:000000018002E797 C3 retn + +After running the script: + + STACK VIEW +-0000000000000001 // padding byte ++0000000000000000 _UNKNOWN *__return_address; ++0000000000000008 // padding byte ++0000000000000009 // padding byte ++000000000000000A // padding byte ++000000000000000B // padding byte ++000000000000000C // padding byte ++000000000000000D // padding byte ++000000000000000E // padding byte ++000000000000000F // padding byte ++0000000000000010 struct _IMAGE_NT_HEADERS64 *pNtHeaders; + + + DISASSEMBLY +.text:000000018002E770 public RtlImageNtHeader +.text:000000018002E770 RtlImageNtHeader proc near ; CODE XREF: sub_180007FF4+1B1↑p +.text:000000018002E770 ; sub_18002E394+66↑p ... +.text:000000018002E770 +.text:000000018002E770 pNtHeaders = qword ptr 10h +.text:000000018002E770 +.text:000000018002E770 48 83 EC 28 sub rsp, 28h +.text:000000018002E774 48 83 64 24 38 00 and [rsp+28h+pNtHeaders], 0 +.text:000000018002E77A 4C 8D 4C 24 38 lea r9, [rsp+28h+pNtHeaders] +.text:000000018002E77F 45 33 C0 xor r8d, r8d +.text:000000018002E782 48 8B D1 mov rdx, rcx +.text:000000018002E785 41 8D 48 01 lea ecx, [r8+1] +.text:000000018002E789 E8 52 5C FF FF call RtlImageNtHeaderEx +.text:000000018002E789 +.text:000000018002E78E 48 8B 44 24 38 mov rax, [rsp+28h+pNtHeaders] +.text:000000018002E793 48 83 C4 28 add rsp, 28h +.text:000000018002E797 C3 retn +""" + +new_name = "pNtHeaders" +caller_name = "RtlImageNtHeader" +callee_name = "RtlImageNtHeaderEx" + +type_name = "_IMAGE_NT_HEADERS64" + +lea_insn = None + +def main(): + if not ida_ida.inf_is_64bit() or ida_ida.inf_get_procname() != "metapc": + print("Not an x64 database. Quitting!") + return + + func_ea = ida_name.get_name_ea(ida_idaapi.BADADDR, caller_name) + if func_ea == ida_idaapi.BADADDR: + print(f"Function {caller_name} not found. Quitting!") + return + + # We will need the register number for `r9` + import idautils + R_r9 = idautils.procregs.r9.reg + + func_items = ida_funcs.func_item_iterator_t(ida_funcs.get_func(func_ea)) + for func_item in func_items.code_items(): + curr_insn = ida_ua.insn_t() + if not ida_ua.decode_insn(curr_insn, func_item): + continue + + if curr_insn.itype == ida_allins.NN_lea: + if curr_insn.Op1.type == ida_ua.o_reg and curr_insn.Op1.is_reg(R_r9): + lea_insn = curr_insn + continue + + if curr_insn.itype != ida_allins.NN_call: + continue + + if ida_funcs.get_func_name(curr_insn.Op1.addr) == callee_name: + caller_func = ida_funcs.get_func(func_ea) + + caller_frame = ida_typeinf.tinfo_t() + if not ida_frame.get_func_frame(caller_frame, caller_func): + print("Unable to get the frame of the caller function. Quitting!") + break + + if lea_insn is None: + print("LEA address is None. Could not happen! Stop!") + break + + idx = caller_frame.get_stkvar(lea_insn, lea_insn.Op2, lea_insn.Op2.addr) + if idx == -1: + print("Returned stack variable index is -1. Should not happen. Stop!") + break + + tif = ida_typeinf.tinfo_t() + if not tif.get_named_type(None, type_name, ida_typeinf.BTF_STRUCT): + print(f"Unable to retrieve {type_name} type info object") + continue + + if not tif.create_ptr(tif): + print("Unable to create the pointer type.") + continue + + if caller_frame.set_udm_type(idx, tif) == ida_typeinf.TERR_OK: + print(f"Type applied to stack variable index {idx}.") + if caller_frame.rename_udm(idx, new_name) == ida_typeinf.TERR_OK: + print(f"Name changed for stack variable index {idx}.") + else: + print(f"Unable to rename stack variable index {idx}.") + else: + print(f"Unable to change type of stack variable index {idx}.") + +main() diff --git a/examples/types/create_array.py b/examples/types/create_array.py new file mode 100644 index 0000000..c066eb8 --- /dev/null +++ b/examples/types/create_array.py @@ -0,0 +1,35 @@ +""" +summary: create an array type + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we create an array using both versions of + create_array tinfo_t method. + +level: intermediate +""" + +import ida_typeinf + +""" +First method: +* Create the type info object of the array element. +* Create an array of 5 integers (base index set to zero) +""" +tif = ida_typeinf.tinfo_t(ida_typeinf.BTF_INT) +if tif.create_array(tif, 5, 0): + print(f"{tif._print()}") + +""" +Second method: +* Create an array type data object representing an array + of 5 integers with base index 10. +* Create the array using the just constructed object. +""" +atd = ida_typeinf.array_type_data_t() +atd.base = 10 +atd.nelems = 5 +atd.elem_type = ida_typeinf.tinfo_t(ida_typeinf.BTF_INT) +tif = ida_typeinf.tinfo_t() +if tif.create_array(atd): + print(f"{tif._print()}") diff --git a/examples/types/create_bfstruct.py b/examples/types/create_bfstruct.py new file mode 100644 index 0000000..17a6d2a --- /dev/null +++ b/examples/types/create_bfstruct.py @@ -0,0 +1,37 @@ +""" +summary: create a structure with bitfield members + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * Create a bitfield structure. In the present case the bitfield is an int32 + made of three 'members' spanning it entirely: + bit0->bit19: bf1 + bit20->bit25: bf2 + bit26->bit31: bf3 + * For each member create a repeatable comment. + +level: intermediate +""" +import ida_typeinf + +# Create and fill the containing user data type. +udt = ida_typeinf.udt_type_data_t() +for name, offset, size, bitfield_info in [ + ("bf1", 0, 20, (4, 20)), + ("bf2", 20, 6, (4, 6)), + ("bf3", 26, 6, (4, 6)) +]: + bf_bucket_size, bf_nbits = bitfield_info + bftif = ida_typeinf.tinfo_t() + bftif.create_bitfield(bf_bucket_size, bf_nbits) + udm = ida_typeinf.udm_t(name, bftif) + udm.offset = offset + udm.size = size + udm.cmt = f"Bitfield member {name}" + udt.push_back(udm) + +# Create the type. +tif = ida_typeinf.tinfo_t() +if tif.create_udt(udt): + print(f"{tif._print()}") diff --git a/examples/types/create_bmenum.py b/examples/types/create_bmenum.py new file mode 100644 index 0000000..cfbf50c --- /dev/null +++ b/examples/types/create_bmenum.py @@ -0,0 +1,25 @@ +""" +summary: create a bitmask enumeration + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we create a bitmask enumeration member by member. + +level: intermediate +""" +import ida_typeinf + +tif = ida_typeinf.tinfo_t() +tif.create_enum(ida_typeinf.BTE_HEX | ida_typeinf.BTE_BITMASK) +for name, value in [("field1", 1), ("field2", 2), ("field3", 0xC)]: + tif.add_edm(name, value) + +print(f"{tif._print()}") + +""" +Now let's add a couple enumerators to a separate group +""" + +tif.add_edm("field1_1", 0x1100, 0xFF00) +tif.add_edm("field1_2", 0x1200, 0xFF00) +print(f"{tif._print()}") diff --git a/examples/types/create_libssh2_til.py b/examples/types/create_libssh2_til.py new file mode 100644 index 0000000..fc40f64 --- /dev/null +++ b/examples/types/create_libssh2_til.py @@ -0,0 +1,74 @@ +""" +summary: create a type library file + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script: + * We create a new libssh2-64.til file holding some libssh2 64-bit structures. + * Once the file has been created, it can copied in the IDA install + til directory or in the user IDA til directory. + +level: intermediate +""" +import ida_typeinf +import ida_kernwin + +libssh2_types = """ +typedef unsigned char uint8_t; +typedef unsigned int uint32_t; +typedef __int64 size_t; + +struct _LIBSSH2_USERAUTH_KBDINT_PROMPT +{ + unsigned char *text; + size_t length; + unsigned char echo; +}; +typedef struct _LIBSSH2_USERAUTH_KBDINT_PROMPT LIBSSH2_USERAUTH_KBDINT_PROMPT; + +struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE +{ + char *text; + unsigned int length; +}; +typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE LIBSSH2_USERAUTH_KBDINT_RESPONSE; + +struct _LIBSSH2_SK_SIG_INFO { + uint8_t flags; + uint32_t counter; + unsigned char *sig_r; + size_t sig_r_len; + unsigned char *sig_s; + size_t sig_s_len; +}; +typedef struct _LIBSSH2_SK_SIG_INFO LIBSSH2_SK_SIG_INFO; + +""" + + +def create_libssh2_til(): + + # Create a new til file. + til = ida_typeinf.new_til("libssh2-64.til", "Some libssh2 types") + + # Parse the declaratiion, ignoring redeclaration warnings and applying default packing/ + if ida_typeinf.parse_decls(til, libssh2_types, None, ida_typeinf.HTI_DCL | ida_typeinf.HTI_PAKDEF) != 0: + raise Exception("Failed to parse the libssh2 declarations.\n") + + ida_typeinf.compact_til(til) + + return til + + +if __name__ == "__main__": + til = create_libssh2_til() + + print("Create type library with the following types") + for tif in til.named_types(): + print("\t%s" % str(tif)) + + # The save the til in the current working directory. + if ida_typeinf.store_til(til, None, "libssh2-64.til"): + print("TIL file stored on disk.\n") + + ida_typeinf.free_til(til) diff --git a/examples/types/create_struct_by_member.py b/examples/types/create_struct_by_member.py new file mode 100644 index 0000000..992afa0 --- /dev/null +++ b/examples/types/create_struct_by_member.py @@ -0,0 +1,50 @@ +""" +summary: create a structure programmatically + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we create a structure by building it member by member. + +level: intermediate +""" +import ida_typeinf + +# Delete the structure in case it already exist. +ida_typeinf.del_named_type(None, "pcaprec_hdr_s", ida_typeinf.NTF_TYPE) + +print("Add udt members") +# Create and fill the udt. +field_list = [("ts_sec", ida_typeinf.BTF_UINT32), + ("ts_usec", ida_typeinf.BTF_UINT32), + ("incl_len", ida_typeinf.BTF_UINT32), + ("orig_len", ida_typeinf.BTF_UINT32)] +udt = ida_typeinf.udt_type_data_t() +for (name, _type) in field_list: + udm = udt.add_member(name, ida_typeinf.tinfo_t(_type)) + print("udm:", udm.name, udm.size, udm.offset) + +print("Changing udm from last iteration") +udm.name = "upd_udm" +udm.offset = 3 +print("Compare updated udm with the last in the udt") +last = udt.back() +print("udm at the end:", last.name, last.offset) +print("Equal:", last == udm) +print("But not the same object:", last is not udm) + +# Actually create the type +tif = ida_typeinf.tinfo_t() +if tif.create_udt(udt): + print("Created:", + ida_typeinf.tinfo_errstr(tif.set_named_type(None, "pcaprec_hdr_s"))) + +print("\nCheck that the layout is correct") +udt = ida_typeinf.udt_type_data_t() +if tif.get_udt_details(udt): + print(f"Listing the pcaprec_hdr_s structure {udt.size()} field names:") + for idx, udm in enumerate(udt): + print(f"Field {idx}: {udm.name}, " + f"size: {udm.size}, offset: {udm.offset}") + idx += 1 +else: + print("Unable to get udt details for structure") diff --git a/examples/types/create_struct_by_parsing.py b/examples/types/create_struct_by_parsing.py new file mode 100644 index 0000000..61b7805 --- /dev/null +++ b/examples/types/create_struct_by_parsing.py @@ -0,0 +1,33 @@ +""" +summary: create a structure by parsing its definition + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we create a structure using the "parsing" method. + +level: beginner +""" +import ida_typeinf + +# Create a struct with parsing. +struct_name = "pcap_hdr_s" +struct_str = """ +typedef int int32_t; +typedef unsigned int uint32_t; + +struct pcap_hdr_s { + uint32_t magic_number; /* magic number */ + uint16_t version_major; /* major version number */ + uint16_t version_minor; /* minor version number */ + int32_t thiszone; /* GMT to local correction */ + uint32_t sigfigs; /* accuracy of timestamps */ + uint32_t snaplen; /* max length of captured packets, in octets */ + uint32_t network; /* data link type */ +}; +""" + + +tif = ida_typeinf.tinfo_t(struct_str) + +# Persist it to the "Local types" type library +tif.set_named_type(None, struct_name) diff --git a/examples/core/create_structure_programmatically.py b/examples/types/create_structure_programmatically.py similarity index 50% rename from examples/core/create_structure_programmatically.py rename to examples/types/create_structure_programmatically.py index f4f247e..1d7ec9b 100644 --- a/examples/core/create_structure_programmatically.py +++ b/examples/types/create_structure_programmatically.py @@ -1,11 +1,13 @@ """ -summary: programmatically create & populate a structure +summary: create & populate a structure description: Usage of the API to create & populate a structure with members of different types. author: Gergely Erdelyi (gergely.erdelyi@d-dome.net) + +level: intermediate """ #--------------------------------------------------------------------- @@ -22,7 +24,7 @@ import idc tif = ida_typeinf.tinfo_t() if tif.get_named_type(None, "mystr1"): ida_typeinf.del_named_type(None, "mystr1", ida_typeinf.NTF_TYPE) -ida_typeinf.idc_parse_types('struct mystr1 { };', 0) +ida_typeinf.idc_parse_types("struct mystr1 { };", 0) if not tif.get_named_type(None, "mystr1"): print("Error retrieving mystr1") print("%x" % tif.get_ordinal()) @@ -39,29 +41,20 @@ simple_types_data = [ (ida_typeinf.BTF_TBYTE, 10), ] -udm = ida_typeinf.udm_t() for i, tpl in enumerate(simple_types_data): t, nsize = tpl - udm.name = "t%02d" % i - udm.size = nsize * 8 - udm.type = ida_typeinf.tinfo_t(t) - udm.offset = tif.get_unpadded_size() * 8 - print("t%x:"% t, - ida_typeinf.tinfo_errstr(tif.add_udm(udm)) ) + udm = ida_typeinf.udm_t(f"t{i:02d}", t, tif.get_unpadded_size() * 8) + print(f"t{t:x}:", ida_typeinf.tinfo_errstr(tif.add_udm(udm))) -repr = ida_typeinf.value_repr_t() -repr.set_vtype(ida_typeinf.FRB_NUMO) +repr_ = ida_typeinf.value_repr_t() +repr_.set_vtype(ida_typeinf.FRB_NUMO) print("Set member representation to octal:", - ida_typeinf.tinfo_errstr(tif.set_udm_repr(3, repr)) ) + ida_typeinf.tinfo_errstr(tif.set_udm_repr(3, repr_))) # Test ASCII type -udm = ida_typeinf.udm_t() -udm.name = "tascii" -udm.size = 8 * 8 -udm.type.parse('char tascii[8] __strlit(C,"windows-1252");') # no other way? -udm.offset = tif.get_size() * 8 -print("%s:"% udm.name, - ida_typeinf.tinfo_errstr(tif.add_udm(udm)) ) +udm = ida_typeinf.udm_t("tascii", ida_typeinf.BTF_INT64, tif.get_size() * 8) +udm.type.parse('char tascii[8] __strlit(C,"windows-1252");') +print(f"{udm.name}:", ida_typeinf.tinfo_errstr(tif.add_udm(udm))) # Test struct member type by preparing the whole structure at once mtif = ida_typeinf.tinfo_t() @@ -69,57 +62,47 @@ if mtif.get_named_type(None, "mystr2"): ida_typeinf.del_named_type(None, "mystr2", ida_typeinf.NTF_TYPE) mudt = ida_typeinf.udt_type_data_t() -mudt.name="mystr2" -mudm = ida_typeinf.udm_t() -mudm.name="member1" -mudm.type = ida_typeinf.tinfo_t(ida_typeinf.BTF_INT) -mudt.push_back(mudm) -mudm.name="member2" -mudt.push_back(mudm) +mudt.name = "mystr2" +tif_btf_int = ida_typeinf.tinfo_t(ida_typeinf.BTF_INT) +mudt.add_member("member1", tif_btf_int) +mudt.add_member("member2", tif_btf_int) mtif.create_udt(mudt) -print("Struct 2:", ida_typeinf.tinfo_errstr(mtif.set_named_type(None, "mystr2")) ) +print("Struct 2:", + ida_typeinf.tinfo_errstr(mtif.set_named_type(None, "mystr2"))) -#Test structure member -udm.size = mtif.get_size() * 8 -udm.offset = tif.get_unpadded_size() * 8 -udm.name = "tstruct" -udm.type = mtif -print("Struct member:", ida_typeinf.tinfo_errstr(tif.add_udm(udm)) ) +# Test structure member +udm = ida_typeinf.udm_t("tstruct", mtif, tif.get_unpadded_size() * 8) +print("Struct member:", ida_typeinf.tinfo_errstr(tif.add_udm(udm))) -#Test pointer to structure -udm.name = "strptr" -udm.size = 32 -udm.offset = tif.get_unpadded_size() * 8 if not mtif.create_ptr(mtif): print("Error while creating structure pointer") -udm.type = mtif -print("Strptr:", ida_typeinf.tinfo_errstr(tif.add_udm(udm)) ) -#Test structure offset -udm.name = "tstroff" -udm.size = 32 -udm.offset = tif.get_unpadded_size() * 8 +# Test pointer to structure +udm = ida_typeinf.udm_t("strptr", mtif, tif.get_unpadded_size() * 8) +print("Strptr:", ida_typeinf.tinfo_errstr(tif.add_udm(udm))) + +# Test structure offset +udm = ida_typeinf.udm_t("tstroff", mtif, tif.get_unpadded_size() * 8) udm.type.parse("int tstroff __stroff(mystr2);") -print("Stroff:", ida_typeinf.tinfo_errstr(tif.add_udm(udm)) ) +print("Stroff:", ida_typeinf.tinfo_errstr(tif.add_udm(udm))) # Test offset types -udm.name = "toffset" -udm.size = 32 -udm.offset = tif.get_unpadded_size() * 8 +udm = ida_typeinf.udm_t("toffset", mtif, tif.get_unpadded_size() * 8) udm.type.parse("void *toffset;") -print("Offset:", ida_typeinf.tinfo_errstr(tif.add_udm(udm)) ) +print("Offset:", ida_typeinf.tinfo_errstr(tif.add_udm(udm))) # Test C bitfield types -udm.name = "tbitfield" -udm.offset = tif.get_unpadded_size() * 8 btif = ida_typeinf.tinfo_t() -btif.create_bitfield(4, 2, True) # unsigned __int32 : 2 -udm.size = 2 -udm.type = btif -print("Bitfield:", ida_typeinf.tinfo_errstr(tif.add_udm(udm)) ) +bf_nbits = 2 +btif.create_bitfield(4, bf_nbits, True) # unsigned __int32 : 2 +udm = ida_typeinf.udm_t("tbitfield", btif, tif.get_unpadded_size() * 8) +# Need to set value to width, otherwise getting "Bitfield: bad size" +udm.size = bf_nbits +print("Bitfield:", ida_typeinf.tinfo_errstr(tif.add_udm(udm))) # Print the expanded structure -pflags = ida_typeinf.PRTYPE_TYPE|ida_typeinf.PRTYPE_DEF|ida_typeinf.PRTYPE_MULTI +pflags = (ida_typeinf.PRTYPE_TYPE | ida_typeinf.PRTYPE_DEF + | ida_typeinf.PRTYPE_MULTI) print(tif._print(tif.get_type_name(), pflags)) if mtif.get_named_type(None, "mystr2"): print(mtif._print(mtif.get_type_name(), pflags)) diff --git a/examples/types/create_union_by_member.py b/examples/types/create_union_by_member.py new file mode 100644 index 0000000..e13df09 --- /dev/null +++ b/examples/types/create_union_by_member.py @@ -0,0 +1,39 @@ +""" +summary: create a union + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we create a union by building it member after member. + +level: intermediate +""" +import ida_typeinf + +field_list = [("member1", ida_typeinf.BTF_INT32), + ("member2", ida_typeinf.BTF_CHAR), + ("member3", ida_typeinf.BTF_FLOAT)] + +# Delete the structure in case it already exist. +ida_typeinf.del_named_type(None, "my_union", ida_typeinf.NTF_TYPE) + +# Create a union member by member. +udt = ida_typeinf.udt_type_data_t() +udt.is_union = True +for (name, _type) in field_list: + udm = ida_typeinf.udm_t(name, _type) + udt.push_back(udm) + +# Add a pointer to a Elf32_Sym and actually create the type. +tif = ida_typeinf.tinfo_t() +if tif.get_named_type("Elf32_Sym") and tif.create_ptr(tif): + udm = ida_typeinf.udm_t("header_ptr", tif) + udt.push_back(udm) + if tif.create_udt(udt, ida_typeinf.BTF_UNION): + tif.set_named_type(None, "my_union") + print(tif._print(tif.get_type_name(), ida_typeinf.PRTYPE_TYPE + | ida_typeinf.PRTYPE_DEF | ida_typeinf.PRTYPE_MULTI)) + print("Done") + else: + print("Cannot create udt") +else: + print("Error while getting pointer to Elf32_Sym") diff --git a/examples/types/create_user_shared_data.py b/examples/types/create_user_shared_data.py new file mode 100644 index 0000000..cb17d67 --- /dev/null +++ b/examples/types/create_user_shared_data.py @@ -0,0 +1,59 @@ +""" +summary: create a segment, and define (complex) data in it + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we show how to create, set type and name of + a user shared data region in an ntdll IDB: + * Load the `_KUSER_SHARED_DATA` data type from a type info + library shipped with IDA, and import it into the IDB's "local types" + * Create a data segment with UserSharedData as its name. + * Apply the type to the start of the newly created segment base + address. + * Set the address name. + +level: intermediate +""" +import ida_segment +import ida_typeinf +import ida_name +import ida_kernwin + +USE64 = 2 +PERM_RW = 0x6 +start_ea = 0x7FFE0000 + +_KUSER_SHARED_DATA = "_KUSER_SHARED_DATA" + +tif = ida_typeinf.get_idati().get_named_type(_KUSER_SHARED_DATA) +if not tif: + + # Load type library containing the type we're interested in + ntddk64 = ida_typeinf.load_til("ntddk64") + + # Import the type in the "Local types" + tif = ida_typeinf.get_idati().import_type(ntddk64.get_named_type(_KUSER_SHARED_DATA)) + + # clean up after ourselves + ida_typeinf.free_til(ntddk64) + +assert(tif is not None) + +segm = ida_segment.segment_t() +segm.start_ea = start_ea +segm.end_ea = start_ea + tif.get_size() +segm.sel = ida_segment.setup_selector(0) +segm.bitness = USE64 +segm.align = ida_segment.saRelPara +segm.comb = ida_segment.scPub +segm.perm = PERM_RW +if ida_segment.add_segm_ex(segm, "UserSharedData", "DATA", 0) < 0: + print("Unable to create the shared data segment.") +else: + if not ida_typeinf.apply_tinfo(start_ea, tif, ida_typeinf.TINFO_DEFINITE): + print(f"Unable to apply type information @ {start_ea:x}.") + else: + if ida_name.set_name(start_ea, "UserSharedData"): + print("Done!") + else: + print(f"Unable to set {start_ea:x} name.") diff --git a/examples/types/del_struct_members.py b/examples/types/del_struct_members.py new file mode 100644 index 0000000..572c755 --- /dev/null +++ b/examples/types/del_struct_members.py @@ -0,0 +1,52 @@ +""" +summary: delete structure members that fall within an offset range + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we first create a structure with many members, and then + remove all those that fall within a range. + +level: beginner +""" + +import ida_typeinf +import ida_idaapi + +struct_decl = """ +struct pcap_hdr_s { + uint32_t magic_number; /* magic number */ + uint16_t version_major; /* major version number */ + uint16_t version_minor; /* minor version number */ + int32_t thiszone; /* GMT to local correction */ + uint32_t sigfigs; /* accuracy of timestamps */ + uint32_t snaplen; /* max length of captured packets, in octets */ + uint32_t network; /* data link type */ +};""" + +# Compute the indexes that map the range, and then trash the members +def del_range(tif, start_byte_offset, end_byte_offset): + + udm = ida_typeinf.udm_t() + udm.offset = start_byte_offset * 8 + idx1 = tif.find_udm(udm, ida_typeinf.STRMEM_OFFSET) + + udm = ida_typeinf.udm_t() + udm.offset = end_byte_offset * 8 + idx2 = tif.find_udm(udm, ida_typeinf.STRMEM_OFFSET) + + return tif.del_udms(idx1, idx2) + +# Helper +def dump(message, tif): + print(message) + for udm in tif.iter_struct(): + print(f"\t{(udm.offset//8):04x}: {udm.name}") + +# Prepare type +tif = ida_typeinf.tinfo_t(struct_decl) +dump("Initially", tif) + +# Delete some members +assert(del_range(tif, 4, 16) == ida_typeinf.TERR_OK) +dump("After deleting some members", tif) + diff --git a/examples/types/gap_size_align_snippet.py b/examples/types/gap_size_align_snippet.py new file mode 100644 index 0000000..a3ef968 --- /dev/null +++ b/examples/types/gap_size_align_snippet.py @@ -0,0 +1,34 @@ +""" +summary: utilities to detect structure gaps & alignment + +description: + The goal of this script is to illustrate ways to detect gaps & alignments + in structures, from a structure name & (byte) offset. + +level: intermediate +""" + +import ida_typeinf +import ida_range + +# Get size of struct member + alignment +def get_member_size_align(struct_name, byte_offset): + tif = ida_typeinf.get_idati().get_named_type(struct_name) + if tif: + _, udm = tif.get_udm_by_offset(byte_offset * 8) + if udm: + return udm.type.get_size(), udm.effalign + return -1, -1 + +## Check if offset is part of a gap +def is_struct_gap(struc_name, byte_offset): + tif = ida_typeinf.get_idati().get_named_type(struc_name) + if not tif: + return False + rs = ida_range.rangeset_t() + tif.calc_gaps(rs) + for i in range(rs.nranges()): + r = rs.getrange(i) + if r.start_ea <= byte_offset < r.end_ea: + return True + return False diff --git a/examples/types/get_best_fit_member.py b/examples/types/get_best_fit_member.py new file mode 100644 index 0000000..94ad2b7 --- /dev/null +++ b/examples/types/get_best_fit_member.py @@ -0,0 +1,39 @@ +""" +summary: get member by offset, taking into account variable sized structures + +description: + The goal of this script is to provide a way to figure out + what structure member, is most likely referenced by an offset. + + This also works for variable sized types. + +level: intermediate +""" +import ida_typeinf +import ida_idaapi + +def get_best_fit_member(tif, offset): + udm = None + if tif.is_udt(): + udt = ida_typeinf.udt_type_data_t() + if tif.get_udt_details(udt): + _, udm = udt.get_best_fit_member(offset) + return udm + +struct_str = """struct modified_pcap_hdr_s { + uint32_t magic_number; /* magic number */ + uint16_t version_info[6]; + int32_t thiszone; /* GMT to local correction */ + uint32_t sigfigs; /* accuracy of timestamps */ + uint32_t snaplen; /* max length of captured packets, in octets */ + unsigned char mybytes[8]; +};""" + +tif = ida_typeinf.tinfo_t(struct_str) + +byte_offset = 5 +udm = get_best_fit_member(tif, byte_offset) +if udm: + print(f"Found: {udm.name}") +else: + print(f"No member at {byte_offset}") diff --git a/examples/types/get_innermost_member.py b/examples/types/get_innermost_member.py new file mode 100644 index 0000000..0271d43 --- /dev/null +++ b/examples/types/get_innermost_member.py @@ -0,0 +1,137 @@ +""" +summary: get information about the "innermost" member of a structure + +description: + Assuming the 2 following types: + + struct b + { + int low; + int high; + }; + + struct a + { + int foo; + b b_instance; + int bar; + }; + + looking at an offset of 5 bytes inside an `a` instance, might be + interpreted as pointing somewhere inside member `b_instance`, of type `b`. + Alternatively, that same offset might be intprereted as pointing + somewhere inside `low`, of type `int`. + + We refer to that latter interpretation as "innermost", and this sample + shows how the API lets us "drill down" to retrieve that innermost member. + +level: intermediate +""" +import ida_typeinf +import ida_idaapi + +test_types = """ + +/* Taken from lighttpd headers */ + +struct lshpack_enc_table_entry; +struct lshpack_double_enc_head; + +typedef unsigned long long unix_time64_t; + +struct lshpack_enc_head { int whatever; }; + +struct lshpack_enc +{ + unsigned hpe_cur_capacity; + unsigned hpe_max_capacity; + + /* Each new dynamic table entry gets the next number. It is used to + * calculate the entry's position in the decoder table without having + * to maintain an actual array. + */ + unsigned hpe_next_id; + + /* Dynamic table entries (struct enc_table_entry) live in two hash + * tables: name/value hash table and name hash table. These tables + * are the same size. + */ + unsigned hpe_nelem; + unsigned hpe_nbits; + struct lshpack_enc_head + hpe_all_entries; + struct lshpack_double_enc_head + *hpe_buckets; + + uint32_t *hpe_hist_buf; + unsigned hpe_hist_size, hpe_hist_idx; + int hpe_hist_wrapped; + enum { + LSHPACK_ENC_USE_HIST = 1 << 0, + } hpe_flags; +}; + +struct lshpack_arr +{ + unsigned nalloc, + nelem, + off; + uintptr_t *els; +}; + +struct lshpack_dec +{ + struct lshpack_arr hpd_dyn_table; + unsigned hpd_max_capacity; /* Maximum set by caller */ + unsigned hpd_cur_max_capacity; /* Adjusted at runtime */ + unsigned hpd_cur_capacity; + unsigned hpd_state; +}; + + +struct request_st; +struct h2con { + request_st *r[8]; + uint32_t rused; + + uint32_t h2_cid; + uint32_t h2_sid; + int32_t sent_goaway; + unix_time64_t sent_settings; + uint32_t s_header_table_size; /* SETTINGS_HEADER_TABLE_SIZE */ + uint32_t s_enable_push; /* SETTINGS_ENABLE_PUSH */ + uint32_t s_max_concurrent_streams; /* SETTINGS_MAX_CONCURRENT_STREAMS */ + int32_t s_initial_window_size; /* SETTINGS_INITIAL_WINDOW_SIZE */ + uint32_t s_max_frame_size; /* SETTINGS_MAX_FRAME_SIZE */ + uint32_t s_max_header_list_size; /* SETTINGS_MAX_HEADER_LIST_SIZE */ + struct lshpack_dec decoder; + struct lshpack_enc encoder; + unix_time64_t half_closed_ts; +}; +""" + +def get_innermost_member(tif, byte_offset): + if tif.is_udt(): + (found_tif, idx, _) = tif.get_innermost_udm(byte_offset * 8) + idx, udm = found_tif.get_udm(idx) + if udm: + return found_tif, udm + return None, None + +def main(): + + idati = ida_typeinf.get_idati() + + # get, or add parent type + tif = idati.get_named_type("h2con") + if not tif: + if ida_typeinf.parse_decls(idati, test_types, True, 0) != 0: + print("Types could not be parsed.") + return + tif = idati.get_named_type("h2con") + + found_tif, member_in_found_tif = get_innermost_member(tif, 0x9a) # in the middle of h2con.encoder.hpe_hist_wrapped + if found_tif and member_in_found_tif: + print(f"Found innermost type '{found_tif}', at member with name '{member_in_found_tif.name}' and type '{member_in_found_tif.type}'") + +main() diff --git a/examples/types/import_type_from_til.py b/examples/types/import_type_from_til.py new file mode 100644 index 0000000..07752f6 --- /dev/null +++ b/examples/types/import_type_from_til.py @@ -0,0 +1,45 @@ +""" +summary: load a type library from a file, and then a type from it + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * ask the user for a specific til to be lodaed + * if successfully loaded ask the user for a type name to be imported. + * append the type to the local types. + +level: intermediate +""" +import ida_netnode +import ida_typeinf +import ida_kernwin + +def main(): + til_name = ida_kernwin.ask_str("Dummy til name", 0, "Enter a til filename:") + if not til_name: + print("No til name provided.") + return + + src_til = ida_typeinf.load_til(til_name) + if not src_til: + print(f"{til_name} not added.") + return + + type_name = ida_kernwin.ask_str("Dummy type name", 0, "Enter a type name") + if not type_name: + print(f"Please provide a type name.") + return + + src_tif = src_til.get_named_type(type_name) + if not src_tif: + print(f"{til_name} has no type named {type_name}") + return + + imported_tif = ida_typeinf.get_idati().import_type(src_tif) + if not imported_tif: + print(f"Could not import {type_name}") + return + + print(f"{type_name} type has been imported, with ordinal {imported_tif.get_ordinal()}") + +main() diff --git a/examples/types/insert_struct_member.py b/examples/types/insert_struct_member.py new file mode 100644 index 0000000..2eab92e --- /dev/null +++ b/examples/types/insert_struct_member.py @@ -0,0 +1,39 @@ +""" +summary: inject a member in the middle of a structure + +description: + This sample will retrieve the type info object by its name, + find the member at the specified offset, and insert a + new member right before it + +level: intermediate +""" +import ida_typeinf + +def insert_gap(struct_name: str, byte_offset: int, member_type: ida_typeinf.tinfo_t): + + tif = ida_typeinf.tinfo_t() + if not tif.get_named_type(None, struct_name): + print(f"Unable to get {struct_name} structure.") + return False + + idx, existing_udm = tif.get_udm_by_offset(byte_offset * 8) + if idx < 0: + print(f"Cannot find member at offset {byte_offset:x}") + return False + + nbytes = member_type.get_size() + if tif.expand_udt(idx, nbytes) != ida_typeinf.TERR_OK: + print(f"Unable to create a gap member of {nbytes:x} bytes @ offset {byte_offset:x}") + return False + + new_udm = udm_t("fresh_new_member", member_type) + new_udm.offset = existing_udm.offset + tif.add_udm(new_udm, 0, 1, idx) + + return True + +if not insert_gap("_TraceLoggingMetadata_t", 8, ida_typeinf.tinfo_t(ida_typeinf.BT_INT)): + print("Failed to insert gaps.") +else: + print("Done.") diff --git a/examples/types/list_enum_member.py b/examples/types/list_enum_member.py new file mode 100644 index 0000000..0f4d676 --- /dev/null +++ b/examples/types/list_enum_member.py @@ -0,0 +1,36 @@ +""" +summary: print enumeration members + +description: + In this example, we will first ask the user to provide the name + of an enumeration, and then iterate on it + +level: beginner +""" +import ida_kernwin +import ida_typeinf + +def iter_enum(name): + tif = ida_typeinf.get_idati().get_named_type(name) + if not tif: + print(f"No type named {name} in local types") + return + + if not tif.is_enum(): + print(f"Type named {name} is not an enum") + return + + bf = "(bitfield) " if tif.is_bitmask_enum() else "" + print(f"Listing {bf}enum '{name}':") + + for idx, edm in enumerate(tif.iter_enum()): + print(f"\tField {idx}: {edm.name} = 0x{edm.value:x}") + +def main(): + name = ida_kernwin.ask_str("Dummy enum", 0, "Enter an enum name:") + if name is None: + print("Please provide an enumeration type name") + return + return iter_enum(name) + +main() diff --git a/examples/types/list_frame_info.py b/examples/types/list_frame_info.py new file mode 100644 index 0000000..322a86e --- /dev/null +++ b/examples/types/list_frame_info.py @@ -0,0 +1,37 @@ +""" +summary: print function stack frame information + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we retrieve the function frame structure, and iterate + on the frame members. + +level: beginner +""" +import ida_funcs +import ida_frame +import ida_typeinf +import ida_kernwin + +def list_frame_info(func_ea): + func = ida_funcs.get_func(func_ea) + if not func: + print(f"No function found at {func_ea:x}.") + return + + frame_tif = func.frame_object + if not frame_tif: + print(f"Function {func.name} has no frame") + return + + print("List frame information:") + print("-----------------------") + print(f"{func.name} @ {func.start_ea:x} framesize {frame_tif.get_size():x}") + print(f"Local variable size: {func.frsize:x}") + print(f"Saved registers: {func.frregs:x}") + print(f"Argument size: {func.argsize:x}") + for idx, udm in enumerate(frame_tif.iter_struct()): + print(f"\t#{idx} {udm.name}: soff={udm.offset//8:x} eof={udm.end()//8:x} {udm.type.dstr()}") + idx += 1 + +list_frame_info(ida_kernwin.get_screen_ea()) diff --git a/examples/types/list_func_details.py b/examples/types/list_func_details.py new file mode 100644 index 0000000..d99bd2d --- /dev/null +++ b/examples/types/list_func_details.py @@ -0,0 +1,26 @@ +""" +summary: list database functions prototypes + +description: + This script demonstrates how to list a function return type + along with its parameters types and name if any. + We do this for all the functions found in the database. + +level: beginner +""" +import ida_funcs +import ida_typeinf +import ida_kernwin +import ida_nalt +import idautils + +for ea in idautils.Functions(): + func = ida_funcs.get_func(ea) + prototype = func.prototype + if not prototype: + print(f"{ea:x}: {func.name} has no prototype.") + continue + + print(f"{ea:x}: {func.name} returns a: '{prototype.get_rettype()}', and accepts the following arguments:") + for arg in prototype.iter_func(): + print(f"\t{arg.name} (of type '{arg.type})'") diff --git a/examples/core/list_stkvar_xrefs.py b/examples/types/list_stkvar_xrefs.py similarity index 50% rename from examples/core/list_stkvar_xrefs.py rename to examples/types/list_stkvar_xrefs.py index 49e760d..e39edde 100644 --- a/examples/core/list_stkvar_xrefs.py +++ b/examples/types/list_stkvar_xrefs.py @@ -7,6 +7,8 @@ description: next_to() (or higher level utilities such as idautils.XrefsTo) keywords: xrefs + +level: intermediate """ ACTION_NAME = "list_stkvar_xrefs:list" @@ -17,37 +19,43 @@ import ida_frame import ida_funcs import ida_ida import ida_kernwin -import ida_struct +import ida_typeinf import ida_ua class list_stkvar_xrefs_ah_t(ida_kernwin.action_handler_t): def activate(self, ctx): cur_ea = ida_kernwin.get_screen_ea() pfn = ida_funcs.get_func(cur_ea) - if pfn: - v = ida_kernwin.get_current_viewer() - result = ida_kernwin.get_highlight(v) - if result: - stkvar_name, _ = result - frame = ida_frame.get_frame(cur_ea) - sptr = ida_struct.get_struc(frame.id) - mptr = ida_struct.get_member_by_name(sptr, stkvar_name) - if mptr: - for ea in pfn: - F = ida_bytes.get_flags(ea) - for n in range(ida_ida.UA_MAXOP): - if not ida_bytes.is_stkvar(F, n): - continue - insn = ida_ua.insn_t() - if not ida_ua.decode_insn(insn, ea): - continue - v = ida_frame.calc_stkvar_struc_offset(pfn, insn, n) - if v >= mptr.soff and v < mptr.eoff: - print("Found xref at 0x%08x, operand #%d" % (ea, n)) - else: - print("No stack variable named \"%s\"" % stkvar_name) - else: + if not pfn: print("Please position the cursor within a function") + return + + v = ida_kernwin.get_current_viewer() + result = ida_kernwin.get_highlight(v) + if not result: + print("Please highlight the stack variable name") + return + + stkvar_name, _ = result + frame = ida_typeinf.tinfo_t() + pfn = ida_funcs.get_func(cur_ea) + frame.get_func_frame(pfn) + stkvar_idx, stkvar = frame.get_udm(stkvar_name) + if stkvar_idx < 0: + print("No stack variable named \"%s\"" % stkvar_name) + return + + for ea in pfn: + F = ida_bytes.get_flags(ea) + for n in range(ida_ida.UA_MAXOP): + if not ida_bytes.is_stkvar(F, n): + continue + insn = ida_ua.insn_t() + if not ida_ua.decode_insn(insn, ea): + continue + v = ida_frame.calc_stkvar_struc_offset(pfn, insn, n) + if v >= stkvar.begin()/8 and v < stkvar.end()/8: + print("Found xref at 0x%08x, operand #%d" % (ea, n)) def update(self, ctx): return ida_kernwin.AST_ENABLE_FOR_WIDGET \ diff --git a/examples/types/list_struct_member.py b/examples/types/list_struct_member.py new file mode 100644 index 0000000..4b6495e --- /dev/null +++ b/examples/types/list_struct_member.py @@ -0,0 +1,45 @@ +""" +summary: list structure members + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * Ask the user for a structure name. It must already be present in the + local types. + * Retrieve the structure type info from the local type + * Extract its type details (udt) + * Iterates it members and prints their names. + +level: beginner +""" + +import ida_kernwin +import ida_typeinf + +def main(): + name = ida_kernwin.ask_str("Dummy struct", 0, "Enter a structure name:") + if name is None: + print("No structure name provided") + return + + til = ida_typeinf.get_idati() + tif = ida_typeinf.tinfo_t() + if not tif.get_named_type(til, name, ida_typeinf.BTF_STRUCT, True, False): + print(f"'{name}' is not a structure") + return + + if tif.is_typedef(): + print(f"'{name}' is not a (non typedefed) structure.") + return + + udt = ida_typeinf.udt_type_data_t() + if not tif.get_udt_details(udt): + print(f"Unable to get udt details for structure '{name}'") + return + + print(f"Listing the {name} structure {udt.size()} field names:") + for idx, udm in enumerate(udt): + print(f"Field {idx}: {udm.name}") + idx += 1 + +main() diff --git a/examples/types/list_struct_xrefs.py b/examples/types/list_struct_xrefs.py new file mode 100644 index 0000000..3f31892 --- /dev/null +++ b/examples/types/list_struct_xrefs.py @@ -0,0 +1,33 @@ +""" +summary: list cross-references to a structure + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * Ask the user for a structure name. It must already be present in the + local types. + * Get its tid + * Create the list of all the reference. + * Print it + +level: beginner +""" + +import ida_kernwin +import ida_typeinf +import ida_xref +import ida_pro + +tif = ida_typeinf.tinfo_t() +ref_eas = [] +if ida_kernwin.choose_struct(tif, "Choose one structure:"): + tid = tif.get_tid() + xrefblk = ida_xref.xrefblk_t() + for ea in xrefblk.drefs_to(tid): + ref_eas.append(ea) + + if not len(ref_eas): + print("No reference found.") + else: + for idx, ea in enumerate(ref_eas): + print(f"Refnum {idx + 1}: {ea:x}") diff --git a/examples/types/list_union_member.py b/examples/types/list_union_member.py new file mode 100644 index 0000000..a119b22 --- /dev/null +++ b/examples/types/list_union_member.py @@ -0,0 +1,33 @@ +""" +summary: list union members + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * Ask the user for a union name. It must already be present in the + local types. + * Retrieve the union type info from the local type + * Extract its type details (udt) + * Iterates it members and prints their names. + +level: beginner +""" +import ida_kernwin +import ida_typeinf + +name = ida_kernwin.ask_str("Dummy union", 0, "Enter a union name:") +if name is not None: + tif = ida_typeinf.tinfo_t() + if not tif.get_named_type(ida_typeinf.get_idati(), name, ida_typeinf.BTF_UNION, True, False): + print(f"'{name}' is not a union") + elif tif.is_typedef(): + print(f"'{name}' is not a (non typedefed) union.") + else: + udt = ida_typeinf.udt_type_data_t() + if tif.get_udt_details(udt): + print(f"Listing the {name} union {udt.size()} field names:") + for idx, udm in enumerate(udt): + print(f"Field {idx}: {udm.name}") + idx += 1 + else: + print(f"Unable to get udt details for union '{name}'") diff --git a/examples/types/mark_func_spoiled.py b/examples/types/mark_func_spoiled.py new file mode 100644 index 0000000..3ed2bf9 --- /dev/null +++ b/examples/types/mark_func_spoiled.py @@ -0,0 +1,44 @@ +""" +summary: mark a register "spoiled" by a function + +description: + At least two possibilies are offered in order to indicate that a function + spoils registers (excluding the "normal" ones): + + You can either parse & apply a declaration: + + func_tfinfo = ida_typeinf.tinfo_t("int _spoils main();") + ida_typeinf.apply_tinfo(func.start_ea, func_tinfo, ida_typeinf.TINFO_DEFINITE) + + or retrieve & modify the `tinfo_t` object directly. + + This script showcases the latter. + +level: beginner +""" + +import ida_funcs +import ida_typeinf +import ida_idp +import ida_kernwin +import ida_nalt + +def mark_spoiled(address, regs): + + func = ida_funcs.get_func(address) + if func: + func_type = ida_typeinf.tinfo_t() + ida_nalt.get_tinfo(func_type, func.start_ea) + func_details = ida_typeinf.func_type_data_t() + func_type.get_func_details(func_details) + + for reg in regs: + reg_info = ida_idp.reg_info_t() + ida_idp.parse_reg_name(reg_info, reg) + func_details.spoiled.append(reg_info) + + func_details.flags |= ida_typeinf.FTI_SPOILED + func_type.create_func(func_details) + return ida_typeinf.apply_tinfo(func.start_ea, func_type, ida_typeinf.TINFO_DEFINITE) + +mark_spoiled(ida_kernwin.get_screen_ea(), ["rsi"]) diff --git a/examples/types/modify_struct_member.py b/examples/types/modify_struct_member.py new file mode 100644 index 0000000..97c99e1 --- /dev/null +++ b/examples/types/modify_struct_member.py @@ -0,0 +1,47 @@ +""" +summary: modify structure members attributes programmatically + +description: + This example shows how to access & modify certain less-obvious + attributes of structure members (pointer size, representation, ...) + + We will first create the structure without those, and then + show how to programmatically modify them. + +level: intermediate +""" + +import ida_typeinf +import ida_nalt + +# For the sake of the example, we will start with an "approximation" +# of the structure we eventually want to end up with: + +struct_def = """ +struct RTTICompleteObjectLocator +{ + int signature; + int offset; + int cdOffset; + int pTypeDescriptor; // we will eventually want: int *__ptr32 pTypeDescriptor __offset(OFF64|RVAOFF); + int pClassDescriptor; // we will eventually want: int *__ptr32 pClassDescriptor __offset(OFF64|RVAOFF); + int pSelf; // we will eventually want: int *__ptr32 pSelf __offset(OFF64|RVAOFF); +}; +""" + +tif = ida_typeinf.tinfo_t(struct_def) + +# +# We will want to +# - change the _type_, from `int`, to `int *__ptr32` +# - change the _representation_, to an RVA offset +# + +new_type = ida_typeinf.tinfo_t("int *__ptr32") + +new_repr = ida_typeinf.value_repr_t() +new_repr.set_vtype(ida_typeinf.FRB_OFFSET) +new_repr.ri.init(ida_nalt.REF_OFF64 | ida_nalt.REFINFO_RVAOFF) + +for i in range(3, 6): + tif.set_udm_type(i, new_type, 0, new_repr) diff --git a/examples/types/operand_to_struct_member.py b/examples/types/operand_to_struct_member.py new file mode 100644 index 0000000..4fdfb5d --- /dev/null +++ b/examples/types/operand_to_struct_member.py @@ -0,0 +1,108 @@ +""" +summary: turn instruction operand into a structure offset + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we: + * ask the user to choose the structure that will be used for + the conversion. + * build the structure path and call ida_bytes.op_stroff. In case + an enum is found a modal chooser is displayed in order to select + a member. + +level: advanced +""" +import ida_typeinf +import ida_kernwin +import ida_pro +import ida_ua +import ida_bytes + +class union_member_chooser_t(ida_kernwin.Choose): + def __init__(self, title, udm_list): + ida_kernwin.Choose.__init__( + self, + title, + [ + ["Type Name", 30 | ida_kernwin.Choose.CHCOL_PLAIN], + ["Type ID", 30 | ida_kernwin.Choose.CHCOL_HEX] + ] + ) + self.items = [ [udm.type.get_type_name(), hex(udm.type.get_tid())] + for udm in udm_list] + self.icon = 5 + + def OnGetSize(self): + return len(self.items) + + def OnGetLine(self, n): + return self.items[n] + + +def choose_union_member(tif): + """ + Display a chooser containing the list of the union + members. The selected entry (0-based) is returned + or -1. + """ + udm_list = [] + udt = ida_typeinf.udt_type_data_t() + if not tif.get_udt_details(udt): + return None + for udm in udt: + udm_list.append(udm) + uch = union_member_chooser_t("Choose a union member", udm_list) + return uch.Show(modal=True) + + +def build_strpath(tif, offset): + """ + Build the structure path and return it. + """ + tid_list = [] + offset *= 8 + while True: + if tif.is_udt(): + udt = ida_typeinf.udt_type_data_t() + if not tif.get_udt_details(udt): + break + if tif.is_union(): + n = choose_union_member(tif) + if n == -1: + break + tid_list.append(tif.get_udm_tid(n)) + tif = ida_typeinf.tinfo_t(udt[n].type) + elif tif.is_struct(): + tid_list.append(tif.get_tid()) + udm = ida_typeinf.udm_t() + udm.offset = offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_OFFSET) + if idx != -1: + offset -= udm.offset + tif = ida_typeinf.tinfo_t(udm.type) + else: + break + size = len(tid_list) + path = ida_pro.tid_array(size) + for idx, tid in enumerate(tid_list): + path[idx] = tid + return (path, size) + + +def main(ea): + insn = ida_ua.insn_t() + if ida_ua.decode_insn(insn, ea): + tif = ida_typeinf.tinfo_t() + if ida_kernwin.choose_struct(tif, "Choose the structure:"): + n = ida_kernwin.get_opnum() + if n == -1: + print("No operand selected") + else: + path, size = build_strpath(tif, insn.ops[n].addr) + ida_bytes.op_stroff(insn, n, path.cast(), size, 0) + else: + print(f"Unable to decode ins @ {ea:x}") + + +if __name__ == "__main__": + main(ida_kernwin.get_screen_ea()) diff --git a/examples/types/print_stkvar_xrefs.py b/examples/types/print_stkvar_xrefs.py new file mode 100644 index 0000000..5acf67d --- /dev/null +++ b/examples/types/print_stkvar_xrefs.py @@ -0,0 +1,68 @@ +""" +summary: list cross-references to function stack frame variables + +description: + The goal of this script is to demonstrate some usage of the type API. + In this script, we demonstrate how to list each stack variables + xref: + * Get the function object surrounding cursor location. + * Use this function to retrieve the corresponding frame object. + * For each frame element: + - Build the stack variable xref list + - Print it. + +level: intermediate +""" + +import ida_typeinf +import ida_frame +import ida_funcs +import ida_xref +import ida_kernwin + +XREF_TO_STR = {ida_xref.dr_R: "READ", + ida_xref.dr_W: "WRITE" +} + +def list_xrefs(func_ea): + func = ida_funcs.get_func(func_ea) + if not func: + print('No function under the cursor') + return + + print(f'Function @ {func.start_ea:x}') + + frame_tif = ida_typeinf.tinfo_t() + if not ida_frame.get_func_frame(frame_tif, func): + print('No frame found') + return + + nmembers = frame_tif.get_udt_nmembers() + print(f'Frame has {nmembers} members') + + if nmembers <= 0: + print('No members found.') + return + + frame_udt = ida_typeinf.udt_type_data_t() + if not frame_tif.get_udt_details(frame_udt): + print('Unable to get the frame details.') + return + + for frame_udm in frame_udt: + start_off = frame_udm.begin() // 8 + end_off = frame_udm.end() // 8 + xreflist = ida_frame.xreflist_t() + ida_frame.build_stkvar_xrefs( + xreflist, func, start_off, end_off) + size = xreflist.size() + print(f'{frame_udm.name} stack variable starts @ ' + f'{start_off:x}, ends @ {end_off:x}, ' + f'xref size: {size}') + + for idx in range(size): + type_ = XREF_TO_STR.get(xreflist[idx].type, "UNK") + print(f'\t[{idx}]: xref @ {xreflist[idx].ea:x} ' + f'of type {type_}') + +list_xrefs(ida_kernwin.get_screen_ea()) diff --git a/examples/types/setpehdr.py b/examples/types/setpehdr.py new file mode 100644 index 0000000..9ed85ea --- /dev/null +++ b/examples/types/setpehdr.py @@ -0,0 +1,137 @@ +""" +summary: assign DOS/PE headers structures to a PE binary + +description: + The goal of this script is to demonstrate some usage of the type API. + + In this script, we: + + * load a PE64 file in binary mode + * import some types from the mssdk64 til + * apply these types at the correct ofsset in the DB + * finally, rebase the program based on the information stored + in the ImageBase field of the IMAGE_OPTIONAL_HEADER64. + +level: intermediate +""" + +import ida_typeinf +import ida_bytes +import ida_name +import ida_segment +import ida_netnode +import ida_hexrays +import idc + + +def create_struct_at(id, ea, var_name = None): + """ + Create the structure identified by id at + address ea. + """ + tif = ida_typeinf.tinfo_t() + ida_hexrays.get_type(id, tif, ida_typeinf.BTF_STRUCT) + ida_bytes.create_struct(ea, tif.get_size(), id, True) + if var_name: + ida_name.set_name(ea, var_name) + + +def get_struct_size(id): + """ + Return the size of the structure identified by id. + """ + tif = ida_typeinf.tinfo_t() + ida_hexrays.get_type(id, tif, ida_typeinf.BTF_STRUCT) + return tif.get_size() + + +def get_pe_ea(id): + """ + Return the address of the pe header. + """ + tif = ida_typeinf.tinfo_t() + ida_hexrays.get_type(id, tif, ida_typeinf.BTF_STRUCT) + udt = ida_typeinf.udt_type_data_t() + tif.get_udt_details(udt) + udm = udt[tif.get_udt_nmembers() - 1] + return ida_bytes.get_dword(udm.offset // 8) + + + +def get_field_off(id, field): + """ + Return the offset in bytes of the member + 'field' in the structure identified by 'id'. + """ + tif = ida_typeinf.tinfo_t() + ida_hexrays.get_type(id, tif, ida_typeinf.BTF_STRUCT) + udt = ida_typeinf.udt_type_data_t() + tif.get_udt_details(udt) + udm = udt[udt.find_member(field)] + return udm.offset // 8 + + +def get_struct_field_off(struct_name, field): + """ + Return the offset in bytes of the member + 'field' in the structure identified by 'struct_name'. + """ + tif = ida_typeinf.tinfo_t() + tif.get_named_type(None, struct_name, ida_typeinf.BTF_STRUCT, True, False) + udt = ida_typeinf.udt_type_data_t() + tif.get_udt_details(udt) + udm = udt[udt.find_member(field)] + return udm.offset // 8 + + +def main(): + + # Add mssdk64_win10 til to the local types. + ida_typeinf.add_til("mssdk64_win10", ida_typeinf.ADDTIL_DEFAULT) + + # Get _IMAGE_XXX struct ids. -1 Means that the type is appended + # to the local type list. + idh_id = idc.import_type(-1, "_IMAGE_DOS_HEADER") + inh_id = idc.import_type(-1, "_IMAGE_NT_HEADERS64") + ish_id = idc.import_type(-1, "_IMAGE_SECTION_HEADER") + if idh_id == ida_netnode.BADNODE or inh_id == ida_netnode.BADNODE \ + or ish_id == ida_netnode.BADNODE: + print("At least one type has not been imported. Quit.") + return + + # Create _IMAGE_DOS_HEADER at offset 0. + create_struct_at(idh_id, 0, "DOS_HEADER") + + # Get the e_lfanew value. + inh_ea = get_pe_ea(idh_id) + + # Create _IMAGE_NT_HEADERS at offset inh_ea. + create_struct_at(inh_id, inh_ea, "NT_HEADERS") + + # Get the number of sections. + ifh_off = get_field_off(inh_id, "FileHeader") + nos_off = get_struct_field_off("_IMAGE_FILE_HEADER", "NumberOfSections") + sections = ida_bytes.get_word(inh_ea + ifh_off + nos_off) + + # Create _IMAGE_SECTION_HEADERs. + section_ea = inh_ea + get_struct_size(inh_id) + ish_size = get_struct_size(ish_id) + section_eas = [] + for section in range(sections): + section_eas.append(section_ea) + create_struct_at(ish_id, section_ea) + section_ea += ish_size + + + ioh_off = get_field_off(inh_id, "OptionalHeader") + ioh_ea = inh_ea + ioh_off + + # Get Section alignment. + sec_align_off = get_struct_field_off("_IMAGE_OPTIONAL_HEADER64", "SectionAlignment") + + # Get the image base ea. + image_base_member_off = get_struct_field_off("_IMAGE_OPTIONAL_HEADER64", "ImageBase") + image_base = ida_bytes.get_qword(ioh_ea + image_base_member_off) + ida_segment.rebase_program(image_base, ida_segment.MSF_FIXONCE) + +main() diff --git a/examples/types/visit_tinfo.py b/examples/types/visit_tinfo.py new file mode 100644 index 0000000..b64dd4e --- /dev/null +++ b/examples/types/visit_tinfo.py @@ -0,0 +1,54 @@ +""" +summary: recursively visit a type and its members + +description: + In this script, we show an example of tinfo_visitor_t to list + a user define type members, recursively. + + This scripts skips array & pointer members (by calling + `tinfo_visitor_t.prune_now()`) + +level: intermediate +""" +import ida_typeinf +import ida_netnode +import idc + +class tinfo_visitor(ida_typeinf.tinfo_visitor_t): + + def __init__(self): + ida_typeinf.tinfo_visitor_t.__init__(self, ida_typeinf.TVST_DEF) + + def visit_type(self, out, tif, name, cmt): + type_name = tif.get_type_name() + if tif.is_udt(): + print(f"visited udt: {type_name} {name}") + elif tif.is_array(): + ai = ida_typeinf.array_type_data_t() + if tif.get_array_details(ai): + type_name = ai.elem_type._print() + nelems = ai.nelems + print(f"visited array: {type_name} {name}[{nelems}]") + self.prune_now() + elif tif.is_scalar(): + print(f"visited scalar: {type_name} {name}") + elif tif.is_ptr(): + print(f"visited pointer: {type_name} {name}") + self.prune_now() + else: + print(f"visited unknown: {type_name} {name}") + + return 0 + +ida_typeinf.add_til("mssdk64_win10", ida_typeinf.ADDTIL_DEFAULT) +til = ida_typeinf.get_idati() + +idh_id = idc.import_type(-1, "_IMAGE_DOS_HEADER") +if idh_id != ida_netnode.BADNODE: + tif = ida_typeinf.tinfo_t() + if tif.get_named_type(None, "_IMAGE_DOS_HEADER"): + tinfo_visitor().apply_to(tif) + else: + print("Unable to get _IMAGE_DOS_HEADER type info.") +else: + print("Import of _IMAGE_DOS_HEADER failed.") diff --git a/examples/core/actions.py b/examples/ui/actions.py similarity index 99% rename from examples/core/actions.py rename to examples/ui/actions.py index 6ce3b8f..cc69fd4 100644 --- a/examples/core/actions.py +++ b/examples/ui/actions.py @@ -16,6 +16,8 @@ description: keywords: actions see_also: add_hotkey + +level: intermediate """ import ida_kernwin diff --git a/examples/core/add_hotkey.py b/examples/ui/add_hotkey.py similarity index 93% rename from examples/core/add_hotkey.py rename to examples/ui/add_hotkey.py index 1ef2e03..4555e5b 100644 --- a/examples/core/add_hotkey.py +++ b/examples/ui/add_hotkey.py @@ -1,5 +1,5 @@ """ -summary: triggering bits of code by pressing a shortcut +summary: assign a shortcut to a custom function description: `ida_kernwin.add_hotkey` is a simpler, but much less flexible @@ -14,6 +14,8 @@ description: keywords: actions see_also: actions + +level: beginner """ import ida_kernwin diff --git a/examples/core/auto_instantiate_widget_plugin.py b/examples/ui/auto_instantiate_widget_plugin.py similarity index 98% rename from examples/core/auto_instantiate_widget_plugin.py rename to examples/ui/auto_instantiate_widget_plugin.py index a0ae3de..8d874cc 100644 --- a/examples/core/auto_instantiate_widget_plugin.py +++ b/examples/ui/auto_instantiate_widget_plugin.py @@ -1,5 +1,5 @@ """ -summary: better integrating custom widgets in the desktop layout +summary: restore custom widgets across sessions description: This is an example demonstrating how one can create widgets from a plugin, @@ -22,6 +22,8 @@ description: => the widget will be visible keywords: desktop + +level: advanced """ import ida_idaapi diff --git a/examples/core/colorize_disassembly.py b/examples/ui/colorize_disassembly.py similarity index 89% rename from examples/core/colorize_disassembly.py rename to examples/ui/colorize_disassembly.py index 283c3a6..892b759 100644 --- a/examples/core/colorize_disassembly.py +++ b/examples/ui/colorize_disassembly.py @@ -1,5 +1,5 @@ """ -summary: change background colours +summary: assign a background color to an address, function & segment description: This illustrates the setting/retrieval of background colours @@ -9,11 +9,11 @@ description: (item, function, or segment). Those will be persisted in the database. -category: disassembly - keywords: coloring, idc see_also: colorize_disassembly_on_the_fly + +level: beginner """ BG_BLUE = 0xc02020 diff --git a/examples/core/colorize_disassembly_on_the_fly.py b/examples/ui/colorize_disassembly_on_the_fly.py similarity index 98% rename from examples/core/colorize_disassembly_on_the_fly.py rename to examples/ui/colorize_disassembly_on_the_fly.py index ebaaf9c..fbb6b90 100644 --- a/examples/core/colorize_disassembly_on_the_fly.py +++ b/examples/ui/colorize_disassembly_on_the_fly.py @@ -1,5 +1,5 @@ """ -summary: an easy-to-use way to colorize lines +summary: colorize lines interactively description: This builds upon the `ida_kernwin.UI_Hooks.get_lines_rendering_info` @@ -15,6 +15,8 @@ description: keywords: coloring see_also: colorize_disassembly + +level: advanced """ import ida_kernwin diff --git a/examples/core/custom_cli.py b/examples/ui/custom_cli.py similarity index 70% rename from examples/core/custom_cli.py rename to examples/ui/custom_cli.py index c20c0ad..3fc74b4 100644 --- a/examples/core/custom_cli.py +++ b/examples/ui/custom_cli.py @@ -1,5 +1,5 @@ """ -summary: a custom command-line interpreter +summary: add a custom command-line interpreter description: Illustrates how one can add command-line interpreters to IDA @@ -7,6 +7,8 @@ description: This custom interpreter doesn't actually run any code; it's there as a 'getting started'. It provides an example tab completion support. + +level: advanced """ # ----------------------------------------------------------------------- @@ -19,6 +21,7 @@ description: import ida_kernwin import ida_idaapi +import traceback class mycli_t(ida_kernwin.cli_t): flags = 0 @@ -40,12 +43,28 @@ class mycli_t(ida_kernwin.cli_t): "bongiorno", ] - def OnCompleteLine(self, prefix, n, line, prefix_start): - print("OnCompleteLine: prefix=%s n=%d line=%s prefix_start=%d" % (prefix, n, line, prefix_start)) - if prefix == "bon": - if n < len(self.completions): - return self.completions[n] - return None + def OnFindCompletions(self, line, x): + """ + The user pressed Tab. Return a list of completions + + This callback is optional. + + @param line: the current line (string) + @param x: the index where the cursor is (int) + + @return: None if no completion could be generated, otherwise a tuple: + (completions : Sequence[str], hints : Sequence[str], docs: Sequence[str], + match_start: int, match_end: int) + """ + try: + print("OnFindCompletions: line=%s x=%d" % (line, x)) + # self.debug("__call__(line=%s, x=%s)", line, x) + uline = line + if line[x-3:x]=="bon": + return (self.completions, [], [], x-3, x) + except: + print("OnFindCompletions got exception:\n%s", traceback.format_exc()) + pass # ----------------------------------------------------------------------- def nw_handler(code, old=0): diff --git a/examples/core/dump_selection.py b/examples/ui/dump_selection.py similarity index 92% rename from examples/core/dump_selection.py rename to examples/ui/dump_selection.py index f6c9407..59b0197 100644 --- a/examples/core/dump_selection.py +++ b/examples/ui/dump_selection.py @@ -10,8 +10,10 @@ description: After running this script: * select some text in one of the listing widgets (i.e., - "IDA View-*", "Enums", "Structures", "Pseudocode-*") + "IDA View-...", "Local Types", "Pseudocode-...") * press Ctrl+Shift+S to dump the selection + +level: advanced """ import ida_kernwin @@ -35,7 +37,7 @@ def get_widget_lines(widget, tp0, tp1): if last_line_ref == 0: # at last line line = line[0:tp1.x] elif first_line_ref == 0: # at first line - line = ' ' * tp0.x + line[tp0.x:] + line = " " * tp0.x + line[tp0.x:] lines.append(line) return lines @@ -50,8 +52,7 @@ class dump_selection_handler_t(ida_kernwin.action_handler_t): def update(self, ctx): ok_widgets = [ ida_kernwin.BWN_DISASM, - ida_kernwin.BWN_STRUCTS, - ida_kernwin.BWN_ENUMS, + ida_kernwin.BWN_TILVIEW, ida_kernwin.BWN_PSEUDOCODE, ] return ida_kernwin.AST_ENABLE_FOR_WIDGET \ @@ -78,7 +79,7 @@ if ida_kernwin.register_action( # dump current selection p0 = ida_kernwin.twinpos_t() p1 = ida_kernwin.twinpos_t() -view = ida_kernwin.get_current_viewer() +view = ida_kernwin.get_last_widget(ida_kernwin.IWID_ANY_LISTING) if ida_kernwin.read_selection(view, p0, p1): lines = get_widget_lines(view, p0, p1) print("\n".join(lines)) diff --git a/examples/widgets/forms/askusingform.py b/examples/ui/forms/askusingform.py similarity index 99% rename from examples/widgets/forms/askusingform.py rename to examples/ui/forms/askusingform.py index 646c876..e8d57c0 100644 --- a/examples/widgets/forms/askusingform.py +++ b/examples/ui/forms/askusingform.py @@ -1,5 +1,5 @@ """ -summary: Non-trivial uses of the `ida_kernwin.Form` helper class +summary: advanced usage of the form API description: How to query for complex user input, using IDA's built-in forms. @@ -9,6 +9,8 @@ description: `ida_kernwin.ask_str` and similar functions. keywords: forms + +level: advanced """ # ----------------------------------------------------------------------- diff --git a/examples/widgets/graphs/custom_graph_with_actions.py b/examples/ui/graphs/custom_graph_with_actions.py similarity index 99% rename from examples/widgets/graphs/custom_graph_with_actions.py rename to examples/ui/graphs/custom_graph_with_actions.py index e03027c..09732c5 100644 --- a/examples/widgets/graphs/custom_graph_with_actions.py +++ b/examples/ui/graphs/custom_graph_with_actions.py @@ -1,11 +1,13 @@ """ -summary: drawing custom graphs +summary: draw custom graphs description: Showing custom graphs, using `ida_graph.GraphViewer`. In addition, show how to write actions that can be performed on those. keywords: graph, actions + +level: advanced """ # ----------------------------------------------------------------------- diff --git a/examples/widgets/graphs/sync_two_graphs.py b/examples/ui/graphs/sync_two_graphs.py similarity index 97% rename from examples/widgets/graphs/sync_two_graphs.py rename to examples/ui/graphs/sync_two_graphs.py index 1a487f5..2f55b0e 100644 --- a/examples/widgets/graphs/sync_two_graphs.py +++ b/examples/ui/graphs/sync_two_graphs.py @@ -1,5 +1,5 @@ """ -summary: follow the movements of a disassembly graph, in another. +summary: follow the movements of one graph, in another description: Since it is possible to be notified of movements that happen @@ -12,6 +12,8 @@ description: keywords: graph, idaview see_also: wrap_idaview + +level: intermediate """ import ida_kernwin diff --git a/examples/widgets/idaview/wrap_idaview.py b/examples/ui/idaview/wrap_idaview.py similarity index 97% rename from examples/widgets/idaview/wrap_idaview.py rename to examples/ui/idaview/wrap_idaview.py index a5acc70..5512f5f 100644 --- a/examples/widgets/idaview/wrap_idaview.py +++ b/examples/ui/idaview/wrap_idaview.py @@ -1,5 +1,5 @@ """ -summary: manipulate IDAView and graph +summary: programmatically manipulate disassembly and graph widgets description: This is an example illustrating how to manipulate an existing IDA-provided @@ -8,6 +8,8 @@ description: keywords: idaview, graph see_also: custom_graph_with_actions, sync_two_graphs + +level: advanced """ # ----------------------------------------------------------------------- diff --git a/examples/widgets/listings/custom_viewer.py b/examples/ui/listings/custom_viewer.py similarity index 99% rename from examples/widgets/listings/custom_viewer.py rename to examples/ui/listings/custom_viewer.py index 8352dbf..f29c992 100644 --- a/examples/widgets/listings/custom_viewer.py +++ b/examples/ui/listings/custom_viewer.py @@ -10,6 +10,8 @@ description: freshly-created widget (using `ida_kernwin.attach_action_to_popup`.) keywords: listing, actions + +level: intermediate """ import ida_kernwin diff --git a/examples/widgets/listings/jump_next_comment.py b/examples/ui/listings/jump_next_comment.py similarity index 99% rename from examples/widgets/listings/jump_next_comment.py rename to examples/ui/listings/jump_next_comment.py index 442e0f3..a74fea6 100644 --- a/examples/widgets/listings/jump_next_comment.py +++ b/examples/ui/listings/jump_next_comment.py @@ -1,5 +1,5 @@ """ -summary: implement a "jump to next comment" action within IDA's disassembly view. +summary: implement a "jump to next comment" action within IDA's listing description: We want our action not only to find the next line containing a comment, @@ -20,6 +20,8 @@ description: keywords: idaview, actions see_also: save_and_restore_listing_pos + +level: intermediate """ import ida_idaapi diff --git a/examples/widgets/listings/save_and_restore_listing_pos.py b/examples/ui/listings/save_and_restore_listing_pos.py similarity index 91% rename from examples/widgets/listings/save_and_restore_listing_pos.py rename to examples/ui/listings/save_and_restore_listing_pos.py index 1feee88..619bdf1 100644 --- a/examples/widgets/listings/save_and_restore_listing_pos.py +++ b/examples/ui/listings/save_and_restore_listing_pos.py @@ -15,6 +15,8 @@ description: keywords: listing, actions see_also: jump_next_comment + +level: intermediate """ import ida_kernwin @@ -23,8 +25,7 @@ import ida_moves class listing_action_handler_t(ida_kernwin.action_handler_t): def update(self, ctx): is_listing = ctx.widget_type in [ - ida_kernwin.BWN_ENUMS, - ida_kernwin.BWN_STRUCTS, + ida_kernwin.BWN_TILVIEW, ida_kernwin.BWN_DISASM, ida_kernwin.BWN_CUSTVIEW, ida_kernwin.BWN_PSEUDOCODE, @@ -43,7 +44,7 @@ class save_position_ah_t(listing_action_handler_t): ACTION_NAME = "save_and_restore_listing_pos:save_position" ACTION_LABEL = "Save position" ACTION_SHORTCUT = "Ctrl+Shift+S" - HELP_TEXT = "Press %s in a 'listing' widget such as 'IDA View-A', 'Enums', 'Structures', 'Pseudocode-A', ... to remember the position" % ACTION_SHORTCUT + HELP_TEXT = "Press %s in a 'listing' widget such as 'IDA View-A', 'Local Types', 'Pseudocode-A', ... to remember the position" % ACTION_SHORTCUT def activate(self, ctx): global last_pos @@ -59,7 +60,7 @@ class restore_position_ah_t(listing_action_handler_t): ACTION_NAME = "save_and_restore_listing_pos:restore_position" ACTION_LABEL = "Restore position" ACTION_SHORTCUT = "Ctrl+Shift+O" - HELP_TEXT = "Press %s in a 'listing' widget such as 'IDA View-A', 'Enums', 'Structures', 'Pseudocode-A', ... to restore a previously-saved position" % ACTION_SHORTCUT + HELP_TEXT = "Press %s in a 'listing' widget such as 'IDA View-A', 'Local Types', 'Pseudocode-A', ... to restore a previously-saved position" % ACTION_SHORTCUT def activate(self, ctx): global last_pos diff --git a/examples/widgets/misc/add_menus.py b/examples/ui/misc/add_menus.py similarity index 97% rename from examples/widgets/misc/add_menus.py rename to examples/ui/misc/add_menus.py index e8fcd6f..8ff3fb0 100644 --- a/examples/widgets/misc/add_menus.py +++ b/examples/ui/misc/add_menus.py @@ -1,5 +1,5 @@ """ -summary: adding custom menus to IDA +summary: add custom menus to IDA description: It is possible to add custom menus to IDA, either at the @@ -12,6 +12,8 @@ description: * this example does not deal with context menus keywords: actions + +level: beginner """ import ida_kernwin diff --git a/examples/pyqt/inject_command.py b/examples/ui/pyqt/inject_command.py similarity index 98% rename from examples/pyqt/inject_command.py rename to examples/ui/pyqt/inject_command.py index 43447f1..ddd30f3 100644 --- a/examples/pyqt/inject_command.py +++ b/examples/ui/pyqt/inject_command.py @@ -1,5 +1,5 @@ """ -summary: injecting commands in the "Output" window +summary: inject commands in the "Output" window description: This example illustrates how one can execute commands in the @@ -17,6 +17,8 @@ description: `ida_kernwin.find_widget`, is not the same type as a `QtWidgets.QWidget`. We therefore need to convert it using `ida_kernwin.PluginForm.TWidgetToPyQtWidget` + +level: advanced """ from PyQt5 import QtCore diff --git a/examples/pyqt/paint_over_graph.py b/examples/ui/pyqt/paint_over_graph.py similarity index 97% rename from examples/pyqt/paint_over_graph.py rename to examples/ui/pyqt/paint_over_graph.py index dcd1d7f..17321da 100644 --- a/examples/pyqt/paint_over_graph.py +++ b/examples/ui/pyqt/paint_over_graph.py @@ -1,5 +1,5 @@ """ -summary: custom painting on top of graph view edges +summary: paint text on graph view edges description: This sample registers an action enabling painting of a recognizable @@ -13,6 +13,8 @@ description: Using an "event filter", we will intercept paint events targeted at the disassembly view, let it paint itself, and then add our own markers along. + +level: advanced """ from PyQt5 import QtCore @@ -20,6 +22,7 @@ from PyQt5 import QtGui from PyQt5 import QtWidgets import ida_graph +import ida_gdl import ida_kernwin import ida_moves @@ -85,7 +88,7 @@ class painter_t(QtCore.QObject): if not graph.is_visible_node(dst_node): continue - edge_info = graph.get_edge(ida_graph.edge_t(src_node, dst_node)) + edge_info = graph.get_edge(ida_gdl.edge_t(src_node, dst_node)) if edge_info: # For all horizontal edge segments satisfying the length requirements... diff --git a/examples/pyqt/paint_over_navbar.py b/examples/ui/pyqt/paint_over_navbar.py similarity index 97% rename from examples/pyqt/paint_over_navbar.py rename to examples/ui/pyqt/paint_over_navbar.py index 4b5fcd4..0414833 100644 --- a/examples/pyqt/paint_over_navbar.py +++ b/examples/ui/pyqt/paint_over_navbar.py @@ -1,10 +1,12 @@ """ -summary: custom painting on top of the navigation band +summary: paint on top of the navigation band description: Using an "event filter", we will intercept paint events targeted at the navigation band widget, let it paint itself, and then add our own markers on top. + +level: intermediate """ import random diff --git a/examples/pyqt/populate_pluginform_with_pyqt_widgets.py b/examples/ui/pyqt/populate_pluginform_with_pyqt_widgets.py similarity index 92% rename from examples/pyqt/populate_pluginform_with_pyqt_widgets.py rename to examples/ui/pyqt/populate_pluginform_with_pyqt_widgets.py index 67d341b..b46378b 100644 --- a/examples/pyqt/populate_pluginform_with_pyqt_widgets.py +++ b/examples/ui/pyqt/populate_pluginform_with_pyqt_widgets.py @@ -1,11 +1,13 @@ """ -summary: adding PyQt5 widgets into an `ida_kernwin.PluginForm` +summary: create a dockable container, and populate it with Qt widgets description: Using `ida_kernwin.PluginForm.FormToPyQtWidget`, this script converts IDA's own dockable widget into a type that is recognized by PyQt5, which then enables populating it with regular Qt widgets. + +level: beginner """ from PyQt5 import QtCore, QtGui, QtWidgets diff --git a/examples/core/register_timer.py b/examples/ui/register_timer.py similarity index 92% rename from examples/core/register_timer.py rename to examples/ui/register_timer.py index 13421d8..b586798 100644 --- a/examples/core/register_timer.py +++ b/examples/ui/register_timer.py @@ -1,8 +1,10 @@ """ -summary: using timers for delayed execution +summary: use timers for delayed execution description: Register (possibly repeating) timers. + +level: beginner """ import ida_kernwin @@ -37,5 +39,5 @@ def main(): # ------------------------------------------------------------------------- -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/examples/widgets/tabular_views/custom/choose.py b/examples/ui/tabular_views/custom/choose.py similarity index 98% rename from examples/widgets/tabular_views/custom/choose.py rename to examples/ui/tabular_views/custom/choose.py index 14d9c15..c8af378 100644 --- a/examples/widgets/tabular_views/custom/choose.py +++ b/examples/ui/tabular_views/custom/choose.py @@ -1,5 +1,5 @@ """ -summary: A widget showing data in a tabular fashion +summary: show tabular data description: Shows how to subclass the ida_kernwin.Choose class to @@ -9,6 +9,8 @@ description: keywords: chooser, actions see_also: choose_multi, chooser_with_folders + +level: intermediate """ import ida_kernwin diff --git a/examples/widgets/tabular_views/custom/choose_multi.py b/examples/ui/tabular_views/custom/choose_multi.py similarity index 94% rename from examples/widgets/tabular_views/custom/choose_multi.py rename to examples/ui/tabular_views/custom/choose_multi.py index 6f55678..532a3a0 100644 --- a/examples/widgets/tabular_views/custom/choose_multi.py +++ b/examples/ui/tabular_views/custom/choose_multi.py @@ -1,5 +1,5 @@ """ -summary: A widget showing data in a tabular fashion, providing multiple selection +summary: show tabular data, with multiple selection description: Similar to @{choose}, but with multiple selection @@ -7,6 +7,8 @@ description: keywords: chooser, actions see_also: choose, chooser_with_folders + +level: intermediate """ from ida_kernwin import Choose diff --git a/examples/widgets/tabular_views/custom/chooser_with_folders.py b/examples/ui/tabular_views/custom/chooser_with_folders.py similarity index 98% rename from examples/widgets/tabular_views/custom/chooser_with_folders.py rename to examples/ui/tabular_views/custom/chooser_with_folders.py index f9ad2e9..c719b49 100644 --- a/examples/widgets/tabular_views/custom/chooser_with_folders.py +++ b/examples/ui/tabular_views/custom/chooser_with_folders.py @@ -1,6 +1,5 @@ """ -summary: A widget that can show tabular data either as a simple table, - or with a tree-like structure. +summary: showing tabular data in a flat, or tree-like fashion description: By adding the necessary bits to a ida_kernwin.Choose subclass, @@ -16,6 +15,8 @@ description: keywords: chooser, folders, actions see_also: choose, choose_multi + +level: advanced """ import inspect diff --git a/examples/widgets/tabular_views/custom/func_chooser.py b/examples/ui/tabular_views/custom/func_chooser.py similarity index 95% rename from examples/widgets/tabular_views/custom/func_chooser.py rename to examples/ui/tabular_views/custom/func_chooser.py index 018e15d..c5c188d 100644 --- a/examples/widgets/tabular_views/custom/func_chooser.py +++ b/examples/ui/tabular_views/custom/func_chooser.py @@ -1,5 +1,5 @@ """ -summary: An alternative view over the list of functions +summary: implement an alternative "Functions" window description: Partially re-implements the "Functions" widget present in @@ -8,6 +8,8 @@ description: keywords: chooser, functions see_also: choose, choose_multi, chooser_with_folders + +level: intermediate """ import idautils diff --git a/examples/widgets/tabular_views/custom/lazy_loaded_chooser.py b/examples/ui/tabular_views/custom/lazy_loaded_chooser.py similarity index 90% rename from examples/widgets/tabular_views/custom/lazy_loaded_chooser.py rename to examples/ui/tabular_views/custom/lazy_loaded_chooser.py index bb1006f..711e82c 100644 --- a/examples/widgets/tabular_views/custom/lazy_loaded_chooser.py +++ b/examples/ui/tabular_views/custom/lazy_loaded_chooser.py @@ -1,3 +1,19 @@ +""" +summary: a lazy-loaded, tree-like data view + +description: + Brings lazy-loading of folders to the tree-like tabular views. + + The important bit to enable this are: + + * ida_kernwin.Choose.OnLazyLoadDir + +keywords: chooser, folders, actions + +see_also: choose, choose_multi, chooser_with_folders + +level: advanced +""" import idaapi diff --git a/examples/widgets/tabular_views/string_window/show_selected_strings.py b/examples/ui/tabular_views/string_window/show_selected_strings.py similarity index 97% rename from examples/widgets/tabular_views/string_window/show_selected_strings.py rename to examples/ui/tabular_views/string_window/show_selected_strings.py index 69d3905..ddd9a2c 100644 --- a/examples/widgets/tabular_views/string_window/show_selected_strings.py +++ b/examples/ui/tabular_views/string_window/show_selected_strings.py @@ -1,5 +1,5 @@ """ -summary: retrieve the strings that are selected in the "Strings" window. +summary: retrieve the selection from the "Strings" window description: In IDA it's possible to write actions that can be applied even to @@ -13,6 +13,8 @@ description: keywords: actions see_also: list_strings + +level: intermediate """ import ida_kernwin diff --git a/examples/core/trigger_actions_programmatically.py b/examples/ui/trigger_actions_programmatically.py similarity index 97% rename from examples/core/trigger_actions_programmatically.py rename to examples/ui/trigger_actions_programmatically.py index eafaa55..3de177c 100644 --- a/examples/core/trigger_actions_programmatically.py +++ b/examples/ui/trigger_actions_programmatically.py @@ -1,5 +1,5 @@ """ -summary: execute existing actions programmatically +summary: trigger actions programmatically description: It's possible to invoke any action programmatically, by using @@ -13,6 +13,8 @@ description: 'ProcessUiActions' part work as intended. keywords: actions + +level: intermediate """ import ida_kernwin diff --git a/examples/uihooks/func_chooser_coloring.py b/examples/ui/uihooks/func_chooser_coloring.py similarity index 85% rename from examples/uihooks/func_chooser_coloring.py rename to examples/ui/uihooks/func_chooser_coloring.py index 606660c..0085971 100644 --- a/examples/uihooks/func_chooser_coloring.py +++ b/examples/ui/uihooks/func_chooser_coloring.py @@ -1,9 +1,13 @@ """ -summary: using `ida_kernwin.UI_Hooks.get_chooser_item_attrs` to override some defaults +summary: override the default "Functions" chooser colors description: color the function in the Function window according to its size. The larger the function, the darker the color. + + The key, is overriding `ida_kernwin.UI_Hooks.get_chooser_item_attrs` + +level: beginner """ import ida_kernwin diff --git a/examples/uihooks/lines_rendering.py b/examples/ui/uihooks/lines_rendering.py similarity index 98% rename from examples/uihooks/lines_rendering.py rename to examples/ui/uihooks/lines_rendering.py index 12315b2..76ac9c2 100644 --- a/examples/uihooks/lines_rendering.py +++ b/examples/ui/uihooks/lines_rendering.py @@ -1,11 +1,13 @@ """ -summary: dynamically colorize lines backgrounds (or parts of them) +summary: dynamically colorize [parts of] lines description: shows how one can dynamically alter the lines background rendering (as opposed to, say, using ida_nalt.set_item_color()), and also shows how that rendering can be limited to just a few glyphs, not the whole line. + +level: intermediate """ import ida_kernwin diff --git a/examples/uihooks/log_misc_events.py b/examples/ui/uihooks/log_misc_events.py similarity index 98% rename from examples/uihooks/log_misc_events.py rename to examples/ui/uihooks/log_misc_events.py index e4eb4da..ac970bd 100644 --- a/examples/uihooks/log_misc_events.py +++ b/examples/ui/uihooks/log_misc_events.py @@ -1,9 +1,11 @@ """ -summary: being notified, and logging a few UI events +summary: react to UI events/notifications description: hooks to be notified about certain UI events, and dump their information to the "Output" window + +level: intermediate """ import inspect diff --git a/examples/uihooks/prevent_jump.py b/examples/ui/uihooks/prevent_jump.py similarity index 89% rename from examples/uihooks/prevent_jump.py rename to examples/ui/uihooks/prevent_jump.py index 47bf6a1..d83df37 100644 --- a/examples/uihooks/prevent_jump.py +++ b/examples/ui/uihooks/prevent_jump.py @@ -1,10 +1,12 @@ """ -summary: taking precedence over actions +summary: prevent an action from being triggered description: Using `ida_kernwin.UI_Hooks.preprocess_action`, it is possible to respond to a command instead of the action that would otherwise do it. + +level: beginner """ import ida_kernwin diff --git a/examples/widgets/waitbox/show_and_hide_waitbox.py b/examples/ui/waitbox/show_and_hide_waitbox.py similarity index 93% rename from examples/widgets/waitbox/show_and_hide_waitbox.py rename to examples/ui/waitbox/show_and_hide_waitbox.py index 800850a..575e98a 100644 --- a/examples/widgets/waitbox/show_and_hide_waitbox.py +++ b/examples/ui/waitbox/show_and_hide_waitbox.py @@ -1,10 +1,12 @@ """ -summary: showing, updating & hiding the progress dialog +summary: show, update & hide the progress dialog description: Using the progress dialog (aka 'wait box') primitives. keywords: actions + +level: beginner """ import time diff --git a/extapi.cpp b/extapi.cpp index 19743b8..d6c54e0 100644 --- a/extapi.cpp +++ b/extapi.cpp @@ -71,6 +71,7 @@ bool ext_api_t::load(qstring *errbuf) BIND_SYMBOL(_PyLong_AsByteArray); BIND_SYMBOL_WEAK(PyEval_ThreadsInitialized); BIND_SYMBOL_WEAK(PyEval_InitThreads); + BIND_SYMBOL_WEAK(Py_NoSiteFlag); #undef BIND_SYMBOL @@ -90,24 +91,34 @@ void ext_api_t::clear() //------------------------------------------------------------------------- bool ext_api_t::load(qstring *errbuf) { - QASSERT(30603, lib_path.empty() && lib_handle == nullptr); - - // First, let's figure out the library to load - Dl_info dl_info; - memset(&dl_info, 0, sizeof(dl_info)); - int rc = dladdr((void *) Py_IsInitialized, &dl_info); - if ( rc == 0 ) + if ( !lib_path.empty() && lib_handle != nullptr ) { - *errbuf = "Cannot determine path to shared object"; - return false; + return true; } + // QASSERT(30603, lib_path.empty() && lib_handle == nullptr); - lib_path = dl_info.dli_fname; - lib_handle = dlopen(lib_path.c_str(), RTLD_NOLOAD | RTLD_GLOBAL | RTLD_LAZY); - if ( lib_handle == nullptr ) + // first, check if we have global symbols + if ( dlsym(RTLD_DEFAULT, "Py_IsInitialized") != nullptr ) + lib_handle = RTLD_DEFAULT; + else { - errbuf->sprnt("dlopen(\"%s\") failed: %s", lib_path.c_str(), qstrerror(-1)); - return false; + // otherwise, look for shared library to import from + Dl_info dl_info; + memset(&dl_info, 0, sizeof(dl_info)); + int rc = dladdr((void *) Py_IsInitialized, &dl_info); + if ( rc == 0 ) + { + *errbuf = "Cannot determine path to shared object"; + return false; + } + + lib_path = dl_info.dli_fname; + lib_handle = dlopen(lib_path.c_str(), RTLD_NOLOAD | RTLD_GLOBAL | RTLD_LAZY); + if ( lib_handle == nullptr ) + { + errbuf->sprnt("dlopen(\"%s\") failed: %s", lib_path.c_str(), qstrerror(-1)); + return false; + } } #define BIND_SYMBOL(Name) \ @@ -132,6 +143,7 @@ bool ext_api_t::load(qstring *errbuf) BIND_SYMBOL(PyFunction_New); BIND_SYMBOL(PyFunction_GetCode); BIND_SYMBOL(_PyLong_AsByteArray); + BIND_SYMBOL(Py_NoSiteFlag); #undef BIND_SYMBOL @@ -143,7 +155,8 @@ void ext_api_t::clear() { if ( lib_handle != nullptr ) { - dlclose(lib_handle); + if ( lib_handle != RTLD_DEFAULT ) + dlclose(lib_handle); lib_handle = nullptr; } } diff --git a/extapi.hpp b/extapi.hpp index 2fcaebd..852f299 100644 --- a/extapi.hpp +++ b/extapi.hpp @@ -31,6 +31,7 @@ typedef int _PyLong_AsByteArray_t(PyObject *, unsigned char *, size_t, int, int) typedef int PyEval_ThreadsInitialized_t(void); typedef void PyEval_InitThreads_t(void); +typedef int Py_NoSiteFlag_t; struct ext_api_t { @@ -51,6 +52,7 @@ struct ext_api_t _PyLong_AsByteArray_t *_PyLong_AsByteArray_ptr; PyEval_ThreadsInitialized_t *PyEval_ThreadsInitialized_ptr; PyEval_InitThreads_t *PyEval_InitThreads_ptr; + int *Py_NoSiteFlag_ptr; ext_api_t() { memset(this, 0, sizeof(*this)); } ~ext_api_t() { clear(); } diff --git a/idapython.cfg b/idapython.cfg index c10b706..b85bc00 100644 --- a/idapython.cfg +++ b/idapython.cfg @@ -21,5 +21,5 @@ NAMESPACE_AWARE = YES // Should results be printed by 'sys.displayhook'? REPL_USE_SYS_DISPLAYHOOK = YES -// Should directories derived from $IDAUSR (e.g., ~/.idapro/python/3) be added to sys.path? +// Should directories derived from $IDAUSR (e.g., ~/.idapro/python) be added to sys.path? IDAPYTHON_IDAUSR_SYSPATH = YES diff --git a/idapython.cpp b/idapython.cpp index c67063d..ae88326 100644 --- a/idapython.cpp +++ b/idapython.cpp @@ -10,8 +10,20 @@ //--------------------------------------------------------------------- // python.cpp - Main plugin code //--------------------------------------------------------------------- +#if defined(_DEBUG) && defined(Py_LIMITED_API) && defined(_MSC_VER) && _MSC_VER >= 1929 +// Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, and Py_REF_DEBUG +// it would also try to link python3Y_d.lib which is not present in normal Python install +# include // for _invalid_parameter() +#undef _DEBUG +#define _WASDEBUG +#endif #include - +#ifdef __MAC__ +extern "C" __attribute__((weak)) int Py_IsInitialized(void); +#endif +#ifdef _WASDEBUG +#define _DEBUG +#endif //------------------------------------------------------------------------- // This define fixes the redefinition of ssize_t #ifdef HAVE_SSIZE_T @@ -26,6 +38,7 @@ #include #include #include +#include #include #include @@ -44,18 +57,18 @@ idapython_plugin_t *idapython_plugin_t::instance = nullptr; // Python-style version tuple comes from the makefile // Only the serial and status is set here -#define VER_SERIAL 0 -#define VER_STATUS "final" -#define IDAPYTHON_RUNSTATEMENT 0 -#define IDAPYTHON_ENABLE_EXTLANG 3 -#define IDAPYTHON_DISABLE_EXTLANG 4 -#define PYTHON_DIR_NAME "python" -#define S_IDAPYTHON "IDAPython" -#define S_INIT_PY "init.py" -static const char S_IDC_ARGS_VARNAME[] = "ARGV"; -static const char S_IDC_EXEC_PYTHON[] = "exec_python"; -static const char S_IDC_EVAL_PYTHON[] = "eval_python"; -static const char S_IDAPYTHON_DATA_NODE[] = "IDAPython_Data"; +#define IDAPYTHON_RUNSTATEMENT 0 +#define IDAPYTHON_ENABLE_EXTLANG 3 +#define IDAPYTHON_DISABLE_EXTLANG 4 +#define PYTHON_DIR_NAME "python" +#define S_IDAPYTHON "IDAPython" +#define S_INIT_PY "init.py" +static const char S_IDC_ARGS_VARNAME[] = "ARGV"; +static const char S_IDC_EXEC_PYTHON[] = "exec_python"; +static const char S_IDC_EXEC_PYTHON_SCRIPT[] = "exec_python_script"; +static const char S_IDC_EVAL_PYTHON[] = "eval_python"; +static const char S_IDC_EVAL_PYTHON_REPL_STMT[] = "eval_python_repl_stmt"; +static const char S_IDAPYTHON_DATA_NODE[] = "IDAPython_Data"; //lint -e818 could be pointer to const //lint -e1762 member function '' could be made const @@ -416,10 +429,8 @@ static void handle_python_error( errbuf->clear(); // No exception? - if ( !PyErr_Occurred() ) - return; - - PyW_GetError(errbuf, clear_error); + if ( PyErr_Occurred() ) + PyW_GetError(errbuf, clear_error); } //------------------------------------------------------------------------- @@ -487,6 +498,59 @@ static const ext_idcfunc_t idc_eval_python_desc = 0 }; +//------------------------------------------------------------------------- +// A utility for simulating REPL input from IDC + +static error_t idaapi idc_eval_python_repl_stmt( + idc_value_t *argv, + idc_value_t * /*res*/) +{ + qstring buf(argv[0].qstr()); + // We need an extra `\n` to close the statement for `cli_execute_line` + if ( !buf.ends_with("\n") ) + buf.append('\n'); + idapython_plugin_t::cli_execute_line(buf.c_str()); + return eOk; +} + +static const char idc_eval_python_repl_stmt_args[] = { VT_STR, 0 }; +static const ext_idcfunc_t idc_eval_python_repl_stmt_desc = +{ + S_IDC_EVAL_PYTHON_REPL_STMT, + idc_eval_python_repl_stmt, + idc_eval_python_repl_stmt_args, + nullptr, + 0, + 0 +}; + +//------------------------------------------------------------------------- +// A utility for executing a script from IDC +static error_t idaapi idc_exec_python_script( + idc_value_t *argv, + idc_value_t *res) +{ + qstring errbuf; + const char *path = argv[0].c_str(); + bool ok = idapython_plugin_t::exec_script(path, /*gloabls*/ nullptr, &errbuf); + if ( !ok ) + return throw_idc_exception(res, errbuf.c_str()); + return eOk; +} + +static const char idc_exec_python_script_args[] = { VT_STR, 0 }; +static const ext_idcfunc_t idc_exec_python_script_desc = +{ + S_IDC_EXEC_PYTHON_SCRIPT, + idc_exec_python_script, + idc_exec_python_script_args, + nullptr, + 0, + 0 +}; + + + //-------------------------------------------------------------------------- static const cfgopt_t opts[] = { @@ -672,8 +736,7 @@ static const cli_t cli_python = "Python - IDAPython plugin", "Enter any Python expression", idapython_plugin_t::cli_execute_line, - nullptr, - nullptr, + nullptr, // keydown idapython_plugin_t::cli_find_completions, }; @@ -740,31 +803,10 @@ static void send_modules_lifecycle_notification(module_lifecycle_notification_t } } -//------------------------------------------------------------------------- -static wchar_t *utf8_wchar_t(qvector *out, const char *in) -{ -#ifdef __NT__ - qwstring tmp; - utf8_utf16(&tmp, in); - out->qclear(); - out->insert(out->begin(), tmp.begin(), tmp.end()); -#else - const char *p = in; - while ( *p != '\0' ) - { - wchar32_t cp = get_utf8_char(&p); - if ( cp == 0 || cp == BADCP ) - break; - out->push_back(cp); - } - out->push_back(0); // we're not dealing with a qstring; have to do it ourselves -#endif - return out->begin(); -} - //------------------------------------------------------------------------- idapython_plugin_t::idapython_plugin_t() : initialized(false), + owning_interpreter(true), ui_ready(false) #ifdef TESTABLE_BUILD , user_code_lenient(-1) @@ -783,7 +825,7 @@ idapython_plugin_t::~idapython_plugin_t() if ( !initialized || Py_IsInitialized() == 0 ) goto SKIP_CLEANUP; - if ( PyGILState_GetThisThreadState() ) + if ( owning_interpreter && PyGILState_GetThisThreadState() ) { // Note: No 'PYW_GIL_GET' here, as it would try to release // the state after 'Py_Finalize()' has been called. @@ -802,17 +844,24 @@ idapython_plugin_t::~idapython_plugin_t() enable_python_cli(false); // Remove the extlang - remove_extlang(&extlang_python); + if ( extlang_python.refcnt > 0 ) // avoid interr 1442 + remove_extlang(&extlang_python); // De-init pywraps deinit_pywraps(); // Uninstall IDC function del_idc_func(idc_eval_python_desc.name); + del_idc_func(idc_eval_python_repl_stmt_desc.name); + del_idc_func(idc_exec_python_script_desc.name); del_idc_func(idc_runpythonstatement_desc.name); - // Shut the interpreter down - Py_Finalize(); + if ( owning_interpreter ) + { + // Shut the interpreter down if we launched it + Py_Finalize(); + } + initialized = false; #ifdef TESTABLE_BUILD @@ -828,6 +877,37 @@ SKIP_CLEANUP: instance = nullptr; } +#ifdef __NT__ +#define PYEXE "python.exe" +#else +#define PYEXE "python3" +#endif + +//-------------------------------------------------------------------------- +// detect if we're running under venv +// 1. check for IDAPYTHON_VENV_EXECUTABLE override +// 2. check for python3/python.exe in PATH and pyvenv.cfg one level up +static bool detect_venv(qstring *venv_exec_path) +{ + if ( qgetenv("IDAPYTHON_VENV_EXECUTABLE", venv_exec_path) + && qfileexist(venv_exec_path->c_str()) ) + return true; + char exepath[QMAXPATH]; + char cfgpath[QMAXPATH]; + if ( search_path(exepath, sizeof(exepath), PYEXE, false) ) + { + qdirname(cfgpath, sizeof(cfgpath), exepath); + qmakepath(cfgpath, sizeof(cfgpath), cfgpath, "..","pyvenv.cfg", nullptr); + if ( qfileexist(cfgpath) ) + { + *venv_exec_path = exepath; + return true; + } + } + venv_exec_path->clear(); + return false; + +} #ifdef __NT__ // for MessageBox() #pragma comment(lib, "user32") @@ -866,6 +946,7 @@ static void exithandler(void) } } + //lint -e2761 call to non-async-signal-safe function '' within signal handler '' //lint -e2762 call to signal registration function 'signal' within signal handler 'aborthandler' //------------------------------------------------------------------------- @@ -888,7 +969,7 @@ static void aborthandler(int sig) // Initialize the Python environment bool idapython_plugin_t::init() { - if ( Py_IsInitialized() != 0 ) + if ( initialized ) return true; // Read configuration @@ -902,7 +983,7 @@ bool idapython_plugin_t::init() // Form the absolute path to IDA\python folder { char buf[QMAXPATH]; - qmakepath(buf, sizeof(buf), idadir(PYTHON_DIR_NAME), QSTRINGIZE(PY_MAJOR_VERSION), nullptr); + qmakepath(buf, sizeof(buf), idadir(PYTHON_DIR_NAME), nullptr); idapython_dir = buf; } @@ -920,31 +1001,6 @@ bool idapython_plugin_t::init() return false; } -#ifdef __MAC__ - if ( !extapi.lib_path.empty() ) - { - // On OSX we should explicitly call Py_SetPythonHome(). - // When using the system Python installation, sys.path will contain paths to other - // Python installations if they appear in $PATH. This can cause fatal errors during - // the system python's initialization. - // - // Note: The path will be something like: - // /System/Library/Frameworks/Python.framework/Versions/2.5/Python - // We need to strip the last part. - // - // Also, use a permanent buffer because Py_SetPythonHome() just stores a pointer - char utf8_pyhomepath[MAXSTR]; - qstrncpy(utf8_pyhomepath, extapi.lib_path.c_str(), sizeof(utf8_pyhomepath)); - char *lastslash = strrchr(utf8_pyhomepath, '/'); - if ( lastslash != nullptr ) - { - *lastslash = 0; - utf8_wchar_t(&pyhomepath, utf8_pyhomepath); - Py_SetPythonHome(pyhomepath.begin()); - } - } -#endif - if ( config.alert_auto_scripts ) { if ( pywraps_check_autoscripts(path, sizeof(path)) @@ -967,98 +1023,146 @@ bool idapython_plugin_t::init() // ... and exit() atexit(exithandler); - // Start the interpreter - Py_InitializeEx(0 /* Don't catch SIGPIPE, SIGXFZ, SIGXFSZ & SIGINT signals */); - // disable handlers - initdone = 1; - signal(SIGABRT, previousHandler); + // If a virtual environment is requested, we defer the loading of + // the site module until after we updated sys.executable. The site + // module will look for a pyvenv.cfg one level above the interpreter + // and take care of setting site-packages properly. - if ( !Py_IsInitialized() ) + qstring venv_exec_path; + bool venv_requested = detect_venv(&venv_exec_path); + venv_requested = venv_exec_path.size() > 0 && extapi.Py_NoSiteFlag_ptr != nullptr; + + if ( venv_requested ) { - warning("IDAPython: Py_InitializeEx() failed"); - return false; + *extapi.Py_NoSiteFlag_ptr = 1; + msg("IDAPython: Requested to use virtual environment interpreter at %s\n", venv_exec_path.c_str()); + } + + if ( Py_IsInitialized() == 0 ) + { + // Start the interpreter + Py_InitializeEx(0 /* Don't catch SIGPIPE, SIGXFZ, SIGXFSZ & SIGINT signals */); + // disable handlers + initdone = 1; + signal(SIGABRT, previousHandler); + + if ( !Py_IsInitialized() ) + { + warning("IDAPython: Py_InitializeEx() failed"); + return false; + } + owning_interpreter = true; + } + else + { + // We are running under Python, the interpreter was not loaded by us + owning_interpreter = false; + initdone = 1; } // add new Python keywords as needed python_highlighter.add_new_keywords(); - // remove current directory - _prepare_sys_path(); - - if ( extapi.PyEval_ThreadsInitialized_ptr != nullptr - && extapi.PyEval_InitThreads_ptr != nullptr ) { - // Enable multi-threading support (before 3.9 - if ( !extapi.PyEval_ThreadsInitialized_ptr() ) - extapi.PyEval_InitThreads_ptr(); - } + // Aquire Global Interpreter Lock (GIL), ensure current thread is allowed to execute Python code + // This is needed when running idalib from Python and is harmless when running inside IDA + PYW_GIL_GET; + + // remove current directory + _prepare_sys_path(); + + if ( extapi.PyEval_ThreadsInitialized_ptr != nullptr + && extapi.PyEval_InitThreads_ptr != nullptr ) + { + // Enable multi-threading support (before 3.9 + if ( !extapi.PyEval_ThreadsInitialized_ptr() ) + extapi.PyEval_InitThreads_ptr(); + } #ifdef Py_DEBUG - msg("HexraysPython: Python compiled with DEBUG enabled.\n"); + msg("HexraysPython: Python compiled with DEBUG enabled.\n"); #endif - qstring dynload_base; - if ( !qgetenv("IDAPYTHON_DYNLOAD_BASE", &dynload_base) ) - dynload_base = idadir(nullptr); + qstring dynload_base; + if ( !qgetenv("IDAPYTHON_DYNLOAD_BASE", &dynload_base) ) + dynload_base = idadir(nullptr); - // Set IDAPYTHON_VERSION in Python - qstring init_code; - init_code.sprnt( - "IDAPYTHON_VERSION=(%d, %d, %d, '%s', %d)\n" - "IDAPYTHON_REMOVE_CWD_SYS_PATH = %s\n" - "IDAPYTHON_DYNLOAD_BASE = r\"%s\"\n" - "IDAPYTHON_DYNLOAD_RELPATH = \"ida_%" FMT_Z "\"\n" - "IDAPYTHON_COMPAT_AUTOIMPORT_MODULES = %s\n" - "IDAPYTHON_IDAUSR_SYSPATH = %s\n", - VER_MAJOR, VER_MINOR, VER_PATCH, VER_STATUS, VER_SERIAL, - config.remove_cwd_sys_path ? "True" : "False", - dynload_base.c_str(), - sizeof(ea_t)*8, - config.autoimport_compat_idaapi ? "True" : "False", - config.idausr_syspath ? "True" : "False" - ); + // Set IDAPYTHON_VERSION in Python + qstring init_code; + init_code.sprnt( + "IDAPYTHON_VERSION=(%d, %d, %d)\n" + "IDAPYTHON_REMOVE_CWD_SYS_PATH = %s\n" + "IDAPYTHON_DYNLOAD_BASE = r\"%s\"\n" + "IDAPYTHON_COMPAT_AUTOIMPORT_MODULES = %s\n" + "IDAPYTHON_IDAUSR_SYSPATH = %s\n" + "IDAPYTHON_OWNING_INTERPRETER = %s\n" + "IDAPYTHON_VENV_EXECUTABLE = r\"%s\"\n", + IDAVER_MAJOR, IDAVER_MINOR, IDAVER_PATCH, + config.remove_cwd_sys_path ? "True" : "False", + dynload_base.c_str(), + config.autoimport_compat_idaapi ? "True" : "False", + config.idausr_syspath ? "True" : "False", + owning_interpreter ? "True" : "False", + venv_exec_path.c_str() + ); - if ( extapi.PyRun_SimpleStringFlags_ptr(init_code.c_str(), nullptr) != 0 ) - { - warning("IDAPython: error executing bootstrap code"); - return false; - } + if ( extapi.PyRun_SimpleStringFlags_ptr(init_code.c_str(), nullptr) != 0 ) + { + warning("IDAPython: error executing bootstrap code"); + return false; + } - // Install extlang. Needs to be done before running init.py - // in case it's calling idaapi.enable_extlang_python(1) - if ( config.namespace_aware ) - extlang_python.flags |= EXTLANG_NS_AWARE; - install_extlang(&extlang_python); + // Install extlang. Needs to be done before running init.py + // in case it's calling idaapi.enable_extlang_python(1) + if ( config.namespace_aware ) + extlang_python.flags |= EXTLANG_NS_AWARE; + install_extlang(&extlang_python); - // Execute init.py (for Python side initialization) - if ( !_run_init_py() ) - { - // Try to fetch a one line error string. We must do it before printing - // the traceback information. Make sure that the exception is not cleared - handle_python_error(&errbuf, false); + // If loading site was deferred earlier, do it now. + if ( venv_requested ) + { + extapi.PyRun_SimpleStringFlags_ptr( + "import sys\n" + "sys.executable = IDAPYTHON_VENV_EXECUTABLE\n" + "import site\n" + "site.main()\n", + nullptr + ); + } - // Print the exception traceback - extapi.PyRun_SimpleStringFlags_ptr("import traceback;traceback.print_exc();", nullptr); - warning("IDAPython: error executing " S_INIT_PY ":\n" - "%s\n" - "\n" - "Refer to the message window to see the full error log.", errbuf.c_str()); - remove_extlang(&extlang_python); - return false; - } + // Execute init.py (for Python side initialization) + if ( !_run_init_py() ) + { + // Try to fetch a one line error string. We must do it before printing + // the traceback information. Make sure that the exception is not cleared + handle_python_error(&errbuf, /*clear_error=*/ false); - // Init pywraps and notify_when - if ( !init_pywraps() ) - { - warning("IDAPython: init_pywraps() failed!"); - remove_extlang(&extlang_python); - return false; + // Print the exception traceback + extapi.PyRun_SimpleStringFlags_ptr("import traceback;traceback.print_exc();", nullptr); + + warning("IDAPython: error executing " S_INIT_PY ":\n" + "%s\n" + "\n" + "Refer to the message window to see the full error log.", errbuf.c_str()); + remove_extlang(&extlang_python); + return false; + } + + // Init pywraps and notify_when + if ( !init_pywraps() ) + { + warning("IDAPython: init_pywraps() failed!"); + remove_extlang(&extlang_python); + return false; + } } // Register a exec_python() function for IDC add_idc_func(idc_runpythonstatement_desc); add_idc_func(idc_eval_python_desc); + add_idc_func(idc_eval_python_repl_stmt_desc); + add_idc_func(idc_exec_python_script_desc); // A script specified on the command line is run if ( config.run_script.when == RSW_on_init ) @@ -1073,7 +1177,8 @@ bool idapython_plugin_t::init() // Let all modules perform possible initialization send_modules_lifecycle_notification(mln_init); - PyEval_ReleaseThread(PyThreadState_Get()); + if ( owning_interpreter ) + PyEval_ReleaseThread(PyThreadState_Get()); initialized = true; return true; @@ -1239,7 +1344,8 @@ ssize_t idaapi idapython_plugin_t::on_event(ssize_t code, va_list) { PYW_GIL_GET; // See above ui_ready = true; - extapi.PyRun_SimpleStringFlags_ptr("print_banner()", nullptr); + if ( !is_ida_library(nullptr, 0, nullptr) ) + extapi.PyRun_SimpleStringFlags_ptr("print_banner()", nullptr); if ( config.run_script.when == RSW_ui_ready_to_run ) _run_user_script(); } @@ -1281,11 +1387,12 @@ ssize_t idaapi idapython_plugin_t::on_idb_notification(void *, int code, va_list // Compile callback for Python external language evaluator bool idapython_plugin_t::_extlang_compile_file( const char *path, + const char *requested_namespace, qstring *errbuf) { PYW_GIL_GET; new_execution_t exec; - PyObject *globals = _get_module_globals_from_path(path); + PyObject *globals = _get_module_globals_from_path(path, requested_namespace); return _handle_file(path, globals, errbuf); } @@ -1394,7 +1501,9 @@ bool idapython_plugin_t::_extlang_load_procmod( bool ok; { new_execution_t exec; - PyObject *globals = _get_module_globals_from_path(path); + qstring ns; + make_script_ns(&ns, IDP_SUBDIR, path); + PyObject *globals = _get_module_globals_from_path(path, ns.c_str()); ok = _handle_file(path, globals, errbuf, S_IDAAPI_LOADPROCMOD, procobj, /*want_tuple=*/ true); } if ( ok && procobj->is_zero() ) @@ -1413,7 +1522,9 @@ bool idapython_plugin_t::_extlang_unload_procmod( { PYW_GIL_GET; new_execution_t exec; - PyObject *globals = _get_module_globals_from_path(path); + qstring ns; + make_script_ns(&ns, IDP_SUBDIR, path); + PyObject *globals = _get_module_globals_from_path(path, ns.c_str()); return _handle_file(path, globals, errbuf, S_IDAAPI_UNLOADPROCMOD); } @@ -1505,7 +1616,7 @@ bool idapython_plugin_t::_extlang_eval_snippet( globals, globals, nullptr)); - ok = result && !PyErr_Occurred(); //-V560 is always true: !PyErr_Occurred() + ok = result && !PyErr_Occurred(); if ( !ok ) handle_python_error(errbuf); } @@ -1735,7 +1846,7 @@ bool idapython_plugin_t::_extlang_get_attr( if ( !PyUnicode_as_qstring(&clsname, string.o) ) break; - result->set_string(clsname); //-V595 'result' was utilized before it was verified against nullptr + result->set_string(clsname); cvt = CIP_OK; //lint !e838 break; } @@ -1824,6 +1935,50 @@ bool idapython_plugin_t::_extlang_set_attr( return ok; } +//------------------------------------------------------------------------- +// Remove common whitespace prefix (dedent input) +// Returns true if leadig whitespace was trimmed. +static bool strip_leading_whitespace(qstring *lines) +{ + qstrvec_t vec; + lines->split(&vec, "\n"); + + // Traverse all input lines once, looking for a common prefix + size_t min_spaces = SIZE_MAX; + size_t min_tabs = SIZE_MAX; + for ( qstring &s : vec ) + { + // empty lines and comment lines are ignored + if ( s.length() == 0 || s[0] == '#' ) + continue; + + size_t num_spaces = 0; + while ( num_spaces < s.length() && s[num_spaces] == ' ' ) + num_spaces++; + min_spaces = qmin(min_spaces, num_spaces); + + size_t num_tabs = 0; + while ( num_tabs < s.length() && s[num_tabs] == '\t' ) + num_tabs++; + min_tabs = qmin(min_tabs, num_tabs); + } + + if ( min_spaces > 0 && min_tabs > 0 ) + return false; // mix of tabs and spaces is not supported + + size_t prefix_len = min_spaces > 0 ? min_spaces : min_tabs; + if ( prefix_len == 0 ) + return false; + + // If common whitespace prefix was found, remove it + for ( qstring &s : vec ) + if ( s.length() != 0 && s[0] != '#' ) + s.remove(0, prefix_len); + + *lines = qstring::join(vec, "\n"); + return true; +} + //------------------------------------------------------------------------- // Execute a line in the Python CLI bool idapython_plugin_t::_cli_execute_line(const char *line) @@ -1834,6 +1989,10 @@ bool idapython_plugin_t::_cli_execute_line(const char *line) if ( line[0] == '\0' ) return true; + qstring tmp = line; + strip_leading_whitespace(&tmp); + line = tmp.c_str(); + const char *last_line = strrchr(line, '\n'); if ( last_line == nullptr ) last_line = line; @@ -1871,7 +2030,7 @@ bool idapython_plugin_t::_cli_execute_line(const char *line) new_execution_t exec; // Compile as an expression - qstring qstr(line); + qstring qstr = line; newref_t py_code(my_CompileString(insert_encoding_cookie(&qstr), "", Py_eval_input)); if ( !py_code || PyErr_Occurred() ) { @@ -1886,7 +2045,7 @@ bool idapython_plugin_t::_cli_execute_line(const char *line) PyObject *py_globals = _get_module_globals(); newref_t py_result(PyEval_EvalCode(py_code.o, py_globals, py_globals)); - if ( !py_result || PyErr_Occurred() ) //-V560 is always false: PyErr_Occurred() + if ( !py_result || PyErr_Occurred() ) { PyErr_Print(); } @@ -1928,6 +2087,8 @@ bool idapython_plugin_t::_cli_execute_line(const char *line) //------------------------------------------------------------------------- bool idapython_plugin_t::_cli_find_completions( qstrvec_t *out_completions, + qstrvec_t *out_hints, + qstrvec_t *out_docs, int *out_match_start, int *out_match_end, const char *line, @@ -1944,6 +2105,8 @@ bool idapython_plugin_t::_cli_find_completions( return false; return idapython_convert_cli_completions( out_completions, + out_hints, + out_docs, out_match_start, out_match_end, py_res); @@ -2028,7 +2191,7 @@ bool idapython_plugin_t::_handle_file( ret_o = py_ret.o; } - if ( ret_o == Py_None ) //-V614 uninitialized 'ret_o' + if ( ret_o == Py_None ) { if ( want_tuple ) { @@ -2052,6 +2215,17 @@ bool idapython_plugin_t::_handle_file( return ok; } +//------------------------------------------------------------------------- +bool idapython_plugin_t::_exec_script( + const char *path, + PyObject *globals, + qstring *errbuf) +{ + PYW_GIL_GET; + + return _handle_file(path, globals, errbuf); +} + //------------------------------------------------------------------------- // Execute the Python script from the plugin bool idapython_plugin_t::_run_user_script() @@ -2103,7 +2277,7 @@ void idapython_plugin_t::_prepare_sys_path() if ( !path || !PySequence_Check(path.o) ) return; - qstring new_path; + qstrvec_t new_path; Py_ssize_t path_len = PySequence_Size(path.o); if ( path_len > 0 ) { @@ -2115,19 +2289,18 @@ void idapython_plugin_t::_prepare_sys_path() && PyUnicode_Check(path_el.o) && PyUnicode_as_qstring(&path_el_utf8, path_el.o) ) { - if ( path_el_utf8.empty() ) - continue; // skip empty entry - if ( !new_path.empty() ) - new_path.append(DELIMITER); - new_path.append(path_el_utf8); + if ( !path_el_utf8.empty() ) // skip empty entry + new_path.push_back(path_el_utf8); } } } - if ( !new_path.empty() ) - new_path.append(DELIMITER); - new_path.append(idadir("python")); - qvector wpath; - PySys_SetPath(utf8_wchar_t(&wpath, new_path.c_str())); + new_path.push_back(idadir("python")); + + ref_t py_new_path(PyW_StrVecToPyList(new_path)); + // Since `PySys_GetObject` returns a borrowed reference, + // I'm guessing `PySys_SetObject` steals one... + py_new_path.incref(); + PySys_SetObject("path", py_new_path.o); } //------------------------------------------------------------------------- @@ -2191,50 +2364,21 @@ PyObject *idapython_plugin_t::_get_module_globals(const char *modname) return module == nullptr ? nullptr : PyModule_GetDict(module); } -//------------------------------------------------------------------------- -PyObject *idapython_plugin_t::_get_module_globals_from_path_with_kind( - const char *path, - const char *kind) -{ - const char *fname = qbasename(path); - if ( fname != nullptr ) - { - const char *ext = get_file_ext(fname); - if ( ext == nullptr ) - ext = tail(fname); - else - --ext; - if ( ext > fname ) - { - int len = ext - fname; - qstring modname; - modname.sprnt("__%s__%*.*s", kind, len, len, fname); - return _get_module_globals(modname.begin()); - } - } - return nullptr; -} - //------------------------------------------------------------------------- PyObject *idapython_plugin_t::_get_module_globals_from_path( - const char *path) + const char *path, + const char *requested_namespace) { if ( (extlang_python.flags & EXTLANG_NS_AWARE) != 0 ) { + qstring ns; if ( requested_plugin_path == path ) - return _get_module_globals_from_path_with_kind(path, PLG_SUBDIR); - - char dirpath[QMAXPATH]; - if ( qdirname(dirpath, sizeof(dirpath), path) ) { - const char *dirname = qbasename(dirpath); - if ( streq(dirname, PLG_SUBDIR) - || streq(dirname, IDP_SUBDIR) - || streq(dirname, LDR_SUBDIR) ) - { - return _get_module_globals_from_path_with_kind(path, dirname); - } + make_script_ns(&ns, PLG_SUBDIR, path); + requested_namespace = ns.c_str(); } + if ( requested_namespace ) + return _get_module_globals(requested_namespace); } return nullptr; } @@ -2243,10 +2387,17 @@ PyObject *idapython_plugin_t::_get_module_globals_from_path( // Plugin init routine static plugmod_t *idaapi init() { - idapython_plugin_t *p = new idapython_plugin_t; - if ( p->init() ) - return p; - delete p; +#ifdef __MAC__ + // on macOS we link weakly against python so it's best to verify that + // the python symbols have been resolved before using them + if ( Py_IsInitialized != nullptr ) +#endif + { + idapython_plugin_t *p = new idapython_plugin_t; + if ( p->init() ) + return p; + delete p; + } return nullptr; } diff --git a/idapython.script b/idapython.script index ea0519d..396fa3f 100644 --- a/idapython.script +++ b/idapython.script @@ -21,6 +21,7 @@ global: PyW_SizeVecToPyList; PyW_UvalVecToPyList; PyW_StrVecToPyList; + PyW_TidVecToPyList; PyW_TryGetAttrString; PyW_TryImportModule; PyW_register_compiled_form; @@ -29,6 +30,7 @@ global: disable_script_timeout; enable_extlang_python; enable_python_cli; + idapython_convert_cli_completions; idapython_hook_to_notification_point; idapython_unhook_from_notification_point; idapython_register_hook; diff --git a/idapython_implib.def b/idapython_implib.def index e0b7814..7904896 100644 --- a/idapython_implib.def +++ b/idapython_implib.def @@ -7,6 +7,7 @@ EXPORTS PyW_SizeVecToPyList PyW_UvalVecToPyList PyW_StrVecToPyList + PyW_TidVecToPyList PyW_IsSequenceType PyW_ObjectToString PyW_PySeqToEaVec @@ -65,6 +66,7 @@ EXPORTS til_register_python_udt_type_data_t_instance try_create_swig_wrapper get_callable_arg_count + idapython_convert_cli_completions idapython_hook_to_notification_point idapython_unhook_from_notification_point idapython_register_hook diff --git a/libpython3.tbd b/libpython3.tbd deleted file mode 100644 index 908492a..0000000 --- a/libpython3.tbd +++ /dev/null @@ -1,552 +0,0 @@ ---- !tapi-tbd -tbd-version: 4 -targets: [ arm64-macos, x86_64-macos ] -install-name: '@executable_path/libpython3.link.dylib' -current-version: 3.9 -compatibility-version: 3.9 -exports: - - targets: [ arm64-macos, x86_64-macos ] - symbols: [ _PyAST_CompileEx, _PyAST_CompileObject, _PyAST_FromNode, _PyAST_FromNodeObject, - _PyAST_Validate, _PyArena_AddPyObject, _PyArena_Free, _PyArena_Malloc, - _PyArena_New, _PyArg_Parse, _PyArg_ParseTuple, _PyArg_ParseTupleAndKeywords, - _PyArg_UnpackTuple, _PyArg_VaParse, _PyArg_VaParseTupleAndKeywords, - _PyArg_ValidateKeywordArguments, _PyAsyncGen_New, _PyAsyncGen_Type, - _PyBaseObject_Type, _PyBool_FromLong, _PyBool_Type, _PyBuffer_FillContiguousStrides, - _PyBuffer_FillInfo, _PyBuffer_FromContiguous, _PyBuffer_GetPointer, - _PyBuffer_IsContiguous, _PyBuffer_Release, _PyBuffer_SizeFromFormat, - _PyBuffer_ToContiguous, _PyByteArrayIter_Type, _PyByteArray_AsString, - _PyByteArray_Concat, _PyByteArray_FromObject, _PyByteArray_FromStringAndSize, - _PyByteArray_Resize, _PyByteArray_Size, _PyByteArray_Type, - _PyBytesIter_Type, _PyBytes_AsString, _PyBytes_AsStringAndSize, - _PyBytes_Concat, _PyBytes_ConcatAndDel, _PyBytes_DecodeEscape, - _PyBytes_FromFormat, _PyBytes_FromFormatV, _PyBytes_FromObject, - _PyBytes_FromString, _PyBytes_FromStringAndSize, _PyBytes_Repr, - _PyBytes_Size, _PyBytes_Type, _PyCFunction_Call, _PyCFunction_GetFlags, - _PyCFunction_GetFunction, _PyCFunction_GetSelf, _PyCFunction_NewEx, - _PyCFunction_Type, _PyCMethod_New, _PyCMethod_Type, _PyCallIter_New, - _PyCallIter_Type, _PyCallable_Check, _PyCapsule_GetContext, - _PyCapsule_GetDestructor, _PyCapsule_GetName, _PyCapsule_GetPointer, - _PyCapsule_Import, _PyCapsule_IsValid, _PyCapsule_New, _PyCapsule_SetContext, - _PyCapsule_SetDestructor, _PyCapsule_SetName, _PyCapsule_SetPointer, - _PyCapsule_Type, _PyCell_Get, _PyCell_New, _PyCell_Set, _PyCell_Type, - _PyClassMethodDescr_Type, _PyClassMethod_New, _PyClassMethod_Type, - _PyCode_Addr2Line, _PyCode_New, _PyCode_NewEmpty, _PyCode_NewWithPosOnlyArgs, - _PyCode_Optimize, _PyCode_Type, _PyCodec_BackslashReplaceErrors, - _PyCodec_Decode, _PyCodec_Decoder, _PyCodec_Encode, _PyCodec_Encoder, - _PyCodec_IgnoreErrors, _PyCodec_IncrementalDecoder, _PyCodec_IncrementalEncoder, - _PyCodec_KnownEncoding, _PyCodec_LookupError, _PyCodec_NameReplaceErrors, - _PyCodec_Register, _PyCodec_RegisterError, _PyCodec_ReplaceErrors, - _PyCodec_StreamReader, _PyCodec_StreamWriter, _PyCodec_StrictErrors, - _PyCodec_XMLCharRefReplaceErrors, _PyCompile_OpcodeStackEffect, - _PyCompile_OpcodeStackEffectWithJump, _PyComplex_AsCComplex, - _PyComplex_FromCComplex, _PyComplex_FromDoubles, _PyComplex_ImagAsDouble, - _PyComplex_RealAsDouble, _PyComplex_Type, _PyConfig_Clear, - _PyConfig_InitIsolatedConfig, _PyConfig_InitPythonConfig, - _PyConfig_Read, _PyConfig_SetArgv, _PyConfig_SetBytesArgv, - _PyConfig_SetBytesString, _PyConfig_SetString, _PyConfig_SetWideStringList, - _PyContextToken_Type, _PyContextVar_Get, _PyContextVar_New, - _PyContextVar_Reset, _PyContextVar_Set, _PyContextVar_Type, - _PyContext_Copy, _PyContext_CopyCurrent, _PyContext_Enter, - _PyContext_Exit, _PyContext_New, _PyContext_Type, _PyCoro_New, - _PyCoro_Type, _PyDescr_NewClassMethod, _PyDescr_NewGetSet, - _PyDescr_NewMember, _PyDescr_NewMethod, _PyDescr_NewWrapper, - _PyDictItems_Type, _PyDictIterItem_Type, _PyDictIterKey_Type, - _PyDictIterValue_Type, _PyDictKeys_Type, _PyDictProxy_New, - _PyDictProxy_Type, _PyDictRevIterItem_Type, _PyDictRevIterKey_Type, - _PyDictRevIterValue_Type, _PyDictValues_Type, _PyDict_Clear, - _PyDict_Contains, _PyDict_Copy, _PyDict_DelItem, _PyDict_DelItemString, - _PyDict_GetItem, _PyDict_GetItemString, _PyDict_GetItemWithError, - _PyDict_Items, _PyDict_Keys, _PyDict_Merge, _PyDict_MergeFromSeq2, - _PyDict_New, _PyDict_Next, _PyDict_SetDefault, _PyDict_SetItem, - _PyDict_SetItemString, _PyDict_Size, _PyDict_Type, _PyDict_Update, - _PyDict_Values, _PyEllipsis_Type, _PyEnum_Type, _PyErr_BadArgument, - _PyErr_BadInternalCall, _PyErr_CheckSignals, _PyErr_Clear, - _PyErr_Display, _PyErr_ExceptionMatches, _PyErr_Fetch, _PyErr_Format, - _PyErr_FormatV, _PyErr_GetExcInfo, _PyErr_GivenExceptionMatches, - _PyErr_NewException, _PyErr_NewExceptionWithDoc, _PyErr_NoMemory, - _PyErr_NormalizeException, _PyErr_Occurred, _PyErr_Print, - _PyErr_PrintEx, _PyErr_ProgramText, _PyErr_ProgramTextObject, - _PyErr_ResourceWarning, _PyErr_Restore, _PyErr_SetExcInfo, - _PyErr_SetFromErrno, _PyErr_SetFromErrnoWithFilename, _PyErr_SetFromErrnoWithFilenameObject, - _PyErr_SetFromErrnoWithFilenameObjects, _PyErr_SetImportError, - _PyErr_SetImportErrorSubclass, _PyErr_SetInterrupt, _PyErr_SetNone, - _PyErr_SetObject, _PyErr_SetString, _PyErr_SyntaxLocation, - _PyErr_SyntaxLocationEx, _PyErr_SyntaxLocationObject, _PyErr_WarnEx, - _PyErr_WarnExplicit, _PyErr_WarnExplicitFormat, _PyErr_WarnExplicitObject, - _PyErr_WarnFormat, _PyErr_WriteUnraisable, _PyEval_AcquireLock, - _PyEval_AcquireThread, _PyEval_CallFunction, _PyEval_CallMethod, - _PyEval_CallObjectWithKeywords, _PyEval_EvalCode, _PyEval_EvalCodeEx, - _PyEval_EvalFrame, _PyEval_EvalFrameEx, _PyEval_GetBuiltins, - _PyEval_GetFrame, _PyEval_GetFuncDesc, _PyEval_GetFuncName, - _PyEval_GetGlobals, _PyEval_GetLocals, _PyEval_InitThreads, - _PyEval_MergeCompilerFlags, _PyEval_ReleaseLock, _PyEval_ReleaseThread, - _PyEval_RestoreThread, _PyEval_SaveThread, _PyEval_SetProfile, - _PyEval_SetTrace, _PyEval_ThreadsInitialized, _PyExc_ArithmeticError, - _PyExc_AssertionError, _PyExc_AttributeError, _PyExc_BaseException, - _PyExc_BlockingIOError, _PyExc_BrokenPipeError, _PyExc_BufferError, - _PyExc_BytesWarning, _PyExc_ChildProcessError, _PyExc_ConnectionAbortedError, - _PyExc_ConnectionError, _PyExc_ConnectionRefusedError, _PyExc_ConnectionResetError, - _PyExc_DeprecationWarning, _PyExc_EOFError, _PyExc_EnvironmentError, - _PyExc_Exception, _PyExc_FileExistsError, _PyExc_FileNotFoundError, - _PyExc_FloatingPointError, _PyExc_FutureWarning, _PyExc_GeneratorExit, - _PyExc_IOError, _PyExc_ImportError, _PyExc_ImportWarning, - _PyExc_IndentationError, _PyExc_IndexError, _PyExc_InterruptedError, - _PyExc_IsADirectoryError, _PyExc_KeyError, _PyExc_KeyboardInterrupt, - _PyExc_LookupError, _PyExc_MemoryError, _PyExc_ModuleNotFoundError, - _PyExc_NameError, _PyExc_NotADirectoryError, _PyExc_NotImplementedError, - _PyExc_OSError, _PyExc_OverflowError, _PyExc_PendingDeprecationWarning, - _PyExc_PermissionError, _PyExc_ProcessLookupError, _PyExc_RecursionError, - _PyExc_ReferenceError, _PyExc_ResourceWarning, _PyExc_RuntimeError, - _PyExc_RuntimeWarning, _PyExc_StopAsyncIteration, _PyExc_StopIteration, - _PyExc_SyntaxError, _PyExc_SyntaxWarning, _PyExc_SystemError, - _PyExc_SystemExit, _PyExc_TabError, _PyExc_TimeoutError, _PyExc_TypeError, - _PyExc_UnboundLocalError, _PyExc_UnicodeDecodeError, _PyExc_UnicodeEncodeError, - _PyExc_UnicodeError, _PyExc_UnicodeTranslateError, _PyExc_UnicodeWarning, - _PyExc_UserWarning, _PyExc_ValueError, _PyExc_Warning, _PyExc_ZeroDivisionError, - _PyExceptionClass_Name, _PyException_GetCause, _PyException_GetContext, - _PyException_GetTraceback, _PyException_SetCause, _PyException_SetContext, - _PyException_SetTraceback, _PyFile_FromFd, _PyFile_GetLine, - _PyFile_NewStdPrinter, _PyFile_OpenCode, _PyFile_OpenCodeObject, - _PyFile_SetOpenCodeHook, _PyFile_WriteObject, _PyFile_WriteString, - _PyFilter_Type, _PyFloat_AsDouble, _PyFloat_FromDouble, _PyFloat_FromString, - _PyFloat_GetInfo, _PyFloat_GetMax, _PyFloat_GetMin, _PyFloat_Type, - _PyFrame_BlockPop, _PyFrame_BlockSetup, _PyFrame_FastToLocals, - _PyFrame_FastToLocalsWithError, _PyFrame_GetBack, _PyFrame_GetCode, - _PyFrame_GetLineNumber, _PyFrame_LocalsToFast, _PyFrame_New, - _PyFrame_Type, _PyFrozenSet_New, _PyFrozenSet_Type, _PyFunction_GetAnnotations, - _PyFunction_GetClosure, _PyFunction_GetCode, _PyFunction_GetDefaults, - _PyFunction_GetGlobals, _PyFunction_GetKwDefaults, _PyFunction_GetModule, - _PyFunction_New, _PyFunction_NewWithQualName, _PyFunction_SetAnnotations, - _PyFunction_SetClosure, _PyFunction_SetDefaults, _PyFunction_SetKwDefaults, - _PyFunction_Type, _PyFuture_FromAST, _PyFuture_FromASTObject, - _PyGC_Collect, _PyGILState_Check, _PyGILState_Ensure, _PyGILState_GetThisThreadState, - _PyGILState_Release, _PyGen_New, _PyGen_NewWithQualName, _PyGen_Type, - _PyGetSetDescr_Type, _PyHash_GetFuncDef, _PyImport_AddModule, - _PyImport_AddModuleObject, _PyImport_AppendInittab, _PyImport_ExecCodeModule, - _PyImport_ExecCodeModuleEx, _PyImport_ExecCodeModuleObject, - _PyImport_ExecCodeModuleWithPathnames, _PyImport_ExtendInittab, - _PyImport_FrozenModules, _PyImport_GetImporter, _PyImport_GetMagicNumber, - _PyImport_GetMagicTag, _PyImport_GetModule, _PyImport_GetModuleDict, - _PyImport_Import, _PyImport_ImportFrozenModule, _PyImport_ImportFrozenModuleObject, - _PyImport_ImportModule, _PyImport_ImportModuleLevel, _PyImport_ImportModuleLevelObject, - _PyImport_ImportModuleNoBlock, _PyImport_Inittab, _PyImport_ReloadModule, - _PyIndex_Check, _PyInit__abc, _PyInit__ast, _PyInit__codecs, - _PyInit__collections, _PyInit__functools, _PyInit__imp, _PyInit__io, - _PyInit__locale, _PyInit__operator, _PyInit__peg_parser, _PyInit__signal, - _PyInit__sre, _PyInit__stat, _PyInit__string, _PyInit__symtable, - _PyInit__thread, _PyInit__tracemalloc, _PyInit__weakref, _PyInit_atexit, - _PyInit_errno, _PyInit_faulthandler, _PyInit_gc, _PyInit_itertools, - _PyInit_posix, _PyInit_pwd, _PyInit_time, _PyInit_xxsubtype, - _PyInstanceMethod_Function, _PyInstanceMethod_New, _PyInstanceMethod_Type, - _PyInterpreterState_Clear, _PyInterpreterState_Delete, _PyInterpreterState_Get, - _PyInterpreterState_GetDict, _PyInterpreterState_GetID, _PyInterpreterState_Head, - _PyInterpreterState_Main, _PyInterpreterState_New, _PyInterpreterState_Next, - _PyInterpreterState_ThreadHead, _PyIter_Check, _PyIter_Next, - _PyListIter_Type, _PyListRevIter_Type, _PyList_Append, _PyList_AsTuple, - _PyList_GetItem, _PyList_GetSlice, _PyList_Insert, _PyList_New, - _PyList_Reverse, _PyList_SetItem, _PyList_SetSlice, _PyList_Size, - _PyList_Sort, _PyList_Type, _PyLongRangeIter_Type, _PyLong_AsDouble, - _PyLong_AsLong, _PyLong_AsLongAndOverflow, _PyLong_AsLongLong, - _PyLong_AsLongLongAndOverflow, _PyLong_AsSize_t, _PyLong_AsSsize_t, - _PyLong_AsUnsignedLong, _PyLong_AsUnsignedLongLong, _PyLong_AsUnsignedLongLongMask, - _PyLong_AsUnsignedLongMask, _PyLong_AsVoidPtr, _PyLong_FromDouble, - _PyLong_FromLong, _PyLong_FromLongLong, _PyLong_FromSize_t, - _PyLong_FromSsize_t, _PyLong_FromString, _PyLong_FromUnicode, - _PyLong_FromUnicodeObject, _PyLong_FromUnsignedLong, _PyLong_FromUnsignedLongLong, - _PyLong_FromVoidPtr, _PyLong_GetInfo, _PyLong_Type, _PyMap_Type, - _PyMapping_Check, _PyMapping_GetItemString, _PyMapping_HasKey, - _PyMapping_HasKeyString, _PyMapping_Items, _PyMapping_Keys, - _PyMapping_Length, _PyMapping_SetItemString, _PyMapping_Size, - _PyMapping_Values, _PyMarshal_Init, _PyMarshal_ReadLastObjectFromFile, - _PyMarshal_ReadLongFromFile, _PyMarshal_ReadObjectFromFile, - _PyMarshal_ReadObjectFromString, _PyMarshal_ReadShortFromFile, - _PyMarshal_WriteLongToFile, _PyMarshal_WriteObjectToFile, - _PyMarshal_WriteObjectToString, _PyMem_Calloc, _PyMem_Free, - _PyMem_GetAllocator, _PyMem_Malloc, _PyMem_RawCalloc, _PyMem_RawFree, - _PyMem_RawMalloc, _PyMem_RawRealloc, _PyMem_Realloc, _PyMem_SetAllocator, - _PyMem_SetupDebugHooks, _PyMemberDescr_Type, _PyMember_GetOne, - _PyMember_SetOne, _PyMemoryView_FromBuffer, _PyMemoryView_FromMemory, - _PyMemoryView_FromObject, _PyMemoryView_GetContiguous, _PyMemoryView_Type, - _PyMethodDescr_Type, _PyMethod_Function, _PyMethod_New, _PyMethod_Self, - _PyMethod_Type, _PyModuleDef_Init, _PyModuleDef_Type, _PyModule_AddFunctions, - _PyModule_AddIntConstant, _PyModule_AddObject, _PyModule_AddStringConstant, - _PyModule_AddType, _PyModule_Create2, _PyModule_ExecDef, _PyModule_FromDefAndSpec2, - _PyModule_GetDef, _PyModule_GetDict, _PyModule_GetFilename, - _PyModule_GetFilenameObject, _PyModule_GetName, _PyModule_GetNameObject, - _PyModule_GetState, _PyModule_New, _PyModule_NewObject, _PyModule_SetDocString, - _PyModule_Type, _PyNode_AddChild, _PyNode_Compile, _PyNode_Free, - _PyNode_ListTree, _PyNode_New, _PyNumber_Absolute, _PyNumber_Add, - _PyNumber_And, _PyNumber_AsSsize_t, _PyNumber_Check, _PyNumber_Divmod, - _PyNumber_Float, _PyNumber_FloorDivide, _PyNumber_InPlaceAdd, - _PyNumber_InPlaceAnd, _PyNumber_InPlaceFloorDivide, _PyNumber_InPlaceLshift, - _PyNumber_InPlaceMatrixMultiply, _PyNumber_InPlaceMultiply, - _PyNumber_InPlaceOr, _PyNumber_InPlacePower, _PyNumber_InPlaceRemainder, - _PyNumber_InPlaceRshift, _PyNumber_InPlaceSubtract, _PyNumber_InPlaceTrueDivide, - _PyNumber_InPlaceXor, _PyNumber_Index, _PyNumber_Invert, _PyNumber_Long, - _PyNumber_Lshift, _PyNumber_MatrixMultiply, _PyNumber_Multiply, - _PyNumber_Negative, _PyNumber_Or, _PyNumber_Positive, _PyNumber_Power, - _PyNumber_Remainder, _PyNumber_Rshift, _PyNumber_Subtract, - _PyNumber_ToBase, _PyNumber_TrueDivide, _PyNumber_Xor, _PyODictItems_Type, - _PyODictIter_Type, _PyODictKeys_Type, _PyODictValues_Type, - _PyODict_DelItem, _PyODict_New, _PyODict_SetItem, _PyODict_Type, - _PyOS_AfterFork, _PyOS_AfterFork_Child, _PyOS_AfterFork_Parent, - _PyOS_BeforeFork, _PyOS_FSPath, _PyOS_InitInterrupts, _PyOS_InputHook, - _PyOS_InterruptOccurred, _PyOS_Readline, _PyOS_ReadlineFunctionPointer, - _PyOS_double_to_string, _PyOS_getsig, _PyOS_mystricmp, _PyOS_mystrnicmp, - _PyOS_setsig, _PyOS_snprintf, _PyOS_string_to_double, _PyOS_strtol, - _PyOS_strtoul, _PyOS_vsnprintf, _PyObject_ASCII, _PyObject_AsCharBuffer, - _PyObject_AsFileDescriptor, _PyObject_AsReadBuffer, _PyObject_AsWriteBuffer, - _PyObject_Bytes, _PyObject_Call, _PyObject_CallFinalizer, - _PyObject_CallFinalizerFromDealloc, _PyObject_CallFunction, - _PyObject_CallFunctionObjArgs, _PyObject_CallMethod, _PyObject_CallMethodObjArgs, - _PyObject_CallNoArgs, _PyObject_CallObject, _PyObject_Calloc, - _PyObject_CheckBuffer, _PyObject_CheckReadBuffer, _PyObject_ClearWeakRefs, - _PyObject_CopyData, _PyObject_DelItem, _PyObject_DelItemString, - _PyObject_Dir, _PyObject_Format, _PyObject_Free, _PyObject_GC_Del, - _PyObject_GC_IsFinalized, _PyObject_GC_IsTracked, _PyObject_GC_Track, - _PyObject_GC_UnTrack, _PyObject_GET_WEAKREFS_LISTPTR, _PyObject_GenericGetAttr, - _PyObject_GenericGetDict, _PyObject_GenericSetAttr, _PyObject_GenericSetDict, - _PyObject_GetArenaAllocator, _PyObject_GetAttr, _PyObject_GetAttrString, - _PyObject_GetBuffer, _PyObject_GetItem, _PyObject_GetIter, - _PyObject_HasAttr, _PyObject_HasAttrString, _PyObject_Hash, - _PyObject_HashNotImplemented, _PyObject_IS_GC, _PyObject_Init, - _PyObject_InitVar, _PyObject_IsInstance, _PyObject_IsSubclass, - _PyObject_IsTrue, _PyObject_Length, _PyObject_LengthHint, - _PyObject_Malloc, _PyObject_Not, _PyObject_Print, _PyObject_Realloc, - _PyObject_Repr, _PyObject_RichCompare, _PyObject_RichCompareBool, - _PyObject_SelfIter, _PyObject_SetArenaAllocator, _PyObject_SetAttr, - _PyObject_SetAttrString, _PyObject_SetItem, _PyObject_Size, - _PyObject_Str, _PyObject_Type, _PyObject_VectorcallDict, _PyObject_VectorcallMethod, - _PyParser_ASTFromFile, _PyParser_ASTFromFileObject, _PyParser_ASTFromString, - _PyParser_ASTFromStringObject, _PyParser_ClearError, _PyParser_ParseFile, - _PyParser_ParseFileFlags, _PyParser_ParseFileFlagsEx, _PyParser_ParseFileObject, - _PyParser_ParseString, _PyParser_ParseStringFlags, _PyParser_ParseStringFlagsFilename, - _PyParser_ParseStringFlagsFilenameEx, _PyParser_ParseStringObject, - _PyParser_SetError, _PyParser_SimpleParseFile, _PyParser_SimpleParseFileFlags, - _PyParser_SimpleParseString, _PyParser_SimpleParseStringFlags, - _PyParser_SimpleParseStringFlagsFilename, _PyPegen_ASTFromFileObject, - _PyPegen_ASTFromFilename, _PyPegen_ASTFromString, _PyPegen_ASTFromStringObject, - _PyPickleBuffer_FromObject, _PyPickleBuffer_GetBuffer, _PyPickleBuffer_Release, - _PyPickleBuffer_Type, _PyPreConfig_InitIsolatedConfig, _PyPreConfig_InitPythonConfig, - _PyProperty_Type, _PyRangeIter_Type, _PyRange_Type, _PyReversed_Type, - _PyRun_AnyFile, _PyRun_AnyFileEx, _PyRun_AnyFileExFlags, _PyRun_AnyFileFlags, - _PyRun_File, _PyRun_FileEx, _PyRun_FileExFlags, _PyRun_FileFlags, - _PyRun_InteractiveLoop, _PyRun_InteractiveLoopFlags, _PyRun_InteractiveOne, - _PyRun_InteractiveOneFlags, _PyRun_InteractiveOneObject, _PyRun_SimpleFile, - _PyRun_SimpleFileEx, _PyRun_SimpleFileExFlags, _PyRun_SimpleString, - _PyRun_SimpleStringFlags, _PyRun_String, _PyRun_StringFlags, - _PySTEntry_Type, _PyST_GetScope, _PySeqIter_New, _PySeqIter_Type, - _PySequence_Check, _PySequence_Concat, _PySequence_Contains, - _PySequence_Count, _PySequence_DelItem, _PySequence_DelSlice, - _PySequence_Fast, _PySequence_GetItem, _PySequence_GetSlice, - _PySequence_In, _PySequence_InPlaceConcat, _PySequence_InPlaceRepeat, - _PySequence_Index, _PySequence_Length, _PySequence_List, _PySequence_Repeat, - _PySequence_SetItem, _PySequence_SetSlice, _PySequence_Size, - _PySequence_Tuple, _PySetIter_Type, _PySet_Add, _PySet_Clear, - _PySet_Contains, _PySet_Discard, _PySet_New, _PySet_Pop, _PySet_Size, - _PySet_Type, _PySlice_AdjustIndices, _PySlice_GetIndices, - _PySlice_GetIndicesEx, _PySlice_New, _PySlice_Type, _PySlice_Unpack, - _PyState_AddModule, _PyState_FindModule, _PyState_RemoveModule, - _PyStaticMethod_New, _PyStaticMethod_Type, _PyStatus_Error, - _PyStatus_Exception, _PyStatus_Exit, _PyStatus_IsError, _PyStatus_IsExit, - _PyStatus_NoMemory, _PyStatus_Ok, _PyStdPrinter_Type, _PyStructSequence_GetItem, - _PyStructSequence_InitType, _PyStructSequence_InitType2, _PyStructSequence_New, - _PyStructSequence_NewType, _PyStructSequence_SetItem, _PySuper_Type, - _PySymtable_Build, _PySymtable_BuildObject, _PySymtable_Free, - _PySymtable_Lookup, _PySys_AddAuditHook, _PySys_AddWarnOption, - _PySys_AddWarnOptionUnicode, _PySys_AddXOption, _PySys_Audit, - _PySys_FormatStderr, _PySys_FormatStdout, _PySys_GetObject, - _PySys_GetXOptions, _PySys_HasWarnOptions, _PySys_ResetWarnOptions, - _PySys_SetArgv, _PySys_SetArgvEx, _PySys_SetObject, _PySys_SetPath, - _PySys_WriteStderr, _PySys_WriteStdout, _PyThreadState_Clear, - _PyThreadState_Delete, _PyThreadState_DeleteCurrent, _PyThreadState_Get, - _PyThreadState_GetDict, _PyThreadState_GetFrame, _PyThreadState_GetID, - _PyThreadState_GetInterpreter, _PyThreadState_New, _PyThreadState_Next, - _PyThreadState_SetAsyncExc, _PyThreadState_Swap, _PyThread_GetInfo, - _PyThread_ReInitTLS, _PyThread_acquire_lock, _PyThread_acquire_lock_timed, - _PyThread_allocate_lock, _PyThread_create_key, _PyThread_delete_key, - _PyThread_delete_key_value, _PyThread_exit_thread, _PyThread_free_lock, - _PyThread_get_key_value, _PyThread_get_stacksize, _PyThread_get_thread_ident, - _PyThread_get_thread_native_id, _PyThread_init_thread, _PyThread_release_lock, - _PyThread_set_key_value, _PyThread_set_stacksize, _PyThread_start_new_thread, - _PyThread_tss_alloc, _PyThread_tss_create, _PyThread_tss_delete, - _PyThread_tss_free, _PyThread_tss_get, _PyThread_tss_is_created, - _PyThread_tss_set, _PyToken_OneChar, _PyToken_ThreeChars, - _PyToken_TwoChars, _PyTraceBack_Here, _PyTraceBack_Print, - _PyTraceBack_Type, _PyTraceMalloc_Track, _PyTraceMalloc_Untrack, - _PyTupleIter_Type, _PyTuple_GetItem, _PyTuple_GetSlice, _PyTuple_New, - _PyTuple_Pack, _PyTuple_SetItem, _PyTuple_Size, _PyTuple_Type, - _PyType_ClearCache, _PyType_FromModuleAndSpec, _PyType_FromSpec, - _PyType_FromSpecWithBases, _PyType_GenericAlloc, _PyType_GenericNew, - _PyType_GetFlags, _PyType_GetModule, _PyType_GetModuleState, - _PyType_GetSlot, _PyType_IsSubtype, _PyType_Modified, _PyType_Ready, - _PyType_Type, _PyUnicodeDecodeError_Create, _PyUnicodeDecodeError_GetEncoding, - _PyUnicodeDecodeError_GetEnd, _PyUnicodeDecodeError_GetObject, - _PyUnicodeDecodeError_GetReason, _PyUnicodeDecodeError_GetStart, - _PyUnicodeDecodeError_SetEnd, _PyUnicodeDecodeError_SetReason, - _PyUnicodeDecodeError_SetStart, _PyUnicodeEncodeError_Create, - _PyUnicodeEncodeError_GetEncoding, _PyUnicodeEncodeError_GetEnd, - _PyUnicodeEncodeError_GetObject, _PyUnicodeEncodeError_GetReason, - _PyUnicodeEncodeError_GetStart, _PyUnicodeEncodeError_SetEnd, - _PyUnicodeEncodeError_SetReason, _PyUnicodeEncodeError_SetStart, - _PyUnicodeIter_Type, _PyUnicodeTranslateError_Create, _PyUnicodeTranslateError_GetEnd, - _PyUnicodeTranslateError_GetObject, _PyUnicodeTranslateError_GetReason, - _PyUnicodeTranslateError_GetStart, _PyUnicodeTranslateError_SetEnd, - _PyUnicodeTranslateError_SetReason, _PyUnicodeTranslateError_SetStart, - _PyUnicode_Append, _PyUnicode_AppendAndDel, _PyUnicode_AsASCIIString, - _PyUnicode_AsCharmapString, _PyUnicode_AsDecodedObject, _PyUnicode_AsDecodedUnicode, - _PyUnicode_AsEncodedObject, _PyUnicode_AsEncodedString, _PyUnicode_AsEncodedUnicode, - _PyUnicode_AsLatin1String, _PyUnicode_AsRawUnicodeEscapeString, - _PyUnicode_AsUCS4, _PyUnicode_AsUCS4Copy, _PyUnicode_AsUTF16String, - _PyUnicode_AsUTF32String, _PyUnicode_AsUTF8, _PyUnicode_AsUTF8AndSize, - _PyUnicode_AsUTF8String, _PyUnicode_AsUnicode, _PyUnicode_AsUnicodeAndSize, - _PyUnicode_AsUnicodeCopy, _PyUnicode_AsUnicodeEscapeString, - _PyUnicode_AsWideChar, _PyUnicode_AsWideCharString, _PyUnicode_BuildEncodingMap, - _PyUnicode_Compare, _PyUnicode_CompareWithASCIIString, _PyUnicode_Concat, - _PyUnicode_Contains, _PyUnicode_CopyCharacters, _PyUnicode_Count, - _PyUnicode_Decode, _PyUnicode_DecodeASCII, _PyUnicode_DecodeCharmap, - _PyUnicode_DecodeFSDefault, _PyUnicode_DecodeFSDefaultAndSize, - _PyUnicode_DecodeLatin1, _PyUnicode_DecodeLocale, _PyUnicode_DecodeLocaleAndSize, - _PyUnicode_DecodeRawUnicodeEscape, _PyUnicode_DecodeUTF16, - _PyUnicode_DecodeUTF16Stateful, _PyUnicode_DecodeUTF32, _PyUnicode_DecodeUTF32Stateful, - _PyUnicode_DecodeUTF7, _PyUnicode_DecodeUTF7Stateful, _PyUnicode_DecodeUTF8, - _PyUnicode_DecodeUTF8Stateful, _PyUnicode_DecodeUnicodeEscape, - _PyUnicode_Encode, _PyUnicode_EncodeASCII, _PyUnicode_EncodeCharmap, - _PyUnicode_EncodeDecimal, _PyUnicode_EncodeFSDefault, _PyUnicode_EncodeLatin1, - _PyUnicode_EncodeLocale, _PyUnicode_EncodeRawUnicodeEscape, - _PyUnicode_EncodeUTF16, _PyUnicode_EncodeUTF32, _PyUnicode_EncodeUTF7, - _PyUnicode_EncodeUTF8, _PyUnicode_EncodeUnicodeEscape, _PyUnicode_FSConverter, - _PyUnicode_FSDecoder, _PyUnicode_Fill, _PyUnicode_Find, _PyUnicode_FindChar, - _PyUnicode_Format, _PyUnicode_FromEncodedObject, _PyUnicode_FromFormat, - _PyUnicode_FromFormatV, _PyUnicode_FromKindAndData, _PyUnicode_FromObject, - _PyUnicode_FromOrdinal, _PyUnicode_FromString, _PyUnicode_FromStringAndSize, - _PyUnicode_FromUnicode, _PyUnicode_FromWideChar, _PyUnicode_GetDefaultEncoding, - _PyUnicode_GetLength, _PyUnicode_GetMax, _PyUnicode_GetSize, - _PyUnicode_InternFromString, _PyUnicode_InternImmortal, _PyUnicode_InternInPlace, - _PyUnicode_IsIdentifier, _PyUnicode_Join, _PyUnicode_New, - _PyUnicode_Partition, _PyUnicode_RPartition, _PyUnicode_RSplit, - _PyUnicode_ReadChar, _PyUnicode_Replace, _PyUnicode_Resize, - _PyUnicode_RichCompare, _PyUnicode_Split, _PyUnicode_Splitlines, - _PyUnicode_Substring, _PyUnicode_Tailmatch, _PyUnicode_TransformDecimalToASCII, - _PyUnicode_Translate, _PyUnicode_TranslateCharmap, _PyUnicode_Type, - _PyUnicode_WriteChar, _PyVectorcall_Call, _PyWeakref_GetObject, - _PyWeakref_NewProxy, _PyWeakref_NewRef, _PyWideStringList_Append, - _PyWideStringList_Insert, _PyWrapperDescr_Type, _PyWrapper_New, - _PyZip_Type, _Py_AddPendingCall, _Py_AtExit, _Py_BuildValue, - _Py_BytesMain, _Py_BytesWarningFlag, _Py_CompileString, _Py_CompileStringExFlags, - _Py_CompileStringFlags, _Py_CompileStringObject, _Py_DebugFlag, - _Py_DecRef, _Py_DecodeLocale, _Py_DontWriteBytecodeFlag, _Py_EncodeLocale, - _Py_EndInterpreter, _Py_EnterRecursiveCall, _Py_Exit, _Py_ExitStatusException, - _Py_FatalError, _Py_FdIsInteractive, _Py_FileSystemDefaultEncodeErrors, - _Py_FileSystemDefaultEncoding, _Py_Finalize, _Py_FinalizeEx, - _Py_FrozenFlag, _Py_GenericAlias, _Py_GenericAliasType, _Py_GetArgcArgv, - _Py_GetBuildInfo, _Py_GetCompiler, _Py_GetCopyright, _Py_GetExecPrefix, - _Py_GetPath, _Py_GetPlatform, _Py_GetPrefix, _Py_GetProgramFullPath, - _Py_GetProgramName, _Py_GetPythonHome, _Py_GetRecursionLimit, - _Py_GetVersion, _Py_HasFileSystemDefaultEncoding, _Py_HashRandomizationFlag, - _Py_IgnoreEnvironmentFlag, _Py_IncRef, _Py_Initialize, _Py_InitializeEx, - _Py_InitializeFromConfig, _Py_InspectFlag, _Py_InteractiveFlag, - _Py_IsInitialized, _Py_IsolatedFlag, _Py_LeaveRecursiveCall, - _Py_Main, _Py_MakePendingCalls, _Py_NewInterpreter, _Py_NoSiteFlag, - _Py_NoUserSiteDirectory, _Py_OptimizeFlag, _Py_PreInitialize, - _Py_PreInitializeFromArgs, _Py_PreInitializeFromBytesArgs, - _Py_QuietFlag, _Py_ReprEnter, _Py_ReprLeave, _Py_RunMain, - _Py_SetPath, _Py_SetProgramName, _Py_SetPythonHome, _Py_SetRecursionLimit, - _Py_SetStandardStreamEncoding, _Py_SymtableString, _Py_SymtableStringObject, - _Py_UNICODE_strcat, _Py_UNICODE_strchr, _Py_UNICODE_strcmp, - _Py_UNICODE_strcpy, _Py_UNICODE_strlen, _Py_UNICODE_strncmp, - _Py_UNICODE_strncpy, _Py_UNICODE_strrchr, _Py_UTF8Mode, _Py_UnbufferedStdioFlag, - _Py_UniversalNewlineFgets, _Py_VaBuildValue, _Py_VerboseFlag, - _Py_hexdigits, __PyAST_GetDocString, __PyAST_Optimize, __PyAccu_Accumulate, - __PyAccu_Destroy, __PyAccu_Finish, __PyAccu_FinishAsList, - __PyAccu_Init, __PyArg_BadArgument, __PyArg_CheckPositional, - __PyArg_NoKeywords, __PyArg_NoKwnames, __PyArg_NoPositional, - __PyArg_ParseStack, __PyArg_ParseStackAndKeywords, __PyArg_ParseStackAndKeywords_SizeT, - __PyArg_ParseStack_SizeT, __PyArg_ParseTupleAndKeywordsFast, - __PyArg_ParseTupleAndKeywordsFast_SizeT, __PyArg_ParseTupleAndKeywords_SizeT, - __PyArg_ParseTuple_SizeT, __PyArg_Parse_SizeT, __PyArg_UnpackKeywords, - __PyArg_UnpackStack, __PyArg_VaParseTupleAndKeywordsFast, - __PyArg_VaParseTupleAndKeywordsFast_SizeT, __PyArg_VaParseTupleAndKeywords_SizeT, - __PyArg_VaParse_SizeT, __PyArgv_AsWstrList, __PyAsyncGenASend_Type, - __PyAsyncGenAThrow_Type, __PyAsyncGenWrappedValue_Type, __PyByteArray_empty_string, - __PyBytesIOBuffer_Type, __PyBytesWriter_Alloc, __PyBytesWriter_Dealloc, - __PyBytesWriter_Finish, __PyBytesWriter_Init, __PyBytesWriter_Prepare, - __PyBytesWriter_Resize, __PyBytesWriter_WriteBytes, __PyBytes_DecodeEscape, - __PyBytes_FormatEx, __PyBytes_FromHex, __PyBytes_Join, __PyBytes_Resize, - __PyCode_CheckLineNumber, __PyCode_ConstantKey, __PyCode_GetExtra, - __PyCode_SetExtra, __PyCodecInfo_GetIncrementalDecoder, __PyCodecInfo_GetIncrementalEncoder, - __PyCodec_DecodeText, __PyCodec_EncodeText, __PyCodec_Forget, - __PyCodec_Lookup, __PyCodec_LookupTextEncoding, __PyComplex_FormatAdvancedWriter, - __PyConfig_InitCompatConfig, __PyContext_NewHamtForTests, - __PyCoroWrapper_Type, __PyCrossInterpreterData_Lookup, __PyCrossInterpreterData_NewObject, - __PyCrossInterpreterData_RegisterClass, __PyCrossInterpreterData_Release, - __PyDebugAllocatorStats, __PyDictView_Intersect, __PyDictView_New, - __PyDict_CheckConsistency, __PyDict_Contains, __PyDict_DebugMallocStats, - __PyDict_DelItemId, __PyDict_DelItemIf, __PyDict_DelItem_KnownHash, - __PyDict_GetItemId, __PyDict_GetItemIdWithError, __PyDict_GetItemStringWithError, - __PyDict_GetItem_KnownHash, __PyDict_HasOnlyStringKeys, __PyDict_MaybeUntrack, - __PyDict_MergeEx, __PyDict_NewPresized, __PyDict_Next, __PyDict_Pop, - __PyDict_SetItemId, __PyDict_SetItem_KnownHash, __PyDict_SizeOf, - __PyErr_BadInternalCall, __PyErr_ChainExceptions, __PyErr_ChainStackItem, - __PyErr_CheckSignals, __PyErr_CheckSignalsTstate, __PyErr_Clear, - __PyErr_Display, __PyErr_ExceptionMatches, __PyErr_Fetch, - __PyErr_Format, __PyErr_FormatFromCause, __PyErr_FormatFromCauseTstate, - __PyErr_GetExcInfo, __PyErr_GetTopmostException, __PyErr_NoMemory, - __PyErr_NormalizeException, __PyErr_Print, __PyErr_Restore, - __PyErr_SetKeyError, __PyErr_SetNone, __PyErr_SetObject, __PyErr_SetString, - __PyErr_TrySetFromCause, __PyErr_WriteUnraisableMsg, __PyEval_AddPendingCall, - __PyEval_CallTracing, __PyEval_EvalCodeWithName, __PyEval_EvalFrameDefault, - __PyEval_GetAsyncGenFinalizer, __PyEval_GetAsyncGenFirstiter, - __PyEval_GetBuiltinId, __PyEval_GetCoroutineOriginTrackingDepth, - __PyEval_GetSwitchInterval, __PyEval_RequestCodeExtraIndex, - __PyEval_SetAsyncGenFinalizer, __PyEval_SetAsyncGenFirstiter, - __PyEval_SetCoroutineOriginTrackingDepth, __PyEval_SetProfile, - __PyEval_SetSwitchInterval, __PyEval_SetTrace, __PyEval_SignalAsyncExc, - __PyEval_SignalReceived, __PyEval_SliceIndex, __PyEval_SliceIndexNotNone, - __PyFloat_DebugMallocStats, __PyFloat_FormatAdvancedWriter, - __PyFloat_Pack2, __PyFloat_Pack4, __PyFloat_Pack8, __PyFloat_Unpack2, - __PyFloat_Unpack4, __PyFloat_Unpack8, __PyFrame_DebugMallocStats, - __PyFunction_Vectorcall, __PyGC_CollectIfEnabled, __PyGC_CollectNoFail, - __PyGC_InitState, __PyGILState_GetInterpreterStateUnsafe, - __PyGILState_Reinit, __PyGen_FetchStopIterationValue, __PyGen_Finalize, - __PyGen_Send, __PyGen_SetStopIterationValue, __PyHamtItems_Type, - __PyHamtKeys_Type, __PyHamtValues_Type, __PyHamt_ArrayNode_Type, - __PyHamt_BitmapNode_Type, __PyHamt_CollisionNode_Type, __PyHamt_Type, - __PyImport_AcquireLock, __PyImport_FindExtensionObject, __PyImport_FixupBuiltin, - __PyImport_FixupExtensionObject, __PyImport_GetModuleId, __PyImport_IsInitialized, - __PyImport_ReleaseLock, __PyImport_SetModule, __PyImport_SetModuleString, - __PyInterpreterID_LookUp, __PyInterpreterID_New, __PyInterpreterID_Type, - __PyInterpreterState_DeleteExceptMain, __PyInterpreterState_Enable, - __PyInterpreterState_GetConfig, __PyInterpreterState_GetEvalFrameFunc, - __PyInterpreterState_GetIDObject, __PyInterpreterState_GetMainModule, - __PyInterpreterState_IDDecref, __PyInterpreterState_IDIncref, - __PyInterpreterState_IDInitref, __PyInterpreterState_LookUpID, - __PyInterpreterState_RequireIDRef, __PyInterpreterState_RequiresIDRef, - __PyInterpreterState_SetEvalFrameFunc, __PyList_DebugMallocStats, - __PyList_Extend, __PyLong_AsByteArray, __PyLong_AsInt, __PyLong_AsTime_t, - __PyLong_Copy, __PyLong_DigitValue, __PyLong_DivmodNear, __PyLong_Format, - __PyLong_FormatAdvancedWriter, __PyLong_FormatBytesWriter, - __PyLong_FormatWriter, __PyLong_Frexp, __PyLong_FromByteArray, - __PyLong_FromBytes, __PyLong_FromGid, __PyLong_FromNbIndexOrNbInt, - __PyLong_FromNbInt, __PyLong_FromTime_t, __PyLong_FromUid, - __PyLong_GCD, __PyLong_Lshift, __PyLong_New, __PyLong_NumBits, - __PyLong_One, __PyLong_Rshift, __PyLong_Sign, __PyLong_Size_t_Converter, - __PyLong_UnsignedInt_Converter, __PyLong_UnsignedLongLong_Converter, - __PyLong_UnsignedLong_Converter, __PyLong_UnsignedShort_Converter, - __PyLong_Zero, __PyManagedBuffer_Type, __PyMem_GetAllocatorName, - __PyMem_GetCurrentAllocatorName, __PyMem_RawStrdup, __PyMem_RawWcsdup, - __PyMem_SetDefaultAllocator, __PyMem_SetupAllocators, __PyMem_Strdup, - __PyMethodWrapper_Type, __PyModuleSpec_IsInitializing, __PyModule_Clear, - __PyModule_ClearDict, __PyModule_CreateInitialized, __PyNamespace_New, - __PyNamespace_Type, __PyNode_SizeOf, __PyNone_Type, __PyNotImplemented_Type, - __PyOS_InterruptOccurred, __PyOS_IsMainThread, __PyOS_ReadlineTState, - __PyOS_URandom, __PyOS_URandomNonblock, __PyObject_AssertFailed, - __PyObject_Call, __PyObject_CallFunction_SizeT, __PyObject_CallMethodId, - __PyObject_CallMethodIdObjArgs, __PyObject_CallMethodId_SizeT, - __PyObject_CallMethod_SizeT, __PyObject_Call_Prepend, __PyObject_CheckConsistency, - __PyObject_CheckCrossInterpreterData, __PyObject_DebugMallocStats, - __PyObject_DebugTypeStats, __PyObject_Dump, __PyObject_FastCallDictTstate, - __PyObject_FunctionStr, __PyObject_GC_Calloc, __PyObject_GC_Malloc, - __PyObject_GC_New, __PyObject_GC_NewVar, __PyObject_GC_Resize, - __PyObject_GenericGetAttrWithDict, __PyObject_GenericSetAttrWithDict, - __PyObject_GetAttrId, __PyObject_GetCrossInterpreterData, - __PyObject_GetDictPtr, __PyObject_GetMethod, __PyObject_HasAttrId, - __PyObject_HasLen, __PyObject_IsAbstract, __PyObject_IsFreed, - __PyObject_LookupAttr, __PyObject_LookupAttrId, __PyObject_LookupSpecial, - __PyObject_MakeTpCall, __PyObject_New, __PyObject_NewVar, - __PyObject_NextNotImplemented, __PyObject_RealIsInstance, - __PyObject_RealIsSubclass, __PyObject_SetAttrId, __PyParser_Grammar, - __PyParser_TokenNames, __PyPreConfig_InitCompatConfig, __PyRuntime, - __PyRuntimeState_Fini, __PyRuntimeState_Init, __PyRuntimeState_ReInitThreads, - __PyRuntime_Finalize, __PyRuntime_Initialize, __PySequence_BytesToCharpArray, - __PySequence_IterSearch, __PySet_Dummy, __PySet_NextEntry, - __PySet_Update, __PySignal_AfterFork, __PySlice_FromIndices, - __PySlice_GetLongIndices, __PyStack_AsDict, __PyState_AddModule, - __PySys_GetObjectId, __PySys_GetSizeOf, __PySys_SetObjectId, - __PyThreadState_DeleteCurrent, __PyThreadState_DeleteExcept, - __PyThreadState_GetDict, __PyThreadState_Init, __PyThreadState_Prealloc, - __PyThreadState_Swap, __PyThreadState_UncheckedGet, __PyThread_CurrentFrames, - __PyThread_at_fork_reinit, __PyTime_AsMicroseconds, __PyTime_AsMilliseconds, - __PyTime_AsNanosecondsObject, __PyTime_AsSecondsDouble, __PyTime_AsTimespec, - __PyTime_AsTimeval, __PyTime_AsTimevalTime_t, __PyTime_AsTimeval_noraise, - __PyTime_FromMillisecondsObject, __PyTime_FromNanoseconds, - __PyTime_FromNanosecondsObject, __PyTime_FromSeconds, __PyTime_FromSecondsObject, - __PyTime_FromTimespec, __PyTime_FromTimeval, __PyTime_GetMonotonicClock, - __PyTime_GetMonotonicClockWithInfo, __PyTime_GetPerfCounter, - __PyTime_GetPerfCounterWithInfo, __PyTime_GetSystemClock, - __PyTime_GetSystemClockWithInfo, __PyTime_Init, __PyTime_MulDiv, - __PyTime_ObjectToTime_t, __PyTime_ObjectToTimespec, __PyTime_ObjectToTimeval, - __PyTime_gmtime, __PyTime_localtime, __PyTraceMalloc_GetTraceback, - __PyTraceMalloc_NewReference, __PyTraceback_Add, __PyTrash_begin, - __PyTrash_deposit_object, __PyTrash_destroy_chain, __PyTrash_end, - __PyTrash_thread_deposit_object, __PyTrash_thread_destroy_chain, - __PyTuple_DebugMallocStats, __PyTuple_MaybeUntrack, __PyTuple_Resize, - __PyType_CalculateMetaclass, __PyType_CheckConsistency, __PyType_GetDocFromInternalDoc, - __PyType_GetTextSignatureFromInternalDoc, __PyType_Lookup, - __PyType_LookupId, __PyType_Name, __PyUnicodeTranslateError_Create, - __PyUnicodeWriter_Dealloc, __PyUnicodeWriter_Finish, __PyUnicodeWriter_Init, - __PyUnicodeWriter_PrepareInternal, __PyUnicodeWriter_PrepareKindInternal, - __PyUnicodeWriter_WriteASCIIString, __PyUnicodeWriter_WriteChar, - __PyUnicodeWriter_WriteLatin1String, __PyUnicodeWriter_WriteStr, - __PyUnicodeWriter_WriteSubstring, __PyUnicode_AsASCIIString, - __PyUnicode_AsLatin1String, __PyUnicode_AsUTF8String, __PyUnicode_AsUnicode, - __PyUnicode_CheckConsistency, __PyUnicode_Copy, __PyUnicode_DecodeUnicodeEscape, - __PyUnicode_EQ, __PyUnicode_EncodeCharmap, __PyUnicode_EncodeUTF16, - __PyUnicode_EncodeUTF32, __PyUnicode_EncodeUTF7, __PyUnicode_EqualToASCIIId, - __PyUnicode_EqualToASCIIString, __PyUnicode_FastCopyCharacters, - __PyUnicode_FastFill, __PyUnicode_FindMaxChar, __PyUnicode_FormatAdvancedWriter, - __PyUnicode_FormatLong, __PyUnicode_FromASCII, __PyUnicode_FromId, - __PyUnicode_InsertThousandsGrouping, __PyUnicode_IsAlpha, - __PyUnicode_IsCaseIgnorable, __PyUnicode_IsCased, __PyUnicode_IsDecimalDigit, - __PyUnicode_IsDigit, __PyUnicode_IsLinebreak, __PyUnicode_IsLowercase, - __PyUnicode_IsNumeric, __PyUnicode_IsPrintable, __PyUnicode_IsTitlecase, - __PyUnicode_IsUppercase, __PyUnicode_IsWhitespace, __PyUnicode_IsXidContinue, - __PyUnicode_IsXidStart, __PyUnicode_JoinArray, __PyUnicode_Ready, - __PyUnicode_ScanIdentifier, __PyUnicode_ToDecimalDigit, __PyUnicode_ToDigit, - __PyUnicode_ToFoldedFull, __PyUnicode_ToLowerFull, __PyUnicode_ToLowercase, - __PyUnicode_ToNumeric, __PyUnicode_ToTitleFull, __PyUnicode_ToTitlecase, - __PyUnicode_ToUpperFull, __PyUnicode_ToUppercase, __PyUnicode_TransformDecimalAndSpaceToASCII, - __PyUnicode_XStrip, __PyWarnings_Init, __PyWeakref_CallableProxyType, - __PyWeakref_ClearRef, __PyWeakref_GetWeakrefCount, __PyWeakref_ProxyType, - __PyWeakref_RefType, __PyWideStringList_AsList, __PyWideStringList_Clear, - __PyWideStringList_Copy, __PyWideStringList_Extend, __Py_BreakPoint, - __Py_BuildValue_SizeT, __Py_CheckFunctionResult, __Py_CheckRecursionLimit, - __Py_CheckRecursiveCall, __Py_ClearArgcArgv, __Py_ClearStandardStreamEncoding, - __Py_CoerceLegacyLocale, __Py_Dealloc, __Py_DecodeLocaleEx, - __Py_DecodeUTF8Ex, __Py_DecodeUTF8_surrogateescape, __Py_DisplaySourceLine, - __Py_EllipsisObject, __Py_EncodeLocaleEx, __Py_EncodeLocaleRaw, - __Py_EncodeUTF8Ex, __Py_FalseStruct, __Py_FatalErrorFormat, - __Py_FatalErrorFunc, __Py_FatalError_TstateNULL, __Py_FreeCharPArray, - __Py_GetAllocatedBlocks, __Py_GetConfig, __Py_GetConfigsAsDict, - __Py_GetEnv, __Py_GetErrorHandler, __Py_GetForceASCII, __Py_GetLocaleconvNumeric, - __Py_Gid_Converter, __Py_HandleSystemExit, __Py_HashBytes, - __Py_HashDouble, __Py_HashPointer, __Py_HashPointerRaw, __Py_HashSecret, - __Py_InitializeMain, __Py_IsCoreInitialized, __Py_IsFinalizing, - __Py_IsLocaleCoercionTarget, __Py_LegacyLocaleDetected, __Py_Mangle, - __Py_NewInterpreter, __Py_NewReference, __Py_NoneStruct, __Py_NotImplementedStruct, - __Py_PackageContext, __Py_PreInitializeFromConfig, __Py_PreInitializeFromPyArgv, - __Py_PyAtExit, __Py_ResetForceASCII, __Py_RestoreSignals, - __Py_SetLocaleFromEnv, __Py_SetProgramFullPath, __Py_Sigset_Converter, - __Py_SourceAsString, __Py_SwappedOp, __Py_SymtableStringObjectFlags, - __Py_TrueStruct, __Py_Uid_Converter, __Py_UnhandledKeyboardInterrupt, - __Py_VaBuildStack, __Py_VaBuildStack_SizeT, __Py_VaBuildValue_SizeT, - __Py_abspath, __Py_add_one_to_index_C, __Py_add_one_to_index_F, - __Py_ascii_whitespace, __Py_bit_length, __Py_c_abs, __Py_c_diff, - __Py_c_neg, __Py_c_pow, __Py_c_prod, __Py_c_quot, __Py_c_sum, - __Py_convert_optional_to_ssize_t, __Py_ctype_table, __Py_ctype_tolower, - __Py_ctype_toupper, __Py_device_encoding, __Py_dg_dtoa, __Py_dg_freedtoa, - __Py_dg_infinity, __Py_dg_stdnan, __Py_dg_strtod, __Py_dup, - __Py_fopen, __Py_fopen_obj, __Py_fstat, __Py_fstat_noraise, - __Py_get_blocking, __Py_get_env_flag, __Py_get_inheritable, - __Py_get_xoption, __Py_gitidentifier, __Py_gitversion, __Py_hashtable_clear, - __Py_hashtable_compare_direct, __Py_hashtable_destroy, __Py_hashtable_foreach, - __Py_hashtable_get, __Py_hashtable_hash_ptr, __Py_hashtable_new, - __Py_hashtable_new_full, __Py_hashtable_set, __Py_hashtable_size, - __Py_hashtable_steal, __Py_isabs, __Py_open, __Py_open_noraise, - __Py_parse_inf_or_nan, __Py_path_config, __Py_read, __Py_set_blocking, - __Py_set_inheritable, __Py_set_inheritable_async_safe, __Py_stat, - __Py_str_to_int, __Py_strhex, __Py_strhex_bytes, __Py_strhex_bytes_with_sep, - __Py_strhex_with_sep, __Py_string_to_number_with_underscores, - __Py_tracemalloc_config, __Py_wfopen, __Py_wgetcwd, __Py_wreadlink, - __Py_wrealpath, __Py_write, __Py_write_noraise ] -... diff --git a/makefile b/makefile index a0ec24b..d65daf0 100644 --- a/makefile +++ b/makefile @@ -1,4 +1,3 @@ - include ../../allmake.mak #---------------------------------------------------------------------- @@ -18,8 +17,8 @@ include ../../allmake.mak #---------------------------------------------------------------------- # default goals -.PHONY: configs modules pyfiles deployed_modules idapython_modules api_check api_contents pyqt sip bins public_tree test_idc docs tbd examples_index test_pywraps -all: configs modules pyfiles deployed_modules idapython_modules api_check api_contents pyqt sip bins examples_index test_pywraps # public_tree test_idc docs +.PHONY: configs modules pyfiles deployed_modules idapython_modules api_check api_contents qt_bindings bins public_tree test_idc docs docs_md tbd examples examples_index test_pywraps +all: configs modules pyfiles deployed_modules idapython_modules api_check api_contents qt_bindings bins examples examples_index test_pywraps # public_tree test_idc docs docs_md ifeq ($(OUT_OF_TREE_BUILD),) IDAPYSWITCH:=$(R)idapyswitch$(B) @@ -96,41 +95,17 @@ CONFIGS += idapython.cfg #---------------------------------------------------------------------- # the 'modules' target is in $(IDA)module.mak ifdef __EA64__ - MODULE_NAME_STEM:=idapython3_ -else MODULE_NAME_STEM:=idapython3 +else + MODULE_NAME_STEM:=idapython3_ endif MODULE = $(call module_dll,$(MODULE_NAME_STEM)) MODULES += $(MODULE) #---------------------------------------------------------------------- -ifdef __MAC__ - # it is important that we guarantee some available space in the header, - # we might want to patch the libpython load commands later. - LDFLAGS += -Wl,-headerpad,0x400 -else - ifdef __LINUX__ - # We want the 'DT_NEEDED' of idapython.so to be sufficiently large - # to hold any libpython3.Y.so. Therefore, at - # build-time, let's use our tool (which will in turn use patchelf) - # to expand the DT_NEEDED 'slot' size. - IDAPYSWITCH_MODULE_DEP := $(IDAPYSWITCH_DEP) - ifndef __CODE_CHECKER__ - # this is for idapython[64].so - POSTACTION=$(Q)$(IDAPYSWITCH_PATH) --split-debug-and-expand-libpython3-dtneeded-room $(MODULE) - # and this for _ida_*.so - POSTACTION_IDA_X_SO=$(Q)$(IDAPYSWITCH_PATH) --split-debug-and-expand-libpython3-dtneeded-room - endif - endif -endif - -#---------------------------------------------------------------------- -ifdef __MAC__ - # use a stub .tbd library to link against, see tbd.md - TBD_FILE = libpython$(PYTHON_VERSION_MAJOR).tbd - # note: this path must be compatible with -L$(R) -lpython3 in pyplg.mak - TBD_MODULE_DEP = $(R)$(TBD_FILE) - # idapyswitch must be told that we're working with Python2 +ifdef __LINUX__ + # we don't link to libpython anymore so allow to have undefined symbols + NO_UNDEFS= endif #---------------------------------------------------------------------- @@ -148,17 +123,18 @@ include ../pyplg.mak #---------------------------------------------------------------------- PYTHON_OBJS += $(F)idapython$(O) $(MODULE): MODULE_OBJS += $(PYTHON_OBJS) -$(MODULE): $(PYTHON_OBJS) $(IDAPYSWITCH_MODULE_DEP) $(TBD_MODULE_DEP) +$(MODULE): $(PYTHON_OBJS) $(IDAPYSWITCH_MODULE_DEP) ifdef __NT__ - $(MODULE): OUTDLL = /DLL /NOEXP + $(MODULE): OUTDLL = /DLL $(MODULE): LDFLAGS += /DEF:$(IDAPYTHON_IMPLIB_DEF) /IMPLIB:$(IDAPYTHON_IMPLIB_PATH) endif # TODO these should apply only to $(MODULE) DEFFILE = idapython.script -INSTALL_NAME = @executable_path/plugins/$(notdir $(MODULE)) +INSTALL_NAME = @rpath/plugins/$(notdir $(MODULE)) ifdef __LINUX__ - LDFLAGS += -Wl,-soname,$(notdir $(MODULE)) + LDFLAGS_MOD = -Wl,-soname,$(notdir $(MODULE)) + LDFLAGS_EXE = -lpython$(PYTHON_VERSION_MAJOR).$(PYTHON_VERSION_MINOR) -Wl,--no-undefined endif PATCH_CONST=$(Q)$(PYTHON) tools/patch_constants.py -i $(1) -o $(2) @@ -194,7 +170,7 @@ ifeq ($(OUT_OF_TREE_BUILD),) endif # output directory for python scripts -DEPLOY_PYDIR=$(R)python/$(PYTHON_VERSION_MAJOR) +DEPLOY_PYDIR=$(R)python DEPLOY_INIT_PY=$(DEPLOY_PYDIR)/init.py DEPLOY_IDC_PY=$(DEPLOY_PYDIR)/idc.py DEPLOY_IDAUTILS_PY=$(DEPLOY_PYDIR)/idautils.py @@ -211,9 +187,17 @@ else endif ifeq ($(OUT_OF_TREE_BUILD),) - IDAT_CMD=TVHEADLESS=1 "$(IDAT_PATH)$(SUFF64)" + IDAT_CMD=TVHEADLESS=1 "$(IDAT_PATH)$(SUFF32)" else - IDAT_CMD=TVHEADLESS=1 IDAPYTHON_DYNLOAD_BASE=$(R) "$(IDAT_PATH)$(SUFF64)" + IDAT_CMD=TVHEADLESS=1 IDAPYTHON_DYNLOAD_BASE=$(R) "$(IDAT_PATH)$(SUFF32)" +endif + +ifeq ($(LOCAL_LICENSE),1) + IDAT_CMD := $(IDAT_CMD) -Olicense:keyfile +endif + +ifdef LOG_FILE + IDAT_CMD := $(IDAT_CMD) -L$(LOG_FILE) endif # envvar HAS_HEXRAYS must have been set by build.py if needed @@ -234,12 +218,11 @@ else endif ST_SDK_TARGETS = $(SDK_SOURCES:$(IDA_INCLUDE)/%=$(ST_SDK)/%) -_SWIGPY3FLAG := -py3 -py3-stable-abi -DPY3=1 +_SWIGPY3FLAG := -DPY3=1 CC_DEFS += PY3=1 CC_DEFS += Py_LIMITED_API=0x03040000 # we should make sure we use the same version as SWiG -DYNLOAD_SUBDIR := python$(PYTHON_VERSION_MAJOR).$(PYTHON_VERSION_MINOR) -DEPLOY_LIBDIR=$(DEPLOY_PYDIR)/ida_$(ADRSIZE) +DEPLOY_LIBDIR=$(DEPLOY_PYDIR)/lib-dynload ifdef __NT__ PYDLL_EXT = .pyd @@ -269,7 +252,6 @@ MODULES_NAMES += dbg MODULES_NAMES += diskio MODULES_NAMES += dirtree MODULES_NAMES += entry -MODULES_NAMES += enum MODULES_NAMES += expr MODULES_NAMES += fixup MODULES_NAMES += fpro @@ -284,6 +266,7 @@ MODULES_NAMES += idd MODULES_NAMES += idp MODULES_NAMES += ieee MODULES_NAMES += kernwin +MODULES_NAMES += libfuncs MODULES_NAMES += lines MODULES_NAMES += loader ifdef TESTABLE_BUILD @@ -304,15 +287,13 @@ MODULES_NAMES += segment MODULES_NAMES += segregs MODULES_NAMES += srclang MODULES_NAMES += strlist -MODULES_NAMES += struct MODULES_NAMES += tryblks MODULES_NAMES += typeinf MODULES_NAMES += ua MODULES_NAMES += xref -ifndef NOTEAMS - MODULES_NAMES += mergemod - MODULES_NAMES += merge -endif +MODULES_NAMES += mergemod +MODULES_NAMES += merge +MODULES_NAMES += undo ALL_ST_WRAP_CPP = $(foreach mod,$(MODULES_NAMES),$(ST_WRAP)/$(mod).cpp) ALL_ST_WRAP_PY = $(foreach mod,$(MODULES_NAMES),$(ST_WRAP)/ida_$(mod).py) @@ -335,12 +316,13 @@ endif ifdef __NT__ # os and compiler specific flags _SWIGFLAGS = -D__NT__ -DWIN32 -D_USRDLL -I"$(PYTHON_ROOT)/include" - CFLAGS += /bigobj $(_SWIGFLAGS) -I$(ST_SDK) /U_DEBUG + CFLAGS += /bigobj $(_SWIGFLAGS) -I$(ST_SDK) else # unix/mac ifdef __LINUX__ PYTHON_LDFLAGS_RPATH_MODULE=-Wl,-rpath='$$ORIGIN/../../..' _SWIGFLAGS = -D__LINUX__ else ifdef __MAC__ + PYTHON_LDFLAGS_RPATH_MODULE=-Wl,-rpath,@loader_path/../../.. _SWIGFLAGS = -D__MAC__ endif endif @@ -352,9 +334,6 @@ endif # types will not interfere or clash with the types in your module. DEF_TYPE_TABLE = SWIG_TYPE_TABLE=idaapi SWIGFLAGS=$(_SWIGFLAGS) -Itools/typemaps-supplement $(SWIG_INCLUDES) $(addprefix -D,$(DEF_TYPE_TABLE)) -DMISSED_BC695 -ifdef NOTEAMS - SWIGFLAGS += -DNOTEAMS -endif pyfiles: $(DEPLOY_IDAUTILS_PY) \ $(DEPLOY_IDC_PY) \ @@ -369,14 +348,14 @@ ifeq ($(OUT_OF_TREE_BUILD),) else SRC_PYQT_BUNDLE:=$(PYQT5_RELEASE) endif - DEST_PYQT_DIR:=$(R)python/$(PYTHON_VERSION_MAJOR)/PyQt5 + DEST_PYQT_DIR:=$(R)python/PyQt5 $(DEST_PYQT_DIR): -$(Q)if [ ! -d "$(DEST_PYQT_DIR)" ] ; then mkdir -p 2>/dev/null $(DEST_PYQT_DIR) ; fi # PyQt5 DEST_PYQT_QTCORE:=$(DEST_PYQT_DIR)/QtCore$(PYDLL_EXT) $(DEST_PYQT_QTCORE): $(SRC_PYQT_BUNDLE) | $(DEST_PYQT_DIR) - $(Q)tar -xf $(SRC_PYQT_BUNDLE) -C $(dir $(DEST_PYQT_DIR)) --strip 1 + $(Q)$(TAR) -xf $(SRC_PYQT_BUNDLE) -C $(dir $(DEST_PYQT_DIR)) --strip 1 $(Q)touch $@ DEST_PYQT += $(DEST_PYQT_QTCORE) @@ -407,7 +386,7 @@ ifeq ($(OUT_OF_TREE_BUILD),) $(Q)$(CP) $? $@ DEST_SIP += $(DEST_SIP38_PYDLL) $(DEST_SIP38_PYI) - # sip for Python [3.9, 3.10) + # sip for Python 3.9 DEST_SIP39_DIR:=$(DEST_PYQT_DIR)/python_3.9 $(DEST_SIP39_DIR): -$(Q)if [ ! -d "$(DEST_SIP39_DIR)" ] ; then mkdir -p 2>/dev/null $(DEST_SIP39_DIR) ; fi @@ -419,7 +398,7 @@ ifeq ($(OUT_OF_TREE_BUILD),) $(Q)$(CP) $? $@ DEST_SIP += $(DEST_SIP39_PYDLL) $(DEST_SIP39_PYI) - # sip for Python [3.10, 3.11) + # sip for Python 3.10 DEST_SIP310_DIR:=$(DEST_PYQT_DIR)/python_3.10 $(DEST_SIP310_DIR): -$(Q)if [ ! -d "$(DEST_SIP310_DIR)" ] ; then mkdir -p 2>/dev/null $(DEST_SIP310_DIR) ; fi @@ -431,7 +410,7 @@ ifeq ($(OUT_OF_TREE_BUILD),) $(Q)$(CP) $? $@ DEST_SIP += $(DEST_SIP310_PYDLL) $(DEST_SIP310_PYI) - # sip for Python [3.11, 3.12) + # sip for Python 3.11 DEST_SIP311_DIR:=$(DEST_PYQT_DIR)/python_3.11 $(DEST_SIP311_DIR): -$(Q)if [ ! -d "$(DEST_SIP311_DIR)" ] ; then mkdir -p 2>/dev/null $(DEST_SIP311_DIR) ; fi @@ -443,7 +422,7 @@ ifeq ($(OUT_OF_TREE_BUILD),) $(Q)$(CP) $? $@ DEST_SIP += $(DEST_SIP311_PYDLL) $(DEST_SIP311_PYI) - # sip for Python [3.12, ... + # sip for Python 3.12 DEST_SIP312_DIR:=$(DEST_PYQT_DIR)/python_3.12 $(DEST_SIP312_DIR): -$(Q)if [ ! -d "$(DEST_SIP312_DIR)" ] ; then mkdir -p 2>/dev/null $(DEST_SIP312_DIR) ; fi @@ -455,41 +434,107 @@ ifeq ($(OUT_OF_TREE_BUILD),) $(Q)$(CP) $? $@ DEST_SIP += $(DEST_SIP312_PYDLL) $(DEST_SIP312_PYI) - # And pick the right sip.so now (Python3 only; for Python2, we already put it in the right place) - ifeq ($(shell test $(PYTHON_VERSION_MINOR) -gt 11; echo $$?),0) # ugh - DEST_INSTALL_SIP_PYDLL:=$(DEST_SIP312_PYDLL) - else - ifeq ($(shell test $(PYTHON_VERSION_MINOR) -gt 10; echo $$?),0) # ugh - DEST_INSTALL_SIP_PYDLL:=$(DEST_SIP311_PYDLL) - else - ifeq ($(shell test $(PYTHON_VERSION_MINOR) -gt 9; echo $$?),0) # ugh - DEST_INSTALL_SIP_PYDLL:=$(DEST_SIP310_PYDLL) - else - ifeq ($(shell test $(PYTHON_VERSION_MINOR) -gt 8; echo $$?),0) # ugh - DEST_INSTALL_SIP_PYDLL:=$(DEST_SIP39_PYDLL) - else - ifeq ($(shell test $(PYTHON_VERSION_MINOR) -gt 7; echo $$?),0) # ugh - DEST_INSTALL_SIP_PYDLL:=$(DEST_SIP38_PYDLL) - else - DEST_INSTALL_SIP_PYDLL:=$(DEST_SIP34_PYDLL) - endif - endif - endif + # sip for Python 3.13 + DEST_SIP313_DIR:=$(DEST_PYQT_DIR)/python_3.13 + $(DEST_SIP313_DIR): + -$(Q)if [ ! -d "$(DEST_SIP313_DIR)" ] ; then mkdir -p 2>/dev/null $(DEST_SIP313_DIR) ; fi + DEST_SIP313_PYDLL:=$(DEST_SIP313_DIR)/$(SIP_PYDLL_FNAME) + DEST_SIP313_PYI:=$(DEST_SIP313_DIR)/$(SIP_PYI_FNAME) + $(DEST_SIP313_PYDLL): $(wildcard $(SIP313_TREE)/lib/python*/PyQt5/$(SIP_PYDLL_FNAME)) | $(DEST_SIP313_DIR) + $(Q)$(CP) $? $@ + $(DEST_SIP313_PYI): $(wildcard $(SIP313_TREE)/lib/python*/PyQt5/$(SIP_PYI_FNAME)) | $(DEST_SIP313_DIR) + $(Q)$(CP) $? $@ + DEST_SIP += $(DEST_SIP313_PYDLL) $(DEST_SIP313_PYI) + + ifdef __LINUX__ + ifdef __APPLE_SILICON__ + DEST_SIP = $(DEST_SIP313_PYDLL) $(DEST_SIP313_PYI) endif endif - $(DEST_PYQT_DIR)/$(SIP_PYDLL_FNAME): $(DEST_INSTALL_SIP_PYDLL) - $(Q)$(CP) $? $@ - $(Q)chmod +w $@ - DEST_SIP += $(DEST_PYQT_DIR)/$(SIP_PYDLL_FNAME) + + DEST_PYQT5_SHIMS += $(DEST_PYQT_DIR)/__init__.py + DEST_PYQT5_SHIMS += $(DEST_PYQT_DIR)/sip.py + DEST_PYQT5_SHIMS += $(DEST_PYQT_DIR)/QtCore.py + DEST_PYQT5_SHIMS += $(DEST_PYQT_DIR)/QtGui.py + DEST_PYQT5_SHIMS += $(DEST_PYQT_DIR)/QtWidgets.py + + + # + # PySide6 + # + # For PySide6, we'll be producing the following tree structure, + # for every Python version we support: + # + # python/PySide6-python3.13/ + # ├── libpyside6.abi3.so.6.8 + # ├── libshiboken6.abi3.so.6.8 + # └── python3.13 + # └── site-packages + # ├── PySide6 + # │   ├── __init__.py + # │   ├── QtCore.abi3.so + # │   ├── QtCore.pyi + # │   ├── QtGui.abi3.so + # │   ├── QtGui.pyi + # │   ├── QtWidgets.abi3.so + # │   └── QtWidgets.pyi + # └── shiboken6 + # ├── __init__.py + # ├── Shiboken.abi3.so + # └── Shiboken.pyi + # + define make-pyside6-rules + + DEST_PYSIDE6_DEPS += $(2)/libpyside6.abi3.so.6.8 + DEST_PYSIDE6_DEPS += $(2)/libshiboken6.abi3.so.6.8 + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/shiboken6/__init__.py + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/shiboken6/Shiboken.abi3.so + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/shiboken6/Shiboken.pyi + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/PySide6/__init__.py + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/PySide6/QtCore.abi3.so + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/PySide6/QtCore.pyi + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/PySide6/QtGui.abi3.so + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/PySide6/QtGui.pyi + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/PySide6/QtWidgets.abi3.so + DEST_PYSIDE6_DEPS += $(2)/python3.$(1)/site-packages/PySide6/QtWidgets.pyi + + DEST_PYSIDE6_PYTHON3$(1)_DIRS += $(2)/python3.$(1)/site-packages/PySide6 + DEST_PYSIDE6_PYTHON3$(1)_DIRS += $(2)/python3.$(1)/site-packages/shiboken6 + + $(2)/python3.$(1)/site-packages/PySide6: + -$(Q)if [ ! -d "$$@" ] ; then mkdir -p 2>/dev/null $$@ ; fi + $(2)/python3.$(1)/site-packages/shiboken6: + -$(Q)if [ ! -d "$$@" ] ; then mkdir -p 2>/dev/null $$@ ; fi + + $(2)/libpyside6.abi3.so.6.8: $(3)/libpyside6.abi3.so.6.8.0 | $$(DEST_PYSIDE6_PYTHON3$(1)_DIRS) + $(Q)$(CP) $$? $$@ + $(2)/libshiboken6.abi3.so.6.8: $(3)/libshiboken6.abi3.so.6.8.0 | $$(DEST_PYSIDE6_PYTHON3$(1)_DIRS) + $(Q)$(CP) $$? $$@ + $(2)/python3.13/site-packages/shiboken6/%: $(3)/python3.$(1)/site-packages/shiboken6/% | $$(DEST_PYSIDE6_PYTHON3$(1)_DIRS) + $(Q)$(CP) $$? $$@ + $(2)/python3.13/site-packages/PySide6/%: $(3)/python3.$(1)/site-packages/PySide6/% | $$(DEST_PYSIDE6_PYTHON3$(1)_DIRS) + $(Q)$(CP) $$? $$@ + endef + + $(eval $(call make-pyside6-rules,13,$(R)python/PySide6-python3.13,$(PYSIDE6_DIR)/PySide6-python3.13)) + endif -pyqt: $(DEST_PYQT) -sip: $(DEST_SIP) +ifeq ($(QT_VERSION_MAJOR),6) + QT_BINDINGS_DEPS += $(DEST_PYQT5_SHIMS) $(DEST_PYSIDE6_DEPS) + $(DEST_PYQT_DIR)/%: PyQt5-shims/% | $(DEST_PYQT_DIR) + $(CP) $? $@ +else + QT_BINDINGS_DEPS += $(DEST_PYQT) + QT_BINDINGS_DEPS += $(DEST_SIP) +endif + +qt_bindings: $(QT_BINDINGS_DEPS) GENHOOKS=tools/genhooks/ -$(DEPLOY_INIT_PY): python/init.py - $(CP) $? $@ +$(DEPLOY_INIT_PY): python/init.py tools/genidaapi.py $(IDAPYTHON_MODULES) + $(QGENIDAAPI)$(PYTHON) tools/genidaapi.py -i $< -o $@ -m $(subst $(space),$(comma),$(MODULES_NAMES)) $(DEPLOY_IDC_PY): python/idc.py $(CP) $? $@ @@ -643,13 +688,12 @@ CC_DEFS += MISSED_BC695 CC_DEFS += $(DEF_TYPE_TABLE) CC_DEFS += $(WITH_HEXRAYS_DEF) CC_DEFS += USE_STANDARD_FILE_FUNCTIONS -CC_DEFS += VER_MAJOR=$(IDAVER_MAJOR) -CC_DEFS += VER_MINOR=$(IDAVER_MINOR) -CC_DEFS += VER_PATCH="0" +CC_DEFS += IDAVER_MAJOR=$(IDAVER_MAJOR) +CC_DEFS += IDAVER_MINOR=$(IDAVER_MINOR) +CC_DEFS += IDAVER_PATCH=$(IDAVER_PATCH) CC_DEFS += __EXPR_SRC CC_INCP += $(F) CC_INCP += $(ST_SWIG) -CC_INCP += ../../ldr/mach-o/h CC_INCP += . ifdef __UNIX__ @@ -690,7 +734,6 @@ ifdef __NT__ endif find-pywraps-deps = $(wildcard pywraps/py_$(subst .i,,$(notdir $(1)))*.hpp) $(wildcard pywraps/py_$(subst .i,,$(notdir $(1)))*.py) -find-pydoc-patches-deps = $(wildcard tools/inject_pydoc/$(1).py) find-patch-codegen-deps = $(wildcard tools/patch_codegen/*$(1)*.py) # Some .i files depend on some other .i files in order to be parseable by SWiG @@ -733,17 +776,16 @@ define make-module-rules $(Q)$(CP) $$< $$@ # obj/x86_linux_gcc/wrappers/ida_X.py.final (note: dep. on .cpp. See note above.) - $(ST_WRAP)/ida_$(1).py.final: $(ST_WRAP)/$(1).cpp tools/inject_pydoc.py $(PARSED_HEADERS_MARKER) $(call find-pydoc-patches-deps,$(1)) $(call find-patch-codegen-deps,$(1)) - $(QINJECT_PYDOC)$(PYTHON) tools/inject_pydoc.py \ - --xml-doc-directory $(ST_PARSED_HEADERS) \ - --module $(1) \ + $(ST_WRAP)/ida_$(1).py.final: $(ST_WRAP)/$(1).cpp $(wildcard tools/pypasses/*.py) $(wildcard tools/pypasses/*/*.py) $(wildcard apidoc/ida_$(1).py) $(PARSED_HEADERS_MARKER) $(call find-patch-codegen-deps,$(1)) + $(QINJECT_PYDOC)$(PYTHON) tools/pypasses.py \ --input $(ST_WRAP)/ida_$(1).py \ - --interface $(ST_SWIG)/$(1).i \ + --idapython-module-name ida_$(1) \ + --doxygen-xml $(ST_PARSED_HEADERS) \ --cpp-wrapper $(ST_WRAP)/$(1).cpp \ - --traces tools/collected_traces.txt \ - --cases tools/inject_pydoc_cases.txt \ + --passes inject_doxygen,return_type_from_cpp_wrapper,pydoc_overrides,proto_overrides,argsify_for_dispatching_cpp,proto_fix_known_types \ + --pydoc-overrides apidoc/ida_$(1).py \ --output $$@ \ - --verbose > $(ST_WRAP)/ida_$(1).pydoc_injection + --debug > $(ST_WRAP)/ida_$(1).pydoc_injection # obj/x86_linux_gcc/swig/X.i $(ST_SWIG)/$(1).i: $(addprefix $(F),$(call find-pywraps-deps,$(1))) swig/$(1).i $(ST_SWIG_HEADER) $(SWIG_IFACE_$(1):%=$(ST_SWIG)/%.i) $(ST_SWIG_HEADER) tools/deploy.py $(PARSED_HEADERS_MARKER) @@ -765,7 +807,7 @@ define make-module-rules # 6. on windows, patch_directors_cc.py patches x.h in place again $(ST_WRAP)/$(1).cpp: $(ST_SWIG)/$(1).i tools/patch_codegen.py tools/patch_python_codegen.py $(PATCH_DIRECTORS_SCRIPT) $(PARSED_HEADERS_MARKER) tools/chkapi.py tools/wrapper_utils.py $(QSWIG)$(SWIG) $(addprefix -D,$(WITH_HEXRAYS_DEF)) -python $(_SWIGPY3FLAG) -threads -c++ -shadow \ - -D__GNUC__ -DSWIG_PYTHON_LEGACY_BOOL=1 $(SWIGFLAGS) $(addprefix -D,$(DEF64)) -I$(ST_SWIG) \ + -D__GNUC__ -DSWIG_PYTHON_LEGACY_BOOL=1 $(SWIGFLAGS) $(addprefix -D,$(EASIZE_DEF)) -I$(ST_SWIG) \ -outdir $(ST_WRAP) -o $$@.in1 -oh $(ST_WRAP)/$(1).h -I$(ST_SDK) -DIDAPYTHON_MODULE_$(1)=1 $$< $(call PATCH_CONST,$(ST_WRAP)/$(1).cpp.in1,$(ST_WRAP)/$(1).cpp.in2) $(QPATCH_CODEGEN)$(PYTHON) tools/patch_codegen.py \ @@ -799,11 +841,16 @@ X_O = $(call objs,$(MODULES_NAMES)) vpath %.cpp $(ST_WRAP) ifdef __NT__ # remove warnings from generated code: + # warning C4100: '': unreferenced formal parameter # error C4296: '<': expression is always false # warning C4647: behavior change: __is_pod(type) has different value in previous versions # warning C4700: uninitialized local variable 'c_result' used # warning C4706: assignment within conditional expression - $(X_O): CFLAGS += /wd4296 /wd4647 /wd4700 /wd4706 + $(X_O): CFLAGS += /wd4100 /wd4296 /wd4647 /wd4700 /wd4706 +ifndef NDEBUG + # Use debug wrappers with the Python release dll + $(X_O): CC_DEFS += SWIG_PYTHON_INTERPRETER_NO_DEBUG +endif endif # disable -fno-rtti $(X_O): pywraps.hpp @@ -830,7 +877,7 @@ endif # See Python's dynload_win.c:GetPythonImport() for more details. $(_IDA_X_SO): STDLIBS += $(LINKIDAPYTHON) $(_IDA_X_SO): LDFLAGS += $(PYTHON_LDFLAGS) $(PYTHON_LDFLAGS_RPATH_MODULE) $(OUTMAP)$(F)$(@F).map -$(F)_ida_%$(PYDLL_EXT): $(F)%$(O) $(MODULE) $(IDAPYTHON_IMPLIB_DEF) $(IDAPYSWITCH_MODULE_DEP) $(TBD_MODULE_DEP) +$(F)_ida_%$(PYDLL_EXT): $(F)%$(O) $(MODULE) $(IDAPYTHON_IMPLIB_DEF) $(IDAPYSWITCH_MODULE_DEP) $(call link_dll, $<, $(LINKIDA)) ifdef __NT__ $(Q)$(RM) $(@:$(PYDLL_EXT)=.exp) $(@:$(PYDLL_EXT)=.lib) @@ -840,44 +887,58 @@ endif $(DEPLOY_LIBDIR)/_ida_%$(PYDLL_EXT): $(F)_ida_%$(PYDLL_EXT) $(Q)$(CP) $< $@ ifdef __LINUX__ - ifndef __CODE_CHECKER__ + ifneq (,$(POSTACTION_IDA_X_SO)) $(Q)$(POSTACTION_IDA_X_SO) $@ endif endif #---------------------------------------------------------------------- -ifdef TESTABLE_BUILD - API_CONTENTS = api_contents$(EXTRASUF1).brief -else - API_CONTENTS = api_contents$(EXTRASUF1).full - API_CONTENTS_OPTS := --dump-doc -endif -ST_API_CONTENTS = $(F)$(API_CONTENTS) -ST_API_CONTENTS_SUCCESS = $(ST_API_CONTENTS).success -.PRECIOUS: $(ST_API_CONTENTS) -api_contents: $(ST_API_CONTENTS_SUCCESS) -ifeq ($(or $(__CODE_CHECKER__),$(NO_CMP_API),$(__ASAN__),$(IDAHOME),$(DEMO_OR_FREE)),) -$(ST_API_CONTENTS_SUCCESS): $(ALL_ST_WRAP_PY_FINAL) $(API_CONTENTS) tools/py_scanner.py - $(QDUMPAPI)$(PYTHON) tools/py_scanner.py --dump-kind $(API_CONTENTS_OPTS) --paths $(subst $(space),$(comma),$(ALL_ST_WRAP_PY_FINAL)) > $(ST_API_CONTENTS) - ifeq ($(OUT_OF_TREE_BUILD),) - $(Q)((diff -w $(API_CONTENTS) $(ST_API_CONTENTS)) > /dev/null && touch $@) || \ - (echo "API CONTENTS CHANGED! update $(API_CONTENTS) or fix the API" && \ - echo "(New API: $(ST_API_CONTENTS)) ***" && \ - (diff -U 1 -w $(API_CONTENTS) $(ST_API_CONTENTS); true)) - else - $(Q)touch $@ - endif +API_CONTENTS_BRIEF = api_contents$(EXTRASUF1).brief +API_CONTENTS_FULL = api_contents$(EXTRASUF1).full + +ST_API_CONTENTS_BRIEF = $(F)$(API_CONTENTS_BRIEF) +ST_API_CONTENTS_FULL = $(F)$(API_CONTENTS_FULL) +ST_API_CONTENTS_BRIEF_SUCCESS = $(ST_API_CONTENTS_BRIEF).success +ST_API_CONTENTS_FULL_SUCCESS = $(ST_API_CONTENTS_FULL).success + +.PRECIOUS: $(ST_API_CONTENTS_BRIEF) $(ST_API_CONTENTS_FULL) + +ifdef TESTABLE_BUILD + DEFAULT_API_CONTENTS = $(API_CONTENTS_BRIEF) else -$(ST_API_CONTENTS_SUCCESS): $(ALL_ST_WRAP_PY_FINAL) tools/py_scanner.py - $(Q)touch $@ + DEFAULT_API_CONTENTS = $(API_CONTENTS_FULL) endif +api_contents: $(DEFAULT_API_CONTENTS) + +define make-api-contents-rule + $(1): $(3) + ifeq ($(or $(__CODE_CHECKER__),$(NO_CMP_API),$(__ASAN__),$(IDAHOME),$(IDACLASS),$(IDAFREE)),) + $(3): $(ALL_ST_WRAP_PY_FINAL) tools/py_scanner.py + $(QDUMPAPI)$(PYTHON) tools/py_scanner.py $(4) --paths $(subst $(space),$(comma),$(ALL_ST_WRAP_PY_FINAL)) > $(2) + ifeq ($(OUT_OF_TREE_BUILD),) + $(Q)((diff -w $(1) $(2)) > /dev/null && touch $$@) || \ + (echo "API CONTENTS CHANGED! update $(1) or fix the API" && \ + echo "(New API: $(2)) ***" && \ + (diff -U 1 -w $(1) $(2); true)) + else + $(Q)touch $$@ + endif + else + $(3): $(ALL_ST_WRAP_PY_FINAL) tools/py_scanner.py + $(Q)touch $$@ + endif +endef + +$(eval $(call make-api-contents-rule,$(API_CONTENTS_BRIEF),$(ST_API_CONTENTS_BRIEF),$(ST_API_CONTENTS_BRIEF_SUCCESS),)) +$(eval $(call make-api-contents-rule,$(API_CONTENTS_FULL),$(ST_API_CONTENTS_FULL),$(ST_API_CONTENTS_FULL_SUCCESS),--dump-doc)) + #------------------------------------------------------------------------- ST_API_CHECK_SUCCESS := $(F)api_check.success api_check: $(ST_API_CHECK_SUCCESS) $(ST_API_CHECK_SUCCESS): $(ALL_ST_WRAP_CPP) -ifeq ($(or $(__CODE_CHECKER__),$(NO_CMP_API),$(__ASAN__),$(IDAHOME),$(DEMO_OR_FREE)),) +ifeq ($(or $(__CODE_CHECKER__),$(NO_CMP_API),$(__ASAN__),$(IDAHOME),$(IDACLASS),$(IDAFREE)),) $(QCHKAPI)$(PYTHON) tools/chkapi.py $(WITH_HEXRAYS_CHKAPI) -i $(subst $(space),$(comma),$(ALL_ST_WRAP_CPP)) -p $(subst $(space),$(comma),$(ALL_ST_WRAP_PY)) endif $(Q)touch $@ @@ -889,19 +950,42 @@ else endif #---------------------------------------------------------------------- +DOCS_DEPS=tools/docs/hrdoc.py tools/docs/hrdoc.css DOCS_MODULES=$(foreach mod,$(MODULES_NAMES),ida_$(mod)) SORTED_DOCS_MODULES=$(sort $(DOCS_MODULES)) -docs: tools/docs/hrdoc.py tools/docs/hrdoc.css +DOC_OUT_HTML?=docs/hr-html +DOC_OUT_MD?=docs/hr-md +docs_html: $(DOCS_DEPS) ifndef __NT__ - $(IDAT_CMD) $(BATCH_SWITCH) -S"tools/docs/hrdoc.py -o docs/hr-html -m $(subst $(space),$(comma),$(SORTED_DOCS_MODULES)),idc,idautils -s idc,idautils -x ida_allins" -t > /dev/null -# $(IDAT_CMD) $(BATCH_SWITCH) -S"tools/docs/hrdoc.py -o docs/hr-html -m ida_pro,ida_kernwin -s idc,idautils -x ida_allins" -t > /dev/null # use this one for testing (faster) + $(IDAT_CMD) $(BATCH_SWITCH) -S"tools/docs/hrdoc.py -o $(DOC_OUT_HTML) -m $(subst $(space),$(comma),$(SORTED_DOCS_MODULES)),idc,idautils -s idc,idautils -x ida_allins" -t > /dev/null +else + $(R)ida -S"tools/docs/hrdoc.py -o $(DOC_OUT_HTML) -m $(subst $(space),$(comma),$(SORTED_DOCS_MODULES)),idc,idautils -s idc,idautils -x ida_allins" -t +endif + +docs_md: $(DOCS_DEPS) +ifndef __NT__ + $(IDAT_CMD) $(BATCH_SWITCH) -S"tools/docs/hrdoc.py -o $(DOC_OUT_MD) -M -m $(subst $(space),$(comma),$(SORTED_DOCS_MODULES)),idc,idautils -s idc,idautils -x ida_allins" -t > /dev/null else $(R)ida -Stools/docs/hrdoc.py -t endif +docs: docs_html docs_md + @echo "copy MARKDOWN files from docs/hr-md ../../../../www/www.hex-rays.com/public_html/hex-rays/cgi-bin/themer/static/products/ida/support/idapython_docs_md/" + @echo "copy HTML files from docs/hr-html ../../../../www/www.hex-rays.com/public_html/hex-rays/cgi-bin/themer/static/products/ida/support/idapython_docs/" + @echo "" + @read -p "Do you want to copy files to P4 repo? [y/N] " ans && ans=$${ans:-N} ; \ + if [ $${ans} = y ] || [ $${ans} = Y ]; then \ + echo "Starting to copy html & md files" ; \ + ./copy_docs_to_p4.sh MARKDOWN docs/hr-md ../../../www/www.hex-rays.com/public_html/hex-rays/cgi-bin/themer/static/products/ida/support/idapython_docs_md/; \ + ./copy_docs_to_p4.sh HTML docs/hr-html ../../../www/www.hex-rays.com/public_html/hex-rays/cgi-bin/themer/static/products/ida/support/idapython_docs/; \ + else \ + echo "NO file copied" ; \ + fi + + @echo "\033[0;32mFiles prepared in P4, you need to manually submit them\033[0m" # the demo version of ida does not have the -B command line option ifeq ($(OUT_OF_TREE_BUILD),) - ifndef DEMO_OR_FREE + ifndef IDAFREE BATCH_SWITCH=-B endif endif @@ -947,7 +1031,7 @@ ifdef __NT__ endif endif endif -$(R)idapyswitch$(B): $(call dumb_target, pro, $(IDAPYSWITCH_OBJS)) +$(R)idapyswitch$(B): $(QT_BINDINGS_DEPS) $(call dumb_target, pro compress, $(IDAPYSWITCH_OBJS)) #---------------------------------------------------------------------- TEST_PYWRAPS_OBJS += $(F)test_pywraps$(O) @@ -959,7 +1043,11 @@ ifdef __NT__ $(F)test_pywraps$(O): RUNTIME_LIBSW=/MT endif endif -$(R)test_pywraps$(B): $(call dumb_target, json idc unicode pro, $(TEST_PYWRAPS_OBJS)) $(PYTHON_LDFLAGS) + +ifdef __MAC__ +LDFLAGS_EXE += -Wl,-rpath,@executable_path +endif +$(R)test_pywraps$(B): $(call dumb_target, json idc unicode pro, $(TEST_PYWRAPS_OBJS)) $(PYTHON_LDFLAGS) $(LDFLAGS_EXE) $(F)$(TEST_PYWRAPS_RESULT_FNAME).marker: $(R)test_pywraps$(B) $(Q)$(TEST_PYWRAPS_ENV) $(R)test_pywraps$(B) > $(F)$(TEST_PYWRAPS_RESULT_FNAME) @@ -977,17 +1065,6 @@ else test_pywraps: $(TEST_PYWRAPS) endif -#---------------------------------------------------------------------- -ifdef __MAC__ -tbd: $(TBD_MODULE_DEP) -# copy the tbd library to idabin, and instruct idapyswitch to create the symlink to libpython -$(TBD_MODULE_DEP): $(TBD_FILE) $(IDAPYSWITCH_DEP) - $(Q)$(CP) $< $@ - cd $(R) && $(IDAPYSWITCH_PATH) $(TBD_IDAPYSWITCH_ARGS) --force-path $(shell $(PYTHON)-config --prefix)/Python -else -tbd: ; -endif - #---------------------------------------------------------------------- # the 'echo_modules' target must be called explicitly # Note: used by ida/build/pkgbin.py @@ -1000,48 +1077,52 @@ clean:: ifdef __CODE_CHECKER__ examples_index: ; + examples: ; else - EXAMPLES := $(wildcard examples/**/*.py) + EXAMPLES := $(wildcard examples/*/*.py examples/*/*/*.py examples/*/*/*/*.py) GEN_EXAMPLES_TOOL := tools/gen_examples_index.py GEN_EXAMPLES_CFG := tools/gen_examples_index.cfg - ST_EXAMPLES_INDEX_HTML := $(F)examples/index.html - ST_EXAMPLES_INDEX_MD := $(F)examples/index.md + EXAMPLES_INDEX_MD := examples/index.md + EXAMPLES_README := examples/README.md + + ST_EXAMPLES_INDEX_MD = $(F)$(EXAMPLES_INDEX_MD) + ST_EXAMPLES_INDEX_MD_SUCCESS = $(ST_EXAMPLES_INDEX_MD).success + + .PRECIOUS: $(ST_EXAMPLES_INDEX_MD) define make-examples-index-rules - $(eval EXAMPLES_INDEX := examples/index.$(1)) - $(eval ST_EXAMPLES_INDEX := $(2)) - $(eval EXAMPLES_TEMPLATE := tools/examples_index_template.$(1)) - - .PRECIOUS: $(ST_EXAMPLES_INDEX) - $(eval EXAMPLES_INDEX_CMD := $(PYTHON) $(GEN_EXAMPLES_TOOL) write \ - -t $(EXAMPLES_TEMPLATE) \ + -t $(4) \ -e examples \ - -o $(ST_EXAMPLES_INDEX) \ + -o $(2) \ ) - $(ST_EXAMPLES_INDEX): $(GEN_EXAMPLES_TOOL) $(GEN_EXAMPLES_CFG) \ - $(EXAMPLES_TEMPLATE) $(EXAMPLES) + $(1): $(3) + $(3): $(GEN_EXAMPLES_TOOL) $(GEN_EXAMPLES_CFG) $(4) $(EXAMPLES) -$(Q)if [ ! -d "$(F)examples" ] ; then mkdir -p 2>/dev/null $(F)examples ; fi $(QGEN_EXAMPLES_INDEX)$(EXAMPLES_INDEX_CMD) \ || echo FAILED: $(EXAMPLES_INDEX_CMD) - $(Q)diff -w $(EXAMPLES_INDEX) $(ST_EXAMPLES_INDEX) > /dev/null \ - || (echo "EXAMPLES INDEX CHANGED! update $(EXAMPLES_INDEX)" \ - && echo "(New examples: $(ST_EXAMPLES_INDEX)) ***" \ - && diff -U 1 -w $(EXAMPLES_INDEX) $(ST_EXAMPLES_INDEX) \ - && false) + $(Q)diff -w $(1) $(2) > /dev/null && touch $$@ \ + || (echo "EXAMPLES INDEX CHANGED! update $(1)" \ + && echo "(New examples: $(2)) ***" \ + && diff -U 1 -w $(1) $(2); true) endef - $(eval $(call make-examples-index-rules,html,$(ST_EXAMPLES_INDEX_HTML))) - $(eval $(call make-examples-index-rules,md,$(ST_EXAMPLES_INDEX_MD))) + $(eval $(call make-examples-index-rules,$(EXAMPLES_INDEX_MD),$(ST_EXAMPLES_INDEX_MD),$(ST_EXAMPLES_INDEX_MD_SUCCESS),tools/examples_index_template.md,md)) - examples_index: $(ST_EXAMPLES_INDEX_HTML) $(ST_EXAMPLES_INDEX_MD) + examples_index: $(EXAMPLES_INDEX_MD) + + EXAMPLE_FILES := $(addprefix $(R)python/,$(EXAMPLES) $(EXAMPLES_INDEX_MD) $(EXAMPLES_README)) + examples: $(EXAMPLE_FILES) + $(EXAMPLE_FILES): $(R)python/examples/%: examples/% + $(Q)if [ ! -d $(dir $@) ]; then mkdir -p $(dir $@); fi + $(Q)$(CP) $< $@ endif -$(MODULE): LDFLAGS += $(PYTHON_LDFLAGS) +$(MODULE): LDFLAGS += $(PYTHON_LDFLAGS) $(LDFLAGS_MOD) # MAKEDEP dependency list ------------------ $(F)idapyswitch$(O): $(I)auto.hpp $(I)bitrange.hpp $(I)bytes.hpp \ @@ -1052,82 +1133,31 @@ $(F)idapyswitch$(O): $(I)auto.hpp $(I)bitrange.hpp $(I)bytes.hpp \ $(I)lzvn_decode_base.h $(I)md5.h $(I)nalt.hpp \ $(I)name.hpp $(I)netnode.hpp $(I)network.hpp \ $(I)offset.hpp $(I)pro.h $(I)prodir.h $(I)range.hpp \ - $(I)segment.hpp $(I)segregs.hpp $(I)ua.hpp $(I)xref.hpp \ - ../../ldr/ar/aixar.hpp ../../ldr/ar/ar.hpp \ - ../../ldr/ar/arcmn.cpp ../../ldr/elf/../idaldr.h \ - ../../ldr/elf/elf.h ../../ldr/elf/elfbase.h \ - ../../ldr/elf/elfr_arm.h ../../ldr/elf/elfr_ia64.h \ - ../../ldr/elf/elfr_mips.h ../../ldr/elf/elfr_ppc.h \ - ../../ldr/elf/reader.cpp ../../ldr/mach-o/../ar/ar.hpp \ - ../../ldr/mach-o/../idaldr.h ../../ldr/mach-o/base.cpp \ - ../../ldr/mach-o/common.cpp ../../ldr/mach-o/common.h \ - ../../ldr/mach-o/h/architecture/byte_order.h \ - ../../ldr/mach-o/h/arm/_types.h \ - ../../ldr/mach-o/h/i386/_types.h \ - ../../ldr/mach-o/h/i386/eflags.h \ - ../../ldr/mach-o/h/libkern/OSByteOrder.h \ - ../../ldr/mach-o/h/libkern/arm/OSByteOrder.h \ - ../../ldr/mach-o/h/libkern/i386/OSByteOrder.h \ - ../../ldr/mach-o/h/libkern/i386/_OSByteOrder.h \ - ../../ldr/mach-o/h/libkern/machine/OSByteOrder.h \ - ../../ldr/mach-o/h/mach-o/arm/reloc.h \ - ../../ldr/mach-o/h/mach-o/arm64/reloc.h \ - ../../ldr/mach-o/h/mach-o/fat.h \ - ../../ldr/mach-o/h/mach-o/fixup-chains.h \ - ../../ldr/mach-o/h/mach-o/hppa/reloc.h \ - ../../ldr/mach-o/h/mach-o/i860/reloc.h \ - ../../ldr/mach-o/h/mach-o/loader.h \ - ../../ldr/mach-o/h/mach-o/m88k/reloc.h \ - ../../ldr/mach-o/h/mach-o/nlist.h \ - ../../ldr/mach-o/h/mach-o/ppc/reloc.h \ - ../../ldr/mach-o/h/mach-o/reloc.h \ - ../../ldr/mach-o/h/mach-o/sparc/reloc.h \ - ../../ldr/mach-o/h/mach-o/stab.h \ - ../../ldr/mach-o/h/mach-o/x86_64/reloc.h \ - ../../ldr/mach-o/h/mach/arm/_structs.h \ - ../../ldr/mach-o/h/mach/arm/boolean.h \ - ../../ldr/mach-o/h/mach/arm/thread_state.h \ - ../../ldr/mach-o/h/mach/arm/thread_status.h \ - ../../ldr/mach-o/h/mach/arm/vm_types.h \ - ../../ldr/mach-o/h/mach/boolean.h \ - ../../ldr/mach-o/h/mach/i386/_structs.h \ - ../../ldr/mach-o/h/mach/i386/boolean.h \ - ../../ldr/mach-o/h/mach/i386/fp_reg.h \ - ../../ldr/mach-o/h/mach/i386/kern_return.h \ - ../../ldr/mach-o/h/mach/i386/thread_state.h \ - ../../ldr/mach-o/h/mach/i386/thread_status.h \ - ../../ldr/mach-o/h/mach/i386/vm_param.h \ - ../../ldr/mach-o/h/mach/i386/vm_types.h \ - ../../ldr/mach-o/h/mach/kern_return.h \ - ../../ldr/mach-o/h/mach/kmod.h \ - ../../ldr/mach-o/h/mach/machine.h \ - ../../ldr/mach-o/h/mach/machine/boolean.h \ - ../../ldr/mach-o/h/mach/machine/kern_return.h \ - ../../ldr/mach-o/h/mach/machine/thread_status.h \ - ../../ldr/mach-o/h/mach/machine/vm_types.h \ - ../../ldr/mach-o/h/mach/message.h \ - ../../ldr/mach-o/h/mach/port.h \ - ../../ldr/mach-o/h/mach/vm_prot.h \ - ../../ldr/mach-o/h/mach/vm_types.h \ - ../../ldr/mach-o/h/sys/_posix_availability.h \ - ../../ldr/mach-o/h/sys/_symbol_aliasing.h \ - ../../ldr/mach-o/h/sys/cdefs.h \ - ../../ldr/mach-o/macho_node.h \ + $(I)registry.hpp $(I)segment.hpp $(I)segregs.hpp \ + $(I)ua.hpp $(I)xref.hpp ../../ldr/ar/aixar.hpp \ + ../../ldr/ar/ar.hpp ../../ldr/ar/arcmn.cpp \ + ../../ldr/mach-o/../ar/ar.hpp \ + ../../ldr/mach-o/../idaldr.h \ + ../../ldr/mach-o/apple_common.h \ + ../../ldr/mach-o/base.cpp ../../ldr/mach-o/common.cpp \ + ../../ldr/mach-o/common.h ../../ldr/mach-o/macho_node.h \ ../../ldr/mach-o/strtab_reader_t.h \ ../../ldr/mach-o/uncompress.cpp ../../ldr/pe/../idaldr.h \ ../../ldr/pe/common.cpp ../../ldr/pe/common.h \ - ../../ldr/pe/pe.h idapyswitch.cpp idapyswitch_linux.cpp \ - idapyswitch_mac.cpp idapyswitch_win.cpp + ../../ldr/pe/pe.h ../../pro/registry.cpp idapyswitch.cpp \ + idapyswitch_linux.cpp idapyswitch_mac.cpp \ + idapyswitch_win.cpp $(F)idapython$(O): $(I)bitrange.hpp $(I)bytes.hpp $(I)config.hpp \ $(I)diskio.hpp $(I)err.h $(I)expr.hpp $(I)fpro.h \ $(I)funcs.hpp $(I)gdl.hpp $(I)graph.hpp $(I)ida.hpp \ $(I)ida_highlighter.hpp $(I)idd.hpp $(I)idp.hpp \ - $(I)ieee.h $(I)kernwin.hpp $(I)lex.hpp $(I)lines.hpp \ - $(I)llong.hpp $(I)loader.hpp $(I)nalt.hpp $(I)name.hpp \ + $(I)ieee.h $(I)kernwin.hpp $(I)lex.hpp \ + $(I)lines.hpp $(I)llong.hpp $(I)loader.hpp \ + $(I)make_script_ns.hpp $(I)nalt.hpp $(I)name.hpp \ $(I)netnode.hpp $(I)parsejson.hpp $(I)pro.h \ $(I)range.hpp $(I)segment.hpp $(I)typeinf.hpp $(I)ua.hpp \ - $(I)xref.hpp extapi.hpp idapython.cpp pywraps.cpp \ - pywraps.hpp + $(I)xref.hpp extapi.cpp \ + extapi.hpp idapython.cpp pywraps.cpp pywraps.hpp $(F)test_pywraps$(O): $(I)bitrange.hpp $(I)bytes.hpp $(I)config.hpp \ $(I)err.h $(I)expr.hpp $(I)fpro.h $(I)funcs.hpp \ $(I)gdl.hpp $(I)graph.hpp $(I)ida.hpp $(I)idd.hpp \ @@ -1135,5 +1165,5 @@ $(F)test_pywraps$(O): $(I)bitrange.hpp $(I)bytes.hpp $(I)config.hpp \ $(I)lines.hpp $(I)llong.hpp $(I)loader.hpp $(I)nalt.hpp \ $(I)name.hpp $(I)netnode.hpp $(I)parsejson.hpp $(I)pro.h \ $(I)range.hpp $(I)segment.hpp $(I)typeinf.hpp $(I)ua.hpp \ - $(I)xref.hpp extapi.cpp extapi.hpp pywraps.cpp \ - pywraps.hpp test_pywraps.cpp + $(I)xref.hpp extapi.cpp extapi.hpp pywraps.cpp \ + pywraps.hpp test_pywraps.cpp diff --git a/out_of_tree/parsed_notifications.zip b/out_of_tree/parsed_notifications.zip index 1c0835a..5a88d3f 100644 Binary files a/out_of_tree/parsed_notifications.zip and b/out_of_tree/parsed_notifications.zip differ diff --git a/python/idautils.py b/python/idautils.py index 76c6693..b79ff62 100644 --- a/python/idautils.py +++ b/python/idautils.py @@ -26,7 +26,7 @@ import ida_name import ida_netnode import ida_segment import ida_strlist -import ida_struct +import ida_typeinf import ida_ua import ida_xref @@ -310,13 +310,14 @@ def Structs(): """ Get a list of structures - @return: List of tuples (idx, sid, name) + @return: List of tuples (ordinal, sid, name) """ - idx = idc.get_first_struc_idx() - while idx != ida_idaapi.BADADDR: - sid = idc.get_struc_by_idx(idx) - yield (idx, sid, idc.get_struc_name(sid)) - idx = idc.get_next_struc_idx(idx) + limit = ida_typeinf.get_ordinal_limit() + for ordinal in range(1, limit): + tif = ida_typeinf.tinfo_t() + tif.get_numbered_type(None, ordinal) + if tif.is_udt(): + yield (ordinal, tif.get_tid(), tif.get_type_name()) def StructMembers(sid): @@ -325,21 +326,21 @@ def StructMembers(sid): @param sid: ID of the structure. - @return: List of tuples (offset, name, size) + @return: List of tuples (offset_in_bytes, name, size_in_bytes) @note: If 'sid' does not refer to a valid structure, an exception will be raised. @note: This will not return 'holes' in structures/stack frames; it only returns defined structure members. """ - sptr = ida_struct.get_struc(sid) - if sptr is None: + tif = ida_typeinf.tinfo_t() + if not tif.get_type_by_tid(sid) or not tif.is_udt(): raise Exception("No structure with ID: 0x%x" % sid) - for m in sptr.members: - name = idc.get_member_name(sid, m.soff) - if name: - size = ida_struct.get_member_size(m) - yield (m.soff, name, size) + udt = ida_typeinf.udt_type_data_t() + tif.get_udt_details(udt) + for udm in udt: + if not udm.is_gap(): + yield (udm.offset//8, udm.name, udm.size//8) def DecodePrecedingInstruction(ea): @@ -738,8 +739,8 @@ class peutils_t(object): header_offset = property(lambda self: self.__penode.altval(peutils_t.PE_ALT_PEHDR_OFF)) """Offset of PE header""" - def __str__(self): - return "peutils_t(imagebase=%x, header=%x)" % (self.imagebase, self.header_offset) + def __repr__(self): + return f"{self.__class__.__module__}.{self.__class__.__name__}(imagebase=%x, header=%x)" % (self.imagebase, self.header_offset) header = lambda self: self.__penode.valobj() """Returns the complete PE header as an instance of peheader_t (defined in the SDK).""" diff --git a/python/idc.py b/python/idc.py index 4dd2667..643e806 100644 --- a/python/idc.py +++ b/python/idc.py @@ -32,7 +32,6 @@ import ida_auto import ida_dbg import ida_diskio import ida_entry -import ida_enum import ida_expr import ida_fixup import ida_frame @@ -55,7 +54,6 @@ import ida_pro import ida_search import ida_segment import ida_segregs -import ida_struct import ida_typeinf import ida_ua import ida_xref @@ -275,20 +273,16 @@ FF_JUMP = ida_bytes.FF_JUMP & 0xFFFFFFFF # Has jump table # # Loader flags # -if ida_idaapi.uses_swig_builtins: - _scope = ida_loader.loader_t -else: - _scope = ida_loader -NEF_SEGS = _scope.NEF_SEGS # Create segments -NEF_RSCS = _scope.NEF_RSCS # Load resources -NEF_NAME = _scope.NEF_NAME # Rename entries -NEF_MAN = _scope.NEF_MAN # Manual load -NEF_FILL = _scope.NEF_FILL # Fill segment gaps -NEF_IMPS = _scope.NEF_IMPS # Create imports section -NEF_FIRST = _scope.NEF_FIRST # This is the first file loaded -NEF_CODE = _scope.NEF_CODE # for load_binary_file: -NEF_RELOAD = _scope.NEF_RELOAD # reload the file at the same place: -NEF_FLAT = _scope.NEF_FLAT # Autocreated FLAT group (PE) +NEF_SEGS = ida_loader.NEF_SEGS # Create segments +NEF_RSCS = ida_loader.NEF_RSCS # Load resources +NEF_NAME = ida_loader.NEF_NAME # Rename entries +NEF_MAN = ida_loader.NEF_MAN # Manual load +NEF_FILL = ida_loader.NEF_FILL # Fill segment gaps +NEF_IMPS = ida_loader.NEF_IMPS # Create imports section +NEF_FIRST = ida_loader.NEF_FIRST # This is the first file loaded +NEF_CODE = ida_loader.NEF_CODE # for load_binary_file: +NEF_RELOAD = ida_loader.NEF_RELOAD # reload the file at the same place: +NEF_FLAT = ida_loader.NEF_FLAT # Autocreated FLAT group (PE) # List of built-in functions # -------------------------- @@ -506,10 +500,10 @@ def delete_all_segments(): Delete all segments, instructions, comments, i.e. everything except values of bytes. """ - ea = ida_ida.cvar.inf.min_ea + ea = ida_ida.inf_get_min_ea() # Brute-force nuke all info from all the heads - while ea != BADADDR and ea <= ida_ida.cvar.inf.max_ea: + while ea != BADADDR and ea <= ida_ida.inf_get_max_ea(): ida_name.del_local_name(ea) ida_name.del_global_name(ea) func = ida_funcs.get_func(ea) @@ -524,7 +518,7 @@ def delete_all_segments(): ida_segment.set_segment_cmt(seg, "", True) ida_segment.del_segm(ea, ida_segment.SEGMOD_KEEP | ida_segment.SEGMOD_SILENT) - ea = ida_bytes.next_head(ea, ida_ida.cvar.inf.max_ea) + ea = ida_bytes.next_head(ea, ida_ida.inf_get_max_ea()) create_insn = ida_ua.create_insn @@ -755,12 +749,14 @@ def create_struct(ea, size, strname): @return: 1-ok, 0-failure """ - strid = ida_struct.get_struc_id(strname) + tif = ida_typeinf.tinfo_t() + if not tif.get_named_type(None, strname) or not tif.is_udt(): + return -1 if size == -1: - size = ida_struct.get_struc_size(strid) + size = tif.get_size() - return ida_bytes.create_struct(ea, size, strid) + return ida_bytes.create_struct(ea, size, tif.get_tid()) create_custom_data = ida_bytes.create_custdata @@ -800,7 +796,7 @@ def define_local_var(start, end, location, name): return 0 offset = int(m.group(2), 0) - return 1 if ida_frame.define_stkvar(func, name, offset, ida_bytes.byte_flag(), None, 1) else 0 + return 1 if ida_frame.define_stkvar(func, name, offset, ida_typeinf.tinfo_t(ida_typeinf.BT_UNK_BYTE)) else 0 else: # Location as simple register name return ida_frame.add_regvar(func, start, end, location, name, None) @@ -1029,11 +1025,10 @@ def split_sreg_range(ea, reg, value, tag=SR_user): values. This function allows you to specify the correct value of a segment register if IDA is not able to find the correct value. """ - rnames = [r.casefold() for r in ida_idp.ph_get_regnames()] - for regno in range(ida_idp.ph_get_reg_first_sreg(), ida_idp.ph_get_reg_last_sreg()+1): - if rnames[regno]==reg.casefold(): - return ida_segregs.split_sreg_range(ea, regno, value, tag) - return False + reg = ida_idp.str2sreg(reg); + if reg == -1: + return False + return ida_segregs.split_sreg_range(ea, reg, value, tag) auto_mark_range = ida_auto.auto_mark_range @@ -1072,11 +1067,12 @@ def gen_file(filetype, path, ea1, ea2, flags): -1 if an error occurred OFILE_EXE: 0-can't generate exe file, 1-ok """ - f = ida_diskio.fopenWB(path) - - if f: - retval = ida_loader.gen_file(filetype, f, ea1, ea2, flags) - ida_diskio.eclose(f) + fopen = ida_diskio.fopenWB if filetype == ida_loader.OFILE_EXE else ida_diskio.fopenWT + fp = fopen(path) + if fp: + retval = ida_loader.gen_file(filetype, fp, ea1, ea2, flags) + import ida_fpro + ida_fpro.qfclose(fp) return retval else: return -1 @@ -1190,7 +1186,7 @@ def __DbgValue(ea, len): if len not in ida_idaapi.__struct_unpack_table: return None r = ida_idd.dbg_read_memory(ea, len) - return None if r is None else struct.unpack((">" if ida_ida.cvar.inf.is_be() else "<") + ida_idaapi.__struct_unpack_table[len][1], r)[0] + return None if r is None else struct.unpack((">" if ida_ida.inf_is_be() else "<") + ida_idaapi.__struct_unpack_table[len][1], r)[0] def read_dbg_byte(ea): @@ -1372,11 +1368,10 @@ def get_sreg(ea, reg): so to get paragraph pointed to by the segment register you need to call sel2para() function. """ - reg = ida_idp.str2reg(reg); - if reg >= 0: - return ida_segregs.get_sreg(ea, reg) - else: + reg = ida_idp.str2sreg(reg); + if reg == -1: return -1 + return ida_segregs.get_sreg(ea, reg) next_addr = ida_bytes.next_addr prev_addr = ida_bytes.prev_addr @@ -1742,28 +1737,8 @@ find_data = ida_search.find_data find_unknown = ida_search.find_unknown find_defined = ida_search.find_defined find_imm = ida_search.find_imm - -SEARCH_UP = ida_search.SEARCH_UP # search backward -SEARCH_DOWN = ida_search.SEARCH_DOWN # search forward -SEARCH_NEXT = ida_search.SEARCH_NEXT # start the search at the next/prev item - # useful only for find_text() and find_binary() -SEARCH_CASE = ida_search.SEARCH_CASE # search case-sensitive - # (only for bin&txt search) -SEARCH_REGEX = ida_search.SEARCH_REGEX # enable regular expressions (only for text) -SEARCH_NOBRK = ida_search.SEARCH_NOBRK # don't test ctrl-break -SEARCH_NOSHOW = ida_search.SEARCH_NOSHOW # don't display the search progress - - -def find_text(ea, flag, y, x, searchstr): - __warn_once_deprecated_proto_confusion("find_text", "ida_search.find_text") - return ida_search.find_text(ea, y, x, searchstr, flag) - - -def find_binary(ea, flag, searchstr, radix=16): - __warn_once_deprecated_proto_confusion("find_binary", "ida_search.find_binary") - endea = flag & 1 and ida_ida.cvar.inf.max_ea or ida_ida.cvar.inf.min_ea - return ida_search.find_binary(ea, endea, searchstr, radix, flag) - +find_text = ida_search.find_text +find_bytes = ida_bytes.find_bytes #---------------------------------------------------------------------------- # G L O B A L S E T T I N G S M A N I P U L A T I O N @@ -1891,7 +1866,7 @@ INF_START_PRIVRANGE=INF_PRIVRANGE_START_EA INF_PRIVRANGE_END_EA = 28 # uval_t; Initially (MAXADDR, MAXADDR+0x100000) INF_END_PRIVRANGE=INF_PRIVRANGE_END_EA -INF_NETDELTA = 29 # sval_t; Delta value to be added to all adresses for mapping to netnodes. +INF_NETDELTA = 29 # sval_t; Delta value to be added to all addresses for mapping to netnodes. # Initially 0. # CROSS REFERENCES INF_XREFNUM = 30 # char; Number of references to generate @@ -1911,7 +1886,7 @@ INF_XREFS=INF_XREFFLAG # NAMES INF_MAX_AUTONAME_LEN = 34 # ushort; max name length (without zero byte) -INF_NAMETYPE = 35 # char; dummy names represenation type +INF_NAMETYPE = 35 # char; dummy names representation type INF_SHORT_DEMNAMES = 36 # int32; short form of demangled names INF_SHORT_DN=INF_SHORT_DEMNAMES INF_LONG_DEMNAMES = 37 # int32; long form of demangled names @@ -2159,7 +2134,7 @@ def sel2para(sel): def find_selector(val): """ - Find a selector which has the specifed value + Find a selector which has the specified value @param val: value to search for @@ -2377,26 +2352,22 @@ def set_segm_alignment(ea, alignment): return set_segm_attr(ea, SEGATTR_ALIGN, alignment) -if ida_idaapi.uses_swig_builtins: - _scope = ida_segment.segment_t -else: - _scope = ida_segment -saAbs = _scope.saAbs # Absolute segment. -saRelByte = _scope.saRelByte # Relocatable, byte aligned. -saRelWord = _scope.saRelWord # Relocatable, word (2-byte, 16-bit) aligned. -saRelPara = _scope.saRelPara # Relocatable, paragraph (16-byte) aligned. -saRelPage = _scope.saRelPage # Relocatable, aligned on 256-byte boundary - # (a "page" in the original Intel specification). -saRelDble = _scope.saRelDble # Relocatable, aligned on a double word - # (4-byte) boundary. This value is used by - # the PharLap OMF for the same alignment. -saRel4K = _scope.saRel4K # This value is used by the PharLap OMF for - # page (4K) alignment. It is not supported - # by LINK. -saGroup = _scope.saGroup # Segment group -saRel32Bytes = _scope.saRel32Bytes # 32 bytes -saRel64Bytes = _scope.saRel64Bytes # 64 bytes -saRelQword = _scope.saRelQword # 8 bytes +saAbs = ida_segment.saAbs # Absolute segment. +saRelByte = ida_segment.saRelByte # Relocatable, byte aligned. +saRelWord = ida_segment.saRelWord # Relocatable, word (2-byte, 16-bit) aligned. +saRelPara = ida_segment.saRelPara # Relocatable, paragraph (16-byte) aligned. +saRelPage = ida_segment.saRelPage # Relocatable, aligned on 256-byte boundary + # (a "page" in the original Intel specification). +saRelDble = ida_segment.saRelDble # Relocatable, aligned on a double word + # (4-byte) boundary. This value is used by + # the PharLap OMF for the same alignment. +saRel4K = ida_segment.saRel4K # This value is used by the PharLap OMF for + # page (4K) alignment. It is not supported + # by LINK. +saGroup = ida_segment.saGroup # Segment group +saRel32Bytes = ida_segment.saRel32Bytes # 32 bytes +saRel64Bytes = ida_segment.saRel64Bytes # 64 bytes +saRelQword = ida_segment.saRelQword # 8 bytes def set_segm_combination(segea, comb): @@ -2411,15 +2382,15 @@ def set_segm_combination(segea, comb): return set_segm_attr(segea, SEGATTR_COMB, comb) -scPriv = _scope.scPriv # Private. Do not combine with any other program - # segment. -scPub = _scope.scPub # Public. Combine by appending at an offset that - # meets the alignment requirement. -scPub2 = _scope.scPub2 # As defined by Microsoft, same as C=2 (public). -scStack = _scope.scStack # Stack. Combine as for C=2. This combine type - # forces byte alignment. -scCommon = _scope.scCommon # Common. Combine by overlay using maximum size. -scPub3 = _scope.scPub3 # As defined by Microsoft, same as C=2 (public). +scPriv = ida_segment.scPriv # Private. Do not combine with any other program + # segment. +scPub = ida_segment.scPub # Public. Combine by appending at an offset that + # meets the alignment requirement. +scPub2 = ida_segment.scPub2 # As defined by Microsoft, same as C=2 (public). +scStack = ida_segment.scStack # Stack. Combine as for C=2. This combine type + # forces byte alignment. +scCommon = ida_segment.scCommon # Common. Combine by overlay using maximum size. +scPub3 = ida_segment.scPub3 # As defined by Microsoft, same as C=2 (public). def set_segm_addressing(ea, bitness): @@ -2468,12 +2439,10 @@ def set_default_sreg_value(ea, reg, value): @param value: default value of the segment register. -1-undefined. """ seg = ida_segment.getseg(ea) - - reg = ida_idp.str2reg(reg); - if seg and reg >= 0: - return ida_segregs.set_default_sreg_value(seg, reg, value) - else: + reg = ida_idp.str2sreg(reg); + if reg == -1: return False + return ida_segregs.set_default_sreg_value(seg, reg, value) def set_segm_type(segea, segtype): @@ -2494,22 +2463,22 @@ def set_segm_type(segea, segtype): return seg.update() -SEG_NORM = _scope.SEG_NORM -SEG_XTRN = _scope.SEG_XTRN # * segment with 'extern' definitions - # no instructions are allowed -SEG_CODE = _scope.SEG_CODE # pure code segment -SEG_DATA = _scope.SEG_DATA # pure data segment -SEG_IMP = _scope.SEG_IMP # implementation segment -SEG_GRP = _scope.SEG_GRP # * group of segments - # no instructions are allowed -SEG_NULL = _scope.SEG_NULL # zero-length segment -SEG_UNDF = _scope.SEG_UNDF # undefined segment type -SEG_BSS = _scope.SEG_BSS # uninitialized segment -SEG_ABSSYM = _scope.SEG_ABSSYM # * segment with definitions of absolute symbols - # no instructions are allowed -SEG_COMM = _scope.SEG_COMM # * segment with communal definitions - # no instructions are allowed -SEG_IMEM = _scope.SEG_IMEM # internal processor memory & sfr (8051) +SEG_NORM = ida_segment.SEG_NORM +SEG_XTRN = ida_segment.SEG_XTRN # * segment with 'extern' definitions + # no instructions are allowed +SEG_CODE = ida_segment.SEG_CODE # pure code segment +SEG_DATA = ida_segment.SEG_DATA # pure data segment +SEG_IMP = ida_segment.SEG_IMP # implementation segment +SEG_GRP = ida_segment.SEG_GRP # * group of segments + # no instructions are allowed +SEG_NULL = ida_segment.SEG_NULL # zero-length segment +SEG_UNDF = ida_segment.SEG_UNDF # undefined segment type +SEG_BSS = ida_segment.SEG_BSS # uninitialized segment +SEG_ABSSYM = ida_segment.SEG_ABSSYM # * segment with definitions of absolute symbols + # no instructions are allowed +SEG_COMM = ida_segment.SEG_COMM # * segment with communal definitions + # no instructions are allowed +SEG_IMEM = ida_segment.SEG_IMEM # internal processor memory & sfr (8051) def get_segm_attr(segea, attr): @@ -2776,14 +2745,14 @@ def SaveFile(filepath, pos, ea, size): @return: 0 - error, 1 - ok """ if ( os.path.isfile(filepath) ): - of = ida_diskio.fopenM(filepath) + fp = ida_diskio.fopenM(filepath) else: - of = ida_diskio.fopenWB(filepath) + fp = ida_diskio.fopenWB(filepath) - - if of: - retval = ida_loader.base2file(of, pos, ea, ea+size) - ida_diskio.eclose(of) + if fp: + retval = ida_loader.base2file(fp, pos, ea, ea+size) + import ida_fpro + ida_fpro.qfclose(fp) return retval else: return 0 @@ -2950,40 +2919,35 @@ def get_func_flags(ea): return func.flags -if ida_idaapi.uses_swig_builtins: - _scope = ida_funcs.func_t -else: - _scope = ida_funcs - -FUNC_NORET = _scope.FUNC_NORET # function doesn't return -FUNC_FAR = _scope.FUNC_FAR # far function -FUNC_LIB = _scope.FUNC_LIB # library function -FUNC_STATIC = _scope.FUNC_STATICDEF # static function -FUNC_FRAME = _scope.FUNC_FRAME # function uses frame pointer (BP) -FUNC_USERFAR = _scope.FUNC_USERFAR # user has specified far-ness - # of the function -FUNC_HIDDEN = _scope.FUNC_HIDDEN # a hidden function -FUNC_THUNK = _scope.FUNC_THUNK # thunk (jump) function -FUNC_BOTTOMBP = _scope.FUNC_BOTTOMBP # BP points to the bottom of the stack frame -FUNC_NORET_PENDING = _scope.FUNC_NORET_PENDING # Function 'non-return' analysis - # must be performed. This flag is - # verified upon func_does_return() -FUNC_SP_READY = _scope.FUNC_SP_READY # SP-analysis has been performed - # If this flag is on, the stack - # change points should not be not - # modified anymore. Currently this - # analysis is performed only for PC -FUNC_PURGED_OK = _scope.FUNC_PURGED_OK # 'argsize' field has been validated. - # If this bit is clear and 'argsize' - # is 0, then we do not known the real - # number of bytes removed from - # the stack. This bit is handled - # by the processor module. -FUNC_TAIL = _scope.FUNC_TAIL # This is a function tail. - # Other bits must be clear - # (except FUNC_HIDDEN) -FUNC_LUMINA = _scope.FUNC_LUMINA # Function info is provided by Lumina. -FUNC_OUTLINE = _scope.FUNC_OUTLINE # Outlined code, not a real function. +FUNC_NORET = ida_funcs.FUNC_NORET # function doesn't return +FUNC_FAR = ida_funcs.FUNC_FAR # far function +FUNC_LIB = ida_funcs.FUNC_LIB # library function +FUNC_STATIC = ida_funcs.FUNC_STATICDEF # static function +FUNC_FRAME = ida_funcs.FUNC_FRAME # function uses frame pointer (BP) +FUNC_USERFAR = ida_funcs.FUNC_USERFAR # user has specified far-ness + # of the function +FUNC_HIDDEN = ida_funcs.FUNC_HIDDEN # a hidden function +FUNC_THUNK = ida_funcs.FUNC_THUNK # thunk (jump) function +FUNC_BOTTOMBP = ida_funcs.FUNC_BOTTOMBP # BP points to the bottom of the stack frame +FUNC_NORET_PENDING = ida_funcs.FUNC_NORET_PENDING # Function 'non-return' analysis + # must be performed. This flag is + # verified upon func_does_return() +FUNC_SP_READY = ida_funcs.FUNC_SP_READY # SP-analysis has been performed + # If this flag is on, the stack + # change points should not be not + # modified anymore. Currently this + # analysis is performed only for PC +FUNC_PURGED_OK = ida_funcs.FUNC_PURGED_OK # 'argsize' field has been validated. + # If this bit is clear and 'argsize' + # is 0, then we do not known the real + # number of bytes removed from + # the stack. This bit is handled + # by the processor module. +FUNC_TAIL = ida_funcs.FUNC_TAIL # This is a function tail. + # Other bits must be clear + # (except FUNC_HIDDEN) +FUNC_LUMINA = ida_funcs.FUNC_LUMINA # Function info is provided by Lumina. +FUNC_OUTLINE = ida_funcs.FUNC_OUTLINE # Outlined code, not a real function. def set_func_flags(ea, flags): @@ -3122,12 +3086,7 @@ def get_frame_id(ea): you need to use structure member manipulaion functions with the obtained ID. """ - frame = ida_frame.get_frame(ea) - - if frame: - return frame.id - else: - return None + return get_func_attr(ea, FUNCATTR_FRAME) def get_frame_lvar_size(ea): @@ -3138,7 +3097,7 @@ def get_frame_lvar_size(ea): @return: Size of local variables in bytes. If the function doesn't have a frame, return 0 - If the function does't exist, return None + If the function doesn't exist, return None """ return get_func_attr(ea, FUNCATTR_FRSIZE) @@ -3152,7 +3111,7 @@ def get_frame_regs_size(ea): @return: Size of saved registers in bytes. If the function doesn't have a frame, return 0 This value is used as offset for BP (if FUNC_FRAME is set) - If the function does't exist, return None + If the function doesn't exist, return None """ return get_func_attr(ea, FUNCATTR_FRREGS) @@ -3165,7 +3124,7 @@ def get_frame_args_size(ea): @return: Size of function arguments in bytes. If the function doesn't have a frame, return 0 - If the function does't exist, return -1 + If the function doesn't exist, return -1 """ return get_func_attr(ea, FUNCATTR_ARGSIZE) @@ -3181,7 +3140,7 @@ def get_frame_size(ea): return address + size of function arguments If the function doesn't have a frame, return size of function return address in the stack. - If the function does't exist, return 0 + If the function doesn't exist, return 0 """ func = ida_funcs.get_func(ea) @@ -3253,6 +3212,184 @@ def get_sp_delta(ea): return ida_frame.get_sp_delta(func, ea) +def get_fchunk_attr(ea, attr): + """ + Get a function chunk attribute + + @param ea: any address in the chunk + @param attr: one of: FUNCATTR_START, FUNCATTR_END, FUNCATTR_OWNER, FUNCATTR_REFQTY + + @return: desired attribute or -1 + """ + func = ida_funcs.get_fchunk(ea) + return _IDC_GetAttr(func, _FUNCATTRMAP, attr) if func else BADADDR + + +def set_fchunk_attr(ea, attr, value): + """ + Set a function chunk attribute + + @param ea: any address in the chunk + @param attr: only FUNCATTR_START, FUNCATTR_END, FUNCATTR_OWNER + @param value: desired value + + @return: 0 if failed, 1 if success + """ + if attr in [ FUNCATTR_START, FUNCATTR_END, FUNCATTR_OWNER ]: + chunk = ida_funcs.get_fchunk(ea) + if chunk: + _IDC_SetAttr(chunk, _FUNCATTRMAP, attr, value) + return ida_funcs.update_func(chunk) + return 0 + + +get_fchunk_referer = ida_funcs.get_fchunk_referer + + +def get_next_fchunk(ea): + """ + Get next function chunk + + @param ea: any address + + @return: the starting address of the next function chunk or BADADDR + + @note: This function enumerates all chunks of all functions in the database + """ + func = ida_funcs.get_next_fchunk(ea) + + if func: + return func.start_ea + else: + return BADADDR + + +def get_prev_fchunk(ea): + """ + Get previous function chunk + + @param ea: any address + + @return: the starting address of the function chunk or BADADDR + + @note: This function enumerates all chunks of all functions in the database + """ + func = ida_funcs.get_prev_fchunk(ea) + + if func: + return func.start_ea + else: + return BADADDR + + +def append_func_tail(funcea, ea1, ea2): + """ + Append a function chunk to the function + + @param funcea: any address in the function + @param ea1: start of function tail + @param ea2: end of function tail + @return: 0 if failed, 1 if success + + @note: If a chunk exists at the specified addresses, it must have exactly + the specified boundaries + """ + func = ida_funcs.get_func(funcea) + + if not func: + return 0 + else: + return ida_funcs.append_func_tail(func, ea1, ea2) + + +def remove_fchunk(funcea, tailea): + """ + Remove a function chunk from the function + + @param funcea: any address in the function + @param tailea: any address in the function chunk to remove + + @return: 0 if failed, 1 if success + """ + func = ida_funcs.get_func(funcea) + + if not func: + return 0 + else: + return ida_funcs.remove_func_tail(func, tailea) + + +def set_tail_owner(tailea, funcea): + """ + Change the function chunk owner + + @param tailea: any address in the function chunk + @param funcea: the starting address of the new owner + + @return: False if failed, True if success + + @note: The new owner must already have the chunk appended before the call + """ + tail = ida_funcs.get_fchunk(tailea) + + if not tail: + return False + else: + return ida_funcs.set_tail_owner(tail, funcea) + + +def first_func_chunk(funcea): + """ + Get the first function chunk of the specified function + + @param funcea: any address in the function + + @return: the function entry point or BADADDR + + @note: This function returns the first (main) chunk of the specified function + """ + func = ida_funcs.get_func(funcea) + fci = ida_funcs.func_tail_iterator_t(func, funcea) + if fci.main(): + return fci.chunk().start_ea + else: + return BADADDR + + +def next_func_chunk(funcea, tailea): + """ + Get the next function chunk of the specified function + + @param funcea: any address in the function + @param tailea: any address in the current chunk + + @return: the starting address of the next function chunk or BADADDR + + @note: This function returns the next chunk of the specified function + """ + func = ida_funcs.get_func(funcea) + fci = ida_funcs.func_tail_iterator_t(func, funcea) + if not fci.main(): + return BADADDR + + # Iterate and try to find the current chunk + found = False + while True: + if fci.chunk().start_ea <= tailea and \ + fci.chunk().end_ea > tailea: + found = True + break + if not next(fci): + break + + # Return the next chunk, if there is one + if found and next(fci): + return fci.chunk().start_ea + else: + return BADADDR + + + # ---------------------------------------------------------------------------- # S T A C K @@ -3260,7 +3397,7 @@ def get_sp_delta(ea): def add_auto_stkpnt(func_ea, ea, delta): """ - Add automatical SP register change point + Add automatic SP register change point @param func_ea: function start @param ea: linear address where SP changes usually this is the end of the instruction which @@ -3470,17 +3607,28 @@ get_bookmark_desc = ida_idc.get_mark_comment # S T R U C T U R E S # ---------------------------------------------------------------------------- -get_struc_qty = ida_struct.get_struc_qty -get_first_struc_idx = ida_struct.get_first_struc_idx -get_last_struc_idx = ida_struct.get_last_struc_idx -get_next_struc_idx = ida_struct.get_next_struc_idx -get_prev_struc_idx = ida_struct.get_prev_struc_idx -get_struc_idx = ida_struct.get_struc_idx -get_struc_by_idx = ida_struct.get_struc_by_idx -get_struc_id = ida_struct.get_struc_id -get_struc_name = ida_struct.get_struc_name -get_struc_cmt = ida_struct.get_struc_cmt -get_struc_size = ida_struct.get_struc_size +def get_struc_id(name): + tid = ida_typeinf.get_named_type_tid(name) + tif = ida_typeinf.tinfo_t() + if tid != BADADDR and tif.get_type_by_tid(tid) and tif.is_udt(): + return tid + return BADADDR + + +def get_struc_name(tid): + return ida_typeinf.get_tid_name(tid) + + +def get_struc_cmt(tid): + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(tid) and tif.is_udt(): + return tif.get_type_cmt() + + +def get_struc_size(tid): + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(tid) and tif.is_udt(): + return tif.get_size() def get_member_qty(sid): @@ -3491,17 +3639,46 @@ def get_member_qty(sid): @return: -1 if bad structure type ID is passed otherwise returns number of members. - - @note: Union members are, in IDA's internals, located - at subsequent byte offsets: member 0 -> offset 0x0, - member 1 -> offset 0x1, etc... """ - s = ida_struct.get_struc(sid) - return -1 if not s else s.memqty + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + return tif.get_udt_nmembers() + return -1 + + +def get_member_by_idx(sid, idx): + """ + Get member ID by member ordinal number + + @param sid: structure type ID + @param idx: member ordinal number + + @return: -1 if bad structure type ID is passed or there is + no member with the specified index + otherwise returns the member ID. + """ + tif = ida_typeinf.tinfo_t() + if idx >= 0 and tif.get_type_by_tid(sid) and tif.is_udt() and idx < tif.get_udt_nmembers(): + return tif.get_udm_tid(idx) + return -1 + + +def is_member_id(sid): + """ + Is a member id? + + @param sid: structure type ID + + @return: True there is structure member with the specified ID + False otherwise + """ + tif = ida_typeinf.tinfo_t() + return tif.get_udm_by_tid(None, sid) != -1 def get_member_id(sid, member_offset): """ + @param sid: structure type ID @param member_offset:. The offset can be any offset in the member. For example, @@ -3513,120 +3690,14 @@ def get_member_id(sid, member_offset): no member at the specified offset. otherwise returns the member id. """ - s = ida_struct.get_struc(sid) - if not s: - return -1 - - m = ida_struct.get_member(s, member_offset) - if not m: - return -1 - - return m.id - - -def get_prev_offset(sid, offset): - """ - Get previous offset in a structure - - @param sid: structure type ID - @param offset: current offset - - @return: -1 if bad structure type ID is passed, - ida_idaapi.BADADDR if no (more) offsets in the structure, - otherwise returns previous offset in a structure. - - @note: IDA allows 'holes' between members of a - structure. It treats these 'holes' - as unnamed arrays of bytes. - This function returns a member offset or a hole offset. - It will return size of the structure if input - 'offset' is bigger than the structure size. - - @note: Union members are, in IDA's internals, located - at subsequent byte offsets: member 0 -> offset 0x0, - member 1 -> offset 0x1, etc... - """ - s = ida_struct.get_struc(sid) - if not s: - return -1 - - return ida_struct.get_struc_prev_offset(s, offset) - - -def get_next_offset(sid, offset): - """ - Get next offset in a structure - - @param sid: structure type ID - @param offset: current offset - - @return: -1 if bad structure type ID is passed, - ida_idaapi.BADADDR if no (more) offsets in the structure, - otherwise returns next offset in a structure. - - @note: IDA allows 'holes' between members of a - structure. It treats these 'holes' - as unnamed arrays of bytes. - This function returns a member offset or a hole offset. - It will return size of the structure if input - 'offset' belongs to the last member of the structure. - - @note: Union members are, in IDA's internals, located - at subsequent byte offsets: member 0 -> offset 0x0, - member 1 -> offset 0x1, etc... - """ - s = ida_struct.get_struc(sid) - return -1 if not s else ida_struct.get_struc_next_offset(s, offset) - - -def get_first_member(sid): - """ - Get offset of the first member of a structure - - @param sid: structure type ID - - @return: -1 if bad structure type ID is passed, - ida_idaapi.BADADDR if structure has no members, - otherwise returns offset of the first member. - - @note: IDA allows 'holes' between members of a - structure. It treats these 'holes' - as unnamed arrays of bytes. - - @note: Union members are, in IDA's internals, located - at subsequent byte offsets: member 0 -> offset 0x0, - member 1 -> offset 0x1, etc... - """ - s = ida_struct.get_struc(sid) - if not s: - return -1 - - return ida_struct.get_struc_first_offset(s) - - -def get_last_member(sid): - """ - Get offset of the last member of a structure - - @param sid: structure type ID - - @return: -1 if bad structure type ID is passed, - ida_idaapi.BADADDR if structure has no members, - otherwise returns offset of the last member. - - @note: IDA allows 'holes' between members of a - structure. It treats these 'holes' - as unnamed arrays of bytes. - - @note: Union members are, in IDA's internals, located - at subsequent byte offsets: member 0 -> offset 0x0, - member 1 -> offset 0x1, etc... - """ - s = ida_struct.get_struc(sid) - if not s: - return -1 - - return ida_struct.get_struc_last_offset(s) + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + return tif.get_udm_tid(idx) + return -1 def get_member_offset(sid, member_name): @@ -3644,15 +3715,19 @@ def get_member_offset(sid, member_name): at subsequent byte offsets: member 0 -> offset 0x0, member 1 -> offset 0x1, etc... """ - s = ida_struct.get_struc(sid) - if not s: - return -1 + if member_name == " r": + member_name = ida_typeinf.FRAME_UDM_NAME_R + if member_name == " s": + member_name = ida_typeinf.FRAME_UDM_NAME_S - m = ida_struct.get_member_by_name(s, member_name) - if not m: - return -1 - - return m.get_soff() + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.name = member_name + idx = tif.find_udm(udm, ida_typeinf.STRMEM_NAME) + if idx != -1: + return udm.offset // 8 + return -1 def get_member_name(sid, member_offset): @@ -3670,18 +3745,17 @@ def get_member_name(sid, member_offset): or no such member in the structure otherwise returns name of the specified member. """ - s = ida_struct.get_struc(sid) - if not s: - return None - - m = ida_struct.get_member(s, member_offset) - if not m: - return None - - return ida_struct.get_member_name(m.id) + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + return udm.name + return None -def get_member_cmt(sid, member_offset, repeatable): +def get_member_cmt(sid, member_offset, repeatable=True): """ Get comment of a member @@ -3691,22 +3765,20 @@ def get_member_cmt(sid, member_offset, repeatable): is a member is 4 bytes long and starts at offset 2, then 2,3,4,5 denote the same structure member. - @param repeatable: 1: get repeatable comment - 0: get regular comment + @param repeatable: is not used anymore @return: None if bad structure type ID is passed or no such member in the structure otherwise returns comment of the specified member. """ - s = ida_struct.get_struc(sid) - if not s: - return None - - m = ida_struct.get_member(s, member_offset) - if not m: - return None - - return ida_struct.get_member_cmt(m.id, repeatable) + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + return udm.cmt + return None def get_member_size(sid, member_offset): @@ -3725,41 +3797,14 @@ def get_member_size(sid, member_offset): otherwise returns size of the specified member in bytes. """ - s = ida_struct.get_struc(sid) - if not s: - return None - - m = ida_struct.get_member(s, member_offset) - if not m: - return None - - return ida_struct.get_member_size(m) - - -def get_member_flag(sid, member_offset): - """ - Get type of a member - - @param sid: structure type ID - @param member_offset: member offset. The offset can be - any offset in the member. For example, - is a member is 4 bytes long and starts - at offset 2, then 2,3,4,5 denote - the same structure member. - - @return: -1 if bad structure type ID is passed - or no such member in the structure - otherwise returns type of the member, see bit - definitions above. If the member type is a structure - then function GetMemberStrid() should be used to - get the structure type id. - """ - s = ida_struct.get_struc(sid) - if not s: - return -1 - - m = ida_struct.get_member(s, member_offset) - return -1 if not m else m.flag + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + return udm.size // 8 + return -1 def get_member_strid(sid, member_offset): @@ -3777,19 +3822,16 @@ def get_member_strid(sid, member_offset): otherwise returns structure id of the member. If the current member is not a structure, returns -1. """ - s = ida_struct.get_struc(sid) - if not s: - return -1 - - m = ida_struct.get_member(s, member_offset) - if not m: - return -1 - - cs = ida_struct.get_sptr(m) - if cs: - return cs.id - else: - return -1 + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + tid = udm.type.get_tid() + if tid != BADADDR: + return tid + return -1 def is_union(sid): @@ -3798,30 +3840,22 @@ def is_union(sid): @param sid: structure type ID - @return: 1: yes, this is a union id - 0: no + @return: True: yes, this is a union id + False: no @note: Unions are a special kind of structures """ - s = ida_struct.get_struc(sid) - if not s: - return 0 - - return s.is_union() + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + return tif.is_union() + return False def add_struc(index, name, is_union): """ Define a new structure type - @param index: index of new structure type - If another structure has the specified index, - then index of that structure and all other - structures will be incremented, freeing the specifed - index. If index is == -1, then the biggest index - number will be used. - See get_first_struc_idx() for the explanation of - structure indices and IDs. + @param index: -1 @param name: name of the new structure type. @param is_union: 0: structure 1: union @@ -3831,10 +3865,12 @@ def add_struc(index, name, is_union): already used in the program. otherwise returns ID of the new structure type """ - if index == -1: - index = BADADDR - - return ida_struct.add_struc(index, name, is_union) + udt = ida_typeinf.udt_type_data_t() + udt.is_union = is_union + tif = ida_typeinf.tinfo_t() + if tif.create_udt(udt) and tif.set_named_type(None, name) == ida_typeinf.TERR_OK: + return tif.get_tid() + return BADADDR def del_struc(sid): @@ -3849,34 +3885,22 @@ def del_struc(sid): deleted structure type will be displayed as array of bytes. """ - s = ida_struct.get_struc(sid) - if not s: - return 0 - - return ida_struct.del_struc(s) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(sid) + return ida_typeinf.del_numbered_type(None, tif.get_ordinal()) -def set_struc_idx(sid, index): - """ - Change structure index - - @param sid: structure type ID - @param index: new index of the structure - - @return: != 0 - ok - - @note: See get_first_struc_idx() for the explanation of - structure indices and IDs. - """ - s = ida_struct.get_struc(sid) - if not s: - return 0 - - return ida_struct.set_struc_idx(s, index) +def set_struc_name(sid, name): + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid): + return tif.rename_type(name) == ida_typeinf.TERR_OK + return False -set_struc_name = ida_struct.set_struc_name -set_struc_cmt = ida_struct.set_struc_cmt +def set_struc_cmt(sid, cmt, repeatable=True): + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid): + return tif.set_type_cmt(cmt, not repeatable) == ida_typeinf.TERR_OK def add_struc_member(sid, name, offset, flag, typeid, nbytes, target=-1, tdelta=0, reftype=REF_OFF32): @@ -3906,7 +3930,7 @@ def add_struc_member(sid, name, offset, flag, typeid, nbytes, target=-1, tdelta= @note: The remaining arguments are allowed only if is_off0(flag) and you want to specify a complex offset expression - @return: 0 - ok, otherwise error code (one of STRUC_ERROR_*) + @return: 0 - ok, otherwise error code (one of typeinf.TERR_*) """ if is_off0(flag): @@ -3916,15 +3940,6 @@ def add_struc_member(sid, name, offset, flag, typeid, nbytes, target=-1, tdelta= return eval_idc('add_struc_member(%d, "%s", %d, %d, %d, %d);' % (sid, ida_kernwin.str2user(name or ""), offset, flag, typeid, nbytes)) -STRUC_ERROR_MEMBER_NAME = -1 # already has member with this name (bad name) -STRUC_ERROR_MEMBER_OFFSET = -2 # already has member at this offset -STRUC_ERROR_MEMBER_SIZE = -3 # bad number of bytes or bad sizeof(type) -STRUC_ERROR_MEMBER_TINFO = -4 # bad typeid parameter -STRUC_ERROR_MEMBER_STRUCT = -5 # bad struct id (the 1st argument) -STRUC_ERROR_MEMBER_UNIVAR = -6 # unions can't have variable sized members -STRUC_ERROR_MEMBER_VARLAST = -7 # variable sized member should be the last member in the structure - - def del_struc_member(sid, member_offset): """ Delete structure member @@ -3938,11 +3953,14 @@ def del_struc_member(sid, member_offset): structure. It treats these 'holes' as unnamed arrays of bytes. """ - s = ida_struct.get_struc(sid) - if not s: - return 0 - - return ida_struct.del_struc_member(s, member_offset) + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + return tif.del_udm(idx) == ida_typeinf.TERR_OK + return False def set_member_name(sid, member_offset, name): @@ -3955,11 +3973,14 @@ def set_member_name(sid, member_offset, name): @return: != 0 - ok. """ - s = ida_struct.get_struc(sid) - if not s: - return 0 - - return ida_struct.set_member_name(s, member_offset, name) + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + return tif.rename_udm(idx, name) == ida_typeinf.TERR_OK + return False def set_member_type(sid, member_offset, flag, typeid, nitems, target=-1, tdelta=0, reftype=REF_OFF32): @@ -4008,227 +4029,163 @@ def set_member_cmt(sid, member_offset, comment, repeatable): @return: != 0 - ok """ - s = ida_struct.get_struc(sid) - if not s: - return 0 - - m = ida_struct.get_member(s, member_offset) - if not m: - return 0 - - return ida_struct.set_member_cmt(m, comment, repeatable) + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = member_offset + idx = tif.find_udm(udm, ida_typeinf.STRMEM_AUTO) + if idx != -1: + return tif.set_udm_cmt(idx, comment, not repeatable) == ida_typeinf.TERR_OK + return False -def expand_struc(sid, offset, delta, recalc): +def expand_struc(sid, offset, delta, recalc=True): """ 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 + @param recalc: is not used anymore + @return: True if ok, False on error """ - s = ida_struct.get_struc(sid) - if not s: - return 0 - - return ida_struct.expand_struc(s, offset, delta, recalc) - - -def get_fchunk_attr(ea, attr): - """ - Get a function chunk attribute - - @param ea: any address in the chunk - @param attr: one of: FUNCATTR_START, FUNCATTR_END, FUNCATTR_OWNER, FUNCATTR_REFQTY - - @return: desired attribute or -1 - """ - func = ida_funcs.get_fchunk(ea) - return _IDC_GetAttr(func, _FUNCATTRMAP, attr) if func else BADADDR - - -def set_fchunk_attr(ea, attr, value): - """ - Set a function chunk attribute - - @param ea: any address in the chunk - @param attr: only FUNCATTR_START, FUNCATTR_END, FUNCATTR_OWNER - @param value: desired value - - @return: 0 if failed, 1 if success - """ - if attr in [ FUNCATTR_START, FUNCATTR_END, FUNCATTR_OWNER ]: - chunk = ida_funcs.get_fchunk(ea) - if chunk: - _IDC_SetAttr(chunk, _FUNCATTRMAP, attr, value) - return ida_funcs.update_func(chunk) - return 0 - - -get_fchunk_referer = ida_funcs.get_fchunk_referer - - -def get_next_fchunk(ea): - """ - Get next function chunk - - @param ea: any address - - @return: the starting address of the next function chunk or BADADDR - - @note: This function enumerates all chunks of all functions in the database - """ - func = ida_funcs.get_next_fchunk(ea) - - if func: - return func.start_ea - else: - return BADADDR - - -def get_prev_fchunk(ea): - """ - Get previous function chunk - - @param ea: any address - - @return: the starting address of the function chunk or BADADDR - - @note: This function enumerates all chunks of all functions in the database - """ - func = ida_funcs.get_prev_fchunk(ea) - - if func: - return func.start_ea - else: - return BADADDR - - -def append_func_tail(funcea, ea1, ea2): - """ - Append a function chunk to the function - - @param funcea: any address in the function - @param ea1: start of function tail - @param ea2: end of function tail - @return: 0 if failed, 1 if success - - @note: If a chunk exists at the specified addresses, it must have exactly - the specified boundaries - """ - func = ida_funcs.get_func(funcea) - - if not func: - return 0 - else: - return ida_funcs.append_func_tail(func, ea1, ea2) - - -def remove_fchunk(funcea, tailea): - """ - Remove a function chunk from the function - - @param funcea: any address in the function - @param tailea: any address in the function chunk to remove - - @return: 0 if failed, 1 if success - """ - func = ida_funcs.get_func(funcea) - - if not func: - return 0 - else: - return ida_funcs.remove_func_tail(func, tailea) - - -def set_tail_owner(tailea, funcea): - """ - Change the function chunk owner - - @param tailea: any address in the function chunk - @param funcea: the starting address of the new owner - - @return: False if failed, True if success - - @note: The new owner must already have the chunk appended before the call - """ - tail = ida_funcs.get_fchunk(tailea) - - if not tail: - return False - else: - return ida_funcs.set_tail_owner(tail, funcea) - - -def first_func_chunk(funcea): - """ - Get the first function chunk of the specified function - - @param funcea: any address in the function - - @return: the function entry point or BADADDR - - @note: This function returns the first (main) chunk of the specified function - """ - func = ida_funcs.get_func(funcea) - fci = ida_funcs.func_tail_iterator_t(func, funcea) - if fci.main(): - return fci.chunk().start_ea - else: - return BADADDR - - -def next_func_chunk(funcea, tailea): - """ - Get the next function chunk of the specified function - - @param funcea: any address in the function - @param tailea: any address in the current chunk - - @return: the starting address of the next function chunk or BADADDR - - @note: This function returns the next chunk of the specified function - """ - func = ida_funcs.get_func(funcea) - fci = ida_funcs.func_tail_iterator_t(func, funcea) - if not fci.main(): - return BADADDR - - # Iterate and try to find the current chunk - found = False - while True: - if fci.chunk().start_ea <= tailea and \ - fci.chunk().end_ea > tailea: - found = True - break - if not next(fci): - break - - # Return the next chunk, if there is one - if found and next(fci): - return fci.chunk().start_ea - else: - return BADADDR - + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(sid) and tif.is_udt(): + udm = ida_typeinf.udm_t() + udm.offset = offset*8 + idx = tif.find_udm(udm, ida_typeinf.STRMEM_LOWBND|ida_typeinf.STRMEM_SKIP_GAPS) + if idx != -1: + return tif.expand_udt(idx, delta) == ida_typeinf.TERR_OK + return False # ---------------------------------------------------------------------------- # E N U M S # ---------------------------------------------------------------------------- -get_enum_qty = ida_enum.get_enum_qty -getn_enum = ida_enum.getn_enum -get_enum_idx = ida_enum.get_enum_idx -get_enum = ida_enum.get_enum -get_enum_name = ida_enum.get_enum_name -get_enum_cmt = ida_enum.get_enum_cmt -get_enum_size = ida_enum.get_enum_size -get_enum_width = ida_enum.get_enum_width -get_enum_flag = ida_enum.get_enum_flag -get_enum_member_by_name = ida_enum.get_enum_member_by_name -get_enum_member_value = ida_enum.get_enum_member_value -get_enum_member_bmask = ida_enum.get_enum_member_bmask -get_enum_member_enum = ida_enum.get_enum_member_enum +ENFL_REGEX = 0x0001 # apply regular expressions to beautify the name + +def get_enum(name): + """ + Get enum by name + + @param name: enum type name + + @return: enum type TID or BADADDR + """ + tif = ida_typeinf.tinfo_t() + if tif.get_named_type(None, name) and tif.is_enum(): + return tif.get_tid() + return BADADDR + + +def get_enum_name(enum_id, flags=0): + """ + Get name of enum + + @param enum_id: enum TID + @param flags: use ENFL_REGEX to beautify the name + + @return: enum name or None + """ + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(enum_id): + return tif.get_nice_type_name() if (flags & ENFL_REGEX) != 0 else tif.get_type_name() + return None + + +def get_enum_cmt(enum_id): + """ + Get enum comment + + @param enum_id: enum TID + + @return: enum comment + """ + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + return tif.get_type_cmt() + + +def get_enum_size(enum_id): + """ + Get the number of the members of the enum + + @param enum_id: enum TID + + @return: number of members + """ + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + return tif.get_enum_nmembers() + + +def get_enum_width(enum_id): + """ + Get the width of a enum element + allowed values: 0 (unspecified),1,2,4,8,16,32,64 + + @param enum_id: enum TID + + @return: enum width or -1 in case of error + """ + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + return tif.get_enum_width() + + +def get_enum_flag(enum_id): + """ + Get flags determining the representation of the enum. + (currently they define the numeric base: octal, decimal, hex, bin) and signness. + + @param enum_id: enum TID + + @return: flag of 0 + """ + tif = ida_typeinf.tinfo_t() + F = 0 + if tif.get_type_by_tid(enum_id) and tif.is_enum(): + radix = tif.get_enum_radix() + if radix == 1: + F = ida_bytes.get_operand_flag(ida_bytes.FF_N_CHAR, 0) + elif radix == 2: + F = ida_bytes.get_operand_flag(ida_bytes.FF_N_NUMB, 0); + elif radix == 8: + F = ida_bytes.get_operand_flag(ida_bytes.FF_N_NUMO, 0); + elif radix == 10: + F = ida_bytes.get_operand_flag(ida_bytes.FF_N_NUMD, 0); + else: + F = ida_bytes.get_operand_flag(ida_bytes.FF_N_NUMH, 0); + if tif.is_signed(): + F |= ida_bytes.FF_SIGN + return F + + +def get_enum_member_by_name(name): + """ + Get a reference to an enum member by its name + + @param name: enum member name + + @return: enum member TID or BADADDR + """ + tif = ida_typeinf.tinfo_t() + idx = tif.get_edm_by_name(name) + if idx != -1: + return tif.get_edm_tid(idx) + return BADADDR + + +def get_enum_member_enum(const_id): + """ + Get the parent enum of an enum member + + @param const_id: id of const + + @return: enum TID or BADADDR + """ + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(const_id) and tif.is_enum(): + return tif.get_tid() + return BADADDR; def get_enum_member(enum_id, value, serial, bmask): @@ -4240,19 +4197,106 @@ def get_enum_member(enum_id, value, serial, bmask): @param serial: serial number of the constant in the enumeration. See op_enum() for details. @param bmask: bitmask of the constant - ordinary enums accept only ida_enum.DEFMASK as a bitmask + ordinary enums accept only -1 as a bitmask @return: id of constant or -1 if error """ if bmask < 0: bmask &= BADADDR - return ida_enum.get_enum_member(enum_id, value, serial, bmask) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + edm = ida_typeinf.edm_t() + if tif.get_type_by_tid(enum_id) and tif.find_edm(edm, value, bmask, serial) != -1: + return ida_typeinf.get_named_type_tid(edm.name) + return -1 -get_first_bmask = ida_enum.get_first_bmask -get_last_bmask = ida_enum.get_last_bmask -get_next_bmask = ida_enum.get_next_bmask -get_prev_bmask = ida_enum.get_prev_bmask +def get_first_bmask(enum_id): + """ + Get first bitmask in the enum + + @param enum_id: id of enum + + @return: id of constant or -1 if error + """ + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + tif.get_enum_details(ei) + if not ei.group_sizes.empty(): + return ei[0].value & ei.calc_mask() + return -1 + + +def get_last_bmask(enum_id): + """ + Get last bitmask in the enum + + @param enum_id: id of enum + + @return: id of constant or -1 if error + """ + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + tif.get_enum_details(ei) + m = -1 + for (grp_start, grp_size) in ei.all_groups(): + m = ei[grp_start].value & ei.calc_mask() + return m + + +def get_next_bmask(enum_id, bmask): + """ + Get next bitmask in the enum + + @param enum_id: id of enum + @param bmask + + @return: id of constant or -1 if error + """ + if bmask < 0: + bmask &= BADADDR + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + tif.get_enum_details(ei) + found = False + vmask = ei.calc_mask() + bmask &= vmask + for (grp_start, grp_size) in ei.all_groups(): + m = ei[grp_start].value & vmask + if not found and m == bmask: + found = True + elif found: + return m + return -1 + + +def get_prev_bmask(enum_id, bmask): + """ + Get prev bitmask in the enum + + @param enum_id: id of enum + @param bmask + + @return: id of constant or -1 if error + """ + if bmask < 0: + bmask &= BADADDR + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + tif.get_enum_details(ei) + prev_grp_start = -1 + vmask = ei.calc_mask() + bmask &= vmask + for (grp_start, grp_size) in ei.all_groups(): + m = ei[grp_start].value & vmask + if m == bmask: + return ei[prev_grp_start].value & vmask if prev_grp_start != -1 else -1 + prev_grp_start = grp_start + return -1 def get_bmask_name(enum_id, bmask): @@ -4266,7 +4310,13 @@ def get_bmask_name(enum_id, bmask): """ if bmask < 0: bmask &= BADADDR - return ida_enum.get_bmask_name(enum_id, bmask) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + edm = ida_typeinf.edm_t() + idx = tif.find_edm(edm, bmask) + if idx != -1: + return edm.name + return None def get_bmask_cmt(enum_id, bmask, repeatable): @@ -4281,7 +4331,13 @@ def get_bmask_cmt(enum_id, bmask, repeatable): """ if bmask < 0: bmask &= BADADDR - return ida_enum.get_bmask_cmt(enum_id, bmask, repeatable) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + edm = ida_typeinf.edm_t() + idx = tif.find_edm(edm, bmask) + if idx != -1: + return edm.cmt + return None def set_bmask_name(enum_id, bmask, name): @@ -4292,11 +4348,16 @@ def set_bmask_name(enum_id, bmask, name): @param bmask: bitmask of the constant @param name: name of bitmask - @return: 1-ok, 0-failed + @return: True-ok, False-failed """ if bmask < 0: bmask &= BADADDR - return ida_enum.set_bmask_name(enum_id, bmask, name) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + idx = tif.find_edm(None, bmask) + if idx != -1: + return tif.rename_edm(idx, name) == ida_typeinf.TERR_OK + return False def set_bmask_cmt(enum_id, bmask, cmt, repeatable): @@ -4306,79 +4367,141 @@ def set_bmask_cmt(enum_id, bmask, cmt, repeatable): @param enum_id: id of enum @param bmask: bitmask of the constant @param cmt: comment - repeatable - type of comment, 0-regular, 1-repeatable + repeatable - is not used anymore @return: 1-ok, 0-failed """ if bmask < 0: bmask &= BADADDR - return ida_enum.set_bmask_cmt(enum_id, bmask, cmt, repeatable) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + idx = tif.find_edm(None, bmask) + if idx != -1: + return tif.set_edm_cmt(idx, cmt) == ida_typeinf.TERR_OK + return False -def get_first_enum_member(enum_id, bmask): +def __collect_enum_value(ei, bmask): + vmask = ei.calc_mask() + values = set() + if bmask == BADADDR: + for (idx, _, _) in ei.all_constants(): + values.add(ei[idx].value & vmask) + elif ei.is_bf(): + bmask &= vmask + for (grp_start, grp_size) in ei.all_groups(): + if (ei[grp_start].value & vmask) == bmask: + grp_end = grp_start + grp_size + if grp_size != 1: + grp_start += 1 + for idx in range(grp_start, grp_end): + values.add(ei[idx].value & vmask) + break + return list(sorted(values)) + + +def get_first_enum_member(enum_id, bmask=-1): """ Get first constant in the enum @param enum_id: id of enum - @param bmask: bitmask of the constant (ordinary enums accept only ida_enum.DEFMASK as a bitmask) + @param bmask: bitmask of the constant (ordinary enums accept only -1 as a bitmask) - @return: value of constant or idaapi.BADNODE no constants are defined + @return: value of constant or -1 if no constants are defined All constants are sorted by their values as unsigned longs. """ if bmask < 0: bmask &= BADADDR - return ida_enum.get_first_enum_member(enum_id, bmask) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + if tif.get_enum_details(ei): + values = __collect_enum_value(ei, bmask) + if len(values) != 0: + return values[0] + return -1 -def get_last_enum_member(enum_id, bmask): +def get_last_enum_member(enum_id, bmask=-1): """ Get last constant in the enum @param enum_id: id of enum - @param bmask: bitmask of the constant (ordinary enums accept only ida_enum.DEFMASK as a bitmask) + @param bmask: bitmask of the constant (ordinary enums accept only -1 as a bitmask) - @return: value of constant or idaapi.BADNODE no constants are defined + @return: value of constant or -1 if no constants are defined All constants are sorted by their values as unsigned longs. """ if bmask < 0: bmask &= BADADDR - return ida_enum.get_last_enum_member(enum_id, bmask) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + if tif.get_enum_details(ei): + values = __collect_enum_value(ei, bmask) + if len(values) != 0: + return values[-1] + return -1 -def get_next_enum_member(enum_id, value, bmask): +def get_next_enum_member(enum_id, value, bmask=-1): """ Get next constant in the enum @param enum_id: id of enum - @param bmask: bitmask of the constant ordinary enums accept only ida_enum.DEFMASK as a bitmask + @param bmask: bitmask of the constant ordinary enums accept only -1 as a bitmask @param value: value of the current constant @return: value of a constant with value higher than the specified - value. idaapi.BADNODE no such constants exist. + value. -1 if no such constants exist. All constants are sorted by their values as unsigned longs. """ if bmask < 0: bmask &= BADADDR - return ida_enum.get_next_enum_member(enum_id, value, bmask) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + if tif.get_enum_details(ei): + values = __collect_enum_value(ei, bmask) + value &= ei.calc_mask() + try: + idx = values.index(value) + if idx < len(values): + return values[idx+1] + except: + pass + return -1 -def get_prev_enum_member(enum_id, value, bmask): +def get_prev_enum_member(enum_id, value, bmask=-1): """ Get prev constant in the enum @param enum_id: id of enum @param bmask : bitmask of the constant - ordinary enums accept only ida_enum.DEFMASK as a bitmask + ordinary enums accept only -1 as a bitmask @param value: value of the current constant @return: value of a constant with value lower than the specified - value. idaapi.BADNODE no such constants exist. + value. -1 if no such constants exist. All constants are sorted by their values as unsigned longs. """ if bmask < 0: bmask &= BADADDR - return ida_enum.get_prev_enum_member(enum_id, value, bmask) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + ei = ida_typeinf.enum_type_data_t() + if tif.get_enum_details(ei): + values = __collect_enum_value(ei, bmask) + value &= ei.calc_mask() + try: + idx = values.index(value) + if idx != 0: + return values[idx-1] + except: + pass + return -1 def get_enum_member_name(const_id): @@ -4389,68 +4512,183 @@ def get_enum_member_name(const_id): Returns: name of constant """ - name = ida_enum.get_enum_member_name(const_id) - - if not name: - return "" - else: - return name + tif = ida_typeinf.tinfo_t() + edm = ida_typeinf.edm_t() + if tif.get_edm_by_tid(edm, const_id) != -1: + return edm.name + return None -def get_enum_member_cmt(const_id, repeatable): +def get_enum_member_cmt(const_id, repeatable=True): """ Get comment of a constant @param const_id: id of const - @param repeatable: 0:get regular comment, 1:get repeatable comment + @param repeatable: not used anymore @return: comment string """ - cmt = ida_enum.get_enum_member_cmt(const_id, repeatable) + tif = ida_typeinf.tinfo_t() + edm = ida_typeinf.edm_t() + if tif.get_edm_by_tid(edm, const_id) != -1: + return edm.cmt + return None - if not cmt: - return "" - else: - return cmt + +def get_enum_member_value(const_id): + """ + Get value of an enum member + + @param const_id: id of const + + @return: member value or None + """ + tif = ida_typeinf.tinfo_t() + edm = ida_typeinf.edm_t() + if tif.get_edm_by_tid(edm, const_id) != -1: + return edm.value & tif.calc_enum_mask() + return None + + +def get_enum_member_bmask(const_id): + """ + Get bitmask of an enum member + + @param const_id: id of const + + @return: member value or None + """ + tif = ida_typeinf.tinfo_t() + idx = tif.get_edm_by_tid(None, const_id) + if idx != -1 and tif.is_bitmask_enum(): + ei = ida_typeinf.enum_type_data_t() + if tif.get_enum_details(ei): + grp = ei.get_constant_group(idx) + if grp is not None: + return ei[grp[0]].value + return None def add_enum(idx, name, flag): """ Add a new enum type - @param idx: serial number of the new enum. - If another enum with the same serial number - exists, then all enums with serial - numbers >= the specified idx get their - serial numbers incremented (in other words, - the new enum is put in the middle of the list of enums). - - If idx >= get_enum_qty() or idx == idaapi.BADNODE - then the new enum is created at the end of - the list of enums. - + @param idx: is not used anymore @param name: name of the enum. @param flag: flags for representation of numeric constants in the definition of enum. @return: id of new enum or BADADDR """ - if idx < 0: - idx = idx & SIZE_MAX - return ida_enum.add_enum(idx, name, flag) + ei = ida_typeinf.enum_type_data_t() + radix = 1 if ida_bytes.is_char0(flag) else ida_bytes.get_radix(flag, 0) + ei.set_enum_radix(radix, (flag & ida_bytes.FF_SIGN) != 0) + tif = ida_typeinf.tinfo_t() + if tif.create_enum(ei) and tif.set_named_type(None, name) == ida_typeinf.TERR_OK: + return tif.get_tid() + return BADADDR -del_enum = ida_enum.del_enum -set_enum_idx = ida_enum.set_enum_idx -set_enum_name = ida_enum.set_enum_name -set_enum_cmt = ida_enum.set_enum_cmt -set_enum_flag = ida_enum.set_enum_flag -set_enum_bf = ida_enum.set_enum_bf -set_enum_width = ida_enum.set_enum_width -is_bf = ida_enum.is_bf +def del_enum(enum_id): + """ + Delete an enum type + + @param enum_id: id of enum + + @return: success + """ + return ida_typeinf.del_named_type(None, ida_typeinf.get_tid_name(enum_id), ida_typeinf.NTF_TYPE) -def add_enum_member(enum_id, name, value, bmask): +def set_enum_name(enum_id, name): + """ + Set name of enum type + + @param enum_id: id of enum + @param name: new enum name + + @return: 1-ok, 0-failed + """ + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(enum_id) and tif.rename_type(name): + return 1 + return 0 + + +def set_enum_flag(enum_id, flag): + """ + Set enum constant representation flags + + @param enum_id: enum TID + @param flag + + @return: success + """ + tif = ida_typeinf.tinfo_t() + if ida_bytes.is_char0(flag): + radix = 1 + else: + radix = ida_bytes.get_radix(flag, 0) + return tif.get_type_by_tid(enum_id) and tif.set_enum_radix(radix, (flag & ida_bytes.FF_SIGN) != 0) == ida_typeinf.TERR_OK; + + +def set_enum_width(enum_id, nbytes): + """ + Set the width of enum base type + + @param enum_id: enum TID + @param nbytes: width of enum base type, allowed values: 0 (unspecified),1,2,4,8,16,32,64 + + @return: success + """ + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + return tif.set_enum_width(nbytes) + + +def is_bf(enum_id): + """ + Is enum a bitmask ? + + @param enum_id: enum TID + + @return: if it is a bitmask enum return True, otherwise False + """ + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + return tif.is_bitmask_enum() + + +def set_enum_bf(enum_id, bf): + """ + Set or clear the 'bitmask' attribute of an enum + + @param enum_id: enum TID + @param bf: bitmask enum or not + + @return: success + """ + tif = ida_typeinf.tinfo_t() + return tif.get_type_by_tid(enum_id) and tif.set_enum_is_bitmask(ida_typeinf.tinfo_t.ENUMBM_ON if bf else ida_typeinf.tinfo_t.ENUMBM_OFF) == ida_typeinf.TERR_OK + + +def set_enum_cmt(enum_id, cmt, repeatable): + """ + Set comment for enum type + + @param enum_id: enum TID + @param cmt: comment + @param repeatable: is comment repeatable ? + + @return: 1-ok, 0-failed + """ + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(enum_id) and tif.set_type_cmt(cmt, not repeatable): + return 1 + return 0 + + +def add_enum_member(enum_id, name, value, bmask=-1): """ Add a member of enum - a symbolic constant @@ -4458,24 +4696,23 @@ def add_enum_member(enum_id, name, value, bmask): @param name: name of symbolic constant. Must be unique in the program. @param value: value of symbolic constant. @param bmask: bitmask of the constant - ordinary enums accept only ida_enum.DEFMASK as a bitmask + ordinary enums accept only -1 as a bitmask all bits set in value should be set in bmask too @return: 0-ok, otherwise error code (one of ENUM_MEMBER_ERROR_*) """ if bmask < 0: bmask &= BADADDR - return ida_enum.add_enum_member(enum_id, name, value, bmask) + tif = ida_typeinf.tinfo_t() + if tif.get_type_by_tid(enum_id): + edm = ida_typeinf.edm_t() + edm.name = name + edm.value = value + return tif.add_edm(edm, bmask) + return ida_typeinf.TERR_BAD_TYPE -ENUM_MEMBER_ERROR_NAME = ida_enum.ENUM_MEMBER_ERROR_NAME # already have member with this name (bad name) -ENUM_MEMBER_ERROR_VALUE = ida_enum.ENUM_MEMBER_ERROR_VALUE # already have member with this value -ENUM_MEMBER_ERROR_ENUM = ida_enum.ENUM_MEMBER_ERROR_ENUM # bad enum id -ENUM_MEMBER_ERROR_MASK = ida_enum.ENUM_MEMBER_ERROR_MASK # bad bmask -ENUM_MEMBER_ERROR_ILLV = ida_enum.ENUM_MEMBER_ERROR_ILLV # bad bmask and value combination (~bmask & value != 0) - - -def del_enum_member(enum_id, value, serial, bmask): +def del_enum_member(enum_id, value, serial, bmask=-1): """ Delete a member of enum - a symbolic constant @@ -4484,17 +4721,53 @@ def del_enum_member(enum_id, value, serial, bmask): @param serial: serial number of the constant in the enumeration. See op_enum() for for details. @param bmask: bitmask of the constant ordinary enums accept - only ida_enum.DEFMASK as a bitmask + only -1 as a bitmask @return: 1-ok, 0-failed """ if bmask < 0: bmask &= BADADDR - return ida_enum.del_enum_member(enum_id, value, serial, bmask) + tif = ida_typeinf.tinfo_t() + tif.get_type_by_tid(enum_id) + idx = tif.find_edm(None, value, bmask, serial) + if idx != -1 and tif.del_edm(idx) == ida_typeinf.TERR_OK: + return 1 + return 0 -set_enum_member_name = ida_enum.set_enum_member_name -set_enum_member_cmt = ida_enum.set_enum_member_cmt +def set_enum_member_name(const_id, name): + """ + Set name of enum member + + @param const_id: enum constant TID + @param name: new member name + + @return: 1-ok, 0-failed + """ + tif = ida_typeinf.tinfo_t() + idx = tif.get_edm_by_tid(None, const_id) + if idx != -1 and tif.rename_edm(idx, name) == ida_typeinf.TERR_OK: + return 1 + return 0 + + +def set_enum_member_cmt(const_id, cmt, repeatable=False): + """ + Set comment for enum member + + @param const_id: enum constant TID + @param cmt: comment + @param repeatable: is not used anymore + + @return: 1-ok, 0-failed + """ + name = ida_typeinf.get_tid_name(const_id) + tif = ida_typeinf.tinfo_t() + idx = tif.get_edm_by_name(name) + if idx != -1 and tif.set_edm_cmt(idx, cmt) == ida_typeinf.TERR_OK: + return 1 + return 0 + #---------------------------------------------------------------------------- # A R R A Y S I N I D C @@ -4959,13 +5232,15 @@ def import_type(idx, type_name): Copy structure, union, or enum definition from the type library to the IDA database. - @param idx: the position of the new type in the list of - types (structures or enums) -1 means at the end of the list + @param idx: -1, ignored @param type_name: name of type to copy @return: BADNODE-failed, otherwise the type id (structure id or enum id) """ - return ida_typeinf.import_type(None, idx, type_name) + tif = ida_typeinf.tinfo_t() + if tif.get_named_type(None, type_name): + return tif.force_tid() + return BADADDR def get_type(ea): @@ -5171,13 +5446,13 @@ PDF_DEF_BASE = 0x4 # include base types: __int8, __int16, etc.. PDF_HEADER_CMT = 0x8 # prepend output with a descriptive comment -def get_ordinal_qty(): +def get_ordinal_limit(): """ Get number of local types + 1 @return: value >= 1. 1 means that there are no local types. """ - return ida_typeinf.get_ordinal_qty(None) + return ida_typeinf.get_ordinal_limit(None) def set_local_type(ordinal, input, flags): @@ -5705,7 +5980,7 @@ BPT_WRITE = 1 # Hardware: Write access BPT_RDWR = 3 # Hardware: Read/write access BPT_SOFT = 4 # Software breakpoint BPT_EXEC = 8 # Hardware: Execute instruction -BPT_DEFAULT = (BPT_SOFT|BPT_EXEC); # Choose bpt type automaticaly +BPT_DEFAULT = (BPT_SOFT|BPT_EXEC); # Choose bpt type automatically BPTATTR_COUNT = 4 BPTATTR_FLAGS = 5 @@ -5744,7 +6019,7 @@ def set_bpt_attr(address, bptattr, value): @param address: any address in the breakpoint range @param bptattr: the attribute code, one of BPTATTR_* constants BPTATTR_CND is not allowed, see set_bpt_cond() - @param value: the attibute value + @param value: the attribute value @return: success """ diff --git a/python/init.py b/python/init.py index 61f78b4..8d6a354 100644 --- a/python/init.py +++ b/python/init.py @@ -35,28 +35,35 @@ if not os.path.isabs(IDAPYTHON_DYNLOAD_BASE): IDAPYTHON_DYNLOAD_BASE = os.path.abspath(IDAPYTHON_DYNLOAD_BASE); # Prepare sys.path so loading of the shared objects works -lib_dynload = os.path.join( - IDAPYTHON_DYNLOAD_BASE, - "python", - str(sys.version_info.major)) +lib_dynload = os.path.join(IDAPYTHON_DYNLOAD_BASE, "python") # We always want our own lib-dynload to come first: # the PyQt (& sip) modules that might have to be loaded, should # be the ones shipped with IDA and not those possibly available # on the system. -sys.path.insert(0, os.path.join(lib_dynload, IDAPYTHON_DYNLOAD_RELPATH)) +sys.path.insert(0, os.path.join(lib_dynload, "lib-dynload")) sys.path.insert(0, lib_dynload) -try: - import ida_idaapi - import ida_kernwin - import ida_diskio -except ImportError as e: - print("Import failed: %s. Current sys.path:" % str(e)) - for p in sys.path: - print("\t%s" % p) - raise +# We want all ida_* modules to be available +all_mods = "${MODULES}" +for mod in all_mods.split(","): + try: + # Import module and make it visible at global scope + globals()[f"ida_{mod}"] = __import__(f"ida_{mod}") + except ImportError as e: + print("Import failed: %s. Current sys.path:" % str(e)) + for p in sys.path: + print("\t%s" % p) + raise + except Exception as e: + print("Cannot load module ida_%s: %s" % (mod, str(e))) + import traceback + traceback.print_exc() + raise + except ModuleNotFoundError as e: + # Silently skip modules not present in current installation + continue # ----------------------------------------------------------------------- # Take over the standard text outputs @@ -96,7 +103,7 @@ def runscript(script): def print_banner(): banner = [ "Python %s " % sys.version, - "IDAPython" + (" 64-bit" if ida_idaapi.__EA64__ else "") + " v%d.%d.%d %s (serial %d) (c) The IDAPython Team " % IDAPYTHON_VERSION + "IDAPython" + (" 64-bit" if ida_idaapi.__EA64__ else "") + " v%d.%d.%d (c) The IDAPython Team " % IDAPYTHON_VERSION ] sepline = '-' * (max([len(s) for s in banner])+1) @@ -107,9 +114,10 @@ def print_banner(): # ----------------------------------------------------------------------- # Redirect stderr and stdout to the IDA message window -_orig_stdout = sys.stdout; -_orig_stderr = sys.stderr; -sys.stdout = sys.stderr = IDAPythonStdOut() +if IDAPYTHON_OWNING_INTERPRETER: + _orig_stdout = sys.stdout + _orig_stderr = sys.stderr + sys.stdout = sys.stderr = IDAPythonStdOut() # ----------------------------------------------------------------------- # Initialize the help, with our own stdin wrapper, that'll query the user @@ -131,7 +139,8 @@ class IDAPythonHelp(pydoc.Helper): help = IDAPythonHelp() # Assign a default sys.argv -sys.argv = [""] +if IDAPYTHON_OWNING_INTERPRETER: + sys.argv = [""] # Have to make sure Python finds our modules sys.path.append(ida_diskio.idadir("python")) @@ -147,12 +156,11 @@ if os.getcwd() in sys.path: if not IDAPYTHON_REMOVE_CWD_SYS_PATH: sys.path.append(os.getcwd()) -# Additional $IDAUSR-derived paths +# Additional IDAUSR-derived paths if IDAPYTHON_IDAUSR_SYSPATH: idausr_python_list = ida_diskio.get_ida_subdirs("python") - for idausr_python in idausr_python_list: - one = os.path.join(idausr_python, str(sys.version_info.major)) - if one not in sys.path: + for one in idausr_python_list: + if one not in sys.path and os.path.exists(one): sys.path.append(one) if IDAPYTHON_COMPAT_AUTOIMPORT_MODULES: @@ -183,4 +191,27 @@ if sys.version_info.major >= 3: if sp not in sys.path: sys.path.append(sp) + +# Prepare PySide6 path, if found +def prepare_PySide6_import(): + python_name = f"python{sys.version_info[0]}.{sys.version_info[1]}" + pyside_subdir = f"PySide6-{python_name}" + candidate_PySide6_dist = os.path.join(IDAPYTHON_DYNLOAD_BASE, "python", pyside_subdir) + if os.path.isdir(candidate_PySide6_dist): + candidate_PySide6_dir = os.path.join(candidate_PySide6_dist, python_name, "site-packages") + if os.path.isdir(candidate_PySide6_dir): + if "linux" in sys.platform: + import ctypes + try: + # preload libraries + ctypes.cdll.LoadLibrary(os.path.join(candidate_PySide6_dist, "libshiboken6.abi3.so.6.8")) + ctypes.cdll.LoadLibrary(os.path.join(candidate_PySide6_dist, "libpyside6.abi3.so.6.8")) + except: + import traceback + traceback.print_exc() + sys.path.append(candidate_PySide6_dir) + +if sys.version_info[:2] >= (3, 9): + prepare_PySide6_import() + # All done, ready to rock. diff --git a/pywraps.cpp b/pywraps.cpp index cd9a3bd..31ca53c 100644 --- a/pywraps.cpp +++ b/pywraps.cpp @@ -110,7 +110,17 @@ ref_t ida_export PyW_StrVecToPyList(const qstrvec_t &vec) for ( size_t i = 0; i < n; ++i ) PyList_SetItem(py_list.o, i, PyUnicode_from_qstring(vec[i])); return ref_t(py_list); +} +//------------------------------------------------------------------------- +ref_t ida_export PyW_TidVecToPyList(const qvector &vec) +{ + size_t n = vec.size(); + PYW_GIL_CHECK_LOCKED_SCOPE(); + newref_t py_list(PyList_New(n)); + for ( size_t i = 0; i < n; ++i ) + PyList_SetItem(py_list.o, i, PyLong_FromUnsignedLongLong(vec[i])); + return ref_t(py_list); } //------------------------------------------------------------------------- @@ -211,7 +221,7 @@ Py_ssize_t ida_export PyW_PySeqToEaVec( if ( PyLong_Check(py_item.o) ) { unsigned long long ull = PyLong_AsUnsignedLongLong(py_item.o); - if ( ull == -1ULL && PyErr_Occurred() != nullptr ) + if ( ull + 1 == 0 && PyErr_Occurred() != nullptr ) return CIP_FAILED; ea = ea_t(ull); } @@ -250,7 +260,7 @@ Py_ssize_t ida_export PyW_PySeqToEa64Vec(ea64vec_t *out, PyObject *py_list, size if ( PyLong_Check(py_item.o) ) { unsigned long long ull = PyLong_AsUnsignedLongLong(py_item.o); - if ( ull == -1ULL && PyErr_Occurred() != nullptr ) + if ( ull + 1 == 0 && PyErr_Occurred() != nullptr ) return CIP_FAILED; v = uint64(ull); } @@ -905,7 +915,7 @@ int ida_export idcvar_to_pyvar( if ( !*py_var ) { double x; - if ( processor_t::realcvt(&x, (fpvalue_t*)&idc_var.e, (sizeof(x)/2-1)|010) != 1 ) + if ( ieee_realcvt(&x, (fpvalue_t*)&idc_var.e, (sizeof(x)/2-1)|010) != REAL_ERROR_OK ) INTERR(30160); *py_var = newref_t(PyFloat_FromDouble(x)); @@ -1385,7 +1395,7 @@ bool ida_export PyW_GetNumber(PyObject *py_var, uint64 *num, bool *is_64) if ( py_num && py_mask ) { ull = PyLong_AsUnsignedLongLong(py_num.o); - if ( PyErr_Occurred() == nullptr ) //-V547 'PyErr_Occurred() == nullptr' is always false + if ( PyErr_Occurred() == nullptr ) { *is_64 = true; *num = uint64(ull); @@ -1978,6 +1988,8 @@ void ida_export idapython_unregister_hook( } #ifdef TESTABLE_BUILD QASSERT(30510, found); +#else + qnotused(found); #endif // TESTABLE_BUILD } @@ -2009,33 +2021,47 @@ bool ida_export idapython_unhook_from_notification_point( //------------------------------------------------------------------------- bool ida_export idapython_convert_cli_completions( qstrvec_t *out_completions, + qstrvec_t *out_hints, + qstrvec_t *out_docs, int *out_match_start, int *out_match_end, ref_t py_res) { bool ok = py_res != nullptr && PyTuple_Check(py_res.o) - && PyTuple_Size(py_res.o) == 3; + && PyTuple_Size(py_res.o) == 5; if ( ok ) { borref_t i0(PyTuple_GetItem(py_res.o, 0)); borref_t i1(PyTuple_GetItem(py_res.o, 1)); borref_t i2(PyTuple_GetItem(py_res.o, 2)); - ok = PyList_Check(i0.o) && PyLong_Check(i1.o) && PyLong_Check(i2.o); + borref_t i3(PyTuple_GetItem(py_res.o, 3)); + borref_t i4(PyTuple_GetItem(py_res.o, 4)); + // NB: Invalid i1.o and i2.o will fail the PySeqToStrVec conversion below, + // we don't enforce them as valid lists here to allow the Python code to + // return None for hints and docs. + ok = PyList_Check(i0.o) && PyLong_Check(i3.o) && PyLong_Check(i4.o); if ( ok ) { - ok = PyW_PySeqToStrVec(out_completions, i0.o) > 0; + ssize_t num_comps = PyW_PySeqToStrVec(out_completions, i0.o); + ssize_t num_hints = PyW_PySeqToStrVec(out_hints, i1.o); + ssize_t num_docs = PyW_PySeqToStrVec(out_docs, i2.o); + // Clear the error that was set by PyW_PySeqToStrVec() + PyErr_Clear(); + // We accept the generated result if num_comps yielded at least 1 item, + // and we find a matching number of elements in hints and docs. Optionally, + // hints and docs can be zero-element lists, or None, which means we will only + // display completions. + ok = (num_comps > 0) + && ((num_comps == num_hints && num_hints == num_docs) + || (num_hints == num_docs && num_docs == 0) + || (num_hints == CIP_FAILED && num_docs == CIP_FAILED)); if ( ok ) { - *out_match_start = PyLong_AsLong(i1.o); - *out_match_end = PyLong_AsLong(i2.o); + *out_match_start = PyLong_AsLong(i3.o); + *out_match_end = PyLong_AsLong(i4.o); ok = PyErr_Occurred() == nullptr; } - else - { - // Clear the error that was set by PyW_PySeqToStrVec() - PyErr_Clear(); - } } } return ok; diff --git a/pywraps.hpp b/pywraps.hpp index 8bd4944..7010621 100644 --- a/pywraps.hpp +++ b/pywraps.hpp @@ -95,7 +95,6 @@ static const char S_ON_CLOSE[] = "OnClose"; static const char S_ON_DBL_CLICK[] = "OnDblClick"; static const char S_ON_CURSOR_POS_CHANGED[] = "OnCursorPosChanged"; static const char S_ON_KEYDOWN[] = "OnKeydown"; -static const char S_ON_COMPLETE_LINE[] = "OnCompleteLine"; static const char S_ON_FIND_COMPLETIONS[] = "OnFindCompletions"; static const char S_ON_CREATE[] = "OnCreate"; static const char S_ON_POPUP[] = "OnPopup"; @@ -503,6 +502,7 @@ idaman Py_ssize_t ida_export pyvar_walk_seq( idaman ref_t ida_export PyW_SizeVecToPyList(const sizevec_t &vec); idaman ref_t ida_export PyW_UvalVecToPyList(const uvalvec_t &vec); idaman ref_t ida_export PyW_StrVecToPyList(const qstrvec_t &vec); +idaman ref_t ida_export PyW_TidVecToPyList(const qvector &vec); // Converts a Python list, to a vector of the given type. // An exception will be raised in case: @@ -872,6 +872,7 @@ struct idapython_plugin_t : public plugmod_t, public event_listener_t qvector pyhomepath; #endif bool initialized; + bool owning_interpreter; bool ui_ready; #ifdef TESTABLE_BUILD int user_code_lenient; @@ -896,9 +897,10 @@ struct idapython_plugin_t : public plugmod_t, public event_listener_t static bool idaapi extlang_compile_file( const char *path, + const char *requested_namespace, qstring *errbuf) { - return get_instance()->_extlang_compile_file(path, errbuf); + return get_instance()->_extlang_compile_file(path, requested_namespace, errbuf); } static bool idaapi extlang_compile_expr( @@ -996,17 +998,29 @@ struct idapython_plugin_t : public plugmod_t, public event_listener_t static bool idaapi cli_find_completions( qstrvec_t *out_completions, + qstrvec_t *out_hints, + qstrvec_t *out_docs, int *out_match_start, int *out_match_end, const char *line, int x) { - return get_instance()->_cli_find_completions(out_completions, out_match_start, out_match_end, line, x); + return get_instance()->_cli_find_completions(out_completions, out_hints, out_docs, + out_match_start, out_match_end, line, x); + } + + static bool idaapi exec_script( + const char *path, + PyObject *globals, + qstring *errbuf) + { + return get_instance()->_exec_script(path, globals, errbuf); } private: bool _extlang_compile_file( const char *path, + const char *requested_namespace, qstring *errbuf); bool _extlang_compile_expr( const char *name, @@ -1060,6 +1074,8 @@ private: const char *line); bool _cli_find_completions( qstrvec_t *out_completions, + qstrvec_t *out_hints, + qstrvec_t *out_docs, int *out_match_start, int *out_match_end, const char *line, @@ -1072,6 +1088,10 @@ private: const char *idaapi_executor_func_name = S_IDAAPI_EXECSCRIPT, idc_value_t *second_res = nullptr, bool want_tuple = false); + bool _exec_script( + const char *path, + PyObject *globals, + qstring *errbuf); bool _run_user_script(); @@ -1080,11 +1100,9 @@ private: bool _run_init_py(); PyObject *_get_module_globals(const char *modname=nullptr); - PyObject *_get_module_globals_from_path_with_kind( - const char *path, - const char *kind); PyObject *_get_module_globals_from_path( - const char *path); + const char *path, + const char *requested_namespace); static idapython_plugin_t *instance; }; @@ -1354,6 +1372,8 @@ idaman void ida_export idapython_hide_wait_box(); //------------------------------------------------------------------------- idaman bool ida_export idapython_convert_cli_completions( qstrvec_t *out_completions, + qstrvec_t *out_hints, + qstrvec_t *out_docs, int *out_match_start, int *out_match_end, ref_t py_res); diff --git a/pywraps/py_bytes.hpp b/pywraps/py_bytes.hpp index 65ab31d..8927aab 100644 --- a/pywraps/py_bytes.hpp +++ b/pywraps/py_bytes.hpp @@ -126,46 +126,16 @@ static bool py_do_get_bytes( #define FF_1CUST 0x0D000000 ///< Custom representation? //------------------------------------------------------------------------ -/* -# -def visit_patched_bytes(ea1, ea2, callable): - """ - 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. - """ - pass -# -*/ -static int py_visit_patched_bytes(ea_t ea1, ea_t ea2, PyObject *py_callable) +static int py_visit_patched_bytes(ea_t ea1, ea_t ea2, PyObject *callable) { PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( !PyCallable_Check(py_callable) ) + if ( !PyCallable_Check(callable) ) return 0; else - return visit_patched_bytes(ea1, ea2, py_visit_patched_bytes_cb, py_callable); + return visit_patched_bytes(ea1, ea2, py_visit_patched_bytes_cb, callable); } //------------------------------------------------------------------------ -/* -# -def get_bytes(ea, size): - """ - Get the specified number of bytes of the program. - @param ea: program address - @param size: number of bytes to return - @return: the bytes (as a str), or None in case of failure - """ - pass -# -*/ static PyObject *py_get_bytes(ea_t ea, unsigned int size, int gmb_flags=GMB_READALL) { PyObject *py_bytes = nullptr; @@ -176,20 +146,6 @@ static PyObject *py_get_bytes(ea_t ea, unsigned int size, int gmb_flags=GMB_READ } //--------------------------------------------------------------------------- -/* -# -def get_bytes_and_mask(ea, size, mask): - """ - Get the specified number of bytes of the program, and a bitmask - specifying what bytes are defined and what bytes are not. - @param ea: program address - @param size: number of bytes to return - @return: a tuple (bytes, mask), or None in case of failure. - Both 'bytes' and 'mask' are 'str' instances. - """ - pass -# -*/ static PyObject *py_get_bytes_and_mask(ea_t ea, unsigned int size, int gmb_flags=GMB_READALL) { PyObject *py_bytes = nullptr; @@ -201,44 +157,20 @@ static PyObject *py_get_bytes_and_mask(ea_t ea, unsigned int size, int gmb_flags } //--------------------------------------------------------------------------- -/* -# -# Conversion options for get_strlit_contents(): -STRCONV_ESCAPE = 0x00000001 # convert non-printable characters to C escapes (\n, \xNN, \uNNNN) - -def get_strlit_contents(ea, len, type, flags = 0): - """ - Get contents of string literal, as UTF-8-encoded codepoints. - It works even if the string has not been created in the database yet. - - Note that the returned value will be of type 'bytes'; if - you want auto-conversion to unicode strings (that is: real Python - strings), you should probably be using the idautils.Strings class. - - @param ea: linear address of the string - @param len: length of the string in bytes (including terminating 0) - @param type: type of the string. Represents both the character encoding, - and the 'type' of string at the given location. - @param flags: combination of STRCONV_..., to perform output conversion. - @return: a bytes-filled str object. - """ - pass -# -*/ static PyObject *py_get_strlit_contents( ea_t ea, - PyObject *py_len, + PyObject *len, int32 type, int flags = 0) { - uint64 len; - if ( !PyW_GetNumber(py_len, &len) ) + uint64 llen; + if ( !PyW_GetNumber(len, &llen) ) Py_RETURN_NONE; - if ( len == BADADDR ) - len = uint64(-1); + if ( llen == BADADDR ) + llen = uint64(-1); qstring buf; - if ( len != uint64(-1) && ea_t(ea + len) < ea - || get_strlit_contents(&buf, ea, len, type, nullptr, flags) < 0 ) + if ( llen != uint64(-1) && ea_t(ea + llen) < ea + || get_strlit_contents(&buf, ea, llen, type, nullptr, flags) < 0 ) { Py_RETURN_NONE; } @@ -250,46 +182,6 @@ static PyObject *py_get_strlit_contents( return py_buf.o; } -//------------------------------------------------------------------------- -static ea_t py_bin_search( - ea_t start_ea, - ea_t end_ea, - const bytevec_t &image, - const bytevec_t &imask, - int step, - int flags) -{ - if ( image.empty() ) - return BADADDR; - if ( step != /* old value of BIN_SEARCH_FORWARD*/ 1 - && step != /* new value of BIN_SEARCH_FORWARD */ 0 ) - { - flags |= BIN_SEARCH_BACKWARD; - } - const size_t len = image.size(); - const uchar *mask = imask.begin(); - bytevec_t lmask; - if ( mask != nullptr ) - { - if ( *mask == 0xFF ) - { - // a value of '0xFF' in the first byte meant "all bytes defined". We - // can thus turn that into a nullptr mask. - mask = nullptr; - } - else - { - // some bytes defined, some bytes aren't. Those that are have a value - // 1 in the mask. We must turn them into 0xFF's - lmask.resize(len); - for ( size_t i = 0; i < len; ++i ) - lmask[i] = mask[i] != 0 ? 0xFF : 0; - mask = lmask.begin(); - } - } - return bin_search2(start_ea, end_ea, image.begin(), mask, len, flags); -} - //------------------------------------------------------------------------- static PyObject *py_print_strlit_type(int32 strtype, int flags=0) { @@ -299,20 +191,6 @@ static PyObject *py_print_strlit_type(int32 strtype, int flags=0) return Py_BuildValue("(ss)", s.c_str(), t.c_str()); } -//------------------------------------------------------------------------- -static PyObject *py_get_octet(ea_t ea, uint64 v, int nbit) -{ - uchar octet = get_octet(&ea, &v, &nbit); - return Py_BuildValue("(i" PY_BV_EA "Ki)", int(uint32(octet)), bvea_t(ea), v, nbit); -} - -//------------------------------------------------------------------------- -static PyObject *py_get_8bit(ea_t ea, uint32 v, int nbit) -{ - uchar octet = get_8bit(&ea, &v, &nbit); - return Py_BuildValue("(i" PY_BV_EA "ki)", int(uint32(octet)), bvea_t(ea), v, nbit); -} - //------------------------------------------------------------------------- static bool ida_export py_op_stroff( const insn_t &insn, @@ -324,22 +202,26 @@ static bool ida_export py_op_stroff( } //------------------------------------------------------------------------- -/* -# -def bin_search(start_ea, end_ea, data, flags): - """ - Search for a set of bytes in the program - - @param start_ea: linear address, start of range to search - @param end_ea: linear address, end of range to search (exclusive) - @param data: the prepared data to search for (see parse_binpat_str()) - @param flags: combination of BIN_SEARCH_* flags - @return: the address of a match, or ida_idaapi.BADADDR if not found - """ - pass -# -*/ - +static int get_stroff_path( + qvector *out_path, + adiff_t *out_delta, + ea_t ea, + int n) +{ + if ( !is_stroff(get_flags(ea), n) ) + return -1; + tid_t path[MAXSTRUCPATH]; + const int path_size = get_stroff_path(path, out_delta, ea, n); + if ( path_size > 0 ) + { + qvector storage; + storage.reserve(path_size); + for ( int i = 0; i < path_size; ++i ) + storage.push_back(path[i]); + out_path->swap(storage); + } + return path_size; +} // #endif diff --git a/pywraps/py_bytes_custdata.hpp b/pywraps/py_bytes_custdata.hpp index 0af400a..289c118 100644 --- a/pywraps/py_bytes_custdata.hpp +++ b/pywraps/py_bytes_custdata.hpp @@ -419,23 +419,10 @@ static void clear_custom_data_types_and_formats() // //------------------------------------------------------------------------ -/* -# -def register_custom_data_type(dt): - """ - 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 - """ - pass -# -*/ // Given a py_data_type_t object, this function will register a datatype -static int py_register_custom_data_type(PyObject *py_dt) +static int py_register_custom_data_type(PyObject *dt) { - ref_t py_attr = PyW_TryGetAttrString(py_dt, "this"); + ref_t py_attr = PyW_TryGetAttrString(dt, "this"); if ( py_attr == nullptr ) return -1; @@ -447,17 +434,6 @@ static int py_register_custom_data_type(PyObject *py_dt) } //------------------------------------------------------------------------ -/* -# -def unregister_custom_data_type(dtid): - """ - Unregisters a custom data type. - @param dtid: the data type id - @return: Boolean - """ - pass -# -*/ static bool py_unregister_custom_data_type(int dtid) { const data_type_t *_dt = get_custom_data_type(dtid); @@ -474,22 +450,9 @@ static bool py_unregister_custom_data_type(int dtid) } //------------------------------------------------------------------------ -/* -# -def register_custom_data_format(df): - """ - Registers a custom data format with a given data type. - @param df: an instance of data_format_t - @return: - < 0 if failed to register - > 0 data format id - """ - pass -# -*/ -static int py_register_custom_data_format(PyObject *py_df) +static int py_register_custom_data_format(PyObject *df) { - ref_t py_attr = PyW_TryGetAttrString(py_df, "this"); + ref_t py_attr = PyW_TryGetAttrString(df, "this"); if ( py_attr == nullptr ) return -1; @@ -502,17 +465,6 @@ static int py_register_custom_data_format(PyObject *py_df) } //------------------------------------------------------------------------ -/* -# -def unregister_custom_data_format(dfid): - """ - Unregisters a custom data format - @param dfid: data format id - @return: Boolean - """ - pass -# -*/ static bool py_unregister_custom_data_format(int dfid) { const data_format_t *_df = get_custom_data_format(dfid); diff --git a/pywraps/py_bytes_custdata.py b/pywraps/py_bytes_custdata.py index 302cc40..e6da78a 100644 --- a/pywraps/py_bytes_custdata.py +++ b/pywraps/py_bytes_custdata.py @@ -90,83 +90,4 @@ def unregister_data_types_and_formats(formats): ok = __walk_types_and_formats(formats, __unreg_type, __unreg_format, False) return 1 if ok else -1 -#-------------------------------------------------------------------------- -# -# -# -#class data_type_t(object): -# """ -# The following optional callback methods can be implemented -# in a data_type_t subclass -# """ -# -# def may_create_at(self, ea, nbytes): -# """May create data? -# No such callback means: always succeed (i.e., no restriction where -# such a data type can be created.) -# @param ea: candidate address for the data item -# @param nbytes: candidate size for the data item -# @return: True/False -# """ -# return True -# -# def calc_item_size(self, ea, maxsize): -# """This callback is used to determine size of the (possible) -# item at `ea`. -# No such callback means that datatype is of fixed size `value_size`. -# (thus, this callback is required only for varsize datatypes.) -# @param ea: address of the item -# @param maxsize: maximum size of the item -# @return: 0 - no such item can be created/displayed -# """ -# return 0 -# -# -#class data_format_t(object): -# """ -# The following callback methods can be implemented -# in a data_format_t subclass -# """ -# -# def printf(self, value, current_ea, operand_num, dtid): -# """Convert `value` to colored string using custom format. -# @param value: value to print (of type 'str', sequence of bytes) -# @param current_ea: current address (BADADDR if unknown) -# @param operand_num: current operand number -# @param dtid: custom data type id -# @return: string representing data -# """ -# return None -# -# def scan(self, input, current_ea, operand_num): -# """Convert uncolored string (user input) to the value. -# This callback is called from the debugger when an user enters a -# new value for a register with a custom data representation (e.g., -# an MMX register.) -# @param input: input string -# @param current_ea: current address (BADADDR if unknown) -# @param operand_num: current operand number (-1 if unknown) -# @return: tuple(bool, string) -# (True, output value) or -# (False, error message) -# """ -# return (False, "Not implemented") -# -# def analyze(self, current_ea, operand_num): -# """Analyze custom data format occurrence. -# This callback is called in 2 cases: -# - after emulating an instruction (after a call of -# 'ev_emu_insn') if its operand is marked as "custom data -# representation" -# - when emulating data (this is done using a call of -# 'ev_out_data' with analyze_only == true). This is the right -# place to create cross references from the current item. -# @param current_ea: current address (BADADDR if unknown) -# @param operand_num: current operand number -# """ -# pass -# -# -# # -# ----------------------------------------------------------------------- diff --git a/pywraps/py_bytes_find_bytes.hpp b/pywraps/py_bytes_find_bytes.hpp new file mode 100644 index 0000000..0c77830 --- /dev/null +++ b/pywraps/py_bytes_find_bytes.hpp @@ -0,0 +1,23 @@ + +// /* +// TODO's +// * `start_ea` -> `range_start` +// * `end_ea` -> `range_size` +// * parse_binpat_str => warning in case of error +// * make start_ea the 1st argument? +// * "4f fd" fails parsing +// * masks don't honor the bit granularity: anything non-0 is considered as a match +// */ + + +// +// + + +// +inline bytevec_t __to_bytevec(const bytevec_t &in) +{ + return in; +} +// + diff --git a/pywraps/py_bytes_find_bytes.py b/pywraps/py_bytes_find_bytes.py new file mode 100644 index 0000000..9bbc618 --- /dev/null +++ b/pywraps/py_bytes_find_bytes.py @@ -0,0 +1,68 @@ +# + +import typing + +import ida_idaapi +import ida_nalt +import ida_range + +def find_bytes( + bs: typing.Union[bytes, bytearray, str], + range_start: int, + range_size: typing.Optional[int] = None, + range_end: typing.Optional[int] = ida_idaapi.BADADDR, + mask: typing.Optional[typing.Union[bytes, bytearray]] = None, + flags: typing.Optional[int] = BIN_SEARCH_FORWARD | BIN_SEARCH_NOSHOW, + radix: typing.Optional[int] = 16, + strlit_encoding: typing.Optional[typing.Union[int, str]] = PBSENC_DEF1BPU) -> int: + + if isinstance(range_start, ida_range.range_t): + range_start, range_end = range_start.start_ea, range_start.end_ea + + patterns = compiled_binpat_vec_t() + if isinstance(bs, str): + if isinstance(strlit_encoding, str): + strlit_encoding_i = ida_nalt.add_encoding(strlit_encoding) + if strlit_encoding_i > 0: + strlit_encoding = strlit_encoding_i + else: + raise Exception("Unknown encoding: \"%s\"" % strlit_encoding) + parse_result = parse_binpat_str( + patterns, + range_start, + bs, + radix, + strlit_encoding) + if parse_result is False or (isinstance(parse_result, str) and len(parse_result) > 0): + raise Exception("Could not parse pattern: %s" % (parse_result or "unknown error",)) + else: + p0 = patterns.push_back() + p0.bytes = __to_bytevec(bs) + if mask is not None: + p0.mask = __to_bytevec(mask) + + if range_size is not None: + range_end = range_start + range_size + + ea, _ = bin_search(range_start, range_end, patterns, flags) + return ea + + +def find_string( + _str: str, + range_start: int, + range_end: typing.Optional[int] = ida_idaapi.BADADDR, + range_size: typing.Optional[int] = None, + strlit_encoding: typing.Optional[typing.Union[int, str]] = PBSENC_DEF1BPU, + flags: typing.Optional[int] = BIN_SEARCH_FORWARD | BIN_SEARCH_NOSHOW) -> int: + escaped = _str.replace('"', r"\22") + return find_bytes( + '"' + escaped + '"', + range_start, + range_end=range_end, + range_size=range_size, + flags=flags, + strlit_encoding=strlit_encoding) + + +# diff --git a/pywraps/py_dbg.hpp b/pywraps/py_dbg.hpp index 5f64ecb..cf8675e 100644 --- a/pywraps/py_dbg.hpp +++ b/pywraps/py_dbg.hpp @@ -34,17 +34,31 @@ static PyObject *_from_reg_val( // +inline void idaapi set_process_options( + const char *path, + const char *args, + const char *sdir, + const char *host, + const char *pass, + int port) +{ + launch_env_t envs; + return set_process_options(path, args, &envs, sdir, host, pass, port); +} + +inline void idaapi get_process_options_noenv( + qstring *path, + qstring *args, + qstring *sdir, + qstring *host, + qstring *pass, + int *port) +{ + launch_env_t envs; + get_process_options(path, args, &envs, sdir, host, pass, port); +} + //------------------------------------------------------------------------- -/* -# -def get_manual_regions(): - """ - Returns the manual memory regions - @return: list(start_ea, end_ea, name, sclass, sbase, bitness, perm) - """ - pass -# -*/ static PyObject *py_get_manual_regions() { meminfo_vec_t ranges; @@ -55,32 +69,12 @@ static PyObject *py_get_manual_regions() } //------------------------------------------------------------------------- -/* -# -def dbg_is_loaded(): - """ - Checks if a debugger is loaded - @return: Boolean - """ - pass -# -*/ static bool dbg_is_loaded() { return dbg != nullptr; } //------------------------------------------------------------------------- -/* -# -def refresh_debugger_memory(): - """ - Refreshes the debugger memory - @return: Nothing - """ - pass -# -*/ static PyObject *refresh_debugger_memory() { SWIG_PYTHON_THREAD_BEGIN_ALLOW; @@ -146,16 +140,6 @@ ssize_t idaapi DBG_Callback(void *ud, int code, va_list va) //------------------------------------------------------------------------ -/* -# -def py_list_bptgrps(): - """ - Returns list of breakpoint group names - @return: A list of strings or None on failure - """ - pass -# -*/ static PyObject *py_list_bptgrps() { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -167,17 +151,6 @@ static PyObject *py_list_bptgrps() } //------------------------------------------------------------------------ -/* -# -def internal_get_sreg_base(): - """ - Get the sreg base, for the given thread. - - @return: The sreg base, or BADADDR on failure. - """ - pass -# -*/ static ea_t py_internal_get_sreg_base(thid_t tid, int sreg_value) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -202,22 +175,6 @@ static ssize_t py_write_dbg_memory(ea_t ea, PyObject *py_buf, size_t size=size_t return write_dbg_memory(ea, buf, size); } -/* -# -def dbg_can_query(): - """ - 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 - """ - pass -# -*/ - //------------------------------------------------------------------------- static bool py_dbg_can_query() { @@ -225,11 +182,11 @@ static bool py_dbg_can_query() } //------------------------------------------------------------------------- -static PyObject *py_set_reg_val(const char *regname, PyObject *o) +static PyObject *py_set_reg_val(const char *regname, PyObject *value) { regval_t buf; regval_t *ptr; - if ( !_to_reg_val(&ptr, &buf, regname, o) ) + if ( !_to_reg_val(&ptr, &buf, regname, value) ) return nullptr; SWIG_PYTHON_THREAD_BEGIN_ALLOW; bool ok = set_reg_val(regname, ptr); @@ -243,14 +200,14 @@ static PyObject *py_set_reg_val(const char *regname, PyObject *o) } //------------------------------------------------------------------------- -static PyObject *py_set_reg_val(thid_t tid, int regidx, PyObject *o) +static PyObject *py_set_reg_val(thid_t tid, int regidx, PyObject *value) { if ( dbg == nullptr ) { PyErr_SetString(PyExc_Exception, "No debugger loaded"); return nullptr; } - if ( regidx < 0 || regidx >= dbg->nregs ) + if ( regidx < 0 || regidx >= dbg->nregisters ) { qstring buf; buf.sprnt("Bad register index: %d", regidx); @@ -260,7 +217,7 @@ static PyObject *py_set_reg_val(thid_t tid, int regidx, PyObject *o) const register_info_t &ri = dbg->regs(regidx); regval_t buf; regval_t *ptr; - if ( !_to_reg_val(&ptr, &buf, ri.name, o) ) + if ( !_to_reg_val(&ptr, &buf, ri.name, value) ) return nullptr; SWIG_PYTHON_THREAD_BEGIN_ALLOW; bool ok = set_reg_val(tid, regidx, ptr) > 0; @@ -302,28 +259,12 @@ static PyObject *py_get_reg_val(const char *regname) } //------------------------------------------------------------------------- -/* -# -def get_reg_vals(): - """ - Fetch live registers values for the thread - - @param tid The ID of the thread to read registers for - @param clsmask An OR'ed mask of register classes to - read values for (can be used to speed up the - retrieval process) - - @return: a regvals_t instance (empty if an error occurs) - """ - pass -# -*/ -static regvals_t *py_get_reg_vals(thid_t tid, int clsmask=-1) +static regvals_t *py_get_reg_vals(thid_t tid, int clsmask) { regvals_t *rvs = new regvals_t(); if ( dbg != nullptr ) { - rvs->resize(dbg->nregs); + rvs->resize(dbg->nregisters); if ( get_reg_vals(tid, clsmask, rvs->begin()) != DRC_OK ) rvs->clear(); } diff --git a/pywraps/py_diskio.hpp b/pywraps/py_diskio.hpp index 0b6ee53..4f067bb 100644 --- a/pywraps/py_diskio.hpp +++ b/pywraps/py_diskio.hpp @@ -2,22 +2,6 @@ #define __PY_IDA_DISKIO__ // -//-------------------------------------------------------------------------- -int idaapi py_enumerate_files_cb(const char *file, void *ud) -{ - // No need to 'PYW_GIL_GET' here, as this is called synchronously - // and from the same thread as the one that executes - // 'py_enumerate_files'. - PYW_GIL_CHECK_LOCKED_SCOPE(); - newref_t py_file(PyUnicode_FromString(file)); - newref_t py_ret( - PyObject_CallFunctionObjArgs( - (PyObject *)ud, - py_file.o, - nullptr)); - return (!py_ret || !PyNumber_Check(py_ret.o)) ? 1 /* stop enum on failure */ : PyInt_AsLong(py_ret.o); -} - //------------------------------------------------------------------------- struct bytearray_linput_data_t { @@ -31,27 +15,34 @@ static bytearray_linput_data_vec_t bytearray_linput_data_vec; // //-------------------------------------------------------------------------- -/* -# -def enumerate_files(path, fname, callback): - """ - 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 - """ - pass -# -*/ PyObject *py_enumerate_files(PyObject *path, PyObject *fname, PyObject *callback) { PYW_GIL_CHECK_LOCKED_SCOPE(); + struct ida_local file_enumerator_adapter_t : public file_enumerator_t + { + PyObject *callback; + + file_enumerator_adapter_t(PyObject *c) : callback(c) {} + int visit_file(const char *file) override + { + // No need to 'PYW_GIL_GET' here, as this is called synchronously + // and from the same thread as the one that executes + // 'py_enumerate_files'. + PYW_GIL_CHECK_LOCKED_SCOPE(); + newref_t py_file(PyUnicode_FromString(file)); + newref_t py_ret( + PyObject_CallFunctionObjArgs( + callback, + py_file.o, + nullptr)); + return !py_ret || !PyNumber_Check(py_ret.o) + ? 1 /* stop enum on failure */ + : PyInt_AsLong(py_ret.o); + } + }; + ida_local file_enumerator_adapter_t adapter(callback); + do { if ( !PyUnicode_Check(path) || !PyUnicode_Check(fname) || !PyCallable_Check(callback) ) @@ -62,13 +53,13 @@ PyObject *py_enumerate_files(PyObject *path, PyObject *fname, PyObject *callback if ( !PyUnicode_as_qstring(&_path, path) || !PyUnicode_as_qstring(&_fname, fname) ) break; - char answer[MAXSTR]; + char answer[QMAXPATH]; answer[0] = '\0'; int r = enumerate_files( answer, sizeof(answer), _path.c_str(), _fname.c_str(), - py_enumerate_files_cb, callback); + adapter); return Py_BuildValue("(is)", r, answer); } while ( false ); Py_RETURN_NONE; diff --git a/pywraps/py_fpro.hpp b/pywraps/py_fpro.hpp index 268e6bf..4850d54 100644 --- a/pywraps/py_fpro.hpp +++ b/pywraps/py_fpro.hpp @@ -2,83 +2,6 @@ #define __PY_IDA_FPRO__ // -/* -# -class qfile_t(pyidc_opaque_object_t): - """A helper class to work with FILE related functions.""" - def __init__(self): - pass - - def close(self): - """Closes the file""" - pass - - def open(self, filename, mode): - """ - Opens a file - - @param filename: the file name - @param mode: The mode string, ala fopen() style - @return: Boolean - """ - pass - - def set_linput(self, linput): - """Links the current loader_input_t instance to a linput_t instance""" - pass - - @staticmethod - def tmpfile(): - """A static method to construct an instance using a temporary file""" - pass - - def seek(self, pos, whence = SEEK_SET): - """ - Set input source position - @return: the new position (not 0 as fseek!) - """ - pass - - def tell(self): - """Returns the current position""" - pass - - def gets(self, len): - """Reads a line from the input file. Returns the read line or None""" - pass - - def read(self, size): - """Reads from the file. Returns the buffer or None""" - pass - - def write(self, buf): - """Writes to the file. Returns 0 or the number of bytes written""" - pass - - def readbytes(self, size, big_endian): - """Similar to read() but it respect the endianness""" - pass - - def writebytes(self, size, big_endian): - """Similar to write() but it respect the endianness""" - pass - - def flush(self): - pass - - def get_byte(self): - """Reads a single byte from the file. Returns None if EOF or the read byte""" - pass - - def put_byte(self): - """Writes a single byte to the file""" - pass - - def opened(self): - """Checks if the file is opened or not""" - pass -# -*/ class qfile_t { private: @@ -212,7 +135,7 @@ public: } //-------------------------------------------------------------------------- - int seek(int64 offset, int whence = SEEK_SET) + int seek(int64 offset, int whence) { int rc; SWIG_PYTHON_THREAD_BEGIN_ALLOW; diff --git a/pywraps/py_fpro_end.py b/pywraps/py_fpro_end.py new file mode 100644 index 0000000..fad7176 --- /dev/null +++ b/pywraps/py_fpro_end.py @@ -0,0 +1,5 @@ +# +qfile_t_from_fp = qfile_t.from_fp +qfile_t_from_capsule = qfile_t.from_capsule +qfile_t_tmpfile = qfile_t.tmpfile +# diff --git a/pywraps/py_frame.hpp b/pywraps/py_frame.hpp index f4d580b..64698a1 100644 --- a/pywraps/py_frame.hpp +++ b/pywraps/py_frame.hpp @@ -1,34 +1,5 @@ // -//------------------------------------------------------------------------- -/* -# -def get_stkvar(op, v): - """ - 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 - """ - pass -# -*/ -PyObject *py_get_stkvar(const insn_t &insn, const op_t &op, sval_t v) -{ - PYW_GIL_CHECK_LOCKED_SCOPE(); - sval_t actval; - member_t *member = get_stkvar(&actval, insn, op, v); - if ( member == nullptr ) - Py_RETURN_NONE; - - return Py_BuildValue("(O" PY_BV_SVAL ")", - SWIG_InternalNewPointerObj(SWIG_as_voidptr(member), SWIGTYPE_p_member_t, 0), - bvsval_t(actval)); -} - //------------------------------------------------------------------------- inline bool is_funcarg_off(const func_t *pfn, uval_t frameoff) { diff --git a/pywraps/py_funcs.hpp b/pywraps/py_funcs.hpp index 20e9d31..d6ba231 100644 --- a/pywraps/py_funcs.hpp +++ b/pywraps/py_funcs.hpp @@ -6,12 +6,6 @@ #endif //----------------------------------------------------------------------- -/* -# -def get_fchunk_referer(ea, idx): - pass -# -*/ static ea_t get_fchunk_referer(ea_t ea, size_t idx) { func_t *pfn = get_fchunk(ea); @@ -25,21 +19,6 @@ static ea_t get_fchunk_referer(ea_t ea, size_t idx) } //----------------------------------------------------------------------- -/* -# -def get_idasgn_desc(n): - """ - Get information about a signature in the list. - It returns: (name of signature, names of optional libraries) - - See also: get_idasgn_desc_with_matches - - @param n: number of signature in the list (0..get_idasgn_qty()-1) - @return: None on failure or tuple(signame, optlibs) - """ - pass -# -*/ static PyObject *py_get_idasgn_desc(int n) { qstring signame; @@ -52,19 +31,6 @@ static PyObject *py_get_idasgn_desc(int n) } //----------------------------------------------------------------------- -/* -# -def get_idasgn_desc_with_matches(n): - """ - Get information about a signature in the list. - It returns: (name of signature, names of optional libraries, number of matches) - - @param n: number of signature in the list (0..get_idasgn_qty()-1) - @return: None on failure or tuple(signame, optlibs, nmatches) - """ - pass -# -*/ static PyObject *py_get_idasgn_desc_with_matches(int n) { qstring signame; @@ -82,4 +48,5 @@ static func_t *func_t__from_ptrval__(size_t ptrval) { return (func_t *) ptrval; } + // diff --git a/pywraps/py_graph.hpp b/pywraps/py_graph.hpp index 4b5a445..ed928d3 100644 --- a/pywraps/py_graph.hpp +++ b/pywraps/py_graph.hpp @@ -75,11 +75,11 @@ private: // Refresh user-defined graph node number and edges // It calls Python method and expects that the user already filled // the nodes and edges. The nodes and edges are retrieved and passed to IDA - void on_user_refresh(mutable_graph_t *g); + void on_user_refresh(interactive_graph_t *g); // Retrieves the text for user-defined graph node // It expects either a string or a tuple (string, bgcolor) - bool on_user_text(mutable_graph_t * /*g*/, int node, const char **str, bgcolor_t *bg_color); + bool on_user_text(interactive_graph_t * /*g*/, int node, const char **str, bgcolor_t *bg_color); // Retrieves the hint for the user-defined graph // Calls Python and expects a string or None @@ -88,7 +88,7 @@ private: int _on_hint_epilog(char **hint, ref_t result); // graph is being destroyed - void on_graph_destroyed(mutable_graph_t * /*g*/ = nullptr) + void on_graph_destroyed(interactive_graph_t * /*g*/ = nullptr) { refresh_needed = true; node_cache.clear(); @@ -173,7 +173,7 @@ private: } // a group is being created - int on_creating_group(mutable_graph_t * /*my_g*/, intvec_t *my_nodes) + int on_creating_group(interactive_graph_t * /*my_g*/, intvec_t *my_nodes) { PYW_GIL_CHECK_LOCKED_SCOPE(); newref_t py_nodes(PyList_New(my_nodes->size())); @@ -194,7 +194,7 @@ private: } // a group is being deleted - int on_deleting_group(mutable_graph_t * /*g*/, int /*old_group*/) + int on_deleting_group(interactive_graph_t * /*g*/, int /*old_group*/) { PYW_GIL_CHECK_LOCKED_SCOPE(); // TODO @@ -202,7 +202,7 @@ private: } // a group is being collapsed/uncollapsed - int on_group_visibility(mutable_graph_t * /*g*/, int /*group*/, bool /*expand*/) + int on_group_visibility(interactive_graph_t * /*g*/, int /*group*/, bool /*expand*/) { PYW_GIL_CHECK_LOCKED_SCOPE(); // TODO @@ -338,7 +338,7 @@ public: py_graph->unbind(); py_graph->bind(self, view); py_graph->refresh_needed = true; - refresh_viewer(view); // cfr graph.hpp how to refresh an existing mutable_graph_t + refresh_viewer(view); // cfr graph.hpp how to refresh an existing interactive_graph_t } if ( py_graph->initialize(self, title.c_str()) < 0 ) { @@ -374,7 +374,7 @@ void py_graph_t::collect_class_callbacks_ids(pycim_callbacks_ids_t *out) } //------------------------------------------------------------------------- -void py_graph_t::on_user_refresh(mutable_graph_t *g) +void py_graph_t::on_user_refresh(interactive_graph_t *g) { if ( !refresh_needed ) return; @@ -439,7 +439,7 @@ void py_graph_t::on_user_refresh(mutable_graph_t *g) } //------------------------------------------------------------------------- -bool py_graph_t::on_user_text(mutable_graph_t * /*g*/, int node, const char **str, bgcolor_t *bg_color) +bool py_graph_t::on_user_text(interactive_graph_t * /*g*/, int node, const char **str, bgcolor_t *bg_color) { // If already cached then return the value nodetext_cache_t *c = node_cache.get(node); @@ -531,16 +531,16 @@ ssize_t py_graph_t::gr_callback(int code, va_list va) // case grcode_user_text: { - mutable_graph_t *g = va_arg(va, mutable_graph_t *); - int node = va_arg(va, int); - const char **result = va_arg(va, const char **); - bgcolor_t *bgcolor = va_arg(va, bgcolor_t *); + interactive_graph_t *g = va_arg(va, interactive_graph_t *); + int node = va_arg(va, int); + const char **result = va_arg(va, const char **); + bgcolor_t *bgcolor = va_arg(va, bgcolor_t *); ret = on_user_text(g, node, result, bgcolor); break; } // case grcode_destroyed: - on_graph_destroyed(va_arg(va, mutable_graph_t *)); + on_graph_destroyed(va_arg(va, interactive_graph_t *)); ret = 0; break; @@ -548,7 +548,7 @@ ssize_t py_graph_t::gr_callback(int code, va_list va) case grcode_clicked: if ( has_callback(GRCODE_HAVE_CLICKED) ) { - graph_viewer_t *view = va_arg(va, graph_viewer_t *); + graph_viewer_t *view = va_arg(va, graph_viewer_t *); selection_item_t *item = va_arg(va, selection_item_t *); graph_item_t *gitem = va_arg(va, graph_item_t *); ret = on_clicked(view, item, gitem); @@ -594,14 +594,14 @@ ssize_t py_graph_t::gr_callback(int code, va_list va) break; // case grcode_user_refresh: - on_user_refresh(va_arg(va, mutable_graph_t *)); + on_user_refresh(va_arg(va, interactive_graph_t *)); ret = 1; break; // case grcode_user_hint: { - /*mutable_graph_t *g =*/ va_arg(va, mutable_graph_t *); + /*interactive_graph_t *g =*/ va_arg(va, interactive_graph_t *); int node = va_arg(va, int); int src = va_arg(va, int); int dest = va_arg(va, int); @@ -618,7 +618,7 @@ ssize_t py_graph_t::gr_callback(int code, va_list va) case grcode_creating_group: // a group is being created if ( has_callback(GRCODE_HAVE_CREATING_GROUP) ) { - mutable_graph_t *g = va_arg(va, mutable_graph_t*); + interactive_graph_t *g = va_arg(va, interactive_graph_t*); intvec_t *nodes = va_arg(va, intvec_t*); ret = on_creating_group(g, nodes); } @@ -631,7 +631,7 @@ ssize_t py_graph_t::gr_callback(int code, va_list va) case grcode_deleting_group: // a group is being deleted if ( has_callback(GRCODE_HAVE_DELETING_GROUP) ) { - mutable_graph_t *g = va_arg(va, mutable_graph_t*); + interactive_graph_t *g = va_arg(va, interactive_graph_t*); int old_group = va_arg(va, int); ret = on_deleting_group(g, old_group); } @@ -644,7 +644,7 @@ ssize_t py_graph_t::gr_callback(int code, va_list va) case grcode_group_visibility: // a group is being collapsed/uncollapsed if ( has_callback(GRCODE_HAVE_GROUP_VISIBILITY) ) { - mutable_graph_t *g = va_arg(va, mutable_graph_t*); + interactive_graph_t *g = va_arg(va, interactive_graph_t*); int group = va_arg(va, int); bool expand = bool(va_arg(va, int)); ret = on_group_visibility(g, group, expand); diff --git a/pywraps/py_graph.py b/pywraps/py_graph.py index e440e70..b9ffe6e 100644 --- a/pywraps/py_graph.py +++ b/pywraps/py_graph.py @@ -1,6 +1,17 @@ # import ida_idaapi import ida_kernwin +import ida_gdl + +edge_t = ida_gdl.edge_t +node_ordering_t = ida_gdl.node_ordering_t +abstract_graph_t = drawable_graph_t +mutable_graph_t = interactive_graph_t + +create_mutable_graph = create_interactive_graph +delete_mutable_graph = delete_interactive_graph +grcode_create_mutable_graph = grcode_create_interactive_graph +grcode_create_mutable_graph = grcode_create_interactive_graph class GraphViewer(ida_kernwin.CustomIDAMemo): class UI_Hooks_Trampoline(ida_kernwin.UI_Hooks): @@ -124,68 +135,4 @@ class GraphViewer(ida_kernwin.CustomIDAMemo): self.ui_hooks_trampoline.unhook() super()._OnBind(hook) -# -# def OnGetText(self, node_id): -# """ -# Triggered when the graph viewer wants the text and color for a given node. -# This callback is triggered one time for a given node (the value will be cached and used later without calling Python). -# When you call refresh then again this callback will be called for each node. -# -# This callback is mandatory. -# -# @return: Return a string to describe the node text or return a tuple (node_text, node_color) to describe both text and color -# """ -# return str(self[node_id]) -# -# def OnActivate(self): -# """ -# Triggered when the graph window gets the focus -# @return: None -# """ -# print("Activated....") -# -# def OnDeactivate(self): -# """Triggered when the graph window loses the focus -# @return: None -# """ -# print("Deactivated....") -# -# def OnHint(self, node_id): -# """ -# Triggered when the graph viewer wants to retrieve hint text associated with a given node -# -# @return: None if no hint is avail or a string designating the hint -# """ -# return "hint for " + str(node_id) -# -# def OnEdgeHint(self, src, dst): -# """ -# Triggered when the graph viewer wants to retrieve hint text associated with a edge -# -# @return: None if no hint is avail or a string designating the hint -# """ -# return "hint for edge %d -> %d" % (src, dst) -# -# def OnClose(self): -# """Triggered when the graph viewer window is being closed -# @return: None -# """ -# print("Closing.......") -# -# def OnClick(self, node_id): -# """ -# Triggered when a node is clicked -# @return: False to ignore the click and True otherwise -# """ -# print("clicked on", self[node_id]) -# return True -# -# def OnDblClick(self, node_id): -# """ -# Triggerd when a node is double-clicked. -# @return: False to ignore the click and True otherwise -# """ -# print("dblclicked on", self[node_id]) -# return True -# # diff --git a/pywraps/py_hexrays.hpp b/pywraps/py_hexrays.hpp index 5c5d40b..ba2fbc6 100644 --- a/pywraps/py_hexrays.hpp +++ b/pywraps/py_hexrays.hpp @@ -331,8 +331,7 @@ static bool is_hexrays_plugin(const plugin_t *entry) //------------------------------------------------------------------------- static void try_init() { - init_hexrays_plugin(0); - if ( get_hexdsp() != nullptr ) + if ( init_hexrays_plugin(0) ) msg("IDAPython Hex-Rays bindings initialized.\n"); } @@ -358,7 +357,7 @@ static ssize_t idaapi ida_hexrays_ui_notification(void *, int code, va_list va) break; case ui_destroying_plugmod: - if ( get_hexdsp() != nullptr ) + if ( hexdsp_inited() ) { /*const plugmod_t *plugmod =*/ va_arg(va, plugmod_t *); const plugin_t *entry = va_arg(va, plugin_t *); diff --git a/pywraps/py_hexrays.py b/pywraps/py_hexrays.py index 23fd02a..22abeae 100644 --- a/pywraps/py_hexrays.py +++ b/pywraps/py_hexrays.py @@ -3,7 +3,7 @@ import ida_funcs import ida_idaapi -hexrays_failure_t.__str__ = lambda self: str("%x: %s" % (self.errea, self.desc())) +hexrays_failure_t.__repr__ = lambda self: str("%x: %s" % (self.errea, self.desc())) # --------------------------------------------------------------------- # Renamings @@ -136,6 +136,7 @@ def cinsn_details(self): cinsn_t.details = property(cinsn_details) cfuncptr_t.__str__ = lambda self: str(self.__deref__()) +cfuncptr_t.__repr__ = lambda self: repr(self.__deref__()) cfuncptr_t.__eq__ = lambda self, other: self.__ptrval__() == other.__ptrval__() if isinstance(other, cfuncptr_t) else False import ida_typeinf diff --git a/pywraps/py_ida.py b/pywraps/py_ida.py index 4f0eabf..c35cec5 100644 --- a/pywraps/py_ida.py +++ b/pywraps/py_ida.py @@ -147,19 +147,6 @@ idainfo_comment_set = inf_set_cmt_indent __make_idainfo_accessors(None, "is_graph_view", "set_graph_view") -if ida_idaapi.uses_swig_builtins: - _scope = _ida_ida.idainfo -else: - _scope = _ida_ida -SW_RPTCMT = _scope.SCF_RPTCMT -SW_ALLCMT = _scope.SCF_ALLCMT -SW_NOCMT = _scope.SCF_NOCMT -SW_LINNUM = _scope.SCF_LINNUM -SW_TESTMODE = _scope.SCF_TESTMODE -SW_SHHID_ITEM = _scope.SCF_SHHID_ITEM -SW_SHHID_FUNC = _scope.SCF_SHHID_FUNC -SW_SHHID_SEGM = _scope.SCF_SHHID_SEGM - def __wrap_hooks_callback(klass, new_name, old_name, do_call): bkp_name = "__real_%s" % new_name def __wrapper(self, *args): diff --git a/pywraps/py_idaapi.hpp b/pywraps/py_idaapi.hpp index 003f1e8..c7ab6dc 100644 --- a/pywraps/py_idaapi.hpp +++ b/pywraps/py_idaapi.hpp @@ -109,17 +109,6 @@ static void ida_idaapi_closebase(void) {} #define HBF_VOLATILE_METHOD_SET 0x00000002 //------------------------------------------------------------------------ -/* -# -def parse_command_line(cmdline): - """ - Parses a space separated string (quotes and escape character are supported) - @param cmdline: The command line to parse - @return: A list of strings or None on failure - """ - pass -# -*/ static PyObject *py_parse_command_line(const char *cmdline) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -129,69 +118,17 @@ static PyObject *py_parse_command_line(const char *cmdline) Py_RETURN_NONE; return qstrvec2pylist(args); } - -//------------------------------------------------------------------------- -/* -# -def get_inf_structure(): - """ - Returns the global variable 'inf' (an instance of idainfo structure, see ida.hpp) - """ - pass -# -*/ -idainfo *get_inf_structure(void) -{ - return &inf; -} - -//------------------------------------------------------------------------- // Declarations from Python.cpp -/* -# -def set_script_timeout(timeout): - """ - 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 - """ - pass -# -*/ idaman int ida_export set_script_timeout(int timeout); -/* -# -def 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 - """ - pass -# -*/ +//------------------------------------------------------------------------- idaman void ida_export disable_script_timeout(); -/* -# -def 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 - """ - pass -# -*/ +//------------------------------------------------------------------------- idaman void ida_export enable_extlang_python(bool enable); idaman void ida_export enable_python_cli(bool enable); -idaman PyObject *ida_export format_basestring(PyObject *_in) +idaman qstring ida_export format_basestring(PyObject *_in) { // This is basically a reimplementation of str.__repr__, except that // we don't want to turn non-ASCII bytes into a \xNN equivalent: IDA @@ -239,22 +176,10 @@ idaman PyObject *ida_export format_basestring(PyObject *_in) buf.append(c); } buf.append(quote); - return PyUnicode_FromStringAndSize(buf.c_str(), buf.length()); + return buf; } -/* -# -def RunPythonStatement(stmt): - """ - This is an IDC function exported from the Python plugin. - It is used to evaluate Python statements from IDC. - @param stmt: The statement to evaluate - @return: 0 - on success otherwise a string containing the error - """ - pass -# -*/ - +//------------------------------------------------------------------------- void pygc_refresh(PyObject *self); PyObject *pygc_create_groups(PyObject *self, PyObject *groups_infos); PyObject *pygc_delete_groups(PyObject *self, PyObject *groups, PyObject *new_current); diff --git a/pywraps/py_idaapi.py b/pywraps/py_idaapi.py index 76721fb..070e6f9 100644 --- a/pywraps/py_idaapi.py +++ b/pywraps/py_idaapi.py @@ -1,4 +1,5 @@ from __future__ import print_function +from __future__ import annotations # ----------------------------------------------------------------------- try: import pywraps @@ -13,8 +14,12 @@ import datetime # +# Type aliases (we currently still support 3.8, so no `type` statement, or `typing.TypeAlias`es just yet) +ea_t = int + __EA64__ = BADADDR == 0xFFFFFFFFFFFFFFFF +import inspect import struct import traceback import os @@ -330,7 +335,7 @@ def as_UTF16(s): s = s.decode("UTF-8") else: s = unicode(s) - return s.encode("UTF-16" + ("BE" if _ida_ida.cvar.inf.is_be() else "LE")) + return s.encode("UTF-16" + ("BE" if _ida_ida.inf_is_be() else "LE")) as_unicode = as_UTF16 # ----------------------------------------------------------------------- @@ -538,12 +543,602 @@ def IDAPython_UnLoadProcMod(script, g, print_error=True): PY_COMPILE_ERR = None return PY_COMPILE_ERR +# ---------------------------------------------------------------------- +# Shameless rip-off of pdoc AST parsing follows +def IDAPython_GetDocstrings(obj): + import ast + from itertools import tee + from itertools import zip_longest + from typing import TypeVar + from typing import Optional + T = TypeVar("T") + + empty: type = inspect.Signature.empty # type: ignore # noqa + + if sys.version_info >= (3, 9): + from functools import cache + else: # pragma: no cover + from functools import lru_cache + + cache = lru_cache(maxsize=None) + + if sys.version_info >= (3, 12): + from ast import TypeAlias as ast_TypeAlias + else: # pragma: no cover + class ast_TypeAlias: + pass + + def _dedent(source: str) -> str: + if not source or source[0] not in (" ", "\t"): + return source + source = source.lstrip() + if not any(source.startswith(x) for x in ["async ", "def ", "class "]): + first_line, rest = source.split("\n", 1) + return first_line + "\n" + _dedent(rest) + else: + return source + + def _pairwise_longest(iterable): + """s -> (s0,s1), (s1,s2), (s2, s3), ..., (sN, None)""" + a, b = tee(iterable) + next(b, None) + return zip_longest(a, b) + + @cache + def _nodes(tree): + """ + Returns the list of all nodes in tree's body. + """ + return list(_nodes_iter(tree)) + + def _nodes_iter(tree): + for a in tree.body: + yield a + + @cache + def _walk_tree(tree): + var_docstrings = {} + func_docstrings = {} + nodes = _nodes(tree) + if len(nodes) == 1 and type(nodes[0]) is ast.ClassDef: + nodes = nodes[0].body + for a, b in _pairwise_longest(nodes): + if isinstance(a, ast_TypeAlias): + name = a.name.id + elif ( + isinstance(a, ast.AnnAssign) and isinstance(a.target, ast.Name) and a.simple + ): + name = a.target.id + elif ( + isinstance(a, ast.Assign) + and len(a.targets) == 1 + and isinstance(a.targets[0], ast.Name) + ): + name = a.targets[0].id + elif isinstance(a, ast.FunctionDef) and a.body: + continue + else: + continue + if ( + isinstance(b, ast.Expr) + and isinstance(b.value, ast.Constant) + and isinstance(b.value.value, str) + ): + var_docstrings[name] = inspect.cleandoc(b.value.value).strip() + return var_docstrings + + res = None + try: + res = _walk_tree(ast.parse(inspect.getsource(obj))) + except: + pass + return res + # ---------------------------------------------------------------------- class __IDAPython_Completion_Util(object): """Internal utility class for auto-completion support""" def __init__(self): pass + def __resolve_type(self, tname): + rtypes = { + 'char': 'char', + 'short': 'short', + 'int': 'int', + 'long': 'long', + 'long long': 'long long', + 'unsigned char': 'unsigned char', + 'unsigned short': 'unsigned short', + 'unsigned int': 'unsigned int', + 'unsigned long': 'unsigned long', + 'unsigned long long': 'unsigned long long', + 'aflags_t': 'unsigned int', + 'off_t': 'unsigned long long', + 'time_t': 'unsigned long long', + 'size_t': 'unsigned long', + 'uint_fast8_t': 'unsigned char', + 'uint_fast16_t': 'unsigned long', + 'uint_fast32_t': 'unsigned long', + 'uint_fast64_t': 'unsigned long', + 'uintptr_t': 'unsigned long', + 'wint_t': 'unsigned int', + '__cpu_mask': 'unsigned long', + '_Atomic_word': 'int', + 'uchar': 'unsigned char', + 'ushort': 'unsigned short', + 'uint': 'unsigned int', + 'int8': 'char', + 'uint8': 'unsigned char', + 'int16': 'short', + 'uint16': 'unsigned short', + 'int32': 'int', + 'uint32': 'unsigned int', + 'uint64': 'unsigned long long', + 'int64': 'long long', + 'ulonglong': 'unsigned long long', + 'longlong': 'long long', + 'wchar16_t': 'unsigned short', + 'wchar32_t': 'unsigned int', + 'ea_t': 'unsigned long long', + 'sel_t': 'unsigned long long', + 'asize_t': 'unsigned long long', + 'adiff_t': 'long long', + 'uval_t': 'unsigned long long', + 'sval_t': 'long long', + 'ea32_t': 'unsigned int', + 'ea64_t': 'unsigned long long', + 'error_t': 'int', + 'op_dtype_t': 'unsigned char', + 'inode_t': 'unsigned long long', + 'diffpos_t': 'unsigned long', + 'qtime32_t': 'int', + 'qtime64_t': 'unsigned long long', + 'flags_t': 'unsigned int', + 'flags64_t': 'unsigned long long', + 'tid_t': 'unsigned long long', + 'bgcolor_t': 'unsigned int', + 'qhandle_t': 'int', + 'comp_t': 'unsigned char', + 'cm_t': 'unsigned char', + 'atype_t': 'int', + 'idastate_t': 'int', + 'nodeidx64_t': 'unsigned long long', + 'nodeidx32_t': 'unsigned int', + 'nodeidx_t': 'unsigned long long', + 'reftype_t': 'unsigned char', + 'type_t': 'unsigned char', + 'p_list': 'unsigned char', + 'color_t': 'unsigned char', + 'enum_t': 'unsigned long long', + 'bmask_t': 'unsigned long long', + 'const_t': 'unsigned long long', + 'tif_cursor_t': 'unsigned long long', + 'cpidx_t': 'int', + 'cplen_t': 'int', + 'twidget_type_t': 'int', + 'input_event_modifiers_t': 'int', + 'view_event_state_t': 'int', + 'optype_t': 'unsigned char', + 'help_t': 'int', + 'pid_t': 'int', + 'thid_t': 'int', + 'register_class_t': 'unsigned char', + 'bpttype_t': 'int', + 'mangled_name_type_t': 'int', + 'diff_degree_t': 'ssize_t', + 'diridx_t': 'unsigned long long', + 'blob_idx_t': 'unsigned long long', + 'fixup_type_t': 'unsigned short', + 'graph_id_t': 'unsigned long long', + 'layout_type_t': 'int', + 'ignore_name_def_t': 'int', + 'p_string': 'unsigned char', + 'bmask64_t': 'unsigned long long', + 'bte_t': 'unsigned char', + 'type_sign_t': 'int', + 'argloc_type_t': 'int', + 'biggest_t': 'unsigned long', + 'regnum_t': 'short', + 'lxtype': 'unsigned short', + 'utc_timestamp_t': 'unsigned long long', + 'lofi_timestamp_t': 'unsigned long long', + 'problist_id_t': 'unsigned char', + 'nfds_t': 'unsigned long', + 'regoff_t': 'unsigned long long', + 'srclang_t': 'int' + } + if tname in rtypes.keys(): + resolved = rtypes[tname] + t2sz = { + 'char': 1, + 'short': 2, + 'int': 4, + 'long': 8, + 'long long': 8, + 'unsigned char': 1, + 'unsigned short': 2, + 'unsigned int': 4, + 'unsigned long': 8, + 'unsigned long long': 8, + 'ssize_t': 8, + } + size = t2sz[resolved] + else: + resolved = tname + size = None + return resolved, size + + def __render_rets(self, rets): + import ida_lines as il + h = lambda s, c: f"{il.SCOLOR_ON}{c}{s}{il.SCOLOR_OFF}{c}" + ha = lambda strs, cs: "".join([ h(s, c) for s, c in zip(strs, cs) ]) + tmp = [] + for i in range(len(rets)): + if rets[i] == "void": + continue + tmp.append(ha( [ rets[i] ], [ il.SCOLOR_REG ])) + + retstr = ha([", "], [il.SCOLOR_DEFAULT]).join(tmp) + return retstr + + def __render_args(self, args, types, defaults): + import ida_lines as il + h = lambda s, c: f"{il.SCOLOR_ON}{c}{s}{il.SCOLOR_OFF}{c}" + ha = lambda strs, cs: "".join([ h(s, c) for s, c in zip(strs, cs) ]) + tmp = [] + for i in range(len(args)): + if types[i] is None and defaults[i] is None: + tmp.append(ha( [ f"{args[i]}" ], [ il.SCOLOR_LOCNAME ])) + elif types[i] is None and defaults[i] is not None: + tmp.append(ha([ f"{args[i]}", " = ", f"{defaults[i]}" ], + [ il.SCOLOR_LOCNAME, il.SCOLOR_DEFAULT, il.SCOLOR_NUMBER ])) + elif types[i] is not None and defaults[i] is None: + tmp.append(ha([ f"{args[i]}", ": ", f"{types[i]}", ], + [ il.SCOLOR_LOCNAME, il.SCOLOR_DEFAULT, il.SCOLOR_REG, ])) + elif types[i] is not None and defaults[i] is not None: + tmp.append(ha([ f"{args[i]}", ": ", f"{types[i]}", " = ", f"{defaults[i]}" ], + [ il.SCOLOR_LOCNAME, il.SCOLOR_DEFAULT, il.SCOLOR_REG, + il.SCOLOR_DEFAULT, il.SCOLOR_NUMBER ])) + + argstr = ha([", "], [il.SCOLOR_DEFAULT]).join(tmp) + return argstr + + + def __render_proto(self, name, args, types, defaults, rets, is_ctor = False): + import ida_lines as il + h = lambda s, c: f"{il.SCOLOR_ON}{c}{s}{il.SCOLOR_OFF}{c}" + ha = lambda strs, cs: "".join([ h(s, c) for s, c in zip(strs, cs) ]) + argstr = self.__render_args(args, types, defaults) + if is_ctor and len(rets) == 0: + rets = [ name ] + retstr = self.__render_rets(rets) + + proto = ha([ f"{name}", "(" ], + [ il.SCOLOR_MACRO if is_ctor else il.SCOLOR_CNAME, il.SCOLOR_DEFAULT ]) + \ + f"{argstr}" + + if len(retstr) > 0: + proto += ha( [ ") -> ", ], [ il.SCOLOR_DEFAULT, ]) + retstr + else: + proto += ha( [")" ], [ il.SCOLOR_DEFAULT ]) + + return proto + + def __render_constant(self, name, attr): + import ida_lines as il + h = lambda s, c: f"{il.SCOLOR_ON}{c}{s}{il.SCOLOR_OFF}{c}" + ha = lambda strs, cs: "".join([ h(s, c) for s, c in zip(strs, cs) ]) + out = ha([ f"{name.ljust(48)}", f" = ", f"{attr:#018x}", ], + [ il.SCOLOR_DNAME, il.SCOLOR_DEFAULT, il.SCOLOR_NUMBER ]) + return out + + def __render_default(self, name): + import ida_lines as il + h = lambda s, c: f"{il.SCOLOR_ON}{c}{s}{il.SCOLOR_OFF}{c}" + ha = lambda strs, cs: "".join([ h(s, c) for s, c in zip(strs, cs) ]) + out = ha([ f"{name.ljust(48)}", ], [ il.SCOLOR_UNKNAME, ]) + return out + + def __render_int_member(self, name, typ, val): + import ida_lines as il + h = lambda s, c: f"{il.SCOLOR_ON}{c}{s}{il.SCOLOR_OFF}{c}" + ha = lambda strs, cs: "".join([ h(s, c) for s, c in zip(strs, cs) ]) + _, sz = self.__resolve_type(typ) + if sz is None: + val_fmt = f"{val:#018x}" + else: + val_fmt = { + 1: f"{val:#04x}", + 2: f"{val:#06x}", + 4: f"{val:#010x}", + 8: f"{val:#018x}", + }[sz] + pref_len = len(f"{name}: {typ}") + eq_pad = f" {'='.rjust(48-pref_len)} " + out = ha([ f"{name}", ": ", f"{typ}", eq_pad, val_fmt ], + [ il.SCOLOR_LOCNAME, il.SCOLOR_DEFAULT, il.SCOLOR_REG, il.SCOLOR_DEFAULT, + il.SCOLOR_NUMBER ]) + return out + + def __render_docstr(self, doc, name): + import ida_lines as il + h = lambda s, c: f"{il.SCOLOR_ON}{c}{s}{il.SCOLOR_OFF}{c}" + ha = lambda strs, cs: "".join([ h(s, c) for s, c in zip(strs, cs) ]) + + if doc is None: + return "" + + # proto = (args, types, defaults, rets) + out = [] + ign = False + for l in doc.splitlines(): + l = l.strip(" \n\r\t") + m = re.match(f"(\\d). {name}\\(", l) + if len(l) == 0: + continue + elif m is not None or "This function has the following signatures:" in l: + # prototype definition + continue + else: + # re-wrap docstring to 128 chars + final = [] + curline = "" + tmp = l.split(" ") + for i in range(len(tmp)): + if len(curline) + len(tmp[i]) + 1 > 128: + final.append(f"{curline}") + curline = f"{tmp[i]} " + else: + curline += f"{tmp[i]} " + if len(curline) > 0: + final.append(f"{curline}") + + out.append("\n".join(final)) + return "\n".join(out) + + def __parse_arg(self, arg): + arg = arg.strip(" ") + default = None + typ = None + if "=" in arg: + arg, default = [ z.strip(" ") for z in arg.split("=") ] + if ":" in arg: + arg, typ = [ z.strip(" ") for z in arg.split(":") ] + # Swig auto-renames certain argument names if they are also + # python keywords (for example from -> _from) + arg = arg.lstrip("_") + return arg, typ, default + + def __proto_from_docstring(self, name, doc, altname = None): + import re + out = [] + args, types, defaults, rets = [], [], [], [] + if doc is None or len(doc) == 0: + out.append((args, types, defaults, rets)) + return out + if altname is not None: + name = altname + for l in doc.splitlines(): + m = re.match(f" (\\d). {name}\\(", l) + if m: + if len(args + types + defaults + rets) > 0: + out.append((args, types, defaults, rets)) + args, types, defaults, rets = [], [], [], [] + + l = l[len(" 0. "):] + + # return types + if " -> " in l: + tmp = l.split(" -> ")[1].strip("() ") + if tmp == "void": + rets = [] + else: + rets = [ t.strip(" ") for t in tmp.split(",") ] + else: + rets = [] + + # arguments, types, default values in prototype + o = 0 + lvl = 1 + # poor man's context free grammar state machine finding + # outermost group of parentheses + for o in range(l.find("("), len(l)): + if l[o] == "(": + lvl += 1 + elif l[o] == ")": + lvl -= 1 + if lvl == 1: + tmp = l[l.find("(") + 1:o] + break + else: + # couldn't find outermost parenthesis group, skip + continue + + if "void" in tmp: + args = [] + for t in tmp.split(","): + arg, typ, default = self.__parse_arg(t) + args.append(arg) + types.append(typ) + defaults.append(default) + + if len(args + types + defaults + rets) > 0: + out.append((args, types, defaults, rets)) + if len(out) == 0: + return [([], [], [], [])] + return out + + def __proto_from_argspec(self, name, args, defaults, annotations): + types = [] + _defaults = [] + rets = [] + out = [] + def __repr_type(typ): + if type(typ) is str: + # string annotation, leave as is + return typ + elif typ.__class__.__module__ in [ "typing", "types" ]: + # type hint, leave as is + return typ + elif typ in [ bool, str, int, float ]: + # builtin type, format as string + return typ.__name__ + else: + # anything complex, leave as is + return typ.__class__.__name__ + + for i, arg in enumerate(args): + if arg not in annotations.keys(): + types.append(None) + else: + types.append(__repr_type(annotations[arg])) + + if defaults and i >= len(args) - len(defaults): + z = i - (len(args) - len(defaults)) + _defaults.append(defaults[z]) + else: + _defaults.append(None) + if "return" not in annotations.keys(): + rets = [] + elif annotations["return"] == "void": + rets = [] + elif type(annotations["return"]) == list: + rets = [ __repr_type(r) for r in annotations["return"] ] + else: + rets = [ __repr_type(annotations["return"]) ] + + out.append((args, types, _defaults, rets)) + return out + + def build_hints(self, names, ns): + out = [] + W_CMEMB = 258 + W_CTOR = 257 + W_FUNC = 256 + var_docs = {} + try: + var_docs = IDAPython_GetDocstrings(ns) + except: + pass + + for name in names: + try: + attr = getattr(ns, name) + is_prop = False + pclass = None + try: + is_prop = type(getattr(type(ns), name)) is property + except: + pass + is_int = type(attr) == int + is_spo = "SwigPyObject" in str(type(attr)) + is_typing = type(attr).__module__ == "typing" + if is_typing: + # Ignore typing-related imports ("from typing import X" ...) + continue + if is_prop: + pclass = getattr(ns, "__class__") + mod, cls = pclass.__module__, pclass.__name__ + var_docs = IDAPython_GetDocstrings(pclass) + doc = var_docs[name] if name in var_docs.keys() else "" + docr = self.__render_docstr(doc, name) + + if is_int or is_spo: + # class member, integral type or SwigPyObject + try: + # get low-level swig auto generated function + getter = getattr(getattr(sys.modules[mod], f"_{mod}"), f"{cls}_{name}_get") + typ = inspect.getdoc(getter).split(" -> ")[1] + except: + typ = "unk" + if is_int: + hint = self.__render_int_member(name, typ, attr) + else: + hint = self.__render_args([ name ], [ typ ], [ None ]) + out.append((name, hint, docr, [ W_CMEMB ])) + else: + # class member, complex type, property, no SwigPyObject + annots = getattr(pclass, "__annotations__") + if name in annots.keys(): + # if we have a type annnotation, pick that + typ = annots[name] + else: + # if we don't have a type annotation, take the python type + typ = type(attr).__name__ + hint = self.__render_args([ name ], [ typ ], [ None ]) + out.append((name, hint, docr, [ W_CMEMB ])) + elif is_int: + # constant + hint = self.__render_constant(name, attr) + if name in var_docs.keys(): + doc = var_docs[name] + else: + doc = "" + docr = self.__render_docstr(doc, name) + out.append((name, hint, docr, [ W_CMEMB ])) + elif inspect.isfunction(attr) or inspect.ismethod(attr) or inspect.isclass(attr): + # function or constructor + args, varargs, _, defaults, _, _, annots = inspect.getfullargspec(attr) + doc = inspect.getdoc(attr) + docr = self.__render_docstr(doc, name) + altname = None + is_ctor = inspect.isclass(attr) + weight = W_CTOR if is_ctor else W_FUNC + if name not in str(attr): + # Some functions are mapped to each other. The docstring + # parser can only extract prototypes from overloaded + # functions if it knows the name of the target function + altname = str(attr).split(" ")[1] + if varargs == "args" and doc is not None: + # Overloaded function, retrieve prototype from comment and + # insert one entry per prototype + prots = self.__proto_from_docstring(name, doc, altname = altname) + for prot in prots: + hint = self.__render_proto(name, *prot, is_ctor = is_ctor) + out.append((name, hint, docr, [ weight ])) + else: + # Regular function, retrieve prototype from argspec + prot = self.__proto_from_argspec(name, args, defaults, annots)[0] + hint = self.__render_proto(name, *prot, is_ctor = is_ctor) + out.append((name, hint, docr, [ weight ])) + elif inspect.isclass(type(attr)) and type(attr).__name__ == "str": + # class member, string + if name in var_docs.keys(): + doc = var_docs[name] + else: + doc = "" + docr = self.__render_docstr(doc, name) + hint = self.__render_default(name) + out.append((name, hint, docr, [] )) + elif inspect.isclass(type(attr)) and not callable(attr): + # class member, complex type + typ = type(attr).__name__ + if typ == "module" and ns.__name__ != "__main__": + # hide submodules that show up just because they were + # imported by code in the module we're inspecting + continue + doc = inspect.getdoc(attr) + if doc is None: + doc = "" + docr = self.__render_docstr(doc, name) + hint = self.__render_args([ name ], [ typ ], [ None ]) + out.append((name, hint, docr, [ W_CMEMB ])) + else: + doc = inspect.getdoc(attr) + if doc is None: + doc = "" + docr = self.__render_docstr(doc, name) + hint = self.__render_default(name) + out.append((name, hint, docr, [] )) + except: + out.append((name, name, "", [] )) + # self.debug("build_hint(%s) got an exception:\n%s", name, traceback.format_exc()) + pass + + out = sorted(out, key = lambda r: sum([ 1 << x for x in r[3] ])) + comps, hints, docs, _ = zip(*out) + return list(comps), list(hints), list(docs) + def debug(self, *args): try: msg = args[0] % args[1:] @@ -577,6 +1172,48 @@ class __IDAPython_Completion_Util(object): def get_candidates(self, qname, line, match_syntax_char): # self.debug("get_candidates(qname=%s, line=%s, match_syntax_char=%s)", qname, line, match_syntax_char) results = [] + MAGIC_METHODS = [ f"__{m}__" for m in [ + # as per https://docs.python.org/3/reference/datamodel.html (v3.12.3) + "abs", "add", "aenter", "aexit", "aiter", "and", "anext", + "annotations", "await", "bases", "bool", "buffer", "bytes", "call", + "ceil", "class", "class_getitem", "closure", "code", "complex", + "contains", "copy", "deepcopy", "defaults", "del", "delattr", + "delete", "delitem", "dict", "dir", "divmod", "doc", "enter", "eq", + "exit", "file", "float", "floor", "floordiv", "format", "fspath", + "func", "future", "ge", "get", "getattr", "getattribute", "getitem", + "getnewargs", "getstate", "globals", "gt", "hash", "iadd", "iand", + "ifloordiv", "ilshift", "imatmul", "imod", "imul", "index", "init", + "init_subclass", "instancecheck", "int", "invert", "ior", "ipow", + "irshift", "isub", "iter", "itruediv", "ixor", "kwdefaults", "le", + "len", "length_hint", "lshift", "lt", "match_args", "matmul", + "missing", "mod", "module", "mro_entries", "mul", "name", "ne", + "neg", "new", "next", "objclass", "or", "pos", "pow", "prepare", + "qualname", "radd", "rand", "rdivmod", "reduce", "reduce_ex", + "release_buffer", "repr", "reversed", "rfloordiv", "rlshift", + "rmatmul", "rmod", "rmul", "ror", "round", "rpow", "rrshift", + "rshift", "rsub", "rtruediv", "rxor", "self", "set", "set_name", + "setattr", "setitem", "sizeof", "slots", "str", "sub", + "subclasscheck", "subclasses", "traceback", "truediv", "trunc", + "type_params", "typing_prepare_subst", "typing_subst", "weakref", + "xor", "builtins", + # and some more (manually picked) + "cached", "loader", "package", "spec", "subclasshook", + ]] + + # and some Swig internals that are decorated differently + MAGIC_METHODS.extend([ + "__swig_destroy__", + "_SwigNonDynamicMeta", + "_swig_python_version_info", + "_swig_add_metaclass", + "_swig_repr", + "_swig_setattr_nondynamic_class_variable", + "_swig_setattr_nondynamic_instance_variable", + "thisown", "this", "weakref", + "cvar", "_real_cvar", "_wrap_cvar", + "SWIG_PYTHON_LEGACY_BOOL", + ]) + try: ns = sys.modules['__main__'] parts = qname.split('.') @@ -596,12 +1233,27 @@ class __IDAPython_Completion_Util(object): if not results and len(parts) == 1: results = self.dir_namespace(builtins, last_token) # self.debug("get_candidates() completions for %s in %s: %s", last_token, builtins, results) + if last_token not in [ "_", "__" ]: + # only filter out __magic_methods__ if user doesn't explicitly + # look for something with a "_" or "__" prefix. + results = [ r for r in results if + not (r in MAGIC_METHODS) and # magic methods + not (r.startswith(f"_ida_") and r in sys.modules) and # low-level module + not (r.startswith(f"__get")) and # property getters + not (r.startswith(f"__set")) and # property setters + not (r.endswith(f"__from_ptrval__")) # swig + ] + + results, hints, docs = self.build_hints(results, ns) + + docs = [ " " + d.replace("\n", "\n ") if len(d) > 0 else "" for d in docs ] results = map(lambda r: self.maybe_extend_syntactically(ns, r, line, match_syntax_char), results) + ns_parts = parts[:-1] results = list(map(lambda r: ".".join(ns_parts + [r]), results)) - # self.debug("get_candidates() => '%s'", str(results)) - return results + # self.debug("get_candidates() => '%s', '%s'", str(results), str(hints)) + return results, hints, docs QNAME_PAT = re.compile(r"([a-zA-Z_]([a-zA-Z0-9_\.]*)?)") @@ -628,7 +1280,9 @@ class __IDAPython_Completion_Util(object): if sys.version_info.major < 3: qname = qname.encode("UTF-8") if x >= start and x <= end: - result = self.get_candidates(qname, line, match_syntax_char), start, end + (1 if match_syntax_char else 0) + matches, hints, docs = self.get_candidates(qname, line, match_syntax_char) + rep_x, end = start, end + (1 if match_syntax_char else 0) + result = matches, hints, docs, rep_x, end # self.debug("__call__() => '%s'", str(result)) return result @@ -731,28 +1385,32 @@ class IDAPython_displayhook: self.format_item(num_printer, storage, pair[1]) storage.append('}') else: - storage.append(str(item)) + storage.append(repr(item)) def _print_hex(self, x): return hex(x) + def displayhook_format(self, item): + storage = [] + import ida_idp + num_printer = self._print_hex + dn = ida_idp.ph_get_flag() & ida_idp.PR_DEFNUM + if dn == ida_idp.PRN_OCT: + num_printer = oct + elif dn == ida_idp.PRN_DEC: + num_printer = str + elif dn == ida_idp.PRN_BIN: + num_printer = bin + self.format_item(num_printer, storage, item) + return "".join(storage) + def displayhook(self, item): if item is None or type(item) is bool: self.orig_displayhook(item) return try: - storage = [] - import ida_idp - num_printer = self._print_hex - dn = ida_idp.ph_get_flag() & ida_idp.PR_DEFNUM - if dn == ida_idp.PRN_OCT: - num_printer = oct - elif dn == ida_idp.PRN_DEC: - num_printer = str - elif dn == ida_idp.PRN_BIN: - num_printer = bin - self.format_item(num_printer, storage, item) - sys.stdout.write("%s\n" % "".join(storage)) + clob = self.displayhook_format(item) + sys.stdout.write("%s\n" % clob) except: import traceback traceback.print_exc() diff --git a/pywraps/py_idaapi_loader_input.hpp b/pywraps/py_idaapi_loader_input.hpp index f672def..18fdaf5 100644 --- a/pywraps/py_idaapi_loader_input.hpp +++ b/pywraps/py_idaapi_loader_input.hpp @@ -3,101 +3,6 @@ //-------------------------------------------------------------------------- // -/* -# -class loader_input_t(pyidc_opaque_object_t): - """ - A helper class to work with linput_t related functions. - This class is also used by file loaders scripts. - """ - def __init__(self): - pass - - def close(self): - """Closes the file""" - pass - - def open(self, filename, remote = False): - """ - Opens a file (or a remote file) - @return: Boolean - """ - pass - - def set_linput(self, linput): - """Links the current loader_input_t instance to a linput_t instance""" - pass - - @staticmethod - def from_fp(fp): - """A static method to construct an instance from a FILE*""" - pass - - def open_memory(self, start, size): - """ - 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 range to represent as linput - if unknown, may be passed as 0 - """ - pass - - def seek(self, pos, whence = SEEK_SET): - """ - Set input source position - @return: the new position (not 0 as fseek!) - """ - pass - - def tell(self): - """Returns the current position""" - pass - - def getz(self, sz, fpos = -1): - """ - 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. - """ - pass - - def gets(self, len): - """Reads a line from the input file. Returns the read line or None""" - pass - - def read(self, size): - """Reads from the file. Returns the buffer or None""" - pass - - def readbytes(self, size, big_endian): - """Similar to read() but it respect the endianness""" - pass - - def file2base(self, pos, ea1, ea2, patchable): - """ - 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 - """ - pass - - def get_byte(self): - """Reads a single byte from the file. Returns None if EOF or the read byte""" - pass - - def opened(self): - """Checks if the file is opened or not""" - pass -# -*/ class loader_input_t { private: @@ -168,7 +73,7 @@ public: } //-------------------------------------------------------------------------- - bool open(const char *filename, bool remote = false) + bool open(const char *filename, bool remote) { close(); PYW_GIL_GET; @@ -238,12 +143,12 @@ public: } //-------------------------------------------------------------------------- - bool open_memory(ea_t start, asize_t size = 0) + bool open_memory(ea_t start, int64 size) { PYW_GIL_GET; linput_t *l; SWIG_PYTHON_THREAD_BEGIN_ALLOW; - l = create_memory_linput(start, size); + l = create_memory_linput(start, asize_t(size)); if ( l != nullptr ) { close(); @@ -256,12 +161,12 @@ public: } //-------------------------------------------------------------------------- - int64 seek(int64 pos, int whence = SEEK_SET) + int64 seek(int64 offset, int whence) { int64 r; PYW_GIL_GET; SWIG_PYTHON_THREAD_BEGIN_ALLOW; - r = qlseek(li, pos, whence); + r = qlseek(li, offset, whence); SWIG_PYTHON_THREAD_END_ALLOW; return r; } @@ -278,16 +183,16 @@ public: } //-------------------------------------------------------------------------- - PyObject *getz(size_t sz, int64 fpos = -1) + PyObject *getz(size_t size, int64 fpos) { PYW_GIL_CHECK_LOCKED_SCOPE(); do { - char *buf = (char *) malloc(sz + 5); + char *buf = (char *) malloc(size + 5); if ( buf == nullptr ) break; SWIG_PYTHON_THREAD_BEGIN_ALLOW; - qlgetz(li, fpos, buf, sz); + qlgetz(li, fpos, buf, size); SWIG_PYTHON_THREAD_END_ALLOW; PyObject *ret = PyUnicode_FromString(buf); free(buf); @@ -297,7 +202,7 @@ public: } //-------------------------------------------------------------------------- - PyObject *gets(size_t len) + PyObject *gets(int64 len) { PYW_GIL_CHECK_LOCKED_SCOPE(); bytevec_t buf; @@ -312,17 +217,23 @@ public: } //-------------------------------------------------------------------------- - PyObject *read(size_t size) + PyObject *read(int64 size) { PYW_GIL_CHECK_LOCKED_SCOPE(); - bytevec_t buf; - buf.resize(size); - ssize_t nread; SWIG_PYTHON_THREAD_BEGIN_ALLOW; + ssize_t ssize(size); + bytevec_t buf; + if ( ssize < 0 ) + ssize = qlsize(li) - qltell(li); + buf.resize(ssize); + ssize_t nread; nread = qlread(li, (char *) buf.begin(), buf.size()); SWIG_PYTHON_THREAD_END_ALLOW; if ( nread <= 0 ) - Py_RETURN_NONE; + { + buf.clear(); + nread = 0; + } return PyBytes_FromStringAndSize((const char *) buf.begin(), nread); } diff --git a/pywraps/py_idd.hpp b/pywraps/py_idd.hpp index 08368b8..63a6d39 100644 --- a/pywraps/py_idd.hpp +++ b/pywraps/py_idd.hpp @@ -157,20 +157,7 @@ static debugger_t *get_dbg() return dbg; } -/* -# -def dbg_get_registers(): - """ - 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, dtype, bit_strings, default_bit_strings_mask) - The bit_strings can be a tuple of strings or None (if the register does not have bit_strings) - """ - pass -# -*/ +//------------------------------------------------------------------------- static PyObject *dbg_get_registers() { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -178,9 +165,9 @@ static PyObject *dbg_get_registers() if ( dbg == nullptr ) Py_RETURN_NONE; - PyObject *py_list = PyList_New(dbg->nregs); + PyObject *py_list = PyList_New(dbg->nregisters); - for ( int i=0; i < dbg->nregs; i++ ) + for ( int i=0; i < dbg->nregisters; i++ ) { register_info_t &ri = dbg->regs(i); PyObject *py_bits; @@ -217,20 +204,6 @@ static PyObject *dbg_get_registers() } //------------------------------------------------------------------------- -/* -# -def dbg_get_thread_sreg_base(tid, sreg_value): - """ - 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 - """ - pass -# -*/ static PyObject *dbg_get_thread_sreg_base(thid_t tid, int sreg_value) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -241,18 +214,6 @@ static PyObject *dbg_get_thread_sreg_base(thid_t tid, int sreg_value) } //------------------------------------------------------------------------- -/* -# -def dbg_read_memory(ea, sz): - """ - Reads from the debugee's memory at the specified ea - @return: - - The read buffer (as a string) - - Or None on failure - """ - pass -# -*/ static PyObject *dbg_read_memory(ea_t ea, size_t sz) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -278,41 +239,21 @@ static PyObject *dbg_read_memory(ea_t ea, size_t sz) } //------------------------------------------------------------------------- -/* -# -def dbg_write_memory(ea, buffer): - """ - Writes a buffer to the debugee's memory - @return: Boolean - """ - pass -# -*/ static PyObject *dbg_write_memory( ea_t ea, - const bytevec_t &buf) + const bytevec_t &buffer) { PYW_GIL_CHECK_LOCKED_SCOPE(); if ( !dbg_can_query(dbg) ) Py_RETURN_NONE; - if ( write_dbg_memory(ea, buf.begin(), buf.size()) != buf.size() ) + if ( write_dbg_memory(ea, buffer.begin(), buffer.size()) != buffer.size() ) Py_RETURN_FALSE; Py_RETURN_TRUE; } //------------------------------------------------------------------------- -/* -# -def dbg_get_name(): - """ - This function returns the current debugger's name. - @return: Debugger name or None if no debugger is active - """ - pass -# -*/ static PyObject *dbg_get_name() { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -324,18 +265,6 @@ static PyObject *dbg_get_name() } //------------------------------------------------------------------------- -/* -# -def dbg_get_memory_info(): - """ - This function returns the memory configuration of a debugged process. - @return: - None if no debugger is active - tuple(start_ea, end_ea, name, sclass, sbase, bitness, perm) - """ - pass -# -*/ static PyObject *dbg_get_memory_info() { PYW_GIL_CHECK_LOCKED_SCOPE(); diff --git a/pywraps/py_idd.py b/pywraps/py_idd.py index 817510a..4e33359 100644 --- a/pywraps/py_idd.py +++ b/pywraps/py_idd.py @@ -441,13 +441,13 @@ class Appcall__(object): def set_appcall_options(opt): """Method to change the Appcall options globally (not per Appcall)""" old_opt = Appcall__.get_appcall_options() - _ida_ida.cvar.inf.appcall_options = opt + _ida_ida.inf_set_appcall_options(opt) return old_opt @staticmethod def get_appcall_options(): """Return the global Appcall options""" - return _ida_ida.cvar.inf.appcall_options + return _ida_ida.inf_get_appcall_options() @staticmethod def cleanup_appcall(tid = 0): diff --git a/pywraps/py_idp.hpp b/pywraps/py_idp.hpp index f7b131b..d455743 100644 --- a/pywraps/py_idp.hpp +++ b/pywraps/py_idp.hpp @@ -6,24 +6,6 @@ //------------------------------------------------------------------------- //------------------------------------------------------------------------- -/* -# -def AssembleLine(ea, cs, ip, use32, line): - """ - 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 - """ - pass -# -*/ static PyObject *AssembleLine( ea_t ea, ea_t cs, @@ -31,31 +13,18 @@ static PyObject *AssembleLine( bool use32, const char *line) { - char buf[MAXSTR]; - int inslen = processor_t::assemble((uchar *)buf, ea, cs, ip, use32, line); - PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( inslen > 0 ) - return PyBytes_FromStringAndSize(buf, inslen); - else - Py_RETURN_NONE; + if ( line != nullptr ) + { + char buf[MAXSTR]; + int inslen = processor_t::assemble((uchar *)buf, ea, cs, ip, use32, line); + PYW_GIL_CHECK_LOCKED_SCOPE(); + if ( inslen > 0 ) + return PyBytes_FromStringAndSize(buf, inslen); + } + Py_RETURN_NONE; } //--------------------------------------------------------------------------- -/* -# -def assemble(ea, cs, ip, use32, line): - """ - 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. - """ -# -*/ bool assemble( ea_t ea, ea_t cs, @@ -78,226 +47,90 @@ bool assemble( } //------------------------------------------------------------------------- -/* -# -def ph_get_id(): - """ - Returns the 'ph.id' field - """ - pass -# -*/ static size_t ph_get_id() { return PH.id; } //------------------------------------------------------------------------- -/* -# -def ph_get_version(): - """ - Returns the 'ph.version' - """ - pass -# -*/ static size_t ph_get_version() { return PH.version; } //------------------------------------------------------------------------- -/* -# -def ph_get_flag(): - """ - Returns the 'ph.flag' - """ - pass -# -*/ static size_t ph_get_flag() { return PH.flag; } //------------------------------------------------------------------------- -/* -# -def ph_get_cnbits(): - """ - Returns the 'ph.cnbits' - """ - pass -# -*/ static size_t ph_get_cnbits() { return PH.cnbits; } //------------------------------------------------------------------------- -/* -# -def ph_get_dnbits(): - """ - Returns the 'ph.dnbits' - """ - pass -# -*/ static size_t ph_get_dnbits() { return PH.dnbits; } //------------------------------------------------------------------------- -/* -# -def ph_get_reg_first_sreg(): - """ - Returns the 'ph.reg_first_sreg' - """ - pass -# -*/ static size_t ph_get_reg_first_sreg() { return PH.reg_first_sreg; } //------------------------------------------------------------------------- -/* -# -def ph_get_reg_last_sreg(): - """ - Returns the 'ph.reg_last_sreg' - """ - pass -# -*/ static size_t ph_get_reg_last_sreg() { return PH.reg_last_sreg; } //------------------------------------------------------------------------- -/* -# -def ph_get_segreg_size(): - """ - Returns the 'ph.segreg_size' - """ - pass -# -*/ static size_t ph_get_segreg_size() { return PH.segreg_size; } //------------------------------------------------------------------------- -/* -# -def ph_get_reg_code_sreg(): - """ - Returns the 'ph.reg_code_sreg' - """ - pass -# -*/ static size_t ph_get_reg_code_sreg() { return PH.reg_code_sreg; } //------------------------------------------------------------------------- -/* -# -def ph_get_reg_data_sreg(): - """ - Returns the 'ph.reg_data_sreg' - """ - pass -# -*/ static size_t ph_get_reg_data_sreg() { return PH.reg_data_sreg; } //------------------------------------------------------------------------- -/* -# -def ph_get_icode_return(): - """ - Returns the 'ph.icode_return' - """ - pass -# -*/ static size_t ph_get_icode_return() { return PH.icode_return; } //------------------------------------------------------------------------- -/* -# -def ph_get_instruc_start(): - """ - Returns the 'ph.instruc_start' - """ - pass -# -*/ static size_t ph_get_instruc_start() { return PH.instruc_start; } //------------------------------------------------------------------------- -/* -# -def ph_get_instruc_end(): - """ - Returns the 'ph.instruc_end' - """ - pass -# -*/ static size_t ph_get_instruc_end() { return PH.instruc_end; } //------------------------------------------------------------------------- -/* -# -def ph_get_tbyte_size(): - """ - Returns the 'ph.tbyte_size' field as defined in he processor module - """ - pass -# -*/ static size_t ph_get_tbyte_size() { return PH.tbyte_size; } //------------------------------------------------------------------------- -/* -# -def ph_get_instruc(): - """ - Returns a list of tuples (instruction_name, instruction_feature) containing the - instructions list as defined in he processor module - """ - pass -# -*/ static PyObject *ph_get_instruc() { Py_ssize_t i = 0; @@ -314,15 +147,6 @@ static PyObject *ph_get_instruc() } //------------------------------------------------------------------------- -/* -# -def ph_get_regnames(): - """ - Returns the list of register names as defined in the processor module - """ - pass -# -*/ static PyObject *ph_get_regnames() { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -338,21 +162,7 @@ static const regval_t *idaapi _py_getreg( const char *name, const regval_t *regvals); -/* -# -def ph_get_operand_info(): - """ - 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. - """ - pass -# -*/ +//------------------------------------------------------------------------- static PyObject *ph_get_operand_info( ea_t ea, int n) @@ -369,7 +179,7 @@ static PyObject *ph_get_operand_info( // Allocate register space thid_t tid = get_current_thread(); regvals_t regvalues; - regvalues.resize(dbg->nregs); + regvalues.resize(dbg->nregisters); // Read registers if ( get_reg_vals(tid, -1, regvalues.begin()) != DRC_OK ) break; @@ -427,6 +237,15 @@ static ssize_t ph_get_reg_accesses( return processor_t::get_reg_accesses(accvec, insn, flags); } +//------------------------------------------------------------------------- +static ssize_t ph_get_abi_info( + qstrvec_t *abi_names, + qstrvec_t *abi_opts, + comp_t comp) +{ + return processor_t::get_abi_info(abi_names, abi_opts, comp); +} + //--------------------------------------------------------------------------- // IDP hooks //--------------------------------------------------------------------------- @@ -687,7 +506,7 @@ static const regval_t *idaapi _py_getreg( const char *name, const regval_t *regvals) { - for ( int i=dbg->nregs - 1; i >= 0; i-- ) + for ( int i=dbg->nregisters - 1; i >= 0; i-- ) { if ( strieq(name, dbg->regs(i).name) ) return ®vals[i]; diff --git a/pywraps/py_idp.py b/pywraps/py_idp.py index d90c8d5..ad99dae 100644 --- a/pywraps/py_idp.py +++ b/pywraps/py_idp.py @@ -54,10 +54,6 @@ class processor_t(IDP_Hooks): """ return '\x01'.join(map(lambda t: '\x01'.join(t), zip(self.plnames, self.psnames))) - def get_uFlag(self): - """Use this utility function to retrieve the 'uFlag' global variable""" - return ida_ua.cvar.uFlag - def get_auxpref(self, insn): """This function returns insn.auxpref value""" return insn.auxpref @@ -427,10 +423,14 @@ class __ph(object): tbyte_size = property(lambda self: ph_get_tbyte_size()) version = property(lambda self: ph_get_version()) +def str2sreg(name: str): + """get segment register number from its name or -1""" + rn = ph_get_regnames() + for i in range(ph_get_reg_first_sreg(), ph_get_reg_last_sreg()+1): + if name.lower()==rn[i].lower(): + return i + return -1 + ph = __ph() -class _idp_cvar_t: - ash = property(lambda self: get_ash()) -cvar = _idp_cvar_t() - # diff --git a/pywraps/py_ieee.hpp b/pywraps/py_ieee.hpp index d1b2bea..d4b951d 100644 --- a/pywraps/py_ieee.hpp +++ b/pywraps/py_ieee.hpp @@ -1,5 +1,4 @@ // -typedef bytevec_t bytevec12_t; -typedef bytevec_t bytevec10_t; +typedef bytevec_t bytevec16_t; // diff --git a/pywraps/py_ieee.py b/pywraps/py_ieee.py index 0cb7edf..274758a 100644 --- a/pywraps/py_ieee.py +++ b/pywraps/py_ieee.py @@ -5,7 +5,7 @@ # user mistakenly modifies it. # -EZERO = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" -EONE = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\xFF\x3F" -ETWO = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x40" +EZERO = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +EONE = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\xFF\x3F" +ETWO = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x40" # diff --git a/pywraps/py_kernwin.hpp b/pywraps/py_kernwin.hpp index b52a91d..74f5d46 100644 --- a/pywraps/py_kernwin.hpp +++ b/pywraps/py_kernwin.hpp @@ -22,7 +22,7 @@ struct py_idchotkey_ctx_t static ref_t py_colorizer; -static void py_ss_restore_callback(const char *err_msg, void *userdata); +static void py_snapshot_restore_callback(const char *err_msg, void *userdata); //------------------------------------------------------------------------ // @@ -33,27 +33,11 @@ static void py_ss_restore_callback(const char *err_msg, void *userdata); //------------------------------------------------------------------------ //------------------------------------------------------------------------ -/* -# -def register_timer(interval, callback): - """ - 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 - """ - pass -# -*/ -static PyObject *py_register_timer(int interval, PyObject *py_callback) +static PyObject *py_register_timer(int interval, PyObject *callback) { PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( py_callback == nullptr || !PyCallable_Check(py_callback) ) + if ( callback == nullptr || !PyCallable_Check(callback) ) Py_RETURN_NONE; // An inner class hosting the callback method @@ -82,7 +66,7 @@ static PyObject *py_register_timer(int interval, PyObject *py_callback) }; }; - py_timer_ctx_t *ctx = python_timer_new(py_callback); + py_timer_ctx_t *ctx = python_timer_new(callback); ctx->timer_id = register_timer( interval, tmr_t::callback, @@ -100,48 +84,24 @@ static PyObject *py_register_timer(int interval, PyObject *py_callback) } //------------------------------------------------------------------------ -/* -# -def unregister_timer(timer_obj): - """ - 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. - """ - pass -# -*/ -static bool py_unregister_timer(PyObject *py_timerctx) +static bool py_unregister_timer(PyObject *timer_obj) { PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( py_timerctx == nullptr || !PyCapsule_IsValid(py_timerctx, VALID_CAPSULE_NAME) ) + if ( timer_obj == nullptr || !PyCapsule_IsValid(timer_obj, VALID_CAPSULE_NAME) ) return false; - py_timer_ctx_t *ctx = (py_timer_ctx_t *) PyCapsule_GetPointer(py_timerctx, VALID_CAPSULE_NAME); + py_timer_ctx_t *ctx = (py_timer_ctx_t *) PyCapsule_GetPointer(timer_obj, VALID_CAPSULE_NAME); if ( ctx == nullptr || !unregister_timer(ctx->timer_id) ) return false; python_timer_del(ctx); // invalidate capsule; make sure we don't try and delete twice - PyCapsule_SetName(py_timerctx, INVALID_CAPSULE_NAME); + PyCapsule_SetName(timer_obj, INVALID_CAPSULE_NAME); return true; } //------------------------------------------------------------------------ -/* -# -def choose_idasgn(): - """ - Opens the signature chooser - - @return: None or the selected signature name - """ - pass -# -*/ static PyObject *py_choose_idasgn() { char *name = choose_idasgn(); @@ -159,29 +119,15 @@ static PyObject *py_choose_idasgn() } //------------------------------------------------------------------------ -/* -# -def get_highlight(v, flags=0): - """ - Returns the currently highlighted identifier and flags - - @param v: The UI widget to operate on - @param flags: Optionally specify a slot (see kernwin.hpp), current otherwise - @return: a tuple (text, flags), or None if nothing - is highlighted or in case of error. - """ - pass -# -*/ -static PyObject *py_get_highlight(TWidget *v, uint32 in_flags=0) +static PyObject *py_get_highlight(TWidget *v, uint32 flags=0) { qstring buf; - uint32 flags; - bool ok = get_highlight(&buf, v, &flags, in_flags); + uint32 lflags; + bool ok = get_highlight(&buf, v, &lflags, flags); PYW_GIL_CHECK_LOCKED_SCOPE(); if ( !ok ) Py_RETURN_NONE; - return Py_BuildValue("(sk)", buf.c_str(), flags); + return Py_BuildValue("(sk)", buf.c_str(), lflags); } //------------------------------------------------------------------------ @@ -203,98 +149,42 @@ static int py_load_custom_icon_data(PyObject *data, const char *format) } //------------------------------------------------------------------------ -/* -# -def free_custom_icon(icon_id): - """ - Frees an icon loaded with load_custom_icon() - """ - pass -# -*/ - -//------------------------------------------------------------------------- -/* -# -def read_selection(view, p0, p1): - """ - 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.read_selection(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. - """ - pass -# -*/ - -//------------------------------------------------------------------------ -static PyObject *py_msg(PyObject *o) +static int py_msg(const char *message) { - const char *utf8 = nullptr; - ref_t py_utf8; - if ( PyUnicode_Check(o) ) + int rc = 0; + if ( message != nullptr ) { - py_utf8 = newref_t(PyUnicode_AsUTF8String(o)); - if ( PyErr_Occurred() != nullptr ) - return nullptr; - utf8 = PyString_AsString(py_utf8.o); + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + rc = msg("%s", message); + SWIG_PYTHON_THREAD_END_ALLOW; } - else if ( PyString_Check(o) ) - { - utf8 = PyString_AsString(o); - } - else - { - PyErr_SetString(PyExc_TypeError, "A string expected"); - return nullptr; - } - int rc; - SWIG_PYTHON_THREAD_BEGIN_ALLOW; - rc = msg("%s", utf8); - SWIG_PYTHON_THREAD_END_ALLOW; - return PyInt_FromLong(rc); + return rc; } //------------------------------------------------------------------------ -/* -# -def ask_text(defval, prompt): - """ - Asks for a long text +static int py_warning(const char *message) +{ + int rc; + if ( message != nullptr ) + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + rc = warning("%s", message); + SWIG_PYTHON_THREAD_END_ALLOW; + } + return rc; +} - @param max_size: Maximum text length, 0 for unlimited - @param defval: The default value - @param prompt: The prompt value - @return: None or the entered string - """ - pass -# -*/ +//------------------------------------------------------------------------ +static void py_error(const char *message) +{ + if ( message != nullptr ) + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + error("%s", message); + } +} + +//------------------------------------------------------------------------ PyObject *py_ask_text(size_t max_size, const char *defval, const char *prompt) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -315,20 +205,6 @@ PyObject *py_ask_text(size_t max_size, const char *defval, const char *prompt) } //------------------------------------------------------------------------ -/* -# -def ask_str(defval, hist, prompt): - """ - Asks for a long text - - @param hist: history id - @param defval: The default value - @param prompt: The prompt value - @return: None or the entered string - """ - pass -# -*/ PyObject *py_ask_str(qstring *defval, int hist, const char *prompt) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -347,80 +223,40 @@ PyObject *py_ask_str(qstring *defval, int hist, const char *prompt) } //------------------------------------------------------------------------ -/* -# -def process_ui_action(name): - """ - Invokes an IDA UI action by name - - @param name: action name - @return: Boolean - """ - pass -# -*/ static bool py_process_ui_action(const char *name, int flags = 0) { return process_ui_action(name, flags, nullptr); } //------------------------------------------------------------------------ -/* -# -def del_hotkey(ctx): - """ - Deletes a previously registered function hotkey - - @param ctx: Hotkey context previously returned by add_hotkey() - - @return: Boolean. - """ - pass -# -*/ -bool py_del_hotkey(PyObject *pyctx) +bool py_del_hotkey(PyObject *ctx) { PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( !PyCapsule_IsValid(pyctx, VALID_CAPSULE_NAME) ) + if ( !PyCapsule_IsValid(ctx, VALID_CAPSULE_NAME) ) return false; - py_idchotkey_ctx_t *ctx = (py_idchotkey_ctx_t *) PyCapsule_GetPointer(pyctx, VALID_CAPSULE_NAME); - if ( ctx == nullptr || !unregister_action(ctx->action_name.c_str()) ) + py_idchotkey_ctx_t *_ctx = (py_idchotkey_ctx_t *) PyCapsule_GetPointer(ctx, VALID_CAPSULE_NAME); + if ( _ctx == nullptr || !unregister_action(_ctx->action_name.c_str()) ) return false; - delete ctx; + delete _ctx; // invalidate capsule; make sure we don't try and delete twice - PyCapsule_SetName(pyctx, INVALID_CAPSULE_NAME); + PyCapsule_SetName(ctx, INVALID_CAPSULE_NAME); return true; } //------------------------------------------------------------------------ -/* -# -def add_hotkey(hotkey, pyfunc): - """ - 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. - """ - pass -# -*/ -PyObject *py_add_hotkey(const char *hotkey, PyObject *pyfunc) +PyObject *py_add_hotkey(const char *hotkey, PyObject *callable) { PYW_GIL_CHECK_LOCKED_SCOPE(); // Make sure a callable was passed - if ( !PyCallable_Check(pyfunc) ) + if ( !PyCallable_Check(callable) ) return nullptr; // Form the function name qstring idc_func_name; - idc_func_name.sprnt("py_hotkeycb_%p", pyfunc); + idc_func_name.sprnt("py_hotkeycb_%p", callable); // Can add the hotkey? if ( add_idc_hotkey(hotkey, idc_func_name.c_str()) == IDCHK_OK ) @@ -429,7 +265,7 @@ PyObject *py_add_hotkey(const char *hotkey, PyObject *pyfunc) { // Generate global variable name qstring idc_gvarname; - idc_gvarname.sprnt("_g_pyhotkey_ref_%p", pyfunc); + idc_gvarname.sprnt("_g_pyhotkey_ref_%p", callable); // Now add the global variable idc_value_t *gvar = add_idc_gvar(idc_gvarname.c_str()); @@ -450,10 +286,10 @@ PyObject *py_add_hotkey(const char *hotkey, PyObject *pyfunc) break; // Create new context - py_idchotkey_ctx_t *ctx = new py_idchotkey_ctx_t(idc_func_name.c_str(), pyfunc); + py_idchotkey_ctx_t *ctx = new py_idchotkey_ctx_t(idc_func_name.c_str(), callable); // Bind IDC variable w/ the PyCallable - gvar->set_pvoid(pyfunc); + gvar->set_pvoid(callable); // Return the context return PyCapsule_New(ctx, VALID_CAPSULE_NAME, nullptr); @@ -465,13 +301,13 @@ PyObject *py_add_hotkey(const char *hotkey, PyObject *pyfunc) } //------------------------------------------------------------------------ -static PyObject *py_take_database_snapshot(snapshot_t *ss) +static PyObject *py_take_database_snapshot(snapshot_t *snapshot) { PYW_GIL_CHECK_LOCKED_SCOPE(); qstring err_msg; - bool b = take_database_snapshot(ss, &err_msg); + bool b = take_database_snapshot(snapshot, &err_msg); // Return (b, err_msg) return Py_BuildValue("(Ns)", PyBool_FromLong(b), err_msg.empty() ? nullptr : err_msg.c_str()); @@ -479,33 +315,33 @@ static PyObject *py_take_database_snapshot(snapshot_t *ss) //------------------------------------------------------------------------- static PyObject *py_restore_database_snapshot( - const snapshot_t *ss, - PyObject *pyfunc_or_none, - PyObject *pytuple_or_none) + const snapshot_t *snapshot, + PyObject *callback, + PyObject *userdata) { PYW_GIL_CHECK_LOCKED_SCOPE(); // If there is no callback, just call the function directly - if ( pyfunc_or_none == Py_None ) - return PyBool_FromLong(restore_database_snapshot(ss, nullptr, nullptr)); + if ( callback == Py_None ) + return PyBool_FromLong(restore_database_snapshot(snapshot, nullptr, nullptr)); - // Create a new tuple or increase reference to pytuple_or_none - if ( pytuple_or_none == Py_None ) + // Create a new tuple or increase reference to userdata + if ( userdata == Py_None ) { - pytuple_or_none = PyTuple_New(0); - if ( pytuple_or_none == nullptr ) + userdata = PyTuple_New(0); + if ( userdata == nullptr ) return nullptr; } else { - Py_INCREF(pytuple_or_none); + Py_INCREF(userdata); } - // Create callback data tuple (use 'N' for pytuple_or_none, since its + // Create callback data tuple (use 'N' for userdata, since its // reference has already been incremented) - PyObject *cb_data = Py_BuildValue("(ON)", pyfunc_or_none, pytuple_or_none); + PyObject *cb_data = Py_BuildValue("(ON)", callback, userdata); - bool b = restore_database_snapshot(ss, py_ss_restore_callback, (void *) cb_data); + bool b = restore_database_snapshot(snapshot, py_snapshot_restore_callback, (void *) cb_data); if ( !b ) Py_DECREF(cb_data); @@ -514,64 +350,23 @@ static PyObject *py_restore_database_snapshot( } //------------------------------------------------------------------------ -/* -# - -MFF_FAST = 0x0000 -"""execute code as soon as possible -this mode is ok call ui related functions -that do not query the database.""" - -MFF_READ = 0x0001 -"""execute code only when ida is idle and it is safe to query the database. -this mode is recommended only for code that does not modify the database. -(nb: ida may be in the middle of executing another user request, for example it may be waiting for him to enter values into a modal dialog box)""" - -MFF_WRITE = 0x0002 -"""execute code only when ida is idle and it is safe to modify the database. in particular, this flag will suspend execution if there is -a modal dialog box on the screen this mode can be used to call any ida api function. MFF_WRITE implies MFF_READ""" - -MFF_NOWAIT = 0x0004 -"""Do not wait for the request to be executed. -he caller should ensure that the request is not -destroyed until the execution completes. -if not, the request will be ignored. -the return code of execute_sync() is meaningless -in this case. -This flag can be used to delay the code execution -until the next UI loop run even from the main thread""" - -def execute_sync(callable, reqf): - """ - 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. - - @param callable: A python callable object, must return an integer value - @param reqf: one of MFF_ flags - @return: -1 or the return value of the callable - """ - pass -# -*/ -//------------------------------------------------------------------------ -static int py_execute_sync(PyObject *py_callable, int reqf) +static ssize_t py_execute_sync(PyObject *callable, int reqf) { PYW_GIL_CHECK_LOCKED_SCOPE(); - int rc = -1; + ssize_t rc = -1; // Callable? - if ( PyCallable_Check(py_callable) ) + if ( PyCallable_Check(callable) ) { struct py_exec_request_t : exec_request_t { ref_t py_callable; - virtual int idaapi execute() override + virtual ssize_t idaapi execute() override { PYW_GIL_GET; newref_t py_result(PyObject_CallFunctionObjArgs(py_callable.o, nullptr)); - int ret = !py_result || !PyLong_Check(py_result.o) - ? -1 - : PyLong_AsLong(py_result.o); + ssize_t ret = !py_result || !PyLong_Check(py_result.o) + ? -1 + : PyLong_AsLong(py_result.o); // if the requesting thread decided not to wait for the request to // complete, we have to self-destroy, nobody else will do it if ( (code & MFF_NOWAIT) != 0 ) @@ -592,7 +387,7 @@ static int py_execute_sync(PyObject *py_callable, int reqf) py_callable = ref_t(); // Release callable } }; - py_exec_request_t *req = new py_exec_request_t(py_callable); + py_exec_request_t *req = new py_exec_request_t(callable); // Release GIL before executing, or if this is running in the // non-main thread, this will wait on the req.sem, while the main @@ -609,23 +404,7 @@ static int py_execute_sync(PyObject *py_callable, int reqf) } //------------------------------------------------------------------------ -/* -# - -def execute_ui_requests(callable_list): - """ - 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 callable item - """ - pass -# -*/ -static bool py_execute_ui_requests(PyObject *py_list) +static bool py_execute_ui_requests(PyObject *callable_list) { struct py_ui_request_t: public ui_request_t { @@ -633,7 +412,7 @@ static bool py_execute_ui_requests(PyObject *py_list) ref_vec_t py_callables; size_t py_callable_idx; - static int idaapi s_py_list_walk_cb( + static int idaapi s_callable_list_walk_cb( const ref_t &py_item, Py_ssize_t /*index*/, void *ud) @@ -683,11 +462,11 @@ static bool py_execute_ui_requests(PyObject *py_list) } // Walk the list and extract all callables - bool init(PyObject *py_list) + bool init(PyObject *callable_list) { Py_ssize_t count = pyvar_walk_seq( - py_list, - s_py_list_walk_cb, + callable_list, + s_callable_list_walk_cb, this); return count > 0; } @@ -700,7 +479,7 @@ static bool py_execute_ui_requests(PyObject *py_list) }; py_ui_request_t *req = new py_ui_request_t(); - if ( !req->init(py_list) ) + if ( !req->init(callable_list) ) { delete req; return false; @@ -710,38 +489,6 @@ static bool py_execute_ui_requests(PyObject *py_list) } //------------------------------------------------------------------------ -/* -# -def set_dock_pos(src, dest, orient, left = 0, top = 0, right = 0, bottom = 0): - """ - Sets the dock orientation of a window relatively to another window. - - Use the left, top, right, bottom parameters if DP_FLOATING is used, - or if you want to specify the width of docked windows. - - @param src: Source docking control - @param dest: Destination docking control - @param orient: One of DP_XXXX constants - @return: Boolean - - Example: - set_dock_pos('Structures', 'Enums', DP_RIGHT) <- docks the Structures window to the right of Enums window - """ - pass -# -*/ - -//------------------------------------------------------------------------ -/* -# -def is_idaq(): - """ - Returns True or False depending if IDAPython is hosted by IDAQ - """ -# -*/ - - struct jobj_wrapper_t { private: @@ -889,33 +636,6 @@ PyObject *py_get_registered_actions() } //------------------------------------------------------------------------- -/* -# -def attach_dynamic_action_to_popup( - unused, - popup_handle, - desc, - popuppath = None, - flags = 0): - """ - Create & insert an action into the widget's popup menu - (::ui_attach_dynamic_action_to_popup). - Note: The action description in the 'desc' parameter is modified by - this call so you should prepare a new description for each call. - For example: - desc = idaapi.action_desc_t(None, 'Dynamic popup action', Handler()) - idaapi.attach_dynamic_action_to_popup(form, popup, desc) - - @param unused: deprecated; should be None - @param popup_handle: target popup - @param desc: action description of type action_desc_t - @param popuppath: can be None - @param flags: a combination of SETMENU_ constants - @return: success - """ - pass -# -*/ bool py_attach_dynamic_action_to_popup( TWidget *unused, TPopupMenu *popup_handle, @@ -1001,40 +721,8 @@ void py_gen_disasm_text(disasm_text_t &text, ea_t ea1, ea_t ea2, bool truncate_l } } -/* -# -def set_nav_colorizer(callback): - """ - Set a new colorizer for the navigation band. - - The 'callback' is a function of 2 arguments: - - ea (the EA to colorize for) - - nbytes (the number of bytes at that EA) - and must return a 'long' value. - - The previous colorizer is returned, allowing - the new 'callback' to use 'call_nav_colorizer' - with it. - - Note that the previous colorizer is returned - only the first time set_nav_colorizer() is called: - due to the way the colorizers API is defined in C, - it is impossible to chain more than 2 colorizers - in IDAPython: the original, IDA-provided colorizer, - and a user-provided one. - - Example: colorizer inverting the color provided by the IDA colorizer: - def my_colorizer(ea, nbytes): - global ida_colorizer - orig = idaapi.call_nav_colorizer(ida_colorizer, ea, nbytes) - return long(~orig) - - ida_colorizer = idaapi.set_nav_colorizer(my_colorizer) - """ - pass -# -*/ -PyObject *py_set_nav_colorizer(PyObject *new_py_colorizer) +//------------------------------------------------------------------------- +PyObject *py_set_nav_colorizer(PyObject *callback) { struct ida_local lambda_t { @@ -1087,7 +775,7 @@ PyObject *py_set_nav_colorizer(PyObject *new_py_colorizer) // Always perform the call to set_nav_colorizer(): that has side-effects // (e.g., updating the legend.) bool first_install = py_colorizer == nullptr; - py_colorizer = borref_t(new_py_colorizer); + py_colorizer = borref_t(callback); nav_colorizer_t *was_fun = nullptr; void *was_ud = nullptr; set_nav_colorizer(&was_fun, &was_ud, lambda_t::call_py_colorizer, nullptr); @@ -1102,25 +790,15 @@ PyObject *py_set_nav_colorizer(PyObject *new_py_colorizer) } //------------------------------------------------------------------------- -/* -# -def call_nav_colorizer(colorizer, ea, nbytes): - """ - To be used with the IDA-provided colorizer, that is - returned as result of the first call to set_nav_colorizer(). - """ - pass -# -*/ uint32 py_call_nav_colorizer( - PyObject *dict, + PyObject *colorizer, ea_t ea, asize_t nbytes) { - if ( !PyDict_Check(dict) ) + if ( !PyDict_Check(colorizer) ) return 0; - borref_t py_fun(PyDict_GetItemString(dict, "fun")); - borref_t py_ud(PyDict_GetItemString(dict, "ud")); + borref_t py_fun(PyDict_GetItemString(colorizer, "fun")); + borref_t py_ud(PyDict_GetItemString(colorizer, "ud")); if ( !py_fun || !PyCapsule_IsValid(py_fun.o, VALID_CAPSULE_NAME) || !PyCapsule_IsValid(py_ud.o, VALID_CAPSULE_NAME) ) @@ -1134,6 +812,7 @@ uint32 py_call_nav_colorizer( return fun(ea, nbytes, ud); } +//------------------------------------------------------------------------- PyObject *py_msg_get_lines(int count=-1) { qstrvec_t lines; @@ -1141,43 +820,7 @@ PyObject *py_msg_get_lines(int count=-1) return qstrvec2pylist(lines); } -/* -# -def msg(message): - """ - 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 message: message to print (formatting is done in Python) - - This function can be used to debug IDAPython scripts - """ - pass - -def warning(message): - """ - Display a message in a message box - - @param message: message to print (formatting is done in Python) - - This function can be used to debug IDAPython scripts - The user will be able to hide messages if they appear twice in a row on - the screen - """ - pass - -def error(format): - """ - Display a fatal message in a message box and quit IDA - - @param format: message to print - """ - pass -# -*/ - +//------------------------------------------------------------------------- static TWidget *TWidget__from_ptrval__(size_t ptrval) { return (TWidget *) ptrval; @@ -1186,7 +829,7 @@ static TWidget *TWidget__from_ptrval__(size_t ptrval) // we limit the the number of spaces that can be added to 512k #define MAX_SPACES_ADDED 524288 //------------------------------------------------------------------------- -static PyObject *py_add_spaces(const char *s, size_t len) +static qstring py_add_spaces(const char *s, size_t len) { qstring qbuf(s); const size_t slen = tag_strlen(qbuf.c_str()); @@ -1203,7 +846,7 @@ static PyObject *py_add_spaces(const char *s, size_t len) // we use the actual 'size' because we know that // 'add_spaces()' will add a terminating zero anyway add_spaces(qbuf.begin(), qbuf.size(), len); - return PyUnicode_FromString(qbuf.c_str()); + return qbuf; } //------------------------------------------------------------------------- @@ -1247,7 +890,7 @@ bool idaapi py_menu_item_callback(void *userdata) PyObject *args = PyTuple_GetItem(o, 1); // Call the python function - newref_t result(PyEval_CallObject(func, args)); + newref_t result(PyObject_Call(func, args, nullptr)); // We cannot raise an exception in the callback, just print it. if ( result == nullptr ) @@ -1272,7 +915,7 @@ static void ida_kernwin_term(void) static void ida_kernwin_closebase(void) {} //------------------------------------------------------------------------ -static void py_ss_restore_callback(const char *err_msg, void *userdata) +static void py_snapshot_restore_callback(const char *err_msg, void *userdata) { PYW_GIL_GET; @@ -1290,7 +933,7 @@ static void py_ss_restore_callback(const char *err_msg, void *userdata) PyObject *cb_args = Py_BuildValue("(sO)", err_msg, args); // Call the python function - newref_t result(PyEval_CallObject(func, cb_args)); + newref_t result(PyObject_Call(func, cb_args, nullptr)); // Free cb_args and userdata Py_DECREF(cb_args); @@ -1300,20 +943,6 @@ static void py_ss_restore_callback(const char *err_msg, void *userdata) if ( !result ) PyErr_Print(); } - -/* -# -def get_navband_pixel(ea): - """ - Maps an address, onto a pixel coordinate within the navigation band - - @param ea: The address to map - @return: a list [pixel, is_vertical] - """ - pass -# -*/ - // #endif diff --git a/pywraps/py_kernwin.py b/pywraps/py_kernwin.py index f98d5d6..fc81540 100644 --- a/pywraps/py_kernwin.py +++ b/pywraps/py_kernwin.py @@ -136,4 +136,16 @@ ida_ida.__wrap_hooks_callback( from ida_pro import str2user SETMENU_IF_ENABLED = 4 +# bw-compat (flag removed in IDA 8.4): +CH_NOIDB = CH_UNUSED + +BWN_TILVIEW = BWN_TICSR +IWID_TILVIEW = IWID_TICSR + +BWN_LOCTYPS = BWN_TILVIEW +IWID_LOCTYPS = IWID_TILVIEW + +BWN_DISASMS = BWN_DISASM +IWID_DISASMS = IWID_DISASM + # diff --git a/pywraps/py_kernwin_askform.hpp b/pywraps/py_kernwin_askform.hpp index cbbbd87..511229c 100644 --- a/pywraps/py_kernwin_askform.hpp +++ b/pywraps/py_kernwin_askform.hpp @@ -9,7 +9,7 @@ #define DECLARE_FORM_ACTIONS form_actions_t *fa = (form_actions_t *)p_fa; #ifdef TESTABLE_BUILD -#include +idaman void ida_export add_test_feature(const char *name); #endif //--------------------------------------------------------------------------- static bool textctrl_info_t_assign(PyObject *self, PyObject *other) @@ -171,7 +171,7 @@ static PyObject *formchgcbfa_get_field_value( { uval_t val; if ( fa->get_unsigned_value(fid, &val) ) - return PyLong_FromUnsignedLong(val); + return PyLong_FromUnsignedLong(val & 0xFFFFFFFF); break; } // ushort diff --git a/pywraps/py_kernwin_askform.py b/pywraps/py_kernwin_askform.py index 45a1907..cf1b951 100644 --- a/pywraps/py_kernwin_askform.py +++ b/pywraps/py_kernwin_askform.py @@ -205,8 +205,8 @@ class Form(object): @param tp: One of Form.FT_XXX """ DefI64 = False - def __init__(self, tp, value): - cls = Form.fieldtype_to_ctype(tp, self.DefI64) + def __init__(self, tp, value, i64=None): + cls = Form.fieldtype_to_ctype(tp, i64 if i64 is not None else self.DefI64) if cls is None: raise TypeError("Invalid numeric field type: %s" % tp) # Get a pointer type to the ctype type @@ -513,12 +513,13 @@ class Form(object): width=50, swidth=10, hlp=None, - is_relative_offset=False): + is_relative_offset=False, + i64=None): if tp is None: tp = Form.FT_HEX Form.InputControl.__init__(self, tp, width, swidth, hlp, is_relative_offset) - Form.NumericArgument.__init__(self, self.tp, value) + Form.NumericArgument.__init__(self, self.tp, value, i64=i64) class ColorInput(NumericInput): @@ -529,7 +530,7 @@ class Form(object): """ @param value: Initial color value in RGB """ - Form.NumericInput.__init__(self, tp=Form.FT_COLOR, value=value) + Form.NumericInput.__init__(self, tp=Form.FT_COLOR, value=value, i64=False) class StringInput(InputControl, StringArgument): diff --git a/pywraps/py_kernwin_choose.hpp b/pywraps/py_kernwin_choose.hpp index afc0541..8d1f2ac 100644 --- a/pywraps/py_kernwin_choose.hpp +++ b/pywraps/py_kernwin_choose.hpp @@ -984,10 +984,10 @@ PyObject *choose_choose(PyObject *self); void choose_activate(PyObject *self); PyObject *choose_create_embedded_chobj(PyObject *self); -PyObject *py_get_chooser_data(const char *chooser_caption, int n) +PyObject *py_get_chooser_data(const char *title, int n) { qstrvec_t data; - if ( !get_chooser_data(&data, chooser_caption, n) ) + if ( !get_chooser_data(&data, title, n) ) Py_RETURN_NONE; ref_t py_list_ref = PyW_StrVecToPyList(data); py_list_ref.incref(); diff --git a/pywraps/py_kernwin_cli.hpp b/pywraps/py_kernwin_cli.hpp index 58ec0d7..54e7595 100644 --- a/pywraps/py_kernwin_cli.hpp +++ b/pywraps/py_kernwin_cli.hpp @@ -10,12 +10,6 @@ struct py_cli_cbs_t { bool (idaapi *execute_line)(const char *line); - bool (idaapi *complete_line)( - qstring *completion, - const char *prefix, - int n, - const char *line, - int x); bool (idaapi *keydown)( qstring *line, int *p_x, @@ -24,6 +18,8 @@ struct py_cli_cbs_t int shift); bool (idaapi *find_completions)( qstrvec_t *out_completions, + qstrvec_t *out_hints, + qstrvec_t *out_docs, int *out_match_start, int *out_match_end, const char *line, @@ -52,13 +48,9 @@ private: { \ return py_clis[CBN]->on_execute_line(line); \ } \ - static bool idaapi s_complete_line##CBN(qstring *completion, const char *prefix, int n, const char *line, int x) \ + static bool idaapi s_find_completions##CBN(qstrvec_t *completions, qstrvec_t *hints, qstrvec_t *docs, int *out_start, int *out_end, const char *line, int x) \ { \ - return py_clis[CBN]->on_complete_line(completion, prefix, n, line, x); \ - } \ - static bool idaapi s_find_completions##CBN(qstrvec_t *completions, int *out_start, int *out_end, const char *line, int x) \ - { \ - return py_clis[CBN]->on_find_completions(completions, out_start, out_end, line, x); \ + return py_clis[CBN]->on_find_completions(completions, hints, docs, out_start, out_end, line, x); \ } IMPL_PY_CLI_CB(0); IMPL_PY_CLI_CB(1); IMPL_PY_CLI_CB(2); IMPL_PY_CLI_CB(3); @@ -147,42 +139,13 @@ private: return ok; } - // callback: the user pressed Tab - // Find a completion number N for prefix PREFIX - // LINE is given as context information. X is the index where PREFIX starts in LINE - // New prefix should be stored in PREFIX. - // Returns: true if generated a new completion - // This callback is optional - bool on_complete_line( - qstring *completion, - const char *prefix, - int n, - const char *line, - int x) - { - PYW_GIL_GET; - newref_t result( - PyObject_CallMethod( - self, - (char *)S_ON_COMPLETE_LINE, - "sisi", - prefix, - n, - line, - x)); - - bool ok = result && PyUnicode_Check(result.o); - PyW_ShowCbErr(S_ON_COMPLETE_LINE); - if ( ok ) - PyUnicode_as_qstring(completion, result.o); - return ok; - } - // callback: the user pressed Tab // Find completions // This callback is optional bool on_find_completions( qstrvec_t *out_completions, + qstrvec_t *out_hints, + qstrvec_t *out_docs, int *out_match_start, int *out_match_end, const char *line, @@ -200,7 +163,7 @@ private: if ( PyErr_Occurred() != nullptr ) return false; return idapython_convert_cli_completions( - out_completions, out_match_start, out_match_end, py_res); + out_completions, out_hints, out_docs, out_match_start, out_match_end, py_res); } // Private ctor (use bind()) @@ -262,7 +225,6 @@ public: if ( !PyObject_HasAttrString(py_obj, S_ON_EXECUTE_LINE) ) break; py_cli->cli.execute_line = py_cli_cbs[cli_idx].execute_line; - py_cli->cli.unused = (void *) (PyObject_HasAttrString(py_obj, S_ON_COMPLETE_LINE) ? py_cli_cbs[cli_idx].complete_line : nullptr); py_cli->cli.keydown = PyObject_HasAttrString(py_obj, S_ON_KEYDOWN) ? py_cli_cbs[cli_idx].keydown : nullptr; py_cli->cli.find_completions = PyObject_HasAttrString(py_obj, S_ON_FIND_COMPLETIONS) ? py_cli_cbs[cli_idx].find_completions : nullptr; @@ -305,7 +267,7 @@ public: } }; py_cli_t *py_cli_t::py_clis[MAX_PY_CLI] = { nullptr }; -#define DECL_PY_CLI_CB(CBN) { s_execute_line##CBN, s_complete_line##CBN, s_keydown##CBN } +#define DECL_PY_CLI_CB(CBN) { s_execute_line##CBN, s_keydown##CBN, s_find_completions##CBN } const py_cli_cbs_t py_cli_t::py_cli_cbs[MAX_PY_CLI] = { DECL_PY_CLI_CB(0), DECL_PY_CLI_CB(1), DECL_PY_CLI_CB(2), DECL_PY_CLI_CB(3), diff --git a/pywraps/py_kernwin_cli.py b/pywraps/py_kernwin_cli.py index 6f20f12..37f3cba 100644 --- a/pywraps/py_kernwin_cli.py +++ b/pywraps/py_kernwin_cli.py @@ -82,18 +82,18 @@ class cli_t(ida_idaapi.pyidc_opaque_object_t): """ return None - def OnCompleteLine(self, prefix, n, line, prefix_start): + def OnFindCompletions(self, line, x): """ - The user pressed Tab. Find a completion number N for prefix PREFIX + The user pressed Tab. Return a list of completions This callback is optional. - @param prefix: Line prefix at prefix_start (string) - @param n: completion number (int) @param line: the current line (string) - @param prefix_start: the index where PREFIX starts in LINE (int) + @param x: the index where the cursor is (int) - @return: None if no completion could be generated otherwise a String with the completion suggestion + @return: None if no completion could be generated, otherwise a tuple: + (completions : Sequence[str], hints : Sequence[str], docs: Sequence[str], + match_start: int, match_end: int) """ return None diff --git a/pywraps/py_kernwin_custview.py b/pywraps/py_kernwin_custview.py index 9bd135e..2a0ad45 100644 --- a/pywraps/py_kernwin_custview.py +++ b/pywraps/py_kernwin_custview.py @@ -181,69 +181,4 @@ class simplecustviewer_t(object): """ return _ida_kernwin.pyscv_get_widget(self.__this) - - - # Here are all the supported events -# -# def OnClick(self, shift): -# """ -# User clicked in the view -# @param shift: Shift flag -# @return: Boolean. True if you handled the event -# """ -# print("OnClick, shift=%d" % shift) -# return True -# -# def OnDblClick(self, shift): -# """ -# User dbl-clicked in the view -# @param shift: Shift flag -# @return: Boolean. True if you handled the event -# """ -# print("OnDblClick, shift=%d" % shift) -# return True -# -# def OnCursorPosChanged(self): -# """ -# Cursor position changed. -# @return: Nothing -# """ -# print("OnCurposChanged") -# -# def OnClose(self): -# """ -# The view is closing. Use this event to cleanup. -# @return: Nothing -# """ -# print("OnClose") -# -# def OnKeydown(self, vkey, shift): -# """ -# User pressed a key -# @param vkey: Virtual key code -# @param shift: Shift flag -# @return: Boolean. True if you handled the event -# """ -# print("OnKeydown, vk=%d shift=%d" % (vkey, shift)) -# return False -# -# def OnHint(self, lineno): -# """ -# Hint requested for the given line number. -# @param lineno: The line number (zero based) -# @return: -# - tuple(number of important lines, hint string) -# - None: if no hint available -# """ -# return (1, "OnHint, line=%d" % lineno) -# -# def OnPopupMenu(self, menu_id): -# """ -# A context (or popup) menu item was executed. -# @param menu_id: ID previously registered with add_popup_menu() -# @return: Boolean -# """ -# print("OnPopupMenu, menu_id=" % menu_id) -# return True -# # diff --git a/pywraps/py_kernwin_end.py b/pywraps/py_kernwin_end.py new file mode 100644 index 0000000..1dfe3d9 --- /dev/null +++ b/pywraps/py_kernwin_end.py @@ -0,0 +1,5 @@ +# +place_t_as_idaplace_t = place_t.as_idaplace_t +place_t_as_simpleline_place_t = place_t.as_simpleline_place_t +place_t_as_tiplace_t = place_t.as_tiplace_t +# diff --git a/pywraps/py_kernwin_plgform.py b/pywraps/py_kernwin_plgform.py index 5bc1f14..516f71e 100644 --- a/pywraps/py_kernwin_plgform.py +++ b/pywraps/py_kernwin_plgform.py @@ -91,23 +91,30 @@ class PluginForm(object): VALID_CAPSULE_NAME = b"$valid$" @staticmethod - def TWidgetToPyQtWidget(tw, ctx = sys.modules['__main__']): + def TWidgetToQtPythonWidget(tw, ctx = sys.modules['__main__']): """ - Convert a TWidget* to a QWidget to be used by PyQt - - @param ctx: Context. Reference to a module that already imported SIP and QtWidgets modules + Convert a TWidget* to a QWidget to be used by the Qt Python bindings """ - if type(tw).__name__ == "SwigPyObject": - ptr_l = ida_idaapi.long_type(tw) + if type(tw).__name__ == 'SwigPyObject': + ptr_l = int(tw) else: import ctypes ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p] ptr_l = ctypes.pythonapi.PyCapsule_GetPointer(tw, PluginForm.VALID_CAPSULE_NAME) - PluginForm._ensure_widget_deps(ctx) - vptr = ctx.sip.voidptr(ptr_l) - return ctx.sip.wrapinstance(vptr.__int__(), ctx.QtWidgets.QWidget) - FormToPyQtWidget = TWidgetToPyQtWidget + + try: + import shiboken6.Shiboken + import PySide6.QtWidgets + return shiboken6.Shiboken.wrapInstance(ptr_l, PySide6.QtWidgets.QWidget) + except ImportError: + # Assume PyQt5 + PluginForm._ensure_widget_deps(ctx) + vptr = ctx.sip.voidptr(ptr_l) + return ctx.sip.wrapinstance(vptr.__int__(), ctx.QtWidgets.QWidget) + + TWidgetToPyQtWidget = TWidgetToQtPythonWidget + FormToPyQtWidget = TWidgetToQtPythonWidget @staticmethod diff --git a/pywraps/py_lines.hpp b/pywraps/py_lines.hpp index 6c034a5..d98f194 100644 --- a/pywraps/py_lines.hpp +++ b/pywraps/py_lines.hpp @@ -1,92 +1,26 @@ #ifndef __PYWRAPS__LINES__ #define __PYWRAPS__LINES__ -// -//------------------------------------------------------------------------ -static PyObject *py_get_user_defined_prefix = nullptr; -static void idaapi s_py_get_user_defined_prefix( - qstring *buf, - ea_t ea, - int lnnum, - int indent, - const char *line) -{ - PYW_GIL_GET; - newref_t py_ret( - PyObject_CallFunction( - py_get_user_defined_prefix, - PY_BV_EA "iis" PY_BV_SZ, - bvea_t(ea), lnnum, indent, line, 0)); - - // Error? Display it - // No error? Copy the buffer - if ( !PyW_ShowCbErr("py_get_user_defined_prefix") ) - PyUnicode_as_qstring(buf, py_ret.o); -} -// - //------------------------------------------------------------------------ // -//------------------------------------------------------------------------ -/* -# -def set_user_defined_prefix(width, callback): - """ - Deprecated. Please use install_user_defined_prefix() instead - """ - pass -# -*/ -static PyObject *py_set_user_defined_prefix(size_t width, PyObject *pycb) -{ - PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( width == 0 || pycb == Py_None ) - { - // Release old callback reference - Py_XDECREF(py_get_user_defined_prefix); - - // ...and clear it - py_get_user_defined_prefix = nullptr; - - // Uninstall user defind prefix - set_user_defined_prefix(0, nullptr); - } - else if ( PyCallable_Check(pycb) ) - { - // Release old callback reference - Py_XDECREF(py_get_user_defined_prefix); - - // Copy new callback and hold a reference - py_get_user_defined_prefix = pycb; - Py_INCREF(py_get_user_defined_prefix); - - set_user_defined_prefix(width, s_py_get_user_defined_prefix); - } - else - { - Py_RETURN_FALSE; - } - Py_RETURN_TRUE; -} - //------------------------------------------------------------------------- -PyObject *py_tag_remove(const char *str) +qstring py_tag_remove(const char *str) { PYW_GIL_CHECK_LOCKED_SCOPE(); qstring qbuf; tag_remove(&qbuf, str); - return PyUnicode_FromString(qbuf.c_str()); + return qbuf; } //------------------------------------------------------------------------- -PyObject *py_tag_addr(ea_t ea) +qstring py_tag_addr(ea_t ea) { qstring tag; tag_addr(&tag, ea); PYW_GIL_CHECK_LOCKED_SCOPE(); - return PyUnicode_FromString(tag.begin()); + return tag; } //------------------------------------------------------------------------- @@ -108,23 +42,6 @@ int py_tag_advance(const char *line, int cnt) } //------------------------------------------------------------------------- -/* -# -def generate_disassembly(ea, max_lines, as_stack, notags): - """ - 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, list(lines)) : Returns a tuple containing - the most important line number and a list of generated lines - """ - pass -# -*/ PyObject *py_generate_disassembly( ea_t ea, int max_lines, diff --git a/pywraps/py_loader.hpp b/pywraps/py_loader.hpp index 18dfea5..c03cd12 100644 --- a/pywraps/py_loader.hpp +++ b/pywraps/py_loader.hpp @@ -5,29 +5,13 @@ // //------------------------------------------------------------------------ -/* -# -def mem2base(mem, ea, fpos): - """ - 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 - """ - pass -# -*/ -static int py_mem2base(PyObject *py_mem, ea_t ea, qoff64_t fpos = -1) +static int py_mem2base(PyObject *mem, ea_t ea, qoff64_t fpos = -1) { Py_ssize_t len; char *buf; { PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( PyBytes_AsStringAndSize(py_mem, &buf, &len) == -1 ) + if ( PyBytes_AsStringAndSize(mem, &buf, &len) == -1 ) return 0; } @@ -35,18 +19,6 @@ static int py_mem2base(PyObject *py_mem, ea_t ea, qoff64_t fpos = -1) } //------------------------------------------------------------------------ -/* -# -def load_plugin(name): - """ - Loads a plugin - @return: - - None if plugin could not be loaded - - An opaque object representing the loaded plugin - """ - pass -# -*/ static PyObject *py_load_plugin(const char *name) { if ( qfileexist(name) ) @@ -61,17 +33,6 @@ static PyObject *py_load_plugin(const char *name) } //------------------------------------------------------------------------ -/* -# -def run_plugin(plg): - """ - Runs a plugin - @param plg: A plugin object (returned by load_plugin()) - @return: Boolean - """ - pass -# -*/ static bool py_run_plugin(PyObject *plg, size_t arg) { PYW_GIL_CHECK_LOCKED_SCOPE(); diff --git a/pywraps/py_lumina.hpp b/pywraps/py_lumina.hpp index 3a33f54..4b621e2 100644 --- a/pywraps/py_lumina.hpp +++ b/pywraps/py_lumina.hpp @@ -16,11 +16,11 @@ bool py_extract_type_from_metadata(tinfo_t *out, const bytevec_t &in) } //------------------------------------------------------------------------- -PyObject *py_split_metadata(const metadata_t &md) +PyObject *py_split_metadata(const metadata_t &metadata) { PyObject *py_dict = PyDict_New(); - metadata_iterator_t p(md); + metadata_iterator_t p(metadata); while ( p.next() ) { newref_t py_key(PyInt_FromLong(p.key)); diff --git a/pywraps/py_moves_end.py b/pywraps/py_moves_end.py new file mode 100644 index 0000000..21b9aec --- /dev/null +++ b/pywraps/py_moves_end.py @@ -0,0 +1,9 @@ +# +bookmarks_t_erase = bookmarks_t.erase +bookmarks_t_find_index = bookmarks_t.find_index +bookmarks_t_get = bookmarks_t.get +bookmarks_t_get_desc = bookmarks_t.get_desc +bookmarks_t_get_dirtree_id = bookmarks_t.get_dirtree_id +bookmarks_t_mark = bookmarks_t.mark +bookmarks_t_size = bookmarks_t.size +# diff --git a/pywraps/py_nalt.hpp b/pywraps/py_nalt.hpp index 81dbf46..de0a8df 100644 --- a/pywraps/py_nalt.hpp +++ b/pywraps/py_nalt.hpp @@ -44,16 +44,6 @@ static int idaapi py_import_enum_cb( // //------------------------------------------------------------------------- -/* -# -def get_import_module_name(path, fname, callback): - """ - Returns the name of an imported module given its index - @return: None or the module name - """ - pass -# -*/ static PyObject *py_get_import_module_name(int mod_index) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -65,26 +55,12 @@ static PyObject *py_get_import_module_name(int mod_index) } //------------------------------------------------------------------------- -/* -# -def enum_import_names(mod_index, callback): - """ - 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) - """ - pass -# -*/ -static int py_enum_import_names(int mod_index, PyObject *py_cb) +static int py_enum_import_names(int mod_index, PyObject *callback) { PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( !PyCallable_Check(py_cb) ) + if ( !PyCallable_Check(callback) ) return -1; - return enum_import_names(mod_index, py_import_enum_cb, py_cb); + return enum_import_names(mod_index, py_import_enum_cb, callback); } //------------------------------------------------------------------------- diff --git a/pywraps/py_name.hpp b/pywraps/py_name.hpp index 5fcfffe..3f33476 100644 --- a/pywraps/py_name.hpp +++ b/pywraps/py_name.hpp @@ -45,7 +45,7 @@ inline qstring py_get_ea_name(ea_t ea, int gtn_flags=0) } //------------------------------------------------------------------------- -PyObject *py_validate_name(const char *name, nametype_t type, int flags=0) +PyObject *py_validate_name(const char *name, nametype_t type, int flags=SN_NOCHECK) { qstring qname(name); if ( validate_name(&qname, type, flags) ) diff --git a/pywraps/py_netnode_end.py b/pywraps/py_netnode_end.py new file mode 100644 index 0000000..b27fef5 --- /dev/null +++ b/pywraps/py_netnode_end.py @@ -0,0 +1,3 @@ +# +netnode_exist = netnode.exist +# diff --git a/pywraps/py_pro.hpp b/pywraps/py_pro.hpp index 3231993..86c83ce 100644 --- a/pywraps/py_pro.hpp +++ b/pywraps/py_pro.hpp @@ -108,17 +108,6 @@ static bool qstrvec_t_remove(PyObject *self, size_t idx) //------------------------------------------------------------------------ -/* -# -def str2user(str): - """ - Insert C-style escape characters to string - - @return: new string with escape characters inserted - """ - pass -# -*/ PyObject *py_str2user(const char *str) { if ( str == nullptr ) diff --git a/pywraps/py_search.hpp b/pywraps/py_search.hpp index 732be71..7ca9230 100644 --- a/pywraps/py_search.hpp +++ b/pywraps/py_search.hpp @@ -1,13 +1,2 @@ // - -/* -# -def find_binary(arg1, arg2, arg3, arg4, arg5): - """ - Deprecated. Please use ida_bytes.bin_search() instead. - """ - pass -# -*/ - // diff --git a/pywraps/py_search.py b/pywraps/py_search.py index dce9f06..39d214b 100644 --- a/pywraps/py_search.py +++ b/pywraps/py_search.py @@ -1,4 +1,3 @@ # -SEARCH_UNICODE = 0x40 # Deprecated. For find_binary() # diff --git a/pywraps/py_segment.hpp b/pywraps/py_segment.hpp index 8af08ee..fb4eed7 100644 --- a/pywraps/py_segment.hpp +++ b/pywraps/py_segment.hpp @@ -37,32 +37,12 @@ ea_t segment_t_end_ea_get(segment_t *segm) // //-------------------------------------------------------------------------- -/* -# -def get_defsr(s, reg): - """ - Deprecated, use instead: - value = s.defsr[reg] - """ - pass -# -*/ sel_t get_defsr(segment_t *s, int reg) { return s != nullptr && reg >= 0 && reg < SREG_NUM ? s->defsr[reg] : BADSEL; } //-------------------------------------------------------------------------- -/* -# -def set_defsr(s, reg, value): - """ - Deprecated, use instead: - s.defsr[reg] = value - """ - pass -# -*/ void set_defsr(segment_t *s, int reg, sel_t value) { if ( s != nullptr && reg >= 0 && reg < SREG_NUM ) diff --git a/pywraps/py_struct.hpp b/pywraps/py_struct.hpp deleted file mode 100644 index a0cc1ff..0000000 --- a/pywraps/py_struct.hpp +++ /dev/null @@ -1,39 +0,0 @@ - -#ifndef __PY_STRUCT__ -#define __PY_STRUCT__ - -// - -//------------------------------------------------------------------------- -/* -# -def get_innermost_member(sptr, offset): - """ - Get the innermost member at the given offset - @param sptr: the starting structure - @param offset: offset into the starting structure - @return: - - None on failure - - tuple(member_t, struct_t, offset) - where member_t: a member in SPTR (it is not a structure), - struct_t: the innermost structure, - offset: remaining offset into the returned member - """ - pass -# -*/ -PyObject *py_get_innermost_member(struc_t *sptr, asize_t offset) -{ - PYW_GIL_CHECK_LOCKED_SCOPE(); - member_t *mptr = get_innermost_member(&sptr, &offset); - if ( mptr == nullptr ) - Py_RETURN_NONE; - return Py_BuildValue("(OO" PY_BV_ASIZE ")", - SWIG_NewPointerObj(SWIG_as_voidptr(mptr), SWIGTYPE_p_member_t, 0), - SWIG_NewPointerObj(SWIG_as_voidptr(sptr), SWIGTYPE_p_struc_t, 0), - bvasize_t(offset)); -} - -// - -#endif // __PY_STRUCT__ diff --git a/pywraps/py_typeinf.hpp b/pywraps/py_typeinf.hpp index b1a10fe..24c8447 100644 --- a/pywraps/py_typeinf.hpp +++ b/pywraps/py_typeinf.hpp @@ -3,12 +3,12 @@ // //------------------------------------------------------------------------- -PyObject *idc_parse_decl(til_t *ti, const char *decl, int flags) +PyObject *idc_parse_decl(til_t *til, const char *decl, int flags) { tinfo_t tif; qstring name; qtype fields, type; - bool ok = parse_decl(&tif, &name, ti, decl, flags); + bool ok = parse_decl(&tif, &name, til, decl, flags); if ( ok ) ok = tif.serialize(&type, &fields, nullptr, SUDT_FAST); @@ -22,32 +22,18 @@ PyObject *idc_parse_decl(til_t *ti, const char *decl, int flags) } //------------------------------------------------------------------------- -/* -# -def calc_type_size(ti, tp): - """ - Returns the size of a type - @param ti: Type info library. 'None' can be passed. - @param tp: serialized type byte string - @return: - - None on failure - - The size of the type - """ - pass -# -*/ -PyObject *py_calc_type_size(const til_t *ti, PyObject *tp) +PyObject *py_calc_type_size(const til_t *til, PyObject *type) { PYW_GIL_CHECK_LOCKED_SCOPE(); - if ( PyBytes_Check(tp) ) + if ( PyBytes_Check(type) ) { // To avoid release of 'data' during Py_BEGIN|END_ALLOW_THREADS section. - borref_t tpref(tp); - const type_t *data = (type_t *)PyBytes_AsString(tp); + borref_t typeref(type); + const type_t *data = (type_t *)PyBytes_AsString(type); size_t sz; SWIG_PYTHON_THREAD_BEGIN_ALLOW; tinfo_t tif; - tif.deserialize(ti, &data, nullptr, nullptr); + tif.deserialize(til, &data, nullptr, nullptr); sz = tif.get_size(); SWIG_PYTHON_THREAD_END_ALLOW; if ( sz != BADSIZE ) @@ -62,23 +48,8 @@ PyObject *py_calc_type_size(const til_t *ti, PyObject *tp) } //------------------------------------------------------------------------- -/* -# -def apply_type(ti, ea, tp_name, py_type, py_fields, flags): - """ - Apply the specified type to the address - @param ti: Type info library. 'None' can be used. - @param py_type: type string - @param py_fields: fields string (may be empty or None) - @param ea: the address of the object - @param flags: combination of TINFO_... constants or 0 - @return: Boolean - """ - pass -# -*/ static bool py_apply_type( - til_t *ti, + til_t *til, const type_t *type, const p_list *fields, ea_t ea, @@ -87,17 +58,12 @@ static bool py_apply_type( PYW_GIL_CHECK_LOCKED_SCOPE(); bool rc; SWIG_PYTHON_THREAD_BEGIN_ALLOW; - struc_t *sptr; - member_t *mptr = get_member_by_id(ea, &sptr); + tinfo_t udttif; + udm_t udm; + ssize_t idx = udttif.get_udm_by_tid(&udm, ea); if ( type == nullptr || type[0] == '\0' ) { - if ( mptr != nullptr ) - { - rc = mptr->has_ti(); - if ( rc ) - del_member_tinfo(sptr, mptr); - } - else + if ( idx == -1 ) { rc = has_ti(ea); if ( rc ) @@ -107,11 +73,11 @@ static bool py_apply_type( else { tinfo_t tif; - rc = tif.deserialize(ti, &type, &fields, nullptr); + rc = tif.deserialize(til, &type, &fields, nullptr); if ( rc ) { - if ( mptr != nullptr ) - rc = set_member_tinfo(sptr, mptr, 0, tif, 0) > SMT_FAILED; + if ( idx != -1 ) + rc = udttif.set_udm_type(idx, tif) >= TERR_OK; else rc = apply_tinfo(ea, tif, flags); } @@ -121,19 +87,6 @@ static bool py_apply_type( } //------------------------------------------------------------------------- -/* -header: typeinf.hpp -# -def get_arg_addrs(caller): - """ - Retrieve addresses of argument initialization instructions - - @param caller: the address of the call instruction - @return: list of instruction addresses - """ - pass -# -*/ PyObject *py_get_arg_addrs(ea_t caller) { eavec_t addrs; @@ -147,29 +100,19 @@ PyObject *py_get_arg_addrs(ea_t caller) } //------------------------------------------------------------------------- -/* -# -def py_unpack_object_from_idb(ti, tp, fields, ea, pio_flags = 0): - """ - Unpacks from the database at 'ea' to an object. - Please refer to unpack_object_from_bv() - """ - pass -# -*/ PyObject *py_unpack_object_from_idb( - til_t *ti, + til_t *til, const type_t *type, const p_list *fields, ea_t ea, - int pio_flags = 0) + int pio_flags) { PYW_GIL_CHECK_LOCKED_SCOPE(); idc_value_t idc_obj; error_t err; SWIG_PYTHON_THREAD_BEGIN_ALLOW; tinfo_t tif; - tif.deserialize(ti, &type, &fields); + tif.deserialize(til, &type, &fields); err = unpack_idcobj_from_idb( &idc_obj, tif, @@ -194,36 +137,18 @@ PyObject *py_unpack_object_from_idb( } //------------------------------------------------------------------------- -/* -# -def unpack_object_from_bv(ti, tp, fields, bytes, pio_flags = 0): - """ - Unpacks a buffer into an object. - Returns the error_t returned by idaapi.pack_object_to_idb - @param ti: Type info. 'None' can be passed. - @param tp: type string - @param fields: fields string (may be empty or None) - @param bytes: the bytes to unpack - @param pio_flags: flags used while unpacking - @return: - - tuple(0, err) on failure - - tuple(1, obj) on success - """ - pass -# -*/ PyObject *py_unpack_object_from_bv( - til_t *ti, + til_t *til, const type_t *type, const p_list *fields, const bytevec_t &bytes, - int pio_flags = 0) + int pio_flags) { idc_value_t idc_obj; error_t err; SWIG_PYTHON_THREAD_BEGIN_ALLOW; tinfo_t tif; - tif.deserialize(ti, &type, &fields); + tif.deserialize(til, &type, &fields); err = unpack_idcobj_from_bv( &idc_obj, tif, @@ -247,36 +172,20 @@ PyObject *py_unpack_object_from_bv( } //------------------------------------------------------------------------- -/* -# -def pack_object_to_idb(obj, ti, tp, fields, ea, pio_flags = 0): - """ - 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. 'None' can be passed. - @param tp: type string - @param fields: fields string (may be empty or None) - @param ea: ea to be used while packing - @param pio_flags: flags used while unpacking - """ - pass -# -*/ PyObject *py_pack_object_to_idb( - PyObject *py_obj, - til_t *ti, + PyObject *obj, + til_t *til, const type_t *type, const p_list *fields, ea_t ea, - int pio_flags = 0) + int pio_flags) { PYW_GIL_CHECK_LOCKED_SCOPE(); // Convert Python object to IDC object idc_value_t idc_obj; - borref_t py_obj_ref(py_obj); - if ( !pyvar_to_idcvar_or_error(py_obj_ref, &idc_obj) ) + borref_t obj_ref(obj); + if ( !pyvar_to_idcvar_or_error(obj_ref, &idc_obj) ) return nullptr; // Pack @@ -284,45 +193,28 @@ PyObject *py_pack_object_to_idb( error_t err; SWIG_PYTHON_THREAD_BEGIN_ALLOW; tinfo_t tif; - tif.deserialize(ti, &type, &fields); + tif.deserialize(til, &type, &fields); err = pack_idcobj_to_idb(&idc_obj, tif, ea, pio_flags); SWIG_PYTHON_THREAD_END_ALLOW; return PyInt_FromLong(err); } //------------------------------------------------------------------------- -/* -# -def pack_object_to_bv(obj, ti, tp, fields, base_ea, pio_flags = 0): - """ - Packs a typed object to a string - @param ti: Type info. 'None' can be passed. - @param tp: type string - @param fields: fields string (may be empty or None) - @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 - """ - pass -# -*/ // Returns a tuple(Boolean, PackedBuffer or Error Code) PyObject *py_pack_object_to_bv( - PyObject *py_obj, - til_t *ti, + PyObject *obj, + til_t *til, const type_t *type, const p_list *fields, ea_t base_ea, - int pio_flags=0) + int pio_flags) { PYW_GIL_CHECK_LOCKED_SCOPE(); // Convert Python object to IDC object idc_value_t idc_obj; - borref_t py_obj_ref(py_obj); - if ( !pyvar_to_idcvar_or_error(py_obj_ref, &idc_obj) ) + borref_t obj_ref(obj); + if ( !pyvar_to_idcvar_or_error(obj_ref, &idc_obj) ) return nullptr; // Pack @@ -330,7 +222,7 @@ PyObject *py_pack_object_to_bv( error_t err; SWIG_PYTHON_THREAD_BEGIN_ALLOW; tinfo_t tif; - tif.deserialize(ti, &type, &fields); + tif.deserialize(til, &type, &fields); err = pack_idcobj_to_bv( &idc_obj, tif, @@ -358,6 +250,11 @@ int idc_parse_types(const char *input, int flags) hti |= HTI_FIL; flags &= ~PT_FILE; } + if ( (flags & PT_SEMICOLON) != 0 ) + { + hti |= HTI_SEMICOLON; + flags &= ~PT_SEMICOLON; + } return parse_decls(nullptr, input, (flags & PT_SIL) == 0 ? msg : nullptr, hti); } @@ -497,21 +394,6 @@ char idc_get_local_type_name(int ordinal, char *buf, size_t bufsize) } //------------------------------------------------------------------------- -/* -# -def get_named_type(til, name, ntf_flags): - """ - Get a type data by its name. - @param til: the type library - @param name: the type name - @param ntf_flags: a combination of NTF_* constants - @return: - None on failure - tuple(code, type_str, fields_str, cmt, field_cmts, sclass, value) on success - """ - pass -# -*/ PyObject *py_get_named_type(const til_t *til, const char *name, int ntf_flags) { const type_t *type = nullptr; @@ -536,20 +418,20 @@ PyObject *py_get_named_type64(const til_t *til, const char *name, int ntf_flags) } //------------------------------------------------------------------------- -PyObject *py_print_decls(text_sink_t &printer, til_t *til, PyObject *py_ordinals, uint32 flags) +PyObject *py_print_decls(text_sink_t &printer, til_t *til, PyObject *ordinals, uint32 flags) { - if ( !PyList_Check(py_ordinals) ) + if ( !PyList_Check(ordinals) ) { PyErr_SetString(PyExc_ValueError, "'ordinals' must be a list"); return nullptr; } - Py_ssize_t nords = PyList_Size(py_ordinals); - ordvec_t ordinals; - ordinals.reserve(size_t(nords)); + Py_ssize_t nords = PyList_Size(ordinals); + ordvec_t _ordinals; + _ordinals.reserve(size_t(nords)); for ( Py_ssize_t i = 0; i < nords; ++i ) { - borref_t item(PyList_GetItem(py_ordinals, i)); + borref_t item(PyList_GetItem(ordinals, i)); if ( !item || !PyLong_Check(item.o) ) { qstring msg; @@ -558,9 +440,9 @@ PyObject *py_print_decls(text_sink_t &printer, til_t *til, PyObject *py_ordinals return nullptr; } uint32 ord = PyLong_AsLong(item.o); - ordinals.push_back(ord); + _ordinals.push_back(ord); } - return PyLong_FromLong(print_decls(printer, til, ordinals.empty() ? nullptr : &ordinals, flags)); + return PyLong_FromLong(print_decls(printer, til, _ordinals.empty() ? nullptr : &_ordinals, flags)); } //------------------------------------------------------------------------- @@ -585,6 +467,23 @@ static PyObject *py_get_numbered_type(const til_t *til, uint32 ordinal) Py_RETURN_NONE; } +//------------------------------------------------------------------------- +static tinfo_code_t py_set_numbered_type( + til_t *ti, + uint32 ordinal, + int ntf_flags, + const char *name, + const type_t *type, + const p_list *fields=nullptr, + const char *cmt=nullptr, + const p_list *fldcmts=nullptr, + const sclass_t *sclass=nullptr) +{ + tinfo_t tif; + return tif.deserialize(ti, &type, &fields, &fldcmts, cmt) + ? tif.set_numbered_type(ti, ordinal, ntf_flags, name) + : TERR_BAD_TYPE; +} // // diff --git a/pywraps/py_typeinf.py b/pywraps/py_typeinf.py index 7d80e46..8e35859 100644 --- a/pywraps/py_typeinf.py +++ b/pywraps/py_typeinf.py @@ -35,7 +35,6 @@ sc_virt = SC_VIRT TERR_SAVE = TERR_SAVE_ERROR TERR_WRONGNAME = TERR_BAD_NAME -TERR_BADSYNC = TERR_BAD_SYNC BADORD = 0xFFFFFFFF @@ -44,7 +43,4 @@ enum_member_t = edm_t udt_member_t = udm_t tinfo_t.find_udt_member = tinfo_t.find_udm -IMPTYPE_VERBOSE = 0x0001 -IMPTYPE_OVERRIDE = 0x0002 - # diff --git a/pywraps/py_ua.hpp b/pywraps/py_ua.hpp index dd1de86..16bbaac 100644 --- a/pywraps/py_ua.hpp +++ b/pywraps/py_ua.hpp @@ -7,18 +7,6 @@ //------------------------------------------------------------------------- // -/* -# -def decode_preceding_insn(ea): - """ - Decodes the preceding instruction. Please check ua.hpp / decode_preceding_insn() - @param ea: current ea - @param out: instruction storage - @return: tuple(preceeding_ea or BADADDR, farref = Boolean) - """ - pass -# -*/ PyObject *py_decode_preceding_insn(insn_t *out, ea_t ea) { bool farref; @@ -28,15 +16,6 @@ PyObject *py_decode_preceding_insn(insn_t *out, ea_t ea) } //------------------------------------------------------------------------- -/* -# -def construct_macro(insn): - """ - See ua.hpp's construct_macro(). - """ - pass -# -*/ bool py_construct_macro(insn_t &insn, bool enable, PyObject *build_macro) { PYW_GIL_CHECK_LOCKED_SCOPE(); @@ -44,18 +23,17 @@ bool py_construct_macro(insn_t &insn, bool enable, PyObject *build_macro) if ( !PyCallable_Check(build_macro) ) return false; - static qstack macro_builders; - - macro_builders.push(newref_t(build_macro)); - struct ida_local lambda_t + struct ida_local adapter_t : public macro_constructor_t { - static bool idaapi call_build_macro(insn_t &insn, bool may_go_forward) + PyObject *py_builder; + + adapter_t(PyObject *b) : py_builder(b) {} + bool idaapi build_macro(insn_t *insn, bool may_go_forward) override { - PyObject *py_builder = macro_builders.top().o; ref_t py_res; if ( ref_t py_mod = ref_t(PyW_TryImportModule(SWIG_name)) ) { - if ( ref_t py_insn = ref_t(try_create_swig_wrapper(py_mod, "insn_t", &insn)) ) + if ( ref_t py_insn = ref_t(try_create_swig_wrapper(py_mod, "insn_t", insn)) ) { py_res = newref_t( PyObject_CallFunction( @@ -69,9 +47,8 @@ bool py_construct_macro(insn_t &insn, bool enable, PyObject *build_macro) return py_res.o == Py_True; } }; - bool res = construct_macro(insn, enable, lambda_t::call_build_macro); - macro_builders.pop(); - return res; + adapter_t ad(build_macro); + return ad.construct_macro(&insn, enable); } //------------------------------------------------------------------------- diff --git a/pywraps/py_xref.hpp b/pywraps/py_xref.hpp index 5622df1..cd5bc66 100644 --- a/pywraps/py_xref.hpp +++ b/pywraps/py_xref.hpp @@ -7,32 +7,13 @@ typedef qvector casevec_t; typedef qvector eavec_t; // -/* -# -def create_switch_xrefs(ea, si): - """ - 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 ea: address of the 'indirect jump' instruction - @param si: switch information - - @return: Boolean - """ - pass -# -*/ +//------------------------------------------------------------------------- bool py_create_switch_xrefs(ea_t ea, const switch_info_t &si) { create_switch_xrefs(ea, si); return true; } - //------------------------------------------------------------------------- struct cases_and_targets_t { @@ -41,28 +22,6 @@ struct cases_and_targets_t }; //------------------------------------------------------------------------- -/* -# -def calc_switch_cases(ea, si): - """ - Get information about a switch's cases. - - The returned information can be used as follows: - - for idx in range(len(results.cases)): - cur_case = results.cases[idx] - for cidx in range(len(cur_case)): - print("case: %d" % cur_case[cidx]) - print(" goto 0x%x" % results.targets[idx]) - - @param ea: address of the 'indirect jump' instruction - @param si: switch information - - @return: a structure with 2 members: 'cases', and 'targets'. - """ - pass -# -*/ cases_and_targets_t *py_calc_switch_cases( ea_t ea, const switch_info_t &si) @@ -77,20 +36,6 @@ cases_and_targets_t *py_calc_switch_cases( } //------------------------------------------------------------------------- -/* -# -def create_switch_table(ea, si): - """ - Create switch table from the switch information - - @param ea: address of the 'indirect jump' instruction - @param si: switch information - - @return: Boolean - """ - pass -# -*/ bool py_create_switch_table(ea_t ea, const switch_info_t &si) { create_switch_table(ea, si); diff --git a/pywraps/py_xref.py b/pywraps/py_xref.py index fb91ec4..ca7100d 100644 --- a/pywraps/py_xref.py +++ b/pywraps/py_xref.py @@ -5,4 +5,7 @@ import ida_idaapi ida_idaapi._listify_types( casevec_t) +XREF_ALL = XREF_FLOW +XREF_FAR = XREF_NOFLOW + # diff --git a/pywraps/pywraps.vcproj b/pywraps/pywraps.vcproj index 82f0e20..0862b0f 100644 --- a/pywraps/pywraps.vcproj +++ b/pywraps/pywraps.vcproj @@ -1093,10 +1093,6 @@ RelativePath="..\swig\entry.i" > - - diff --git a/swig/bitrange.i b/swig/bitrange.i index 5fccd9e..c9a6db1 100644 --- a/swig/bitrange.i +++ b/swig/bitrange.i @@ -82,6 +82,12 @@ $self->mask64()); return qs; } + + + %pythoncode { + def __repr__(self): + return f"{self.__class__.__module__}.{self.__class__.__name__}({self.bitoff()}, {self.bitsize()})" % () + } } %include "bitrange.hpp" diff --git a/swig/bytes.i b/swig/bytes.i index bfd957b..14e49df 100644 --- a/swig/bytes.i +++ b/swig/bytes.i @@ -4,6 +4,9 @@ %apply (testf_t *func, void *ud) { (testf_t *testf, void *ud=nullptr) }; +%ignore next_that(ea_t, ea_t, testf_t *); +%ignore prev_that(ea_t, ea_t, testf_t *); + // Unexported and kernel-only declarations %ignore adjust_visea; %ignore visit_patched_bytes; @@ -35,24 +38,70 @@ %ignore get_bytes; %ignore get_strlit_contents; %ignore get_hex_string; -%ignore bin_search; // we redefine our own, w/ 2 params swapped, so we can apply the typemaps below -%rename (bin_search) py_bin_search; -%rename (bin_search) bin_search2; +%ignore bin_search(ea_t,ea_t,const compiled_binpat_vec_t&,int); +%ignore find_binary; %rename (op_stroff) py_op_stroff; -%ignore bin_search2(ea_t, ea_t, const uchar *, const uchar *, size_t, int); %ignore bytes_match_for_bin_search; -%ignore get_8bit; -%rename (get_8bit) py_get_8bit; +%apply uchar * OUTPUT { uchar *out }; // get_octet -%ignore get_octet; -%rename (get_octet) py_get_octet; +//------------------------------------------------------------------------- +// get_stroff_path +//------------------------------------------------------------------------- -%apply uchar * OUTPUT { uchar *out }; // get_octet2 +%typemap(in,numinputs=0) (qvector *out_path) (qvector temp) { + // %typemap(in,numinputs=0) (qvector *out_path) (qvector temp) + $1 = &temp; +} + +%typemap(argout) qvector *out_path +{ + // %typemap(argout) qvector *out_path + if ( result > 0 ) + { + ref_t py_list(PyW_TidVecToPyList(*($1))); + py_list.incref(); + $result = SWIG_Python_AppendOutput($result, py_list.o, /*is_void=*/ 1); + } + else + { + Py_INCREF(Py_None); + $result = SWIG_Python_AppendOutput($result, Py_None, /*is_void=*/ 1); + } +} + +%typemap(in,numinputs=0) (adiff_t *out_delta) (adiff_t temp) { + // %typemap(in,numinputs=0) (adiff_t *out_delta) (adiff_t temp) + $1 = &temp; +} + +%typemap(argout) adiff_t *out_delta +{ + // %typemap(argout) adiff_t *out_delta + if ( result > 0 ) + { + newref_t py_delta(PyLong_FromUnsignedLongLong(*($1))); + py_delta.incref(); + $result = SWIG_Python_AppendOutput($result, py_delta.o, /*is_void=*/ 1); + } + else + { + Py_INCREF(Py_None); + $result = SWIG_Python_AppendOutput($result, Py_None, /*is_void=*/ 1); + } +} + +%feature("pythonappend") get_stroff_path %{ + if isinstance(val, tuple): # "modern" form; let's drop the count + val = (val[1], val[2]) +%} + +//------------------------------------------------------------------------- %template(compiled_binpat_vec_t) qvector; +%ignore parse_binpat_str(compiled_binpat_vec_t *,ea_t,char const *,int,int); -%apply size_t * OUTPUT { size_t *out_matched_idx }; // bin_search3 +%apply size_t * OUTPUT { size_t *out_matched_idx }; // bin_search // TODO: This could be fixed (if needed) %ignore set_dbgmem_source; @@ -88,6 +137,12 @@ // %} +%{ +// +// +%} + + %extend data_type_t { data_type_t( @@ -203,7 +258,18 @@ // %} +%inline %{ +// +// +%} + + %pythoncode %{ # # %} + +%pythoncode %{ +# +# +%} diff --git a/swig/dbg.i b/swig/dbg.i index a7ee8b0..f7b1aee 100644 --- a/swig/dbg.i +++ b/swig/dbg.i @@ -42,6 +42,7 @@ %rename (get_reg_vals) py_get_reg_vals; %newobject py_get_reg_vals; +%ignore list_bptgrps(qstrvec_t *); %rename (list_bptgrps) py_list_bptgrps; %apply qstring *result { qstring *grp_name }; %uncomparable_elements_qvector(bpt_t, bpt_vec_t); @@ -65,33 +66,43 @@ //------------------------------------------------------------------------- // get_process_options() -%define %get_process_options_out_qstring(ARG_NAME) +%rename (get_process_options2) get_process_options; +%rename (get_process_options) get_process_options_noenv; + +%define %get_process_options_out_arg(ARG_NAME) %typemap(in, numinputs=0) qstring *ARG_NAME (qstring temp) { - // %get_process_options_out_qstring %typemap(in, numinputs=0) qstring *ARG_NAME + // %get_process_options_out_arg %typemap(in, numinputs=0) qstring *ARG_NAME $1 = &temp; } %typemap(argout) qstring *ARG_NAME { - // %get_process_options_out_qstring %typemap(argout) qstring *ARG_NAME - $result = SWIG_Python_AppendOutput($result, PyUnicode_FromString($1->c_str())); + // %get_process_options_out_arg %typemap(argout) qstring *ARG_NAME + $result = SWIG_Python_AppendOutput($result, PyUnicode_FromString($1->c_str()), /*is_void=*/ 1); } %typemap(freearg) qstring* ARG_NAME { - // %get_process_options_out_qstring %typemap(freearg) qstring* ARG_NAME + // %get_process_options_out_arg %typemap(freearg) qstring* ARG_NAME // Nothing. We certainly don't want 'temp' to be deleted. } -%enddef -%get_process_options_out_qstring(path); -%get_process_options_out_qstring(args); -%get_process_options_out_qstring(sdir); -%get_process_options_out_qstring(host); -%get_process_options_out_qstring(pass); -%typemap(in, numinputs=0) launch_env_t *envs (launch_env_t temp) +%typemap(in, numinputs=0) launch_env_t *out_envs (launch_env_t temp) { - // %typemap(in, numinputs=0) launch_env_t *envs (launch_envs_t temp) + // %get_process_options_out_arg %typemap(in, numinputs=0) launch_env_t *ARG_NAME $1 = &temp; } +%typemap(argout) launch_env_t *out_envs +{ + // %get_process_options_out_arg %typemap(argout) launch_env_t *ARG_NAME + PyObject *py_launch_env = SWIG_NewPointerObj(new launch_env_t(*($1)), $1_descriptor, SWIG_POINTER_OWN | 0); + $result = SWIG_Python_AppendOutput($result, py_launch_env, /*is_void=*/ 1); +} +%enddef +%get_process_options_out_arg(path); +%get_process_options_out_arg(args); +%get_process_options_out_arg(envs); +%get_process_options_out_arg(sdir); +%get_process_options_out_arg(host); +%get_process_options_out_arg(pass); %apply int *OUTPUT { int *port }; // specialize for 'get_process_options()'s first output diff --git a/swig/diskio.i b/swig/diskio.i index 7c1d113..c6ffe3c 100644 --- a/swig/diskio.i +++ b/swig/diskio.i @@ -11,7 +11,6 @@ %ignore ioport_bit_t; %ignore ioport_bits_t; %ignore ioport_t; -%ignore read_ioports; %ignore choose_ioport_device; %ignore find_ioport; %ignore find_ioport_bit; diff --git a/swig/enum.i b/swig/enum.i deleted file mode 100644 index 497e40f..0000000 --- a/swig/enum.i +++ /dev/null @@ -1,8 +0,0 @@ -%{ -#include -%} -%ignore get_enum_name(tid_t, int); - -%constant bmask_t DEFMASK = bmask_t(-1); - -%include "enum.hpp" diff --git a/swig/expr.i b/swig/expr.i index 9d83b34..d22017d 100644 --- a/swig/expr.i +++ b/swig/expr.i @@ -55,6 +55,8 @@ %ignore idc_value_t::_set_string; %ignore idc_value_t::idc_value_t(const qstring &); %ignore idc_value_t::set_string(const qstring &); +%ignore idc_value_t::qstr(); + %ignore eval_expr; %rename (eval_expr) py_eval_expr; @@ -65,6 +67,9 @@ %ignore compile_idc_text; %rename (compile_idc_text) py_compile_idc_text; +%ignore compile_idc_snippet(char const *,char const *); +%ignore exec_idc_script(idc_value_t *,char const *,char const *,idc_value_t const [],size_t); + %cstring_output_buf_and_size_returning_charptr( 1, char *buf, diff --git a/swig/fpro.i b/swig/fpro.i index 8dc23f9..cd8958b 100644 --- a/swig/fpro.i +++ b/swig/fpro.i @@ -1,4 +1,50 @@ %inline %{ // -// +.// +%} + +%ignore fread2bytes; +%ignore fread4bytes; +%ignore fread8bytes; +%ignore freadbytes; +%ignore fwrite2bytes; +%ignore fwrite4bytes; +%ignore fwrite8bytes; +%ignore fwritebytes; +%ignore qaccess; +%ignore qcopyfile; +%ignore qeprintf; +//%ignore qfclose; +%ignore qfgetc; +%ignore qfgets; +%ignore qflush; +%ignore qfopen; +%ignore qfprintf; +%ignore qfputc; +%ignore qfputs; +%ignore qfread; +%ignore qfscanf; +%ignore qfseek; +%ignore qfsize; +%ignore qftell; +%ignore qfwrite; +%ignore qgetline; +%ignore qgets; +%ignore qmove; +%ignore qprintf; +%ignore qrename; +%ignore qtmpdir; +%ignore qtmpfile; +%ignore qtmpnam; +%ignore qunlink; +%ignore qveprintf; +%ignore qvfprintf; +%ignore qvfscanf; +%ignore qvprintf; + +%include "fpro.h" + +%pythoncode %{ +# +# %} diff --git a/swig/frame.i b/swig/frame.i index 759cfc6..e7e221c 100644 --- a/swig/frame.i +++ b/swig/frame.i @@ -4,22 +4,20 @@ %ignore add_frame_spec_member; %ignore del_stkvars; -%ignore calc_frame_offset; %ignore set_llabel; %ignore get_llabel_ea; %ignore get_llabel; -%ignore get_stkvar; -%rename (get_stkvar) py_get_stkvar; - -%ignore calc_frame_offset; %ignore add_stkvar; %ignore delete_wrong_frame_info; -%ignore get_frame(ea_t); +%ignore get_func_frame(tinfo_t *tif, ea_t ea); %template(xreflist_t) qvector; +// +// + %inline %{ // // diff --git a/swig/funcs.i b/swig/funcs.i index c07b1e7..9146d09 100644 --- a/swig/funcs.i +++ b/swig/funcs.i @@ -5,7 +5,6 @@ // FIXME: Are these really useful? %ignore iterate_func_chunks; -%ignore get_idasgn_header_by_short_name; // Kernel-only & unexported symbols %ignore determine_rtl; @@ -136,14 +135,47 @@ %alias_func_item_iterator(head_items); %alias_func_item_iterator(not_tails); +%feature("pythonappend") func_t::get_frame_object %{ + if val.empty(): + val = None +%} + +%feature("pythonappend") func_t::get_prototype %{ + if val.empty(): + val = None +%} + %extend func_t { + tinfo_t get_frame_object() const + { + tinfo_t frame; + get_func_frame(&frame, $self); + return frame; + } + + ssize_t get_name(qstring *out) const + { + return get_func_name(out, $self->start_ea); + } + + tinfo_t get_prototype() const + { + tinfo_t proto; + get_tinfo(&proto, $self->start_ea); + return proto; + } + %pythoncode { def __iter__(self): """ Alias for func_item_iterator_t(self).__iter__() """ return func_item_iterator_t(self).__iter__() + + frame_object = property(get_frame_object) + name = property(get_name) + prototype = property(get_prototype) } } diff --git a/swig/graph.i b/swig/graph.i index 14823d3..bc05d99 100644 --- a/swig/graph.i +++ b/swig/graph.i @@ -7,32 +7,32 @@ #pragma SWIG nowarn=305 // "Warning 473: Returning a pointer or reference in a director method is not recommended." -%warnfilter(473) mutable_graph_t::nrect; +%warnfilter(473) interactive_graph_t::nrect; %warnfilter(473) place_t::clone; %warnfilter(473) place_t::makeplace; %warnfilter(473) place_t::name; %warnfilter(473) place_t::enter; -// "Warning 517: Director class 'mutable_graph_t' can't be constructed" -%warnfilter(517) mutable_graph_t; +// "Warning 517: Director class 'interactive_graph_t' can't be constructed" +%warnfilter(517) interactive_graph_t; // most of these aren't defined/exported through graph.hpp -%ignore abstract_graph_t::callback; -%ignore abstract_graph_t::vgrcall; -%ignore abstract_graph_t::clear; -%ignore abstract_graph_t::dump_graph; -%ignore abstract_graph_t::calc_bounds; -%ignore abstract_graph_t::calc_fitting_params; -%ignore abstract_graph_t::for_all_nodes_edges; -%ignore abstract_graph_t::get_edge_ports; -%ignore abstract_graph_t::add_node_edges; -%ignore abstract_graph_t::create_polar_tree_layout; -%ignore abstract_graph_t::create_radial_tree_layout; -%ignore abstract_graph_t::create_orthogonal_layout; -%ignore abstract_graph_t::clone; -%ignore abstract_graph_t::nrect; +%ignore drawable_graph_t::callback; +%ignore drawable_graph_t::vgrcall; +%ignore drawable_graph_t::clear; +%ignore drawable_graph_t::dump_graph; +%ignore drawable_graph_t::calc_bounds; +%ignore drawable_graph_t::calc_fitting_params; +%ignore drawable_graph_t::for_all_nodes_edges; +%ignore drawable_graph_t::get_edge_ports; +%ignore drawable_graph_t::add_node_edges; +%ignore drawable_graph_t::create_polar_tree_layout; +%ignore drawable_graph_t::create_radial_tree_layout; +%ignore drawable_graph_t::create_orthogonal_layout; +%ignore drawable_graph_t::clone; +%ignore drawable_graph_t::nrect; %rename (nrect) novirt_nrect; -%ignore abstract_graph_t::get_edge; +%ignore drawable_graph_t::get_edge; %rename (get_edge) novirt_get_edge; %ignore edge_info_t::add_layout_point; @@ -42,16 +42,16 @@ %ignore graph_item_t::operator==; // Meant to be constructed by the kernel/ui only -%feature("nodirector") mutable_graph_t; -%ignore mutable_graph_t::mutable_graph_t; -%ignore mutable_graph_t::calc_center_of; -%ignore mutable_graph_t::change_visibility; -%ignore mutable_graph_t::check_new_group; -%ignore mutable_graph_t::groups_are_present; -%ignore mutable_graph_t::insert_simple_nodes; -%ignore mutable_graph_t::insert_visible_nodes; -%ignore mutable_graph_t::move_grouped_nodes; -%ignore mutable_graph_t::move_to_same_place; +%feature("nodirector") interactive_graph_t; +%ignore interactive_graph_t::interactive_graph_t; +%ignore interactive_graph_t::calc_center_of; +%ignore interactive_graph_t::change_visibility; +%ignore interactive_graph_t::check_new_group; +%ignore interactive_graph_t::groups_are_present; +%ignore interactive_graph_t::insert_simple_nodes; +%ignore interactive_graph_t::insert_visible_nodes; +%ignore interactive_graph_t::move_grouped_nodes; +%ignore interactive_graph_t::move_to_same_place; %ignore point_t::dstr; %ignore point_t::print; @@ -60,6 +60,7 @@ %ignore rect_t::operator<; %ignore selection_item_t::selection_item_t(class graph_item_t &); %feature("nodirector") user_graph_place_t; +%nodefaultdtor user_graph_place_t; %extend graph_visitor_t { public: @@ -67,7 +68,7 @@ public: virtual int idaapi visit_edge(edge_t /*e*/, edge_info_t * /*ei*/) { qnotused(self); return 0; } } -%extend abstract_graph_t { +%extend drawable_graph_t { public: edge_info_t *novirt_get_edge(edge_t e) { diff --git a/swig/hexrays.i b/swig/hexrays.i index 5ecc9a6..3c8e7c8 100644 --- a/swig/hexrays.i +++ b/swig/hexrays.i @@ -1,6 +1,6 @@ %{ -#undef HEXDSP hexdsp_t *get_idapython_hexdsp(); +#undef HEXDSP #define HEXDSP get_idapython_hexdsp() #include %} @@ -55,9 +55,9 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) } %enddef -%define %method_sets_type_and_gains_ownership_of_regular_object_argument(TYPE, METHOD) +%define %method_sets_type_and_gains_ownership_of_regular_object_argument(TYPE, METHOD, ARGNAME) %feature("pythonprepend") TYPE::METHOD %{ - o = args[0] + o = ARGNAME self._ensure_cond(self.t == mop_z, "self.t == mop_z") %} %feature("pythonappend") TYPE::METHOD %{ @@ -81,7 +81,10 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) %ignore string_printer_t::vprint; %ignore vdui_t::vdui_t; %ignore cblock_t::find; + %ignore citem_t::op; +%ignore citem_t::find_parent_of(const citem_t *) const; + %ignore cfunc_t::cfunc_t; %ignore cfunc_t::sv; // lazy member. Use get_pseudocode() instead %ignore cfunc_t::boundaries; // lazy member. Use get_boundaries() instead @@ -98,6 +101,9 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) %ignore cblock_t::use_curly_braces; %ignore casm_t::print; %ignore cgoto_t::print; +%ignore ctry_t::print; +%ignore ccatch_t::print; + %ignore cexpr_t::is_aliasable; %ignore cexpr_t::like_boolean; %ignore cexpr_t::contains_expr; @@ -106,6 +112,10 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) %ignore cexpr_t::is_type_partial; %ignore cexpr_t::set_type_partial; %ignore cexpr_t::is_value_used; +%ignore cexpr_t::find_num_op() const; +%ignore cexpr_t::find_op(ctype_t) const; +%ignore cexpr_t::theother(const cexpr_t *) const; + %ignore lvar_t::is_promoted_arg; %ignore lvar_t::lvar_t; %ignore lvar_t::is_partialy_typed; @@ -143,6 +153,8 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) %ignore mba_t::idaloc2vd(const mba_t *, const argloc_t &, int); %ignore mba_t::range_contains; %ignore mba_t::get_stkvar; +%ignore mba_t::arg(int) const; +%ignore mba_t::get_mblock(uint) const; %feature("nodirector") codegen_t; %ignore codegen_t::reserved; @@ -150,43 +162,63 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) %feature("nodirector") simple_graph_t; %ignore simple_graph_t::simple_graph_t; %ignore simple_graph_t::~simple_graph_t; +%ignore simple_graph_t::ignore_edge; +%ignore simple_graph_t::iterator; +%ignore hexrays_node_visitor_t; %feature("nodirector") mbl_graph_t; %ignore mbl_graph_t::mbl_graph_t; %ignore mbl_graph_t::~mbl_graph_t; +%ignore mbl_graph_t::ignore_edge; %define_hexrays_lifecycle_object(minsn_t); %ignore minsn_t::find_ins_op(const mop_t **, mcode_t) const; +%ignore minsn_t::find_ins_op(const mop_t **) const; %ignore minsn_t::find_num_op(const mop_t **) const; +%ignore minsn_t::find_opcode(mcode_t) const; %ignore minsn_t::set_combined; + +%ignore mop_t::is_constant(uint64 *) const; +%ignore mop_t::is_constant() const; +%ignore mop_t::get_insn(mcode_t) const; + %define_hexrays_lifecycle_object(mop_t); %ignore mop_t::_make_strlit(qstring *); %template(mopvec_t) qvector; -%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_cases) -%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_callinfo) -%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_pair) -%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_insn) +%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_cases, _cases) +%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_callinfo, fi) +%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_pair, _pair) +%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, _make_insn, ins) +%method_sets_type_and_gains_ownership_of_regular_object_argument(mop_t, make_insn, ins) %template(mcallargs_t) qvector; +%ignore block_chains_t::get_reg_chain(mreg_t, int); +%ignore block_chains_t::get_stk_chain(sval_t, int); +%ignore block_chains_t::get_chain(voff_t &, int); +%ignore block_chains_t::get_chain(chain_t &); %uncomparable_elements_qvector(block_chains_t, block_chains_vec_t); %ignore mblock_t::mblock_t; -%ignore mblock_t::find_first_use(mlist_t *, const minsn_t *, const minsn_t *, maymust_t) const; + +%ignore mblock_t::find_first_use(mlist_t *, const minsn_t *, const minsn_t *, maymust_t=MAY_ACCESS) const; +%ignore mblock_t::find_first_use(mlist_t *, const minsn_t *, const minsn_t *) const; %ignore mblock_t::find_redefinition(const mlist_t &, const minsn_t *, const minsn_t *, maymust_t) const; +%ignore mblock_t::find_redefinition(const mlist_t &, const minsn_t *, const minsn_t *) const; %ignore mblock_t::reserved; %ignore mblock_t::vdump_block; + // Note: we cannot use %delobject here, as that would disown // the block itself, not the instruction. %feature("pythonappend") mblock_t::insert_into_block %{ - mn = args[0] + mn = nm mn._maybe_disown_and_deregister() %} // Note: we could be using %newobject here, but for the sake of // symmetry with 'insert_into_block', let's go with "pythonappend". %feature("pythonprepend") mblock_t::remove_from_block %{ - mn = args[0] + mn = m %} %feature("pythonappend") mblock_t::remove_from_block %{ if mn: @@ -224,14 +256,21 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) %ignore getf_reginsn(const minsn_t *); %ignore getb_reginsn(const minsn_t *); + %ignore lvar_t::dstr; +%ignore lvar_t::type() const; + %ignore lvar_locator_t::dstr; +%ignore lvar_locator_t::get_scattered() const; + %ignore fnumber_t::dstr; %ignore range_item_iterator_t; %ignore mba_item_iterator_t; %ignore range_chunk_iterator_t; %ignore mba_ranges_t::range_contains; +%ignore hexrays_failure_t::hexrays_failure_t(merror_t,ea_t); + %newobject gen_microcode; %define_hexrays_lifecycle_object(mba_t); %const_void_pointer_and_size(uchar, bytes, nbytes); @@ -242,6 +281,10 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) %apply uint64 *OUTPUT { uvlr_t *val }; // valrng_t::cvt_to_cmp %apply int *OUTPUT { cmpop_t *cmp }; // valrng_t::cvt_to_cmp +%apply qstrvec_t *out { qstrvec_t *warnings }; + +%hooks_director_handle_qstrvec_t_output(collect_warnings, warnings); + %define %def_opt_handler(TypeName, Install, Remove, Hxclr) %ignore Install; %ignore Remove; @@ -364,6 +407,10 @@ SWIGINTERN void __raise_vdf(const vd_failure_t &e) $self->print_func(p); return qs; } + + %pythoncode { + __repr__ = __str__ + } }; %ignore qstring_printer_t::qstring_printer_t(const cfunc_t *, qstring &, bool); @@ -910,6 +957,10 @@ typedef int iterator_word; %template(qvector_lvar_t) qvector; %template(qvector_carg_t) qvector; %template(qvector_ccase_t) qvector; +%template(qvector_catchexprs_t) qvector; +%template(qvector_ccatchvec_t) qvector; +%uncomparable_elements_qvector(cblock_pos_t, cblock_posvec_t); + %template(lvar_saved_infos_t) qvector; %template(ui_stroff_ops_t) qvector; @@ -965,6 +1016,9 @@ void qswap(cinsn_t &a, cinsn_t &b); %ignore get_widget_vdui; %rename (get_widget_vdui) py_get_widget_vdui; +%ignore decompile_func(func_t *,hexrays_failure_t *); +%ignore decompile_func(func_t *); + %feature("pythonappend") decompile_func %{ if val.__deref__() is None: val = None @@ -972,7 +1026,6 @@ void qswap(cinsn_t &a, cinsn_t &b); //------------------------------------------------------------------------- -#if SWIG_VERSION == 0x40000 || SWIG_VERSION == 0x40001 %typemap(out) cfuncptr_t {} %typemap(ret) cfuncptr_t { @@ -991,9 +1044,6 @@ void qswap(cinsn_t &a, cinsn_t &b); hexrays_register_python_clearable_instance(ni, hxclr_cfuncptr); $result = SWIG_NewPointerObj(ni, $1_descriptor, SWIG_POINTER_OWN | 0); } -#else -#error Ensure cfuncptr_t wrapping is compatible with this version of SWIG -#endif //--------------------------------------------------------------------- %define %python_callback_in(CB) diff --git a/swig/ida.i b/swig/ida.i index 8668ae9..0e8191d 100644 --- a/swig/ida.i +++ b/swig/ida.i @@ -13,7 +13,9 @@ %ignore idainfo::lflags; %ignore inf_get_procname(); +%ignore inf_get_procname(char *); %ignore inf_get_strlit_pref(); +%ignore inf_get_strlit_pref(char *); %ignore ea_helper_t; %ignore hook_cb_t; @@ -31,10 +33,6 @@ %ignore setinf; %ignore setinf_buf; %ignore setinf_flag; -#ifdef NOTEAMS -%ignore idbattr_info_t; -%ignore idbattr_valmap_t; -#endif %extend idainfo { diff --git a/swig/idaapi.i b/swig/idaapi.i index e832c2b..6f72d15 100644 --- a/swig/idaapi.i +++ b/swig/idaapi.i @@ -17,12 +17,12 @@ %ignore parse_command_line3; %rename (parse_command_line3) py_parse_command_line; -%constant ea_t BADADDR = ea_t(-1); -%constant ea32_t BADADDR32 = ea32_t(-1ULL); -%constant ea64_t BADADDR64 = ea64_t(-1ULL); -%constant sel_t BADSEL = sel_t(-1); -%constant size_t SIZE_MAX = size_t(-1); -/* %constant nodeidx_t BADNODE = nodeidx_t(-1); */ +%constant ea_t BADADDR = ea_t(0-1); +%constant ea32_t BADADDR32 = ea32_t(0-1ULL); +%constant ea64_t BADADDR64 = ea64_t(0-1ULL); +%constant sel_t BADSEL = sel_t(0-1); +%constant size_t SIZE_MAX = size_t(0-1); +/* %constant nodeidx_t BADNODE = nodeidx_t(0-1); */ %include "typemaps.i" @@ -41,11 +41,6 @@ // %} -%pythoncode %{ -import types -uses_swig_builtins = isinstance(get_inf_structure, types.BuiltinFunctionType) -%} - //------------------------------------------------------------------------- %inline %{ // diff --git a/swig/idbhooks.i b/swig/idbhooks.i index 83abeb0..af57fc0 100644 --- a/swig/idbhooks.i +++ b/swig/idbhooks.i @@ -1,5 +1,4 @@ %{ -#include #include %} diff --git a/swig/idd.i b/swig/idd.i index 1f571f2..4dc1417 100644 --- a/swig/idd.i +++ b/swig/idd.i @@ -5,6 +5,32 @@ #include %} +%ignore debugger_t::init_debugger(char const *,int,char const *); +%ignore debugger_t::get_processes(procinfo_vec_t *); +%ignore debugger_t::start_process(char const *,char const *,launch_env_t *,char const *,uint32,char const *,uint32); +%ignore debugger_t::attach_process(pid_t,int,uint32); +%ignore debugger_t::detach_process(); +%ignore debugger_t::request_pause(); +%ignore debugger_t::exit_process(); +%ignore debugger_t::resume(debug_event_t const *); +%ignore debugger_t::thread_suspend(thid_t); +%ignore debugger_t::thread_continue(thid_t); +%ignore debugger_t::set_resume_mode(thid_t,resume_mode_t); +%ignore debugger_t::read_registers(thid_t,int,regval_t *); +%ignore debugger_t::write_register(thid_t,int,regval_t const *); +%ignore debugger_t::thread_get_sreg_base(ea_t *,thid_t,int); +%ignore debugger_t::get_memory_info(meminfo_vec_t &); +%ignore debugger_t::read_memory(size_t *,ea_t,void *,size_t); +%ignore debugger_t::write_memory(size_t *,ea_t,void const *,size_t); +%ignore debugger_t::update_bpts(int *,update_bpt_info_t *,int,int); +%ignore debugger_t::update_lowcnds(int *,lowcnd_t const *,int); +%ignore debugger_t::open_file(char const *,uint64 *,bool); +%ignore debugger_t::read_file(int,qoff64_t,void *,size_t); +%ignore debugger_t::write_file(int,qoff64_t,void const *,size_t); +%ignore debugger_t::eval_lowcnd(thid_t,ea_t); +%ignore debugger_t::send_ioctl(int,void const *,size_t,void **,ssize_t *); +%ignore debugger_t::bin_search(ea_t *,ea_t,ea_t,compiled_binpat_vec_t const &,int); + %ignore dynamic_register_set_t; %ignore serialize_dynamic_register_set; %ignore deserialize_dynamic_register_set; @@ -17,7 +43,7 @@ %ignore debugger_t::notify; %ignore debugger_t::notify_drc; %ignore debugger_t::registers; -%ignore debugger_t::nregs; +%ignore debugger_t::nregisters; %ignore debugger_t::regclasses; %ignore debugger_t::bpt_bytes; %ignore debugger_t::default_port_number; @@ -30,7 +56,13 @@ %ignore idd_opinfo_t; %ignore gdecode_t; %ignore memory_buffer_t; + %ignore debug_event_t::exit_code(); +%ignore debug_event_t::bpt() const; +%ignore debug_event_t::exc() const; +%ignore debug_event_t::info() const; +%ignore debug_event_t::modinfo() const; + %ignore append_regval; %ignore extract_regvals; %ignore unpack_regvals; @@ -60,12 +92,12 @@ { dynamic_wrapped_array_t __get_registers() { - return dynamic_wrapped_array_t($self->registers, $self->nregs); + return dynamic_wrapped_array_t($self->registers, $self->nregisters); } - int __get_nregs() + int __get_nregisters() { - return $self->nregs; + return $self->nregisters; } PyObject *__get_regclasses() @@ -87,7 +119,7 @@ %pythoncode { registers = property(__get_registers) - nregs = property(__get_nregs) + nregisters = property(__get_nregisters) regclasses = property(__get_regclasses) bpt_bytes = property(__get_bpt_bytes) } @@ -137,6 +169,23 @@ } } +//------------------------------------------------------------------------- +%extend launch_env_t +{ + void set(const char *envvar, const char *value) + { + qstring envline = envvar; + envline += "="; + envline += value; + $self->push_back(envline); + } + + PyObject *envs() + { + return qstrvec2pylist(*$self, S2LF_EMPTY_NONE); + } +} + %{ // // diff --git a/swig/idp.i b/swig/idp.i index 35cd0f3..be7458c 100644 --- a/swig/idp.i +++ b/swig/idp.i @@ -100,7 +100,7 @@ struct undo_records_t; %ignore set_module_data; %ignore clr_module_data; %ignore get_module_data; -%ignore get_modctx; +%ignore get_eah; // @arnaud %ignore notify__calc_next_eas; @@ -130,6 +130,10 @@ struct undo_records_t; %apply size_t *OUTPUT { size_t *out_consumed }; %apply bytevec_t *vout { bytevec_t *out_relbits }; +%ignore processor_t::privrange_changed(range_t const &,adiff_t); +%ignore processor_t::cvt64_supval(nodeidx_t,uchar,nodeidx_t,uchar const *,size_t); +%ignore processor_t::cvt64_hashval(nodeidx_t,uchar,char const *,uchar const *,size_t); + // ev_cvt64_supval, ev_cvt64_hashval, ev_privrange_changed %const_pointer_and_size(uchar, data, datlen, bytevec_t, PyBytes_as_bytevec_t, size); %typemap(argout) (qstring *errbuf) @@ -173,15 +177,40 @@ struct undo_records_t; %fill_director_method_errbuf(ev_cvt64_hashval); %fill_director_method_errbuf(ev_privrange_changed); +%apply qstrvec_t *out { qstrvec_t *abi_names }; +%apply qstrvec_t *out_wrap_in_list_and_append { qstrvec_t *abi_opts }; + +%typemap(directorout) int ev_get_abi_info +{ + // %typemap(directorout) int get_abi_info + if ( result != Py_None ) + { + $result = PySequence_Check(result) && PySequence_Size(result) == 2; + if ( $result ) + { + newref_t r0(PySequence_GetItem(result, 0)); + newref_t r1(PySequence_GetItem(result, 1)); + $result = PyW_PySeqToStrVec(abi_names, r0.o) && PyW_PySeqToStrVec(abi_opts, r1.o); + } + + if ( !$result ) + { + Swig::DirectorTypeMismatchException::raise( + SWIG_ErrorType(SWIG_TypeError), + "in output value of type '" "int" "'" " in method '$symname'"); + } + } + else + { + $result = 0; // not implemented + } +} + // @arnaud ditch this once all modules are ported // temporary: %ignore out_old_data; %ignore out_old_specea; -%pywraps_nonnul_argument_prototype( - static PyObject *AssembleLine(ea_t ea, ea_t cs, ea_t ip, bool use32, const char *nonnul_line), - const char *nonnul_line); - #ifndef SWIGIMPORTED // let's not modify the wrappers for modules %import'ing us (e.g., typeinf.i, hexrays.i) %cstring_output_buf_and_size_returning_charptr( 1, @@ -226,10 +255,6 @@ struct undo_records_t; //------------------------------------------------------------------------- // IDB_Hooks //------------------------------------------------------------------------- -%{ -#include -%} - %define_Hooks_class(IDB); %inline %{ diff --git a/swig/ieee.i b/swig/ieee.i index c3ff784..68d1809 100644 --- a/swig/ieee.i +++ b/swig/ieee.i @@ -63,8 +63,7 @@ "invalid bytes " "in method '" "$symname" "', argument " "$argnum"" should be " #SIZE " bytes long"); } %enddef -%define_sized_bytevec_t(bytevec12_t, 12); -%define_sized_bytevec_t(bytevec10_t, 10); +%define_sized_bytevec_t(bytevec16_t, 16); %ignore fpvalue_t::from_half; %ignore fpvalue_t::from_float; @@ -84,37 +83,24 @@ return fp; } - fpvalue_t(const bytevec12_t &in) + fpvalue_t(const bytevec16_t &in) { fpvalue_t *fp = new fpvalue_t(); memmove(fp->w, in.begin(), sizeof(fp->w)); return fp; } - void _get_bytes(bytevec12_t *vout) const + void _get_bytes(bytevec16_t *vout) const { - vout->resize(12); + vout->resize(16); memmove(vout->begin(), (const void *) $self->w, vout->size()); } - void _set_bytes(const bytevec12_t &in) + void _set_bytes(const bytevec16_t &in) { memmove($self->w, (const void *) in.begin(), sizeof($self->w)); } - void _get_10bytes(bytevec10_t *vout) const - { - vout->resize(10); - memmove(vout->begin(), (const void *) $self->w, vout->size()); - } - - void _set_10bytes(const bytevec10_t &in) - { - CASSERT(sizeof($self) == 10); - memmove($self->w, (const void *) in.begin(), in.size()); // guaranteed to be 10 bytes long, thanks to %typemap(check) (const bytevec10_t) - $self->w[FPVAL_NWORDS-1] = 0; - } - // yes, it's called '_get_float', but we return a 'double' because // that 'double' will be for SWiG to turn the type into a Python // floating-point value with as much accuracy as possible. @@ -138,6 +124,11 @@ "The floating-point number couldn't be converted"); } + fpvalue_t copy() const + { + return *$self; + } + qstring __str__() const { char buf[MAXSTR]; @@ -152,6 +143,14 @@ return wrapped_array_t($self->w); } + static fpvalue_t new_from_str(const char *p) + { + fpvalue_t v; + if ( v.from_str(&p) != REAL_ERROR_OK ) + v.clear(); + return v; + } + fpvalue_error_t from_str(const char *p) { return p != nullptr ? $self->from_str(&p) : REAL_ERROR_BADSTR; @@ -165,7 +164,6 @@ %pythoncode { bytes = property(_get_bytes, _set_bytes) - _10bytes = property(_get_10bytes, _set_10bytes) shorts = property(_get_shorts) float = property(_get_float, _set_float) sval = property(lambda self: self.to_sval(), lambda self, v: self.from_sval(v)) @@ -182,6 +180,10 @@ def __setitem__(self, i, v): self.shorts[i] = v + + def __repr__(self): + return f"{self.__class__.__module__}.{self.__class__.__name__}.new_from_str('{str(self)}')" + } } diff --git a/swig/kernwin.i b/swig/kernwin.i index d582cf1..3f932a0 100644 --- a/swig/kernwin.i +++ b/swig/kernwin.i @@ -75,11 +75,33 @@ struct dirspec_t; $result = qstrvec2pylist(*$1); } +%template(tagged_line_section_vec_t) qvector; + %rename (del_hotkey) py_del_hotkey; %rename (add_hotkey) py_add_hotkey; %ignore msg; %rename (msg) py_msg; +%ignore warning; +%rename (warning) py_warning; +%ignore error; +%rename (error) py_error; + +%feature("pythonprepend") py_msg %{ + if isinstance(message, bytes): + message = message.decode("UTF-8") +%} + +%feature("pythonprepend") py_warning %{ + if isinstance(message, bytes): + message = message.decode("UTF-8") +%} + +%feature("pythonprepend") py_error %{ + if isinstance(message, bytes): + message = message.decode("UTF-8") +%} + %ignore vinfo; @@ -174,6 +196,21 @@ struct dirspec_t; } } +%extend tagged_line_section_t { + qstring __str__() const + { + qstring qs; + qs.sprnt("{start=%d, length=%d (end=%d), byte_offsets={text_start=%d, text_end=%d}, tag=%d}", + $self->start, + $self->length, + $self->start + $self->length, + $self->byte_offsets.text_start, + $self->byte_offsets.text_end, + $self->tag); + return qs; + } +} + // Make ask_addr(), ask_seg(), and ask_long() return a // tuple: (result, value) %rename (_ask_long) ask_long; @@ -194,6 +231,13 @@ struct dirspec_t; %ignore place_t__generate; %rename (generate) py_generate; %newobject place_t::clone; +// disable destruction of place_t and its children +%nodefaultdtor place_t; +%nodefaultdtor simpleline_place_t; +%nodefaultdtor idaplace_t; +%nodefaultdtor structplace_t; +%nodefaultdtor enumplace_t; +%nodefaultdtor tiplace_t; // For place_t::serialize() %apply bytevec_t *vout { bytevec_t *out }; @@ -350,6 +394,7 @@ SWIG_DECLARE_PY_CLINKED_OBJECT(textctrl_info_t) %ignore qvector::resize; %ignore qvector::push_back(); %template(sync_source_vec_t) qvector; +%ignore add_test_feature; // // @@ -431,14 +476,10 @@ SWIG_DECLARE_PY_CLINKED_OBJECT(textctrl_info_t) //------------------------------------------------------------------------- %newobject place_t::as_idaplace_t; -%newobject place_t::as_enumplace_t; -%newobject place_t::as_structplace_t; %newobject place_t::as_simpleline_place_t; %newobject place_t::as_tiplace_t; %extend place_t { static idaplace_t *as_idaplace_t(place_t *p) { return p != nullptr ? (idaplace_t *) p->clone() : nullptr; } - static enumplace_t *as_enumplace_t(place_t *p) { return p != nullptr ? (enumplace_t *) p->clone() : nullptr; } - static structplace_t *as_structplace_t(place_t *p) { return p != nullptr ? (structplace_t *) p->clone() : nullptr; } static simpleline_place_t *as_simpleline_place_t(place_t *p) { return p != nullptr ? (simpleline_place_t *) p->clone() : nullptr; } static tiplace_t *as_tiplace_t(place_t *p) { return p != nullptr ? (tiplace_t *) p->clone() : nullptr; } @@ -463,10 +504,6 @@ SWIG_DECLARE_PY_CLINKED_OBJECT(textctrl_info_t) %pythoncode { 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_tiplace_t(self): @@ -476,10 +513,6 @@ SWIG_DECLARE_PY_CLINKED_OBJECT(textctrl_info_t) ptype = get_viewer_place_type(view) if ptype == TCCPT_IDAPLACE: return self.place_as_idaplace_t() - elif ptype == TCCPT_ENUMPLACE: - return self.place_as_enumplace_t() - elif ptype == TCCPT_STRUCTPLACE: - return self.place_as_structplace_t() elif ptype == TCCPT_SIMPLELINE_PLACE: return self.place_as_simpleline_place_t() elif ptype == TCCPT_TIPLACE: @@ -630,3 +663,8 @@ SWIG_DECLARE_PY_CLINKED_OBJECT(textctrl_info_t) # # %} + +%pythoncode %{ +# +# +%} diff --git a/swig/libfuncs.i b/swig/libfuncs.i new file mode 100644 index 0000000..7677efd --- /dev/null +++ b/swig/libfuncs.i @@ -0,0 +1,8 @@ + +%{ +#include +%} +%ignore fix_version; +%apply qstring *result { qstring *out_libname}; +%apply qstring *result { qstring *out_fullpath}; +%include "libfuncs.hpp" \ No newline at end of file diff --git a/swig/lines.i b/swig/lines.i index 4b27263..1f0e7fc 100644 --- a/swig/lines.i +++ b/swig/lines.i @@ -17,11 +17,6 @@ $1 = nullptr; } -// compat -%ignore set_user_defined_prefix; -%rename (set_user_defined_prefix) py_set_user_defined_prefix; -// end compat - %ignore generate_disassembly; %rename (generate_disassembly) py_generate_disassembly; @@ -60,13 +55,8 @@ %include "lines.hpp" -%{ -// -// -%} - %pywraps_nonnul_argument_prototype( - PyObject *py_tag_remove(const char *nonnul_instr), + qstring py_tag_remove(const char *nonnul_instr), const char *nonnul_instr); %inline %{ diff --git a/swig/loader.i b/swig/loader.i index 67848cf..233ce74 100644 --- a/swig/loader.i +++ b/swig/loader.i @@ -74,6 +74,8 @@ %ignore load_and_run_plugin; %rename (load_and_run_plugin) py_load_and_run_plugin; +%ignore process_archive(qstring *,linput_t *,qstring *,ushort *,char const *,load_info_t const *); + %ignore extract_module_from_archive; %rename (extract_module_from_archive) py_extract_module_from_archive; diff --git a/swig/lumina.i b/swig/lumina.i index ba5eb4d..193376f 100644 --- a/swig/lumina.i +++ b/swig/lumina.i @@ -115,7 +115,7 @@ { // bytes_container typemap(argout) (metadata_t *out_md) PyObject *py_md = PyBytes_FromStringAndSize((const char *) $1->begin(), $1->size()); - $result = SWIG_Python_AppendOutput($result, py_md); + $result = SWIG_Python_AppendOutput($result, py_md, /*is_void=*/ 1); } @@ -152,7 +152,7 @@ { // typemap(argout) (md5_t *out) PyObject *py_hash = PyBytes_FromStringAndSize((const char *) $1->hash, sizeof($1->hash)); - $result = SWIG_Python_AppendOutput($result, py_hash); + $result = SWIG_Python_AppendOutput($result, py_hash, /*is_void=*/ 1); } %apply md5_t *out { md5_t *out_hash }; diff --git a/swig/merge.i b/swig/merge.i index c4c48f0..5f75e63 100644 --- a/swig/merge.i +++ b/swig/merge.i @@ -123,38 +123,6 @@ typedef int diff_source_idx_t; // const merge_node_info2_t *valdesc, // size_t nvals, // bool skip_empty_nodes = true); -%typemap(in,numinputs=0) (int moddata_id) { $1 = -1; } -%typemap(in,numinputs=1) (const merge_node_info2_t *valdesc, size_t nvals) (qvector temp) -{ - if ( $input == Py_None ) - { - $2 = 0; - $1 = nullptr; - } - else - { - if ( !PySequence_Check($input) ) - { - PyErr_SetString(PyExc_TypeError, "Expecting a list of `merge_node_info2_t` instances"); - return nullptr; - } - PyObject *s = $input; - Py_ssize_t len = PySequence_Size(s); - temp.reserve(len); - for ( Py_ssize_t i = 0; i < len; ++i ) - { - newref_t o(PySequence_GetItem(s, i)); - void *ap = 0 ; - int cvt = SWIG_ConvertPtr(o.o, &ap, SWIGTYPE_p_merge_node_info2_t, 0); - if ( !SWIG_IsOK(cvt) ) - SWIG_exception_fail( - SWIG_ArgError(cvt), - "in method '" "$symname" "', argument " "$argnum"" consists of 'merge_node_info2_t' instances"); - temp.push_back(*reinterpret_cast(ap)); - } - $2 = temp.size(); - $1 = temp.extract(); - } -} +%define_merge_handler_typemap(valdesc, nvals); %include "merge.hpp" diff --git a/swig/mergemod.i b/swig/mergemod.i index 3d2229a..503f148 100644 --- a/swig/mergemod.i +++ b/swig/mergemod.i @@ -5,6 +5,7 @@ %ignore create_std_modmerge_handlers; %rename(create_std_modmerge_handlers) create_std_modmerge_handlers2; +%ignore create_std_modmerge_handlers2(merge_handler_params_t &,int,moddata_diff_helper_t &,merge_node_info2_t const *); // Prototype of the custom function to create merge handlers %ignore create_merge_handlers; @@ -15,39 +16,7 @@ // moddata_diff_helper_t &helper, // const merge_node_info2_t *merge_node_info=nullptr, // size_t n_merge_node_info=0); -%typemap(in,numinputs=0) (int moddata_id) { $1 = -1; } -%typemap(in,numinputs=1) (const merge_node_info2_t *merge_node_info, size_t n_merge_node_info) (qvector temp) -{ - if ( $input == Py_None ) - { - $2 = 0; - $1 = nullptr; - } - else - { - if ( !PySequence_Check($input) ) - { - PyErr_SetString(PyExc_TypeError, "Expecting a list of `merge_node_info2_t` instances"); - return nullptr; - } - PyObject *s = $input; - Py_ssize_t len = PySequence_Size(s); - temp.reserve(len); - for ( Py_ssize_t i = 0; i < len; ++i ) - { - newref_t o(PySequence_GetItem(s, i)); - void *ap = 0 ; - int cvt = SWIG_ConvertPtr(o.o, &ap, SWIGTYPE_p_merge_node_info2_t, 0); - if ( !SWIG_IsOK(cvt) ) - SWIG_exception_fail( - SWIG_ArgError(cvt), - "in method '" "$symname" "', argument " "$argnum"" consists of 'merge_node_info2_t' instances"); - temp.push_back(*reinterpret_cast(ap)); - } - $2 = temp.size(); - $1 = temp.extract(); - } -} +%define_merge_handler_typemap(merge_node_info, n_merge_node_info); %include "mergemod.hpp" diff --git a/swig/moves.i b/swig/moves.i index 6714dc4..8188d23 100644 --- a/swig/moves.i +++ b/swig/moves.i @@ -10,9 +10,13 @@ %ignore lochist_t::rebase_stack; %ignore location_t::location_t(bool); %ignore lochist_t::is_hexrays68_compat; + %ignore lochist_entry_t::set_place(const place_t &); +%ignore lochist_entry_t::place() const; +%ignore lochist_entry_t::renderer_info() const; %ignore lochist_entry_t::serialize; %ignore lochist_entry_t::deserialize; + %ignore graph_location_info_t::serialize(bytevec_t *) const; %ignore graph_location_info_t::deserialize(memory_deserializer_t &); %ignore renderer_info_pos_t::serialize(bytevec_t *) const; @@ -101,3 +105,8 @@ } %include "moves.hpp" + +%pythoncode %{ +# +# +%} diff --git a/swig/name.i b/swig/name.i index baa0e5c..80f164e 100644 --- a/swig/name.i +++ b/swig/name.i @@ -25,12 +25,19 @@ // Duplicate names, in-out qstring w/ existing // qstring-returning alternatives. %ignore get_visible_name(qstring *, ea_t, int); +%ignore get_visible_name(qstring *, ea_t); %ignore get_short_name(qstring *, ea_t, int); +%ignore get_short_name(qstring *, ea_t); %ignore get_long_name(qstring *, ea_t, int); +%ignore get_long_name(qstring *, ea_t); %ignore get_colored_short_name(qstring *, ea_t, int); +%ignore get_colored_short_name(qstring *, ea_t); %ignore get_colored_long_name(qstring *, ea_t, int); +%ignore get_colored_long_name(qstring *, ea_t); %ignore get_demangled_name(qstring *, ea_t, int32, int, int); +%ignore get_demangled_name(qstring *, ea_t, int32, int); %ignore get_colored_demangled_name(qstring *, ea_t, int32, int, int); +%ignore get_colored_demangled_name(qstring *, ea_t, int32, int); %uncomparable_elements_qvector(ea_name_t, ea_name_vec_t); @@ -43,10 +50,12 @@ // 'flags' versions, they can still rely on get_ea_name(). %define %restrict_ambiguous_name_function(FNAME) %ignore FNAME(qstring *, ea_t, int); +%ignore FNAME(qstring *, ea_t); %ignore FNAME(ea_t, int); %rename (FNAME) py_ ## FNAME; %ignore demangle_name(const char *, uint32, demreq_type_t); +%ignore demangle_name(const char *, uint32); %inline %{ inline qstring py_## FNAME(ea_t ea) { return FNAME(ea); } diff --git a/swig/netnode.i b/swig/netnode.i index e4151df..83db7c4 100644 --- a/swig/netnode.i +++ b/swig/netnode.i @@ -22,9 +22,11 @@ %ignore netnode_supstr; %ignore netnode_qsupstr; %ignore netnode::supstr(nodeidx_t,char*,size_t,uchar) const; +%ignore netnode::supstr(nodeidx_t,char*,size_t) const; %ignore netnode_supstr_ea; %ignore netnode_qsupstr_ea; %ignore netnode::supstr_ea(ea_t,char*,size_t,uchar) const; +%ignore netnode::supstr_ea(ea_t,char*,size_t) const; %ignore netnode_supset; %ignore netnode_supdel; %ignore netnode_lower_bound; @@ -36,6 +38,7 @@ %ignore netnode_supstr_idx8; %ignore netnode_qsupstr_idx8; %ignore netnode::supstr_idx8(uchar,char*,size_t,uchar) const; +%ignore netnode::supstr_idx8(uchar,char*,size_t) const; %ignore netnode_supset_idx8; %ignore netnode_supdel_idx8; %ignore netnode_lower_bound_idx8; @@ -50,21 +53,26 @@ %ignore netnode_hashstr; %ignore netnode_qhashstr; %ignore netnode::hashstr(const char*,char*,size_t,uchar) const; +%ignore netnode::hashstr(const char*,char*,size_t) const; %ignore netnode_hashval_long; %ignore netnode_hashset; %ignore netnode_hashdel; %ignore netnode_hashfirst; %ignore netnode_qhashfirst; %ignore netnode::hashfirst(char*,size_t,uchar) const; +%ignore netnode::hashfirst(char*,size_t) const; %ignore netnode_hashnext; %ignore netnode_qhashnext; %ignore netnode::hashnext(const char*,char*,size_t,uchar) const; +%ignore netnode::hashnext(const char*,char*,size_t) const; %ignore netnode_hashlast; %ignore netnode_qhashlast; %ignore netnode::hashlast(char*,size_t,uchar) const; +%ignore netnode::hashlast(char*,size_t) const; %ignore netnode_hashprev; %ignore netnode_qhashprev; %ignore netnode::hashprev(const char*,char*,size_t,uchar) const; +%ignore netnode::hashprev(const char*,char*,size_t) const; %ignore netnode_blobsize; %ignore netnode_getblob; %ignore netnode_qgetblob; @@ -125,6 +133,9 @@ %include "netnode.hpp" +%ignore netnode::supset(nodeidx_t, const char *); +%ignore netnode::supset_ea(ea_t, const char *); + %extend netnode { nodeidx_t index() @@ -183,3 +194,8 @@ return self->supset_ea(ea, (void *) value, length, tag); } } + +%pythoncode %{ +# +# +%} diff --git a/swig/pro.i b/swig/pro.i index 9f664cf..de0b6bc 100644 --- a/swig/pro.i +++ b/swig/pro.i @@ -42,6 +42,7 @@ %ignore plugin_option_t; %ignore plugins_option_t; %ignore parse_plugin_options; +%ignore build_plugin_options; %ignore test_bit; %ignore set_bit; %ignore set_bits; @@ -125,6 +126,7 @@ %ignore call_atexits; %ignore launch_process_params_t; %ignore launch_process; +%ignore pipe_process; %ignore term_process; %ignore get_process_exit_code; %ignore BELOW_NORMAL_PRIORITY_CLASS; @@ -139,6 +141,9 @@ %ignore qstrlwr; %ignore qstrupr; +// do not generate operator delete etc. +%feature("nodirector") qrefcnt_obj_t; + %extend qrefcnt_t { size_t __ptrval__() const { @@ -164,7 +169,6 @@ %import "ida.hpp" %import "xref.hpp" %import "typeinf.hpp" - %import "enum.hpp" %import "netnode.hpp" #endif @@ -197,18 +201,46 @@ SWIG_DECLARE_PY_CLINKED_OBJECT(qstrvec_t) // %} +// Create wrapper classes for basic type arrays #ifdef IDA_MODULE_PRO - %include "carrays.i" - %include "cpointer.i" + %include + %include %array_class(uchar, uchar_array); %array_class(tid_t, tid_array); %array_class(ea_t, ea_array); %array_class(sel_t, sel_array); %array_class(uval_t, uval_array); - %pointer_class(int, int_pointer); - %pointer_class(ea_t, ea_pointer); - %pointer_class(sval_t, sval_pointer); - %pointer_class(sel_t, sel_pointer); + + // wrappers for everything in pro.h that our API functions expect to be passed + %pointer_class(uchar , uchar_pointer); + %pointer_class(ushort , ushort_pointer); + %pointer_class(uint , uint_pointer); + %pointer_class(sint8 , sint8_pointer); + %pointer_class(int8 , int8_pointer); + %pointer_class(uint8 , uint8_pointer); + %pointer_class(int16 , int16_pointer); + %pointer_class(uint16 , uint16_pointer); + %pointer_class(int32 , int32_pointer); + %pointer_class(uint32 , uint32_pointer); + %pointer_class(int64 , int64_pointer); + %pointer_class(uint64 , uint64_pointer); + %pointer_class(ssize_t , ssize_pointer); + %pointer_class(bool , bool_pointer); + %pointer_class(char , char_pointer); + %pointer_class(short , short_pointer); + %pointer_class(int , int_pointer); + %pointer_class(ea_t , ea_pointer); + %pointer_class(sel_t , sel_pointer); + %pointer_class(asize_t , asize_pointer); + %pointer_class(adiff_t , adiff_pointer); + %pointer_class(uval_t , uval_pointer); + %pointer_class(sval_t , sval_pointer); + %pointer_class(ea32_t , ea32_pointer); + %pointer_class(ea64_t , ea64_pointer); + %pointer_class(flags_t , flags_pointer); + %pointer_class(flags64_t , flags64_pointer); + %pointer_class(tid_t , tid_pointer); + #endif %pythoncode %{ diff --git a/swig/range.i b/swig/range.i index 8c6363a..f758fd9 100644 --- a/swig/range.i +++ b/swig/range.i @@ -1,8 +1,12 @@ + %ignore rangeset_t::count; %ignore rangeset_t::lower_bound; %ignore rangeset_t::upper_bound; %ignore rangeset_t::move_chunk; %ignore rangeset_t::check_move_args; +%ignore rangeset_t::begin() const; +%ignore rangeset_t::end() const; + %ignore range64_t; %ignore range64vec_t; diff --git a/swig/regfinder.i b/swig/regfinder.i index de30f08..a74fd5c 100644 --- a/swig/regfinder.i +++ b/swig/regfinder.i @@ -24,19 +24,21 @@ //------------------------------------------------------------------------- // ignore helpers -%ignore reg_finder_invalidate_cache(reg_finder_t *_this, ea_t ea); -%ignore reg_finder_find(reg_finder_t *_this, reg_value_info_t *out, ea_t ea, ea_t ds, reg_finder_op_t op, int max_depth); -%ignore reg_finder_calc_op_addr(reg_finder_t *_this, reg_value_info_t *addr, const op_t *memop, const insn_t *insn, ea_t ea, ea_t ds); +%ignore reg_finder_invalidate_cache(reg_finder_t *_this, ea_t to, ea_t from); +%ignore reg_finder_invalidate_cache(reg_finder_t *_this); +%ignore reg_finder_find(reg_finder_t *_this, reg_value_info_t *out, ea_t ea, ea_t ds, reg_finder_op_t op, int max_depth, size_t linear_insns); +%ignore reg_finder_calc_op_addr(reg_finder_t *_this, reg_value_info_t *addr, const op_t *memop, const insn_t *insn, ea_t ea, ea_t ds, int max_depth); %ignore reg_finder_emulate_mem_read(reg_finder_t *_this, reg_value_info_t *value, const reg_value_info_t *addr, int width, bool is_signed, const insn_t *insn); %ignore reg_finder_emulate_binary_op(reg_finder_t *_this, reg_value_info_t *value, int aop, const op_t *op1, const op_t *op2, const insn_t *insn, ea_t ea, ea_t ds, reg_finder_binary_ops_adjust_fun adjust, void *ud); %ignore reg_finder_emulate_unary_op(reg_finder_t *_this, reg_value_info_t *value, int aop, int reg, const insn_t *insn, ea_t ea, ea_t ds); -%ignore reg_finder_may_modify_stkvars(const reg_finder_t *_this, reg_finder_op_t op, const insn_t *insn); +%ignore reg_finder_may_modify_stkvar(reg_finder_t *_this, reg_finder_op_t op, const insn_t *insn); +%ignore reg_finder_can_resolve_mem(const reg_finder_t *_this, ea_t ea); %ignore reg_finder_ctr(reg_finder_t *_this); %ignore reg_finder_dtr(reg_finder_t *_this); %ignore reg_value_def_dstr(const reg_value_def_t *_this, qstring *vout, int how, const procmod_t *pm); %ignore reg_value_info_dstr(const reg_value_info_t *_this, qstring *vout, const procmod_t *pm); %ignore reg_value_info_vals_union(reg_value_info_t *_this, const reg_value_info_t *r); -%ignore reg_finder_op_make_rfop(func_t *pfn, const insn_t *insn, const op_t *op); +%ignore reg_finder_make_rfop(reg_finder_t *_this, reg_finder_op_t *rfop, const op_t *op, const insn_t *insn, func_t *pfn); //------------------------------------------------------------------------- // add access to reg_value_info_t::vals diff --git a/swig/search.i b/swig/search.i index 21d1e92..d04e47a 100644 --- a/swig/search.i +++ b/swig/search.i @@ -6,6 +6,11 @@ %ignore search; %ignore user2bin; +%ignore find_error(ea_t,int); +%ignore find_notype(ea_t,int); +%ignore find_suspop(ea_t,int); +%ignore find_imm(ea_t,int,uval_t); + %pythoncode %{ # # diff --git a/swig/struct.i b/swig/struct.i deleted file mode 100644 index dcfc005..0000000 --- a/swig/struct.i +++ /dev/null @@ -1,75 +0,0 @@ -%{ -#include -%} -// Kernel-only symbols -%ignore save_structs; -%ignore get_struc_name(tid_t, int); -%ignore get_member_name(tid_t); -%ignore get_member_by_id(tid_t, struc_t **); // allow version w/ qstring* only - -%ignore get_innermost_member; -%rename (get_innermost_member) py_get_innermost_member; - -%ignore MF_RESERVED1; - -//------------------------------------------------------------------------- -// For 'get_member_by_id()' -%typemap(in,numinputs=0) qstring *out_mname (qstring temp) { - $1 = &temp; -} -%typemap(argout) qstring *out_mname { - if (result) - { - %append_output(PyUnicode_FromStringAndSize($1->begin(), $1->length())); - } - else - { - Py_XDECREF(resultobj); - Py_INCREF(Py_None); - resultobj = Py_None; - } -} -%typemap(freearg) qstring* out_mname -{ - // Nothing. We certainly don't want 'temp' to be deleted. -} - -//------------------------------------------------------------------------- -// For 'get_member_by_fullname()' and 'get_member_by_id()' -%typemap(in,numinputs=0) struc_t **sptr_place (struc_t *temp) { - $1 = &temp; -} -%typemap(argout) struc_t **sptr_place { - if ( result ) - { - %append_output(SWIG_NewPointerObj(SWIG_as_voidptr(*($1)), SWIGTYPE_p_struc_t, 0 | 0 )); - } - else - { - Py_XDECREF(resultobj); - Py_INCREF(Py_None); - resultobj = Py_None; - } -} - -%template (dyn_member_ref_array) dynamic_wrapped_array_t; - -//------------------------------------------------------------------------- -%include "struct.hpp" -%extend struc_t { - dynamic_wrapped_array_t __get_members__() - { - return dynamic_wrapped_array_t($self->members, $self->memqty); - } - - %pythoncode { - members = property(__get_members__) - def get_member(self, index): - return self.members[index] - } -} - -%inline %{ -// -// -%} diff --git a/swig/typeinf.i b/swig/typeinf.i index f3f4655..e69a379 100644 --- a/swig/typeinf.i +++ b/swig/typeinf.i @@ -1,6 +1,5 @@ %{ #include -#include %} %constant bmask64_t DEFMASK64 = bmask64_t(-1); @@ -23,6 +22,8 @@ %ignore get_int_type_bit; %ignore get_unk_type_bit; %ignore tns; +%ignore get_frame_var; +%ignore tinfo_get_func_frame; %ignore til_t::syms; %ignore til_t::types; @@ -45,9 +46,22 @@ %ignore get_argloc_info; %ignore argloc_t::dstr; %ignore argloc_t::consume_scattered(scattered_aloc_t *p); +%ignore argloc_t::scattered() const; +%ignore argloc_t::get_rrel() const; %ignore argpart_t::copy_from; -%ignore get_numbered_type(const til_t *, uint32, const type_t **, const p_list **, const char **, const p_list **, sclass_t *); +%ignore get_idainfo_by_type(size_t *,flags64_t *,opinfo_t *,tinfo_t const &); + +// because default args! +%ignore ::get_numbered_type(const til_t *, uint32, const type_t **, const p_list **, const char **, const p_list **, sclass_t *); +%ignore ::get_numbered_type(const til_t *, uint32, const type_t **, const p_list **, const char **, const p_list **); +%ignore ::get_numbered_type(const til_t *, uint32, const type_t **, const p_list **, const char **); +%ignore ::get_numbered_type(const til_t *, uint32, const type_t **, const p_list **); +%ignore ::get_numbered_type(const til_t *, uint32, const type_t **); +%ignore ::get_numbered_type(const til_t *, uint32); +%ignore tinfo_t::get_innermost_udm(uint64, size_t *) const; +%ignore tinfo_t::get_innermost_udm(uint64) const; +%ignore tinfo_t::get_innermost_member_type(uint64) const; %rename (get_numbered_type) py_get_numbered_type; %ignore NTF_NOSYNC; @@ -69,6 +83,10 @@ %rename (get_named_type64) py_get_named_type64; %rename ("%s") tinfo_t::get_named_type; +%ignore set_numbered_type; +%rename (set_numbered_type) py_set_numbered_type; +%rename ("%s") tinfo_t::set_numbered_type; + %rename (print_decls) py_print_decls; %ignore print_decls; @@ -135,24 +153,29 @@ %ignore name_requires_qualifier; %ignore tinfo_visitor_t::level; %ignore tinfo_t::serialize(qtype *, qtype *, qtype *, int) const; +%ignore tinfo_t::get_stkvar(sval_t *, const insn_t &, const op_t *, sval_t); %ignore tinfo_t::deserialize(const til_t *, const qtype *, const qtype *, const qtype *, const char *); %ignore tinfo_get_innermost_udm; %ignore save_tinfo2; -// Let's declare our own version of `deserialize_tinfo2` before + +// Let's declare our own version of `deserialize_tinfo` before // SWiG hits the one that's in `typeinf.hpp` (and cannot, alas, // enjoy the addition of the default value.) -%rename (deserialize_tinfo) deserialize_tinfo2; %inline %{ -idaman bool ida_export deserialize_tinfo2(tinfo_t *tif, const til_t *til, const type_t **ptype, const p_list **pfields, const p_list **pfldcmts, const char *cmt=nullptr); +idaman bool ida_export deserialize_tinfo(tinfo_t *tif, const til_t *til, const type_t **ptype, const p_list **pfields, const p_list **pfldcmts, const char *cmt=nullptr); %} %ignore deserialize_tinfo; -%ignore deserialize_tinfo2; %ignore get_udm_by_tid(tinfo_t *tif, udm_t *udm, tid_t tid); %ignore get_edm_by_tid(tinfo_t *tif, edm_t *edm, tid_t tid); %ignore get_type_by_tid(tinfo_t *tif, tid_t tid); %ignore get_tinfo_by_edm_name(tinfo_t *tif, til_t *til, const char *mname); +%ignore get_frame_var(tinfo_t *tif, sval_t *actval, const insn_t &insn, const op_t &x, sval_t v); %ignore value_repr_t__parse_value_repr; +%ignore enum_type_data_t__get_value_repr; %ignore enum_type_data_t__set_value_repr; +%ignore enum_type_data_t__get_max_serial; +%ignore enum_type_data_t::get_constant_group(size_t *, size_t *, size_t); +%ignore get_tinfo_tid; %ignore custloc_desc_t; %ignore install_custom_argloc; @@ -181,6 +204,68 @@ idaman bool ida_export deserialize_tinfo2(tinfo_t *tif, const til_t *til, const { return (n < 0 || n >= $self->nbases) ? nullptr : $self->base[n]; } + + bool operator==(const til_t *r) + { + return $self == r; + } + + bool operator!=(const til_t *r) + { + return $self != r; + } + + tinfo_t import_type(const tinfo_t &src) + { + tinfo_t tif; + if ( !src.empty() ) + { + qstring src_name; + if ( src.get_type_name(&src_name) ) + { + const til_t *src_til = src.get_til(); + if ( src_til != nullptr ) + { + uint32 ord = copy_named_type($self, src_til, src_name.c_str()); + if ( ord != 0 ) + tif.get_numbered_type($self, ord); + } + } + } + return tif; + } + + %pythoncode { + def named_types(self): + for name in self.type_names: + tif = tinfo_t() # a new type. Always + if tif.get_named_type(self, name): + yield tif + + def numbered_types(self): + for ord in range(1, get_ordinal_limit(self)): + tif = tinfo_t() # a new type. Always + if tif.get_numbered_type(self, ord): + yield tif + + def get_named_type(self, name): + tif = tinfo_t() + if tif.get_named_type(self, name): + return tif + + def get_numbered_type(self, ordinal): + tif = tinfo_t() + if tif.get_numbered_type(self, ordinal): + return tif + + def get_type_names(self): + n = first_named_type(self, NTF_TYPE) + while n: + yield n + n = next_named_type(self, n, NTF_TYPE) + + type_names = property(get_type_names) + } } //------------------------------------------------------------------------- @@ -201,6 +286,14 @@ idaman bool ida_export deserialize_tinfo2(tinfo_t *tif, const til_t *til, const return $self->deserialize(til, &type, &fields, cmts == nullptr ? nullptr : &cmts); } + ssize_t get_stkvar( + const insn_t &insn, + const op_t x, + sval_t v) + { + return ::get_frame_var($self, nullptr, insn, &x, v); + } + tinfo_t copy() const { return *$self; @@ -267,7 +360,58 @@ idaman bool ida_export deserialize_tinfo2(tinfo_t *tif, const til_t *til, const } %template(udtmembervec_template_t) qvector; %ignore udt_type_data_t::VERSION; -%ignore udt_type_data_old_t; +%ignore udt_type_data_t::get_best_fit_member(asize_t) const; + +%feature("shadow") tinfo_t::tinfo_t %{ +def __init__(self, *args, ordinal=None, name=None, tid=None, til=None): + _ida_typeinf.tinfo_t_swiginit(self, _ida_typeinf.new_tinfo_t(*args)) + if args and self.empty(): + raise ValueError("Invalid input data: %s" % str(args)) + elif ordinal is not None: + if not self.get_numbered_type(til, ordinal): + raise ValueError("No type with ordinal %s in type library %s" % (ordinal, til)) + elif name is not None: + if not self.get_named_type(til, name): + raise ValueError("No type with name %s in type library %s" % (name, til)) + elif tid is not None: + if not self.get_type_by_tid(tid): + raise ValueError("No type with ID %s in type library %s" % (name, til)) +%} + +// We want to make it possible to support both: +// tinfo_t::get_edm(size_t idx) +// tinfo_t::get_edm(edm_t *out, size_t idx) +// but to do that, we cannot just apply an out typemap to `edm_t *`: +// SWiG will collapse the 2 methods into 1. So we resort to a +// made-up type! +%inline %{ + typedef edm_t out_edm_t; +%} + +%typemap(in,numinputs=0) out_edm_t *out_edm (out_edm_t temp) +{ + // %typemap(in,numinputs=0) out_edm_t *out_edm (out_edm_t temp) + $1 = &temp; +} +%typemap(argout) out_edm_t *out_edm +{ + // %typemap(argout) out_edm_t *out_edm + if ( result > -1 ) + { + PyObject *py_edm = SWIG_NewPointerObj(new out_edm_t(*($1)), $1_descriptor, SWIG_POINTER_OWN | 0); + $result = SWIG_Python_AppendOutput($result, py_edm, /*is_void=*/ 1); + } + else + { + Py_INCREF(Py_None); + $result = SWIG_Python_AppendOutput($result, Py_None, /*is_void=*/ 1); + } +} +%typemap(freearg) out_edm_t *out_edm +{ + // %typemap(freearg) out_edm_t *out_edm + // Nothing. We certainly don't want 'temp' to be deleted. +} %extend tinfo_t { PyObject *get_attr(const qstring &key, bool all_attrs=true) @@ -278,9 +422,133 @@ idaman bool ida_export deserialize_tinfo2(tinfo_t *tif, const til_t *til, const else Py_RETURN_NONE; } + + int get_edm(out_edm_t *out_edm, size_t idx) const + { + tinfo_code_t rc = $self->get_edm((edm_t *) out_edm, idx); + return rc == TERR_OK ? idx : -1; + } + + // bw-compat + ssize_t find_edm(edm_t *edm, uint64 value, bmask64_t bmask=DEFMASK64, uchar serial=0) const + { return $self->get_edm_by_value(edm, value, bmask, serial); } + + // bw-compat + ssize_t find_edm(edm_t *edm, const char *name) const + { return $self->get_edm(edm, name); } + + %pythoncode { + + def __repr__(self): + if self.present(): + til = self.get_til() + if til == get_idati(): + name = self.get_type_name() + if name: + return f'{self.__class__.__module__}.{self.__class__.__name__}(get_idati(), "{name}")' + else: + ord = self.get_ordinal() + if ord > 0: + return f'{self.__class__.__module__}.{self.__class__.__name__}(get_idati(), {ord})' + return f'{self.__class__.__module__}.{self.__class__.__name__}("""{self._print()}""")' + return f'{self.__class__.__module__}.{self.__class__.__name__}()' + + def iter_struct(self): + udt = udt_type_data_t() + if not self.is_struct() or not self.get_udt_details(udt): + raise TypeError("Type is not a structure") + for udm in udt: + yield udm_t(udm) + + + def iter_union(self): + udt = udt_type_data_t() + if not self.is_union() or not self.get_udt_details(udt): + raise TypeError("Type is not a union") + for udm in udt: + yield udm_t(udm) + + def iter_udt(self): + udt = udt_type_data_t() + if not self.is_udt() or not self.get_udt_details(udt): + raise TypeError("Type is not a structure or union") + for udm in udt: + yield udm_t(udm) + + def iter_enum(self): + edt = enum_type_data_t() + if not self.is_enum() or not self.get_enum_details(edt): + raise TypeError("Type is not a structure") + for edm in edt: + yield edm_t(edm) + + def iter_func(self): + fdt = func_type_data_t() + if not self.is_func() or not self.get_func_details(fdt): + raise TypeError("Type is not a function") + for arg in fdt: + yield funcarg_t(arg) + + get_edm_by_name = get_by_edm_name # bw-compat + } } %ignore tinfo_t::get_attr; +%extend enum_type_data_t +{ + // \ref enum_type_data_t::get_constant_group but return tupple (group_start_index, group_size) + PyObject *get_constant_group(size_t idx) const + { + size_t group_start_index; + size_t group_size; + if ( $self->get_constant_group(&group_start_index, &group_size, idx) ) + return Py_BuildValue("(nn)", group_start_index, group_size); + else + Py_RETURN_NONE; + } + + %pythoncode { + def all_groups(self, skip_trivial=False): + """ + Generate tuples for bitmask enum groups. + Each tupple is: + [0] enum member index of group start + [1] group size + Tupples may include or not the group with 1 element. + """ + if len(self.group_sizes) != 0 and self.is_valid_group_sizes(): + grp_start = 0 + for grp_size in self.group_sizes: + if not skip_trivial or grp_size != 1: + yield (grp_start, grp_size) + grp_start += grp_size + return None + + + def all_constants(self): + """ + Generate tupples of all constants except of bitmasks. + Each tupple is: + [0] constant index + [1] enum member index of group start + [2] group size + In case of regular enum the second element of tupple is 0 and the third element of tupple is the number of enum members. + """ + if len(self.group_sizes) != 0: # bitmask enum + for (grp_start, grp_size) in self.all_groups(): + grp_end = grp_start + grp_size + if grp_size != 1: + grp_start += 1 + for idx in range(grp_start, grp_end): + yield (idx, grp_start, grp_size) + else: # regular enum + sz = self.size() + for idx in range(0, sz): + yield (idx, 0, sz) + return None + } +} + %feature("director") predicate_t; %ignore remove_tinfo_pointer; @@ -304,13 +572,64 @@ idaman bool ida_export deserialize_tinfo2(tinfo_t *tif, const til_t *til, const SWIG_ValueError, "invalid argument " "in method '" "$symname" "', argument " "$argnum"" of type '" "$1_type""'"); } + +%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) const sclass_t * { + // %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) const sclass_t * + $1 = ($input == Py_None || PyLong_Check($input)) ? 1 : 0; +} + %typemap(freearg) const sclass_t * { // %typemap(freearg) const sclass_t * delete $1; } +//------------------------------------------------------------------------- +%feature("pythonappend") udm_t::udm_t %{ + if args and self.empty(): + raise ValueError("Invalid input data: %s" % str(args)) +%} + +%feature("pythonappend") funcarg_t::funcarg_t %{ + if args and self.type.empty(): + raise ValueError("Invalid input data: %s" % str(args)) +%} + +%feature("pythonappend") tinfo_t::add_udm %{ + if val != 0: + raise ValueError("Invalid input data: %s" % tinfo_errstr(val)) +%} + +%feature("pythonappend") tinfo_t::add_edm %{ + if val != 0: + raise ValueError("Invalid input data: %s" % tinfo_errstr(val)) +%} + %include "typeinf.hpp" +%extend udm_t { + + udm_t(const udm_t &r) + { + return new udm_t(r); + } +} + +%extend edm_t { + + edm_t(const edm_t &r) + { + return new edm_t(r); + } +} + +%extend funcarg_t { + + funcarg_t(const funcarg_t &r) + { + return new funcarg_t(r); + } +} + // Custom wrappers %rename (idc_get_type_raw) py_idc_get_type_raw; diff --git a/swig/ua.i b/swig/ua.i index 826e17f..13c7cad 100644 --- a/swig/ua.i +++ b/swig/ua.i @@ -20,8 +20,6 @@ %ignore insn_get_next_qword; %ignore insn_create_op_data; -%ignore construct_macro; -%ignore API70_construct_macro; %rename (construct_macro) py_construct_macro; %ignore get_dtype_by_size; %rename (get_dtype_by_size) py_get_dtype_by_size; @@ -36,6 +34,7 @@ %ignore outctx_base_t::get_cmtgen_state; %ignore outctx_base_t::get_binop_state; +%ignore outctx_base_t::_eah; %ignore outctx_base_t::regname_idx; %ignore outctx_base_t::suspop; %ignore outctx_base_t::F; diff --git a/swig/undo.i b/swig/undo.i new file mode 100644 index 0000000..a5581ab --- /dev/null +++ b/swig/undo.i @@ -0,0 +1,22 @@ +%{ +#include +%} + +// Apply a well-known recipe to `create_undo_point(const uchar *, size_t)` +%const_void_pointer_and_size(const uchar, bytes, size); + +// Make the label output argument for `get_undo_action_label/get_redo_action_label` +%apply qstring *result { qstring *action_to_be_undone, qstring *action_to_be_redone}; + +%inline %{ +// And define our own wrapper, too +bool create_undo_point(const char *action_name, const char *label) +{ + bytevec_t rec; + rec.pack_ds(action_name); + rec.pack_ds(label); + return create_undo_point(rec.begin(), rec.size()); +} +%} + +%include "undo.hpp" diff --git a/til_api_improvements.md b/til_api_improvements.md new file mode 100644 index 0000000..acd17ef --- /dev/null +++ b/til_api_improvements.md @@ -0,0 +1,324 @@ + +# Additions + +## udm_t(name: str, type, offset: int = -1) : udm_t + + # Create a structure/union member, with the specified name + # and type. + # + # The size will be computed automatically. + # + # @param name a valid member name. Must not be empty. + # @param type the member type. the type can be specified one of the following ways: + # - type_t if the type is simple (integral/floating/bool); + # - tinfo_t a more complex type, like a pointer, array, etc; + # - string as a C type declaration. + # @param offset the member offset in bits. It is the caller's responsibility + # to specify correct offsets. + # if an input argument is incorrect, the constructor may raise an exception + +## tinfo_t.get_udm_by_name(name: str) : (idx, udm_t) | (-1, None) + + # Retrieve a structure/union member (and its index) with the + # specified name in the specified tinfo_t object. + # + # @param name Member name. Must not be empty. + # @returns a tuple (int, udm_t), or (-1, None) if member not found. + +* CL#156578 - first attempt, w/o the index + +## tinfo_t.get_udm_by_offset(offset: int) : (idx, udm_t) | (-1, None) + + # Retrieve a structure/union member with the specified offset + # in the specified tinfo_t object. + # + # @param offset Member bit offset + # @returns a tuple (int, udm_t), or (-1, None) if member not found. + +## tinfo_t.add_udm(name: str, type: tinfo_t | type_t | str, offset: int = -1) + + # Add a new member to a structure/union type, with the specified name and type. + # + # The size will be computed automatically. + # The new member must not overlap with the existing members. + # if an input argument is incorrect, the constructor may raise an exception + # + # @param name Member name. Must not be empty. + # @param type Member type. Can be specified one of the following ways: + # - type_t if the type is simple (integral/floating/bool); + # - tinfo_t a more complex type, like a pointer, array, etc; + # - string as a C type declaration. + # @param offset Member offset in bits. If specified as -1, the new member + # is added at the end of the structure/union. + # @returns member object + +* CL#156615 + +## tinfo_t.insert_udm(self, udm: udm_t, idx: int, times: int = 1, etf_flags: int = 0): + + # Insert a member in the current structure/union, at the specified index. + # + # The member's size will be computed automatically. + # + # @param udm The member, fully initialized (but whose offset is not set) + # @param idx the index in the udm array where the new udm should be placed. + # @param times how many times to insert the new member + # @param etf_flags an OR'ed combination of ETF_ flags + +## funcarg_t(name: str, type: tinfo_t | type_t | str, argloc: argloc_t = argloc_t()) + + # Create a function argument, with the specified name and type. + # + # The 'type' descriptor, can be one of: + # + # * type_t: if the type is simple (integral/floating/bool). E.g., `BTF_INT` + # * tinfo_t: can handle more complex types (structures, pointers, arrays, ...) + # * str: a C type declaration + # + # If an input argument is incorrect, the constructor may raise an exception + # + # @param name a valid argument name. May not be empty. + # @param type the member type + # @param argloc the argument location. Can be empty. + +* CL#156993 + +## til_t.numbered_types() : generator of tinfo_t + + # Returns a generator over the numbered types contained in this + # type library. + # + # Every iteration returns a fresh new tinfo_t object + # + # @return a tinfo_t-producing generator + +* CL#156968 + +## til_t.named_types() : generator of tinfo_t + + # Returns a generator over the named types contained in this + # type library. + # + # Every iteration returns a fresh new tinfo_t object + # + # @return a tinfo_t-producing generator + +* CL#156968 + +## til_t.get_named_type(name: str) : tinfo_t | None + + # Retrieves a tinfo_t representing the named type in this type library. + # + # @param name a type name + # @return a new tinfo_t object, or None if not found + +* CL#156969 + +## til_t.get_numbered_type(ordinal: int): tinfo_t | None + + # Retrieves a tinfo_t representing the numbered type in this type library. + # + # @param ordinal a type ordinal + # @return a new tinfo_t object, or None if not found + +* CL#156969 + +## qvector.append(thing: any) : None + + # Alias of push_back() + +* CL#156975 + +## qvector.extend(thing: qvector) : None + + # Alias of insert(end(), thing.begin(), thing.end()) + +* CL#156975 + +## func_type_data_t() should default to `CM_CC_UNKNOWN` + +Otherwise, the following is not working: + + ftd = func_type_data_t() + ftd.append(funcarg_t("myarg", BT_INT32)) + ftd.rettype = tinfo_t(BT_INT64) + tif = tinfo_t() + tif.create_func(ftd) + tif._print() => features a `__bad_cc` calling convention + +* CL#157005 + +## tinfo_t.add_edm(name: str, value: int) + + # Add an enumerator to the current enumeration. + # + # When creating a new enumeration from scratch, you might + # want to first call `create_enum()` + # + # This method has the following signatures: + # + # * add_edm(edm: edm_t, bmask: int = -1, etf_flags: int = 0, idx: int = -1) + # * add_edm(name: str, value: int, bmask: int = -1, etf_flags: int = 0, idx: int = -1) + # + # If an input argument is incorrect, the constructor may raise an exception + # + # @param edm The member, fully initialized (first form) + # @param name Enumerator name - must not be empty + # @param value Enumerator value + # @param bmask A bitmask to which the enumerator belongs + # @param etf_flags an OR'ed combination of ETF_ flags + # @param idx the index in the edm array where the new udm should be placed. + # If the specified index cannot be honored because it would spoil + +* CL#1570?? + +## edm_t(name: str, value: int, cmt: str = None) : edm_t + + # Create a structure/union member, with the specified name and value + # + # @param name Enumerator name. Must not be empty. + # @param value Enumerator value + # @param cmt Enumerator repeatable comment. May be empty. + +* CL#1570?? + +## tinfo_t(type: type_t) : tinfo_t +## tinfo_t(decl: str, til: til_t = None, pt_flags: int = 0) : tinfo_t +## tinfo_t(**kwargs) : tinfo_t + + # Create a type object with the provided argumens. + # + # This constructor has the following signatures: + # + # * tinfo_t(decl_type: type_t) + # * tinfo_t(decl: str, til: til_t = None, pt_flags: int = 0) + # + # The latter form will create the type object by parsing the type declaration + # + # Alternatively, you can use a form accepting the following keyword arguments: + # + # * ordinal: int + # * name: str + # * til: til_t=None # `None` means `get_idati()` + # + # E.g., + # + # * tinfo_t(ordinal=3) + # * tinfo_t(ordinal=10, til=get_idati()) + # * tinfo_t(name="mytype_t") + # * tinfo_t(name="thattype_t", til=my_other_til) + # + # The constructor may raise an exception if data was invalid/parsing failed. + # + # @param decl_type A simple type + # @param decl A valid C declaration + # @param til A type library, or `None` to use the (`get_idati()`) default + # @param ordinal An ordinal in the type library + # @param name A valid type name + # @param pt_flags Parsing flags + +## tinfo_t.iter_struct() : generator of udm_t + + # Iterate on the members composing this structure. + # + # Example: + # til = ida_typeinf.get_idati() + # tif = til.get_named_type("my_struc") + # for udm in tif.iter_struct(): + # print(f"{udm.name} at bit offset {udm.offset}") + # + # Will raise an exception if this type is not a structure. + # + # @return a udm_t-producing generator + +## tinfo_t.iter_union() : generator of udm_t + + # Iterate on the members composing this union. + # + # Example: + # til = ida_typeinf.get_idati() + # tif = til.get_named_type("my_union") + # for udm in tif.iter_union(): + # print(f"{udm.name} with type {udm.type}") + # + # Will raise an exception if this type is not a union. + # + # @return a udm_t-producing generator + +## tinfo_t.iter_udt() : generator of udm_t + + # Iterate on the members composing this structure, or union. + # + # Example: + # til = ida_typeinf.get_idati() + # tif = til.get_named_type("my_type") + # for udm in tif.iter_udt(): + # print(f"{udm.name} at bit offset {udm.offset} with type {udm.type}") + # + # Will raise an exception if this type is not a structure, or union + # + # @return a udm_t-producing generator + +## tinfo_t.iter_enum() : generator of edm_t + + # Iterate on the members composing this enumeration + # + # Example: + # til = ida_typeinf.get_idati() + # tif = til.get_named_type("my_enum") + # for edm in tif.iter_enum(): + # print(f"{edm.name} = {edm.value}") + # + # Will raise an exception if this type is not an enumeration + # + # @return a edm_t-producing generator + + +# Proposals + + +## tinfo_t repr +``` +Python>idati.get_named_type("Elf32_Vernaux") + +``` +Or any alternatives that show module and class names instead of +``` +Python>idati.get_named_type("Elf32_Vernaux") # it's tinfo_t object, not a string +Elf32_Vernaux +```` + +## All idapython default representation as `__repr__` + +On typing objects Python interpreters show `__repr__`, but IDAPython shows `__str__` +Suggestion is to be synced with the interpreters and show `__repr__` + +# Effectively test + + [v] pc_api_add_frame_member.elf + [?] pc_api_apply_callee_tinfo.elf + [ ] pc_api_change_stkvar_type.elf + [v] pc_api_create_array.elf + [v] pc_api_create_bfstruct.elf + [v] pc_api_create_bmenum.elf + [v] pc_api_create_libssh2_til.elf + [v] pc_api_create_struct_by_parsing.elf + [v] pc_api_create_user_shared_data.elf + [v] pc_api_del_struct_members.elf + [v] pc_api_func_ti_changed_listener.elf + [v] pc_api_gap_size_align_snippet.elf + [v] pc_api_get_best_fit_member.elf + [v] pc_api_get_innermost_member.elf + [v] pc_api_import_type_from_til.elf -> idapython-examples__import_type_from_til (requires UI) + [v] pc_api_insert_gap.elf + [v] pc_api_list_enum_member.elf + [v] pc_api_list_frame_info.elf + [v] pc_api_list_func_details.elf + [v] pc_api_list_struct_accesses.elf + [ ] pc_api_list_struct_member.elf + [ ] pc_api_list_struct_xrefs.elf + [ ] pc_api_list_union_member.elf + [ ] pc_api_mark_func_spoiled.elf + [ ] pc_api_operand_to_struct_member.elf + [ ] pc_api_setpehdr.elf + [ ] pc_api_visit_tinfo.elf diff --git a/tools/astor_0_8_1/VERSION b/tools/astor_0_8_1/VERSION new file mode 100644 index 0000000..6f4eebd --- /dev/null +++ b/tools/astor_0_8_1/VERSION @@ -0,0 +1 @@ +0.8.1 diff --git a/tools/astor_0_8_1/__init__.py b/tools/astor_0_8_1/__init__.py new file mode 100644 index 0000000..bdedaef --- /dev/null +++ b/tools/astor_0_8_1/__init__.py @@ -0,0 +1,78 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright 2012 (c) Patrick Maupin +Copyright 2013 (c) Berker Peksag + +""" + +import os +import warnings + +from .code_gen import SourceGenerator, to_source # NOQA +from .node_util import iter_node, strip_tree, dump_tree # NOQA +from .node_util import ExplicitNodeVisitor # NOQA +from .file_util import CodeToAst, code_to_ast # NOQA +from .op_util import get_op_symbol, get_op_precedence # NOQA +from .op_util import symbol_data # NOQA +from .tree_walk import TreeWalk # NOQA + +ROOT = os.path.dirname(__file__) +with open(os.path.join(ROOT, 'VERSION')) as version_file: + __version__ = version_file.read().strip() + +parse_file = code_to_ast.parse_file + +# DEPRECATED!!! +# These aliases support old programs. Please do not use in future. + +deprecated = """ +get_boolop = get_binop = get_cmpop = get_unaryop = get_op_symbol +get_anyop = get_op_symbol +parsefile = code_to_ast.parse_file +codetoast = code_to_ast +dump = dump_tree +all_symbols = symbol_data +treewalk = tree_walk +codegen = code_gen +""" + +exec(deprecated) + + +def deprecate(): + def wrap(deprecated_name, target_name): + if '.' in target_name: + target_mod, target_fname = target_name.split('.') + target_func = getattr(globals()[target_mod], target_fname) + else: + target_func = globals()[target_name] + msg = "astor.%s is deprecated. Please use astor.%s." % ( + deprecated_name, target_name) + if callable(target_func): + def newfunc(*args, **kwarg): + warnings.warn(msg, DeprecationWarning, stacklevel=2) + return target_func(*args, **kwarg) + else: + class ModProxy: + def __getattr__(self, name): + warnings.warn(msg, DeprecationWarning, stacklevel=2) + return getattr(target_func, name) + newfunc = ModProxy() + + globals()[deprecated_name] = newfunc + + for line in deprecated.splitlines(): # NOQA + line = line.split('#')[0].replace('=', '').split() + if line: + target_name = line.pop() + for deprecated_name in line: + wrap(deprecated_name, target_name) + + +deprecate() + +del deprecate, deprecated diff --git a/tools/astor_0_8_1/code_gen.py b/tools/astor_0_8_1/code_gen.py new file mode 100644 index 0000000..e004807 --- /dev/null +++ b/tools/astor_0_8_1/code_gen.py @@ -0,0 +1,901 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright (c) 2008 Armin Ronacher +Copyright (c) 2012-2017 Patrick Maupin +Copyright (c) 2013-2017 Berker Peksag + +This module converts an AST into Python source code. + +Before being version-controlled as part of astor, +this code came from here (in 2012): + + https://gist.github.com/1250562 + +""" + +import ast +import inspect +import math +import sys + +from .op_util import get_op_symbol, get_op_precedence, Precedence +from .node_util import ExplicitNodeVisitor +from .string_repr import pretty_string +from .source_repr import pretty_source + + +def to_source(node, indent_with=' ' * 4, add_line_information=False, + pretty_string=pretty_string, pretty_source=pretty_source, + source_generator_class=None): + """This function can convert a node tree back into python sourcecode. + This is useful for debugging purposes, especially if you're dealing with + custom asts not generated by python itself. + + It could be that the sourcecode is evaluable when the AST itself is not + compilable / evaluable. The reason for this is that the AST contains some + more data than regular sourcecode does, which is dropped during + conversion. + + Each level of indentation is replaced with `indent_with`. Per default this + parameter is equal to four spaces as suggested by PEP 8, but it might be + adjusted to match the application's styleguide. + + If `add_line_information` is set to `True` comments for the line numbers + of the nodes are added to the output. This can be used to spot wrong line + number information of statement nodes. + + `source_generator_class` defaults to `SourceGenerator`, and specifies the + class that will be instantiated and used to generate the source code. + + """ + if source_generator_class is None: + source_generator_class = SourceGenerator + elif not inspect.isclass(source_generator_class): + raise TypeError('source_generator_class should be a class') + elif not issubclass(source_generator_class, SourceGenerator): + raise TypeError('source_generator_class should be a subclass of SourceGenerator') + generator = source_generator_class( + indent_with, add_line_information, pretty_string) + generator.visit(node) + generator.result.append('\n') + if set(generator.result[0]) == set('\n'): + generator.result[0] = '' + return pretty_source(generator.result) + + +def precedence_setter(AST=ast.AST, get_op_precedence=get_op_precedence, + isinstance=isinstance, list=list): + """ This only uses a closure for performance reasons, + to reduce the number of attribute lookups. (set_precedence + is called a lot of times.) + """ + + def set_precedence(value, *nodes): + """Set the precedence (of the parent) into the children. + """ + if isinstance(value, AST): + value = get_op_precedence(value) + for node in nodes: + if isinstance(node, AST): + node._pp = value + elif isinstance(node, list): + set_precedence(value, *node) + else: + assert node is None, node + + return set_precedence + + +set_precedence = precedence_setter() + + +class Delimit(object): + """A context manager that can add enclosing + delimiters around the output of a + SourceGenerator method. By default, the + parentheses are added, but the enclosed code + may set discard=True to get rid of them. + """ + + discard = False + + def __init__(self, tree, *args): + """ use write instead of using result directly + for initial data, because it may flush + preceding data into result. + """ + delimiters = '()' + node = None + op = None + for arg in args: + if isinstance(arg, ast.AST): + if node is None: + node = arg + else: + op = arg + else: + delimiters = arg + tree.write(delimiters[0]) + result = self.result = tree.result + self.index = len(result) + self.closing = delimiters[1] + if node is not None: + self.p = p = get_op_precedence(op or node) + self.pp = pp = tree.get__pp(node) + self.discard = p >= pp + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + result = self.result + start = self.index - 1 + if self.discard: + result[start] = '' + else: + result.append(self.closing) + + +class SourceGenerator(ExplicitNodeVisitor): + """This visitor is able to transform a well formed syntax tree into Python + sourcecode. + + For more details have a look at the docstring of the `node_to_source` + function. + + """ + + using_unicode_literals = False + + def __init__(self, indent_with, add_line_information=False, + pretty_string=pretty_string, + # constants + len=len, isinstance=isinstance, callable=callable): + self.result = [] + self.indent_with = indent_with + self.add_line_information = add_line_information + self.indentation = 0 # Current indentation level + self.new_lines = 0 # Number of lines to insert before next code + self.colinfo = 0, 0 # index in result of string containing linefeed, and + # position of last linefeed in that string + self.pretty_string = pretty_string + AST = ast.AST + + visit = self.visit + result = self.result + append = result.append + + def write(*params): + """ self.write is a closure for performance (to reduce the number + of attribute lookups). + """ + for item in params: + if isinstance(item, AST): + visit(item) + elif callable(item): + item() + else: + if self.new_lines: + append('\n' * self.new_lines) + self.colinfo = len(result), 0 + append(self.indent_with * self.indentation) + self.new_lines = 0 + if item: + append(item) + + self.write = write + + def __getattr__(self, name, defaults=dict(keywords=(), + _pp=Precedence.highest).get): + """ Get an attribute of the node. + like dict.get (returns None if doesn't exist) + """ + if not name.startswith('get_'): + raise AttributeError + geta = getattr + shortname = name[4:] + default = defaults(shortname) + + def getter(node): + return geta(node, shortname, default) + + setattr(self, name, getter) + return getter + + def delimit(self, *args): + return Delimit(self, *args) + + def conditional_write(self, *stuff): + if stuff[-1] is not None: + self.write(*stuff) + # Inform the caller that we wrote + return True + + def newline(self, node=None, extra=0): + self.new_lines = max(self.new_lines, 1 + extra) + if node is not None and self.add_line_information: + self.write('# line: %s' % node.lineno) + self.new_lines = 1 + + def body(self, statements): + self.indentation += 1 + self.write(*statements) + self.indentation -= 1 + + def else_body(self, elsewhat): + if elsewhat: + self.write(self.newline, 'else:') + self.body(elsewhat) + + def body_or_else(self, node): + self.body(node.body) + self.else_body(node.orelse) + + def visit_arguments(self, node): + want_comma = [] + + def write_comma(): + if want_comma: + self.write(', ') + else: + want_comma.append(True) + + def loop_args(args, defaults): + set_precedence(Precedence.Comma, defaults) + padding = [None] * (len(args) - len(defaults)) + for arg, default in zip(args, padding + defaults): + self.write(write_comma, arg) + self.conditional_write('=', default) + + posonlyargs = getattr(node, 'posonlyargs', []) + offset = 0 + if posonlyargs: + offset += len(node.defaults) - len(node.args) + loop_args(posonlyargs, node.defaults[:offset]) + self.write(write_comma, '/') + + loop_args(node.args, node.defaults[offset:]) + self.conditional_write(write_comma, '*', node.vararg) + + kwonlyargs = self.get_kwonlyargs(node) + if kwonlyargs: + if node.vararg is None: + self.write(write_comma, '*') + loop_args(kwonlyargs, node.kw_defaults) + self.conditional_write(write_comma, '**', node.kwarg) + + def statement(self, node, *params, **kw): + self.newline(node) + self.write(*params) + + def decorators(self, node, extra): + self.newline(extra=extra) + for decorator in node.decorator_list: + self.statement(decorator, '@', decorator) + + def comma_list(self, items, trailing=False): + set_precedence(Precedence.Comma, *items) + for idx, item in enumerate(items): + self.write(', ' if idx else '', item) + self.write(',' if trailing else '') + + # Statements + + def visit_Assign(self, node): + set_precedence(node, node.value, *node.targets) + self.newline(node) + for target in node.targets: + self.write(target, ' = ') + self.visit(node.value) + + def visit_AugAssign(self, node): + set_precedence(node, node.value, node.target) + self.statement(node, node.target, get_op_symbol(node.op, ' %s= '), + node.value) + + def visit_AnnAssign(self, node): + set_precedence(node, node.target, node.annotation) + set_precedence(Precedence.Comma, node.value) + need_parens = isinstance(node.target, ast.Name) and not node.simple + begin = '(' if need_parens else '' + end = ')' if need_parens else '' + self.statement(node, begin, node.target, end, ': ', node.annotation) + self.conditional_write(' = ', node.value) + + def visit_ImportFrom(self, node): + self.statement(node, 'from ', node.level * '.', + node.module or '', ' import ') + self.comma_list(node.names) + # Goofy stuff for Python 2.7 _pyio module + if node.module == '__future__' and 'unicode_literals' in ( + x.name for x in node.names): + self.using_unicode_literals = True + + def visit_Import(self, node): + self.statement(node, 'import ') + self.comma_list(node.names) + + def visit_Expr(self, node): + set_precedence(node, node.value) + self.statement(node) + self.generic_visit(node) + + def visit_FunctionDef(self, node, is_async=False): + prefix = 'async ' if is_async else '' + self.decorators(node, 1 if self.indentation else 2) + self.statement(node, '%sdef %s' % (prefix, node.name), '(') + self.visit_arguments(node.args) + self.write(')') + self.conditional_write(' ->', self.get_returns(node)) + self.write(':') + self.body(node.body) + if not self.indentation: + self.newline(extra=2) + + # introduced in Python 3.5 + def visit_AsyncFunctionDef(self, node): + self.visit_FunctionDef(node, is_async=True) + + def visit_ClassDef(self, node): + have_args = [] + + def paren_or_comma(): + if have_args: + self.write(', ') + else: + have_args.append(True) + self.write('(') + + self.decorators(node, 2) + self.statement(node, 'class %s' % node.name) + for base in node.bases: + self.write(paren_or_comma, base) + # keywords not available in early version + for keyword in self.get_keywords(node): + self.write(paren_or_comma, keyword.arg or '', + '=' if keyword.arg else '**', keyword.value) + self.conditional_write(paren_or_comma, '*', self.get_starargs(node)) + self.conditional_write(paren_or_comma, '**', self.get_kwargs(node)) + self.write(have_args and '):' or ':') + self.body(node.body) + if not self.indentation: + self.newline(extra=2) + + def visit_If(self, node): + set_precedence(node, node.test) + self.statement(node, 'if ', node.test, ':') + self.body(node.body) + while True: + else_ = node.orelse + if len(else_) == 1 and isinstance(else_[0], ast.If): + node = else_[0] + set_precedence(node, node.test) + self.write(self.newline, 'elif ', node.test, ':') + self.body(node.body) + else: + self.else_body(else_) + break + + def visit_For(self, node, is_async=False): + set_precedence(node, node.target) + prefix = 'async ' if is_async else '' + self.statement(node, '%sfor ' % prefix, + node.target, ' in ', node.iter, ':') + self.body_or_else(node) + + # introduced in Python 3.5 + def visit_AsyncFor(self, node): + self.visit_For(node, is_async=True) + + def visit_While(self, node): + set_precedence(node, node.test) + self.statement(node, 'while ', node.test, ':') + self.body_or_else(node) + + def visit_With(self, node, is_async=False): + prefix = 'async ' if is_async else '' + self.statement(node, '%swith ' % prefix) + if hasattr(node, "context_expr"): # Python < 3.3 + self.visit_withitem(node) + else: # Python >= 3.3 + self.comma_list(node.items) + self.write(':') + self.body(node.body) + + # new for Python 3.5 + def visit_AsyncWith(self, node): + self.visit_With(node, is_async=True) + + # new for Python 3.3 + def visit_withitem(self, node): + self.write(node.context_expr) + self.conditional_write(' as ', node.optional_vars) + + # deprecated in Python 3.8 + def visit_NameConstant(self, node): + self.write(repr(node.value)) + + def visit_Pass(self, node): + self.statement(node, 'pass') + + def visit_Print(self, node): + # XXX: python 2.6 only + self.statement(node, 'print ') + values = node.values + if node.dest is not None: + self.write(' >> ') + values = [node.dest] + node.values + self.comma_list(values, not node.nl) + + def visit_Delete(self, node): + self.statement(node, 'del ') + self.comma_list(node.targets) + + def visit_TryExcept(self, node): + self.statement(node, 'try:') + self.body(node.body) + self.write(*node.handlers) + self.else_body(node.orelse) + + # new for Python 3.3 + def visit_Try(self, node): + self.statement(node, 'try:') + self.body(node.body) + self.write(*node.handlers) + self.else_body(node.orelse) + if node.finalbody: + self.statement(node, 'finally:') + self.body(node.finalbody) + + def visit_ExceptHandler(self, node): + self.statement(node, 'except') + if self.conditional_write(' ', node.type): + self.conditional_write(' as ', node.name) + self.write(':') + self.body(node.body) + + def visit_TryFinally(self, node): + self.statement(node, 'try:') + self.body(node.body) + self.statement(node, 'finally:') + self.body(node.finalbody) + + def visit_Exec(self, node): + dicts = node.globals, node.locals + dicts = dicts[::-1] if dicts[0] is None else dicts + self.statement(node, 'exec ', node.body) + self.conditional_write(' in ', dicts[0]) + self.conditional_write(', ', dicts[1]) + + def visit_Assert(self, node): + set_precedence(node, node.test, node.msg) + self.statement(node, 'assert ', node.test) + self.conditional_write(', ', node.msg) + + def visit_Global(self, node): + self.statement(node, 'global ', ', '.join(node.names)) + + def visit_Nonlocal(self, node): + self.statement(node, 'nonlocal ', ', '.join(node.names)) + + def visit_Return(self, node): + set_precedence(node, node.value) + self.statement(node, 'return') + self.conditional_write(' ', node.value) + + def visit_Break(self, node): + self.statement(node, 'break') + + def visit_Continue(self, node): + self.statement(node, 'continue') + + def visit_Raise(self, node): + # XXX: Python 2.6 / 3.0 compatibility + self.statement(node, 'raise') + if self.conditional_write(' ', self.get_exc(node)): + self.conditional_write(' from ', node.cause) + elif self.conditional_write(' ', self.get_type(node)): + set_precedence(node, node.inst) + self.conditional_write(', ', node.inst) + self.conditional_write(', ', node.tback) + + # Expressions + + def visit_Attribute(self, node): + self.write(node.value, '.', node.attr) + + def visit_Call(self, node, len=len): + write = self.write + want_comma = [] + + def write_comma(): + if want_comma: + write(', ') + else: + want_comma.append(True) + + args = node.args + keywords = node.keywords + starargs = self.get_starargs(node) + kwargs = self.get_kwargs(node) + numargs = len(args) + len(keywords) + numargs += starargs is not None + numargs += kwargs is not None + p = Precedence.Comma if numargs > 1 else Precedence.call_one_arg + set_precedence(p, *args) + self.visit(node.func) + write('(') + for arg in args: + write(write_comma, arg) + + set_precedence(Precedence.Comma, *(x.value for x in keywords)) + for keyword in keywords: + # a keyword.arg of None indicates dictionary unpacking + # (Python >= 3.5) + arg = keyword.arg or '' + write(write_comma, arg, '=' if arg else '**', keyword.value) + # 3.5 no longer has these + self.conditional_write(write_comma, '*', starargs) + self.conditional_write(write_comma, '**', kwargs) + write(')') + + def visit_Name(self, node): + self.write(node.id) + + # ast.Constant is new in Python 3.6 and it replaces ast.Bytes, + # ast.Ellipsis, ast.NameConstant, ast.Num, ast.Str in Python 3.8 + def visit_Constant(self, node): + value = node.value + + if isinstance(value, (int, float, complex)): + with self.delimit(node): + self._handle_numeric_constant(value) + elif isinstance(value, str): + self._handle_string_constant(node, node.value) + elif value is Ellipsis: + self.write('...') + else: + self.write(repr(value)) + + def visit_JoinedStr(self, node): + self._handle_string_constant(node, None, is_joined=True) + + def _handle_string_constant(self, node, value, is_joined=False): + # embedded is used to control when we might want + # to use a triple-quoted string. We determine + # if we are in an assignment and/or in an expression + precedence = self.get__pp(node) + embedded = ((precedence > Precedence.Expr) + + (precedence >= Precedence.Assign)) + + # Flush any pending newlines, because we're about + # to severely abuse the result list. + self.write('') + result = self.result + + # Calculate the string representing the line + # we are working on, up to but not including + # the string we are adding. + + res_index, str_index = self.colinfo + current_line = self.result[res_index:] + if str_index: + current_line[0] = current_line[0][str_index:] + current_line = ''.join(current_line) + + has_ast_constant = sys.version_info >= (3, 6) + + if is_joined: + # Handle new f-strings. This is a bit complicated, because + # the tree can contain subnodes that recurse back to JoinedStr + # subnodes... + + def recurse(node): + for value in node.values: + if isinstance(value, ast.Str): + # Double up braces to escape them. + self.write(value.s.replace('{', '{{').replace('}', '}}')) + elif isinstance(value, ast.FormattedValue): + with self.delimit('{}'): + # expr_text used for f-string debugging syntax. + if getattr(value, 'expr_text', None): + self.write(value.expr_text) + else: + set_precedence(value, value.value) + self.visit(value.value) + if value.conversion != -1: + self.write('!%s' % chr(value.conversion)) + if value.format_spec is not None: + self.write(':') + recurse(value.format_spec) + elif has_ast_constant and isinstance(value, ast.Constant): + self.write(value.value) + else: + kind = type(value).__name__ + assert False, 'Invalid node %s inside JoinedStr' % kind + + index = len(result) + recurse(node) + + # Flush trailing newlines (so that they are part of mystr) + self.write('') + mystr = ''.join(result[index:]) + del result[index:] + self.colinfo = res_index, str_index # Put it back like we found it + uni_lit = False # No formatted byte strings + + else: + assert value is not None, "Node value cannot be None" + mystr = value + uni_lit = self.using_unicode_literals + + mystr = self.pretty_string(mystr, embedded, current_line, uni_lit) + + if is_joined: + mystr = 'f' + mystr + elif getattr(node, 'kind', False): + # Constant.kind is a Python 3.8 addition. + mystr = node.kind + mystr + + self.write(mystr) + + lf = mystr.rfind('\n') + 1 + if lf: + self.colinfo = len(result) - 1, lf + + # deprecated in Python 3.8 + def visit_Str(self, node): + self._handle_string_constant(node, node.s) + + # deprecated in Python 3.8 + def visit_Bytes(self, node): + self.write(repr(node.s)) + + def _handle_numeric_constant(self, value): + x = value + + def part(p, imaginary): + # Represent infinity as 1e1000 and NaN as 1e1000-1e1000. + s = 'j' if imaginary else '' + try: + if math.isinf(p): + if p < 0: + return '-1e1000' + s + return '1e1000' + s + if math.isnan(p): + return '(1e1000%s-1e1000%s)' % (s, s) + except OverflowError: + # math.isinf will raise this when given an integer + # that's too large to convert to a float. + pass + return repr(p) + s + + real = part(x.real if isinstance(x, complex) else x, imaginary=False) + if isinstance(x, complex): + imag = part(x.imag, imaginary=True) + if x.real == 0: + s = imag + elif x.imag == 0: + s = '(%s+0j)' % real + else: + # x has nonzero real and imaginary parts. + s = '(%s%s%s)' % (real, ['+', ''][imag.startswith('-')], imag) + else: + s = real + self.write(s) + + def visit_Num(self, node, + # constants + new=sys.version_info >= (3, 0)): + with self.delimit(node) as delimiters: + self._handle_numeric_constant(node.n) + + # We can leave the delimiters handling in visit_Num + # since this is meant to handle a Python 2.x specific + # issue and ast.Constant exists only in 3.6+ + + # The Python 2.x compiler merges a unary minus + # with a number. This is a premature optimization + # that we deal with here... + if not new and delimiters.discard: + if not isinstance(node.n, complex) and node.n < 0: + pow_lhs = Precedence.Pow + 1 + delimiters.discard = delimiters.pp != pow_lhs + else: + op = self.get__p_op(node) + delimiters.discard = not isinstance(op, ast.USub) + + def visit_Tuple(self, node): + with self.delimit(node) as delimiters: + # Two things are special about tuples: + # 1) We cannot discard the enclosing parentheses if empty + # 2) We need the trailing comma if only one item + elts = node.elts + delimiters.discard = delimiters.discard and elts + self.comma_list(elts, len(elts) == 1) + + def visit_List(self, node): + with self.delimit('[]'): + self.comma_list(node.elts) + + def visit_Set(self, node): + if node.elts: + with self.delimit('{}'): + self.comma_list(node.elts) + else: + # If we tried to use "{}" to represent an empty set, it would be + # interpreted as an empty dictionary. We can't use "set()" either + # because the name "set" might be rebound. + self.write('{1}.__class__()') + + def visit_Dict(self, node): + set_precedence(Precedence.Comma, *node.values) + with self.delimit('{}'): + for idx, (key, value) in enumerate(zip(node.keys, node.values)): + self.write(', ' if idx else '', + key if key else '', + ': ' if key else '**', value) + + def visit_BinOp(self, node): + op, left, right = node.op, node.left, node.right + with self.delimit(node, op) as delimiters: + ispow = isinstance(op, ast.Pow) + p = delimiters.p + set_precedence((Precedence.Pow + 1) if ispow else p, left) + set_precedence(Precedence.PowRHS if ispow else (p + 1), right) + self.write(left, get_op_symbol(op, ' %s '), right) + + def visit_BoolOp(self, node): + with self.delimit(node, node.op) as delimiters: + op = get_op_symbol(node.op, ' %s ') + set_precedence(delimiters.p + 1, *node.values) + for idx, value in enumerate(node.values): + self.write(idx and op or '', value) + + def visit_Compare(self, node): + with self.delimit(node, node.ops[0]) as delimiters: + set_precedence(delimiters.p + 1, node.left, *node.comparators) + self.visit(node.left) + for op, right in zip(node.ops, node.comparators): + self.write(get_op_symbol(op, ' %s '), right) + + # assignment expressions; new for Python 3.8 + def visit_NamedExpr(self, node): + with self.delimit(node) as delimiters: + p = delimiters.p + set_precedence(p, node.target) + set_precedence(p + 1, node.value) + # Python is picky about delimiters for assignment + # expressions: it requires at least one pair in any + # statement that uses an assignment expression, even + # when not necessary according to the precedence + # rules. We address this with the kludge of forcing a + # pair of parentheses around every assignment + # expression. + delimiters.discard = False + self.write(node.target, ' := ', node.value) + + def visit_UnaryOp(self, node): + with self.delimit(node, node.op) as delimiters: + set_precedence(delimiters.p, node.operand) + # In Python 2.x, a unary negative of a literal + # number is merged into the number itself. This + # bit of ugliness means it is useful to know + # what the parent operation was... + node.operand._p_op = node.op + sym = get_op_symbol(node.op) + self.write(sym, ' ' if sym.isalpha() else '', node.operand) + + def visit_Subscript(self, node): + set_precedence(node, node.slice) + self.write(node.value, '[', node.slice, ']') + + def visit_Slice(self, node): + set_precedence(node, node.lower, node.upper, node.step) + self.conditional_write(node.lower) + self.write(':') + self.conditional_write(node.upper) + if node.step is not None: + self.write(':') + if not (isinstance(node.step, ast.Name) and + node.step.id == 'None'): + self.visit(node.step) + + def visit_Index(self, node): + with self.delimit(node) as delimiters: + set_precedence(delimiters.p, node.value) + self.visit(node.value) + + def visit_ExtSlice(self, node): + dims = node.dims + set_precedence(node, *dims) + self.comma_list(dims, len(dims) == 1) + + def visit_Yield(self, node): + with self.delimit(node): + set_precedence(get_op_precedence(node) + 1, node.value) + self.write('yield') + self.conditional_write(' ', node.value) + + # new for Python 3.3 + def visit_YieldFrom(self, node): + with self.delimit(node): + self.write('yield from ', node.value) + + # new for Python 3.5 + def visit_Await(self, node): + with self.delimit(node): + self.write('await ', node.value) + + def visit_Lambda(self, node): + with self.delimit(node) as delimiters: + set_precedence(delimiters.p, node.body) + self.write('lambda ') + self.visit_arguments(node.args) + self.write(': ', node.body) + + def visit_Ellipsis(self, node): + self.write('...') + + def visit_ListComp(self, node): + with self.delimit('[]'): + self.write(node.elt, *node.generators) + + def visit_GeneratorExp(self, node): + with self.delimit(node) as delimiters: + if delimiters.pp == Precedence.call_one_arg: + delimiters.discard = True + set_precedence(Precedence.Comma, node.elt) + self.write(node.elt, *node.generators) + + def visit_SetComp(self, node): + with self.delimit('{}'): + self.write(node.elt, *node.generators) + + def visit_DictComp(self, node): + with self.delimit('{}'): + self.write(node.key, ': ', node.value, *node.generators) + + def visit_IfExp(self, node): + with self.delimit(node) as delimiters: + set_precedence(delimiters.p + 1, node.body, node.test) + set_precedence(delimiters.p, node.orelse) + self.write(node.body, ' if ', node.test, ' else ', node.orelse) + + def visit_Starred(self, node): + self.write('*', node.value) + + def visit_Repr(self, node): + # XXX: python 2.6 only + with self.delimit('``'): + self.visit(node.value) + + def visit_Module(self, node): + self.write(*node.body) + + visit_Interactive = visit_Module + + def visit_Expression(self, node): + self.visit(node.body) + + # Helper Nodes + + def visit_arg(self, node): + self.write(node.arg) + self.conditional_write(': ', node.annotation) + + def visit_alias(self, node): + self.write(node.name) + self.conditional_write(' as ', node.asname) + + def visit_comprehension(self, node): + set_precedence(node, node.iter, *node.ifs) + set_precedence(Precedence.comprehension_target, node.target) + stmt = ' async for ' if self.get_is_async(node) else ' for ' + self.write(stmt, node.target, ' in ', node.iter) + for if_ in node.ifs: + self.write(' if ', if_) diff --git a/tools/astor_0_8_1/codegen.py b/tools/astor_0_8_1/codegen.py new file mode 100644 index 0000000..c5ff51d --- /dev/null +++ b/tools/astor_0_8_1/codegen.py @@ -0,0 +1,11 @@ +import warnings + +from .code_gen import * # NOQA + + +warnings.warn( + 'astor.codegen module is deprecated. Please import ' + 'astor.code_gen module instead.', + DeprecationWarning, + stacklevel=2 +) diff --git a/tools/astor_0_8_1/file_util.py b/tools/astor_0_8_1/file_util.py new file mode 100644 index 0000000..d685597 --- /dev/null +++ b/tools/astor_0_8_1/file_util.py @@ -0,0 +1,111 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright (c) 2012-2015 Patrick Maupin +Copyright (c) 2013-2015 Berker Peksag + +Functions that interact with the filesystem go here. + +""" + +import ast +import sys +import os + +try: + from tokenize import open as fopen +except ImportError: + fopen = open + + +class CodeToAst(object): + """Given a module, or a function that was compiled as part + of a module, re-compile the module into an AST and extract + the sub-AST for the function. Allow caching to reduce + number of compiles. + + Also contains static helper utility functions to + look for python files, to parse python files, and to extract + the file/line information from a code object. + """ + + @staticmethod + def find_py_files(srctree, ignore=None): + """Return all the python files in a source tree + + Ignores any path that contains the ignore string + + This is not used by other class methods, but is + designed to be used in code that uses this class. + """ + + if not os.path.isdir(srctree): + yield os.path.split(srctree) + for srcpath, _, fnames in os.walk(srctree): + # Avoid infinite recursion for silly users + if ignore is not None and ignore in srcpath: + continue + for fname in (x for x in fnames if x.endswith('.py')): + yield srcpath, fname + + @staticmethod + def parse_file(fname): + """Parse a python file into an AST. + + This is a very thin wrapper around ast.parse + + TODO: Handle encodings other than the default for Python 2 + (issue #26) + """ + try: + with fopen(fname) as f: + fstr = f.read() + except IOError: + if fname != 'stdin': + raise + sys.stdout.write('\nReading from stdin:\n\n') + fstr = sys.stdin.read() + fstr = fstr.replace('\r\n', '\n').replace('\r', '\n') + if not fstr.endswith('\n'): + fstr += '\n' + return ast.parse(fstr, filename=fname) + + @staticmethod + def get_file_info(codeobj): + """Returns the file and line number of a code object. + + If the code object has a __file__ attribute (e.g. if + it is a module), then the returned line number will + be 0 + """ + fname = getattr(codeobj, '__file__', None) + linenum = 0 + if fname is None: + func_code = codeobj.__code__ + fname = func_code.co_filename + linenum = func_code.co_firstlineno + fname = fname.replace('.pyc', '.py') + return fname, linenum + + def __init__(self, cache=None): + self.cache = cache or {} + + def __call__(self, codeobj): + cache = self.cache + key = self.get_file_info(codeobj) + result = cache.get(key) + if result is not None: + return result + fname = key[0] + cache[(fname, 0)] = mod_ast = self.parse_file(fname) + for obj in mod_ast.body: + if not isinstance(obj, ast.FunctionDef): + continue + cache[(fname, obj.lineno)] = obj + return cache[key] + + +code_to_ast = CodeToAst() diff --git a/tools/astor_0_8_1/node_util.py b/tools/astor_0_8_1/node_util.py new file mode 100644 index 0000000..19463fb --- /dev/null +++ b/tools/astor_0_8_1/node_util.py @@ -0,0 +1,208 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright 2012-2015 (c) Patrick Maupin +Copyright 2013-2015 (c) Berker Peksag + +Utilities for node (and, by extension, tree) manipulation. +For a whole-tree approach, see the treewalk submodule. + +""" + +import ast +import itertools + +try: + zip_longest = itertools.zip_longest +except AttributeError: + zip_longest = itertools.izip_longest + + +class NonExistent(object): + """This is not the class you are looking for. + """ + pass + + +def iter_node(node, name='', unknown=None, + # Runtime optimization + list=list, getattr=getattr, isinstance=isinstance, + enumerate=enumerate, missing=NonExistent): + """Iterates over an object: + + - If the object has a _fields attribute, + it gets attributes in the order of this + and returns name, value pairs. + + - Otherwise, if the object is a list instance, + it returns name, value pairs for each item + in the list, where the name is passed into + this function (defaults to blank). + + - Can update an unknown set with information about + attributes that do not exist in fields. + """ + fields = getattr(node, '_fields', None) + if fields is not None: + for name in fields: + value = getattr(node, name, missing) + if value is not missing: + yield value, name + if unknown is not None: + unknown.update(set(vars(node)) - set(fields)) + elif isinstance(node, list): + for value in node: + yield value, name + + +def dump_tree(node, name=None, initial_indent='', indentation=' ', + maxline=120, maxmerged=80, + # Runtime optimization + iter_node=iter_node, special=ast.AST, + list=list, isinstance=isinstance, type=type, len=len): + """Dumps an AST or similar structure: + + - Pretty-prints with indentation + - Doesn't print line/column/ctx info + + """ + def dump(node, name=None, indent=''): + level = indent + indentation + name = name and name + '=' or '' + values = list(iter_node(node)) + if isinstance(node, list): + prefix, suffix = '%s[' % name, ']' + elif values: + prefix, suffix = '%s%s(' % (name, type(node).__name__), ')' + elif isinstance(node, special): + prefix, suffix = name + type(node).__name__, '' + else: + return '%s%s' % (name, repr(node)) + node = [dump(a, b, level) for a, b in values if b != 'ctx'] + oneline = '%s%s%s' % (prefix, ', '.join(node), suffix) + if len(oneline) + len(indent) < maxline: + return '%s' % oneline + if node and len(prefix) + len(node[0]) < maxmerged: + prefix = '%s%s,' % (prefix, node.pop(0)) + node = (',\n%s' % level).join(node).lstrip() + return '%s\n%s%s%s' % (prefix, level, node, suffix) + return dump(node, name, initial_indent) + + +def strip_tree(node, + # Runtime optimization + iter_node=iter_node, special=ast.AST, + list=list, isinstance=isinstance, type=type, len=len): + """Strips an AST by removing all attributes not in _fields. + + Returns a set of the names of all attributes stripped. + + This canonicalizes two trees for comparison purposes. + """ + stripped = set() + + def strip(node, indent): + unknown = set() + leaf = True + for subnode, _ in iter_node(node, unknown=unknown): + leaf = False + strip(subnode, indent + ' ') + if leaf: + if isinstance(node, special): + unknown = set(vars(node)) + stripped.update(unknown) + for name in unknown: + delattr(node, name) + if hasattr(node, 'ctx'): + delattr(node, 'ctx') + if 'ctx' in node._fields: + mylist = list(node._fields) + mylist.remove('ctx') + node._fields = mylist + strip(node, '') + return stripped + + +class ExplicitNodeVisitor(ast.NodeVisitor): + """This expands on the ast module's NodeVisitor class + to remove any implicit visits. + + """ + + def abort_visit(node): # XXX: self? + msg = 'No defined handler for node of type %s' + raise AttributeError(msg % node.__class__.__name__) + + def visit(self, node, abort=abort_visit): + """Visit a node.""" + method = 'visit_' + node.__class__.__name__ + visitor = getattr(self, method, abort) + return visitor(node) + + +def allow_ast_comparison(): + """This ugly little monkey-patcher adds in a helper class + to all the AST node types. This helper class allows + eq/ne comparisons to work, so that entire trees can + be easily compared by Python's comparison machinery. + Used by the anti8 functions to compare old and new ASTs. + Could also be used by the test library. + + + """ + + class CompareHelper(object): + def __eq__(self, other): + return type(self) == type(other) and vars(self) == vars(other) + + def __ne__(self, other): + return type(self) != type(other) or vars(self) != vars(other) + + for item in vars(ast).values(): + if type(item) != type: + continue + if issubclass(item, ast.AST): + try: + item.__bases__ = tuple(list(item.__bases__) + [CompareHelper]) + except TypeError: + pass + + +def fast_compare(tree1, tree2): + """ This is optimized to compare two AST trees for equality. + It makes several assumptions that are currently true for + AST trees used by rtrip, and it doesn't examine the _attributes. + """ + + geta = ast.AST.__getattribute__ + + work = [(tree1, tree2)] + pop = work.pop + extend = work.extend + # TypeError in cPython, AttributeError in PyPy + exception = TypeError, AttributeError + zipl = zip_longest + type_ = type + list_ = list + while work: + n1, n2 = pop() + try: + f1 = geta(n1, '_fields') + f2 = geta(n2, '_fields') + except exception: + if type_(n1) is list_: + extend(zipl(n1, n2)) + continue + if n1 == n2: + continue + return False + else: + f1 = [x for x in f1 if x != 'ctx'] + if f1 != [x for x in f2 if x != 'ctx']: + return False + extend((geta(n1, fname), geta(n2, fname)) for fname in f1) + + return True diff --git a/tools/astor_0_8_1/op_util.py b/tools/astor_0_8_1/op_util.py new file mode 100644 index 0000000..e54e88b --- /dev/null +++ b/tools/astor_0_8_1/op_util.py @@ -0,0 +1,110 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright (c) 2015 Patrick Maupin + +This module provides data and functions for mapping +AST nodes to symbols and precedences. + +""" + +import ast + +op_data = """ + GeneratorExp 1 + + Assign 1 + AnnAssign 1 + AugAssign 0 + Expr 0 + Yield 1 + YieldFrom 0 + If 1 + For 0 + AsyncFor 0 + While 0 + Return 1 + + Slice 1 + Subscript 0 + Index 1 + ExtSlice 1 + comprehension_target 1 + Tuple 0 + FormattedValue 0 + + Comma 1 + NamedExpr 1 + Assert 0 + Raise 0 + call_one_arg 1 + + Lambda 1 + IfExp 0 + + comprehension 1 + Or or 1 + And and 1 + Not not 1 + + Eq == 1 + Gt > 0 + GtE >= 0 + In in 0 + Is is 0 + NotEq != 0 + Lt < 0 + LtE <= 0 + NotIn not in 0 + IsNot is not 0 + + BitOr | 1 + BitXor ^ 1 + BitAnd & 1 + LShift << 1 + RShift >> 0 + Add + 1 + Sub - 0 + Mult * 1 + Div / 0 + Mod % 0 + FloorDiv // 0 + MatMult @ 0 + PowRHS 1 + Invert ~ 1 + UAdd + 0 + USub - 0 + Pow ** 1 + Await 1 + Num 1 + Constant 1 +""" + +op_data = [x.split() for x in op_data.splitlines()] +op_data = [[x[0], ' '.join(x[1:-1]), int(x[-1])] for x in op_data if x] +for index in range(1, len(op_data)): + op_data[index][2] *= 2 + op_data[index][2] += op_data[index - 1][2] + +precedence_data = dict((getattr(ast, x, None), z) for x, y, z in op_data) +symbol_data = dict((getattr(ast, x, None), y) for x, y, z in op_data) + + +def get_op_symbol(obj, fmt='%s', symbol_data=symbol_data, type=type): + """Given an AST node object, returns a string containing the symbol. + """ + return fmt % symbol_data[type(obj)] + + +def get_op_precedence(obj, precedence_data=precedence_data, type=type): + """Given an AST node object, returns the precedence. + """ + return precedence_data[type(obj)] + + +class Precedence(object): + vars().update((x, z) for x, y, z in op_data) + highest = max(z for x, y, z in op_data) + 2 diff --git a/tools/astor_0_8_1/rtrip.py b/tools/astor_0_8_1/rtrip.py new file mode 100644 index 0000000..8b108e7 --- /dev/null +++ b/tools/astor_0_8_1/rtrip.py @@ -0,0 +1,209 @@ +#! /usr/bin/env python +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright (c) 2015 Patrick Maupin +""" + +import sys +import os +import ast +import shutil +import logging + +from astor.code_gen import to_source +from astor.file_util import code_to_ast +from astor.node_util import (allow_ast_comparison, dump_tree, + strip_tree, fast_compare) + + +dsttree = 'tmp_rtrip' + +# TODO: Remove this workaround once we remove version 2 support + + +def out_prep(s, pre_encoded=(sys.version_info[0] == 2)): + return s if pre_encoded else s.encode('utf-8') + + +def convert(srctree, dsttree=dsttree, readonly=False, dumpall=False, + ignore_exceptions=False, fullcomp=False): + """Walk the srctree, and convert/copy all python files + into the dsttree + + """ + + if fullcomp: + allow_ast_comparison() + + parse_file = code_to_ast.parse_file + find_py_files = code_to_ast.find_py_files + srctree = os.path.normpath(srctree) + + if not readonly: + dsttree = os.path.normpath(dsttree) + logging.info('') + logging.info('Trashing ' + dsttree) + shutil.rmtree(dsttree, True) + + unknown_src_nodes = set() + unknown_dst_nodes = set() + badfiles = set() + broken = [] + + oldpath = None + + allfiles = find_py_files(srctree, None if readonly else dsttree) + for srcpath, fname in allfiles: + # Create destination directory + if not readonly and srcpath != oldpath: + oldpath = srcpath + if srcpath >= srctree: + dstpath = srcpath.replace(srctree, dsttree, 1) + if not dstpath.startswith(dsttree): + raise ValueError("%s not a subdirectory of %s" % + (dstpath, dsttree)) + else: + assert srctree.startswith(srcpath) + dstpath = dsttree + os.makedirs(dstpath) + + srcfname = os.path.join(srcpath, fname) + logging.info('Converting %s' % srcfname) + try: + srcast = parse_file(srcfname) + except SyntaxError: + badfiles.add(srcfname) + continue + + try: + dsttxt = to_source(srcast) + except Exception: + if not ignore_exceptions: + raise + dsttxt = '' + + if not readonly: + dstfname = os.path.join(dstpath, fname) + try: + with open(dstfname, 'wb') as f: + f.write(out_prep(dsttxt)) + except UnicodeEncodeError: + badfiles.add(dstfname) + + # As a sanity check, make sure that ASTs themselves + # round-trip OK + try: + dstast = ast.parse(dsttxt) if readonly else parse_file(dstfname) + except SyntaxError: + dstast = [] + if fullcomp: + unknown_src_nodes.update(strip_tree(srcast)) + unknown_dst_nodes.update(strip_tree(dstast)) + bad = srcast != dstast + else: + bad = not fast_compare(srcast, dstast) + if dumpall or bad: + srcdump = dump_tree(srcast) + dstdump = dump_tree(dstast) + logging.warning(' calculating dump -- %s' % + ('bad' if bad else 'OK')) + if bad: + broken.append(srcfname) + if dumpall or bad: + if not readonly: + try: + with open(dstfname[:-3] + '.srcdmp', 'wb') as f: + f.write(out_prep(srcdump)) + except UnicodeEncodeError: + badfiles.add(dstfname[:-3] + '.srcdmp') + try: + with open(dstfname[:-3] + '.dstdmp', 'wb') as f: + f.write(out_prep(dstdump)) + except UnicodeEncodeError: + badfiles.add(dstfname[:-3] + '.dstdmp') + elif dumpall: + sys.stdout.write('\n\nAST:\n\n ') + sys.stdout.write(srcdump.replace('\n', '\n ')) + sys.stdout.write('\n\nDecompile:\n\n ') + sys.stdout.write(dsttxt.replace('\n', '\n ')) + sys.stdout.write('\n\nNew AST:\n\n ') + sys.stdout.write('(same as old)' if dstdump == srcdump + else dstdump.replace('\n', '\n ')) + sys.stdout.write('\n') + + if badfiles: + logging.warning('\nFiles not processed due to syntax errors:') + for fname in sorted(badfiles): + logging.warning(' %s' % fname) + if broken: + logging.warning('\nFiles failed to round-trip to AST:') + for srcfname in broken: + logging.warning(' %s' % srcfname) + + ok_to_strip = 'col_offset _precedence _use_parens lineno _p_op _pp' + ok_to_strip = set(ok_to_strip.split()) + bad_nodes = (unknown_dst_nodes | unknown_src_nodes) - ok_to_strip + if bad_nodes: + logging.error('\nERROR -- UNKNOWN NODES STRIPPED: %s' % bad_nodes) + logging.info('\n') + return broken + + +def usage(msg): + raise SystemExit(textwrap.dedent(""" + + Error: %s + + Usage: + + python -m astor.rtrip [readonly] [] + + + This utility tests round-tripping of Python source to AST + and back to source. + + If readonly is specified, then the source will be tested, + but no files will be written. + + if the source is specified to be "stdin" (without quotes) + then any source entered at the command line will be compiled + into an AST, converted back to text, and then compiled to + an AST again, and the results will be displayed to stdout. + + If neither readonly nor stdin is specified, then rtrip + will create a mirror directory named tmp_rtrip and will + recursively round-trip all the Python source from the source + into the tmp_rtrip dir, after compiling it and then reconstituting + it through code_gen.to_source. + + If the source is not specified, the entire Python library will be used. + + """) % msg) + + +if __name__ == '__main__': + import textwrap + + args = sys.argv[1:] + + readonly = 'readonly' in args + if readonly: + args.remove('readonly') + + if not args: + args = [os.path.dirname(textwrap.__file__)] + + if len(args) > 1: + usage("Too many arguments") + + fname, = args + dumpall = False + if not os.path.exists(fname): + dumpall = fname == 'stdin' or usage("Cannot find directory %s" % fname) + + logging.basicConfig(format='%(msg)s', level=logging.INFO) + convert(fname, readonly=readonly or dumpall, dumpall=dumpall) diff --git a/tools/astor_0_8_1/source_repr.py b/tools/astor_0_8_1/source_repr.py new file mode 100644 index 0000000..3985523 --- /dev/null +++ b/tools/astor_0_8_1/source_repr.py @@ -0,0 +1,273 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright (c) 2015 Patrick Maupin + +Pretty-print source -- post-process for the decompiler + +The goals of the initial cut of this engine are: + +1) Do a passable, if not PEP8, job of line-wrapping. + +2) Serve as an example of an interface to the decompiler + for anybody who wants to do a better job. :) +""" + + +def pretty_source(source): + """ Prettify the source. + """ + + return ''.join(split_lines(source)) + + +def split_lines(source, maxline=79): + """Split inputs according to lines. + If a line is short enough, just yield it. + Otherwise, fix it. + """ + result = [] + extend = result.extend + append = result.append + line = [] + multiline = False + count = 0 + for item in source: + newline = type(item)('\n') + index = item.find(newline) + if index: + line.append(item) + multiline = index > 0 + count += len(item) + else: + if line: + if count <= maxline or multiline: + extend(line) + else: + wrap_line(line, maxline, result) + count = 0 + multiline = False + line = [] + append(item) + return result + + +def count(group, slen=str.__len__): + return sum([slen(x) for x in group]) + + +def wrap_line(line, maxline=79, result=[], count=count): + """ We have a line that is too long, + so we're going to try to wrap it. + """ + + # Extract the indentation + + append = result.append + extend = result.extend + + indentation = line[0] + lenfirst = len(indentation) + indent = lenfirst - len(indentation.lstrip()) + assert indent in (0, lenfirst) + indentation = line.pop(0) if indent else '' + + # Get splittable/non-splittable groups + + dgroups = list(delimiter_groups(line)) + unsplittable = dgroups[::2] + splittable = dgroups[1::2] + + # If the largest non-splittable group won't fit + # on a line, try to add parentheses to the line. + + if max(count(x) for x in unsplittable) > maxline - indent: + line = add_parens(line, maxline, indent) + dgroups = list(delimiter_groups(line)) + unsplittable = dgroups[::2] + splittable = dgroups[1::2] + + # Deal with the first (always unsplittable) group, and + # then set up to deal with the remainder in pairs. + + first = unsplittable[0] + append(indentation) + extend(first) + if not splittable: + return result + pos = indent + count(first) + indentation += ' ' + indent += 4 + if indent >= maxline / 2: + maxline = maxline / 2 + indent + + for sg, nsg in zip(splittable, unsplittable[1:]): + + if sg: + # If we already have stuff on the line and even + # the very first item won't fit, start a new line + if pos > indent and pos + len(sg[0]) > maxline: + append('\n') + append(indentation) + pos = indent + + # Dump lines out of the splittable group + # until the entire thing fits + csg = count(sg) + while pos + csg > maxline: + ready, sg = split_group(sg, pos, maxline) + if ready[-1].endswith(' '): + ready[-1] = ready[-1][:-1] + extend(ready) + append('\n') + append(indentation) + pos = indent + csg = count(sg) + + # Dump the remainder of the splittable group + if sg: + extend(sg) + pos += csg + + # Dump the unsplittable group, optionally + # preceded by a linefeed. + cnsg = count(nsg) + if pos > indent and pos + cnsg > maxline: + append('\n') + append(indentation) + pos = indent + extend(nsg) + pos += cnsg + + +def split_group(source, pos, maxline): + """ Split a group into two subgroups. The + first will be appended to the current + line, the second will start the new line. + + Note that the first group must always + contain at least one item. + + The original group may be destroyed. + """ + first = [] + source.reverse() + while source: + tok = source.pop() + first.append(tok) + pos += len(tok) + if source: + tok = source[-1] + allowed = (maxline + 1) if tok.endswith(' ') else (maxline - 4) + if pos + len(tok) > allowed: + break + + source.reverse() + return first, source + + +begin_delim = set('([{') +end_delim = set(')]}') +end_delim.add('):') + + +def delimiter_groups(line, begin_delim=begin_delim, + end_delim=end_delim): + """Split a line into alternating groups. + The first group cannot have a line feed inserted, + the next one can, etc. + """ + text = [] + line = iter(line) + while True: + # First build and yield an unsplittable group + for item in line: + text.append(item) + if item in begin_delim: + break + if not text: + break + yield text + + # Now build and yield a splittable group + level = 0 + text = [] + for item in line: + if item in begin_delim: + level += 1 + elif item in end_delim: + level -= 1 + if level < 0: + yield text + text = [item] + break + text.append(item) + else: + assert not text, text + break + + +statements = set(['del ', 'return', 'yield ', 'if ', 'while ']) + + +def add_parens(line, maxline, indent, statements=statements, count=count): + """Attempt to add parentheses around the line + in order to make it splittable. + """ + + if line[0] in statements: + index = 1 + if not line[0].endswith(' '): + index = 2 + assert line[1] == ' ' + line.insert(index, '(') + if line[-1] == ':': + line.insert(-1, ')') + else: + line.append(')') + + # That was the easy stuff. Now for assignments. + groups = list(get_assign_groups(line)) + if len(groups) == 1: + # So sad, too bad + return line + + counts = list(count(x) for x in groups) + didwrap = False + + # If the LHS is large, wrap it first + if sum(counts[:-1]) >= maxline - indent - 4: + for group in groups[:-1]: + didwrap = False # Only want to know about last group + if len(group) > 1: + group.insert(0, '(') + group.insert(-1, ')') + didwrap = True + + # Might not need to wrap the RHS if wrapped the LHS + if not didwrap or counts[-1] > maxline - indent - 10: + groups[-1].insert(0, '(') + groups[-1].append(')') + + return [item for group in groups for item in group] + + +# Assignment operators +ops = list('|^&+-*/%@~') + '<< >> // **'.split() + [''] +ops = set(' %s= ' % x for x in ops) + + +def get_assign_groups(line, ops=ops): + """ Split a line into groups by assignment (including + augmented assignment) + """ + group = [] + for item in line: + group.append(item) + if item in ops: + yield group + group = [] + yield group diff --git a/tools/astor_0_8_1/string_repr.py b/tools/astor_0_8_1/string_repr.py new file mode 100644 index 0000000..6dce9cc --- /dev/null +++ b/tools/astor_0_8_1/string_repr.py @@ -0,0 +1,112 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright (c) 2015 Patrick Maupin + +Pretty-print strings for the decompiler + +We either return the repr() of the string, +or try to format it as a triple-quoted string. + +This is a lot harder than you would think. + +This has lots of Python 2 / Python 3 ugliness. + +""" + +import re + +try: + special_unicode = unicode +except NameError: + class special_unicode(object): + pass + +try: + basestring = basestring +except NameError: + basestring = str + + +def _properly_indented(s, line_indent): + mylist = s.split('\n')[1:] + mylist = [x.rstrip() for x in mylist] + mylist = [x for x in mylist if x] + if not s: + return False + counts = [(len(x) - len(x.lstrip())) for x in mylist] + return counts and min(counts) >= line_indent + + +mysplit = re.compile(r'(\\|\"\"\"|\"$)').split +replacements = {'\\': '\\\\', '"""': '""\\"', '"': '\\"'} + + +def _prep_triple_quotes(s, mysplit=mysplit, replacements=replacements): + """ Split the string up and force-feed some replacements + to make sure it will round-trip OK + """ + + s = mysplit(s) + s[1::2] = (replacements[x] for x in s[1::2]) + return ''.join(s) + + +def string_triplequote_repr(s): + """Return string's python representation in triple quotes. + """ + return '"""%s"""' % _prep_triple_quotes(s) + + +def pretty_string(s, embedded, current_line, uni_lit=False, + min_trip_str=20, max_line=100): + """There are a lot of reasons why we might not want to or + be able to return a triple-quoted string. We can always + punt back to the default normal string. + """ + + default = repr(s) + + # Punt on abnormal strings + if (isinstance(s, special_unicode) or not isinstance(s, basestring)): + return default + if uni_lit and isinstance(s, bytes): + return 'b' + default + + len_s = len(default) + + if current_line.strip(): + len_current = len(current_line) + second_line_start = s.find('\n') + 1 + if embedded > 1 and not second_line_start: + return default + + if len_s < min_trip_str: + return default + + line_indent = len_current - len(current_line.lstrip()) + + # Could be on a line by itself... + if embedded and not second_line_start: + return default + + total_len = len_current + len_s + if total_len < max_line and not _properly_indented(s, line_indent): + return default + + fancy = string_triplequote_repr(s) + + # Sometimes this doesn't work. One reason is that + # the AST has no understanding of whether \r\n was + # entered that way in the string or was a cr/lf in the + # file. So we punt just so we can round-trip properly. + + try: + if eval(fancy) == s and '\r' not in fancy: + return fancy + except Exception: + pass + return default diff --git a/tools/astor_0_8_1/tree_walk.py b/tools/astor_0_8_1/tree_walk.py new file mode 100644 index 0000000..359242b --- /dev/null +++ b/tools/astor_0_8_1/tree_walk.py @@ -0,0 +1,179 @@ +# -*- coding: utf-8 -*- +""" +Part of the astor library for Python AST manipulation. + +License: 3-clause BSD + +Copyright 2012 (c) Patrick Maupin +Copyright 2013 (c) Berker Peksag + +This file contains a TreeWalk class that views a node tree +as a unified whole and allows several modes of traversal. + +""" + +from .node_util import iter_node + + +class MetaFlatten(type): + """This metaclass is used to flatten classes to remove + class hierarchy. + + This makes it easier to manipulate classes (find + attributes in a single dict, etc.) + + """ + def __new__(clstype, name, bases, clsdict): + newbases = (object,) + newdict = {} + for base in reversed(bases): + if base not in newbases: + newdict.update(vars(base)) + newdict.update(clsdict) + # These are class-bound, we should let Python recreate them. + newdict.pop('__dict__', None) + newdict.pop('__weakref__', None) + # Delegate the real work to type + return type.__new__(clstype, name, newbases, newdict) + + +MetaFlatten = MetaFlatten('MetaFlatten', (object,), {}) + + +class TreeWalk(MetaFlatten): + """The TreeWalk class can be used as a superclass in order + to walk an AST or similar tree. + + Unlike other treewalkers, this class can walk a tree either + recursively or non-recursively. Subclasses can define + methods with the following signatures:: + + def pre_xxx(self): + pass + + def post_xxx(self): + pass + + def init_xxx(self): + pass + + Where 'xxx' is one of: + + - A class name + - An attribute member name concatenated with '_name' + For example, 'pre_targets_name' will process nodes + that are referenced by the name 'targets' in their + parent's node. + - An attribute member name concatenated with '_item' + For example, 'pre_targets_item' will process nodes + that are in a list that is the targets attribute + of some node. + + pre_xxx will process a node before processing any of its subnodes. + if the return value from pre_xxx evalates to true, then walk + will not process any of the subnodes. Those can be manually + processed, if desired, by calling self.walk(node) on the subnodes + before returning True. + + post_xxx will process a node after processing all its subnodes. + + init_xxx methods can decorate the class instance with subclass-specific + information. A single init_whatever method could be written, but to + make it easy to keep initialization with use, any number of init_xxx + methods can be written. They will be called in alphabetical order. + + """ + + def __init__(self, node=None): + self.nodestack = [] + self.setup() + if node is not None: + self.walk(node) + + def setup(self): + """All the node-specific handlers are setup at + object initialization time. + + """ + self.pre_handlers = pre_handlers = {} + self.post_handlers = post_handlers = {} + for name in sorted(vars(type(self))): + if name.startswith('init_'): + getattr(self, name)() + elif name.startswith('pre_'): + pre_handlers[name[4:]] = getattr(self, name) + elif name.startswith('post_'): + post_handlers[name[5:]] = getattr(self, name) + + def walk(self, node, name='', list=list, len=len, type=type): + """Walk the tree starting at a given node. + + Maintain a stack of nodes. + + """ + pre_handlers = self.pre_handlers.get + post_handlers = self.post_handlers.get + nodestack = self.nodestack + emptystack = len(nodestack) + append, pop = nodestack.append, nodestack.pop + append([node, name, list(iter_node(node, name + '_item')), -1]) + while len(nodestack) > emptystack: + node, name, subnodes, index = nodestack[-1] + if index >= len(subnodes): + handler = (post_handlers(type(node).__name__) or + post_handlers(name + '_name')) + if handler is None: + pop() + continue + self.cur_node = node + self.cur_name = name + handler() + current = nodestack and nodestack[-1] + popstack = current and current[0] is node + if popstack and current[-1] >= len(current[-2]): + pop() + continue + nodestack[-1][-1] = index + 1 + if index < 0: + handler = (pre_handlers(type(node).__name__) or + pre_handlers(name + '_name')) + if handler is not None: + self.cur_node = node + self.cur_name = name + if handler(): + pop() + else: + node, name = subnodes[index] + append([node, name, list(iter_node(node, name + '_item')), -1]) + + @property + def parent(self): + """Return the parent node of the current node.""" + nodestack = self.nodestack + if len(nodestack) < 2: + return None + return nodestack[-2][0] + + @property + def parent_name(self): + """Return the parent node and name.""" + nodestack = self.nodestack + if len(nodestack) < 2: + return None + return nodestack[-2][:2] + + def replace(self, new_node): + """Replace a node after first checking integrity of node stack.""" + cur_node = self.cur_node + nodestack = self.nodestack + cur = nodestack.pop() + prev = nodestack[-1] + index = prev[-1] - 1 + oldnode, name = prev[-2][index] + assert cur[0] is cur_node is oldnode, (cur[0], cur_node, prev[-2], + index) + parent = prev[0] + if isinstance(parent, list): + parent[index] = new_node + else: + setattr(parent, name, new_node) diff --git a/tools/chkapi.py b/tools/chkapi.py index 5917392..72cdad9 100644 --- a/tools/chkapi.py +++ b/tools/chkapi.py @@ -53,8 +53,8 @@ def check_cpp(args): # # Misc. # - "_wrap_tinfo_t_deserialize__SWIG_1" : { - "mustcall" : "tinfo_t_deserialize__SWIG_1", + "_wrap_tinfo_t_deserialize__SWIG_7" : { + "mustcall" : "tinfo_t_deserialize__SWIG_7", }, "_wrap_get_bpt_group" : { "mustcall" : "_maybe_sized_cstring_result", @@ -115,15 +115,6 @@ def check_cpp(args): "_wrap_idainfo_tag_get" : { "nostring" : " --size;", }, - - "_wrap_warning__varargs__" : { - "nullptrcheck" : 1, # 1st arg - "mustcall" : "PyUnicode_as_qstring", - }, - "_wrap_error__varargs__" : { - "nullptrcheck" : 1, - "mustcall" : "PyUnicode_as_qstring", - }, "_wrap_tag_remove" : { "nullptrcheck" : 1, }, @@ -133,20 +124,12 @@ def check_cpp(args): "_wrap_compile_idc_text" : { "nullptrcheck" : 1, }, - "_wrap_get_member_size" : { - "nullptrcheck" : 1, - }, "_wrap_load_debugger" : { "string" : ["SWIG_PYTHON_THREAD_BEGIN_ALLOW", "SWIG_PYTHON_THREAD_END_ALLOW"], }, - "_wrap_AssembleLine" : { - "nullptrcheck" : 5, - }, - "_wrap_get_opinfo" : { "string" : ["Py_XDECREF(resultobj)", "Py_INCREF(resultobj)"], }, - "_wrap_file2base" : { "nostring" : ["SWIGTYPE_p_qoff64_t", "qoff64_t *"], }, @@ -166,13 +149,13 @@ def check_cpp(args): "_wrap_vd_failure_t_desc" : { "mustcall" : "PyUnicode_FromStringAndSize", }, - "_wrap_create_field_name" : { + "_wrap_create_field_name__SWIG_0" : { "mustcall" : "PyUnicode_FromStringAndSize", }, "delete_qrefcnt_t_Sl_cfunc_t_Sg_" : { "mustcall" : "hexrays_deregister_python_clearable_instance", }, - "_wrap_decompile" : { + "_wrap_decompile__SWIG_0" : { "mustcall" : "hexrays_register_python_clearable_instance", }, "_wrap_vdui_t_cfunc_get" : { @@ -372,7 +355,6 @@ def check_python(args): "_qstrvec_t" : { "mustinherit" : "ida_idaapi.py_clinked_object_t" }, "argpart_t" : { "mustinherit" : "argloc_t" }, "cli_t" : { "mustinherit" : "ida_idaapi.pyidc_opaque_object_t" }, - "enumplace_t" : { "mustinherit" : "place_t" }, "func_type_data_t" : { "mustinherit" : "funcargvec_t" }, "ida_lowertype_helper_t" : { "mustinherit" : "lowertype_helper_t" }, "idaplace_t" : { "mustinherit" : "place_t" }, @@ -383,13 +365,13 @@ def check_python(args): "py_clinked_object_t" : { "mustinherit" : "pyidc_opaque_object_t" }, "segm_move_infos_t" : { "mustinherit" : "segm_move_info_vec_t" }, "simpleline_place_t" : { "mustinherit" : "place_t" }, - "structplace_t" : { "mustinherit" : "place_t" }, + "tiplace_t" : { "mustinherit" : "place_t" }, "textctrl_info_t" : { "mustinherit" : "ida_idaapi.py_clinked_object_t" }, "udtmembervec_t" : { "mustinherit" : "udtmembervec_template_t" }, "udt_type_data_t" : { "mustinherit" : "udtmembervec_t" }, "call_stack_t" : { "mustinherit" : "call_stack_info_vec_t" }, - "abstract_graph_t" : { "mustinherit" : "ida_gdl.gdl_graph_t" }, - "mutable_graph_t" : { "mustinherit" : "abstract_graph_t" }, + "drawable_graph_t" : { "mustinherit" : "ida_gdl.gdl_graph_t" }, + "interactive_graph_t" : { "mustinherit" : "drawable_graph_t" }, "meminfo_vec_t" : { "mustinherit" : "meminfo_vec_template_t" }, # Just look for the presence of those things diff --git a/tools/collected_traces.txt b/tools/collected_traces.txt deleted file mode 100644 index 7f11559..0000000 --- a/tools/collected_traces.txt +++ /dev/null @@ -1,18564 +0,0 @@ -{ - "#empty": { - "ida.inf_get_privrange_start_ea": [ - 'int', - ], - "idaapi.IDAPython_ExecScript": [ - 'NoneType', - 'str', - ], - "idaapi.IDAPython_LoadProcMod": [ - ('NoneType', 'ClemencyProcessor'), - ('NoneType', 'clunky_processor_t'), - ('NoneType', 'cyci_processor_t'), - ('NoneType', 'ebc_processor_t'), - ('NoneType', 'msp430_processor_t'), - ('NoneType', 'sample_processor_t'), - ('NoneType', 'spu_processor_t'), - ], - "idaapi.IDAPython_UnLoadProcMod": [ - 'NoneType', - ], - "idp.IDP_Hooks.hook": [ - 'bool', - ], - "idp.processor_t.get_idpdesc": [ - 'str', - ], - "kernwin.attach_action_to_menu": [ - 'bool', - ], - "kernwin.msg": [ - 'int', - ], - "kernwin.register_action": [ - 'bool', - ], - "loader.get_plugin_options": [ - 'NoneType', - ], - "netnode.netnode.create": [ - 'bool', - ], - }, - "auto.auto_make_code": { - "return": [ - 'NoneType', - ], - "tests": [ - "frview-center_in_window", - "frview-scrollbar", - "grview-navigate_nodes_endless_analysis", - "hexrays-navigate5__ndis_arrow_down_constantly_modified_idb", - "prview-paths2", - ] - }, - "auto.auto_make_proc": { - "return": [ - 'NoneType', - ], - "tests": [ - "frview-scrollbar", - ] - }, - "auto.auto_wait": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-caching__rebase_down_1000", - "hexrays-caching__rebase_up_1000", - "idapython-big_spd_bug", - "idapython-examples__produce_c_file", - "idapython-examples__produce_lst_file", - "strings-misc__rebase", - "strings-misc__rebase_range", - "strings-misc__restore_after_rebase", - ] - }, - "auto.may_create_stkvars": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "auto.may_trace_sp": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "auto.plan_ea": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-big_spd_bug", - ] - }, - "bitrange.bitrange_t.apply_mask": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__bitrange", - "idapython-api__idp", - ] - }, - "bitrange.bitrange_t.bitoff": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bitrange.bitrange_t.bitsize": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bitrange.bitrange_t.extract": { - "return": [ - 'bytes', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bitrange.bitrange_t.inject": { - "return": [ - 'NoneType', - 'bytes', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bitrange.bitrange_t.intersect": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bitrange.bitrange_t.mask64": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bitrange.bitrange_t.shift_down": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bitrange.bitrange_t.shift_up": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__bitrange", - ] - }, - "bytes.add_mapping": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-mapping", - "idapython-misc3", - ] - }, - "bytes.attach_custom_data_format": { - "return": [ - 'bool', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-custom_data", - "idapython-custom_data2__beword_idaview", - "idapython-custom_data2__beword_shortcut", - "idapython-custom_data2__beword_structs", - "idapython-custom_data3", - "idaview-context_menu", - ] - }, - "bytes.bin_search": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search_bin__search1_dbg", - "customidamemo-search_bin__search1_sparse", - "customidamemo-search_bin__search1_varray", - "idapython-examples__bin_search", - ] - }, - "bytes.byte_flag": { - "return": [ - 'int', - ], - "tests": [ - "stackview-misc", - "structs-members", - ] - }, - "bytes.create_strlit": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - ] - }, - "bytes.create_struct": { - "return": [ - 'bool', - ], - "tests": [ - "strlits-borland", - ] - }, - "bytes.del_hidden_range": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - ] - }, - "bytes.del_items": { - "return": [ - 'bool', - ], - "tests": [ - "frview-center_in_window", - "frview-scrollbar", - "grview-navigate_nodes_endless_analysis", - "hexrays-navigate5__ndis_arrow_down_constantly_modified_idb", - "idaview-hints__instruction_gets_deleted", - "prview-paths2", - "undo-widgets__snippets", - ] - }, - "bytes.del_mapping": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-mapping", - "idapython-misc3", - ] - }, - "bytes.dword_flag": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "structs-members", - ] - }, - "bytes.find_custom_data_format": { - "return": [ - 'int', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-custom_data", - ] - }, - "bytes.find_custom_data_type": { - "return": [ - 'int', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-custom_data", - ] - }, - "bytes.free_chunk": { - "return": [ - 'int', - ], - "tests": [ - "screenshots-misc__proc_dsp56k", - ] - }, - "bytes.get_byte": { - "return": [ - 'int', - ], - "tests": [ - "api-put_patch_get", - "training-test__CallStackWalk_py", - ] - }, - "bytes.get_bytes": { - "return": [ - 'NoneType', - 'bytes', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "idapython-api__idautils", - "idapython-get_ascii_contents", - "idapython-misc3", - "plugins-procext_py", - ] - }, - "bytes.get_cmt": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-snapshots", - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - ] - }, - "bytes.get_custom_data_type": { - "return": [ - 'data_type_t', - ], - "tests": [ - "idapython-custom_data", - ] - }, - "bytes.get_dword": { - "return": [ - 'int', - ], - "tests": [ - "api-put_patch_get", - "idapython-custom_fixup", - "training-test__CallStackWalk_py", - ] - }, - "bytes.get_flags": { - "return": [ - 'int', - ], - "tests": [ - "debugger-breakpoints2__bpt_perf", - "i18n-strlits__bad_encoding_name", - "i18n-strlits__create_C_16_strlit", - "i18n-strlits__create_C_32_strlit", - "i18n-strlits__create_C_strlit", - "i18n-strlits__create_pascal_16", - "i18n-strlits__delete_encoding", - "i18n-strlits__delete_encoding_using_idapython", - "i18n-strlits__dup_encodings", - "i18n-strlits__edit_encoding", - "i18n-strlits__edit_encoding_with_changing_its_BUP", - "i18n-strlits__select_BPU_incompatible_charset_changes_strtype_BPU", - "idapython-custom_data", - "idapython-examples__list_stkvar_xrefs", - "idapython-examples__operand_changed", - "idapython-execute_sync", - "idapython-misc3", - "idapython-opinfo", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython_hr-examples__modified_vds13_twice", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds13", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - "training-test__sol_cyci_py", - ] - }, - "bytes.get_full_flags": { - "return": [ - 'int', - ], - "tests": [ - "idapython-execute_sync", - ] - }, - "bytes.get_hidden_range": { - "return": [ - 'hidden_range_t', - ], - "tests": [ - "idapython-misc2", - ] - }, - "bytes.get_item_size": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - ] - }, - "bytes.get_mapping": { - "return": [ - ('bool', 'int', 'int', 'int'), - ], - "tests": [ - "idapython-mapping", - "idapython-misc3", - ] - }, - "bytes.get_mappings_qty": { - "return": [ - 'int', - ], - "tests": [ - "idapython-mapping", - "idapython-misc3", - ] - }, - "bytes.get_max_strlit_length": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "i18n-strlits__get_strlit_contents_utf8_with_bom", - "idapython-examples__operand_changed", - "idapython-get_ascii_contents", - "idapython-misc4", - ] - }, - "bytes.get_octet": { - "return": [ - ('int', 'int', 'int', 'int'), - ], - "tests": [ - "idapython-misc3", - ] - }, - "bytes.get_opinfo": { - "return": [ - 'NoneType', - 'opinfo_t', - ], - "tests": [ - "i18n-strlits__bad_encoding_name", - "i18n-strlits__create_C_16_strlit", - "i18n-strlits__create_C_32_strlit", - "i18n-strlits__create_C_strlit", - "i18n-strlits__create_pascal_16", - "i18n-strlits__delete_encoding", - "i18n-strlits__delete_encoding_using_idapython", - "i18n-strlits__dup_encodings", - "i18n-strlits__edit_encoding", - "i18n-strlits__edit_encoding_with_changing_its_BUP", - "i18n-strlits__select_BPU_incompatible_charset_changes_strtype_BPU", - "idapython-custom_data", - "idapython-examples__operand_changed", - "idapython-misc3", - "idapython-opinfo", - ] - }, - "bytes.get_original_qword": { - "return": [ - 'int', - ], - "tests": [ - "api-put_patch_get", - ] - }, - "bytes.get_predef_insn_cmt": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-misc3", - ] - }, - "bytes.get_qword": { - "return": [ - 'int', - ], - "tests": [ - "api-put_patch_get", - ] - }, - "bytes.get_strlit_contents": { - "return": [ - 'NoneType', - 'bytes', - ], - "tests": [ - "i18n-strlits__get_strlit_contents_utf8_with_bom", - "idapython-examples__operand_changed", - "idapython-examples__show_selected_using_get_strlist_item", - "idapython-get_ascii_contents", - "idapython-misc4", - "idapython-strings", - "pyqt-qabstractitemdelegate", - ] - }, - "bytes.get_wide_dword": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__ana_emu_out", - ] - }, - "bytes.get_wide_word": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module_mem", - "training-test__sol_cyci_py", - ] - }, - "bytes.get_word": { - "return": [ - 'int', - ], - "tests": [ - "api-put_patch_get", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "bytes.has_value": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-execute_sync", - ] - }, - "bytes.is_code": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__modified_vds13_twice", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds13", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - ] - }, - "bytes.is_defarg": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "bytes.is_enum": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__operand_changed", - ] - }, - "bytes.is_loaded": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-execute_sync", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "bytes.is_off": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__operand_changed", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "bytes.is_stkvar": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__list_stkvar_xrefs", - ] - }, - "bytes.is_strlit": { - "return": [ - 'bool', - ], - "tests": [ - "i18n-strlits__bad_encoding_name", - "i18n-strlits__create_C_16_strlit", - "i18n-strlits__create_C_32_strlit", - "i18n-strlits__create_C_strlit", - "i18n-strlits__create_pascal_16", - "i18n-strlits__delete_encoding", - "i18n-strlits__delete_encoding_using_idapython", - "i18n-strlits__dup_encodings", - "i18n-strlits__edit_encoding", - "i18n-strlits__edit_encoding_with_changing_its_BUP", - "i18n-strlits__select_BPU_incompatible_charset_changes_strtype_BPU", - "idapython-examples__operand_changed", - "idapython-misc3", - ] - }, - "bytes.is_stroff": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__operand_changed", - ] - }, - "bytes.is_struct": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__operand_changed", - ] - }, - "bytes.next_addr": { - "return": [ - 'int', - ], - "tests": [ - "idapython-snapshots", - ] - }, - "bytes.next_head": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - "debugger-breakpoints2__bpt_perf", - "hexrays-misc2", - "idapython-examples__jump_next_comment", - "idapython-examples__lines_rendering", - ] - }, - "bytes.next_visea": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search2__idaview_across_hidden_function", - ] - }, - "bytes.off_flag": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__create_structure_programmatically", - ] - }, - "bytes.op_stkvar": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "bytes.op_stroff": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_doc__bytes", - "api-idapython_nocompat_695__idc", - ] - }, - "bytes.parse_binpat_str": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-examples__bin_search", - ] - }, - "bytes.patch_byte": { - "return": [ - 'bool', - ], - "tests": [ - "api-put_patch_get", - "eaview-patch_bytes__chooser", - ] - }, - "bytes.patch_dword": { - "return": [ - 'bool', - ], - "tests": [ - "api-put_patch_get", - ] - }, - "bytes.patch_qword": { - "return": [ - 'bool', - ], - "tests": [ - "api-put_patch_get", - ] - }, - "bytes.patch_word": { - "return": [ - 'bool', - ], - "tests": [ - "api-put_patch_get", - ] - }, - "bytes.prev_head": { - "return": [ - 'int', - ], - "tests": [ - "training-test__find_mgen_key_py", - ] - }, - "bytes.print_strlit_type": { - "return": [ - ('str', 'str'), - ], - "tests": [ - "i18n-strlits__change_default_string_style", - ] - }, - "bytes.put_byte": { - "return": [ - 'bool', - ], - "tests": [ - "idaview-hints__instruction_gets_deleted", - ] - }, - "bytes.put_bytes": { - "return": [ - 'NoneType', - ], - "tests": [ - "customidamemo-search_bin__search1_sparse", - "customidamemo-search_bin__search1_varray", - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "screenshots-misc__proc_dsp56k", - ] - }, - "bytes.put_dword": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-bfld", - ] - }, - "bytes.qword_flag": { - "return": [ - 'int', - ], - "tests": [ - "structs-members", - ] - }, - "bytes.register_custom_data_format": { - "return": [ - 'int', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-custom_data", - "idapython-custom_data2__beword_idaview", - "idapython-custom_data2__beword_shortcut", - "idapython-custom_data2__beword_structs", - "idapython-custom_data3", - "idaview-context_menu", - ] - }, - "bytes.register_custom_data_type": { - "return": [ - 'int', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-custom_data", - "idapython-custom_data2__beword_idaview", - "idapython-custom_data2__beword_shortcut", - "idapython-custom_data2__beword_structs", - "idapython-custom_data3", - "idaview-context_menu", - ] - }, - "bytes.register_data_types_and_formats": { - "return": [ - 'int', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idaview-context_menu", - ] - }, - "bytes.revert_byte": { - "return": [ - 'bool', - ], - "tests": [ - "eaview-patch_bytes__basic", - "eaview-patch_bytes__chooser", - ] - }, - "bytes.set_cmt": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-snapshots", - ] - }, - "bytes.stroff_flag": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__create_structure_programmatically", - "structs-members", - ] - }, - "bytes.unregister_custom_data_format": { - "return": [ - 'bool', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-custom_data", - ] - }, - "bytes.unregister_custom_data_type": { - "return": [ - 'bool', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-custom_data", - ] - }, - "bytes.unregister_data_types_and_formats": { - "return": [ - 'int', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - ] - }, - "bytes.update_hidden_range": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-misc2", - ] - }, - "bytes.use_mapping": { - "return": [ - 'int', - ], - "tests": [ - "idapython-mapping", - "idapython-misc3", - ] - }, - "bytes.visit_patched_bytes": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__list_patched_bytes", - ] - }, - "bytes.word_flag": { - "return": [ - 'int', - ], - "tests": [ - "structs-members", - ] - }, - "dbg.DBG_Hooks.dump_state": { - "return": [ - 'str', - ], - "tests": [ - "bptgrp-misc__disable_after_move", - "debugger-exceptions", - "idapython-debugger", - ] - }, - "dbg.DBG_Hooks.hook": { - "return": [ - 'bool', - ], - "tests": [ - "bptgrp-misc__disable_after_move", - "debugger-exceptions", - "idapython-debugger", - "idapython-examples__automatic_steps", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.DBG_Hooks.unhook": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-exceptions", - "idapython-debugger", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.add_bpt": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-breakpoints", - "debugger-breakpoints2__bpt_perf", - "hexrays-move_undo_bpt", - "idapython-api__dbg", - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - ] - }, - "dbg.bpt_t.is_low_level": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-breakpoints", - ] - }, - "dbg.bpt_t.set_src_bpt": { - "return": [ - 'NoneType', - ], - "tests": [ - "hexrays-move_undo_bpt", - ] - }, - "dbg.collect_stack_trace": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - ] - }, - "dbg.continue_process": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-exceptions", - ] - }, - "dbg.dbg_can_query": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-search_bin__search1_dbg", - "debugger-memory", - ] - }, - "dbg.del_bpt": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-breakpoints", - "idapython-api__dbg", - "idapython-breakpoints", - ] - }, - "dbg.del_bptgrp": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__dbg", - "idapython-bptgrp", - ] - }, - "dbg.enable_func_trace": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-misc2", - ] - }, - "dbg.enable_insn_trace": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-misc2", - ] - }, - "dbg.enable_manual_regions": { - "return": [ - 'NoneType', - ], - "tests": [ - "debugger-manual_memory_regions", - ] - }, - "dbg.enable_step_trace": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.exist_bpt": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__dbg", - ] - }, - "dbg.get_bpt": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-breakpoints", - "idapython-breakpoints", - ] - }, - "dbg.get_bpt_group": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "bptgrp-misc__disable_after_move", - "idapython-api__dbg", - "idapython-bptgrp", - ] - }, - "dbg.get_bpt_qty": { - "return": [ - 'int', - ], - "tests": [ - "debugger-breakpoints", - "debugger-breakpoints2__bpt_perf", - "idapython-api__dbg", - "idapython-breakpoints", - ] - }, - "dbg.get_current_source_file": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "hexrays-move_undo_bpt", - "idapython-api__dbg", - ] - }, - "dbg.get_current_thread": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__dbg", - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - "idapython-misc_debugger", - "training-test__CallStackWalk_py", - ] - }, - "dbg.get_dbg_reg_info": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__registers_context_menu", - ] - }, - "dbg.get_first_module": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-memory", - "idapython-modules", - ] - }, - "dbg.get_grp_bpts": { - "return": [ - 'int', - ], - "tests": [ - "idapython-bptgrp", - ] - }, - "dbg.get_insn_tev_reg_mem": { - "return": [ - 'bool', - ], - "tests": [ - "tracing-misc", - ] - }, - "dbg.get_insn_tev_reg_val": { - "return": [ - 'bool', - ], - "tests": [ - "tracing-misc", - ] - }, - "dbg.get_manual_regions": { - "return": [ - 'NoneType', - [('int', 'int', 'str', 'str', 'int', 'int', 'int'), '...'], - ], - "tests": [ - "debugger-manual_memory_regions", - ] - }, - "dbg.get_module_info": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - ] - }, - "dbg.get_next_module": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-memory", - "idapython-modules", - ] - }, - "dbg.get_process_options": { - "return": [ - ('str', 'str', 'str', 'str', 'str', 'int'), - ], - "tests": [ - "idapython-api__dbg", - ] - }, - "dbg.get_process_state": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__show_debug_names", - "training-test__CallStackWalk_py", - ] - }, - "dbg.get_reg_val": { - "return": [ - 'bool', - 'float', - 'int', - ], - "tests": [ - "idapython-api__dbg", - "idapython-appcall_manual__delayed_cleanup", - "idapython-appcall_manual__no_cleanup", - "idapython-appcall_manual__normal", - "idapython-appcall_manual__single_stmt", - "idapython-appcall_manual__single_stmt_delayed_cleanup", - "idapython-appcall_manual__single_stmt_no_cleanup", - "idapython-examples__automatic_steps", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__registers_context_menu", - ] - }, - "dbg.get_step_trace_options": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.get_tev_info": { - "return": [ - 'bool', - ], - "tests": [ - "tracing-misc", - ] - }, - "dbg.getn_bpt": { - "return": [ - 'bool', - ], - "tests": [ - "bptgrp-remove_from_group", - "debugger-breakpoints", - "idapython-api__dbg", - "idapython-bptgrp", - "idapython-breakpoints", - ] - }, - "dbg.internal_get_sreg_base": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc_debugger", - ] - }, - "dbg.is_debugger_on": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__show_debug_names", - "training-test__CallStackWalk_py", - ] - }, - "dbg.list_bptgrps": { - "return": [ - ['str', '...'], - ], - "tests": [ - "idapython-api__dbg", - "idapython-bptgrp", - ] - }, - "dbg.load_debugger": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-misc2", - ] - }, - "dbg.memreg_infos_t.size": { - "return": [ - 'int', - ], - "tests": [ - "tracing-misc", - ] - }, - "dbg.move_bpt_to_grp": { - "return": [ - 'NoneType', - ], - "tests": [ - "bptgrp-remove_from_group", - "idapython-bptgrp", - ] - }, - "dbg.refresh_debugger_memory": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.rename_bptgrp": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__dbg", - "idapython-bptgrp", - ] - }, - "dbg.request_continue_process": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.request_enable_step_trace": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.request_exit_process": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__automatic_steps", - ] - }, - "dbg.request_run_to": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__automatic_steps", - ] - }, - "dbg.request_set_step_trace_options": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.request_step_into": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-debugger", - ] - }, - "dbg.request_step_over": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__automatic_steps", - ] - }, - "dbg.retrieve_exceptions": { - "return": [ - 'excvec_t', - ], - "tests": [ - "debugger-exceptions", - ] - }, - "dbg.run_requests": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-debugger", - "idapython-examples__automatic_steps", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.run_to": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.set_bpt_group": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__dbg", - "idapython-bptgrp", - ] - }, - "dbg.set_bptloc_group": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__dbg", - ] - }, - "dbg.set_debugger_options": { - "return": [ - 'int', - ], - "tests": [ - "debugger-exceptions", - ] - }, - "dbg.set_manual_regions": { - "return": [ - 'NoneType', - ], - "tests": [ - "debugger-manual_memory_regions", - ] - }, - "dbg.set_reg_val": { - "return": [ - 'bool', - 'int', - ], - "tests": [ - "idapython-api__dbg", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "tracing-misc", - ] - }, - "dbg.set_step_trace_options": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.start_process": { - "return": [ - 'int', - ], - "tests": [ - "idapython-debugger", - ] - }, - "dbg.store_exceptions": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-exceptions", - ] - }, - "dbg.update_bpt": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-breakpoints", - "idapython-breakpoints", - ] - }, - "dbg.wait_for_next_event": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "dbg.write_dbg_memory": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search_bin__search1_dbg", - ] - }, - "dirtree.dirtree_t.change_rank": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__no_tree", - ] - }, - "dirtree.dirtree_t.findfirst": { - "return": [ - 'bool', - ], - "tests": [ - "dirtree-load", - ] - }, - "dirtree.dirtree_t.findnext": { - "return": [ - 'bool', - ], - "tests": [ - "dirtree-load", - ] - }, - "dirtree.dirtree_t.get_abspath": { - "return": [ - 'str', - ], - "tests": [ - "dirtree-load", - "idapython-api__dirtree", - ] - }, - "dirtree.dirtree_t.get_dir_size": { - "return": [ - 'int', - ], - "tests": [ - "dirtree-load", - ] - }, - "dirtree.dirtree_t.get_entry_attrs": { - "return": [ - 'str', - ], - "tests": [ - "dirtree-load", - ] - }, - "dirtree.dirtree_t.get_entry_name": { - "return": [ - 'str', - ], - "tests": [ - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - ] - }, - "dirtree.dirtree_t.get_rank": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__no_tree", - ] - }, - "dirtree.dirtree_t.getcwd": { - "return": [ - 'str', - ], - "tests": [ - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "stddirtrees-misc__actions_on_selection_local_types", - "stddirtrees-misc__bad_delete_all_structures", - "stddirtrees-misc__basic_undo_steps_imports", - "stddirtrees-misc__basic_undo_steps_imports_2", - "stddirtrees-misc__create_with_selection_enums", - "stddirtrees-misc__create_with_selection_structures", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_functions", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - "stddirtrees-misc__delete_folder_enums", - "stddirtrees-misc__delete_folder_local_types", - "stddirtrees-misc__delete_folder_names", - "stddirtrees-misc__delete_folder_structures", - "stddirtrees-misc__delete_listing_selection_enums", - "stddirtrees-misc__delete_listing_selection_structures", - "stddirtrees-misc__delete_root_enums", - "stddirtrees-misc__delete_root_local_types", - "stddirtrees-misc__delete_root_structures", - "stddirtrees-misc__drag_drop_folders_enums", - "stddirtrees-misc__drag_drop_folders_structures", - "stddirtrees-misc__drag_drop_functions_2", - "stddirtrees-misc__drag_drop_reordering_enums", - "stddirtrees-misc__drag_drop_reordering_structures", - "stddirtrees-misc__expand_collapse_enums", - "stddirtrees-misc__expand_collapse_imports", - "stddirtrees-misc__expand_collapse_local_types", - "stddirtrees-misc__expand_collapse_names", - "stddirtrees-misc__expand_collapse_structures", - "stddirtrees-misc__filter_by_folder_then_jump_out_structures", - "stddirtrees-misc__focus_and_nav_enums", - "stddirtrees-misc__focus_and_nav_structures", - "stddirtrees-misc__folders_sorting_imports", - "stddirtrees-misc__ilfak_s_sequence_2_structures", - "stddirtrees-misc__ilfak_s_sequence_structures", - "stddirtrees-misc__insert_before_current_structures", - "stddirtrees-misc__interr_40799_local_types", - "stddirtrees-misc__interr_40868_local_types", - "stddirtrees-misc__jump_enums", - "stddirtrees-misc__jump_structures", - "stddirtrees-misc__misc_local_types", - "stddirtrees-misc__move_then_undo_enums", - "stddirtrees-misc__move_then_undo_functions", - "stddirtrees-misc__move_then_undo_imports", - "stddirtrees-misc__move_then_undo_local_types", - "stddirtrees-misc__move_then_undo_structures", - "stddirtrees-misc__no_infinite_scroll_enums", - "stddirtrees-misc__no_infinite_scroll_structures", - "stddirtrees-misc__quick_filter_enums", - "stddirtrees-misc__quick_filter_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "stddirtrees-misc__rename_enums", - "stddirtrees-misc__rename_imports", - "stddirtrees-misc__rename_local_types", - "stddirtrees-misc__rename_shortcut_local_types", - "stddirtrees-misc__rename_structures", - "stddirtrees-misc__search_enums", - "stddirtrees-misc__search_fast_enums", - "stddirtrees-misc__search_fast_imports", - "stddirtrees-misc__search_fast_local_types", - "stddirtrees-misc__search_fast_structures", - "stddirtrees-misc__search_imports", - "stddirtrees-misc__search_local_types", - "stddirtrees-misc__search_structures", - "stddirtrees-misc__selection_filtering_enums", - "stddirtrees-misc__selection_filtering_structures", - "stddirtrees-misc__sorting_enums", - "stddirtrees-misc__sorting_structures", - "stddirtrees-misc__undo_status_local_types", - ] - }, - "dirtree.dirtree_t.isdir": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__no_tree", - "dirtree-load", - ] - }, - "dirtree.dirtree_t.link": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - ] - }, - "dirtree.dirtree_t.mkdir": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__programmatically_add_folder", - "localtypes-misc__manipulate_dirtree_programmatically", - "stddirtrees-misc__programmatically_add_folder_enums", - "stddirtrees-misc__programmatically_add_folder_local_types", - "stddirtrees-misc__programmatically_add_folder_structures", - ] - }, - "dirtree.dirtree_t.notify_dirtree": { - "return": [ - 'NoneType', - ], - "tests": [ - "chooser-dirtree__delete_folder", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__no_tree", - ] - }, - "dirtree.dirtree_t.rename": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__programmatically_add_folder", - "localtypes-misc__manipulate_dirtree_programmatically", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__programmatically_add_folder_enums", - "stddirtrees-misc__programmatically_add_folder_local_types", - "stddirtrees-misc__programmatically_add_folder_structures", - ] - }, - "dirtree.dirtree_t.resolve_cursor": { - "return": [ - 'direntry_t', - ], - "tests": [ - "dirtree-load", - ] - }, - "dirtree.dirtree_t.resolve_path": { - "return": [ - 'direntry_t', - ], - "tests": [ - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__no_tree", - ] - }, - "dirtree.dirtree_t.traverse": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__dirtree", - ] - }, - "dirtree.dirtree_t.unlink": { - "return": [ - 'int', - ], - "tests": [ - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - ] - }, - "dirtree.get_std_dirtree": { - "return": [ - 'dirtree_t', - ], - "tests": [ - "dirtree-load", - "idapython-api__dirtree", - "localtypes-misc__manipulate_dirtree_programmatically", - "stddirtrees-misc__actions_on_selection_local_types", - "stddirtrees-misc__bad_delete_all_structures", - "stddirtrees-misc__basic_enums", - "stddirtrees-misc__basic_structures", - "stddirtrees-misc__basic_undo_steps_imports", - "stddirtrees-misc__basic_undo_steps_imports_2", - "stddirtrees-misc__complex_filters_enums", - "stddirtrees-misc__complex_filters_structures", - "stddirtrees-misc__create_with_selection_enums", - "stddirtrees-misc__create_with_selection_structures", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_functions", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - "stddirtrees-misc__debugging_imports", - "stddirtrees-misc__delete_folder_enums", - "stddirtrees-misc__delete_folder_local_types", - "stddirtrees-misc__delete_folder_names", - "stddirtrees-misc__delete_folder_structures", - "stddirtrees-misc__delete_listing_selection_enums", - "stddirtrees-misc__delete_listing_selection_structures", - "stddirtrees-misc__delete_root_enums", - "stddirtrees-misc__delete_root_local_types", - "stddirtrees-misc__delete_root_structures", - "stddirtrees-misc__delete_undo_delete_again_enums", - "stddirtrees-misc__drag_drop_folders_enums", - "stddirtrees-misc__drag_drop_folders_structures", - "stddirtrees-misc__drag_drop_functions_2", - "stddirtrees-misc__drag_drop_reordering_enums", - "stddirtrees-misc__drag_drop_reordering_structures", - "stddirtrees-misc__expand_collapse_enums", - "stddirtrees-misc__expand_collapse_imports", - "stddirtrees-misc__expand_collapse_local_types", - "stddirtrees-misc__expand_collapse_names", - "stddirtrees-misc__expand_collapse_structures", - "stddirtrees-misc__filter_by_folder_then_jump_out_structures", - "stddirtrees-misc__filter_by_tree_then_jump_out_enums", - "stddirtrees-misc__focus_and_nav_enums", - "stddirtrees-misc__focus_and_nav_structures", - "stddirtrees-misc__folders_sorting_imports", - "stddirtrees-misc__goto_line_fast_enums", - "stddirtrees-misc__goto_line_fast_functions", - "stddirtrees-misc__goto_line_fast_imports", - "stddirtrees-misc__goto_line_fast_local_types", - "stddirtrees-misc__goto_line_fast_names", - "stddirtrees-misc__goto_line_fast_structures", - "stddirtrees-misc__hscrollbar_as_needed_enums", - "stddirtrees-misc__hscrollbar_as_needed_structures", - "stddirtrees-misc__ilfak_s_sequence_2_structures", - "stddirtrees-misc__ilfak_s_sequence_structures", - "stddirtrees-misc__insert_before_current_structures", - "stddirtrees-misc__interr_40799_local_types", - "stddirtrees-misc__interr_40868_local_types", - "stddirtrees-misc__interr_41069_local_types", - "stddirtrees-misc__jump_enums", - "stddirtrees-misc__jump_from_pseudocode_to_local_types", - "stddirtrees-misc__jump_structures", - "stddirtrees-misc__jump_to_pseudocode_from_local_types", - "stddirtrees-misc__misc_local_types", - "stddirtrees-misc__move_then_undo_enums", - "stddirtrees-misc__move_then_undo_functions", - "stddirtrees-misc__move_then_undo_imports", - "stddirtrees-misc__move_then_undo_local_types", - "stddirtrees-misc__move_then_undo_local_types_2", - "stddirtrees-misc__move_then_undo_structures", - "stddirtrees-misc__nav_actions_state_enums", - "stddirtrees-misc__nav_actions_state_structures", - "stddirtrees-misc__newfile_imports", - "stddirtrees-misc__no_infinite_scroll_enums", - "stddirtrees-misc__no_infinite_scroll_structures", - "stddirtrees-misc__no_subfolders_jump_enums", - "stddirtrees-misc__no_subfolders_jump_structures", - "stddirtrees-misc__no_subfolders_sorting_enums", - "stddirtrees-misc__no_subfolders_sorting_structures", - "stddirtrees-misc__open_in_folders_columns_sizes_local_types", - "stddirtrees-misc__persisted_state_enums", - "stddirtrees-misc__persisted_state_functions", - "stddirtrees-misc__persisted_state_imports", - "stddirtrees-misc__persisted_state_local_types", - "stddirtrees-misc__persisted_state_structures", - "stddirtrees-misc__programmatically_add_folder_enums", - "stddirtrees-misc__programmatically_add_folder_local_types", - "stddirtrees-misc__programmatically_add_folder_structures", - "stddirtrees-misc__quick_filter_enums", - "stddirtrees-misc__quick_filter_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "stddirtrees-misc__rename_enums", - "stddirtrees-misc__rename_imports", - "stddirtrees-misc__rename_local_types", - "stddirtrees-misc__rename_shortcut_local_types", - "stddirtrees-misc__rename_structures", - "stddirtrees-misc__search_enums", - "stddirtrees-misc__search_fast_enums", - "stddirtrees-misc__search_fast_functions_1", - "stddirtrees-misc__search_fast_functions_2", - "stddirtrees-misc__search_fast_functions_3", - "stddirtrees-misc__search_fast_functions_4", - "stddirtrees-misc__search_fast_functions_5", - "stddirtrees-misc__search_fast_functions_6", - "stddirtrees-misc__search_fast_imports", - "stddirtrees-misc__search_fast_local_types", - "stddirtrees-misc__search_fast_structures", - "stddirtrees-misc__search_imports", - "stddirtrees-misc__search_local_types", - "stddirtrees-misc__search_structures", - "stddirtrees-misc__selection_filtering_enums", - "stddirtrees-misc__selection_filtering_structures", - "stddirtrees-misc__sorting_enums", - "stddirtrees-misc__sorting_structures", - "stddirtrees-misc__toggle_folders_on_each_column_local_types", - "stddirtrees-misc__undo_status_local_types", - ] - }, - "diskio.close_linput": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-base2file", - "idapython-misc3", - ] - }, - "diskio.create_bytearray_linput": { - "return": [ - 'linput_t *', - ], - "tests": [ - "idapython-misc3", - ] - }, - "diskio.eclose": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-base2file", - "idapython-savefile", - ] - }, - "diskio.fopenM": { - "return": [ - 'FILE *', - ], - "tests": [ - "idapython-savefile", - ] - }, - "diskio.fopenWB": { - "return": [ - 'FILE *', - ], - "tests": [ - "idapython-base2file", - "idapython-savefile", - ] - }, - "diskio.get_ida_subdirs": { - "return": [ - ['str', '...'], - ], - "tests": [ - "idapython-misc4", - ] - }, - "diskio.get_linput_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc3", - ] - }, - "diskio.idadir": { - "return": [ - 'str', - ], - "tests": [ - "idapython-misc2", - "plugins-hexrayspytools", - ] - }, - "diskio.open_linput": { - "return": [ - 'linput_t *', - ], - "tests": [ - "idapython-base2file", - ] - }, - "entry.add_entry": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-bfld", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "screenshots-misc__proc_dsp56k", - ] - }, - "enum.add_enum": { - "return": [ - 'int', - ], - "tests": [ - "enums-api", - ] - }, - "enum.del_enum": { - "return": [ - 'NoneType', - ], - "tests": [ - "stddirtrees-misc__cut_and_paste_enums", - ] - }, - "enum.for_all_enum_members": { - "return": [ - 'int', - ], - "tests": [ - "idapython-enums_api", - ] - }, - "enum.get_enum": { - "return": [ - 'int', - ], - "tests": [ - "enums-api", - "idapython-enums_api", - "stddirtrees-misc__cut_and_paste_enums", - ] - }, - "enum.get_enum_member_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-enums_api", - ] - }, - "enum.get_enum_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__operand_changed", - ] - }, - "enum.get_first_enum_member": { - "return": [ - 'int', - ], - "tests": [ - "enums-api", - ] - }, - "enum.get_first_serial_enum_member": { - "return": [ - ('int', 'int'), - ], - "tests": [ - "idapython-enums_api", - ] - }, - "enum.get_next_serial_enum_member": { - "return": [ - ('int', 'int'), - ], - "tests": [ - "idapython-enums_api", - ] - }, - "expr.add_idc_func": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__expr", - "idapython-examples__extend_idc", - ] - }, - "expr.compile_idc_text": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__add_idc_hotkey", - ] - }, - "expr.eval_idc_expr": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__pro", - "idapython-examples__create_structure_programmatically", - "idapython-misc", - "idapython-misc4", - "idapython-switch_info", - "ppc-analysis_options", - "structs-asm_and_c", - "structs-create", - ] - }, - "expr.idc_value_t.c_str": { - "return": [ - 'str', - ], - "tests": [ - "idapython-misc4", - ] - }, - "expr.idc_value_t.qstr": { - "return": [ - 'str', - ], - "tests": [ - "idapython-misc4", - ] - }, - "expr.idc_value_t.set_int64": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc4", - ] - }, - "expr.idc_value_t.set_string": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc4", - ] - }, - "fixup.fixup_data_t.get": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-custom_fixup", - ] - }, - "fixup.fixup_data_t.get_desc": { - "return": [ - 'str', - ], - "tests": [ - "idapython-custom_fixup", - ] - }, - "fixup.fixup_data_t.get_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-custom_fixup", - ] - }, - "fixup.fixup_data_t.set": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-bfld", - ] - }, - "fpro.qfile_t.close": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__produce_lst_file", - "loadfile-archive_locked_idb", - ] - }, - "fpro.qfile_t.get_fp": { - "return": [ - 'FILE *', - ], - "tests": [ - "idapython-examples__produce_lst_file", - ] - }, - "fpro.qfile_t.open": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__produce_lst_file", - "loadfile-archive_locked_idb", - ] - }, - "fpro.qfile_t.puts": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idp_hooks2__gen_map_file", - ] - }, - "fpro.qfile_t_from_fp": { - "return": [ - 'qfile_t', - ], - "tests": [ - "idapython-idp_hooks2__gen_map_file", - ] - }, - "frame.add_auto_stkpnt": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "frame.build_stkvar_xrefs": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-xrefs", - ] - }, - "frame.calc_stkvar_struc_offset": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__list_stkvar_xrefs", - ] - }, - "frame.get_frame": { - "return": [ - 'NoneType', - 'struc_t', - ], - "tests": [ - "funstack-misc", - "idapython-api__frame", - "idapython-examples__list_stkvar_xrefs", - "idapython-funcs", - "idapython-print_tinfo", - "idapython-structs", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-xrefs", - "stackview-misc", - ] - }, - "frame.get_spd": { - "return": [ - 'int', - ], - "tests": [ - "idapython-big_spd_bug", - ] - }, - "frame.get_stkvar": { - "return": [ - 'NoneType', - ('member_t', 'int'), - ], - "tests": [ - "idapython-funcs", - "idapython-processor_module__error_in_ev_is_sp_based", - ] - }, - "frame.set_frame_size": { - "return": [ - 'bool', - ], - "tests": [ - "funstack-misc", - ] - }, - "funcs.apply_idasgn_to": { - "return": [ - 'int', - ], - "tests": [ - "config-idausr_subdirs", - ] - }, - "funcs.del_func": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - ] - }, - "funcs.func_item_iterator_t.current": { - "return": [ - 'int', - ], - "tests": [ - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "grview-nodepropsUser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__list_stkvar_xrefs", - "idapython-user_graphs", - "training-test__find_ret_py", - ] - }, - "funcs.func_item_iterator_t.next_code": { - "return": [ - 'bool', - ], - "tests": [ - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "grview-nodepropsUser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__list_stkvar_xrefs", - "idapython-user_graphs", - "training-test__find_ret_py", - ] - }, - "funcs.func_item_iterator_t.set": { - "return": [ - 'bool', - ], - "tests": [ - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "grview-nodepropsUser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__list_stkvar_xrefs", - "idapython-user_graphs", - "training-test__find_ret_py", - ] - }, - "funcs.func_t.does_return": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dump_func_info", - ] - }, - "funcs.func_t.is_far": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dump_func_info", - ] - }, - "funcs.get_fchunk": { - "return": [ - 'NoneType', - 'func_t', - ], - "tests": [ - "grview-api", - "idapython-api__frame", - "idapython-examples__dump_func_info", - "idapython-examples__list_segment_functions_using_idautils", - "lumina-view_and_apply_metadata", - "mainmsglist-misc__double_click_ids", - "waitdialog-misc2__loadfile_wait_dialog_t", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "funcs.get_fchunk_qty": { - "return": [ - 'int', - ], - "tests": [ - "areas-misc", - ] - }, - "funcs.get_func": { - "return": [ - 'NoneType', - 'func_t', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - "functions_window-misc__updating_func_causes_refresh", - "funstack-misc", - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "grview-nodepropsUser", - "hexrays-misc2", - "hexrays-rename-misc__make_library_function_and_undo", - "hexrays-rename_lvars", - "idapython-api__frame", - "idapython-api__funcs", - "idapython-big_spd_bug", - "idapython-cleanup", - "idapython-examples__colorize_disassembly", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__dump_flowchart", - "idapython-examples__func_chooser_coloring", - "idapython-examples__list_segment_functions", - "idapython-examples__list_stkvar_xrefs", - "idapython-examples__replay_prototypes_changes", - "idapython-execute_sync", - "idapython-flow_chart", - "idapython-funcs", - "idapython-idb_hooks", - "idapython-idp_hooks2__gen_regvar_def", - "idapython-misc2", - "idapython-misc4", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-user_graphs", - "idapython-xrefs", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-base_classes2__broken_optblock_t", - "idapython_hr-base_classes2__broken_optinsn_t", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-base_classes2__cfunc_t", - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__minsn_t", - "idapython_hr-base_classes2__minsn_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-base_classes2__qlist_cinsn_t_iterator", - "idapython_hr-base_classes2__vc_printer_t", - "idapython_hr-base_classes2__vd_printer_t", - "idapython_hr-ctree_visitor__force_all_calls", - "idapython_hr-ctree_visitor__misc", - "idapython_hr-decompile", - "idapython_hr-decompile2__DecompilationFailure", - "idapython_hr-decompile2__flags", - "idapython_hr-ea", - "idapython_hr-ea64", - "idapython_hr-examples__vds1", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds13", - "idapython_hr-examples__vds4", - "idapython_hr-hexrays_callback", - "idapython_hr-misc__cexpr_ctor", - "idaview-hints__instruction_gets_deleted", - "lumina-view_and_apply_metadata", - "plugins-hexrayspytools", - "plugins-lucid", - "screenshots-misc__idapython_snippets", - "stackview-misc", - "training-test__CallStackWalk_py", - "training-test__ImpRef_py", - "training-test__color_to_py", - "training-test__find_mgen_key_py", - "training-test__find_ret_py", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "funcs.get_func_name": { - "return": [ - 'str', - ], - "tests": [ - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "grview-nodepropsUser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__list_segment_functions", - "idapython-examples__list_segment_functions_using_idautils", - "idapython-user_graphs", - "screenshots-misc__idapython_snippets", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - "training-test__ImpRef_py", - ] - }, - "funcs.get_idasgn_desc": { - "return": [ - ('str', 'str'), - ], - "tests": [ - "sigs-basic", - ] - }, - "funcs.get_idasgn_desc_with_matches": { - "return": [ - ('str', 'str', 'int'), - ], - "tests": [ - "sigs-basic", - ] - }, - "funcs.get_idasgn_qty": { - "return": [ - 'int', - ], - "tests": [ - "sigs-basic", - ] - }, - "funcs.get_next_fchunk": { - "return": [ - 'func_t', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "funcs.get_next_func": { - "return": [ - 'NoneType', - 'func_t', - ], - "tests": [ - "grview-api", - "idapython-examples__list_segment_functions", - "idapython-examples__list_segment_functions_using_idautils", - "lumina-view_and_apply_metadata", - "mainmsglist-misc__double_click_ids", - "screenshots-misc__idapython_snippets", - "waitdialog-misc2__loadfile_wait_dialog_t", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "funcs.getn_fchunk": { - "return": [ - 'func_t', - ], - "tests": [ - "areas-misc", - ] - }, - "funcs.is_func_entry": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dump_func_info", - ] - }, - "funcs.is_func_tail": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dump_func_info", - ] - }, - "funcs.set_func_cmt": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - ] - }, - "funcs.set_func_end": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module__error_in_set_func_end", - ] - }, - "funcs.set_func_start": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__error_in_set_func_start", - ] - }, - "funcs.update_func": { - "return": [ - 'bool', - ], - "tests": [ - "functions_window-misc__updating_func_causes_refresh", - "idapython-big_spd_bug", - "idapython-examples__colorize_disassembly", - "idapython-idb_hooks", - ] - }, - "gdl.BasicBlock.preds": { - "return": [ - 'generator', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "gdl.BasicBlock.succs": { - "return": [ - 'generator', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "gdl.FlowChart.refresh": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-flow_chart", - ] - }, - "gdl.display_gdl": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - ] - }, - "gdl.gdl_graph_t.entry": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__gdl", - ] - }, - "gdl.gdl_graph_t.exists": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__gdl", - ] - }, - "gdl.gdl_graph_t.print_edge": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__gdl", - ] - }, - "gdl.gdl_graph_t.print_graph_attributes": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__gdl", - ] - }, - "gdl.gdl_graph_t.print_node": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__gdl", - ] - }, - "gdl.gdl_graph_t.print_node_attributes": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__gdl", - ] - }, - "gdl.gen_gdl": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__gdl", - "idapython-api__graph", - ] - }, - "gdl.qflow_chart_t.calc_block_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "gdl.qflow_chart_t.npred": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "gdl.qflow_chart_t.nsucc": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "gdl.qflow_chart_t.pred": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "gdl.qflow_chart_t.refresh": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-flow_chart", - ] - }, - "gdl.qflow_chart_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "gdl.qflow_chart_t.succ": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_flowchart", - "idapython-flow_chart", - ] - }, - "graph.GraphViewer.AddCommand": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - ] - }, - "graph.GraphViewer.AddEdge": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "grview-gruser", - "i18n-basic", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - ] - }, - "graph.GraphViewer.AddNode": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-gruser", - "grview-nodepropsUser", - "i18n-basic", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - ] - }, - "graph.GraphViewer.Clear": { - "return": [ - 'NoneType', - ], - "tests": [ - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-stress", - "grview-gruser", - "grview-nodepropsUser", - "i18n-basic", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - ] - }, - "graph.GraphViewer.Close": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-user_graphs", - ] - }, - "graph.GraphViewer.OnPopup": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "gruser-misc__check_grouping_without_callback", - "grview-gruser", - ] - }, - "graph.GraphViewer.Show": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-gruser", - "grview-nodepropsUser", - "i18n-basic", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - ] - }, - "graph.GraphViewer.UI_Hooks_Trampoline.populating_widget_popup": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "gruser-misc__check_grouping_without_callback", - "grview-gruser", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - ] - }, - "graph.abstract_graph_t.get_edge": { - "return": [ - 'NoneType', - 'edge_info_t', - ], - "tests": [ - "grview-rendering", - "idapython-api__graph", - ] - }, - "graph.create_disasm_graph": { - "return": [ - 'mutable_graph_t', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.create_mutable_graph": { - "return": [ - 'mutable_graph_t', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.get_graph_viewer": { - "return": [ - 'TWidget *', - ], - "tests": [ - "gruser-misc__get_graph_viewer", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__get_graph_viewer_idaview", - ] - }, - "graph.get_viewer_graph": { - "return": [ - 'mutable_graph_t', - ], - "tests": [ - "grview-api", - "grview-rendering", - ] - }, - "graph.mutable_graph_t.add_edge": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.mutable_graph_t.add_node": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.mutable_graph_t.create_digraph_layout": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.mutable_graph_t.set_edge": { - "return": [ - 'bool', - ], - "tests": [ - "grview-rendering", - ] - }, - "graph.node_ordering_t.clr": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.node_ordering_t.node": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.node_ordering_t.order": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.node_ordering_t.resize": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.node_ordering_t.set": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.node_ordering_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__graph", - ] - }, - "graph.pointvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-rendering", - ] - }, - "graph.viewer_del_node_info": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "idapython-examples__wrap_idaview", - ] - }, - "graph.viewer_get_node_info": { - "return": [ - 'bool', - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "idapython-api__kernwin", - ] - }, - "graph.viewer_get_selection": { - "return": [ - 'bool', - ], - "tests": [ - "gruser-misc__get_graph_viewer", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__get_graph_viewer_idaview", - ] - }, - "graph.viewer_set_node_info": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__node_info", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - ] - }, - "hexrays.Hexrays_Hooks.dump_state": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "idapython_hr-hexrays_hooks__close_pseudocode", - "idapython_hr-hexrays_hooks__cmt_changed", - "idapython_hr-hexrays_hooks__combine", - "idapython_hr-hexrays_hooks__create_hint", - "idapython_hr-hexrays_hooks__create_hint2", - "idapython_hr-hexrays_hooks__create_hint3", - "idapython_hr-hexrays_hooks__curpos", - "idapython_hr-hexrays_hooks__double_click", - "idapython_hr-hexrays_hooks__flowchart", - "idapython_hr-hexrays_hooks__func_printed", - "idapython_hr-hexrays_hooks__glbopt", - "idapython_hr-hexrays_hooks__keyboard", - "idapython_hr-hexrays_hooks__locopt", - "idapython_hr-hexrays_hooks__lvar_cmt_changed", - "idapython_hr-hexrays_hooks__lvar_mapping_changed", - "idapython_hr-hexrays_hooks__lvar_name_changed", - "idapython_hr-hexrays_hooks__lvar_type_changed", - "idapython_hr-hexrays_hooks__maturity", - "idapython_hr-hexrays_hooks__microcode", - "idapython_hr-hexrays_hooks__open_pseudocode", - "idapython_hr-hexrays_hooks__populating_popup", - "idapython_hr-hexrays_hooks__prealloc", - "idapython_hr-hexrays_hooks__preoptimized", - "idapython_hr-hexrays_hooks__print_func", - "idapython_hr-hexrays_hooks__prolog", - "idapython_hr-hexrays_hooks__refresh_pseudocode", - "idapython_hr-hexrays_hooks__resolve_stkaddrs", - "idapython_hr-hexrays_hooks__right_click", - "idapython_hr-hexrays_hooks__stkpnts", - "idapython_hr-hexrays_hooks__structural", - "idapython_hr-hexrays_hooks__switch_pseudocode", - "idapython_hr-hexrays_hooks__text_ready", - ] - }, - "hexrays.Hexrays_Hooks.hook": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-plugin_actions", - "idapython_hr-base_classes", - "idapython_hr-decompile", - "idapython_hr-examples__vds21", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-examples__vds6", - "idapython_hr-examples__vds7", - "idapython_hr-gssincla_sample5", - "idapython_hr-hexrays_callback", - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "idapython_hr-hexrays_hooks__close_pseudocode", - "idapython_hr-hexrays_hooks__cmt_changed", - "idapython_hr-hexrays_hooks__combine", - "idapython_hr-hexrays_hooks__create_hint", - "idapython_hr-hexrays_hooks__create_hint2", - "idapython_hr-hexrays_hooks__create_hint3", - "idapython_hr-hexrays_hooks__curpos", - "idapython_hr-hexrays_hooks__double_click", - "idapython_hr-hexrays_hooks__flowchart", - "idapython_hr-hexrays_hooks__forget_unregistering", - "idapython_hr-hexrays_hooks__func_printed", - "idapython_hr-hexrays_hooks__glbopt", - "idapython_hr-hexrays_hooks__keyboard", - "idapython_hr-hexrays_hooks__locopt", - "idapython_hr-hexrays_hooks__lvar_cmt_changed", - "idapython_hr-hexrays_hooks__lvar_mapping_changed", - "idapython_hr-hexrays_hooks__lvar_name_changed", - "idapython_hr-hexrays_hooks__lvar_type_changed", - "idapython_hr-hexrays_hooks__maturity", - "idapython_hr-hexrays_hooks__microcode", - "idapython_hr-hexrays_hooks__open_pseudocode", - "idapython_hr-hexrays_hooks__populating_popup", - "idapython_hr-hexrays_hooks__prealloc", - "idapython_hr-hexrays_hooks__preoptimized", - "idapython_hr-hexrays_hooks__print_func", - "idapython_hr-hexrays_hooks__prolog", - "idapython_hr-hexrays_hooks__refresh_pseudocode", - "idapython_hr-hexrays_hooks__resolve_stkaddrs", - "idapython_hr-hexrays_hooks__right_click", - "idapython_hr-hexrays_hooks__stkpnts", - "idapython_hr-hexrays_hooks__structural", - "idapython_hr-hexrays_hooks__switch_pseudocode", - "idapython_hr-hexrays_hooks__text_ready", - "idapython_hr-plugin_hexlit", - "plugins-hexlight_2016", - "plugins-hexrayspytools", - "plugins-lucid", - ] - }, - "hexrays.Hexrays_Hooks.unhook": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-decompile", - "idapython_hr-examples__vds21", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-examples__vds6", - "idapython_hr-hexrays_callback", - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "idapython_hr-hexrays_hooks__close_pseudocode", - "idapython_hr-hexrays_hooks__cmt_changed", - "idapython_hr-hexrays_hooks__combine", - "idapython_hr-hexrays_hooks__create_hint", - "idapython_hr-hexrays_hooks__create_hint2", - "idapython_hr-hexrays_hooks__create_hint3", - "idapython_hr-hexrays_hooks__curpos", - "idapython_hr-hexrays_hooks__double_click", - "idapython_hr-hexrays_hooks__flowchart", - "idapython_hr-hexrays_hooks__func_printed", - "idapython_hr-hexrays_hooks__glbopt", - "idapython_hr-hexrays_hooks__keyboard", - "idapython_hr-hexrays_hooks__locopt", - "idapython_hr-hexrays_hooks__lvar_cmt_changed", - "idapython_hr-hexrays_hooks__lvar_mapping_changed", - "idapython_hr-hexrays_hooks__lvar_name_changed", - "idapython_hr-hexrays_hooks__lvar_type_changed", - "idapython_hr-hexrays_hooks__maturity", - "idapython_hr-hexrays_hooks__microcode", - "idapython_hr-hexrays_hooks__open_pseudocode", - "idapython_hr-hexrays_hooks__populating_popup", - "idapython_hr-hexrays_hooks__prealloc", - "idapython_hr-hexrays_hooks__preoptimized", - "idapython_hr-hexrays_hooks__print_func", - "idapython_hr-hexrays_hooks__prolog", - "idapython_hr-hexrays_hooks__refresh_pseudocode", - "idapython_hr-hexrays_hooks__resolve_stkaddrs", - "idapython_hr-hexrays_hooks__right_click", - "idapython_hr-hexrays_hooks__stkpnts", - "idapython_hr-hexrays_hooks__structural", - "idapython_hr-hexrays_hooks__switch_pseudocode", - "idapython_hr-hexrays_hooks__text_ready", - "plugins-hexlight_2016", - "plugins-hexrayspytools", - "plugins-lucid", - ] - }, - "hexrays.bitset_t.add": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__bitset_t", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.begin": { - "return": [ - 'iterator', - ], - "tests": [ - "idapython_hr-base_classes2__bitset_t", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.clear": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.compare": { - "return": [ - 'int', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.count": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__bitset_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.dstr": { - "return": [ - 'str', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.fill_with_ones": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.has": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - ] - }, - "hexrays.bitset_t.inc": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__bitset_t", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.intersect": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.itv": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__bitset_t", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.bitset_t.sub": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__bitset_t", - ] - }, - "hexrays.block_chains_begin": { - "return": [ - 'block_chains_iterator_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - ] - }, - "hexrays.block_chains_end": { - "return": [ - 'block_chains_iterator_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - ] - }, - "hexrays.block_chains_get": { - "return": [ - 'chain_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - ] - }, - "hexrays.block_chains_next": { - "return": [ - 'block_chains_iterator_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - ] - }, - "hexrays.block_chains_t.get_chain": { - "return": [ - 'NoneType', - 'chain_t', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.boundaries_t.begin": { - "return": [ - 'boundaries_iterator_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.end": { - "return": [ - 'boundaries_iterator_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.find": { - "return": [ - 'boundaries_iterator_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.first": { - "return": [ - 'cinsn_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.items": { - "return": [ - [('cinsn_t', 'rangeset_t'), '...'], - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.iteritems": { - "return": [ - 'generator', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.iterkeys": { - "return": [ - 'generator', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.keys": { - "return": [ - ['cinsn_t', '...'], - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.keytype.insn_is_epilog": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - ] - }, - "hexrays.boundaries_t.keytype.is_epilog": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - ] - }, - "hexrays.boundaries_t.next": { - "return": [ - 'boundaries_iterator_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.second": { - "return": [ - 'rangeset_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.valuetype.add": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-misc4", - ] - }, - "hexrays.boundaries_t.valuetype.getrange": { - "return": [ - 'range_t', - ], - "tests": [ - "idapython-misc4", - "idapython_hr-base_classes", - ] - }, - "hexrays.boundaries_t.valuetype.nranges": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.call_helper": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.cexpr_t.assign": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.cexpr_t.get_const_value": { - "return": [ - 'NoneType', - 'int', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.cexpr_t.get_v": { - "return": [ - 'NoneType', - 'var_ref_t', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-misc__cexpr_ctor", - "plugins-hexrayspytools", - ] - }, - "hexrays.cexpr_t.is_const_value": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.cexpr_t.numval": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.cexpr_t.print1": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - ] - }, - "hexrays.cexpr_t.set_v": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.cexpr_t.swap": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds3", - ] - }, - "hexrays.cfunc_t.get_boundaries": { - "return": [ - 'boundaries_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.cfunc_t.get_func_type": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.cfunc_t.get_lvars": { - "return": [ - 'lvars_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.cfunc_t.get_pseudocode": { - "return": [ - 'strvec_t', - ], - "tests": [ - "idapython_hr-examples__vds6", - ] - }, - "hexrays.cfuncptr_t.find_item_coords": { - "return": [ - 'bool', - ('int', 'int'), - ], - "tests": [ - "idapython_hr-ea", - ] - }, - "hexrays.cfuncptr_t.get_eamap": { - "return": [ - 'eamap_t', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - "idapython_hr-ea", - "idapython_hr-ea64", - ] - }, - "hexrays.cfuncptr_t.get_func_type": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.cfuncptr_t.get_line_item": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.cfuncptr_t.get_lvars": { - "return": [ - 'lvars_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.cfuncptr_t.get_pseudocode": { - "return": [ - 'strvec_t', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - "idapython_hr-ea", - "idapython_hr-examples__vds1", - "idapython_hr-hexrays_hooks__create_hint2", - "idapython_hr-plugin_hexlit", - "plugins-hexlight_2016", - "plugins-lucid", - ] - }, - "hexrays.cfuncptr_t.print_func": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__vc_printer_t", - ] - }, - "hexrays.cfuncptr_t.save_user_cmts": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.cfuncptr_t.save_user_unions": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds17", - ] - }, - "hexrays.cfuncptr_t.set_user_cmt": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.cfuncptr_t.set_user_union_selection": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds17", - ] - }, - "hexrays.chain_t.dstr": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - ] - }, - "hexrays.cinsn_t.insn_is_epilog": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - ] - }, - "hexrays.cinsn_t.is_epilog": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - ] - }, - "hexrays.citem_t.find_closest_addr": { - "return": [ - 'citem_t', - ], - "tests": [ - "idapython_hr-ea", - ] - }, - "hexrays.citem_t.find_parent_of": { - "return": [ - 'NoneType', - 'citem_t', - ], - "tests": [ - "idapython_hr-ctree_visitor__force_all_calls", - "idapython_hr-examples__vds17", - "plugins-hexrayspytools", - ] - }, - "hexrays.citem_t.is_expr": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "idapython_hr-misc__cexpr_ctor", - "plugins-hexrayspytools", - ] - }, - "hexrays.citem_t.print1": { - "return": [ - 'str', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.clear_cached_cfuncs": { - "return": [ - 'NoneType', - ], - "tests": [ - "hexrays-caching__clear_after_decompilation", - "hexrays-caching__clear_on_start", - "hexrays-global_xrefs", - "hexrays-navigate5__open_pseudocode_compat_new_window", - "hexrays-navigate5__open_pseudocode_compat_reuse", - "hexrays-navigate5__open_pseudocode_compat_reuse_active", - "hexrays-navigate5__open_pseudocode_new_window", - "hexrays-navigate5__open_pseudocode_reuse", - "hexrays-navigate5__open_pseudocode_reuse_active", - "idapython_hr-base_classes2__broken_optblock_t", - "idapython_hr-base_classes2__broken_optinsn_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds1", - "idapython_hr-examples__vds10", - "idapython_hr-examples__vds11", - "idapython_hr-examples__vds19", - "idapython_hr-examples__vds21", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-examples__vds6", - "idapython_hr-examples__vds7", - "idapython_hr-examples__vds8", - "idapython_hr-examples__vds_modify_user_lvars", - ] - }, - "hexrays.create_cfunc": { - "return": [ - 'cfuncptr_t', - ], - "tests": [ - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - ] - }, - "hexrays.create_helper": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.create_typedef": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.ctree_anchor_t.is_citem_anchor": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-misc2", - ] - }, - "hexrays.ctree_item_t.get_lvar": { - "return": [ - 'NoneType', - 'lvar_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.ctree_item_t.is_citem": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds17", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - ] - }, - "hexrays.ctree_items_t.at": { - "return": [ - 'citem_t', - ], - "tests": [ - "idapython-misc", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "idapython_hr-hexrays_hooks__create_hint2", - ] - }, - "hexrays.ctree_items_t.back": { - "return": [ - 'citem_t', - ], - "tests": [ - "idapython-misc", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - ] - }, - "hexrays.ctree_items_t.front": { - "return": [ - 'citem_t', - ], - "tests": [ - "idapython-misc", - ] - }, - "hexrays.ctree_items_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc", - ] - }, - "hexrays.ctree_items_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - ] - }, - "hexrays.ctree_visitor_t.apply_to": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-ctree_visitor__misc", - "idapython_hr-decompile", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-examples__vds7", - "idapython_hr-gssincla_sample5", - "plugins-hexrayspytools", - ] - }, - "hexrays.ctree_visitor_t.apply_to_exprs": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-ctree_visitor__force_all_calls", - ] - }, - "hexrays.ctree_visitor_t.leave_insn": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.ctree_visitor_t.parent_expr": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.ctree_visitor_t.visit_expr": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-examples__vds7", - "plugins-hexrayspytools", - ] - }, - "hexrays.ctree_visitor_t.visit_insn": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.decompile": { - "return": [ - 'cfuncptr_t', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-base_classes2__cfunc_t", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-base_classes2__qlist_cinsn_t_iterator", - "idapython_hr-base_classes2__vc_printer_t", - "idapython_hr-ctree_visitor__force_all_calls", - "idapython_hr-ctree_visitor__misc", - "idapython_hr-decompile", - "idapython_hr-decompile2__flags", - "idapython_hr-ea", - "idapython_hr-ea64", - "idapython_hr-examples__vds1", - "idapython_hr-examples__vds4", - "idapython_hr-hexrays_callback", - "idapython_hr-misc__cexpr_ctor", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "hexrays.decompile_many": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__produce_c_file", - "idapython_hr-decompile", - ] - }, - "hexrays.dereference": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.dummy_ptrtype": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.eamap_t.begin": { - "return": [ - 'eamap_iterator_t', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.eamap_t.end": { - "return": [ - 'eamap_iterator_t', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - "idapython_hr-ea", - "idapython_hr-ea64", - ] - }, - "hexrays.eamap_t.find": { - "return": [ - 'eamap_iterator_t', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-ea", - "idapython_hr-ea64", - ] - }, - "hexrays.eamap_t.first": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.eamap_t.iteritems": { - "return": [ - 'generator', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.eamap_t.next": { - "return": [ - 'eamap_iterator_t', - ], - "tests": [ - "idapython_hr-decompile", - ] - }, - "hexrays.eamap_t.second": { - "return": [ - 'cinsnptrvec_t', - ], - "tests": [ - "hexrays-misc2", - "idapython_hr-decompile", - "idapython_hr-ea", - "idapython_hr-ea64", - ] - }, - "hexrays.gco_info_t.append_to_list": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.gco_info_t.is_def": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.gco_info_t.is_use": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.gen_microcode": { - "return": [ - 'NoneType', - 'mba_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__minsn_t", - "idapython_hr-base_classes2__minsn_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-base_classes2__vd_printer_t", - "idapython_hr-examples__modified_vds13_twice", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds13", - "plugins-lucid", - ] - }, - "hexrays.get_ctype_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "plugins-hexrayspytools", - ] - }, - "hexrays.get_current_operand": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.get_float_type": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "hexrays.get_hexrays_version": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-examples__vds1", - "idapython_hr-examples__vds17", - "idapython_hr-gssincla_sample5", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.get_mreg_name": { - "return": [ - 'str', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.get_unk_type": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.get_widget_vdui": { - "return": [ - 'NoneType', - 'vdui_t', - ], - "tests": [ - "hexrays-misc3__get_vdui_by_api", - "idapython-examples__colorize_pseudocode_lines", - "idapython_hr-codegen", - "idapython_hr-ctree_visitor__force_all_calls", - "idapython_hr-examples__vds17", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "plugins-hexrayspytools", - "plugins-lucid", - ] - }, - "hexrays.getf_reginsn": { - "return": [ - 'NoneType', - 'minsn_t', - ], - "tests": [ - "idapython_hr-examples__vds11", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.hexrays_failure_t.desc": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-decompile2__DecompilationFailure", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "hexrays.init_hexrays_plugin": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-global_xrefs", - "idapython-plugin__plugin_fix", - "idapython-tinfo_manip", - "idapython_hr-codegen", - "idapython_hr-ctree_visitor__misc", - "idapython_hr-decompile", - "idapython_hr-examples__modified_vds13_twice", - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds1", - "idapython_hr-examples__vds10", - "idapython_hr-examples__vds11", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds13", - "idapython_hr-examples__vds17", - "idapython_hr-examples__vds19", - "idapython_hr-examples__vds21", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds4", - "idapython_hr-examples__vds5", - "idapython_hr-examples__vds6", - "idapython_hr-examples__vds7", - "idapython_hr-examples__vds8", - "idapython_hr-examples__vds8_crash", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "idapython_hr-examples__vds_modify_user_lvars", - "idapython_hr-gssincla_sample5", - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "idapython_hr-plugin_hexlit", - "plugins-hexlight_2016", - "plugins-hexrayspytools", - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.install_hexrays_callback": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-plugin_actions", - "idapython_hr-base_classes", - "idapython_hr-decompile", - "idapython_hr-gssincla_sample5", - "idapython_hr-hexrays_callback", - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "idapython_hr-plugin_hexlit", - "plugins-hexlight_2016", - "plugins-hexrayspytools", - ] - }, - "hexrays.install_microcode_filter": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-codegen", - "idapython_hr-examples__vds8", - "idapython_hr-examples__vds8_crash", - ] - }, - "hexrays.is_mcode_jcond": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.is_mcode_set": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.lnot": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-examples__vds3", - ] - }, - "hexrays.lvar_locator_t.get_reg1": { - "return": [ - 'int', - ], - "tests": [ - "hexrays-rename_lvars", - ] - }, - "hexrays.lvar_locator_t.get_stkoff": { - "return": [ - 'int', - ], - "tests": [ - "hexrays-rename_lvars", - ] - }, - "hexrays.lvar_locator_t.is_reg1": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-rename_lvars", - ] - }, - "hexrays.lvar_locator_t.is_stk_var": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-rename_lvars", - ] - }, - "hexrays.lvar_mapping_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds_modify_user_lvars", - ] - }, - "hexrays.lvar_saved_infos_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.lvar_t.type": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.make_num": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.make_ref": { - "return": [ - 'cexpr_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.mark_cfunc_dirty": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-lucid", - ] - }, - "hexrays.mba_t.analyze_calls": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mba_t.build_graph": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mba_t.deserialize": { - "return": [ - 'mba_t', - ], - "tests": [ - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - ] - }, - "hexrays.mba_t.find_mop": { - "return": [ - 'NoneType', - 'mop_t', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mba_t.for_all_topinsns": { - "return": [ - 'int', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mba_t.get_graph": { - "return": [ - 'mbl_graph_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mba_t.get_mblock": { - "return": [ - 'mblock_t', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-examples__vds11", - "idapython_hr-examples__vds12", - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mba_t.serialize": { - "return": [ - 'bytes', - ], - "tests": [ - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - ] - }, - "hexrays.mba_t.verify": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds19", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mbl_array_t.analyze_calls": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mbl_array_t.build_graph": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mbl_array_t.deserialize": { - "return": [ - 'mba_t', - ], - "tests": [ - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - ] - }, - "hexrays.mbl_array_t.find_mop": { - "return": [ - 'NoneType', - 'mop_t', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mbl_array_t.for_all_topinsns": { - "return": [ - 'int', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mbl_array_t.get_graph": { - "return": [ - 'mbl_graph_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mbl_array_t.get_mblock": { - "return": [ - 'mblock_t', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-examples__vds11", - "idapython_hr-examples__vds12", - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mbl_array_t.serialize": { - "return": [ - 'bytes', - ], - "tests": [ - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - ] - }, - "hexrays.mbl_array_t.verify": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds19", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mbl_graph_t.get_du": { - "return": [ - 'graph_chains_t', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mbl_graph_t.get_ud": { - "return": [ - 'graph_chains_t', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mblock_t.append_use_list": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.build_def_list": { - "return": [ - 'mlist_t', - ], - "tests": [ - "idapython_hr-examples__vds12", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.build_use_list": { - "return": [ - 'mlist_t', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mblock_t.for_all_insns": { - "return": [ - 'int', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.insert_into_block": { - "return": [ - 'minsn_t', - ], - "tests": [ - "idapython_hr-base_classes2__minsn_t", - "idapython_hr-base_classes2__minsn_t_64", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.is_call_block": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.make_nop": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.mark_lists_dirty": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.needs_propagation": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-lucid", - ] - }, - "hexrays.mblock_t.npred": { - "return": [ - 'int', - ], - "tests": [ - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.nsucc": { - "return": [ - 'int', - ], - "tests": [ - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.optimize_insn": { - "return": [ - 'int', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.pred": { - "return": [ - 'int', - ], - "tests": [ - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.preds": { - "return": [ - 'generator', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - ] - }, - "hexrays.mblock_t.remove_from_block": { - "return": [ - 'NoneType', - 'minsn_t', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - ] - }, - "hexrays.mblock_t.succ": { - "return": [ - 'int', - ], - "tests": [ - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mblock_t.succs": { - "return": [ - 'generator', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - ] - }, - "hexrays.mcallargs_t.empty": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - ] - }, - "hexrays.mcallargs_t.push_back": { - "return": [ - 'mcallarg_t', - ], - "tests": [ - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - ] - }, - "hexrays.mcases_t.resize": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - ] - }, - "hexrays.minsn_t.dstr": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-examples__vds21", - ] - }, - "hexrays.minsn_t.equal_insns": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - ] - }, - "hexrays.minsn_t.find_num_op": { - "return": [ - ('NoneType', 'NoneType'), - ('mop_t', 'mop_t'), - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.minsn_t.for_all_insns": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds19", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.minsn_t.is_helper": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - ] - }, - "hexrays.minsn_t.optimize_solo": { - "return": [ - 'int', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mlist_t.add": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mlist_t.clear": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mlist_t.empty": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mlist_t.has_common": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mlist_t.includes": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mlist_t.sub": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "hexrays.mnumber_t.update_value": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.modify_user_lvars": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds_modify_user_lvars", - ] - }, - "hexrays.mop_t.assign": { - "return": [ - 'mop_t', - ], - "tests": [ - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - ] - }, - "hexrays.mop_t.dstr": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - ] - }, - "hexrays.mop_t.empty": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-lucid", - ] - }, - "hexrays.mop_t.equal_mops": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mop_t.for_all_ops": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - ] - }, - "hexrays.mop_t.has_side_effects": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds19", - ] - }, - "hexrays.mop_t.is_arglist": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-lucid", - ] - }, - "hexrays.mop_t.is_constant": { - "return": [ - 'NoneType', - 'int', - ], - "tests": [ - "plugins-lucid", - ] - }, - "hexrays.mop_t.is_insn": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds19", - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mop_t.make_fpnum": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - ] - }, - "hexrays.mop_t.make_number": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds19", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.mop_t.swap": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.negate_mcode_relation": { - "return": [ - 'int', - ], - "tests": [ - "plugins-pyhexraysdeob__big_func", - ] - }, - "hexrays.new_block": { - "return": [ - 'cinsn_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.op_uses_x": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-ctree_visitor__force_all_calls", - "idapython_hr-decompile", - "idapython_hr-examples__vds17", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "idapython_hr-misc__cexpr_ctor", - "plugins-hexrayspytools", - ] - }, - "hexrays.op_uses_y": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-decompile", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "idapython_hr-misc__cexpr_ctor", - "plugins-hexrayspytools", - ] - }, - "hexrays.op_uses_z": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - ] - }, - "hexrays.open_pseudocode": { - "return": [ - 'vdui_t', - ], - "tests": [ - "hexrays-misc__decompile_delete_type_re_decompile", - "hexrays-navigate5__open_pseudocode_compat_new_window", - "hexrays-navigate5__open_pseudocode_compat_reuse", - "hexrays-navigate5__open_pseudocode_compat_reuse_active", - "hexrays-navigate5__open_pseudocode_new_window", - "hexrays-navigate5__open_pseudocode_reuse", - "hexrays-navigate5__open_pseudocode_reuse_active", - "idapython-tinfo_func", - "idapython_hr-base_classes2__cfunc_t", - "idapython_hr-decompile", - "plugins-hexrayspytools", - ] - }, - "hexrays.optblock_t.install": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__broken_optblock_t", - "idapython_hr-examples__vds11", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.optblock_t.remove": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds11", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.optinsn_t.install": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__broken_optinsn_t", - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - "idapython_hr-examples__vds19", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.optinsn_t.remove": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - "idapython_hr-examples__vds19", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.qlist_cinsn_t.at": { - "return": [ - 'cinsn_t', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-decompile", - "plugins-hexrayspytools", - ] - }, - "hexrays.qlist_cinsn_t.back": { - "return": [ - 'cinsn_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.begin": { - "return": [ - 'qlist_cinsn_t_iterator', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-base_classes2__qlist_cinsn_t_iterator", - "idapython_hr-decompile", - "plugins-hexrayspytools", - ] - }, - "hexrays.qlist_cinsn_t.end": { - "return": [ - 'qlist_cinsn_t_iterator', - ], - "tests": [ - "idapython_hr-base_classes2__qlist_cinsn_t_iterator", - ] - }, - "hexrays.qlist_cinsn_t.find": { - "return": [ - 'NoneType', - 'qlist_cinsn_t_iterator', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.front": { - "return": [ - 'cinsn_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.insert": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.pop_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.pop_front": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.push_back": { - "return": [ - 'NoneType', - 'cinsn_t', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.remove": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "hexrays.qlist_cinsn_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-decompile", - "plugins-hexrayspytools", - ] - }, - "hexrays.qlist_cinsn_t_iterator.next": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__qlist_cinsn_t_iterator", - ] - }, - "hexrays.qswap": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds3", - ] - }, - "hexrays.remove_hexrays_callback": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes", - "idapython_hr-decompile", - "idapython_hr-hexrays_callback", - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "plugins-hexlight_2016", - "plugins-hexrayspytools", - ] - }, - "hexrays.rename_lvar": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-rename_lvars", - ] - }, - "hexrays.restore_user_cmts": { - "return": [ - 'NoneType', - 'user_cmts_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.restore_user_iflags": { - "return": [ - 'NoneType', - 'user_iflags_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.restore_user_labels": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.restore_user_lvar_settings": { - "return": [ - 'bool', - ], - "tests": [ - "hexrays-rename_lvars", - "idapython_hr-examples__vds4", - ] - }, - "hexrays.restore_user_numforms": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.save_user_lvar_settings": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.select_udt_by_offset": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds17", - ] - }, - "hexrays.term_hexrays_plugin": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.udc_filter_t.init": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-codegen", - "idapython_hr-examples__vds8", - "idapython_hr-examples__vds8_crash", - "idapython_hr-examples__vds8_crash_minimal_no_install", - ] - }, - "hexrays.ui_stroff_ops_t.push_back": { - "return": [ - 'ui_stroff_op_t', - ], - "tests": [ - "idapython_hr-examples__vds17", - ] - }, - "hexrays.user_cmts_free": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_cmts_t.begin": { - "return": [ - 'user_cmts_iterator_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_cmts_t.end": { - "return": [ - 'user_cmts_iterator_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_cmts_t.first": { - "return": [ - 'treeloc_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_cmts_t.items": { - "return": [ - [('treeloc_t', 'citem_cmt_t'), '...'], - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_cmts_t.iteritems": { - "return": [ - 'generator', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_cmts_t.next": { - "return": [ - 'user_cmts_iterator_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_cmts_t.second": { - "return": [ - 'citem_cmt_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_free": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_t.begin": { - "return": [ - 'user_iflags_iterator_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_t.end": { - "return": [ - 'user_iflags_iterator_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_t.first": { - "return": [ - 'citem_locator_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_t.items": { - "return": [ - [('citem_locator_t', 'int'), '...'], - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_t.iteritems": { - "return": [ - 'generator', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_t.next": { - "return": [ - 'user_iflags_iterator_t', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_iflags_t.second": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds4", - ] - }, - "hexrays.user_unions_t.valuetype.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "hexrays.user_unions_t.valuetype.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "hexrays.user_unions_t.valuetype.empty": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-examples__vds17", - ] - }, - "hexrays.user_unions_t.valuetype.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "hexrays.user_unions_t.valuetype.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "hexrays.user_unions_t.valuetype.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__block_chain_t_64", - ] - }, - "hexrays.uval_ivl_ivlset_t.getivl": { - "return": [ - 'ivl_t', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - ] - }, - "hexrays.uval_ivl_ivlset_t.nivls": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - ] - }, - "hexrays.valrng_t.all_values": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.cvt_to_cmp": { - "return": [ - ('bool', 'int', 'int'), - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.cvt_to_single_value": { - "return": [ - ('bool', 'int'), - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.dstr": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.get_size": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.has": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.intersect_with": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.is_unknown": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.max_svalue": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.max_value": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.min_svalue": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.set_cmp": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.set_eq": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.valrng_t.swap": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__valrng_t", - ] - }, - "hexrays.vc_printer_t.oneliner": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__vc_printer_t", - ] - }, - "hexrays.vdui_t.get_current_item": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds17", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__create_hint", - "idapython_hr-hexrays_hooks__create_hint2", - ] - }, - "hexrays.vdui_t.refresh_cpos": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-plugin_hexlit", - "plugins-hexlight_2016", - ] - }, - "hexrays.vdui_t.refresh_ctext": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds3", - ] - }, - "hexrays.vdui_t.refresh_view": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-tinfo_func", - "idapython_hr-codegen", - "idapython_hr-ctree_visitor__force_all_calls", - "idapython_hr-examples__vds17", - ] - }, - "hexrays.vdui_t.set_lvar_type": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "hexrays.vdui_t.visible": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-plugin_hexlit", - "plugins-hexlight_2016", - ] - }, - "ida.idainfo.is_64bit": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "ida.idainfo.set_be": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - ] - }, - "ida.idainfo.set_gen_tryblks": { - "return": [ - 'bool', - ], - "tests": [ - "idaview-misc__tryblocks", - ] - }, - "ida.inf_get_af": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ida", - ] - }, - "ida.inf_get_cc": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython__ida_ida", - ] - }, - "ida.inf_get_filetype": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "ida.inf_get_max_ea": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__search", - "idapython-examples__bin_search", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__produce_lst_file", - "idapython-examples__show_debug_names", - ] - }, - "ida.inf_get_min_ea": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__search", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__list_problems", - "idapython-examples__produce_lst_file", - "idapython-examples__show_debug_names", - ] - }, - "ida.inf_get_start_ip": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__automatic_steps", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - ] - }, - "ida.inf_get_xrefnum": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc5__bad_inf_set_xrefnum", - ] - }, - "ida.inf_is_64bit": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__modified_vds13_twice", - ] - }, - "ida.inf_set_af": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__ida", - ] - }, - "ida.inf_set_xrefnum": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-misc5__bad_inf_set_xrefnum", - ] - }, - "idaapi.CustomIDAMemo.CreateGroups": { - "return": [ - 'NoneType', - ['int', '...'], - ], - "tests": [ - "grview-groups__api", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.CustomIDAMemo.DelNodesInfos": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "idapython-examples__wrap_idaview", - ] - }, - "idaapi.CustomIDAMemo.DeleteGroups": { - "return": [ - 'bool', - ], - "tests": [ - "grview-groups__api", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.CustomIDAMemo.GetCurrentRendererType": { - "return": [ - 'int', - ], - "tests": [ - "grview-grida", - "idapython-api__kernwin", - ] - }, - "idaapi.CustomIDAMemo.GetNodeInfo": { - "return": [ - 'NoneType', - 'bool', - ('int', 'int', 'int', 'str'), - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "idapython-api__kernwin", - ] - }, - "idaapi.CustomIDAMemo.GetWidget": { - "return": [ - 'NoneType', - 'TWidget *', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.CustomIDAMemo.SetCurrentRendererType": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-grida", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - ] - }, - "idaapi.CustomIDAMemo.SetGroupsVisibility": { - "return": [ - 'bool', - ], - "tests": [ - "grview-groups__api", - ] - }, - "idaapi.CustomIDAMemo.SetNodeInfo": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__node_info", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - ] - }, - "idaapi.CustomIDAMemo.SetNodesInfos": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - ] - }, - "idaapi.CustomIDAMemo.view_activated": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-gruser", - "grview-nodepropsUser", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.CustomIDAMemo.view_click": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__dbl_click_handler", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "grview-grida", - "grview-gruser", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - ] - }, - "idaapi.CustomIDAMemo.view_close": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.CustomIDAMemo.view_curpos": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__dbl_click_handler", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "grview-grida", - "grview-gruser", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - ] - }, - "idaapi.CustomIDAMemo.view_dblclick": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__dbl_click_handler", - "idapython-customidamemo", - "idapython-user_graphs", - ] - }, - "idaapi.CustomIDAMemo.view_deactivated": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-gruser", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.CustomIDAMemo.view_keydown": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__check_grouping_without_callback", - "gruser-misc__dbl_click_handler", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "grview-grida", - "grview-gruser", - "grview-on_view_keydown", - "idapython-examples__custom_graph_with_actions", - ] - }, - "idaapi.CustomIDAMemo.view_loc_changed": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.CustomIDAMemo.view_mouse_moved": { - "return": [ - 'NoneType', - ], - "tests": [ - "docks-show_existent", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-stress", - "grview-grida", - "grview-gruser", - "grview-mouseOver", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - ] - }, - "idaapi.CustomIDAMemo.view_mouse_over": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "grview-grida", - "grview-gruser", - "grview-mouseOver", - "grview-nodeprops__register_highlight", - "idapython-customidamemo", - "idapython-user_graphs", - ] - }, - "idaapi.CustomIDAMemo.view_switched": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-grida", - "grview-on_view_click", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - ] - }, - "idaapi.IDAPython_FormatExc": { - "return": [ - 'str', - ], - "tests": [ - "actions-script_actions_no_interr", - "bptgrp-multiline", - "debugger-breakpoints", - "debugger-breakpoints2__compat_760", - "debugger-breakpoints2__python_from_future_cond", - "docks-misc2__set_dock_pos_using_size_hint", - "docks-misc2__set_dock_pos_using_size_hint_toplevel", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_refreshes", - "idapython-addHotkey", - "idapython-breakpoints", - "idapython-plugin__broken_plugin_init", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-python_as_primary_interpreter", - "idapython-ui_hooks__create_desktop_widget_pluginform", - "pyqt-tform2", - ] - }, - "idaapi.IDAPython_displayhook.format_item": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__get_action_attributes", - "api-actions__register_unregister_lifecycle", - "api-idapython__add_del_hotkey", - "api-idapython__add_del_hotkey_vs_plugin", - "api-idapython__get_set_numbered_type", - "api-idapython_doc__bytes", - "api-idapython_nocompat_695__ida_idp", - "api-idapython_nocompat_695__ida_kernwin", - "api-put_patch_get", - "bptgrp-create_and_move", - "chooser-attrs__choose_name", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__modify_number_of_columns_recreate_chooser", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "chooser-misc2__recreate_chooser_context_menu", - "chooser-misc2__reinit_after_search", - "chooser-misc2__select_callback_called", - "chooser-misc2__size_accounts_for_scrollbar", - "chooser-misc2__sort_CHCOL_DEC", - "chooser-misc__ex_choose_multi", - "coloredview-highlight", - "config-idausr_subdirs", - "console-actions", - "customidamemo-highlight", - "customidamemo-homeend", - "customidamemo-navigate3__enums", - "customidamemo-navigate3__jump_from_incompatible_place", - "customidamemo-navigate3__structs", - "customidamemo-navigate__dump_imported_bookmarks", - "customidamemo-search_bin__patgen_all", - "customidamemo-search_bin__patgen_cp1251", - "customidamemo-search_bin__patgen_defbpu", - "customidamemo-search_bin__patgen_utf32be", - "customidamemo-search_bin__patgen_utf8", - "customidamemo-search_bin__persistedinreg", - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "dbg_restore_snapshot", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-breakpoints2__bpt_perf", - "debugger-exceptions", - "debugger-manual_memory_regions", - "debugger-memory", - "desktops-misc__compat_old_window_titles", - "dwarf-load_options_fprots", - "eaview-navigate_rebase", - "enums-api", - "functions_window-misc__compat_find_widget", - "gruser-misc__get_graph_viewer", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__get_graph_viewer_idaview", - "grview-contextmenu", - "grview-grida", - "grview-gruser", - "grview-jumpto_xref", - "grview-jumpto_xref_from_other_tab", - "hexrays-caching__rebase_down_1000", - "hexrays-caching__rebase_up_1000", - "hexrays-misc3__get_vdui_by_api", - "hexrays-misc__decompile_delete_type_re_decompile", - "hexrays-navigate", - "i18n-files", - "i18n-strlits__bad_encoding_name", - "i18n-strlits__change_default_string_style", - "i18n-strlits__create_C_16_strlit", - "i18n-strlits__create_C_32_strlit", - "i18n-strlits__create_C_strlit", - "i18n-strlits__create_pascal_16", - "i18n-strlits__delete_encoding", - "i18n-strlits__delete_encoding_using_idapython", - "i18n-strlits__dup_encodings", - "i18n-strlits__edit_encoding", - "i18n-strlits__edit_encoding_with_changing_its_BUP", - "i18n-strlits__select_BPU_incompatible_charset_changes_strtype_BPU", - "idapython-addHotkey", - "idapython-api__695bwcompat_misses", - "idapython-api__bitrange", - "idapython-api__dbg", - "idapython-api__dirtree", - "idapython-api__expr", - "idapython-api__funcs", - "idapython-api__gdl", - "idapython-api__graph", - "idapython-api__ida", - "idapython-api__idc", - "idapython-api__idp", - "idapython-api__ieee", - "idapython-api__kernwin", - "idapython-api__kernwin_dbg", - "idapython-api__lines", - "idapython-api__nalt", - "idapython-api__pro", - "idapython-api__search", - "idapython-api__segment", - "idapython-api__struct", - "idapython-api__typeinf", - "idapython-askusingform__direct_call", - "idapython-base2file", - "idapython-big_spd_bug", - "idapython-bptgrp", - "idapython-calc_switch_cases", - "idapython-custom_data", - "idapython-debugger", - "idapython-displayhook", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-examples__no_implicit_imports", - "idapython-funcs", - "idapython-idb_hooks", - "idapython-idp_hooks", - "idapython-idp_hooks2__decorate_name", - "idapython-idp_hooks2__gen_regvar_def", - "idapython-idp_hooks2__get_reg_accesses", - "idapython-misc", - "idapython-misc2", - "idapython-misc3", - "idapython-misc4", - "idapython-misc5__bad_inf_set_xrefnum", - "idapython-names__compat", - "idapython-names__get_name_value", - "idapython-names__ida68", - "idapython-netnode", - "idapython-plugin_alternative_path__load_plugin", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__ph_object", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython-read_selection_64", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "idapython-registry", - "idapython-srareas", - "idapython-structs", - "idapython-switch_info", - "idapython-timers", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-tinfo_func", - "idapython-tinfo_manip", - "idapython-tinfo_manip2", - "idapython-tinfo_udt", - "idapython-user_graphs", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__bitset_t", - "idapython_hr-base_classes2__broken_optblock_t", - "idapython_hr-base_classes2__broken_optinsn_t", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-base_classes2__fnumber_t", - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-base_classes2__qlist_cinsn_t_iterator", - "idapython_hr-base_classes2__valrng_t", - "idapython_hr-base_classes2__vd_printer_t", - "idapython_hr-decompile", - "idapython_hr-decompile2__flags", - "idapython_hr-ea", - "idapython_hr-ea64", - "idapython_hr-examples__vds13", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "idapython_hr-hexrays_callback", - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "idaview-misc__recreate_insn", - "idaview-misc__tryblocks", - "loadfile-dyld_shared_cache2", - "localtypes-misc__anonymous_union_members", - "localtypes-misc__manipulate_dirtree_programmatically", - "lumina-update__do_not_override", - "lumina-update__merge", - "lumina-update__override", - "lumina-update__override_if_better", - "lumina-update__override_leaves_addr_untouched", - "mainmsglist-misc__API", - "mainmsglist-misc__cursor_position_breakable_line", - "mainmsglist-misc__double_click_addresses", - "mainmsglist-misc__double_click_addresses_space", - "mainmsglist-misc__goto_end", - "mainmsglist-misc__hscrollbar_selection", - "mainmsglist-misc__hscrollbar_shows_as_needed", - "mainmsglist-misc__unbreakable_line_doesnt_affect_others", - "navbar-api", - "navbar-paint_over__horizontal", - "navbar-paint_over__vertical", - "notepad-misc", - "registry-misc__strlist", - "scriptsnippets-misc__load_dups", - "scriptsnippets-undo__opening_no_undo_point", - "scriptsnippets-undo__undo_after_closing", - "squishutils-evalpython", - "squishutils-msg", - "stackview-misc", - "stddirtrees-misc__actions_on_selection_local_types", - "stddirtrees-misc__bad_delete_all_structures", - "stddirtrees-misc__basic_undo_steps_imports", - "stddirtrees-misc__basic_undo_steps_imports_2", - "stddirtrees-misc__create_with_selection_enums", - "stddirtrees-misc__create_with_selection_structures", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_functions", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - "stddirtrees-misc__delete_folder_enums", - "stddirtrees-misc__delete_folder_local_types", - "stddirtrees-misc__delete_folder_names", - "stddirtrees-misc__delete_folder_structures", - "stddirtrees-misc__delete_listing_selection_enums", - "stddirtrees-misc__delete_listing_selection_structures", - "stddirtrees-misc__delete_root_enums", - "stddirtrees-misc__delete_root_local_types", - "stddirtrees-misc__delete_root_structures", - "stddirtrees-misc__drag_drop_folders_enums", - "stddirtrees-misc__drag_drop_folders_structures", - "stddirtrees-misc__drag_drop_functions_2", - "stddirtrees-misc__drag_drop_reordering_enums", - "stddirtrees-misc__drag_drop_reordering_structures", - "stddirtrees-misc__expand_collapse_enums", - "stddirtrees-misc__expand_collapse_imports", - "stddirtrees-misc__expand_collapse_local_types", - "stddirtrees-misc__expand_collapse_names", - "stddirtrees-misc__expand_collapse_structures", - "stddirtrees-misc__filter_by_folder_then_jump_out_structures", - "stddirtrees-misc__focus_and_nav_enums", - "stddirtrees-misc__focus_and_nav_structures", - "stddirtrees-misc__folders_sorting_imports", - "stddirtrees-misc__ilfak_s_sequence_2_structures", - "stddirtrees-misc__ilfak_s_sequence_structures", - "stddirtrees-misc__insert_before_current_structures", - "stddirtrees-misc__interr_40799_local_types", - "stddirtrees-misc__interr_40868_local_types", - "stddirtrees-misc__jump_enums", - "stddirtrees-misc__jump_structures", - "stddirtrees-misc__misc_local_types", - "stddirtrees-misc__move_then_undo_enums", - "stddirtrees-misc__move_then_undo_functions", - "stddirtrees-misc__move_then_undo_imports", - "stddirtrees-misc__move_then_undo_local_types", - "stddirtrees-misc__move_then_undo_structures", - "stddirtrees-misc__no_infinite_scroll_enums", - "stddirtrees-misc__no_infinite_scroll_structures", - "stddirtrees-misc__programmatically_add_folder_enums", - "stddirtrees-misc__programmatically_add_folder_local_types", - "stddirtrees-misc__programmatically_add_folder_structures", - "stddirtrees-misc__quick_filter_enums", - "stddirtrees-misc__quick_filter_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "stddirtrees-misc__rename_enums", - "stddirtrees-misc__rename_imports", - "stddirtrees-misc__rename_local_types", - "stddirtrees-misc__rename_shortcut_local_types", - "stddirtrees-misc__rename_structures", - "stddirtrees-misc__search_enums", - "stddirtrees-misc__search_fast_enums", - "stddirtrees-misc__search_fast_imports", - "stddirtrees-misc__search_fast_local_types", - "stddirtrees-misc__search_fast_structures", - "stddirtrees-misc__search_imports", - "stddirtrees-misc__search_local_types", - "stddirtrees-misc__search_structures", - "stddirtrees-misc__selection_filtering_enums", - "stddirtrees-misc__selection_filtering_structures", - "stddirtrees-misc__sorting_enums", - "stddirtrees-misc__sorting_structures", - "stddirtrees-misc__undo_status_local_types", - "strings-misc__idapython1", - "strings-misc__idapython2", - "strings-misc__idapython3", - "strings-misc__rebase", - "strings-misc__rebase_range", - "strings-misc__restore_after_rebase", - "structs-members", - "structview-navigate2__custom_viewer_jump", - "til-loaded_til", - "til-misc", - "til-nonlocal_deps", - "til-redeclare_named_type", - "til-simple_export", - "tracing-misc", - "xrefview-misc__basic", - "xrefview-misc__generate_add_event", - "xrefview-misc__generate_del_event", - "xrefview-misc__insert_and_check_cursor", - "xrefview-misc__restore_widget", - ] - }, - "idaapi.IDAPython_displayhook.format_seq": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__get_action_attributes", - "customidamemo-highlight", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-manual_memory_regions", - "i18n-strlits__change_default_string_style", - "idapython-api__dbg", - "idapython-api__gdl", - "idapython-api__idc", - "idapython-api__kernwin", - "idapython-bptgrp", - "idapython-debugger", - "idapython-displayhook", - "idapython-misc2", - "idapython-misc3", - "idapython-names__get_name_value", - "idapython-processor_module__ph_object", - "idapython-read_selection_64", - "idapython-registry", - "idapython-tinfo_manip", - "idapython-tinfo_udt", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-base_classes2__valrng_t", - "idapython_hr-ea", - "mainmsglist-misc__goto_end", - "navbar-api", - "navbar-paint_over__horizontal", - "navbar-paint_over__vertical", - "registry-misc__strlist", - "structs-members", - "til-redeclare_named_type", - ] - }, - "idaapi.disable_script_timeout": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-command_palette", - ] - }, - "idaapi.format_basestring": { - "return": [ - 'str', - ], - "tests": [ - "api-actions__get_action_attributes", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "coloredview-highlight", - "customidamemo-highlight", - "customidamemo-homeend", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-manual_memory_regions", - "desktops-misc__compat_old_window_titles", - "dwarf-load_options_fprots", - "enums-api", - "functions_window-misc__compat_find_widget", - "grview-contextmenu", - "grview-grida", - "grview-gruser", - "grview-jumpto_xref_from_other_tab", - "hexrays-misc3__get_vdui_by_api", - "hexrays-navigate", - "i18n-strlits__change_default_string_style", - "idapython-api__695bwcompat_misses", - "idapython-api__dbg", - "idapython-api__expr", - "idapython-api__gdl", - "idapython-api__idc", - "idapython-api__idp", - "idapython-api__ieee", - "idapython-api__kernwin", - "idapython-api__kernwin_dbg", - "idapython-api__lines", - "idapython-api__nalt", - "idapython-api__pro", - "idapython-api__typeinf", - "idapython-bptgrp", - "idapython-debugger", - "idapython-displayhook", - "idapython-idb_hooks", - "idapython-misc", - "idapython-misc2", - "idapython-misc3", - "idapython-misc4", - "idapython-names__compat", - "idapython-names__get_name_value", - "idapython-names__ida68", - "idapython-netnode", - "idapython-processor_module__ph_object", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "idapython-registry", - "idapython-structs", - "idapython-switch_info", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-tinfo_manip", - "idapython-tinfo_udt", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__broken_optblock_t", - "idapython_hr-base_classes2__broken_optinsn_t", - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-base_classes2__valrng_t", - "idapython_hr-base_classes2__vd_printer_t", - "idapython_hr-decompile", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "localtypes-misc__anonymous_union_members", - "mainmsglist-misc__API", - "mainmsglist-misc__cursor_position_breakable_line", - "mainmsglist-misc__double_click_addresses", - "mainmsglist-misc__double_click_addresses_space", - "mainmsglist-misc__hscrollbar_selection", - "mainmsglist-misc__hscrollbar_shows_as_needed", - "mainmsglist-misc__unbreakable_line_doesnt_affect_others", - "notepad-misc", - "registry-misc__strlist", - "scriptsnippets-misc__load_dups", - "squishutils-msg", - "stddirtrees-misc__actions_on_selection_local_types", - "stddirtrees-misc__bad_delete_all_structures", - "stddirtrees-misc__basic_undo_steps_imports", - "stddirtrees-misc__basic_undo_steps_imports_2", - "stddirtrees-misc__create_with_selection_enums", - "stddirtrees-misc__create_with_selection_structures", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_functions", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - "stddirtrees-misc__delete_folder_enums", - "stddirtrees-misc__delete_folder_local_types", - "stddirtrees-misc__delete_folder_names", - "stddirtrees-misc__delete_folder_structures", - "stddirtrees-misc__delete_listing_selection_enums", - "stddirtrees-misc__delete_listing_selection_structures", - "stddirtrees-misc__delete_root_enums", - "stddirtrees-misc__delete_root_local_types", - "stddirtrees-misc__delete_root_structures", - "stddirtrees-misc__drag_drop_folders_enums", - "stddirtrees-misc__drag_drop_folders_structures", - "stddirtrees-misc__drag_drop_functions_2", - "stddirtrees-misc__drag_drop_reordering_enums", - "stddirtrees-misc__drag_drop_reordering_structures", - "stddirtrees-misc__expand_collapse_enums", - "stddirtrees-misc__expand_collapse_imports", - "stddirtrees-misc__expand_collapse_local_types", - "stddirtrees-misc__expand_collapse_names", - "stddirtrees-misc__expand_collapse_structures", - "stddirtrees-misc__filter_by_folder_then_jump_out_structures", - "stddirtrees-misc__focus_and_nav_enums", - "stddirtrees-misc__focus_and_nav_structures", - "stddirtrees-misc__folders_sorting_imports", - "stddirtrees-misc__ilfak_s_sequence_2_structures", - "stddirtrees-misc__ilfak_s_sequence_structures", - "stddirtrees-misc__insert_before_current_structures", - "stddirtrees-misc__interr_40799_local_types", - "stddirtrees-misc__interr_40868_local_types", - "stddirtrees-misc__jump_enums", - "stddirtrees-misc__jump_structures", - "stddirtrees-misc__misc_local_types", - "stddirtrees-misc__move_then_undo_enums", - "stddirtrees-misc__move_then_undo_functions", - "stddirtrees-misc__move_then_undo_imports", - "stddirtrees-misc__move_then_undo_local_types", - "stddirtrees-misc__move_then_undo_structures", - "stddirtrees-misc__no_infinite_scroll_enums", - "stddirtrees-misc__no_infinite_scroll_structures", - "stddirtrees-misc__quick_filter_enums", - "stddirtrees-misc__quick_filter_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "stddirtrees-misc__rename_enums", - "stddirtrees-misc__rename_imports", - "stddirtrees-misc__rename_local_types", - "stddirtrees-misc__rename_shortcut_local_types", - "stddirtrees-misc__rename_structures", - "stddirtrees-misc__search_enums", - "stddirtrees-misc__search_fast_enums", - "stddirtrees-misc__search_fast_imports", - "stddirtrees-misc__search_fast_local_types", - "stddirtrees-misc__search_fast_structures", - "stddirtrees-misc__search_imports", - "stddirtrees-misc__search_local_types", - "stddirtrees-misc__search_structures", - "stddirtrees-misc__selection_filtering_enums", - "stddirtrees-misc__selection_filtering_structures", - "stddirtrees-misc__sorting_enums", - "stddirtrees-misc__sorting_structures", - "stddirtrees-misc__undo_status_local_types", - "structs-members", - "tracing-misc", - "xrefview-misc__basic", - "xrefview-misc__generate_add_event", - "xrefview-misc__generate_del_event", - "xrefview-misc__insert_and_check_cursor", - "xrefview-misc__restore_widget", - ] - }, - "idaapi.get_inf_structure": { - "return": [ - 'idainfo', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "idaapi.loader_input_t.file2base": { - "return": [ - 'int', - ], - "tests": [ - "idapython-bfld", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - ] - }, - "idaapi.loader_input_t.gets": { - "return": [ - 'str', - ], - "tests": [ - "screenshots-misc__proc_dsp56k", - ] - }, - "idaapi.loader_input_t.read": { - "return": [ - 'NoneType', - 'bytes', - ], - "tests": [ - "actions-flush_buffers_doesnt_add_entry_in_menu", - "address_details-misc__strings", - "areas-killcb", - "areas-srareas", - "bench-autoanalysis__ntoskrnl72", - "bench-autoanalysis__pc_dwarfdump", - "bptgrp-multiline", - "bptgrp-remove_from_group", - "coloredview-basic", - "config-idausr_subdirs", - "customidamemo-switch_views", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-breakpoint_llcond", - "debugger-breakpoints_newfile", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida32_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin64", - "debugger-set_as_default", - "desktops-66_compat_geometry", - "desktops-load_save__save_default", - "desktops-misc__batch_new_file", - "desktops-misc__batch_new_file_show_sp", - "desktops-newfile__cli_asmex", - "desktops-newfile__java_sign2", - "desktops-newfile__pc_dwarf_arrays", - "desktops-newfile__tms320c6_coff2", - "dwarf-load_options", - "dwarf-load_options_fprots", - "dwarf-load_options_glob_func_types", - "enums-bitfields", - "frview-colors", - "frview-contextmenu", - "frview-cursor", - "frview-hints", - "frview-history_initial", - "frview-hscrolling", - "frview-resize", - "grview-blinking_edges", - "grview-contextmenu", - "grview-fatGraph", - "grview-flowchart_update", - "grview-line_prefixes", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-on_view_click", - "grview-on_view_keydown", - "grview-overview", - "grview-stats", - "grview-stats2", - "grview-statsFindItemAt", - "hexrays-fuzzy_sp", - "hexrays-misc3__send_idb_newfile", - "hexrays-navigate2", - "hexview-longbytes2", - "hexview-sync_base_newfile", - "i18n-broken_config", - "i18n-broken_config_bad_TypeNameChars", - "idapython-bfld", - "idapython-breakpoints", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "idapython-read_selection_64", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "idapython_hr-examples__vds8_crash", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "imports-load_other_file", - "loadfile-archive_locked_idb", - "loadfile-binary_no_entry_point", - "loadfile-dyld_shared_cache", - "loadfile-misc__arm_elf", - "loadfile-misc__armb_elf", - "loadfile-misc__conflicting_procs", - "loadfile-misc__dex_conflicting_procs", - "loadfile-misc__dialog_access", - "loadfile-misc__files_history", - "loadfile-misc__filtered_tree_hover", - "loadfile-misc__libso_inside_zip", - "loadfile-misc__ppc_elf", - "loadfile-misc__ppcl_elf", - "loadfile-misc__reload_input_file", - "loadfile-misc__screen_center", - "loadfile-misc__tree_context_menu", - "loadfile-nonnative_filedialogs", - "lumina-misc__armb", - "miniview-tracefile_node_colors", - "navbar-hints", - "prview-contextmenu", - "prview-quit_ida", - "prview-stats", - "running_initial_aa-misc__chooser_quick_filtering", - "screenshots-misc__proc_51xa", - "screenshots-misc__proc_6502", - "screenshots-misc__proc_6803", - "screenshots-misc__proc_68040_amiga", - "screenshots-misc__proc_6805", - "screenshots-misc__proc_6808", - "screenshots-misc__proc_6809_os9_flex", - "screenshots-misc__proc_6809_os9_obj", - "screenshots-misc__proc_6811", - "screenshots-misc__proc_68hc12", - "screenshots-misc__proc_68hc16", - "screenshots-misc__proc_68k_amiga", - "screenshots-misc__proc_68k_pilot", - "screenshots-misc__proc_68k_unix_coff", - "screenshots-misc__proc_78k0s", - "screenshots-misc__proc_80196", - "screenshots-misc__proc_8051", - "screenshots-misc__proc_ad218x_voc_code", - "screenshots-misc__proc_alpha_nt_coff", - "screenshots-misc__proc_alpha_unix_elf", - "screenshots-misc__proc_android_arm", - "screenshots-misc__proc_arc_7400_outer", - "screenshots-misc__proc_arm_epoc_app", - "screenshots-misc__proc_arm_epoc_pe", - "screenshots-misc__proc_arm_epoc_rom", - "screenshots-misc__proc_arm_epoc_sis", - "screenshots-misc__proc_arm_ios_lock_unlock", - "screenshots-misc__proc_arm_ios_objc", - "screenshots-misc__proc_arm_ios_objc_vars", - "screenshots-misc__proc_arm_ios_pit", - "screenshots-misc__proc_arm_ios_start", - "screenshots-misc__proc_arm_ios_switch", - "screenshots-misc__proc_arm_ios_symbol_info", - "screenshots-misc__proc_arm_ios_write", - "screenshots-misc__proc_arm_linux_elf", - "screenshots-misc__proc_arm_sdk_aof", - "screenshots-misc__proc_arm_wince_coff", - "screenshots-misc__proc_avr", - "screenshots-misc__proc_c166", - "screenshots-misc__proc_c166_elf", - "screenshots-misc__proc_c39_v90", - "screenshots-misc__proc_cli_vb", - "screenshots-misc__proc_cr16_dect11", - "screenshots-misc__proc_dalvik", - "screenshots-misc__proc_dotnet", - "screenshots-misc__proc_dsp56k", - "screenshots-misc__proc_fr_hello", - "screenshots-misc__proc_gameboy", - "screenshots-misc__proc_h8300_coff", - "screenshots-misc__proc_h8300s_coff", - "screenshots-misc__proc_h8500", - "screenshots-misc__proc_hppa_hpux_som", - "screenshots-misc__proc_i51", - "screenshots-misc__proc_i860", - "screenshots-misc__proc_i960", - "screenshots-misc__proc_ia64", - "screenshots-misc__proc_java", - "screenshots-misc__proc_kr1878", - "screenshots-misc__proc_m16c", - "screenshots-misc__proc_m32r_elf", - "screenshots-misc__proc_m740", - "screenshots-misc__proc_m7700", - "screenshots-misc__proc_m7900", - "screenshots-misc__proc_mips_nintendo_n64", - "screenshots-misc__proc_mips_sony_bin_r5900", - "screenshots-misc__proc_mips_sony_elf", - "screenshots-misc__proc_mips_sony_psx", - "screenshots-misc__proc_mips_unix_coff", - "screenshots-misc__proc_mips_unix_elf", - "screenshots-misc__proc_mips_wince_pe", - "screenshots-misc__proc_mips_wince_pe2", - "screenshots-misc__proc_mn102", - "screenshots-misc__proc_oakdsp", - "screenshots-misc__proc_pc_elf", - "screenshots-misc__proc_pc_geos_drv", - "screenshots-misc__proc_pc_geos_lib", - "screenshots-misc__proc_pc_gnu_coff", - "screenshots-misc__proc_pc_lx", - "screenshots-misc__proc_pc_nlm", - "screenshots-misc__proc_pc_qnx", - "screenshots-misc__proc_pc_watcom", - "screenshots-misc__proc_pc_win_omf", - "screenshots-misc__proc_pc_win_pe", - "screenshots-misc__proc_pc_win_xvd", - "screenshots-misc__proc_pdp11_rt11_sav", - "screenshots-misc__proc_pic", - "screenshots-misc__proc_pic12xx", - "screenshots-misc__proc_ppc_aix_ecoff", - "screenshots-misc__proc_ppc_linux_elf", - "screenshots-misc__proc_ppc_macos_X", - "screenshots-misc__proc_ppc_macos_pef", - "screenshots-misc__proc_ppc_nt_pe", - "screenshots-misc__proc_sh3_wince_coff", - "screenshots-misc__proc_sh3_wince_pe", - "screenshots-misc__proc_sh4_elf", - "screenshots-misc__proc_sh4_wince_pe", - "screenshots-misc__proc_snes", - "screenshots-misc__proc_sparc_solaris_coff", - "screenshots-misc__proc_sparc_solaris_elf", - "screenshots-misc__proc_sparc_sun_elf", - "screenshots-misc__proc_sparc_sun_elf_so", - "screenshots-misc__proc_st20", - "screenshots-misc__proc_st7", - "screenshots-misc__proc_st9", - "screenshots-misc__proc_tlcs900", - "screenshots-misc__proc_tms320c2_coff", - "screenshots-misc__proc_tms320c5", - "screenshots-misc__proc_tms320c54", - "screenshots-misc__proc_tms320c6_coff", - "screenshots-misc__proc_tricore", - "screenshots-misc__proc_unsp", - "screenshots-misc__proc_v850_elf", - "screenshots-misc__proc_z180_coff", - "screenshots-misc__proc_z380_coff", - "screenshots-misc__proc_z8", - "screenshots-misc__proc_z80", - "screenshots-misc__tutorial_debugger_linux_local", - "screenshots-misc__tutorial_debugger_linux_to_linux64", - "segs-offset_xrefs", - "sigs-status", - "srcdbg-large_structs", - "srcdbg-watch_mem", - "srcdbg-watch_reg", - "stddirtrees-misc__debugging_functions", - "stddirtrees-misc__newfile_imports", - "strings-refresh_when_auto_empty", - "training-test__chunkldr_idc", - "training-test__sol_cyci_py", - "welcome-load_binary_dont_save_idb", - ] - }, - "idaapi.loader_input_t.seek": { - "return": [ - 'int', - ], - "tests": [ - "actions-flush_buffers_doesnt_add_entry_in_menu", - "address_details-misc__strings", - "areas-killcb", - "areas-srareas", - "bench-autoanalysis__ntoskrnl72", - "bench-autoanalysis__pc_dwarfdump", - "bptgrp-multiline", - "bptgrp-remove_from_group", - "coloredview-basic", - "config-idausr_subdirs", - "customidamemo-switch_views", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-breakpoint_llcond", - "debugger-breakpoints_newfile", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida32_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin64", - "debugger-set_as_default", - "desktops-66_compat_geometry", - "desktops-load_save__save_default", - "desktops-misc__batch_new_file", - "desktops-misc__batch_new_file_show_sp", - "desktops-newfile__cli_asmex", - "desktops-newfile__java_sign2", - "desktops-newfile__pc_dwarf_arrays", - "desktops-newfile__tms320c6_coff2", - "dwarf-load_options", - "dwarf-load_options_fprots", - "dwarf-load_options_glob_func_types", - "enums-bitfields", - "frview-colors", - "frview-contextmenu", - "frview-cursor", - "frview-hints", - "frview-history_initial", - "frview-hscrolling", - "frview-resize", - "grview-blinking_edges", - "grview-contextmenu", - "grview-fatGraph", - "grview-flowchart_update", - "grview-line_prefixes", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-on_view_click", - "grview-on_view_keydown", - "grview-overview", - "grview-stats", - "grview-stats2", - "grview-statsFindItemAt", - "hexrays-fuzzy_sp", - "hexrays-misc3__send_idb_newfile", - "hexrays-navigate2", - "hexview-longbytes2", - "hexview-sync_base_newfile", - "i18n-broken_config", - "i18n-broken_config_bad_TypeNameChars", - "idapython-bfld", - "idapython-breakpoints", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "idapython-read_selection_64", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "idapython_hr-examples__vds8_crash", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "imports-load_other_file", - "loadfile-archive_locked_idb", - "loadfile-binary_no_entry_point", - "loadfile-dyld_shared_cache", - "loadfile-misc__arm_elf", - "loadfile-misc__armb_elf", - "loadfile-misc__conflicting_procs", - "loadfile-misc__dex_conflicting_procs", - "loadfile-misc__dialog_access", - "loadfile-misc__files_history", - "loadfile-misc__filtered_tree_hover", - "loadfile-misc__libso_inside_zip", - "loadfile-misc__ppc_elf", - "loadfile-misc__ppcl_elf", - "loadfile-misc__reload_input_file", - "loadfile-misc__screen_center", - "loadfile-misc__tree_context_menu", - "loadfile-nonnative_filedialogs", - "lumina-misc__armb", - "miniview-tracefile_node_colors", - "navbar-hints", - "prview-contextmenu", - "prview-quit_ida", - "prview-stats", - "running_initial_aa-misc__chooser_quick_filtering", - "screenshots-misc__proc_51xa", - "screenshots-misc__proc_6502", - "screenshots-misc__proc_6803", - "screenshots-misc__proc_68040_amiga", - "screenshots-misc__proc_6805", - "screenshots-misc__proc_6808", - "screenshots-misc__proc_6809_os9_flex", - "screenshots-misc__proc_6809_os9_obj", - "screenshots-misc__proc_6811", - "screenshots-misc__proc_68hc12", - "screenshots-misc__proc_68hc16", - "screenshots-misc__proc_68k_amiga", - "screenshots-misc__proc_68k_pilot", - "screenshots-misc__proc_68k_unix_coff", - "screenshots-misc__proc_78k0s", - "screenshots-misc__proc_80196", - "screenshots-misc__proc_8051", - "screenshots-misc__proc_ad218x_voc_code", - "screenshots-misc__proc_alpha_nt_coff", - "screenshots-misc__proc_alpha_unix_elf", - "screenshots-misc__proc_android_arm", - "screenshots-misc__proc_arc_7400_outer", - "screenshots-misc__proc_arm_epoc_app", - "screenshots-misc__proc_arm_epoc_pe", - "screenshots-misc__proc_arm_epoc_rom", - "screenshots-misc__proc_arm_epoc_sis", - "screenshots-misc__proc_arm_ios_lock_unlock", - "screenshots-misc__proc_arm_ios_objc", - "screenshots-misc__proc_arm_ios_objc_vars", - "screenshots-misc__proc_arm_ios_pit", - "screenshots-misc__proc_arm_ios_start", - "screenshots-misc__proc_arm_ios_switch", - "screenshots-misc__proc_arm_ios_symbol_info", - "screenshots-misc__proc_arm_ios_write", - "screenshots-misc__proc_arm_linux_elf", - "screenshots-misc__proc_arm_sdk_aof", - "screenshots-misc__proc_arm_wince_coff", - "screenshots-misc__proc_avr", - "screenshots-misc__proc_c166", - "screenshots-misc__proc_c166_elf", - "screenshots-misc__proc_c39_v90", - "screenshots-misc__proc_cli_vb", - "screenshots-misc__proc_cr16_dect11", - "screenshots-misc__proc_dalvik", - "screenshots-misc__proc_dotnet", - "screenshots-misc__proc_dsp56k", - "screenshots-misc__proc_fr_hello", - "screenshots-misc__proc_gameboy", - "screenshots-misc__proc_h8300_coff", - "screenshots-misc__proc_h8300s_coff", - "screenshots-misc__proc_h8500", - "screenshots-misc__proc_hppa_hpux_som", - "screenshots-misc__proc_i51", - "screenshots-misc__proc_i860", - "screenshots-misc__proc_i960", - "screenshots-misc__proc_ia64", - "screenshots-misc__proc_java", - "screenshots-misc__proc_kr1878", - "screenshots-misc__proc_m16c", - "screenshots-misc__proc_m32r_elf", - "screenshots-misc__proc_m740", - "screenshots-misc__proc_m7700", - "screenshots-misc__proc_m7900", - "screenshots-misc__proc_mips_nintendo_n64", - "screenshots-misc__proc_mips_sony_bin_r5900", - "screenshots-misc__proc_mips_sony_elf", - "screenshots-misc__proc_mips_sony_psx", - "screenshots-misc__proc_mips_unix_coff", - "screenshots-misc__proc_mips_unix_elf", - "screenshots-misc__proc_mips_wince_pe", - "screenshots-misc__proc_mips_wince_pe2", - "screenshots-misc__proc_mn102", - "screenshots-misc__proc_oakdsp", - "screenshots-misc__proc_pc_elf", - "screenshots-misc__proc_pc_geos_drv", - "screenshots-misc__proc_pc_geos_lib", - "screenshots-misc__proc_pc_gnu_coff", - "screenshots-misc__proc_pc_lx", - "screenshots-misc__proc_pc_nlm", - "screenshots-misc__proc_pc_qnx", - "screenshots-misc__proc_pc_watcom", - "screenshots-misc__proc_pc_win_omf", - "screenshots-misc__proc_pc_win_pe", - "screenshots-misc__proc_pc_win_xvd", - "screenshots-misc__proc_pdp11_rt11_sav", - "screenshots-misc__proc_pic", - "screenshots-misc__proc_pic12xx", - "screenshots-misc__proc_ppc_aix_ecoff", - "screenshots-misc__proc_ppc_linux_elf", - "screenshots-misc__proc_ppc_macos_X", - "screenshots-misc__proc_ppc_macos_pef", - "screenshots-misc__proc_ppc_nt_pe", - "screenshots-misc__proc_sh3_wince_coff", - "screenshots-misc__proc_sh3_wince_pe", - "screenshots-misc__proc_sh4_elf", - "screenshots-misc__proc_sh4_wince_pe", - "screenshots-misc__proc_snes", - "screenshots-misc__proc_sparc_solaris_coff", - "screenshots-misc__proc_sparc_solaris_elf", - "screenshots-misc__proc_sparc_sun_elf", - "screenshots-misc__proc_sparc_sun_elf_so", - "screenshots-misc__proc_st20", - "screenshots-misc__proc_st7", - "screenshots-misc__proc_st9", - "screenshots-misc__proc_tlcs900", - "screenshots-misc__proc_tms320c2_coff", - "screenshots-misc__proc_tms320c5", - "screenshots-misc__proc_tms320c54", - "screenshots-misc__proc_tms320c6_coff", - "screenshots-misc__proc_tricore", - "screenshots-misc__proc_unsp", - "screenshots-misc__proc_v850_elf", - "screenshots-misc__proc_z180_coff", - "screenshots-misc__proc_z380_coff", - "screenshots-misc__proc_z8", - "screenshots-misc__proc_z80", - "screenshots-misc__tutorial_debugger_linux_local", - "screenshots-misc__tutorial_debugger_linux_to_linux64", - "segs-offset_xrefs", - "sigs-status", - "srcdbg-large_structs", - "srcdbg-watch_mem", - "srcdbg-watch_reg", - "stddirtrees-misc__debugging_functions", - "stddirtrees-misc__newfile_imports", - "strings-refresh_when_auto_empty", - "training-test__chunkldr_idc", - "training-test__sol_cyci_py", - "welcome-load_binary_dont_save_idb", - ] - }, - "idaapi.loader_input_t.size": { - "return": [ - 'int', - ], - "tests": [ - "actions-flush_buffers_doesnt_add_entry_in_menu", - "address_details-misc__strings", - "areas-killcb", - "areas-srareas", - "bench-autoanalysis__ntoskrnl72", - "bench-autoanalysis__pc_dwarfdump", - "bptgrp-multiline", - "bptgrp-remove_from_group", - "coloredview-basic", - "config-idausr_subdirs", - "customidamemo-switch_views", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-breakpoint_llcond", - "debugger-breakpoints_newfile", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida32_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin64", - "debugger-set_as_default", - "desktops-66_compat_geometry", - "desktops-load_save__save_default", - "desktops-misc__batch_new_file", - "desktops-misc__batch_new_file_show_sp", - "desktops-newfile__cli_asmex", - "desktops-newfile__java_sign2", - "desktops-newfile__pc_dwarf_arrays", - "desktops-newfile__tms320c6_coff2", - "dwarf-load_options", - "dwarf-load_options_fprots", - "dwarf-load_options_glob_func_types", - "enums-bitfields", - "frview-colors", - "frview-contextmenu", - "frview-cursor", - "frview-hints", - "frview-history_initial", - "frview-hscrolling", - "frview-resize", - "grview-blinking_edges", - "grview-contextmenu", - "grview-fatGraph", - "grview-flowchart_update", - "grview-line_prefixes", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-on_view_click", - "grview-on_view_keydown", - "grview-overview", - "grview-stats", - "grview-stats2", - "grview-statsFindItemAt", - "hexrays-fuzzy_sp", - "hexrays-misc3__send_idb_newfile", - "hexrays-navigate2", - "hexview-longbytes2", - "hexview-sync_base_newfile", - "i18n-broken_config", - "i18n-broken_config_bad_TypeNameChars", - "idapython-bfld", - "idapython-breakpoints", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "idapython-read_selection_64", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "idapython_hr-examples__vds8_crash", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "imports-load_other_file", - "loadfile-archive_locked_idb", - "loadfile-binary_no_entry_point", - "loadfile-dyld_shared_cache", - "loadfile-misc__arm_elf", - "loadfile-misc__armb_elf", - "loadfile-misc__conflicting_procs", - "loadfile-misc__dex_conflicting_procs", - "loadfile-misc__dialog_access", - "loadfile-misc__files_history", - "loadfile-misc__filtered_tree_hover", - "loadfile-misc__libso_inside_zip", - "loadfile-misc__ppc_elf", - "loadfile-misc__ppcl_elf", - "loadfile-misc__reload_input_file", - "loadfile-misc__screen_center", - "loadfile-misc__tree_context_menu", - "loadfile-nonnative_filedialogs", - "lumina-misc__armb", - "miniview-tracefile_node_colors", - "navbar-hints", - "prview-contextmenu", - "prview-quit_ida", - "prview-stats", - "running_initial_aa-misc__chooser_quick_filtering", - "screenshots-misc__proc_51xa", - "screenshots-misc__proc_6502", - "screenshots-misc__proc_6803", - "screenshots-misc__proc_68040_amiga", - "screenshots-misc__proc_6805", - "screenshots-misc__proc_6808", - "screenshots-misc__proc_6809_os9_flex", - "screenshots-misc__proc_6809_os9_obj", - "screenshots-misc__proc_6811", - "screenshots-misc__proc_68hc12", - "screenshots-misc__proc_68hc16", - "screenshots-misc__proc_68k_amiga", - "screenshots-misc__proc_68k_pilot", - "screenshots-misc__proc_68k_unix_coff", - "screenshots-misc__proc_78k0s", - "screenshots-misc__proc_80196", - "screenshots-misc__proc_8051", - "screenshots-misc__proc_ad218x_voc_code", - "screenshots-misc__proc_alpha_nt_coff", - "screenshots-misc__proc_alpha_unix_elf", - "screenshots-misc__proc_android_arm", - "screenshots-misc__proc_arc_7400_outer", - "screenshots-misc__proc_arm_epoc_app", - "screenshots-misc__proc_arm_epoc_pe", - "screenshots-misc__proc_arm_epoc_rom", - "screenshots-misc__proc_arm_epoc_sis", - "screenshots-misc__proc_arm_ios_lock_unlock", - "screenshots-misc__proc_arm_ios_objc", - "screenshots-misc__proc_arm_ios_objc_vars", - "screenshots-misc__proc_arm_ios_pit", - "screenshots-misc__proc_arm_ios_start", - "screenshots-misc__proc_arm_ios_switch", - "screenshots-misc__proc_arm_ios_symbol_info", - "screenshots-misc__proc_arm_ios_write", - "screenshots-misc__proc_arm_linux_elf", - "screenshots-misc__proc_arm_sdk_aof", - "screenshots-misc__proc_arm_wince_coff", - "screenshots-misc__proc_avr", - "screenshots-misc__proc_c166", - "screenshots-misc__proc_c166_elf", - "screenshots-misc__proc_c39_v90", - "screenshots-misc__proc_cli_vb", - "screenshots-misc__proc_cr16_dect11", - "screenshots-misc__proc_dalvik", - "screenshots-misc__proc_dotnet", - "screenshots-misc__proc_dsp56k", - "screenshots-misc__proc_fr_hello", - "screenshots-misc__proc_gameboy", - "screenshots-misc__proc_h8300_coff", - "screenshots-misc__proc_h8300s_coff", - "screenshots-misc__proc_h8500", - "screenshots-misc__proc_hppa_hpux_som", - "screenshots-misc__proc_i51", - "screenshots-misc__proc_i860", - "screenshots-misc__proc_i960", - "screenshots-misc__proc_ia64", - "screenshots-misc__proc_java", - "screenshots-misc__proc_kr1878", - "screenshots-misc__proc_m16c", - "screenshots-misc__proc_m32r_elf", - "screenshots-misc__proc_m740", - "screenshots-misc__proc_m7700", - "screenshots-misc__proc_m7900", - "screenshots-misc__proc_mips_nintendo_n64", - "screenshots-misc__proc_mips_sony_bin_r5900", - "screenshots-misc__proc_mips_sony_elf", - "screenshots-misc__proc_mips_sony_psx", - "screenshots-misc__proc_mips_unix_coff", - "screenshots-misc__proc_mips_unix_elf", - "screenshots-misc__proc_mips_wince_pe", - "screenshots-misc__proc_mips_wince_pe2", - "screenshots-misc__proc_mn102", - "screenshots-misc__proc_oakdsp", - "screenshots-misc__proc_pc_elf", - "screenshots-misc__proc_pc_geos_drv", - "screenshots-misc__proc_pc_geos_lib", - "screenshots-misc__proc_pc_gnu_coff", - "screenshots-misc__proc_pc_lx", - "screenshots-misc__proc_pc_nlm", - "screenshots-misc__proc_pc_qnx", - "screenshots-misc__proc_pc_watcom", - "screenshots-misc__proc_pc_win_omf", - "screenshots-misc__proc_pc_win_pe", - "screenshots-misc__proc_pc_win_xvd", - "screenshots-misc__proc_pdp11_rt11_sav", - "screenshots-misc__proc_pic", - "screenshots-misc__proc_pic12xx", - "screenshots-misc__proc_ppc_aix_ecoff", - "screenshots-misc__proc_ppc_linux_elf", - "screenshots-misc__proc_ppc_macos_X", - "screenshots-misc__proc_ppc_macos_pef", - "screenshots-misc__proc_ppc_nt_pe", - "screenshots-misc__proc_sh3_wince_coff", - "screenshots-misc__proc_sh3_wince_pe", - "screenshots-misc__proc_sh4_elf", - "screenshots-misc__proc_sh4_wince_pe", - "screenshots-misc__proc_snes", - "screenshots-misc__proc_sparc_solaris_coff", - "screenshots-misc__proc_sparc_solaris_elf", - "screenshots-misc__proc_sparc_sun_elf", - "screenshots-misc__proc_sparc_sun_elf_so", - "screenshots-misc__proc_st20", - "screenshots-misc__proc_st7", - "screenshots-misc__proc_st9", - "screenshots-misc__proc_tlcs900", - "screenshots-misc__proc_tms320c2_coff", - "screenshots-misc__proc_tms320c5", - "screenshots-misc__proc_tms320c54", - "screenshots-misc__proc_tms320c6_coff", - "screenshots-misc__proc_tricore", - "screenshots-misc__proc_unsp", - "screenshots-misc__proc_v850_elf", - "screenshots-misc__proc_z180_coff", - "screenshots-misc__proc_z380_coff", - "screenshots-misc__proc_z8", - "screenshots-misc__proc_z80", - "screenshots-misc__tutorial_debugger_linux_local", - "screenshots-misc__tutorial_debugger_linux_to_linux64", - "segs-offset_xrefs", - "sigs-status", - "srcdbg-large_structs", - "srcdbg-watch_mem", - "srcdbg-watch_reg", - "stddirtrees-misc__debugging_functions", - "stddirtrees-misc__newfile_imports", - "strings-refresh_when_auto_empty", - "training-test__chunkldr_idc", - "training-test__sol_cyci_py", - "welcome-load_binary_dont_save_idb", - ] - }, - "idaapi.loader_input_t.tell": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - ] - }, - "idaapi.notify_when": { - "return": [ - 'bool', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-examples__custom_cli", - "idapython-notify_when__basic", - "plugins-hexrayspytools", - ] - }, - "idaapi.pycim_get_widget": { - "return": [ - 'NoneType', - 'TWidget *', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.pycim_view_close": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.pygc_create_groups": { - "return": [ - 'NoneType', - ['int', '...'], - ], - "tests": [ - "grview-groups__api", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.pygc_delete_groups": { - "return": [ - 'bool', - ], - "tests": [ - "grview-groups__api", - "miniview-tracefile_node_colors", - ] - }, - "idaapi.pygc_set_groups_visibility": { - "return": [ - 'bool', - ], - "tests": [ - "grview-groups__api", - ] - }, - "idd.Appcall__.get_appcall_options": { - "return": [ - 'int', - ], - "tests": [ - "idapython-appcall_manual__delayed_cleanup", - "idapython-appcall_manual__no_cleanup", - "idapython-appcall_manual__normal", - "idapython-appcall_manual__single_stmt", - "idapython-appcall_manual__single_stmt_delayed_cleanup", - "idapython-appcall_manual__single_stmt_no_cleanup", - ] - }, - "idd.Appcall__.set_appcall_options": { - "return": [ - 'int', - ], - "tests": [ - "idapython-appcall_manual__delayed_cleanup", - "idapython-appcall_manual__no_cleanup", - "idapython-appcall_manual__normal", - "idapython-appcall_manual__single_stmt", - "idapython-appcall_manual__single_stmt_delayed_cleanup", - "idapython-appcall_manual__single_stmt_no_cleanup", - ] - }, - "idd.dbg_write_memory": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-search_bin__search1_dbg", - "debugger-memory", - ] - }, - "idd.meminfo_vec_t.push_back": { - "return": [ - 'memory_info_t', - ], - "tests": [ - "debugger-manual_memory_regions", - ] - }, - "idd.regval_t.set_int": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-registers__linux", - "idapython-registers__linux_x64", - ] - }, - "idp.AssembleLine": { - "return": [ - 'bytes', - ], - "tests": [ - "training-test__FindInstructions_py", - ] - }, - "idp.IDB_Hooks.dump_state": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__log_idb_events", - "idapython-idb_hooks2__compiler_changed", - "idapython-idb_hooks2__compiler_changed_compat", - "idapython-idb_hooks2__renamed", - "idapython-idb_hooks2__renamed_compat", - "idapython-idb_hooks2__sgr_changed_deleted", - ] - }, - "idp.IDB_Hooks.hook": { - "return": [ - 'bool', - ], - "tests": [ - "cpuregs-custom_data_formats", - "custdata-menus", - "idapython-examples__custom_cli", - "idapython-examples__log_idb_events", - "idapython-examples__operand_changed", - "idapython-examples__replay_prototypes_changes", - "idapython-extra_cmt", - "idapython-idb_hooks", - "idapython-idb_hooks2__bookmark_changed", - "idapython-idb_hooks2__bookmark_changed_compat", - "idapython-idb_hooks2__compiler_changed", - "idapython-idb_hooks2__compiler_changed_compat", - "idapython-idb_hooks2__renamed", - "idapython-idb_hooks2__renamed_compat", - "idapython-idb_hooks2__segm_deleted_compat", - "idapython-idb_hooks2__sgr_changed_deleted", - "idapython-notify_when__basic", - "plugins-hexrayspytools", - ] - }, - "idp.IDB_Hooks.unhook": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-extra_cmt", - ] - }, - "idp.IDP_Hooks.dump_state": { - "return": [ - 'str', - ], - "tests": [ - "idapython-idp_hooks2__assemble", - "idapython-idp_hooks2__calc_step_over", - "idapython-idp_hooks2__coagulate_dref", - "idapython-idp_hooks2__decorate_name", - "idapython-idp_hooks2__func_bounds", - "idapython-idp_hooks2__gen_map_file", - "idapython-idp_hooks2__gen_regvar_def", - "idapython-idp_hooks2__gen_src_file_lnnum", - "idapython-idp_hooks2__get_autocmt", - "idapython-idp_hooks2__get_bg_color", - "idapython-idp_hooks2__get_bg_color_compat", - "idapython-idp_hooks2__get_frame_retsize", - "idapython-idp_hooks2__get_operand_string", - "idapython-idp_hooks2__get_reg_accesses", - "idapython-idp_hooks2__is_sp_based", - ] - }, - "idp.IDP_Hooks.unhook": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks", - "idaview-hints__instruction_gets_deleted", - "plugins-procext_py", - ] - }, - "idp.get_ash": { - "return": [ - 'asm_t', - ], - "tests": [ - "idapython-api__idp", - ] - }, - "idp.get_reg_info": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__idp", - ] - }, - "idp.is_call_insn": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__ida_idp", - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "grview-nodepropsUser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "training-test__CallStackWalk_py", - ] - }, - "idp.parse_reg_name": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "idapython-debugger", - ] - }, - "idp.ph_calcrel": { - "return": [ - ('bytes', 'int'), - ], - "tests": [ - "idapython-api__idp", - ] - }, - "idp.ph_find_op_value": { - "return": [ - 'NoneType', - 'int', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "idp.ph_find_reg_value": { - "return": [ - 'NoneType', - 'int', - ], - "tests": [ - "idapython-idp_hooks", - "ppc-analysis_options", - ] - }, - "idp.ph_get_cnbits": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_dnbits": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_flag": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__get_action_attributes", - "api-actions__register_unregister_lifecycle", - "api-idapython__add_del_hotkey", - "api-idapython__add_del_hotkey_vs_plugin", - "api-idapython__get_set_numbered_type", - "api-idapython_doc__bytes", - "api-idapython_nocompat_695__ida_idp", - "api-idapython_nocompat_695__ida_kernwin", - "api-put_patch_get", - "bptgrp-create_and_move", - "chooser-attrs__choose_name", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__modify_number_of_columns_recreate_chooser", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "chooser-misc2__recreate_chooser_context_menu", - "chooser-misc2__reinit_after_search", - "chooser-misc2__select_callback_called", - "chooser-misc2__size_accounts_for_scrollbar", - "chooser-misc2__sort_CHCOL_DEC", - "chooser-misc__ex_choose_multi", - "coloredview-highlight", - "config-idausr_subdirs", - "console-actions", - "customidamemo-highlight", - "customidamemo-homeend", - "customidamemo-navigate3__enums", - "customidamemo-navigate3__jump_from_incompatible_place", - "customidamemo-navigate3__structs", - "customidamemo-navigate__dump_imported_bookmarks", - "customidamemo-search_bin__patgen_all", - "customidamemo-search_bin__patgen_cp1251", - "customidamemo-search_bin__patgen_defbpu", - "customidamemo-search_bin__patgen_utf32be", - "customidamemo-search_bin__patgen_utf8", - "customidamemo-search_bin__persistedinreg", - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "dbg_restore_snapshot", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-breakpoints2__bpt_perf", - "debugger-exceptions", - "debugger-manual_memory_regions", - "debugger-memory", - "desktops-misc__compat_old_window_titles", - "dwarf-load_options_fprots", - "eaview-navigate_rebase", - "enums-api", - "functions_window-misc__compat_find_widget", - "gruser-misc__get_graph_viewer", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__get_graph_viewer_idaview", - "grview-contextmenu", - "grview-grida", - "grview-gruser", - "grview-jumpto_xref", - "grview-jumpto_xref_from_other_tab", - "hexrays-caching__rebase_down_1000", - "hexrays-caching__rebase_up_1000", - "hexrays-misc3__get_vdui_by_api", - "hexrays-misc__decompile_delete_type_re_decompile", - "hexrays-navigate", - "i18n-files", - "i18n-strlits__bad_encoding_name", - "i18n-strlits__change_default_string_style", - "i18n-strlits__create_C_16_strlit", - "i18n-strlits__create_C_32_strlit", - "i18n-strlits__create_C_strlit", - "i18n-strlits__create_pascal_16", - "i18n-strlits__delete_encoding", - "i18n-strlits__delete_encoding_using_idapython", - "i18n-strlits__dup_encodings", - "i18n-strlits__edit_encoding", - "i18n-strlits__edit_encoding_with_changing_its_BUP", - "i18n-strlits__select_BPU_incompatible_charset_changes_strtype_BPU", - "idapython-addHotkey", - "idapython-api__695bwcompat_misses", - "idapython-api__bitrange", - "idapython-api__dbg", - "idapython-api__dirtree", - "idapython-api__expr", - "idapython-api__funcs", - "idapython-api__gdl", - "idapython-api__graph", - "idapython-api__ida", - "idapython-api__idc", - "idapython-api__idp", - "idapython-api__ieee", - "idapython-api__kernwin", - "idapython-api__kernwin_dbg", - "idapython-api__lines", - "idapython-api__nalt", - "idapython-api__pro", - "idapython-api__search", - "idapython-api__segment", - "idapython-api__struct", - "idapython-api__typeinf", - "idapython-askusingform__direct_call", - "idapython-base2file", - "idapython-big_spd_bug", - "idapython-bptgrp", - "idapython-calc_switch_cases", - "idapython-custom_data", - "idapython-debugger", - "idapython-displayhook", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-examples__no_implicit_imports", - "idapython-funcs", - "idapython-idb_hooks", - "idapython-idp_hooks", - "idapython-idp_hooks2__decorate_name", - "idapython-idp_hooks2__gen_regvar_def", - "idapython-idp_hooks2__get_reg_accesses", - "idapython-misc", - "idapython-misc2", - "idapython-misc3", - "idapython-misc4", - "idapython-misc5__bad_inf_set_xrefnum", - "idapython-names__compat", - "idapython-names__get_name_value", - "idapython-names__ida68", - "idapython-netnode", - "idapython-plugin_alternative_path__load_plugin", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__ph_object", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython-read_selection_64", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "idapython-registry", - "idapython-srareas", - "idapython-structs", - "idapython-switch_info", - "idapython-timers", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-tinfo_func", - "idapython-tinfo_manip", - "idapython-tinfo_manip2", - "idapython-tinfo_udt", - "idapython-user_graphs", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__bitset_t", - "idapython_hr-base_classes2__broken_optblock_t", - "idapython_hr-base_classes2__broken_optinsn_t", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-base_classes2__fnumber_t", - "idapython_hr-base_classes2__mbl_array_t", - "idapython_hr-base_classes2__mbl_array_t_64", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-base_classes2__qlist_cinsn_t_iterator", - "idapython_hr-base_classes2__valrng_t", - "idapython_hr-base_classes2__vd_printer_t", - "idapython_hr-decompile", - "idapython_hr-decompile2__flags", - "idapython_hr-ea", - "idapython_hr-ea64", - "idapython_hr-examples__vds13", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "idapython_hr-hexrays_callback", - "idapython_hr-hexrays_hooks__cb_close_pseudocode", - "idapython_hr-hexrays_hooks__cb_create_hint", - "idapython_hr-hexrays_hooks__cb_curpos", - "idapython_hr-hexrays_hooks__cb_double_click", - "idapython_hr-hexrays_hooks__cb_func_printed", - "idapython_hr-hexrays_hooks__cb_keyboard", - "idapython_hr-hexrays_hooks__cb_maturity", - "idapython_hr-hexrays_hooks__cb_open_pseudocode", - "idapython_hr-hexrays_hooks__cb_populating_popup", - "idapython_hr-hexrays_hooks__cb_print_func", - "idapython_hr-hexrays_hooks__cb_refresh_pseudocode", - "idapython_hr-hexrays_hooks__cb_right_click", - "idapython_hr-hexrays_hooks__cb_switch_pseudocode", - "idapython_hr-hexrays_hooks__cb_text_ready", - "idaview-misc__recreate_insn", - "idaview-misc__tryblocks", - "loadfile-dyld_shared_cache2", - "localtypes-misc__anonymous_union_members", - "localtypes-misc__manipulate_dirtree_programmatically", - "lumina-update__do_not_override", - "lumina-update__merge", - "lumina-update__override", - "lumina-update__override_if_better", - "lumina-update__override_leaves_addr_untouched", - "mainmsglist-misc__API", - "mainmsglist-misc__cursor_position_breakable_line", - "mainmsglist-misc__double_click_addresses", - "mainmsglist-misc__double_click_addresses_space", - "mainmsglist-misc__goto_end", - "mainmsglist-misc__hscrollbar_selection", - "mainmsglist-misc__hscrollbar_shows_as_needed", - "mainmsglist-misc__unbreakable_line_doesnt_affect_others", - "navbar-api", - "navbar-paint_over__horizontal", - "navbar-paint_over__vertical", - "notepad-misc", - "registry-misc__strlist", - "scriptsnippets-misc__load_dups", - "scriptsnippets-undo__opening_no_undo_point", - "scriptsnippets-undo__undo_after_closing", - "squishutils-evalpython", - "squishutils-msg", - "stackview-misc", - "stddirtrees-misc__actions_on_selection_local_types", - "stddirtrees-misc__bad_delete_all_structures", - "stddirtrees-misc__basic_undo_steps_imports", - "stddirtrees-misc__basic_undo_steps_imports_2", - "stddirtrees-misc__create_with_selection_enums", - "stddirtrees-misc__create_with_selection_structures", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_functions", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - "stddirtrees-misc__delete_folder_enums", - "stddirtrees-misc__delete_folder_local_types", - "stddirtrees-misc__delete_folder_names", - "stddirtrees-misc__delete_folder_structures", - "stddirtrees-misc__delete_listing_selection_enums", - "stddirtrees-misc__delete_listing_selection_structures", - "stddirtrees-misc__delete_root_enums", - "stddirtrees-misc__delete_root_local_types", - "stddirtrees-misc__delete_root_structures", - "stddirtrees-misc__drag_drop_folders_enums", - "stddirtrees-misc__drag_drop_folders_structures", - "stddirtrees-misc__drag_drop_functions_2", - "stddirtrees-misc__drag_drop_reordering_enums", - "stddirtrees-misc__drag_drop_reordering_structures", - "stddirtrees-misc__expand_collapse_enums", - "stddirtrees-misc__expand_collapse_imports", - "stddirtrees-misc__expand_collapse_local_types", - "stddirtrees-misc__expand_collapse_names", - "stddirtrees-misc__expand_collapse_structures", - "stddirtrees-misc__filter_by_folder_then_jump_out_structures", - "stddirtrees-misc__focus_and_nav_enums", - "stddirtrees-misc__focus_and_nav_structures", - "stddirtrees-misc__folders_sorting_imports", - "stddirtrees-misc__ilfak_s_sequence_2_structures", - "stddirtrees-misc__ilfak_s_sequence_structures", - "stddirtrees-misc__insert_before_current_structures", - "stddirtrees-misc__interr_40799_local_types", - "stddirtrees-misc__interr_40868_local_types", - "stddirtrees-misc__jump_enums", - "stddirtrees-misc__jump_structures", - "stddirtrees-misc__misc_local_types", - "stddirtrees-misc__move_then_undo_enums", - "stddirtrees-misc__move_then_undo_functions", - "stddirtrees-misc__move_then_undo_imports", - "stddirtrees-misc__move_then_undo_local_types", - "stddirtrees-misc__move_then_undo_structures", - "stddirtrees-misc__no_infinite_scroll_enums", - "stddirtrees-misc__no_infinite_scroll_structures", - "stddirtrees-misc__programmatically_add_folder_enums", - "stddirtrees-misc__programmatically_add_folder_local_types", - "stddirtrees-misc__programmatically_add_folder_structures", - "stddirtrees-misc__quick_filter_enums", - "stddirtrees-misc__quick_filter_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "stddirtrees-misc__rename_enums", - "stddirtrees-misc__rename_imports", - "stddirtrees-misc__rename_local_types", - "stddirtrees-misc__rename_shortcut_local_types", - "stddirtrees-misc__rename_structures", - "stddirtrees-misc__search_enums", - "stddirtrees-misc__search_fast_enums", - "stddirtrees-misc__search_fast_imports", - "stddirtrees-misc__search_fast_local_types", - "stddirtrees-misc__search_fast_structures", - "stddirtrees-misc__search_imports", - "stddirtrees-misc__search_local_types", - "stddirtrees-misc__search_structures", - "stddirtrees-misc__selection_filtering_enums", - "stddirtrees-misc__selection_filtering_structures", - "stddirtrees-misc__sorting_enums", - "stddirtrees-misc__sorting_structures", - "stddirtrees-misc__undo_status_local_types", - "strings-misc__idapython1", - "strings-misc__idapython2", - "strings-misc__idapython3", - "strings-misc__rebase", - "strings-misc__rebase_range", - "strings-misc__restore_after_rebase", - "structs-members", - "structview-navigate2__custom_viewer_jump", - "til-loaded_til", - "til-misc", - "til-nonlocal_deps", - "til-redeclare_named_type", - "til-simple_export", - "tracing-misc", - "xrefview-misc__basic", - "xrefview-misc__generate_add_event", - "xrefview-misc__generate_del_event", - "xrefview-misc__insert_and_check_cursor", - "xrefview-misc__restore_widget", - ] - }, - "idp.ph_get_icode_return": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_id": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__ana_emu_out", - "idapython-idp_hooks", - "idapython-processor_module__ph_object", - "plugins-procext_py", - ] - }, - "idp.ph_get_instruc": { - "return": [ - [('str', 'int'), '...'], - ], - "tests": [ - "idapython-processor_module__ph_object", - "training-test__AsmViewer_py", - ] - }, - "idp.ph_get_instruc_end": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_instruc_start": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_operand_info": { - "return": [ - 'NoneType', - ('int', 'int', 'int', 'int', 'int'), - ], - "tests": [ - "idapython-debugger", - ] - }, - "idp.ph_get_reg_accesses": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idp_hooks2__get_reg_accesses", - ] - }, - "idp.ph_get_reg_code_sreg": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_reg_data_sreg": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_reg_first_sreg": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - "idapython-srareas", - ] - }, - "idp.ph_get_reg_last_sreg": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_regnames": { - "return": [ - ['str', '...'], - ], - "tests": [ - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "idapython-processor_module__ph_object", - "training-test__AsmViewer_py", - ] - }, - "idp.ph_get_segreg_size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_tbyte_size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.ph_get_version": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__ph_object", - ] - }, - "idp.processor_t.auto_empty": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.auto_empty_finally": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.closebase": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.deleting_func": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - ] - }, - "idp.processor_t.ev_ana_insn": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_auto_queue_empty": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_can_have_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - ] - }, - "idp.processor_t.ev_coagulate": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_coagulate_dref": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_create_func_frame": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.ev_creating_segm": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_emu_insn": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_endbinary": { - "return": [ - 'int', - ], - "tests": [ - "idapython-proctemplate__oldapi", - ] - }, - "idp.processor_t.ev_func_bounds": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.ev_is_align_insn": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_is_basic_block_end": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.ev_is_call_insn": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.ev_is_ret_insn": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - ] - }, - "idp.processor_t.ev_is_sane_insn": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__endianness", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_is_sp_based": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.ev_is_switch": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_may_be_func": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.ev_newbinary": { - "return": [ - 'int', - ], - "tests": [ - "idapython-proctemplate__oldapi", - ] - }, - "idp.processor_t.ev_newfile": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_newprc": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_oldfile": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - ] - }, - "idp.processor_t.ev_out_assumes": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_out_data": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_out_footer": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-proctemplate__oldapi", - ] - }, - "idp.processor_t.ev_out_header": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_out_insn": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_out_label": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - ] - }, - "idp.processor_t.ev_out_mnem": { - "return": [ - 'int', - ], - "tests": [ - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_out_operand": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_out_segend": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - ] - }, - "idp.processor_t.ev_out_segstart": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_rename": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.ev_str2reg": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.ev_treat_hindering_item": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module_mem", - ] - }, - "idp.processor_t.ev_undefine": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module_mem", - ] - }, - "idp.processor_t.func_added": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.get_auxpref": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.kernel_config_loaded": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.make_code": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.make_data": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.renamed": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.savebase": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.processor_t.set_func_end": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.set_func_start": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "idp.processor_t.sgr_changed": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "idp.reg_access_vec_t.push_back": { - "return": [ - 'reg_access_t', - ], - "tests": [ - "idapython-idp_hooks2__get_reg_accesses", - ] - }, - "idp.set_processor_type": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-bfld", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "screenshots-misc__proc_dsp56k", - ] - }, - "idp.str2reg": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__ana_emu_out", - "stackview-misc", - ] - }, - "ieee.fpvalue_t.assign": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.eabs": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.fadd": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.fdiv": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.fmul": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.from_int64": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.from_str": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.from_sval": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.from_uint64": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.fsub": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.get_kind": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.is_negative": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.mul_pow2": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.negate": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.to_int64": { - "return": [ - 'NoneType', - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.to_str": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.to_sval": { - "return": [ - 'NoneType', - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "ieee.fpvalue_t.to_uint64": { - "return": [ - 'NoneType', - 'int', - ], - "tests": [ - "idapython-api__ieee", - ] - }, - "kernwin.Choose.AddCommand": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython_nocompat_695__ida_kernwin", - ] - }, - "kernwin.Choose.Close": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-actions__action_destroys_chooser", - "chooser-dirtree__modal", - "chooser-misc2__size_accounts_for_scrollbar", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__ex_choose_multi", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "chooser-quick_filter", - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-choosers", - "idapython_hr-examples__vds12", - "mainmsglist-misc__carriage_return_after_form", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - ] - }, - "kernwin.Choose.Embedded": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Choose.GetWidget": { - "return": [ - 'TWidget *', - ], - "tests": [ - "api-actions__chooser_actions", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-actions__action_destroys_chooser", - "chooser-actions__actions_availability", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-misc2__recreate_chooser_context_menu", - "chooser-misc__ex_choose", - "desktops-floating_dock__idapython_chooser", - "idapython-api__kernwin", - "squishutils-menus", - ] - }, - "kernwin.Choose.OnPopup": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__chooser_actions", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-actions__action_destroys_chooser", - "chooser-actions__actions_availability", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-misc__ex_choose", - "squishutils-menus", - ] - }, - "kernwin.Choose.Refresh": { - "return": [ - 'NoneType', - ], - "tests": [ - "chooser-keyboard", - ] - }, - "kernwin.Choose.Show": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__chooser_actions", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-actions__action_destroys_chooser", - "chooser-actions__actions_availability", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__modify_number_of_columns_recreate_chooser", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "chooser-keyboard", - "chooser-misc2__recreate_chooser_context_menu", - "chooser-misc2__reinit_after_search", - "chooser-misc2__select_callback_called", - "chooser-misc2__size_accounts_for_scrollbar", - "chooser-misc2__sort_CHCOL_DEC", - "chooser-misc__chooser_broken", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__ex_choose", - "chooser-misc__ex_choose_multi", - "chooser-misc__selection_changed_called_and_colors_considered", - "chooser-misc__status_bar", - "chooser-quick_filter", - "desktops-floating_dock__idapython_chooser", - "idapython-api__kernwin", - "idapython-choosers", - "idapython_hr-examples__vds12", - "squishutils-menus", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - ] - }, - "kernwin.Choose.UI_Hooks_Trampoline.populating_widget_popup": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__chooser_actions", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-actions__action_destroys_chooser", - "chooser-actions__actions_availability", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-misc2__recreate_chooser_context_menu", - "chooser-misc__ex_choose", - "squishutils-menus", - ] - }, - "kernwin.Choose.adjust_last_item": { - "return": [ - ['int', '...'], - ], - "tests": [ - "chooser-actions__actions_availability", - "chooser-misc__chooser_broken", - "idapython-choosers", - ] - }, - "kernwin.CustomIDAMemo.CreateGroups": { - "return": [ - 'NoneType', - ['int', '...'], - ], - "tests": [ - "grview-groups__api", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.CustomIDAMemo.DelNodesInfos": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "idapython-examples__wrap_idaview", - ] - }, - "kernwin.CustomIDAMemo.DeleteGroups": { - "return": [ - 'bool', - ], - "tests": [ - "grview-groups__api", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.CustomIDAMemo.GetCurrentRendererType": { - "return": [ - 'int', - ], - "tests": [ - "grview-grida", - "idapython-api__kernwin", - ] - }, - "kernwin.CustomIDAMemo.GetNodeInfo": { - "return": [ - 'NoneType', - 'bool', - ('int', 'int', 'int', 'str'), - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "idapython-api__kernwin", - ] - }, - "kernwin.CustomIDAMemo.GetWidget": { - "return": [ - 'NoneType', - 'TWidget *', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.CustomIDAMemo.SetCurrentRendererType": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-grida", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - ] - }, - "kernwin.CustomIDAMemo.SetGroupsVisibility": { - "return": [ - 'bool', - ], - "tests": [ - "grview-groups__api", - ] - }, - "kernwin.CustomIDAMemo.SetNodeInfo": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__node_info", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - ] - }, - "kernwin.CustomIDAMemo.SetNodesInfos": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - ] - }, - "kernwin.CustomIDAMemo.view_activated": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-gruser", - "grview-nodepropsUser", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.CustomIDAMemo.view_click": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__dbl_click_handler", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "grview-grida", - "grview-gruser", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - ] - }, - "kernwin.CustomIDAMemo.view_close": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.CustomIDAMemo.view_curpos": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__dbl_click_handler", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "grview-grida", - "grview-gruser", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - ] - }, - "kernwin.CustomIDAMemo.view_dblclick": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__dbl_click_handler", - "idapython-customidamemo", - "idapython-user_graphs", - ] - }, - "kernwin.CustomIDAMemo.view_deactivated": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-gruser", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.CustomIDAMemo.view_keydown": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__check_grouping_without_callback", - "gruser-misc__dbl_click_handler", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "grview-grida", - "grview-gruser", - "grview-on_view_keydown", - "idapython-examples__custom_graph_with_actions", - ] - }, - "kernwin.CustomIDAMemo.view_loc_changed": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.CustomIDAMemo.view_mouse_moved": { - "return": [ - 'NoneType', - ], - "tests": [ - "docks-show_existent", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-stress", - "grview-grida", - "grview-gruser", - "grview-mouseOver", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - ] - }, - "kernwin.CustomIDAMemo.view_mouse_over": { - "return": [ - 'NoneType', - ], - "tests": [ - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "grview-grida", - "grview-gruser", - "grview-mouseOver", - "grview-nodeprops__register_highlight", - "idapython-customidamemo", - "idapython-user_graphs", - ] - }, - "kernwin.CustomIDAMemo.view_switched": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-grida", - "grview-on_view_click", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - ] - }, - "kernwin.Form.Add": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__misplaced_formchangecb", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.AddControls": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__misplaced_formchangecb", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.ButtonInput.helper_cb": { - "return": [ - 'int', - ], - "tests": [ - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - ] - }, - "kernwin.Form.ButtonInput.is_input_field": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.Close": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - ] - }, - "kernwin.Form.Compile": { - "return": [ - ('MyChooserForm', ['bytes', 'CFunctionType', 'LP_c_void_p', 'LP_c_void_p', 'LP_c_void_p', 'LP_c_void_p', 'c_char_Array_1024']), - ('MyForm', ['bytes', 'CFunctionType', 'LP_c_void_p', 'LP_c_void_p', 'CFunctionType']), - ('MyForm', ['bytes', 'CFunctionType', 'LP_c_void_p', 'LP_c_void_p']), - ('MyForm3', ['bytes', 'CFunctionType', 'CFunctionType']), - ('MyNonModalForm', ['bytes', 'int', 'CFunctionType', 'CFunctionType']), - ('UpdateCollectiveIntelForm', ['bytes', 'CFunctionType', 'LP_c_long', 'LP_c_long', 'LP_c_long', 'LP_c_long', 'LP_c_void_p', 'LP_c_void_p', 'LP_c_ushort', 'LP_c_long', 'LP_c_long']), - ('VirusTotalForm', ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_ushort', 'c_char_Array_512', 'LP_c_void_p', 'LP_c_void_p', 'CFunctionType']), - ('busy_form_t', ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_ulong', 'c_char_Array_1024', 'LP_c_ulong', 'c_char_Array_1024', 'LP_c_ulong', 'c_char_Array_512', 'c_char_Array_512', 'c_char_Array_512', 'LP_c_ulong', 'LP_c_ulong', 'LP_c_long', 'LP_c_ulong', 'c_char_Array_1024', 'CFunctionType', 'CFunctionType', 'LP_c_ushort', 'LP_c_ushort', 'LP_c_void_p', 'LP_c_void_p']), - ('enable_field_file_browser_t', ['bytes', 'CFunctionType', 'c_char_Array_512']), - ('jmp_to_form', ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_void_p', 'LP_c_void_p']), - ('search_strlit_form_t', ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_ushort']), - ('test_plugin_form_t', ['bytes', 'int', 'CFunctionType', 'LP_c_void_p']), - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.CompileEx": { - "return": [ - ['bytes', 'CFunctionType', 'CFunctionType'], - ['bytes', 'CFunctionType', 'LP_c_long', 'LP_c_long', 'LP_c_long', 'LP_c_long', 'LP_c_void_p', 'LP_c_void_p', 'LP_c_ushort', 'LP_c_long', 'LP_c_long'], - ['bytes', 'CFunctionType', 'LP_c_void_p', 'LP_c_void_p', 'CFunctionType'], - ['bytes', 'CFunctionType', 'LP_c_void_p', 'LP_c_void_p', 'LP_c_void_p', 'LP_c_void_p', 'c_char_Array_1024'], - ['bytes', 'CFunctionType', 'LP_c_void_p', 'LP_c_void_p'], - ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_ulong', 'c_char_Array_1024', 'LP_c_ulong', 'c_char_Array_1024', 'LP_c_ulong', 'c_char_Array_512', 'c_char_Array_512', 'c_char_Array_512', 'LP_c_ulong', 'LP_c_ulong', 'LP_c_long', 'LP_c_ulong', 'c_char_Array_1024', 'CFunctionType', 'CFunctionType', 'LP_c_ushort', 'LP_c_ushort', 'LP_c_void_p', 'LP_c_void_p'], - ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_ushort', 'c_char_Array_512', 'LP_c_void_p', 'LP_c_void_p', 'CFunctionType'], - ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_ushort'], - ['bytes', 'CFunctionType', 'c_char_Array_1024', 'LP_c_void_p', 'LP_c_void_p'], - ['bytes', 'CFunctionType', 'c_char_Array_512'], - ['bytes', 'int', 'CFunctionType', 'CFunctionType'], - ['bytes', 'int', 'CFunctionType', 'LP_c_void_p'], - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.Compiled": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.Control.free": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.Control.get_arg": { - "return": [ - 'CFunctionType', - 'LP_c_long', - 'LP_c_ulong', - 'LP_c_ushort', - 'LP_c_void_p', - 'c_char_Array_1024', - 'c_char_Array_512', - ('LP_c_void_p', 'LP_c_void_p'), - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.Control.is_input_field": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__refresh_and_check_selection", - "idapython-askusingform__close_on_click", - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.DropdownListControl.free": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython_hr-examples__modified_vds13_twice", - ] - }, - "kernwin.Form.EmbeddedChooserControl.free": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.EnableField": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-askusingform__enable_field_file_browser", - ] - }, - "kernwin.Form.Execute": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.FindControlById": { - "return": [ - 'ButtonInput', - 'ChkGroupControl', - 'ChkGroupItemControl', - 'EmbeddedChooserControl', - 'FileInput', - 'FormChangeCb', - 'StringInput', - ], - "tests": [ - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - ] - }, - "kernwin.Form.FormChangeCb.free": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.FormChangeCb.get_tag": { - "return": [ - 'str', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__refresh_and_check_selection", - "idapython-askusingform__close_on_click", - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.FormChangeCb.helper_cb": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.Free": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.GroupControl.get_tag": { - "return": [ - 'str', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-examples__bin_search", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.GroupControl.next_child_pos": { - "return": [ - 'int', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-examples__bin_search", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.GroupItemControl.assign_pos": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-examples__bin_search", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.GroupItemControl.get_tag": { - "return": [ - 'str', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-examples__bin_search", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.GroupItemControl.is_input_field": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-examples__bin_search", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.InputControl.get_tag": { - "return": [ - 'str', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.InputControl.is_input_field": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__misplaced_formchangecb", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.LabelControl.get_tag": { - "return": [ - 'str', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.MultiLineTextControl.free": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-askusingform__multiline", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - ] - }, - "kernwin.Form.Open": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - ] - }, - "kernwin.Form.RefreshField": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-askusingform__dropdown", - ] - }, - "kernwin.Form.create_string_buffer": { - "return": [ - 'c_char_Array_10', - 'c_char_Array_1024', - 'c_char_Array_512', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - "idapython-askusingform__legacy", - "idapython-askusingform__misplaced_formchangecb", - "idapython-askusingform__multiline", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.Form.fieldtype_to_ctype": { - "return": [ - 'PyCSimpleType', - ], - "tests": [ - "idapython-askusingform__dropdown", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_ids", - "idapython-askusingform__legacy", - "idapython-askusingform__misplaced_formchangecb", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-examples__bin_search", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.IDAViewWrapper.Bind": { - "return": [ - 'bool', - ], - "tests": [ - "grview-grida", - "grview-groups__api", - "grview-mouseOver", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.IDAViewWrapper.Unbind": { - "return": [ - 'bool', - ], - "tests": [ - "grview-grida", - ] - }, - "kernwin.PluginForm.FormToPyQtWidget": { - "return": [ - 'QAbstractScrollArea', - 'QWidget', - ], - "tests": [ - "hexrays-misc3__get_vdui_by_api", - "navbar-paint_over__horizontal", - "navbar-paint_over__vertical", - "plugins-hexrayspytools", - "pyqt-qabstractitemdelegate", - "pyqt-raw_widgets_in_tree", - "squishutils-drag", - ] - }, - "kernwin.PluginForm.GetWidget": { - "return": [ - 'TWidget *', - ], - "tests": [ - "idapython-ui_hooks__create_desktop_widget_pluginform", - ] - }, - "kernwin.PluginForm.OnClose": { - "return": [ - 'NoneType', - ], - "tests": [ - "docks-misc2__set_dock_pos_using_size_hint", - "docks-misc2__set_dock_pos_using_size_hint_toplevel", - "docks-set_dock_pos_empty_dst", - ] - }, - "kernwin.PluginForm.OnCreate": { - "return": [ - 'NoneType', - ], - "tests": [ - "docks-set_dock_pos_empty_dst", - ] - }, - "kernwin.PluginForm.QtWidgetToTWidget": { - "return": [ - 'TWidget *', - ], - "tests": [ - "idapython-ui_hooks__create_desktop_widget_qwidget", - ] - }, - "kernwin.PluginForm.Show": { - "return": [ - 'bool', - ], - "tests": [ - "docks-misc2__set_dock_pos_using_size_hint", - "docks-misc2__set_dock_pos_using_size_hint_toplevel", - "docks-set_dock_pos_empty_dst", - "idapython-ui_hooks__create_desktop_widget_pluginform", - "plugins-hexrayspytools", - "pyqt-tform2", - ] - }, - "kernwin.PluginForm.TWidgetToPyQtWidget": { - "return": [ - 'QAbstractScrollArea', - 'QWidget', - ], - "tests": [ - "idapython-examples__inject_command", - "idapython-ui_hooks__misc", - "plugins-lucid", - ] - }, - "kernwin.TWidget__from_ptrval__": { - "return": [ - 'TWidget *', - ], - "tests": [ - "idapython-ui_hooks__create_desktop_widget_qwidget", - ] - }, - "kernwin.UI_Hooks.dump_state": { - "return": [ - 'str', - ], - "tests": [ - "idapython-ui_hooks__create_desktop_widget_pluginform", - "idapython-ui_hooks__create_desktop_widget_qwidget", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython-ui_hooks__database_closed", - "idapython-ui_hooks__debugger_menu_change_default_impl", - "idapython-ui_hooks__get_custom_viewer_hint_embedded", - "idapython-ui_hooks__get_custom_viewer_hint_embedded_dbg", - "idapython-ui_hooks__misc", - "idapython-ui_hooks__term", - ] - }, - "kernwin.UI_Hooks.hook": { - "return": [ - 'bool', - ], - "tests": [ - "actions-misc2", - "api-actions__attach_dynamic_action_to_popup", - "api-actions__attach_dynamic_action_to_popup_lifecycle", - "api-actions__attach_same_dynamic_action_twice_to_popup", - "api-actions__attach_to_chooser_popup", - "api-actions__attach_to_embedded_chooser_popup_python", - "api-actions__attach_to_popup", - "api-actions__chooser_actions", - "api-actions__path_part_name_starts_like_action", - "api-actions__separators", - "api-actions__tooltips", - "api-actions__unused_action_desc", - "api-actions__updating_actions_notif", - "api-idapython_nocompat_695__ida_graph", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-actions__action_destroys_chooser", - "chooser-actions__actions_availability", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__modify_number_of_columns_recreate_chooser", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "chooser-keyboard", - "chooser-misc2__missing_attributes", - "chooser-misc2__recreate_chooser_context_menu", - "chooser-misc2__reinit_after_search", - "chooser-misc2__select_callback_called", - "chooser-misc2__size_accounts_for_scrollbar", - "chooser-misc2__sort_CHCOL_DEC", - "chooser-misc__chooser_broken", - "chooser-misc__colorize_chooser", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__ex_choose", - "chooser-misc__ex_choose_multi", - "chooser-misc__selection_changed_called_and_colors_considered", - "chooser-misc__status_bar", - "chooser-quick_filter", - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "debugger-regviews_actions", - "desktops-floating_dock__idapython_chooser", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-gruser", - "grview-nodepropsUser", - "i18n-basic", - "idapython-api__graph", - "idapython-api__kernwin", - "idapython-choosers", - "idapython-cleanup", - "idapython-custom_viewer", - "idapython-customidamemo", - "idapython-example_add_menu_item", - "idapython-examples__auto_instantiate_widget_plugin", - "idapython-examples__auto_instantiate_widget_plugin_desktop", - "idapython-examples__colorize_pseudocode_lines", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-examples__func_chooser_coloring", - "idapython-examples__lines_rendering", - "idapython-examples__prevent_jump", - "idapython-examples__registers_context_menu", - "idapython-examples__uihook", - "idapython-tform", - "idapython-tform_type", - "idapython-ui_hooks__attach_action_to_any_popup", - "idapython-ui_hooks__create_desktop_widget_pluginform", - "idapython-ui_hooks__create_desktop_widget_qwidget", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython-ui_hooks__database_closed", - "idapython-ui_hooks__debugger_menu_change_default_impl", - "idapython-ui_hooks__desktop_applied", - "idapython-ui_hooks__get_custom_viewer_hint_embedded", - "idapython-ui_hooks__get_custom_viewer_hint_embedded_dbg", - "idapython-ui_hooks__misc", - "idapython-ui_hooks__saving_saved", - "idapython-ui_hooks__saving_saved_bwcompat", - "idapython-ui_hooks__term", - "idapython-user_graphs", - "idapython_hr-codegen", - "idapython_hr-examples__modified_vds13_twice", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds8", - "idapython_hr-examples__vds8_crash", - "plugins-lucid", - "squishutils-menus", - "training-test__AsmViewer_py", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - ] - }, - "kernwin.UI_Hooks.unhook": { - "return": [ - 'bool', - ], - "tests": [ - "actions-misc2", - "api-actions__attach_dynamic_action_to_popup", - "api-actions__attach_dynamic_action_to_popup_lifecycle", - "api-actions__attach_same_dynamic_action_twice_to_popup", - "api-actions__attach_to_chooser_popup", - "api-actions__attach_to_embedded_chooser_popup_python", - "api-actions__attach_to_popup", - "api-actions__chooser_actions", - "api-actions__separators", - "api-actions__tooltips", - "api-actions__updating_actions_notif", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-actions__action_destroys_chooser", - "chooser-actions__actions_availability", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__modify_number_of_columns_recreate_chooser", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "chooser-keyboard", - "chooser-misc2__recreate_chooser_context_menu", - "chooser-misc2__reinit_after_search", - "chooser-misc2__select_callback_called", - "chooser-misc2__size_accounts_for_scrollbar", - "chooser-misc2__sort_CHCOL_DEC", - "chooser-misc__chooser_broken", - "chooser-misc__colorize_chooser", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__ex_choose", - "chooser-misc__ex_choose_multi", - "chooser-misc__selection_changed_called_and_colors_considered", - "chooser-misc__status_bar", - "chooser-quick_filter", - "debugger-regviews_actions", - "desktops-floating_dock__idapython_chooser", - "idapython-api__kernwin", - "idapython-choosers", - "idapython-examples__prevent_jump", - "idapython-ui_hooks__create_desktop_widget_pluginform", - "idapython-ui_hooks__create_desktop_widget_qwidget", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython-ui_hooks__misc", - "idapython_hr-examples__vds12", - "plugins-lucid", - "squishutils-menus", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - ] - }, - "kernwin.View_Hooks.hook": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "docks-show_existent", - "gruser-misc__addedge_out_of_bounds", - "gruser-misc__check_grouping_without_callback", - "gruser-misc__check_onactivate", - "gruser-misc__check_refreshes", - "gruser-misc__dbl_click_handler", - "gruser-misc__edge_hints", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__memory_usage", - "gruser-misc__node_hints", - "gruser-misc__node_info", - "gruser-misc__two_graphs_with_same_title", - "gruser-stress", - "grview-grida", - "grview-groups__api", - "grview-gruser", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-nodeprops__misc", - "grview-nodeprops__register_highlight", - "grview-on_view_click", - "grview-on_view_keydown", - "i18n-basic", - "idapython-api__kernwin", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__wrap_idaview", - "idapython-user_graphs", - "idaview-misc__callback_for_click_on_registers", - "miniview-tracefile_node_colors", - ] - }, - "kernwin.View_Hooks.unhook": { - "return": [ - 'bool', - ], - "tests": [ - "grview-grida", - "idapython-user_graphs", - ] - }, - "kernwin.action_ctx_base_t.has_flag": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__dump_selection", - ] - }, - "kernwin.action_handler_t.update": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_toolbar", - "api-actions__register_actions_before_exit", - ] - }, - "kernwin.activate_widget": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-gruser", - "grview-nodepropsUser", - ] - }, - "kernwin.add_hotkey": { - "return": [ - 'PyCapsule', - ], - "tests": [ - "api-idapython__add_del_hotkey", - "api-idapython__add_del_hotkey_vs_plugin", - "idapython-addHotkey", - "idapython-examples__add_hotkey", - "idapython-misc2", - ] - }, - "kernwin.add_idc_hotkey": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__add_idc_hotkey", - ] - }, - "kernwin.add_spaces": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__kernwin", - ] - }, - "kernwin.ask_addr": { - "return": [ - 'NoneType', - ], - "tests": [ - "desktops-floating_dock__dis_forms", - "dialogs-misc__positioning", - "dialogs-misc__positioning_desktop_reset", - "dialogs-misc__positioning_prevented", - "forms-misc__regular_forms", - ] - }, - "kernwin.ask_file": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "filedlg-open_file__filters", - "idapython-misc3", - "idapython-waitdialog", - "training-test__AsmViewer_py", - ] - }, - "kernwin.ask_form": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "chooser-misc__chooser_selection", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__refresh_and_check_selection", - "chooser-misc__selection_changed_called_and_colors_considered", - "idapython-askusingform__close_on_click", - "idapython-askusingform__close_on_click_minimal", - "idapython-askusingform__direct_call", - "idapython-askusingform__dropdown", - "idapython-askusingform__enable_field_file_browser", - "idapython-askusingform__ex_askusingform", - "idapython-askusingform__form_ShowField_EnableField", - "idapython-askusingform__form_controls_chooser", - "idapython-askusingform__form_ids", - "idapython-askusingform__legacy", - "idapython-askusingform__multiline", - "idapython-askusingform__non_freed_forms", - "idapython-askusingform__set_color_interactively", - "idapython-askusingform__set_color_programmatically", - "idapython-askusingform__whitespace", - "idapython-examples__bin_search", - "idapython_hr-examples__modified_vds13_twice", - "mainmsglist-misc__carriage_return_after_form", - ] - }, - "kernwin.ask_str": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__no_tree", - "idapython-askusingform__dropdown", - "idapython-help_function", - "idapython-help_shortcut", - "training-test__ImpRef_py", - ] - }, - "kernwin.ask_text": { - "return": [ - 'str', - ], - "tests": [ - "dialogs-asktext__sizes", - "plugins-hexrayspytools", - ] - }, - "kernwin.ask_yn": { - "return": [ - 'int', - ], - "tests": [ - "idapython-uirequests", - ] - }, - "kernwin.attach_action_to_popup": { - "return": [ - 'bool', - ], - "tests": [ - "actions-misc2", - "actions-misc4", - "api-actions__attach_to_chooser_popup", - "api-actions__attach_to_popup", - "api-actions__chooser_actions", - "api-actions__permanent_attach_to_chooser_popup", - "api-actions__permanent_attach_to_popup", - "api-actions__separators", - "api-actions__tooltips", - "chooser-actions__action_destroys_chooser", - "chooser-misc__ex_choose", - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "debugger-regviews_actions", - "desktops-floating_dock__idapython_chooser", - "grview-gruser", - "grview-nodepropsUser", - "idapython-api__kernwin", - "idapython-custom_viewer", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-examples__dump_extra_comments", - "idapython-examples__registers_context_menu", - "idapython-examples__show_selected_using_get_chooser_data", - "idapython-examples__show_selected_using_get_strlist_item", - "idapython-plugin_actions", - "idapython-tform_type", - "idapython-ui_hooks__attach_action_to_any_popup", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython_hr-examples__vds3", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "plugins-hexrayspytools", - "squishutils-menus", - "training-test__AsmViewer_py", - ] - }, - "kernwin.attach_action_to_toolbar": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_to_toolbar", - "api-actions__separators", - "api-actions__update_action", - "idapython-example_add_menu_item", - "toolbars-add_custom", - ] - }, - "kernwin.attach_dynamic_action_to_popup": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_dynamic_action_to_popup", - "api-actions__attach_dynamic_action_to_popup_lifecycle", - "api-actions__attach_same_dynamic_action_twice_to_popup", - "api-actions__attach_to_embedded_chooser_popup_python", - "api-actions__path_part_name_starts_like_action", - "api-actions__unused_action_desc", - "api-idapython_nocompat_695__ida_graph", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-misc2__recreate_chooser_context_menu", - "idapython-examples__custom_graph_with_actions", - "idapython-tform_type", - "idapython-user_graphs", - ] - }, - "kernwin.call_nav_colorizer": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - ] - }, - "kernwin.choose_find": { - "return": [ - 'MyChoose', - 'NoneType', - ], - "tests": [ - "idapython-api__kernwin", - ] - }, - "kernwin.choose_name": { - "return": [ - 'int', - ], - "tests": [ - "chooser-attrs__choose_name", - ] - }, - "kernwin.choose_segm": { - "return": [ - 'NoneType', - ], - "tests": [ - "segs-manip", - ] - }, - "kernwin.chooser_base_t.get_ea": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__func_chooser_coloring", - ] - }, - "kernwin.chooser_base_t.get_row": { - "return": [ - (['str', '...'], 'int', 'chooser_item_attrs_t'), - ], - "tests": [ - "chooser-misc__colorize_chooser", - ] - }, - "kernwin.cli_t.register": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__custom_cli", - ] - }, - "kernwin.cli_t.unregister": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__custom_cli", - ] - }, - "kernwin.close_chooser": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-columns__modify_number_of_columns_recreate_chooser", - "desktops-misc__compat_old_window_titles", - "functions_window-misc__compat_close_chooser", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - ] - }, - "kernwin.close_widget": { - "return": [ - 'NoneType', - ], - "tests": [ - "console-restore", - "debugger-regviews", - "docks-close_with_middle_button", - "eaview-sync_pseudocode", - "enums-asm_and_c", - "forms-massiveclose", - "frview-resize", - "funstack-navigate", - "gruser-misc__node_info", - "grview-grida", - "grview-gruser", - "grview-on_view_click", - "hexrays-navigate", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-customidamemo", - "miniview-close", - "miniview-tracefile_node_colors", - "stddirtrees-misc__actions_on_selection_local_types", - "stddirtrees-misc__bad_delete_all_structures", - "stddirtrees-misc__basic_enums", - "stddirtrees-misc__basic_structures", - "stddirtrees-misc__basic_undo_steps_imports", - "stddirtrees-misc__basic_undo_steps_imports_2", - "stddirtrees-misc__complex_filters_enums", - "stddirtrees-misc__complex_filters_structures", - "stddirtrees-misc__create_with_selection_enums", - "stddirtrees-misc__create_with_selection_structures", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_functions", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - "stddirtrees-misc__debugging_functions", - "stddirtrees-misc__debugging_imports", - "stddirtrees-misc__delete_folder_enums", - "stddirtrees-misc__delete_folder_local_types", - "stddirtrees-misc__delete_folder_names", - "stddirtrees-misc__delete_folder_structures", - "stddirtrees-misc__delete_listing_selection_enums", - "stddirtrees-misc__delete_listing_selection_structures", - "stddirtrees-misc__delete_root_enums", - "stddirtrees-misc__delete_root_local_types", - "stddirtrees-misc__delete_root_structures", - "stddirtrees-misc__delete_undo_delete_again_enums", - "stddirtrees-misc__drag_drop_folders_enums", - "stddirtrees-misc__drag_drop_folders_structures", - "stddirtrees-misc__drag_drop_functions_1", - "stddirtrees-misc__drag_drop_functions_2", - "stddirtrees-misc__drag_drop_reordering_enums", - "stddirtrees-misc__drag_drop_reordering_structures", - "stddirtrees-misc__exit_after_sorting_functions", - "stddirtrees-misc__expand_collapse_enums", - "stddirtrees-misc__expand_collapse_imports", - "stddirtrees-misc__expand_collapse_local_types", - "stddirtrees-misc__expand_collapse_names", - "stddirtrees-misc__expand_collapse_structures", - "stddirtrees-misc__filter_by_folder_then_jump_out_structures", - "stddirtrees-misc__filter_by_tree_then_jump_out_enums", - "stddirtrees-misc__focus_and_nav_enums", - "stddirtrees-misc__focus_and_nav_structures", - "stddirtrees-misc__folders_sorting_imports", - "stddirtrees-misc__goto_line_fast_enums", - "stddirtrees-misc__goto_line_fast_functions", - "stddirtrees-misc__goto_line_fast_imports", - "stddirtrees-misc__goto_line_fast_local_types", - "stddirtrees-misc__goto_line_fast_names", - "stddirtrees-misc__goto_line_fast_structures", - "stddirtrees-misc__hscrollbar_as_needed_enums", - "stddirtrees-misc__hscrollbar_as_needed_structures", - "stddirtrees-misc__ilfak_s_sequence_2_structures", - "stddirtrees-misc__ilfak_s_sequence_structures", - "stddirtrees-misc__insert_before_current_structures", - "stddirtrees-misc__interr_40799_local_types", - "stddirtrees-misc__interr_40868_local_types", - "stddirtrees-misc__interr_41069_local_types", - "stddirtrees-misc__jump_enums", - "stddirtrees-misc__jump_from_pseudocode_to_local_types", - "stddirtrees-misc__jump_structures", - "stddirtrees-misc__jump_to_pseudocode_from_local_types", - "stddirtrees-misc__local_types_and_structures_delete", - "stddirtrees-misc__local_types_and_structures_delete_all", - "stddirtrees-misc__misc_local_types", - "stddirtrees-misc__move_then_undo_enums", - "stddirtrees-misc__move_then_undo_functions", - "stddirtrees-misc__move_then_undo_imports", - "stddirtrees-misc__move_then_undo_local_types", - "stddirtrees-misc__move_then_undo_local_types_2", - "stddirtrees-misc__move_then_undo_structures", - "stddirtrees-misc__nav_actions_state_enums", - "stddirtrees-misc__nav_actions_state_structures", - "stddirtrees-misc__newfile_imports", - "stddirtrees-misc__no_infinite_scroll_enums", - "stddirtrees-misc__no_infinite_scroll_structures", - "stddirtrees-misc__no_subfolders_jump_enums", - "stddirtrees-misc__no_subfolders_jump_structures", - "stddirtrees-misc__no_subfolders_sorting_enums", - "stddirtrees-misc__no_subfolders_sorting_structures", - "stddirtrees-misc__open_in_folders_columns_sizes_local_types", - "stddirtrees-misc__persisted_state_enums", - "stddirtrees-misc__persisted_state_functions", - "stddirtrees-misc__persisted_state_imports", - "stddirtrees-misc__persisted_state_imports_mangling", - "stddirtrees-misc__persisted_state_imports_mangling_2", - "stddirtrees-misc__persisted_state_local_types", - "stddirtrees-misc__persisted_state_structures", - "stddirtrees-misc__programmatically_add_folder_enums", - "stddirtrees-misc__programmatically_add_folder_local_types", - "stddirtrees-misc__programmatically_add_folder_structures", - "stddirtrees-misc__quick_filter_enums", - "stddirtrees-misc__quick_filter_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "stddirtrees-misc__rename_enums", - "stddirtrees-misc__rename_imports", - "stddirtrees-misc__rename_local_types", - "stddirtrees-misc__rename_shortcut_local_types", - "stddirtrees-misc__rename_structures", - "stddirtrees-misc__search_enums", - "stddirtrees-misc__search_fast_enums", - "stddirtrees-misc__search_fast_functions_1", - "stddirtrees-misc__search_fast_functions_2", - "stddirtrees-misc__search_fast_functions_3", - "stddirtrees-misc__search_fast_functions_4", - "stddirtrees-misc__search_fast_functions_5", - "stddirtrees-misc__search_fast_functions_6", - "stddirtrees-misc__search_fast_imports", - "stddirtrees-misc__search_fast_local_types", - "stddirtrees-misc__search_fast_structures", - "stddirtrees-misc__search_imports", - "stddirtrees-misc__search_local_types", - "stddirtrees-misc__search_structures", - "stddirtrees-misc__selection_filtering_enums", - "stddirtrees-misc__selection_filtering_structures", - "stddirtrees-misc__sorting_enums", - "stddirtrees-misc__sorting_structures", - "stddirtrees-misc__toggle_folders_on_each_column_local_types", - "stddirtrees-misc__undo_status_local_types", - "structs-asm_and_c", - ] - }, - "kernwin.create_empty_widget": { - "return": [ - 'TWidget *', - ], - "tests": [ - "idapython-ui_hooks__desktop_applied", - "plugins-lucid", - ] - }, - "kernwin.create_menu": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__add_menus", - "menus-add_custom", - ] - }, - "kernwin.create_toolbar": { - "return": [ - 'bool', - ], - "tests": [ - "toolbars-add_custom", - ] - }, - "kernwin.custom_viewer_jump": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__jump_from_incompatible_place", - "customidamemo-navigate3__structs", - "idapython-examples__jump_next_comment", - "idapython-examples__save_and_restore_listing_pos_enums", - "idapython-examples__save_and_restore_listing_pos_idaview", - "idapython-examples__save_and_restore_listing_pos_pseudocode", - "idapython-examples__save_and_restore_listing_pos_structs", - "structview-navigate2__custom_viewer_jump", - ] - }, - "kernwin.del_hotkey": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython__add_del_hotkey", - "api-idapython__add_del_hotkey_vs_plugin", - "idapython-examples__add_hotkey", - "idapython-misc2", - ] - }, - "kernwin.del_idc_hotkey": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__add_idc_hotkey", - ] - }, - "kernwin.delete_menu": { - "return": [ - 'bool', - ], - "tests": [ - "menus-add_custom", - ] - }, - "kernwin.delete_toolbar": { - "return": [ - 'bool', - ], - "tests": [ - "toolbars-add_custom", - ] - }, - "kernwin.detach_action_from_menu": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_to_menu", - "api-actions__detach_unexisting_from_menu", - "api-actions__run_edit_menu_populating_script_from_recent_scripts", - ] - }, - "kernwin.detach_action_from_popup": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__permanent_attach_to_popup", - ] - }, - "kernwin.detach_action_from_toolbar": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_to_toolbar", - ] - }, - "kernwin.display_widget": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-ui_hooks__desktop_applied", - "plugins-lucid", - "structview-jump", - ] - }, - "kernwin.ea2str": { - "return": [ - 'str', - ], - "tests": [ - "idapython-misc3", - ] - }, - "kernwin.enable_chooser_item_attrs": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-misc__colorize_chooser", - "idapython-examples__func_chooser_coloring", - ] - }, - "kernwin.execute_sync": { - "return": [ - 'int', - ], - "tests": [ - "frview-scrollbar", - "hexrays-navigate5__open_pseudocode_compat_new_window", - "hexrays-navigate5__open_pseudocode_compat_reuse", - "hexrays-navigate5__open_pseudocode_compat_reuse_active", - "hexrays-navigate5__open_pseudocode_new_window", - "hexrays-navigate5__open_pseudocode_reuse", - "hexrays-navigate5__open_pseudocode_reuse_active", - "idapython-examples__wrap_idaview", - "idapython-execute_sync", - ] - }, - "kernwin.execute_ui_requests": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-uirequests", - ] - }, - "kernwin.find_widget": { - "return": [ - 'NoneType', - 'TWidget *', - ], - "tests": [ - "actions-misc2", - "actions-misc4", - "console-restore", - "customidamemo-highlight4__identifier_nocase", - "customidamemo-highlight4__register_nocase", - "customidamemo-highlight4__regular_nocase", - "customidamemo-navigate3__jump_from_incompatible_place", - "debugger-regviews", - "desktops-misc__compat_old_window_titles", - "docks-close_with_middle_button", - "eaview-sync_pseudocode", - "enums-asm_and_c", - "forms-massiveclose", - "frview-resize", - "functions_window-misc__compat_find_widget", - "funstack-navigate", - "gruser-misc__get_graph_viewer", - "gruser-misc__get_graph_viewer_idapython", - "gruser-misc__get_graph_viewer_idaview", - "gruser-misc__node_info", - "grview-grida", - "grview-gruser", - "grview-nodepropsUser", - "grview-on_view_click", - "hexrays-misc3__get_vdui_by_api", - "hexrays-navigate", - "idapython-api__kernwin", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-customidamemo", - "idapython-examples__auto_instantiate_widget_plugin", - "idapython-examples__auto_instantiate_widget_plugin_desktop", - "idapython-examples__dump_extra_comments", - "idapython-examples__inject_command", - "idapython-examples__save_and_restore_listing_pos_enums", - "idapython-examples__save_and_restore_listing_pos_idaview", - "idapython-examples__save_and_restore_listing_pos_pseudocode", - "idapython-examples__save_and_restore_listing_pos_structs", - "idapython-examples__show_selected_using_get_chooser_data", - "idapython-examples__show_selected_using_get_strlist_item", - "miniview-close", - "miniview-tracefile_node_colors", - "plugins-hexrayspytools", - "plugins-lucid", - "pyqt-qabstractitemdelegate", - "pyqt-raw_widgets_in_tree", - "squishutils-drag", - "stddirtrees-misc__actions_on_selection_local_types", - "stddirtrees-misc__bad_delete_all_structures", - "stddirtrees-misc__basic_enums", - "stddirtrees-misc__basic_structures", - "stddirtrees-misc__basic_undo_steps_imports", - "stddirtrees-misc__basic_undo_steps_imports_2", - "stddirtrees-misc__complex_filters_enums", - "stddirtrees-misc__complex_filters_structures", - "stddirtrees-misc__create_with_selection_enums", - "stddirtrees-misc__create_with_selection_structures", - "stddirtrees-misc__cut_and_paste_enums", - "stddirtrees-misc__cut_and_paste_functions", - "stddirtrees-misc__cut_and_paste_imports", - "stddirtrees-misc__cut_and_paste_local_types", - "stddirtrees-misc__cut_and_paste_names", - "stddirtrees-misc__cut_and_paste_structures", - "stddirtrees-misc__debugging_functions", - "stddirtrees-misc__debugging_imports", - "stddirtrees-misc__delete_folder_enums", - "stddirtrees-misc__delete_folder_local_types", - "stddirtrees-misc__delete_folder_names", - "stddirtrees-misc__delete_folder_structures", - "stddirtrees-misc__delete_listing_selection_enums", - "stddirtrees-misc__delete_listing_selection_structures", - "stddirtrees-misc__delete_root_enums", - "stddirtrees-misc__delete_root_local_types", - "stddirtrees-misc__delete_root_structures", - "stddirtrees-misc__delete_undo_delete_again_enums", - "stddirtrees-misc__drag_drop_folders_enums", - "stddirtrees-misc__drag_drop_folders_structures", - "stddirtrees-misc__drag_drop_functions_1", - "stddirtrees-misc__drag_drop_functions_2", - "stddirtrees-misc__drag_drop_reordering_enums", - "stddirtrees-misc__drag_drop_reordering_structures", - "stddirtrees-misc__exit_after_sorting_functions", - "stddirtrees-misc__expand_collapse_enums", - "stddirtrees-misc__expand_collapse_imports", - "stddirtrees-misc__expand_collapse_local_types", - "stddirtrees-misc__expand_collapse_names", - "stddirtrees-misc__expand_collapse_structures", - "stddirtrees-misc__filter_by_folder_then_jump_out_structures", - "stddirtrees-misc__filter_by_tree_then_jump_out_enums", - "stddirtrees-misc__focus_and_nav_enums", - "stddirtrees-misc__focus_and_nav_structures", - "stddirtrees-misc__folders_sorting_imports", - "stddirtrees-misc__goto_line_fast_enums", - "stddirtrees-misc__goto_line_fast_functions", - "stddirtrees-misc__goto_line_fast_imports", - "stddirtrees-misc__goto_line_fast_local_types", - "stddirtrees-misc__goto_line_fast_names", - "stddirtrees-misc__goto_line_fast_structures", - "stddirtrees-misc__hscrollbar_as_needed_enums", - "stddirtrees-misc__hscrollbar_as_needed_structures", - "stddirtrees-misc__ilfak_s_sequence_2_structures", - "stddirtrees-misc__ilfak_s_sequence_structures", - "stddirtrees-misc__insert_before_current_structures", - "stddirtrees-misc__interr_40799_local_types", - "stddirtrees-misc__interr_40868_local_types", - "stddirtrees-misc__interr_41069_local_types", - "stddirtrees-misc__jump_enums", - "stddirtrees-misc__jump_from_pseudocode_to_local_types", - "stddirtrees-misc__jump_structures", - "stddirtrees-misc__jump_to_pseudocode_from_local_types", - "stddirtrees-misc__local_types_and_structures_delete", - "stddirtrees-misc__local_types_and_structures_delete_all", - "stddirtrees-misc__misc_local_types", - "stddirtrees-misc__move_then_undo_enums", - "stddirtrees-misc__move_then_undo_functions", - "stddirtrees-misc__move_then_undo_imports", - "stddirtrees-misc__move_then_undo_local_types", - "stddirtrees-misc__move_then_undo_local_types_2", - "stddirtrees-misc__move_then_undo_structures", - "stddirtrees-misc__nav_actions_state_enums", - "stddirtrees-misc__nav_actions_state_structures", - "stddirtrees-misc__newfile_imports", - "stddirtrees-misc__no_infinite_scroll_enums", - "stddirtrees-misc__no_infinite_scroll_structures", - "stddirtrees-misc__no_subfolders_jump_enums", - "stddirtrees-misc__no_subfolders_jump_structures", - "stddirtrees-misc__no_subfolders_sorting_enums", - "stddirtrees-misc__no_subfolders_sorting_structures", - "stddirtrees-misc__open_in_folders_columns_sizes_local_types", - "stddirtrees-misc__persisted_state_enums", - "stddirtrees-misc__persisted_state_functions", - "stddirtrees-misc__persisted_state_imports", - "stddirtrees-misc__persisted_state_imports_mangling", - "stddirtrees-misc__persisted_state_imports_mangling_2", - "stddirtrees-misc__persisted_state_local_types", - "stddirtrees-misc__persisted_state_structures", - "stddirtrees-misc__programmatically_add_folder_enums", - "stddirtrees-misc__programmatically_add_folder_local_types", - "stddirtrees-misc__programmatically_add_folder_structures", - "stddirtrees-misc__quick_filter_enums", - "stddirtrees-misc__quick_filter_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "stddirtrees-misc__rename_enums", - "stddirtrees-misc__rename_imports", - "stddirtrees-misc__rename_local_types", - "stddirtrees-misc__rename_shortcut_local_types", - "stddirtrees-misc__rename_structures", - "stddirtrees-misc__search_enums", - "stddirtrees-misc__search_fast_enums", - "stddirtrees-misc__search_fast_functions_1", - "stddirtrees-misc__search_fast_functions_2", - "stddirtrees-misc__search_fast_functions_3", - "stddirtrees-misc__search_fast_functions_4", - "stddirtrees-misc__search_fast_functions_5", - "stddirtrees-misc__search_fast_functions_6", - "stddirtrees-misc__search_fast_imports", - "stddirtrees-misc__search_fast_local_types", - "stddirtrees-misc__search_fast_structures", - "stddirtrees-misc__search_imports", - "stddirtrees-misc__search_local_types", - "stddirtrees-misc__search_structures", - "stddirtrees-misc__selection_filtering_enums", - "stddirtrees-misc__selection_filtering_structures", - "stddirtrees-misc__sorting_enums", - "stddirtrees-misc__sorting_structures", - "stddirtrees-misc__toggle_folders_on_each_column_local_types", - "stddirtrees-misc__undo_status_local_types", - "structs-asm_and_c", - "structview-jump", - ] - }, - "kernwin.free_custom_icon": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - ] - }, - "kernwin.gen_disasm_text": { - "return": [ - 'NoneType', - ], - "tests": [ - "hexrays-misc2", - "idapython-interrupt_long_op", - "idapython-misc", - "tryblocks__big_blob", - ] - }, - "kernwin.get_action_checkable": { - "return": [ - ('bool', 'bool'), - ], - "tests": [ - "api-actions__get_action_attributes", - ] - }, - "kernwin.get_action_checked": { - "return": [ - ('bool', 'bool'), - ], - "tests": [ - "api-actions__get_action_attributes", - ] - }, - "kernwin.get_action_icon": { - "return": [ - ('bool', 'int'), - ], - "tests": [ - "api-actions__get_action_attributes", - ] - }, - "kernwin.get_action_label": { - "return": [ - 'str', - ], - "tests": [ - "api-actions__dump_actions_list", - "api-actions__get_action_attributes", - "plugins-command_palette", - ] - }, - "kernwin.get_action_shortcut": { - "return": [ - 'str', - ], - "tests": [ - "api-actions__dump_actions_list", - "api-actions__get_action_attributes", - "plugins-command_palette", - ] - }, - "kernwin.get_action_state": { - "return": [ - ('bool', 'int'), - ], - "tests": [ - "api-actions__get_action_attributes", - "plugins-command_palette", - ] - }, - "kernwin.get_action_tooltip": { - "return": [ - 'str', - ], - "tests": [ - "api-actions__get_action_attributes", - "plugins-command_palette", - ] - }, - "kernwin.get_action_visibility": { - "return": [ - ('bool', 'bool'), - ], - "tests": [ - "api-actions__get_action_attributes", - ] - }, - "kernwin.get_chooser_data": { - "return": [ - ['str', '...'], - ], - "tests": [ - "chooser-misc__chooser_selection", - "idapython-examples__show_selected_using_get_chooser_data", - ] - }, - "kernwin.get_current_viewer": { - "return": [ - 'TWidget *', - ], - "tests": [ - "bookmarks-basic__enums_selection_after_delete_programmatically", - "bookmarks-basic__idaview_selection_after_delete_programmatically", - "bookmarks-basic__structs_selection_after_delete_programmatically", - "coloredview-highlight", - "customidamemo-highlight", - "customidamemo-homeend", - "customidamemo-navigate3__enums", - "customidamemo-navigate3__structs", - "grview-api", - "grview-contextmenu", - "grview-gruser", - "grview-nodepropsUser", - "grview-rendering", - "idapython-api__kernwin", - "idapython-examples__list_stkvar_xrefs", - "idapython-place", - "idapython-readsel2", - "idapython_hr-hexrays_callback", - "structview-navigate2__custom_viewer_jump", - ] - }, - "kernwin.get_current_widget": { - "return": [ - 'TWidget *', - ], - "tests": [ - "api-actions__permanent_attach_to_chooser_popup", - "api-actions__permanent_attach_to_popup", - "console-actions", - "hexrays-navigate", - "idapython-api__kernwin_dbg", - "idapython-tform_type", - "squishutils-menus", - "tracing-misc", - ] - }, - "kernwin.get_custom_viewer_curline": { - "return": [ - 'str', - ], - "tests": [ - "idapython_hr-examples__vds17", - "idaview-misc__callback_for_click_on_registers", - ] - }, - "kernwin.get_custom_viewer_location": { - "return": [ - 'bool', - ], - "tests": [ - "bookmarks-basic__enums_selection_after_delete_programmatically", - "bookmarks-basic__idaview_selection_after_delete_programmatically", - "bookmarks-basic__structs_selection_after_delete_programmatically", - "customidamemo-navigate3__jump_from_incompatible_place", - "idapython-examples__colorize_pseudocode_lines", - "idapython-examples__jump_next_comment", - "idapython-examples__save_and_restore_listing_pos_enums", - "idapython-examples__save_and_restore_listing_pos_idaview", - "idapython-examples__save_and_restore_listing_pos_pseudocode", - "idapython-examples__save_and_restore_listing_pos_structs", - "structview-navigate2__custom_viewer_jump", - ] - }, - "kernwin.get_custom_viewer_place": { - "return": [ - ('place_t', 'int', 'int'), - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__structs", - "idapython-place", - "idaview-misc__callback_for_click_on_registers", - "plugins-hexlight_2016", - ] - }, - "kernwin.get_highlight": { - "return": [ - 'NoneType', - ('str', 'int'), - ], - "tests": [ - "coloredview-highlight", - "customidamemo-highlight", - "customidamemo-homeend", - "grview-contextmenu", - "grview-gruser", - "idapython-examples__list_stkvar_xrefs", - "idapython-ui_hooks__get_custom_viewer_hint_embedded", - "idapython-ui_hooks__get_custom_viewer_hint_embedded_dbg", - "idapython_hr-hexrays_callback", - ] - }, - "kernwin.get_key_code": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexlight_2016", - ] - }, - "kernwin.get_navband_pixel": { - "return": [ - ('int', 'bool'), - ], - "tests": [ - "navbar-api", - "navbar-paint_over__horizontal", - "navbar-paint_over__vertical", - ] - }, - "kernwin.get_registered_actions": { - "return": [ - ['str', '...'], - ], - "tests": [ - "api-actions__get_registered_actions", - "plugins-command_palette", - ] - }, - "kernwin.get_screen_ea": { - "return": [ - 'int', - ], - "tests": [ - "areas-killcb", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "gruser-misc__get_graph_viewer_idapython", - "idapython-cleanup", - "idapython-examples__bin_search", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__dump_extra_comments", - "idapython-examples__dump_flowchart", - "idapython-examples__dump_func_info", - "idapython-examples__lines_rendering", - "idapython-examples__list_segment_functions", - "idapython-examples__list_segment_functions_using_idautils", - "idapython-examples__list_stkvar_xrefs", - "idapython-ui_hooks__misc", - "idapython-user_graphs", - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - "idapython_hr-decompile", - "idapython_hr-examples__vds1", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds4", - "plugins-lucid", - "screenshots-misc__idapython_snippets", - ] - }, - "kernwin.get_synced_group": { - "return": [ - 'NoneType', - 'synced_group_t', - ], - "tests": [ - "idapython-api__kernwin", - "idapython-api__kernwin_dbg", - ] - }, - "kernwin.get_view_renderer_type": { - "return": [ - 'int', - ], - "tests": [ - "grview-grida", - "idapython-api__kernwin", - "idapython-misc4", - ] - }, - "kernwin.get_viewer_place_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__kernwin", - "idapython-readsel2", - ] - }, - "kernwin.get_viewer_user_data": { - "return": [ - 'NoneType', - 'void *', - ], - "tests": [ - "bookmarks-basic__enums_selection_after_delete_programmatically", - "bookmarks-basic__idaview_selection_after_delete_programmatically", - "bookmarks-basic__structs_selection_after_delete_programmatically", - "idapython-examples__dump_selection", - "idapython-place", - ] - }, - "kernwin.get_widget_title": { - "return": [ - 'str', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "api-actions__attach_to_popup", - "api-actions__chooser_actions", - "api-actions__separators", - "desktops-misc__compat_old_window_titles", - "functions_window-misc__compat_find_widget", - "hexrays-navigate", - "idapython-api__kernwin_dbg", - "idapython-tform", - "idapython-tform_type", - "idapython-ui_hooks__get_custom_viewer_hint_embedded", - "idapython-ui_hooks__get_custom_viewer_hint_embedded_dbg", - "idapython-ui_hooks__misc", - "tracing-misc", - ] - }, - "kernwin.get_widget_type": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__attach_dynamic_action_to_popup", - "api-actions__attach_dynamic_action_to_popup_lifecycle", - "api-actions__attach_same_dynamic_action_twice_to_popup", - "api-actions__attach_to_chooser_popup", - "api-actions__attach_to_embedded_chooser_popup_python", - "console-actions", - "debugger-regviews_actions", - "idapython-examples__registers_context_menu", - "idapython-tform", - "idapython-tform_type", - "idapython_hr-examples__vds8_crash", - "plugins-lucid", - ] - }, - "kernwin.get_window_id": { - "return": [ - 'int', - ], - "tests": [ - "idapython-get_window_id", - ] - }, - "kernwin.hide_wait_box": { - "return": [ - 'NoneType', - ], - "tests": [ - "waitdialog-misc", - "waitdialog-misc2__loadfile_wait_dialog_t", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "kernwin.is_chooser_widget": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-misc__ex_choose", - "desktops-floating_dock__idapython_chooser", - "idapython-api__kernwin", - "squishutils-menus", - ] - }, - "kernwin.jobj_wrapper_t.get_dict": { - "return": [ - 'dict', - ], - "tests": [ - "idapython-ui_hooks__create_desktop_widget_qwidget", - "idapython-ui_hooks__create_desktop_widget_twidget", - ] - }, - "kernwin.jumpto": { - "return": [ - 'bool', - ], - "tests": [ - "grview-api", - "idapython-examples__bin_search", - "idapython-place", - "plugins-hexlight_2016", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - ] - }, - "kernwin.l_compare2": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_selection", - ] - }, - "kernwin.line_rendering_output_entries_refs_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__colorize_pseudocode_lines", - "idapython-examples__lines_rendering", - "plugins-lucid", - ] - }, - "kernwin.linearray_t.down": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__dump_selection", - ] - }, - "kernwin.linearray_t.get_place": { - "return": [ - 'place_t', - ], - "tests": [ - "idapython-examples__dump_selection", - ] - }, - "kernwin.linearray_t.set_place": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__dump_selection", - ] - }, - "kernwin.load_custom_icon": { - "return": [ - 'int', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_python", - "idapython-example_add_menu_item", - ] - }, - "kernwin.lookup_key_code": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexlight_2016", - ] - }, - "kernwin.msg_clear": { - "return": [ - 'NoneType', - ], - "tests": [ - "mainmsglist-misc__API", - ] - }, - "kernwin.msg_get_lines": { - "return": [ - ['str', '...'], - ], - "tests": [ - "mainmsglist-misc__API", - ] - }, - "kernwin.msg_save": { - "return": [ - 'bool', - ], - "tests": [ - "mainmsglist-misc__API", - ] - }, - "kernwin.open_disasm_window": { - "return": [ - 'TWidget *', - ], - "tests": [ - "idapython-misc4", - ] - }, - "kernwin.open_form": { - "return": [ - 'int', - ], - "tests": [ - "idapython-askusingform__direct_call", - "idapython-askusingform__open_form", - "idapython-askusingform__open_form_minimal", - "idapython-plugin_form__open_at_WOPN_DP_BOTTOM", - ] - }, - "kernwin.open_navband_window": { - "return": [ - 'TWidget *', - ], - "tests": [ - "navbar-paint_over__horizontal", - "navbar-paint_over__vertical", - ] - }, - "kernwin.open_strings_window": { - "return": [ - 'TWidget *', - ], - "tests": [ - "idapython-examples__show_selected_using_get_chooser_data", - "idapython-examples__show_selected_using_get_strlist_item", - ] - }, - "kernwin.place_t.as_enumplace_t": { - "return": [ - 'enumplace_t', - ], - "tests": [ - "idapython-readsel2", - ] - }, - "kernwin.place_t.as_idaplace_t": { - "return": [ - 'idaplace_t', - ], - "tests": [ - "idapython-readsel2", - ] - }, - "kernwin.place_t.as_simpleline_place_t": { - "return": [ - 'NoneType', - 'simpleline_place_t', - ], - "tests": [ - "idapython-api__kernwin", - "idapython-examples__colorize_pseudocode_lines", - "idapython-place", - ] - }, - "kernwin.place_t.as_structplace_t": { - "return": [ - 'structplace_t', - ], - "tests": [ - "idapython-readsel2", - "structview-navigate2__custom_viewer_jump", - ] - }, - "kernwin.place_t.clone": { - "return": [ - 'place_t', - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__jump_from_incompatible_place", - "customidamemo-navigate3__structs", - "idapython-place", - "plugins-hexlight_2016", - ] - }, - "kernwin.place_t.deserialize": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__structs", - ] - }, - "kernwin.place_t.generate": { - "return": [ - (['str', '...'], 'int', 'int', 'int'), - ], - "tests": [ - "idapython-place", - ] - }, - "kernwin.place_t.serialize": { - "return": [ - 'bytes', - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__structs", - ] - }, - "kernwin.place_t.toea": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-navigate3__jump_from_incompatible_place", - "idapython-examples__lines_rendering", - "idapython-ui_hooks__misc", - ] - }, - "kernwin.place_t_as_idaplace_t": { - "return": [ - 'idaplace_t', - ], - "tests": [ - "idapython-examples__jump_next_comment", - ] - }, - "kernwin.place_t_as_simpleline_place_t": { - "return": [ - 'simpleline_place_t', - ], - "tests": [ - "plugins-hexlight_2016", - "plugins-lucid", - ] - }, - "kernwin.process_ui_action": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_dynamic_action_to_popup", - "api-actions__attach_dynamic_action_to_popup_lifecycle", - "api-actions__buggy_handler", - "api-actions__register_unregister", - "api-actions__register_unregister_lifecycle", - "api-actions__run_plugin_check_actions_disappeared", - "console-cli", - "idapython-examples__inject_command", - "idapython-idp_hooks2__coagulate_dref", - "idapython-uirequests", - "plugins-command_palette", - "telemetry-misc__basic", - ] - }, - "kernwin.quick_widget_commands_t.add": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython_nocompat_695__ida_graph", - "api-idapython_nocompat_695__ida_kernwin", - ] - }, - "kernwin.quick_widget_commands_t.populate_popup": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__chooser_actions", - "api-idapython_nocompat_695__ida_graph", - "api-idapython_nocompat_695__ida_kernwin", - "chooser-actions__action_destroys_chooser", - "chooser-actions__actions_availability", - "chooser-columns__20_columns", - "chooser-columns__hidden_by_default", - "chooser-columns__hide_all", - "chooser-columns__persistence_in_idb", - "chooser-columns__persistence_in_session", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-misc__ex_choose", - "gruser-misc__check_grouping_without_callback", - "grview-gruser", - "squishutils-menus", - ] - }, - "kernwin.read_range_selection": { - "return": [ - ('bool', 'int', 'int'), - ], - "tests": [ - "idapython-read_selection_64", - "idapython_hr-examples__modified_vds13_twice", - "idapython_hr-examples__vds13", - ] - }, - "kernwin.read_selection": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__kernwin", - "idapython-readsel2", - ] - }, - "kernwin.refresh_chooser": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-misc__colorize_chooser", - "chooser-misc__refresh_and_check_selection", - "squishutils-menus", - ] - }, - "kernwin.refresh_custom_viewer": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__colorize_pseudocode_lines", - ] - }, - "kernwin.refresh_idaview": { - "return": [ - 'NoneType', - ], - "tests": [ - "chooser-misc__refresh_and_check_selection", - ] - }, - "kernwin.refresh_idaview_anyway": { - "return": [ - 'NoneType', - ], - "tests": [ - "customidamemo-nav_i18n__colors_flat", - "customidamemo-nav_i18n__colors_graph", - "customidamemo-nav_i18n__end_of_line_flat", - "customidamemo-nav_i18n__end_of_line_graph", - "customidamemo-nav_i18n__enter_on_address_after_large_chars", - "customidamemo-nav_i18n__move_left_right_on_large_chars", - "customidamemo-nav_i18n__move_right_to_the_end_of_line_flat", - "customidamemo-nav_i18n__move_word_left_right_on_large_chars", - "customidamemo-nav_i18n__set_cursor_by_mouse", - "customidamemo-nav_i18n__set_cursor_by_mouse_graph", - "grview-copyToClipboard__debugger", - "grview-copyToClipboard__debugger_noprefix_graph", - "grview-copyToClipboard__programmatic", - "grview-non_displayable_node", - "i18n-produce_file", - "idapython-examples__lines_rendering", - "idapython-misc2", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-switch_info", - "idapython_hr-decompile", - "idapython_hr-plugin_hexlit", - "idaview-misc__tryblocks", - "plugins-hexlight_2016", - "plugins-lucid", - "structs-xrefs", - ] - }, - "kernwin.refresh_navband": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc", - ] - }, - "kernwin.register_addon": { - "return": [ - 'int', - ], - "tests": [ - "plugins-command_palette", - "plugins-hexlight_2016", - ] - }, - "kernwin.register_timer": { - "return": [ - 'PyCapsule', - ], - "tests": [ - "gruser-stress", - "idapython-examples__register_timer", - "idapython-timers", - "idapython-waitdialog", - ] - }, - "kernwin.replace_wait_box": { - "return": [ - 'NoneType', - ], - "tests": [ - "waitdialog-misc", - "waitdialog-misc2__loadfile_wait_dialog_t", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "kernwin.restore_database_snapshot": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-snapshots", - ] - }, - "kernwin.set_dock_pos": { - "return": [ - 'bool', - ], - "tests": [ - "actions-misc", - "address_details-misc__desktop", - "bookmarks-basic__enums", - "bookmarks-basic__enums_add_refresh", - "bookmarks-basic__enums_add_to_folder", - "bookmarks-basic__enums_edit_through_tree", - "bookmarks-basic__enums_hints", - "bookmarks-basic__enums_open_and_jump", - "bookmarks-basic__enums_open_empty_then_add", - "bookmarks-basic__enums_selection_after_delete", - "bookmarks-basic__enums_selection_after_delete_programmatically", - "bookmarks-basic__hexview_add_refresh", - "bookmarks-basic__hexview_add_to_folder", - "bookmarks-basic__hexview_edit_through_tree", - "bookmarks-basic__hexview_hints", - "bookmarks-basic__hexview_open_and_jump", - "bookmarks-basic__hexview_open_empty_then_add", - "bookmarks-basic__hexview_selection_after_delete", - "bookmarks-basic__idaview", - "bookmarks-basic__idaview_add_refresh", - "bookmarks-basic__idaview_add_to_folder", - "bookmarks-basic__idaview_adding_bookmark_opens_then_selects", - "bookmarks-basic__idaview_edit_through_tree", - "bookmarks-basic__idaview_hints", - "bookmarks-basic__idaview_jump_browse_bookmarks_no_focus_transfer", - "bookmarks-basic__idaview_open_and_jump", - "bookmarks-basic__idaview_open_empty_then_add", - "bookmarks-basic__idaview_selection_after_delete", - "bookmarks-basic__idaview_selection_after_delete_programmatically", - "bookmarks-basic__structs", - "bookmarks-basic__structs_add_refresh", - "bookmarks-basic__structs_add_to_folder", - "bookmarks-basic__structs_edit_through_tree", - "bookmarks-basic__structs_hints", - "bookmarks-basic__structs_open_and_jump", - "bookmarks-basic__structs_open_empty_then_add", - "bookmarks-basic__structs_selection_after_delete", - "bookmarks-basic__structs_selection_after_delete_programmatically", - "bookmarks-misc__broken_bookmarks", - "bookmarks-misc__create_from_listing_while_in_folder", - "bookmarks-misc__delete_from_modal", - "bookmarks-misc__desktop", - "bookmarks-misc__jumping", - "bookmarks-misc__non_modal_lifecycle", - "bookmarks-misc__rendering", - "bookmarks-misc__same_desc", - "bookmarks-misc__toggle_from_arrows", - "chooser-columns__hide_columns", - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "chooser-misc2__reinit_after_search", - "chooser-misc2__sort_CHCOL_DEC", - "chooser-misc__colorize_chooser", - "chooser-misc__enter_and_double_click_call_callback", - "chooser-misc__selection_changed_called_and_colors_considered", - "chooser-search_and_keys", - "coloredview-basic", - "console-cli", - "customidamemo-sync", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-breakpoints", - "debugger-dwarf_shared_elf", - "debugger-misc4__bpt_hit_selects_bpt", - "debugger-regviews_actions", - "debugger-regviews_actions2__modify", - "debugger-regviews_colors", - "desktops-icons_and_titles__debugger", - "desktops-icons_and_titles__normal", - "desktops-load_save__save_default", - "desktops-misc__restore_positions", - "docks-close_persistent", - "docks-close_splitter_in_last_tab_position", - "docks-complex_docks", - "docks-dock_btns", - "docks-empty_areas", - "docks-floating_tabs", - "docks-hidden__hsplitter_in_floating_area", - "docks-hidden__hsplitter_in_hsplitter", - "docks-hidden__hsplitter_in_vsplitter", - "docks-hidden__tabs_in_floating_area", - "docks-hidden__tabs_in_hsplitter", - "docks-hidden__tabs_in_vsplitter", - "docks-hidden__vsplitter_in_floating_area", - "docks-hidden__vsplitter_in_hsplitter", - "docks-hidden__vsplitter_in_vsplitter", - "docks-hint_mode", - "docks-massive_docking", - "docks-misc2__re_tabify", - "docks-misc2__set_dock_pos_using_size_hint", - "docks-misc2__set_dock_pos_using_size_hint_toplevel", - "docks-root_widget_always_visible", - "docks-set_dock_pos_empty_dst", - "docks-show_existent", - "docks-sizes", - "docks-toggle_splitter_rightmost_dock__within_tab", - "docks-toggle_splitter_rightmost_dock__without_tab", - "docks-two_areas", - "eaview-navigate", - "eaview-patch_bytes__chooser_multi", - "eaview-sync", - "eaview-sync_pseudocode", - "eaview-sync_reg", - "fonts-basic__debugger_widgets", - "fonts-basic__regular_widgets", - "forms-massiveclose", - "frview-markPos", - "frview-scrollbar", - "functions_window-misc__hiding_or_unhiding_doesnt_trigger_refresh", - "gruser-misc__check_onactivate", - "gruser-misc__edge_hints", - "gruser-misc__node_hints", - "gruser-stress", - "grview-rendering", - "grview-testgraph", - "hexrays-navigate5__modify_struct_no_refresh", - "hexrays-refresh_crash__refresh", - "hexview-longbytes", - "hexview-stats_hidden", - "hexview-sync_base", - "hexview-sync_base_newfile", - "i18n-basic", - "idapython-cleanup", - "idapython-customidamemo", - "idapython-examples__registers_context_menu", - "idapython-get_window_id", - "idapython-tform_type", - "idapython-ui_hooks__create_desktop_widget_pluginform", - "idapython-ui_hooks__desktop_applied", - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-examples__modified_vds13_twice", - "idaview-hide_unhide", - "lumina-view_and_apply_metadata", - "mainmsglist-misc__colors", - "mainmsglist-misc__double_click_addresses", - "mainmsglist-misc__double_click_addresses_space", - "mainmsglist-misc__double_click_ids", - "mainmsglist-misc__lines_shown_in_full", - "merge-misc__basic_frame", - "merge-misc__basic_idaview", - "merge-misc__navigate_regions_idaview", - "miniview-current_node", - "miniview-docks", - "miniview-node_buttons", - "miniview-pull_out", - "miniview-tracefile_node_colors", - "plugins-lucid", - "pyqt-tform2", - "screenshots-misc__idapython_snippets", - "scriptsnippets-debugger", - "scriptsnippets-inherit_cli", - "scriptsnippets-misc2__clone", - "scriptsnippets-misc2__clone_reload", - "scriptsnippets-misc2__line_separator", - "scriptsnippets-misc2__typing_text_doesnt_refresh_list", - "scriptsnippets-misc2__typing_text_doesnt_refresh_sorted_list", - "scriptsnippets-misc2__unicode", - "scriptsnippets-misc__debugger", - "segregs-misc__delete_refreshes_view", - "snippets-insert", - "squishutils-menus", - "squishutils-sizer", - "srcdbg-bitfields", - "srcdbg-dwarf_misc__gcc_bool", - "srcdbg-hints", - "srcdbg-idaq_locals", - "srcdbg-reload_dll", - "srcdbg-watch_mem", - "srcdbg-watch_reg", - "stddirtrees-misc__local_types_and_structures_delete", - "stddirtrees-misc__local_types_and_structures_delete_all", - "stddirtrees-misc__nav_actions_state_enums", - "stddirtrees-misc__nav_actions_state_structures", - "stddirtrees-misc__rebase_enums", - "stddirtrees-misc__rebase_functions", - "stddirtrees-misc__rebase_imports", - "stddirtrees-misc__rebase_names", - "stddirtrees-misc__rebase_structures", - "structview-jump", - "stylesheets-envvar", - "textarrows-misc__debugger_no_infinite_loop", - "textedit-misc__restored", - "tracing-misc2__no_interference", - "typeeditor-misc__cancel_edit", - "undo-misc__restored_on_desktop_reload", - "undo-misc__undo_history_reset_on_new_idb", - "undo-widgets__snippets", - "waitdialog-misc", - "watchlist-misc__update_on_rename", - ] - }, - "kernwin.set_highlight": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-highlight", - "customidamemo-highlight4__identifier_nocase", - "customidamemo-highlight4__register_nocase", - "customidamemo-highlight4__regular_nocase", - "grview-nodepropsUser", - ] - }, - "kernwin.set_nav_colorizer": { - "return": [ - 'NoneType', - 'dict', - ], - "tests": [ - "idapython-misc", - ] - }, - "kernwin.set_view_renderer_type": { - "return": [ - 'NoneType', - ], - "tests": [ - "grview-grida", - "idapython-api__kernwin", - "idapython-examples__wrap_idaview", - "idapython-misc4", - ] - }, - "kernwin.show_wait_box": { - "return": [ - 'NoneType', - ], - "tests": [ - "waitdialog-misc", - "waitdialog-misc2__loadfile_wait_dialog_t", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "kernwin.simplecustviewer_t.AddLine": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "idapython-custom_viewer", - "idapython-examples__auto_instantiate_widget_plugin", - "idapython-examples__auto_instantiate_widget_plugin_desktop", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython_hr-examples__modified_vds13_twice", - "plugins-lucid", - "training-test__AsmViewer_py", - ] - }, - "kernwin.simplecustviewer_t.ClearLines": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-lucid", - "training-test__AsmViewer_py", - ] - }, - "kernwin.simplecustviewer_t.Close": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-custom_viewer", - "training-test__AsmViewer_py", - ] - }, - "kernwin.simplecustviewer_t.Create": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "idapython-api__kernwin", - "idapython-custom_viewer", - "idapython-examples__auto_instantiate_widget_plugin", - "idapython-examples__auto_instantiate_widget_plugin_desktop", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython_hr-examples__modified_vds13_twice", - "plugins-lucid", - "training-test__AsmViewer_py", - ] - }, - "kernwin.simplecustviewer_t.EditLine": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-custom_viewer", - ] - }, - "kernwin.simplecustviewer_t.GetCurrentLine": { - "return": [ - 'str', - ], - "tests": [ - "idapython-custom_viewer", - ] - }, - "kernwin.simplecustviewer_t.GetLineNo": { - "return": [ - 'int', - ], - "tests": [ - "idapython-custom_viewer", - ] - }, - "kernwin.simplecustviewer_t.GetPos": { - "return": [ - ('int', 'int', 'int'), - ], - "tests": [ - "idapython-custom_viewer", - ] - }, - "kernwin.simplecustviewer_t.GetWidget": { - "return": [ - 'NoneType', - 'TWidget *', - ], - "tests": [ - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "idapython-api__kernwin", - "idapython-custom_viewer", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-ui_hooks__create_desktop_widget_twidget", - "plugins-lucid", - "training-test__AsmViewer_py", - ] - }, - "kernwin.simplecustviewer_t.Jump": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-lucid", - ] - }, - "kernwin.simplecustviewer_t.RefreshCurrent": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-custom_viewer", - ] - }, - "kernwin.simplecustviewer_t.Show": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "idapython-api__kernwin", - "idapython-custom_viewer", - "idapython-examples__auto_instantiate_widget_plugin", - "idapython-examples__auto_instantiate_widget_plugin_desktop", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython_hr-examples__modified_vds13_twice", - "training-test__AsmViewer_py", - ] - }, - "kernwin.str2user": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__pro", - "idapython-examples__create_structure_programmatically", - "idapython-misc", - "idapython-switch_info", - "ppc-analysis_options", - "structs-asm_and_c", - "structs-create", - ] - }, - "kernwin.sync_source_t.get_register": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__kernwin_dbg", - ] - }, - "kernwin.sync_source_t.get_widget": { - "return": [ - 'TWidget *', - ], - "tests": [ - "idapython-api__kernwin", - "idapython-api__kernwin_dbg", - ] - }, - "kernwin.sync_source_t.is_widget": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__kernwin", - "idapython-api__kernwin_dbg", - ] - }, - "kernwin.take_database_snapshot": { - "return": [ - ('bool', 'NoneType'), - ], - "tests": [ - "idapython-snapshots", - ] - }, - "kernwin.twinpos_t.place": { - "return": [ - 'NoneType', - 'enumplace_t', - 'idaplace_t', - 'structplace_t', - ], - "tests": [ - "idapython-api__kernwin", - "idapython-readsel2", - ] - }, - "kernwin.twinpos_t.place_as_enumplace_t": { - "return": [ - 'enumplace_t', - ], - "tests": [ - "idapython-readsel2", - ] - }, - "kernwin.twinpos_t.place_as_idaplace_t": { - "return": [ - 'idaplace_t', - ], - "tests": [ - "idapython-readsel2", - ] - }, - "kernwin.twinpos_t.place_as_simpleline_place_t": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__kernwin", - ] - }, - "kernwin.twinpos_t.place_as_structplace_t": { - "return": [ - 'structplace_t', - ], - "tests": [ - "idapython-readsel2", - ] - }, - "kernwin.unregister_action": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__get_registered_actions", - "api-actions__register_unregister", - "api-actions__register_unregister_lifecycle", - "api-actions__run_plugin_check_actions_disappeared", - "api-actions__unregister_core_actions", - "chooser-misc__chooser_selection", - "chooser-misc__ex_choose", - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "debugger-regviews_actions", - "desktops-floating_dock__idapython_chooser", - "idapython-api__kernwin", - "idapython-custom_viewer", - "idapython-example_add_menu_item", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-examples__dump_extra_comments", - "idapython-examples__dump_selection", - "idapython-examples__jump_next_comment", - "idapython-examples__save_and_restore_listing_pos_enums", - "idapython-examples__save_and_restore_listing_pos_idaview", - "idapython-examples__save_and_restore_listing_pos_pseudocode", - "idapython-examples__save_and_restore_listing_pos_structs", - "idapython-examples__show_selected_using_get_chooser_data", - "idapython-examples__show_selected_using_get_strlist_item", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython_hr-ctree_visitor__force_all_calls", - "plugins-command_palette", - "plugins-hexrayspytools", - "plugins-lucid", - ] - }, - "kernwin.unregister_timer": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-timers", - "idapython-waitdialog", - ] - }, - "kernwin.update_action_checkable": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__get_action_attributes", - ] - }, - "kernwin.update_action_checked": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__get_action_attributes", - ] - }, - "kernwin.update_action_icon": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__update_action", - ] - }, - "kernwin.update_action_label": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__update_action", - ] - }, - "kernwin.update_action_shortcut": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__update_action", - ] - }, - "kernwin.update_action_tooltip": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__update_action", - ] - }, - "kernwin.update_action_visibility": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__update_action", - ] - }, - "kernwin.user_cancelled": { - "return": [ - 'bool', - ], - "tests": [ - "waitdialog-misc2__loadfile_wait_dialog_t", - "waitdialog-misc2__loadfile_wait_dialog_t_with_decompilation", - "waitdialog-misc2__wait_dialog_t", - "waitdialog-misc2__wait_dialog_t_with_decompilation", - ] - }, - "kernwin.warning": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-actions__register_with_hotkey", - "api-actions__register_with_shortcut", - "idapython_hr-examples__vds12", - "idapython_hr-examples__vds13", - "idapython_hr-examples__vds21", - "squishutils-shortcuts", - ] - }, - "lines.COLSTR": { - "return": [ - 'str', - ], - "tests": [ - "customidamemo-search", - "customidamemo-search_all__custom_viewer", - "idapython-custom_viewer", - "idapython-examples__custview", - "idapython-examples__custview_nodelref", - "idapython-idp_hooks2__gen_regvar_def", - "idapython-ui_hooks__create_desktop_widget_twidget", - "idapython_hr-hexrays_hooks__create_hint2", - "training-test__AsmViewer_py", - ] - }, - "lines.add_sourcefile": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks2__gen_src_file_lnnum", - ] - }, - "lines.del_extra_cmt": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-extra_cmt", - ] - }, - "lines.generate_disasm_line": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__lines", - "idapython-custom_data", - "idapython-custom_data3", - "idapython-examples__automatic_steps", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-processor_module_mem", - "idapython_hr-examples__vds12", - "idapython_hr-hexrays_hooks__create_hint2", - "training-test__FindInstructions_py", - ] - }, - "lines.generate_disassembly": { - "return": [ - ('int', ['str', '...']), - ], - "tests": [ - "idapython-examples__jump_next_comment", - ] - }, - "lines.get_extra_cmt": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-examples__dump_extra_comments", - "idapython-extra_cmt", - "idapython-idb_hooks", - ] - }, - "lines.get_first_free_extra_cmtidx": { - "return": [ - 'int', - ], - "tests": [ - "idapython-extra_cmt", - ] - }, - "lines.set_user_defined_prefix": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__install_user_defined_prefix_compat", - ] - }, - "lines.tag_advance": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds6", - ] - }, - "lines.tag_remove": { - "return": [ - 'str', - ], - "tests": [ - "api-idapython__tag_remove", - "hexrays-misc2", - "idapython-custom_data", - "idapython-custom_data3", - "idapython-custom_fixup", - "idapython-examples__automatic_steps", - "idapython-examples__dump_selection", - "idapython-misc", - "idapython-place", - "idapython-processor_module_mem", - "idapython_hr-decompile", - "idapython_hr-examples__vds1", - "idapython_hr-examples__vds17", - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - "idapython_hr-plugin_hexlit", - "plugins-hexlight_2016", - "plugins-hexrayspytools", - "plugins-lucid", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - "training-test__FindInstructions_py", - "tryblocks__big_blob", - ] - }, - "lines.tag_skipcodes": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-examples__vds6", - ] - }, - "lines.tag_strlen": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython__tag_strlen", - "idapython-examples__jump_next_comment", - "idapython-misc", - ] - }, - "lines.update_extra_cmt": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-extra_cmt", - "idapython-idb_hooks", - ] - }, - "loader.base2file": { - "return": [ - 'int', - ], - "tests": [ - "idapython-base2file", - "idapython-savefile", - ] - }, - "loader.build_snapshot_tree": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-snapshots", - ] - }, - "loader.extract_module_from_archive": { - "return": [ - ('NoneType', 'NoneType'), - ('str', 'str'), - ], - "tests": [ - "idapython-api__loader", - ] - }, - "loader.file2base": { - "return": [ - 'int', - ], - "tests": [ - "idapython-base2file", - "idapython-misc3", - ] - }, - "loader.gen_file": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__produce_lst_file", - ] - }, - "loader.get_file_type_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-execute_sync", - ] - }, - "loader.get_path": { - "return": [ - 'str', - ], - "tests": [ - "i18n-files", - "idapython-examples__produce_c_file", - "idapython-examples__produce_lst_file", - "idapython-misc", - ] - }, - "loader.load_and_run_plugin": { - "return": [ - 'bool', - ], - "tests": [ - "api-actions__attach_to_embedded_chooser_popup_cpp_plugin", - "api-actions__run_plugin_check_actions_disappeared", - "customidamemo-sync", - "forms-open", - "grview-gruser_centernode", - "grview-testgraph", - "i18n-basic", - "idapython-misc5__test_evalpython", - "idapython-plugin__misc", - "idapython-plugin_alternative_path__load_and_run_plugin", - "idapython-ui_hooks__misc", - "idapython_hr-examples__vds10", - "idapython_hr-examples__vds11", - "idapython_hr-examples__vds19", - "objc-deleted_segms", - "plugins-comhelper__activate_plugin", - "plugins-comhelper__plugin_after_reload", - "plugins-interr_1827", - "plugins-navcolor__72", - "plugins-navcolor__current", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "loader.load_plugin": { - "return": [ - 'NoneType', - 'PyCapsule', - ], - "tests": [ - "dbg_restore_snapshot", - "idapython-misc2", - "idapython-plugin_alternative_path__load_plugin", - ] - }, - "loader.save_database": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - ] - }, - "lumina.calc_func_metadata": { - "return": [ - ('int', 'bytes'), - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "lumina.create_simple_idb_diff_handler": { - "return": [ - 'simple_idb_diff_handler_t', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "lumina.diff_metadata": { - "return": [ - 'bool', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "lumina.extract_frame_desc_from_metadata": { - "return": [ - 'NoneType', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "lumina.extract_insn_cmts_from_metadata": { - "return": [ - 'NoneType', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "lumina.extract_type_from_metadata": { - "return": [ - 'bool', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "lumina.get_server_connection": { - "return": [ - 'lumina_client_t', - ], - "tests": [ - "lumina-update__do_not_override", - "lumina-update__merge", - "lumina-update__override", - "lumina-update__override_if_better", - "lumina-update__override_leaves_addr_untouched", - ] - }, - "lumina.lumina_client_t.push_md": { - "return": [ - 'bool', - ], - "tests": [ - "lumina-update__do_not_override", - "lumina-update__merge", - "lumina-update__override", - "lumina-update__override_if_better", - "lumina-update__override_leaves_addr_untouched", - ] - }, - "lumina.score_metadata": { - "return": [ - 'int', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "lumina.split_metadata": { - "return": [ - 'dict', - ], - "tests": [ - "lumina-view_and_apply_metadata", - ] - }, - "moves.bookmarks_t.erase": { - "return": [ - 'bool', - ], - "tests": [ - "bookmarks-basic__enums_selection_after_delete_programmatically", - "bookmarks-basic__idaview_selection_after_delete_programmatically", - "bookmarks-basic__structs_selection_after_delete_programmatically", - ] - }, - "moves.lochist_entry_t.acquire_place": { - "return": [ - 'NoneType', - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__structs", - "structview-navigate2__custom_viewer_jump", - ] - }, - "moves.lochist_entry_t.place": { - "return": [ - 'place_t', - ], - "tests": [ - "customidamemo-navigate3__jump_from_incompatible_place", - "idapython-examples__colorize_pseudocode_lines", - "idapython-examples__jump_next_comment", - "structview-navigate2__custom_viewer_jump", - ] - }, - "moves.lochist_entry_t.renderer_info": { - "return": [ - 'renderer_info_t', - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__structs", - "gruser-misc__get_graph_viewer_idapython", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__jump_next_comment", - "idapython-user_graphs", - ] - }, - "moves.lochist_entry_t.set_place": { - "return": [ - 'NoneType', - ], - "tests": [ - "customidamemo-navigate3__enums", - "customidamemo-navigate3__jump_from_incompatible_place", - "customidamemo-navigate3__structs", - "idapython-examples__jump_next_comment", - ] - }, - "nalt.add_encoding": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-nav_i18n__colors_flat", - "customidamemo-nav_i18n__colors_graph", - "customidamemo-nav_i18n__end_of_line_flat", - "customidamemo-nav_i18n__end_of_line_graph", - "customidamemo-nav_i18n__enter_on_address_after_large_chars", - "customidamemo-nav_i18n__move_left_right_on_large_chars", - "customidamemo-nav_i18n__move_right_to_the_end_of_line_flat", - "customidamemo-nav_i18n__move_word_left_right_on_large_chars", - "customidamemo-nav_i18n__set_cursor_by_mouse", - "customidamemo-nav_i18n__set_cursor_by_mouse_graph", - "customidamemo-search_bin__patgen_all", - "customidamemo-search_bin__patgen_cp1251", - "customidamemo-search_bin__patgen_defbpu", - "customidamemo-search_bin__patgen_utf32be", - "customidamemo-search_bin__patgen_utf8", - "customidamemo-search_bin__persistedinreg", - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "hexview-basic", - "hexview-edit2__outside_of_token", - "hexview-edit2__set_value_ff_to_undefined_bytes", - "hexview-edit2__text_eol_click_next_line_bytes", - "hexview-edit2__undo", - "hexview-edit2__undo_partial_edit", - "i18n-produce_file", - "i18n-strlits__set_default_strtype_to_specific_termchar", - "strings-misc__min_len", - "strlits-borland", - ] - }, - "nalt.clr_abits": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-execute_sync", - ] - }, - "nalt.del_encoding": { - "return": [ - 'bool', - ], - "tests": [ - "i18n-strlits__delete_encoding", - "i18n-strlits__delete_encoding_using_idapython", - ] - }, - "nalt.del_switch_info": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-switch_info", - ] - }, - "nalt.ea2node": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idb_hooks", - ] - }, - "nalt.enum_import_names": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__list_imports", - "plugins-hexrayspytools", - "training-test__ImpRef_py", - ] - }, - "nalt.get_aflags": { - "return": [ - 'int', - ], - "tests": [ - "dwarf-load_options_fprots", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "nalt.get_alignment": { - "return": [ - 'int', - ], - "tests": [ - "idapython-alignment", - ] - }, - "nalt.get_archive_path": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_default_encoding_idx": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__bin_search", - "idapython-examples__operand_changed", - ] - }, - "nalt.get_encoding_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__operand_changed", - ] - }, - "nalt.get_ida_notepad_text": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_imagebase": { - "return": [ - 'int', - ], - "tests": [ - "eaview-navigate_rebase", - "plugins-hexrayspytools", - ] - }, - "nalt.get_import_module_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__list_imports", - "idapython-import_modules", - "plugins-hexrayspytools", - "training-test__ImpRef_py", - ] - }, - "nalt.get_import_module_qty": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__list_imports", - "idapython-import_modules", - "plugins-hexrayspytools", - "training-test__ImpRef_py", - ] - }, - "nalt.get_initial_ida_version": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_initial_idb_version": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_initial_version": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_item_color": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__colorize_disassembly", - ] - }, - "nalt.get_loader_format_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_op_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds21", - ] - }, - "nalt.get_refinfo": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-custom_fixup", - ] - }, - "nalt.get_srcdbg_paths": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_srcdbg_undesired_paths": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_str_encoding_idx": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__operand_changed", - ] - }, - "nalt.get_strid": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.get_strtype_bpu": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__operand_changed", - ] - }, - "nalt.get_switch_info": { - "return": [ - 'NoneType', - 'switch_info_t', - ], - "tests": [ - "idapython-calc_switch_cases", - "idapython-processor_module_mem", - "idapython-switch_info", - ] - }, - "nalt.get_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "debugger-dwarf_shared_elf", - "idapython-funcs", - "idapython-tinfo_func", - ] - }, - "nalt.make_str_type": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "i18n-strlits__set_default_strtype_to_specific_termchar", - ] - }, - "nalt.retrieve_input_file_md5": { - "return": [ - 'bytes', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.retrieve_input_file_sha256": { - "return": [ - 'bytes', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.set_abits": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-execute_sync", - ] - }, - "nalt.set_alignment": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-alignment", - ] - }, - "nalt.set_archive_path": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.set_default_encoding_idx": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-nav_i18n__colors_flat", - "customidamemo-nav_i18n__colors_graph", - "customidamemo-nav_i18n__end_of_line_flat", - "customidamemo-nav_i18n__end_of_line_graph", - "customidamemo-nav_i18n__enter_on_address_after_large_chars", - "customidamemo-nav_i18n__move_left_right_on_large_chars", - "customidamemo-nav_i18n__move_right_to_the_end_of_line_flat", - "customidamemo-nav_i18n__move_word_left_right_on_large_chars", - "customidamemo-nav_i18n__set_cursor_by_mouse", - "customidamemo-nav_i18n__set_cursor_by_mouse_graph", - "hexview-basic", - "hexview-edit2__outside_of_token", - "hexview-edit2__set_value_ff_to_undefined_bytes", - "hexview-edit2__text_eol_click_next_line_bytes", - "hexview-edit2__undo", - "hexview-edit2__undo_partial_edit", - "i18n-produce_file", - "strings-misc__min_len", - "strlits-borland", - ] - }, - "nalt.set_ida_notepad_text": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.set_item_color": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__colorize_disassembly", - "themes-misc__produce_html", - "training-test__color_to_py", - ] - }, - "nalt.set_loader_format_name": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.set_op_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-ctree_visitor__force_all_calls", - ] - }, - "nalt.set_source_linnum": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-idp_hooks2__gen_src_file_lnnum", - ] - }, - "nalt.set_srcdbg_paths": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.set_srcdbg_undesired_paths": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__nalt", - ] - }, - "nalt.set_switch_info": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-switch_info", - ] - }, - "nalt.set_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_func", - ] - }, - "name.NearestName.find": { - "return": [ - 'NoneType', - ], - "tests": [ - "training-test__CallStackWalk_py", - ] - }, - "name.NearestName.update": { - "return": [ - 'NoneType', - ], - "tests": [ - "training-test__CallStackWalk_py", - ] - }, - "name.append_struct_fields": { - "return": [ - 'int', - ('str', 'int'), - ], - "tests": [ - "structs-members", - ] - }, - "name.del_global_name": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - ] - }, - "name.del_local_name": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - ] - }, - "name.demangle_name": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-idp_hooks", - "idapython-names__compat", - "idapython-names__ida68", - "plugins-hexrayspytools", - ] - }, - "name.extract_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__compat", - ] - }, - "name.get_colored_demangled_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - ] - }, - "name.get_colored_long_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - ] - }, - "name.get_colored_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - ] - }, - "name.get_colored_short_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - ] - }, - "name.get_debug_names": { - "return": [ - 'NoneType', - 'dict', - ], - "tests": [ - "idapython-examples__show_debug_names", - "idapython-modules", - "training-test__CallStackWalk_py", - ] - }, - "name.get_demangled_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__compat", - "idapython-names__ida68", - ] - }, - "name.get_ea_name": { - "return": [ - 'str', - ], - "tests": [ - "grview-jumpto_xref_from_other_tab", - "idapython-appcall_manual__delayed_cleanup", - "idapython-appcall_manual__no_cleanup", - "idapython-appcall_manual__normal", - "idapython-appcall_manual__single_stmt", - "idapython-appcall_manual__single_stmt_delayed_cleanup", - "idapython-appcall_manual__single_stmt_no_cleanup", - "idapython-names__compat", - "idapython-names__ida68", - "xrefview-misc__basic", - "xrefview-misc__generate_add_event", - "xrefview-misc__generate_del_event", - "xrefview-misc__insert_and_check_cursor", - "xrefview-misc__restore_widget", - ] - }, - "name.get_long_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - ] - }, - "name.get_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - "mainmsglist-misc__double_click_ids", - ] - }, - "name.get_name_ea": { - "return": [ - 'int', - ], - "tests": [ - "grview-jumpto_xref", - "hexrays-navigate5__open_pseudocode_compat_new_window", - "hexrays-navigate5__open_pseudocode_compat_reuse", - "hexrays-navigate5__open_pseudocode_compat_reuse_active", - "hexrays-navigate5__open_pseudocode_new_window", - "hexrays-navigate5__open_pseudocode_reuse", - "hexrays-navigate5__open_pseudocode_reuse_active", - "idapython-appcall", - "idapython-breakpoints", - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - "idapython-misc3", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__cfunc_t", - "idapython_hr-base_classes2__mbl_graph_t", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__vc_printer_t", - "idapython_hr-base_classes2__vd_printer_t", - "idapython_hr-examples__vds13", - "training-test__find_mgen_key_py", - ] - }, - "name.get_name_value": { - "return": [ - ('int', 'int'), - ], - "tests": [ - "idapython-names__get_name_value", - ] - }, - "name.get_nice_colored_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - ] - }, - "name.get_nlist_ea": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "name.get_nlist_name": { - "return": [ - 'str', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "name.get_nlist_size": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "name.get_short_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - "plugins-hexrayspytools", - ] - }, - "name.get_visible_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-names__ida68", - ] - }, - "name.is_ident": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "name.set_cp_validity": { - "return": [ - 'NoneType', - ], - "tests": [ - "customidamemo-i18n", - "exportdata-basic", - "mainmsglist-misc__double_click_addresses_space", - ] - }, - "name.set_name": { - "return": [ - 'bool', - ], - "tests": [ - "undo-widgets__recent_scripts", - ] - }, - "netnode.exist": { - "return": [ - 'bool', - ], - "tests": [ - "prview-paths", - ] - }, - "netnode.netnode.altdel": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-dirtree__delete_folder", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__no_tree", - ] - }, - "netnode.netnode.altfirst": { - "return": [ - 'int', - ], - "tests": [ - "prview-paths", - "scriptsnippets-undo__opening_no_undo_point", - "scriptsnippets-undo__undo_after_closing", - ] - }, - "netnode.netnode.altlast": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - ] - }, - "netnode.netnode.altnext": { - "return": [ - 'int', - ], - "tests": [ - "prview-paths", - ] - }, - "netnode.netnode.altset": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - ] - }, - "netnode.netnode.altshift": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__delete_folder", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__no_tree", - ] - }, - "netnode.netnode.altval": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "idapython-misc2", - "scriptsnippets-misc__load_dups", - ] - }, - "netnode.netnode.charval_ea": { - "return": [ - 'int', - ], - "tests": [ - "hexrays-toggle", - ] - }, - "netnode.netnode.get_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-netnode", - "plugins-hexrayspytools", - "prview-paths", - ] - }, - "netnode.netnode.getblob": { - "return": [ - 'NoneType', - 'bytes', - ], - "tests": [ - "idapython-netnode", - "prview-paths", - ] - }, - "netnode.netnode.getclob": { - "return": [ - 'str', - ], - "tests": [ - "notepad-misc", - ] - }, - "netnode.netnode.index": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "netnode.netnode.kill": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-netnode", - ] - }, - "netnode.netnode.setblob": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-netnode", - "idapython_hr-examples__vds3", - "notepad-misc", - ] - }, - "netnode.netnode.supset": { - "return": [ - 'bool', - ], - "tests": [ - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__no_tree", - "chooser-dirtree__rename_folder_full_tree", - "idapython-netnode", - "plugins-hexrayspytools", - "scriptsnippets-misc__load_dups", - ] - }, - "netnode.netnode.supshift": { - "return": [ - 'int', - ], - "tests": [ - "chooser-dirtree__delete_folder", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__no_tree", - ] - }, - "netnode.netnode.supstr": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "chooser-dirtree__basic", - "chooser-dirtree__complex_filters_folders_only_root", - "chooser-dirtree__complex_filters_full_tree_root", - "chooser-dirtree__complex_filters_no_tree_root", - "chooser-dirtree__create_folder_then_insert_then_undo", - "chooser-dirtree__create_folder_with_items", - "chooser-dirtree__delete_folder", - "chooser-dirtree__drag_drop_folders", - "chooser-dirtree__filtering_folders_only", - "chooser-dirtree__filtering_full_tree", - "chooser-dirtree__filtering_no_tree", - "chooser-dirtree__folders_only", - "chooser-dirtree__full_tree", - "chooser-dirtree__full_tree_indices", - "chooser-dirtree__insert_directly_in_folder_folders_only", - "chooser-dirtree__insert_directly_in_folder_full_tree", - "chooser-dirtree__modal", - "chooser-dirtree__move_then_undo", - "chooser-dirtree__no_tree", - "chooser-dirtree__programmatically_add_folder", - "chooser-dirtree__rename_folder_folders_only", - "chooser-dirtree__rename_folder_full_tree", - "chooser-dirtree__sorting_across_modes_from_folders_only", - "chooser-dirtree__sorting_across_modes_from_full_tree", - "chooser-dirtree__sorting_across_modes_from_no_tree", - "chooser-dirtree__sorting_folders_only", - "chooser-dirtree__sorting_full_tree", - "chooser-dirtree__sorting_no_tree", - "chooser-dirtree__toggle_columns_folders_only", - "chooser-dirtree__toggle_columns_full_tree", - "chooser-dirtree__toggle_columns_no_tree", - "chooser-dirtree__unavailable_actions_when_no_CH_CAN_EDIT", - "chooser-dirtree__widths_across_modes_from_folders_only", - "chooser-dirtree__widths_across_modes_from_full_tree", - "chooser-dirtree__widths_across_modes_from_no_tree", - "idapython-netnode", - "scriptsnippets-misc__load_dups", - ] - }, - "netnode.netnode.supval": { - "return": [ - 'NoneType', - 'bytes', - ], - "tests": [ - "idapython-netnode", - ] - }, - "offset.get_offset_expr": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-custom_fixup", - ] - }, - "offset.op_plain_offset": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "pro.boolvec_t.at": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.boolvec_t.back": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.boolvec_t.front": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.boolvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.boolvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.ea_pointer.assign": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-idp_hooks2__calc_step_over", - "idapython-idp_hooks2__coagulate_dref", - ] - }, - "pro.ea_pointer.cast": { - "return": [ - 'ea_t *', - ], - "tests": [ - "idapython-misc4", - ] - }, - "pro.ea_pointer.frompointer": { - "return": [ - 'ea_pointer', - ], - "tests": [ - "idapython-idp_hooks2__calc_step_over", - "idapython-idp_hooks2__coagulate_dref", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "pro.ea_pointer.value": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-misc4", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "pro.eavec_t.append": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "pro.eavec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.eavec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.eavec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.eavec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc", - "idapython-misc4", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "lumina-update__do_not_override", - "lumina-update__merge", - "lumina-update__override", - "lumina-update__override_if_better", - "lumina-update__override_leaves_addr_untouched", - ] - }, - "pro.eavec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-examples__vds12", - ] - }, - "pro.int64vec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.int64vec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.int64vec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.int64vec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.int64vec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.int_pointer.assign": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-idp_hooks2__func_bounds", - "idapython-idp_hooks2__gen_map_file", - "idapython-idp_hooks2__get_frame_retsize", - "idapython-idp_hooks2__is_sp_based", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython_hr-ea", - ] - }, - "pro.int_pointer.frompointer": { - "return": [ - 'int_pointer', - ], - "tests": [ - "idapython-idp_hooks2__func_bounds", - "idapython-idp_hooks2__gen_map_file", - "idapython-idp_hooks2__get_frame_retsize", - "idapython-idp_hooks2__is_sp_based", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "pro.int_pointer.value": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython_hr-ea", - ] - }, - "pro.intvec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.intvec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.intvec_t.empty": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-examples__vds17", - ] - }, - "pro.intvec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.intvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "pro.intvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__block_chain_t_64", - ] - }, - "pro.longlongvec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.longlongvec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.longlongvec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.longlongvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.longlongvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.str2user": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-api__pro", - "idapython_hr-examples__vds5", - ] - }, - "pro.strvec_t.push_back": { - "return": [ - 'simpleline_t', - ], - "tests": [ - "idapython-misc", - ] - }, - "pro.strvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "plugins-lucid", - ] - }, - "pro.svalvec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.svalvec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.svalvec_t.empty": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds17", - ] - }, - "pro.svalvec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.svalvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "plugins-pyhexraysdeob__big_func", - "plugins-pyhexraysdeob__default", - ] - }, - "pro.svalvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.tid_array.cast": { - "return": [ - 'ea_t *', - ], - "tests": [ - "api-idapython_doc__bytes", - "api-idapython_nocompat_695__idc", - ] - }, - "pro.uint64vec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.uint64vec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.uint64vec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.uint64vec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.uint64vec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.uintvec_t.append": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "pro.uintvec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - ] - }, - "pro.uintvec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - ] - }, - "pro.uintvec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.uintvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc", - "idapython-misc4", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "lumina-update__do_not_override", - "lumina-update__merge", - "lumina-update__override", - "lumina-update__override_if_better", - "lumina-update__override_leaves_addr_untouched", - ] - }, - "pro.uintvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-examples__vds12", - ] - }, - "pro.ulonglongvec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.ulonglongvec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.ulonglongvec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.ulonglongvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.ulonglongvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.uvalvec_t.append": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-examples__vds12", - ] - }, - "pro.uvalvec_t.at": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.uvalvec_t.back": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - ] - }, - "pro.uvalvec_t.front": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - ] - }, - "pro.uvalvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc", - "idapython-misc4", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "lumina-update__do_not_override", - "lumina-update__merge", - "lumina-update__override", - "lumina-update__override_if_better", - "lumina-update__override_leaves_addr_untouched", - ] - }, - "pro.uvalvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-qvector__ea32", - "idapython-qvector__ea64", - "idapython_hr-base_classes2__casm_t", - "idapython_hr-base_classes2__casm_t_64", - "idapython_hr-examples__vds12", - ] - }, - "problems.forget_problem": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-misc", - ] - }, - "problems.get_problem": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__list_problems", - ] - }, - "problems.get_problem_desc": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-misc", - ] - }, - "problems.get_problem_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__list_problems", - ] - }, - "problems.remember_problem": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-misc", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "range.array_of_rangesets.push_back": { - "return": [ - 'rangeset_t', - ], - "tests": [ - "idapython-misc4", - ] - }, - "range.range_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__func_chooser_coloring", - ] - }, - "range.rangeset_t.add": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-misc4", - ] - }, - "range.rangeset_t.getrange": { - "return": [ - 'range_t', - ], - "tests": [ - "idapython-misc4", - "idapython_hr-base_classes", - ] - }, - "range.rangeset_t.nranges": { - "return": [ - 'int', - ], - "tests": [ - "idapython_hr-base_classes", - ] - }, - "range.rangevec_base_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython_hr-base_classes2__block_chain_t_64", - "idapython_hr-examples__modified_vds13_twice", - "idapython_hr-examples__vds13", - ] - }, - "registry.reg_data_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_exists": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_read_binary": { - "return": [ - 'NoneType', - 'bytes', - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_read_int": { - "return": [ - 'int', - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_read_string": { - "return": [ - 'str', - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_read_strlist": { - "return": [ - ['str', '...'], - ], - "tests": [ - "registry-misc__strlist", - ] - }, - "registry.reg_subkey_subkeys": { - "return": [ - ['str', '...'], - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_subkey_values": { - "return": [ - ['str', '...'], - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_update_filestrlist": { - "return": [ - 'NoneType', - ], - "tests": [ - "chooser-recent_scripts", - ] - }, - "registry.reg_update_strlist": { - "return": [ - 'NoneType', - ], - "tests": [ - "registry-misc__strlist", - ] - }, - "registry.reg_write_binary": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_write_int": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-registry", - ] - }, - "registry.reg_write_string": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-registry", - ] - }, - "search.find_binary": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__search", - "training-test__FindInstructions_py", - ] - }, - "search.find_text": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search2__idaview_across_hidden_function", - ] - }, - "segment.add_segm": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-bfld", - ] - }, - "segment.add_segm_ex": { - "return": [ - 'bool', - ], - "tests": [ - "customidamemo-search_bin__search1_sparse", - "customidamemo-search_bin__search1_varray", - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "idapython-base2file", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "screenshots-misc__proc_dsp56k", - ] - }, - "segment.del_segm": { - "return": [ - 'bool', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - "segs-manip", - "segs-offset_xrefs", - ] - }, - "segment.get_defsr": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - ] - }, - "segment.get_first_seg": { - "return": [ - 'segment_t', - ], - "tests": [ - "training-test__FindInstructions_py", - ] - }, - "segment.get_segm_by_name": { - "return": [ - 'segment_t', - ], - "tests": [ - "customidamemo-search_bin__search1_dbg", - ] - }, - "segment.get_segm_class": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "segment.get_segm_name": { - "return": [ - 'str', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "idapython-breakpoints", - "loadfile-dyld_shared_cache", - "loadfile-dyld_shared_cache2", - "navbar-api", - ] - }, - "segment.get_segm_qty": { - "return": [ - 'int', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "loadfile-dyld_shared_cache", - "loadfile-dyld_shared_cache2", - "navbar-api", - ] - }, - "segment.get_selector_qty": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc3", - ] - }, - "segment.get_visible_segm_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "segment.getn_selector": { - "return": [ - ('bool', 'int', 'int'), - ], - "tests": [ - "idapython-misc3", - ] - }, - "segment.getnseg": { - "return": [ - 'segment_t', - ], - "tests": [ - "customidamemo-search_bin__searchall_all", - "customidamemo-search_bin__searchall_cp1251", - "customidamemo-search_bin__searchall_defbpu", - "customidamemo-search_bin__searchall_utf32be", - "customidamemo-search_bin__searchall_utf8", - "loadfile-dyld_shared_cache", - "loadfile-dyld_shared_cache2", - "navbar-api", - ] - }, - "segment.getseg": { - "return": [ - 'NoneType', - 'segment_t', - ], - "tests": [ - "actions-flush_buffers_doesnt_add_entry_in_menu", - "address_details-misc__strings", - "api-idapython_nocompat_695__idc", - "areas-killcb", - "areas-srareas", - "bench-autoanalysis__ntoskrnl72", - "bench-autoanalysis__pc_dwarfdump", - "bptgrp-multiline", - "bptgrp-remove_from_group", - "coloredview-basic", - "config-idausr_subdirs", - "customidamemo-switch_views", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "debugger-breakpoint_llcond", - "debugger-breakpoints_newfile", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida32_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin32", - "debugger-dbgsrv_easize__linux_dbgsrv64_ida64_bin64", - "debugger-set_as_default", - "desktops-66_compat_geometry", - "desktops-load_save__save_default", - "desktops-misc__batch_new_file", - "desktops-misc__batch_new_file_show_sp", - "desktops-newfile__cli_asmex", - "desktops-newfile__java_sign2", - "desktops-newfile__pc_dwarf_arrays", - "desktops-newfile__tms320c6_coff2", - "dwarf-load_options", - "dwarf-load_options_fprots", - "dwarf-load_options_glob_func_types", - "enums-bitfields", - "frview-colors", - "frview-contextmenu", - "frview-cursor", - "frview-hints", - "frview-history_initial", - "frview-hscrolling", - "frview-resize", - "grview-blinking_edges", - "grview-contextmenu", - "grview-fatGraph", - "grview-flowchart_update", - "grview-line_prefixes", - "grview-mouseOver", - "grview-nodepropsUser", - "grview-on_view_click", - "grview-on_view_keydown", - "grview-overview", - "grview-stats", - "grview-stats2", - "grview-statsFindItemAt", - "hexrays-fuzzy_sp", - "hexrays-misc3__send_idb_newfile", - "hexrays-navigate2", - "hexview-longbytes2", - "hexview-sync_base_newfile", - "i18n-broken_config", - "i18n-broken_config_bad_TypeNameChars", - "idapython-api__segment", - "idapython-bfld", - "idapython-breakpoints", - "idapython-examples__colorize_disassembly", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__list_segment_functions", - "idapython-examples__list_segment_functions_using_idautils", - "idapython-examples__print_call_stack_linux32", - "idapython-examples__print_call_stack_linux64", - "idapython-interrupt_long_op", - "idapython-misc", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "idapython-read_selection_64", - "idapython-registers__linux", - "idapython-registers__linux_x64", - "idapython-savefile", - "idapython_hr-examples__vds8_crash", - "idapython_hr-examples__vds8_crash_minimal_no_install", - "imports-load_other_file", - "loadfile-archive_locked_idb", - "loadfile-binary_no_entry_point", - "loadfile-dyld_shared_cache", - "loadfile-dyld_shared_cache2", - "loadfile-misc__arm_elf", - "loadfile-misc__armb_elf", - "loadfile-misc__conflicting_procs", - "loadfile-misc__dex_conflicting_procs", - "loadfile-misc__dialog_access", - "loadfile-misc__files_history", - "loadfile-misc__filtered_tree_hover", - "loadfile-misc__libso_inside_zip", - "loadfile-misc__ppc_elf", - "loadfile-misc__ppcl_elf", - "loadfile-misc__reload_input_file", - "loadfile-misc__screen_center", - "loadfile-misc__tree_context_menu", - "loadfile-nonnative_filedialogs", - "lumina-misc__armb", - "miniview-tracefile_node_colors", - "navbar-api", - "navbar-hints", - "prview-contextmenu", - "prview-quit_ida", - "prview-stats", - "running_initial_aa-misc__chooser_quick_filtering", - "screenshots-misc__idapython_snippets", - "screenshots-misc__proc_51xa", - "screenshots-misc__proc_6502", - "screenshots-misc__proc_6803", - "screenshots-misc__proc_68040_amiga", - "screenshots-misc__proc_6805", - "screenshots-misc__proc_6808", - "screenshots-misc__proc_6809_os9_flex", - "screenshots-misc__proc_6809_os9_obj", - "screenshots-misc__proc_6811", - "screenshots-misc__proc_68hc12", - "screenshots-misc__proc_68hc16", - "screenshots-misc__proc_68k_amiga", - "screenshots-misc__proc_68k_pilot", - "screenshots-misc__proc_68k_unix_coff", - "screenshots-misc__proc_78k0s", - "screenshots-misc__proc_80196", - "screenshots-misc__proc_8051", - "screenshots-misc__proc_ad218x_voc_code", - "screenshots-misc__proc_alpha_nt_coff", - "screenshots-misc__proc_alpha_unix_elf", - "screenshots-misc__proc_android_arm", - "screenshots-misc__proc_arc_7400_outer", - "screenshots-misc__proc_arm_epoc_app", - "screenshots-misc__proc_arm_epoc_pe", - "screenshots-misc__proc_arm_epoc_rom", - "screenshots-misc__proc_arm_epoc_sis", - "screenshots-misc__proc_arm_ios_lock_unlock", - "screenshots-misc__proc_arm_ios_objc", - "screenshots-misc__proc_arm_ios_objc_vars", - "screenshots-misc__proc_arm_ios_pit", - "screenshots-misc__proc_arm_ios_start", - "screenshots-misc__proc_arm_ios_switch", - "screenshots-misc__proc_arm_ios_symbol_info", - "screenshots-misc__proc_arm_ios_write", - "screenshots-misc__proc_arm_linux_elf", - "screenshots-misc__proc_arm_sdk_aof", - "screenshots-misc__proc_arm_wince_coff", - "screenshots-misc__proc_avr", - "screenshots-misc__proc_c166", - "screenshots-misc__proc_c166_elf", - "screenshots-misc__proc_c39_v90", - "screenshots-misc__proc_cli_vb", - "screenshots-misc__proc_cr16_dect11", - "screenshots-misc__proc_dalvik", - "screenshots-misc__proc_dotnet", - "screenshots-misc__proc_dsp56k", - "screenshots-misc__proc_fr_hello", - "screenshots-misc__proc_gameboy", - "screenshots-misc__proc_h8300_coff", - "screenshots-misc__proc_h8300s_coff", - "screenshots-misc__proc_h8500", - "screenshots-misc__proc_hppa_hpux_som", - "screenshots-misc__proc_i51", - "screenshots-misc__proc_i860", - "screenshots-misc__proc_i960", - "screenshots-misc__proc_ia64", - "screenshots-misc__proc_java", - "screenshots-misc__proc_kr1878", - "screenshots-misc__proc_m16c", - "screenshots-misc__proc_m32r_elf", - "screenshots-misc__proc_m740", - "screenshots-misc__proc_m7700", - "screenshots-misc__proc_m7900", - "screenshots-misc__proc_mips_nintendo_n64", - "screenshots-misc__proc_mips_sony_bin_r5900", - "screenshots-misc__proc_mips_sony_elf", - "screenshots-misc__proc_mips_sony_psx", - "screenshots-misc__proc_mips_unix_coff", - "screenshots-misc__proc_mips_unix_elf", - "screenshots-misc__proc_mips_wince_pe", - "screenshots-misc__proc_mips_wince_pe2", - "screenshots-misc__proc_mn102", - "screenshots-misc__proc_oakdsp", - "screenshots-misc__proc_pc_elf", - "screenshots-misc__proc_pc_geos_drv", - "screenshots-misc__proc_pc_geos_lib", - "screenshots-misc__proc_pc_gnu_coff", - "screenshots-misc__proc_pc_lx", - "screenshots-misc__proc_pc_nlm", - "screenshots-misc__proc_pc_qnx", - "screenshots-misc__proc_pc_watcom", - "screenshots-misc__proc_pc_win_omf", - "screenshots-misc__proc_pc_win_pe", - "screenshots-misc__proc_pc_win_xvd", - "screenshots-misc__proc_pdp11_rt11_sav", - "screenshots-misc__proc_pic", - "screenshots-misc__proc_pic12xx", - "screenshots-misc__proc_ppc_aix_ecoff", - "screenshots-misc__proc_ppc_linux_elf", - "screenshots-misc__proc_ppc_macos_X", - "screenshots-misc__proc_ppc_macos_pef", - "screenshots-misc__proc_ppc_nt_pe", - "screenshots-misc__proc_sh3_wince_coff", - "screenshots-misc__proc_sh3_wince_pe", - "screenshots-misc__proc_sh4_elf", - "screenshots-misc__proc_sh4_wince_pe", - "screenshots-misc__proc_snes", - "screenshots-misc__proc_sparc_solaris_coff", - "screenshots-misc__proc_sparc_solaris_elf", - "screenshots-misc__proc_sparc_sun_elf", - "screenshots-misc__proc_sparc_sun_elf_so", - "screenshots-misc__proc_st20", - "screenshots-misc__proc_st7", - "screenshots-misc__proc_st9", - "screenshots-misc__proc_tlcs900", - "screenshots-misc__proc_tms320c2_coff", - "screenshots-misc__proc_tms320c5", - "screenshots-misc__proc_tms320c54", - "screenshots-misc__proc_tms320c6_coff", - "screenshots-misc__proc_tricore", - "screenshots-misc__proc_unsp", - "screenshots-misc__proc_v850_elf", - "screenshots-misc__proc_z180_coff", - "screenshots-misc__proc_z380_coff", - "screenshots-misc__proc_z8", - "screenshots-misc__proc_z80", - "screenshots-misc__tutorial_debugger_linux_local", - "screenshots-misc__tutorial_debugger_linux_to_linux64", - "segs-offset_xrefs", - "sigs-status", - "srcdbg-large_structs", - "srcdbg-watch_mem", - "srcdbg-watch_reg", - "stddirtrees-misc__debugging_functions", - "stddirtrees-misc__newfile_imports", - "strings-refresh_when_auto_empty", - "training-test__CallStackWalk_py", - "training-test__FindInstructions_py", - "training-test__chunkldr_idc", - "training-test__sol_cyci_py", - "welcome-load_binary_dont_save_idb", - ] - }, - "segment.rebase_program": { - "return": [ - 'int', - ], - "tests": [ - "eaview-navigate_rebase", - "hexrays-caching__rebase_down_1000", - "hexrays-caching__rebase_up_1000", - "strings-misc__rebase", - "strings-misc__rebase_range", - "strings-misc__restore_after_rebase", - ] - }, - "segment.segment_t.is_64bit": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__segment", - ] - }, - "segment.segment_t.update": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__colorize_disassembly", - "idapython-misc", - ] - }, - "segment.segment_t.use64": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__segment", - ] - }, - "segment.sel2para": { - "return": [ - 'int', - ], - "tests": [ - "training-test__FindInstructions_py", - ] - }, - "segment.set_defsr": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-misc", - ] - }, - "segment.set_segm_addressing": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-bfld", - ] - }, - "segment.set_segment_cmt": { - "return": [ - 'NoneType', - ], - "tests": [ - "api-idapython_nocompat_695__idc", - ] - }, - "segment.setup_selector": { - "return": [ - 'int', - ], - "tests": [ - "screenshots-misc__proc_dsp56k", - ] - }, - "segregs.get_sreg": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__ana_emu_out", - ] - }, - "segregs.get_sreg_range": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-srareas", - ] - }, - "segregs.get_sreg_ranges_qty": { - "return": [ - 'int', - ], - "tests": [ - "idapython-srareas", - ] - }, - "segregs.getn_sreg_range": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-srareas", - ] - }, - "segregs.split_sreg_range": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-srareas", - ] - }, - "strlist.build_strlist": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__idautils", - "idapython-get_ascii_contents", - "idapython-strings", - "pyqt-qabstractitemdelegate", - "strings-misc__idapython1", - "strings-misc__idapython3", - ] - }, - "strlist.get_strlist_item": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__idautils", - "idapython-examples__show_selected_using_get_strlist_item", - "idapython-get_ascii_contents", - "idapython-strings", - "pyqt-qabstractitemdelegate", - ] - }, - "strlist.get_strlist_options": { - "return": [ - 'strwinsetup_t', - ], - "tests": [ - "idapython-api__idautils", - "idapython-get_ascii_contents", - "idapython-strings", - "pyqt-qabstractitemdelegate", - ] - }, - "strlist.get_strlist_qty": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__idautils", - "idapython-get_ascii_contents", - "idapython-strings", - "pyqt-qabstractitemdelegate", - "strings-misc__idapython1", - "strings-misc__idapython2", - "strings-misc__idapython3", - ] - }, - "struct.add_struc": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__pro", - "idapython-examples__create_structure_programmatically", - "idapython-misc", - "structs-create", - "structs-members", - ] - }, - "struct.add_struc_member": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "stackview-misc", - "structs-members", - ] - }, - "struct.del_struc": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idb_hooks", - "stddirtrees-misc__cut_and_paste_structures", - "structs-deps", - "structs-produce_file", - "structview-add_fields", - "structview-navigate", - ] - }, - "struct.del_struc_member": { - "return": [ - 'bool', - ], - "tests": [ - "stroff-misc", - "structs-asm_and_c", - ] - }, - "struct.get_first_struc_idx": { - "return": [ - 'int', - ], - "tests": [ - "structview-modify_align", - ] - }, - "struct.get_innermost_member": { - "return": [ - ('member_t', 'struc_t', 'int'), - ], - "tests": [ - "idapython-structs", - ] - }, - "struct.get_last_struc_idx": { - "return": [ - 'int', - ], - "tests": [ - "structview-modify_align", - ] - }, - "struct.get_member": { - "return": [ - 'NoneType', - 'member_t', - ], - "tests": [ - "funstack-misc", - "idapython-api__idautils", - "idapython-idb_hooks", - "idapython-misc", - "idapython-print_tinfo", - "idapython-structs", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-xrefs", - "stackview-misc", - "structs-members", - ] - }, - "struct.get_member_by_fullname": { - "return": [ - 'NoneType', - ('member_t', 'struc_t'), - ], - "tests": [ - "structs-members", - ] - }, - "struct.get_member_by_id": { - "return": [ - 'NoneType', - ('member_t', 'str', 'struc_t'), - ], - "tests": [ - "structs-members", - ] - }, - "struct.get_member_by_name": { - "return": [ - 'NoneType', - 'member_t', - ], - "tests": [ - "funstack-misc", - "idapython-examples__list_stkvar_xrefs", - "structs-members", - "structs-xrefs", - ] - }, - "struct.get_member_cmt": { - "return": [ - 'str', - ], - "tests": [ - "idapython-idb_hooks", - ] - }, - "struct.get_member_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__idautils", - "idapython-print_tinfo", - "idapython-structs", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-xrefs", - "idaview-create_struct_from_data", - "idaview-create_struct_from_data_destructor", - "structs-members", - ] - }, - "struct.get_member_size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__idautils", - "idapython-structs", - ] - }, - "struct.get_member_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "funstack-misc", - "idapython-idb_hooks", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idaview-create_struct_from_data", - "idaview-create_struct_from_data_destructor", - ] - }, - "struct.get_next_struc_idx": { - "return": [ - 'int', - ], - "tests": [ - "structview-modify_align", - ] - }, - "struct.get_or_guess_member_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-print_tinfo", - ] - }, - "struct.get_struc": { - "return": [ - 'NoneType', - 'struc_t', - ], - "tests": [ - "funstack-misc", - "idapython-api__idautils", - "idapython-api__struct", - "idapython-examples__create_structure_programmatically", - "idapython-examples__list_stkvar_xrefs", - "idapython-idb_hooks", - "idapython-misc", - "idapython-structs", - "idaview-create_struct_from_data", - "idaview-create_struct_from_data_destructor", - "stddirtrees-misc__cut_and_paste_structures", - "stroff-misc", - "structs-asm_and_c", - "structs-deps", - "structs-members", - "structs-produce_file", - "structs-xrefs", - "structview-add_fields", - "structview-navigate", - ] - }, - "struct.get_struc_by_idx": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idb_hooks", - "structs-deps", - "structs-produce_file", - "structview-add_fields", - "structview-modify_align", - ] - }, - "struct.get_struc_cmt": { - "return": [ - 'str', - ], - "tests": [ - "idapython-idb_hooks", - ] - }, - "struct.get_struc_first_offset": { - "return": [ - 'int', - ], - "tests": [ - "idapython-print_tinfo", - "idapython-xrefs", - ] - }, - "struct.get_struc_id": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython_doc__bytes", - "api-idapython_nocompat_695__idc", - "idapython-api__struct", - "idapython-examples__create_structure_programmatically", - "idapython-idb_hooks", - "idapython-structs", - "idaview-create_struct_from_data", - "idaview-create_struct_from_data_destructor", - "stddirtrees-misc__cut_and_paste_structures", - "strlits-borland", - "stroff-misc", - "structs-members", - "structview-navigate", - "structview-navigate2__custom_viewer_jump", - ] - }, - "struct.get_struc_idx": { - "return": [ - 'int', - ], - "tests": [ - "structview-navigate2__custom_viewer_jump", - ] - }, - "struct.get_struc_name": { - "return": [ - 'str', - ], - "tests": [ - "idapython-examples__operand_changed", - "structs-members", - "structview-modify_align", - ] - }, - "struct.get_struc_next_offset": { - "return": [ - 'int', - ], - "tests": [ - "idapython-print_tinfo", - "idapython-xrefs", - ] - }, - "struct.get_struc_qty": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idb_hooks", - "structs-deps", - "structs-produce_file", - "structview-add_fields", - ] - }, - "struct.get_struc_size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__create_structure_programmatically", - ] - }, - "struct.is_member_id": { - "return": [ - 'bool', - ], - "tests": [ - "structs-members", - ] - }, - "struct.member_t.get_soff": { - "return": [ - 'int', - ], - "tests": [ - "funstack-misc", - ] - }, - "struct.member_t.has_ti": { - "return": [ - 'bool', - ], - "tests": [ - "idaview-create_struct_from_data", - "idaview-create_struct_from_data_destructor", - ] - }, - "struct.set_member_cmt": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idb_hooks", - ] - }, - "struct.set_member_name": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-funcs", - ] - }, - "struct.set_member_tinfo": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idb_hooks", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - ] - }, - "struct.set_member_type": { - "return": [ - 'bool', - ], - "tests": [ - "structs-members", - ] - }, - "struct.set_struc_cmt": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idb_hooks", - ] - }, - "struct.struc_t.get_member": { - "return": [ - 'member_t', - ], - "tests": [ - "idapython-api__struct", - ] - }, - "struct.visit_stroff_fields": { - "return": [ - ('int', 'int'), - ], - "tests": [ - "structs-members", - ] - }, - "tryblks.add_tryblk": { - "return": [ - 'int', - ], - "tests": [ - "idaview-misc__tryblocks", - ] - }, - "tryblks.del_tryblks": { - "return": [ - 'NoneType', - ], - "tests": [ - "idaview-misc__tryblocks", - ] - }, - "tryblks.get_tryblks": { - "return": [ - 'int', - ], - "tests": [ - "idaview-misc__tryblocks", - ] - }, - "typeinf.add_til": { - "return": [ - 'int', - ], - "tests": [ - "til-loaded_til", - ] - }, - "typeinf.alloc_type_ordinal": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython__get_set_numbered_type", - "idapython-tinfo_manip", - "localtypes-misc__manipulate_dirtree_programmatically", - ] - }, - "typeinf.apply_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__replay_prototypes_changes", - "idapython-tinfo_manip", - ] - }, - "typeinf.apply_type": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-api__idc", - "idapython-api__typeinf", - "idapython-misc", - "structs-members", - ] - }, - "typeinf.argloc_t.atype": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_func", - "idapython_hr-base_classes2__mblock_t", - "idapython_hr-base_classes2__mblock_t_64", - "idapython_hr-base_classes2__mop_t", - "idapython_hr-base_classes2__mop_t_64", - ] - }, - "typeinf.argloc_t.consume_scattered": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__typeinf", - ] - }, - "typeinf.argloc_t.is_ea": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "typeinf.argloc_t.is_reg1": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "typeinf.argloc_t.is_reg2": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "typeinf.argloc_t.is_rrel": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "typeinf.argloc_t.is_stkoff": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "typeinf.argloc_t.reg1": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idp_hooks", - "idapython-tinfo_func", - ] - }, - "typeinf.argloc_t.set_reg1": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-idp_hooks", - "idapython_hr-examples__vds21", - ] - }, - "typeinf.argloc_t.set_reg2": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-tinfo_func", - ] - }, - "typeinf.argloc_t.set_stkoff": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__typeinf", - "idapython_hr-examples__vds4", - ] - }, - "typeinf.argloc_t.stkoff": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "typeinf.argpartvec_t.push_back": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-api__typeinf", - ] - }, - "typeinf.argpartvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_manip2", - ] - }, - "typeinf.choose_named_type": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.del_numbered_type": { - "return": [ - 'bool', - ], - "tests": [ - "dirtree-misc__manipulate_programmatically", - "localtypes-misc__manipulate_dirtree_programmatically", - "stddirtrees-misc__cut_and_paste_local_types", - ] - }, - "typeinf.enum_member_vec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_manip2", - ] - }, - "typeinf.for_all_arglocs": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_func", - ] - }, - "typeinf.get_idainfo_by_type": { - "return": [ - ('bool', 'int', 'int', 'NoneType', 'int'), - ('bool', 'int', 'int', 'opinfo_t *', 'int'), - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.get_idati": { - "return": [ - 'til_t', - ], - "tests": [ - "dirtree-misc__manipulate_programmatically", - "idapython-examples__replay_prototypes_changes", - "idapython-idb_hooks", - "idapython-idp_hooks2__decorate_name", - "idapython-tinfo_manip", - ] - }, - "typeinf.get_named_type": { - "return": [ - ('int', 'bytes', 'bytes', 'NoneType', 'NoneType', 'int', 'int'), - ], - "tests": [ - "idapython-tinfo_manip", - "stddirtrees-misc__cut_and_paste_local_types", - ] - }, - "typeinf.get_named_type64": { - "return": [ - ('int', 'bytes', 'NoneType', 'NoneType', 'NoneType', 'int', 'int'), - ], - "tests": [ - "til-redeclare_named_type", - ] - }, - "typeinf.get_numbered_type": { - "return": [ - ('bytes', 'NoneType', 'NoneType', 'NoneType', 'int'), - ('bytes', 'bytes', 'NoneType', 'NoneType', 'int'), - ], - "tests": [ - "api-idapython__get_set_numbered_type", - "idapython-tinfo_udt", - "localtypes-misc__anonymous_union_members", - ] - }, - "typeinf.get_numbered_type_name": { - "return": [ - 'str', - ], - "tests": [ - "api-idapython__get_set_numbered_type", - ] - }, - "typeinf.get_stock_tinfo": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_func", - ] - }, - "typeinf.get_type_ordinal": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.guess_tinfo": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.idc_get_local_type_name": { - "return": [ - 'str', - ], - "tests": [ - "localtypes-misc__anonymous_union_members", - ] - }, - "typeinf.idc_get_local_type_raw": { - "return": [ - ('bytes', 'bytes'), - ], - "tests": [ - "localtypes-misc__anonymous_union_members", - ] - }, - "typeinf.idc_parse_decl": { - "return": [ - 'NoneType', - ('str', 'bytes', 'bytes'), - ], - "tests": [ - "idapython-api__idc", - "idapython-misc", - "plugins-hexrayspytools", - ] - }, - "typeinf.idc_parse_types": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__idc", - "structs-asm_and_c", - "til-loaded_til", - ] - }, - "typeinf.idc_print_type": { - "return": [ - 'str', - ], - "tests": [ - "localtypes-misc__anonymous_union_members", - ] - }, - "typeinf.idc_set_local_type": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.import_type": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - "til-redeclare_named_type", - ] - }, - "typeinf.load_til": { - "return": [ - 'til_t', - ], - "tests": [ - "til-redeclare_named_type", - ] - }, - "typeinf.parse_decl": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-idb_hooks", - "idapython-tinfo_manip", - "idapython_hr-examples__vds21", - "idapython_hr-examples__vds_modify_user_lvars", - "localtypes-misc__manipulate_dirtree_programmatically", - ] - }, - "typeinf.print_argloc": { - "return": [ - 'str', - ], - "tests": [ - "idapython-idp_hooks", - ] - }, - "typeinf.print_decls": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc4", - "til-misc", - "til-nonlocal_deps", - "til-simple_export", - ] - }, - "typeinf.print_tinfo": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "funstack-misc", - "idapython-idb_hooks", - "idapython-idp_hooks", - "idapython-print_tinfo", - "idapython-tinfo_manip", - "idapython-tinfo_udt", - "idapython_hr-examples__vds17", - "idapython_hr-gssincla_sample5", - "plugins-hexrayspytools", - ] - }, - "typeinf.reginfovec_t.push_back": { - "return": [ - 'NoneType', - 'reg_info_t', - ], - "tests": [ - "idapython-funcs", - ] - }, - "typeinf.regobjvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_manip2", - ] - }, - "typeinf.remove_pointer": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "idapython_hr-ctree_visitor__force_all_calls", - "idapython_hr-examples__vds17", - ] - }, - "typeinf.remove_tinfo_pointer": { - "return": [ - ('bool', 'NoneType'), - ('bool', 'str'), - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.set_abi_name": { - "return": [ - 'bool', - ], - "tests": [ - "ppc-analysis_options", - ] - }, - "typeinf.set_numbered_type": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython__get_set_numbered_type", - ] - }, - "typeinf.tinfo_t.calc_udt_aligns": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.clr_const": { - "return": [ - 'NoneType', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.copy": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.create_func": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_func", - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.create_ptr": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.create_udt": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.del_attr": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.del_attrs": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.deserialize": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-examples__replay_prototypes_changes", - "idapython-idb_hooks", - "idapython-tinfo_arrays_in_proto__ea32", - "idapython-tinfo_arrays_in_proto__ea64", - "idapython-tinfo_manip", - "localtypes-misc__anonymous_union_members", - ] - }, - "typeinf.tinfo_t.dstr": { - "return": [ - 'str', - ], - "tests": [ - "idapython-api__typeinf", - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.empty": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds5", - "idapython_hr-gssincla_sample5", - ] - }, - "typeinf.tinfo_t.equals_to": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.get_array_details": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.get_attr": { - "return": [ - 'NoneType', - 'str', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.get_attrs": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.get_enum_details": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip2", - ] - }, - "typeinf.tinfo_t.get_func_details": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-funcs", - "idapython-tinfo_func", - ] - }, - "typeinf.tinfo_t.get_named_type": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - "structs-members", - ] - }, - "typeinf.tinfo_t.get_numbered_type": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip2", - "idapython-tinfo_udt", - ] - }, - "typeinf.tinfo_t.get_ordinal": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.get_pointed_object": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.get_ptrarr_objsize": { - "return": [ - 'int', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.get_rettype": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.get_size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-api__typeinf", - "idapython-tinfo_manip", - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.get_stock": { - "return": [ - 'tinfo_t', - ], - "tests": [ - "idapython-api__typeinf", - "idapython-idp_hooks2__decorate_name", - "idapython-tinfo_manip", - "idapython_hr-examples__old_vds10", - "idapython_hr-examples__vds10", - "idapython_hr-examples__vds4", - ] - }, - "typeinf.tinfo_t.get_type_name": { - "return": [ - 'str', - ], - "tests": [ - "structs-members", - ] - }, - "typeinf.tinfo_t.get_udt_details": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - "idapython-tinfo_udt", - ] - }, - "typeinf.tinfo_t.is_forward_decl": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.is_func": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-ctree_visitor__force_all_calls", - ] - }, - "typeinf.tinfo_t.is_ptr": { - "return": [ - 'bool', - ], - "tests": [ - "plugins-hexrayspytools", - ] - }, - "typeinf.tinfo_t.is_udt": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds17", - "plugins-hexrayspytools", - "structs-members", - ] - }, - "typeinf.tinfo_t.is_union": { - "return": [ - 'bool', - ], - "tests": [ - "idapython_hr-examples__vds17", - ] - }, - "typeinf.tinfo_t.serialize": { - "return": [ - ('bytes', 'NoneType', 'NoneType'), - ('bytes', 'bytes', 'NoneType'), - ], - "tests": [ - "idapython-tinfo_manip", - "structs-members", - ] - }, - "typeinf.tinfo_t.set_attr": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.set_attrs": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.set_named_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-idp_hooks2__decorate_name", - "idapython-tinfo_manip", - ] - }, - "typeinf.tinfo_t.set_numbered_type": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_manip", - "localtypes-misc__manipulate_dirtree_programmatically", - ] - }, - "typeinf.tinfo_visitor_t.apply_to": { - "return": [ - 'int', - ], - "tests": [ - "structs-members", - ] - }, - "typeinf.type_attrs_t.push_back": { - "return": [ - 'type_attr_t', - ], - "tests": [ - "idapython-tinfo_manip", - ] - }, - "typeinf.udtmembervec_template_t.push_back": { - "return": [ - 'NoneType', - 'udt_member_t', - ], - "tests": [ - "idapython-api__typeinf", - "idapython-tinfo_manip", - "plugins-hexrayspytools", - ] - }, - "typeinf.valstrvec_t.size": { - "return": [ - 'int', - ], - "tests": [ - "idapython-tinfo_manip2", - ] - }, - "ua.construct_macro": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - ] - }, - "ua.create_insn": { - "return": [ - 'int', - ], - "tests": [ - "idaview-hints__instruction_gets_deleted", - ] - }, - "ua.decode_insn": { - "return": [ - 'int', - ], - "tests": [ - "api-idapython_doc__bytes", - "api-idapython_nocompat_695__ida_idp", - "api-idapython_nocompat_695__idc", - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "grview-nodepropsUser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-examples__dbg_trace_linux32", - "idapython-examples__dbg_trace_linux64", - "idapython-examples__list_stkvar_xrefs", - "idapython-funcs", - "idapython-idp_hooks", - "idapython-idp_hooks2__get_reg_accesses", - "idapython-interrupt_long_op", - "idapython-misc", - "idapython-misc3", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-ui_hooks__misc", - "idapython-user_graphs", - "ppc-analysis_options", - "training-test__CallStackWalk_py", - "training-test__find_mgen_key_py", - "training-test__find_ret_py", - ] - }, - "ua.decode_preceding_insn": { - "return": [ - ('int', 'int'), - ], - "tests": [ - "idapython-misc", - ] - }, - "ua.decode_prev_insn": { - "return": [ - 'int', - ], - "tests": [ - "idapython-misc", - "idapython-processor_module_mem", - ] - }, - "ua.get_dtype_by_size": { - "return": [ - 'int', - ], - "tests": [ - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - "idapython-debugger", - "idapython-misc", - ] - }, - "ua.get_dtype_size": { - "return": [ - 'int', - ], - "tests": [ - "debugger-avx2__linux", - "debugger-avx2__linux_numeric_locale", - "debugger-avx2__linux_x64", - "debugger-avx2__linux_x64_forced_dbgsrv", - "debugger-avx2__linux_x64_numeric_locale", - ] - }, - "ua.get_immvals": { - "return": [ - ['int', '...'], - ], - "tests": [ - "idapython-misc2", - ] - }, - "ua.insn_t.add_cref": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "ua.insn_t.add_dref": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.insn_t.add_off_drefs": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.insn_t.create_op_data": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.insn_t.create_stkvar": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.insn_t.get_canon_feature": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "training-test__sol_cyci_py", - ] - }, - "ua.insn_t.get_canon_mnem": { - "return": [ - 'str', - ], - "tests": [ - "idapython-ui_hooks__misc", - ] - }, - "ua.insn_t.get_next_byte": { - "return": [ - 'int', - ], - "tests": [ - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.insn_t.get_next_dword": { - "return": [ - 'int', - ], - "tests": [ - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.insn_t.get_next_word": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - ] - }, - "ua.op_t.assign": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - ] - }, - "ua.op_t.is_reg": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - ] - }, - "ua.outctx_base_t.flush_outbuf": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks2__gen_regvar_def", - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.outctx_base_t.gen_cmt_line": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-idp_hooks2__gen_src_file_lnnum", - ] - }, - "ua.outctx_base_t.out_btoa": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.outctx_base_t.out_char": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.outctx_base_t.out_name_expr": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - ] - }, - "ua.outctx_base_t.out_printf": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-idp_hooks2__gen_regvar_def", - ] - }, - "ua.outctx_base_t.out_register": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.outctx_base_t.out_spaces": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-idp_hooks2__gen_regvar_def", - ] - }, - "ua.outctx_base_t.out_symbol": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.outctx_base_t.out_tagoff": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.outctx_base_t.out_tagon": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.outctx_base_t.out_value": { - "return": [ - 'int', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.outctx_base_t.set_gen_cmt": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.outctx_t.out_custom_mnem": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-examples__ana_emu_out", - "plugins-procext_py", - ] - }, - "ua.outctx_t.out_data": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - ] - }, - "ua.outctx_t.out_mnem": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - ] - }, - "ua.outctx_t.out_mnemonic": { - "return": [ - 'NoneType', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module_mem", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "ua.outctx_t.out_one_operand": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "training-test__sol_cyci_py", - ] - }, - "xref.add_cref": { - "return": [ - 'bool', - ], - "tests": [ - "idapython-interrupt_long_op", - "idapython-processor_module64", - "idapython-processor_module__endianness", - "idapython-processor_module__error_in_ev_ana_insn", - "idapython-processor_module__error_in_ev_emu_insn", - "idapython-processor_module__error_in_ev_is_sp_based", - "idapython-processor_module__error_in_ev_out_insn", - "idapython-processor_module__error_in_set_func_end", - "idapython-processor_module__error_in_set_func_start", - "idapython-processor_module__macro_instruction", - "idapython-processor_module__ph_object", - "idapython-processor_module_mem", - "idapython-processor_module_misc__procmod_and_loader_have_same_name", - "idapython-processor_module_misc__spu_ev_set_idp_options", - "idapython-proctemplate__ev_set_idp_options_newapi", - "idapython-proctemplate__newapi", - "idapython-proctemplate__oldapi", - "xrefview-misc__generate_add_event", - "xrefview-misc__generate_del_event", - ] - }, - "xref.add_dref": { - "return": [ - 'bool', - ], - "tests": [ - "xrefview-misc__generate_add_event", - "xrefview-misc__generate_del_event", - ] - }, - "xref.calc_switch_cases": { - "return": [ - 'cases_and_targets_t', - ], - "tests": [ - "idapython-calc_switch_cases", - ] - }, - "xref.del_cref": { - "return": [ - 'bool', - ], - "tests": [ - "xrefview-misc__generate_del_event", - "xrefview-misc__insert_and_check_cursor", - ] - }, - "xref.del_dref": { - "return": [ - 'NoneType', - ], - "tests": [ - "xrefview-misc__generate_del_event", - "xrefview-misc__insert_and_check_cursor", - ] - }, - "xref.get_first_cref_to": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__list_segment_functions", - "idapython-examples__list_segment_functions_using_idautils", - "screenshots-misc__idapython_snippets", - ] - }, - "xref.get_next_cref_to": { - "return": [ - 'int', - ], - "tests": [ - "idapython-examples__list_segment_functions", - "idapython-examples__list_segment_functions_using_idautils", - "screenshots-misc__idapython_snippets", - ] - }, - "xref.xrefblk_t.first_from": { - "return": [ - 'bool', - ], - "tests": [ - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - ] - }, - "xref.xrefblk_t.first_to": { - "return": [ - 'bool', - ], - "tests": [ - "training-test__ImpRef_py", - "training-test__color_to_py", - "training-test__find_mgen_key_py", - ] - }, - "xref.xrefblk_t.next_from": { - "return": [ - 'bool', - ], - "tests": [ - "gruser-misc__get_graph_viewer_idapython", - "grview-gruser", - "idapython-cleanup", - "idapython-examples__custom_graph_with_actions", - "idapython-user_graphs", - ] - }, - "xref.xrefblk_t.next_to": { - "return": [ - 'bool', - ], - "tests": [ - "training-test__ImpRef_py", - "training-test__color_to_py", - "training-test__find_mgen_key_py", - ] - }, -} diff --git a/tools/deploy.py b/tools/deploy.py index 3ba2a5c..c49b6cd 100644 --- a/tools/deploy.py +++ b/tools/deploy.py @@ -145,11 +145,7 @@ def deploy(module, template, output, pywraps, iface_deps, lifecycle_aware, verbo # write output file with open(output, 'w') as f: - # f.write("""%module(docstring="IDA Plugin SDK API wrapper: {0}",directors="1",threads="1") {1}\n""".format( - # module, - # module if module == "idaapi" else "_ida_%s" % module)) - f.write("""%module(docstring="IDA Plugin SDK API wrapper: {0}",directors="1",threads="1") {1}\n""".format( - module, "ida_%s" % module)) + f.write("""%module(directors="1",threads="1") {0}\n""".format("ida_%s" % module)) f.write("#ifndef IDA_MODULE_DEFINED\n") f.write(""" #define IDA_MODULE_%s\n""" % module.upper()) f.write("#define IDA_MODULE_DEFINED\n") diff --git a/tools/deploy/header.i.in b/tools/deploy/header.i.in index b44883a..ff52f6d 100644 --- a/tools/deploy/header.i.in +++ b/tools/deploy/header.i.in @@ -34,7 +34,6 @@ extern plugin_t PLUGIN; // generate directors for all classes that have virtual methods %feature("director"); // exceptions -%feature("nodirector") enumplace_t; %feature("nodirector") generic_linput64_t; %feature("nodirector") generic_linput_t; %feature("nodirector") place_t; @@ -57,6 +56,7 @@ extern plugin_t PLUGIN; // and others... #pragma SWIG nowarn=312 #pragma SWIG nowarn=325 +#pragma SWIG nowarn=328 // Value assigned to cb not used due to limited parsing implementation #pragma SWIG nowarn=314 #pragma SWIG nowarn=362 #pragma SWIG nowarn=383 @@ -70,9 +70,6 @@ extern plugin_t PLUGIN; #pragma SWIG nowarn=395 // operator delete[] ignored #pragma SWIG nowarn=351 // operator delete ignored -// Do not create separate wrappers for default arguments -%feature("compactdefaultargs"); - %ignore qvector::at(size_t); %ignore qvector::front; %ignore qvector::back; @@ -122,6 +119,8 @@ extern plugin_t PLUGIN; #define CASSERT(type) %pythoncode { +from typing import Tuple, List, Union + import ida_idaapi } @@ -152,6 +151,16 @@ import ida_idaapi $self->at(i) = v; } + inline void append(const T &x) + { + $self->push_back(x); + } + + inline void extend(const qvector &x) + { + $self->insert($self->end(), x.begin(), x.end()); + } + %pythoncode { front = ida_idaapi._qvector_front back = ida_idaapi._qvector_back @@ -213,18 +222,20 @@ import ida_idaapi __iter__ = ida_idaapi._bounded_getitem_iterator def find(self, item): - it = self.begin() - for i in range(self.size()): - if it.cur == item: - return it - next(it) + if item is not None: + it = self.begin() + for i in range(self.size()): + if it.cur == item: + return it + next(it) def index(self, item): - it = self.begin() - for i in range(self.size()): - if it.cur == item: - return i - next(it) + if item is not None: + it = self.begin() + for i in range(self.size()): + if it.cur == item: + return i + next(it) def at(self, index): it = self.begin() @@ -296,8 +307,8 @@ class QLIST_TYPE##_iterator {}; %enddef %exception_set_default_handlers(); -// Enable automatic docstring generation -%feature(autodoc,2); +// Enable C/C++ type annotations in function prototypes +%feature("python:annotations", "c"); %{ /* strnlen() arrived on OSX at v10.7. Provide it ourselves if needed. */ @@ -413,10 +424,12 @@ static PyObject *type##_get_clink_ptr(PyObject *self) %define %define_netnode_tag_accessors() %apply char { uchar tag }; -%fragment("cvt_netnode_tag", "header") + +%fragment("cvt_netnode_tag", + "header", + fragment="SWIG_AsVal_char", + fragment="SWIG_AsVal_unsigned_SS_char") { - SWIGINTERN int SWIG_AsVal_char (PyObject * obj, char *val); - SWIGINTERN int SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val); bool cvt_netnode_tag(uchar *out, PyObject *obj) { char c = '\0'; @@ -436,6 +449,14 @@ static PyObject *type##_get_clink_ptr(PyObject *self) SWIG_ValueError, "in method '" "$symname" "', argument " "$argnum"" of type '" "$1_type""'"); } + +%typemap(typecheck, fragment="cvt_netnode_tag") uchar tag { + // %typemap(typecheck) uchar tag + uchar tmp; + $1 = cvt_netnode_tag(&tmp, $input); +} + + %enddef //--------------------------------------------------------------------- @@ -654,6 +675,15 @@ SWIGINTERN PyObject *_maybe_byte_array_or_none_result( //------------------------------------------------------------------------- // OUT qstrvec_t //------------------------------------------------------------------------- +%typemap(in) const qstrvec_t & (qstrvec_t temp) +{ + // %typemap(in) const qstrvec_t & (qstrvec_t temp) + Py_ssize_t len = PyW_PySeqToStrVec(&temp, $input); + if ( len == CIP_FAILED ) + return nullptr; + + $1 = &temp; +} %typemap(in,numinputs=0) qstrvec_t *out (qstrvec_t temp) { // %typemap(in,numinputs=0) qstrvec_t *out (qstrvec_t temp) @@ -671,6 +701,52 @@ SWIGINTERN PyObject *_maybe_byte_array_or_none_result( // Nothing. We certainly don't want 'temp' to be deleted. } +// Same, but for tuple-appending +%typemap(in,numinputs=0) qstrvec_t *out_wrap_in_list_and_append (qstrvec_t temp) +{ + // %typemap(in,numinputs=0) qstrvec_t *out_wrap_in_list_and_append (qstrvec_t temp) + $1 = &temp; +} +%typemap(argout) qstrvec_t *out_wrap_in_list_and_append +{ + // %typemap(argout) qstrvec_t *out_wrap_in_list_and_append + PyObject *was = $result; + $result = PyList_New(0); // Will be tuplified + + PyList_Append($result, was); + newref_t _nl(qstrvec2pylist(*($1))); + PyList_Append($result, _nl.o); +} +%typemap(freearg) qstrvec_t* out_wrap_in_list_and_append +{ + // %typemap(freearg) qstrvec_t* out_wrap_in_list_and_append + // Nothing. We certainly don't want 'temp' to be deleted. +} + +//------------------------------------------------------------------------- +// Director helpers +%define %hooks_director_handle_qstrvec_t_output(METHOD_NAME, STORAGE_QSTRVEC_T) +%typemap(directorout) int METHOD_NAME +{ // %typemap(directorout) int METHOD_NAME + if ( PySequence_Check(result) ) + { + $result = PyW_PySeqToStrVec(STORAGE_QSTRVEC_T, result); + + if ( !$result ) + { + Swig::DirectorTypeMismatchException::raise( + SWIG_ErrorType(SWIG_TypeError), + "in output value of type 'qstrvec_t' in method '$symname'"); + } + } + else + { + $result = 0; // not implemented + } +} +%enddef + + //------------------------------------------------------------------------- // md5/sha256 hash retrieval (as hex representation) //------------------------------------------------------------------------- @@ -762,7 +838,7 @@ SWIGINTERN PyObject *_maybe_byte_array_or_none_result( ARGOUT_MAYBE_CONVERTER, ELTYPE_TO_REPORT1, ELTYPE_TO_REPORT2) -%typemap(typecheck) REFTYPE +%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) REFTYPE { // bytes_container REFTYPE typemap(typecheck) $1 = CHECKER($input) ? 1 : 0; } @@ -1250,7 +1326,6 @@ struct dynamic_wrapped_array_t { } //------------------------------------------------------------------------- -#if SWIG_VERSION == 0x40000 || SWIG_VERSION == 0x40001 %typemap(out) tinfo_t { // %typemap(out) tinfo_t @@ -1296,9 +1371,61 @@ struct dynamic_wrapped_array_t { $result = SWIG_NewPointerObj($1, $1_descriptor, 0); } -#else -#error Ensure tinfo_t wrapping is compatible with this version of SWIG -#endif +//------------------------------------------------------------------------- +// udm_t *out +//------------------------------------------------------------------------- +%typemap(in,numinputs=0) udm_t *out (udm_t temp) +{ + // %typemap(in,numinputs=0) udm_t *out (udm_t temp) + $1 = &temp; +} +%typemap(argout) udm_t *out +{ + // %typemap(argout) udm_t *out + if ( result > -1 ) + { + PyObject *py_udm = SWIG_NewPointerObj(new udm_t(*($1)), $1_descriptor, SWIG_POINTER_OWN | 0); + $result = SWIG_Python_AppendOutput($result, py_udm, /*is_void=*/ 1); + } + else + { + Py_INCREF(Py_None); + $result = SWIG_Python_AppendOutput($result, Py_None, /*is_void=*/ 1); + } +} +%typemap(freearg) udm_t *out +{ + // %typemap(freearg) udm_t *out + // Nothing. We certainly don't want 'temp' to be deleted. +} + +//------------------------------------------------------------------------- +// edm_t *out +//------------------------------------------------------------------------- +%typemap(in,numinputs=0) edm_t *out (edm_t temp) +{ + // %typemap(in,numinputs=0) edm_t *out (edm_t temp) + $1 = &temp; +} +%typemap(argout) edm_t *out +{ + // %typemap(argout) edm_t *out + if ( result > -1 ) + { + PyObject *py_edm = SWIG_NewPointerObj(new edm_t(*($1)), $1_descriptor, SWIG_POINTER_OWN | 0); + $result = SWIG_Python_AppendOutput($result, py_edm, /*is_void=*/ 1); + } + else + { + Py_INCREF(Py_None); + $result = SWIG_Python_AppendOutput($result, Py_None, /*is_void=*/ 1); + } +} +%typemap(freearg) edm_t *out +{ + // %typemap(freearg) edm_t *out + // Nothing. We certainly don't want 'temp' to be deleted. +} // Convert all of these %cstring_output_maxstr_none(char *buf, size_t bufsize); @@ -1361,17 +1488,7 @@ struct dynamic_wrapped_array_t { %const_void_pointer_and_size(void, dataptr, len); %const_char_pointer_and_size(char, value, length); -// Create wrapper classes for basic type arrays -%array_class(uchar, uchar_array); -%array_class(tid_t, tid_array); -%array_class(ea_t, ea_array); -%array_class(sel_t, sel_array); -%array_class(uval_t, uval_array); -%pointer_class(int, int_pointer); -%pointer_class(ea_t, ea_pointer); -%pointer_class(sval_t, sval_pointer); -%pointer_class(sel_t, sel_pointer); - +%include %{ #define S2LF_EMPTY_NONE 0x1 @@ -1430,6 +1547,13 @@ SWIGINTERN PyObject *qstrvec2pylist(const qstrvec_t &vec, int flags=0) SWIG_exception_fail(SWIG_ArgError(ecode), "in method '$symname', argument $argnum of type $1_type"); } +%typemap(typecheck, precedence=SWIG_TYPECHECK_INTEGER, fragment="cvt_uint64") uint64 +{ + // %typemap(typecheck) uint64 + uint64 tmp; + $1 = cvt_uint64(&tmp, $input) == SWIG_OK; +} + //------------------------------------------------------------------------- %define %_uint_result_as_output(TYPE, CONVFUNC, CHECK_EXPR) %typemap(in,numinputs=0) TYPE *result (TYPE temp = 0) @@ -1474,9 +1598,9 @@ SWIGINTERN PyObject *qstrvec2pylist(const qstrvec_t &vec, int flags=0) { // %typemap(argout) ea_t *appended_ea #ifdef __EA64__ - $result = SWIG_Python_AppendOutput($result, PyLong_FromUnsignedLongLong(*($1))); + $result = SWIG_Python_AppendOutput($result, PyLong_FromUnsignedLongLong(*($1)), /*is_void=*/ 1); #else - $result = SWIG_Python_AppendOutput($result, PyLong_FromUnsignedLong(*($1))); + $result = SWIG_Python_AppendOutput($result, PyLong_FromUnsignedLong(*($1)), /*is_void=*/ 1); #endif } @@ -1550,12 +1674,12 @@ SWIGINTERN PyObject *qstrvec2pylist(const qstrvec_t &vec, int flags=0) //------------------------------------------------------------------------- // For e.g., get_idainfo_by_type() -%apply uint32 * OUTPUT { flags_t *out_flags }; +%apply uint64 * OUTPUT { flags64_t *out_flags }; %apply size_t * OUTPUT { size_t *out_size }; %apply size_t * OUTPUT { size_t *out_alsize }; %typemap(check) size_t *out_size "*($1) = 0; // %typemap(check) size_t *out_size"; %typemap(check) size_t *out_alsize "*($1) = 0; // %typemap(check) size_t *out_alsize"; -%typemap(check) flags_t *out_flags "*($1) = 0; // %typemap(check) flags_t *out_flags"; +%typemap(check) flags64_t *out_flags "*($1) = 0; // %typemap(check) flags_t *out_flags"; %typemap(in,numinputs=0) opinfo_t *out_mt (opinfo_t temp) { // typemap(in,numinputs=0) opinfo_t *out_mt @@ -1567,12 +1691,12 @@ SWIGINTERN PyObject *qstrvec2pylist(const qstrvec_t &vec, int flags=0) if ( result ) { PyObject *py_opinfo = SWIG_NewPointerObj(SWIG_as_voidptr(new opinfo_t(*($1))), SWIGTYPE_p_opinfo_t, SWIG_POINTER_NEW ); - $result = SWIG_Python_AppendOutput($result, py_opinfo); + $result = SWIG_Python_AppendOutput($result, py_opinfo, /*is_void=*/ 1); } else { Py_INCREF(Py_None); - $result = SWIG_Python_AppendOutput($result, Py_None); + $result = SWIG_Python_AppendOutput($result, Py_None, /*is_void=*/ 1); } } %typemap(freearg) opinfo_t *out_mt @@ -1615,6 +1739,7 @@ HOOKS_DUMP_STATE(); %{ #include +#include #include #include "../../../pywraps.hpp" %} @@ -1748,16 +1873,6 @@ inline void _kludge_force_declare_##NAME(const NAME *) {} %include -// If the module is 'pro', don't import pro.h, or the %include -// at the beginning of pro.i won't have any effect. Same for all -// modules. -${ALL_IMPORTS} - -// This is where all the collected NONNULL information coming -// from the SDK, will be injected in the form of 'check' -// typemaps. -${NONNULL_TYPEMAPS} - // gdl_graph_t & subclasses %cstring_output_maxstr_none(char *iobuf, int iobufsize); @@ -1821,7 +1936,7 @@ ${NONNULL_TYPEMAPS} int res = SWIG_ConvertFunctionPtr($input, (void**)(&$1), SWIGTYPE_p_f_p_q_const__char_v_______int); if ( !SWIG_IsOK(res) ) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "parse_decls" "', argument " "3"" of type '" "printer_t *""'"); + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "parse_decls" "', argument " "3"" of type '" "printer_t *""'"); SWIG_exception_fail( SWIG_TypeError, "in method '" "$symname" "', argument " "$argnum"" of type 'printer_t *'"); @@ -1874,33 +1989,27 @@ static PyObject *get_regval_t( { PyObject *res = nullptr; _cvt_status_t status(PyExc_ValueError, "Conversion failed"); - switch ( dtype ) + if ( is_floating_dtype(dtype) ) { - default: - if ( rv.ival <= uint64(LONG_MAX) ) - res = PyInt_FromLong(long(rv.ival)); - else - res = PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) rv.ival); - break; - case dt_float: - case dt_tbyte: - case dt_double: - case dt_ldbl: - { - double dbl; - status.ok = rv.fval.to_double(&dbl) == REAL_ERROR_OK; - if ( status.ok ) - res = PyFloat_FromDouble(dbl); - } - break; - case dt_byte16: - case dt_byte32: - case dt_byte64: - { - const bytevec_t &b = rv.bytes(); - res = PyBytes_FromStringAndSize((const char *) b.begin(), b.size()); - } - break; + double dbl; + fpvalue_t fpv; + const bytevec_t &b = rv.bytes(); + status.ok = cpu2ieee(&fpv, b.begin(), b.size()) == REAL_ERROR_OK + && fpv.to_double(&dbl) == REAL_ERROR_OK; + if ( status.ok ) + res = PyFloat_FromDouble(dbl); + } + else if ( dtype == dt_byte16 || dtype == dt_byte32 || dtype == dt_byte64 ) + { + const bytevec_t &b = rv.bytes(); + res = PyBytes_FromStringAndSize((const char *) b.begin(), b.size()); + } + else + { + if ( rv.ival <= uint64(LONG_MAX) ) + res = PyInt_FromLong(long(rv.ival)); + else + res = PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) rv.ival); } return res; } @@ -1944,19 +2053,29 @@ bool set_regval_t(regval_t **out, regval_t *buf, op_dtype_t dtype, PyObject *o) return status.ok; } - static bool convert_float(regval_t *lout, PyObject *in, op_dtype_t) + static bool convert_float(regval_t *lout, PyObject *in, op_dtype_t dt) { - fpvalue_t fpval; _cvt_status_t status(PyExc_TypeError, "Expected float value"); double dbl = PyFloat_AsDouble(in); status.ok = PyErr_Occurred() == nullptr; if ( status.ok ) - status.ok = ieee_realcvt(&dbl, &fpval, 003 /*load double*/) == REAL_ERROR_OK; - if ( !status.ok ) + { + // convert from IBM PC format to IEEE; then to the target cpu format + uchar native[32]; + int size = get_dtype_size(dt); + QASSERT(0, size <= sizeof(native)); + fpvalue_t fpval; + uint16 swt = sizeof(double) / 2 - 1; + status.ok = ieee_realcvt(&dbl, &fpval, swt) == REAL_ERROR_OK + && ieee2cpu(native, fpval, size) == REAL_ERROR_OK; + if ( status.ok ) + { + lout->set_bytes(native, size, RVT_FLOAT); + return true; + } status.failed(PyExc_ValueError).sprnt("Float conversion failed"); - if ( status.ok ) - lout->set_float(fpval); - return status.ok; + } + return false; } static bool convert_bytes(regval_t *lout, PyObject *in, op_dtype_t dt) @@ -2065,6 +2184,7 @@ TRY_RAW_LONG: default: ok = cvt_t::convert_int(&rv, o, dtype); break; + case dt_half: case dt_float: case dt_tbyte: case dt_double: @@ -2125,5 +2245,59 @@ TRY_RAW_LONG: $result = PyW_from_jvalue_t(*$1); } +// pattern matching of multi-argument typemaps is more strict; would not work without argument names +%define %define_merge_handler_typemap(MNI_ARG_NAME, N_ARG_NAME) +%typemap(in,numinputs=0) (int moddata_id) { $1 = -1; } +%typemap(in,numinputs=1) (const merge_node_info2_t *MNI_ARG_NAME, size_t N_ARG_NAME) (qvector temp) +{ + // %typemap(in,numinputs=1) (const merge_node_info2_t *, size_t ) (qvector temp) + if ( $input == Py_None ) + { + $2 = 0; + $1 = nullptr; + } + else + { + if ( !PySequence_Check($input) ) + { + PyErr_SetString(PyExc_TypeError, "Expecting a list of `merge_node_info2_t` instances"); + return nullptr; + } + PyObject *s = $input; + Py_ssize_t len = PySequence_Size(s); + temp.reserve(len); + for ( Py_ssize_t i = 0; i < len; ++i ) + { + newref_t o(PySequence_GetItem(s, i)); + void *ap = 0 ; + int cvt = SWIG_ConvertPtr(o.o, &ap, $descriptor, 0); + if ( !SWIG_IsOK(cvt) ) + SWIG_exception_fail( + SWIG_ArgError(cvt), + "in method '" "$symname" "', argument " "$argnum"" consists of 'merge_node_info2_t' instances"); + temp.push_back(*reinterpret_cast(ap)); + } + $2 = temp.size(); + $1 = temp.extract(); + } +} + +%typemap(typecheck,numinputs=1) (const merge_node_info2_t *MNI_ARG_NAME, size_t N_ARG_NAME) +{ + // %typemap(typecheck,numinputs=1) (const merge_node_info2_t *, size_t ) + $1 = ($input == Py_None || PySequence_Check($input)); +} +%enddef + +// If the module is 'pro', don't import pro.h, or the %include +// at the beginning of pro.i won't have any effect. Same for all +// modules. +${ALL_IMPORTS} + +// This is where all the collected NONNULL information coming +// from the SDK, will be injected in the form of 'check' +// typemaps. +${NONNULL_TYPEMAPS} + #endif // __HEADER_I__ // END: auto-inserted header diff --git a/tools/docs/hrdoc.py b/tools/docs/hrdoc.py index ae064ca..f2925e2 100644 --- a/tools/docs/hrdoc.py +++ b/tools/docs/hrdoc.py @@ -20,6 +20,7 @@ parser.add_argument("-m", "--modules", required=True) parser.add_argument("-s", "--include-source-for-modules", required=True) parser.add_argument("-x", "--exclude-modules-from-searchable-index", required=True) parser.add_argument("-v", "--verbose", default=False, action="store_true") +parser.add_argument("-M", "--markdown", default=False, action="store_true", help="Output to Markdown, not HTML") args = parser.parse_args(idc.ARGV[1:]) @@ -29,7 +30,7 @@ args.exclude_modules_from_searchable_index = args.exclude_modules_from_searchabl try: # pdoc location - pdoc_path = os.path.join(idasrc_path, "third_party", "pdoc", "pdoc-master") + pdoc_path = os.path.join(idasrc_path, "third_party", "pdoc", "pdoc-240411") sys.path.append(pdoc_path) sys.path.append(tools_docs_path) # for the custom epytext import pdoc @@ -130,58 +131,67 @@ def build_documentation(): pdoc.link_inheritance() # - # ida_*.html + # ida_*.[html|md] # - pdoc.tpl_lookup.directories.insert(0, os.path.join(tools_docs_path, "templates")) - show_source_code = set(args.include_source_for_modules) - def all_modules(module_collection): for module in module_collection: yield module yield from all_modules(module.submodules()) + pdoc.tpl_lookup.directories.insert(0, os.path.join(tools_docs_path, "templates")) + show_source_code = set(args.include_source_for_modules) for module in all_modules(modules): - module.obj.__docformat__ = "hr_epy" - print("Processing: %s" % module.name) - html = module.html( - show_source_code=module.name in show_source_code, - search_prefix=module.name) + + if args.markdown: + contents = module.md( + show_source_code=module.name in show_source_code, + search_prefix=module.name) + else: + contents = module.html( + show_source_code=module.name in show_source_code, + search_prefix=module.name) path = os.path.join(args.output, module.url()) + # close your eyes + if args.markdown and path.endswith(".html"): + path = path[:-5] + ".md" + dirname = os.path.dirname(path) os.makedirs(dirname, exist_ok=True) print("Writing: %s" % path) + with open(path, "w", encoding="utf-8") as f: + f.write(contents) + + if not args.markdown: + + # + # doc-search.html, index.js + # + template_config = {} + gen_lunr_search( + [mod for mod in modules if mod.name not in args.exclude_modules_from_searchable_index], + index_docstrings=True, + template_config=pdoc._get_config(**template_config).get('lunr_search')) + + # + # index.html + # + path = os.path.join(args.output, "index.html") + class fake_module_t(object): + def __init__(self, name, url): + self.name = name + self._url = url + def url(self): + return self._url + + index_module = fake_module_t("index", "index.html") + html = pdoc._render_template('/index.mako', module=index_module, modules=modules) with open(path, "w", encoding="utf-8") as f: f.write(html) - # - # doc-search.html, index.js - # - template_config = {} - gen_lunr_search( - [mod for mod in modules if mod.name not in args.exclude_modules_from_searchable_index], - index_docstrings=True, - template_config=pdoc._get_config(**template_config).get('lunr_search')) - - # - # index.html - # - path = os.path.join(args.output, "index.html") - class fake_module_t(object): - def __init__(self, name, url): - self.name = name - self._url = url - def url(self): - return self._url - - index_module = fake_module_t("index", "index.html") - html = pdoc._render_template('/index.mako', module=index_module, modules=modules) - with open(path, "w", encoding="utf-8") as f: - f.write(html) - # -------------------------------------------------------------------------- def main(): print("Generating documentation.....") diff --git a/tools/docs/templates/md.mako b/tools/docs/templates/md.mako new file mode 100644 index 0000000..bd338d3 --- /dev/null +++ b/tools/docs/templates/md.mako @@ -0,0 +1,168 @@ +## Define mini-templates for each portion of the doco. + +<%! + def indent(s, spaces=3): + new = s.replace('\n', '\n' + ' ' * spaces).replace("@param", "").replace("@return", " return").replace("@retval", " retval").replace("@note", " note") + return ' ' * spaces + new.strip() +%> + +<%! + def class_indent(s, spaces=4): + new = s.replace('\n', '\n' + ' ' * spaces).replace("@param", "").replace("@return", " return").replace("@retval", " retval").replace("@note", " note") + return ' ' * spaces + new.strip() +%> + +<%def name="c_deflist(s)">:${class_indent(s)[1:]} +<%def name="deflist(s)"> ${indent(s)[1:]} + +<%def name="h3(s)">### ${s} + + + +<%def name="function(func)" buffered="True"> +<% + returns = show_type_annotations and func.return_annotation() or '' + if returns: + returns = ' \N{non-breaking hyphen}> ' + returns +%> +${func.name}(${", ".join(func.params(annotate=show_type_annotations))})${returns} +--------- +${func.docstring | deflist} + + +<%def name="method(func)" buffered="True"> +<% + returns = show_type_annotations and func.return_annotation() or '' + if returns: + returns = ' \N{non-breaking hyphen}> ' + returns +%> +- ${func.name}(${", ".join(func.params(annotate=show_type_annotations))})${returns} +${func.docstring | deflist} +--- + + + +<%def name="variable(var)" buffered="True"> +<% + annot = show_type_annotations and var.type_annotation() or '' + if annot: + annot = ': ' + annot +%> +${var.name}${annot} +--------- +${var.docstring | class_indent} + + +<%def name="class_variable(var)" buffered="True"> +<% + annot = show_type_annotations and var.type_annotation() or '' + if annot: + annot = ': ' + annot +%> +- ${var.name}${annot} +`${var.docstring | deflist}` +--- + + +<%def name="class_(cls)" buffered="True"> +${cls.name}(${", ".join(cls.params(annotate=show_type_annotations))}) +--------- +${cls.docstring | c_deflist} +<% + class_vars = cls.class_variables(show_inherited_members, sort=sort_identifiers) + static_methods = cls.functions(show_inherited_members, sort=sort_identifiers) + inst_vars = cls.instance_variables(show_inherited_members, sort=sort_identifiers) + methods = cls.methods(show_inherited_members, sort=sort_identifiers) + mro = cls.mro() + subclasses = cls.subclasses() +%> +% if mro: +${h3('Ancestors (in MRO)')} + % for c in mro: + * ${c.refname} + % endfor + +% endif +% if subclasses: +${h3('Descendants')} + % for c in subclasses: + * ${c.refname} + % endfor + +% endif +% if class_vars: +${h3('Class variables')} + % for v in class_vars: +${class_variable(v)} + + % endfor +% endif +% if static_methods: +${h3('Static methods')} + % for f in static_methods: +${method(f)} + + % endfor +% endif +% if inst_vars: +${h3('Instance variables')} + % for v in inst_vars: +${class_variable(v)} + + % endfor +% endif +% if methods: +${h3('Methods')} + % for m in methods: +${method(m)} + + % endfor +% endif + + +## Start the output logic for an entire module. + +<% + variables = module.variables(sort=sort_identifiers) + classes = module.classes(sort=sort_identifiers) + functions = module.functions(sort=sort_identifiers) + submodules = module.submodules() + heading = 'Namespace' if module.is_namespace else 'Module' +%> + +${heading} ${module.name} +=${'=' * (len(module.name) + len(heading))} +${module.docstring} + + +% if submodules: +Sub-modules +=========== + % for m in submodules: +* ${m.name} + % endfor +% endif + +% if variables: +Global Variables +================ + % for v in variables: +${variable(v)} + % endfor +% endif + +% if functions: +Functions +========= + % for f in functions: +${function(f)} + % endfor +% endif + +% if classes: +Classes +======= + % for c in classes: +${class_(c)} + % endfor +% endif diff --git a/tools/examples_index_template.html b/tools/examples_index_template.html deleted file mode 100644 index fb60c42..0000000 --- a/tools/examples_index_template.html +++ /dev/null @@ -1,103 +0,0 @@ - - - - - IDAPython examples - - - - - - -
- Expand all - | - Collapse all -
- -

IDAPython examples:

-% for category in sorted(examples): -

Category: {{category}}

-
- % for example in sorted(examples[category], key=lambda e: e.name): -
-
- ▹ - - {{example.name}}: {{example.summary}} -
-
- -
-{{example.description if example.description else example.summary}}
-
- -
    -
  • Category: {{example.category}}
    • -
  • Summary: {{example.summary}}
    • -
  • View on GitHub
    • - % if example.keywords: -
  • Keywords: - % for keyword in example.keywords: - {{keyword}} - % endfor -
    • - % endif - - % if example.shortcuts: -
  • Shortcut{{'s' if len(example.shortcuts) > 1 else ''}}: - % for shortcut in example.shortcuts: - {{shortcut}} - % endfor -
    • - % endif - - % if example.imports: -
  • Imports -
      - % for imported in example.imports: -
    • {{imported}}
      • - % endfor -
    -
    • - % endif - - % if example.uses: -
  • APIs used -
      - % for use in example.uses: -
    • {{use}}
      • - % endfor -
    -
    • - % endif - - % if example.see_also: -
  • See also: -
      - % for see in example.see_also: -
    • {{see}}
      • - % endfor -
    -
    • - % endif - - % if example.author: -
  • Author: {{example.author}}
    • - % endif -
-
-
- % endfor # examples of a category - -
-% endfor # categories - - diff --git a/tools/examples_index_template.md b/tools/examples_index_template.md index ec57859..01d5502 100644 --- a/tools/examples_index_template.md +++ b/tools/examples_index_template.md @@ -1,65 +1,93 @@ -[HTML version](http://htmlpreview.github.io/?https://github.com/idapython/src/blob/master/examples/index.html) -# IDAPython examples +# Examples -% for category in sorted(examples): -## Category: {{category}} +## IDAPython examples - % for example in sorted(examples[category], key=lambda e: e.name): -#### {{example.name}} -
- {{example.summary}} +This collection of examples organizes all IDAPython sample code into [categories](#example-categories-overview) for easy reference. Each example demonstrates practical implementation for the IDAPython API, complementing the [reference documentation](https://python.docs.hex-rays.com/) with a real-world usage scenario. -
+### How to run the examples? -#### Source code -{{example.path}} +#### Load the script via File Loader -#### Category -{{example.category}} +1. Navigate to **File -> Script file...**. +2. In the new dialog, select the `.py` script you want to run and click **Open**. -#### Description -{{example.description if example.description else example.summary}} +#### Load the script via Script command - % if example.shortcuts: -#### Shortcut{{'s' if len(example.shortcuts) > 1 else ''}} -{{' '.join(example.shortcuts)}} +1. Navigate to **File -> Script command...**. +2. Paste the code into _Please enter script body_ field and click **Run**. - % endif - % if example.keywords: -#### Keywords -{{' '.join(example.keywords)}} +#### Load the script via output window/console - % endif - % if example.imports: -#### Imports - % for imported in example.imports: -* {{imported}} - % endfor +1. In the output window/IDAPython console, type the following command: `exec(open("path/to/your_script.py").read())` to execute the script. - % endif - % if example.uses: -#### Uses - % for use in example.uses: -* {{use}} - % endfor +## Example Categories: Overview - % endif - % if example.see_also: -#### See also - % for see in example.see_also: -* [{{see}}](#{{see}}) - % endfor + + + - % endif - % if example.author: -#### Author -{{example.author}} +% for c in sorted(categories.categories, key=lambda c: c.rank): + + + + +% endfor # categories - % endif - + +
{{c.label}}{{c.description}}
-
- % endfor # examples of a category -% endfor # categories +% for c in sorted(categories.categories, key=lambda c: c.rank): + +## {{c.label}} {#{{c.id}}} + + + + + + + + + + + % for l in sorted(c.levels, key=lambda l: l.rank): + + + + + % endfor # levels + + +
LevelExamples
{{l.label}}
    {{"".join(["
  • %s
    • " % (e.name, e.summary) for e in sorted(l.examples, key=lambda e: e.name)])}}
+ +% endfor # categories + + +*** + +## Examples list + +% for c in sorted(categories.categories, key=lambda c: c.rank): + % for l in sorted(c.levels, key=lambda l: l.rank): + % for e in sorted(l.examples, key=lambda e: e.name): + +### {{e.summary}} {#{{e.name}}} +{{e.description}} + +| Source code | Keywords | Level | +|-------------------------------|------------|------------------------------------| +| [{{e.file_name}}](https://github.com/HexRaysSA/IDAPython/tree//examples/{{e.path}}) | {{' '.join(e.keywords)}} | {{l.label}} | + + % if e.uses: +**APIs Used:** + % for use in e.uses: +* `{{use}}` + % endfor + % endif + +*** + + % endfor # examples + % endfor # levels +% endfor # categories diff --git a/tools/gen_examples_index.py b/tools/gen_examples_index.py index 7173628..934b60c 100755 --- a/tools/gen_examples_index.py +++ b/tools/gen_examples_index.py @@ -29,6 +29,66 @@ s_subparser.add_argument("-e", "--examples-dir", required=True) args = parser.parse_args() +#------------------------------------------------------------------------------- +CATEGORY_INFO = [ + ( + "ui", + "User interface", + "Creating & manipulating user-interface widgets, prompting the " + + "user with forms, enriching existing widgets, or creating your " + + "own UI through Python Qt bindings." + ), + ( + "disassembler", + "Disassembly", + "Various ways to query, or modify the disassembly listing, " + + "alter the way analysis is performed, or be notified of changes " + + "made to the IDB." + ), + ( + "decompiler", + "Decompilation", + "Querying the decompiler, manipulating the decompilation trees " + + "(either at the microcode level, or the C-tree), and examples " + + "showing how to intervene in the decompilation output." + ), + ( + "debugger", + "Debuggers", + "Driving debugging sessions, be notified of debugging events." + ), + ( + "types", + "Working with types", + "These samples utilize our Type APIs, which allow you to manage " + + "the types and perform various operations on them, like creating " + + "the structures or enums and adding their members programmatically." + ), + ( + "misc", + "Miscellaneous", + "Miscellaneous examples that don't quite fall into another category, " + + "but don't really justify one of their own." + ), +] + +#------------------------------------------------------------------------------- +LEVEL_INFO = [ + ( + "beginner", + "Beginner", + ), + ( + "intermediate", + "Intermediate", + ), + ( + "advanced", + "Advanced", + ), +] + + # -------------------------------------------------------------------------- def verb(msg): if args.verbose: @@ -403,14 +463,17 @@ class Tags(object): IMPORTS = "imports" SEE_ALSO = "see_also" AUTHOR = "author" + LEVEL = "level" # tags that can be used in the template (with the {{example.XXX}} syntax) ALL_TAGS = set([NAME, PATH, SUMMARY, DESCRIPTION, CATEGORY, \ - KEYWORDS, USES, IMPORTS, SEE_ALSO, AUTHOR]) + KEYWORDS, USES, IMPORTS, SEE_ALSO, AUTHOR, \ + LEVEL]) # tags that can be used in the examples' docstrings IN_DOCSTRING = set([SUMMARY, DESCRIPTION, CATEGORY, \ - KEYWORDS, USES, SEE_ALSO, AUTHOR]) + KEYWORDS, USES, SEE_ALSO, AUTHOR, \ + LEVEL]) def __init__(self): self.items = {} @@ -447,6 +510,7 @@ class Tags(object): class Example(object): def __init__(self, content): self.content = content + _, self.file_name = os.path.split(self.path) def __getattr__(self, key): if key in self.content: @@ -537,8 +601,8 @@ class ShortcutFinder(ast.NodeVisitor): value = None # save strings - if isinstance(node.value, ast.Str): - value = node.value.s + if isinstance(node.value, ast.Constant): + value = node.value.value # save also lists of names, in case they are class names elif isinstance(node.value, ast.List): if all(isinstance(elt, ast.Name) for elt in node.value.elts): @@ -588,8 +652,8 @@ class ShortcutFinder(ast.NodeVisitor): del scope[name] def _find_values(self, arg): - if isinstance(arg, ast.Str): - return [arg.s] + if isinstance(arg, ast.Constant): + return [arg.value] # single variable if isinstance(arg, ast.Name): @@ -656,6 +720,63 @@ class ExamplesIndex(object): with open(args.output, "w", encoding="UTF-8") as f: self.replacer.expand(examples, all_keywords, f) +#------------------------------------------------------------------------------- +class Categories(object): + + class Category(object): + + class Level(object): + def __init__(self, id): + self.id = id + assert(self.id) + for rank, tpl in enumerate(LEVEL_INFO): + if tpl[0] == id: + self.rank = rank + _, label = tpl + self.label = label # will bomb if not found + self.examples = [] + + def append(self, example): + self.examples.append(example) + + def __init__(self, id): + self.id = id + for rank, tpl in enumerate(CATEGORY_INFO): + if tpl[0] == id: + self.rank = rank + _, label, description = tpl + self.label = label # will bomb if not found + self.description = " ".join(description.split("\n")) + self.levels = [] + + def get_level(self, id): + for l in self.levels: + if l.id == id: + return l + l = self.Level(id) + self.levels.append(l) + return l + + def append(self, example): + if not example.level: + raise Exception("Missing level for %s" % example.path) + self.get_level(example.level).append(example) + + def __init__(self): + self.categories = [] + + def get_category(self, id): + for c in self.categories: + if c.id == id: + return c + c = self.Category(id) + self.categories.append(c) + return c + + def append(self, example): + self.get_category(example.category).append(example) + + #------------------------------------------------------------------------------- class TemplateReplacer(object): def __init__(self): @@ -688,14 +809,13 @@ class TemplateReplacer(object): def expand(self, examples, all_keywords, f): # group by category - grouped = {} + categories = Categories() for example in examples: - if example.category not in grouped: - grouped[example.category] = [] - grouped[example.category].append(example) + assert example.description and example.summary and not example.summary.endswith("."), "Path: %s" % example.path + categories.append(example) # call the template's entry point - self.module_scope["__mm__entry"](grouped, all_keywords, f) + self.module_scope["__mm__entry"](categories, all_keywords, f) def _sandwich(self, lines, lineno=0, open_keyword=None): in_else = False @@ -758,7 +878,7 @@ class TemplateReplacer(object): # wrap the final code in a function, so that data can be passed return self._function_def("__mm__entry", - ["examples", "all_keywords", "_mm_f"], + ["categories", "all_keywords", "_mm_f"], body) def _code_block(self, lines, lineno): @@ -870,11 +990,11 @@ class TemplateReplacer(object): def _output_text(self, text): return ast.Expr(value=self._call(self._dot("_mm_f", "write"), - [ast.Str(text)])) + [ast.Constant(text)])) def _output_eval(self, expr): # eval(expr) - value = self._call(ast.Name("eval", ast.Load()), [ast.Str(expr)]) + value = self._call(ast.Name("eval", ast.Load()), [ast.Constant(expr)]) # str(eval(expr)) valueStr = self._call(ast.Name("str", ast.Load()), [value]) # _mm_f.write(str(eval(expr))) diff --git a/tools/genhooks/all_recipes.py b/tools/genhooks/all_recipes.py deleted file mode 100644 index 1dfa417..0000000 --- a/tools/genhooks/all_recipes.py +++ /dev/null @@ -1,65 +0,0 @@ - -import recipe_idphooks -import recipe_idbhooks -import recipe_dbghooks -import recipe_uihooks -import recipe_viewhooks -import recipe_hexrays - -# filename -# enum name -# discard enum names with prefixes -# discard docs with prefixes -# remove prefixes from enum value names -# module with recipes - -hooks = { - "IDP_Hooks" : ( - "structprocessor__t.xml", - "event_t", - [], - None, - [], - recipe_idphooks - ), - "IDB_Hooks" : ( - "namespaceidb__event.xml", - "event_code_t", - [], - None, - [], - recipe_idbhooks - ), - "DBG_Hooks" : ( - "dbg_8hpp.xml", - "dbg_notification_t", - [], - None, - [], - recipe_dbghooks - ), - "UI_Hooks" : ( - "kernwin_8hpp.xml", - "ui_notification_t", - ["ui_dbg_", "ui_obsolete"], - "ui:", - ["ui_"], - recipe_uihooks - ), - "View_Hooks" : ( - "kernwin_8hpp.xml", - "view_notification_t", - [], - None, - [], - recipe_viewhooks - ), - "Hexrays_Hooks" : ( - "hexrays_8hpp.xml", - "hexrays_event_t", - [], - None, - ["hxe_", "lxe_"], - recipe_hexrays - ) -} diff --git a/tools/genhooks/genhooks.py b/tools/genhooks/genhooks.py index a96b34b..b11a6d0 100644 --- a/tools/genhooks/genhooks.py +++ b/tools/genhooks/genhooks.py @@ -31,7 +31,7 @@ def warn(msg): import hooks_utils enum_info = hooks_utils.get_hooks_enum_information(args.hooks_class) -recipe = enum_info.recipe +recipe = enum_info.recipe_module.recipe enumerators = hooks_utils.get_hooks_enumerators(args.xml_dir, args.hooks_class) def dump(): diff --git a/tools/genhooks/recipe_hexrays.py b/tools/genhooks/recipe_hexrays.py index 9a2b4e6..efe9e2b 100644 --- a/tools/genhooks/recipe_hexrays.py +++ b/tools/genhooks/recipe_hexrays.py @@ -28,6 +28,17 @@ recipe = { "convertor_pass_args" : True, } }, + # "collect_warnings" : { + # "params" : { + # "warnings" : { "suppress_for_call" : True, } + # }, + # "return" : { + # "type" : "PyObject *", + # "retexpr" : "Py_RETURN_NONE", + # "convertor" : "Hexrays_Hooks::handle_build_qstrvec_output", + # "convertor_pass_args" : True, + # } + # }, } default_rtype = "int" diff --git a/tools/genhooks/recipe_index.py b/tools/genhooks/recipe_index.py new file mode 100644 index 0000000..07dac1a --- /dev/null +++ b/tools/genhooks/recipe_index.py @@ -0,0 +1,91 @@ + +import recipe_idphooks +import recipe_idbhooks +import recipe_dbghooks +import recipe_uihooks +import recipe_viewhooks +import recipe_hexrays + +class hooks_info_t(object): + def __init__( + self, + class_name, + toplevel_xml_fname, + enum_name, + discard_prefixes, + discard_doc, + strip_prefixes, + recipe_module): + self.class_name = class_name + self.toplevel_xml_fname = toplevel_xml_fname + self.enum_name = enum_name + self.discard_prefixes = discard_prefixes or () + self.discard_doc = discard_doc + self.strip_prefixes = strip_prefixes or [] + self.recipe_module = recipe_module + + +hooks = { + "ida_idp" : [ + hooks_info_t( + "IDP_Hooks", + "structprocessor__t.xml", + "event_t", + None, + None, + None, + recipe_idphooks + ), + hooks_info_t( + "IDB_Hooks", + "namespaceidb__event.xml", + "event_code_t", + None, + None, + None, + recipe_idbhooks + ), + ], + "ida_dbg" : [ + hooks_info_t( + "DBG_Hooks", + "dbg_8hpp.xml", + "dbg_notification_t", + None, + None, + None, + recipe_dbghooks + ), + ], + "ida_kernwin" : [ + hooks_info_t( + "UI_Hooks", + "kernwin_8hpp.xml", + "ui_notification_t", + ("ui_dbg_", "ui_obsolete"), + "ui:", + ["ui_"], + recipe_uihooks + ), + hooks_info_t( + "View_Hooks", + "kernwin_8hpp.xml", + "view_notification_t", + None, + None, + None, + recipe_viewhooks + ), + ], + "ida_hexrays" : [ + hooks_info_t( + "Hexrays_Hooks", + "hexrays_8hpp.xml", + "hexrays_event_t", + None, + None, + ["hxe_", "lxe_"], + recipe_hexrays + ) + ], +} diff --git a/tools/genidaapi.py b/tools/genidaapi.py index b5cc143..9d4b0bc 100644 --- a/tools/genidaapi.py +++ b/tools/genidaapi.py @@ -10,11 +10,15 @@ parser.add_argument("-o", "--output", required=True) parser.add_argument("-m", "--modules", required=True) args = parser.parse_args() +# Hack to force ida_idaapi to be loaded as first element +mods = args.modules.split(",") +mods.insert(0, mods.pop(mods.index("idaapi"))) + with open(args.input) as fin: with open(args.output, "w") as fout: template = string.Template(fin.read()) kvps = { - "MODULES" : args.modules, - "IMPORTS" : "\n".join([("from ida_%s import *" % mod) for mod in args.modules.split(",")]) + "MODULES" : ",".join(mods), + "IMPORTS" : "\n".join([(f"from ida_{mod} import *") for mod in mods ]) } fout.write(template.substitute(kvps)) diff --git a/tools/hooks_utils.py b/tools/hooks_utils.py index 971ed23..06a000f 100644 --- a/tools/hooks_utils.py +++ b/tools/hooks_utils.py @@ -10,47 +10,13 @@ genhooks_dir = os.path.join(mydir, "genhooks") if genhooks_dir not in sys.path: sys.path.append(genhooks_dir) -import all_recipes - -class enum_info_t: - def __init__( - self, - fname, - enum_name, - discard_prefixes, - discard_doc, - strip_prefixes, - recipe, - default_rtype): - self.fname = fname - self.enum_name = enum_name - self.discard_prefixes = discard_prefixes - self.discard_doc = discard_doc - self.strip_prefixes = strip_prefixes - self.recipe = recipe - self.default_rtype = default_rtype - -_hooks_enum_info = {} -for klass in all_recipes.hooks: - fname, \ - enum_name, \ - discard_prefixes, \ - discard_doc, \ - strip_prefixes, \ - recipe_module = all_recipes.hooks[klass] - - _hooks_enum_info[klass] = enum_info_t( - fname, - enum_name, - discard_prefixes, - discard_doc, - strip_prefixes, - recipe_module.recipe, - recipe_module.default_rtype) - +import recipe_index def get_hooks_enum_information(class_name): - return _hooks_enum_info[class_name] + for _, recipes in recipe_index.hooks.items(): + for recipe in recipes: + if recipe.class_name == class_name: + return recipe def _parse_param_type(desc): if desc.startswith("("): @@ -82,7 +48,7 @@ def _parse_enumerator(enumval_el, name, enum_name, hooks_info): rtype = None rdefault = None rexpr = None - recipe_data = hooks_info.recipe.get(name, {}) + recipe_data = hooks_info.recipe_module.recipe.get(name, {}) if "ignore" in recipe_data and recipe_data["ignore"]: return @@ -96,7 +62,7 @@ def _parse_enumerator(enumval_el, name, enum_name, hooks_info): if "type" in return_data: rtype = return_data["type"] elif ret_el is not None: - rdesc = ret_el.find("para").text + rdesc = doxygen_utils.join_all_element_text(ret_el) rtype, notype_rdesc, rdefault = _parse_return_type(rdesc) detaileddescription_el = enumval_el.find("detaileddescription") @@ -106,7 +72,7 @@ def _parse_enumerator(enumval_el, name, enum_name, hooks_info): doxygen_utils.for_each_retval(detaileddescription_el, collect_retval) if rtype is None: - rtype = hooks_info.default_rtype + rtype = hooks_info.recipe_module.default_rtype if rtype != "void" and rdefault is None: rdefault = 0 @@ -157,7 +123,7 @@ def _parse_enumerator(enumval_el, name, enum_name, hooks_info): def get_hooks_enumerators(xml_dir, class_name): hooks_info = get_hooks_enum_information(class_name) - tree = ET.parse(os.path.join(xml_dir, hooks_info.fname)) + tree = ET.parse(os.path.join(xml_dir, hooks_info.toplevel_xml_fname)) enum_el = tree.find(".//memberdef[@kind='enum']/[name='%s']" % hooks_info.enum_name) enumerators = [] diff --git a/tools/inject_pydoc.py b/tools/inject_pydoc.py deleted file mode 100644 index 90b7c87..0000000 --- a/tools/inject_pydoc.py +++ /dev/null @@ -1,2171 +0,0 @@ - -# A program to combine docstrings from multiple sources (Python, C++) -# into the final docstrings in the IDAPython sources. -# Called from the idapython makefile. -# -# Bird's eye view: -# -# main() Input from idapython/obj/.../*.py, -# Various inputs Output to current/bin/.../*.py -# ------------------------ ----------------------- -# swig_pydoc_collector_t \ -# cpp_wrapper_parser_t |--> pydoc_patcher_t -# doxygen_info_t / -# ------------------------ ----------------------- -# -# pydoc_visitor_t __/ swig_pydoc_collector_t \__ -# used by both \ pydoc_patcher_t / to read Python's AST -# -# doc_info_t \ -# class_info_t | -# cpp_fun_info_t |-- (mostly) data objects -# location_t | -# repo_t | -# hook_info_t / -# -# prototype_t \ -# structured_comment_t |-- split docs in parts (prototype, parameters, text) -# assembled_comment_t / and help to reassemble these from multiple sources -# -# call_traces_t -- runtime info collected from uitests, -# used to fix prototypes (f.i. return values) -# -# cases_t \__ allow special exceptions to the general rules; -# case_t / special cases are read from the file given by the --cases argument -# -# inspect_importer_t \__ helper classes used resp. by __/ pydoc_visitor_t -# cpp_patterns_t / \ pydoc_patcher_t - - -from __future__ import print_function - -import ast -import re -import sys -import os -import xml.etree.ElementTree as ET -import textwrap -from argparse import ArgumentParser - -genhooks_dir = os.path.join(os.path.dirname(__file__), "genhooks") -if genhooks_dir not in sys.path: - sys.path.append(genhooks_dir) -import all_recipes - -parser = ArgumentParser() -parser.add_argument("-i", "--input", required=True) -parser.add_argument("-s", "--interface", required=True) -parser.add_argument("-w", "--cpp-wrapper", required=True) -parser.add_argument("-o", "--output", required=True) -parser.add_argument("-x", "--xml-doc-directory", required=True) -parser.add_argument("-m", "--module", required=True) -parser.add_argument("-t", "--traces", required=False) -parser.add_argument("-c", "--cases", required=False) -parser.add_argument("-v", "--verbose", default=False, action="store_true") -parser.add_argument("-d", "--debug", default=False, action="store_true") -parser.add_argument("-D", "--debug-name", type=str, default="") -args = parser.parse_args() - -# -------------------------------------------------------------------------- -class pysyntax_exception_t(Exception): - def __init__(self, message, text): - super(pysyntax_exception_t, self).__init__( - "%s\n %s" % (message, text)) - -# -------------------------------------------------------------------------- -class cppsyntax_exception_t(Exception): - def __init__(self, parser, message): - super(cppsyntax_exception_t, self).__init__( - "%s\n Path: %s\n Func: %s" - % (message, parser.path, parser.fun_name)) - -# -------------------------------------------------------------------------- -class process_exception_t(Exception): - pass - -selective_debug = False - -# -------------------------------------------------------------------------- -def pyver(): - return sys.version_info.major - -LOG_LEVEL_DEBUG = 1 -LOG_LEVEL_VERB = 2 -LOG_LEVEL_INFO = 3 -log_level_pfx = { - LOG_LEVEL_DEBUG : "DEBUG", - LOG_LEVEL_VERB : "VERB", - LOG_LEVEL_INFO : "INFO", -} - -log_level = LOG_LEVEL_INFO -log_indent = 0 -class new_log_indent_t(object): - def __enter__(self): - global log_indent - log_indent += 1 - return self - - def __exit__(self, exc_type, exc_value, traceback): - global log_indent - log_indent -= 1 - if exc_value: - raise - - -# -------------------------------------------------------------------------- -def log(level, msg): - if log_level >= level: - pfx = log_level_pfx[level] - if isinstance(msg, bytes): - msg = msg.decode("utf-8") - lines = msg.split("\n") - for line in lines: - print("%s: %s%s" % (pfx, log_indent * " ", line)) - -# -------------------------------------------------------------------------- -def log_debug(msg): - return log(LOG_LEVEL_DEBUG, msg) - -# -------------------------------------------------------------------------- -def log_verb(msg): - return log(LOG_LEVEL_VERB, msg) - -# -------------------------------------------------------------------------- -def log_info(msg): - return log(LOG_LEVEL_INFO, msg) - -# -------------------------------------------------------------------------- -# TL;DR: we need the proper "inspect" module, -# and this class ensures that we import the right one. -# -# Long story: -# -# pydoc_visitor_t (below) uses ast.get_docstring(..., False) -# ("True" would have cleaned the docstring by calling -# the "cleandoc" function in the "inspect" module). -# -# We chose to read without cleaning, and clean manually later -# (by a call to "inspect.cleandoc"), because other docstrings -# do not come from ast.get_docstring() - namely, the ones we -# pcik up manually after assignments, as docstrings for a variable. -# -# For that manual cleaning, we need the inspect module; -# this class ensures that we load the correct one -# (why is there a "correct" or an "incorrect" inspect module, -# is explaned in another comment below). - -class inspect_importer_t(object): - - singleton = None - - @staticmethod - def get_singleton(): - klass = inspect_importer_t - - if not klass.singleton: - klass.singleton = inspect_importer_t() - - return klass.singleton - - def __init__(self): - self.imported_inspect = False - self.saved_sys_path = None - self.is_python_2 = pyver() == 2 - - def ensure_imported_inspect(self): - if self.imported_inspect: - return - self.imported_inspect = True - - if self.is_python_2: - self._modify_sys_path() - - import inspect - self.inspect = inspect - - if self.is_python_2: - self._restore_sys_path() - - def _modify_sys_path(self): - # We need to use the "inspect" module after "ast.get_docstring()". - # (See pydoc_visitor_t.) And... - # - # ... there is an "inspect.py" module next to this program, that - # is used (as per CL 101338) to ensure a consistent documentation - # regardless of the minor version of Python 3. - # - # However, it's useless when running on Python 2, - # in which case we temporarily remove dirname(__file__) from sys.path - # in order to use Python 2's own "inspect" module. - - self.saved_sys_path = sys.path[:] - - executable_dir = os.path.abspath(os.path.dirname(__file__)) - while True: - try: - sys.path.remove(executable_dir) - except: - break - - def _restore_sys_path(self): - sys.path = self.saved_sys_path[:] - -# -------------------------------------------------------------------------- -# Keeps track of where a docstring appears in the source code, -# so that the text can be replaced later. - -class location_t(object): - def __init__(self, *args): - if len(args) == 1: - reference = args[0] - - # used when there is no comment to be removed from the source; - # we just need a line to insert a comment if needed - - line_after_ref = self.last_line(reference) + 1 - - self.start_line = self.end_line = line_after_ref - self.start_col = self.end_col = reference.col_offset - - elif len(args) == 2: - node, reference = args - - # the docstring's lineno/col_offset mark the end - # for multiline comments (end_col for single-line comments - # is not available, so the rest of the code will not use it); - # we use a "reference node" (the class or function, or - # the assigment before the string) to guess the start - # and assume that there is nothing else in between. - # The initial column is assumed 4 if class/function, - # or 0 if variable assignment (plus the reference indent). - - is_variable = isinstance(reference, ast.Assign) - - if hasattr(node, "end_lineno"): - self.start_line = node.lineno - self.end_line = node.end_lineno - else: - self.start_line = self.last_line(reference) + 1 - self.end_line = node.lineno - - self.end_col = node.col_offset # only for multi-line comments - self.start_col = reference.col_offset + (0 if is_variable else 4) - - else: - raise process_exception_t("Internal error, location_t with %d args" \ - % len(args)) - - @staticmethod - def last_line(node): - if hasattr(node, "end_lineno"): - return node.end_lineno - - # hack, until Python 3.8 (where nodes have both lineno and end_lineno) - - last_line = node.lineno - - if isinstance(node, ast.ClassDef): - # note: no class body, just the header - last_line = max(last_line, - last_line + len(node.decorator_list), - location_t._max_lineno(node.bases)) - - elif isinstance(node, ast.FunctionDef): - # note: no function body, just the header - last_line = max(last_line, - last_line + len(node.decorator_list), - location_t._max_lineno(node.args)) - - elif isinstance(node, (ast.Assign, ast.AugAssign)): - last_line = max(last_line, - location_t._max_lineno(node)) - - return last_line - - @staticmethod - def _max_lineno(subtree): - # can return 0 - - if isinstance(subtree, list): - return max(location_t._max_lineno(item) for item in subtree) \ - if len(subtree) > 0 else 0 - - linenos = [node.lineno for node in ast.walk(subtree) \ - if hasattr(node, "lineno")] - return max(linenos) if len(linenos) > 0 else 0 - -# -------------------------------------------------------------------------- -# Containers for docstrings - -class doc_info_t(object): - # for both functions and variables; classes use a specialization - - def __init__(self, name, doc, location, extra=None): - self.name = name - self.doc = doc if doc else "" - self.location = location - self.extra = extra - self.parent = None # filled in later - -# -------------------------------------------------------------------------- -class class_info_t(doc_info_t): - def __init__(self, name, doc, location): - super(class_info_t, self).__init__(name, doc, location) - self.classes = {} - self.functions = {} - self.variables = {} - -# -------------------------------------------------------------------------- -# C++ functions with body text - -class cpp_fun_info_t(object): - def __init__(self, name, body): - self.name = name - self.body = body - -# -------------------------------------------------------------------------- -# In this context, "storage" is an object with dictionaries -# named "classes", "functions" and "variables". -# This class implement common lookups for all such containers. - -KIND_CLASS = "class" -KIND_UNION = "union" -KIND_STRUCT = "struct" -KIND_FUNCTION = "function" -KIND_VARIABLE = "variable" -KIND_DEFINE = "define" -KIND_FILE = "module" - -class repo_t(object): - def __init__(self, storage, ident): - self.storage = storage - self.ident = ident - - def match(self, kind, long_name): - return self._match(kind, long_name.split("."), self.storage) - - def _match(self, kind, chain, storage): - name = chain[0] - - if len(chain) > 1: - # only classes left of dots - if name not in storage.classes: - return None - - return self._match(kind, chain[1:], storage.classes[name]) - - # right terminal - - if kind == KIND_CLASS: - return storage.classes.get(name, None) - elif kind == KIND_FUNCTION: - return storage.functions.get(name, None) - elif kind == KIND_VARIABLE: - return storage.variables.get(name, None) - - return None - -# -------------------------------------------------------------------------- -# AST navigation common to wrappers/*.py files -# and s in swig/*.i files -# (they are both Python code) - -class pydoc_visitor_t(ast.NodeVisitor): - - WARN_ON_VARIABLE = "Docstring on assignment not recognized" - - ADD_CLASS = 1 - ADD_FUNCTION = 2 - ADD_VARIABLE = 3 - - def __init__(self, classes, functions, variables): - self.super = super(pydoc_visitor_t, self) - self.super.__init__() - - self.classes = classes - self.functions = functions - self.variables = variables - - self.assign_line = -1 - - def collect_from(self, tree): - self.in_class = [] - self.in_func = [] - self.generic_visit(tree) - - def visit_ClassDef(self, node): - info = self._info_class_or_func(node, class_info_t, self.in_func) - if info is None: - return - - self._add(info, self.ADD_CLASS) - - self.in_class.append(info) - self.super.generic_visit(node) - self.in_class.pop() - - def visit_FunctionDef(self, node): - # ignore "replfun"-decorated functions - for dec in node.decorator_list: - if isinstance(dec, ast.Attribute) and dec.attr == "replfun": - return - - info = self._info_class_or_func(node, doc_info_t, self.in_func) - if info is None: - return - - self._add(info, self.ADD_FUNCTION) - - self.in_func.append(info) - self.super.generic_visit(node) - self.in_func.pop() - - def visit_If(self, node): - # ignore declarations in block (formerly, if _BC695) - - pass # no call to generic_visit into its body - - def visit_Assign(self, node): - if self.in_func: - return - - self.assign_line = location_t.last_line(node) - # unless stated otherwise - self.assign_warn = self.WARN_ON_VARIABLE - - # only syntax accepted: var = expr or self.member = expr - # (as opposed to v1 = v2 = expr, or var += expr, or obj.member = expr) - - if len(node.targets) != 1: - return - target = node.targets[0] - - if isinstance(target, ast.Attribute): - if not isinstance(target.value, ast.Name): - return - if target.value.id != "self": - return - if not self.in_class: - self.assign_warn = "\"self.%s\" not inside a class" \ - % target.attr - return - - name = target.attr - - elif isinstance(target, ast.Name): - name = target.id - else: - return - - # success - - self.assign_node = node - self.assign_var = name - self.assign_warn = None - - # aim to add a comment after this line, if there isn't one - info = doc_info_t(self.assign_var, "", location_t(node)) - self._add(info, self.ADD_VARIABLE) - - def visit_AugAssign(self, node): - if self.in_func: - return - - # unaccepted syntax, f.i. var += expr - self.assign_line = location_t.last_line(node) - self.assign_warn = self.WARN_ON_VARIABLE - - def visit_Expr(self, node): - if self.in_func: - return - - if isinstance(node.value, ast.Str): - if hasattr(node, "end_lineno"): - line_before = node.lineno - 1 # "lineno" is the start line - else: - # hack until Python 3.8 - num_lines = len(node.value.s.split("\n")) - line_before = node.lineno - num_lines # "lineno" is the end line - - if line_before == self.assign_line: - # the string follows an assignment - # (as opposed to a class or function) - - if self.assign_warn: - log_verb("%s, line %d: %s" - % (self.path, node.lineno, self.assign_warn)) - return - - docstring = self._clean_docstring(node.value.s) - - # update the info structure already collected on Assign - - storage = self.in_class[-1] if self.in_class else self - info = storage.variables[self.assign_var] - - info.doc = docstring - info.location = location_t(node, self.assign_node) - - def _info_class_or_func(self, node, info_type, nested): - private = node.name[0] == "_" and node.name[:2] != "__" - if private or nested: - # ignore internals - if not private: - log_verb("Ignoring nested (%s): %s" - % (nested[-1].name, node.name)) - return None - - docstring = self._get_docstring(node) - - return info_type(node.name, docstring, - location_t(node.body[0], node)) - - def _add(self, info, add_type): - target = self.in_class[-1] if self.in_class else self - - if add_type == self.ADD_CLASS: - storage = target.classes - msg = KIND_CLASS - elif add_type == self.ADD_FUNCTION: - storage = target.functions - msg = KIND_FUNCTION - else: - storage = target.variables - msg = KIND_VARIABLE - - if info.name in storage: - if self.in_class: - if msg == KIND_FUNCTION: - msg = "method" - msg = "%s in class %s" % (msg, target.name) - - log_verb("Duplicate %s: %s" % (msg, info.name)) - return # keep the first - - storage[info.name] = info - - info.parent = None if target is self else target - - def _get_docstring(self, node): - # clean a docstring manually, as we would for strings after a variable - return self._clean_docstring(ast.get_docstring(node, False)) - - def _clean_docstring(self, docstring): - if docstring: - inspect_importer = inspect_importer_t.get_singleton() - inspect_importer.ensure_imported_inspect() - - docstring = inspect_importer.inspect.cleandoc(docstring) - - return docstring - -# -------------------------------------------------------------------------- -# for s in swig/*.i files - -class swig_pydoc_collector_t(object): - def __init__(self): - super(swig_pydoc_collector_t, self).__init__() - - self.re_pydoc = re.compile(r"^#.*?$" - r"(.*?)" - r"^#.*?$", re.MULTILINE | re.DOTALL) - - def collect(self, path): - # collect ... texts - - with open(path, "r") as f: - text = f.read() - - pydocs = [] - start = 0 - while text: - m = self.re_pydoc.search(text, start) - if not m: - break - pydocs.append(m.group(1)) - start = m.end() - - # parse the pydocs for docstrings - - self.classes = {} - self.functions = {} - self.variables = {} - - visitor = pydoc_visitor_t(self.classes, self.functions, self.variables) - - for pydoc in pydocs: - try: - log_verb("swig_pydoc_collector_t: parsing clob %s" % pydoc) - tree = ast.parse(pydoc) - except Exception as ex: - message = ex.__class__.__name__ + ": " + str(ex) - raise pysyntax_exception_t(message, pydoc) - - visitor.collect_from(tree) - -# -------------------------------------------------------------------------- -# for wrappers/*.cpp files - -class cpp_wrapper_parser_t(object): - def __init__(self): - self.re_wrap = re.compile(r".*PyObject *\*_wrap_([^\(]*)\(.*\) *{") - self.re_string = re.compile(r"([\"'])(?:\\?.)*?\1") - self.re_curly = re.compile(r"[{}]") - - def collect(self, path): - # only "functions" filled in - self.classes = {} - self.functions = {} - self.variables = {} - - self.path = path # for cppsyntax_exception_t - - with open(path, "r") as f: - text = f.read() - - # remove strings - # (to avoid being confused by "{" "}" inside strings) - text = self.re_string.sub("", text) - # no need to remove comments - # because these _wrap_* functions are computer-generated code, - # they contain no comments - - start = 0 - while text: - m = self.re_wrap.search(text, start) - if not m: - break - self.fun_name = m.group(1) # for cppsyntax_exception_t - start, end = self._find_body(text, m.start()) - body = text[start:end] - - self.functions[self.fun_name] = cpp_fun_info_t(self.fun_name, body) - start = end - - def _find_body(self, text, pos): - count = 0 - while True: - m = self.re_curly.search(text, pos) - if not m: - break - - if m.group()[0] == "{": - if count == 0: - start = m.start() - count += 1 - else: - if count == 0: - break - count -= 1 - if count == 0: - return start, m.end() - - pos = m.end() - - raise cppsyntax_exception_t(self, "Cannot find body") - -# -------------------------------------------------------------------------- -# get return types from patterns in the C++ body - -class cpp_patterns_t(object): - PATTERNS = ( - ("resultobj = _maybe_sized_cstring_result(", "str"), - ("resultobj = _maybe_cstring_result(", "str"), - ("resultobj = _maybe_binary_result(", "str"), - ("resultobj = _maybe_cstring_result_on_charptr_using_allocated_buf(", "str"), - ("resultobj = _maybe_cstring_result_on_charptr_using_qbuf(", "str"), - ("resultobj = _maybe_byte_array_as_hex_or_none_result(", "str"), - ("resultobj = _maybe_byte_array_or_none_result(", "bytes"), - ("resultobj = _sized_cstring_result(", "str") - ) - - def from_pattern(self, fun_info): - have_type = None - - for pattern, ret_type in cpp_patterns_t.PATTERNS: - if fun_info.body.find(pattern) >= 0: - if have_type: - log_verb("C++ function \"%s\", multiple patterns match" - % fun_info.name) - have_type = ret_type - - return have_type - -# -------------------------------------------------------------------------- -class hook_info_t(object): - def __init__(self, storage, data): - self.filename, \ - self.enum_name, \ - self.discard_prefixes, \ - self.discard_doc, \ - self.strip_prefixes, \ - recipe_module = data - - self.storage = storage - self.discard_prefixes = tuple(self.discard_prefixes) - self.recipe = recipe_module.recipe - self.default_rtype = recipe_module.default_rtype - self.ignore_parameters = {} - - def add_fun(self, klass, fun, doc): - if klass in self.storage.classes: - info = self.storage.classes[klass] - else: - info = self.storage.classes[klass] = class_info_t(klass, "", None) - - if fun in info.functions: - log_verb("%s: existing function collides with hook callback \"%s\"" - % (klass, fun)) - - info.functions[fun] = fun_info = doc_info_t(fun, doc, None) - - def ignore_parameter(self, fun, param): - if fun not in self.ignore_parameters: - self.ignore_parameters[fun] = set() - - self.ignore_parameters[fun].add(param) - -# -------------------------------------------------------------------------- -class doxygen_info_t(object): - def __init__(self, xml_dir): - self.xml_dir = xml_dir - - self.module = None - self.classes = {} - self.functions = {} - self.variables = {} - - self.hook_recipes = {} - - # hook (callback) functions from C++ enumerations - - def get_hook_info(self, klass): - return self.hook_recipes.get(klass) - - def load_hooks(self): - file_index = {} - - for klass in all_recipes.hooks: - hook = all_recipes.hooks[klass] - - self.hook_recipes[klass] = info = hook_info_t(self, hook) - - if info.filename in file_index: - index_entry = file_index[info.filename] - else: - index_entry = file_index[info.filename] = {} - index_entry[info.enum_name] = klass - - for filename in file_index: - pathname = os.path.join(self.xml_dir, filename) - if not os.path.exists(pathname): - log_verb("A hook recipe calls for XML file \"%s\"," - " which does not exist!" - % filename) - continue - - with open(pathname, "r") as f: - xml = ET.fromstring(f.read()) - - for compound_kind, section_kind, member_kind, name, _, _, _, enum_nodes \ - in self._enumerate_names(xml): - - if member_kind != "enum" or name not in file_index[filename]: - continue - klass = file_index[filename][name] - info = self.hook_recipes[klass] - - if enum_nodes is None: - log_verb("Hooks recipe \"%s\" calls for enum \"%s\"" - " in file \"%s\", which has no data!" - % (klass, info.enum_name, filename)) - continue - - for node in enum_nodes: - data = self._candidate_value(node, compound_kind, section_kind, member_kind, name) - if data: - _, _, _, \ - value_name, brief_node, detailed_node, _, _ = data - - if value_name.startswith(info.discard_prefixes): - continue - - brief_doc = self._outer_paragraphs(brief_node) - detailed_doc = self._outer_paragraphs(detailed_node) - doc = self._join_paragraphs( (brief_doc, detailed_doc) ) - - if info.discard_doc and doc.startswith(info.discard_doc): - continue - if doc.startswith("cb:"): - doc = doc[3:].lstrip() - - for prefix in info.strip_prefixes: - if value_name.startswith(prefix): - value_name = value_name[len(prefix):] - break - - if not self._follow_recipe(info, value_name): - continue - - info.add_fun(klass, value_name, doc) - - def _follow_recipe(self, info, fun_name): - if fun_name not in info.recipe: - return True - - recipe = info.recipe[fun_name] - - if recipe.get("ignore", False): - return False - - if "params" in recipe: - params = recipe["params"] - for param_name in params: - param = params[param_name] - - if param.get("suppress_for_call", False): - info.ignore_parameter(fun_name, param_name) - - return True - - # recover comments from C++ classes / functions / variables - - def load(self, module): - xmodule = self._load_module(module) - if xmodule is None: - return False - log_verb("Loading module %s" % module) - self._examine_xml(xmodule, module, self) - return True - - def _examine_xml(self, xml, module_name, storage): - for name in self._enum_classes(xml): - if name not in storage.classes: - storage.classes[name] = class_info_t(name, "", None) - - xclass = self._load_class(xml, name) - self._examine_xml(xclass, module_name, storage.classes[name]) - - for compound_kind, section_kind, member_kind, name, brief_node, detailed_node, plist, enum_nodes \ - in self._enumerate_names(xml): - - brief_doc = self._outer_paragraphs(brief_node) - detailed_doc = self._outer_paragraphs(detailed_node) - doc = self._join_paragraphs( (brief_doc, detailed_doc) ) - - # log_verb("section_kind=%s, compound_kind=%s, member_kind=%s, name=%s, brief_doc=%s" % ( - # section_kind, - # compound_kind, - # member_kind, - # name, - # brief_doc)) - - if section_kind == "": - if compound_kind in (KIND_CLASS, KIND_STRUCT, KIND_UNION): - if name in storage.classes: - storage.classes[name].doc = doc - else: - storage.classes[name] = class_info_t(name, doc, None) - elif compound_kind == "file" and name.startswith("%s.h" % module_name): - storage.module = self._join_paragraphs( (brief_doc, detailed_doc) ) - continue - - if member_kind == KIND_FUNCTION: - storage.functions[name] = doc_info_t(name, doc, None, plist) - elif member_kind in (KIND_DEFINE, KIND_VARIABLE): - storage.variables[name] = doc_info_t(name, doc, None) - - # add enum values as variables definitions - - if enum_nodes is None: - continue - - for node in enum_nodes: - data = self._candidate_value(node, compound_kind, section_kind, member_kind, name) - if data: - _, _, _, \ - value_name, brief_node, detailed_node, _, _ = data - - brief_doc = self._outer_paragraphs(brief_node) - detailed_doc = self._outer_paragraphs(detailed_node) - doc = self._join_paragraphs( (brief_doc, detailed_doc) ) - - storage.variables[value_name] = doc_info_t(value_name, doc, None) - - def _enumerate_names(self, xml): - for compound in xml.findall("compounddef"): - compound_kind = compound.attrib["kind"] - - data = self._candidate_value(compound, - compound_kind) - if data: - yield data - - for section in compound.findall("sectiondef"): - section_kind = section.attrib["kind"] - - if section_kind.startswith("private-") or \ - section_kind.startswith("protected-") or \ - section_kind in ("friend"): - continue - - data = self._candidate_value(section, - compound_kind, - section_kind) - if data: - yield data - - for member in section.findall("memberdef"): - member_kind = member.attrib["kind"] - - data = self._candidate_value(member, - compound_kind, - section_kind, - member_kind, - "", - True) - if data: - yield data - - def _candidate_value(self, node, compound_kind, section_kind="", member_kind="", enum="", get_enums=False): - brief_node = node.find("briefdescription") - detailed_node = node.find("detaileddescription") - enum_nodes = node.findall("enumvalue") if get_enums else None - - if brief_node is None and \ - detailed_node is None and \ - enum_nodes is None: - return None - - plist = [] - for pnode in node.findall("param"): - plist.append(self._parse_param_node(pnode)) - - name_node = node.find("name" if section_kind else "compoundname") - name = "" - if name_node is not None: - name = name_node.text - if not name: - log_verb("Doxygen xml: compound \"%s\", section \"%s\"," - " member \"%s\"%s has no name but has content!" - % (compound_kind, section_kind, member_kind, - (", enum \"%s\"" % enum) if enum else "")) - return None - - return compound_kind, section_kind, member_kind, name, brief_node, detailed_node, plist, enum_nodes - - def _parse_param_node(self, pnode): - name_child = pnode.find("declname") - type_child = pnode.find("type") - - ret = ["", ""] - if name_child is not None: - ret[0] = name_child.text - if type_child is not None: - ret[1] = self._clean(type_child) - return ret - - def _outer_paragraphs(self, node): - return self._paragraphs(node, True) - - def _paragraphs(self, node, wrap=False): - if node is None: - return "" - - texts = [self._nul(node.text)] - for para in node.findall("para"): - clean = self._clean(para) - if wrap: - clean = self._wrap(clean) - texts.append(clean) - - return self._join_paragraphs(texts) - - def _wrap(self, text): - lines = text.split("\n") - - out = [] - for line in lines: - subsequent_indent = "" - - clean = line.lstrip() - if clean and clean[0] == "@": - # compute indent for @tags - pos_colon = line.find(":") - if pos_colon >= 0: - subsequent_indent = (pos_colon + 2) * " " - - # wrapping at 80; if left at 70, - # texts from C++/Doxygen already contain - # linebreaks just after 70, that will - # make the wrapping ugly. Removing - # C++ linebreaks is probably not an option, - # if we want to respect pre-formatting. - out.extend(textwrap.wrap(line, 80, \ - subsequent_indent=subsequent_indent)) - - return "\n".join(out) - - def _join_paragraphs(self, texts): - # paragraphs (from "") separated by a blank line - - return "\n\n".join( (text.strip() for text in texts) ).strip("\n") - - def _clean(self, node): - N = self._nul - - texts = [N(node.text)] - for child in node: - check_subchildren = False - - if child.tag == "ref": - check_subchildren = True - texts[-1] += N(child.text) + N(child.tail) - - elif child.tag == "parameterlist": - self._add_parameter_list(child, texts) - - elif child.tag == "itemizedlist": - self._add_unordered_list(child, texts) - - elif child.tag == "orderedlist": - self._add_ordered_list(child, texts) - - elif child.tag == "simplesect": - kind = child.attrib["kind"] - desc = self._paragraphs(child) - # remove "@return: void" - if kind != "return" or desc != "void": - self._add_tag(kind, desc, texts) - - elif child.tag == "ulink": - check_subchildren = True - # macro interpreted in tools/docs/epytext.py - ref = child.attrib["url"] - if ref == child.text: - texts[-1] += r"\link{{{}}}".format(ref) - else: - texts[-1] += r"\link{{{},{}}}".format(ref, child.text) - texts[-1] += N(child.tail) - - elif child.tag == "linebreak": - check_subchildren = True - texts.append(child.tail) - - elif child.tag in ("mdash", "ndash"): - check_subchildren = True - texts[-1] += "-" + N(child.tail) - - elif child.tag == "sp": - check_subchildren = True - texts[-1] += " " + N(child.tail) - - elif child.tag in ("preformatted", "verbatim"): - # TODO? blockquote? may contain sub-elements like ) - - inner = [N(child.text)] - for sub in child: - if sub.tag == "ref": - # ignore the link markup inside a 
-                        inner[-1] += N(sub.text) + N(sub.tail)
-                    else:
-                        # fail
-                        check_subchildren = True
-                        break
-                if child.tail:
-                    inner.append(N(child.tail))
-                texts.append("".join(inner).strip("\n"))
-
-            elif child.tag == "computeroutput":
-                # like preformatted/verbatim above, but inline text
-                texts[-1] += N(child.text)
-                for sub in child:
-                    if sub.tag == "ref":
-                        # ignore the link markup
-                        texts[-1] += N(sub.text) + N(sub.tail)
-                    else:
-                        # fail
-                        check_subchildren = True
-                        break
-                texts[-1] += N(child.tail)
-
-            elif child.tag == "programlisting":
-                for sub in child:
-                    if sub.tag == "codeline":
-                        texts.append(self._clean(sub))
-                    else:
-                        # fail
-                        check_subchildren = True
-                        break
-                if child.tail:
-                    texts.append(N(child.tail))
-
-            elif child.tag == "codeline":
-                for sub in child:
-                    texts[-1] += self._clean(sub)
-                texts[-1] += N(child.tail)
-
-            elif child.tag == "highlight":
-                texts[-1] += self._clean(child)
-
-            else:
-                log_verb("Unrecognized tag \"%s\"" % child.tag)
-                if child.text is not None:
-                    texts.append(self._paragraphs(child))
-                if child.tail is not None:
-                    texts.append(child.tail)
-
-            if check_subchildren:
-                for sub in child:
-                    raise process_exception_t(
-                        "Unrecognized sub-tag \"%s\" under \"%s\"" \
-                        % (sub.tag, child.tag))
-
-        texts[-1] += N(node.tail)
-
-        return "\n".join(text.strip() for text in texts)
-
-    def _add_parameter_list(self, node, texts):
-        tag   = node.attrib["kind"]
-        plist = []
-        for param in node.findall("parameteritem"):
-            namelist    = param.find("parameternamelist")
-            description = param.find("parameterdescription")
-            names = []
-            if namelist is not None:
-                for name in namelist.findall("parametername"):
-                    names.append(self._clean(name))
-            if not names:
-                names = ["unknown"]
-            plist.append( (tag + " " + ",".join(names),
-                           self._paragraphs(description).strip()) )
-
-        # remove "@param none"
-        if len(plist) == 1 and plist[0] == ("param none", ""):
-            return
-
-        for tag, desc in plist:
-            self._add_tag(tag, desc, texts)
-
-    def _add_unordered_list(self, node, texts):
-        self._add_list(lambda n: "*", node, texts)
-
-    def _add_ordered_list(self, node, texts):
-        self._add_list(lambda n: "%d." % n, node, texts)
-
-    def _add_list(self, marker, node, texts):
-        num = 0
-        for item in node.findall("listitem"):
-            num += 1
-            para = self._paragraphs(item).strip()
-            texts.append(("%s " % marker(num)) + para)
-
-    def _add_tag(self, tag, text, texts):
-        result = "@%s" % tag
-        if text:
-            result += ": " + text
-        texts.append(result)
-
-    def _nul(self, text):
-        return text if text else ""
-
-    def _load_module(self, name):
-        for suffix in ("_8hpp", "_8h"):
-            xml_path = os.path.join(self.xml_dir, "%s%s.xml" % (name, suffix))
-            if os.path.isfile(xml_path):
-                with open(xml_path, "r") as f:
-                    return ET.fromstring(f.read())
-        return None
-
-    def _enum_classes(self, xml):
-        for node in xml.findall("compounddef/innerclass"):
-            yield node.text
-
-    def _load_class(self, xml, name):
-        # apparently, an xpath to search for the TEXT of an element
-        # is not available until Python 3.7
-        for node in xml.findall("compounddef/innerclass"):
-            if node.text == name:
-                break
-        else:
-            node = None
-
-        if node is None:
-            return None
-        xml_path = os.path.join(self.xml_dir, "%s.xml" % node.attrib["refid"])
-        with open(xml_path, "r") as fin:
-            return ET.fromstring(fin.read())
-
-# --------------------------------------------------------------------------
-# for wrappers/*.py files
-# (output goes typically to bin/.../python/[23])
-
-class pydoc_patcher_t(object):
-    def __init__(self):
-        self.traces = call_traces_t()
-        self.traces.load(args.traces)
-
-        self.cases = cases_t()
-        self.cases.load(args.cases)
-
-    def patch(self, infile, extra_sources, outfile):
-        swig, cpp, doxy = extra_sources
-
-        swig_repo = repo_t(swig, "SWiG")
-        cpp_repo  = repo_t(cpp, "CPP parsing")
-        doxy_repo = repo_t(doxy, "Doxygen parsing")
-
-        self.classes   = {}
-        self.functions = {}
-        self.variables = {}
-
-        with open(infile, "r") as f:
-            text  = f.read()
-            lines = text.split("\n")
-
-        try:
-            tree = ast.parse(text)
-        except Exception as ex:
-            # this text can be very long,
-            # so we're not including all of it in the exception
-            bad_line = "Line %d: %s" % (ex.lineno, lines[ex.lineno - 1]) \
-                if ex.lineno > 0 and ex.lineno <= len(lines) \
-                else "(line %s)" % str(ex.lineno)
-
-            message = ex.__class__.__name__ + ": " + str(ex)
-            raise pysyntax_exception_t(message, bad_line)
-
-        log_info("Collecting from %s" % infile)
-        with new_log_indent_t():
-            visitor = pydoc_visitor_t(self.classes, self.functions, self.variables)
-            visitor.collect_from(tree)
-
-        cpp_patterns = cpp_patterns_t()
-
-        NOT_SKIPPING = -1
-
-        by_line   = self._sort_docstrings(visitor)
-        skip_upto = NOT_SKIPPING
-
-        with open(outfile, "w") as f:
-            lineno = 0
-
-            for lidx, line in enumerate(lines):
-                if line.find("IDA Plugin SDK API wrapper") > -1:
-                    skip_upto = lidx + 1
-                    break
-
-            if doxy.module is not None:
-                f.write("\"\"\"\n")
-                f.write(doxy.module)
-                f.write("\"\"\"\n")
-
-            for line in lines:
-                lineno += 1
-
-                if by_line and by_line[0][1].location.start_line == lineno:
-                    kind, info   = by_line[0]
-                    skip_upto    = info.location.end_line
-                    indent       = info.location.start_col * " "
-                    quote_open   = indent + "r\"\"\"\n"
-                    quote_close  = indent + "\"\"\"\n"
-                    long_name    = self._long_name(info)
-                    special_case = self.cases.get(long_name)
-
-                    global selective_debug
-                    selective_debug = info.name == args.debug_name
-
-                    log_debug("### Processing %s" % long_name)
-
-                    # pywraps comments for functions typically contain
-                    # a function prototype before the parameter documentation;
-                    # for classes and variables, we add a dummy, empty prototype
-                    # to allow matching in the replace() function below.
-
-                    comment = structured_comment_t(kind != KIND_FUNCTION)
-                    comment.parse(info.doc)
-
-                    # "swig" and "doxy" have typically parameter documentation
-                    # without a prototype, so an empty prototype is added
-                    # (parameter True of structured_comment_t)
-                    # in order to attempt to parse @param tags from these texts
-                    # (as opposed to "free text before any prototype").
-
-                    doxy_kind = special_case.doxy_kind(kind) \
-                                if special_case else kind
-
-                    swig_cmt  = structured_comment_t(True)
-                    swig_info = swig_repo.match(kind, long_name)
-                    if swig_info and swig_info.doc:
-                        swig_cmt.parse(swig_info.doc)
-
-                    doxy_cmt  = structured_comment_t(True)
-                    doxy_info = doxy_repo.match(doxy_kind, long_name)
-                    if doxy_info and doxy_info.doc:
-                        # no prototypes from doxygen; also, avoid lines
-                        # wrapped by textwrap to be interpreted as
-                        # prototypes by accident
-                        doxy_cmt.parse(doxy_info.doc, parse_prototypes=False)
-                        # for functions, doxy_info.extra = C++ parameter types
-                        doxy_cmt.add_cpp_params(doxy_info.extra)
-
-                    cpp_info = cpp_repo.match(kind, long_name)
-
-                    log_debug("==== From wrappers (.py)\n" + comment.total())
-                    log_debug("==== From swig (.i)\n"      + swig_cmt.total())
-                    log_debug("==== From Doxygen (.xml)\n" + doxy_cmt.total())
-
-                    assembled = assembled_comment_t(special_case)
-                    if comment.text_before.strip():
-                        assembled.add_text_before(comment.text_before)
-                    elif swig_cmt.text_before.strip():
-                        assembled.add_text_before(swig_cmt.text_before)
-                    else:
-                        assembled.add_text_before(doxy_cmt.text_before)
-
-                    if comment.prototypes:
-                        for p in comment.prototypes:
-                            assembled.add_prototype(p)
-                    else:
-                        assembled.add_prototype(prototype_t(""))
-
-                    ret_type = cpp_patterns.from_pattern(cpp_info) \
-                               if cpp_info else None
-                    if ret_type:
-                        log_debug("==== Return type from C++/Doxygen: \"%s\"" % ret_type)
-                        for p in assembled.prototypes:
-                            p.replace_return_type(ret_type)
-                    else:
-                        have_pyobject = any(p.get_return_type() == "PyObject *" \
-                                            for p in assembled.prototypes)
-                        if have_pyobject:
-                            runtime_type = self.traces.suggest_return_type(long_name)
-                            if runtime_type:
-                                log_debug("==== Return type from runtime trace: \"%s\"" \
-                                      % runtime_type)
-                                for p in assembled.prototypes:
-                                    if p.get_return_type() == "PyObject *":
-                                        p.replace_return_type(runtime_type)
-
-                    def replace(cmt):
-                        for p in cmt.prototypes:
-                            n = assembled.match_prototype(p)
-                            if n < 0:
-                                continue
-                            log_debug("==== Matched prototype # %d, replaced" % n)
-                            assembled.replace_after_prototype(n, p)
-
-                    # SWIG has precedence
-                    if swig_cmt.parsed:
-                        log_debug("==== Taking from swig:")
-                        replace(swig_cmt)
-                    elif doxy_cmt.parsed:
-                        log_debug("==== Taking from doxygen:")
-                        replace(doxy_cmt)
-
-                    if info.parent:
-                        hook = doxy.get_hook_info(info.parent.name)
-                        if hook:
-                            assembled.ignore_parameters(
-                                hook.ignore_parameters.get(info.name))
-
-                    out_comment = assembled.total()
-                    log_debug("==== Final comment:\n" + out_comment)
-                    if out_comment:
-                        f.write(quote_open)
-                        f.write(self._indent(indent, out_comment))
-                        f.write(quote_close)
-                    else:
-                        log_debug("==== (Empty, not written)")
-
-                    if info.doc:
-                        if skip_upto == lineno:
-                            skip_upto = NOT_SKIPPING
-                    else:
-                        # no comment at source: the start line is actual code
-                        f.write(line + "\n")
-                        skip_upto = NOT_SKIPPING
-
-                    by_line = by_line[1:]
-                    continue
-
-                if skip_upto == NOT_SKIPPING:
-                    f.write(line + "\n")
-                else:
-                    if skip_upto == lineno:
-                        skip_upto = NOT_SKIPPING
-                    continue
-
-        self._final_check(tree, outfile)
-
-    class simplifier_t(ast.NodeVisitor):
-        # Produce a simplified version of the AST
-        # (flattened list, containing ony node names)
-        # but without any string node
-        # (it is not enough to leave a "Str" name without string content;
-        #  some docstring may have been removed).
-        # Expr nodes are also removed; docstrings are an Expr(Str()),
-        # and Exprs containing something more complex will show the interior nodes.
-
-        def simplify(self, subtree):
-            self.output = []
-            self.generic_visit(subtree)
-
-            return self.output
-
-        def visit(self, node):
-            if not isinstance(node, (ast.Str, ast.Expr)):
-                self.output.append(node.__class__.__name__)
-
-            super(pydoc_patcher_t.simplifier_t, self).generic_visit(node)
-
-    def _final_check(self, tree, outfile):
-        # check that we produced valid Python code
-
-        with open(outfile, "r") as f:
-            try:
-                # part 1: can it be parsed?
-                final_tree = ast.parse(f.read())
-
-                # part 2: basic AST comparison
-                simpl = pydoc_patcher_t.simplifier_t()
-                if simpl.simplify(tree) != simpl.simplify(final_tree):
-                    raise process_exception_t("Final AST comparison failed!")
-
-            except Exception as ex:
-                message = ex.__class__.__name__ + ": " + str(ex)
-                raise pysyntax_exception_t(message, outfile)
-
-    def _indent(self, indent, text):
-        lines = text.split("\n")
-        lines = [(indent + line if line.strip() else "") \
-                 for line in lines]
-
-        return "\n".join(lines)
-
-    def _long_name(self, info):
-        if info.parent:
-            return self._long_name(info.parent) + "." + info.name
-
-        return info.name
-
-    def _sort_docstrings(self, visitor):
-        docs = []
-
-        self._add_to_docs(visitor, docs)
-
-        for info in visitor.classes.values():
-            docs.append( (KIND_CLASS, info) )
-
-            self._add_to_docs(info, docs)
-
-        return sorted(docs, key=lambda pair: pair[1].location.start_line)
-
-    def _add_to_docs(self, obj, docs):
-        for info in obj.functions.values():
-            docs.append( (KIND_FUNCTION, info) )
-
-        for info in obj.variables.values():
-            docs.append( (KIND_VARIABLE, info) )
-
-# --------------------------------------------------------------------------
-# Runtime info from calls to the IDAPython API,
-# collected during special tests (t2 uitests ... --trace-idapython-calls)
-# and gathered together in one file by tools/collect_traces.py.
-# The name of this one file is passed to the program on the --traces option.
-
-class call_traces_t(object):
-    def load(self, path):
-        if not path or not os.path.exists(path):
-            self.traces = {}
-            return
-
-        with open(path, "r") as f:
-            content = ast.literal_eval(f.read())
-
-            self.traces = {}
-            for key in content:
-                data = content[key]
-                if key == "#empty":
-                    # entry with special format
-                    for fun in data:
-                        self.traces[fun] = set(self._str(x) for x in data[fun])
-                else:
-                    self.traces[key] = set(self._str(x) for x in data["return"])
-
-    def _str(self, expr):
-        if isinstance(expr, list):
-            return "[" + ", ".join(self._str(x) for x in expr) + "]"
-        if isinstance(expr, tuple):
-            if len(expr) == 1:
-                return "(" + self._str(expr[0]) + ",)"
-            return "(" + ", ".join(self._str(x) for x in expr) + ")"
-
-        return str(expr)
-
-    def suggest_return_type(self, long_name):
-        key = args.module + "." + long_name
-
-        if key not in self.traces:
-            return None
-
-        # type [, type ...] [or None]
-
-        return_set = self.traces[key]
-        none_repr = "NoneType"
-        if none_repr in return_set:
-            suffix = " or None"
-            return_set.remove(none_repr)
-        else:
-            suffix = ""
-
-        types = ", ".join(sorted(return_set))
-        if not types:
-            return None
-
-        return types + suffix
-
-# --------------------------------------------------------------------------
-# Exceptions to the general rule.
-
-class cases_t(object):
-    def load(self, path):
-        if args.cases:
-            with open(path, "r") as f:
-                self.cases = ast.literal_eval(f.read())
-        else:
-            self.cases = {}
-
-        for fun in self.cases:
-            self.cases[fun] = case_t(fun, self.cases[fun])
-
-    def get(self, long_name):
-        key = args.module + "." + long_name
-
-        return self.cases[key] if key in self.cases else None
-
-# --------------------------------------------------------------------------
-# Special case for one symbol.
-
-class case_t(object):
-    def __init__(self, symbol, items):
-        self.symbol = symbol
-        self.items  = items
-
-        for item in items:
-            if "param" in item:
-                item["param"] = set(item["param"].split("|"))
-            if "change" in item:
-                item["change"] = self._to_function(item["change"])
-
-    def _to_function(self, code_text):
-        code_fun_name = "__INJECT_PYDOC__case"
-
-        code     = ast.parse(code_text.strip())
-        module   = ast.parse("def %s(_):\n pass" % code_fun_name)
-        function = module.body[0]
-        function.body = code.body
-
-        scope  = {}
-        exec(compile(module, "" % self.symbol, "exec"), scope)
-
-        return scope[code_fun_name]
-
-    def ignore_parameter(self, name):
-        # supercedes any special case
-        for item in self.items:
-            if "param" in item and name in item["param"]:
-                if len(item["param"]) == 1:
-                    # an action for just this parameter. Hijack it
-                    item["ignore"] = True
-                else:
-                    # remove the parameter from this action, add a new one
-                    item["param"].remove(name)
-                    self._append_ignore_action(name)
-                break
-        else:
-            # add exception
-            self._append_ignore_action(name)
-
-    def _append_ignore_action(self, name):
-        self.items.append({
-            "param" : set([name]),
-            "ignore" : True
-        })
-
-    def is_parameter_ignored(self, name):
-        item = self._get_param_action(name)
-
-        return item and item.get("ignore", False)
-
-    def change_param(self, name, desc):
-        item = self._get_param_action(name)
-        if item:
-            change = item.get("change")
-            if change:
-                name, desc = change([name, desc])
-
-        return name, desc
-
-    def _get_param_action(self, name):
-        for item in self.items:
-            if "param" in item and name in item["param"]:
-                return item
-        return None
-
-    def doxy_kind(self, kind):
-        attr = "doxy-kind"
-        for item in self.items:
-            if attr in item:
-                return item[attr]
-        return kind
-
-# --------------------------------------------------------------------------
-# A function prototype, plus parameters and some text around.
-
-class prototype_t(object):
-    RE_PARAM = re.compile(r" *([A-Za-z0-9_]+)(?: *=.*?)? *([\),])")
-
-    def __init__(self, *parts):
-        self.proto   = list(parts)  # [0] name, [1] parameters, [2] return type
-        self.after   = ""
-        self.params  = []
-        self.ctypes  = {}
-        self.inter   = []  # text after each parameter
-        self.retn    = ""
-        self.ignored = False
-
-        self._split_params_in_proto()
-
-    def _split_params_in_proto(self):
-        self.param_names = []
-
-        if len(self.proto) < 2:
-            return
-
-        start = 1  # parameter list; skip "(" at 0
-        while True:
-            m = self.RE_PARAM.match(self.proto[1], start)
-            if not m:
-                break
-
-            name, delimiter = m.groups()
-            if name[0] == "_" and len(name) > 1:    # "self", not "_self"
-                name = name[1:]
-            self.param_names.append(name)
-
-            if delimiter == ")":
-                break
-            start = m.end()
-
-    def get_return_type(self):
-        if len(self.proto) < 2:
-            return None
-
-        return self.proto[-1]
-
-    def replace_return_type(self, ret_type):
-        if len(self.proto) < 2:
-            return  # no-op for dummy prototypes
-
-        if len(self.proto) == 2:
-            self.proto.append(ret_type)
-        else:
-            self.proto[-1] = ret_type
-
-    def text_after_proto(self, line):
-        self.after += line + "\n"
-
-    def add_parameter(self, *parts):
-        self.params.append(parts)
-        self.inter .append("")
-
-    def add_cpp_param(self, name, ctype):
-        self.ctypes[name] = ctype
-
-    def text_after_last_param(self, line):
-        self.inter[-1] += line + "\n"
-
-    def text_return(self, line):
-        self.retn += line + "\n"
-
-    def clone(self):
-        copy = prototype_t(*self.proto)
-        copy.ctypes = dict(self.ctypes)
-        copy.after  = self.after
-        copy.retn   = self.retn
-
-        for p, t in zip(self.params, self.inter):
-            copy.params.append(tuple(p))
-            copy.inter .append(t)
-
-        return copy
-
-    def total(self, case=None):
-        # ignored? (typically from assembled_comment_t._clear_repeats)
-        if self.ignored:
-            return ""
-
-        part_1 = self.repr_proto() \
-               + self._clean(self.after)
-
-        part_2 = ""
-        for p, t in zip(self.params, self.inter):
-            # note: not cleaning texts after parameters ("t")
-            #       to preserve some of the original formatting
-
-            if self._is_parameter_ignored(p, case):
-                repr_p = ""
-                text_p = []
-                for line in t.split("\n"):
-                    # remove text associated to an ignored parameter,
-                    # but stop removing on the next @tag
-                    # (which may be other than @param)
-
-                    if text_p:
-                        text_p.append(line)
-                    else:
-                        line_text = line.lstrip()
-                        if line_text and line_text[0] == "@":
-                            text_p.append(line)
-                t = "\n".join(text_p)
-            else:
-                repr_p = self._repr_param(p, case)
-
-            part_2 += repr_p + t
-
-        clean_retn = self._clean(self.retn)
-        if clean_retn:
-            part_2 += "@return: " + clean_retn
-
-        return "\n".join(part for part in (part_1, part_2) if part)
-
-    def _is_parameter_ignored(self, parts, case):
-        if not case:
-            return False
-
-        _, name, _ = parts
-        return case.is_parameter_ignored(name)
-
-    def _repr_param(self, parts, case):
-        indent, name, desc = parts
-
-        if case:
-            name, desc = case.change_param(name, desc)
-
-        text = indent + "@param " + name
-        if name.startswith("NONNULL_") and not name in self.ctypes:
-            name = name[8:]
-        if name in self.ctypes:
-            if desc == self.ctypes[name]: # avoid some duplication
-                desc = ""
-            desc = ("(C++: %s)" % self.ctypes[name]) \
-                 + (" " if desc else "") + desc
-        if desc:
-            text += ": " + desc
-
-        return text + "\n"
-
-    def _clean(self, text):
-        cleaned = text.strip("\n")
-        if cleaned:
-            cleaned += "\n"
-        return cleaned
-
-    def repr_proto(self):
-        if not self.proto[0]:
-            return ""
-
-        if len(self.proto) == 1:
-            log_verb("Internal error, prototype with only 1 part: %s"
-                 % repr(self.proto))
-            return self.proto[0] + "\n"
-
-        if len(self.proto) == 2:
-            return "".join(self.proto) + "\n"
-
-        return "".join(self.proto[:-1]) \
-             + " -> " + self.proto[-1] + "\n"
-
-# --------------------------------------------------------------------------
-# Class to split a docstring into parts (prototype, parameter information, etc.)
-#
-# Docstrings are considered to be of the form:
-#   (prototype, optionally parameters) repeated zero or more times,
-#   with arbitrary text anywhere in-between.
-#
-# Prototypes are required to have NO space between function name and
-# open parenthesis, otherwise many texts would look like a prototype.
-
-class structured_comment_t(object):
-
-    WORD       = r"[A-Za-z_][A-Za-z0-9_]*"
-    PROTO_HEAD = r"(%s)(\(.*?\))" % WORD
-
-    RE_WORD   = re.compile(WORD)
-    RE_PARAM  = re.compile(r"(%s) *: *([< ]*%s.*)" % (WORD, WORD))
-    RE_PROTO1 = re.compile(PROTO_HEAD + r"$")
-    RE_PROTO2 = re.compile(PROTO_HEAD + r" *-> *(.*)")
-    RE_TITLE  = re.compile(r"[Pp]arameters? *:?$")  # Parameters
-    RE_DASHES = re.compile(r"-+$")                  # ----------
-    RE_INDENT = re.compile(r" *")
-
-    PAT_NONE   = 0
-    PAT_PROTO  = 1
-    PAT_PARAM  = 2
-    PAT_TITLE  = 3
-    PAT_RETURN = 4
-    PAT_TEXT   = 5
-
-    def __init__(self, always_a_prototype=False):
-        self.always_a_prototype = always_a_prototype
-
-        self.reset()
-        self.parsed = False
-
-    def reset(self):
-        self.text_before = ""
-        self.prototypes  = []
-        self.ctypes      = {}  # collected for only one prototype in Doxygen
-
-    def parse(self, text, parse_prototypes=True):
-        self.reset()
-        self.parsed = True
-
-        lines = text.split("\n") if text else [""]
-        prev  = self.PAT_NONE
-        state = self.PAT_NONE # used to decide where to store text
-                              # (after the prototype, or after a parameter)
-
-        if self.always_a_prototype:
-            self.prototypes.append(prototype_t(""))
-            state = self.PAT_PROTO
-
-        for line in lines:
-            pat  = self._pattern(line, prev, parse_prototypes)
-            prev = pat
-
-            if pat == self.PAT_TITLE:
-                continue
-
-            if pat == self.PAT_PROTO:
-                self.prototypes.append(prototype_t(*self.parts))
-
-            elif pat == self.PAT_PARAM:
-                if not self.prototypes:
-                    self.prototypes.append(prototype_t(""))
-                self.prototypes[-1].add_parameter(*self.parts)
-
-            elif pat == self.PAT_RETURN:
-                if not self.prototypes:
-                   self.prototypes.append(prototype_t(""))
-                self.prototypes[-1].text_return(self.parts[0])
-
-            elif pat == self.PAT_TEXT:
-                if self.prototypes:
-                    if state == self.PAT_PROTO:
-                        self.prototypes[-1].text_after_proto(line)
-                    elif state == self.PAT_PARAM:
-                        self.prototypes[-1].text_after_last_param(line)
-                    elif state == self.PAT_RETURN:
-                        self.prototypes[-1].text_return(line)
-                    else:
-                        self.text_before += line + "\n"
-                else:
-                    self.text_before += line + "\n"
-
-            if pat in (self.PAT_PROTO, self.PAT_PARAM, self.PAT_RETURN):
-                state = pat
-
-    def _pattern(self, line, prev, parse_prototypes):
-        # may also return extra information in self.parts
-
-        indent = self.RE_INDENT.match(line).group(0)
-        line   = line.strip()
-
-        if line.startswith("@"):
-            m = self.RE_WORD.search(line, 1)
-            if m:
-                tag = m.group(0)
-                if tag == "param":
-                    m = self.RE_WORD.search(line, m.end())
-                    if m:
-                        self.parts = indent, m.group(0), \
-                                     self._rest_after_colon(line, m)
-                        return self.PAT_PARAM
-                    raise process_exception_t("No word after @param: " + line)
-                if tag == "return":
-                    self.parts = (self._rest_after_colon(line, m),)
-                    return self.PAT_RETURN
-                else:
-                    return self.PAT_TEXT
-
-            log_verb("Missing or invalid tag after \"@\": " + line)
-            return self.PAT_TEXT
-
-        if self.RE_TITLE.match(line) or self.RE_DASHES.match(line):
-            return self.PAT_TITLE
-
-        m = self.RE_PARAM.match(line)
-        if m and prev != self.PAT_TEXT:
-            self.parts = (indent,) + m.groups()
-            return self.PAT_PARAM
-
-        if not indent and parse_prototypes:
-            for re in (self.RE_PROTO1, self.RE_PROTO2):
-                m = re.match(line)
-                if m:
-                    self.parts = m.groups()
-                    return self.PAT_PROTO
-
-        return self.PAT_TEXT
-
-    def _rest_after_colon(self, line, m):
-        rest = line[m.end():].strip()
-        if rest and rest[0] == ":":
-            rest = rest[1:].lstrip()
-        return rest
-
-    def add_cpp_params(self, plist):
-        if plist is None:
-            return
-        proto = self.prototypes[-1]
-        for name, ctype in plist:
-            proto.add_cpp_param(name, ctype)
-
-    def total(self):
-        # used only for debug output;
-        # no notion of "special cases" passed to prototype_t.total()
-
-        text = self.text_before
-        if text:
-            text = "\n" + text
-
-        protos = "\n".join(p.total() for p in self.prototypes)
-        if protos:
-            protos = "\n" + protos
-
-        return text + protos
-
-# --------------------------------------------------------------------------
-class assembled_comment_t(object):
-    def __init__(self, case):
-        self.case        = case
-        self.text_before = ""
-        self.prototypes  = []
-
-    def add_text_before(self, text):
-        self.text_before += text
-
-    def add_prototype(self, prototype):
-        self.prototypes.append(prototype.clone())
-
-    def match_prototype(self, given):
-        for i in range(len(self.prototypes)):
-            if self._match(self.prototypes[i], given):
-                return i
-        return -1
-
-    # add more detail if needed
-    def _match(self, p1, p2):
-        t1 = tuple(p1.proto)
-        t2 = tuple(p2.proto)
-
-        if t1 == ("",) or t2 == ("",):
-            # wildcard - possibly coming from structured_comment_t(True)
-            return True
-
-        return t1 == t2
-
-    def replace_after_prototype(self, i, given):
-        proto = self.prototypes[i]
-        if tuple(proto.proto) == ("",):
-            proto.proto       = given.proto
-            proto.param_names = given.param_names
-        proto.ctypes = given.ctypes
-        proto.after  = given.after
-        proto.retn   = given.retn
-
-        # replace only the parameters that match the prototype
-
-        old_params = proto.params
-        old_inter  = proto.inter
-        proto.params = []
-        proto.inter  = []
-
-        names_in_proto = proto.param_names
-        if len(names_in_proto) > 1 and names_in_proto[0] == "self":
-            names_in_proto = names_in_proto[1:]
-
-        given_params = self._params_fix(given.params, names_in_proto)
-
-        NAME = 1
-        index_old   = { old_params[i][NAME]   : (old_params[i], old_inter[i]) \
-                                                for i in range(len(old_params)) }
-        index_given = { given.params[i][NAME] : (given.params[i], given.inter[i]) \
-                                                for i in range(len(given.params)) }
-
-        selected = set()
-        for i in range(len(names_in_proto)):
-            param, inter = self._choose_param(i, names_in_proto,
-                            given.params, given.inter, index_given,
-                            old_params,   old_inter,   index_old)
-            if param is not None:
-                selected.add(param[NAME])
-                proto.params.append(param)
-                proto.inter .append(inter)
-
-        # extra given parameters (not in the prototype)
-        # are added but marked as ignored,
-        # so that additional @tags in the inter-text can be displayed
-
-        for i in range(len(names_in_proto), len(given.params)):
-            name = given.params[i][NAME]
-            if name not in selected:
-                log_debug("Param %d: ignored \"%s\"" % (i, name))
-                self.ignore_parameter(name)
-                proto.params.append(given.params[i])
-                proto.inter .append(given.inter [i])
-
-    def _params_fix(self, given_params, names_in_proto):
-        # make "py_XXX" match "XXX"
-
-        NAME = 1
-        for i in range(min(len(names_in_proto), len(given_params))):
-            given_param = list(given_params[i])
-            in_proto    = names_in_proto[i]
-
-            if in_proto[:3] == "py_" and in_proto[3:] == given_param[NAME]:
-                given_param[NAME] = in_proto
-                given_params[i] = tuple(given_param)
-
-    def _choose_param(self, i, names_in_proto,
-                            given_params, given_inter, index_given,
-                            old_params,   old_inter,   index_old):
-        def safe_index(i, arr):
-            return arr[i] if i < len(arr) else None
-
-        in_proto = names_in_proto[i]
-
-        # use a name if recognized, even if not in order
-        if in_proto in index_given:
-            given_param, given_inter = index_given[in_proto]
-        else:
-            given_param = safe_index(i, given_params)
-            given_inter = safe_index(i, given_inter)
-
-        if in_proto in index_old:
-            old_param, old_inter = index_old[in_proto]
-        else:
-            old_param = safe_index(i, old_params)
-            old_inter = safe_index(i, old_inter)
-
-        NAME = 1
-        DESC = 2
-
-        log_debug("Param %d: in prototype \"%s\", original doc \"%s\", given doc \"%s\""
-              % (i, in_proto, old_param[NAME] if old_param else "",
-                              given_param[NAME] if given_param else ""))
-
-        if given_param is None:
-            if old_param:
-                log_debug("- choosing old \"%s\" because none given" % old_param[NAME])
-            return old_param, old_inter
-
-        # make "py_XXX" match "XXX"
-        given_param = list(given_param)
-        if in_proto[:3] == "py_" and in_proto[3:] == given_param[NAME]:
-            given_param[NAME] = in_proto
-        given_param = tuple(given_param)
-
-        if in_proto == "" or given_param[NAME] == in_proto:
-            log_debug("- choosing given \"%s\"" % given_param[NAME])
-            return given_param, given_inter
-
-        if old_param is None:
-            log_debug("- no match")
-            return None, None
-
-        # even if there is no match,
-        # choose data if it appears to be more informative
-
-        if len(old_param[NAME]) <= 2 and len(given_param[NAME]) > 2:
-            log_debug("- choosing given \"%s\" because of short name \"%s\""
-                  % (given_param[NAME], old_param[NAME]))
-            return given_param, given_inter
-
-        if len(given_param[NAME]) <= 2 and len(old_param[NAME]) > 2:
-            log_debug("- choosing old \"%s\" because of short name \"%s\""
-                  % (old_param[NAME], given_param[NAME]))
-            return old_param, old_inter
-
-        if len(given_param[DESC]) > 3 * len(old_param[DESC]):
-            log_debug("- choosing given \"%s\" because it has more text"
-                  % given_param[NAME])
-            return given_param, given_inter
-
-        if old_param:
-            log_debug("- no good match, choosing old \"%s\""
-                  % old_param[NAME])
-        return old_param, old_inter
-
-    def ignore_parameters(self, ignore_set):
-        if ignore_set:
-            for name in ignore_set:
-                self.ignore_parameter(name)
-
-    def ignore_parameter(self, name):
-        if self.case is None:
-            self.case = case_t("", [])
-            # assembled_comment_t operates at the very end of the process;
-            # there is likely no need to store this dummy case_t in the
-            # dictionary of cases for all symbols (inside pydoc_patcher_t)
-
-        self.case.ignore_parameter(name)
-
-    def total(self):
-        self._clear_repeats()
-        return self.text_before + "".join(p.total(self.case) \
-                                          for p in self.prototypes)
-
-    def _clear_repeats(self):
-        unique = set()
-        for p in self.prototypes:
-            tuple_p = tuple(p.proto)
-            if tuple_p in unique:
-                p.ignored = True
-            else:
-                unique.add(tuple_p)
-
-# --------------------------------------------------------------------------
-def main():
-    if args.debug:
-        log_level = LOG_LEVEL_DEBUG
-    elif args.verbose:
-        log_level = LOG_LEVEL_VERB
-
-    log_info("Collecting from: %s" % args.interface)
-    with new_log_indent_t():
-        swig = swig_pydoc_collector_t()
-        swig.collect(args.interface)
-
-    log_info("Collecting from: %s" % args.cpp_wrapper)
-    with new_log_indent_t():
-        cpp = cpp_wrapper_parser_t()
-        cpp.collect(args.cpp_wrapper)
-
-    log_info("Collecting from: %s" % args.xml_doc_directory)
-    with new_log_indent_t():
-        doxy = doxygen_info_t(args.xml_doc_directory)
-        doxy.load_hooks()
-        doxy.load(args.module)
-
-    extra_sources = swig, cpp, doxy
-
-    log_info("Patching")
-    with new_log_indent_t():
-        patcher = pydoc_patcher_t()
-        patcher.patch(args.input, extra_sources, args.output)
-
-main()
diff --git a/tools/inject_pydoc/bytes.py b/tools/inject_pydoc/bytes.py
deleted file mode 100644
index b55825c..0000000
--- a/tools/inject_pydoc/bytes.py
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "op_stroff" : {
-        "+example" :
-"""
-ins = ida_ua.insn_t()
-if ida_ua.decode_insn(ins, some_address):
-    path_len = 1
-    path = ida_pro.tid_array(path_len)
-    path[0] = ida_struct.get_struc_id("my_stucture_t")
-    ida_bytes.op_stroff(ins, 0, path.cast(), path_len, 0)
-"""
-    }
-}
diff --git a/tools/inject_pydoc/idp.py b/tools/inject_pydoc/idp.py
deleted file mode 100644
index a32d307..0000000
--- a/tools/inject_pydoc/idp.py
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "ev_get_bg_color" : {
-        "repl_text" : ("(self, color, ea) -> int", "(self, ea) -> int or None"),
-    }
-}
diff --git a/tools/inject_pydoc_cases.txt b/tools/inject_pydoc_cases.txt
deleted file mode 100644
index bb0d71f..0000000
--- a/tools/inject_pydoc_cases.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-
-# Individual exceptions to the general processing in "inject_pydoc.py".
-
-{
-  "typeinf.til_t.base" : [
-    {
-      "doxy-kind" : "variable"
-    }
-  ]
-}
diff --git a/tools/inspect.py b/tools/inspect.py
index 72a8397..d808bd5 100644
--- a/tools/inspect.py
+++ b/tools/inspect.py
@@ -1955,14 +1955,8 @@ def _signature_fromstr(cls, obj, s, skip_bound_arg=True):
             except NameError:
                 raise RuntimeError()
 
-        if isinstance(value, str):
-            return ast.Str(value)
-        if isinstance(value, (int, float)):
-            return ast.Num(value)
-        if isinstance(value, bytes):
-            return ast.Bytes(value)
-        if value in (True, False, None):
-            return ast.NameConstant(value)
+        if isinstance(value, (str, int, float, bytes)) or value in (True, False, None):
+            return ast.Constant(value)
         raise RuntimeError()
 
     class RewriteSymbolics(ast.NodeTransformer):
diff --git a/tools/patch_codegen.py b/tools/patch_codegen.py
index 06cbbd5..a0da1e1 100644
--- a/tools/patch_codegen.py
+++ b/tools/patch_codegen.py
@@ -204,13 +204,16 @@ with open(args.input) as f:
                             "printf(\"swig/python detected a memory leak",
                             (
                                 "#ifdef TESTABLE_BUILD",
-                                "      if ( name == nullptr || strcmp(name, \"std::out_of_range *\") != 0 )",
-                                "        abort();",
+                                "      /* disabled because of https://github.com/swig/swig/issues/2638#issuecomment-1991845894 */",
+                                "      // if ( name == nullptr || strcmp(name, \"std::out_of_range *\") != 0 )",
+                                "        // abort();",
                                 "#endif",
                             ),
                         ),
                     ))
+
             line = line.replace(", ...arg0)", ", ...)")
+            line = line.replace(",...arg0)", ",...)")
         else:
             if line.find("(args") > -1:
                 current_function_uses_args = True
@@ -219,7 +222,8 @@ with open(args.input) as f:
             elif line.find("varargs") > -1:
                 current_function_uses_varargs = True
 
-            if line.find("SWIG_Python_AppendOutput") > -1:
+            if line.find("SWIG_Python_AppendOutput") > -1 \
+               or line.find("Will be tuplified") > -1:
                 current_function_uses_AppendOutput = True
             elif line.find("return resultobj;") > -1:
                 if current_function_uses_AppendOutput:
@@ -274,6 +278,15 @@ with open(args.input) as f:
                             repl = "\n".join(repl)
                         subst = line.rstrip().replace(patch_data[0], repl)
                         subst = "%s %s" % (subst, patched_cmt)
+                elif patch_kind == "release_gil_around":
+                    expr = patch_data
+                    idx = line.find(expr)
+                    if idx > -1:
+                        subst = [
+                            "SWIG_PYTHON_THREAD_BEGIN_ALLOW;",
+                            line,
+                            "SWIG_PYTHON_THREAD_END_ALLOW;",
+                        ]
                 elif patch_kind == "insert_before_text":
                     idx = line.find(patch_data[0])
                     if idx > -1:
diff --git a/tools/patch_codegen/expr.py b/tools/patch_codegen/expr.py
index 445b89f..e249175 100644
--- a/tools/patch_codegen/expr.py
+++ b/tools/patch_codegen/expr.py
@@ -3,5 +3,11 @@
         ("repl_text", (
             "PyObject *argv[2];",
             "PyObject *argv[2] = {0, 0};")),
-    ]
+    ],
+    "exec_system_script__SWIG_0" : [
+        ("release_gil_around", "exec_system_script(")
+    ],
+    "exec_system_script__SWIG_1" : [
+        ("release_gil_around", "exec_system_script(")
+    ],
 }
diff --git a/tools/patch_codegen/graph.py b/tools/patch_codegen/graph.py
index 48396c3..f5cd680 100644
--- a/tools/patch_codegen/graph.py
+++ b/tools/patch_codegen/graph.py
@@ -1,17 +1,17 @@
 {
-    "SwigDirector_abstract_graph_t::nrect" : [
+    "SwigDirector_drawable_graph_t::nrect" : [
         ("repl_text", ("return", "qnotused(c_result); qnotused(n); // return")),
     ],
-    "SwigDirector_abstract_graph_t::get_edge" : [
+    "SwigDirector_drawable_graph_t::get_edge" : [
         ("repl_text", ("return", "qnotused(c_result); qnotused(e); // return")),
     ],
-    "SwigDirector_abstract_graph_t::clone" : [
+    "SwigDirector_drawable_graph_t::clone" : [
         ("repl_text", ("return", "qnotused(c_result); // return")),
     ],
-    "SwigDirector_mutable_graph_t::get_edge" : [
+    "SwigDirector_interactive_graph_t::get_edge" : [
         ("repl_text", ("return", "qnotused(c_result); qnotused(e); // return")),
     ],
-    "SwigDirector_mutable_graph_t::clone" : [
+    "SwigDirector_interactive_graph_t::clone" : [
         ("repl_text", ("return", "qnotused(c_result); // return")),
     ],
 }
diff --git a/tools/patch_directors_cc.py b/tools/patch_directors_cc.py
index 31a32f0..8959dee 100644
--- a/tools/patch_directors_cc.py
+++ b/tools/patch_directors_cc.py
@@ -71,10 +71,10 @@ patches = [
     "virtual int idaapi walk_forward",
     "virtual int idaapi walk_backward",
 
-    # mutable_graph_t
+    # interactive_graph_t
     "virtual rect_t &idaapi nrect",
     "virtual edge_info_t *idaapi get_edge",
-    "virtual abstract_graph_t *idaapi clone",
+    "virtual drawable_graph_t *idaapi clone",
     "virtual bool idaapi set_nrect",
     "virtual bool idaapi set_edge",
     "virtual int idaapi add_node",
@@ -83,7 +83,7 @@ patches = [
     "virtual bool idaapi del_edge",
     "virtual bool idaapi replace_edge",
     "virtual bool idaapi refresh",
-    "virtual mutable_graph_t *idaapi clone",
+    "virtual interactive_graph_t *idaapi clone",
     "virtual bool idaapi redo_layout",
     "virtual void idaapi resize",
     "virtual ea_t idaapi calc_group_ea",
diff --git a/tools/patch_h_codegen.py b/tools/patch_h_codegen.py
index cf2a2b8..5a1eb2a 100644
--- a/tools/patch_h_codegen.py
+++ b/tools/patch_h_codegen.py
@@ -21,6 +21,7 @@ if os.path.isfile(args.patches):
     all_lines = []
     for l in lines:
         l = l.replace(", ...arg0)", ", ...)")
+        l = l.replace(",...arg0)", ",...)")
         all_lines.append(l)
 
     import tempfile
diff --git a/tools/py_scanner.py b/tools/py_scanner.py
index 9138c79..4498282 100644
--- a/tools/py_scanner.py
+++ b/tools/py_scanner.py
@@ -8,7 +8,6 @@ import os
 p = argparse.ArgumentParser()
 p.add_argument("-p", "--paths", type=str, required=True, help="Path(s) to the file(s) to parse")
 p.add_argument("-c", "--dump-doc", default=False, action="store_true", help="Dump python docstrings")
-p.add_argument("-k", "--dump-kind", default=False, action="store_true", help="Dump scopes kinds (class, method, ...)")
 args = p.parse_args()
 
 class scope_t(object):
@@ -30,9 +29,6 @@ class scope_t(object):
     def new_class(self, node):
         return self._new_scope(class_t, node)
 
-    def new_method(self, node):
-        return self._new_scope(method_t, node)
-
     def new_function(self, node):
         return self._new_scope(function_t, node)
 
@@ -64,9 +60,6 @@ class module_t(scope_t):
 class class_t(scope_t):
     pass
 
-class method_t(scope_t):
-    pass
-
 class function_t(scope_t):
     pass
 
@@ -76,15 +69,102 @@ class variable_t(scope_t):
 
 
 DF_DOC  = 0x1
-DF_KIND = 0x2
+
+# https://gist.github.com/MineRobber9000/485e648da3a77d5894fa1fe9189b5728
+def produce_function_prototype(node, name):
+
+    def get_value(node):
+        if type(node) == ast.Name:
+            return node.id
+        if type(node) == ast.Num:
+            return str(node.n)
+        if type(node) == ast.Subscript:
+            return get_value(node.value)+"["+get_value(node.slice)+"]"
+        if type(node) == ast.Index:
+            return get_value(node.value)
+        if type(node) == ast.Tuple:
+            return ", ".join(map(get_value,node.elts))
+        if type(node) == ast.Ellipsis:
+            return "..."
+        if type(node) == ast.NameConstant:
+            return str(node.value)
+        if type(node) == ast.Attribute:
+            return get_value(node.value)+"."+node.attr
+        if type(node) == ast.Constant:
+            value = str(node.value)
+            if isinstance(node.value, str):
+                value = f'"{value}"'
+            return value
+        if type(node) == ast.List:
+            pieces = map(get_value, node.elts)
+            return "[" + ", ".join(pieces) + "]"
+        if type(node) == ast.UnaryOp:
+            return get_value(node.op) + get_value(node.operand)
+        if type(node) == ast.BinOp:
+            return get_value(node.left) + get_value(node.op) + get_value(node.right)
+        if type(node) == ast.USub:
+            return "-"
+        if type(node) == ast.BitOr:
+            return "|"
+        print(type(node))
+        return "???"
+
+    out = [name, "("]
+    def put(what):
+        if what is not None:
+            out.append(what)
+
+    defs = len(node.args.args) - len(node.args.defaults)
+    for n, arg in enumerate(node.args.args):
+        put(arg.arg)
+        if arg.annotation:
+            put(": ")
+            put(get_value(arg.annotation))
+        if n >= defs:
+            put(" = ")
+            put(get_value(node.args.defaults[n-defs]))
+        put(", ")
+    if node.args.vararg:
+        put("*")
+        put(node.args.vararg.arg)
+        if node.args.vararg.annotation:
+            put(": ")
+            put(get_value(node.args.vararg.annotation))
+        put(", ")
+    if node.args.kwarg:
+        put("**")
+        put(node.args.kwarg.arg)
+        if node.args.kwarg.annotation:
+            put(": ")
+            put(get_value(node.args.kwarg.annotation))
+        put(", ")
+    if node.args.kwonlyargs:
+        if not node.args.vararg:
+            put("*, ")
+        for n, arg in enumerate(node.args.kwonlyargs):
+            put(arg.arg)
+            if arg.annotation:
+                put(": ")
+                put(get_value(arg.annotation))
+            if node.args.kw_defaults[n]:
+                put(" = ")
+                put(get_value(node.args.kw_defaults[n]))
+            put(", ")
+    out = "".join(out)
+    out = (out[:-2] if (node.args.args or node.args.vararg or node.args.kwarg or node.args.kwonlyargs) else out)+")"
+    if node.returns:
+        out += " -> "+get_value(node.returns)
+
+    return out
 
 def dump(scope, flags=0, sort=True):
     lines = []
     def dump1(s):
         name = s.get_full_name()
-        line = [name]
-        if (flags & DF_KIND) != 0:
-            line.append("(%s)" % s.kind())
+        if (flags & DF_DOC) != 0 and isinstance(s, function_t):
+            line = [produce_function_prototype(s.node, name)]
+        else:
+            line = [name]
         lines.append(" ".join(line))
         if (flags & DF_DOC) != 0:
             if s.doc is not None:
@@ -135,10 +215,7 @@ class collector_t(ast.NodeVisitor):
 
     def visit_FunctionDef(self, node):
         if self.accept(node):
-            if self.in_class():
-                s = self.scope.new_method(node)
-            else:
-                s = self.scope.new_function(node)
+            s = self.scope.new_function(node)
             with self.temp_scope_t(self, s):
                 self.generic_visit(node)
 
@@ -149,14 +226,21 @@ class collector_t(ast.NodeVisitor):
             with self.temp_scope_t(self, self.scope.new_class(node)):
                 self.generic_visit(node)
 
+    def visit_AnnAssign(self, node):
+        return self.visit_Assign(node)
+
     def visit_Assign(self, node):
         if self.in_function():
             return
-        if len(node.targets) == 1:
+        if isinstance(node, ast.AnnAssign):
+            target = node.target
+        elif len(node.targets) != 1:
+            return
+        else:
             target = node.targets[0]
-            if isinstance(target, ast.Name):
-                self.assign_variable  = target.id
-                self.assign_last_line = self._highest_lineno(node)
+        if isinstance(target, ast.Name):
+            self.assign_variable  = target.id
+            self.assign_last_line = self._highest_lineno(node)
 
     def _highest_lineno(self, node):
         if hasattr(node, "end_lineno"):
@@ -170,7 +254,7 @@ class collector_t(ast.NodeVisitor):
 
     def visit_Expr(self, node):
         # print("%d: %s" % (node.lineno, ast.dump(node.value)))
-        if not isinstance(node.value, ast.Str):
+        if not isinstance(node.value, ast.Constant):
             return
 
         if hasattr(node, "end_lineno"):
@@ -179,7 +263,7 @@ class collector_t(ast.NodeVisitor):
             # hack until Python 3.8; if <3.8, lineno = end
             line_before = node.lineno - len(node.value.s.split("\n"))
 
-        clean_doc = self._cleandoc(node.value.s)
+        clean_doc = self._cleandoc(node.value.value)
         if line_before == self.assign_last_line:
             self.scope.new_variable(node, self.assign_variable).set_doc(clean_doc)
         else:
@@ -206,6 +290,10 @@ class docfixing_collector_t(collector_t):
         "ida_kernwin.__ask_form_callable",
         "ida_kernwin.__call_form_callable",
         "ida_kernwin.__open_form_callable",
+        "ida_kernwin.PluginForm.TWidgetToQtPythonWidget",
+        "ida_kernwin.PluginForm.TWidgetToPyQtWidget",
+        "ida_kernwin.PluginForm.TWidgetToPySideWidget",
+        "ida_kernwin.PluginForm.FormToPyQtWidget",
         "*._SwigNonDynamicMeta",
         "*._swig_add_metaclass",
         "*._swig_add_metaclass.wrapper",
@@ -525,7 +613,6 @@ for path in args.paths.split(","):
     vc.visit(tree)
     toplevel_scopes.append(vc.scope)
 
-flags = (DF_DOC if args.dump_doc else 0) \
-      | (DF_KIND if args.dump_kind else 0)
+flags = (DF_DOC if args.dump_doc else 0)
 for s in toplevel_scopes:
     print(dump(s, flags=flags))
diff --git a/tools/pydoc_injection.py b/tools/pydoc_injection.py
new file mode 100644
index 0000000..bf32ef9
--- /dev/null
+++ b/tools/pydoc_injection.py
@@ -0,0 +1,296 @@
+
+import ast
+
+# --------------------------------------------------------------------------
+# TL;DR: we need the proper "inspect" module,
+#        and this class ensures that we import the right one.
+#
+# Long story:
+#
+# pydoc_visitor_t (below) uses ast.get_docstring(..., False)
+#    ("True" would have cleaned the docstring by calling
+#     the "cleandoc" function in the "inspect" module).
+#
+# We chose to read without cleaning, and clean manually later
+# (by a call to "inspect.cleandoc"), because other docstrings
+# do not come from ast.get_docstring() - namely, the ones we
+# pcik up manually after assignments, as docstrings for a variable.
+#
+# For that manual cleaning, we need the inspect module;
+# this class ensures that we load the correct one
+# (why is there a "correct" or an "incorrect" inspect module,
+#  is explaned in another comment below).
+
+class inspect_importer_t(object):
+
+    singleton = None
+
+    @staticmethod
+    def get_singleton():
+        klass = inspect_importer_t
+
+        if not klass.singleton:
+            klass.singleton = inspect_importer_t()
+
+        return klass.singleton
+
+    def __init__(self):
+        self.imported_inspect = False
+        self.saved_sys_path   = None
+        self.is_python_2      = pyver() == 2
+
+    def ensure_imported_inspect(self):
+        if self.imported_inspect:
+            return
+        self.imported_inspect = True
+
+        if self.is_python_2:
+            self._modify_sys_path()
+
+        import inspect
+        self.inspect = inspect
+
+        if self.is_python_2:
+            self._restore_sys_path()
+
+    def _modify_sys_path(self):
+        # We need to use the "inspect" module after "ast.get_docstring()".
+        # (See pydoc_visitor_t.) And...
+        #
+        # ... there is an "inspect.py" module next to this program, that
+        # is used (as per CL 101338) to ensure a consistent documentation
+        # regardless of the minor version of Python 3.
+        #
+        # However, it's useless when running on Python 2,
+        # in which case we temporarily remove dirname(__file__) from sys.path
+        # in order to use Python 2's own "inspect" module.
+
+        self.saved_sys_path = sys.path[:]
+
+        executable_dir = os.path.abspath(os.path.dirname(__file__))
+        while True:
+            try:
+                sys.path.remove(executable_dir)
+            except:
+                break
+
+    def _restore_sys_path(self):
+        sys.path = self.saved_sys_path[:]
+
+# --------------------------------------------------------------------------
+# In this context, "storage" is an object with dictionaries
+# named "classes", "functions" and "variables".
+# This class implement common lookups for all such containers.
+
+KIND_CLASS = "class"
+KIND_UNION = "union"
+KIND_STRUCT = "struct"
+KIND_FUNCTION = "function"
+KIND_VARIABLE = "variable"
+KIND_DEFINE = "define"
+KIND_FILE = "module"
+ALL_KINDS = [
+    KIND_CLASS,
+    KIND_UNION,
+    KIND_STRUCT,
+    KIND_FUNCTION,
+    KIND_VARIABLE,
+    KIND_DEFINE,
+    KIND_FILE,
+]
+
+# --------------------------------------------------------------------------
+class pydoc_visitor_t(ast.NodeVisitor):
+
+    WARN_ON_VARIABLE = "Docstring on assignment not recognized"
+
+    ADD_CLASS    = 1
+    ADD_FUNCTION = 2
+    ADD_VARIABLE = 3
+
+    def __init__(self, classes, functions, variables):
+        self.super = super(pydoc_visitor_t, self)
+        self.super.__init__()
+
+        self.classes   = classes
+        self.functions = functions
+        self.variables = variables
+
+        self.assign_line = -1
+
+    def collect_from(self, tree):
+        self.in_class = []
+        self.in_func  = []
+        self.generic_visit(tree)
+
+    def visit_ClassDef(self, node):
+        info = self._info_class_or_func(node, class_info_t, self.in_func)
+        if info is None:
+            return
+
+        self._add(info, self.ADD_CLASS)
+
+        self.in_class.append(info)
+        self.super.generic_visit(node)
+        self.in_class.pop()
+
+    def visit_FunctionDef(self, node):
+        # ignore "replfun"-decorated functions
+        for dec in node.decorator_list:
+            if isinstance(dec, ast.Attribute) and dec.attr == "replfun":
+                return
+
+        info = self._info_class_or_func(node, doc_info_t, self.in_func)
+        if info is None:
+            return
+
+        self._add(info, self.ADD_FUNCTION)
+
+        self.in_func.append(info)
+        self.super.generic_visit(node)
+        self.in_func.pop()
+
+    def visit_If(self, node):
+        # ignore declarations in block (formerly, if _BC695)
+
+        pass # no call to generic_visit into its body
+
+    def visit_AnnAssign(self, node):
+        return self.visit_Assign(node)
+
+    def visit_Assign(self, node):
+        if self.in_func:
+            return
+
+        self.assign_line = location_t.last_line(node)
+        # unless stated otherwise
+        self.assign_warn = self.WARN_ON_VARIABLE
+
+        # only syntax accepted: var = expr or self.member = expr
+        # (as opposed to v1 = v2 = expr, or var += expr, or obj.member = expr)
+
+        if isinstance(node, ast.Assign):
+            if len(node.targets) != 1:
+                return
+            target = node.targets[0]
+        else:
+            target = node.target
+
+        if isinstance(target, ast.Attribute):
+            if not isinstance(target.value, ast.Name):
+                return
+            if target.value.id != "self":
+                return
+            if not self.in_class:
+                self.assign_warn = "\"self.%s\" not inside a class" \
+                                   % target.attr
+                return
+
+            name = target.attr
+
+        elif isinstance(target, ast.Name):
+            name = target.id
+        else:
+            return
+
+        # success
+
+        self.assign_node = node
+        self.assign_var  = name
+        self.assign_warn = None
+
+        # aim to add a comment after this line, if there isn't one
+        info = doc_info_t(self.assign_var, "", location_t(node))
+        self._add(info, self.ADD_VARIABLE)
+
+    def visit_AugAssign(self, node):
+        if self.in_func:
+            return
+
+        # unaccepted syntax, f.i. var += expr
+        self.assign_line = location_t.last_line(node)
+        self.assign_warn = self.WARN_ON_VARIABLE
+
+    def visit_Expr(self, node):
+        if self.in_func:
+            return
+
+        if isinstance(node.value, ast.Constant):
+            if hasattr(node, "end_lineno"):
+                line_before = node.lineno - 1   # "lineno" is the start line
+            else:
+                # hack until Python 3.8
+                num_lines   = len(node.value.s.split("\n"))
+                line_before = node.lineno - num_lines   # "lineno" is the end line
+
+            if line_before == self.assign_line:
+                # the string follows an assignment
+                # (as opposed to a class or function)
+
+                if self.assign_warn:
+                    log_verb("%s, line %d: %s"
+                         % (self.path, node.lineno, self.assign_warn))
+                    return
+
+                docstring = self._clean_docstring(node.value.value)
+
+                # update the info structure already collected on Assign
+
+                storage = self.in_class[-1] if self.in_class else self
+                info    = storage.variables[self.assign_var]
+
+                info.doc      = docstring
+                info.location = location_t(node, self.assign_node)
+
+    def _info_class_or_func(self, node, info_type, nested):
+        private = node.name[0] == "_" and node.name[:2] != "__"
+        if private or nested:
+            # ignore internals
+            if not private:
+                log_verb("Ignoring nested (%s): %s"
+                     % (nested[-1].name, node.name))
+            return None
+
+        docstring = self._get_docstring(node)
+
+        return info_type(node.name, docstring,
+                         location_t(node.body[0], node))
+
+    def _add(self, info, add_type):
+        target = self.in_class[-1] if self.in_class else self
+
+        if add_type == self.ADD_CLASS:
+            storage = target.classes
+            msg     = KIND_CLASS
+        elif add_type == self.ADD_FUNCTION:
+            storage = target.functions
+            msg     = KIND_FUNCTION
+        else:
+            storage = target.variables
+            msg     = KIND_VARIABLE
+
+        if info.name in storage:
+            if self.in_class:
+                if msg == KIND_FUNCTION:
+                    msg = "method"
+                msg = "%s in class %s" % (msg, target.name)
+
+            log_verb("Duplicate %s: %s" % (msg, info.name))
+            return # keep the first
+
+        storage[info.name] = info
+
+        info.parent = None if target is self else target
+
+    def _get_docstring(self, node):
+        # clean a docstring manually, as we would for strings after a variable
+        return self._clean_docstring(ast.get_docstring(node, False))
+
+    def _clean_docstring(self, docstring):
+        if docstring:
+            inspect_importer = inspect_importer_t.get_singleton()
+            inspect_importer.ensure_imported_inspect()
+
+            docstring = inspect_importer.inspect.cleandoc(docstring)
+
+        return docstring
diff --git a/tools/pypasses.py b/tools/pypasses.py
new file mode 100644
index 0000000..014cb55
--- /dev/null
+++ b/tools/pypasses.py
@@ -0,0 +1,64 @@
+
+import sys
+import logging
+import re
+
+logging.basicConfig(stream=sys.stdout)
+logger = logging.getLogger(__name__)
+
+class CleanLoggerAdapter(logging.LoggerAdapter):
+
+    objaddr_re = re.compile(r"(<[a-zA-Z0-9\.\s_']* at )0x[0-9a-f]*(>)")
+
+    def process(self, msg, kwargs):
+        msg = re.sub(self.objaddr_re, r"\1(snipped)\2", msg)
+        return msg, kwargs
+
+    def getChild(self, suffix):
+        sub_logger = self.logger.getChild(suffix)
+        return CleanLoggerAdapter(sub_logger, self.extra)
+
+logger = CleanLoggerAdapter(logger, {})
+
+import importlib
+import ast
+
+import os
+__dir__, _ = os.path.split(__file__)
+import astor_0_8_1
+
+def parse_options():
+    from argparse import ArgumentParser
+    p = ArgumentParser()
+    p.add_argument("-m", "--idapython-module-name", required=True)
+    p.add_argument("-i", "--input", required=True)
+    p.add_argument("-x", "--doxygen-xml", required=True)
+    p.add_argument("-c", "--cpp-wrapper", required=True)
+    p.add_argument("-r", "--pydoc-overrides", required=True)
+    p.add_argument("-o", "--output", required=True)
+    p.add_argument("-d", "--debug", default=False, action="store_true")
+    p.add_argument("-p", "--passes", required=True)
+    return p.parse_args()
+
+opts = parse_options()
+if opts.debug:
+    logger.setLevel(logging.DEBUG)
+
+with open(opts.input) as fin:
+    tree = ast.parse(fin.read(), filename=opts.input)
+
+import pypasses.doxy
+setattr(opts, "dx_module", pypasses.doxy.parse(opts, logger))
+
+
+for one_pass in opts.passes.split(","):
+    module_name = f"pypasses.{one_pass}"
+    module = importlib.import_module(module_name)
+    sub_logger = logger.getChild(module_name)
+    module.process(tree, opts, sub_logger)
+    tree = ast.fix_missing_locations(tree)
+
+clob = astor_0_8_1.to_source(tree)
+with open(opts.output, "wb") as fout:
+    fout.write(clob.encode("UTF-8"))
+
diff --git a/tools/pypasses/__init__.py b/tools/pypasses/__init__.py
new file mode 100644
index 0000000..9bba1bb
--- /dev/null
+++ b/tools/pypasses/__init__.py
@@ -0,0 +1,61 @@
+
+import ast
+
+class _new_path_t(object):
+    def __init__(self, visitor, path_el):
+        self.visitor = visitor
+        self.path_el = path_el
+
+    def __enter__(self):
+        self.visitor.current_path.append(self.path_el)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.visitor.current_path.pop()
+        if exc_value:
+            raise
+
+
+class base_visitor_t(ast.NodeVisitor):
+
+    def __init__(self, module_name):
+        self.current_path = [module_name]
+
+    def visit_ClassDef(self, node):
+        with _new_path_t(self, node.name):
+            self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        with _new_path_t(self, node.name):
+            self.generic_visit(node)
+
+
+class base_transformer_t(ast.NodeTransformer):
+
+    def __init__(self, module_name):
+        self.module_name = module_name
+        self.current_path = []
+
+    def visit_Module(self, node):
+        assert not self.current_path
+        with _new_path_t(self, self.module_name):
+            self.generic_visit(node)
+        return node
+
+    def visit_ClassDef(self, node):
+        with _new_path_t(self, node.name):
+            self.generic_visit(node)
+        return node
+
+    def visit_FunctionDef(self, node):
+        with _new_path_t(self, node.name):
+            self.generic_visit(node)
+        return node
+
+
+def set_docstring(node, text):
+    ds_node = ast.Expr(value=ast.Str(text))
+    existing_ds = ast.get_docstring(node)
+    if existing_ds:
+        node.body[0] = ds_node
+    else:
+        node.body.insert(0, ds_node)
diff --git a/tools/pypasses/argsify_for_dispatching_cpp.py b/tools/pypasses/argsify_for_dispatching_cpp.py
new file mode 100644
index 0000000..ecd9cf1
--- /dev/null
+++ b/tools/pypasses/argsify_for_dispatching_cpp.py
@@ -0,0 +1,122 @@
+
+import ast
+
+import pypasses
+
+# In the case of C++ functions/methods with default paramater values:
+#
+#     tinfo_code_t tinfo_t::del_edm_by_value(
+#           uint64 value,
+#           uint etf_flags=0,
+#           bmask64_t bmask=DEFMASK64,
+#           uchar serial=0);
+#
+# SWiG will treat every single default-valued argument as an overload
+# of the function, create multiple C++ implementations, and perform
+# dispatch there.
+# On the Python side, SWiG will create:
+#
+# class tinfo_t(...):
+#     ...
+#     def del_edm_by_value(self, *args):
+#         return _ida_typeinf.tinfo_t_del_edm_by_value(*args)
+#
+# While that looks good, it is a problem for us because this is not "real"
+# overloading, and we would prefer the method to have the signature:
+#
+#     def del_edm_by_value(self, value: int, etf_flags: int=0, bmask: int=DEFMASK64, serial: int=0):
+#
+# ...and that's exactly how we'll define it in the overrides.
+# (Naturally, that means this pass needs to happen _after_ the prototype-overriding/fixing one(s))
+#
+# ---
+#
+# However, the _body_ of `del_edm_by_value` in the Python side, will
+# remain:
+#
+#     def del_edm_by_value(self, value: int, etf_flags: int=0, bmask: int=DEFMASK64, serial: int=0):
+#         return _ida_typeinf.tinfo_t_del_edm_by_value(*args)
+#
+# ...which will cause an error.
+#
+# We want to spot such occurrences, and prepare an `args`
+# tuple with all the arguments:
+#
+#     def del_edm_by_value(self, value: int, etf_flags: int=0, bmask: int=DEFMASK64, serial: int=0):
+#         args = value, etf_flags, bmask, serial
+#         return _ida_typeinf.tinfo_t_del_edm_by_value(*args)
+#
+
+def process(tree, opts, top_logger):
+
+    class source_transformer_t(pypasses.base_transformer_t):
+
+        def _is_string_literal(self, node):
+            if isinstance(node, ast.Expr):
+                if isinstance(node.value, ast.Constant):
+                    if isinstance(node.value.value, str):
+                        return True
+            return False
+
+        def visit_FunctionDef(self, node):
+
+            logger = top_logger.getChild(node.name)
+
+            # We want to match things such as:
+            #
+            #   def del_edm_by_value(self, value: int, etf_flags: int=0, bmask: int=DEFMASK64, serial: int=0)
+            #       return _ida_typeinf.tinfo_t_get_edm_by_value(self, *args)
+            #
+            #   def my_function(something: sometype, otherthing: othertype=-2)
+            #       return ...(*args)
+            #
+            has_self = False
+            real_arg = None
+            for arg in node.args.args:
+                if arg.arg == "self":
+                    has_self = True
+                else:
+                    logger.debug(f"Found 'real' argument \"{arg.arg}\". Needs investigating.")
+                    real_arg = arg
+                    break
+
+            if real_arg:
+                #
+                # Now we need to see if the entire function body
+                # consists solely of a call to a function, with
+                # an `*args` expression
+                #
+                retexpr_idx = 0
+                if self._is_string_literal(node.body[0]): # docstring
+                    logger.debug("Ignoring docstring during body investigation")
+                    retexpr_idx = 1
+
+                if isinstance(node.body[retexpr_idx], ast.Return):
+                    _return = node.body[retexpr_idx]
+                    if isinstance(_return.value, ast.Call):
+                        args = _return.value.args
+                        logger.debug(f"Arguments to function call: {args}")
+                        if args:
+                            if isinstance(args[0], ast.Name) and args[0].id == "self":
+                                logger.debug(f"Dropping \"{args[0].id}\" from the list of arguments to the call")
+                                args = args[1:]
+                        if args:
+                            if isinstance(args[0], ast.Starred) and args[0].value.id == "args":
+                                logger.debug(f"Call consists of a single starred \"{args[0].value.id}\". Let's create it!")
+                                targets = [ast.Name("args", ast.Store())]
+                                elts = []
+                                for arg in node.args.args:
+                                    if arg.arg != "self":
+                                        elts.append(ast.Name(arg.arg))
+                                value = ast.Tuple(elts, ast.Load())
+                                assign = ast.Assign(targets, value)
+                                node.body.insert(retexpr_idx, assign)
+                                # logger.debug(f">>>> {ast.dump(node, indent=4)}")
+
+            self.generic_visit(node)
+            return node
+
+    transformer = source_transformer_t(opts.idapython_module_name)
+    transformer.visit(tree)
+
+    return tree
diff --git a/tools/pypasses/doxy/__init__.py b/tools/pypasses/doxy/__init__.py
new file mode 100644
index 0000000..1c5ad99
--- /dev/null
+++ b/tools/pypasses/doxy/__init__.py
@@ -0,0 +1,748 @@
+
+import os
+import sys
+import xml.etree.ElementTree as ET
+import textwrap
+
+COMPOUND_KIND_CLASS = "class"
+COMPOUND_KIND_UNION = "union"
+COMPOUND_KIND_STRUCT = "struct"
+
+def newlineify(line):
+    if not line.endswith("\n"):
+        line = line + "\n"
+    return line
+
+class tree_visitor_t(object):
+
+    SKIP_TREE = {}
+
+    def __init__(
+            self,
+            passthrough_elements=[],
+            skip_elements=[]):
+        if not isinstance(passthrough_elements, list):
+            passthrough_elements = [passthrough_elements]
+        if not isinstance(skip_elements, list):
+            skip_elements = [skip_elements]
+        self.passthrough_elements = passthrough_elements
+        self.skip_elements = skip_elements
+
+    def _on_any(self, *args):
+        pass
+
+    def visit(self, tree):
+        if tree.tag not in self.skip_elements:
+            on = getattr(self, f"on_{tree.tag}") if tree.tag not in self.passthrough_elements else self._on_any
+            if on(tree, True) is not self.SKIP_TREE:
+                self.visit_children(tree)
+                on(tree, False)
+
+    def visit_children(self, tree):
+        for child in tree:
+            self.visit(child)
+
+
+class base_text_collector_visitor_t(tree_visitor_t):
+
+    def __init__(self, *args, **kwargs):
+        super(base_text_collector_visitor_t, self).__init__(*args, **kwargs)
+        self.text_bits = []
+
+    def newline(self):
+        self.text_bits.append("\n")
+
+    def _sanitize_node_text(self, tree, text):
+        return text
+
+    def _collect_node_text(self, tree, is_start):
+        text = tree.text if is_start else tree.tail
+        text = self._sanitize_node_text(tree, text)
+        self.text_bits.append(text)
+
+    def clob(self, spacer="", strip=False, remove_empty=False):
+        bits = filter(lambda b: b is not None, self.text_bits)
+        if strip:
+            chars = " " if strip is True else strip
+            bits = map(lambda b: b.strip(chars), bits)
+        if remove_empty:
+            bits = filter(lambda b: b, bits)
+        return spacer.join(bits)
+
+    def oneliner_clob(self):
+        return self.clob(spacer=" ", strip=" \n\t", remove_empty=True)
+
+
+class description_text_collector_visitor_t(base_text_collector_visitor_t):
+
+    def on_para(self, tree, is_start):
+        class para_text_collector_visitor_t(description_text_collector_visitor_t):
+            def on_para(self, tree, is_start):
+                self._collect_node_text(tree, is_start)
+        v = para_text_collector_visitor_t(
+            passthrough_elements=self.passthrough_elements,
+            skip_elements=self.skip_elements)
+        v.visit(tree)
+        # see if there's any content at all in there
+        clob = v.oneliner_clob()
+        if clob:
+            # if yes, let's keep it as-is
+            self.text_bits.append(v.clob())
+            self.newline
+        return self.SKIP_TREE
+
+    def on_linebreak(self, tree, is_start):
+        self._collect_node_text(tree, is_start)
+
+    def on_ref(self, tree, is_start):
+        self._collect_node_text(tree, is_start)
+
+    def on_ndash(self, tree, is_start):
+        if is_start:
+            self.text_bits.append("-")
+        self._collect_node_text(tree, is_start)
+
+    def on_ulink(self, tree, is_start):
+        if is_start:
+            self.text_bits.append(f"[{tree.text}]({tree.attrib['url']})")
+        else:
+            self._collect_node_text(tree, is_start)
+
+    def on_computeroutput(self, tree, is_start):
+        if is_start:
+            self.text_bits.append("`")
+            self._collect_node_text(tree, is_start)
+            self.text_bits.append("`")
+        else:
+            self._collect_node_text(tree, is_start)
+
+    def on_verbatim(self, tree, is_start):
+        return self.on_computeroutput(tree, is_start)
+
+    def on_preformatted(self, tree, is_start):
+        self._collect_node_text(tree, is_start)
+
+    def on_programlisting(self, tree, is_start):
+
+        class codeline_visitor_t(base_text_collector_visitor_t):
+            def __init__(self, *args, **kwargs):
+                kwargs["passthrough_elements"] = "highlight"
+                super(codeline_visitor_t, self).__init__(*args, **kwargs)
+
+            def on_ref(self, tree, is_start):
+                self._collect_node_text(tree, is_start)
+
+            def on_sp(self, tree, is_start):
+                if is_start:
+                    self.text_bits.append(" ")
+                self._collect_node_text(tree, is_start)
+
+        class programlisting_visitor_t(base_text_collector_visitor_t):
+            def __init__(self, *args, **kwargs):
+                super(programlisting_visitor_t, self).__init__(*args, **kwargs)
+                self.lines = []
+
+            def on_codeline(self, tree, is_start):
+                sub = codeline_visitor_t()
+                sub.visit_children(tree)
+                line = newlineify(sub.clob())
+                self.lines.append(" " * 4 + line)
+                return self.SKIP_TREE
+
+        v = programlisting_visitor_t()
+        v.visit_children(tree)
+        self.newline()
+        self.text_bits.extend(v.lines)
+        self.newline()
+        return self.SKIP_TREE
+
+    def _on_list(self, tree, is_start, prefixer):
+        class list_visitor_t(description_text_collector_visitor_t):
+            def __init__(self, *args, **kwargs):
+                super(list_visitor_t, self).__init__(*args, **kwargs)
+                self.lines = []
+
+            # Note: Do _not_ add more `on_*` handlers here unless you are
+            # absolutely sure you know what you're doing.
+            # In particular, the fact that we don't support `on_parameterlist`
+            # is _by design_, as it helps us realize when the doxygen-parsed
+            # text is incorrect (because typically we have not left an empty
+            # line after the last list item.)
+
+            def on_listitem(self, tree, is_start):
+                sub = description_text_collector_visitor_t()
+                sub.visit_children(tree)
+                line = newlineify(sub.clob())
+                self.lines.append(prefixer(line, len(self.lines)))
+                return self.SKIP_TREE
+
+        v = list_visitor_t()
+        v.visit_children(tree)
+        self.newline()
+        self.text_bits.extend(v.lines)
+        self.newline()
+
+        return self.SKIP_TREE
+
+    def on_itemizedlist(self, tree, is_start):
+        return self._on_list(tree, is_start, lambda l, _: f"* {l}")
+
+    def on_orderedlist(self, tree, is_start):
+        return self._on_list(tree, is_start, lambda l, idx: f"{idx}. {l}")
+
+
+class type_text_collector_visitor_t(description_text_collector_visitor_t):
+    def _sanitize_node_text(self, tree, text):
+        if text:
+            for undesirable in ["hexapi", "idaapi", "idaman", "ida_export"]:
+                text = text.replace(undesirable, "")
+        return text
+
+    def on_type(self, tree, is_start):
+        self._collect_node_text(tree, is_start)
+
+    def type_clob(self):
+        return self.oneliner_clob()
+
+
+# --------------------------------------------------------
+
+class documentable_t(object):
+    def __init__(self, name):
+        self.name = name
+        self.classes = []
+        self.functions = []
+        self.variables = []
+
+    def find_in_dataset(self, dataset, name):
+        for one in dataset:
+            if one.name == name:
+                return one
+
+    def find_class(self, name):
+        return self.find_in_dataset(self.classes, name)
+
+    def ensure_class(self, name):
+        one = self.find_class(name)
+        if one is None:
+            one = class_t(name)
+            self.classes.append(one)
+        return one
+
+    def find_function(self, name):
+        return self.find_in_dataset(self.functions, name)
+
+    def ensure_function(self, name):
+        one = self.find_function(name)
+        if one is None:
+            one = function_t(name)
+            self.functions.append(one)
+        return one
+
+    def find_variable(self, name):
+        return self.find_in_dataset(self.variables, name)
+
+    def ensure_variable(self, name):
+        one = self.find_variable(name)
+        if one is None:
+            one = variable_t(name)
+            self.variables.append(one)
+        return one
+
+    def find_with_kind(self, tree, element_name, kind):
+        found = tree.find(element_name)
+        if found:
+            found_kind = found.attrib["kind"]
+            if found_kind == kind:
+                return found
+
+    @staticmethod
+    def load_description(tree, oneliner=False):
+
+        class description_visitor_t(description_text_collector_visitor_t):
+            def __init__(self, top_tag):
+                super(description_visitor_t, self).__init__(
+                    passthrough_elements=top_tag,
+                    skip_elements=["parameterlist", "simplesect"])
+
+        dv = description_visitor_t(tree.tag)
+        dv.visit(tree)
+
+        return dv.oneliner_clob() if oneliner else dv.clob()
+
+    @staticmethod
+    def load_descriptions(tree):
+        # # wrapping at 80; if left at 70, texts from C++/Doxygen already contain
+        # # linebreaks just after 70, that will make the wrapping ugly.
+        # # Removing C++ linebreaks is probably not an option,
+        # # if we want to respect pre-formatting.
+        # wrap_text_at_column = 80
+        brief = documentable_t.load_description(tree.find("briefdescription"), oneliner=True)
+        detailed = documentable_t.load_description(tree.find("detaileddescription"))
+        return brief, detailed
+
+    def _get_direct_child_name(self, node):
+        name_trees = node.findall("name")
+        assert(len(name_trees) <= 1)
+        if len(name_trees) == 1:
+            return name_trees[0].text
+
+    def load_section_functions(self, node):
+        for member_tree in node.findall("./memberdef[@kind='function']"):
+            function_name = self._get_direct_child_name(member_tree)
+            if function_name:
+                logger.debug(f"Found function: {self.name}.{function_name}")
+                fun = self.ensure_function(function_name)
+                fun_flavor = fun.new_flavor()
+                fun_flavor.load_tree(member_tree, fun)
+
+                logger.debug(f"{fun.name}: loaded function flavor with"
+                             + f"\n\tbrief: {fun_flavor.brief_description}"
+                             + f"\n\tdetailed: {fun_flavor.detailed_description}"
+                             + f"\n\tprototype: {fun.compose_prototype_string(fun_flavor)}")
+
+    def load_section_variables(self, node):
+        section_kind = node.attrib["kind"]
+        memberdef_kind = {
+            "var" : "variable",
+            "define" : "define",
+            "user-defined" : "define",
+            "public-attrib" : "variable",
+            "public-static-attrib" : "variable",
+        }[section_kind]
+        for member_tree in node.findall(f"./memberdef[@kind='{memberdef_kind}']"):
+            var_name = self._get_direct_child_name(member_tree)
+            if var_name:
+                logger.debug(f"Found variable: {self.name}.{var_name}")
+                v = self.ensure_variable(var_name)
+                v.load_tree(member_tree)
+
+    def load_section_enums(self, node):
+        for enum_tree in node.findall(f"./memberdef[@kind='enum']"):
+            for enumvalue_tree in enum_tree.findall(f"./enumvalue"):
+                enumvalue_name = self._get_direct_child_name(enumvalue_tree)
+                if enumvalue_name:
+                    logger.debug(f"Found (enum-based) variable: {self.name}.{enumvalue_name}")
+                    v = self.ensure_variable(enumvalue_name)
+                    v.load_tree(enumvalue_tree)
+
+
+class module_t(documentable_t):
+    def __init__(self, ida_module_name):
+        super(module_t, self).__init__(ida_module_name)
+        self.brief_description = None
+        self.detailed_description = None
+
+    def load_tree(self, tree):
+        compounddef_node = tree.find("compounddef")
+        if compounddef_node is not None:
+            self.brief_description, self.detailed_description = documentable_t.load_descriptions(compounddef_node)
+
+        for node in tree.findall("compounddef/innerclass"):
+            logger.debug(f"Module has class {node.text} with refid {node.attrib['refid']}")
+            klass_path = os.path.join(opts.doxygen_xml, f"{node.attrib['refid']}.xml")
+            with open(klass_path, "r") as f:
+                klass_tree = ET.fromstring(f.read())
+            self.ensure_class(node.text).load_tree(klass_tree)
+
+        for node in tree.findall("compounddef/sectiondef"):
+            kind = node.attrib['kind']
+            logger.debug(f"Module has section with kind {kind}")
+            if kind in ["func"]:
+                self.load_section_functions(node)
+            elif kind in ["var", "define", "user-defined"]:
+                self.load_section_variables(node)
+            elif kind in ["enum"]:
+                self.load_section_enums(node)
+
+
+class variable_t(documentable_t):
+    def __init__(self, name):
+        self.name = name
+        self.brief_description = None
+        self.detailed_description = None
+
+    def load_tree(self, tree):
+        self.brief_description, self.detailed_description = documentable_t.load_descriptions(tree)
+
+
+class function_t(documentable_t):
+
+    class flavor_t(object):
+
+        class prototype_element_t():
+            def __init__(self, type, desc):
+                self.type = type
+                self.description = desc
+
+        class param_t(prototype_element_t):
+            def __init__(self, type, desc, name, defval):
+                super(function_t.flavor_t.param_t, self).__init__(type, desc)
+                self.name = name
+                self.defval = defval
+
+        class return_t(prototype_element_t):
+            def __init__(self, type, desc):
+                super(function_t.flavor_t.return_t, self).__init__(type, desc)
+                self.retvals = []
+
+            def append_retval(self, value, desc):
+                self.retvals.append((value, desc))
+
+        """
+        While Python doesn't provide polymorphism, C++ does, and thus
+        it's possible that the same function has multiple "flavors",
+        each having their documentation & prototype.
+
+        Since doxygen-produced contents represents information coming
+        from the C++ side, it's only fitting that there can be multiple
+        "flavors" of a function: it'll be up to the pypass to
+        consolidate that into a single Python piece of pydoc.
+        """
+        def __init__(self):
+            self.brief_description = None
+            self.detailed_description = None
+            self.return_info = None
+            self.parameters = []
+
+        def find_parameter_by_name(self, name):
+            for p in self.parameters:
+                if p.name == name:
+                    return p
+
+        def load_parameter_desc(self, tree, param_name):
+
+            # Try to find the description in the 
+            # 
+            #   Retrive tinfo using type TID or struct/enum member MID
+            #   
+            #     
+            #       
+            #         tid
+            #       
+            #       
+            #         tid can denote a type tid or a member tid. 
+            #       
+            #     
+            for parameteritem_tree in tree.findall("./detaileddescription//parameterlist[@kind='param']/parameteritem"):
+                for parameternamelist_tree in parameteritem_tree.findall("parameternamelist"):
+                    for parametername_tree in parameternamelist_tree.findall("parametername"):
+                        if parametername_tree.text == param_name:
+                            parameterdescription_tree = parameteritem_tree.find("parameterdescription")
+                            if parameterdescription_tree is not None:
+                                v = description_text_collector_visitor_t()
+                                v.visit_children(parameterdescription_tree)
+                                return v.oneliner_clob()
+
+        def load_parameter(self, param_tree, toplevel_tree):
+
+            param_name, param_type, param_desc, param_defval = "unnamed", None, None, None
+            declname_tree = param_tree.find("declname")
+            if declname_tree is not None:
+                param_name = declname_tree.text
+
+            defval_tree = param_tree.find("defval")
+            if defval_tree is not None:
+                class defval_text_collector_visitor_t(description_text_collector_visitor_t):
+                    def on_defval(self, tree, is_start):
+                        self._collect_node_text(tree, is_start)
+                v = defval_text_collector_visitor_t()
+                v.visit(defval_tree)
+                param_defval = v.oneliner_clob()
+
+            type_tree = param_tree.find("type")
+            if type_tree is not None:
+                v = type_text_collector_visitor_t()
+                v.visit(type_tree)
+                param_type = v.type_clob()
+                # logger.debug(f"RAW BITS: {v.text_bits}")
+                # logger.debug(f"PARAM TYPE: '{param_type}'")
+
+            param_desc = self.load_parameter_desc(toplevel_tree, param_name)
+
+            self.parameters.append(self.param_t(param_type, param_desc, param_name, param_defval))
+
+        def load_tree(self, tree, parent_function):
+            """
+            From the markup below, we can see that on one hand we have
+            the prototype of the function that's directly under the `memberdef`
+            tree, whereas the description of the parameters, is under another
+            `parameterlist` tree.
+
+            
+              ssize_t
+              ssize_t tinfo_t::get_udm_by_tid
+              (udm_t *udm, tid_t tid)
+              get_udm_by_tid
+              tinfo_t::get_udm_by_tid
+              
+                udm_t *
+                udm
+              
+              
+                tid_t
+                tid
+              
+              
+              
+              
+                Retrive tinfo using type TID or struct/enum member MID
+                
+                  
+                    
+                      tid
+                    
+                    
+                      tid can denote a type tid or a member tid. 
+                    
+                  
+                  
+                    
+                      udm[out]
+                    
+                    
+                      place to save the found member to, may be nullptr 
+                    
+                  
+                
+                
+                  if a member tid was specified, returns the member index, otherwise returns -1. if the function fails, THIS object becomes empty. 
+                
+                
+              
+              
+              
+              
+            
+            """
+
+            self.brief_description, self.detailed_description = documentable_t.load_descriptions(tree)
+
+            for param_tree in tree.findall("param"):
+                self.load_parameter(param_tree, tree)
+
+            return_type, return_description = None, None
+            return_type_tree = tree.find("type")
+            if return_type_tree is not None:
+                v = type_text_collector_visitor_t()
+                v.visit(return_type_tree)
+                return_type = v.type_clob()
+
+            # We'll guarantee that we have only 1 'return' item.
+            # The various values that are returned, should be placed in 'retval's
+            for return_tree in tree.findall("./detaileddescription//simplesect[@kind='return']"):
+                assert return_description is None
+                v = description_text_collector_visitor_t()
+                v.visit_children(return_tree)
+                return_description = v.oneliner_clob()
+
+            self.return_info = self.return_t(return_type, return_description)
+
+            # While at it, we'll also guarantee that we don't have 'returns' items
+            for returns_tree in tree.findall("./detaileddescription//simplesect[@kind='returns']"):
+                crash()
+
+            # Add support for '\retval's
+            for parameteritem_tree in tree.findall("./detaileddescription//parameterlist[@kind='retval']/parameteritem"):
+                retval_desc = None
+                parameterdescription_tree = parameteritem_tree.find("parameterdescription")
+                if parameterdescription_tree is not None:
+                        v = description_text_collector_visitor_t()
+                        v.visit_children(parameterdescription_tree)
+                        retval_desc = v.oneliner_clob()
+
+                for parameternamelist_tree in parameteritem_tree.findall("parameternamelist"):
+                    for parametername_tree in parameternamelist_tree.findall("parametername"):
+                        retval_value = parametername_tree.text
+                        self.return_info.append_retval(retval_value, retval_desc)
+
+    def __init__(self, name):
+        super(function_t, self).__init__(name)
+        self.flavors = []
+
+    def new_flavor(self):
+        f = self.flavor_t()
+        self.flavors.append(f)
+        return f
+
+    def compose_prototype_string(self, flavor, type_processor=lambda t: t):
+        parts = [self.name]
+        parts.append("(")
+        params_parts = []
+        for p in flavor.parameters:
+            param_parts = []
+            param_parts.append(f"{p.name}")
+            if p.type:
+                param_parts.append(f": {type_processor(p.type)}")
+            if p.defval is not None:
+                param_parts.append(f"={p.defval}")
+            params_parts.append("".join(param_parts))
+        parts.append(", ".join(params_parts))
+        parts.append(")")
+        if flavor.return_info.type:
+            parts.append(f" -> {type_processor(flavor.return_info.type)}")
+        return "".join(parts)
+
+
+class class_t(documentable_t):
+    def __init__(self, name):
+        super(class_t, self).__init__(name)
+        self.brief_description = None
+        self.detailed_description = None
+
+    def load_tree(self, tree):
+        compounds = list(tree.findall("compounddef"))
+        assert(len(compounds) == 1)
+        compound = compounds[0]
+        compound_kind = compound.attrib["kind"]
+        assert(compound_kind in [COMPOUND_KIND_CLASS, COMPOUND_KIND_UNION, COMPOUND_KIND_STRUCT])
+
+        wks = {
+            "public-type" : None,
+            "public-func" : None,
+            "public-attrib" : None,
+
+            "public-static-func" : None,
+            "public-static-attrib" : None,
+        }
+        for section_tree in compound.findall("sectiondef"):
+            section_kind = section_tree.attrib["kind"]
+            if section_kind.startswith("private-"):
+                continue
+            if section_kind.startswith("protected-"):
+                continue
+            if section_kind.startswith("friend"):
+                continue
+            if section_kind.startswith("user-defined"):
+                # bitrange.hpp, netnode.hpp; see the `\name` things.
+                # Just skip them for now
+                logger.debug(f"Skipping section {section_tree}")
+                continue
+            assert(wks[section_kind] is None)
+            wks[section_kind] = section_tree
+
+        for section in map(lambda sn: wks[sn], ["public-func", "public-static-func"]):
+            if section is not None:
+                self.load_section_functions(section)
+
+        for kind in ["var", "define", "user-defined", "public-attrib", "public-static-attrib"]:
+            for section_tree in compound.findall(f"sectiondef[@kind='{kind}']"):
+                self.load_section_variables(section_tree)
+
+        for kind in ["enum"]:
+            for section_tree in compound.findall(f"sectiondef[@kind='{kind}']"):
+                self.load_section_enums(section_tree)
+
+        if wks["public-type"]:
+            self.load_section_enums(wks["public-type"])
+
+opts, logger = None, None
+
+class hooks_builder_t(object):
+
+    def __init__(self, hooks_info):
+        self.hooks_info = hooks_info
+
+    def load_hooks_function(self, klass, tree):
+
+        method_name = tree.find("./name").text
+
+        hi = self.hooks_info
+        logger.debug(f"Investigating hook function '{hi.class_name}.{method_name}'")
+        if self.hooks_info.discard_prefixes and method_name.startswith(hi.discard_prefixes):
+            logger.debug(f"Ignoring due to discarded prefixes {hi.discard_prefixes}")
+            return
+
+        brief, detailed = documentable_t.load_descriptions(tree)
+        if hi.discard_doc and (
+                brief.startswith(hi.discard_doc) or \
+                detailed.startswith(hi.discard_doc)):
+            logger.debug(f"Ignoring due to discarded doc {hi.discard_doc}")
+            return
+
+        for prefix in (hi.strip_prefixes or []):
+            if method_name.startswith(prefix):
+                method_name = method_name[len(prefix):]
+                break
+
+        recipe_info = hi.recipe_module.recipe.get(method_name, {})
+        if recipe_info.get("ignore", False):
+            logger.debug(f"Ignoring due to recipe-mandated ignore")
+            return
+
+        assert klass.find_function(method_name) is None
+        fun = klass.ensure_function(method_name)
+        fun_flavor = fun.new_flavor()
+        fun_flavor.load_tree(tree, fun)
+
+        def clean(thing):
+            if thing.startswith("cb:"):
+                thing = thing[3:].lstrip()
+            return thing
+        fun_flavor.brief_description = clean(fun_flavor.brief_description)
+        fun_flavor.detailed_description = clean(fun_flavor.detailed_description)
+
+        # `flavor_t.load_tree` expects a proper list of  elements
+        # to determine the prototyp.
+        # Since we are not parsing proper function documentation here, but
+        # rather piecing things together, we don't have that  list:
+        # all we have is a  with less-than-ideally-structured
+        # information, extracted purely from the doxygen docstring, and not
+        # from parsing the C++ prototype.
+        # We'll have to do our best to collect that information, and
+        # let the matcher hopefully do a good job.
+        for parameteritem_tree in tree.findall("./detaileddescription//parameterlist[@kind='param']/parameteritem"):
+            param_type, param_name, param_desc, param_defval = None, None, None, None
+            param_name = parameteritem_tree.find(".//parametername").text
+            param_desc = fun_flavor.load_parameter_desc(tree, param_name)
+            fun_flavor.parameters.append(fun_flavor.param_t(param_type, param_desc, param_name, param_defval))
+            logger.debug(f"Found parameter '{param_name}' ({param_desc})")
+
+        logger.debug(f"Created hook method {klass.name}.{method_name}")
+
+    def load_hooks_class(self, module, tree):
+
+        hi = self.hooks_info
+        logger.debug(f"Loading tree for hooks '{hi.class_name}', from enumeration with name '{hi.enum_name}'")
+        klass = module.ensure_class(self.hooks_info.class_name)
+
+        for enumvalue_tree in tree.findall("enumvalue"):
+            self.load_hooks_function(klass, enumvalue_tree)
+
+
+
+def parse(_opts, _logger):
+    global opts
+    global logger
+    opts, logger = _opts, _logger
+
+    module = None
+
+    # Start from the toplevel doxygen-parsed XML document
+    for suffix in ["_8hpp", "_8h"]:
+        module_name = opts.idapython_module_name.replace("ida_", "")
+        path = os.path.join(opts.doxygen_xml, f"{module_name}{suffix}.xml")
+        if os.path.isfile(path):
+            logger.debug(f"Found module entrypoint: {path}")
+            with open(path, "r") as f:
+                tree = ET.fromstring(f.read())
+            module = module_t(opts.idapython_module_name)
+            module.load_tree(tree)
+
+    # And then create fake "hooks" classes
+    genhooks_dir = os.path.join(os.path.dirname(__file__), "..", "..", "genhooks")
+    if genhooks_dir not in sys.path:
+        sys.path.append(genhooks_dir)
+    import recipe_index
+    for hinfo in recipe_index.hooks.get(opts.idapython_module_name, []):
+        hbuilder = hooks_builder_t(hinfo)
+
+        path = os.path.join(opts.doxygen_xml, hinfo.toplevel_xml_fname)
+        with open(path, "r") as f:
+            tree = ET.fromstring(f.read())
+        enum_tree = tree.find(f".//memberdef[@kind='enum'][name='{hbuilder.hooks_info.enum_name}']")
+        assert enum_tree
+
+        hbuilder.load_hooks_class(module, enum_tree)
+
+    return module
diff --git a/tools/pypasses/inject_doxygen.py b/tools/pypasses/inject_doxygen.py
new file mode 100644
index 0000000..a61be6e
--- /dev/null
+++ b/tools/pypasses/inject_doxygen.py
@@ -0,0 +1,190 @@
+
+import ast
+import os
+
+import pypasses
+
+def process(tree, opts, logger):
+
+    class source_transformer_t(pypasses.base_transformer_t):
+
+        class new_scope_t(object):
+            def __init__(self, transformer, scope):
+                self.transformer = transformer
+                self.scope = scope
+
+            def __enter__(self):
+                self.transformer.dx_scope.append(self.scope)
+
+            def __exit__(self, exc_type, exc_value, traceback):
+                self.transformer.dx_scope.pop()
+                if exc_value:
+                    raise
+
+        def __init__(self, module_name, dx_module):
+            super(source_transformer_t, self).__init__(module_name)
+            self.dx_scope = [dx_module]
+
+        def _append_descriptions(self, dx_source, storage):
+            if dx_source.brief_description:
+                storage.append(dx_source.brief_description)
+                storage.append("")
+            if dx_source.detailed_description:
+                storage.append(dx_source.detailed_description)
+
+        def _handle_assign(self, node, target):
+            ds_node = None
+            if isinstance(target, ast.Name):
+                dx_var = self.dx_scope[-1].find_variable(target.id)
+                if dx_var:
+                    logger.debug(f"Found documentation for assignment '{ast.dump(node)}': {dx_var}")
+                    text = []
+                    self._append_descriptions(dx_var, text)
+                    if text:
+                        ds_node = ast.Expr(value=ast.Str("\n".join(text)))
+            return [node, ds_node] if ds_node else node
+
+        def visit_AnnAssign(self, node: ast.AnnAssign):
+            return self._handle_assign(node, node.target)
+
+        def visit_Assign(self, node: ast.Assign):
+            if len(node.targets) != 1:
+                return node
+            return self._handle_assign(node, node.targets[0])
+
+        def visit_ClassDef(self, node):
+            dx_class = self.dx_scope[-1].find_class(node.name)
+            if dx_class:
+                text = []
+                self._append_descriptions(dx_class, text)
+                if text:
+                    pypasses.set_docstring(node, "\n".join(text))
+                with self.new_scope_t(self, dx_class):
+                    super(source_transformer_t, self).visit_ClassDef(node)
+            else:
+                super(source_transformer_t, self).visit_ClassDef(node)
+            return node
+
+        def visit_Module(self, node):
+            dx_module = self.dx_scope[-1]
+            if dx_module:
+                text = []
+                self._append_descriptions(dx_module, text)
+                if text:
+                    ds_node = ast.Expr(value=ast.Str("\n".join(text)))
+                    node.body.insert(0, ds_node)
+            self.generic_visit(node)
+            return node
+
+        def _map_argument_names_to_doxygen_info_and_derive_tags(
+                self,
+                dx_source,
+                storage,
+                arg_names):
+            self._append_descriptions(dx_source, storage)
+            args_and_return = []
+
+            for arg_name in arg_names:
+                if arg_name == "self":
+                    continue
+                dx_param = dx_source.find_parameter_by_name(arg_name)
+                # if there's no description, no point in wasting space
+                if dx_param and dx_param.description:
+                    args_and_return.append(f"@param {arg_name}: {dx_param.description}")
+
+            if dx_source.return_info and dx_source.return_info.description:
+                args_and_return.append(f"@returns {dx_source.return_info.description}")
+
+            for retval_value, retval_desc in dx_source.return_info.retvals:
+                args_and_return.append(f"@retval {retval_value}: {retval_desc}")
+
+            if args_and_return:
+                storage.extend(args_and_return)
+
+        def _is_likely_SWiG_dispatcher(self, node):
+            """
+            A SWiG polymorphism dispatcher will look like so:
+
+              * def inf_huge_arg_align(*args) -> "bool"
+              * def find_member(self, *args) -> "ssize_t"
+
+            IOW:
+              1. must not have regular args except for 'self'
+              2. must have a vararg called 'args'
+              3. must not have kwargs
+            """
+
+            # 1.
+            for arg in node.args.args:
+                if arg.arg != "self":
+                    return False
+
+            # 2.
+            if not node.args.vararg or node.args.vararg.arg != "args":
+                return False
+
+            # 3.
+            if node.args.kwarg:
+                return False
+
+            return True
+
+        def _full_dx_scope_path(self, name):
+            return ".".join(map(lambda s: s.name, self.dx_scope)) + "." + name
+
+        def _process_type(self, type_text):
+            from pypasses.proto_fix_known_types import find_annotation_replacement as far
+            found = far(ast.Constant(type_text))
+            if found:
+                assert isinstance(found, ast.Name)
+                type_text = found.id
+            return type_text
+
+        def visit_FunctionDef(self, node):
+            logger.debug(f"Looking for: {self._full_dx_scope_path(node.name)}")
+            dx_fun = self.dx_scope[-1].find_function(node.name)
+            if dx_fun:
+                logger.debug(f"Found doxygen function information")
+                text = []
+                arg_names = list(map(lambda a: a.arg, node.args.args))
+
+                # If we have more than 1 flavor, it is either:
+                #   - a polymorphic function
+                #   - a function with default parameters
+                # Let's check if SWiG was led to implement polymorphism (will use
+                # `*args` in that case), or if it turns out we `%ignore`'d some and
+                # thus have only one prototype in the Python bindings.
+                if len(dx_fun.flavors) == 1 and self._is_likely_SWiG_dispatcher(node):
+                    logger.debug(f"{self._full_dx_scope_path(node.name)} is a defarg-caused dispatcher")
+                    # In this case, the prototype is pretty damn boring, and
+                    # won't tell us much (i.e.,  `def thing(*args)`).
+                    # We still want a list of tags though.
+                    arg_names = list(map(lambda p: p.name, dx_fun.flavors[0].parameters))
+
+                if len(dx_fun.flavors) > 1 and self._is_likely_SWiG_dispatcher(node):
+                    logger.debug(f"{self._full_dx_scope_path(node.name)} is a dispatcher")
+                    text.append("This function has the following signatures:")
+                    text.append("")
+                    for idx, flavor in enumerate(dx_fun.flavors):
+                        text.append(f"    {idx}. {dx_fun.compose_prototype_string(flavor, self._process_type)}")
+                    text.append("")
+                    for idx, flavor in enumerate(dx_fun.flavors):
+                        text.append(f"# {idx}: {dx_fun.compose_prototype_string(flavor, self._process_type)}")
+                        text.append("")
+                        self._map_argument_names_to_doxygen_info_and_derive_tags(flavor, text, arg_names)
+                        if idx < len(dx_fun.flavors):
+                            text.append("")
+                else:
+                    self._map_argument_names_to_doxygen_info_and_derive_tags(dx_fun.flavors[0], text, arg_names)
+                if text:
+                    pypasses.set_docstring(node, "\n".join(text))
+            super(source_transformer_t, self).visit_FunctionDef(node)
+            return node
+
+    if opts.dx_module:
+        transformer = source_transformer_t(
+            opts.idapython_module_name,
+            opts.dx_module)
+        transformer.visit(tree)
+
+    return tree
diff --git a/tools/pypasses/proto_fix_known_types.py b/tools/pypasses/proto_fix_known_types.py
new file mode 100644
index 0000000..c4fdf88
--- /dev/null
+++ b/tools/pypasses/proto_fix_known_types.py
@@ -0,0 +1,63 @@
+
+import ast
+
+import pypasses
+
+REPLS = {
+    ast.Constant("sval_t") : ast.Name("int"),
+    ast.Constant("uval_t") : ast.Name("int"),
+    ast.Constant("int32") : ast.Name("int"),
+    ast.Constant("uint32") : ast.Name("int"),
+    ast.Constant("int") : ast.Name("int"),
+    ast.Constant("bool") : ast.Name("bool"),
+    ast.Constant("void") : ast.Name("None"),
+    ast.Constant("ea_t") : ast.Name("ida_idaapi.ea_t"),
+
+    ast.Constant("qstring") : ast.Name("str"),
+    ast.Constant("qstring const &") : ast.Name("str"),
+    ast.Constant("qstring &") : ast.Name("str"),
+    ast.Constant("qstring const *") : ast.Name("str"),
+    ast.Constant("qstring *") : ast.Name("str"),
+    ast.Constant("const char *") : ast.Name("str"),
+    ast.Constant("char const *") : ast.Name("str"),
+}
+
+def _node_eq(n0, n1):
+    t0 = type(n0)
+    if t0 == type(n1):
+        if t0 == ast.Constant:
+            if n0.value == n1.value:
+                return True
+        else:
+            raise Exception(f"Unknown annotation type: {n0}")
+    return False
+
+def find_annotation_replacement(node):
+    for key, value in REPLS.items():
+        if _node_eq(key, node):
+            return value
+
+
+def process(tree, opts, logger):
+
+    class source_transformer_t(pypasses.base_transformer_t):
+
+        def visit_arg(self, node):
+            if node.annotation is not None:
+                repl = find_annotation_replacement(node.annotation)
+                if repl is not None:
+                    node = ast.arg(node.arg, repl, node.type_comment)
+            return node
+
+        def visit_FunctionDef(self, node):
+            if node.returns:
+                repl = find_annotation_replacement(node.returns)
+                if repl is not None:
+                    node.returns = repl
+            self.generic_visit(node)
+            return node
+
+    transformer = source_transformer_t(opts.idapython_module_name)
+    transformer.visit(tree)
+
+    return tree
diff --git a/tools/pypasses/proto_overrides.py b/tools/pypasses/proto_overrides.py
new file mode 100644
index 0000000..ed44611
--- /dev/null
+++ b/tools/pypasses/proto_overrides.py
@@ -0,0 +1,57 @@
+
+import ast
+import os
+
+import pypasses
+
+def process(tree, opts, logger):
+
+    if not os.path.isfile(opts.pydoc_overrides):
+        return tree
+
+    #
+    # Collect prototypes from the overrides
+    #
+    class overrides_visitor_t(pypasses.base_visitor_t):
+
+        def __init__(self, module_name):
+            super(overrides_visitor_t, self).__init__(module_name)
+            self.prototypes = {}
+
+        def _register_proto(self, node):
+            path = ".".join(self.current_path + [node.name])
+            logger.debug(f"Registering \"{path}\": {node}")
+            self.prototypes[path] = node
+
+        def visit_FunctionDef(self, node):
+            self._register_proto(node)
+            return super(overrides_visitor_t, self).visit_FunctionDef(node)
+
+
+    with open(opts.pydoc_overrides) as fin:
+        overrides_tree = ast.parse(fin.read(), filename=opts.pydoc_overrides)
+    overrides = overrides_visitor_t(opts.idapython_module_name)
+    overrides.visit(overrides_tree)
+
+    #
+    # And apply it to the input
+    #
+    class source_transformer_t(pypasses.base_transformer_t):
+        def __init__(self, module_name, prototypes):
+            super(source_transformer_t, self).__init__(module_name)
+            self.prototypes = prototypes
+
+        def visit_FunctionDef(self, node):
+            path = ".".join(self.current_path + [node.name])
+            found = self.prototypes.get(path, None)
+            if found is not None:
+                logger.debug(f"Found override for \"{path}\"")
+                node.args = found.args
+                node.returns = found.returns
+            self.generic_visit(node)
+            return node
+
+    transformer = source_transformer_t(opts.idapython_module_name, overrides.prototypes)
+    transformer.visit(tree)
+
+    return tree
diff --git a/tools/pypasses/pydoc_overrides.py b/tools/pypasses/pydoc_overrides.py
new file mode 100644
index 0000000..39a3d93
--- /dev/null
+++ b/tools/pypasses/pydoc_overrides.py
@@ -0,0 +1,78 @@
+
+import ast
+import os
+
+import pypasses
+
+def process(tree, opts, logger):
+
+    if not os.path.isfile(opts.pydoc_overrides):
+        return tree
+
+    #
+    # Collect docstrings from the overrides
+    #
+    class overrides_visitor_t(pypasses.base_visitor_t):
+
+        def __init__(self, module_name):
+            super(overrides_visitor_t, self).__init__(module_name)
+
+            # we'll be storing documentation items as kvp's
+            # where the key is the "path" to the item (e.g.,
+            # `ida_typeinf.tinfo_t.get_udm`.
+            self.doc_items = {}
+
+        def _register_doc(self, node):
+            ds = self._get_docstring(node)
+            if ds:
+                path = ".".join(self.current_path + [node.name])
+                logger.debug(f"Registering \"{path}\"")
+                self.doc_items[path] = ds
+
+        def _get_docstring(self, node):
+            return ast.get_docstring(node, clean=True)
+
+        def visit_ClassDef(self, node):
+            self._register_doc(node)
+            return super(overrides_visitor_t, self).visit_ClassDef(node)
+
+        def visit_FunctionDef(self, node):
+            self._register_doc(node)
+            return super(overrides_visitor_t, self).visit_FunctionDef(node)
+
+
+    with open(opts.pydoc_overrides) as fin:
+        overrides_tree = ast.parse(fin.read(), filename=opts.pydoc_overrides)
+    overrides = overrides_visitor_t(opts.idapython_module_name)
+    overrides.visit(overrides_tree)
+
+    #
+    # And apply it to the input
+    #
+    class source_transformer_t(pypasses.base_visitor_t):
+        def __init__(self, module_name, overrides_kvps):
+            super(source_transformer_t, self).__init__(module_name)
+            self.overrides_kvps = overrides_kvps
+
+        def _restore_doc(self, node):
+            path = ".".join(self.current_path + [node.name])
+            got = self.overrides_kvps.get(path, None)
+            if got is not None:
+                logger.debug(f"Found override for \"{path}\"")
+                pypasses.set_docstring(node, got)
+            return node
+
+        def visit_ClassDef(self, node):
+            node = self._restore_doc(node)
+            super(source_transformer_t, self).visit_ClassDef(node)
+            return node
+
+        def visit_FunctionDef(self, node):
+            node = self._restore_doc(node)
+            super(source_transformer_t, self).visit_FunctionDef(node)
+            return node
+
+    transformer = source_transformer_t(opts.idapython_module_name, overrides.doc_items)
+    transformer.visit(tree)
+
+    return tree
diff --git a/tools/pypasses/return_type_from_cpp_wrapper.py b/tools/pypasses/return_type_from_cpp_wrapper.py
new file mode 100644
index 0000000..c20b844
--- /dev/null
+++ b/tools/pypasses/return_type_from_cpp_wrapper.py
@@ -0,0 +1,100 @@
+
+import ast
+import re
+
+import pypasses
+
+def process(tree, opts, logger):
+
+    class func_info_t(object):
+        def __init__(self, name, body):
+            self.name    = name
+            self.body    = body
+
+    def collect():
+        with open(opts.cpp_wrapper) as fin:
+            text = fin.read()
+
+        re_wrap   = re.compile(r".*PyObject *\*_wrap_([^\(]*)\(.*\) *{")
+        re_string = re.compile(r"([\"'])(?:\\?.)*?\1")
+        re_curly  = re.compile(r"[{}]")
+
+        # remove strings, (to avoid being confused by "{" "}" inside strings)
+        text = re_string.sub("", text)
+
+        functions = {}
+
+        def _find_body(text, pos):
+            count = 0
+            while True:
+                m = re_curly.search(text, pos)
+                if not m:
+                    break
+
+                if m.group()[0] == "{":
+                    if count == 0:
+                        start = m.start()
+                    count += 1
+                else:
+                    if count == 0:
+                        break
+                    count -= 1
+                    if count == 0:
+                        return start, m.end()
+
+                pos = m.end()
+            raise Exception("Cannot find body")
+
+        start = 0
+        while text:
+            m = re_wrap.search(text, start)
+            if not m:
+                break
+            fun_name = m.group(1)
+            start, end = _find_body(text, m.start())
+            body = text[start:end]
+
+            functions[f"{opts.idapython_module_name}.{fun_name}"] = func_info_t(fun_name, body)
+            start = end
+
+        return functions
+
+    #
+    # First, collect functions
+    #
+    functions = collect()
+
+    #
+    # Then, patch the return types
+    #
+    class source_transformer_t(pypasses.base_transformer_t):
+
+        PATTERNS = (
+            ("resultobj = _maybe_sized_cstring_result(", ast.Name("str")),
+            ("resultobj = _maybe_cstring_result(", ast.Name("str")),
+            ("resultobj = _maybe_binary_result(", ast.Name("str")),
+            ("resultobj = _maybe_cstring_result_on_charptr_using_allocated_buf(", ast.Name("str")),
+            ("resultobj = _maybe_cstring_result_on_charptr_using_qbuf(", ast.Name("str")),
+            ("resultobj = _maybe_byte_array_as_hex_or_none_result(", ast.Name("str")),
+            ("resultobj = _maybe_byte_array_or_none_result(", ast.Name("bytes")),
+            ("resultobj = _sized_cstring_result(", ast.Name("str"))
+        )
+
+        def __init__(self, module_name, cpp_functions):
+            super(source_transformer_t, self).__init__(module_name)
+            self.cpp_functions = cpp_functions
+
+        def visit_FunctionDef(self, node):
+            path = ".".join(self.current_path + [node.name])
+            got = self.cpp_functions.get(path, None)
+            if got is not None:
+                for pattern, ret_type in self.PATTERNS:
+                    if got.body.find(pattern) >= 0:
+                        node.returns = ret_type
+                        break
+            return node
+
+    transformer = source_transformer_t(opts.idapython_module_name, functions)
+    transformer.visit(tree)
+
+    return tree